alvin-bot 4.4.1

package/dist/providers/claude-sdk-provider.js

@@ -0,0 +1,173 @@
+/**
+ * Claude Agent SDK Provider
+ *
+ * Wraps the existing Claude Agent SDK integration as a provider.
+ * This is the "premium" provider with full tool use (Read, Write, Bash, etc.)
+ *
+ * Requires: Claude CLI installed & logged in (Max subscription)
+ */
+import { query } from "@anthropic-ai/claude-agent-sdk";
+import { readFileSync } from "fs";
+import { resolve, dirname } from "path";
+import { fileURLToPath } from "url";
+import { findClaudeBinary } from "../find-claude-binary.js";
+const BOT_PROJECT_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "../..");
+// Load CLAUDE.md once at startup
+let botClaudeMd = "";
+try {
+    botClaudeMd = readFileSync(resolve(BOT_PROJECT_ROOT, "CLAUDE.md"), "utf-8");
+    botClaudeMd = botClaudeMd.replaceAll("docs/", `${BOT_PROJECT_ROOT}/docs/`);
+}
+catch {
+    // CLAUDE.md not found — continue without
+}
+// Checkpoint thresholds
+const CHECKPOINT_TOOL_THRESHOLD = 15;
+const CHECKPOINT_MSG_THRESHOLD = 10;
+export class ClaudeSDKProvider {
+    config;
+    constructor(config) {
+        this.config = {
+            type: "claude-sdk",
+            name: "Claude (Agent SDK)",
+            model: "claude-opus-4-6",
+            supportsTools: true,
+            supportsVision: true,
+            supportsStreaming: true,
+            ...config,
+        };
+    }
+    async *query(options) {
+        // Clean env to prevent nested session errors
+        const cleanEnv = { ...process.env };
+        delete cleanEnv.CLAUDECODE;
+        delete cleanEnv.CLAUDE_CODE_ENTRYPOINT;
+        // Build prompt with optional checkpoint reminder
+        let prompt = options.prompt;
+        const sessionState = options._sessionState;
+        if (sessionState) {
+            const needsCheckpoint = sessionState.toolUseCount >= CHECKPOINT_TOOL_THRESHOLD ||
+                sessionState.messageCount >= CHECKPOINT_MSG_THRESHOLD;
+            if (needsCheckpoint) {
+                prompt = `[CHECKPOINT] Du hast bereits ${sessionState.toolUseCount} Tool-Aufrufe und ${sessionState.messageCount} Nachrichten in dieser Session. Schreibe jetzt einen Checkpoint in deine Memory-Datei (docs/memory/YYYY-MM-DD.md) bevor du diese Anfrage bearbeitest.\n\n${prompt}`;
+            }
+        }
+        // Build system prompt
+        const systemPrompt = options.systemPrompt
+            ? `${options.systemPrompt}\n\n${botClaudeMd}`
+            : botClaudeMd;
+        try {
+            const claudePath = findClaudeBinary();
+            const q = query({
+                prompt,
+                options: {
+                    cwd: options.workingDir || process.cwd(),
+                    abortController: options.abortSignal
+                        ? { signal: options.abortSignal }
+                        : undefined,
+                    resume: options.sessionId ?? undefined,
+                    pathToClaudeCodeExecutable: claudePath,
+                    permissionMode: "bypassPermissions",
+                    allowDangerouslySkipPermissions: true,
+                    env: cleanEnv,
+                    settingSources: ["user", "project"],
+                    allowedTools: [
+                        "Read", "Write", "Edit", "Bash", "Glob", "Grep",
+                        "WebSearch", "WebFetch", "Task",
+                    ],
+                    systemPrompt,
+                    effort: (options.effort || "high"),
+                    maxTurns: 50,
+                    betas: ["context-1m-2025-08-07"],
+                },
+            });
+            let accumulatedText = "";
+            let capturedSessionId = options.sessionId || "";
+            let localToolUseCount = 0;
+            for await (const message of q) {
+                // System init — capture session ID
+                if (message.type === "system" && "subtype" in message && message.subtype === "init") {
+                    const sysMsg = message;
+                    capturedSessionId = sysMsg.session_id;
+                }
+                // Assistant message — text + tool use
+                if (message.type === "assistant") {
+                    const assistantMsg = message;
+                    capturedSessionId = assistantMsg.session_id;
+                    if (assistantMsg.message?.content) {
+                        for (const block of assistantMsg.message.content) {
+                            if ("text" in block && block.text) {
+                                accumulatedText += block.text;
+                                yield {
+                                    type: "text",
+                                    text: accumulatedText,
+                                    delta: block.text,
+                                    sessionId: capturedSessionId,
+                                };
+                            }
+                            if ("name" in block) {
+                                localToolUseCount++;
+                                yield {
+                                    type: "tool_use",
+                                    toolName: block.name,
+                                    sessionId: capturedSessionId,
+                                };
+                            }
+                        }
+                    }
+                }
+                // Result — done (extract full usage including cache tokens)
+                if (message.type === "result") {
+                    const resultMsg = message;
+                    const usage = "usage" in resultMsg ? resultMsg.usage : null;
+                    const inputTok = usage
+                        ? (usage.input_tokens || 0) + (usage.cache_creation_input_tokens || 0) + (usage.cache_read_input_tokens || 0)
+                        : 0;
+                    const outputTok = usage?.output_tokens || 0;
+                    yield {
+                        type: "done",
+                        text: accumulatedText,
+                        sessionId: resultMsg.session_id || capturedSessionId,
+                        costUsd: "total_cost_usd" in resultMsg ? resultMsg.total_cost_usd : 0,
+                        inputTokens: inputTok,
+                        outputTokens: outputTok,
+                    };
+                }
+            }
+        }
+        catch (err) {
+            if (err instanceof Error && err.message.includes("abort")) {
+                yield { type: "error", error: "Request aborted" };
+            }
+            else {
+                yield {
+                    type: "error",
+                    error: `Claude SDK error: ${err instanceof Error ? err.message : String(err)}`,
+                };
+            }
+        }
+    }
+    async isAvailable() {
+        // Check if native Claude binary exists and responds to --version.
+        // NOTE: Don't test with `claude -p "ping"` — CLI login and SDK auth
+        // are separate. The SDK uses its own auth via bypassPermissions.
+        try {
+            const claudePath = findClaudeBinary();
+            if (!claudePath)
+                return false;
+            const { execSync } = await import("child_process");
+            execSync(`"${claudePath}" --version`, { stdio: "pipe", timeout: 5000 });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    getInfo() {
+        return {
+            name: this.config.name,
+            model: this.config.model,
+            status: "✅ Agent SDK (CLI auth)",
+        };
+    }
+}

package/dist/providers/codex-cli-provider.js

@@ -0,0 +1,121 @@
+/**
+ * Codex CLI Provider
+ *
+ * Wraps OpenAI's Codex CLI as a provider, similar to how Claude SDK Provider
+ * wraps the Claude CLI. Uses `codex exec` for non-interactive completions.
+ *
+ * Requires: Codex CLI installed & logged in (`codex login --device-auth`)
+ */
+import { spawn } from "child_process";
+export class CodexCLIProvider {
+    config;
+    constructor(config) {
+        this.config = {
+            type: "codex-cli",
+            name: "Codex CLI (OpenAI)",
+            model: "gpt-5.4",
+            supportsTools: true,
+            supportsVision: false,
+            supportsStreaming: true,
+            ...config,
+        };
+    }
+    async *query(options) {
+        const args = [
+            "exec",
+            "--skip-git-repo-check",
+            "--ephemeral",
+            "-s", "read-only",
+            "-m", this.config.model,
+        ];
+        if (options.workingDir) {
+            args.push("-C", options.workingDir);
+        }
+        // Build the prompt with system context
+        let fullPrompt = options.prompt;
+        if (options.systemPrompt) {
+            fullPrompt = `${options.systemPrompt}\n\n${fullPrompt}`;
+        }
+        args.push(fullPrompt);
+        try {
+            const result = await this.execCodex(args, options.abortSignal);
+            if (result.trim()) {
+                yield {
+                    type: "text",
+                    text: result,
+                    delta: result,
+                };
+            }
+            yield {
+                type: "done",
+                text: result,
+            };
+        }
+        catch (err) {
+            if (err instanceof Error && err.message.includes("abort")) {
+                yield { type: "error", error: "Request aborted" };
+            }
+            else {
+                yield {
+                    type: "error",
+                    error: `Codex CLI error: ${err instanceof Error ? err.message : String(err)}`,
+                };
+            }
+        }
+    }
+    async isAvailable() {
+        try {
+            const { execSync } = await import("child_process");
+            const output = execSync("codex login status 2>&1", {
+                stdio: "pipe",
+                timeout: 5000,
+                encoding: "utf-8",
+            });
+            return output.includes("Logged in");
+        }
+        catch {
+            return false;
+        }
+    }
+    getInfo() {
+        return {
+            name: this.config.name,
+            model: this.config.model,
+            status: "✅ Codex CLI (ChatGPT auth)",
+        };
+    }
+    execCodex(args, abortSignal) {
+        return new Promise((resolve, reject) => {
+            const proc = spawn("codex", args, {
+                stdio: ["pipe", "pipe", "pipe"],
+                timeout: 120_000,
+                env: { ...process.env, NO_COLOR: "1" },
+            });
+            let stdout = "";
+            let stderr = "";
+            proc.stdout.on("data", (data) => {
+                stdout += data.toString();
+            });
+            proc.stderr.on("data", (data) => {
+                stderr += data.toString();
+            });
+            proc.on("close", (code) => {
+                if (code === 0 || stdout.trim()) {
+                    resolve(stdout.trim());
+                }
+                else {
+                    reject(new Error(stderr.trim() || `codex exec exited with code ${code}`));
+                }
+            });
+            proc.on("error", (err) => {
+                reject(new Error(`Failed to spawn codex: ${err.message}`));
+            });
+            if (abortSignal) {
+                abortSignal.addEventListener("abort", () => {
+                    proc.kill("SIGTERM");
+                    reject(new Error("abort"));
+                });
+            }
+        });
+    }
+}

package/dist/providers/index.js

@@ -0,0 +1,7 @@
+/**
+ * Provider system — public API
+ */
+export { PROVIDER_PRESETS } from "./types.js";
+export { ClaudeSDKProvider } from "./claude-sdk-provider.js";
+export { OpenAICompatibleProvider } from "./openai-compatible.js";
+export { ProviderRegistry, createRegistry } from "./registry.js";

package/dist/providers/openai-compatible.js

@@ -0,0 +1,388 @@
+/**
+ * OpenAI-Compatible Provider
+ *
+ * Works with: OpenAI, Groq, Gemini, NVIDIA NIM, Ollama, OpenRouter, LM Studio,
+ * and any other endpoint that implements the OpenAI Chat Completions API.
+ *
+ * Supports function calling (tool use) for providers that support it,
+ * giving non-Claude models full agent capabilities (shell, files, web).
+ */
+import { AGENT_TOOLS, executeTool } from "./tool-executor.js";
+import { updateRateLimits } from "../services/usage-tracker.js";
+// Max tool call rounds to prevent infinite loops
+const MAX_TOOL_ROUNDS = 10;
+// Providers known to support function calling
+const TOOL_CAPABLE_PROVIDERS = [
+    "api.openai.com",
+    "api.groq.com",
+    "generativelanguage.googleapis.com",
+    "openrouter.ai",
+    "integrate.api.nvidia.com",
+    "api.mistral.ai",
+    "api.together.xyz",
+    "api.fireworks.ai",
+];
+export class OpenAICompatibleProvider {
+    config;
+    constructor(config) {
+        this.config = {
+            maxTokens: 4096,
+            temperature: 0.7,
+            supportsStreaming: true,
+            supportsVision: false,
+            supportsTools: false,
+            ...config,
+        };
+    }
+    /** Check if this provider's endpoint likely supports function calling */
+    supportsToolUse() {
+        if (this.config.supportsTools)
+            return true;
+        const url = this.config.baseUrl || "";
+        return TOOL_CAPABLE_PROVIDERS.some(p => url.includes(p));
+    }
+    async *query(options) {
+        const useTools = this.supportsToolUse();
+        if (useTools) {
+            // Tool-use loop: send messages, get response, execute tools, repeat
+            yield* this.queryWithTools(options);
+        }
+        else {
+            // Simple text-only query
+            yield* this.querySimple(options);
+        }
+    }
+    // ── Tool-Use Query Loop ─────────────────────────────────────────────────
+    async *queryWithTools(options) {
+        const messages = this.buildMessages(options);
+        let accumulatedText = "";
+        let totalCost = 0;
+        let totalInputTokens = 0;
+        let totalOutputTokens = 0;
+        for (let round = 0; round < MAX_TOOL_ROUNDS; round++) {
+            // Non-streaming request for tool use (streaming + tools is complex)
+            const body = {
+                model: this.config.model,
+                messages,
+                max_tokens: this.config.maxTokens,
+                temperature: this.config.temperature,
+                tools: AGENT_TOOLS,
+                tool_choice: "auto",
+            };
+            const headers = this.buildHeaders();
+            const url = `${this.config.baseUrl}/chat/completions`;
+            let response;
+            try {
+                response = await fetch(url, {
+                    method: "POST",
+                    headers,
+                    body: JSON.stringify(body),
+                    signal: options.abortSignal,
+                });
+            }
+            catch (err) {
+                // If tool call fails, retry without tools
+                if (round === 0) {
+                    yield* this.querySimple(options);
+                    return;
+                }
+                yield { type: "error", error: `Network error: ${err instanceof Error ? err.message : err}` };
+                return;
+            }
+            if (!response.ok) {
+                const errorBody = await response.text().catch(() => "");
+                // If 400/422 (tools not supported), fall back to simple
+                if ((response.status === 400 || response.status === 422) && round === 0) {
+                    yield* this.querySimple(options);
+                    return;
+                }
+                yield { type: "error", error: `${this.config.name} error (${response.status}): ${errorBody}` };
+                return;
+            }
+            // Extract rate limits from response headers
+            const rlInfo = this.extractRateLimits(response);
+            const data = await response.json();
+            const choice = data.choices?.[0];
+            if (!choice) {
+                yield { type: "error", error: "No response from provider" };
+                return;
+            }
+            const msg = choice.message;
+            totalCost += this.estimateCostFromUsage(data.usage);
+            if (data.usage) {
+                totalInputTokens += data.usage.prompt_tokens || 0;
+                totalOutputTokens += data.usage.completion_tokens || 0;
+            }
+            // Check for tool calls
+            if (msg.tool_calls && msg.tool_calls.length > 0) {
+                // Add assistant message with tool calls to history
+                messages.push(msg);
+                // Execute each tool call
+                for (const toolCall of msg.tool_calls) {
+                    const fn = toolCall.function;
+                    let args = {};
+                    try {
+                        args = JSON.parse(fn.arguments || "{}");
+                    }
+                    catch {
+                        args = {};
+                    }
+                    // Notify about tool use
+                    yield {
+                        type: "tool_use",
+                        toolName: fn.name,
+                        toolInput: JSON.stringify(args).substring(0, 200),
+                    };
+                    // Execute the tool
+                    const result = executeTool(fn.name, args, options.workingDir);
+                    // Notify about result
+                    yield {
+                        type: "tool_result",
+                        toolName: fn.name,
+                        text: result.result.substring(0, 200),
+                    };
+                    // Add tool result to conversation
+                    messages.push({
+                        role: "tool",
+                        tool_call_id: toolCall.id,
+                        content: result.result,
+                    });
+                }
+                // Continue loop — let the model process tool results
+                continue;
+            }
+            // No tool calls — this is the final text response
+            if (msg.content) {
+                accumulatedText += msg.content;
+                yield { type: "text", text: accumulatedText };
+            }
+            yield { type: "done", text: accumulatedText, costUsd: totalCost, inputTokens: totalInputTokens, outputTokens: totalOutputTokens, rateLimits: rlInfo };
+            return;
+        }
+        // Max rounds reached
+        if (accumulatedText) {
+            yield { type: "done", text: accumulatedText, costUsd: totalCost, inputTokens: totalInputTokens, outputTokens: totalOutputTokens };
+        }
+        else {
+            yield { type: "error", error: "Max tool call rounds reached" };
+        }
+    }
+    // ── Simple Text-Only Query ──────────────────────────────────────────────
+    async *querySimple(options) {
+        const messages = this.buildMessages(options);
+        const body = {
+            model: this.config.model,
+            messages,
+            max_tokens: this.config.maxTokens,
+            temperature: this.config.temperature,
+            stream: true,
+        };
+        const headers = this.buildHeaders();
+        const url = `${this.config.baseUrl}/chat/completions`;
+        try {
+            const response = await fetch(url, {
+                method: "POST",
+                headers,
+                body: JSON.stringify(body),
+                signal: options.abortSignal,
+            });
+            if (!response.ok) {
+                const errorBody = await response.text().catch(() => "Unknown error");
+                yield {
+                    type: "error",
+                    error: `${this.config.name} API error (${response.status}): ${errorBody}`,
+                };
+                return;
+            }
+            // Extract rate limits from streaming response headers
+            const streamRlInfo = this.extractRateLimits(response);
+            if (!response.body) {
+                yield { type: "error", error: "No response body (streaming not supported?)" };
+                return;
+            }
+            let accumulatedText = "";
+            let streamInputTokens = 0;
+            let streamOutputTokens = 0;
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder();
+            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) {
+                    const trimmed = line.trim();
+                    if (!trimmed || !trimmed.startsWith("data: "))
+                        continue;
+                    const data = trimmed.slice(6);
+                    if (data === "[DONE]") {
+                        yield { type: "done", text: accumulatedText };
+                        return;
+                    }
+                    try {
+                        const json = JSON.parse(data);
+                        const delta = json.choices?.[0]?.delta;
+                        if (delta?.content) {
+                            accumulatedText += delta.content;
+                            yield { type: "text", text: accumulatedText, delta: delta.content };
+                        }
+                        // Some providers include usage in the final streaming chunk
+                        if (json.usage) {
+                            streamInputTokens = json.usage.prompt_tokens || 0;
+                            streamOutputTokens = json.usage.completion_tokens || 0;
+                        }
+                        if (json.choices?.[0]?.finish_reason) {
+                            const estOut = streamOutputTokens || Math.ceil(accumulatedText.length / 4);
+                            const estIn = streamInputTokens || Math.ceil((options.prompt?.length || 0) / 4);
+                            yield {
+                                type: "done",
+                                text: accumulatedText,
+                                costUsd: this.estimateCost(accumulatedText),
+                                inputTokens: estIn,
+                                outputTokens: estOut,
+                                rateLimits: streamRlInfo,
+                            };
+                            return;
+                        }
+                    }
+                    catch {
+                        // Skip unparseable chunks
+                    }
+                }
+            }
+            if (accumulatedText) {
+                const estOut = streamOutputTokens || Math.ceil(accumulatedText.length / 4);
+                const estIn = streamInputTokens || Math.ceil((options.prompt?.length || 0) / 4);
+                yield { type: "done", text: accumulatedText, costUsd: this.estimateCost(accumulatedText), inputTokens: estIn, outputTokens: estOut };
+            }
+        }
+        catch (err) {
+            if (err instanceof Error && err.name === "AbortError") {
+                yield { type: "error", error: "Request aborted" };
+            }
+            else {
+                yield {
+                    type: "error",
+                    error: `${this.config.name} error: ${err instanceof Error ? err.message : String(err)}`,
+                };
+            }
+        }
+    }
+    // ── Provider Interface ──────────────────────────────────────────────────
+    async isAvailable() {
+        if (this.config.baseUrl?.includes("localhost") || this.config.baseUrl?.includes("127.0.0.1")) {
+            try {
+                const res = await fetch(`${this.config.baseUrl}/models`, { signal: AbortSignal.timeout(3000) });
+                return res.ok;
+            }
+            catch {
+                return false;
+            }
+        }
+        return !!this.config.apiKey;
+    }
+    getInfo() {
+        const tools = this.supportsToolUse() ? " 🔧" : "";
+        return {
+            name: this.config.name + tools,
+            model: this.config.model,
+            status: this.config.apiKey ? "✅ configured" : "❌ no API key",
+        };
+    }
+    // ── Rate Limit Extraction ───────────────────────────────────────────────
+    extractRateLimits(response) {
+        // OpenAI / Groq style: x-ratelimit-*
+        const rl = response.headers.get("x-ratelimit-remaining-requests");
+        const tl = response.headers.get("x-ratelimit-remaining-tokens");
+        // Anthropic style: anthropic-ratelimit-*
+        const arl = response.headers.get("anthropic-ratelimit-requests-remaining");
+        const atl = response.headers.get("anthropic-ratelimit-tokens-remaining");
+        if (!rl && !tl && !arl && !atl)
+            return undefined;
+        const limits = {};
+        if (rl || arl) {
+            limits.requestsRemaining = parseInt(rl || arl || "0");
+            limits.requestsLimit = parseInt(response.headers.get("x-ratelimit-limit-requests")
+                || response.headers.get("anthropic-ratelimit-requests-limit")
+                || "0") || undefined;
+            limits.requestsReset =
+                response.headers.get("x-ratelimit-reset-requests")
+                    || response.headers.get("anthropic-ratelimit-requests-reset")
+                    || undefined;
+        }
+        if (tl || atl) {
+            limits.tokensRemaining = parseInt(tl || atl || "0");
+            limits.tokensLimit = parseInt(response.headers.get("x-ratelimit-limit-tokens")
+                || response.headers.get("anthropic-ratelimit-tokens-limit")
+                || "0") || undefined;
+            limits.tokensReset =
+                response.headers.get("x-ratelimit-reset-tokens")
+                    || response.headers.get("anthropic-ratelimit-tokens-reset")
+                    || undefined;
+        }
+        // Persist to usage tracker
+        const providerKey = this.config.name;
+        updateRateLimits(providerKey, {
+            ...limits,
+        });
+        return limits;
+    }
+    // ── Helpers ─────────────────────────────────────────────────────────────
+    buildHeaders() {
+        const headers = {
+            "Content-Type": "application/json",
+        };
+        if (this.config.apiKey) {
+            headers["Authorization"] = `Bearer ${this.config.apiKey}`;
+        }
+        if (this.config.baseUrl?.includes("openrouter.ai")) {
+            headers["HTTP-Referer"] = "https://github.com/alvbln/Alvin-Bot";
+            headers["X-Title"] = "Alvin Bot";
+        }
+        return headers;
+    }
+    buildMessages(options) {
+        const messages = [];
+        if (options.systemPrompt) {
+            messages.push({ role: "system", content: options.systemPrompt });
+        }
+        if (options.history && options.history.length > 0) {
+            for (const msg of options.history) {
+                if (this.config.supportsVision && msg.images && msg.images.length > 0) {
+                    const content = [
+                        { type: "text", text: msg.content },
+                    ];
+                    for (const img of msg.images) {
+                        content.push({
+                            type: "image_url",
+                            image_url: { url: img.startsWith("http") ? img : `data:image/jpeg;base64,${img}` },
+                        });
+                    }
+                    messages.push({ role: msg.role, content });
+                }
+                else {
+                    messages.push({ role: msg.role, content: msg.content });
+                }
+            }
+        }
+        messages.push({ role: "user", content: options.prompt });
+        return messages;
+    }
+    estimateCost(text) {
+        const tokens = text.length / 4;
+        const costs = {
+            "gpt-4o": 0.01, "gpt-4o-mini": 0.0003,
+            "gemini-2.5-pro": 0.005, "gemini-2.5-flash": 0.0005,
+        };
+        return (tokens / 1000) * (costs[this.config.model] || 0.001);
+    }
+    estimateCostFromUsage(usage) {
+        if (!usage)
+            return 0;
+        const total = (usage.prompt_tokens || 0) + (usage.completion_tokens || 0);
+        return (total / 1000) * 0.001; // rough estimate
+    }
+}