@game_ryo/lsji 0.1.1 → 0.3.0

package/src/llm/providers/anthropic.js

@@ -0,0 +1,250 @@
+/**
+ * Anthropic Provider Implementation
+ * 
+ * Supports Anthropic API (Claude 3.5 Sonnet, Haiku, Opus, etc.)
+ */
+
+import { LLMProvider } from './base.js';
+
+// Anthropic pricing (USD per 1M tokens) - as of 2026
+const PRICING = {
+  'claude-3-5-sonnet-20241022': { input: 3.00, output: 15.00 },
+  'claude-3-5-haiku-20241022': { input: 0.25, output: 1.25 },
+  'claude-3-opus-20240229': { input: 15.00, output: 75.00 },
+  'claude-3-sonnet-20240229': { input: 3.00, output: 15.00 },
+  'claude-3-haiku-20240307': { input: 0.25, output: 1.25 },
+};
+
+export class AnthropicProvider extends LLMProvider {
+  constructor(config = {}) {
+    super({
+      model: config.model || 'claude-3-5-haiku-20241022',
+      apiKey: config.apiKey || process.env.ANTHROPIC_API_KEY,
+      baseUrl: config.baseUrl || 'https://api.anthropic.com',
+      defaultParams: config.defaultParams || {},
+    });
+    
+    this.pricing = PRICING[this.model] || PRICING['claude-3-5-haiku-20241022'];
+    this.client = null;
+  }
+
+  /**
+   * Lazy-load Anthropic client
+   */
+  async getClient() {
+    if (!this.client) {
+      const { default: Anthropic } = await import('@anthropic-ai/sdk');
+      this.client = new Anthropic({
+        apiKey: this.apiKey,
+        baseURL: this.baseUrl,
+      });
+    }
+    return this.client;
+  }
+
+  /**
+   * Generate completion from Anthropic
+   */
+  async generate(messages, options = {}) {
+    const client = await this.getClient();
+    
+    // Separate system message from conversation
+    const systemMessage = messages.find(m => m.role === 'system');
+    const conversationMessages = messages.filter(m => m.role !== 'system');
+    
+    const params = {
+      model: this.model,
+      messages: this.formatMessages(conversationMessages),
+      system: systemMessage?.content,
+      temperature: options.temperature ?? this.defaultParams.temperature ?? 0.7,
+      max_tokens: options.maxTokens ?? this.defaultParams.maxTokens ?? 4096,
+      ...this.defaultParams,
+    };
+
+    if (options.tools && options.tools.length > 0) {
+      params.tools = this.formatTools(options.tools);
+      params.tool_choice = options.toolChoice || 'auto';
+    }
+
+    const response = await client.messages.create(params);
+    
+    return this.parseResponse(response);
+  }
+
+  /**
+   * Generate streaming completion
+   */
+  async *generateStream(messages, options = {}) {
+    const client = await this.getClient();
+    
+    const systemMessage = messages.find(m => m.role === 'system');
+    const conversationMessages = messages.filter(m => m.role !== 'system');
+    
+    const params = {
+      model: this.model,
+      messages: this.formatMessages(conversationMessages),
+      system: systemMessage?.content,
+      temperature: options.temperature ?? this.defaultParams.temperature ?? 0.7,
+      max_tokens: options.maxTokens ?? this.defaultParams.maxTokens ?? 4096,
+      stream: true,
+      ...this.defaultParams,
+    };
+
+    if (options.tools && options.tools.length > 0) {
+      params.tools = this.formatTools(options.tools);
+      params.tool_choice = options.toolChoice || 'auto';
+    }
+
+    const stream = await client.messages.stream(params);
+    
+    for await (const chunk of stream) {
+      yield this.parseStreamChunk(chunk);
+    }
+  }
+
+  /**
+   * Format messages for Anthropic API
+   */
+  formatMessages(messages) {
+    return messages.map(msg => ({
+      role: msg.role === 'assistant' ? 'assistant' : 'user',
+      content: msg.content,
+    }));
+  }
+
+  /**
+   * Format tools for Anthropic API
+   */
+  formatTools(tools) {
+    return tools.map(tool => ({
+      name: tool.name,
+      description: tool.description,
+      input_schema: tool.parameters,
+    }));
+  }
+
+  /**
+   * Parse Anthropic response
+   */
+  parseResponse(response) {
+    const content = response.content.find(c => c.type === 'text');
+    const toolCalls = response.content
+      .filter(c => c.type === 'tool_use')
+      .map(c => ({
+        id: c.id,
+        type: 'function',
+        function: {
+          name: c.name,
+          arguments: JSON.stringify(c.input),
+        },
+      }));
+
+    return {
+      content: content?.text || '',
+      toolCalls,
+      usage: {
+        inputTokens: response.usage?.input_tokens || 0,
+        outputTokens: response.usage?.output_tokens || 0,
+        totalTokens: (response.usage?.input_tokens || 0) + (response.usage?.output_tokens || 0),
+      },
+      finishReason: response.stop_reason,
+      model: response.model,
+    };
+  }
+
+  /**
+   * Parse streaming chunk
+   */
+  parseStreamChunk(chunk) {
+    if (chunk.type === 'content_block_delta' && chunk.delta.type === 'text_delta') {
+      return {
+        content: chunk.delta.text,
+        toolCalls: [],
+        usage: null,
+        finishReason: null,
+      };
+    }
+    
+    if (chunk.type === 'content_block_start' && chunk.content_block.type === 'tool_use') {
+      return {
+        content: '',
+        toolCalls: [{
+          id: chunk.content_block.id,
+          type: 'function',
+          function: {
+            name: chunk.content_block.name,
+            arguments: JSON.stringify(chunk.content_block.input),
+          },
+        }],
+        usage: null,
+        finishReason: null,
+      };
+    }
+    
+    if (chunk.type === 'message_delta') {
+      return {
+        content: '',
+        toolCalls: [],
+        usage: chunk.usage ? {
+          inputTokens: chunk.usage.input_tokens || 0,
+          outputTokens: chunk.usage.output_tokens || 0,
+          totalTokens: (chunk.usage.input_tokens || 0) + (chunk.usage.output_tokens || 0),
+        } : null,
+        finishReason: chunk.delta?.stop_reason,
+      };
+    }
+
+    return { content: '', toolCalls: [], usage: null, finishReason: null };
+  }
+
+  /**
+   * Calculate cost for usage
+   */
+  calculateCost(usage) {
+    const inputCost = (usage.inputTokens / 1_000_000) * this.pricing.input;
+    const outputCost = (usage.outputTokens / 1_000_000) * this.pricing.output;
+    return inputCost + outputCost;
+  }
+
+  /**
+   * Get pricing info for current model
+   */
+  getPricing() {
+    return { ...this.pricing };
+  }
+
+  /**
+   * Check if provider supports function calling
+   */
+  supportsTools() {
+    return true;
+  }
+
+  /**
+   * Check if provider supports streaming
+   */
+  supportsStreaming() {
+    return true;
+  }
+
+  /**
+   * Validate configuration
+   */
+  async validate() {
+    if (!this.apiKey) {
+      return { valid: false, error: 'Anthropic API key is required' };
+    }
+    
+    try {
+      const client = await this.getClient();
+      await client.messages.create({
+        model: this.model,
+        max_tokens: 1,
+        messages: [{ role: 'user', content: 'test' }],
+      });
+      return { valid: true };
+    } catch (e) {
+      return { valid: false, error: e.message };
+    }
+  }
+}

package/src/llm/providers/base.js

@@ -0,0 +1,116 @@
+/**
+ * LLM Provider Base Interface
+ * 
+ * All LLM providers must implement this interface.
+ * Provides a unified API for different LLM backends.
+ */
+
+export class LLMProvider {
+  /**
+   * @param {Object} config
+   * @param {string} config.model - Model name
+   * @param {string} [config.apiKey] - API key (for cloud providers)
+   * @param {string} [config.baseUrl] - Base URL (for local/custom endpoints)
+   * @param {Object} [config.defaultParams] - Default generation parameters
+   */
+  constructor(config = {}) {
+    this.model = config.model;
+    this.apiKey = config.apiKey;
+    this.baseUrl = config.baseUrl;
+    this.defaultParams = config.defaultParams || {};
+  }
+
+  /**
+   * Generate a completion from the LLM
+   * @param {Array<Object>} messages - Chat messages [{role, content}]
+   * @param {Object} [options] - Generation options
+   * @param {number} [options.temperature] - Sampling temperature
+   * @param {number} [options.maxTokens] - Maximum tokens to generate
+   * @param {Array<Object>} [options.tools] - Tool definitions
+   * @param {string} [options.toolChoice] - Tool choice strategy
+   * @returns {Promise<Object>} Response with content, toolCalls, usage
+   */
+  async generate(messages, options = {}) {
+    throw new Error('generate() must be implemented by subclass');
+  }
+
+  /**
+   * Generate a completion with streaming
+   * @param {Array<Object>} messages - Chat messages
+   * @param {Object} [options] - Generation options
+   * @returns {AsyncGenerator<Object>} Stream of response chunks
+   */
+  async *generateStream(messages, options = {}) {
+    throw new Error('generateStream() must be implemented by subclass');
+  }
+
+  /**
+   * Get the model name
+   * @returns {string}
+   */
+  getModel() {
+    return this.model;
+  }
+
+  /**
+   * Estimate token count for messages (approximate)
+   * @param {Array<Object>} messages
+   * @returns {number} Estimated token count
+   */
+  estimateTokens(messages) {
+    // Rough approximation: ~4 chars per token for English
+    const text = messages.map(m => m.content || '').join(' ');
+    return Math.ceil(text.length / 4);
+  }
+
+  /**
+   * Check if provider supports function calling
+   * @returns {boolean}
+   */
+  supportsTools() {
+    return false;
+  }
+
+  /**
+   * Check if provider supports streaming
+   * @returns {boolean}
+   */
+  supportsStreaming() {
+    return false;
+  }
+
+  /**
+   * Validate configuration
+   * @returns {Promise<{valid: boolean, error?: string}>}
+   */
+  async validate() {
+    return { valid: true };
+  }
+}
+
+/**
+ * Create provider instance from config
+ * @param {Object} config - Provider configuration
+ * @returns {Promise<LLMProvider>}
+ */
+export async function createProvider(config) {
+  const { provider, ...options } = config;
+  
+  switch (provider) {
+    case 'openai': {
+      const { OpenAIProvider } = await import('./openai.js');
+      return new OpenAIProvider(options);
+    }
+    case 'anthropic': {
+      const { AnthropicProvider } = await import('./anthropic.js');
+      return new AnthropicProvider(options);
+    }
+    case 'local':
+    case 'ollama': {
+      const { LocalProvider } = await import('./local.js');
+      return new LocalProvider(options);
+    }
+    default:
+      throw new Error(`Unknown provider: ${provider}`);
+  }
+}

package/src/llm/providers/local.js

@@ -0,0 +1,163 @@
+/**
+ * Local LLM Provider (Ollama, LM Studio, etc.)
+ * 
+ * Supports OpenAI-compatible local endpoints
+ */
+
+import { LLMProvider } from './base.js';
+
+export class LocalProvider extends LLMProvider {
+  constructor(config = {}) {
+    super({
+      model: config.model || 'llama3.1',
+      apiKey: config.apiKey || 'ollama', // dummy key for Ollama
+      baseUrl: config.baseUrl || 'http://localhost:11434/v1',
+      defaultParams: config.defaultParams || {},
+    });
+    
+    this.client = null;
+    // Local models are free (no API cost)
+    this.pricing = { input: 0, output: 0 };
+  }
+
+  /**
+   * Lazy-load OpenAI-compatible client
+   */
+  async getClient() {
+    if (!this.client) {
+      const { default: OpenAI } = await import('openai');
+      this.client = new OpenAI({
+        apiKey: this.apiKey,
+        baseURL: this.baseUrl,
+      });
+    }
+    return this.client;
+  }
+
+  /**
+   * Generate completion from local LLM
+   */
+  async generate(messages, options = {}) {
+    const client = await this.getClient();
+    
+    const params = {
+      model: this.model,
+      messages: messages.map(m => ({ role: m.role, content: m.content })),
+      temperature: options.temperature ?? this.defaultParams.temperature ?? 0.7,
+      max_tokens: options.maxTokens ?? this.defaultParams.maxTokens ?? 4096,
+      ...this.defaultParams,
+    };
+
+    if (options.tools && options.tools.length > 0) {
+      params.tools = options.tools.map(tool => ({
+        type: 'function',
+        function: {
+          name: tool.name,
+          description: tool.description,
+          parameters: tool.parameters,
+        },
+      }));
+      params.tool_choice = options.toolChoice || 'auto';
+    }
+
+    const response = await client.chat.completions.create(params);
+    
+    return {
+      content: response.choices[0]?.message?.content || '',
+      toolCalls: response.choices[0]?.message?.tool_calls || [],
+      usage: {
+        inputTokens: response.usage?.prompt_tokens || 0,
+        outputTokens: response.usage?.completion_tokens || 0,
+        totalTokens: response.usage?.total_tokens || 0,
+      },
+      finishReason: response.choices[0]?.finish_reason,
+      model: response.model,
+    };
+  }
+
+  /**
+   * Generate streaming completion
+   */
+  async *generateStream(messages, options = {}) {
+    const client = await this.getClient();
+    
+    const params = {
+      model: this.model,
+      messages: messages.map(m => ({ role: m.role, content: m.content })),
+      temperature: options.temperature ?? this.defaultParams.temperature ?? 0.7,
+      max_tokens: options.maxTokens ?? this.defaultParams.maxTokens ?? 4096,
+      stream: true,
+      ...this.defaultParams,
+    };
+
+    if (options.tools && options.tools.length > 0) {
+      params.tools = options.tools.map(tool => ({
+        type: 'function',
+        function: {
+          name: tool.name,
+          description: tool.description,
+          parameters: tool.parameters,
+        },
+      }));
+      params.tool_choice = options.toolChoice || 'auto';
+    }
+
+    const stream = await client.chat.completions.create(params);
+    
+    for await (const chunk of stream) {
+      const delta = chunk.choices[0]?.delta;
+      yield {
+        content: delta?.content || '',
+        toolCalls: delta?.tool_calls || [],
+        usage: chunk.usage ? {
+          inputTokens: chunk.usage.prompt_tokens || 0,
+          outputTokens: chunk.usage.completion_tokens || 0,
+          totalTokens: chunk.usage.total_tokens || 0,
+        } : null,
+        finishReason: chunk.choices[0]?.finish_reason,
+      };
+    }
+  }
+
+  /**
+   * Calculate cost (free for local)
+   */
+  calculateCost(usage) {
+    return 0;
+  }
+
+  /**
+   * Get pricing info
+   */
+  getPricing() {
+    return { input: 0, output: 0 };
+  }
+
+  /**
+   * Check if provider supports function calling
+   */
+  supportsTools() {
+    // Depends on the model, assume yes for modern models
+    return true;
+  }
+
+  /**
+   * Check if provider supports streaming
+   */
+  supportsStreaming() {
+    return true;
+  }
+
+  /**
+   * Validate configuration
+   */
+  async validate() {
+    try {
+      const client = await this.getClient();
+      await client.models.list();
+      return { valid: true };
+    } catch (e) {
+      return { valid: false, error: `Cannot connect to local LLM at ${this.baseUrl}: ${e.message}` };
+    }
+  }
+}