genesis-ai-cli 7.4.5

package/dist/src/cli/dispatcher.d.ts

@@ -0,0 +1,182 @@
+/**
+ * Genesis 6.0 - Tool Dispatcher
+ *
+ * Intelligent router that:
+ * 1. Parses tool calls from LLM responses
+ * 2. Routes to appropriate tools (local or MCP)
+ * 3. Supports parallel execution
+ * 4. Tracks execution status with progress
+ * 5. Feeds results back for continued conversation
+ */
+import { MCPServerName } from '../types.js';
+export interface ToolCall {
+    id: string;
+    name: string;
+    params: Record<string, unknown>;
+    source: 'local' | 'mcp';
+    mcpServer?: MCPServerName;
+}
+export interface ToolResult {
+    callId: string;
+    name: string;
+    success: boolean;
+    data?: unknown;
+    error?: string;
+    duration: number;
+    source: 'local' | 'mcp';
+}
+export interface DispatchResult {
+    success: boolean;
+    results: ToolResult[];
+    totalDuration: number;
+    parallelExecutions: number;
+    sequentialExecutions: number;
+}
+export interface DispatcherConfig {
+    maxParallel: number;
+    timeout: number;
+    retries: number;
+    verbose: boolean;
+    onProgress?: (status: ProgressStatus) => void;
+}
+export interface ProgressStatus {
+    phase: 'parsing' | 'validating' | 'executing' | 'complete';
+    current: number;
+    total: number;
+    currentTool?: string;
+    message?: string;
+}
+export interface LLMToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+export declare class ToolDispatcher {
+    private config;
+    private executionHistory;
+    constructor(config?: Partial<DispatcherConfig>);
+    /**
+     * Parse tool calls from LLM response
+     */
+    parseToolCalls(response: string | LLMToolCall[]): ToolCall[];
+    /**
+     * Parse OpenAI-style tool call
+     */
+    private parseLLMToolCall;
+    /**
+     * Parse XML-style tool calls from text
+     * Example: <tool_use name="bash"><param name="command">ls -la</param></tool_use>
+     */
+    private parseXMLToolCalls;
+    /**
+     * Parse params from tool content
+     */
+    private parseToolParams;
+    /**
+     * Route tool to local or MCP
+     */
+    private routeTool;
+    /**
+     * Execute tool calls
+     */
+    dispatch(calls: ToolCall[]): Promise<DispatchResult>;
+    /**
+     * Validate a tool call
+     */
+    private validateCall;
+    /**
+     * Group calls by dependencies
+     * For now, all calls are independent and can run in parallel
+     */
+    private groupByDependencies;
+    /**
+     * Execute a single tool call
+     */
+    private executeCall;
+    /**
+     * Execute local tool
+     */
+    private executeLocalTool;
+    /**
+     * Execute MCP tool
+     */
+    private executeMCPTool;
+    /**
+     * Report progress
+     */
+    private progress;
+    /**
+     * Get execution history
+     */
+    getHistory(): ToolResult[];
+    /**
+     * Clear history
+     */
+    clearHistory(): void;
+    /**
+     * Update config
+     */
+    updateConfig(updates: Partial<DispatcherConfig>): void;
+    /**
+     * Get available tools (names only, for backward compatibility)
+     */
+    listTools(): {
+        local: string[];
+        mcp: Record<string, string[]>;
+    };
+    /**
+     * Get available tools with schemas (for dynamic prompt building)
+     * Returns tool definitions with name, description, and inputSchema
+     * Note: This is the sync version with static fallbacks - use discoverToolsWithSchemas() for real schemas
+     */
+    listToolsWithSchemas(): {
+        local: Array<{
+            name: string;
+            description?: string;
+        }>;
+        mcp: Record<string, Array<{
+            name: string;
+            description?: string;
+        }>>;
+    };
+    /**
+     * v7.3: Discover tools with REAL schemas from MCP servers
+     * Falls back to static schemas for servers that fail to connect
+     */
+    discoverToolsWithSchemas(): Promise<{
+        local: Array<{
+            name: string;
+            description?: string;
+            inputSchema?: any;
+        }>;
+        mcp: Record<string, Array<{
+            name: string;
+            description?: string;
+            inputSchema?: any;
+        }>>;
+    }>;
+    /**
+     * Format results for LLM context
+     */
+    formatResultsForLLM(results: ToolResult[]): string;
+}
+export declare function getDispatcher(config?: Partial<DispatcherConfig>): ToolDispatcher;
+export declare function resetDispatcher(): void;
+/**
+ * Parse and dispatch tool calls from LLM response
+ */
+export declare function dispatchTools(response: string | LLMToolCall[], config?: Partial<DispatcherConfig>): Promise<DispatchResult>;
+/**
+ * Execute a single tool by name
+ */
+export declare function executeTool(name: string, params: Record<string, unknown>): Promise<ToolResult>;
+/**
+ * List all available tools
+ */
+export declare function listAllTools(): {
+    local: string[];
+    mcp: Record<string, string[]>;
+};