js-agent-core 1.0.1

package/src/core/BaseAgent.ts

@@ -0,0 +1,676 @@
+import { IAgentEvent, IEventEmitter, ISkill, ITool, ILLMProvider, LLMMessage, IMemory, LLMResponse, IPlanner, TaskList, IAgentState, ISkillStore, SkillFile, SkillMetadata, ILogger, LogLevel, LogContext } from '../interfaces/index.js';
+import { SimpleEventEmitter } from './EventEmitter.js';
+import { ToolRegistry } from './ToolRegistry.js';
+import { SimpleMemory } from './SimpleMemory.js';
+import { LongTermMemory } from './LongTermMemory.js';
+import { AutoVectorStore } from './AutoVectorStore.js';
+import { LocalEmbedder } from './LocalEmbedder.js';
+import { StructuredPlanner } from './StructuredPlanner.js';
+import { SkillLoader } from './persistence/SkillLoader.js';
+import { LoggerFactory } from './logging/index.js';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+// Removed uuid import to avoid new dependencies
+
+export interface AgentOptions {
+  provider: ILLMProvider;
+  model: string;
+  systemPrompt?: string;
+  memory?: IMemory;
+  planner?: IPlanner;
+  maxIterations?: number;
+  enableDynamicSkills?: boolean;
+  routerModel?: string;
+  skillStore?: ISkillStore;
+  stream?: boolean;
+  logger?: ILogger;
+  agentId?: string;
+}
+
+export class BaseAgent {
+  private eventEmitter: IEventEmitter;
+  private toolRegistry: ToolRegistry;
+  private provider: ILLMProvider;
+  private memory: IMemory;
+  private planner: IPlanner;
+  private model: string;
+  private routerModel?: string;
+  private maxIterations: number;
+  private enableDynamicSkills: boolean;
+  private skillStore?: ISkillStore;
+  private stream: boolean;
+  private logger?: ILogger;
+  private agentId: string;
+  private currentTraceId?: string;
+  private skills: ISkill[] = [];
+  private registeredSkills: ISkill[] = [];
+  private activeSkills: Set<string> = new Set();
+  private currentTaskList?: TaskList;
+
+  constructor(options: AgentOptions) {
+    this.eventEmitter = new SimpleEventEmitter();
+    this.toolRegistry = new ToolRegistry();
+    this.provider = options.provider;
+    this.model = options.model;
+    this.routerModel = options.routerModel;
+    this.logger = options.logger;
+    this.agentId = options.agentId || `agent_${Date.now()}`;
+    
+    // Default to LongTermMemory with AutoVectorStore and LocalEmbedder
+    // This allows for environment-aware persistence and lazy-loading of models
+    this.memory = options.memory || new LongTermMemory({
+      provider: this.provider,
+      vectorStore: new AutoVectorStore(),
+      embedder: new LocalEmbedder()
+    });
+    
+    this.stream = options.stream ?? true;
+    this.planner = options.planner || new StructuredPlanner(this.provider, this.model, this.stream);
+    this.maxIterations = options.maxIterations || 10;
+    this.enableDynamicSkills = options.enableDynamicSkills || false;
+    this.skillStore = options.skillStore;
+    
+    if (options.systemPrompt) {
+      this.addToMemory({ role: 'system', content: options.systemPrompt });
+    }
+
+    // 异步初始化默认 Logger
+    this.initDefaultLogger();
+  }
+
+  private async initDefaultLogger() {
+    if (!this.logger) {
+      this.logger = await LoggerFactory.createDefaultLogger() || undefined;
+    }
+  }
+
+  registerSkill(skill: ISkill): void {
+    if (!this.registeredSkills.some(s => s.name === skill.name)) {
+      this.registeredSkills.push(skill);
+    }
+  }
+
+  /**
+   * 持久化保存一个新技能并自动注册
+   */
+  async saveSkill(metadata: SkillMetadata, files: SkillFile[]): Promise<void> {
+    if (!this.skillStore) {
+      throw new Error('Skill store not configured for this agent.');
+    }
+
+    // 1. 保存到存储器
+    await this.skillStore.saveSkill(metadata, files);
+
+    // 2. 加载并注册到内存
+    const skill = await SkillLoader.load(metadata, files, (this.skillStore as any).baseDir);
+    this.registerSkill(skill);
+  }
+
+  /**
+   * 从存储中加载所有已保存的技能
+   */
+  async loadStoredSkills(): Promise<void> {
+    if (!this.skillStore) return;
+
+    const metadataList = await this.skillStore.listSkills();
+    for (const meta of metadataList) {
+      const files = await this.skillStore.getSkillFiles(meta.name);
+      try {
+        const skill = await SkillLoader.load(meta, files, (this.skillStore as any).baseDir);
+        this.registerSkill(skill);
+      } catch (e) {
+        console.error(`Failed to load stored skill ${meta.name}:`, e);
+      }
+    }
+  }
+
+  async use(skill: ISkill): Promise<void> {
+    if (this.activeSkills.has(skill.name)) {
+      return;
+    }
+
+    this.skills.push(skill);
+    this.activeSkills.add(skill.name);
+    this.toolRegistry.registerSkill(skill);
+    
+    if (skill.onInit) {
+      await skill.onInit(this);
+    }
+
+    if (skill.systemPrompt) {
+      const prompt = await skill.systemPrompt(this);
+      await this.addToMemory({ role: 'system', content: prompt });
+    }
+  }
+
+  registerTool(tool: ITool): void {
+    this.toolRegistry.registerTool(tool);
+  }
+
+  on<T = any>(event: IAgentEvent['type'], listener: (payload: T) => void): void {
+    this.eventEmitter.on(event, listener);
+  }
+
+  async getHistory(): Promise<LLMMessage[]> {
+    return this.memory.getHistory();
+  }
+
+  async getMemoryUsage(): Promise<{ used: number; total: number }> {
+    const history = await this.memory.getHistory();
+    const totalChars = history.reduce((acc, m) => acc + (m.content?.length || 0), 0);
+    const estimatedTokens = Math.ceil(totalChars / 4);
+    return { used: estimatedTokens, total: 128000 };
+  }
+
+  async exportState(): Promise<IAgentState> {
+    return {
+      history: await this.memory.getHistory(),
+      taskList: this.currentTaskList,
+      skills: {
+        active: Array.from(this.activeSkills),
+        registered: this.registeredSkills.map(s => s.name)
+      },
+      tools: this.toolRegistry.getAllTools().map(t => t.name),
+      config: {
+        model: this.model,
+        routerModel: this.routerModel,
+        enableDynamicSkills: this.enableDynamicSkills,
+        maxIterations: this.maxIterations
+      },
+      metadata: {
+        version: '1.0.0',
+        exportedAt: new Date().toISOString()
+      }
+    };
+  }
+
+  /**
+   * 恢复 Agent 状态 (从快照中恢复)
+   * @param state 导出的状态快照
+   * @param availableSkills 可用的技能定义列表 (因为函数逻辑无法序列化，需手动提供)
+   * @param availableTools 可用的工具定义列表 (可选)
+   */
+  async restoreState(state: IAgentState, availableSkills: ISkill[] = [], availableTools: ITool[] = []): Promise<void> {
+    // 1. 恢复配置 (Config)
+    this.model = state.config.model;
+    this.routerModel = state.config.routerModel;
+    this.enableDynamicSkills = state.config.enableDynamicSkills;
+    this.maxIterations = state.config.maxIterations;
+    this.currentTaskList = state.taskList;
+
+    // 2. 恢复记忆 (Memory) - 先清空再添加
+    if (this.memory.clear) {
+      await this.memory.clear();
+    }
+    const history = state.history;
+    for (const msg of history) {
+      await this.addToMemory(msg);
+    }
+
+    // 3. 恢复已注册的技能 (Registered Skills)
+    for (const skillName of state.skills.registered) {
+      const skill = availableSkills.find(s => s.name === skillName);
+      if (skill) {
+        this.registerSkill(skill);
+      }
+    }
+
+    // 4. 恢复已激活的技能 (Active Skills)
+    for (const skillName of state.skills.active) {
+      const skill = availableSkills.find(s => s.name === skillName);
+      if (skill) {
+        // 使用 use 会注入提示词和工具，由于 memory 已经恢复，这里需要确保幂等
+        await this.use(skill);
+      }
+    }
+
+    // 5. 恢复手动注册的工具 (Tools)
+    if (state.tools && state.tools.length > 0) {
+      for (const toolName of state.tools) {
+        // 如果工具不在已激活技能中，则尝试手动注册
+        const tool = availableTools.find(t => t.name === toolName);
+        if (tool) {
+          this.registerTool(tool);
+        }
+      }
+    }
+  }
+
+  async run(input: string, options?: { traceId?: string }): Promise<string> {
+    this.currentTraceId = options?.traceId || `tr-${Math.random().toString(36).substring(2, 11)}`;
+    const traceId = this.currentTraceId;
+    this.emit('start', input);
+    this.log('info', 'Agent run started', { input });
+
+    // Step 0: Dynamic Skill Selection (Optional)
+    if (this.enableDynamicSkills && this.registeredSkills.length > 0) {
+      this.emit('think', 'Selecting relevant skills...');
+      this.log('debug', 'Selecting dynamic skills');
+      await this.selectAndActivateSkills(input);
+    }
+
+    // Get context from memory if available
+    let context = '';
+    if (this.memory.getContext) {
+      context = await this.memory.getContext(input);
+      this.log('debug', 'Context retrieved from memory', { contextLength: context.length });
+    }
+
+    const tools = this.toolRegistry.getAllTools();
+    const toolsJson = tools.map(tool => ({
+      type: 'function',
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: zodToJsonSchema(tool.parameters),
+      },
+    }));
+
+    // Add mark_task_status system tool dynamically
+    toolsJson.push({
+      type: 'function',
+      function: {
+        name: 'mark_task_status',
+        description: 'Mark a task as completed or failed based on its criteria. MUST be called when a task criteria is met or determined impossible.',
+        parameters: {
+          type: 'object',
+          properties: {
+            task_id: { type: 'string', description: 'The ID of the task to mark' },
+            status: { type: 'string', enum: ['completed', 'failed'] },
+            result_or_reason: { type: 'string', description: 'Final result summary or failure reason' }
+          },
+          required: ['task_id', 'status', 'result_or_reason']
+        }
+      }
+    } as any);
+
+    // Step 1: Planning
+    this.emit('think', 'Planning tasks...');
+    this.log('info', 'Starting task planning', { toolsCount: tools.length });
+    let currentPlanningContent = '';
+    this.currentTaskList = await this.planner.plan(input, tools, context, (chunk) => {
+      currentPlanningContent += chunk;
+      
+      // Optimization: Only emit content inside <think> tags during planning
+      // to avoid showing raw JSON to the user
+      const thinkMatch = currentPlanningContent.match(/<think>([\s\S]*?)$/);
+      if (thinkMatch) {
+        let thought = thinkMatch[1];
+        // If there's a closing tag, only show content before it
+        if (thought.includes('</think>')) {
+          thought = thought.split('</think>')[0];
+        }
+        this.emit('think', thought);
+      }
+    });
+    this.log('debug', 'Planning completed', { rawResponse: currentPlanningContent });
+    this.emit('task.plan', this.currentTaskList);
+
+    // Optimization: If planner provides a direct response, return it immediately
+    if (this.currentTaskList.isCompleted && this.currentTaskList.response) {
+      this.log('info', 'Planner provided direct response', { response: this.currentTaskList.response });
+      this.emit('think', this.currentTaskList.response);
+      await this.addToMemory({ role: 'user', content: input });
+      await this.addToMemory({ role: 'assistant', content: this.currentTaskList.response });
+      this.emit('agent.done', this.currentTaskList.response);
+      return this.currentTaskList.response;
+    }
+
+    this.emit('think', `Plan generated with ${this.currentTaskList.tasks.length} tasks.`);
+    this.log('info', 'Tasks to execute', { tasks: this.currentTaskList.tasks });
+
+    await this.addToMemory({ role: 'user', content: input });
+
+    let iterations = 0;
+    while (iterations < this.maxIterations) {
+      iterations++;
+      this.log('info', `Starting iteration ${iterations}`);
+      
+      const messages = await this.memory.getHistory();
+      
+      // Inject context from LongTermMemory as a system message if it exists
+      if (context) {
+        messages.push({ 
+          role: 'system', 
+          content: context 
+        });
+      }
+
+      // 动态注入当前任务列表，不持久化到 memory history
+      if (this.currentTaskList) {
+        // Find ready tasks
+        const readyTasks = this.currentTaskList.tasks.filter(t => 
+          (t.status === 'pending' || t.status === 'in_progress') && 
+          t.dependsOn.every(depId => this.currentTaskList!.tasks.find(dep => dep.id === depId)?.status === 'completed')
+        );
+
+        for (const t of readyTasks) {
+          if (t.status === 'pending') {
+            t.status = 'in_progress';
+            this.emit('task.update', t);
+          }
+        }
+
+        const taskContext = readyTasks.map(t => `- Task ID: ${t.id}\n  Goal: ${t.goal}\n  Criteria (Definition of Done): ${t.criteria}`).join('\n\n');
+
+        messages.push({
+          role: 'system',
+          content: `Current Task List:\n${JSON.stringify(this.currentTaskList, null, 2)}\n\nYou are currently executing the following active task(s):\n${taskContext}\n\nYou MUST use the 'mark_task_status' tool to explicitly mark a task as 'completed' or 'failed' once its criteria is met or it is determined impossible. Do not guess the status, explicitly call the tool.`
+        });
+      }
+      
+      // Attempt generation with streaming support
+      let response: LLMResponse;
+      this.log('debug', 'Calling LLM provider', { traceId, iterations, messagesCount: messages.length });
+      
+      if (this.provider.stream && this.stream) {
+        let fullContent = '';
+
+        response = await this.provider.stream(messages, {
+          model: this.model,
+          tools: toolsJson.length > 0 ? toolsJson : undefined,
+          stream: true,
+          intent: 'execute',
+        }, (chunk) => {
+          if (chunk.content) {
+            fullContent += chunk.content;
+            this.emit('think', fullContent); // Emit partial content
+          }
+          if (chunk.toolCalls) {
+            this.emit('tool.call.delta', chunk.toolCalls);
+          }
+        });
+        this.log('debug', 'LLM stream finished', { fullContent, toolCallsCount: response.toolCalls?.length });
+      } else {
+        response = await this.provider.generate(messages, {
+          model: this.model,
+          tools: toolsJson.length > 0 ? toolsJson : undefined,
+          stream: false,
+          intent: 'execute',
+        });
+        this.log('debug', 'LLM generation finished', { response });
+      }
+
+      if (response.content) {
+        this.emit('think', response.content);
+        await this.addToMemory({ 
+          role: 'assistant', 
+          content: response.content,
+          toolCalls: response.toolCalls 
+        });
+      }
+
+      // Check if goal reached or need more planning
+      if (!response.toolCalls || response.toolCalls.length === 0) {
+        this.log('info', 'Agent execution completed successfully', { finalResponse: response.content });
+        this.emit('agent.done', response.content || '');
+        return response.content || '';
+      }
+
+      if (response.toolCalls && response.toolCalls.length > 0) {
+        this.log('info', `Executing ${response.toolCalls.length} tools in parallel`, { toolCalls: response.toolCalls });
+        // Collect results and errors for all calls in parallel
+        const toolExecutionPromises = response.toolCalls.map(async (toolCall) => {
+          if (toolCall.function.name === 'mark_task_status') {
+            try {
+              const args = JSON.parse(toolCall.function.arguments);
+              const task = this.currentTaskList!.tasks.find(t => t.id === args.task_id);
+              if (task) {
+                task.status = args.status;
+                if (args.status === 'completed') {
+                  task.result = args.result_or_reason;
+                } else {
+                  task.error = args.result_or_reason;
+                }
+                this.emit('task.update', task);
+                
+                const resultMsg = `Task ${args.task_id} successfully marked as ${args.status}.`;
+                this.log('info', resultMsg, { task_id: args.task_id, status: args.status });
+                await this.addToMemory({
+                  role: 'tool',
+                  tool_call_id: toolCall.id,
+                  name: toolCall.function.name,
+                  content: resultMsg,
+                });
+                return { toolName: toolCall.function.name, success: true, data: resultMsg };
+              } else {
+                const errorMsg = `Task with ID ${args.task_id} not found.`;
+                this.log('warn', errorMsg, { task_id: args.task_id });
+                await this.addToMemory({
+                  role: 'tool',
+                  tool_call_id: toolCall.id,
+                  name: toolCall.function.name,
+                  content: errorMsg,
+                });
+                return { toolName: toolCall.function.name, success: false, error: errorMsg };
+              }
+            } catch (err: any) {
+              const errorMsg = `Failed to parse mark_task_status arguments: ${err.message}`;
+              await this.addToMemory({
+                role: 'tool',
+                tool_call_id: toolCall.id,
+                name: toolCall.function.name,
+                content: errorMsg,
+              });
+              return { toolName: toolCall.function.name, success: false, error: errorMsg };
+            }
+          }
+
+          const tool = this.toolRegistry.getTool(toolCall.function.name);
+          if (!tool) {
+            const error = `Tool '${toolCall.function.name}' not found.`;
+            this.log('error', error, { toolName: toolCall.function.name });
+            await this.addToMemory({
+              role: 'tool',
+              tool_call_id: toolCall.id,
+              name: toolCall.function.name,
+              content: error,
+            });
+            return { toolName: toolCall.function.name, error };
+          }
+
+            // 人机协作审批机制 (Human-in-the-loop)
+            if (tool.requiresApproval) {
+              this.emit('think', `Waiting for user approval to execute tool: ${tool.name}`);
+              this.log('info', 'Waiting for tool approval', { toolName: tool.name, arguments: toolCall.function.arguments });
+              
+              try {
+                const approvalResult = await new Promise<any>((resolve, reject) => {
+                  // 设置超时机制 (例如 5 分钟)，防止 Agent 永久挂起
+                  const timeoutId = setTimeout(() => {
+                    reject(new Error(`Approval timeout for tool ${tool.name}`));
+                  }, 5 * 60 * 1000);
+
+                  this.emit('tool.require_approval', {
+                    toolCallId: toolCall.id,
+                    toolName: tool.name,
+                    arguments: toolCall.function.arguments,
+                    resolve: (result: any) => {
+                      clearTimeout(timeoutId);
+                      resolve(result);
+                    },
+                    reject: (error: Error) => {
+                      clearTimeout(timeoutId);
+                      reject(error);
+                    }
+                  });
+                });
+
+                if (!approvalResult.approved) {
+                  const errorMsg = `User rejected execution. Reason: ${approvalResult.feedback || 'No reason provided'}`;
+                  this.log('warn', 'Tool execution rejected by user', { toolName: tool.name, feedback: approvalResult.feedback });
+
+                  await this.addToMemory({
+                    role: 'tool',
+                    tool_call_id: toolCall.id,
+                    name: tool.name,
+                    content: errorMsg,
+                  });
+
+                  return { toolName: tool.name, error: errorMsg };
+                }
+                
+                // 进阶：如果用户修改了参数，则覆盖原参数
+                if (approvalResult.modifiedArgs) {
+                  this.log('info', 'Tool arguments modified by user', { toolName: tool.name, oldArgs: toolCall.function.arguments, newArgs: approvalResult.modifiedArgs });
+                  toolCall.function.arguments = typeof approvalResult.modifiedArgs === 'string' 
+                    ? approvalResult.modifiedArgs 
+                    : JSON.stringify(approvalResult.modifiedArgs);
+                }
+
+              } catch (approvalError: any) {
+                const errorMsg = `Approval process failed: ${approvalError.message}`;
+                this.log('error', errorMsg, { toolName: tool.name, stack: approvalError.stack });
+                await this.addToMemory({
+                  role: 'tool',
+                  tool_call_id: toolCall.id,
+                  name: tool.name,
+                  content: errorMsg,
+                });
+                return { toolName: tool.name, error: errorMsg };
+              }
+            }
+
+            this.log('info', `Calling tool: ${tool.name}`, { arguments: toolCall.function.arguments });
+            this.emit('tool.call', {
+              name: tool.name,
+              arguments: toolCall.function.arguments,
+            });
+
+          try {
+            const startTime = Date.now();
+            // 使用 ToolRegistry 的统一校验与执行逻辑
+            const result = await this.toolRegistry.validateAndExecute(
+              toolCall.function.name,
+              toolCall.function.arguments,
+              undefined,
+              (percent, message) => {
+                this.emit('tool.progress', { name: tool.name, percent, message });
+              }
+            );
+            const latency = Date.now() - startTime;
+            
+            this.log('info', `Tool ${tool.name} executed`, { latency, result });
+            this.emit('tool.result', result);
+
+            await this.addToMemory({
+              role: 'tool',
+              tool_call_id: toolCall.id,
+              name: tool.name,
+              content: result.error ? result.error : JSON.stringify(result.data),
+            });
+            return { toolName: tool.name, ...result };
+          } catch (error: any) {
+            const errorMsg = `Error executing tool ${tool.name}: ${error.message}`;
+            this.log('error', errorMsg, { toolName: tool.name, stack: error.stack });
+            this.emit('agent.error', errorMsg);
+
+            await this.addToMemory({
+              role: 'tool',
+              tool_call_id: toolCall.id,
+              name: tool.name,
+              content: errorMsg,
+            });
+            return { toolName: tool.name, error: error.message };
+          }
+        });
+
+        const executionResults = await Promise.all(toolExecutionPromises);
+
+        // Check if goal reached or need more planning if ANY tool failed
+        const failedResults = executionResults.filter(r => r && r.error);
+        if (failedResults.length > 0) {
+          const errorContext = failedResults
+            .map(r => `Tool ${r!.toolName} failed: ${r!.error}`)
+            .join('\n');
+
+          this.log('warn', 'Some tools failed, triggering replan', { failedTools: failedResults.map(r => r!.toolName) });
+          this.emit('think', `Re-planning due to errors: ${failedResults.map(r => r!.toolName).join(', ')}...`);
+          let currentReplanContent = '';
+          this.currentTaskList = await this.planner.replan(input, tools, this.currentTaskList!, errorContext, (chunk) => {
+            currentReplanContent += chunk;
+            this.emit('think', currentReplanContent);
+          });
+          this.log('debug', 'Re-planning completed', { rawResponse: currentReplanContent });
+          this.emit('task.plan', this.currentTaskList);
+        }
+      }
+    }
+
+
+    const errorMsg = `Agent exceeded max iterations (${this.maxIterations})`;
+    this.log('error', errorMsg, { traceId, iterations });
+    this.emit('agent.error', errorMsg);
+    throw new Error(errorMsg);
+  }
+
+  private emit(type: IAgentEvent['type'], payload: any) {
+    const event: IAgentEvent = {
+      id: `evt-${Math.random().toString(36).substring(2, 11)}`,
+      type,
+      payload,
+      timestamp: Date.now(),
+      agentId: this.agentId,
+      traceId: this.currentTraceId,
+    };
+    this.eventEmitter.emit(type, event);
+  }
+
+  private log(level: LogLevel, message: string, context?: LogContext) {
+    if (this.logger) {
+      this.logger.log(level, message, {
+        agentId: this.agentId,
+        traceId: this.currentTraceId,
+        ...context
+      });
+    }
+  }
+
+  private async addToMemory(message: LLMMessage): Promise<void> {
+    await this.memory.add(message);
+    this.emit('memory.add', message);
+    this.log('debug', 'Message added to memory', { 
+      role: message.role, 
+      contentPreview: message.content?.substring(0, 100),
+      toolCalls: message.toolCalls?.length 
+    });
+    
+    // Estimate memory usage (simplified for demo)
+    const history = await this.memory.getHistory();
+    const totalChars = history.reduce((acc, m) => acc + (m.content?.length || 0), 0);
+    const estimatedTokens = Math.ceil(totalChars / 4);
+    this.emit('memory.usage', { used: estimatedTokens, total: 128000 });
+  }
+
+  private async selectAndActivateSkills(input: string): Promise<void> {
+    const skillList = this.registeredSkills
+      .map(s => `- ${s.name}: ${s.description || 'No description'}`)
+      .join('\n');
+
+    const prompt = `Based on the user's request: "${input}", select the most relevant skills from the following list to help solve the task. 
+Return only the names of the selected skills as a JSON array of strings. If no skills are needed, return an empty array [].
+
+Available Skills:
+${skillList}`;
+
+    const response = await this.provider.generate([
+      { role: 'system', content: 'You are a skill router. Your goal is to select necessary skills for a given task.' },
+      { role: 'user', content: prompt }
+    ], { model: this.routerModel || this.model });
+
+    try {
+      // Simple extraction of JSON array
+      const match = response.content?.match(/\[.*\]/s);
+      if (match) {
+        const selectedNames: string[] = JSON.parse(match[0]);
+        for (const name of selectedNames) {
+          const skill = this.registeredSkills.find(s => s.name === name);
+          if (skill) {
+            await this.use(skill);
+          }
+        }
+      }
+    } catch (e: any) {
+      this.emit('agent.error', `Failed to parse skill routing response: ${e.message}`);
+    }
+  }
+}