botinabox 2.5.1 → 2.5.2

package/dist/provider-qqJYv9nv.d.ts

@@ -0,0 +1,75 @@
+/** LLM provider types — Story 1.5 / 2.1 */
+interface ToolDefinition {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+}
+interface ChatMessage {
+    role: "user" | "assistant" | "system";
+    content: string | ContentBlock[];
+}
+type ContentBlock = {
+    type: "text";
+    text: string;
+} | {
+    type: "tool_use";
+    id: string;
+    name: string;
+    input: unknown;
+} | {
+    type: "tool_result";
+    tool_use_id: string;
+    content: string;
+};
+interface ChatParams {
+    messages: ChatMessage[];
+    system?: string;
+    tools?: ToolDefinition[];
+    maxTokens?: number;
+    temperature?: number;
+    model: string;
+    abortSignal?: AbortSignal;
+}
+interface TokenUsage {
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens?: number;
+    cacheWriteTokens?: number;
+}
+interface ChatResult {
+    content: string;
+    toolUses?: ToolUse[];
+    usage: TokenUsage;
+    model: string;
+    stopReason: "end_turn" | "tool_use" | "max_tokens" | "stop_sequence";
+}
+interface ToolUse {
+    id: string;
+    name: string;
+    input: unknown;
+}
+interface ModelInfo {
+    id: string;
+    displayName: string;
+    contextWindow: number;
+    maxOutputTokens: number;
+    capabilities: Array<"chat" | "tools" | "vision" | "streaming">;
+    /** Cost in micro-cents per 1M tokens */
+    inputCostPerMToken?: number;
+    outputCostPerMToken?: number;
+}
+interface ResolvedModel {
+    provider: string;
+    model: string;
+}
+interface LLMProvider {
+    id: string;
+    displayName: string;
+    models: ModelInfo[];
+    chat(params: ChatParams): Promise<ChatResult>;
+    chatStream(params: ChatParams): AsyncGenerator<string, ChatResult, unknown>;
+    /** Convert ToolDefinition[] to provider-native format */
+    serializeTools(tools: ToolDefinition[]): unknown;
+}
+
+export type { ChatMessage as C, LLMProvider as L, ModelInfo as M, ResolvedModel as R, TokenUsage as T, ChatParams as a, ChatResult as b, ContentBlock as c, ToolDefinition as d, ToolUse as e };

package/dist/providers/anthropic/models.d.ts

@@ -0,0 +1,2 @@
+import type { ModelInfo } from "../../shared/index.js";
+export declare const MODELS: ModelInfo[];

package/dist/providers/anthropic/models.js

@@ -0,0 +1,29 @@
+export const MODELS = [
+    {
+        id: 'claude-opus-4-6',
+        displayName: 'Claude Opus 4.6',
+        contextWindow: 200000,
+        maxOutputTokens: 32000,
+        inputCostPerMToken: 15,
+        outputCostPerMToken: 75,
+        capabilities: ['chat', 'tools', 'vision', 'streaming'],
+    },
+    {
+        id: 'claude-sonnet-4-6',
+        displayName: 'Claude Sonnet 4.6',
+        contextWindow: 200000,
+        maxOutputTokens: 16000,
+        inputCostPerMToken: 3,
+        outputCostPerMToken: 15,
+        capabilities: ['chat', 'tools', 'vision', 'streaming'],
+    },
+    {
+        id: 'claude-haiku-4-5',
+        displayName: 'Claude Haiku 4.5',
+        contextWindow: 200000,
+        maxOutputTokens: 8192,
+        inputCostPerMToken: 0.8,
+        outputCostPerMToken: 4,
+        capabilities: ['chat', 'tools', 'vision', 'streaming'],
+    },
+];

package/dist/providers/anthropic/provider.d.ts

@@ -0,0 +1,13 @@
+import type { LLMProvider, ChatParams, ChatResult, ModelInfo, ToolDefinition } from "../../shared/index.js";
+export declare class AnthropicProvider implements LLMProvider {
+    readonly id = "anthropic";
+    readonly displayName = "Anthropic";
+    readonly models: ModelInfo[];
+    private client;
+    constructor({ apiKey }: {
+        apiKey: string;
+    });
+    serializeTools(tools: ToolDefinition[]): unknown;
+    chat(params: ChatParams): Promise<ChatResult>;
+    chatStream(params: ChatParams): AsyncGenerator<string, ChatResult, unknown>;
+}

package/dist/providers/anthropic/provider.js

@@ -0,0 +1,119 @@
+import Anthropic from '@anthropic-ai/sdk';
+import { MODELS } from './models.js';
+import { convertTools } from './tool-converter.js';
+export class AnthropicProvider {
+    id = 'anthropic';
+    displayName = 'Anthropic';
+    models = MODELS;
+    client;
+    constructor({ apiKey }) {
+        this.client = new Anthropic({ apiKey });
+    }
+    serializeTools(tools) {
+        return convertTools(tools);
+    }
+    async chat(params) {
+        const { messages, system, tools, maxTokens, temperature, model, abortSignal } = params;
+        const anthropicMessages = messages
+            .filter((m) => m.role !== 'system')
+            .map((m) => ({
+            role: m.role,
+            content: typeof m.content === 'string' ? m.content : m.content,
+        }));
+        const response = await this.client.messages.create({
+            model,
+            max_tokens: maxTokens ?? 4096,
+            messages: anthropicMessages,
+            ...(system ? { system } : {}),
+            ...(tools && tools.length > 0 ? { tools: convertTools(tools) } : {}),
+            ...(temperature !== undefined ? { temperature } : {}),
+        }, { signal: abortSignal });
+        let content = '';
+        const toolUses = [];
+        for (const block of response.content) {
+            if (block.type === 'text') {
+                content += block.text;
+            }
+            else if (block.type === 'tool_use') {
+                toolUses.push({
+                    id: block.id,
+                    name: block.name,
+                    input: block.input,
+                });
+            }
+        }
+        const stopReason = mapStopReason(response.stop_reason);
+        return {
+            content,
+            toolUses: toolUses.length > 0 ? toolUses : undefined,
+            usage: {
+                inputTokens: response.usage.input_tokens,
+                outputTokens: response.usage.output_tokens,
+            },
+            model: response.model,
+            stopReason,
+        };
+    }
+    async *chatStream(params) {
+        const { messages, system, tools, maxTokens, temperature, model, abortSignal } = params;
+        const anthropicMessages = messages
+            .filter((m) => m.role !== 'system')
+            .map((m) => ({
+            role: m.role,
+            content: typeof m.content === 'string' ? m.content : m.content,
+        }));
+        const stream = this.client.messages.stream({
+            model,
+            max_tokens: maxTokens ?? 4096,
+            messages: anthropicMessages,
+            ...(system ? { system } : {}),
+            ...(tools && tools.length > 0 ? { tools: convertTools(tools) } : {}),
+            ...(temperature !== undefined ? { temperature } : {}),
+        }, { signal: abortSignal });
+        for await (const event of stream) {
+            if (event.type === 'content_block_delta' &&
+                event.delta.type === 'text_delta') {
+                yield event.delta.text;
+            }
+        }
+        const finalMessage = await stream.finalMessage();
+        let content = '';
+        const toolUses = [];
+        for (const block of finalMessage.content) {
+            if (block.type === 'text') {
+                content += block.text;
+            }
+            else if (block.type === 'tool_use') {
+                toolUses.push({
+                    id: block.id,
+                    name: block.name,
+                    input: block.input,
+                });
+            }
+        }
+        return {
+            content,
+            toolUses: toolUses.length > 0 ? toolUses : undefined,
+            usage: {
+                inputTokens: finalMessage.usage.input_tokens,
+                outputTokens: finalMessage.usage.output_tokens,
+            },
+            model: finalMessage.model,
+            stopReason: mapStopReason(finalMessage.stop_reason),
+        };
+    }
+}
+function mapStopReason(reason) {
+    switch (reason) {
+        case 'end_turn':
+            return 'end_turn';
+        case 'tool_use':
+            return 'tool_use';
+        case 'max_tokens':
+            return 'max_tokens';
+        case 'stop_sequence':
+            return 'stop_sequence';
+        default:
+            return 'end_turn';
+    }
+}

package/dist/providers/anthropic/tool-converter.d.ts

@@ -0,0 +1,10 @@
+import type { ToolDefinition } from "../../shared/index.js";
+export interface AnthropicTool {
+    name: string;
+    description: string;
+    input_schema: {
+        type: 'object';
+        [key: string]: unknown;
+    };
+}
+export declare function convertTools(tools: ToolDefinition[]): AnthropicTool[];

package/dist/providers/anthropic/tool-converter.js

@@ -0,0 +1,7 @@
+export function convertTools(tools) {
+    return tools.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        input_schema: { type: 'object', ...tool.parameters },
+    }));
+}

package/dist/providers/ollama/provider.d.ts

@@ -0,0 +1,17 @@
+import type { LLMProvider, ChatParams, ChatResult, ModelInfo, ToolDefinition } from "../../shared/index.js";
+export declare class OllamaProvider implements LLMProvider {
+    readonly id = "ollama";
+    readonly displayName = "Ollama";
+    private baseUrl;
+    private cachedModels;
+    private cacheTimestamp;
+    private readonly cacheTtlMs;
+    constructor({ baseUrl }?: {
+        baseUrl?: string;
+    });
+    get models(): ModelInfo[];
+    serializeTools(_tools: ToolDefinition[]): unknown;
+    getModels(): Promise<ModelInfo[]>;
+    chat(params: ChatParams): Promise<ChatResult>;
+    chatStream(params: ChatParams): AsyncGenerator<string, ChatResult, unknown>;
+}

package/dist/providers/ollama/provider.js

@@ -0,0 +1,185 @@
+export class OllamaProvider {
+    id = 'ollama';
+    displayName = 'Ollama';
+    baseUrl;
+    cachedModels = [];
+    cacheTimestamp = 0;
+    cacheTtlMs = 5 * 60 * 1000; // 5 minutes
+    constructor({ baseUrl = 'http://localhost:11434' } = {}) {
+        this.baseUrl = baseUrl.replace(/\/$/, '');
+    }
+    get models() {
+        return this.cachedModels;
+    }
+    serializeTools(_tools) {
+        // Ollama uses a similar format to OpenAI for tools
+        return _tools.map((tool) => ({
+            type: 'function',
+            function: {
+                name: tool.name,
+                description: tool.description,
+                parameters: tool.parameters,
+            },
+        }));
+    }
+    async getModels() {
+        const now = Date.now();
+        if (this.cachedModels.length > 0 && now - this.cacheTimestamp < this.cacheTtlMs) {
+            return this.cachedModels;
+        }
+        try {
+            const response = await fetch(`${this.baseUrl}/api/tags`);
+            if (!response.ok) {
+                return [];
+            }
+            const data = (await response.json());
+            this.cachedModels = data.models.map((m) => ({
+                id: m.name,
+                displayName: m.name,
+                contextWindow: 128000,
+                maxOutputTokens: 4096,
+                capabilities: ['chat', 'streaming'],
+            }));
+            this.cacheTimestamp = now;
+            return this.cachedModels;
+        }
+        catch {
+            return [];
+        }
+    }
+    async chat(params) {
+        const { messages, system, model, maxTokens, temperature } = params;
+        const ollamaMessages = [];
+        if (system) {
+            ollamaMessages.push({ role: 'system', content: system });
+        }
+        for (const msg of messages) {
+            const content = typeof msg.content === 'string'
+                ? msg.content
+                : msg.content
+                    .filter((b) => b.type === 'text')
+                    .map((b) => (b.type === 'text' ? b.text : ''))
+                    .join('');
+            ollamaMessages.push({
+                role: msg.role,
+                content,
+            });
+        }
+        const body = {
+            model,
+            messages: ollamaMessages,
+            stream: false,
+        };
+        if (maxTokens !== undefined) {
+            body['options'] = { ...(body['options'] ?? {}), num_predict: maxTokens };
+        }
+        if (temperature !== undefined) {
+            body['options'] = { ...(body['options'] ?? {}), temperature };
+        }
+        const response = await fetch(`${this.baseUrl}/api/chat`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body),
+            signal: params.abortSignal,
+        });
+        if (!response.ok) {
+            throw new Error(`Ollama API error: ${response.status} ${response.statusText}`);
+        }
+        const data = (await response.json());
+        return {
+            content: data.message.content,
+            usage: {
+                inputTokens: data.prompt_eval_count ?? 0,
+                outputTokens: data.eval_count ?? 0,
+            },
+            model: data.model,
+            stopReason: 'end_turn',
+        };
+    }
+    async *chatStream(params) {
+        const { messages, system, model, maxTokens, temperature } = params;
+        const ollamaMessages = [];
+        if (system) {
+            ollamaMessages.push({ role: 'system', content: system });
+        }
+        for (const msg of messages) {
+            const content = typeof msg.content === 'string'
+                ? msg.content
+                : msg.content
+                    .filter((b) => b.type === 'text')
+                    .map((b) => (b.type === 'text' ? b.text : ''))
+                    .join('');
+            ollamaMessages.push({
+                role: msg.role,
+                content,
+            });
+        }
+        const body = {
+            model,
+            messages: ollamaMessages,
+            stream: true,
+        };
+        if (maxTokens !== undefined) {
+            body['options'] = { ...(body['options'] ?? {}), num_predict: maxTokens };
+        }
+        if (temperature !== undefined) {
+            body['options'] = { ...(body['options'] ?? {}), temperature };
+        }
+        const response = await fetch(`${this.baseUrl}/api/chat`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body),
+            signal: params.abortSignal,
+        });
+        if (!response.ok) {
+            throw new Error(`Ollama API error: ${response.status} ${response.statusText}`);
+        }
+        if (!response.body) {
+            throw new Error('No response body for streaming');
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        let fullContent = '';
+        let lastChunk;
+        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) {
+                    if (!line.trim())
+                        continue;
+                    try {
+                        const chunk = JSON.parse(line);
+                        if (chunk.message?.content) {
+                            fullContent += chunk.message.content;
+                            yield chunk.message.content;
+                        }
+                        if (chunk.done) {
+                            lastChunk = chunk;
+                        }
+                    }
+                    catch {
+                        // skip malformed lines
+                    }
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+        return {
+            content: fullContent,
+            usage: {
+                inputTokens: lastChunk?.prompt_eval_count ?? 0,
+                outputTokens: lastChunk?.eval_count ?? 0,
+            },
+            model,
+            stopReason: 'end_turn',
+        };
+    }
+}

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

@@ -0,0 +1,2 @@
+import type { ModelInfo } from "../../shared/index.js";
+export declare const MODELS: ModelInfo[];

package/dist/providers/openai/models.js

@@ -0,0 +1,29 @@
+export const MODELS = [
+    {
+        id: 'gpt-4o',
+        displayName: 'GPT-4o',
+        contextWindow: 128000,
+        maxOutputTokens: 16384,
+        inputCostPerMToken: 2.5,
+        outputCostPerMToken: 10,
+        capabilities: ['chat', 'tools', 'vision', 'streaming'],
+    },
+    {
+        id: 'gpt-4o-mini',
+        displayName: 'GPT-4o Mini',
+        contextWindow: 128000,
+        maxOutputTokens: 16384,
+        inputCostPerMToken: 0.15,
+        outputCostPerMToken: 0.6,
+        capabilities: ['chat', 'tools', 'vision', 'streaming'],
+    },
+    {
+        id: 'o3-mini',
+        displayName: 'o3 Mini',
+        contextWindow: 200000,
+        maxOutputTokens: 100000,
+        inputCostPerMToken: 1.1,
+        outputCostPerMToken: 4.4,
+        capabilities: ['chat', 'tools', 'streaming'],
+    },
+];

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

@@ -0,0 +1,13 @@
+import type { LLMProvider, ChatParams, ChatResult, ModelInfo, ToolDefinition } from "../../shared/index.js";
+export declare class OpenAIProvider implements LLMProvider {
+    readonly id = "openai";
+    readonly displayName = "OpenAI";
+    readonly models: ModelInfo[];
+    private client;
+    constructor({ apiKey }: {
+        apiKey: string;
+    });
+    serializeTools(tools: ToolDefinition[]): unknown;
+    chat(params: ChatParams): Promise<ChatResult>;
+    chatStream(params: ChatParams): AsyncGenerator<string, ChatResult, unknown>;
+}

package/dist/providers/openai/provider.js

@@ -0,0 +1,163 @@
+import OpenAI from 'openai';
+import { MODELS } from './models.js';
+import { convertTools } from './tool-converter.js';
+export class OpenAIProvider {
+    id = 'openai';
+    displayName = 'OpenAI';
+    models = MODELS;
+    client;
+    constructor({ apiKey }) {
+        this.client = new OpenAI({ apiKey });
+    }
+    serializeTools(tools) {
+        return convertTools(tools);
+    }
+    async chat(params) {
+        const { messages, system, tools, maxTokens, temperature, model, abortSignal } = params;
+        const openaiMessages = [];
+        if (system) {
+            openaiMessages.push({ role: 'system', content: system });
+        }
+        for (const msg of messages) {
+            if (typeof msg.content === 'string') {
+                openaiMessages.push({
+                    role: msg.role,
+                    content: msg.content,
+                });
+            }
+            else {
+                // content blocks — convert text blocks to string
+                const textContent = msg.content
+                    .filter((b) => b.type === 'text')
+                    .map((b) => (b.type === 'text' ? b.text : ''))
+                    .join('');
+                openaiMessages.push({
+                    role: msg.role,
+                    content: textContent,
+                });
+            }
+        }
+        const response = await this.client.chat.completions.create({
+            model,
+            messages: openaiMessages,
+            ...(maxTokens !== undefined ? { max_tokens: maxTokens } : {}),
+            ...(temperature !== undefined ? { temperature } : {}),
+            ...(tools && tools.length > 0 ? { tools: convertTools(tools) } : {}),
+        }, { signal: abortSignal });
+        const choice = response.choices[0];
+        if (!choice) {
+            throw new Error('No choices returned from OpenAI');
+        }
+        const messageContent = choice.message.content ?? '';
+        const toolUses = [];
+        if (choice.message.tool_calls) {
+            for (const tc of choice.message.tool_calls) {
+                let input;
+                try {
+                    input = JSON.parse(tc.function.arguments);
+                }
+                catch {
+                    input = tc.function.arguments;
+                }
+                toolUses.push({
+                    id: tc.id,
+                    name: tc.function.name,
+                    input,
+                });
+            }
+        }
+        const stopReason = mapFinishReason(choice.finish_reason);
+        return {
+            content: messageContent,
+            toolUses: toolUses.length > 0 ? toolUses : undefined,
+            usage: {
+                inputTokens: response.usage?.prompt_tokens ?? 0,
+                outputTokens: response.usage?.completion_tokens ?? 0,
+            },
+            model: response.model,
+            stopReason,
+        };
+    }
+    async *chatStream(params) {
+        const { messages, system, tools, maxTokens, temperature, model, abortSignal } = params;
+        const openaiMessages = [];
+        if (system) {
+            openaiMessages.push({ role: 'system', content: system });
+        }
+        for (const msg of messages) {
+            if (typeof msg.content === 'string') {
+                openaiMessages.push({
+                    role: msg.role,
+                    content: msg.content,
+                });
+            }
+            else {
+                const textContent = msg.content
+                    .filter((b) => b.type === 'text')
+                    .map((b) => (b.type === 'text' ? b.text : ''))
+                    .join('');
+                openaiMessages.push({
+                    role: msg.role,
+                    content: textContent,
+                });
+            }
+        }
+        const stream = this.client.chat.completions.stream({
+            model,
+            messages: openaiMessages,
+            ...(maxTokens !== undefined ? { max_tokens: maxTokens } : {}),
+            ...(temperature !== undefined ? { temperature } : {}),
+            ...(tools && tools.length > 0 ? { tools: convertTools(tools) } : {}),
+        }, { signal: abortSignal });
+        let accumulatedContent = '';
+        for await (const chunk of stream) {
+            const delta = chunk.choices[0]?.delta?.content;
+            if (delta) {
+                accumulatedContent += delta;
+                yield delta;
+            }
+        }
+        const finalCompletion = await stream.finalChatCompletion();
+        const choice = finalCompletion.choices[0];
+        if (!choice) {
+            throw new Error('No choices in final completion');
+        }
+        const toolUses = [];
+        if (choice.message.tool_calls) {
+            for (const tc of choice.message.tool_calls) {
+                let input;
+                try {
+                    input = JSON.parse(tc.function.arguments);
+                }
+                catch {
+                    input = tc.function.arguments;
+                }
+                toolUses.push({ id: tc.id, name: tc.function.name, input });
+            }
+        }
+        return {
+            content: choice.message.content ?? accumulatedContent,
+            toolUses: toolUses.length > 0 ? toolUses : undefined,
+            usage: {
+                inputTokens: finalCompletion.usage?.prompt_tokens ?? 0,
+                outputTokens: finalCompletion.usage?.completion_tokens ?? 0,
+            },
+            model: finalCompletion.model,
+            stopReason: mapFinishReason(choice.finish_reason),
+        };
+    }
+}
+function mapFinishReason(reason) {
+    switch (reason) {
+        case 'stop':
+            return 'end_turn';
+        case 'tool_calls':
+            return 'tool_use';
+        case 'length':
+            return 'max_tokens';
+        case 'content_filter':
+            return 'stop_sequence';
+        default:
+            return 'end_turn';
+    }
+}

package/dist/providers/openai/tool-converter.d.ts

@@ -0,0 +1,10 @@
+import type { ToolDefinition } from "../../shared/index.js";
+export interface OpenAITool {
+    type: 'function';
+    function: {
+        name: string;
+        description: string;
+        parameters: Record<string, unknown>;
+    };
+}
+export declare function convertTools(tools: ToolDefinition[]): OpenAITool[];