@auxiora/providers 1.0.0

package/src/openai-compatible.ts

@@ -0,0 +1,154 @@
+import OpenAI from 'openai';
+import type {
+  Provider,
+  ProviderMetadata,
+  ChatMessage,
+  CompletionOptions,
+  CompletionResult,
+  StreamChunk,
+} from './types.js';
+
+const DEFAULT_MAX_TOKENS = 4096;
+
+export interface OpenAICompatibleProviderOptions {
+  baseUrl: string;
+  apiKey?: string;
+  model: string;
+  maxTokens?: number;
+  name?: string;
+}
+
+export class OpenAICompatibleProvider implements Provider {
+  name: string;
+  metadata: ProviderMetadata;
+  private client: OpenAI;
+  private defaultModel: string;
+  private defaultMaxTokens: number;
+
+  constructor(options: OpenAICompatibleProviderOptions) {
+    this.name = options.name || 'openai-compatible';
+    this.defaultModel = options.model;
+    this.defaultMaxTokens = options.maxTokens || DEFAULT_MAX_TOKENS;
+
+    this.client = new OpenAI({
+      apiKey: options.apiKey || 'not-needed',
+      baseURL: options.baseUrl,
+    });
+
+    this.metadata = {
+      name: this.name,
+      displayName: options.name ? `${options.name} (OpenAI-compatible)` : 'OpenAI-compatible',
+      models: {
+        [this.defaultModel]: {
+          maxContextTokens: 128000,
+          supportsVision: false,
+          supportsTools: true,
+          supportsStreaming: true,
+          supportsImageGen: false,
+          costPer1kInput: 0,
+          costPer1kOutput: 0,
+          strengths: ['code', 'reasoning'],
+          isLocal: true,
+        },
+      },
+      isAvailable: async () => {
+        try {
+          await this.client.models.list();
+          return true;
+        } catch {
+          return false;
+        }
+      },
+    };
+  }
+
+  async complete(
+    messages: ChatMessage[],
+    options?: CompletionOptions,
+  ): Promise<CompletionResult> {
+    const openaiMessages = this.prepareMessages(messages, options);
+
+    const response = await this.client.chat.completions.create({
+      model: options?.model || this.defaultModel,
+      max_tokens: options?.maxTokens || this.defaultMaxTokens,
+      messages: openaiMessages,
+      temperature: options?.temperature,
+    });
+
+    const choice = response.choices[0];
+    const content = choice?.message?.content || '';
+
+    return {
+      content,
+      usage: {
+        inputTokens: response.usage?.prompt_tokens || 0,
+        outputTokens: response.usage?.completion_tokens || 0,
+      },
+      model: response.model,
+      finishReason: choice?.finish_reason || 'unknown',
+    };
+  }
+
+  async *stream(
+    messages: ChatMessage[],
+    options?: CompletionOptions,
+  ): AsyncGenerator<StreamChunk, void, unknown> {
+    const openaiMessages = this.prepareMessages(messages, options);
+
+    try {
+      const stream = await this.client.chat.completions.create({
+        model: options?.model || this.defaultModel,
+        max_tokens: options?.maxTokens || this.defaultMaxTokens,
+        messages: openaiMessages,
+        temperature: options?.temperature,
+        stream: true,
+        stream_options: { include_usage: true },
+      });
+
+      let inputTokens = 0;
+      let outputTokens = 0;
+
+      for await (const chunk of stream) {
+        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,
+  ): OpenAI.ChatCompletionMessageParam[] {
+    const openaiMessages: OpenAI.ChatCompletionMessageParam[] = [];
+
+    if (options?.systemPrompt) {
+      openaiMessages.push({ role: 'system', content: options.systemPrompt });
+    }
+
+    for (const msg of messages) {
+      openaiMessages.push({ role: msg.role, content: msg.content });
+    }
+
+    return openaiMessages;
+  }
+}

package/src/openai.ts

@@ -0,0 +1,307 @@
+import OpenAI from 'openai';
+import type {
+  Provider,
+  ProviderMetadata,
+  ChatMessage,
+  CompletionOptions,
+  CompletionResult,
+  StreamChunk,
+  ToolDefinition,
+} from './types.js';
+import { getOpenAIReasoningEffort, isOpenAIReasoningModel } from './thinking-levels.js';
+
+const DEFAULT_MODEL = 'gpt-5.2';
+const DEFAULT_MAX_TOKENS = 4096;
+
+export interface OpenAIProviderOptions {
+  apiKey: string;
+  model?: string;
+  maxTokens?: number;
+  baseURL?: string;
+}
+
+export class OpenAIProvider implements Provider {
+  name = 'openai';
+  metadata: ProviderMetadata = {
+    name: 'openai',
+    displayName: 'OpenAI GPT',
+    models: {
+      'gpt-5.2': {
+        maxContextTokens: 1048576,
+        supportsVision: true,
+        supportsTools: true,
+        supportsStreaming: true,
+        supportsImageGen: false,
+        costPer1kInput: 0.003,
+        costPer1kOutput: 0.012,
+        strengths: ['reasoning', 'code', 'vision', 'creative', 'agentic'],
+        isLocal: false,
+      },
+      'gpt-5.2-pro': {
+        maxContextTokens: 1048576,
+        supportsVision: true,
+        supportsTools: true,
+        supportsStreaming: true,
+        supportsImageGen: false,
+        costPer1kInput: 0.01,
+        costPer1kOutput: 0.04,
+        strengths: ['reasoning', 'code', 'precision', 'agentic'],
+        isLocal: false,
+      },
+      'gpt-5': {
+        maxContextTokens: 1048576,
+        supportsVision: true,
+        supportsTools: true,
+        supportsStreaming: true,
+        supportsImageGen: false,
+        costPer1kInput: 0.0025,
+        costPer1kOutput: 0.01,
+        strengths: ['reasoning', 'code', 'agentic'],
+        isLocal: false,
+      },
+      'gpt-5-mini': {
+        maxContextTokens: 1048576,
+        supportsVision: true,
+        supportsTools: true,
+        supportsStreaming: true,
+        supportsImageGen: false,
+        costPer1kInput: 0.0004,
+        costPer1kOutput: 0.0016,
+        strengths: ['fast', 'code', 'cost-efficient'],
+        isLocal: false,
+      },
+      'gpt-5-nano': {
+        maxContextTokens: 1048576,
+        supportsVision: true,
+        supportsTools: true,
+        supportsStreaming: true,
+        supportsImageGen: false,
+        costPer1kInput: 0.0001,
+        costPer1kOutput: 0.0004,
+        strengths: ['fast', 'cost-efficient'],
+        isLocal: false,
+      },
+      'gpt-4.1': {
+        maxContextTokens: 1048576,
+        supportsVision: true,
+        supportsTools: true,
+        supportsStreaming: true,
+        supportsImageGen: false,
+        costPer1kInput: 0.002,
+        costPer1kOutput: 0.008,
+        strengths: ['code', 'instruction-following', 'long-context'],
+        isLocal: false,
+      },
+    },
+    isAvailable: async () => {
+      try {
+        return this.client !== undefined;
+      } catch {
+        return false;
+      }
+    },
+  };
+  private client: OpenAI;
+  private defaultModel: string;
+  private defaultMaxTokens: number;
+
+  constructor(options: OpenAIProviderOptions) {
+    this.client = new OpenAI({
+      apiKey: options.apiKey,
+      baseURL: options.baseURL,
+    });
+    this.defaultModel = options.model || DEFAULT_MODEL;
+    this.defaultMaxTokens = options.maxTokens || DEFAULT_MAX_TOKENS;
+  }
+
+  async complete(
+    messages: ChatMessage[],
+    options?: CompletionOptions
+  ): Promise<CompletionResult> {
+    const openaiMessages = this.prepareMessages(messages, options);
+
+    const model = options?.model || this.defaultModel;
+    const createParams: OpenAI.ChatCompletionCreateParams = {
+      model,
+      max_tokens: options?.maxTokens || this.defaultMaxTokens,
+      messages: openaiMessages,
+    };
+
+    // Add tools if provided
+    if (options?.tools && options.tools.length > 0) {
+      createParams.tools = this.transformTools(options.tools);
+    }
+
+    // Add reasoning_effort for o-series models
+    if (options?.thinkingLevel && isOpenAIReasoningModel(model)) {
+      const effort = getOpenAIReasoningEffort(options.thinkingLevel);
+      if (effort) {
+        (createParams as any).reasoning_effort = effort;
+      }
+    }
+
+    const response = await this.client.chat.completions.create(createParams);
+
+    const choice = response.choices[0];
+    const message = choice?.message;
+    const content = message?.content || '';
+
+    // Handle tool calls in the response
+    const toolCalls = message?.tool_calls;
+    if (toolCalls && toolCalls.length > 0) {
+      return {
+        content,
+        toolUse: toolCalls.map((tc) => ({
+          id: tc.id,
+          name: tc.function.name,
+          input: JSON.parse(tc.function.arguments || '{}'),
+        })),
+        usage: {
+          inputTokens: response.usage?.prompt_tokens || 0,
+          outputTokens: response.usage?.completion_tokens || 0,
+        },
+        model: response.model,
+        finishReason: 'tool_use',
+      };
+    }
+
+    return {
+      content,
+      usage: {
+        inputTokens: response.usage?.prompt_tokens || 0,
+        outputTokens: response.usage?.completion_tokens || 0,
+      },
+      model: response.model,
+      finishReason: choice?.finish_reason || 'unknown',
+    };
+  }
+
+  async *stream(
+    messages: ChatMessage[],
+    options?: CompletionOptions
+  ): AsyncGenerator<StreamChunk, void, unknown> {
+    const openaiMessages = this.prepareMessages(messages, options);
+
+    try {
+      const model = options?.model || this.defaultModel;
+      const createParams: OpenAI.ChatCompletionCreateParams = {
+        model,
+        max_tokens: options?.maxTokens || this.defaultMaxTokens,
+        messages: openaiMessages,
+        stream: true,
+        stream_options: { include_usage: true },
+      };
+
+      // Add tools if provided
+      if (options?.tools && options.tools.length > 0) {
+        createParams.tools = this.transformTools(options.tools);
+      }
+
+      // Add reasoning_effort for o-series models
+      if (options?.thinkingLevel && isOpenAIReasoningModel(model)) {
+        const effort = getOpenAIReasoningEffort(options.thinkingLevel);
+        if (effort) {
+          (createParams as any).reasoning_effort = effort;
+        }
+      }
+
+      const stream = await this.client.chat.completions.create(createParams);
+
+      let inputTokens = 0;
+      let outputTokens = 0;
+
+      // Track streaming tool calls: index -> { id, name, arguments }
+      const toolCallAccumulators = new Map<number, { id: string; name: string; arguments: string }>();
+
+      for await (const chunk of stream) {
+        const choice = chunk.choices[0];
+        const delta = choice?.delta;
+
+        if (delta?.content) {
+          yield { type: 'text', content: delta.content };
+        }
+
+        // Handle streaming tool_calls deltas
+        if (delta?.tool_calls) {
+          for (const tc of delta.tool_calls) {
+            const idx = tc.index;
+            if (!toolCallAccumulators.has(idx)) {
+              toolCallAccumulators.set(idx, { id: '', name: '', arguments: '' });
+            }
+            const acc = toolCallAccumulators.get(idx)!;
+            if (tc.id) acc.id = tc.id;
+            if (tc.function?.name) acc.name = tc.function.name;
+            if (tc.function?.arguments) acc.arguments += tc.function.arguments;
+          }
+        }
+
+        if (chunk.usage) {
+          inputTokens = chunk.usage.prompt_tokens || 0;
+          outputTokens = chunk.usage.completion_tokens || 0;
+        }
+
+        if (choice?.finish_reason) {
+          // Yield accumulated tool calls before done
+          if (choice.finish_reason === 'tool_calls' && toolCallAccumulators.size > 0) {
+            for (const [, acc] of toolCallAccumulators) {
+              yield {
+                type: 'tool_use',
+                toolUse: {
+                  id: acc.id,
+                  name: acc.name,
+                  input: JSON.parse(acc.arguments || '{}'),
+                },
+              };
+            }
+          }
+
+          yield {
+            type: 'done',
+            usage: { inputTokens, outputTokens },
+          };
+        }
+      }
+    } catch (error) {
+      yield {
+        type: 'error',
+        error: error instanceof Error ? error.message : 'Unknown error',
+      };
+    }
+  }
+
+  private transformTools(tools: ToolDefinition[]): OpenAI.ChatCompletionTool[] {
+    return tools.map((tool) => ({
+      type: 'function' as const,
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.input_schema as OpenAI.FunctionParameters,
+      },
+    }));
+  }
+
+  private prepareMessages(
+    messages: ChatMessage[],
+    options?: CompletionOptions
+  ): OpenAI.ChatCompletionMessageParam[] {
+    const openaiMessages: OpenAI.ChatCompletionMessageParam[] = [];
+
+    // Add system prompt if provided
+    if (options?.systemPrompt) {
+      openaiMessages.push({
+        role: 'system',
+        content: options.systemPrompt,
+      });
+    }
+
+    // Convert messages
+    for (const msg of messages) {
+      openaiMessages.push({
+        role: msg.role,
+        content: msg.content,
+      });
+    }
+
+    return openaiMessages;
+  }
+}

package/src/replicate.ts

@@ -0,0 +1,247 @@
+import type {
+  Provider,
+  ProviderMetadata,
+  ChatMessage,
+  CompletionOptions,
+  CompletionResult,
+  StreamChunk,
+} from './types.js';
+
+const DEFAULT_MODEL = 'meta/meta-llama-3-70b-instruct';
+const DEFAULT_POLL_INTERVAL = 1000;
+const BASE_URL = 'https://api.replicate.com/v1';
+
+export interface ReplicateProviderOptions {
+  apiToken: string;
+  model?: string;
+  pollInterval?: number;
+}
+
+interface ReplicatePrediction {
+  id: string;
+  status: 'starting' | 'processing' | 'succeeded' | 'failed' | 'canceled';
+  output?: string[] | string;
+  error?: string;
+  metrics?: {
+    predict_time?: number;
+  };
+}
+
+export class ReplicateProvider implements Provider {
+  name = 'replicate';
+  metadata: ProviderMetadata = {
+    name: 'replicate',
+    displayName: 'Replicate',
+    models: {
+      'meta/meta-llama-3-70b-instruct': {
+        maxContextTokens: 8192,
+        supportsVision: false,
+        supportsTools: false,
+        supportsStreaming: false,
+        supportsImageGen: false,
+        costPer1kInput: 0.00065,
+        costPer1kOutput: 0.00275,
+        strengths: ['reasoning', 'code'],
+        isLocal: false,
+      },
+      'stability-ai/sdxl': {
+        maxContextTokens: 0,
+        supportsVision: false,
+        supportsTools: false,
+        supportsStreaming: false,
+        supportsImageGen: true,
+        costPer1kInput: 0,
+        costPer1kOutput: 0,
+        strengths: ['image-generation'],
+        isLocal: false,
+      },
+    },
+    isAvailable: async () => {
+      try {
+        const response = await fetch(`${BASE_URL}/models`, {
+          headers: { Authorization: `Bearer ${this.apiToken}` },
+        });
+        return response.ok;
+      } catch {
+        return false;
+      }
+    },
+  };
+
+  private apiToken: string;
+  private defaultModel: string;
+  private pollInterval: number;
+
+  constructor(options: ReplicateProviderOptions) {
+    this.apiToken = options.apiToken;
+    this.defaultModel = options.model || DEFAULT_MODEL;
+    this.pollInterval = options.pollInterval || DEFAULT_POLL_INTERVAL;
+  }
+
+  async complete(
+    messages: ChatMessage[],
+    options?: CompletionOptions,
+  ): Promise<CompletionResult> {
+    const model = options?.model || this.defaultModel;
+    const prompt = this.formatPrompt(messages, options);
+
+    const prediction = await this.createPrediction(model, {
+      prompt,
+      max_tokens: options?.maxTokens || 4096,
+      temperature: options?.temperature,
+    });
+
+    const result = await this.pollPrediction(prediction.id);
+
+    if (result.status === 'failed') {
+      throw new Error(`Replicate prediction failed: ${result.error || 'unknown error'}`);
+    }
+
+    const output = Array.isArray(result.output)
+      ? result.output.join('')
+      : result.output || '';
+
+    return {
+      content: output,
+      usage: {
+        inputTokens: 0,
+        outputTokens: 0,
+      },
+      model,
+      finishReason: 'stop',
+    };
+  }
+
+  async *stream(
+    messages: ChatMessage[],
+    options?: CompletionOptions,
+  ): AsyncGenerator<StreamChunk, void, unknown> {
+    try {
+      const model = options?.model || this.defaultModel;
+      const prompt = this.formatPrompt(messages, options);
+
+      const response = await fetch(`${BASE_URL}/models/${model}/predictions`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Bearer ${this.apiToken}`,
+          Prefer: 'respond-async',
+        },
+        body: JSON.stringify({
+          input: {
+            prompt,
+            max_tokens: options?.maxTokens || 4096,
+            temperature: options?.temperature,
+          },
+          stream: true,
+        }),
+      });
+
+      if (!response.ok) {
+        throw new Error(`Replicate API error: ${response.status} ${response.statusText}`);
+      }
+
+      const prediction = (await response.json()) as ReplicatePrediction;
+      const streamUrl = `${BASE_URL}/predictions/${prediction.id}/stream`;
+
+      const streamResponse = await fetch(streamUrl, {
+        headers: { Authorization: `Bearer ${this.apiToken}`, Accept: 'text/event-stream' },
+      });
+
+      if (!streamResponse.ok || !streamResponse.body) {
+        const result = await this.pollPrediction(prediction.id);
+        const output = Array.isArray(result.output)
+          ? result.output.join('')
+          : result.output || '';
+        yield { type: 'text', content: output };
+        yield { type: 'done', usage: { inputTokens: 0, outputTokens: 0 } };
+        return;
+      }
+
+      const reader = streamResponse.body.getReader();
+      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) {
+          const trimmed = line.trim();
+          if (!trimmed || !trimmed.startsWith('data: ')) continue;
+          const data = trimmed.slice(6);
+          if (data === '[DONE]') continue;
+          yield { type: 'text', content: data };
+        }
+      }
+
+      yield { type: 'done', usage: { inputTokens: 0, outputTokens: 0 } };
+    } catch (error) {
+      yield {
+        type: 'error',
+        error: error instanceof Error ? error.message : 'Unknown error',
+      };
+    }
+  }
+
+  private async createPrediction(
+    model: string,
+    input: Record<string, unknown>,
+  ): Promise<ReplicatePrediction> {
+    const response = await fetch(`${BASE_URL}/models/${model}/predictions`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${this.apiToken}`,
+        Prefer: 'respond-async',
+      },
+      body: JSON.stringify({ input }),
+    });
+
+    if (!response.ok) {
+      throw new Error(`Replicate API error: ${response.status} ${response.statusText}`);
+    }
+
+    return (await response.json()) as ReplicatePrediction;
+  }
+
+  private async pollPrediction(id: string): Promise<ReplicatePrediction> {
+    while (true) {
+      const response = await fetch(`${BASE_URL}/predictions/${id}`, {
+        headers: { Authorization: `Bearer ${this.apiToken}` },
+      });
+
+      if (!response.ok) {
+        throw new Error(`Replicate API error: ${response.status} ${response.statusText}`);
+      }
+
+      const prediction = (await response.json()) as ReplicatePrediction;
+
+      if (prediction.status === 'succeeded' || prediction.status === 'failed' || prediction.status === 'canceled') {
+        return prediction;
+      }
+
+      await new Promise((resolve) => setTimeout(resolve, this.pollInterval));
+    }
+  }
+
+  private formatPrompt(messages: ChatMessage[], options?: CompletionOptions): string {
+    const parts: string[] = [];
+
+    if (options?.systemPrompt) {
+      parts.push(`<|begin_of_text|><|start_header_id|>system<|end_header_id|>\n\n${options.systemPrompt}<|eot_id|>`);
+    }
+
+    for (const msg of messages) {
+      parts.push(`<|start_header_id|>${msg.role}<|end_header_id|>\n\n${msg.content}<|eot_id|>`);
+    }
+
+    parts.push('<|start_header_id|>assistant<|end_header_id|>\n\n');
+
+    return parts.join('');
+  }
+}