@unerr-ai/unerr 0.0.1 → 0.1.1

package/dist/core/local-chat-provider.js

@@ -0,0 +1,475 @@
+/**
+ * Local Chat Provider — BYO-LLM streaming chat for the REPL.
+ *
+ * Implements the ChatProvider interface by routing to Ollama (/api/chat),
+ * LM Studio / OpenAI-compatible (/v1/chat/completions), or anthropic-direct.
+ * All providers use Server-Sent Events or NDJSON streaming.
+ *
+ * SECURITY: API keys are NEVER logged or included in MCP responses.
+ */
+import Anthropic from "@anthropic-ai/sdk";
+// ── Convert unerr Tool → ChatToolDef ────────────────────────
+export function toChatToolDefs(tools) {
+    return tools.map((t) => ({
+        type: "function",
+        function: {
+            name: t.name,
+            description: t.description,
+            parameters: t.inputSchema,
+        },
+    }));
+}
+// ── Anthropic Chat Provider ─────────────────────────────────
+export class AnthropicChatProvider {
+    providerName = "anthropic";
+    modelId;
+    client;
+    constructor(apiKey, model) {
+        this.client = new Anthropic({ apiKey });
+        this.modelId = model;
+    }
+    async streamChat(messages, tools, systemPrompt, maxTokens, onChunk) {
+        // Convert ChatMessage[] → Anthropic format
+        const anthropicMessages = this.toAnthropicMessages(messages);
+        const anthropicTools = tools.map((t) => ({
+            name: t.function.name,
+            description: t.function.description,
+            input_schema: t.function.parameters,
+        }));
+        const stream = this.client.messages.stream({
+            model: this.modelId,
+            max_tokens: maxTokens,
+            system: systemPrompt,
+            messages: anthropicMessages,
+            tools: anthropicTools.length > 0 ? anthropicTools : undefined,
+        });
+        let text = "";
+        stream.on("text", (t) => {
+            text += t;
+            onChunk({ type: "text_delta", text: t });
+        });
+        const message = await stream.finalMessage();
+        const toolCalls = [];
+        for (const block of message.content) {
+            if (block.type === "tool_use") {
+                toolCalls.push({
+                    id: block.id,
+                    name: block.name,
+                    args: block.input,
+                });
+            }
+        }
+        onChunk({ type: "done" });
+        return {
+            text,
+            toolCalls,
+            inputTokens: message.usage.input_tokens,
+            outputTokens: message.usage.output_tokens,
+        };
+    }
+    toAnthropicMessages(messages) {
+        const result = [];
+        for (const msg of messages) {
+            if (msg.role === "system")
+                continue; // System prompt handled separately
+            if (msg.role === "tool") {
+                result.push({
+                    role: "user",
+                    content: [
+                        {
+                            type: "tool_result",
+                            tool_use_id: msg.tool_call_id ?? "",
+                            content: msg.content,
+                        },
+                    ],
+                });
+            }
+            else if (msg.role === "assistant" && msg.tool_calls?.length) {
+                const blocks = [];
+                if (msg.content)
+                    blocks.push({ type: "text", text: msg.content });
+                for (const tc of msg.tool_calls) {
+                    blocks.push({
+                        type: "tool_use",
+                        id: tc.id,
+                        name: tc.function.name,
+                        input: JSON.parse(tc.function.arguments),
+                    });
+                }
+                result.push({ role: "assistant", content: blocks });
+            }
+            else {
+                result.push({
+                    role: msg.role,
+                    content: msg.content,
+                });
+            }
+        }
+        return result;
+    }
+}
+// ── Local Chat Provider ─────────────────────────────────────
+const DEFAULT_BASE_URLS = {
+    ollama: "http://localhost:11434",
+    "lm-studio": "http://localhost:1234",
+    "openai-compatible": "http://localhost:8080",
+    "anthropic-direct": "https://api.anthropic.com",
+};
+export class LocalChatProvider {
+    providerName;
+    modelId;
+    baseUrl;
+    apiKey;
+    useOllamaApi;
+    constructor(config) {
+        this.providerName = config.provider;
+        this.modelId = config.chatModel;
+        this.baseUrl = (config.baseUrl ??
+            DEFAULT_BASE_URLS[config.provider] ??
+            "http://localhost:8080").replace(/\/+$/, "");
+        this.apiKey = config.apiKey;
+        this.useOllamaApi = config.provider === "ollama";
+    }
+    async streamChat(messages, tools, systemPrompt, maxTokens, onChunk) {
+        // anthropic-direct uses the Anthropic SDK directly
+        if (this.providerName === "anthropic-direct") {
+            return this.streamAnthropicDirect(messages, tools, systemPrompt, maxTokens, onChunk);
+        }
+        if (this.useOllamaApi) {
+            return this.streamOllama(messages, tools, systemPrompt, maxTokens, onChunk);
+        }
+        return this.streamOpenAiCompatible(messages, tools, systemPrompt, maxTokens, onChunk);
+    }
+    async streamAnthropicDirect(messages, tools, systemPrompt, maxTokens, onChunk) {
+        if (!this.apiKey) {
+            throw new Error("[LocalChatProvider] anthropic-direct requires an API key. " +
+                "Set localLlm.apiKey in settings.json.");
+        }
+        const provider = new AnthropicChatProvider(this.apiKey, this.modelId);
+        return provider.streamChat(messages, tools, systemPrompt, maxTokens, onChunk);
+    }
+    // ── Ollama: POST /api/chat with NDJSON streaming ──────────
+    async streamOllama(messages, tools, systemPrompt, _maxTokens, onChunk) {
+        const ollamaMessages = [
+            { role: "system", content: systemPrompt },
+            ...messages.map((m) => ({
+                role: m.role === "tool" ? "user" : m.role,
+                content: m.content,
+            })),
+        ];
+        const body = {
+            model: this.modelId,
+            messages: ollamaMessages,
+            stream: true,
+        };
+        // Ollama supports tools via the OpenAI-compatible format
+        if (tools.length > 0) {
+            body.tools = tools;
+        }
+        const response = await fetch(`${this.baseUrl}/api/chat`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            const errText = await response.text().catch(() => "");
+            throw new Error(`[LocalChatProvider] Ollama chat failed: ${response.status} ${response.statusText}${errText ? ` — ${errText.slice(0, 200)}` : ""}`);
+        }
+        return this.parseNdjsonStream(response, onChunk);
+    }
+    async parseNdjsonStream(response, onChunk) {
+        const reader = response.body?.getReader();
+        if (!reader)
+            throw new Error("[LocalChatProvider] No response body");
+        const decoder = new TextDecoder();
+        let text = "";
+        const toolCalls = [];
+        let inputTokens = 0;
+        let outputTokens = 0;
+        let buffer = "";
+        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) {
+                        text += chunk.message.content;
+                        onChunk({ type: "text_delta", text: chunk.message.content });
+                    }
+                    if (chunk.message?.tool_calls) {
+                        for (const tc of chunk.message.tool_calls) {
+                            toolCalls.push({
+                                id: tc.id ?? `tool_${Date.now()}`,
+                                name: tc.function?.name ?? "",
+                                args: typeof tc.function?.arguments === "string"
+                                    ? JSON.parse(tc.function.arguments)
+                                    : (tc.function?.arguments ?? {}),
+                            });
+                        }
+                    }
+                    if (chunk.eval_count)
+                        outputTokens = chunk.eval_count;
+                    if (chunk.prompt_eval_count)
+                        inputTokens = chunk.prompt_eval_count;
+                }
+                catch {
+                    // Skip malformed JSON lines
+                }
+            }
+        }
+        onChunk({ type: "done" });
+        return { text, toolCalls, inputTokens, outputTokens };
+    }
+    // ── OpenAI-Compatible: POST /v1/chat/completions with SSE ──
+    async streamOpenAiCompatible(messages, tools, systemPrompt, maxTokens, onChunk) {
+        const openaiMessages = [
+            { role: "system", content: systemPrompt },
+            ...messages.map((m) => {
+                if (m.tool_calls) {
+                    return { role: m.role, content: m.content, tool_calls: m.tool_calls };
+                }
+                if (m.tool_call_id) {
+                    return {
+                        role: m.role,
+                        content: m.content,
+                        tool_call_id: m.tool_call_id,
+                    };
+                }
+                return { role: m.role, content: m.content };
+            }),
+        ];
+        const body = {
+            model: this.modelId,
+            messages: openaiMessages,
+            max_tokens: maxTokens,
+            stream: true,
+        };
+        if (tools.length > 0) {
+            body.tools = tools;
+        }
+        const headers = {
+            "Content-Type": "application/json",
+        };
+        if (this.apiKey) {
+            headers.Authorization = `Bearer ${this.apiKey}`;
+        }
+        const response = await fetch(`${this.baseUrl}/v1/chat/completions`, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            const errText = await response.text().catch(() => "");
+            throw new Error(`[LocalChatProvider] Chat request failed: ${response.status} ${response.statusText}${errText ? ` — ${errText.slice(0, 200)}` : ""}`);
+        }
+        return this.parseSseStream(response, onChunk);
+    }
+    async parseSseStream(response, onChunk) {
+        const reader = response.body?.getReader();
+        if (!reader)
+            throw new Error("[LocalChatProvider] No response body");
+        const decoder = new TextDecoder();
+        let text = "";
+        const toolCalls = [];
+        const pendingToolArgs = new Map();
+        let buffer = "";
+        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.startsWith("data: "))
+                    continue;
+                const data = line.slice(6).trim();
+                if (data === "[DONE]")
+                    continue;
+                try {
+                    const chunk = JSON.parse(data);
+                    const delta = chunk.choices?.[0]?.delta;
+                    if (!delta)
+                        continue;
+                    if (delta.content) {
+                        text += delta.content;
+                        onChunk({ type: "text_delta", text: delta.content });
+                    }
+                    if (delta.tool_calls) {
+                        for (const tc of delta.tool_calls) {
+                            const idx = tc.index ?? 0;
+                            if (tc.id) {
+                                pendingToolArgs.set(idx, {
+                                    id: tc.id,
+                                    name: tc.function?.name ?? "",
+                                    args: tc.function?.arguments ?? "",
+                                });
+                            }
+                            else if (pendingToolArgs.has(idx) && tc.function?.arguments) {
+                                const pending = pendingToolArgs.get(idx);
+                                if (pending)
+                                    pending.args += tc.function.arguments;
+                            }
+                        }
+                    }
+                }
+                catch {
+                    // Skip malformed SSE data
+                }
+            }
+        }
+        // Finalize pending tool calls
+        for (const [, pending] of pendingToolArgs) {
+            try {
+                toolCalls.push({
+                    id: pending.id,
+                    name: pending.name,
+                    args: pending.args ? JSON.parse(pending.args) : {},
+                });
+            }
+            catch {
+                toolCalls.push({
+                    id: pending.id,
+                    name: pending.name,
+                    args: {},
+                });
+            }
+        }
+        onChunk({ type: "done" });
+        // OpenAI-compatible endpoints don't always return token counts in streamed responses
+        return { text, toolCalls, inputTokens: 0, outputTokens: 0 };
+    }
+}
+// ── AI SDK Chat Provider ─────────────────────────────────────
+/**
+ * Chat provider backed by Vercel AI SDK streamText().
+ *
+ * Works with any AI SDK-compatible LanguageModel (Anthropic, OpenAI, Google,
+ * Ollama, any OpenAI-compatible). This is the recommended provider for new
+ * integrations — it replaces both AnthropicChatProvider and LocalChatProvider.
+ */
+export class AiSdkChatProvider {
+    providerName;
+    modelId;
+    model;
+    constructor(model, providerName, modelId) {
+        this.model = model;
+        this.providerName = providerName;
+        this.modelId = modelId;
+    }
+    async streamChat(messages, tools, systemPrompt, maxTokens, onChunk) {
+        const { streamText } = await import("ai");
+        const modelMessages = this.toModelMessages(messages);
+        const aiTools = this.toAiTools(tools);
+        const result = streamText({
+            model: this.model,
+            system: systemPrompt,
+            messages: modelMessages,
+            tools: Object.keys(aiTools).length > 0 ? aiTools : undefined,
+            maxOutputTokens: maxTokens,
+            toolChoice: tools.length > 0 ? "auto" : undefined,
+        });
+        let text = "";
+        const collectedToolCalls = [];
+        for await (const part of result.fullStream) {
+            if (part.type === "text-delta") {
+                const delta = part.text ??
+                    part.textDelta ??
+                    "";
+                text += delta;
+                onChunk({ type: "text_delta", text: delta });
+            }
+            else if (part.type === "tool-call") {
+                const tc = part;
+                const toolCallId = tc.toolCallId ?? "";
+                const toolName = tc.toolName ?? "";
+                const args = tc.args ?? tc.input ?? {};
+                onChunk({ type: "tool_use_start", toolCallId, toolName });
+                onChunk({
+                    type: "tool_use_delta",
+                    toolCallId,
+                    toolArgs: JSON.stringify(args),
+                });
+                onChunk({ type: "tool_use_end", toolCallId });
+                collectedToolCalls.push({
+                    id: toolCallId,
+                    name: toolName,
+                    args: args,
+                });
+            }
+        }
+        let inputTokens = 0;
+        let outputTokens = 0;
+        try {
+            const usage = await result.usage;
+            const u = usage;
+            inputTokens = u?.promptTokens ?? 0;
+            outputTokens = u?.completionTokens ?? 0;
+        }
+        catch {
+            /* token counts unavailable for some providers */
+        }
+        onChunk({ type: "done" });
+        return { text, toolCalls: collectedToolCalls, inputTokens, outputTokens };
+    }
+    toModelMessages(messages) {
+        const result = [];
+        for (const msg of messages) {
+            if (msg.role === "system")
+                continue;
+            if (msg.role === "user") {
+                result.push({ role: "user", content: msg.content });
+            }
+            else if (msg.role === "tool") {
+                result.push({
+                    role: "tool",
+                    content: [
+                        {
+                            type: "tool-result",
+                            toolCallId: msg.tool_call_id ?? "",
+                            result: msg.content,
+                        },
+                    ],
+                });
+            }
+            else if (msg.role === "assistant") {
+                if (msg.tool_calls?.length) {
+                    const parts = [];
+                    if (msg.content) {
+                        parts.push({ type: "text", text: msg.content });
+                    }
+                    for (const tc of msg.tool_calls) {
+                        parts.push({
+                            type: "tool-call",
+                            toolCallId: tc.id,
+                            toolName: tc.function.name,
+                            args: JSON.parse(tc.function.arguments),
+                        });
+                    }
+                    result.push({ role: "assistant", content: parts });
+                }
+                else {
+                    result.push({ role: "assistant", content: msg.content });
+                }
+            }
+        }
+        return result;
+    }
+    toAiTools(tools) {
+        const result = {};
+        for (const t of tools) {
+            result[t.function.name] = {
+                description: t.function.description,
+                parameters: t.function.parameters,
+            };
+        }
+        return result;
+    }
+}

package/dist/core/provider-factory.js

@@ -0,0 +1,55 @@
+/**
+ * Provider Factory — creates AI SDK provider from settings configuration.
+ *
+ * Reads the LLM configuration (provider, model, apiKey, baseUrl) and
+ * returns a ready-to-use LanguageModel for streamText().
+ *
+ * Supports two config shapes:
+ *   1. Direct ProviderConfig: { provider, model, apiKey, baseUrl }
+ *   2. Settings-based: reads from loadSettings().llm
+ */
+import { createLanguageModel, } from "./providers.js";
+const DEFAULT_MODELS = {
+    anthropic: "claude-sonnet-4-20250514",
+    openai: "gpt-4o",
+    google: "gemini-2.0-flash",
+    ollama: "llama3",
+    "openai-compatible": "default",
+};
+/**
+ * Resolve a ProviderConfig from loose settings.
+ * Fills in defaults for missing fields.
+ */
+export function resolveProviderConfig(settings) {
+    const provider = (settings.provider ?? "anthropic");
+    const model = settings.model ?? DEFAULT_MODELS[provider] ?? "default";
+    return {
+        provider,
+        model,
+        apiKey: settings.apiKey,
+        baseUrl: settings.baseUrl,
+    };
+}
+/**
+ * Create a LanguageModel from settings configuration.
+ * This is the primary entry point for the rest of the codebase.
+ */
+export async function createModelFromSettings(settings) {
+    const config = resolveProviderConfig(settings);
+    return createLanguageModel(config);
+}
+/**
+ * Create a LanguageModel from environment variables.
+ * Falls back to Anthropic with claude-sonnet-4-20250514.
+ */
+export async function createModelFromEnv() {
+    const provider = (process.env.UNERR_LLM_PROVIDER ??
+        "anthropic");
+    const model = process.env.UNERR_MODEL ?? DEFAULT_MODELS[provider] ?? "default";
+    return createLanguageModel({
+        provider,
+        model,
+        apiKey: process.env.ANTHROPIC_API_KEY ?? process.env.OPENAI_API_KEY,
+        baseUrl: process.env.UNERR_LLM_BASE_URL,
+    });
+}

package/dist/core/providers.js

@@ -0,0 +1,90 @@
+/**
+ * AI Provider Registry — unified provider abstraction via Vercel AI SDK.
+ *
+ * Supports: Anthropic, OpenAI, Google Gemini, Ollama (local), any OpenAI-compatible.
+ * Each provider returns an AI SDK LanguageModel that plugs into streamText().
+ *
+ * Design: the registry is a pure function map — no state, no singletons.
+ * Provider creation is lazy (only when called) to avoid importing unused SDKs.
+ */
+/**
+ * Create an AI SDK LanguageModel from provider configuration.
+ * Throws on invalid config or missing API keys (except Ollama).
+ */
+export async function createLanguageModel(config) {
+    switch (config.provider) {
+        case "anthropic":
+            return createAnthropicModel(config);
+        case "openai":
+            return createOpenAIModel(config);
+        case "google":
+            return createGoogleModel(config);
+        case "ollama":
+            return createOllamaModel(config);
+        case "openai-compatible":
+            return createOpenAICompatibleModel(config);
+        default: {
+            const _exhaustive = config.provider;
+            throw new Error(`Unknown provider: ${config.provider}`);
+        }
+    }
+}
+async function createAnthropicModel(config) {
+    const { createAnthropic } = await import("@ai-sdk/anthropic");
+    const anthropic = createAnthropic({
+        apiKey: config.apiKey ?? process.env.ANTHROPIC_API_KEY,
+    });
+    return anthropic(config.model);
+}
+async function createOpenAIModel(config) {
+    const { createOpenAI } = await import("@ai-sdk/openai");
+    const openai = createOpenAI({
+        apiKey: config.apiKey ?? process.env.OPENAI_API_KEY,
+        ...(config.baseUrl ? { baseURL: config.baseUrl } : {}),
+    });
+    return openai(config.model);
+}
+async function createGoogleModel(config) {
+    const { createGoogleGenerativeAI } = await import("@ai-sdk/google");
+    const google = createGoogleGenerativeAI({
+        apiKey: config.apiKey ?? process.env.GOOGLE_GENERATIVE_AI_API_KEY,
+    });
+    return google(config.model);
+}
+/**
+ * Ollama uses the OpenAI-compatible endpoint with a local baseURL.
+ * No API key required — Ollama runs locally.
+ */
+async function createOllamaModel(config) {
+    const { createOpenAI } = await import("@ai-sdk/openai");
+    const ollama = createOpenAI({
+        baseURL: config.baseUrl ?? "http://localhost:11434/v1",
+        apiKey: "ollama",
+    });
+    return ollama(config.model);
+}
+/**
+ * Any OpenAI-compatible API (LM Studio, vLLM, Together, Fireworks, etc.)
+ * Requires baseUrl to be set.
+ */
+async function createOpenAICompatibleModel(config) {
+    if (!config.baseUrl) {
+        throw new Error("openai-compatible provider requires baseUrl to be set");
+    }
+    const { createOpenAI } = await import("@ai-sdk/openai");
+    const compatible = createOpenAI({
+        baseURL: config.baseUrl,
+        apiKey: config.apiKey ?? "no-key",
+    });
+    return compatible(config.model);
+}
+/**
+ * List of all supported provider names.
+ */
+export const SUPPORTED_PROVIDERS = [
+    "anthropic",
+    "openai",
+    "google",
+    "ollama",
+    "openai-compatible",
+];