neuro-cli 4.1.0

package/dist/advisor/advisor.js

@@ -0,0 +1,178 @@
+// ============================================================
+// NeuroCLI - Advisor Model
+// Second model consultation during tasks (like Claude Code's Advisor)
+// ============================================================
+export class AdvisorSystem {
+    client;
+    config;
+    consultationCount = 0;
+    recentErrors = [];
+    constructor(client, config) {
+        this.client = client;
+        this.config = {
+            enabled: config?.enabled ?? true,
+            model: config?.model ?? 'nvidia/nemotron-3-super-120b-a12b:free',
+            consultOn: config?.consultOn ?? ['before_complete', 'recurring_error', 'security_sensitive'],
+            maxConsultations: config?.maxConsultations ?? 5,
+        };
+    }
+    /**
+     * Check if advisor should be consulted for a given trigger
+     */
+    shouldConsult(trigger) {
+        if (!this.config.enabled)
+            return false;
+        if (this.consultationCount >= this.config.maxConsultations)
+            return false;
+        return this.config.consultOn.includes(trigger);
+    }
+    /**
+     * Consult the advisor model
+     */
+    async consult(conversation, trigger, currentAction, context) {
+        this.consultationCount++;
+        const triggerDescriptions = {
+            'before_approach': 'The agent is about to commit to a specific approach. Review the plan.',
+            'recurring_error': 'The agent has encountered a recurring error. Suggest alternative approaches.',
+            'before_complete': 'The agent is about to declare the task complete. Verify quality.',
+            'complex_decision': 'The agent faces a complex architectural decision. Provide guidance.',
+            'security_sensitive': 'The agent is modifying security-sensitive code. Review for vulnerabilities.',
+            'manual': 'The user requested an advisor consultation.',
+        };
+        // Build advisor prompt
+        const advisorMessages = [
+            {
+                role: 'system',
+                content: `You are an expert advisor AI. Your role is to review the agent's work and provide constructive guidance.
+
+You have access to the full conversation including every tool call and result.
+
+When advising:
+1. Identify potential issues or risks
+2. Suggest better approaches if applicable
+3. Point out anything the agent might have missed
+4. Assess code quality and correctness
+5. Consider security implications
+
+Be concise but thorough. End with a clear recommendation: PROCEED or REVISE.`,
+                timestamp: Date.now(),
+            },
+            {
+                role: 'user',
+                content: `## Advisor Consultation: ${trigger}
+
+${triggerDescriptions[trigger]}
+
+## Current Action
+${currentAction}
+
+${context ? `## Additional Context\n${context}\n` : ''}
+
+## Conversation So Far
+${this.summarizeConversation(conversation)}
+
+Please provide your assessment and recommendation.`,
+                timestamp: Date.now(),
+            },
+        ];
+        try {
+            const response = await this.client.quickChat(this.config.model, advisorMessages);
+            const advice = response.content;
+            const shouldProceed = advice.toUpperCase().includes('PROCEED') &&
+                !advice.toUpperCase().includes('REVISE');
+            return {
+                advice,
+                shouldProceed,
+                suggestedChanges: shouldProceed ? undefined : this.extractSuggestions(advice),
+                usage: response.usage,
+            };
+        }
+        catch (error) {
+            return {
+                advice: 'Advisor consultation failed. Proceed with caution.',
+                shouldProceed: true,
+                usage: { inputTokens: 0, outputTokens: 0, cost: 0 },
+            };
+        }
+    }
+    /**
+     * Track errors for recurring error detection
+     */
+    trackError(error) {
+        this.recentErrors.push(error);
+        // Keep last 5 errors
+        if (this.recentErrors.length > 5) {
+            this.recentErrors.shift();
+        }
+    }
+    /**
+     * Check if an error is recurring
+     */
+    isRecurringError(error) {
+        const similar = this.recentErrors.filter(e => this.computeSimilarity(e, error) > 0.5);
+        return similar.length >= 2;
+    }
+    /**
+     * Get consultation count
+     */
+    getConsultationCount() {
+        return this.consultationCount;
+    }
+    /**
+     * Reset for new task
+     */
+    reset() {
+        this.consultationCount = 0;
+        this.recentErrors = [];
+    }
+    // ---- Private ----
+    summarizeConversation(messages) {
+        const parts = [];
+        const maxMessages = 30;
+        const recent = messages.slice(-maxMessages);
+        for (const msg of recent) {
+            switch (msg.role) {
+                case 'user':
+                    parts.push(`[User]: ${msg.content.slice(0, 200)}`);
+                    break;
+                case 'assistant':
+                    if (msg.toolCalls?.length) {
+                        parts.push(`[Assistant called: ${msg.toolCalls.map(tc => tc.function.name).join(', ')}]`);
+                    }
+                    else {
+                        parts.push(`[Assistant]: ${msg.content.slice(0, 300)}`);
+                    }
+                    break;
+                case 'tool':
+                    parts.push(`[Tool result]: ${msg.content.slice(0, 200)}`);
+                    break;
+            }
+        }
+        return parts.join('\n');
+    }
+    extractSuggestions(advice) {
+        // Extract suggested changes from advisor response
+        const lines = advice.split('\n');
+        const suggestions = [];
+        let inSuggestion = false;
+        for (const line of lines) {
+            if (line.match(/^#{1,3}\s+(suggestion|recommendation|change|fix)/i)) {
+                inSuggestion = true;
+                continue;
+            }
+            if (inSuggestion && line.trim()) {
+                suggestions.push(line.trim());
+            }
+        }
+        return suggestions.join('\n') || advice.slice(0, 500);
+    }
+    computeSimilarity(a, b) {
+        // Simple similarity: word overlap
+        const wordsA = new Set(a.toLowerCase().split(/\W+/));
+        const wordsB = new Set(b.toLowerCase().split(/\W+/));
+        const intersection = new Set([...wordsA].filter(w => wordsB.has(w)));
+        const union = new Set([...wordsA, ...wordsB]);
+        return union.size === 0 ? 0 : intersection.size / union.size;
+    }
+}
+//# sourceMappingURL=advisor.js.map

package/dist/agents/base.d.ts

@@ -0,0 +1,62 @@
+import { Message, ToolCall, AgentConfig, AgentExecution } from '../core/types.js';
+import { OpenRouterClient, TokenUsage } from '../api/openrouter.js';
+import { ToolRegistry } from '../tools/registry.js';
+export interface AgentRunResult {
+    content: string;
+    toolCallsMade: number;
+    iterations: number;
+    usage: TokenUsage;
+    execution: AgentExecution;
+}
+export interface AgentCallbacks {
+    onThinking?: (thinking: string) => void;
+    onToken?: (token: string) => void;
+    onToolCall?: (toolName: string, args: Record<string, unknown>) => void;
+    onToolResult?: (toolName: string, result: string, isError: boolean) => void;
+    onApprovalNeeded?: (toolName: string, args: Record<string, unknown>, risk: string) => Promise<boolean>;
+    onIteration?: (iteration: number, maxIterations: number) => void;
+    onComplete?: (result: AgentRunResult) => void;
+}
+export declare class BaseAgent {
+    protected config: AgentConfig;
+    protected client: OpenRouterClient;
+    protected registry: ToolRegistry;
+    protected workingDirectory: string;
+    protected sessionId: string;
+    protected messages: Message[];
+    constructor(config: AgentConfig, client: OpenRouterClient, registry: ToolRegistry, workingDirectory: string, sessionId: string);
+    get name(): string;
+    get description(): string;
+    /** Access to agent config for model overrides etc. */
+    get configModel(): string | undefined;
+    set configModel(model: string | undefined);
+    /**
+     * Initialize agent with system prompt and context
+     */
+    protected initializeMessages(taskContext?: string): Message[];
+    /**
+     * Build the system prompt with context
+     */
+    protected buildSystemPrompt(taskContext?: string): string;
+    /**
+     * Add a user message to the conversation
+     */
+    addUserMessage(content: string): void;
+    /**
+     * Add an assistant message
+     */
+    protected addAssistantMessage(content: string, toolCalls?: ToolCall[]): void;
+    /**
+     * Add a tool result message
+     */
+    protected addToolResult(toolCallId: string, content: string, name: string, isError?: boolean): void;
+    /**
+     * Run the agent loop
+     */
+    run(task: string, callbacks?: AgentCallbacks, maxIterations?: number): Promise<AgentRunResult>;
+    /**
+     * Quick single-turn query (no tool loop)
+     */
+    query(prompt: string): Promise<string>;
+}
+//# sourceMappingURL=base.d.ts.map

package/dist/agents/base.js

@@ -0,0 +1,215 @@
+// ============================================================
+// NeuroCLI - Base Agent
+// Foundation class for all agents
+// ============================================================
+import { MODELS } from '../api/models.js';
+export class BaseAgent {
+    config;
+    client;
+    registry;
+    workingDirectory;
+    sessionId;
+    messages = [];
+    constructor(config, client, registry, workingDirectory, sessionId) {
+        this.config = config;
+        this.client = client;
+        this.registry = registry;
+        this.workingDirectory = workingDirectory;
+        this.sessionId = sessionId;
+    }
+    get name() {
+        return this.config.name;
+    }
+    get description() {
+        return this.config.description;
+    }
+    /** Access to agent config for model overrides etc. */
+    get configModel() {
+        return this.config.model;
+    }
+    set configModel(model) {
+        this.config.model = model;
+    }
+    /**
+     * Initialize agent with system prompt and context
+     */
+    initializeMessages(taskContext) {
+        const systemContent = this.buildSystemPrompt(taskContext);
+        this.messages = [
+            { role: 'system', content: systemContent, timestamp: Date.now() },
+        ];
+        return this.messages;
+    }
+    /**
+     * Build the system prompt with context
+     */
+    buildSystemPrompt(taskContext) {
+        const model = MODELS[this.config.model || ''];
+        const cwd = this.workingDirectory;
+        let prompt = this.config.systemPrompt;
+        prompt += `\n\n## Environment`;
+        prompt += `\n- Working Directory: ${cwd}`;
+        prompt += `\n- Current Model: ${model?.name || this.config.model}`;
+        prompt += `\n- Agent: ${this.config.name} (${this.config.description})`;
+        prompt += `\n- Available Tools: ${(this.config.tools || []).join(', ')}`;
+        if (taskContext) {
+            prompt += `\n\n## Task Context\n${taskContext}`;
+        }
+        prompt += `\n\n## Guidelines
+- Be precise and thorough in your responses
+- Use tools to verify your assumptions before making changes
+- When modifying files, make minimal, targeted changes
+- Always read a file before editing it
+- Report what you've done and what still needs to be done
+- If you encounter errors, analyze them before retrying
+- Do NOT repeat the same action if it failed - try a different approach`;
+        return prompt;
+    }
+    /**
+     * Add a user message to the conversation
+     */
+    addUserMessage(content) {
+        this.messages.push({ role: 'user', content, timestamp: Date.now() });
+    }
+    /**
+     * Add an assistant message
+     */
+    addAssistantMessage(content, toolCalls) {
+        this.messages.push({ role: 'assistant', content, toolCalls, timestamp: Date.now() });
+    }
+    /**
+     * Add a tool result message
+     */
+    addToolResult(toolCallId, content, name, isError = false) {
+        this.messages.push({
+            role: 'tool',
+            content: isError ? `ERROR: ${content}` : content,
+            toolCallId,
+            name,
+            timestamp: Date.now(),
+        });
+    }
+    /**
+     * Run the agent loop
+     */
+    async run(task, callbacks, maxIterations) {
+        const maxIter = maxIterations || this.config.maxIterations || 10;
+        const startTime = Date.now();
+        let totalUsage = { inputTokens: 0, outputTokens: 0, cost: 0 };
+        let toolCallsMade = 0;
+        let iteration = 0;
+        const execution = {
+            agentName: this.config.name,
+            task,
+            startTime,
+            iterations: 0,
+            tokensUsed: 0,
+            status: 'running',
+        };
+        // Initialize messages
+        this.initializeMessages();
+        this.addUserMessage(task);
+        for (iteration = 1; iteration <= maxIter; iteration++) {
+            callbacks?.onIteration?.(iteration, maxIter);
+            // Get tool definitions for this agent
+            const toolDefs = this.registry.getDefinitions(this.config.tools);
+            // Prepare stream callbacks
+            const streamCallbacks = {
+                onToken: (token) => callbacks?.onToken?.(token),
+                onThinking: (thinking) => callbacks?.onThinking?.(thinking),
+                onToolCall: (tc) => callbacks?.onToolCall?.(tc.function.name, JSON.parse(tc.function.arguments)),
+            };
+            // Call LLM
+            try {
+                const response = await this.client.chat({
+                    model: this.config.model || 'qwen/qwen3-coder:free',
+                    messages: this.messages,
+                    tools: toolDefs.length > 0 ? toolDefs : undefined,
+                    temperature: this.config.temperature,
+                    maxTokens: this.config.maxTokens,
+                    stream: false, // Disable streaming for better compatibility with free models
+                }, streamCallbacks);
+                totalUsage.inputTokens += response.usage.inputTokens;
+                totalUsage.outputTokens += response.usage.outputTokens;
+                totalUsage.cost += response.usage.cost;
+                // If no tool calls, we're done
+                if (response.toolCalls.length === 0) {
+                    this.addAssistantMessage(response.content);
+                    execution.status = 'completed';
+                    execution.result = response.content;
+                    break;
+                }
+                // Process tool calls
+                this.addAssistantMessage(response.content, response.toolCalls);
+                for (const toolCall of response.toolCalls) {
+                    let args;
+                    try {
+                        args = JSON.parse(toolCall.function.arguments);
+                    }
+                    catch {
+                        args = {};
+                    }
+                    const toolName = toolCall.function.name;
+                    toolCallsMade++;
+                    callbacks?.onToolCall?.(toolName, args);
+                    // Check if approval is needed
+                    const needsApproval = this.registry.getApprovalRequest(toolName, args);
+                    if (needsApproval && this.config.autoApprove !== true) {
+                        const approved = await callbacks?.onApprovalNeeded?.(toolName, args, needsApproval.risk) ?? true; // Default to approve if no callback
+                        if (!approved) {
+                            this.addToolResult(toolCall.id, 'User denied this tool call.', toolName);
+                            callbacks?.onToolResult?.(toolName, 'Denied by user', false);
+                            continue;
+                        }
+                    }
+                    // Execute tool
+                    const toolContext = {
+                        workingDirectory: this.workingDirectory,
+                        sessionId: this.sessionId,
+                        agentName: this.config.name,
+                        onProgress: (msg) => callbacks?.onThinking?.(msg),
+                    };
+                    const result = await this.registry.execute(toolName, args, toolContext);
+                    // Use the original tool_call_id from the assistant's tool call, not the registry's generated one
+                    this.addToolResult(toolCall.id, result.content, toolName, result.isError);
+                    callbacks?.onToolResult?.(toolName, result.content, result.isError || false);
+                }
+            }
+            catch (error) {
+                const errMsg = error instanceof Error ? error.message : String(error);
+                this.addAssistantMessage(`Error encountered: ${errMsg}`);
+                execution.status = 'failed';
+                execution.result = errMsg;
+                break;
+            }
+        }
+        if (iteration > maxIter) {
+            execution.status = 'completed';
+            execution.result = 'Max iterations reached';
+        }
+        execution.endTime = Date.now();
+        execution.iterations = iteration;
+        execution.tokensUsed = totalUsage.inputTokens + totalUsage.outputTokens;
+        const result = {
+            content: this.messages.filter(m => m.role === 'assistant' && !m.toolCalls?.length).pop()?.content || '',
+            toolCallsMade,
+            iterations: iteration,
+            usage: totalUsage,
+            execution,
+        };
+        callbacks?.onComplete?.(result);
+        return result;
+    }
+    /**
+     * Quick single-turn query (no tool loop)
+     */
+    async query(prompt) {
+        const messages = [
+            { role: 'system', content: this.config.systemPrompt, timestamp: Date.now() },
+            { role: 'user', content: prompt, timestamp: Date.now() },
+        ];
+        const response = await this.client.quickChat(this.config.model || 'anthropic/claude-sonnet-4', messages);
+        return response.content;
+    }
+}
+//# sourceMappingURL=base.js.map

package/dist/agents/orchestrator.d.ts

@@ -0,0 +1,46 @@
+import { BaseAgent, AgentRunResult, AgentCallbacks } from './base.js';
+import { OpenRouterClient, TokenUsage } from '../api/openrouter.js';
+import { ToolRegistry } from '../tools/registry.js';
+import { AgentConfig, AgentExecution } from '../core/types.js';
+export interface SubAgentTask {
+    agent: string;
+    task: string;
+    context?: string;
+    dependsOn?: string[];
+}
+export interface OrchestratedPlan {
+    tasks: SubAgentTask[];
+    reasoning: string;
+}
+export interface OrchestratorResult {
+    content: string;
+    plan: OrchestratedPlan | null;
+    agentResults: Map<string, AgentRunResult>;
+    totalUsage: TokenUsage;
+    execution: AgentExecution;
+}
+export declare class Orchestrator extends BaseAgent {
+    private agents;
+    constructor(config: AgentConfig, client: OpenRouterClient, registry: ToolRegistry, workingDirectory: string, sessionId: string);
+    /**
+     * Register a sub-agent
+     */
+    registerAgent(agent: BaseAgent): void;
+    /**
+     * Get all registered agents
+     */
+    getAgents(): BaseAgent[];
+    /**
+     * Plan the task decomposition using the orchestrator model
+     */
+    plan(task: string, callbacks?: AgentCallbacks): Promise<OrchestratedPlan>;
+    /**
+     * Execute a planned task with sub-agents
+     */
+    orchestrate(task: string, callbacks?: AgentCallbacks, autoPlan?: boolean): Promise<OrchestratorResult>;
+    /**
+     * Direct run - delegate to the most appropriate agent
+     */
+    runDirect(task: string, agentName: string, callbacks?: AgentCallbacks): Promise<AgentRunResult>;
+}
+//# sourceMappingURL=orchestrator.d.ts.map

package/dist/agents/orchestrator.js

@@ -0,0 +1,192 @@
+// ============================================================
+// NeuroCLI - Orchestrator Agent
+// Central coordinator that manages sub-agents
+// ============================================================
+import { BaseAgent } from './base.js';
+export class Orchestrator extends BaseAgent {
+    agents = new Map();
+    constructor(config, client, registry, workingDirectory, sessionId) {
+        super(config, client, registry, workingDirectory, sessionId);
+    }
+    /**
+     * Register a sub-agent
+     */
+    registerAgent(agent) {
+        this.agents.set(agent.name, agent);
+    }
+    /**
+     * Get all registered agents
+     */
+    getAgents() {
+        return Array.from(this.agents.values());
+    }
+    /**
+     * Plan the task decomposition using the orchestrator model
+     */
+    async plan(task, callbacks) {
+        const agentDescriptions = Array.from(this.agents.entries())
+            .map(([name, agent]) => `- ${name}: ${agent.description}`)
+            .join('\n');
+        const planPrompt = `You are the Orchestrator. Analyze the following task and create an execution plan using the available agents.
+
+## Available Agents
+${agentDescriptions}
+
+## Task
+${task}
+
+## Instructions
+1. Break down the task into specific sub-tasks
+2. Assign each sub-task to the most appropriate agent
+3. Specify dependencies between tasks (which tasks must complete before others can start)
+4. Provide any context each agent needs
+
+Respond with a JSON plan in this exact format:
+\`\`\`json
+{
+  "reasoning": "Your analysis of the task and why you chose this approach",
+  "tasks": [
+    {
+      "agent": "agent_name",
+      "task": "specific task description",
+      "context": "any additional context",
+      "dependsOn": []
+    }
+  ]
+}
+\`\`\``;
+        const messages = [
+            { role: 'system', content: 'You are an expert task orchestrator. Always respond with valid JSON.', timestamp: Date.now() },
+            { role: 'user', content: planPrompt, timestamp: Date.now() },
+        ];
+        const response = await this.client.quickChat(this.config.model || 'anthropic/claude-sonnet-4', messages);
+        try {
+            // Extract JSON from response
+            const jsonMatch = response.content.match(/```json\n([\s\S]*?)\n```/) ||
+                response.content.match(/\{[\s\S]*\}/);
+            const jsonStr = jsonMatch ? (jsonMatch[1] || jsonMatch[0]) : response.content;
+            return JSON.parse(jsonStr);
+        }
+        catch {
+            // Fallback: use coder agent directly
+            return {
+                reasoning: 'Could not parse plan, defaulting to direct coding approach',
+                tasks: [{ agent: 'Coder', task, dependsOn: [] }],
+            };
+        }
+    }
+    /**
+     * Execute a planned task with sub-agents
+     */
+    async orchestrate(task, callbacks, autoPlan = true) {
+        const startTime = Date.now();
+        const totalUsage = { inputTokens: 0, outputTokens: 0, cost: 0 };
+        const agentResults = new Map();
+        const execution = {
+            agentName: 'Orchestrator',
+            task,
+            startTime,
+            iterations: 0,
+            tokensUsed: 0,
+            status: 'running',
+        };
+        // Step 1: Create execution plan
+        let plan;
+        if (autoPlan) {
+            callbacks?.onThinking?.('🧠 Planning task decomposition...');
+            plan = await this.plan(task, callbacks);
+        }
+        else {
+            plan = {
+                reasoning: 'Direct execution without planning',
+                tasks: [{ agent: 'Coder', task }],
+            };
+        }
+        callbacks?.onThinking?.(`📋 Plan: ${plan.tasks.length} sub-tasks`);
+        callbacks?.onThinking?.(`💭 ${plan.reasoning}`);
+        // Step 2: Execute tasks respecting dependencies
+        const completedTasks = new Set();
+        let taskIndex = 0;
+        while (completedTasks.size < plan.tasks.length) {
+            // Find tasks whose dependencies are all completed
+            const readyTasks = plan.tasks.filter(t => {
+                if (completedTasks.has(t.agent + ':' + t.task))
+                    return false;
+                if (!t.dependsOn || t.dependsOn.length === 0)
+                    return true;
+                return t.dependsOn.every(dep => completedTasks.has(dep));
+            });
+            if (readyTasks.length === 0) {
+                // Deadlock or all tasks completed
+                break;
+            }
+            // Execute ready tasks (could be parallelized in future)
+            for (const subTask of readyTasks) {
+                const agent = this.agents.get(subTask.agent);
+                if (!agent) {
+                    callbacks?.onThinking?.(`⚠️ Agent not found: ${subTask.agent}`);
+                    completedTasks.add(subTask.agent + ':' + subTask.task);
+                    continue;
+                }
+                taskIndex++;
+                callbacks?.onThinking?.(`\n🤖 [${taskIndex}/${plan.tasks.length}] Running ${subTask.agent}: ${subTask.task.slice(0, 80)}...`);
+                // Build context from previous agent results
+                let fullTask = subTask.task;
+                if (subTask.context) {
+                    fullTask = `${subTask.context}\n\nTask: ${subTask.task}`;
+                }
+                // Add results from dependent tasks as context
+                if (subTask.dependsOn && subTask.dependsOn.length > 0) {
+                    const depResults = subTask.dependsOn
+                        .map(dep => agentResults.get(dep))
+                        .filter(Boolean)
+                        .map(r => `Previous agent result:\n${r.content}`)
+                        .join('\n\n');
+                    if (depResults) {
+                        fullTask = `${fullTask}\n\n## Context from previous agents:\n${depResults}`;
+                    }
+                }
+                const result = await agent.run(fullTask, {
+                    onToken: (token) => callbacks?.onToken?.(token),
+                    onToolCall: (name, args) => callbacks?.onToolCall?.(name, args),
+                    onToolResult: (name, result, isError) => callbacks?.onToolResult?.(name, result, isError),
+                    onApprovalNeeded: async (name, args, risk) => {
+                        return callbacks?.onApprovalNeeded?.(name, args, risk) ?? true;
+                    },
+                    onThinking: (thinking) => callbacks?.onThinking?.(thinking),
+                });
+                agentResults.set(subTask.agent + ':' + subTask.task, result);
+                totalUsage.inputTokens += result.usage.inputTokens;
+                totalUsage.outputTokens += result.usage.outputTokens;
+                totalUsage.cost += result.usage.cost;
+                completedTasks.add(subTask.agent + ':' + subTask.task);
+            }
+        }
+        execution.endTime = Date.now();
+        execution.iterations = taskIndex;
+        execution.tokensUsed = totalUsage.inputTokens + totalUsage.outputTokens;
+        execution.status = 'completed';
+        // Step 3: Synthesize final result
+        const resultSummary = Array.from(agentResults.entries())
+            .map(([key, result]) => `### ${key}\n${result.content}`)
+            .join('\n\n');
+        return {
+            content: resultSummary,
+            plan,
+            agentResults,
+            totalUsage,
+            execution,
+        };
+    }
+    /**
+     * Direct run - delegate to the most appropriate agent
+     */
+    async runDirect(task, agentName, callbacks) {
+        const agent = this.agents.get(agentName);
+        if (!agent) {
+            throw new Error(`Agent not found: ${agentName}. Available: ${Array.from(this.agents.keys()).join(', ')}`);
+        }
+        return agent.run(task, callbacks);
+    }
+}
+//# sourceMappingURL=orchestrator.js.map