mcp-rubber-duck 1.1.0

package/src/providers/manager.ts

@@ -0,0 +1,257 @@
+import { DuckProvider } from './provider.js';
+import { ConfigManager } from '../config/config.js';
+import { ProviderHealth, DuckResponse } from '../config/types.js';
+import { ChatOptions, ModelInfo } from './types.js';
+import { logger } from '../utils/logger.js';
+import { getRandomDuckMessage } from '../utils/ascii-art.js';
+
+export class ProviderManager {
+  private providers: Map<string, DuckProvider> = new Map();
+  private healthStatus: Map<string, ProviderHealth> = new Map();
+  protected configManager: ConfigManager;
+  private defaultProvider?: string;
+
+  constructor(configManager: ConfigManager) {
+    this.configManager = configManager;
+    this.initializeProviders();
+  }
+
+  private initializeProviders() {
+    const config = this.configManager.getConfig();
+    const allProviders = config.providers;
+
+    for (const [name, providerConfig] of Object.entries(allProviders)) {
+      try {
+        const provider = new DuckProvider(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.providers.set(name, provider);
+        logger.info(`Initialized provider: ${name} (${providerConfig.nickname})`);
+      } catch (error) {
+        logger.error(`Failed to initialize provider ${name}:`, error);
+      }
+    }
+
+    this.defaultProvider = config.default_provider;
+    
+    if (this.providers.size === 0) {
+      throw new Error('No providers could be initialized');
+    }
+  }
+
+  async checkHealth(providerName?: string): Promise<ProviderHealth[]> {
+    const results: ProviderHealth[] = [];
+    const providersToCheck = providerName 
+      ? [this.providers.get(providerName)].filter(Boolean)
+      : Array.from(this.providers.values());
+
+    for (const provider of providersToCheck) {
+      if (!provider) continue;
+      
+      const startTime = Date.now();
+      try {
+        const healthy = await provider.healthCheck();
+        const health: ProviderHealth = {
+          provider: provider.name,
+          healthy,
+          latency: Date.now() - startTime,
+          lastCheck: new Date(),
+        };
+        
+        this.healthStatus.set(provider.name, health);
+        results.push(health);
+      } catch (error: unknown) {
+        const health: ProviderHealth = {
+          provider: provider.name,
+          healthy: false,
+          lastCheck: new Date(),
+          error: error instanceof Error ? error.message : String(error),
+        };
+        
+        this.healthStatus.set(provider.name, health);
+        results.push(health);
+      }
+    }
+
+    return results;
+  }
+
+  async askDuck(
+    providerName: string | undefined,
+    prompt: string,
+    options?: Partial<ChatOptions>
+  ): Promise<DuckResponse> {
+    const provider = this.getProvider(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,
+      };
+    } 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 provider failed, attempting failover: ${errorMessage}`);
+        return this.askWithFailover(prompt, options, provider.name);
+      }
+      throw error;
+    }
+  }
+
+  async compareDucks(
+    prompt: string,
+    providerNames?: string[],
+    options?: Partial<ChatOptions>
+  ): Promise<DuckResponse[]> {
+    const providersToUse = providerNames 
+      ? providerNames.map(name => this.providers.get(name)).filter(Boolean)
+      : Array.from(this.providers.values());
+
+    if (providersToUse.length === 0) {
+      throw new Error('No valid providers specified');
+    }
+
+    const promises = providersToUse.map(provider => 
+      provider ? this.askDuck(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 duckCouncil(
+    prompt: string,
+    options?: Partial<ChatOptions>
+  ): Promise<DuckResponse[]> {
+    return this.compareDucks(prompt, undefined, options);
+  }
+
+  private async askWithFailover(
+    prompt: string,
+    options: Partial<ChatOptions> | undefined,
+    failedProvider: string
+  ): Promise<DuckResponse> {
+    const availableProviders = Array.from(this.providers.keys()).filter(
+      name => name !== failedProvider
+    );
+
+    for (const providerName of availableProviders) {
+      try {
+        logger.info(`${getRandomDuckMessage('failover')} Trying ${providerName}...`);
+        return await this.askDuck(providerName, prompt, options);
+      } catch (error) {
+        logger.warn(`Failover to ${providerName} failed:`, error);
+        continue;
+      }
+    }
+
+    throw new Error('All ducks have flown away! No providers available.');
+  }
+
+  getProvider(name?: string): DuckProvider {
+    const providerName = name || this.defaultProvider;
+    
+    if (!providerName) {
+      throw new Error('No provider specified and no default provider configured');
+    }
+
+    const provider = this.providers.get(providerName);
+    
+    if (!provider) {
+      throw new Error(`Duck "${providerName}" not found in the pond`);
+    }
+
+    return provider;
+  }
+
+  getAllProviders(): Array<{ name: string; info: ReturnType<DuckProvider['getInfo']>; health?: ProviderHealth }> {
+    return Array.from(this.providers.entries()).map(([name, provider]) => ({
+      name,
+      info: provider.getInfo(),
+      health: this.healthStatus.get(name),
+    }));
+  }
+
+  getProviderNames(): string[] {
+    return Array.from(this.providers.keys());
+  }
+
+  async getAvailableModels(providerName: string): Promise<ModelInfo[]> {
+    const provider = this.providers.get(providerName);
+    if (!provider) {
+      throw new Error(`Provider ${providerName} not found`);
+    }
+    return provider.listModels();
+  }
+
+  async getAllModels(): Promise<Map<string, ModelInfo[]>> {
+    const allModels = new Map<string, ModelInfo[]>();
+    
+    for (const [name, provider] of this.providers) {
+      try {
+        const models = await provider.listModels();
+        allModels.set(name, models);
+      } catch (error) {
+        logger.error(`Failed to get models for ${name}:`, error);
+        allModels.set(name, []);
+      }
+    }
+    
+    return allModels;
+  }
+
+  validateModel(providerName: string, modelId: string): boolean {
+    const provider = this.providers.get(providerName);
+    if (!provider) {
+      return false;
+    }
+    
+    const info = provider.getInfo();
+    if (info.availableModels) {
+      return info.availableModels.includes(modelId);
+    }
+    
+    // If no models list, accept any model (let the API validate)
+    return true;
+  }
+}

package/src/providers/provider.ts

@@ -0,0 +1,207 @@
+import OpenAI from 'openai';
+import { ChatOptions, ChatResponse, ProviderOptions, StreamChunk, ModelInfo, OpenAIChatParams, OpenAIChatResponse, OpenAIMessage } from './types.js';
+import { ConversationMessage } from '../config/types.js';
+import { logger } from '../utils/logger.js';
+
+export class DuckProvider {
+  protected client: OpenAI;
+  protected options: ProviderOptions;
+  public name: string;
+  public nickname: string;
+
+  constructor(name: string, nickname: string, options: ProviderOptions) {
+    this.name = name;
+    this.nickname = nickname;
+    this.options = options;
+    
+    this.client = new OpenAI({
+      apiKey: options.apiKey || 'not-needed',
+      baseURL: options.baseURL,
+      timeout: options.timeout || 300000,
+      maxRetries: options.maxRetries || 3,
+    });
+  }
+
+  protected supportsTemperature(model: string): boolean {
+    // Reasoning models don't support temperature parameter
+    return !model.startsWith('o1') && 
+           !model.includes('o1-') &&
+           !model.startsWith('o3') &&
+           !model.includes('o3-') &&
+           !model.startsWith('gpt-5') &&
+           !model.includes('gpt-5');
+  }
+
+  async chat(options: ChatOptions): Promise<ChatResponse> {
+    try {
+      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,
+      };
+
+      // Only add temperature if the model supports it
+      if (this.supportsTemperature(modelToUse)) {
+        baseParams.temperature = options.temperature ?? this.options.temperature ?? 0.7;
+      }
+
+      const response = await this.createChatCompletion(baseParams);
+      const choice = response.choices[0];
+      
+      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,  // Return the requested model, not the resolved one
+        finishReason: choice.finish_reason || undefined,
+      };
+    } catch (error: unknown) {
+      logger.error(`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}`);
+    }
+  }
+
+  protected async createChatCompletion(baseParams: Partial<OpenAIChatParams>): Promise<OpenAIChatResponse> {
+    const params = { ...baseParams } as OpenAIChatParams;
+    return await this.client.chat.completions.create(params);
+  }
+
+  async *chatStream(options: ChatOptions): AsyncGenerator<StreamChunk> {
+    try {
+      const messages = this.prepareMessages(options.messages, options.systemPrompt);
+      const modelToUse = options.model || this.options.model;
+      
+      const streamParams = {
+        model: modelToUse,
+        messages: messages as OpenAIMessage[],
+        stream: true as const,
+        ...(this.supportsTemperature(modelToUse) && {
+          temperature: options.temperature ?? this.options.temperature ?? 0.7
+        })
+      };
+      
+      const stream = await this.client.chat.completions.create(streamParams);
+
+      for await (const chunk of stream) {
+        const content = chunk.choices[0]?.delta?.content || '';
+        const done = chunk.choices[0]?.finish_reason !== null;
+        
+        yield { content, done };
+      }
+    } catch (error: unknown) {
+      logger.error(`Provider ${this.name} stream error:`, error);
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new Error(`Duck ${this.nickname} stream failed: ${errorMessage}`);
+    }
+  }
+
+  async healthCheck(): Promise<boolean> {
+    try {
+      const baseParams: Partial<OpenAIChatParams> = {
+        model: this.options.model,
+        messages: [{ role: 'user', content: 'Say "healthy"' }] as OpenAIMessage[],
+        stream: false,
+      };
+
+      // Only add temperature if the model supports it
+      if (this.supportsTemperature(this.options.model)) {
+        baseParams.temperature = 0.5;
+      }
+      
+      // Health check without token limits
+      const response = await this.createChatCompletion(baseParams);
+      
+      const content = response.choices[0]?.message?.content;
+      const hasContent = !!content;
+      
+      if (!hasContent) {
+        logger.warn(`Health check for ${this.name}: No content in response`, {
+          response: JSON.stringify(response, null, 2)
+        });
+      } else {
+        logger.debug(`Health check for ${this.name} succeeded with response: ${content}`);
+      }
+      
+      return hasContent;
+    } catch (error) {
+      logger.warn(`Health check failed for ${this.name}:`, error);
+      return false;
+    }
+  }
+
+  protected prepareMessages(
+    messages: ConversationMessage[],
+    systemPrompt?: string
+  ): Array<{ role: string; content: string }> {
+    const prepared: Array<{ role: string; content: string }> = [];
+    
+    // Add system prompt if provided
+    const prompt = systemPrompt || this.options.systemPrompt;
+    if (prompt) {
+      prepared.push({ role: 'system', content: prompt });
+    }
+    
+    // Add conversation messages
+    for (const msg of messages) {
+      prepared.push({
+        role: msg.role,
+        content: msg.content,
+      });
+    }
+    
+    return prepared;
+  }
+
+  async listModels(): Promise<ModelInfo[]> {
+    try {
+      // Try to fetch models from the API
+      const response = await this.client.models.list();
+      const models: ModelInfo[] = [];
+      
+      for await (const model of response) {
+        models.push({
+          id: model.id,
+          created: model.created,
+          owned_by: model.owned_by,
+          object: model.object,
+        });
+      }
+      
+      logger.debug(`Fetched ${models.length} models from ${this.name}`);
+      return models;
+    } catch (error: unknown) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      logger.warn(`Failed to fetch models from ${this.name}: ${errorMessage}`);
+      // Fall back to configured models
+      if (this.options.availableModels && this.options.availableModels.length > 0) {
+        return this.options.availableModels.map(id => ({
+          id,
+          description: 'Configured model (not fetched from API)',
+        }));
+      }
+      // Last fallback: return just the default model
+      return [{
+        id: this.options.model,
+        description: 'Default configured model',
+      }];
+    }
+  }
+
+  getInfo() {
+    return {
+      name: this.name,
+      nickname: this.nickname,
+      model: this.options.model,
+      availableModels: this.options.availableModels,
+      baseURL: this.options.baseURL,
+      hasApiKey: !!this.options.apiKey,
+    };
+  }
+}

package/src/providers/types.ts

@@ -0,0 +1,78 @@
+import { ConversationMessage } from '../config/types.js';
+import { FunctionDefinition } from '../services/function-bridge.js';
+import type { 
+  ChatCompletion, 
+  ChatCompletionMessageParam,
+  ChatCompletionMessageToolCall,
+  ChatCompletionCreateParamsNonStreaming
+} from 'openai/resources/chat/completions';
+
+export interface ModelInfo {
+  id: string;
+  created?: number;
+  owned_by?: string;
+  object?: string;
+  context_window?: number;
+  description?: string;
+}
+
+export interface ProviderOptions {
+  apiKey?: string;
+  baseURL: string;
+  model: string;
+  availableModels?: string[];
+  temperature?: number;
+  timeout?: number;
+  maxRetries?: number;
+  systemPrompt?: string;
+}
+
+export interface ToolCall {
+  id: string;
+  type: 'function';
+  function: {
+    name: string;
+    arguments: string; // JSON string
+  };
+}
+
+export interface ChatOptions {
+  messages: ConversationMessage[];
+  model?: string;
+  stream?: boolean;
+  temperature?: number;
+  systemPrompt?: string;
+  tools?: FunctionDefinition[];
+  toolChoice?: 'auto' | 'none' | { type: 'function'; function: { name: string } };
+}
+
+export interface ChatResponse {
+  content: string;
+  usage?: {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+  };
+  model: string;
+  finishReason?: string;
+  toolCalls?: ToolCall[];
+}
+
+export interface StreamChunk {
+  content: string;
+  done: boolean;
+}
+
+// OpenAI API parameter types
+export type OpenAIChatParams = ChatCompletionCreateParamsNonStreaming;
+export type OpenAIMessage = ChatCompletionMessageParam;
+export type OpenAIChatResponse = ChatCompletion;
+export type OpenAIToolCall = ChatCompletionMessageToolCall;
+
+// Enhanced response type with MCP functionality
+export interface MCPResult {
+  id: string;
+  success: boolean;
+  data?: unknown;
+  error?: string;
+}