overarch-linux-arm64 0.8.0

package/dist/src/providers/factory.js

@@ -0,0 +1,142 @@
+import { OpenAIProvider } from './openai.js';
+import { AnthropicProvider } from './anthropic.js';
+import { GeminiProvider } from './gemini.js';
+import { OpenRouterProvider } from './openrouter.js';
+import { CANONICAL_MODELS, SUPPORTED_PROVIDERS, normalizeModel } from './registry.js';
+export { CANONICAL_MODELS, SUPPORTED_PROVIDERS, normalizeModel };
+import { getApiKey } from '../config/index.js';
+export const MODEL_REGISTRY = CANONICAL_MODELS;
+export class OfflineProvider {
+    name = 'offline';
+    async complete(request) {
+        return {
+            content: 'Offline mode is currently active. Connect an AI provider with `/setup` or `/config provider` to enable AI completions.',
+            toolCalls: [],
+            finishReason: 'stop'
+        };
+    }
+    async *stream(request) {
+        yield {
+            type: 'text',
+            content: 'Offline mode is currently active. Connect an AI provider with `/setup` or `/config provider` to enable AI completions.'
+        };
+        yield { type: 'done' };
+    }
+}
+export function createProvider(providerName, config = {}) {
+    const normProvider = providerName.toLowerCase().trim();
+    if (normProvider === 'none' || normProvider === 'offline') {
+        return new OfflineProvider();
+    }
+    const apiKey = config.apiKey || getApiKey(normProvider);
+    if (!apiKey) {
+        throw new Error(`API key not found for provider: ${providerName}`);
+    }
+    switch (normProvider) {
+        case 'openai':
+            return new OpenAIProvider(apiKey, config.baseUrl);
+        case 'anthropic':
+            return new AnthropicProvider(apiKey, config.baseUrl);
+        case 'gemini':
+        case 'google':
+            return new GeminiProvider(apiKey, config.baseUrl);
+        case 'openrouter':
+            return new OpenRouterProvider(apiKey, config.baseUrl);
+        default:
+            // Generic OpenAI-compatible fallback (e.g. Ollama, Groq, DeepSeek, vLLM)
+            return new OpenAIProvider(apiKey, config.baseUrl, normProvider);
+    }
+}
+/**
+ * Resolves a raw model string, alias, or provider/model into a canonical structure.
+ */
+export function resolveModel(modelId, preferredProvider) {
+    return normalizeModel(modelId, preferredProvider);
+}
+export function listModels(providerFilter) {
+    if (!providerFilter) {
+        return CANONICAL_MODELS.filter(m => m.provider !== 'none');
+    }
+    return CANONICAL_MODELS.filter(m => m.provider.toLowerCase() === providerFilter.toLowerCase());
+}
+export function listProviders() {
+    return SUPPORTED_PROVIDERS;
+}
+/**
+ * Validates whether an API key is structurally and functionally plausible.
+ */
+export async function validateProviderKey(providerName, apiKey) {
+    const cleanKey = apiKey.trim();
+    if (!cleanKey) {
+        return { valid: false, error: 'Key cannot be empty' };
+    }
+    const norm = providerName.toLowerCase();
+    // Basic syntax/prefix heuristics
+    if (norm === 'anthropic' && !cleanKey.startsWith('sk-ant-') && cleanKey.length < 20) {
+        return { valid: false, error: 'Anthropic keys typically begin with sk-ant-' };
+    }
+    if (norm === 'openai' && !cleanKey.startsWith('sk-') && cleanKey.length < 20) {
+        return { valid: false, error: 'OpenAI keys typically begin with sk-' };
+    }
+    // Network verification probe
+    try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 6000);
+        if (norm === 'anthropic') {
+            const res = await fetch('https://api.anthropic.com/v1/models', {
+                headers: {
+                    'x-api-key': cleanKey,
+                    'anthropic-version': '2023-06-01'
+                },
+                signal: controller.signal
+            });
+            clearTimeout(timeout);
+            if (res.status === 401 || res.status === 403) {
+                return { valid: false, error: 'Authentication failed: Invalid Anthropic API key' };
+            }
+            return { valid: true };
+        }
+        if (norm === 'openai') {
+            const res = await fetch('https://api.openai.com/v1/models', {
+                headers: { 'Authorization': `Bearer ${cleanKey}` },
+                signal: controller.signal
+            });
+            clearTimeout(timeout);
+            if (res.status === 401 || res.status === 403) {
+                return { valid: false, error: 'Authentication failed: Invalid OpenAI API key' };
+            }
+            return { valid: true };
+        }
+        if (norm === 'gemini' || norm === 'google') {
+            const res = await fetch(`https://generativelanguage.googleapis.com/v1beta/models?key=${cleanKey}`, {
+                signal: controller.signal
+            });
+            clearTimeout(timeout);
+            if (res.status === 400 || res.status === 401 || res.status === 403) {
+                return { valid: false, error: 'Authentication failed: Invalid Gemini API key' };
+            }
+            return { valid: true };
+        }
+        if (norm === 'openrouter') {
+            const res = await fetch('https://openrouter.ai/api/v1/auth/key', {
+                headers: { 'Authorization': `Bearer ${cleanKey}` },
+                signal: controller.signal
+            });
+            clearTimeout(timeout);
+            if (res.status === 401 || res.status === 403) {
+                return { valid: false, error: 'Authentication failed: Invalid OpenRouter API key' };
+            }
+            return { valid: true };
+        }
+        clearTimeout(timeout);
+        return { valid: true };
+    }
+    catch (err) {
+        if (err.name === 'AbortError') {
+            // If network times out, don't block user if key looks well-formed
+            return { valid: true };
+        }
+        // Network unreachable or offline during probe
+        return { valid: true };
+    }
+}

package/dist/src/providers/gemini.d.ts

@@ -0,0 +1,10 @@
+import { BaseProvider } from './base.js';
+import { CompletionRequest, CompletionResponse, StreamChunk } from './types.js';
+export declare class GeminiProvider extends BaseProvider {
+    constructor(apiKey: string, baseUrl?: string);
+    protected headers(): Record<string, string>;
+    protected getEndpoint(request: CompletionRequest): string;
+    protected buildRequestBody(request: CompletionRequest): Record<string, unknown>;
+    protected parseResponse(body: any): CompletionResponse;
+    protected parseStreamChunk(dataStr: string, buffer: Record<string, unknown>): StreamChunk | null;
+}

package/dist/src/providers/gemini.js

@@ -0,0 +1,97 @@
+import { BaseProvider } from './base.js';
+export class GeminiProvider extends BaseProvider {
+    constructor(apiKey, baseUrl = 'https://generativelanguage.googleapis.com/v1beta') {
+        super('gemini', apiKey, baseUrl);
+    }
+    headers() {
+        return {
+            'Content-Type': 'application/json'
+        };
+    }
+    getEndpoint(request) {
+        const base = this.baseUrl.replace(/\/$/, '');
+        if (request.stream) {
+            return `${base}/models/${request.model}:streamGenerateContent?alt=sse&key=${this.apiKey}`;
+        }
+        return `${base}/models/${request.model}:generateContent?key=${this.apiKey}`;
+    }
+    buildRequestBody(request) {
+        const contents = request.messages.map(m => {
+            // All roles should be user-facing except assistant which maps to model.
+            // Gemini API does not support a 'function' role; map tool to user.
+            let role = 'user';
+            if (m.role === 'assistant')
+                role = 'model';
+            // NOTE: do NOT map tool role to 'function'.
+            return {
+                role,
+                parts: [{ text: m.content || '' }]
+            };
+        });
+        const tools = request.tools ? [{
+                functionDeclarations: request.tools.map(t => ({
+                    name: t.function.name,
+                    description: t.function.description,
+                    parameters: t.function.parameters
+                }))
+            }] : undefined;
+        return {
+            contents,
+            ...(tools ? { tools } : {}),
+            generationConfig: {
+                ...(request.temperature !== undefined ? { temperature: request.temperature } : {}),
+                ...(request.maxTokens !== undefined ? { maxOutputTokens: request.maxTokens } : {})
+            }
+        };
+    }
+    parseResponse(body) {
+        const candidate = body.candidates?.[0];
+        const parts = candidate?.content?.parts || [];
+        let content = '';
+        const toolCalls = [];
+        for (const part of parts) {
+            if (part.text)
+                content += part.text;
+            if (part.functionCall) {
+                toolCalls.push({
+                    id: `call_${Math.random().toString(36).substring(7)}`,
+                    name: part.functionCall.name,
+                    arguments: part.functionCall.args
+                });
+            }
+        }
+        return {
+            content,
+            toolCalls,
+            finishReason: candidate?.finishReason === 'STOP' ? 'stop' : (toolCalls.length > 0 ? 'tool_calls' : 'stop')
+        };
+    }
+    parseStreamChunk(dataStr, buffer) {
+        try {
+            const data = JSON.parse(dataStr);
+            const candidate = data.candidates?.[0];
+            if (!candidate)
+                return null;
+            const parts = candidate.content?.parts || [];
+            for (const part of parts) {
+                if (part.text) {
+                    return { type: 'text', content: part.text };
+                }
+                if (part.functionCall) {
+                    return {
+                        type: 'tool_call_start',
+                        toolCall: {
+                            id: `call_${Math.random().toString(36).substring(7)}`,
+                            name: part.functionCall.name,
+                            arguments: JSON.stringify(part.functionCall.args)
+                        }
+                    };
+                }
+            }
+            return null;
+        }
+        catch (e) {
+            return null;
+        }
+    }
+}

package/dist/src/providers/openai.d.ts

@@ -0,0 +1,9 @@
+import { BaseProvider } from './base.js';
+import { CompletionRequest, CompletionResponse, StreamChunk } from './types.js';
+export declare class OpenAIProvider extends BaseProvider {
+    constructor(apiKey: string, baseUrl?: string, name?: string);
+    protected getEndpoint(request: CompletionRequest): string;
+    protected buildRequestBody(request: CompletionRequest): Record<string, unknown>;
+    protected parseResponse(body: any): CompletionResponse;
+    protected parseStreamChunk(dataStr: string, buffer: Record<string, unknown>): StreamChunk | null;
+}

package/dist/src/providers/openai.js

@@ -0,0 +1,85 @@
+import { BaseProvider } from './base.js';
+import { formatForOpenAI } from './validator.js';
+export class OpenAIProvider extends BaseProvider {
+    constructor(apiKey, baseUrl = 'https://api.openai.com/v1', name = 'openai') {
+        super(name, apiKey, baseUrl);
+    }
+    getEndpoint(request) {
+        return `${this.baseUrl.replace(/\/$/, '')}/chat/completions`;
+    }
+    buildRequestBody(request) {
+        return {
+            model: request.model,
+            messages: formatForOpenAI(request.messages),
+            ...(request.tools && request.tools.length > 0 ? { tools: request.tools } : {}),
+            ...(request.temperature !== undefined ? { temperature: request.temperature } : {}),
+            ...(request.maxTokens !== undefined ? { max_tokens: request.maxTokens } : {}),
+            stream: request.stream
+        };
+    }
+    parseResponse(body) {
+        const choice = body.choices?.[0];
+        const message = choice?.message || {};
+        return {
+            content: message.content || '',
+            toolCalls: (message.tool_calls || []).map((tc) => {
+                let parsedArgs = tc.function?.arguments;
+                if (typeof parsedArgs === 'string') {
+                    try {
+                        parsedArgs = JSON.parse(parsedArgs);
+                    }
+                    catch {
+                        parsedArgs = {};
+                    }
+                }
+                return {
+                    id: tc.id,
+                    name: tc.function?.name,
+                    arguments: parsedArgs || {}
+                };
+            }),
+            usage: body.usage ? {
+                promptTokens: body.usage.prompt_tokens,
+                completionTokens: body.usage.completion_tokens,
+                totalTokens: body.usage.total_tokens
+            } : undefined,
+            finishReason: choice?.finish_reason || 'stop'
+        };
+    }
+    parseStreamChunk(dataStr, buffer) {
+        try {
+            const data = JSON.parse(dataStr);
+            const choice = data.choices?.[0];
+            const delta = choice?.delta || {};
+            if (delta.content) {
+                return { type: 'text', content: delta.content };
+            }
+            if (delta.tool_calls) {
+                const tcDelta = delta.tool_calls[0];
+                if (tcDelta.id) {
+                    buffer.toolCallArgs = '';
+                    return {
+                        type: 'tool_call_start',
+                        toolCall: {
+                            id: tcDelta.id,
+                            name: tcDelta.function?.name
+                        }
+                    };
+                }
+                else if (tcDelta.function?.arguments) {
+                    buffer.toolCallArgs = (buffer.toolCallArgs || '') + tcDelta.function.arguments;
+                    return {
+                        type: 'tool_call_args',
+                        toolCall: {
+                            arguments: tcDelta.function.arguments
+                        }
+                    };
+                }
+            }
+            return null;
+        }
+        catch (e) {
+            return null;
+        }
+    }
+}

package/dist/src/providers/openrouter.d.ts

@@ -0,0 +1,5 @@
+import { OpenAIProvider } from './openai.js';
+export declare class OpenRouterProvider extends OpenAIProvider {
+    constructor(apiKey: string, baseUrl?: string);
+    protected headers(): Record<string, string>;
+}

package/dist/src/providers/openrouter.js

@@ -0,0 +1,14 @@
+import { OpenAIProvider } from './openai.js';
+export class OpenRouterProvider extends OpenAIProvider {
+    constructor(apiKey, baseUrl = 'https://openrouter.ai/api/v1') {
+        super(apiKey, baseUrl, 'openrouter');
+    }
+    headers() {
+        return {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${this.apiKey}`,
+            'HTTP-Referer': 'https://github.com/overarch/cli',
+            'X-Title': 'Overarch CLI'
+        };
+    }
+}

package/dist/src/providers/registry.d.ts

@@ -0,0 +1,19 @@
+import { ModelInfo } from './types.js';
+export interface ProviderDefinition {
+    id: string;
+    name: string;
+    envVar: string;
+    defaultBaseUrl: string;
+    recommendedModels: string[];
+}
+export declare const SUPPORTED_PROVIDERS: ProviderDefinition[];
+export declare const CANONICAL_MODELS: ModelInfo[];
+export declare const MODEL_ALIASES: Record<string, string>;
+/**
+ * Normalizes any model ID or alias into a canonical { provider, model, displayName } structure.
+ */
+export declare function normalizeModel(input: string, preferredProvider?: string): {
+    provider: string;
+    model: string;
+    displayName: string;
+} | undefined;

package/dist/src/providers/registry.js

@@ -0,0 +1,209 @@
+export const SUPPORTED_PROVIDERS = [
+    {
+        id: 'anthropic',
+        name: 'Anthropic Claude',
+        envVar: 'ANTHROPIC_API_KEY',
+        defaultBaseUrl: 'https://api.anthropic.com/v1',
+        recommendedModels: [
+            'claude-3-5-sonnet-20241022',
+            'claude-opus-4-6',
+            'claude-sonnet-4-20250514',
+            'claude-3-5-haiku-20241022'
+        ]
+    },
+    {
+        id: 'openai',
+        name: 'OpenAI',
+        envVar: 'OPENAI_API_KEY',
+        defaultBaseUrl: 'https://api.openai.com/v1',
+        recommendedModels: [
+            'gpt-4o',
+            'gpt-4o-mini',
+            'o3-mini',
+            'o1'
+        ]
+    },
+    {
+        id: 'gemini',
+        name: 'Google Gemini',
+        envVar: 'GEMINI_API_KEY',
+        defaultBaseUrl: 'https://generativelanguage.googleapis.com/v1beta',
+        recommendedModels: [
+            'gemini-2.5-flash',
+            'gemini-2.5-pro',
+            'gemini-2.0-flash-exp',
+            'gemini-1.5-pro'
+        ]
+    },
+    {
+        id: 'openrouter',
+        name: 'OpenRouter (Multi-Provider)',
+        envVar: 'OPENROUTER_API_KEY',
+        defaultBaseUrl: 'https://openrouter.ai/api/v1',
+        recommendedModels: [
+            'openrouter/auto',
+            'anthropic/claude-3.5-sonnet',
+            'openai/gpt-4o',
+            'deepseek/deepseek-chat',
+            'google/gemini-2.0-flash-001',
+            'meta-llama/llama-3.3-70b-instruct'
+        ]
+    }
+];
+export const CANONICAL_MODELS = [
+    // Anthropic
+    { id: 'claude-3-5-sonnet-20241022', name: 'Claude 3.5 Sonnet', provider: 'anthropic', contextWindow: 200000, supportsTools: true },
+    { id: 'claude-opus-4-6', name: 'Claude Opus 4.6', provider: 'anthropic', contextWindow: 200000, supportsTools: true },
+    { id: 'claude-sonnet-4-20250514', name: 'Claude 4 Sonnet', provider: 'anthropic', contextWindow: 200000, supportsTools: true },
+    { id: 'claude-3-5-haiku-20241022', name: 'Claude 3.5 Haiku', provider: 'anthropic', contextWindow: 200000, supportsTools: true },
+    // OpenAI
+    { id: 'gpt-4o', name: 'GPT-4o', provider: 'openai', contextWindow: 128000, supportsTools: true },
+    { id: 'gpt-4o-mini', name: 'GPT-4o Mini', provider: 'openai', contextWindow: 128000, supportsTools: true },
+    { id: 'o3-mini', name: 'o3-mini', provider: 'openai', contextWindow: 200000, supportsTools: true },
+    { id: 'o1', name: 'o1', provider: 'openai', contextWindow: 200000, supportsTools: false },
+    // Gemini
+    { id: 'gemini-2.5-flash', name: 'Gemini 2.5 Flash', provider: 'gemini', contextWindow: 1048576, supportsTools: true },
+    { id: 'gemini-2.5-pro', name: 'Gemini 2.5 Pro', provider: 'gemini', contextWindow: 2097152, supportsTools: true },
+    { id: 'gemini-2.0-flash-exp', name: 'Gemini 2.0 Flash', provider: 'gemini', contextWindow: 1048576, supportsTools: true },
+    { id: 'gemini-1.5-pro', name: 'Gemini 1.5 Pro', provider: 'gemini', contextWindow: 2097152, supportsTools: true },
+    // OpenRouter
+    { id: 'openrouter/auto', name: 'OpenRouter Auto (Best)', provider: 'openrouter', contextWindow: 128000, supportsTools: true },
+    { id: 'anthropic/claude-3.5-sonnet', name: 'Claude 3.5 Sonnet (OpenRouter)', provider: 'openrouter', contextWindow: 200000, supportsTools: true },
+    { id: 'openai/gpt-4o', name: 'GPT-4o (OpenRouter)', provider: 'openrouter', contextWindow: 128000, supportsTools: true },
+    { id: 'deepseek/deepseek-chat', name: 'DeepSeek V3 (OpenRouter)', provider: 'openrouter', contextWindow: 128000, supportsTools: true },
+    { id: 'google/gemini-2.0-flash-001', name: 'Gemini 2.0 Flash (OpenRouter)', provider: 'openrouter', contextWindow: 1048576, supportsTools: true },
+    { id: 'meta-llama/llama-3.3-70b-instruct', name: 'Llama 3.3 70B (OpenRouter)', provider: 'openrouter', contextWindow: 128000, supportsTools: true },
+    // Offline
+    { id: 'offline', name: 'Offline (No AI)', provider: 'none', contextWindow: 0, supportsTools: true }
+];
+export const MODEL_ALIASES = {
+    // Common Anthropic aliases
+    'claude-3-5-sonnet': 'claude-3-5-sonnet-20241022',
+    'claude-sonnet': 'claude-3-5-sonnet-20241022',
+    'sonnet': 'claude-3-5-sonnet-20241022',
+    'claude-haiku': 'claude-3-5-haiku-20241022',
+    'haiku': 'claude-3-5-haiku-20241022',
+    'claude-opus': 'claude-opus-4-6',
+    'opus': 'claude-opus-4-6',
+    // Common OpenAI aliases
+    '4o': 'gpt-4o',
+    '4o-mini': 'gpt-4o-mini',
+    // Common Gemini aliases
+    'gemini-flash': 'gemini-2.5-flash',
+    'gemini-pro': 'gemini-2.5-pro',
+    // Common OpenRouter aliases
+    'openrouter': 'openrouter/auto',
+    'auto': 'openrouter/auto',
+    // Offline
+    'none': 'offline'
+};
+/**
+ * Normalizes any model ID or alias into a canonical { provider, model, displayName } structure.
+ */
+export function normalizeModel(input, preferredProvider) {
+    const trimmed = input.trim();
+    if (!trimmed)
+        return undefined;
+    // 1. Direct offline check
+    if (trimmed.toLowerCase() === 'none' || trimmed.toLowerCase() === 'offline') {
+        return { provider: 'none', model: 'offline', displayName: 'Offline Mode' };
+    }
+    // 2. Check alias map first
+    const aliasTarget = MODEL_ALIASES[trimmed.toLowerCase()];
+    const lookupId = aliasTarget || trimmed;
+    // 3. Match in canonical models
+    const canonical = CANONICAL_MODELS.find(m => {
+        if (m.id.toLowerCase() !== lookupId.toLowerCase())
+            return false;
+        if (m.provider === 'openrouter') {
+            return preferredProvider === 'openrouter' || lookupId.toLowerCase().startsWith('openrouter/');
+        }
+        return true;
+    });
+    if (canonical) {
+        return {
+            provider: canonical.provider,
+            model: canonical.id,
+            displayName: canonical.name
+        };
+    }
+    // 4. Handle openrouter/ prefix explicitly
+    if (lookupId.toLowerCase().startsWith('openrouter/')) {
+        const rawModel = lookupId.slice('openrouter/'.length);
+        return {
+            provider: 'openrouter',
+            model: lookupId,
+            displayName: `OpenRouter (${rawModel || 'auto'})`
+        };
+    }
+    // If preferredProvider is explicitly openrouter, preserve model string as-is for OpenRouter
+    if (preferredProvider === 'openrouter') {
+        return {
+            provider: 'openrouter',
+            model: lookupId,
+            displayName: `OpenRouter (${lookupId})`
+        };
+    }
+    // 5. Handle provider/model syntax
+    if (lookupId.includes('/')) {
+        const slashIdx = lookupId.indexOf('/');
+        const firstPart = lookupId.slice(0, slashIdx).toLowerCase();
+        const rest = lookupId.slice(slashIdx + 1);
+        const vendorEnvMap = {
+            anthropic: 'ANTHROPIC_API_KEY',
+            openai: 'OPENAI_API_KEY',
+            gemini: 'GEMINI_API_KEY',
+            google: 'GEMINI_API_KEY'
+        };
+        // If OpenRouter key is available and direct provider key is not, route to openrouter
+        const directEnv = vendorEnvMap[firstPart];
+        if (process.env.OPENROUTER_API_KEY && directEnv && !process.env[directEnv]) {
+            return {
+                provider: 'openrouter',
+                model: lookupId,
+                displayName: `OpenRouter (${lookupId})`
+            };
+        }
+        const knownProviders = ['anthropic', 'openai', 'gemini', 'google'];
+        if (knownProviders.includes(firstPart)) {
+            const canonicalInner = CANONICAL_MODELS.find(m => m.id.toLowerCase() === rest.toLowerCase() && m.provider === firstPart);
+            return {
+                provider: firstPart === 'google' ? 'gemini' : firstPart,
+                model: rest,
+                displayName: canonicalInner ? canonicalInner.name : `${firstPart.toUpperCase()} ${rest}`
+            };
+        }
+        // Any other vendor/model (e.g. meta-llama/..., mistralai/..., nex-agi/...)
+        if (process.env.OPENROUTER_API_KEY) {
+            return {
+                provider: 'openrouter',
+                model: lookupId,
+                displayName: `OpenRouter (${lookupId})`
+            };
+        }
+        return {
+            provider: firstPart,
+            model: rest,
+            displayName: `${firstPart.toUpperCase()} ${rest}`
+        };
+    }
+    // 6. Intelligent prefix inference
+    if (lookupId.startsWith('claude-')) {
+        return { provider: 'anthropic', model: lookupId, displayName: `Claude (${lookupId})` };
+    }
+    if (lookupId.startsWith('gpt-') || lookupId.startsWith('o1') || lookupId.startsWith('o3')) {
+        return { provider: 'openai', model: lookupId, displayName: `OpenAI (${lookupId})` };
+    }
+    if (lookupId.startsWith('gemini-')) {
+        return { provider: 'gemini', model: lookupId, displayName: `Gemini (${lookupId})` };
+    }
+    // If preferredProvider is set, associate with that provider
+    if (preferredProvider) {
+        return {
+            provider: preferredProvider,
+            model: lookupId,
+            displayName: `${preferredProvider.toUpperCase()} (${lookupId})`
+        };
+    }
+    return undefined;
+}

package/dist/src/providers/types.d.ts

@@ -0,0 +1,59 @@
+export interface Message {
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: string;
+    toolCallId?: string;
+    toolCalls?: ToolCall[];
+}
+export interface ToolCall {
+    id: string;
+    name: string;
+    arguments: Record<string, unknown>;
+}
+export interface ToolSchema {
+    type: 'function';
+    function: {
+        name: string;
+        description: string;
+        parameters: {
+            type: 'object';
+            properties: Record<string, unknown>;
+            required: string[];
+        };
+    };
+}
+export interface CompletionRequest {
+    messages: Message[];
+    model: string;
+    tools?: ToolSchema[];
+    temperature?: number;
+    maxTokens?: number;
+    stream?: boolean;
+}
+export interface CompletionResponse {
+    content: string;
+    toolCalls: ToolCall[];
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+    finishReason: 'stop' | 'tool_calls' | 'length' | 'error';
+}
+export interface StreamChunk {
+    type: 'text' | 'tool_call_start' | 'tool_call_args' | 'done' | 'error';
+    content?: string;
+    toolCall?: Partial<ToolCall>;
+    usage?: CompletionResponse['usage'];
+}
+export interface LLMProvider {
+    name: string;
+    complete(request: CompletionRequest): Promise<CompletionResponse>;
+    stream(request: CompletionRequest): AsyncIterable<StreamChunk>;
+}
+export interface ModelInfo {
+    id: string;
+    name: string;
+    provider: string;
+    contextWindow: number;
+    supportsTools: boolean;
+}

package/dist/src/providers/types.js

@@ -0,0 +1 @@
+export {};