@delofarag/ai-utils 1.7.1 → 1.7.2

package/dist/helpers/cli-llms.js

@@ -0,0 +1,737 @@
+import { BaseChatModel, convertToOpenAITool, AIMessage, AIMessageChunk, ChatGenerationChunk, } from "../imports";
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+import { tmpdir } from "node:os";
+import { mkdtempSync } from "node:fs";
+import { join } from "node:path";
+/**
+ * CLI_LLM — nutzt die headless CLIs der Provider (z.B. `claude -p`, `codex exec`)
+ * wie ein ganz normales LangChain-`BaseChatModel`.
+ *
+ * Idee: statt die HTTP-API aufzurufen, wird pro `.invoke()`/`.stream()` ein
+ * Subprozess der jeweiligen CLI gestartet. Vorteil: es greift die eingeloggte
+ * Abo-Auth (kein API-Key/keine Per-Token-Kosten). Die Klasse verhält sich nach
+ * außen wie jedes andere `BaseChatModel` und ist damit drop-in für `Agent`/`Chain`.
+ *
+ * WICHTIG (bewusste Grenzen):
+ * - Tools: die internen Tools der CLI werden deaktiviert/eingeschränkt → reines LLM.
+ *   `.bindTools()` / das LangChain-Tool-Calling funktioniert hier NICHT wie bei
+ *   `ChatOpenAI` (die CLI führt eigene Tools intern aus, gibt keine `tool_calls` zurück).
+ * - Memory/Kontext: läuft per Default in einem neutralen Verzeichnis (kein Projekt-CLAUDE.md).
+ * - Multi-Turn: die Konversation wird ins Prompt eingebettet (stateless pro Aufruf).
+ */
+let _neutralCwd;
+/** Einmaliges, leeres Temp-Verzeichnis → kein Projekt-CLAUDE.md / keine Coder-Kontamination. */
+function neutralCwd() {
+    if (!_neutralCwd)
+        _neutralCwd = mkdtempSync(join(tmpdir(), "cli-llm-"));
+    return _neutralCwd;
+}
+/** Liest die Rolle einer Message robust aus (`.type` ist die moderne API, `.getType()` Fallback). */
+function messageRole(message) {
+    const anyMsg = message;
+    return anyMsg.type ?? (typeof anyMsg.getType === "function" ? anyMsg.getType() : "human");
+}
+/** Flacht `content` (string oder Content-Blocks) auf reinen Text ab (Bilder werden v1 ignoriert). */
+function contentToText(content) {
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .map((part) => {
+            if (typeof part === "string")
+                return part;
+            if (part && typeof part === "object" && typeof part.text === "string") {
+                return part.text;
+            }
+            return "";
+        })
+            .join("");
+    }
+    return content == null ? "" : String(content);
+}
+/** Basis-Fehler für jeden Fehlschlag eines CLI-Aufrufs (`claude`, `codex`). */
+export class CLIError extends Error {
+    provider;
+    exitCode;
+    status;
+    raw;
+    constructor(message, opts) {
+        super(message);
+        this.name = "CLIError";
+        this.provider = opts.provider;
+        this.exitCode = opts.exitCode;
+        this.status = opts.status;
+        this.raw = opts.raw;
+        // instanceof bleibt auch nach Transpilation/Bundling korrekt:
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+/**
+ * Wird geworfen, wenn die CLI ein Usage-/Rate-Limit gemeldet hat (Abo-Limit,
+ * HTTP 429, Token-Quota oder Billing). So kann man im try/catch gezielt prüfen,
+ * WARUM der Aufruf fehlschlug:
+ *
+ * ```ts
+ * try { await llm.invoke(msgs) }
+ * catch (e) {
+ *   if (e instanceof CLIUsageLimitError) {
+ *     console.log(`Limit erreicht (${e.limitType}); reset:`, e.resetsAt)
+ *   }
+ * }
+ * ```
+ */
+export class CLIUsageLimitError extends CLIError {
+    /** Art des Limits, z.B. "five_hour" | "weekly" | "rate_limit" | "quota" | "billing" | "usage_limit". */
+    limitType;
+    /** Zeitpunkt, zu dem das Limit laut CLI zurückgesetzt wird (falls bekannt). */
+    resetsAt;
+    constructor(message, opts) {
+        super(message, opts);
+        this.name = "CLIUsageLimitError";
+        this.limitType = opts.limitType;
+        this.resetsAt = opts.resetsAt;
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+/**
+ * Muster, die ein Usage-/Rate-/Quota-/Billing-Limit anzeigen.
+ * Bewusst NICHT der transiente 529-Overload ("overloaded") — der ist kein Limit,
+ * sondern vorübergehende Serverlast und wird von der CLI ohnehin automatisch retried.
+ */
+const USAGE_LIMIT_RE = /\b(usage limit|rate[\s_-]?limit|quota|insufficient[\s_]?(?:quota|credits?)|credit balance|too many requests|limit (?:reached|exceeded)|hit your usage|429)\b/i;
+/** Heuristik für die Limit-Art aus einer Fehlermeldung. */
+function extractLimitType(message) {
+    if (/seven[\s_-]?day|weekly|per[\s-]?week|\bweek\b/i.test(message))
+        return "weekly";
+    if (/five[\s_-]?hour|5[\s-]?hour/i.test(message))
+        return "five_hour";
+    if (/insufficient[\s_]?quota|\bquota\b/i.test(message))
+        return "quota";
+    if (/credit|billing/i.test(message))
+        return "billing";
+    if (/rate[\s_-]?limit|429|too many requests/i.test(message))
+        return "rate_limit";
+    if (/usage limit|hit your usage/i.test(message))
+        return "usage_limit";
+    return undefined;
+}
+/** Liest – wenn möglich – einen Reset-Zeitpunkt aus ("resets at …", "try again at …", "|<epoch>"). */
+function extractResetsAt(message) {
+    const phrase = message.match(/(?:try again at|resets? at|resets?)\s+([0-9A-Za-z:+\-.\s,]{6,40})/i);
+    if (phrase) {
+        const candidate = phrase[1].trim().replace(/[.,;]+$/, "");
+        const parsed = new Date(candidate);
+        if (!Number.isNaN(parsed.getTime()))
+            return parsed;
+    }
+    // Claude meldet das Abo-Reset teils als Unix-Epoch (Sekunden) hinter einem Pipe-Zeichen.
+    const epoch = message.match(/\|\s*(\d{10})\b/);
+    if (epoch)
+        return new Date(Number(epoch[1]) * 1000);
+    return undefined;
+}
+/**
+ * Baut den passenden Fehler: `CLIUsageLimitError`, wenn Meldung/Status/Limit-Typ
+ * auf ein Usage-/Rate-Limit hindeuten — sonst ein generischer `CLIError`.
+ */
+function buildCliError(provider, message, opts = {}) {
+    const isUsageLimit = opts.status === 429 || opts.limitType != null || USAGE_LIMIT_RE.test(message);
+    if (isUsageLimit) {
+        return new CLIUsageLimitError(message, {
+            provider,
+            exitCode: opts.exitCode,
+            status: opts.status,
+            raw: opts.raw,
+            limitType: opts.limitType ?? extractLimitType(message),
+            resetsAt: opts.resetsAt ?? extractResetsAt(message),
+        });
+    }
+    return new CLIError(message, { provider, exitCode: opts.exitCode, status: opts.status, raw: opts.raw });
+}
+let _toolCallCounter = 0;
+function nextToolCallId(name) {
+    _toolCallCounter += 1;
+    return `call_${name}_${_toolCallCounter}`;
+}
+function toToolSpec(tool) {
+    const oai = convertToOpenAITool(tool);
+    const fn = oai?.function ?? tool;
+    return {
+        name: String(fn?.name ?? "tool"),
+        description: String(fn?.description ?? ""),
+        parameters: fn?.parameters ?? { type: "object", properties: {} },
+    };
+}
+function safeJson(s) {
+    try {
+        return JSON.parse(s);
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Extrahiert das erste JSON-Objekt aus einem Text (toleriert Markdown-Fences und Begleittext). */
+function extractJsonObject(text) {
+    if (!text)
+        return undefined;
+    let s = text.trim();
+    const fence = s.match(/```(?:json)?\s*([\s\S]*?)```/i);
+    if (fence)
+        s = fence[1].trim();
+    const direct = safeJson(s);
+    if (direct !== undefined)
+        return direct;
+    const start = s.indexOf("{");
+    if (start === -1)
+        return undefined;
+    let depth = 0;
+    let inStr = false;
+    let esc = false;
+    for (let i = start; i < s.length; i++) {
+        const ch = s[i];
+        if (inStr) {
+            if (esc)
+                esc = false;
+            else if (ch === "\\")
+                esc = true;
+            else if (ch === '"')
+                inStr = false;
+        }
+        else if (ch === '"')
+            inStr = true;
+        else if (ch === "{")
+            depth++;
+        else if (ch === "}") {
+            depth--;
+            if (depth === 0)
+                return safeJson(s.slice(start, i + 1));
+        }
+    }
+    return undefined;
+}
+/** Interpretiert die Model-Ausgabe als Tool-Aufruf oder finale Antwort. */
+function parseToolDecision(text) {
+    const obj = extractJsonObject(text);
+    if (obj && typeof obj === "object") {
+        const tc = obj.tool_call;
+        if (tc && typeof tc.name === "string") {
+            const rawArgs = tc.arguments;
+            const args = typeof rawArgs === "string"
+                ? (safeJson(rawArgs) ?? {})
+                : (rawArgs ?? {});
+            return { kind: "tool_call", calls: [{ name: tc.name, args, id: nextToolCallId(tc.name), type: "tool_call" }] };
+        }
+        const final = obj.final;
+        if (typeof final === "string")
+            return { kind: "final", text: final };
+    }
+    // Kein gültiges Protokoll-JSON → die gesamte Ausgabe als finale Antwort behandeln.
+    return { kind: "final", text };
+}
+/**
+ * Abstrakte Basisklasse. Subklassen (`ClaudeCLI_LLM`, `OpenAICLI_LLM`) definieren
+ * nur das CLI-spezifische: Binary, Args, und das Parsen von Output/Stream.
+ */
+export class CLI_LLM extends BaseChatModel {
+    model;
+    systemPrompt;
+    cwd;
+    cliPath;
+    extraArgs;
+    timeoutMs;
+    env;
+    /** Provider-Tag, analog zu `getLLM()`-Rückgaben (`"claude-cli"`, `"openai-cli"`). */
+    provider;
+    /**
+     * Wie der Prompt an stdin übergeben wird. Default: nur der User-Prompt.
+     * Codex hat z.B. kein `--system-prompt`-Flag → überschreibt das, um den
+     * System-Prompt als Präambel voranzustellen.
+     */
+    composeStdin(_systemPrompt, userPrompt) {
+        return userPrompt;
+    }
+    constructor(fields, defaults) {
+        super(fields);
+        this.provider = defaults.provider;
+        this.model = fields.model ?? defaults.model;
+        this.systemPrompt = fields.systemPrompt ?? "";
+        this.cwd = fields.cwd ?? neutralCwd();
+        this.cliPath = fields.cliPath ?? defaults.cliPath;
+        this.extraArgs = fields.extraArgs ?? [];
+        this.timeoutMs = fields.timeoutMs;
+        this.env = fields.env;
+    }
+    _llmType() {
+        return this.provider;
+    }
+    /**
+     * Macht das Model in LangGraph-React-Agents nutzbar. Da die CLI keine nativen
+     * `tool_calls` liefert, werden die Tools als Spezifikationen gebunden und in
+     * `_generate` per Prompt-Protokoll emuliert (siehe `parseToolDecision`).
+     */
+    bindTools(tools, kwargs) {
+        const specs = tools.map(toToolSpec);
+        return this.withConfig({ tools: specs, ...kwargs });
+    }
+    /** Baut die Tool-Anweisung, die dem System-Prompt angehängt wird. */
+    buildToolInstruction(tools) {
+        const list = tools
+            .map((t) => `- ${t.name}: ${t.description}\n  Argumente (JSON-Schema): ${JSON.stringify(t.parameters)}`)
+            .join("\n");
+        return [
+            "Du hast Zugriff auf folgende Tools:",
+            list,
+            "",
+            "Wenn ein Tool die Anfrage beantworten hilft, rufe es auf. Beziehe dich bei Bedarf auf frühere Tool-Ergebnisse im Verlauf.",
+            "Antworte AUSSCHLIESSLICH mit GENAU EINEM JSON-Objekt — kein weiterer Text, keine Markdown-Codeblöcke:",
+            '- Tool aufrufen: {"tool_call": {"name": "<toolname>", "arguments": { ... }}}',
+            '- Endgültige Antwort an den Nutzer: {"final": "<deine Antwort>"}',
+        ].join("\n");
+    }
+    /** Messages → `{ systemPrompt, userPrompt }`. SystemMessages überschreiben `this.systemPrompt`. */
+    messagesToCliInput(messages) {
+        const systemParts = [];
+        const turns = [];
+        const nonSystem = [];
+        for (const message of messages) {
+            const role = messageRole(message);
+            const text = contentToText(message.content);
+            if (role === "system") {
+                systemParts.push(text);
+                continue;
+            }
+            nonSystem.push(message);
+            if (role === "tool") {
+                // Ergebnis eines Tool-Aufrufs (LangGraph `ToolMessage`).
+                const name = message.name ?? "tool";
+                turns.push(`Tool-Ergebnis [${name}]: ${text}`);
+            }
+            else if (role === "ai") {
+                const toolCalls = message.tool_calls;
+                if (toolCalls && toolCalls.length > 0) {
+                    const calls = toolCalls.map((tc) => `${tc.name}(${JSON.stringify(tc.args ?? {})})`).join(", ");
+                    turns.push(`Assistant (Tool-Aufruf): ${calls}`);
+                }
+                else {
+                    turns.push(`Assistant: ${text}`);
+                }
+            }
+            else {
+                turns.push(`Human: ${text}`);
+            }
+        }
+        const systemPrompt = systemParts.length > 0 ? systemParts.join("\n\n") : this.systemPrompt;
+        // Einzelner reiner User-Turn → nur dessen Inhalt; sonst ein lesbares Transkript.
+        const userPrompt = nonSystem.length === 1 && messageRole(nonSystem[0]) === "human"
+            ? contentToText(nonSystem[0].content)
+            : turns.join("\n\n");
+        return { systemPrompt, userPrompt };
+    }
+    async _generate(messages, options, _runManager) {
+        const { systemPrompt, userPrompt } = this.messagesToCliInput(messages);
+        const tools = options?.tools;
+        // Tool-Modus: System-Prompt um das Tool-Protokoll ergänzen und die Antwort als Tool-Aufruf/Final interpretieren.
+        const effectiveSystem = tools && tools.length > 0
+            ? [systemPrompt, this.buildToolInstruction(tools)].filter((s) => s && s.trim()).join("\n\n")
+            : systemPrompt;
+        const args = this.buildArgs(false, effectiveSystem);
+        const stdin = this.composeStdin(effectiveSystem, userPrompt);
+        const stdout = await this.runCli(args, stdin, options?.signal);
+        const parsed = this.parseFinal(stdout);
+        const responseMetadata = { ...parsed.responseMetadata, model: this.model, provider: this.provider };
+        if (tools && tools.length > 0) {
+            const decision = parseToolDecision(parsed.text);
+            if (decision.kind === "tool_call") {
+                const message = new AIMessage({
+                    content: "",
+                    tool_calls: decision.calls,
+                    usage_metadata: parsed.usage,
+                    response_metadata: responseMetadata,
+                });
+                return { generations: [{ text: "", message }], llmOutput: { tokenUsage: parsed.usage } };
+            }
+            const message = new AIMessage({
+                content: decision.text,
+                usage_metadata: parsed.usage,
+                response_metadata: responseMetadata,
+            });
+            return { generations: [{ text: decision.text, message }], llmOutput: { tokenUsage: parsed.usage } };
+        }
+        const message = new AIMessage({
+            content: parsed.text,
+            usage_metadata: parsed.usage,
+            response_metadata: responseMetadata,
+        });
+        return {
+            generations: [{ text: parsed.text, message }],
+            llmOutput: { ...parsed.responseMetadata, tokenUsage: parsed.usage },
+        };
+    }
+    async *_streamResponseChunks(messages, options, runManager) {
+        // Tool-Modus lässt sich nicht token-weise streamen (wir brauchen das ganze JSON
+        // zum Parsen). → einmal `_generate` ausführen und als ein Chunk samt tool_calls liefern.
+        if (options?.tools && options.tools.length > 0) {
+            const result = await this._generate(messages, options, runManager);
+            const gen = result.generations[0];
+            const aiMsg = gen.message;
+            const toolCalls = (aiMsg.tool_calls ?? []);
+            yield new ChatGenerationChunk({
+                text: gen.text,
+                message: new AIMessageChunk({
+                    content: aiMsg.content,
+                    tool_call_chunks: toolCalls.map((tc, i) => ({
+                        name: tc.name,
+                        args: JSON.stringify(tc.args ?? {}),
+                        id: tc.id,
+                        index: i,
+                        type: "tool_call_chunk",
+                    })),
+                    usage_metadata: aiMsg.usage_metadata,
+                    response_metadata: aiMsg.response_metadata,
+                }),
+            });
+            return;
+        }
+        const { systemPrompt, userPrompt } = this.messagesToCliInput(messages);
+        const args = this.buildArgs(true, systemPrompt);
+        const stdin = this.composeStdin(systemPrompt, userPrompt);
+        let finalUsage;
+        let finalMeta = {};
+        let lastRateLimit;
+        for await (const line of this.runCliStreaming(args, stdin, options?.signal)) {
+            const parsed = this.parseStreamLine(line);
+            if (!parsed)
+                continue;
+            if (parsed.rateLimit)
+                lastRateLimit = parsed.rateLimit;
+            if (parsed.error) {
+                // Mit zuvor gesehenen Rate-Limit-Infos anreichern (resetsAt/limitType aus `rate_limit_event`).
+                throw buildCliError(this.provider, parsed.error.message, {
+                    status: parsed.error.status,
+                    raw: line,
+                    limitType: parsed.error.limitType ?? lastRateLimit?.limitType,
+                    resetsAt: parsed.error.resetsAt ?? lastRateLimit?.resetsAt,
+                });
+            }
+            if (parsed.text) {
+                await runManager?.handleLLMNewToken(parsed.text);
+                yield new ChatGenerationChunk({
+                    text: parsed.text,
+                    message: new AIMessageChunk({ content: parsed.text }),
+                });
+            }
+            if (parsed.usage)
+                finalUsage = parsed.usage;
+            if (parsed.responseMetadata)
+                finalMeta = { ...finalMeta, ...parsed.responseMetadata };
+        }
+        // Abschluss-Chunk trägt Usage/Metadaten (analog zu nativen Chat-Models).
+        if (finalUsage || Object.keys(finalMeta).length > 0) {
+            yield new ChatGenerationChunk({
+                text: "",
+                message: new AIMessageChunk({
+                    content: "",
+                    usage_metadata: finalUsage,
+                    response_metadata: { ...finalMeta, model: this.model, provider: this.provider },
+                }),
+            });
+        }
+    }
+    /** Startet die CLI, schreibt stdin, sammelt stdout. Wirft bei Exit≠0, Timeout oder Abort. */
+    runCli(args, stdin, signal) {
+        return new Promise((resolve, reject) => {
+            const child = spawn(this.cliPath, args, {
+                cwd: this.cwd,
+                env: { ...process.env, ...this.env },
+                stdio: ["pipe", "pipe", "pipe"],
+            });
+            let stdout = "";
+            let stderr = "";
+            let timedOut = false;
+            const timer = this.timeoutMs
+                ? setTimeout(() => {
+                    timedOut = true;
+                    child.kill("SIGTERM");
+                }, this.timeoutMs)
+                : undefined;
+            const onAbort = () => child.kill("SIGTERM");
+            if (signal) {
+                if (signal.aborted)
+                    child.kill("SIGTERM");
+                else
+                    signal.addEventListener("abort", onAbort, { once: true });
+            }
+            const cleanup = () => {
+                if (timer)
+                    clearTimeout(timer);
+                if (signal)
+                    signal.removeEventListener("abort", onAbort);
+            };
+            child.stdout.on("data", (d) => (stdout += d.toString()));
+            child.stderr.on("data", (d) => (stderr += d.toString()));
+            child.on("error", (err) => {
+                cleanup();
+                reject(new CLIError(`Konnte '${this.cliPath}' nicht starten: ${err.message}. Ist die CLI installiert und im PATH?`, { provider: this.provider }));
+            });
+            child.on("close", (code) => {
+                cleanup();
+                if (timedOut)
+                    return reject(new CLIError(`${this.provider} CLI Timeout nach ${this.timeoutMs}ms`, { provider: this.provider, exitCode: code }));
+                if (signal?.aborted)
+                    return reject(new CLIError(`${this.provider} CLI abgebrochen`, { provider: this.provider, exitCode: code }));
+                if (code === 0)
+                    return resolve(stdout);
+                // Exit≠0: viele CLIs liefern einen strukturierten Fehler auf stdout (z.B. claude `is_error`).
+                // Den an parseFinal durchreichen, damit eine klare (ggf. Usage-Limit-)Fehlermeldung entsteht.
+                if (stdout.trim().length > 0)
+                    return resolve(stdout);
+                // Sonst aus stderr klassifizieren (z.B. ein Limit-Hinweis dort).
+                reject(buildCliError(this.provider, stderr.trim() || `CLI Exit-Code ${code}`, { exitCode: code }));
+            });
+            if (stdin)
+                child.stdin.write(stdin);
+            child.stdin.end();
+        });
+    }
+    /** Wie `runCli`, liefert stdout aber zeilenweise als Async-Iterator (für Streaming). */
+    async *runCliStreaming(args, stdin, signal) {
+        const child = spawn(this.cliPath, args, {
+            cwd: this.cwd,
+            env: { ...process.env, ...this.env },
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        let stderr = "";
+        let spawnError;
+        let timedOut = false;
+        child.stderr.on("data", (d) => (stderr += d.toString()));
+        child.on("error", (err) => {
+            spawnError = new CLIError(`Konnte '${this.cliPath}' nicht starten: ${err.message}. Ist die CLI installiert und im PATH?`, { provider: this.provider });
+        });
+        const closed = new Promise((resolve) => child.on("close", resolve));
+        const onAbort = () => child.kill("SIGTERM");
+        if (signal) {
+            if (signal.aborted)
+                child.kill("SIGTERM");
+            else
+                signal.addEventListener("abort", onAbort, { once: true });
+        }
+        const timer = this.timeoutMs
+            ? setTimeout(() => {
+                timedOut = true;
+                child.kill("SIGTERM");
+            }, this.timeoutMs)
+            : undefined;
+        if (stdin)
+            child.stdin.write(stdin);
+        child.stdin.end();
+        const rl = createInterface({ input: child.stdout, crlfDelay: Infinity });
+        try {
+            for await (const line of rl) {
+                if (line.trim().length > 0)
+                    yield line;
+            }
+        }
+        finally {
+            rl.close();
+            if (timer)
+                clearTimeout(timer);
+            if (signal)
+                signal.removeEventListener("abort", onAbort);
+        }
+        const code = await closed;
+        if (spawnError)
+            throw spawnError;
+        if (timedOut)
+            throw new CLIError(`${this.provider} CLI Timeout nach ${this.timeoutMs}ms`, { provider: this.provider, exitCode: code });
+        if (signal?.aborted)
+            throw new CLIError(`${this.provider} CLI abgebrochen`, { provider: this.provider, exitCode: code });
+        if (code !== 0 && code !== null) {
+            // Falls der Stream selbst kein Fehler-Event lieferte: aus stderr klassifizieren.
+            throw buildCliError(this.provider, stderr.trim() || `CLI Exit-Code ${code}`, { exitCode: code });
+        }
+    }
+}
+export class ClaudeCLI_LLM extends CLI_LLM {
+    static lc_name() {
+        return "ClaudeCLI_LLM";
+    }
+    constructor(fields = {}) {
+        super(fields, { model: "claude-opus-4-8", cliPath: "claude", provider: "claude-cli" });
+    }
+    buildArgs(stream, systemPrompt) {
+        const base = [
+            "-p",
+            "--model", this.model,
+            "--system-prompt", systemPrompt, // "" ersetzt den Default-Coding-Prompt
+            "--tools", "", // alle Built-in-Tools aus → reines LLM
+            "--strict-mcp-config", // keine fremden MCP-Server (saubere Umgebung)
+        ];
+        const output = stream
+            ? ["--output-format", "stream-json", "--verbose", "--include-partial-messages"]
+            : ["--output-format", "json"];
+        return [...base, ...output, ...this.extraArgs];
+    }
+    parseFinal(stdout) {
+        const obj = JSON.parse(stdout.trim());
+        if (obj.is_error) {
+            const message = typeof obj.result === "string" && obj.result.trim() ? obj.result : (obj.subtype ?? "unbekannter Fehler");
+            throw buildCliError(this.provider, message, {
+                status: typeof obj.api_error_status === "number" ? obj.api_error_status : undefined,
+                raw: obj,
+            });
+        }
+        const usage = obj.usage ?? {};
+        const input = Number(usage.input_tokens ?? 0);
+        const output = Number(usage.output_tokens ?? 0);
+        return {
+            text: typeof obj.result === "string" ? obj.result : "",
+            usage: { input_tokens: input, output_tokens: output, total_tokens: input + output },
+            responseMetadata: {
+                session_id: obj.session_id,
+                total_cost_usd: obj.total_cost_usd,
+                stop_reason: obj.stop_reason,
+            },
+            raw: obj,
+        };
+    }
+    parseStreamLine(line) {
+        let obj;
+        try {
+            obj = JSON.parse(line);
+        }
+        catch {
+            return undefined;
+        }
+        // Rate-Limit-Snapshot (kein Fehler) → als Hinweis (resetsAt/Bucket) für einen evtl. späteren Fehler.
+        if (obj.type === "rate_limit_event" && obj.rate_limit_info) {
+            const info = obj.rate_limit_info;
+            return {
+                rateLimit: {
+                    limitType: typeof info.rateLimitType === "string" ? info.rateLimitType : undefined,
+                    resetsAt: typeof info.resetsAt === "number" ? new Date(info.resetsAt * 1000) : undefined,
+                },
+            };
+        }
+        // Retry-Grund (rate_limit / billing_error) als Limit-Hinweis.
+        if (obj.type === "system" && obj.subtype === "api_retry" && (obj.error === "rate_limit" || obj.error === "billing_error")) {
+            return { rateLimit: { limitType: obj.error === "billing_error" ? "billing" : "rate_limit" } };
+        }
+        // Token-Deltas: { type:"stream_event", event:{ delta:{ type:"text_delta", text } } }
+        if (obj.type === "stream_event" && obj.event?.delta?.type === "text_delta") {
+            return { text: obj.event.delta.text };
+        }
+        // Abschluss-Event: Fehler oder Usage/Kosten.
+        if (obj.type === "result") {
+            if (obj.is_error) {
+                const message = typeof obj.result === "string" && obj.result.trim() ? obj.result : (obj.subtype ?? "unbekannter Fehler");
+                return {
+                    error: { message, status: typeof obj.api_error_status === "number" ? obj.api_error_status : undefined },
+                    done: true,
+                };
+            }
+            const usage = obj.usage ?? {};
+            const input = Number(usage.input_tokens ?? 0);
+            const output = Number(usage.output_tokens ?? 0);
+            return {
+                usage: { input_tokens: input, output_tokens: output, total_tokens: input + output },
+                responseMetadata: {
+                    session_id: obj.session_id,
+                    total_cost_usd: obj.total_cost_usd,
+                    stop_reason: obj.stop_reason,
+                },
+                done: true,
+            };
+        }
+        return undefined;
+    }
+}
+export class OpenAICLI_LLM extends CLI_LLM {
+    static lc_name() {
+        return "OpenAICLI_LLM";
+    }
+    constructor(fields = {}) {
+        super(fields, { model: "gpt-5.5", cliPath: "codex", provider: "openai-cli" });
+    }
+    buildArgs(_stream, _systemPrompt) {
+        // codex exec gibt mit --json in beiden Fällen NDJSON aus.
+        return [
+            "exec",
+            "--json",
+            "--sandbox", "read-only", // keine Datei-Schreibzugriffe
+            "--ask-for-approval", "never", // headless: nie nach Erlaubnis fragen
+            "--skip-git-repo-check", // läuft auch im neutralen (Nicht-Git-)cwd
+            "-m", this.model,
+            ...this.extraArgs,
+            "-", // Prompt komplett aus stdin lesen
+        ];
+    }
+    /** Codex hat kein `--system-prompt` → als Präambel voranstellen. */
+    composeStdin(systemPrompt, userPrompt) {
+        if (systemPrompt && systemPrompt.trim().length > 0) {
+            return `System:\n${systemPrompt}\n\n${userPrompt}`;
+        }
+        return userPrompt;
+    }
+    parseFinal(stdout) {
+        let text = "";
+        let usage;
+        const meta = {};
+        for (const line of stdout.split("\n")) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            let obj;
+            try {
+                obj = JSON.parse(trimmed);
+            }
+            catch {
+                continue;
+            }
+            if (obj.type === "thread.started" && obj.thread_id)
+                meta.thread_id = obj.thread_id;
+            if (obj.type === "item.completed" && obj.item?.type === "agent_message" && typeof obj.item.text === "string") {
+                text = obj.item.text;
+            }
+            if (obj.type === "turn.completed" && obj.usage) {
+                const input = Number(obj.usage.input_tokens ?? 0);
+                const output = Number(obj.usage.output_tokens ?? 0);
+                usage = { input_tokens: input, output_tokens: output, total_tokens: input + output };
+            }
+            if (obj.type === "turn.failed" || obj.type === "error") {
+                const errObj = obj.error ?? obj;
+                const detail = typeof errObj?.message === "string" ? errObj.message : JSON.stringify(errObj);
+                throw buildCliError(this.provider, `codex: ${detail}`, { raw: obj });
+            }
+        }
+        return { text, usage, responseMetadata: meta };
+    }
+    parseStreamLine(line) {
+        let obj;
+        try {
+            obj = JSON.parse(line);
+        }
+        catch {
+            return undefined;
+        }
+        // Codex liefert keine Token-Deltas → die finale agent_message kommt als ein Chunk.
+        if (obj.type === "item.completed" && obj.item?.type === "agent_message" && typeof obj.item.text === "string") {
+            return { text: obj.item.text };
+        }
+        if (obj.type === "turn.completed" && obj.usage) {
+            const input = Number(obj.usage.input_tokens ?? 0);
+            const output = Number(obj.usage.output_tokens ?? 0);
+            return {
+                usage: { input_tokens: input, output_tokens: output, total_tokens: input + output },
+                done: true,
+            };
+        }
+        if (obj.type === "turn.failed" || obj.type === "error") {
+            const errObj = obj.error ?? obj;
+            const detail = typeof errObj?.message === "string" ? errObj.message : JSON.stringify(errObj);
+            return { error: { message: `codex: ${detail}` }, done: true };
+        }
+        return undefined;
+    }
+}
+//# sourceMappingURL=cli-llms.js.map