claude-code-subagents-orchestrator/dist/types/tools.d.ts

Claude Code Sub-agents Orchestrator - A powerful MCP server for orchestrating multiple AI sub-agents for complex task execution in Claude Code

import { z } from 'zod';
import { ToolResult } from './core.js';
export declare const ListAgentsParamsSchema: z.ZodObject<{
    category: z.ZodOptional<z.ZodEnum<["backend", "frontend", "fullstack", "devops", "testing", "security", "data"]>>;
    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    includeMetadata: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    tags?: string[];
    category?: "security" | "backend" | "frontend" | "fullstack" | "devops" | "testing" | "data";
    includeMetadata?: boolean;
}, {
    tags?: string[];
    category?: "security" | "backend" | "frontend" | "fullstack" | "devops" | "testing" | "data";
    includeMetadata?: boolean;
}>;
export declare const InstallAgentsParamsSchema: z.ZodObject<{
    agents: z.ZodArray<z.ZodString, "many">;
    source: z.ZodDefault<z.ZodEnum<["github", "local", "url"]>>;
    repository: z.ZodOptional<z.ZodString>;
    force: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    agents?: string[];
    source?: "github" | "local" | "url";
    repository?: string;
    force?: boolean;
}, {
    agents?: string[];
    source?: "github" | "local" | "url";
    repository?: string;
    force?: boolean;
}>;
export declare const GenerateAgentPromptParamsSchema: z.ZodObject<{
    agentName: z.ZodString;
    task: z.ZodString;
    context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
    additionalConstraints: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
}, "strip", z.ZodTypeAny, {
    agentName?: string;
    task?: string;
    context?: Record<string, any>;
    additionalConstraints?: string[];
}, {
    agentName?: string;
    task?: string;
    context?: Record<string, any>;
    additionalConstraints?: string[];
}>;
export declare const GenerateMultiAgentWorkflowParamsSchema: z.ZodObject<{
    task: z.ZodString;
    complexity: z.ZodDefault<z.ZodEnum<["low", "medium", "high"]>>;
    preferredAgents: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    constraints: z.ZodOptional<z.ZodObject<{
        maxSteps: z.ZodOptional<z.ZodNumber>;
        timeoutMs: z.ZodOptional<z.ZodNumber>;
        parallel: z.ZodDefault<z.ZodBoolean>;
    }, "strip", z.ZodTypeAny, {
        maxSteps?: number;
        timeoutMs?: number;
        parallel?: boolean;
    }, {
        maxSteps?: number;
        timeoutMs?: number;
        parallel?: boolean;
    }>>;
    context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
}, "strip", z.ZodTypeAny, {
    complexity?: "low" | "medium" | "high";
    constraints?: {
        maxSteps?: number;
        timeoutMs?: number;
        parallel?: boolean;
    };
    task?: string;
    context?: Record<string, any>;
    preferredAgents?: string[];
}, {
    complexity?: "low" | "medium" | "high";
    constraints?: {
        maxSteps?: number;
        timeoutMs?: number;
        parallel?: boolean;
    };
    task?: string;
    context?: Record<string, any>;
    preferredAgents?: string[];
}>;
export declare const GenerateRecoveryPromptParamsSchema: z.ZodObject<{
    executionContext: z.ZodAny;
    failedStep: z.ZodString;
    errorDetails: z.ZodObject<{
        message: z.ZodString;
        code: z.ZodString;
        details: z.ZodOptional<z.ZodAny>;
    }, "strip", z.ZodTypeAny, {
        code?: string;
        message?: string;
        details?: any;
    }, {
        code?: string;
        message?: string;
        details?: any;
    }>;
    recoveryOptions: z.ZodOptional<z.ZodArray<z.ZodEnum<["retry", "skip", "alternative", "rollback"]>, "many">>;
}, "strip", z.ZodTypeAny, {
    executionContext?: any;
    failedStep?: string;
    errorDetails?: {
        code?: string;
        message?: string;
        details?: any;
    };
    recoveryOptions?: ("retry" | "skip" | "alternative" | "rollback")[];
}, {
    executionContext?: any;
    failedStep?: string;
    errorDetails?: {
        code?: string;
        message?: string;
        details?: any;
    };
    recoveryOptions?: ("retry" | "skip" | "alternative" | "rollback")[];
}>;
export declare const AnalyzeProjectStateParamsSchema: z.ZodObject<{
    projectPath: z.ZodOptional<z.ZodString>;
    includeFileStructure: z.ZodDefault<z.ZodBoolean>;
    includeDependencies: z.ZodDefault<z.ZodBoolean>;
    includeGitStatus: z.ZodDefault<z.ZodBoolean>;
    depth: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    projectPath?: string;
    includeFileStructure?: boolean;
    includeDependencies?: boolean;
    includeGitStatus?: boolean;
    depth?: number;
}, {
    projectPath?: string;
    includeFileStructure?: boolean;
    includeDependencies?: boolean;
    includeGitStatus?: boolean;
    depth?: number;
}>;
export declare const ListAgentsResponseSchema: z.ZodObject<{
    agents: z.ZodArray<z.ZodObject<{
        name: z.ZodString;
        category: z.ZodString;
        description: z.ZodString;
        version: z.ZodString;
        tags: z.ZodArray<z.ZodString, "many">;
        capabilities: z.ZodOptional<z.ZodObject<{
            tools: z.ZodArray<z.ZodString, "many">;
            languages: z.ZodArray<z.ZodString, "many">;
            frameworks: z.ZodArray<z.ZodString, "many">;
            domains: z.ZodArray<z.ZodString, "many">;
        }, "strip", z.ZodTypeAny, {
            tools?: string[];
            languages?: string[];
            frameworks?: string[];
            domains?: string[];
        }, {
            tools?: string[];
            languages?: string[];
            frameworks?: string[];
            domains?: string[];
        }>>;
        metadata: z.ZodOptional<z.ZodObject<{
            installed: z.ZodBoolean;
            lastUpdated: z.ZodOptional<z.ZodDate>;
            dependencies: z.ZodArray<z.ZodString, "many">;
        }, "strip", z.ZodTypeAny, {
            dependencies?: string[];
            installed?: boolean;
            lastUpdated?: Date;
        }, {
            dependencies?: string[];
            installed?: boolean;
            lastUpdated?: Date;
        }>>;
    }, "strip", z.ZodTypeAny, {
        name?: string;
        version?: string;
        metadata?: {
            dependencies?: string[];
            installed?: boolean;
            lastUpdated?: Date;
        };
        description?: string;
        tags?: string[];
        category?: string;
        capabilities?: {
            tools?: string[];
            languages?: string[];
            frameworks?: string[];
            domains?: string[];
        };
    }, {
        name?: string;
        version?: string;
        metadata?: {
            dependencies?: string[];
            installed?: boolean;
            lastUpdated?: Date;
        };
        description?: string;
        tags?: string[];
        category?: string;
        capabilities?: {
            tools?: string[];
            languages?: string[];
            frameworks?: string[];
            domains?: string[];
        };
    }>, "many">;
    totalCount: z.ZodNumber;
    categories: z.ZodRecord<z.ZodString, z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    agents?: {
        name?: string;
        version?: string;
        metadata?: {
            dependencies?: string[];
            installed?: boolean;
            lastUpdated?: Date;
        };
        description?: string;
        tags?: string[];
        category?: string;
        capabilities?: {
            tools?: string[];
            languages?: string[];
            frameworks?: string[];
            domains?: string[];
        };
    }[];
    totalCount?: number;
    categories?: Record<string, number>;
}, {
    agents?: {
        name?: string;
        version?: string;
        metadata?: {
            dependencies?: string[];
            installed?: boolean;
            lastUpdated?: Date;
        };
        description?: string;
        tags?: string[];
        category?: string;
        capabilities?: {
            tools?: string[];
            languages?: string[];
            frameworks?: string[];
            domains?: string[];
        };
    }[];
    totalCount?: number;
    categories?: Record<string, number>;
}>;
export declare const InstallAgentsResponseSchema: z.ZodObject<{
    installed: z.ZodArray<z.ZodObject<{
        name: z.ZodString;
        version: z.ZodString;
        source: z.ZodString;
        success: z.ZodBoolean;
        error: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        name?: string;
        version?: string;
        success?: boolean;
        error?: string;
        source?: string;
    }, {
        name?: string;
        version?: string;
        success?: boolean;
        error?: string;
        source?: string;
    }>, "many">;
    failed: z.ZodArray<z.ZodObject<{
        name: z.ZodString;
        error: z.ZodString;
        recoverable: z.ZodBoolean;
    }, "strip", z.ZodTypeAny, {
        name?: string;
        recoverable?: boolean;
        error?: string;
    }, {
        name?: string;
        recoverable?: boolean;
        error?: string;
    }>, "many">;
    summary: z.ZodObject<{
        total: z.ZodNumber;
        successful: z.ZodNumber;
        failed: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        failed?: number;
        total?: number;
        successful?: number;
    }, {
        failed?: number;
        total?: number;
        successful?: number;
    }>;
}, "strip", z.ZodTypeAny, {
    failed?: {
        name?: string;
        recoverable?: boolean;
        error?: string;
    }[];
    installed?: {
        name?: string;
        version?: string;
        success?: boolean;
        error?: string;
        source?: string;
    }[];
    summary?: {
        failed?: number;
        total?: number;
        successful?: number;
    };
}, {
    failed?: {
        name?: string;
        recoverable?: boolean;
        error?: string;
    }[];
    installed?: {
        name?: string;
        version?: string;
        success?: boolean;
        error?: string;
        source?: string;
    }[];
    summary?: {
        failed?: number;
        total?: number;
        successful?: number;
    };
}>;
export declare const GenerateAgentPromptResponseSchema: z.ZodObject<{
    prompt: z.ZodString;
    agent: z.ZodObject<{
        name: z.ZodString;
        version: z.ZodString;
        capabilities: z.ZodArray<z.ZodString, "many">;
    }, "strip", z.ZodTypeAny, {
        name?: string;
        version?: string;
        capabilities?: string[];
    }, {
        name?: string;
        version?: string;
        capabilities?: string[];
    }>;
    context: z.ZodObject<{
        task: z.ZodString;
        constraints: z.ZodArray<z.ZodString, "many">;
        estimatedComplexity: z.ZodEnum<["low", "medium", "high"]>;
        estimatedDuration: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        constraints?: string[];
        task?: string;
        estimatedComplexity?: "low" | "medium" | "high";
        estimatedDuration?: number;
    }, {
        constraints?: string[];
        task?: string;
        estimatedComplexity?: "low" | "medium" | "high";
        estimatedDuration?: number;
    }>;
    recommendations: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
}, "strip", z.ZodTypeAny, {
    prompt?: string;
    context?: {
        constraints?: string[];
        task?: string;
        estimatedComplexity?: "low" | "medium" | "high";
        estimatedDuration?: number;
    };
    agent?: {
        name?: string;
        version?: string;
        capabilities?: string[];
    };
    recommendations?: string[];
}, {
    prompt?: string;
    context?: {
        constraints?: string[];
        task?: string;
        estimatedComplexity?: "low" | "medium" | "high";
        estimatedDuration?: number;
    };
    agent?: {
        name?: string;
        version?: string;
        capabilities?: string[];
    };
    recommendations?: string[];
}>;
export declare const GenerateMultiAgentWorkflowResponseSchema: z.ZodObject<{
    workflow: z.ZodAny;
    analysis: z.ZodObject<{
        complexity: z.ZodEnum<["low", "medium", "high"]>;
        estimatedDuration: z.ZodNumber;
        requiredAgents: z.ZodArray<z.ZodString, "many">;
        dependencies: z.ZodArray<z.ZodString, "many">;
        riskFactors: z.ZodArray<z.ZodString, "many">;
    }, "strip", z.ZodTypeAny, {
        requiredAgents?: string[];
        complexity?: "low" | "medium" | "high";
        dependencies?: string[];
        estimatedDuration?: number;
        riskFactors?: string[];
    }, {
        requiredAgents?: string[];
        complexity?: "low" | "medium" | "high";
        dependencies?: string[];
        estimatedDuration?: number;
        riskFactors?: string[];
    }>;
    execution: z.ZodObject<{
        canExecuteImmediately: z.ZodBoolean;
        missingDependencies: z.ZodArray<z.ZodString, "many">;
        warnings: z.ZodArray<z.ZodString, "many">;
    }, "strip", z.ZodTypeAny, {
        canExecuteImmediately?: boolean;
        missingDependencies?: string[];
        warnings?: string[];
    }, {
        canExecuteImmediately?: boolean;
        missingDependencies?: string[];
        warnings?: string[];
    }>;
}, "strip", z.ZodTypeAny, {
    workflow?: any;
    analysis?: {
        requiredAgents?: string[];
        complexity?: "low" | "medium" | "high";
        dependencies?: string[];
        estimatedDuration?: number;
        riskFactors?: string[];
    };
    execution?: {
        canExecuteImmediately?: boolean;
        missingDependencies?: string[];
        warnings?: string[];
    };
}, {
    workflow?: any;
    analysis?: {
        requiredAgents?: string[];
        complexity?: "low" | "medium" | "high";
        dependencies?: string[];
        estimatedDuration?: number;
        riskFactors?: string[];
    };
    execution?: {
        canExecuteImmediately?: boolean;
        missingDependencies?: string[];
        warnings?: string[];
    };
}>;
export declare const GenerateRecoveryPromptResponseSchema: z.ZodObject<{
    recoveryStrategy: z.ZodEnum<["retry", "skip", "alternative", "rollback"]>;
    prompt: z.ZodString;
    modifications: z.ZodObject<{
        updatedStep: z.ZodOptional<z.ZodAny>;
        alternativeSteps: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
        rollbackPoint: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        updatedStep?: any;
        alternativeSteps?: any[];
        rollbackPoint?: string;
    }, {
        updatedStep?: any;
        alternativeSteps?: any[];
        rollbackPoint?: string;
    }>;
    analysis: z.ZodObject<{
        errorCategory: z.ZodString;
        likelihood: z.ZodEnum<["low", "medium", "high"]>;
        impact: z.ZodEnum<["low", "medium", "high"]>;
        recommendations: z.ZodArray<z.ZodString, "many">;
    }, "strip", z.ZodTypeAny, {
        recommendations?: string[];
        errorCategory?: string;
        likelihood?: "low" | "medium" | "high";
        impact?: "low" | "medium" | "high";
    }, {
        recommendations?: string[];
        errorCategory?: string;
        likelihood?: "low" | "medium" | "high";
        impact?: "low" | "medium" | "high";
    }>;
}, "strip", z.ZodTypeAny, {
    prompt?: string;
    analysis?: {
        recommendations?: string[];
        errorCategory?: string;
        likelihood?: "low" | "medium" | "high";
        impact?: "low" | "medium" | "high";
    };
    recoveryStrategy?: "retry" | "skip" | "alternative" | "rollback";
    modifications?: {
        updatedStep?: any;
        alternativeSteps?: any[];
        rollbackPoint?: string;
    };
}, {
    prompt?: string;
    analysis?: {
        recommendations?: string[];
        errorCategory?: string;
        likelihood?: "low" | "medium" | "high";
        impact?: "low" | "medium" | "high";
    };
    recoveryStrategy?: "retry" | "skip" | "alternative" | "rollback";
    modifications?: {
        updatedStep?: any;
        alternativeSteps?: any[];
        rollbackPoint?: string;
    };
}>;
export declare const AnalyzeProjectStateResponseSchema: z.ZodObject<{
    project: z.ZodObject<{
        path: z.ZodString;
        name: z.ZodString;
        type: z.ZodString;
        language: z.ZodOptional<z.ZodString>;
        framework: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        path?: string;
        type?: string;
        name?: string;
        language?: string;
        framework?: string;
    }, {
        path?: string;
        type?: string;
        name?: string;
        language?: string;
        framework?: string;
    }>;
    structure: z.ZodOptional<z.ZodObject<{
        files: z.ZodArray<z.ZodObject<{
            path: z.ZodString;
            type: z.ZodEnum<["file", "directory"]>;
            size: z.ZodOptional<z.ZodNumber>;
            lastModified: z.ZodOptional<z.ZodDate>;
        }, "strip", z.ZodTypeAny, {
            path?: string;
            type?: "file" | "directory";
            size?: number;
            lastModified?: Date;
        }, {
            path?: string;
            type?: "file" | "directory";
            size?: number;
            lastModified?: Date;
        }>, "many">;
        depth: z.ZodNumber;
        totalFiles: z.ZodNumber;
        totalDirectories: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        depth?: number;
        files?: {
            path?: string;
            type?: "file" | "directory";
            size?: number;
            lastModified?: Date;
        }[];
        totalFiles?: number;
        totalDirectories?: number;
    }, {
        depth?: number;
        files?: {
            path?: string;
            type?: "file" | "directory";
            size?: number;
            lastModified?: Date;
        }[];
        totalFiles?: number;
        totalDirectories?: number;
    }>>;
    dependencies: z.ZodOptional<z.ZodObject<{
        package: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        runtime: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        development: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, "strip", z.ZodTypeAny, {
        package?: Record<string, string>;
        runtime?: string[];
        development?: string[];
    }, {
        package?: Record<string, string>;
        runtime?: string[];
        development?: string[];
    }>>;
    git: z.ZodOptional<z.ZodObject<{
        branch: z.ZodString;
        status: z.ZodEnum<["clean", "dirty", "detached"]>;
        commits: z.ZodNumber;
        lastCommit: z.ZodOptional<z.ZodObject<{
            hash: z.ZodString;
            message: z.ZodString;
            date: z.ZodDate;
        }, "strip", z.ZodTypeAny, {
            message?: string;
            date?: Date;
            hash?: string;
        }, {
            message?: string;
            date?: Date;
            hash?: string;
        }>>;
    }, "strip", z.ZodTypeAny, {
        status?: "dirty" | "clean" | "detached";
        branch?: string;
        commits?: number;
        lastCommit?: {
            message?: string;
            date?: Date;
            hash?: string;
        };
    }, {
        status?: "dirty" | "clean" | "detached";
        branch?: string;
        commits?: number;
        lastCommit?: {
            message?: string;
            date?: Date;
            hash?: string;
        };
    }>>;
    recommendations: z.ZodArray<z.ZodObject<{
        type: z.ZodEnum<["agent", "workflow", "tool"]>;
        name: z.ZodString;
        reason: z.ZodString;
        priority: z.ZodEnum<["low", "medium", "high"]>;
    }, "strip", z.ZodTypeAny, {
        type?: "workflow" | "agent" | "tool";
        name?: string;
        priority?: "low" | "medium" | "high";
        reason?: string;
    }, {
        type?: "workflow" | "agent" | "tool";
        name?: string;
        priority?: "low" | "medium" | "high";
        reason?: string;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    dependencies?: {
        package?: Record<string, string>;
        runtime?: string[];
        development?: string[];
    };
    recommendations?: {
        type?: "workflow" | "agent" | "tool";
        name?: string;
        priority?: "low" | "medium" | "high";
        reason?: string;
    }[];
    project?: {
        path?: string;
        type?: string;
        name?: string;
        language?: string;
        framework?: string;
    };
    structure?: {
        depth?: number;
        files?: {
            path?: string;
            type?: "file" | "directory";
            size?: number;
            lastModified?: Date;
        }[];
        totalFiles?: number;
        totalDirectories?: number;
    };
    git?: {
        status?: "dirty" | "clean" | "detached";
        branch?: string;
        commits?: number;
        lastCommit?: {
            message?: string;
            date?: Date;
            hash?: string;
        };
    };
}, {
    dependencies?: {
        package?: Record<string, string>;
        runtime?: string[];
        development?: string[];
    };
    recommendations?: {
        type?: "workflow" | "agent" | "tool";
        name?: string;
        priority?: "low" | "medium" | "high";
        reason?: string;
    }[];
    project?: {
        path?: string;
        type?: string;
        name?: string;
        language?: string;
        framework?: string;
    };
    structure?: {
        depth?: number;
        files?: {
            path?: string;
            type?: "file" | "directory";
            size?: number;
            lastModified?: Date;
        }[];
        totalFiles?: number;
        totalDirectories?: number;
    };
    git?: {
        status?: "dirty" | "clean" | "detached";
        branch?: string;
        commits?: number;
        lastCommit?: {
            message?: string;
            date?: Date;
            hash?: string;
        };
    };
}>;
export type ListAgentsParams = z.infer<typeof ListAgentsParamsSchema>;
export type InstallAgentsParams = z.infer<typeof InstallAgentsParamsSchema>;
export type GenerateAgentPromptParams = z.infer<typeof GenerateAgentPromptParamsSchema>;
export type GenerateMultiAgentWorkflowParams = z.infer<typeof GenerateMultiAgentWorkflowParamsSchema>;
export type GenerateRecoveryPromptParams = z.infer<typeof GenerateRecoveryPromptParamsSchema>;
export type AnalyzeProjectStateParams = z.infer<typeof AnalyzeProjectStateParamsSchema>;
export type ListAgentsResponse = z.infer<typeof ListAgentsResponseSchema>;
export type InstallAgentsResponse = z.infer<typeof InstallAgentsResponseSchema>;
export type GenerateAgentPromptResponse = z.infer<typeof GenerateAgentPromptResponseSchema>;
export type GenerateMultiAgentWorkflowResponse = z.infer<typeof GenerateMultiAgentWorkflowResponseSchema>;
export type GenerateRecoveryPromptResponse = z.infer<typeof GenerateRecoveryPromptResponseSchema>;
export type AnalyzeProjectStateResponse = z.infer<typeof AnalyzeProjectStateResponseSchema>;
export interface ITool {
    name: string;
    description: string;
    execute(params: any): Promise<ToolResult>;
    validate(params: any): boolean;
}
export interface IToolRegistry {
    register(tool: ITool): void;
    get(name: string): ITool | undefined;
    list(): string[];
    execute(name: string, params: any): Promise<ToolResult>;
}
//# sourceMappingURL=tools.d.ts.map