@gentbajko/slopify 3.25.9 → 4.1.0

package/dist/adapters/interest/search-interest.js

@@ -0,0 +1,113 @@
+import { z } from "zod";
+// Public search interest without a key: Google's search suggestions (DuckDuckGo's when Google
+// doesn't answer) and the Wikipedia article's views last month. Checked keyless on 2026-10-18;
+// Google Trends answers 429/404 to such calls, so it isn't asked.
+// ceiling: one service that hangs costs a topic this long at most.
+export const interestRequestMs = 4000;
+const suggestAnswer = z.tuple([z.string(), z.array(z.string())]).rest(z.unknown());
+const openSearchAnswer = z.tuple([z.string(), z.array(z.string())]).rest(z.unknown());
+const pageviewsAnswer = z.object({ items: z.array(z.object({ views: z.number() }).loose()) });
+class Unanswered extends Error {
+    reason;
+    constructor(reason) {
+        super(reason);
+        this.reason = reason;
+    }
+}
+// "en" from "en-GB"; a language Wikipedia names by its two letters.
+function languageOf(language) {
+    const code = language.trim().toLowerCase().slice(0, 2);
+    return /^[a-z]{2}$/.test(code) ? code : "en";
+}
+// The last whole month before `now`, as the pageviews API names its days.
+export function lastMonth(now) {
+    const first = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth() - 1, 1));
+    const last = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), 0));
+    const day = (date) => `${String(date.getUTCFullYear())}${String(date.getUTCMonth() + 1).padStart(2, "0")}${String(date.getUTCDate()).padStart(2, "0")}00`;
+    return { start: day(first), end: day(last) };
+}
+export function createSearchInterest(deps) {
+    const headers = {
+        "User-Agent": `Slopify/${deps.version} (https://github.com/gentbajko/slopify)`,
+        Accept: "application/json",
+    };
+    const json = async (url, signal) => {
+        const timeout = AbortSignal.timeout(interestRequestMs);
+        let response;
+        try {
+            response = await deps.fetch(url, { headers, signal: AbortSignal.any([signal, timeout]) });
+        }
+        catch {
+            throw new Unanswered(timeout.aborted ? "timeout" : "offline");
+        }
+        if (!response.ok)
+            throw new Unanswered("refused");
+        try {
+            return await response.json();
+        }
+        catch {
+            throw new Unanswered("refused");
+        }
+    };
+    const reasonOf = (error) => error instanceof Unanswered ? error.reason : "offline";
+    const suggestions = async (topic, language, signal) => {
+        const q = encodeURIComponent(topic);
+        let failure = "offline";
+        for (const url of [
+            `https://suggestqueries.google.com/complete/search?client=firefox&hl=${language}&q=${q}`,
+            `https://duckduckgo.com/ac/?q=${q}&type=list&kl=wt-wt`,
+        ]) {
+            try {
+                const parsed = suggestAnswer.safeParse(await json(url, signal));
+                if (parsed.success)
+                    return parsed.data[1].slice(0, 10);
+                failure = "refused";
+            }
+            catch (error) {
+                failure = reasonOf(error);
+            }
+        }
+        return failure;
+    };
+    const wikiViews = async (topic, language, signal) => {
+        try {
+            const found = openSearchAnswer.safeParse(await json(`https://${language}.wikipedia.org/w/api.php?action=opensearch&format=json&namespace=0&limit=1&search=${encodeURIComponent(topic)}`, signal));
+            if (!found.success)
+                return "refused";
+            const title = found.data[1][0];
+            if (title === undefined)
+                return null;
+            const { start, end } = lastMonth(deps.now());
+            let answer;
+            try {
+                answer = await json(`https://wikimedia.org/api/rest_v1/metrics/pageviews/per-article/${language}.wikipedia/all-access/user/${encodeURIComponent(title.replaceAll(" ", "_"))}/monthly/${start}/${end}`, signal);
+            }
+            catch (error) {
+                // An article too new to have a month of views answers 404.
+                if (reasonOf(error) === "refused")
+                    return null;
+                throw error;
+            }
+            const views = pageviewsAnswer.safeParse(answer);
+            return views.success ? views.data.items.reduce((sum, item) => sum + item.views, 0) : null;
+        }
+        catch (error) {
+            return reasonOf(error);
+        }
+    };
+    return async (topic, rawLanguage, signal) => {
+        const language = languageOf(rawLanguage);
+        const [offered, views] = await Promise.all([
+            suggestions(topic, language, signal),
+            wikiViews(topic, language, signal),
+        ]);
+        const failed = (value) => typeof value === "string";
+        if (failed(offered) && failed(views))
+            return { ok: false, reason: offered };
+        return {
+            ok: true,
+            suggestions: failed(offered) ? null : offered,
+            wikiViews: failed(views) ? null : views,
+        };
+    };
+}

package/dist/adapters/key-probes.js

@@ -1,5 +1,6 @@
+import { safeJson } from "./http-failure.js";
 import { cartesiaVersion } from "./tts/cartesia.js";
-// Settings → Providers' Test button, per provider. Some answer a key they do not recognise
+// Settings → Keys & services' Test button, per provider. Some answer a key they do not recognise
 // with something other than 401: Google with 400 API_KEY_INVALID, ElevenLabs with 400
 // invalid_api_key, Inworld with 403 "does not exist". Observed on 2026-09-27; their
 // documentation says 401.
@@ -21,6 +22,37 @@ function listed(ids) {
     };
 }
 const field = (value, key) => typeof value === "object" && value !== null ? value[key] : undefined;
+function idsOf(rows, key, strip) {
+    if (!Array.isArray(rows))
+        return undefined;
+    return rows.flatMap((row) => {
+        const id = field(row, key);
+        return typeof id === "string" && id !== "" ? [strip ? id.replace(strip, "") : id] : [];
+    });
+}
+// `{ data: [{ id }] }`: OpenAI's and OpenRouter's lists.
+function dataList(url) {
+    return {
+        url: () => url,
+        read: (body) => {
+            const ids = idsOf(field(safeJson(body), "data"), "id");
+            return ids === undefined ? undefined : { ids };
+        },
+    };
+}
+const googleBase = "https://generativelanguage.googleapis.com/v1beta/models?pageSize=1000";
+const googleList = {
+    url: (page) => page === undefined ? googleBase : `${googleBase}&pageToken=${encodeURIComponent(page)}`,
+    read: (body) => {
+        const value = safeJson(body);
+        const ids = idsOf(field(value, "models"), "name", /^models\//);
+        if (ids === undefined)
+            return undefined;
+        const next = field(value, "nextPageToken");
+        return typeof next === "string" && next !== "" ? { ids, next } : { ids };
+    },
+};
+const openAiList = dataList("https://api.openai.com/v1/models");
 const google = {
     url: "https://generativelanguage.googleapis.com/v1beta/models?pageSize=1",
     headers: (key) => ({ "x-goog-api-key": key }),
@@ -28,6 +60,7 @@ const google = {
     model: {
         url: (model) => `https://generativelanguage.googleapis.com/v1beta/models/${encodeURIComponent(model.replace(/^models\//, ""))}`,
     },
+    list: googleList,
 };
 export const keyProbes = {
     openrouter: {
@@ -40,9 +73,20 @@ export const keyProbes = {
                 return Array.isArray(data) ? data.map((one) => field(one, "id")) : [];
             }),
         },
+        list: dataList("https://openrouter.ai/api/v1/models"),
+    },
+    "openai-tts": {
+        url: "https://api.openai.com/v1/models",
+        headers: bearer,
+        model: openAiModel,
+        list: openAiList,
+    },
+    "openai-image": {
+        url: "https://api.openai.com/v1/models",
+        headers: bearer,
+        model: openAiModel,
+        list: openAiList,
     },
-    "openai-tts": { url: "https://api.openai.com/v1/models", headers: bearer, model: openAiModel },
-    "openai-image": { url: "https://api.openai.com/v1/models", headers: bearer, model: openAiModel },
     "google-image": google,
     "google-tts": google,
     // fal.ai's model list answers without a key; its price lookup requires one.
@@ -72,6 +116,13 @@ export const keyProbes = {
             url: () => "https://api.elevenlabs.io/v1/models",
             lists: listed((body) => Array.isArray(body) ? body.map((one) => field(one, "model_id")) : []),
         },
+        list: {
+            url: () => "https://api.elevenlabs.io/v1/models",
+            read: (body) => {
+                const ids = idsOf(safeJson(body), "model_id");
+                return ids === undefined ? undefined : { ids };
+            },
+        },
     },
     cartesia: {
         url: "https://api.cartesia.ai/voices?limit=1",

package/dist/adapters/llm/antigravity-models.js

@@ -32,6 +32,6 @@ export async function nodeAntigravityModels(binary, read = nodeReadCliOutput) {
     }
     catch {
         // Do not pass the CLI's raw output or home paths to the browser.
-        throw new Error('Slopify could not get the model list from the Antigravity CLI (it ran "agy models"). Check agy is installed and signed in (Settings → Providers), then refresh the list, or type a model slug that "agy models" shows.');
+        throw new Error('Slopify could not get the model list from the Antigravity CLI (it ran "agy models"). Check agy is installed and signed in (Settings → Keys & services), then refresh the list, or type a model slug that "agy models" shows.');
     }
 }

package/dist/adapters/llm/antigravity.js

@@ -5,7 +5,9 @@ import { z } from "zod";
 import { redact } from "../../kernel/log.js";
 import { documentMessages } from "../../kernel/ports/llm-documents.js";
 import { providerError } from "../../kernel/ports/model.js";
+import { editSettings } from "../../kernel/ports/settings-places.js";
 import { cliCheck, cliName, cliReported, commandOf } from "../explain.js";
+import { accessField } from "../model-access.js";
 import { nodeAntigravityModels } from "./antigravity-models.js";
 import { imageWorkspace, readFileName, unseenImages } from "./image-workspace.js";
 import { cliInput, cliShaped, deliveredInput, endedWithout, promptOf, stopCliRun, stuckCli, } from "./run-cli.js";
@@ -76,7 +78,7 @@ export function antigravityLlm(deps) {
         if (/^gemini$/i.test(commandOf(binary)))
             throw providerError({
                 kind: "unsupported",
-                message: `The saved program path for the Antigravity CLI (${binary}) still points at the Gemini CLI, which Google has retired. In Settings → Providers, clear the Antigravity CLI path or set it to the agy program, then use Try again.`,
+                message: `The saved program path for the Antigravity CLI (${binary}) still points at the Gemini CLI, which Google has retired. In Settings → Keys & services, clear the Antigravity CLI path or set it to the agy program, then use Try again.`,
             });
         // The documents travel inline, as with OpenRouter: headless agy refuses MCP tools it was
         // not pre-approved for, so a research reader tool would be silently unavailable.
@@ -159,7 +161,7 @@ export function antigravityLlm(deps) {
         }
         req.signal.throwIfAborted();
         if (run === undefined)
-            throw failure(binary, req.model, "", `The ${cliName(binary)} could not be started. Check it is installed and set up in Settings → Providers, then use Try again.`);
+            throw failure(binary, req.model, "", `The ${cliName(binary)} could not be started. Check it is installed and set up in Settings → Keys & services, then use Try again.`);
         if (authRequired(run.stderr()))
             throw authFailure();
         throw failure(binary, req.model, run.stderr(), ended === undefined ? stuckCli(binary) : endedWithout(binary, ended, run.stderr()));
@@ -190,11 +192,11 @@ function emptyAnswer(binary, stderr) {
     if (/no output produced|auto-denied|permission/i.test(stderr))
         return providerError({
             kind: "other",
-            message: `The ${cliName(binary)} tried to use a tool Slopify does not allow (it said: ${redact(stderr.trim()).slice(0, 300)}), so it gave no answer. Use Try again; if it keeps happening, choose another model or text provider in the Providers section of Edit project.`,
+            message: `The ${cliName(binary)} tried to use a tool Slopify does not allow (it said: ${redact(stderr.trim()).slice(0, 300)}), so it gave no answer. Use Try again; if it keeps happening, choose another service or model in ${editSettings.writer}.`,
         });
     return providerError({
         kind: "other",
-        message: `The ${cliName(binary)} answered with no text. Use Try again; if it keeps happening, run agy in a terminal to check it works, or choose another model in the Providers section of Edit project.`,
+        message: `The ${cliName(binary)} answered with no text. Use Try again; if it keeps happening, run agy in a terminal to check it works, or choose another model in ${editSettings.writer}.`,
     });
 }
 // `message` is what the CLI said; `sentence` replaces the default wording when Slopify
@@ -205,7 +207,9 @@ function failure(binary, model, message, sentence, now = Date.now) {
     if (/invalid model selection/i.test(message))
         return providerError({
             kind: "unsupported",
-            message: `The ${cliName(binary)} does not offer the model "${model}". Run "agy models" in a terminal to see the ones it has, pick one in the Edit tab (Edit project → Providers), then use Continue the run.`,
+            // agy lists models a plan can't run and refuses them with this sentence.
+            access: "no-access",
+            message: `The ${cliName(binary)} does not offer the model "${model}". Run "agy models" in a terminal to see the ones it has, pick one in ${editSettings.writer}, then use Continue the run.`,
         });
     if (/quota|resource.?exhausted|capacity/i.test(message) &&
         /exhaust|exceed|used up|reached|limit/i.test(message)) {
@@ -219,7 +223,7 @@ function failure(binary, model, message, sentence, now = Date.now) {
         if (waitMs !== undefined && waitMs <= 5 * 60_000)
             return providerError({
                 kind: "rate_limit",
-                message: `The ${cliName(binary)} is busy: Google's capacity for this model is used for the moment (it said: ${redact(message)}). Slopify tries again by itself shortly; if it keeps happening, run fewer projects at once or choose another model in the Providers section of Edit project.`,
+                message: `The ${cliName(binary)} is busy: Google's capacity for this model is used for the moment (it said: ${redact(message)}). Slopify tries again by itself shortly; if it keeps happening, run fewer projects at once or choose another model in ${editSettings.writer}.`,
                 retryAfterMs: Math.max(1000, waitMs),
             });
         return providerError({
@@ -233,6 +237,7 @@ function failure(binary, model, message, sentence, now = Date.now) {
     }
     return providerError({
         kind: "other",
+        ...accessField(null, message),
         message: sentence ?? cliReported(binary, redact(message), cliCheck(binary)),
     });
 }

package/dist/adapters/llm/assistant-cli.js

@@ -0,0 +1,388 @@
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { z } from "zod";
+import { redact } from "../../kernel/log.js";
+import { cliName } from "../explain.js";
+import { cliLoginError } from "./cli-login-error.js";
+import { codexBinary, hardenedCodexBase } from "./codex.js";
+import { cliInput, endedWithout, stopCliRun, stuckCli } from "./run-cli.js";
+import { lines } from "./sse-lines.js";
+// The in-app assistant's CLI turn: Claude Code or Codex with no tool of its own (no shell, no
+// files, no web), none of the person's settings, hooks, plugins, skills, memory or MCP
+// servers, and one MCP server: Slopify's `/mcp/assistant`, opened with the turn's token.
+//
+// The token is never an argument: argv is readable by every process on the computer. It is in
+// the CLI's environment only, and the CLIs put it in the header themselves:
+// - Claude Code 2.1.302 expands ${VAR} in an --mcp-config file's headers (checked on this
+//   machine: a stand-in server saw "Bearer <the token>" from `"Bearer
+//   ${SLOPIFY_ASSISTANT_TOKEN}"`). The file names the variable, not the token.
+// - Codex 0.155.1 reads `mcp_servers.<name>.bearer_token_env_var` (codex-rs config
+//   `McpServerTransportConfig::StreamableHttp`; also checked: the server saw the bearer).
+export const assistantServerName = "slopify";
+export const assistantTokenVariable = "SLOPIFY_ASSISTANT_TOKEN";
+const slopifyTool = `mcp__${assistantServerName}__`;
+export function claudeAssistantArgs(options) {
+    return [
+        "-p",
+        "--output-format",
+        "stream-json",
+        "--verbose",
+        "--include-partial-messages",
+        // `claude --help` 2.1.302: --restricted drops the code-running tools and WebFetch and
+        // ignores the user, project and local settings files; --setting-sources "" loads none of
+        // them either. --bare would discard the OAuth sign-in the assistant runs on.
+        "--restricted",
+        "--setting-sources",
+        "",
+        "--disable-slash-commands",
+        "--no-chrome",
+        "--no-session-persistence",
+        "--settings",
+        JSON.stringify({
+            disableAllHooks: true,
+            autoMemoryEnabled: false,
+            claudeMdExcludes: ["**"],
+            enabledPlugins: {},
+        }),
+        "--system-prompt",
+        options.system,
+        "--strict-mcp-config",
+        "--mcp-config",
+        options.mcpConfig,
+        // No built-in tool at all; only Slopify's server is allowed, and the web tools are named
+        // as refused in case a later version brings them back by default.
+        "--tools",
+        "",
+        "--allowedTools",
+        `mcp__${assistantServerName}`,
+        "--disallowedTools",
+        "WebSearch,WebFetch,Bash",
+        "--permission-mode",
+        "dontAsk",
+        ...(options.model === undefined || options.model === "" ? [] : ["--model", options.model]),
+    ];
+}
+export function claudeAssistantConfig(url) {
+    return JSON.stringify({
+        mcpServers: {
+            [assistantServerName]: {
+                type: "http",
+                url,
+                headers: { Authorization: `Bearer \${${assistantTokenVariable}}` },
+            },
+        },
+    });
+}
+export function codexAssistantArgs(options) {
+    const server = `mcp_servers.${assistantServerName}`;
+    return [
+        ...hardenedCodexBase(options.directory),
+        "-c",
+        `instructions=${JSON.stringify(options.system)}`,
+        "-c",
+        'web_search="disabled"',
+        "-c",
+        "tool_output_token_limit=32768",
+        "-c",
+        `${server}.url=${JSON.stringify(options.url)}`,
+        "-c",
+        `${server}.bearer_token_env_var=${JSON.stringify(assistantTokenVariable)}`,
+        "-c",
+        `${server}.required=true`,
+        "-c",
+        `${server}.default_tools_approval_mode="auto"`,
+        ...(options.model === undefined || options.model === "" ? [] : ["-m", options.model]),
+        "--",
+        "-",
+    ];
+}
+// What the CLI is started with: enough to find itself, its sign-in and the network, and
+// nothing else of Slopify's environment. A provider key there would make the CLI bill that key
+// instead of the person's plan, and hand it a secret it never needs.
+const passedNames = new Set([
+    "PATH",
+    "HOME",
+    "USER",
+    "LOGNAME",
+    "SHELL",
+    "LANG",
+    "LANGUAGE",
+    "TZ",
+    "TMPDIR",
+    "TEMP",
+    "TMP",
+    "TERM",
+    // Where each CLI keeps its sign-in and settings, when moved from the default.
+    "CLAUDE_CONFIG_DIR",
+    "CODEX_HOME",
+    // A network that needs a proxy or its own certificates.
+    "HTTP_PROXY",
+    "HTTPS_PROXY",
+    "NO_PROXY",
+    "http_proxy",
+    "https_proxy",
+    "no_proxy",
+    "NODE_EXTRA_CA_CERTS",
+    "SSL_CERT_FILE",
+    "SSL_CERT_DIR",
+    // Windows: the CLI can't start, or find its folders, without these.
+    "SYSTEMROOT",
+    "SystemRoot",
+    "WINDIR",
+    "COMSPEC",
+    "PATHEXT",
+    "USERPROFILE",
+    "APPDATA",
+    "LOCALAPPDATA",
+    "HOMEDRIVE",
+    "HOMEPATH",
+    "PROGRAMDATA",
+    "ProgramData",
+    "PROGRAMFILES",
+    "ProgramFiles",
+    "Path",
+]);
+export function assistantEnv(sourceEnv) {
+    const env = {};
+    for (const [name, value] of Object.entries(sourceEnv))
+        if (value !== undefined && (passedNames.has(name) || /^(LC|XDG)_[A-Z_]+$/.test(name)))
+            env[name] = value;
+    return env;
+}
+// A private folder (0700) that is the CLI's working directory, so nothing of the person's
+// projects is its cwd, holding the 0600 config file; removed when the turn ends.
+export function assistantWorkspace(url, token, sourceEnv) {
+    const directory = mkdtempSync(join(tmpdir(), "slopify-assistant-"));
+    const remove = () => rmSync(directory, { recursive: true, force: true, maxRetries: 3, retryDelay: 50 });
+    try {
+        const config = join(directory, "mcp.json");
+        writeFileSync(config, claudeAssistantConfig(url), { mode: 0o600, flag: "wx" });
+        const env = assistantEnv(sourceEnv);
+        env.PWD = directory;
+        env[assistantTokenVariable] = token;
+        return { directory, config, env, remove };
+    }
+    catch (error) {
+        remove();
+        throw error;
+    }
+}
+const typed = z.object({ type: z.string() }).loose();
+const claudeInit = z
+    .object({
+    subtype: z.literal("init"),
+    tools: z.array(z.string()).optional(),
+    mcp_servers: z.array(z.object({ name: z.string(), status: z.string() }).loose()).optional(),
+})
+    .loose();
+const claudeAssistant = z
+    .object({
+    message: z.object({
+        content: z.array(z
+            .object({ type: z.string(), text: z.string().optional(), name: z.string().optional() })
+            .loose()),
+    }),
+})
+    .loose();
+const claudePartial = z
+    .object({
+    event: z.object({
+        type: z.literal("content_block_delta"),
+        delta: z.object({ type: z.literal("text_delta"), text: z.string() }),
+    }),
+})
+    .loose();
+const claudeResult = z
+    .object({ subtype: z.string(), is_error: z.boolean().optional(), result: z.string().optional() })
+    .loose();
+const codexItem = z
+    .object({
+    item: z
+        .object({
+        id: z.string().optional(),
+        type: z.string(),
+        text: z.string().optional(),
+        server: z.string().optional(),
+        tool: z.string().optional(),
+    })
+        .loose(),
+})
+    .loose();
+const codexFailed = z.object({ error: z.object({ message: z.string() }) }).loose();
+const codexError = z.object({ message: z.string() }).loose();
+// Codex items that are no part of a Slopify chat: a shell command, a file edit, a web
+// search, another agent.
+const codexForeign = new Set([
+    "command_execution",
+    "file_change",
+    "web_search",
+    "collab_tool_call",
+]);
+function failed(cli, said) {
+    const login = cliLoginError(cli, said);
+    if (login !== undefined)
+        return { type: "failed", message: login.message };
+    return {
+        type: "failed",
+        message: `The ${cliName(cli === "claude-code" ? "claude" : "codex")} stopped with an error: ${redact(said).slice(0, 500)}. Send your message again; if it keeps happening, check the CLI in Settings → Keys & services.`,
+    };
+}
+// One JSONL line of the CLI's stream as what the chat shows. A stateful reader: Codex reports
+// a message's text so far, and only what is new is passed on.
+export function assistantStream(cli) {
+    const typedSoFar = new Map();
+    return (line) => {
+        if (line.trim() === "")
+            return [];
+        let value;
+        try {
+            value = JSON.parse(line);
+        }
+        catch {
+            return [];
+        }
+        const event = typed.safeParse(value);
+        if (!event.success)
+            return [];
+        return cli === "claude-code"
+            ? claudeEvents(event.data.type, value)
+            : codexEvents(event.data.type, value);
+    };
+    function claudeEvents(type, value) {
+        if (type === "system") {
+            const init = claudeInit.safeParse(value);
+            if (!init.success)
+                return [];
+            const foreign = (init.data.tools ?? []).filter((name) => !name.startsWith(slopifyTool));
+            if (foreign.length > 0)
+                return [{ type: "foreign", name: foreign.join(", ") }];
+            const server = init.data.mcp_servers?.find((one) => one.name === assistantServerName);
+            if (server !== undefined && (server.status === "failed" || server.status === "needs-auth"))
+                return [
+                    {
+                        type: "failed",
+                        message: "Claude Code couldn't reach Slopify's assistant tools, so it answered nothing. Send your message again; if it keeps happening, restart Slopify.",
+                    },
+                ];
+            return [];
+        }
+        if (type === "stream_event") {
+            const partial = claudePartial.safeParse(value);
+            return partial.success && partial.data.event.delta.text !== ""
+                ? [{ type: "partial", text: partial.data.event.delta.text }]
+                : [];
+        }
+        if (type === "assistant") {
+            const message = claudeAssistant.safeParse(value);
+            if (!message.success)
+                return [];
+            return message.data.message.content.flatMap((block) => {
+                if (block.type === "text" && block.text !== undefined && block.text !== "")
+                    return [{ type: "text", text: block.text }];
+                if (block.type !== "tool_use" || block.name === undefined)
+                    return [];
+                return block.name.startsWith(slopifyTool)
+                    ? [{ type: "tool", name: block.name.slice(slopifyTool.length) }]
+                    : [{ type: "foreign", name: block.name }];
+            });
+        }
+        if (type === "result") {
+            const result = claudeResult.safeParse(value);
+            if (!result.success)
+                return [];
+            return result.data.is_error === true || result.data.subtype !== "success"
+                ? [failed("claude-code", result.data.result ?? result.data.subtype)]
+                : [{ type: "done" }];
+        }
+        return [];
+    }
+    function codexEvents(type, value) {
+        if (type === "item.started" || type === "item.updated" || type === "item.completed") {
+            const parsed = codexItem.safeParse(value);
+            if (!parsed.success)
+                return [];
+            const { item } = parsed.data;
+            if (codexForeign.has(item.type))
+                return [{ type: "foreign", name: item.type }];
+            if (item.type === "mcp_tool_call") {
+                if (item.server !== assistantServerName)
+                    return [{ type: "foreign", name: `${item.server ?? "?"}.${item.tool ?? "?"}` }];
+                return type === "item.started" && item.tool !== undefined
+                    ? [{ type: "tool", name: item.tool }]
+                    : [];
+            }
+            if (item.type !== "agent_message")
+                return [];
+            const id = item.id ?? "";
+            const seen = typedSoFar.get(id) ?? "";
+            const text = item.text ?? "";
+            if (type === "item.completed") {
+                typedSoFar.delete(id);
+                return text === "" ? [] : [{ type: "text", text }];
+            }
+            if (text.length > seen.length && text.startsWith(seen)) {
+                typedSoFar.set(id, text);
+                return [{ type: "partial", text: text.slice(seen.length) }];
+            }
+            return [];
+        }
+        if (type === "turn.completed")
+            return [{ type: "done" }];
+        if (type === "turn.failed") {
+            const parsed = codexFailed.safeParse(value);
+            return [failed("codex", parsed.success ? parsed.data.error.message : "the turn failed")];
+        }
+        if (type === "error") {
+            const parsed = codexError.safeParse(value);
+            return [failed("codex", parsed.success ? parsed.data.message : "unknown error")];
+        }
+        return [];
+    }
+}
+// The turn itself: a private workspace, the CLI started in it with the prompt on stdin, its
+// stream read into the chat's events, and everything stopped and removed at the end.
+export function assistantCliRunner(run, sourceEnv = process.env) {
+    return async function* turn(request) {
+        const space = assistantWorkspace(request.url, request.token, sourceEnv);
+        let child;
+        let ended;
+        try {
+            child = run(request.binary, request.cli === "claude-code"
+                ? claudeAssistantArgs({ mcpConfig: space.config, system: request.system })
+                : codexAssistantArgs({
+                    directory: space.directory,
+                    url: request.url,
+                    system: request.system,
+                }), request.signal, { cwd: space.directory, env: space.env, stdin: cliInput(request.prompt) });
+            const read = assistantStream(request.cli);
+            for await (const line of lines(child.stdout, request.signal))
+                for (const event of read(line)) {
+                    yield event;
+                    if (event.type === "done" || event.type === "failed" || event.type === "foreign")
+                        return;
+                }
+        }
+        finally {
+            // Also when the reader stops early (Stop, the time limit): a CLI left running would
+            // keep spending the person's plan.
+            try {
+                if (child !== undefined)
+                    ended = await stopCliRun(child);
+            }
+            finally {
+                space.remove();
+            }
+        }
+        if (request.signal.aborted || child === undefined)
+            return;
+        // The stream ended with neither an answer nor a failure.
+        const binary = request.cli === "claude-code" ? "claude" : codexBinary;
+        const said = child.stderr();
+        yield {
+            type: "failed",
+            message: cliLoginError(request.cli, said)?.message ??
+                (ended === undefined ? stuckCli(binary) : endedWithout(binary, ended, said)),
+        };
+    };
+}