@infomity/remogent 0.0.0-stage → 0.2.0

package/dist/adapters/codex.js

@@ -0,0 +1,428 @@
+import { RpcError, RpcPeer } from "./rpc.js";
+import { findOnPath, killTree, spawnCli } from "./util.js";
+const isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+const str = (v) => (typeof v === "string" && v.length > 0 ? v : undefined);
+/** Cap on tool output stored in a transcript event. */
+const MAX_OUTPUT = 64 * 1024;
+const cap = (s) => (s.length > MAX_OUTPUT ? s.slice(0, MAX_OUTPUT) : s);
+/** If Codex has not reported the end of an interrupted turn after this long, end it ourselves so the app unlocks. */
+const INTERRUPT_GRACE_MS = 15_000;
+/**
+ * Remogent permission mode -> Codex approval policy + sandbox.
+ * ask: everything except known read-only commands needs approval; plan: read-only and never ask (it cannot change
+ * anything); auto_edit: edits inside the workspace run, anything outside the sandbox asks; auto: no sandbox, no prompts.
+ */
+const POLICIES = {
+    ask: { approvalPolicy: "untrusted", sandbox: "workspace-write" },
+    plan: { approvalPolicy: "never", sandbox: "read-only" },
+    auto_edit: { approvalPolicy: "on-request", sandbox: "workspace-write" },
+    auto: { approvalPolicy: "never", sandbox: "danger-full-access" },
+};
+/** Path of the `codex` executable if it is installed on this host. */
+export function findCodex() {
+    return findOnPath("codex");
+}
+const stripAnsi = (s) => s.replace(/\u001b\[[0-9;]*m/g, "");
+function lastLine(s) {
+    const lines = stripAnsi(s).trim().split(/\r?\n/);
+    return lines[lines.length - 1] ?? "";
+}
+// ---- app-server -> Remogent mapping ----
+function actionRisk(actions) {
+    if (!Array.isArray(actions) || actions.length === 0)
+        return "shell";
+    const readOnly = actions.every((a) => isObj(a) && (a["type"] === "read" || a["type"] === "listFiles" || a["type"] === "search"));
+    return readOnly ? "read" : "shell";
+}
+function commandTitle(item) {
+    const acts = Array.isArray(item["commandActions"]) ? item["commandActions"] : [];
+    const cmds = acts.map((a) => (isObj(a) ? str(a["command"]) : undefined)).filter((c) => !!c);
+    const t = cmds.length ? cmds.join(" ; ") : (str(item["command"]) ?? "command");
+    return t.length > 200 ? t.slice(0, 200) + "..." : t;
+}
+function changePaths(changes) {
+    if (!Array.isArray(changes))
+        return [];
+    return changes.map((c) => (isObj(c) ? str(c["path"]) : undefined)).filter((p) => !!p);
+}
+function changesDiff(changes) {
+    if (!Array.isArray(changes))
+        return undefined;
+    const parts = [];
+    for (const c of changes) {
+        if (!isObj(c))
+            continue;
+        const path = str(c["path"]);
+        if (!path)
+            continue;
+        const kind = isObj(c["kind"]) ? str(c["kind"]["type"]) : undefined;
+        const diff = typeof c["diff"] === "string" ? c["diff"] : "";
+        parts.push(`${kind ?? "change"} ${path}\n${diff}`.trimEnd());
+    }
+    return parts.length ? cap(parts.join("\n\n")) : undefined;
+}
+function toolStart(item) {
+    const toolCallId = str(item["id"]);
+    if (!toolCallId)
+        return undefined;
+    const titled = (title) => (title ? { title } : {});
+    switch (item["type"]) {
+        case "commandExecution":
+            return {
+                kind: "tool_call",
+                toolCallId,
+                name: "shell",
+                title: commandTitle(item),
+                risk: actionRisk(item["commandActions"]),
+                input: { command: item["command"], cwd: item["cwd"] },
+            };
+        case "fileChange": {
+            const paths = changePaths(item["changes"]);
+            return { kind: "tool_call", toolCallId, name: "edit", title: paths.length ? `Edit ${paths.join(", ")}` : "Edit files", risk: "edit", input: { files: paths } };
+        }
+        case "mcpToolCall": {
+            const name = [str(item["server"]), str(item["tool"])].filter(Boolean).join(".");
+            return { kind: "tool_call", toolCallId, name: name || "mcp", risk: "other", input: item["arguments"] ?? {} };
+        }
+        case "webSearch":
+            return { kind: "tool_call", toolCallId, name: "web_search", ...titled(str(item["query"])), risk: "network", input: { query: item["query"] } };
+        case "dynamicToolCall":
+            return { kind: "tool_call", toolCallId, name: str(item["tool"]) ?? "tool", risk: "other", input: item["arguments"] ?? {} };
+        default:
+            return undefined; // userMessage, agentMessage, reasoning, plan, ...
+    }
+}
+function toolEnd(item) {
+    const toolCallId = str(item["id"]);
+    if (!toolCallId)
+        return undefined;
+    const type = item["type"];
+    if (type !== "commandExecution" && type !== "fileChange" && type !== "mcpToolCall" && type !== "webSearch" && type !== "dynamicToolCall") {
+        return undefined;
+    }
+    const s = str(item["status"]);
+    const declined = s === "declined";
+    const status = s === "completed" ? "completed" : s === "failed" || declined ? "failed" : "running";
+    let output;
+    let diff;
+    if (type === "commandExecution")
+        output = str(item["aggregatedOutput"]);
+    else if (type === "fileChange")
+        diff = changesDiff(item["changes"]);
+    else if (type === "mcpToolCall") {
+        const r = item["error"] ?? item["result"];
+        if (r !== undefined && r !== null)
+            output = cap(typeof r === "string" ? r : JSON.stringify(r));
+    }
+    if (!output && declined)
+        output = "Declined.";
+    return {
+        kind: "tool_call_update",
+        toolCallId,
+        status: type === "webSearch" && status === "running" ? "completed" : status,
+        ...(output ? { output: cap(output) } : {}),
+        ...(diff ? { diff } : {}),
+    };
+}
+export function createCodexAdapter(binary) {
+    return {
+        engine: "codex",
+        resumable: true,
+        async start({ cwd, permissionMode, resumeId }, sink) {
+            const policy = POLICIES[permissionMode];
+            let threadId = resumeId;
+            let conn;
+            let ready;
+            let closed = false; // intentionally closed by the host
+            let turn;
+            let textInTurn = false;
+            let lastMsgItem;
+            const deltaItems = new Set();
+            const fileChanges = new Map(); // itemId -> changes, for approval diffs
+            const finishTurn = (t, status, errorMessage) => {
+                if (turn !== t)
+                    return;
+                turn = undefined;
+                if (status === "failed" && errorMessage && t.lastError !== errorMessage)
+                    sink.emit({ kind: "error", message: errorMessage });
+                sink.emit({
+                    kind: "turn_end",
+                    stopReason: status === "interrupted" ? "cancelled" : status === "failed" ? "error" : "end_turn",
+                    ...(t.usage !== undefined ? { usage: t.usage } : {}),
+                });
+                t.resolve();
+            };
+            const handleNotification = (method, params) => {
+                if (!isObj(params))
+                    return;
+                const tid = str(params["threadId"]);
+                if (tid && threadId && tid !== threadId)
+                    return; // another (sub-agent) thread
+                switch (method) {
+                    case "item/agentMessage/delta": {
+                        const delta = typeof params["delta"] === "string" ? params["delta"] : "";
+                        const itemId = str(params["itemId"]);
+                        if (!delta)
+                            return;
+                        // Each agent message item is its own paragraph (commentary before tools, then the final answer).
+                        if (itemId && itemId !== lastMsgItem && textInTurn)
+                            sink.emit({ kind: "agent_text_delta", text: "\n\n" });
+                        if (itemId) {
+                            lastMsgItem = itemId;
+                            deltaItems.add(itemId);
+                        }
+                        textInTurn = true;
+                        sink.emit({ kind: "agent_text_delta", text: delta });
+                        return;
+                    }
+                    case "item/reasoning/summaryTextDelta":
+                    case "item/reasoning/textDelta": {
+                        const delta = typeof params["delta"] === "string" ? params["delta"] : "";
+                        if (delta)
+                            sink.emit({ kind: "agent_thought_delta", text: delta });
+                        return;
+                    }
+                    case "item/started": {
+                        const item = params["item"];
+                        if (!isObj(item))
+                            return;
+                        if (item["type"] === "fileChange")
+                            fileChanges.set(String(item["id"]), item["changes"]);
+                        const ev = toolStart(item);
+                        if (ev)
+                            sink.emit(ev);
+                        return;
+                    }
+                    case "item/fileChange/patchUpdated": {
+                        const itemId = str(params["itemId"]);
+                        if (itemId)
+                            fileChanges.set(itemId, params["changes"]);
+                        return;
+                    }
+                    case "item/completed": {
+                        const item = params["item"];
+                        if (!isObj(item))
+                            return;
+                        if (item["type"] === "agentMessage") {
+                            // Whole message without streamed deltas (some items arrive complete): show it now.
+                            const id = str(item["id"]);
+                            const text = str(item["text"]);
+                            if (text && (!id || !deltaItems.has(id))) {
+                                if (textInTurn)
+                                    sink.emit({ kind: "agent_text_delta", text: "\n\n" });
+                                textInTurn = true;
+                                if (id)
+                                    lastMsgItem = id;
+                                sink.emit({ kind: "agent_text_delta", text });
+                            }
+                            return;
+                        }
+                        const ev = toolEnd(item);
+                        if (ev)
+                            sink.emit(ev);
+                        return;
+                    }
+                    case "thread/tokenUsage/updated": {
+                        if (turn && params["tokenUsage"] !== undefined)
+                            turn.usage = params["tokenUsage"];
+                        return;
+                    }
+                    case "error": {
+                        const err = isObj(params["error"]) ? params["error"] : {};
+                        const message = str(err["message"]);
+                        if (params["willRetry"] === true || !message)
+                            return;
+                        if (turn)
+                            turn.lastError = message;
+                        sink.emit({ kind: "error", message });
+                        return;
+                    }
+                    case "turn/completed": {
+                        const t = turn;
+                        const tn = isObj(params["turn"]) ? params["turn"] : {};
+                        if (!t)
+                            return;
+                        if (t.id && str(tn["id"]) && t.id !== tn["id"])
+                            return;
+                        const err = isObj(tn["error"]) ? str(tn["error"]["message"]) : undefined;
+                        finishTurn(t, str(tn["status"]) ?? "completed", err ?? "the turn failed");
+                        return;
+                    }
+                    default:
+                        return; // thread/*, mcpServer/*, account/*, rate limits, warnings, ...
+                }
+            };
+            const decide = (d) => (d === "deny" ? "decline" : "accept");
+            const handleRequest = async (method, params) => {
+                const p = isObj(params) ? params : {};
+                switch (method) {
+                    case "item/commandExecution/requestApproval": {
+                        const itemId = str(p["itemId"]);
+                        const decision = await sink.requestPermission({
+                            ...(itemId ? { toolCallId: itemId } : {}),
+                            tool: "shell",
+                            risk: p["networkApprovalContext"] ? "network" : actionRisk(p["commandActions"]),
+                            summary: str(p["reason"]) ?? commandTitle(p),
+                            input: { command: p["command"], cwd: p["cwd"], reason: p["reason"] },
+                        });
+                        // allow_session is tracked by the host; toward Codex it is a one-time accept, so Codex never persists an
+                        // exec-policy rule on disk.
+                        return { decision: decide(decision) };
+                    }
+                    case "item/fileChange/requestApproval": {
+                        const itemId = str(p["itemId"]);
+                        const changes = itemId ? fileChanges.get(itemId) : undefined;
+                        const paths = changePaths(changes);
+                        const diff = changesDiff(changes);
+                        const decision = await sink.requestPermission({
+                            ...(itemId ? { toolCallId: itemId } : {}),
+                            tool: "edit",
+                            risk: "edit",
+                            summary: str(p["reason"]) ?? (paths.length ? `Edit ${paths.join(", ")}` : "Apply file changes"),
+                            input: { files: paths, ...(p["grantRoot"] ? { grantRoot: p["grantRoot"] } : {}) },
+                            ...(diff ? { diff } : {}),
+                        });
+                        return { decision: decide(decision) };
+                    }
+                    case "item/permissions/requestApproval": {
+                        const itemId = str(p["itemId"]);
+                        const wanted = isObj(p["permissions"]) ? p["permissions"] : {};
+                        const decision = await sink.requestPermission({
+                            ...(itemId ? { toolCallId: itemId } : {}),
+                            tool: "permissions",
+                            risk: wanted["network"] ? "network" : "edit",
+                            summary: str(p["reason"]) ?? "Codex asks for extra permissions",
+                            input: wanted,
+                        });
+                        return { permissions: decision === "deny" ? {} : wanted, scope: "turn" };
+                    }
+                    case "mcpServer/elicitation/request":
+                        return { action: "decline" };
+                    case "item/tool/requestUserInput":
+                        return { answers: {} };
+                    case "applyPatchApproval":
+                    case "execCommandApproval":
+                        return { decision: "denied" }; // legacy (v1) approvals: never used by this adapter's threads
+                    default:
+                        throw new RpcError(-32601, `unsupported method: ${method}`);
+                }
+            };
+            const boot = async () => {
+                const child = spawnCli(binary, ["app-server"], cwd);
+                const rpc = new RpcPeer(child, { jsonrpcField: false });
+                const c = { child, rpc, alive: true };
+                let stderrTail = "";
+                child.stderr.on("data", (d) => {
+                    stderrTail = (stderrTail + d.toString()).slice(-2000); // kept only for exit diagnostics; never logged
+                });
+                const died = (why) => {
+                    if (!c.alive)
+                        return;
+                    c.alive = false;
+                    const err = new Error(stderrTail ? `${why}: ${lastLine(stderrTail)}` : why);
+                    rpc.failAll(err);
+                    const t = turn;
+                    if (closed || !t)
+                        return;
+                    turn = undefined;
+                    t.reject(err); // the prompt rejection reports the death; the next prompt respawns and resumes the thread
+                };
+                child.on("exit", (code) => died(`codex exited (code ${code})`));
+                child.on("error", (e) => died(`codex failed to start: ${e.message}`));
+                rpc.onNotification = handleNotification;
+                rpc.onRequest = handleRequest;
+                try {
+                    await rpc.request("initialize", {
+                        clientInfo: { name: "remogent", title: "Remogent", version: process.env["npm_package_version"] ?? "dev" },
+                    });
+                    rpc.notify("initialized");
+                    const settings = { cwd, approvalPolicy: policy.approvalPolicy, sandbox: policy.sandbox };
+                    if (threadId) {
+                        await rpc.request("thread/resume", { threadId, excludeTurns: true, ...settings });
+                    }
+                    else {
+                        const res = await rpc.request("thread/start", settings);
+                        const thread = isObj(res) ? res["thread"] : undefined;
+                        threadId = isObj(thread) ? str(thread["id"]) : undefined;
+                        if (!threadId)
+                            throw new Error("codex did not return a thread id");
+                    }
+                }
+                catch (e) {
+                    c.alive = false;
+                    killTree(child);
+                    const msg = e instanceof Error ? e.message : String(e);
+                    throw new Error(/auth|login|sign.?in|unauthor/i.test(msg) ? `${msg} (run \`codex login\` once on the host to sign in)` : msg);
+                }
+                return c;
+            };
+            const ensure = () => {
+                if (conn?.alive)
+                    return Promise.resolve(conn);
+                ready ??= boot()
+                    .then((c) => (conn = c))
+                    .finally(() => {
+                    ready = undefined;
+                });
+                return ready;
+            };
+            // A new chat starts the CLI now (so a missing login shows up immediately); a restored chat waits for its next prompt.
+            if (!resumeId)
+                await ensure();
+            return {
+                async prompt(text) {
+                    if (closed)
+                        throw new Error("codex session is closed");
+                    const c = await ensure();
+                    const t = { cancelled: false, resolve: () => { }, reject: () => { } };
+                    const done = new Promise((resolve, reject) => {
+                        t.resolve = resolve;
+                        t.reject = reject;
+                    });
+                    turn = t;
+                    textInTurn = false;
+                    lastMsgItem = undefined;
+                    deltaItems.clear();
+                    try {
+                        const res = await c.rpc.request("turn/start", { threadId, input: [{ type: "text", text, text_elements: [] }] });
+                        const tn = isObj(res) ? res["turn"] : undefined;
+                        const id = isObj(tn) ? str(tn["id"]) : undefined;
+                        if (turn === t && id) {
+                            t.id = id;
+                            if (t.cancelled)
+                                void c.rpc.request("turn/interrupt", { threadId, turnId: id }).catch(() => { });
+                        }
+                    }
+                    catch (e) {
+                        if (turn === t)
+                            turn = undefined;
+                        throw e;
+                    }
+                    await done;
+                },
+                cancel() {
+                    const t = turn;
+                    const c = conn;
+                    if (!t || !c?.alive || t.cancelled)
+                        return;
+                    t.cancelled = true;
+                    if (t.id)
+                        void c.rpc.request("turn/interrupt", { threadId, turnId: t.id }).catch(() => { });
+                    setTimeout(() => finishTurn(t, "interrupted"), INTERRUPT_GRACE_MS).unref();
+                },
+                close() {
+                    closed = true;
+                    const t = turn;
+                    turn = undefined;
+                    t?.resolve();
+                    if (conn) {
+                        conn.alive = false;
+                        killTree(conn.child);
+                    }
+                },
+                engineSessionId: () => threadId,
+            };
+        },
+    };
+}
+//# sourceMappingURL=codex.js.map

package/dist/adapters/gemini.js

@@ -0,0 +1,229 @@
+import { RpcError, RpcPeer } from "./rpc.js";
+import { findOnPath, killTree, spawnCli } from "./util.js";
+const isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+const str = (v) => (typeof v === "string" && v.length > 0 ? v : undefined);
+/** Cap on tool output stored in a transcript event. */
+const MAX_OUTPUT = 64 * 1024;
+// ---- ACP -> Remogent mapping ----
+/** ACP ToolKind -> protocol risk. */
+function riskOf(kind) {
+    switch (kind) {
+        case "read":
+        case "search":
+            return "read";
+        case "edit":
+        case "delete":
+        case "move":
+            return "edit";
+        case "execute":
+            return "shell";
+        case "fetch":
+            return "network";
+        default:
+            return "other";
+    }
+}
+/** Not a strict unified diff (no hunks); old lines prefixed "-", new lines "+". Enough for a phone review sheet. */
+function simpleDiff(path, oldText, newText) {
+    const lines = (v, p) => (typeof v === "string" && v ? v.split("\n").map((l) => p + l) : []);
+    return [`--- ${path}`, `+++ ${path}`, ...lines(oldText, "-"), ...lines(newText, "+")].join("\n");
+}
+function extractContent(content) {
+    if (!Array.isArray(content))
+        return {};
+    const texts = [];
+    const diffs = [];
+    for (const c of content) {
+        if (!isObj(c))
+            continue;
+        if (c["type"] === "content" && isObj(c["content"]) && c["content"]["type"] === "text") {
+            const t = str(c["content"]["text"]);
+            if (t)
+                texts.push(t);
+        }
+        else if (c["type"] === "diff" && typeof c["path"] === "string") {
+            diffs.push(simpleDiff(c["path"], c["oldText"], c["newText"]));
+        }
+    }
+    return {
+        ...(texts.length ? { output: texts.join("\n").slice(0, MAX_OUTPUT) } : {}),
+        ...(diffs.length ? { diff: diffs.join("\n\n").slice(0, MAX_OUTPUT) } : {}),
+    };
+}
+function textOf(update) {
+    const c = update["content"];
+    return isObj(c) && c["type"] === "text" ? str(c["text"]) : undefined;
+}
+function toEvent(update) {
+    switch (update["sessionUpdate"]) {
+        case "agent_message_chunk": {
+            const text = textOf(update);
+            // Gemini echoes mode changes as message text ("[MODE_UPDATE] yolo"); that is CLI noise, not agent output.
+            return text && !/^\[MODE_UPDATE\]/.test(text) ? { kind: "agent_text_delta", text } : undefined;
+        }
+        case "agent_thought_chunk": {
+            const text = textOf(update);
+            return text ? { kind: "agent_thought_delta", text } : undefined;
+        }
+        case "tool_call": {
+            const toolCallId = str(update["toolCallId"]);
+            if (!toolCallId)
+                return undefined;
+            const title = str(update["title"]);
+            const kind = str(update["kind"]);
+            return {
+                kind: "tool_call",
+                toolCallId,
+                name: kind ?? title ?? "tool",
+                ...(title ? { title } : {}),
+                risk: riskOf(kind),
+                input: update["rawInput"] ?? {},
+            };
+        }
+        case "tool_call_update": {
+            const toolCallId = str(update["toolCallId"]);
+            if (!toolCallId)
+                return undefined;
+            const s = str(update["status"]);
+            const status = s === "completed" ? "completed" : s === "failed" ? "failed" : "running";
+            return { kind: "tool_call_update", toolCallId, status, ...extractContent(update["content"]) };
+        }
+        default:
+            return undefined; // plan, available_commands_update, current_mode_update, user_message_chunk (history on load)
+    }
+}
+const MODE_IDS = { ask: "default", plan: "plan", auto_edit: "autoEdit", auto: "yolo" };
+/** Path of the `gemini` executable if it is installed on this host. */
+export function findGemini() {
+    return findOnPath("gemini");
+}
+function lastLine(s) {
+    const lines = s.trim().split(/\r?\n/);
+    return lines[lines.length - 1] ?? "";
+}
+export function createGeminiAdapter(binary) {
+    return {
+        engine: "gemini",
+        async start({ cwd, permissionMode }, sink) {
+            const child = spawnCli(binary, ["--acp"], cwd);
+            const rpc = new RpcPeer(child);
+            let closed = false; // set once the session is intentionally closed or has died
+            let inTurn = false; // a prompt request is in flight (its rejection reports process death)
+            let stderrTail = "";
+            let sessionId;
+            child.stderr.on("data", (d) => {
+                stderrTail = (stderrTail + d.toString()).slice(-2000); // kept only for exit diagnostics; never logged
+            });
+            const died = (why) => {
+                const err = new Error(stderrTail ? `${why}: ${lastLine(stderrTail)}` : why);
+                rpc.failAll(err);
+                if (closed)
+                    return;
+                closed = true;
+                if (!inTurn)
+                    sink.emit({ kind: "error", message: err.message });
+                sink.emit({ kind: "status", status: "error" });
+            };
+            child.on("exit", (code) => died(`gemini exited (code ${code})`));
+            child.on("error", (e) => died(`gemini failed to start: ${e.message}`));
+            rpc.onNotification = (method, params) => {
+                if (method !== "session/update" || !isObj(params) || !isObj(params["update"]))
+                    return;
+                if (sessionId && params["sessionId"] !== sessionId)
+                    return;
+                const ev = toEvent(params["update"]);
+                if (ev)
+                    sink.emit(ev);
+            };
+            rpc.onRequest = async (method, params) => {
+                if (method !== "session/request_permission" || !isObj(params)) {
+                    throw new RpcError(-32601, `unsupported method: ${method}`);
+                }
+                const tc = isObj(params["toolCall"]) ? params["toolCall"] : {};
+                const options = Array.isArray(params["options"]) ? params["options"].filter(isObj) : [];
+                const kind = str(tc["kind"]);
+                const title = str(tc["title"]);
+                const toolCallId = str(tc["toolCallId"]);
+                const { diff } = extractContent(tc["content"]);
+                // `tool` is the ACP kind (not the title) so a host-side allow_session covers the tool class, not one exact command.
+                const decision = await sink.requestPermission({
+                    ...(toolCallId ? { toolCallId } : {}),
+                    tool: kind ?? "tool",
+                    risk: riskOf(kind),
+                    summary: title ?? kind ?? "tool call",
+                    input: tc["rawInput"] ?? {},
+                    ...(diff ? { diff } : {}),
+                });
+                const pick = (...kinds) => {
+                    for (const k of kinds) {
+                        const o = options.find((x) => x["kind"] === k);
+                        if (o && typeof o["optionId"] === "string")
+                            return o["optionId"];
+                    }
+                    return undefined;
+                };
+                // allow_session is tracked by the host; toward Gemini it is a plain one-time allow, so Gemini never
+                // persists an "always" trust rule on disk.
+                const optionId = decision === "deny" ? pick("reject_once", "reject_always") : pick("allow_once", "allow_always");
+                return { outcome: optionId ? { outcome: "selected", optionId } : { outcome: "cancelled" } };
+            };
+            try {
+                await rpc.request("initialize", {
+                    protocolVersion: 1,
+                    clientCapabilities: { fs: { readTextFile: false, writeTextFile: false } },
+                });
+                const res = await rpc.request("session/new", { cwd, mcpServers: [] });
+                sessionId = isObj(res) ? str(res["sessionId"]) : undefined;
+                if (!sessionId)
+                    throw new Error("gemini did not return a sessionId");
+                if (permissionMode !== "ask") {
+                    await rpc.request("session/set_mode", { sessionId, modeId: MODE_IDS[permissionMode] });
+                }
+            }
+            catch (e) {
+                closed = true;
+                killTree(child);
+                const msg = e instanceof Error ? e.message : String(e);
+                throw new Error(/auth/i.test(msg) ? `${msg} (run \`gemini\` once on the host to sign in)` : msg);
+            }
+            const sid = sessionId;
+            return {
+                async prompt(text) {
+                    if (closed)
+                        throw new Error("gemini process is not running");
+                    inTurn = true;
+                    try {
+                        const res = await rpc.request("session/prompt", { sessionId: sid, prompt: [{ type: "text", text }] });
+                        const stop = isObj(res) ? str(res["stopReason"]) : undefined;
+                        const usage = isObj(res) ? res["_meta"] : undefined;
+                        if (stop === "refusal")
+                            sink.emit({ kind: "error", message: "the model refused this request" });
+                        sink.emit({
+                            kind: "turn_end",
+                            stopReason: stop === "cancelled"
+                                ? "cancelled"
+                                : stop === "max_tokens" || stop === "max_turn_requests"
+                                    ? "max_budget"
+                                    : stop === "refusal"
+                                        ? "error"
+                                        : "end_turn",
+                            ...(usage !== undefined ? { usage } : {}),
+                        });
+                    }
+                    finally {
+                        inTurn = false;
+                    }
+                },
+                cancel() {
+                    if (!closed)
+                        rpc.notify("session/cancel", { sessionId: sid });
+                },
+                close() {
+                    closed = true;
+                    killTree(child);
+                },
+            };
+        },
+    };
+}
+//# sourceMappingURL=gemini.js.map