mcp-subagents/dist/manager.d.ts

Multi-Agent AI Orchestration via Model Context Protocol - Access specialized CLI AI agents (Aider, Qwen, Gemini, Goose, etc.) with intelligent fallback and configuration

import { AgentRegistry } from './agents/registry.js';
import type { AgentName, TaskConfig, RunAgentResponse, ListAgentsResponse, TaskStatus, StreamingTaskStatus, WorkflowTask, WorkflowResult, ParallelTask, ParallelResult } from './types/index.js';
export declare class AgentManager {
    private registry;
    private tasks;
    private workflows;
    private runningCount;
    private configManager;
    private processPool;
    private runningAsyncOperations;
    private isShuttingDown;
    constructor(registry: AgentRegistry);
    private handleError;
    private logError;
    runAgent(params: {
        agent: AgentName;
        task: string;
        config?: TaskConfig;
    }): Promise<RunAgentResponse>;
    /**
     * Run agent asynchronously - returns taskId immediately, task runs in background
     */
    runAgentAsync(params: {
        agent: AgentName;
        task: string;
        config?: TaskConfig;
    }): Promise<{
        taskId: string;
        agent: AgentName;
        status: 'running';
        message: string;
    }>;
    /**
     * Execute task asynchronously with fallback support
     */
    private executeTaskAsync;
    listAgents(): Promise<ListAgentsResponse>;
    /**
     * List all currently running tasks
     */
    listRunningTasks(options?: {
        includeOutput?: boolean;
        sortBy?: 'startTime' | 'agent' | 'runtime';
    }): Promise<{
        tasks: Array<{
            taskId: string;
            agent: AgentName;
            status: 'running';
            startTime: number;
            runtime: number;
            pid?: number;
            outputLines: number;
            lastActivity: number;
            taskPreview: string;
            currentOutput?: string[];
        }>;
    }>;
    /**
     * Terminate a running task
     */
    terminateTask(taskId: string, _options?: {
        graceful?: boolean;
        timeout?: number;
    }): Promise<{
        success: boolean;
        previousStatus: string;
        finalStatus: string;
        runtime?: number;
        outputLines: number;
        message: string;
    }>;
    getTaskStatus(taskId: string, outputOptions?: {
        offset?: number;
        limit?: number;
        fromEnd?: boolean;
        maxChars?: number;
        search?: string;
        context?: number;
        outputMode?: 'content' | 'matches_only' | 'count';
        ignoreCase?: boolean;
        matchNumbers?: boolean;
        streaming?: {
            lastSeenLine?: number;
            waitForNew?: boolean;
            maxWaitTime?: number;
            includeLineNumbers?: boolean;
        };
    }): Promise<TaskStatus | StreamingTaskStatus>;
    runAgentSequence(tasks: WorkflowTask[], options?: {
        continueOnFailure?: boolean;
        templateData?: Record<string, any>;
    }): Promise<WorkflowResult>;
    private generateWorkflowId;
    runAgentsParallel(tasks: Record<string, ParallelTask>, options?: {
        timeout?: number;
        failFast?: boolean;
    }): Promise<ParallelResult>;
    private generateParallelId;
    /**
     * Parse task parameter - handles both direct task strings and file:// paths
     * For long tasks or those with special characters, agents can write to temp files
     * and pass file://path instead of the full task content
     */
    private parseTaskParam;
    private applySmartSummary;
    private isComplexTask;
    private executeTask;
    private validateRunAgentParams;
    private generateTaskId;
    private mergeAgentConfig;
    /**
     * Create clean config for fallback agent, excluding agent-specific flags
     */
    private createFallbackConfig;
    private calculateProgress;
    private getAvailableFallbackAgents;
    /**
     * Shutdown the manager and cleanup all processes
     */
    private shutdown;
}
//# sourceMappingURL=manager.d.ts.map