mcp-rubber-duck 1.1.0

package/src/providers/duck-provider-enhanced.ts

@@ -0,0 +1,294 @@
+import { DuckProvider } from './provider.js';
+import { ChatOptions, ChatResponse, ProviderOptions, OpenAIChatParams, OpenAIMessage, MCPResult, OpenAIToolCall } from './types.js';
+import { FunctionBridge } from '../services/function-bridge.js';
+import { ConversationMessage } from '../config/types.js';
+import { logger } from '../utils/logger.js';
+import { SafeLogger } from '../utils/safe-logger.js';
+
+export interface EnhancedChatResponse extends ChatResponse {
+  pendingApprovals?: {
+    id: string;
+    message: string;
+  }[];
+  mcpResults?: MCPResult[];
+}
+
+export class EnhancedDuckProvider extends DuckProvider {
+  private functionBridge: FunctionBridge;
+  private mcpEnabled: boolean;
+
+  constructor(
+    name: string,
+    nickname: string,
+    options: ProviderOptions,
+    functionBridge: FunctionBridge,
+    mcpEnabled: boolean = true
+  ) {
+    super(name, nickname, options);
+    this.functionBridge = functionBridge;
+    this.mcpEnabled = mcpEnabled;
+  }
+
+  async chat(options: ChatOptions): Promise<EnhancedChatResponse> {
+    try {
+      // If MCP is enabled, add function definitions
+      if (this.mcpEnabled) {
+        const functions = await this.functionBridge.getFunctionDefinitions();
+        if (functions.length > 0) {
+          options.tools = functions;
+          options.toolChoice = 'auto';
+          logger.debug(`Added ${functions.length} MCP functions for ${this.nickname}`);
+        }
+      }
+
+      // Prepare messages for function calling
+      const messages = this.prepareMessages(options.messages, options.systemPrompt);
+      const modelToUse = options.model || this.options.model;
+
+      const baseParams: Partial<OpenAIChatParams> = {
+        model: modelToUse,
+        messages: messages as OpenAIMessage[],
+        stream: false,
+      };
+
+      // Add temperature if model supports it
+      if (this.supportsTemperature(modelToUse)) {
+        baseParams.temperature = options.temperature ?? this.options.temperature ?? 0.7;
+      }
+
+      // Add tools if available
+      if (options.tools && options.tools.length > 0) {
+        baseParams.tools = options.tools.map(tool => ({
+          type: 'function',
+          function: {
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.parameters,
+          },
+        }));
+        baseParams.tool_choice = options.toolChoice || 'auto';
+      }
+
+      // First API call
+      const response = await this.createChatCompletion(baseParams);
+      const choice = response.choices[0];
+
+      // Check if the model wants to call functions
+      if (choice.message?.tool_calls && choice.message.tool_calls.length > 0) {
+        return await this.handleToolCalls(
+          choice.message.tool_calls,
+          messages as OpenAIMessage[],
+          baseParams,
+          modelToUse
+        );
+      }
+
+      // No tool calls, return regular response
+      return {
+        content: choice.message?.content || '',
+        usage: response.usage ? {
+          promptTokens: response.usage.prompt_tokens,
+          completionTokens: response.usage.completion_tokens,
+          totalTokens: response.usage.total_tokens,
+        } : undefined,
+        model: modelToUse,
+        finishReason: choice.finish_reason || undefined,
+      };
+
+    } catch (error: unknown) {
+      logger.error(`Enhanced provider ${this.name} chat error:`, error);
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new Error(`Duck ${this.nickname} couldn't respond: ${errorMessage}`);
+    }
+  }
+
+  private async handleToolCalls(
+    toolCalls: OpenAIToolCall[],
+    messages: OpenAIMessage[],
+    baseParams: Partial<OpenAIChatParams>,
+    modelToUse: string
+  ): Promise<EnhancedChatResponse> {
+    const pendingApprovals: { id: string; message: string }[] = [];
+    const toolMessages: OpenAIMessage[] = [];
+    let hasExecutedTools = false;
+
+    // Add the assistant message with tool calls
+    const assistantMessage: OpenAIMessage = {
+      role: 'assistant' as const,
+      content: null,
+      tool_calls: toolCalls,
+    };
+    messages.push(assistantMessage);
+
+    // Process each tool call
+    for (const toolCall of toolCalls) {
+      try {
+        const functionName = toolCall.function.name;
+        const args = JSON.parse(toolCall.function.arguments) as Record<string, unknown>;
+
+        logger.info(`${this.nickname} wants to call function: ${functionName}`);
+        SafeLogger.debug(`Function call arguments for ${functionName}:`, args);
+
+        const result = await this.functionBridge.handleFunctionCall(
+          this.nickname,
+          functionName,
+          args
+        );
+
+        if (result.needsApproval && result.approvalId) {
+          // Function needs approval
+          pendingApprovals.push({
+            id: result.approvalId,
+            message: result.message || `Approval needed for ${functionName}`,
+          });
+
+          // Add a tool message indicating approval is needed
+          toolMessages.push({
+            role: 'tool',
+            tool_call_id: toolCall.id,
+            content: JSON.stringify({
+              status: 'approval_needed',
+              approval_id: result.approvalId,
+              message: result.message,
+            }),
+          });
+
+        } else if (result.success && result.data) {
+          // Function executed successfully
+          hasExecutedTools = true;
+          toolMessages.push({
+            role: 'tool',
+            tool_call_id: toolCall.id,
+            content: typeof result.data === 'string' 
+              ? result.data 
+              : JSON.stringify(result.data),
+          });
+
+        } else {
+          // Function failed
+          toolMessages.push({
+            role: 'tool',
+            tool_call_id: toolCall.id,
+            content: JSON.stringify({
+              error: result.error || 'Unknown error',
+            }),
+          });
+        }
+
+      } catch (error: unknown) {
+        logger.error(`Error processing tool call ${toolCall.id}:`, error);
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        toolMessages.push({
+          role: 'tool',
+          tool_call_id: toolCall.id,
+          content: JSON.stringify({
+            error: `Tool execution failed: ${errorMessage}`,
+          }),
+        });
+      }
+    }
+
+    // If we have pending approvals, return them without calling the model again
+    if (pendingApprovals.length > 0) {
+      const approvalMessage = pendingApprovals.length === 1
+        ? pendingApprovals[0].message
+        : `Multiple approvals needed: ${pendingApprovals.map(a => a.id).join(', ')}`;
+
+      return {
+        content: `⏳ ${approvalMessage}`,
+        model: modelToUse,
+        pendingApprovals,
+        finishReason: 'tool_calls',
+      };
+    }
+
+    // Add tool messages and call model again for final response
+    messages.push(...toolMessages);
+
+    // Remove tools from the follow-up call to get a natural language response
+    const followUpParams = {
+      ...baseParams,
+      messages,
+    };
+    delete followUpParams.tools;
+    delete followUpParams.tool_choice;
+
+    const finalResponse = await this.createChatCompletion(followUpParams);
+    const finalChoice = finalResponse.choices[0];
+
+    return {
+      content: finalChoice.message?.content || '',
+      usage: finalResponse.usage ? {
+        promptTokens: finalResponse.usage.prompt_tokens,
+        completionTokens: finalResponse.usage.completion_tokens,
+        totalTokens: finalResponse.usage.total_tokens,
+      } : undefined,
+      model: modelToUse,
+      finishReason: finalChoice.finish_reason || undefined,
+      mcpResults: hasExecutedTools ? (toolMessages as unknown as MCPResult[]) : undefined,
+    };
+  }
+
+  // Method to retry with approval
+  async retryWithApproval(
+    approvalId: string,
+    originalMessages: ConversationMessage[],
+    options: ChatOptions
+  ): Promise<EnhancedChatResponse> {
+    // Add approval ID to the tool arguments
+    if (options.tools) {
+      options.tools = options.tools.map(tool => ({
+        ...tool,
+        parameters: {
+          ...tool.parameters,
+          properties: {
+            ...(tool.parameters.properties as Record<string, unknown>),
+            _approval_id: {
+              type: 'string',
+              default: approvalId,
+            },
+          },
+        },
+      }));
+    }
+
+    // Retry the chat with the approval ID
+    return this.chat({
+      ...options,
+      messages: originalMessages,
+    });
+  }
+
+  // Check if MCP functions are available
+  async getMCPFunctionCount(): Promise<number> {
+    if (!this.mcpEnabled) {
+      return 0;
+    }
+
+    try {
+      const functions = await this.functionBridge.getFunctionDefinitions();
+      return functions.length;
+    } catch (error) {
+      return 0;
+    }
+  }
+
+  // Get MCP bridge statistics
+  getMCPStats() {
+    if (!this.mcpEnabled) {
+      return null;
+    }
+
+    return this.functionBridge.getStats();
+  }
+
+  // Enable/disable MCP for this provider
+  setMCPEnabled(enabled: boolean): void {
+    this.mcpEnabled = enabled;
+    logger.info(`MCP ${enabled ? 'enabled' : 'disabled'} for ${this.nickname}`);
+  }
+
+  isMCPEnabled(): boolean {
+    return this.mcpEnabled;
+  }
+}

package/src/providers/enhanced-manager.ts

@@ -0,0 +1,290 @@
+import { EnhancedDuckProvider } from './duck-provider-enhanced.js';
+import { ProviderManager } from './manager.js';
+import { ConfigManager } from '../config/config.js';
+import { FunctionBridge } from '../services/function-bridge.js';
+import { DuckResponse } from '../config/types.js';
+import { ChatOptions, MCPResult } from './types.js';
+import { logger } from '../utils/logger.js';
+
+export class EnhancedProviderManager extends ProviderManager {
+  private enhancedProviders: Map<string, EnhancedDuckProvider> = new Map();
+  private functionBridge?: FunctionBridge;
+  private mcpEnabled: boolean = false;
+
+  constructor(configManager: ConfigManager, functionBridge?: FunctionBridge) {
+    super(configManager);
+    this.functionBridge = functionBridge;
+    this.mcpEnabled = !!functionBridge && 
+      (configManager.getConfig().mcp_bridge?.enabled || false);
+    
+    if (this.mcpEnabled) {
+      this.initializeEnhancedProviders();
+    }
+  }
+
+  private initializeEnhancedProviders() {
+    if (!this.functionBridge) {
+      logger.warn('Function bridge not available, skipping enhanced providers');
+      return;
+    }
+
+    const config = this.configManager.getConfig();
+    const allProviders = config.providers;
+
+    for (const [name, providerConfig] of Object.entries(allProviders)) {
+      try {
+        // Create enhanced provider if MCP is enabled
+        const enhancedProvider = new EnhancedDuckProvider(
+          name,
+          providerConfig.nickname,
+          {
+            apiKey: providerConfig.api_key,
+            baseURL: providerConfig.base_url,
+            model: providerConfig.default_model,
+            availableModels: providerConfig.models,
+            temperature: providerConfig.temperature,
+            timeout: providerConfig.timeout,
+            maxRetries: providerConfig.max_retries,
+            systemPrompt: providerConfig.system_prompt,
+          },
+          this.functionBridge,
+          this.mcpEnabled
+        );
+
+        this.enhancedProviders.set(name, enhancedProvider);
+        logger.info(`Initialized enhanced provider: ${name} (${providerConfig.nickname}) with MCP support`);
+      } catch (error) {
+        logger.error(`Failed to initialize enhanced provider ${name}:`, error);
+      }
+    }
+  }
+
+  getEnhancedProvider(name?: string): EnhancedDuckProvider {
+    if (!this.mcpEnabled) {
+      throw new Error('MCP bridge is not enabled');
+    }
+
+    const providerName = name || this.configManager.getConfig().default_provider;
+    
+    if (!providerName) {
+      throw new Error('No provider specified and no default provider configured');
+    }
+
+    const provider = this.enhancedProviders.get(providerName);
+    
+    if (!provider) {
+      throw new Error(`Enhanced duck "${providerName}" not found in the pond`);
+    }
+
+    return provider;
+  }
+
+  async askDuckWithMCP(
+    providerName: string | undefined,
+    prompt: string,
+    options?: Partial<ChatOptions>
+  ): Promise<DuckResponse & { pendingApprovals?: { id: string; message: string }[]; mcpResults?: MCPResult[] }> {
+    if (!this.mcpEnabled) {
+      // Fall back to regular provider
+      return this.askDuck(providerName, prompt, options);
+    }
+
+    const provider = this.getEnhancedProvider(providerName);
+    const startTime = Date.now();
+
+    try {
+      const response = await provider.chat({
+        messages: [{ role: 'user', content: prompt, timestamp: new Date() }],
+        ...options,
+      });
+
+      return {
+        provider: provider.name,
+        nickname: provider.nickname,
+        model: response.model,
+        content: response.content,
+        usage: response.usage ? {
+          prompt_tokens: response.usage.promptTokens,
+          completion_tokens: response.usage.completionTokens,
+          total_tokens: response.usage.totalTokens,
+          promptTokens: response.usage.promptTokens,
+          completionTokens: response.usage.completionTokens,
+          totalTokens: response.usage.totalTokens,
+        } : undefined,
+        latency: Date.now() - startTime,
+        cached: false,
+        pendingApprovals: response.pendingApprovals,
+        mcpResults: response.mcpResults,
+      };
+    } catch (error: unknown) {
+      // Try failover if enabled
+      if (this.configManager.getConfig().enable_failover && providerName === undefined) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logger.warn(`Primary enhanced provider failed, attempting failover: ${errorMessage}`);
+        return this.askDuckWithMCPFailover(prompt, options, provider.name);
+      }
+      throw error;
+    }
+  }
+
+  private async askDuckWithMCPFailover(
+    prompt: string,
+    options: Partial<ChatOptions> | undefined,
+    failedProvider: string
+  ): Promise<DuckResponse & { pendingApprovals?: { id: string; message: string }[]; mcpResults?: MCPResult[] }> {
+    const availableProviders = Array.from(this.enhancedProviders.keys()).filter(
+      name => name !== failedProvider
+    );
+
+    for (const providerName of availableProviders) {
+      try {
+        logger.info(`Trying enhanced failover to ${providerName}...`);
+        return await this.askDuckWithMCP(providerName, prompt, options);
+      } catch (error) {
+        logger.warn(`Enhanced failover to ${providerName} failed:`, error);
+        continue;
+      }
+    }
+
+    throw new Error('All enhanced ducks have flown away! No providers available.');
+  }
+
+  async compareDucksWithMCP(
+    prompt: string,
+    providerNames?: string[],
+    options?: Partial<ChatOptions>
+  ): Promise<Array<DuckResponse & { pendingApprovals?: { id: string; message: string }[]; mcpResults?: MCPResult[] }>> {
+    if (!this.mcpEnabled) {
+      // Fall back to regular comparison
+      return this.compareDucks(prompt, providerNames, options);
+    }
+
+    const providersToUse = providerNames 
+      ? providerNames.map(name => this.enhancedProviders.get(name)).filter(Boolean)
+      : Array.from(this.enhancedProviders.values());
+
+    if (providersToUse.length === 0) {
+      throw new Error('No valid enhanced providers specified');
+    }
+
+    const promises = providersToUse.map(provider => 
+      provider ? this.askDuckWithMCP(provider.name, prompt, options).catch(error => ({
+        provider: provider.name,
+        nickname: provider.nickname,
+        model: '',
+        content: `Error: ${error instanceof Error ? error.message : String(error)}`,
+        latency: 0,
+        cached: false,
+      })) : Promise.resolve({
+        provider: 'unknown',
+        nickname: 'Unknown',
+        model: '',
+        content: 'Error: Invalid provider',
+        latency: 0,
+        cached: false,
+      })
+    );
+
+    return Promise.all(promises);
+  }
+
+  async duckCouncilWithMCP(
+    prompt: string,
+    options?: Partial<ChatOptions>
+  ): Promise<Array<DuckResponse & { pendingApprovals?: { id: string; message: string }[]; mcpResults?: MCPResult[] }>> {
+    return this.compareDucksWithMCP(prompt, undefined, options);
+  }
+
+  // Method to retry with approval
+  async retryWithApproval(
+    approvalId: string,
+    providerName: string | undefined,
+    prompt: string,
+    options?: Partial<ChatOptions>
+  ): Promise<DuckResponse & { pendingApprovals?: { id: string; message: string }[]; mcpResults?: MCPResult[] }> {
+    if (!this.mcpEnabled) {
+      throw new Error('MCP bridge is not enabled');
+    }
+
+    const provider = this.getEnhancedProvider(providerName);
+    const startTime = Date.now();
+
+    try {
+      const response = await provider.retryWithApproval(
+        approvalId,
+        [{ role: 'user', content: prompt, timestamp: new Date() }],
+        {
+          messages: [{ role: 'user', content: prompt, timestamp: new Date() }],
+          ...options,
+        }
+      );
+
+      return {
+        provider: provider.name,
+        nickname: provider.nickname,
+        model: response.model,
+        content: response.content,
+        usage: response.usage ? {
+          prompt_tokens: response.usage.promptTokens,
+          completion_tokens: response.usage.completionTokens,
+          total_tokens: response.usage.totalTokens,
+          promptTokens: response.usage.promptTokens,
+          completionTokens: response.usage.completionTokens,
+          totalTokens: response.usage.totalTokens,
+        } : undefined,
+        latency: Date.now() - startTime,
+        cached: false,
+        pendingApprovals: response.pendingApprovals,
+        mcpResults: response.mcpResults,
+      };
+    } catch (error: unknown) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to retry with approval: ${errorMessage}`);
+    }
+  }
+
+  // Get enhanced provider statistics
+  getAllEnhancedProviders(): Array<{ 
+    name: string; 
+    info: ReturnType<EnhancedDuckProvider['getInfo']>; 
+    mcpEnabled: boolean;
+    mcpStats?: ReturnType<EnhancedDuckProvider['getMCPStats']>;
+    functionCount?: number;
+  }> {
+    return Array.from(this.enhancedProviders.entries()).map(([name, provider]) => ({
+      name,
+      info: provider.getInfo(),
+      mcpEnabled: provider.isMCPEnabled(),
+      mcpStats: provider.getMCPStats(),
+      functionCount: 0, // Will be populated when functions are loaded
+    }));
+  }
+
+  // Check if MCP is enabled
+  isMCPEnabled(): boolean {
+    return this.mcpEnabled;
+  }
+
+  // Enable/disable MCP for all providers
+  setMCPEnabled(enabled: boolean): void {
+    this.mcpEnabled = enabled;
+    for (const provider of this.enhancedProviders.values()) {
+      provider.setMCPEnabled(enabled);
+    }
+    logger.info(`MCP ${enabled ? 'enabled' : 'disabled'} for all providers`);
+  }
+
+  // Get MCP function count for a provider
+  async getMCPFunctionCount(providerName?: string): Promise<number> {
+    if (!this.mcpEnabled) {
+      return 0;
+    }
+
+    try {
+      const provider = this.getEnhancedProvider(providerName);
+      return await provider.getMCPFunctionCount();
+    } catch (error) {
+      return 0;
+    }
+  }
+}