@aiden-ade/sandbox-agent 0.1.5 → 0.1.6

package/dist/runtime-backends.js

@@ -0,0 +1,769 @@
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+function formatCliSpawnError(command, error) {
+    if (error.code === "ENOENT") {
+        return new Error(`CLI command not found: ${command}. Install it or configure this provider with the full executable path.`);
+    }
+    return error;
+}
+function buildPromptWithSystem(config, promptText) {
+    const parts = [
+        config.systemPrompt?.trim(),
+        config.systemPromptAppend?.trim(),
+        promptText.trim(),
+    ].filter((value) => Boolean(value && value.length > 0));
+    return parts.join("\n\n");
+}
+function buildPlanModePrefix(promptText) {
+    return [
+        "You are in plan-only mode.",
+        "Do not make code changes or execute write operations.",
+        "Focus on analysis, planning, and explaining the next steps.",
+        "",
+        promptText,
+    ].join("\n");
+}
+function spawnCli(command, args, context) {
+    const spawnWithShell = process.platform === "win32";
+    return spawn(command, args, {
+        cwd: context.cwd,
+        env: context.env,
+        stdio: ["pipe", "pipe", "pipe"],
+        shell: spawnWithShell,
+        signal: context.abortController.signal,
+    });
+}
+function createGenericCliBackend(options) {
+    return {
+        kind: options.kind,
+        supportTier: options.supportTier,
+        async run(context) {
+            const presenter = context.presenter;
+            const state = {
+                process: null,
+                iterations: 0,
+                summary: "",
+            };
+            const prompt = options.augmentPrompt?.(context) ??
+                (context.config.mode === "plan"
+                    ? buildPlanModePrefix(buildPromptWithSystem(context.config, context.promptText))
+                    : buildPromptWithSystem(context.config, context.promptText));
+            const args = options.buildArgs?.(context, prompt) ??
+                options.args.map((arg) => (arg === "{{prompt}}" ? prompt : arg));
+            const child = spawnCli(options.command, args, context);
+            state.process = child;
+            const safeArgs = args.map((a, i) => 
+            // Redact API keys but show everything else for debugging
+            (i > 0 && args[i - 1] === "--system-prompt") ? `"<system-prompt ${a.length} chars>"` : a);
+            console.info(`[${options.kind}] Spawning: ${options.command} ${safeArgs.join(" ")}`);
+            presenter.recordRawTranscript?.("system", `${options.command} ${args.join(" ")}`, {
+                backendKind: options.kind,
+            });
+            if (options.promptViaStdin) {
+                child.stdin.write(prompt);
+                child.stdin.end();
+            }
+            else {
+                child.stdin.end();
+            }
+            const stdoutRl = createInterface({ input: child.stdout });
+            const stderrRl = createInterface({ input: child.stderr });
+            const stderrLines = [];
+            stdoutRl.on("line", (line) => {
+                presenter.recordRawTranscript?.("stdout", line);
+                if (options.parseStructuredLine) {
+                    options.parseStructuredLine(line, context, state);
+                    return;
+                }
+                if (line.trim().length > 0) {
+                    state.summary += `${line}\n`;
+                    void presenter.onAssistantText(`${line}\n`);
+                }
+            });
+            stderrRl.on("line", (line) => {
+                presenter.recordRawTranscript?.("stderr", line);
+                if (line.trim().length > 0) {
+                    stderrLines.push(line);
+                    void presenter.onLog(`[${options.kind}] ${line}`);
+                }
+            });
+            const exitCode = await new Promise((resolve, reject) => {
+                child.on("error", (error) => {
+                    reject(formatCliSpawnError(options.command, error));
+                });
+                child.on("exit", (code) => resolve(code ?? 0));
+            });
+            if (exitCode !== 0) {
+                console.error(`[${options.kind}] Process exited with code ${exitCode}`, {
+                    stderrLines: stderrLines.slice(-10),
+                    summaryPreview: state.summary.slice(0, 200),
+                    error: state.error,
+                    runtimeSessionId: state.runtimeSessionId,
+                });
+            }
+            const hasRenderableTurn = state.summary.trim().length > 0 ||
+                state.iterations > 0;
+            if (hasRenderableTurn) {
+                await presenter.onTurnComplete([]);
+            }
+            const summary = state.summary.trim() ||
+                state.error?.trim() ||
+                (exitCode === 0 ? "Task completed" : "Task failed");
+            return {
+                success: exitCode === 0,
+                summary,
+                filesModified: [],
+                planFilesCreated: [],
+                iterations: Math.max(state.iterations, 1),
+                error: exitCode === 0
+                    ? undefined
+                    : state.error?.trim() ||
+                        (stderrLines.length > 0 ? stderrLines.join("\n").trim() : undefined) ||
+                        `${options.command} exited with code ${exitCode}`,
+                providerSessionId: state.runtimeSessionId,
+                runtimeSessionId: state.runtimeSessionId,
+                backendKind: options.kind,
+                supportTier: options.supportTier,
+                usage: state.usage,
+            };
+        },
+    };
+}
+function extractToolResultContent(content) {
+    if (typeof content === "string") {
+        return content;
+    }
+    if (!Array.isArray(content)) {
+        return "";
+    }
+    return content
+        .map((block) => {
+        if (typeof block === "object" &&
+            block !== null &&
+            "type" in block &&
+            block.type === "text" &&
+            "text" in block &&
+            typeof block.text === "string") {
+            return block.text;
+        }
+        return "";
+    })
+        .filter(Boolean)
+        .join("\n");
+}
+function parseClaudeStructuredLine(line, context, state) {
+    const presenter = context.presenter;
+    let parsed = null;
+    try {
+        parsed = JSON.parse(line);
+    }
+    catch {
+        state.summary += `${line}\n`;
+        void presenter.onAssistantText(`${line}\n`);
+        return;
+    }
+    const type = typeof parsed.type === "string" ? parsed.type : "";
+    if (!type)
+        return;
+    if (typeof parsed.session_id === "string") {
+        state.runtimeSessionId = parsed.session_id;
+    }
+    switch (type) {
+        case "system": {
+            if (parsed.subtype === "init") {
+                const model = typeof parsed.model === "string" ? parsed.model : "claude";
+                void presenter.onLog(`[claude_cli] Session initialized with ${model}`);
+            }
+            break;
+        }
+        case "assistant": {
+            state.iterations += 1;
+            const message = typeof parsed.message === "object" && parsed.message !== null
+                ? parsed.message
+                : null;
+            const content = Array.isArray(message?.content) ? message.content : [];
+            for (const block of content) {
+                if (typeof block !== "object" || block === null || !("type" in block)) {
+                    continue;
+                }
+                if (block.type === "text" && typeof block.text === "string") {
+                    const text = block.text;
+                    state.summary += `${text}\n`;
+                    void presenter.onAssistantText(text);
+                    continue;
+                }
+                if (block.type === "thinking" &&
+                    typeof block.thinking === "string") {
+                    void presenter.onThinking(block.thinking);
+                    continue;
+                }
+                if (block.type === "tool_use" &&
+                    typeof block.id === "string" &&
+                    typeof block.name === "string") {
+                    const toolBlock = block;
+                    void presenter.onToolUse(toolBlock.name, toolBlock.input ?? {}, toolBlock.id);
+                }
+            }
+            break;
+        }
+        case "user": {
+            const message = typeof parsed.message === "object" && parsed.message !== null
+                ? parsed.message
+                : null;
+            const content = Array.isArray(message?.content) ? message.content : [];
+            for (const block of content) {
+                if (typeof block === "object" &&
+                    block !== null &&
+                    "type" in block &&
+                    block.type === "tool_result" &&
+                    "tool_use_id" in block &&
+                    typeof block.tool_use_id === "string") {
+                    void presenter.onToolResult?.(block.tool_use_id, extractToolResultContent(block.content));
+                }
+            }
+            break;
+        }
+        case "result": {
+            const inputTokens = typeof parsed.usage === "object" &&
+                parsed.usage !== null &&
+                typeof parsed.usage.input_tokens === "number"
+                ? parsed.usage.input_tokens
+                : 0;
+            const outputTokens = typeof parsed.usage === "object" &&
+                parsed.usage !== null &&
+                typeof parsed.usage.output_tokens === "number"
+                ? parsed.usage.output_tokens
+                : 0;
+            const cacheReadTokens = typeof parsed.usage === "object" &&
+                parsed.usage !== null &&
+                typeof parsed.usage.cache_read_input_tokens === "number"
+                ? parsed.usage.cache_read_input_tokens
+                : 0;
+            const cacheCreationTokens = typeof parsed.usage === "object" &&
+                parsed.usage !== null &&
+                typeof parsed.usage.cache_creation_input_tokens === "number"
+                ? parsed.usage.cache_creation_input_tokens
+                : 0;
+            state.usage = {
+                model: typeof parsed.model === "string"
+                    ? parsed.model
+                    : typeof context.config.selectedModel === "string"
+                        ? context.config.selectedModel
+                        : "claude",
+                numTurns: typeof parsed.num_turns === "number" ? parsed.num_turns : Math.max(state.iterations, 1),
+                durationMs: typeof parsed.duration_ms === "number" ? parsed.duration_ms : 0,
+                inputTokens,
+                outputTokens,
+                cacheReadTokens,
+                cacheCreationTokens,
+                costUsd: typeof parsed.total_cost_usd === "number" ? parsed.total_cost_usd : 0,
+            };
+            void presenter.onUsageUpdate?.({
+                model: state.usage.model,
+                inputTokens: state.usage.inputTokens,
+                outputTokens: state.usage.outputTokens,
+                cacheReadTokens: state.usage.cacheReadTokens,
+                cacheCreationTokens: state.usage.cacheCreationTokens,
+            });
+            if (typeof parsed.result === "string" && parsed.result.trim().length > 0) {
+                state.summary = parsed.result.trim();
+            }
+            if (typeof parsed.num_turns === "number") {
+                state.iterations = parsed.num_turns;
+            }
+            const subtype = typeof parsed.subtype === "string" ? parsed.subtype : "";
+            if ((subtype === "error_during_execution" || subtype === "error_max_turns") &&
+                !state.error) {
+                const errObj = typeof parsed.error === "object" && parsed.error !== null
+                    ? parsed.error
+                    : null;
+                const errMsg = (typeof parsed.error === "string" && parsed.error.trim()) ||
+                    (errObj && typeof errObj.message === "string" && errObj.message.trim()) ||
+                    (typeof parsed.message === "string" && parsed.message.trim()) ||
+                    (typeof parsed.result === "string" && parsed.result.trim()) ||
+                    subtype;
+                state.error = errMsg;
+                const errFields = {
+                    error: parsed.error,
+                    message: parsed.message,
+                    result: typeof parsed.result === "string" ? parsed.result.slice(0, 200) : parsed.result,
+                    session_id: parsed.session_id,
+                    model: parsed.model,
+                    num_turns: parsed.num_turns,
+                    is_error: parsed.is_error,
+                };
+                console.error("[claude_cli] result subtype=", subtype, "error fields:", JSON.stringify(errFields));
+                console.error("[claude_cli] Full result event:", JSON.stringify(parsed).slice(0, 2000));
+            }
+            break;
+        }
+        default:
+            break;
+    }
+}
+function parseCodexStructuredLine(line, context, state) {
+    const presenter = context.presenter;
+    let parsed = null;
+    try {
+        parsed = JSON.parse(line);
+    }
+    catch {
+        state.summary += `${line}\n`;
+        void presenter.onAssistantText(`${line}\n`);
+        return;
+    }
+    const type = typeof parsed.type === "string" ? parsed.type : "";
+    if (!type)
+        return;
+    if (typeof parsed.thread_id === "string") {
+        state.runtimeSessionId = parsed.thread_id;
+    }
+    const extractCodexErrorMessage = (value) => {
+        if (typeof value !== "string") {
+            return "";
+        }
+        const trimmed = value.trim();
+        if (!trimmed) {
+            return "";
+        }
+        try {
+            const parsedValue = JSON.parse(trimmed);
+            if (typeof parsedValue.detail === "string" && parsedValue.detail.trim().length > 0) {
+                return parsedValue.detail.trim();
+            }
+            if (typeof parsedValue.message === "string" && parsedValue.message.trim().length > 0) {
+                return parsedValue.message.trim();
+            }
+        }
+        catch {
+            // Fall through to the raw string below.
+        }
+        return trimmed;
+    };
+    switch (type) {
+        case "thread.started":
+            break;
+        case "turn.started":
+            state.iterations += 1;
+            break;
+        case "session_configured":
+            if (typeof parsed.session_id === "string") {
+                state.runtimeSessionId = parsed.session_id;
+            }
+            break;
+        case "task_started":
+            state.iterations += 1;
+            break;
+        case "item.started": {
+            const item = typeof parsed.item === "object" && parsed.item !== null
+                ? parsed.item
+                : null;
+            if (!item || item.type !== "command_execution" || typeof item.id !== "string") {
+                break;
+            }
+            const command = typeof item.command === "string" ? item.command : "";
+            void presenter.onToolUse("Bash", { command, cwd: context.cwd }, item.id);
+            break;
+        }
+        case "item.completed": {
+            const item = typeof parsed.item === "object" && parsed.item !== null
+                ? parsed.item
+                : null;
+            if (!item || typeof item.type !== "string") {
+                break;
+            }
+            if (item.type === "reasoning" && typeof item.text === "string") {
+                void presenter.onThinking(item.text);
+                break;
+            }
+            if (item.type === "agent_message" && typeof item.text === "string") {
+                state.summary += `${item.text}\n`;
+                void presenter.onAssistantText(item.text);
+                break;
+            }
+            if (item.type === "command_execution" && typeof item.id === "string") {
+                const output = typeof item.aggregated_output === "string" ? item.aggregated_output : "";
+                const exitCode = typeof item.exit_code === "number" ? item.exit_code : null;
+                const resultText = output.trim().length > 0
+                    ? output
+                    : exitCode === null
+                        ? ""
+                        : `Exit code: ${exitCode}`;
+                void presenter.onToolResult?.(item.id, resultText);
+                break;
+            }
+            break;
+        }
+        case "agent_message_delta":
+        case "agent_message_content_delta": {
+            const delta = typeof parsed.delta === "string" ? parsed.delta : "";
+            if (!delta)
+                return;
+            state.summary += delta;
+            void presenter.onAssistantText(delta);
+            break;
+        }
+        case "agent_reasoning_delta":
+        case "reasoning_content_delta":
+        case "agent_reasoning_raw_content_delta": {
+            const delta = typeof parsed.delta === "string" ? parsed.delta : "";
+            if (!delta)
+                return;
+            void presenter.onThinking(delta);
+            break;
+        }
+        case "exec_command_begin": {
+            const toolId = typeof parsed.call_id === "string" ? parsed.call_id : `exec-${Date.now()}`;
+            const command = Array.isArray(parsed.command) ? parsed.command.join(" ") : "";
+            const cwd = typeof parsed.cwd === "string" ? parsed.cwd : context.cwd;
+            void presenter.onToolUse("Bash", { command, cwd }, toolId);
+            break;
+        }
+        case "exec_command_end": {
+            const toolId = typeof parsed.call_id === "string" ? parsed.call_id : `exec-${Date.now()}`;
+            const output = typeof parsed.formatted_output === "string"
+                ? parsed.formatted_output
+                : typeof parsed.aggregated_output === "string"
+                    ? parsed.aggregated_output
+                    : "";
+            void presenter.onToolResult?.(toolId, output);
+            break;
+        }
+        case "mcp_tool_call_begin": {
+            const toolId = typeof parsed.call_id === "string" ? parsed.call_id : `mcp-${Date.now()}`;
+            const invocation = typeof parsed.invocation === "object" && parsed.invocation !== null
+                ? parsed.invocation
+                : {};
+            const tool = typeof invocation.tool_name === "string"
+                ? invocation.tool_name
+                : typeof invocation.tool === "string"
+                    ? invocation.tool
+                    : "MCP Tool";
+            void presenter.onToolUse(tool, invocation, toolId);
+            break;
+        }
+        case "mcp_tool_call_end": {
+            const toolId = typeof parsed.call_id === "string" ? parsed.call_id : `mcp-${Date.now()}`;
+            const result = parsed.result;
+            void presenter.onToolResult?.(toolId, JSON.stringify(result ?? {}, null, 2));
+            break;
+        }
+        case "token_count": {
+            const info = typeof parsed.info === "object" && parsed.info !== null
+                ? parsed.info
+                : {};
+            const inputTokens = typeof info.input_tokens === "number" ? info.input_tokens : 0;
+            const outputTokens = typeof info.output_tokens === "number" ? info.output_tokens : 0;
+            state.usage = {
+                model: typeof info.model === "string" ? info.model : "codex",
+                numTurns: Math.max(state.iterations, 1),
+                durationMs: 0,
+                inputTokens,
+                outputTokens,
+                cacheReadTokens: typeof info.cached_input_tokens === "number" ? info.cached_input_tokens : 0,
+                cacheCreationTokens: 0,
+                costUsd: typeof info.total_cost_usd === "number" ? info.total_cost_usd : 0,
+            };
+            void presenter.onUsageUpdate?.({
+                model: state.usage.model,
+                inputTokens: state.usage.inputTokens,
+                outputTokens: state.usage.outputTokens,
+                cacheReadTokens: state.usage.cacheReadTokens,
+                cacheCreationTokens: state.usage.cacheCreationTokens,
+            });
+            break;
+        }
+        case "task_complete": {
+            const lastMessage = typeof parsed.last_agent_message === "string" ? parsed.last_agent_message : "";
+            if (lastMessage.length > 0) {
+                state.summary = lastMessage;
+            }
+            break;
+        }
+        case "turn.completed": {
+            const usage = typeof parsed.usage === "object" && parsed.usage !== null
+                ? parsed.usage
+                : {};
+            const inputTokens = typeof usage.input_tokens === "number" ? usage.input_tokens : 0;
+            const outputTokens = typeof usage.output_tokens === "number" ? usage.output_tokens : 0;
+            const cacheReadTokens = typeof usage.cached_input_tokens === "number" ? usage.cached_input_tokens : 0;
+            state.usage = {
+                model: typeof context.config.selectedModel === "string" && context.config.selectedModel.trim()
+                    ? context.config.selectedModel
+                    : "codex",
+                numTurns: Math.max(state.iterations, 1),
+                durationMs: 0,
+                inputTokens,
+                outputTokens,
+                cacheReadTokens,
+                cacheCreationTokens: 0,
+                costUsd: 0,
+            };
+            void presenter.onUsageUpdate?.({
+                model: state.usage.model,
+                inputTokens: state.usage.inputTokens,
+                outputTokens: state.usage.outputTokens,
+                cacheReadTokens: state.usage.cacheReadTokens,
+                cacheCreationTokens: state.usage.cacheCreationTokens,
+            });
+            break;
+        }
+        case "error": {
+            const message = extractCodexErrorMessage(parsed.message);
+            if (message) {
+                state.error = message;
+            }
+            break;
+        }
+        case "turn.failed": {
+            const error = typeof parsed.error === "object" && parsed.error !== null
+                ? parsed.error
+                : {};
+            const message = extractCodexErrorMessage(error.message);
+            if (message) {
+                state.error = message;
+            }
+            break;
+        }
+        default:
+            break;
+    }
+}
+function buildGeminiToolResultText(parsed) {
+    const output = typeof parsed.output === "string" ? parsed.output : "";
+    if (output.trim().length > 0) {
+        return output;
+    }
+    const error = typeof parsed.error === "object" && parsed.error !== null
+        ? parsed.error
+        : null;
+    const message = typeof error?.message === "string" ? error.message.trim() : "";
+    const errorType = typeof error?.type === "string" ? error.type.trim() : "";
+    if (message && errorType) {
+        return `${errorType}: ${message}`;
+    }
+    if (message) {
+        return message;
+    }
+    const status = typeof parsed.status === "string" ? parsed.status.trim() : "";
+    return status || "Tool completed";
+}
+function parseGeminiStructuredLine(line, context, state) {
+    const presenter = context.presenter;
+    let parsed = null;
+    try {
+        parsed = JSON.parse(line);
+    }
+    catch {
+        state.summary += `${line}\n`;
+        void presenter.onAssistantText(`${line}\n`);
+        return;
+    }
+    const type = typeof parsed.type === "string" ? parsed.type : "";
+    if (!type) {
+        return;
+    }
+    if (typeof parsed.session_id === "string") {
+        state.runtimeSessionId = parsed.session_id;
+    }
+    if (typeof parsed.model === "string") {
+        state.activeModel = parsed.model;
+    }
+    switch (type) {
+        case "init": {
+            const model = state.activeModel || context.config.selectedModel || "gemini";
+            void presenter.onLog(`[gemini_cli] Session initialized with ${model}`);
+            break;
+        }
+        case "message": {
+            const role = typeof parsed.role === "string" ? parsed.role : "";
+            if (role !== "assistant") {
+                break;
+            }
+            const content = typeof parsed.content === "string" ? parsed.content : "";
+            if (!content) {
+                break;
+            }
+            state.iterations = Math.max(state.iterations, 1);
+            state.summary += content;
+            void presenter.onAssistantText(content);
+            break;
+        }
+        case "tool_use": {
+            const toolName = typeof parsed.tool_name === "string" ? parsed.tool_name : "Gemini Tool";
+            const toolId = typeof parsed.tool_id === "string" ? parsed.tool_id : `gemini-tool-${Date.now()}`;
+            state.iterations = Math.max(state.iterations, 1);
+            void presenter.onToolUse(toolName, parsed.parameters ?? {}, toolId);
+            break;
+        }
+        case "tool_result": {
+            const toolId = typeof parsed.tool_id === "string" ? parsed.tool_id : `gemini-tool-${Date.now()}`;
+            state.iterations = Math.max(state.iterations, 1);
+            void presenter.onToolResult?.(toolId, buildGeminiToolResultText(parsed));
+            break;
+        }
+        case "error": {
+            const message = typeof parsed.message === "string" ? parsed.message.trim() : "";
+            const severity = typeof parsed.severity === "string" ? parsed.severity : "error";
+            if (message) {
+                void presenter.onLog(`[gemini_cli/${severity}] ${message}`);
+                if (severity === "error") {
+                    state.error = message;
+                }
+            }
+            break;
+        }
+        case "result": {
+            const stats = typeof parsed.stats === "object" && parsed.stats !== null
+                ? parsed.stats
+                : {};
+            state.iterations = Math.max(state.iterations, 1);
+            state.usage = {
+                model: state.activeModel ||
+                    (typeof context.config.selectedModel === "string" && context.config.selectedModel.trim()
+                        ? context.config.selectedModel
+                        : "gemini"),
+                numTurns: Math.max(state.iterations, 1),
+                durationMs: typeof stats.duration_ms === "number" ? stats.duration_ms : 0,
+                inputTokens: typeof stats.input_tokens === "number"
+                    ? stats.input_tokens
+                    : typeof stats.input === "number"
+                        ? stats.input
+                        : 0,
+                outputTokens: typeof stats.output_tokens === "number" ? stats.output_tokens : 0,
+                cacheReadTokens: typeof stats.cached === "number" ? stats.cached : 0,
+                cacheCreationTokens: 0,
+                costUsd: 0,
+            };
+            void presenter.onUsageUpdate?.({
+                model: state.usage.model,
+                inputTokens: state.usage.inputTokens,
+                outputTokens: state.usage.outputTokens,
+                cacheReadTokens: state.usage.cacheReadTokens,
+                cacheCreationTokens: state.usage.cacheCreationTokens,
+            });
+            if (typeof parsed.status === "string" && parsed.status !== "success" && !state.error) {
+                state.error = parsed.status;
+            }
+            break;
+        }
+        default:
+            break;
+    }
+}
+function getClaudePermissionMode(mode) {
+    switch (mode) {
+        case "plan":
+        case "ask":
+        case "review":
+            return "plan";
+        default:
+            return "bypassPermissions";
+    }
+}
+export function createClaudeCliBackend(command = "claude", defaultArgs = []) {
+    return {
+        kind: "claude_cli",
+        supportTier: "structured",
+        async run(context) {
+            const args = [
+                "--print",
+                "--verbose",
+                "--output-format",
+                "stream-json",
+                "--permission-mode",
+                getClaudePermissionMode(context.config.mode),
+            ];
+            if (context.config.systemPrompt?.trim()) {
+                args.push("--system-prompt", context.config.systemPrompt.trim());
+            }
+            if (context.config.systemPromptAppend?.trim()) {
+                args.push("--append-system-prompt", context.config.systemPromptAppend.trim());
+            }
+            if (context.config.selectedModel?.trim()) {
+                args.push("--model", context.config.selectedModel.trim());
+            }
+            const resumeId = context.config.runtimeSessionId?.trim() || context.config.providerSessionId?.trim();
+            if (resumeId) {
+                args.push("--resume", resumeId);
+                console.info("[claude_cli] Resuming session", { resumeId });
+            }
+            args.push(...defaultArgs, context.promptText);
+            return createGenericCliBackend({
+                kind: "claude_cli",
+                supportTier: "structured",
+                command,
+                args,
+                parseStructuredLine: parseClaudeStructuredLine,
+            }).run(context);
+        },
+    };
+}
+export function createGeminiCliBackend(command = "gemini", defaultArgs = []) {
+    return createGenericCliBackend({
+        kind: "gemini_cli",
+        supportTier: "structured",
+        command,
+        args: [],
+        buildArgs: (context) => {
+            const args = ["-p", "", "--output-format", "stream-json"];
+            const resumeId = context.config.runtimeSessionId?.trim() || context.config.providerSessionId?.trim();
+            const approvalMode = context.config.mode === "plan" ||
+                context.config.mode === "ask" ||
+                context.config.mode === "review"
+                ? "plan"
+                : "yolo";
+            args.push("--approval-mode", approvalMode);
+            if (resumeId) {
+                args.push("--resume", resumeId);
+            }
+            if (context.config.selectedModel?.trim()) {
+                args.push("--model", context.config.selectedModel.trim());
+            }
+            return [...args, ...defaultArgs];
+        },
+        promptViaStdin: true,
+        augmentPrompt: (context) => {
+            const basePrompt = buildPromptWithSystem(context.config, context.promptText);
+            if (context.config.mode === "plan") {
+                return buildPlanModePrefix(basePrompt);
+            }
+            return basePrompt;
+        },
+        parseStructuredLine: parseGeminiStructuredLine,
+    });
+}
+export function createGenericCliPassthroughBackend(command, defaultArgs = []) {
+    return createGenericCliBackend({
+        kind: "generic_cli",
+        supportTier: "text",
+        command,
+        args: defaultArgs,
+        promptViaStdin: true,
+    });
+}
+export function createCodexRuntimeBackend(command = "codex", defaultArgs = []) {
+    return createGenericCliBackend({
+        kind: "codex_app_server",
+        supportTier: "structured",
+        command,
+        args: [],
+        buildArgs: (context) => {
+            const resumeId = context.config.runtimeSessionId?.trim() || context.config.providerSessionId?.trim();
+            const baseArgs = resumeId
+                ? ["exec", "resume", "--json", "--skip-git-repo-check", resumeId, "-"]
+                : ["exec", "--json", "--skip-git-repo-check", "-"];
+            return [...baseArgs, ...defaultArgs];
+        },
+        promptViaStdin: true,
+        augmentPrompt: (context) => {
+            const basePrompt = buildPromptWithSystem(context.config, context.promptText);
+            if (context.config.mode === "plan") {
+                return buildPlanModePrefix(basePrompt);
+            }
+            return basePrompt;
+        },
+        parseStructuredLine: parseCodexStructuredLine,
+    });
+}
+//# sourceMappingURL=runtime-backends.js.map