codebot-ai 1.0.0

package/dist/providers/anthropic.js

@@ -0,0 +1,288 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnthropicProvider = void 0;
+class AnthropicProvider {
+    name;
+    config;
+    constructor(config) {
+        this.config = config;
+        this.name = config.model;
+    }
+    async *chat(messages, tools) {
+        const { systemPrompt, apiMessages } = this.convertMessages(messages);
+        const body = {
+            model: this.config.model,
+            messages: apiMessages,
+            max_tokens: 8192,
+            stream: true,
+        };
+        if (systemPrompt) {
+            body.system = systemPrompt;
+        }
+        if (tools?.length) {
+            body.tools = tools.map(t => ({
+                name: t.function.name,
+                description: t.function.description,
+                input_schema: t.function.parameters,
+            }));
+        }
+        const baseUrl = this.config.baseUrl.replace(/\/+$/, '');
+        let response;
+        try {
+            response = await fetch(`${baseUrl}/v1/messages`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-api-key': this.config.apiKey || '',
+                    'anthropic-version': '2023-06-01',
+                },
+                body: JSON.stringify(body),
+            });
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            yield { type: 'error', error: `Connection failed: ${msg}` };
+            return;
+        }
+        if (!response.ok) {
+            const text = await response.text();
+            yield { type: 'error', error: `Anthropic error ${response.status}: ${text}` };
+            return;
+        }
+        if (!response.body) {
+            yield { type: 'error', error: 'No response body from Anthropic' };
+            return;
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        // Track current content blocks
+        const toolBlocks = new Map();
+        let currentBlockIndex = -1;
+        let currentBlockType = '';
+        try {
+            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() || '';
+                let currentEvent = '';
+                for (const line of lines) {
+                    const trimmed = line.trim();
+                    if (trimmed.startsWith('event: ')) {
+                        currentEvent = trimmed.slice(7);
+                        continue;
+                    }
+                    if (!trimmed.startsWith('data: '))
+                        continue;
+                    const dataStr = trimmed.slice(6);
+                    if (!dataStr || dataStr === '[DONE]')
+                        continue;
+                    let data;
+                    try {
+                        data = JSON.parse(dataStr);
+                    }
+                    catch {
+                        continue;
+                    }
+                    switch (currentEvent) {
+                        case 'content_block_start': {
+                            const block = data.content_block;
+                            currentBlockIndex = data.index;
+                            currentBlockType = block?.type || '';
+                            if (currentBlockType === 'tool_use') {
+                                toolBlocks.set(currentBlockIndex, {
+                                    id: block.id,
+                                    name: block.name,
+                                    input: '',
+                                });
+                                yield {
+                                    type: 'tool_call_start',
+                                    toolCall: {
+                                        id: block.id,
+                                        type: 'function',
+                                        function: { name: block.name, arguments: '' },
+                                    },
+                                };
+                            }
+                            else if (currentBlockType === 'thinking') {
+                                yield { type: 'thinking', text: '' };
+                            }
+                            break;
+                        }
+                        case 'content_block_delta': {
+                            const delta = data.delta;
+                            const deltaType = delta?.type;
+                            if (deltaType === 'text_delta') {
+                                yield { type: 'text', text: delta.text };
+                            }
+                            else if (deltaType === 'input_json_delta') {
+                                const partial = delta.partial_json;
+                                const block = toolBlocks.get(currentBlockIndex);
+                                if (block) {
+                                    block.input += partial;
+                                }
+                                yield { type: 'tool_call_delta', text: partial };
+                            }
+                            else if (deltaType === 'thinking_delta') {
+                                yield { type: 'thinking', text: delta.thinking };
+                            }
+                            break;
+                        }
+                        case 'content_block_stop': {
+                            if (currentBlockType === 'thinking') {
+                                yield { type: 'thinking', text: '\n' };
+                            }
+                            break;
+                        }
+                        case 'message_start': {
+                            const message = data.message;
+                            if (message?.usage) {
+                                const usage = message.usage;
+                                yield {
+                                    type: 'usage',
+                                    usage: {
+                                        inputTokens: usage.input_tokens,
+                                        outputTokens: usage.output_tokens,
+                                    },
+                                };
+                            }
+                            break;
+                        }
+                        case 'message_delta': {
+                            // Emit usage from message_delta
+                            const deltaUsage = data.usage || {};
+                            if (deltaUsage.output_tokens) {
+                                yield {
+                                    type: 'usage',
+                                    usage: { outputTokens: deltaUsage.output_tokens },
+                                };
+                            }
+                            // Message is ending — emit all accumulated tool calls
+                            for (const [, block] of toolBlocks) {
+                                yield {
+                                    type: 'tool_call_end',
+                                    toolCall: {
+                                        id: block.id,
+                                        type: 'function',
+                                        function: { name: block.name, arguments: block.input },
+                                    },
+                                };
+                            }
+                            break;
+                        }
+                        case 'message_stop': {
+                            yield { type: 'done' };
+                            return;
+                        }
+                        case 'error': {
+                            const error = data.error;
+                            yield { type: 'error', error: `Anthropic: ${error?.message || 'Unknown error'}` };
+                            return;
+                        }
+                    }
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+        // Emit remaining tool calls if stream ended without message_delta
+        for (const [, block] of toolBlocks) {
+            yield {
+                type: 'tool_call_end',
+                toolCall: {
+                    id: block.id,
+                    type: 'function',
+                    function: { name: block.name, arguments: block.input },
+                },
+            };
+        }
+        yield { type: 'done' };
+    }
+    convertMessages(messages) {
+        let systemPrompt = '';
+        const apiMessages = [];
+        for (const msg of messages) {
+            if (msg.role === 'system') {
+                systemPrompt += (systemPrompt ? '\n\n' : '') + msg.content;
+                continue;
+            }
+            if (msg.role === 'assistant') {
+                const content = [];
+                if (msg.content) {
+                    content.push({ type: 'text', text: msg.content });
+                }
+                if (msg.tool_calls) {
+                    for (const tc of msg.tool_calls) {
+                        let input;
+                        try {
+                            input = JSON.parse(tc.function.arguments);
+                        }
+                        catch {
+                            input = {};
+                        }
+                        content.push({
+                            type: 'tool_use',
+                            id: tc.id,
+                            name: tc.function.name,
+                            input,
+                        });
+                    }
+                }
+                apiMessages.push({
+                    role: 'assistant',
+                    content: content.length === 1 && content[0].type === 'text'
+                        ? content[0].text
+                        : content,
+                });
+                continue;
+            }
+            if (msg.role === 'tool') {
+                // Tool results in Anthropic go as user messages with tool_result content
+                const lastMsg = apiMessages[apiMessages.length - 1];
+                if (lastMsg?.role === 'user' && Array.isArray(lastMsg.content)) {
+                    lastMsg.content.push({
+                        type: 'tool_result',
+                        tool_use_id: msg.tool_call_id,
+                        content: msg.content,
+                    });
+                }
+                else {
+                    apiMessages.push({
+                        role: 'user',
+                        content: [{
+                                type: 'tool_result',
+                                tool_use_id: msg.tool_call_id,
+                                content: msg.content,
+                            }],
+                    });
+                }
+                continue;
+            }
+            // Regular user message
+            apiMessages.push({ role: 'user', content: msg.content });
+        }
+        // Anthropic requires alternating user/assistant. Merge consecutive same-role messages.
+        const merged = [];
+        for (const msg of apiMessages) {
+            const last = merged[merged.length - 1];
+            if (last && last.role === msg.role) {
+                // Merge content
+                const lastContent = typeof last.content === 'string' ? last.content : '';
+                const msgContent = typeof msg.content === 'string' ? msg.content : '';
+                if (typeof last.content === 'string' && typeof msg.content === 'string') {
+                    last.content = lastContent + '\n' + msgContent;
+                }
+            }
+            else {
+                merged.push(msg);
+            }
+        }
+        return { systemPrompt, apiMessages: merged };
+    }
+}
+exports.AnthropicProvider = AnthropicProvider;
+//# sourceMappingURL=anthropic.js.map

package/dist/providers/index.d.ts

@@ -0,0 +1,5 @@
+export { OpenAIProvider } from './openai';
+export { AnthropicProvider } from './anthropic';
+export { MODEL_REGISTRY, PROVIDER_DEFAULTS, getModelInfo, detectProvider } from './registry';
+export type { ModelInfo } from './registry';
+//# sourceMappingURL=index.d.ts.map

package/dist/providers/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectProvider = exports.getModelInfo = exports.PROVIDER_DEFAULTS = exports.MODEL_REGISTRY = exports.AnthropicProvider = exports.OpenAIProvider = void 0;
+var openai_1 = require("./openai");
+Object.defineProperty(exports, "OpenAIProvider", { enumerable: true, get: function () { return openai_1.OpenAIProvider; } });
+var anthropic_1 = require("./anthropic");
+Object.defineProperty(exports, "AnthropicProvider", { enumerable: true, get: function () { return anthropic_1.AnthropicProvider; } });
+var registry_1 = require("./registry");
+Object.defineProperty(exports, "MODEL_REGISTRY", { enumerable: true, get: function () { return registry_1.MODEL_REGISTRY; } });
+Object.defineProperty(exports, "PROVIDER_DEFAULTS", { enumerable: true, get: function () { return registry_1.PROVIDER_DEFAULTS; } });
+Object.defineProperty(exports, "getModelInfo", { enumerable: true, get: function () { return registry_1.getModelInfo; } });
+Object.defineProperty(exports, "detectProvider", { enumerable: true, get: function () { return registry_1.detectProvider; } });
+//# sourceMappingURL=index.js.map

package/dist/providers/openai.d.ts

@@ -0,0 +1,11 @@
+import { LLMProvider, Message, ToolSchema, StreamEvent, ProviderConfig } from '../types';
+export declare class OpenAIProvider implements LLMProvider {
+    name: string;
+    private config;
+    private supportsTools;
+    constructor(config: ProviderConfig);
+    chat(messages: Message[], tools?: ToolSchema[]): AsyncGenerator<StreamEvent>;
+    listModels(): Promise<string[]>;
+    private formatMessage;
+}
+//# sourceMappingURL=openai.d.ts.map

package/dist/providers/openai.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIProvider = void 0;
+const registry_1 = require("./registry");
+class OpenAIProvider {
+    name;
+    config;
+    supportsTools;
+    constructor(config) {
+        this.config = config;
+        this.name = config.model;
+        this.supportsTools = (0, registry_1.getModelInfo)(config.model).supportsToolCalling;
+    }
+    async *chat(messages, tools) {
+        const body = {
+            model: this.config.model,
+            messages: messages.map(m => this.formatMessage(m)),
+            stream: true,
+        };
+        if (tools?.length && this.supportsTools) {
+            body.tools = tools;
+        }
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        if (this.config.apiKey) {
+            headers['Authorization'] = `Bearer ${this.config.apiKey}`;
+        }
+        let response;
+        try {
+            response = await fetch(`${this.config.baseUrl}/v1/chat/completions`, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify(body),
+            });
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            yield { type: 'error', error: `Connection failed: ${msg}. Is your LLM server running?` };
+            return;
+        }
+        if (!response.ok) {
+            const text = await response.text();
+            yield { type: 'error', error: `LLM error ${response.status}: ${text}` };
+            return;
+        }
+        if (!response.body) {
+            yield { type: 'error', error: 'No response body from LLM' };
+            return;
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        const toolCalls = new Map();
+        try {
+            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;
+                    if (trimmed === 'data: [DONE]') {
+                        for (const [, tc] of toolCalls) {
+                            yield {
+                                type: 'tool_call_end',
+                                toolCall: {
+                                    id: tc.id,
+                                    type: 'function',
+                                    function: { name: tc.name, arguments: tc.arguments },
+                                },
+                            };
+                        }
+                        yield { type: 'done' };
+                        return;
+                    }
+                    try {
+                        const data = JSON.parse(trimmed.slice(6));
+                        const delta = data.choices?.[0]?.delta;
+                        if (!delta)
+                            continue;
+                        if (delta.content) {
+                            yield { type: 'text', text: delta.content };
+                        }
+                        if (delta.tool_calls) {
+                            for (const tc of delta.tool_calls) {
+                                const idx = tc.index ?? 0;
+                                if (!toolCalls.has(idx)) {
+                                    toolCalls.set(idx, {
+                                        id: tc.id || `call_${idx}`,
+                                        name: tc.function?.name || '',
+                                        arguments: '',
+                                    });
+                                    if (tc.function?.name) {
+                                        yield {
+                                            type: 'tool_call_start',
+                                            toolCall: {
+                                                id: tc.id,
+                                                type: 'function',
+                                                function: { name: tc.function.name, arguments: '' },
+                                            },
+                                        };
+                                    }
+                                }
+                                const entry = toolCalls.get(idx);
+                                if (tc.function?.name && !entry.name) {
+                                    entry.name = tc.function.name;
+                                }
+                                if (tc.function?.arguments) {
+                                    entry.arguments += tc.function.arguments;
+                                    yield { type: 'tool_call_delta', text: tc.function.arguments };
+                                }
+                            }
+                        }
+                    }
+                    catch {
+                        // Skip malformed SSE lines
+                    }
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+        // If we reach here without [DONE], emit remaining tool calls
+        for (const [, tc] of toolCalls) {
+            yield {
+                type: 'tool_call_end',
+                toolCall: {
+                    id: tc.id,
+                    type: 'function',
+                    function: { name: tc.name, arguments: tc.arguments },
+                },
+            };
+        }
+        yield { type: 'done' };
+    }
+    async listModels() {
+        try {
+            const headers = {};
+            if (this.config.apiKey) {
+                headers['Authorization'] = `Bearer ${this.config.apiKey}`;
+            }
+            const res = await fetch(`${this.config.baseUrl}/v1/models`, {
+                headers,
+                signal: AbortSignal.timeout(5000),
+            });
+            if (!res.ok)
+                return [];
+            const data = await res.json();
+            return (data.data || []).map(m => m.id);
+        }
+        catch {
+            return [];
+        }
+    }
+    formatMessage(msg) {
+        const formatted = { role: msg.role, content: msg.content };
+        if (msg.tool_calls)
+            formatted.tool_calls = msg.tool_calls;
+        if (msg.tool_call_id)
+            formatted.tool_call_id = msg.tool_call_id;
+        if (msg.name)
+            formatted.name = msg.name;
+        return formatted;
+    }
+}
+exports.OpenAIProvider = OpenAIProvider;
+//# sourceMappingURL=openai.js.map

package/dist/providers/registry.d.ts

@@ -0,0 +1,15 @@
+export interface ModelInfo {
+    contextWindow: number;
+    supportsToolCalling: boolean;
+    provider?: string;
+}
+/** Default base URLs for cloud providers */
+export declare const PROVIDER_DEFAULTS: Record<string, {
+    baseUrl: string;
+    envKey: string;
+}>;
+export declare const MODEL_REGISTRY: Record<string, ModelInfo>;
+export declare function getModelInfo(model: string): ModelInfo;
+/** Detect provider from model name */
+export declare function detectProvider(model: string): string | undefined;
+//# sourceMappingURL=registry.d.ts.map

package/dist/providers/registry.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MODEL_REGISTRY = exports.PROVIDER_DEFAULTS = void 0;
+exports.getModelInfo = getModelInfo;
+exports.detectProvider = detectProvider;
+/** Default base URLs for cloud providers */
+exports.PROVIDER_DEFAULTS = {
+    anthropic: { baseUrl: 'https://api.anthropic.com', envKey: 'ANTHROPIC_API_KEY' },
+    openai: { baseUrl: 'https://api.openai.com', envKey: 'OPENAI_API_KEY' },
+    gemini: { baseUrl: 'https://generativelanguage.googleapis.com/v1beta/openai', envKey: 'GEMINI_API_KEY' },
+    deepseek: { baseUrl: 'https://api.deepseek.com', envKey: 'DEEPSEEK_API_KEY' },
+    groq: { baseUrl: 'https://api.groq.com/openai', envKey: 'GROQ_API_KEY' },
+    mistral: { baseUrl: 'https://api.mistral.ai', envKey: 'MISTRAL_API_KEY' },
+    xai: { baseUrl: 'https://api.x.ai', envKey: 'XAI_API_KEY' },
+};
+exports.MODEL_REGISTRY = {
+    // ── Ollama / Local Models ──────────────────────────────────────────────────
+    'qwen2.5-coder:32b': { contextWindow: 32768, supportsToolCalling: true },
+    'qwen2.5-coder:14b': { contextWindow: 32768, supportsToolCalling: true },
+    'qwen2.5-coder:7b': { contextWindow: 32768, supportsToolCalling: true },
+    'qwen2.5-coder:3b': { contextWindow: 32768, supportsToolCalling: true },
+    'qwen3:32b': { contextWindow: 32768, supportsToolCalling: true },
+    'qwen3:14b': { contextWindow: 32768, supportsToolCalling: true },
+    'qwen3:8b': { contextWindow: 32768, supportsToolCalling: true },
+    'deepseek-coder-v2:16b': { contextWindow: 16384, supportsToolCalling: true },
+    'deepseek-coder:33b': { contextWindow: 16384, supportsToolCalling: false },
+    'codellama:34b': { contextWindow: 16384, supportsToolCalling: false },
+    'llama3.1:70b': { contextWindow: 131072, supportsToolCalling: true },
+    'llama3.1:8b': { contextWindow: 131072, supportsToolCalling: true },
+    'llama3.2:3b': { contextWindow: 131072, supportsToolCalling: true },
+    'llama3.3:70b': { contextWindow: 131072, supportsToolCalling: true },
+    'mistral:7b': { contextWindow: 32768, supportsToolCalling: true },
+    'mixtral:8x7b': { contextWindow: 32768, supportsToolCalling: true },
+    'phi-3:14b': { contextWindow: 4096, supportsToolCalling: false },
+    'phi-4:14b': { contextWindow: 16384, supportsToolCalling: true },
+    'starcoder2:15b': { contextWindow: 16384, supportsToolCalling: false },
+    'granite-code:34b': { contextWindow: 8192, supportsToolCalling: false },
+    'gemma2:27b': { contextWindow: 8192, supportsToolCalling: true },
+    'command-r:35b': { contextWindow: 131072, supportsToolCalling: true },
+    // ── Anthropic / Claude ─────────────────────────────────────────────────────
+    'claude-opus-4-6': { contextWindow: 200000, supportsToolCalling: true, provider: 'anthropic' },
+    'claude-sonnet-4-6': { contextWindow: 200000, supportsToolCalling: true, provider: 'anthropic' },
+    'claude-sonnet-4-20250514': { contextWindow: 200000, supportsToolCalling: true, provider: 'anthropic' },
+    'claude-haiku-4-5-20251001': { contextWindow: 200000, supportsToolCalling: true, provider: 'anthropic' },
+    'claude-3-5-sonnet-20241022': { contextWindow: 200000, supportsToolCalling: true, provider: 'anthropic' },
+    'claude-3-5-haiku-20241022': { contextWindow: 200000, supportsToolCalling: true, provider: 'anthropic' },
+    // ── OpenAI ─────────────────────────────────────────────────────────────────
+    'gpt-4o': { contextWindow: 128000, supportsToolCalling: true, provider: 'openai' },
+    'gpt-4o-mini': { contextWindow: 128000, supportsToolCalling: true, provider: 'openai' },
+    'gpt-4-turbo': { contextWindow: 128000, supportsToolCalling: true, provider: 'openai' },
+    'gpt-4.1': { contextWindow: 1047576, supportsToolCalling: true, provider: 'openai' },
+    'gpt-4.1-mini': { contextWindow: 1047576, supportsToolCalling: true, provider: 'openai' },
+    'gpt-4.1-nano': { contextWindow: 1047576, supportsToolCalling: true, provider: 'openai' },
+    'o1': { contextWindow: 200000, supportsToolCalling: true, provider: 'openai' },
+    'o1-mini': { contextWindow: 128000, supportsToolCalling: true, provider: 'openai' },
+    'o3': { contextWindow: 200000, supportsToolCalling: true, provider: 'openai' },
+    'o3-mini': { contextWindow: 200000, supportsToolCalling: true, provider: 'openai' },
+    'o4-mini': { contextWindow: 200000, supportsToolCalling: true, provider: 'openai' },
+    // ── Google Gemini (OpenAI-compatible endpoint) ─────────────────────────────
+    'gemini-2.5-pro': { contextWindow: 1048576, supportsToolCalling: true, provider: 'gemini' },
+    'gemini-2.5-flash': { contextWindow: 1048576, supportsToolCalling: true, provider: 'gemini' },
+    'gemini-2.0-flash': { contextWindow: 1048576, supportsToolCalling: true, provider: 'gemini' },
+    'gemini-1.5-pro': { contextWindow: 2097152, supportsToolCalling: true, provider: 'gemini' },
+    'gemini-1.5-flash': { contextWindow: 1048576, supportsToolCalling: true, provider: 'gemini' },
+    // ── DeepSeek (OpenAI-compatible) ───────────────────────────────────────────
+    'deepseek-chat': { contextWindow: 65536, supportsToolCalling: true, provider: 'deepseek' },
+    'deepseek-reasoner': { contextWindow: 65536, supportsToolCalling: true, provider: 'deepseek' },
+    // ── Groq (OpenAI-compatible, fast inference) ───────────────────────────────
+    'llama-3.3-70b-versatile': { contextWindow: 131072, supportsToolCalling: true, provider: 'groq' },
+    'llama-3.1-8b-instant': { contextWindow: 131072, supportsToolCalling: true, provider: 'groq' },
+    'mixtral-8x7b-32768': { contextWindow: 32768, supportsToolCalling: true, provider: 'groq' },
+    'gemma2-9b-it': { contextWindow: 8192, supportsToolCalling: true, provider: 'groq' },
+    // ── Mistral (OpenAI-compatible) ────────────────────────────────────────────
+    'mistral-large-latest': { contextWindow: 131072, supportsToolCalling: true, provider: 'mistral' },
+    'mistral-small-latest': { contextWindow: 131072, supportsToolCalling: true, provider: 'mistral' },
+    'codestral-latest': { contextWindow: 32768, supportsToolCalling: true, provider: 'mistral' },
+    // ── xAI / Grok (OpenAI-compatible) ─────────────────────────────────────────
+    'grok-3': { contextWindow: 131072, supportsToolCalling: true, provider: 'xai' },
+    'grok-3-mini': { contextWindow: 131072, supportsToolCalling: true, provider: 'xai' },
+};
+function getModelInfo(model) {
+    if (exports.MODEL_REGISTRY[model])
+        return exports.MODEL_REGISTRY[model];
+    // Prefix match (e.g., "qwen2.5-coder" matches "qwen2.5-coder:32b")
+    for (const [key, info] of Object.entries(exports.MODEL_REGISTRY)) {
+        if (key.startsWith(model) || model.startsWith(key.split(':')[0])) {
+            return info;
+        }
+    }
+    // Default: conservative 8K context, no native tool calling
+    return { contextWindow: 8192, supportsToolCalling: false };
+}
+/** Detect provider from model name */
+function detectProvider(model) {
+    const info = getModelInfo(model);
+    if (info.provider)
+        return info.provider;
+    // Heuristic detection from model name prefixes
+    if (model.startsWith('claude'))
+        return 'anthropic';
+    if (model.startsWith('gpt-') || model.startsWith('o1') || model.startsWith('o3') || model.startsWith('o4'))
+        return 'openai';
+    if (model.startsWith('gemini'))
+        return 'gemini';
+    if (model.startsWith('deepseek'))
+        return 'deepseek';
+    if (model.startsWith('grok'))
+        return 'xai';
+    if (model.startsWith('mistral') || model.startsWith('codestral'))
+        return 'mistral';
+    if (model.includes('groq') || model.startsWith('llama-'))
+        return 'groq';
+    return undefined; // local/ollama
+}
+//# sourceMappingURL=registry.js.map

package/dist/setup.d.ts

@@ -0,0 +1,17 @@
+export interface SavedConfig {
+    model?: string;
+    provider?: string;
+    baseUrl?: string;
+    apiKey?: string;
+    autoApprove?: boolean;
+    maxIterations?: number;
+}
+/** Load saved config from ~/.codebot/config.json */
+export declare function loadConfig(): SavedConfig;
+/** Save config to ~/.codebot/config.json */
+export declare function saveConfig(config: SavedConfig): void;
+/** Check if this is the first run (no config, no env keys) */
+export declare function isFirstRun(): boolean;
+/** Interactive setup wizard */
+export declare function runSetup(): Promise<SavedConfig>;
+//# sourceMappingURL=setup.d.ts.map