cognitive-modules-cli 2.2.1 → 2.2.7

package/src/providers/anthropic.ts

@@ -1,89 +0,0 @@
-/**
- * Anthropic Provider - Claude API
- */
-
-import { BaseProvider } from './base.js';
-import type { InvokeParams, InvokeResult } from '../types.js';
-
-export class AnthropicProvider extends BaseProvider {
-  name = 'anthropic';
-  private apiKey: string;
-  private model: string;
-  private baseUrl = 'https://api.anthropic.com/v1';
-
-  constructor(apiKey?: string, model = 'claude-sonnet-4-5-20250929') {
-    super();
-    this.apiKey = apiKey || process.env.ANTHROPIC_API_KEY || '';
-    this.model = model;
-  }
-
-  isConfigured(): boolean {
-    return !!this.apiKey;
-  }
-
-  async invoke(params: InvokeParams): Promise<InvokeResult> {
-    if (!this.isConfigured()) {
-      throw new Error('Anthropic API key not configured. Set ANTHROPIC_API_KEY environment variable.');
-    }
-
-    const url = `${this.baseUrl}/messages`;
-
-    // Extract system message
-    const systemMessage = params.messages.find(m => m.role === 'system');
-    const otherMessages = params.messages.filter(m => m.role !== 'system');
-
-    // Add JSON schema instruction if provided
-    let messages = otherMessages;
-    if (params.jsonSchema) {
-      const lastUserIdx = messages.findLastIndex(m => m.role === 'user');
-      if (lastUserIdx >= 0) {
-        messages = [...messages];
-        messages[lastUserIdx] = {
-          ...messages[lastUserIdx],
-          content: messages[lastUserIdx].content + this.buildJsonPrompt(params.jsonSchema),
-        };
-      }
-    }
-
-    const body: Record<string, unknown> = {
-      model: this.model,
-      messages: messages.map(m => ({ role: m.role, content: m.content })),
-      max_tokens: params.maxTokens ?? 4096,
-    };
-
-    if (systemMessage) {
-      body.system = systemMessage.content;
-    }
-
-    const response = await fetch(url, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'x-api-key': this.apiKey,
-        'anthropic-version': '2023-06-01',
-      },
-      body: JSON.stringify(body),
-    });
-
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Anthropic API error: ${response.status} - ${error}`);
-    }
-
-    const data = await response.json() as {
-      content?: Array<{ text?: string }>;
-      usage?: { input_tokens?: number; output_tokens?: number };
-    };
-    
-    const content = data.content?.[0]?.text || '';
-    
-    return {
-      content,
-      usage: data.usage ? {
-        promptTokens: data.usage.input_tokens || 0,
-        completionTokens: data.usage.output_tokens || 0,
-        totalTokens: (data.usage.input_tokens || 0) + (data.usage.output_tokens || 0),
-      } : undefined,
-    };
-  }
-}

package/src/providers/base.ts

@@ -1,29 +0,0 @@
-/**
- * Base Provider - Abstract class for all LLM providers
- */
-
-import type { Provider, InvokeParams, InvokeResult } from '../types.js';
-
-export abstract class BaseProvider implements Provider {
-  abstract name: string;
-  
-  abstract invoke(params: InvokeParams): Promise<InvokeResult>;
-  
-  abstract isConfigured(): boolean;
-
-  protected buildJsonPrompt(schema: object): string {
-    return `\n\nYou MUST respond with valid JSON matching this schema:\n${JSON.stringify(schema, null, 2)}\n\nRespond with ONLY the JSON, no markdown code blocks.`;
-  }
-
-  protected parseJsonResponse(content: string): unknown {
-    // Try to extract JSON from markdown code blocks
-    const jsonMatch = content.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
-    const jsonStr = jsonMatch ? jsonMatch[1] : content;
-    
-    try {
-      return JSON.parse(jsonStr.trim());
-    } catch {
-      throw new Error(`Failed to parse JSON response: ${content.substring(0, 200)}`);
-    }
-  }
-}

package/src/providers/deepseek.ts

@@ -1,83 +0,0 @@
-/**
- * DeepSeek Provider - DeepSeek API
- */
-
-import { BaseProvider } from './base.js';
-import type { InvokeParams, InvokeResult } from '../types.js';
-
-export class DeepSeekProvider extends BaseProvider {
-  name = 'deepseek';
-  private apiKey: string;
-  private model: string;
-  private baseUrl = 'https://api.deepseek.com/v1';
-
-  constructor(apiKey?: string, model = 'deepseek-chat') {
-    // deepseek-chat 自动映射到最新的 DeepSeek-V3.2
-    super();
-    this.apiKey = apiKey || process.env.DEEPSEEK_API_KEY || '';
-    this.model = model;
-  }
-
-  isConfigured(): boolean {
-    return !!this.apiKey;
-  }
-
-  async invoke(params: InvokeParams): Promise<InvokeResult> {
-    if (!this.isConfigured()) {
-      throw new Error('DeepSeek API key not configured. Set DEEPSEEK_API_KEY environment variable.');
-    }
-
-    const url = `${this.baseUrl}/chat/completions`;
-
-    const body: Record<string, unknown> = {
-      model: this.model,
-      messages: params.messages.map(m => ({ role: m.role, content: m.content })),
-      temperature: params.temperature ?? 0.7,
-      max_tokens: params.maxTokens ?? 4096,
-    };
-
-    // Add JSON mode if schema provided
-    if (params.jsonSchema) {
-      body.response_format = { type: 'json_object' };
-      const lastUserIdx = params.messages.findLastIndex(m => m.role === 'user');
-      if (lastUserIdx >= 0) {
-        const messages = [...params.messages];
-        messages[lastUserIdx] = {
-          ...messages[lastUserIdx],
-          content: messages[lastUserIdx].content + this.buildJsonPrompt(params.jsonSchema),
-        };
-        body.messages = messages.map(m => ({ role: m.role, content: m.content }));
-      }
-    }
-
-    const response = await fetch(url, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'Authorization': `Bearer ${this.apiKey}`,
-      },
-      body: JSON.stringify(body),
-    });
-
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`DeepSeek API error: ${response.status} - ${error}`);
-    }
-
-    const data = await response.json() as {
-      choices?: Array<{ message?: { content?: string } }>;
-      usage?: { prompt_tokens?: number; completion_tokens?: number; total_tokens?: number };
-    };
-    
-    const content = data.choices?.[0]?.message?.content || '';
-    
-    return {
-      content,
-      usage: data.usage ? {
-        promptTokens: data.usage.prompt_tokens || 0,
-        completionTokens: data.usage.completion_tokens || 0,
-        totalTokens: data.usage.total_tokens || 0,
-      } : undefined,
-    };
-  }
-}

package/src/providers/gemini.ts

@@ -1,117 +0,0 @@
-/**
- * Gemini Provider - Google Gemini API
- */
-
-import { BaseProvider } from './base.js';
-import type { InvokeParams, InvokeResult } from '../types.js';
-
-export class GeminiProvider extends BaseProvider {
-  name = 'gemini';
-  private apiKey: string;
-  private model: string;
-  private baseUrl = 'https://generativelanguage.googleapis.com/v1beta';
-
-  constructor(apiKey?: string, model = 'gemini-3-flash') {
-    super();
-    this.apiKey = apiKey || process.env.GEMINI_API_KEY || '';
-    this.model = model;
-  }
-
-  isConfigured(): boolean {
-    return !!this.apiKey;
-  }
-
-  /**
-   * Clean JSON Schema for Gemini API compatibility
-   * Removes unsupported fields like additionalProperties
-   */
-  private cleanSchemaForGemini(schema: object): object {
-    const unsupportedFields = ['additionalProperties', '$schema', 'default', 'examples'];
-    
-    const clean = (obj: unknown): unknown => {
-      if (Array.isArray(obj)) {
-        return obj.map(clean);
-      }
-      if (obj && typeof obj === 'object') {
-        const result: Record<string, unknown> = {};
-        for (const [key, value] of Object.entries(obj)) {
-          if (!unsupportedFields.includes(key)) {
-            result[key] = clean(value);
-          }
-        }
-        return result;
-      }
-      return obj;
-    };
-    
-    return clean(schema) as object;
-  }
-
-  async invoke(params: InvokeParams): Promise<InvokeResult> {
-    if (!this.isConfigured()) {
-      throw new Error('Gemini API key not configured. Set GEMINI_API_KEY environment variable.');
-    }
-
-    const url = `${this.baseUrl}/models/${this.model}:generateContent?key=${this.apiKey}`;
-
-    // Convert messages to Gemini format
-    const contents = params.messages
-      .filter(m => m.role !== 'system')
-      .map(m => ({
-        role: m.role === 'assistant' ? 'model' : 'user',
-        parts: [{ text: m.content }]
-      }));
-
-    // Add system instruction if present
-    const systemMessage = params.messages.find(m => m.role === 'system');
-    
-    const body: Record<string, unknown> = {
-      contents,
-      generationConfig: {
-        temperature: params.temperature ?? 0.7,
-        maxOutputTokens: params.maxTokens ?? 8192,
-      }
-    };
-
-    if (systemMessage) {
-      body.systemInstruction = { parts: [{ text: systemMessage.content }] };
-    }
-
-    // Add JSON schema constraint if provided
-    if (params.jsonSchema) {
-      const cleanedSchema = this.cleanSchemaForGemini(params.jsonSchema);
-      body.generationConfig = {
-        ...body.generationConfig as object,
-        responseMimeType: 'application/json',
-        responseSchema: cleanedSchema,
-      };
-    }
-
-    const response = await fetch(url, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify(body),
-    });
-
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Gemini API error: ${response.status} - ${error}`);
-    }
-
-    const data = await response.json() as {
-      candidates?: Array<{ content?: { parts?: Array<{ text?: string }> } }>;
-      usageMetadata?: { promptTokenCount?: number; candidatesTokenCount?: number; totalTokenCount?: number };
-    };
-    
-    const content = data.candidates?.[0]?.content?.parts?.[0]?.text || '';
-    
-    return {
-      content,
-      usage: data.usageMetadata ? {
-        promptTokens: data.usageMetadata.promptTokenCount || 0,
-        completionTokens: data.usageMetadata.candidatesTokenCount || 0,
-        totalTokens: data.usageMetadata.totalTokenCount || 0,
-      } : undefined,
-    };
-  }
-}

package/src/providers/index.ts

@@ -1,78 +0,0 @@
-/**
- * Provider Registry
- */
-
-import type { Provider } from '../types.js';
-import { GeminiProvider } from './gemini.js';
-import { OpenAIProvider } from './openai.js';
-import { AnthropicProvider } from './anthropic.js';
-import { MiniMaxProvider } from './minimax.js';
-import { DeepSeekProvider } from './deepseek.js';
-import { MoonshotProvider } from './moonshot.js';
-import { QwenProvider } from './qwen.js';
-import { OllamaProvider } from './ollama.js';
-
-export { BaseProvider } from './base.js';
-export { GeminiProvider } from './gemini.js';
-export { OpenAIProvider } from './openai.js';
-export { AnthropicProvider } from './anthropic.js';
-export { MiniMaxProvider } from './minimax.js';
-export { DeepSeekProvider } from './deepseek.js';
-export { MoonshotProvider } from './moonshot.js';
-export { QwenProvider } from './qwen.js';
-export { OllamaProvider } from './ollama.js';
-
-type ProviderFactory = (model?: string) => Provider;
-
-const providers: Record<string, ProviderFactory> = {
-  gemini: (model) => new GeminiProvider(undefined, model),
-  openai: (model) => new OpenAIProvider(undefined, model),
-  anthropic: (model) => new AnthropicProvider(undefined, model),
-  minimax: (model) => new MiniMaxProvider(undefined, model),
-  deepseek: (model) => new DeepSeekProvider(undefined, model),
-  moonshot: (model) => new MoonshotProvider(undefined, model),
-  kimi: (model) => new MoonshotProvider(undefined, model), // Alias
-  qwen: (model) => new QwenProvider(undefined, model),
-  tongyi: (model) => new QwenProvider(undefined, model), // Alias
-  dashscope: (model) => new QwenProvider(undefined, model), // Alias
-  ollama: (model) => new OllamaProvider(model),
-  local: (model) => new OllamaProvider(model), // Alias
-};
-
-export function getProvider(name?: string, model?: string): Provider {
-  // Check for model override from environment
-  const modelOverride = model || process.env.COG_MODEL;
-
-  // Auto-detect if not specified
-  if (!name) {
-    if (process.env.GEMINI_API_KEY) return new GeminiProvider(undefined, modelOverride);
-    if (process.env.OPENAI_API_KEY) return new OpenAIProvider(undefined, modelOverride);
-    if (process.env.ANTHROPIC_API_KEY) return new AnthropicProvider(undefined, modelOverride);
-    if (process.env.DEEPSEEK_API_KEY) return new DeepSeekProvider(undefined, modelOverride);
-    if (process.env.MINIMAX_API_KEY) return new MiniMaxProvider(undefined, modelOverride);
-    if (process.env.MOONSHOT_API_KEY) return new MoonshotProvider(undefined, modelOverride);
-    if (process.env.DASHSCOPE_API_KEY || process.env.QWEN_API_KEY) return new QwenProvider(undefined, modelOverride);
-    // Ollama is always available as fallback if nothing else is configured
-    return new OllamaProvider(modelOverride);
-  }
-
-  const factory = providers[name.toLowerCase()];
-  if (!factory) {
-    throw new Error(`Unknown provider: ${name}. Available: ${Object.keys(providers).join(', ')}`);
-  }
-
-  return factory(modelOverride);
-}
-
-export function listProviders(): Array<{ name: string; configured: boolean; model: string }> {
-  return [
-    { name: 'gemini', configured: !!process.env.GEMINI_API_KEY, model: 'gemini-3-flash' },
-    { name: 'openai', configured: !!process.env.OPENAI_API_KEY, model: 'gpt-5.2' },
-    { name: 'anthropic', configured: !!process.env.ANTHROPIC_API_KEY, model: 'claude-sonnet-4.5' },
-    { name: 'deepseek', configured: !!process.env.DEEPSEEK_API_KEY, model: 'deepseek-v3.2' },
-    { name: 'minimax', configured: !!process.env.MINIMAX_API_KEY, model: 'MiniMax-M2.1' },
-    { name: 'moonshot', configured: !!process.env.MOONSHOT_API_KEY, model: 'kimi-k2.5' },
-    { name: 'qwen', configured: !!(process.env.DASHSCOPE_API_KEY || process.env.QWEN_API_KEY), model: 'qwen3-max' },
-    { name: 'ollama', configured: true, model: 'llama4 (local)' },
-  ];
-}

package/src/providers/minimax.ts

@@ -1,81 +0,0 @@
-/**
- * MiniMax Provider - MiniMax API
- */
-
-import { BaseProvider } from './base.js';
-import type { InvokeParams, InvokeResult } from '../types.js';
-
-export class MiniMaxProvider extends BaseProvider {
-  name = 'minimax';
-  private apiKey: string;
-  private model: string;
-  private baseUrl = 'https://api.minimax.chat/v1';
-
-  constructor(apiKey?: string, model = 'MiniMax-M2.1') {
-    super();
-    this.apiKey = apiKey || process.env.MINIMAX_API_KEY || '';
-    this.model = model;
-  }
-
-  isConfigured(): boolean {
-    return !!this.apiKey;
-  }
-
-  async invoke(params: InvokeParams): Promise<InvokeResult> {
-    if (!this.isConfigured()) {
-      throw new Error('MiniMax API key not configured. Set MINIMAX_API_KEY environment variable.');
-    }
-
-    const url = `${this.baseUrl}/text/chatcompletion_v2`;
-
-    const body: Record<string, unknown> = {
-      model: this.model,
-      messages: params.messages.map(m => ({ role: m.role, content: m.content })),
-      temperature: params.temperature ?? 0.7,
-      max_tokens: params.maxTokens ?? 4096,
-    };
-
-    // Add JSON mode if schema provided
-    if (params.jsonSchema) {
-      const lastUserIdx = params.messages.findLastIndex(m => m.role === 'user');
-      if (lastUserIdx >= 0) {
-        const messages = [...params.messages];
-        messages[lastUserIdx] = {
-          ...messages[lastUserIdx],
-          content: messages[lastUserIdx].content + this.buildJsonPrompt(params.jsonSchema),
-        };
-        body.messages = messages.map(m => ({ role: m.role, content: m.content }));
-      }
-    }
-
-    const response = await fetch(url, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'Authorization': `Bearer ${this.apiKey}`,
-      },
-      body: JSON.stringify(body),
-    });
-
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`MiniMax API error: ${response.status} - ${error}`);
-    }
-
-    const data = await response.json() as {
-      choices?: Array<{ message?: { content?: string } }>;
-      usage?: { prompt_tokens?: number; completion_tokens?: number; total_tokens?: number };
-    };
-    
-    const content = data.choices?.[0]?.message?.content || '';
-    
-    return {
-      content,
-      usage: data.usage ? {
-        promptTokens: data.usage.prompt_tokens || 0,
-        completionTokens: data.usage.completion_tokens || 0,
-        totalTokens: data.usage.total_tokens || 0,
-      } : undefined,
-    };
-  }
-}

package/src/providers/moonshot.ts

@@ -1,82 +0,0 @@
-/**
- * Moonshot Provider - Moonshot AI (Kimi) API
- */
-
-import { BaseProvider } from './base.js';
-import type { InvokeParams, InvokeResult } from '../types.js';
-
-export class MoonshotProvider extends BaseProvider {
-  name = 'moonshot';
-  private apiKey: string;
-  private model: string;
-  private baseUrl = 'https://api.moonshot.cn/v1';
-
-  constructor(apiKey?: string, model = 'kimi-k2.5') {
-    super();
-    this.apiKey = apiKey || process.env.MOONSHOT_API_KEY || '';
-    this.model = model;
-  }
-
-  isConfigured(): boolean {
-    return !!this.apiKey;
-  }
-
-  async invoke(params: InvokeParams): Promise<InvokeResult> {
-    if (!this.isConfigured()) {
-      throw new Error('Moonshot API key not configured. Set MOONSHOT_API_KEY environment variable.');
-    }
-
-    const url = `${this.baseUrl}/chat/completions`;
-
-    const body: Record<string, unknown> = {
-      model: this.model,
-      messages: params.messages.map(m => ({ role: m.role, content: m.content })),
-      temperature: params.temperature ?? 0.7,
-      max_tokens: params.maxTokens ?? 4096,
-    };
-
-    // Add JSON mode if schema provided
-    if (params.jsonSchema) {
-      body.response_format = { type: 'json_object' };
-      const lastUserIdx = params.messages.findLastIndex(m => m.role === 'user');
-      if (lastUserIdx >= 0) {
-        const messages = [...params.messages];
-        messages[lastUserIdx] = {
-          ...messages[lastUserIdx],
-          content: messages[lastUserIdx].content + this.buildJsonPrompt(params.jsonSchema),
-        };
-        body.messages = messages.map(m => ({ role: m.role, content: m.content }));
-      }
-    }
-
-    const response = await fetch(url, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'Authorization': `Bearer ${this.apiKey}`,
-      },
-      body: JSON.stringify(body),
-    });
-
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Moonshot API error: ${response.status} - ${error}`);
-    }
-
-    const data = await response.json() as {
-      choices?: Array<{ message?: { content?: string } }>;
-      usage?: { prompt_tokens?: number; completion_tokens?: number; total_tokens?: number };
-    };
-    
-    const content = data.choices?.[0]?.message?.content || '';
-    
-    return {
-      content,
-      usage: data.usage ? {
-        promptTokens: data.usage.prompt_tokens || 0,
-        completionTokens: data.usage.completion_tokens || 0,
-        totalTokens: data.usage.total_tokens || 0,
-      } : undefined,
-    };
-  }
-}

package/src/providers/ollama.ts

@@ -1,83 +0,0 @@
-/**
- * Ollama Provider - Local LLM via Ollama
- */
-
-import { BaseProvider } from './base.js';
-import type { InvokeParams, InvokeResult } from '../types.js';
-
-export class OllamaProvider extends BaseProvider {
-  name = 'ollama';
-  private model: string;
-  private baseUrl: string;
-
-  constructor(model = 'llama4', baseUrl = 'http://localhost:11434') {
-    super();
-    this.model = process.env.OLLAMA_MODEL || model;
-    this.baseUrl = process.env.OLLAMA_HOST || baseUrl;
-  }
-
-  isConfigured(): boolean {
-    return true; // Ollama doesn't need API key
-  }
-
-  async invoke(params: InvokeParams): Promise<InvokeResult> {
-    const url = `${this.baseUrl}/api/chat`;
-
-    let messages = params.messages.map(m => ({ role: m.role, content: m.content }));
-
-    // Add JSON mode if schema provided
-    if (params.jsonSchema) {
-      const lastUserIdx = messages.findLastIndex(m => m.role === 'user');
-      if (lastUserIdx >= 0) {
-        messages = [...messages];
-        messages[lastUserIdx] = {
-          ...messages[lastUserIdx],
-          content: messages[lastUserIdx].content + this.buildJsonPrompt(params.jsonSchema),
-        };
-      }
-    }
-
-    const body: Record<string, unknown> = {
-      model: this.model,
-      messages,
-      stream: false,
-      options: {
-        temperature: params.temperature ?? 0.7,
-        num_predict: params.maxTokens ?? 4096,
-      },
-    };
-
-    // Request JSON format
-    if (params.jsonSchema) {
-      body.format = 'json';
-    }
-
-    const response = await fetch(url, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify(body),
-    });
-
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Ollama API error: ${response.status} - ${error}`);
-    }
-
-    const data = await response.json() as {
-      message?: { content?: string };
-      prompt_eval_count?: number;
-      eval_count?: number;
-    };
-    
-    const content = data.message?.content || '';
-    
-    return {
-      content,
-      usage: {
-        promptTokens: data.prompt_eval_count || 0,
-        completionTokens: data.eval_count || 0,
-        totalTokens: (data.prompt_eval_count || 0) + (data.eval_count || 0),
-      },
-    };
-  }
-}