botinabox 2.5.0 → 2.5.2

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[];

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

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

package/dist/shared/constants.d.ts

@@ -0,0 +1,50 @@
+/** Shared constants — event names, default values, status enums */
+/** Hook/event name constants */
+export declare const EVENTS: {
+    readonly COST_RECORDED: "cost.recorded";
+    readonly AGENT_CREATED: "agent.created";
+    readonly AGENT_STATUS_CHANGED: "agent.status_changed";
+    readonly BUDGET_EXCEEDED: "budget.exceeded";
+    readonly TASK_CREATED: "task.created";
+    readonly TASK_COMPLETED: "task.completed";
+    readonly TASK_FAILED: "task.failed";
+    readonly TASK_CANCELLED: "task.cancelled";
+    readonly RUN_STARTED: "run.started";
+    readonly RUN_COMPLETED: "run.completed";
+    readonly RUN_FAILED: "run.failed";
+    readonly MESSAGE_INBOUND: "message.inbound";
+    readonly MESSAGE_ROUTED: "message.routed";
+    readonly MESSAGE_PROCESSED: "message.processed";
+    readonly MESSAGE_OUTBOUND: "message.outbound";
+    readonly MESSAGE_SENT: "message.sent";
+    readonly UPDATE_AVAILABLE: "update.available";
+    readonly UPDATE_STARTED: "update.started";
+    readonly UPDATE_COMPLETED: "update.completed";
+    readonly UPDATE_FAILED: "update.failed";
+    readonly WORKFLOW_STARTED: "workflow.started";
+    readonly WORKFLOW_STEP_COMPLETED: "workflow.step_completed";
+    readonly WORKFLOW_COMPLETED: "workflow.completed";
+    readonly WORKFLOW_FAILED: "workflow.failed";
+};
+/** Default config values */
+export declare const DEFAULTS: {
+    readonly TASK_POLL_INTERVAL_MS: 30000;
+    readonly NOTIFICATION_POLL_INTERVAL_MS: 5000;
+    readonly ORPHAN_REAP_INTERVAL_MS: 300000;
+    readonly STALE_RUN_THRESHOLD_MS: 1800000;
+    readonly STALE_TASK_AGE_MS: 7200000;
+    readonly MAX_CHAIN_DEPTH: 5;
+    readonly MAX_NOTIFICATION_RETRIES: 3;
+    readonly UPDATE_CHECK_INTERVAL_MS: 86400000;
+    readonly RENDER_WATCH_INTERVAL_MS: 30000;
+    readonly DATA_PATH: "./data/bot.db";
+    readonly RENDER_OUTPUT_DIR: "./context";
+    readonly LOG_PATH_TEMPLATE: "./data/runs/{runId}.ndjson";
+    readonly BUDGET_WARN_PERCENT: 80;
+};
+/** Task status values */
+export declare const TASK_STATUSES: readonly ["backlog", "todo", "in_progress", "in_review", "done", "blocked", "cancelled"];
+/** Agent status values */
+export declare const AGENT_STATUSES: readonly ["idle", "running", "paused", "terminated", "error"];
+/** Run status values */
+export declare const RUN_STATUSES: readonly ["queued", "running", "succeeded", "failed", "cancelled"];