@auxiora/providers 1.0.0

package/src/thinking-levels.ts

@@ -0,0 +1,37 @@
+import type { ThinkingLevel } from './types.js';
+
+/**
+ * Map ThinkingLevel to Anthropic budget_tokens for the thinking block.
+ * Returns undefined for 'off' (no thinking).
+ */
+export function getAnthropicThinkingBudget(level: ThinkingLevel): number | undefined {
+  switch (level) {
+    case 'off': return undefined;
+    case 'low': return 1024;
+    case 'medium': return 4096;
+    case 'high': return 10000;
+    case 'xhigh': return 32000;
+  }
+}
+
+/**
+ * Map ThinkingLevel to OpenAI reasoning_effort for o-series models.
+ * Returns undefined for 'off'.
+ */
+export function getOpenAIReasoningEffort(level: ThinkingLevel): 'low' | 'medium' | 'high' | undefined {
+  switch (level) {
+    case 'off': return undefined;
+    case 'low': return 'low';
+    case 'medium': return 'medium';
+    case 'high': return 'high';
+    case 'xhigh': return 'high'; // OpenAI maxes at 'high'
+  }
+}
+
+/**
+ * Check if an OpenAI model supports reasoning_effort (o-series).
+ */
+export function isOpenAIReasoningModel(model: string): boolean {
+  return model.startsWith('o1') || model.startsWith('o3') || model.startsWith('o4')
+    || model.startsWith('gpt-5');
+}

package/src/types.ts

@@ -0,0 +1,171 @@
+/**
+ * Thinking/reasoning budget levels.
+ * Maps to provider-specific parameters:
+ * - Anthropic: thinking budget_tokens
+ * - OpenAI: reasoning_effort (for o-series models)
+ */
+export type ThinkingLevel = 'off' | 'low' | 'medium' | 'high' | 'xhigh';
+
+export type MessageRole = 'user' | 'assistant' | 'system';
+
+export interface ChatMessage {
+  role: MessageRole;
+  content: string;
+}
+
+/**
+ * Tool definition for AI providers
+ */
+export interface ToolDefinition {
+  name: string;
+  description: string;
+  input_schema: {
+    type: 'object';
+    properties: Record<string, any>;
+    required?: string[];
+  };
+}
+
+/**
+ * Tool use request from the AI
+ */
+export interface ToolUse {
+  id: string;
+  name: string;
+  input: any;
+}
+
+/**
+ * Tool result to send back to the AI
+ */
+export interface ToolResultMessage {
+  tool_use_id: string;
+  content: string;
+  is_error?: boolean;
+}
+
+export interface StreamChunk {
+  type: 'text' | 'thinking' | 'tool_use' | 'done' | 'error';
+  content?: string;
+  toolUse?: ToolUse;
+  error?: string;
+  usage?: {
+    inputTokens: number;
+    outputTokens: number;
+  };
+}
+
+export interface CompletionOptions {
+  model?: string;
+  maxTokens?: number;
+  temperature?: number;
+  systemPrompt?: string;
+  stream?: boolean;
+  tools?: ToolDefinition[];
+  /** Thinking/reasoning budget level. Default: 'off'. */
+  thinkingLevel?: ThinkingLevel;
+  /** When true, don't filter Claude Code emulation tool calls — yield them as normal tool_use events. */
+  passThroughAllTools?: boolean;
+}
+
+export interface CompletionResult {
+  content: string;
+  toolUse?: ToolUse[];
+  usage: {
+    inputTokens: number;
+    outputTokens: number;
+  };
+  model: string;
+  finishReason: string;
+}
+
+export interface ModelCapabilities {
+  maxContextTokens: number;
+  supportsVision: boolean;
+  supportsTools: boolean;
+  supportsStreaming: boolean;
+  supportsImageGen: boolean;
+  costPer1kInput: number;
+  costPer1kOutput: number;
+  strengths: string[];
+  isLocal: boolean;
+}
+
+export interface ProviderMetadata {
+  name: string;
+  displayName: string;
+  models: Record<string, ModelCapabilities>;
+  isAvailable(): Promise<boolean>;
+}
+
+export interface Provider {
+  name: string;
+  metadata: ProviderMetadata;
+  complete(messages: ChatMessage[], options?: CompletionOptions): Promise<CompletionResult>;
+  stream(
+    messages: ChatMessage[],
+    options?: CompletionOptions
+  ): AsyncGenerator<StreamChunk, void, unknown>;
+}
+
+export interface ProviderConfig {
+  anthropic?: {
+    apiKey?: string;
+    oauthToken?: string;
+    model?: string;
+    maxTokens?: number;
+    /** Read credentials from Claude CLI (~/.claude/.credentials.json) */
+    useCliCredentials?: boolean;
+    /** Callback to refresh the OAuth token when expired. Returns new access token. */
+    onTokenRefresh?: () => Promise<string | null>;
+    /** When the current OAuth token expires (epoch ms). Used for proactive refresh. */
+    tokenExpiresAt?: number;
+  };
+  openai?: {
+    apiKey: string;
+    model?: string;
+    maxTokens?: number;
+  };
+  google?: {
+    apiKey: string;
+    model?: string;
+    maxTokens?: number;
+  };
+  ollama?: {
+    baseUrl?: string;
+    model?: string;
+    maxTokens?: number;
+  };
+  openaiCompatible?: {
+    baseUrl: string;
+    apiKey?: string;
+    model?: string;
+    maxTokens?: number;
+    name?: string;
+  };
+  groq?: {
+    apiKey: string;
+    model?: string;
+    maxTokens?: number;
+  };
+  replicate?: {
+    apiToken: string;
+    model?: string;
+    pollInterval?: number;
+  };
+  deepseek?: {
+    apiKey: string;
+    model?: string;
+    maxTokens?: number;
+  };
+  cohere?: {
+    apiKey: string;
+    model?: string;
+    maxTokens?: number;
+  };
+  xai?: {
+    apiKey: string;
+    model?: string;
+    maxTokens?: number;
+  };
+}

package/src/xai.ts

@@ -0,0 +1,241 @@
+import type {
+  Provider,
+  ProviderMetadata,
+  ChatMessage,
+  CompletionOptions,
+  CompletionResult,
+  StreamChunk,
+} from './types.js';
+
+const DEFAULT_MODEL = 'grok-2';
+const DEFAULT_MAX_TOKENS = 4096;
+const BASE_URL = 'https://api.x.ai/v1';
+
+export interface XAIProviderOptions {
+  apiKey: string;
+  model?: string;
+  maxTokens?: number;
+}
+
+interface XAIChatMessage {
+  role: string;
+  content: string;
+}
+
+interface XAIChoice {
+  message: { role: string; content: string };
+  finish_reason: string;
+}
+
+interface XAIUsage {
+  prompt_tokens: number;
+  completion_tokens: number;
+}
+
+interface XAIChatResponse {
+  choices: XAIChoice[];
+  usage: XAIUsage;
+  model: string;
+}
+
+interface XAIStreamDelta {
+  content?: string;
+}
+
+interface XAIStreamChoice {
+  delta: XAIStreamDelta;
+  finish_reason: string | null;
+}
+
+interface XAIStreamChunk {
+  choices: XAIStreamChoice[];
+  usage?: XAIUsage;
+}
+
+export class XAIProvider implements Provider {
+  name = 'xai';
+  metadata: ProviderMetadata = {
+    name: 'xai',
+    displayName: 'xAI Grok',
+    models: {
+      'grok-2': {
+        maxContextTokens: 131072,
+        supportsVision: false,
+        supportsTools: true,
+        supportsStreaming: true,
+        supportsImageGen: false,
+        costPer1kInput: 0.002,
+        costPer1kOutput: 0.01,
+        strengths: ['reasoning', 'code', 'creative'],
+        isLocal: false,
+      },
+      'grok-2-mini': {
+        maxContextTokens: 131072,
+        supportsVision: false,
+        supportsTools: true,
+        supportsStreaming: true,
+        supportsImageGen: false,
+        costPer1kInput: 0.0002,
+        costPer1kOutput: 0.001,
+        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: XAIProviderOptions) {
+    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 xaiMessages = 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: xaiMessages,
+        temperature: options?.temperature,
+      }),
+    });
+
+    if (!response.ok) {
+      throw new Error(`xAI API error: ${response.status} ${response.statusText}`);
+    }
+
+    const data = (await response.json()) as XAIChatResponse;
+    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 xaiMessages = 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: xaiMessages,
+          temperature: options?.temperature,
+          stream: true,
+          stream_options: { include_usage: true },
+        }),
+      });
+
+      if (!response.ok) {
+        throw new Error(`xAI 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 XAIStreamChunk;
+
+          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,
+  ): XAIChatMessage[] {
+    const xaiMessages: XAIChatMessage[] = [];
+
+    if (options?.systemPrompt) {
+      xaiMessages.push({ role: 'system', content: options.systemPrompt });
+    }
+
+    for (const msg of messages) {
+      xaiMessages.push({ role: msg.role, content: msg.content });
+    }
+
+    return xaiMessages;
+  }
+}

package/tests/adapters.test.ts

@@ -0,0 +1,185 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { OllamaProvider } from '../src/ollama.js';
+import { OpenAICompatibleProvider } from '../src/openai-compatible.js';
+import { GoogleProvider } from '../src/google.js';
+import { ProviderFactory } from '../src/factory.js';
+
+describe('OllamaProvider', () => {
+  let provider: OllamaProvider;
+
+  beforeEach(() => {
+    provider = new OllamaProvider({ model: 'llama3' });
+  });
+
+  it('should have correct metadata', () => {
+    expect(provider.name).toBe('ollama');
+    expect(provider.metadata.name).toBe('ollama');
+    expect(provider.metadata.displayName).toBe('Ollama (Local)');
+    expect(provider.metadata.models['llama3']).toBeDefined();
+    expect(provider.metadata.models['llama3'].isLocal).toBe(true);
+    expect(provider.metadata.models['llama3'].costPer1kInput).toBe(0);
+    expect(provider.metadata.models['llama3'].costPer1kOutput).toBe(0);
+  });
+
+  it('should use custom base URL', () => {
+    const custom = new OllamaProvider({ baseUrl: 'http://192.168.1.5:11434', model: 'mistral' });
+    expect(custom.metadata.models['mistral']).toBeDefined();
+  });
+
+  it('should make correct API call for complete', async () => {
+    const mockResponse = {
+      message: { role: 'assistant', content: 'Hello! How can I help?' },
+      done: true,
+      eval_count: 10,
+      prompt_eval_count: 5,
+    };
+
+    vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce({
+      ok: true,
+      json: async () => mockResponse,
+    } as Response);
+
+    const result = await provider.complete([{ role: 'user', content: 'Hello' }]);
+    expect(result.content).toBe('Hello! How can I help?');
+    expect(result.usage.inputTokens).toBe(5);
+    expect(result.usage.outputTokens).toBe(10);
+    expect(result.finishReason).toBe('stop');
+
+    vi.restoreAllMocks();
+  });
+
+  it('should handle API errors', async () => {
+    vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce({
+      ok: false,
+      status: 500,
+      statusText: 'Internal Server Error',
+    } as Response);
+
+    await expect(provider.complete([{ role: 'user', content: 'Hello' }]))
+      .rejects.toThrow('Ollama API error: 500');
+
+    vi.restoreAllMocks();
+  });
+
+  it('should check availability via /api/tags', async () => {
+    vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce({ ok: true } as Response);
+    const available = await provider.metadata.isAvailable();
+    expect(available).toBe(true);
+    vi.restoreAllMocks();
+  });
+
+  it('should return false when Ollama is unreachable', async () => {
+    vi.spyOn(globalThis, 'fetch').mockRejectedValueOnce(new Error('Connection refused'));
+    const available = await provider.metadata.isAvailable();
+    expect(available).toBe(false);
+    vi.restoreAllMocks();
+  });
+});
+
+describe('OpenAICompatibleProvider', () => {
+  let provider: OpenAICompatibleProvider;
+
+  beforeEach(() => {
+    provider = new OpenAICompatibleProvider({
+      baseUrl: 'http://localhost:1234/v1',
+      model: 'local-model',
+      name: 'lm-studio',
+    });
+  });
+
+  it('should have correct metadata', () => {
+    expect(provider.name).toBe('lm-studio');
+    expect(provider.metadata.name).toBe('lm-studio');
+    expect(provider.metadata.displayName).toContain('lm-studio');
+    expect(provider.metadata.models['local-model']).toBeDefined();
+    expect(provider.metadata.models['local-model'].isLocal).toBe(true);
+    expect(provider.metadata.models['local-model'].costPer1kInput).toBe(0);
+  });
+
+  it('should default name to openai-compatible', () => {
+    const unnamed = new OpenAICompatibleProvider({
+      baseUrl: 'http://localhost:1234/v1',
+      model: 'test-model',
+    });
+    expect(unnamed.name).toBe('openai-compatible');
+  });
+});
+
+describe('GoogleProvider', () => {
+  it('should have correct metadata', () => {
+    const provider = new GoogleProvider({ apiKey: 'test-key' });
+    expect(provider.name).toBe('google');
+    expect(provider.metadata.name).toBe('google');
+    expect(provider.metadata.displayName).toBe('Google Gemini');
+    expect(provider.metadata.models['gemini-2.5-flash']).toBeDefined();
+    expect(provider.metadata.models['gemini-2.5-pro']).toBeDefined();
+    expect(provider.metadata.models['gemini-2.5-flash'].supportsVision).toBe(true);
+    expect(provider.metadata.models['gemini-2.5-pro'].maxContextTokens).toBe(1048576);
+  });
+});
+
+describe('ProviderFactory with new providers', () => {
+  it('should create ollama provider when config present', () => {
+    const factory = new ProviderFactory({
+      primary: 'ollama',
+      config: {
+        ollama: { model: 'llama3' },
+      },
+    });
+    const provider = factory.getProvider('ollama');
+    expect(provider.name).toBe('ollama');
+  });
+
+  it('should create google provider when API key present', () => {
+    const factory = new ProviderFactory({
+      primary: 'google',
+      config: {
+        google: { apiKey: 'test-google-key' },
+      },
+    });
+    const provider = factory.getProvider('google');
+    expect(provider.name).toBe('google');
+  });
+
+  it('should create openai-compatible provider when baseUrl present', () => {
+    const factory = new ProviderFactory({
+      primary: 'lm-studio',
+      config: {
+        openaiCompatible: {
+          baseUrl: 'http://localhost:1234/v1',
+          model: 'local-model',
+          name: 'lm-studio',
+        },
+      },
+    });
+    const provider = factory.getProvider('lm-studio');
+    expect(provider.name).toBe('lm-studio');
+  });
+
+  it('should list all available providers', () => {
+    const factory = new ProviderFactory({
+      primary: 'ollama',
+      config: {
+        ollama: { model: 'llama3' },
+        google: { apiKey: 'test-key' },
+        openaiCompatible: {
+          baseUrl: 'http://localhost:1234/v1',
+          model: 'test',
+          name: 'vllm',
+        },
+      },
+    });
+    const available = factory.listAvailable();
+    expect(available).toContain('ollama');
+    expect(available).toContain('google');
+    expect(available).toContain('vllm');
+  });
+
+  it('should throw when getting unconfigured provider', () => {
+    const factory = new ProviderFactory({
+      primary: 'anthropic',
+      config: {},
+    });
+    expect(() => factory.getProvider('google')).toThrow('Provider not configured: google');
+  });
+});

package/tests/claude-oauth.test.ts

@@ -0,0 +1,45 @@
+import { describe, it, expect } from 'vitest';
+import {
+  generatePKCE,
+  buildAuthorizationUrl,
+} from '../src/claude-oauth.js';
+
+describe('PKCE generation', () => {
+  it('generates a verifier of 43-128 chars using unreserved chars', () => {
+    const { verifier } = generatePKCE();
+    expect(verifier.length).toBeGreaterThanOrEqual(43);
+    expect(verifier.length).toBeLessThanOrEqual(128);
+    expect(verifier).toMatch(/^[A-Za-z0-9\-._~]+$/);
+  });
+
+  it('generates a base64url-encoded SHA-256 challenge', () => {
+    const { challenge } = generatePKCE();
+    expect(challenge).toMatch(/^[A-Za-z0-9_-]+$/);
+    expect(challenge.length).toBe(43);
+  });
+
+  it('generates unique values each call', () => {
+    const a = generatePKCE();
+    const b = generatePKCE();
+    expect(a.verifier).not.toBe(b.verifier);
+  });
+});
+
+describe('buildAuthorizationUrl', () => {
+  it('includes all required OAuth parameters', () => {
+    const url = buildAuthorizationUrl('test-challenge-value', 'test-state-value');
+    const parsed = new URL(url);
+
+    expect(parsed.origin).toBe('https://claude.ai');
+    expect(parsed.pathname).toBe('/oauth/authorize');
+    expect(parsed.searchParams.get('response_type')).toBe('code');
+    expect(parsed.searchParams.get('client_id')).toBeTruthy();
+    expect(parsed.searchParams.get('redirect_uri')).toBe(
+      'https://console.anthropic.com/oauth/code/callback'
+    );
+    expect(parsed.searchParams.get('scope')).toContain('user:inference');
+    expect(parsed.searchParams.get('code_challenge')).toBe('test-challenge-value');
+    expect(parsed.searchParams.get('code_challenge_method')).toBe('S256');
+    expect(parsed.searchParams.get('state')).toBe('test-state-value');
+  });
+});