@unerr-ai/unerr 0.2.1 → 0.2.3

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

@@ -1,475 +0,0 @@
-/**
- * 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

@@ -1,55 +0,0 @@
-/**
- * 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

@@ -1,90 +0,0 @@
-/**
- * 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",
-];