@auxiora/providers 1.0.0

package/src/cohere.ts

@@ -0,0 +1,242 @@
+import type {
+  Provider,
+  ProviderMetadata,
+  ChatMessage,
+  CompletionOptions,
+  CompletionResult,
+  StreamChunk,
+} from './types.js';
+
+const DEFAULT_MODEL = 'command-r-plus';
+const DEFAULT_MAX_TOKENS = 4096;
+const BASE_URL = 'https://api.cohere.com/v2';
+
+export interface CohereProviderOptions {
+  apiKey: string;
+  model?: string;
+  maxTokens?: number;
+}
+
+interface CohereChatMessage {
+  role: 'user' | 'assistant' | 'system';
+  content: string;
+}
+
+interface CohereUsage {
+  billed_units?: {
+    input_tokens?: number;
+    output_tokens?: number;
+  };
+  tokens?: {
+    input_tokens?: number;
+    output_tokens?: number;
+  };
+}
+
+interface CohereChatResponse {
+  message: {
+    role: string;
+    content: Array<{ type: string; text: string }>;
+  };
+  finish_reason: string;
+  usage: CohereUsage;
+}
+
+interface CohereStreamEvent {
+  type: string;
+  delta?: {
+    message?: {
+      content?: {
+        text?: string;
+      };
+    };
+  };
+  usage?: CohereUsage;
+}
+
+export class CohereProvider implements Provider {
+  name = 'cohere';
+  metadata: ProviderMetadata = {
+    name: 'cohere',
+    displayName: 'Cohere',
+    models: {
+      'command-r-plus': {
+        maxContextTokens: 128000,
+        supportsVision: false,
+        supportsTools: true,
+        supportsStreaming: true,
+        supportsImageGen: false,
+        costPer1kInput: 0.0025,
+        costPer1kOutput: 0.01,
+        strengths: ['reasoning', 'rag', 'multilingual'],
+        isLocal: false,
+      },
+      'command-r': {
+        maxContextTokens: 128000,
+        supportsVision: false,
+        supportsTools: true,
+        supportsStreaming: true,
+        supportsImageGen: false,
+        costPer1kInput: 0.00015,
+        costPer1kOutput: 0.0006,
+        strengths: ['fast', 'rag', 'multilingual'],
+        isLocal: false,
+      },
+    },
+    isAvailable: async () => {
+      try {
+        const response = await fetch(`${BASE_URL}/models`, {
+          headers: { Authorization: `Bearer ${this.apiKey}` },
+        });
+        return response.ok;
+      } catch {
+        return false;
+      }
+    },
+  };
+
+  private apiKey: string;
+  private defaultModel: string;
+  private defaultMaxTokens: number;
+
+  constructor(options: CohereProviderOptions) {
+    this.apiKey = options.apiKey;
+    this.defaultModel = options.model || DEFAULT_MODEL;
+    this.defaultMaxTokens = options.maxTokens || DEFAULT_MAX_TOKENS;
+  }
+
+  async complete(
+    messages: ChatMessage[],
+    options?: CompletionOptions,
+  ): Promise<CompletionResult> {
+    const model = options?.model || this.defaultModel;
+    const cohereMessages = this.prepareMessages(messages, options);
+
+    const response = await fetch(`${BASE_URL}/chat`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${this.apiKey}`,
+      },
+      body: JSON.stringify({
+        model,
+        messages: cohereMessages,
+        max_tokens: options?.maxTokens || this.defaultMaxTokens,
+        temperature: options?.temperature,
+      }),
+    });
+
+    if (!response.ok) {
+      throw new Error(`Cohere API error: ${response.status} ${response.statusText}`);
+    }
+
+    const data = (await response.json()) as CohereChatResponse;
+    const text = data.message?.content?.[0]?.text || '';
+    const usage = data.usage;
+
+    return {
+      content: text,
+      usage: {
+        inputTokens: usage?.tokens?.input_tokens ?? usage?.billed_units?.input_tokens ?? 0,
+        outputTokens: usage?.tokens?.output_tokens ?? usage?.billed_units?.output_tokens ?? 0,
+      },
+      model,
+      finishReason: data.finish_reason || 'unknown',
+    };
+  }
+
+  async *stream(
+    messages: ChatMessage[],
+    options?: CompletionOptions,
+  ): AsyncGenerator<StreamChunk, void, unknown> {
+    const model = options?.model || this.defaultModel;
+    const cohereMessages = this.prepareMessages(messages, options);
+
+    try {
+      const response = await fetch(`${BASE_URL}/chat`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Bearer ${this.apiKey}`,
+        },
+        body: JSON.stringify({
+          model,
+          messages: cohereMessages,
+          max_tokens: options?.maxTokens || this.defaultMaxTokens,
+          temperature: options?.temperature,
+          stream: true,
+        }),
+      });
+
+      if (!response.ok) {
+        throw new Error(`Cohere API error: ${response.status} ${response.statusText}`);
+      }
+
+      const reader = response.body?.getReader();
+      if (!reader) {
+        throw new Error('No response body');
+      }
+
+      const decoder = new TextDecoder();
+      let buffer = '';
+      let inputTokens = 0;
+      let outputTokens = 0;
+
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || '';
+
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed || !trimmed.startsWith('data: ')) continue;
+          const data = trimmed.slice(6);
+          if (data === '[DONE]') continue;
+
+          const event = JSON.parse(data) as CohereStreamEvent;
+
+          if (event.type === 'content-delta' && event.delta?.message?.content?.text) {
+            yield { type: 'text', content: event.delta.message.content.text };
+          }
+
+          if (event.usage) {
+            inputTokens = event.usage.tokens?.input_tokens ?? event.usage.billed_units?.input_tokens ?? 0;
+            outputTokens = event.usage.tokens?.output_tokens ?? event.usage.billed_units?.output_tokens ?? 0;
+          }
+
+          if (event.type === 'message-end') {
+            yield {
+              type: 'done',
+              usage: { inputTokens, outputTokens },
+            };
+          }
+        }
+      }
+    } catch (error) {
+      yield {
+        type: 'error',
+        error: error instanceof Error ? error.message : 'Unknown error',
+      };
+    }
+  }
+
+  private prepareMessages(
+    messages: ChatMessage[],
+    options?: CompletionOptions,
+  ): CohereChatMessage[] {
+    const cohereMessages: CohereChatMessage[] = [];
+
+    if (options?.systemPrompt) {
+      cohereMessages.push({ role: 'system', content: options.systemPrompt });
+    }
+
+    for (const msg of messages) {
+      cohereMessages.push({ role: msg.role, content: msg.content });
+    }
+
+    return cohereMessages;
+  }
+}

package/src/deepseek.ts

@@ -0,0 +1,241 @@
+import type {
+  Provider,
+  ProviderMetadata,
+  ChatMessage,
+  CompletionOptions,
+  CompletionResult,
+  StreamChunk,
+} from './types.js';
+
+const DEFAULT_MODEL = 'deepseek-chat';
+const DEFAULT_MAX_TOKENS = 4096;
+const BASE_URL = 'https://api.deepseek.com';
+
+export interface DeepSeekProviderOptions {
+  apiKey: string;
+  model?: string;
+  maxTokens?: number;
+}
+
+interface DeepSeekChatMessage {
+  role: string;
+  content: string;
+}
+
+interface DeepSeekChoice {
+  message: { role: string; content: string };
+  finish_reason: string;
+}
+
+interface DeepSeekUsage {
+  prompt_tokens: number;
+  completion_tokens: number;
+}
+
+interface DeepSeekChatResponse {
+  choices: DeepSeekChoice[];
+  usage: DeepSeekUsage;
+  model: string;
+}
+
+interface DeepSeekStreamDelta {
+  content?: string;
+}
+
+interface DeepSeekStreamChoice {
+  delta: DeepSeekStreamDelta;
+  finish_reason: string | null;
+}
+
+interface DeepSeekStreamChunk {
+  choices: DeepSeekStreamChoice[];
+  usage?: DeepSeekUsage;
+}
+
+export class DeepSeekProvider implements Provider {
+  name = 'deepseek';
+  metadata: ProviderMetadata = {
+    name: 'deepseek',
+    displayName: 'DeepSeek',
+    models: {
+      'deepseek-chat': {
+        maxContextTokens: 64000,
+        supportsVision: false,
+        supportsTools: true,
+        supportsStreaming: true,
+        supportsImageGen: false,
+        costPer1kInput: 0.00014,
+        costPer1kOutput: 0.00028,
+        strengths: ['reasoning', 'code', 'low-cost'],
+        isLocal: false,
+      },
+      'deepseek-reasoner': {
+        maxContextTokens: 64000,
+        supportsVision: false,
+        supportsTools: true,
+        supportsStreaming: true,
+        supportsImageGen: false,
+        costPer1kInput: 0.00055,
+        costPer1kOutput: 0.0022,
+        strengths: ['reasoning', 'code', 'math'],
+        isLocal: false,
+      },
+    },
+    isAvailable: async () => {
+      try {
+        const response = await fetch(`${BASE_URL}/models`, {
+          headers: { Authorization: `Bearer ${this.apiKey}` },
+        });
+        return response.ok;
+      } catch {
+        return false;
+      }
+    },
+  };
+
+  private apiKey: string;
+  private defaultModel: string;
+  private defaultMaxTokens: number;
+
+  constructor(options: DeepSeekProviderOptions) {
+    this.apiKey = options.apiKey;
+    this.defaultModel = options.model || DEFAULT_MODEL;
+    this.defaultMaxTokens = options.maxTokens || DEFAULT_MAX_TOKENS;
+  }
+
+  async complete(
+    messages: ChatMessage[],
+    options?: CompletionOptions,
+  ): Promise<CompletionResult> {
+    const model = options?.model || this.defaultModel;
+    const dsMessages = this.prepareMessages(messages, options);
+
+    const response = await fetch(`${BASE_URL}/chat/completions`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${this.apiKey}`,
+      },
+      body: JSON.stringify({
+        model,
+        max_tokens: options?.maxTokens || this.defaultMaxTokens,
+        messages: dsMessages,
+        temperature: options?.temperature,
+      }),
+    });
+
+    if (!response.ok) {
+      throw new Error(`DeepSeek API error: ${response.status} ${response.statusText}`);
+    }
+
+    const data = (await response.json()) as DeepSeekChatResponse;
+    const choice = data.choices[0];
+
+    return {
+      content: choice?.message?.content || '',
+      usage: {
+        inputTokens: data.usage?.prompt_tokens || 0,
+        outputTokens: data.usage?.completion_tokens || 0,
+      },
+      model: data.model,
+      finishReason: choice?.finish_reason || 'unknown',
+    };
+  }
+
+  async *stream(
+    messages: ChatMessage[],
+    options?: CompletionOptions,
+  ): AsyncGenerator<StreamChunk, void, unknown> {
+    const model = options?.model || this.defaultModel;
+    const dsMessages = this.prepareMessages(messages, options);
+
+    try {
+      const response = await fetch(`${BASE_URL}/chat/completions`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Bearer ${this.apiKey}`,
+        },
+        body: JSON.stringify({
+          model,
+          max_tokens: options?.maxTokens || this.defaultMaxTokens,
+          messages: dsMessages,
+          temperature: options?.temperature,
+          stream: true,
+          stream_options: { include_usage: true },
+        }),
+      });
+
+      if (!response.ok) {
+        throw new Error(`DeepSeek API error: ${response.status} ${response.statusText}`);
+      }
+
+      const reader = response.body?.getReader();
+      if (!reader) {
+        throw new Error('No response body');
+      }
+
+      const decoder = new TextDecoder();
+      let buffer = '';
+      let inputTokens = 0;
+      let outputTokens = 0;
+
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || '';
+
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed || !trimmed.startsWith('data: ')) continue;
+          const data = trimmed.slice(6);
+          if (data === '[DONE]') continue;
+
+          const chunk = JSON.parse(data) as DeepSeekStreamChunk;
+
+          const delta = chunk.choices[0]?.delta;
+          if (delta?.content) {
+            yield { type: 'text', content: delta.content };
+          }
+
+          if (chunk.usage) {
+            inputTokens = chunk.usage.prompt_tokens || 0;
+            outputTokens = chunk.usage.completion_tokens || 0;
+          }
+
+          if (chunk.choices[0]?.finish_reason) {
+            yield {
+              type: 'done',
+              usage: { inputTokens, outputTokens },
+            };
+          }
+        }
+      }
+    } catch (error) {
+      yield {
+        type: 'error',
+        error: error instanceof Error ? error.message : 'Unknown error',
+      };
+    }
+  }
+
+  private prepareMessages(
+    messages: ChatMessage[],
+    options?: CompletionOptions,
+  ): DeepSeekChatMessage[] {
+    const dsMessages: DeepSeekChatMessage[] = [];
+
+    if (options?.systemPrompt) {
+      dsMessages.push({ role: 'system', content: options.systemPrompt });
+    }
+
+    for (const msg of messages) {
+      dsMessages.push({ role: msg.role, content: msg.content });
+    }
+
+    return dsMessages;
+  }
+}

package/src/factory.ts

@@ -0,0 +1,142 @@
+import { AnthropicProvider, type AnthropicProviderOptions } from './anthropic.js';
+import { OpenAIProvider, type OpenAIProviderOptions } from './openai.js';
+import { GoogleProvider, type GoogleProviderOptions } from './google.js';
+import { OllamaProvider, type OllamaProviderOptions } from './ollama.js';
+import { OpenAICompatibleProvider, type OpenAICompatibleProviderOptions } from './openai-compatible.js';
+import { GroqProvider, type GroqProviderOptions } from './groq.js';
+import { ReplicateProvider, type ReplicateProviderOptions } from './replicate.js';
+import { DeepSeekProvider, type DeepSeekProviderOptions } from './deepseek.js';
+import { CohereProvider, type CohereProviderOptions } from './cohere.js';
+import { XAIProvider, type XAIProviderOptions } from './xai.js';
+import { readClaudeCliCredentials } from './claude-oauth.js';
+import { getLogger } from '@auxiora/logger';
+import type { Provider, ProviderConfig } from './types.js';
+
+const logger = getLogger('providers');
+
+export type ProviderName = string;
+
+export interface ProviderFactoryOptions {
+  primary: ProviderName;
+  fallback?: ProviderName;
+  config: ProviderConfig;
+}
+
+export class ProviderFactory {
+  private providers: Map<ProviderName, Provider> = new Map();
+  private primary: ProviderName;
+  private fallback?: ProviderName;
+
+  constructor(options: ProviderFactoryOptions) {
+    this.primary = options.primary;
+    this.fallback = options.fallback;
+
+    // Initialize configured providers
+    const anthropicConfig = options.config.anthropic;
+    const hasAnthropicCredentials =
+      anthropicConfig?.apiKey ||
+      anthropicConfig?.oauthToken ||
+      (anthropicConfig?.useCliCredentials !== false && readClaudeCliCredentials() !== null);
+
+    if (hasAnthropicCredentials && anthropicConfig) {
+      this.providers.set('anthropic', new AnthropicProvider(anthropicConfig));
+    }
+
+    if (options.config.openai?.apiKey) {
+      this.providers.set('openai', new OpenAIProvider(options.config.openai));
+    }
+
+    if (options.config.google?.apiKey) {
+      this.providers.set('google', new GoogleProvider(options.config.google));
+    }
+
+    if (options.config.ollama) {
+      this.providers.set('ollama', new OllamaProvider(options.config.ollama));
+    }
+
+    if (options.config.openaiCompatible?.baseUrl) {
+      const compat = options.config.openaiCompatible;
+      this.providers.set(
+        compat.name || 'openai-compatible',
+        new OpenAICompatibleProvider({
+          baseUrl: compat.baseUrl,
+          apiKey: compat.apiKey,
+          model: compat.model || '',
+          maxTokens: compat.maxTokens,
+          name: compat.name,
+        }),
+      );
+    }
+
+    if (options.config.groq?.apiKey) {
+      this.providers.set('groq', new GroqProvider(options.config.groq));
+    }
+
+    if (options.config.replicate?.apiToken) {
+      this.providers.set('replicate', new ReplicateProvider(options.config.replicate));
+    }
+
+    if (options.config.deepseek?.apiKey) {
+      this.providers.set('deepseek', new DeepSeekProvider(options.config.deepseek));
+    }
+
+    if (options.config.cohere?.apiKey) {
+      this.providers.set('cohere', new CohereProvider(options.config.cohere));
+    }
+
+    if (options.config.xai?.apiKey) {
+      this.providers.set('xai', new XAIProvider(options.config.xai));
+    }
+
+    // Auto-fallback: if configured primary isn't available, use first registered provider
+    if (this.providers.size > 0 && !this.providers.has(this.primary)) {
+      const firstAvailable = this.providers.keys().next().value as string;
+      logger.warn(`Provider '${this.primary}' not configured, falling back to '${firstAvailable}'`);
+      this.primary = firstAvailable;
+    }
+  }
+
+  getProvider(name?: ProviderName): Provider {
+    const providerName = name || this.primary;
+    const provider = this.providers.get(providerName);
+
+    if (!provider) {
+      throw new Error(`Provider not configured: ${providerName}`);
+    }
+
+    return provider;
+  }
+
+  getPrimaryProvider(): Provider {
+    return this.getProvider(this.primary);
+  }
+
+  getFallbackProvider(): Provider | null {
+    if (!this.fallback) return null;
+
+    try {
+      return this.getProvider(this.fallback);
+    } catch {
+      return null;
+    }
+  }
+
+  async withFallback<T>(
+    fn: (provider: Provider) => Promise<T>
+  ): Promise<T> {
+    try {
+      return await fn(this.getPrimaryProvider());
+    } catch (error) {
+      const fallback = this.getFallbackProvider();
+      if (fallback) {
+        logger.warn('Primary provider failed, using fallback', { error: error instanceof Error ? error : new Error(String(error)) });
+        return await fn(fallback);
+      }
+      throw error;
+    }
+  }
+
+  listAvailable(): ProviderName[] {
+    return Array.from(this.providers.keys());
+  }
+}