cognitive-modules 0.6.0

package/src/providers/gemini.ts

@@ -0,0 +1,117 @@
+/**
+ * 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

@@ -0,0 +1,78 @@
+/**
+ * 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

@@ -0,0 +1,81 @@
+/**
+ * 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

@@ -0,0 +1,82 @@
+/**
+ * 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

@@ -0,0 +1,83 @@
+/**
+ * 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),
+      },
+    };
+  }
+}

package/src/providers/openai.ts

@@ -0,0 +1,84 @@
+/**
+ * OpenAI Provider - OpenAI API (and compatible APIs)
+ */
+
+import { BaseProvider } from './base.js';
+import type { InvokeParams, InvokeResult } from '../types.js';
+
+export class OpenAIProvider extends BaseProvider {
+  name = 'openai';
+  private apiKey: string;
+  private model: string;
+  private baseUrl: string;
+
+  constructor(apiKey?: string, model = 'gpt-5.2', baseUrl = 'https://api.openai.com/v1') {
+    super();
+    this.apiKey = apiKey || process.env.OPENAI_API_KEY || '';
+    this.model = model;
+    this.baseUrl = baseUrl;
+  }
+
+  isConfigured(): boolean {
+    return !!this.apiKey;
+  }
+
+  async invoke(params: InvokeParams): Promise<InvokeResult> {
+    if (!this.isConfigured()) {
+      throw new Error('OpenAI API key not configured. Set OPENAI_API_KEY environment variable.');
+    }
+
+    const url = `${this.baseUrl}/chat/completions`;
+
+    const body: Record<string, unknown> = {
+      model: this.model,
+      messages: params.messages,
+      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' };
+      // Append schema instruction to last user message
+      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;
+      }
+    }
+
+    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(`OpenAI 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/qwen.ts

@@ -0,0 +1,82 @@
+/**
+ * Qwen Provider - Alibaba Tongyi Qianwen (通义千问) via DashScope API
+ */
+
+import { BaseProvider } from './base.js';
+import type { InvokeParams, InvokeResult } from '../types.js';
+
+export class QwenProvider extends BaseProvider {
+  name = 'qwen';
+  private apiKey: string;
+  private model: string;
+  private baseUrl = 'https://dashscope.aliyuncs.com/compatible-mode/v1';
+
+  constructor(apiKey?: string, model = 'qwen3-max') {
+    super();
+    this.apiKey = apiKey || process.env.DASHSCOPE_API_KEY || process.env.QWEN_API_KEY || '';
+    this.model = model;
+  }
+
+  isConfigured(): boolean {
+    return !!this.apiKey;
+  }
+
+  async invoke(params: InvokeParams): Promise<InvokeResult> {
+    if (!this.isConfigured()) {
+      throw new Error('Qwen API key not configured. Set DASHSCOPE_API_KEY or QWEN_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(`Qwen 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,
+    };
+  }
+}