@auxiora/providers 1.0.0

package/src/google.ts

@@ -0,0 +1,176 @@
+import { GoogleGenerativeAI } from '@google/generative-ai';
+import type {
+  Provider,
+  ProviderMetadata,
+  ChatMessage,
+  CompletionOptions,
+  CompletionResult,
+  StreamChunk,
+} from './types.js';
+
+const DEFAULT_MODEL = 'gemini-2.5-flash';
+const DEFAULT_MAX_TOKENS = 4096;
+
+export interface GoogleProviderOptions {
+  apiKey: string;
+  model?: string;
+  maxTokens?: number;
+}
+
+export class GoogleProvider implements Provider {
+  name = 'google';
+  metadata: ProviderMetadata = {
+    name: 'google',
+    displayName: 'Google Gemini',
+    models: {
+      'gemini-2.5-flash': {
+        maxContextTokens: 1048576,
+        supportsVision: true,
+        supportsTools: true,
+        supportsStreaming: true,
+        supportsImageGen: false,
+        costPer1kInput: 0.00015,
+        costPer1kOutput: 0.0006,
+        strengths: ['fast', 'code', 'reasoning'],
+        isLocal: false,
+      },
+      'gemini-2.5-pro': {
+        maxContextTokens: 1048576,
+        supportsVision: true,
+        supportsTools: true,
+        supportsStreaming: true,
+        supportsImageGen: false,
+        costPer1kInput: 0.00125,
+        costPer1kOutput: 0.01,
+        strengths: ['reasoning', 'code', 'long-context', 'creative'],
+        isLocal: false,
+      },
+    },
+    isAvailable: async () => {
+      try {
+        return this.client !== undefined;
+      } catch {
+        return false;
+      }
+    },
+  };
+  private client: GoogleGenerativeAI;
+  private defaultModel: string;
+  private defaultMaxTokens: number;
+
+  constructor(options: GoogleProviderOptions) {
+    this.client = new GoogleGenerativeAI(options.apiKey);
+    this.defaultModel = options.model || DEFAULT_MODEL;
+    this.defaultMaxTokens = options.maxTokens || DEFAULT_MAX_TOKENS;
+  }
+
+  async complete(
+    messages: ChatMessage[],
+    options?: CompletionOptions,
+  ): Promise<CompletionResult> {
+    const modelName = options?.model || this.defaultModel;
+    const model = this.client.getGenerativeModel({
+      model: modelName,
+      systemInstruction: options?.systemPrompt,
+    });
+
+    const { contents, systemInstruction } = this.prepareMessages(messages, options);
+    const genModel = systemInstruction
+      ? this.client.getGenerativeModel({ model: modelName, systemInstruction })
+      : model;
+
+    const result = await genModel.generateContent({
+      contents,
+      generationConfig: {
+        maxOutputTokens: options?.maxTokens || this.defaultMaxTokens,
+        temperature: options?.temperature,
+      },
+    });
+
+    const response = result.response;
+    const text = response.text();
+    const usage = response.usageMetadata;
+
+    return {
+      content: text,
+      usage: {
+        inputTokens: usage?.promptTokenCount ?? 0,
+        outputTokens: usage?.candidatesTokenCount ?? 0,
+      },
+      model: modelName,
+      finishReason: response.candidates?.[0]?.finishReason ?? 'unknown',
+    };
+  }
+
+  async *stream(
+    messages: ChatMessage[],
+    options?: CompletionOptions,
+  ): AsyncGenerator<StreamChunk, void, unknown> {
+    const modelName = options?.model || this.defaultModel;
+    const { contents, systemInstruction } = this.prepareMessages(messages, options);
+    const model = this.client.getGenerativeModel({
+      model: modelName,
+      systemInstruction: systemInstruction || options?.systemPrompt,
+    });
+
+    try {
+      const result = await model.generateContentStream({
+        contents,
+        generationConfig: {
+          maxOutputTokens: options?.maxTokens || this.defaultMaxTokens,
+          temperature: options?.temperature,
+        },
+      });
+
+      for await (const chunk of result.stream) {
+        const text = chunk.text();
+        if (text) {
+          yield { type: 'text', content: text };
+        }
+      }
+
+      const finalResponse = await result.response;
+      const usage = finalResponse.usageMetadata;
+      yield {
+        type: 'done',
+        usage: {
+          inputTokens: usage?.promptTokenCount ?? 0,
+          outputTokens: usage?.candidatesTokenCount ?? 0,
+        },
+      };
+    } catch (error) {
+      yield {
+        type: 'error',
+        error: error instanceof Error ? error.message : 'Unknown error',
+      };
+    }
+  }
+
+  private prepareMessages(
+    messages: ChatMessage[],
+    options?: CompletionOptions,
+  ): { contents: Array<{ role: string; parts: Array<{ text: string }> }>; systemInstruction?: string } {
+    let systemInstruction = options?.systemPrompt;
+    const contents: Array<{ role: string; parts: Array<{ text: string }> }> = [];
+
+    for (const msg of messages) {
+      if (msg.role === 'system') {
+        systemInstruction = systemInstruction
+          ? `${systemInstruction}\n\n${msg.content}`
+          : msg.content;
+      } else {
+        contents.push({
+          role: msg.role === 'assistant' ? 'model' : 'user',
+          parts: [{ text: msg.content }],
+        });
+      }
+    }
+
+    // Gemini requires alternating user/model turns, starting with user
+    if (contents.length > 0 && contents[0].role !== 'user') {
+      contents.unshift({ role: 'user', parts: [{ text: '(Starting conversation)' }] });
+    }
+
+    return { contents, systemInstruction };
+  }
+}

package/src/groq.ts

@@ -0,0 +1,263 @@
+import type {
+  Provider,
+  ProviderMetadata,
+  ChatMessage,
+  CompletionOptions,
+  CompletionResult,
+  StreamChunk,
+} from './types.js';
+
+const DEFAULT_MODEL = 'llama-3.3-70b-versatile';
+const DEFAULT_MAX_TOKENS = 4096;
+const BASE_URL = 'https://api.groq.com/openai/v1';
+
+export interface GroqProviderOptions {
+  apiKey: string;
+  model?: string;
+  maxTokens?: number;
+}
+
+interface GroqChatMessage {
+  role: string;
+  content: string;
+}
+
+interface GroqChoice {
+  message: { role: string; content: string };
+  finish_reason: string;
+}
+
+interface GroqUsage {
+  prompt_tokens: number;
+  completion_tokens: number;
+}
+
+interface GroqChatResponse {
+  choices: GroqChoice[];
+  usage: GroqUsage;
+  model: string;
+}
+
+interface GroqStreamDelta {
+  content?: string;
+}
+
+interface GroqStreamChoice {
+  delta: GroqStreamDelta;
+  finish_reason: string | null;
+}
+
+interface GroqStreamChunk {
+  choices: GroqStreamChoice[];
+  usage?: GroqUsage;
+}
+
+export class GroqProvider implements Provider {
+  name = 'groq';
+  metadata: ProviderMetadata = {
+    name: 'groq',
+    displayName: 'Groq',
+    models: {
+      'llama-3.3-70b-versatile': {
+        maxContextTokens: 128000,
+        supportsVision: false,
+        supportsTools: true,
+        supportsStreaming: true,
+        supportsImageGen: false,
+        costPer1kInput: 0.00059,
+        costPer1kOutput: 0.00079,
+        strengths: ['fast', 'reasoning', 'code'],
+        isLocal: false,
+      },
+      'llama-3.1-8b-instant': {
+        maxContextTokens: 131072,
+        supportsVision: false,
+        supportsTools: true,
+        supportsStreaming: true,
+        supportsImageGen: false,
+        costPer1kInput: 0.00005,
+        costPer1kOutput: 0.00008,
+        strengths: ['fast', 'low-cost'],
+        isLocal: false,
+      },
+      'mixtral-8x7b-32768': {
+        maxContextTokens: 32768,
+        supportsVision: false,
+        supportsTools: true,
+        supportsStreaming: true,
+        supportsImageGen: false,
+        costPer1kInput: 0.00024,
+        costPer1kOutput: 0.00024,
+        strengths: ['fast', 'code', 'multilingual'],
+        isLocal: false,
+      },
+      'gemma2-9b-it': {
+        maxContextTokens: 8192,
+        supportsVision: false,
+        supportsTools: true,
+        supportsStreaming: true,
+        supportsImageGen: false,
+        costPer1kInput: 0.0002,
+        costPer1kOutput: 0.0002,
+        strengths: ['fast', 'low-cost'],
+        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: GroqProviderOptions) {
+    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 groqMessages = 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: groqMessages,
+        temperature: options?.temperature,
+      }),
+    });
+
+    if (!response.ok) {
+      throw new Error(`Groq API error: ${response.status} ${response.statusText}`);
+    }
+
+    const data = (await response.json()) as GroqChatResponse;
+    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 groqMessages = 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: groqMessages,
+          temperature: options?.temperature,
+          stream: true,
+          stream_options: { include_usage: true },
+        }),
+      });
+
+      if (!response.ok) {
+        throw new Error(`Groq 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 GroqStreamChunk;
+
+          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,
+  ): GroqChatMessage[] {
+    const groqMessages: GroqChatMessage[] = [];
+
+    if (options?.systemPrompt) {
+      groqMessages.push({ role: 'system', content: options.systemPrompt });
+    }
+
+    for (const msg of messages) {
+      groqMessages.push({ role: msg.role, content: msg.content });
+    }
+
+    return groqMessages;
+  }
+}

package/src/index.ts

@@ -0,0 +1,44 @@
+export { AnthropicProvider, type AnthropicProviderOptions } from './anthropic.js';
+export { OpenAIProvider, type OpenAIProviderOptions } from './openai.js';
+export { GoogleProvider, type GoogleProviderOptions } from './google.js';
+export { OllamaProvider, type OllamaProviderOptions } from './ollama.js';
+export { OpenAICompatibleProvider, type OpenAICompatibleProviderOptions } from './openai-compatible.js';
+export { GroqProvider, type GroqProviderOptions } from './groq.js';
+export { ReplicateProvider, type ReplicateProviderOptions } from './replicate.js';
+export { DeepSeekProvider, type DeepSeekProviderOptions } from './deepseek.js';
+export { CohereProvider, type CohereProviderOptions } from './cohere.js';
+export { XAIProvider, type XAIProviderOptions } from './xai.js';
+export { ProviderFactory, type ProviderFactoryOptions, type ProviderName } from './factory.js';
+export {
+  getAnthropicThinkingBudget,
+  getOpenAIReasoningEffort,
+  isOpenAIReasoningModel,
+} from './thinking-levels.js';
+export {
+  isSetupToken,
+  validateSetupToken,
+  readClaudeCliCredentials,
+  resolveAnthropicApiKey,
+  generatePKCE,
+  buildAuthorizationUrl,
+  exchangeCodeForTokens,
+  refreshOAuthToken,
+  refreshPKCEOAuthToken,
+  writeClaudeCliCredentials,
+  type ClaudeOAuthCredentials,
+} from './claude-oauth.js';
+export type {
+  Provider,
+  ProviderConfig,
+  ProviderMetadata,
+  ModelCapabilities,
+  ChatMessage,
+  CompletionOptions,
+  CompletionResult,
+  StreamChunk,
+  MessageRole,
+  ThinkingLevel,
+  ToolDefinition,
+  ToolUse,
+  ToolResultMessage,
+} from './types.js';

package/src/ollama.ts

@@ -0,0 +1,194 @@
+import type {
+  Provider,
+  ProviderMetadata,
+  ChatMessage,
+  CompletionOptions,
+  CompletionResult,
+  StreamChunk,
+} from './types.js';
+
+const DEFAULT_BASE_URL = 'http://localhost:11434';
+const DEFAULT_MODEL = 'llama3';
+const DEFAULT_MAX_TOKENS = 4096;
+
+export interface OllamaProviderOptions {
+  baseUrl?: string;
+  model?: string;
+  maxTokens?: number;
+}
+
+interface OllamaChatMessage {
+  role: string;
+  content: string;
+}
+
+interface OllamaChatResponse {
+  message: { role: string; content: string };
+  done: boolean;
+  eval_count?: number;
+  prompt_eval_count?: number;
+}
+
+export class OllamaProvider implements Provider {
+  name = 'ollama';
+  metadata: ProviderMetadata;
+  private baseUrl: string;
+  private defaultModel: string;
+  private defaultMaxTokens: number;
+
+  constructor(options: OllamaProviderOptions) {
+    this.baseUrl = (options.baseUrl || DEFAULT_BASE_URL).replace(/\/$/, '');
+    this.defaultModel = options.model || DEFAULT_MODEL;
+    this.defaultMaxTokens = options.maxTokens || DEFAULT_MAX_TOKENS;
+
+    this.metadata = {
+      name: 'ollama',
+      displayName: 'Ollama (Local)',
+      models: {
+        [this.defaultModel]: {
+          maxContextTokens: 8192,
+          supportsVision: false,
+          supportsTools: false,
+          supportsStreaming: true,
+          supportsImageGen: false,
+          costPer1kInput: 0,
+          costPer1kOutput: 0,
+          strengths: ['fast', 'private'],
+          isLocal: true,
+        },
+      },
+      isAvailable: async () => {
+        try {
+          const response = await fetch(`${this.baseUrl}/api/tags`);
+          return response.ok;
+        } catch {
+          return false;
+        }
+      },
+    };
+  }
+
+  async complete(
+    messages: ChatMessage[],
+    options?: CompletionOptions,
+  ): Promise<CompletionResult> {
+    const model = options?.model || this.defaultModel;
+    const ollamaMessages = this.prepareMessages(messages, options);
+
+    const response = await fetch(`${this.baseUrl}/api/chat`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        model,
+        messages: ollamaMessages,
+        stream: false,
+        options: {
+          num_predict: options?.maxTokens || this.defaultMaxTokens,
+          temperature: options?.temperature,
+        },
+      }),
+    });
+
+    if (!response.ok) {
+      throw new Error(`Ollama API error: ${response.status} ${response.statusText}`);
+    }
+
+    const data = await response.json() as OllamaChatResponse;
+
+    return {
+      content: data.message.content,
+      usage: {
+        inputTokens: data.prompt_eval_count ?? 0,
+        outputTokens: data.eval_count ?? 0,
+      },
+      model,
+      finishReason: data.done ? 'stop' : 'unknown',
+    };
+  }
+
+  async *stream(
+    messages: ChatMessage[],
+    options?: CompletionOptions,
+  ): AsyncGenerator<StreamChunk, void, unknown> {
+    const model = options?.model || this.defaultModel;
+    const ollamaMessages = this.prepareMessages(messages, options);
+
+    try {
+      const response = await fetch(`${this.baseUrl}/api/chat`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          model,
+          messages: ollamaMessages,
+          stream: true,
+          options: {
+            num_predict: options?.maxTokens || this.defaultMaxTokens,
+            temperature: options?.temperature,
+          },
+        }),
+      });
+
+      if (!response.ok) {
+        throw new Error(`Ollama 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 = '';
+
+      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) {
+          if (!line.trim()) continue;
+          const chunk = JSON.parse(line) as OllamaChatResponse;
+
+          if (chunk.message?.content) {
+            yield { type: 'text', content: chunk.message.content };
+          }
+
+          if (chunk.done) {
+            yield {
+              type: 'done',
+              usage: {
+                inputTokens: chunk.prompt_eval_count ?? 0,
+                outputTokens: chunk.eval_count ?? 0,
+              },
+            };
+          }
+        }
+      }
+    } catch (error) {
+      yield {
+        type: 'error',
+        error: error instanceof Error ? error.message : 'Unknown error',
+      };
+    }
+  }
+
+  private prepareMessages(
+    messages: ChatMessage[],
+    options?: CompletionOptions,
+  ): OllamaChatMessage[] {
+    const ollamaMessages: OllamaChatMessage[] = [];
+
+    if (options?.systemPrompt) {
+      ollamaMessages.push({ role: 'system', content: options.systemPrompt });
+    }
+
+    for (const msg of messages) {
+      ollamaMessages.push({ role: msg.role, content: msg.content });
+    }
+
+    return ollamaMessages;
+  }
+}