taskforce-aiagent/dist/engine/taskForce.d.ts

TaskForce is a modular, open-source, production-ready TypeScript agent framework for orchestrating AI agents, LLM-powered autonomous agents, task pipelines, dynamic toolchains, RAG workflows and memory/retrieval systems.

import { Agent } from "../agents/agent.js";
import { Task } from "../tasks/task.js";
import { ExecutionMode, SupportedModel } from "../configs/enum.js";
import { Retriever } from "../memory/retrievals/retrieval.interface.js";
import { EventEmitter } from "events";
interface TaskForceConfig {
    agents: Agent[];
    tasks: Task[];
    verbose?: boolean;
    memory?: boolean;
    executionMode?: ExecutionMode;
    allowParallelProcesses?: boolean;
    managerModel?: SupportedModel;
    maxRetryPerTask?: number;
    maxDelegatePerTask?: number;
    enableReplanning?: boolean;
    enableAIPlanning?: boolean;
    retriever?: Retriever;
}
export declare class TaskForce extends EventEmitter {
    private agents;
    private tasks;
    private verbose;
    private memory;
    private executionMode?;
    private allowParallelProcesses?;
    private managerAgent?;
    private maxRetryPerTask;
    private maxDelegatePerTask;
    private globalReplanAttemptCount;
    private readonly maxGlobalReplanLimit;
    private enableReplanning?;
    private enableAIPlanning?;
    private retriever?;
    constructor(config: TaskForceConfig);
    emitStep(payload: Record<string, any>): void;
    run(inputs: Record<string, any>): Promise<{
        result: any;
        executedTaskIds: string[];
    }>;
    reviewFinalOutput(finalContext: Record<string, any>, isParallel: boolean): Promise<Record<string, any>>;
    private computeReplanTasks;
    private replanRun;
    runSequential(inputs: Record<string, string>): Promise<Record<string, any>>;
    private runHierarchicalFiltered;
    private runParallelHierarchicalFiltered;
    private handleDelegationAndToolOutput;
    private topologicalSortTasks;
    private createTaskPlan;
    decomposeMainTask(mainTask: Task): Promise<Task[]>;
    private getChainedInput;
    private evaluateTaskLoop;
    private runTask;
    train(iterations: number, globalInputs?: Record<string, any>): Promise<void>;
    getTaskById(id: string): Task | undefined;
    listTaskNames(): string[];
    getAgentByName(name: string): Agent | undefined;
    listAgentNames(): string[];
}
export {};