botinabox 0.1.0

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/index.d.ts

@@ -0,0 +1,22 @@
+import { L as LLMProvider, M as ModelInfo, d as ToolDefinition, a as ChatParams, b as ChatResult } from '../../provider-qqJYv9nv.js';
+
+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>;
+}
+
+declare const MODELS: ModelInfo[];
+
+declare function createAnthropicProvider(config: {
+    apiKey: string;
+}): LLMProvider;
+
+export { AnthropicProvider, MODELS, createAnthropicProvider as default };

package/dist/providers/anthropic/index.js

@@ -0,0 +1,169 @@
+// src/providers/anthropic/provider.ts
+import Anthropic from "@anthropic-ai/sdk";
+
+// src/providers/anthropic/models.ts
+var MODELS = [
+  {
+    id: "claude-opus-4-6",
+    displayName: "Claude Opus 4.6",
+    contextWindow: 2e5,
+    maxOutputTokens: 32e3,
+    inputCostPerMToken: 15,
+    outputCostPerMToken: 75,
+    capabilities: ["chat", "tools", "vision", "streaming"]
+  },
+  {
+    id: "claude-sonnet-4-6",
+    displayName: "Claude Sonnet 4.6",
+    contextWindow: 2e5,
+    maxOutputTokens: 16e3,
+    inputCostPerMToken: 3,
+    outputCostPerMToken: 15,
+    capabilities: ["chat", "tools", "vision", "streaming"]
+  },
+  {
+    id: "claude-haiku-4-5",
+    displayName: "Claude Haiku 4.5",
+    contextWindow: 2e5,
+    maxOutputTokens: 8192,
+    inputCostPerMToken: 0.8,
+    outputCostPerMToken: 4,
+    capabilities: ["chat", "tools", "vision", "streaming"]
+  }
+];
+
+// src/providers/anthropic/tool-converter.ts
+function convertTools(tools) {
+  return tools.map((tool) => ({
+    name: tool.name,
+    description: tool.description,
+    input_schema: { type: "object", ...tool.parameters }
+  }));
+}
+
+// src/providers/anthropic/provider.ts
+var AnthropicProvider = class {
+  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 !== void 0 ? { 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 : void 0,
+      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 !== void 0 ? { 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 : void 0,
+      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";
+  }
+}
+
+// src/providers/anthropic/index.ts
+function createAnthropicProvider(config) {
+  return new AnthropicProvider(config);
+}
+export {
+  AnthropicProvider,
+  MODELS,
+  createAnthropicProvider as default
+};

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

@@ -0,0 +1,24 @@
+import { L as LLMProvider, M as ModelInfo, d as ToolDefinition, a as ChatParams, b as ChatResult } from '../../provider-qqJYv9nv.js';
+
+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>;
+}
+
+declare function createOllamaProvider(config?: {
+    baseUrl?: string;
+}): LLMProvider;
+
+export { OllamaProvider, createOllamaProvider as default };

package/dist/providers/ollama/index.js

@@ -0,0 +1,179 @@
+// src/providers/ollama/provider.ts
+var OllamaProvider = class {
+  id = "ollama";
+  displayName = "Ollama";
+  baseUrl;
+  cachedModels = [];
+  cacheTimestamp = 0;
+  cacheTtlMs = 5 * 60 * 1e3;
+  // 5 minutes
+  constructor({ baseUrl = "http://localhost:11434" } = {}) {
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+  }
+  get models() {
+    return this.cachedModels;
+  }
+  serializeTools(_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: 128e3,
+        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 !== void 0) {
+      body["options"] = { ...body["options"] ?? {}, num_predict: maxTokens };
+    }
+    if (temperature !== void 0) {
+      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 !== void 0) {
+      body["options"] = { ...body["options"] ?? {}, num_predict: maxTokens };
+    }
+    if (temperature !== void 0) {
+      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 {
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    return {
+      content: fullContent,
+      usage: {
+        inputTokens: lastChunk?.prompt_eval_count ?? 0,
+        outputTokens: lastChunk?.eval_count ?? 0
+      },
+      model,
+      stopReason: "end_turn"
+    };
+  }
+};
+
+// src/providers/ollama/index.ts
+function createOllamaProvider(config) {
+  return new OllamaProvider(config);
+}
+export {
+  OllamaProvider,
+  createOllamaProvider as default
+};

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

@@ -0,0 +1,22 @@
+import { L as LLMProvider, M as ModelInfo, d as ToolDefinition, a as ChatParams, b as ChatResult } from '../../provider-qqJYv9nv.js';
+
+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>;
+}
+
+declare const MODELS: ModelInfo[];
+
+declare function createOpenAIProvider(config: {
+    apiKey: string;
+}): LLMProvider;
+
+export { MODELS, OpenAIProvider, createOpenAIProvider as default };

package/dist/providers/openai/index.js

@@ -0,0 +1,212 @@
+// src/providers/openai/provider.ts
+import OpenAI from "openai";
+
+// src/providers/openai/models.ts
+var MODELS = [
+  {
+    id: "gpt-4o",
+    displayName: "GPT-4o",
+    contextWindow: 128e3,
+    maxOutputTokens: 16384,
+    inputCostPerMToken: 2.5,
+    outputCostPerMToken: 10,
+    capabilities: ["chat", "tools", "vision", "streaming"]
+  },
+  {
+    id: "gpt-4o-mini",
+    displayName: "GPT-4o Mini",
+    contextWindow: 128e3,
+    maxOutputTokens: 16384,
+    inputCostPerMToken: 0.15,
+    outputCostPerMToken: 0.6,
+    capabilities: ["chat", "tools", "vision", "streaming"]
+  },
+  {
+    id: "o3-mini",
+    displayName: "o3 Mini",
+    contextWindow: 2e5,
+    maxOutputTokens: 1e5,
+    inputCostPerMToken: 1.1,
+    outputCostPerMToken: 4.4,
+    capabilities: ["chat", "tools", "streaming"]
+  }
+];
+
+// src/providers/openai/tool-converter.ts
+function convertTools(tools) {
+  return tools.map((tool) => ({
+    type: "function",
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.parameters
+    }
+  }));
+}
+
+// src/providers/openai/provider.ts
+var OpenAIProvider = class {
+  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 {
+        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 !== void 0 ? { max_tokens: maxTokens } : {},
+        ...temperature !== void 0 ? { 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 : void 0,
+      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 !== void 0 ? { max_tokens: maxTokens } : {},
+        ...temperature !== void 0 ? { 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 : void 0,
+      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";
+  }
+}
+
+// src/providers/openai/index.ts
+function createOpenAIProvider(config) {
+  return new OpenAIProvider(config);
+}
+export {
+  MODELS,
+  OpenAIProvider,
+  createOpenAIProvider as default
+};