@giovannijecha/jecode 0.1.9 → 0.2.1

package/dist/providers/openai-codex.js

@@ -0,0 +1,157 @@
+// ChatGPT-backed Codex Responses, kept separate from the OpenAI API provider.
+import { randomUUID } from "node:crypto";
+import { openAICodexAccount } from "../accounts.js";
+import { openAIAuthorization } from "../openai-account.js";
+import { applicationVersion } from "../version.js";
+import { EFFORTS, isEffort, requireSupportedEffort } from "../effort.js";
+import { getJson, postSse } from "./http.js";
+import { assembleOpenAI } from "./openai-stream.js";
+import { fromWireResponse, stopNotice, toWireItems, toWireTool, } from "./openai-wire.js";
+const ID = "openai-codex";
+const BASE = "https://chatgpt.com/backend-api/codex";
+// Jecode's product version is unrelated to the Codex protocol gate. OpenAI's
+// own catalogue updater uses this sentinel to request the complete current
+// manifest; Jecode then keeps only entries explicitly visible in that manifest.
+const CATALOG_COMPATIBILITY_VERSION = "99.99.99";
+const SESSION_ID = randomUUID();
+const MAX_CATALOG_ITEMS = 4_000;
+const MAX_MODELS = 1_000;
+const MAX_MODEL_CHARS = 256;
+const XHIGH_EFFORTS = ["low", "medium", "high", "xhigh"];
+let effortByModel = new Map();
+export const openaiCodex = {
+    id: ID,
+    defaultModel: "",
+    auth: { kind: "oauth", account: ID, label: "ChatGPT" },
+    blocked() {
+        return openAICodexAccount() === undefined ? "ChatGPT account is not connected" : undefined;
+    },
+    location: () => "cloud",
+    async models(signal, onStatus) {
+        const catalog = await loadCatalog(signal, onStatus);
+        effortByModel = catalog.efforts;
+        return catalog.ids;
+    },
+    async efforts(model, signal, onStatus) {
+        const cached = effortByModel.get(model);
+        if (cached !== undefined)
+            return cached;
+        const catalog = await loadCatalog(signal, onStatus);
+        effortByModel = catalog.efforts;
+        return effortByModel.get(model) ?? fallbackEfforts(model);
+    },
+    async send(req) {
+        const efforts = effortByModel.get(req.model) ?? fallbackEfforts(req.model);
+        const effort = requireSupportedEffort(req.model, req.effort, efforts);
+        return withAuthorization(async (authorization) => {
+            const events = await postSse(`${BASE}/responses`, {
+                ...headers(authorization, randomUUID()),
+                "openai-beta": "responses=experimental",
+            }, {
+                model: req.model,
+                store: false,
+                stream: true,
+                instructions: req.system,
+                input: req.messages.flatMap((message) => toWireItems(message, ID)),
+                tools: req.tools.map(toWireTool),
+                tool_choice: "auto",
+                parallel_tool_calls: true,
+                reasoning: { effort, summary: "auto" },
+                text: { verbosity: "low" },
+                include: ["reasoning.encrypted_content"],
+                prompt_cache_key: SESSION_ID,
+            }, req.signal, req.onStatus);
+            const data = await assembleOpenAI(events, req.onStream);
+            const notice = stopNotice(data);
+            if (notice !== undefined)
+                req.onStream?.({ kind: "text", text: `\n${notice}` });
+            return fromWireResponse(data, ID);
+        }, req.signal, req.onStatus);
+    },
+};
+async function loadCatalog(signal, onStatus) {
+    return withAuthorization(async (authorization) => {
+        const body = await getJson(`${BASE}/models?client_version=${CATALOG_COMPATIBILITY_VERSION}`, headers(authorization, randomUUID()), signal, onStatus);
+        return modelCatalog(body);
+    }, signal, onStatus);
+}
+async function withAuthorization(operation, signal, onStatus) {
+    let authorization = await openAIAuthorization(undefined, signal, onStatus);
+    try {
+        return await operation(authorization);
+    }
+    catch (error) {
+        if (statusOf(error) !== 401)
+            throw error;
+        authorization = await openAIAuthorization(authorization.accessToken, signal, onStatus);
+        return operation(authorization);
+    }
+}
+function headers(authorization, requestId) {
+    const version = applicationVersion();
+    return {
+        authorization: `Bearer ${authorization.accessToken}`,
+        "chatgpt-account-id": authorization.accountId,
+        originator: "jecode",
+        "user-agent": `jecode/${version} (${process.platform}; ${process.arch})`,
+        "session-id": SESSION_ID,
+        "x-client-request-id": requestId,
+    };
+}
+function modelCatalog(value) {
+    const source = record(value) && Array.isArray(value["models"]) ? value["models"] : undefined;
+    if (source === undefined)
+        throw new Error("OpenAI Codex did not return a model list");
+    const seen = new Set();
+    const models = source
+        .slice(0, MAX_CATALOG_ITEMS)
+        .flatMap((entry) => {
+        if (!record(entry))
+            return [];
+        const id = entry["slug"];
+        if (typeof id !== "string" ||
+            id === "" ||
+            id.length > MAX_MODEL_CHARS ||
+            entry["visibility"] !== "list" ||
+            seen.has(id))
+            return [];
+        seen.add(id);
+        return [{
+                id,
+                priority: typeof entry["priority"] === "number" ? entry["priority"] : 0,
+                efforts: reasoningLevels(entry, id),
+            }];
+    })
+        .sort((left, right) => left.priority - right.priority)
+        .slice(0, MAX_MODELS);
+    return {
+        ids: models.map((entry) => entry.id),
+        efforts: new Map(models.map((entry) => [entry.id, entry.efforts])),
+    };
+}
+function reasoningLevels(entry, model) {
+    const source = entry["supported_reasoning_levels"];
+    if (!Array.isArray(source))
+        return fallbackEfforts(model);
+    const seen = new Set();
+    const efforts = source.flatMap((level) => {
+        if (!record(level) || !isEffort(level["effort"]) || seen.has(level["effort"]))
+            return [];
+        seen.add(level["effort"]);
+        return [level["effort"]];
+    });
+    return efforts.length === 0 ? fallbackEfforts(model) : efforts;
+}
+function fallbackEfforts(model) {
+    if (/^gpt-5\.6-(?:sol|terra|luna)(?:-|$)/.test(model))
+        return EFFORTS;
+    return XHIGH_EFFORTS;
+}
+function statusOf(error) {
+    return typeof error === "object" && error !== null && "status" in error
+        ? error.status
+        : undefined;
+}
+function record(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/providers/openai-stream.js

@@ -1,12 +1,11 @@
 // Reassembling an OpenAI Responses reply from its event stream.
 //
-// Unlike Anthropic, this stream ends with the whole finished response in
-// `response.completed`, so there is nothing to rebuild: the deltas drive the
-// display, and the final event is taken as authoritative. Items collected
-// along the way are only a fallback for a stream that ends without it.
+// Unlike Anthropic, a standard Responses stream ends with the whole finished
+// response in `response.completed`. The ChatGPT Codex backend can instead send
+// an empty final `output` after complete `response.output_item.done` events, so
+// those streamed items remain the fallback when the final envelope is empty.
 export async function assembleOpenAI(events, onStream) {
     const items = [];
-    let completed;
     let refusal = false;
     for await (const raw of events) {
         const event = raw;
@@ -29,11 +28,10 @@ export async function assembleOpenAI(events, onStream) {
                 if (event.item !== undefined)
                     items.push(event.item);
                 break;
+            case "response.done":
             case "response.completed":
             case "response.incomplete":
-                if (event.response !== undefined)
-                    completed = event.response;
-                break;
+                return reconcileOutput(event.response, items);
             case "response.failed": {
                 const response = event.response;
                 throw new Error(`openai stream error: ${response?.error?.message ?? "unspecified"}`);
@@ -44,5 +42,11 @@ export async function assembleOpenAI(events, onStream) {
                 break;
         }
     }
-    return completed ?? { output: items };
+    throw new Error("openai stream ended before a terminal response event");
+}
+function reconcileOutput(completed, items) {
+    if (completed === undefined)
+        return { output: items };
+    const finalCount = Array.isArray(completed.output) ? completed.output.length : 0;
+    return items.length > finalCount ? { ...completed, output: items } : completed;
 }

package/dist/providers/openai-wire.js

@@ -1,11 +1,6 @@
 // Translation between the normalized vocabulary and the OpenAI Responses wire
 // shape: a flat `input` list where tool calls and their outputs are top-level
 // items keyed by `call_id`, rather than blocks nested inside a message.
-// The Responses API has no `xhigh`; collapse it onto the nearest level rather
-// than passing through a value it will reject.
-export function normalizeEffort(effort) {
-    return effort === "xhigh" || effort === "max" ? "high" : effort;
-}
 export function toWireTool(tool) {
     return {
         type: "function",
@@ -14,8 +9,8 @@ export function toWireTool(tool) {
         parameters: tool.input,
     };
 }
-export function toWireItems(message) {
-    if (message.rawFrom === "openai" && Array.isArray(message.raw)) {
+export function toWireItems(message, providerId = "openai") {
+    if (message.rawFrom === providerId && Array.isArray(message.raw)) {
         return message.raw;
     }
     const items = [];
@@ -50,7 +45,7 @@ export function stopNotice(data) {
         ? "[truncated: hit max_output_tokens — raise --max-tokens]"
         : `[incomplete: ${reason}]`;
 }
-export function fromWireResponse(data) {
+export function fromWireResponse(data, providerId = "openai") {
     const raw = Array.isArray(data.output) ? data.output : [];
     const content = [];
     for (const entry of raw) {
@@ -81,7 +76,7 @@ export function fromWireResponse(data) {
     const notice = stopNotice(data);
     if (notice !== undefined)
         content.push({ kind: "text", text: notice });
-    return { role: "assistant", content, raw, rawFrom: "openai", usage: normalizeUsage(data) };
+    return { role: "assistant", content, raw, rawFrom: providerId, usage: normalizeUsage(data) };
 }
 function normalizeUsage(data) {
     const usage = data.usage;

package/dist/providers/openai.js

@@ -5,25 +5,42 @@
 import { postSse } from "./http.js";
 import { listModels } from "./catalog.js";
 import { keyFor } from "../credentials.js";
+import { EFFORTS, requireSupportedEffort } from "../effort.js";
 import { assembleOpenAI } from "./openai-stream.js";
-import { fromWireResponse, normalizeEffort, stopNotice, toWireItems, toWireTool, } from "./openai-wire.js";
+import { fromWireResponse, stopNotice, toWireItems, toWireTool, } from "./openai-wire.js";
 const ENDPOINT = "https://api.openai.com/v1/responses";
 const MODELS = "https://api.openai.com/v1/models";
 const KEY = "OPENAI_API_KEY";
-/**
- * What this account can reach that is not a chat model.
- *
- * The list is an exclusion rather than an allow-list on purpose: an unknown
- * `gpt-`something is far more likely to be a model worth offering than one
- * worth hiding, and an allow-list would quietly bury every family shipped
- * after this line was written.
- */
-const NOT_CHAT = /^(text-|tts-|whisper|dall-e|sora|gpt-image|omni-moderation|davinci|babbage)/;
-const NON_TEXT_MODE = /(?:^|[-_])(audio|realtime|transcribe|tts)(?:[-_]|$)/;
+const RESPONSES_REASONING_MODEL = /^(?:gpt-5(?:[.-]|$)|o(?:1|3|4)(?:[.-]|$)|codex-mini(?:[.-]|$))/;
+// Jecode's transport always streams and always declares local tools. Hide
+// catalog entries that cannot satisfy either half of that contract.
+const INCOMPATIBLE_MODEL = /^(?:gpt-5(?:\.[1-3])?-chat-latest|gpt-5\.5-pro|o1-mini|o(?:1|3)-pro|o3-deep-research|o4-mini-deep-research)(?:-|$)/;
+const STANDARD_EFFORTS = ["low", "medium", "high"];
+const XHIGH_EFFORTS = ["low", "medium", "high", "xhigh"];
+const PRO_EFFORTS = ["medium", "high", "xhigh"];
+const HIGH_ONLY_EFFORT = ["high"];
+export function supportsOpenAIModel(model) {
+    return RESPONSES_REASONING_MODEL.test(model) && !INCOMPATIBLE_MODEL.test(model);
+}
+export function openAIEfforts(model) {
+    if (!supportsOpenAIModel(model))
+        return [];
+    if (/^gpt-5-pro(?:-|$)/.test(model))
+        return HIGH_ONLY_EFFORT;
+    if (/^gpt-5\.[2-5]-pro(?:-|$)/.test(model))
+        return PRO_EFFORTS;
+    if (/^gpt-5\.6(?:[.-]|$)/.test(model))
+        return EFFORTS;
+    if (/^gpt-5\.[2-5](?:[.-]|$)/.test(model))
+        return XHIGH_EFFORTS;
+    if (/^(?:o(?:1|3|4)|codex-mini)(?:[.-]|$)/.test(model))
+        return STANDARD_EFFORTS;
+    return STANDARD_EFFORTS;
+}
 export const openai = {
     id: "openai",
     defaultModel: "gpt-5",
-    keyVar: KEY,
+    auth: { kind: "api-key", keyVar: KEY },
     blocked() {
         return apiKey() === undefined ? `${KEY} is not set` : undefined;
     },
@@ -32,19 +49,23 @@ export const openai = {
     async models(signal, onStatus) {
         const ids = await listModels(MODELS, headers(requireKey()), signal, onStatus);
         return ids
-            .filter((id) => !NOT_CHAT.test(id) && !NON_TEXT_MODE.test(id))
+            .filter(supportsOpenAIModel)
             .sort((a, b) => b.localeCompare(a));
     },
+    async efforts(model) {
+        return openAIEfforts(model);
+    },
     location: () => "cloud",
     async send(req) {
         const key = requireKey();
+        const effort = requireSupportedEffort(req.model, req.effort, openAIEfforts(req.model));
         const events = await postSse(ENDPOINT, headers(key), {
             model: req.model,
             instructions: req.system,
-            input: req.messages.flatMap(toWireItems),
+            input: req.messages.flatMap((message) => toWireItems(message)),
             tools: req.tools.map(toWireTool),
             max_output_tokens: req.maxTokens,
-            reasoning: { effort: normalizeEffort(req.effort), summary: "auto" },
+            reasoning: { effort, summary: "auto" },
             store: false,
             include: ["reasoning.encrypted_content"],
             stream: true,

package/dist/providers/sse.js

@@ -76,6 +76,6 @@ function parseData(chunk) {
         return JSON.parse(data);
     }
     catch {
-        return undefined;
+        throw new Error("SSE event contained invalid JSON");
     }
 }

package/dist/settings-command.js

@@ -3,6 +3,7 @@
 import { modelsCommand, providersCommand } from "./provider-commands.js";
 import { credentialsCommand } from "./credential-commands.js";
 import { EFFORTS, readSettings, settingsLabel, updateSettings } from "./settings.js";
+import { providerFailure } from "./provider-errors.js";
 import { ollamaConnectionHint, ollamaConnectionSetting, } from "./ollama-settings-command.js";
 import { of } from "./tui/editor.js";
 import { heading } from "./tui/picker.js";
@@ -75,13 +76,21 @@ function settingsItems(values) {
                 }]),
         { action: "model", option: { label: "model", hint: values.model || "choose a model" } },
         { action: "effort", option: { label: "effort", hint: values.effort } },
-        { action: "maxTokens", option: { label: "max output tokens", hint: String(values.maxTokens) } },
+        ...(values.maxTokens === undefined
+            ? []
+            : [{
+                    action: "maxTokens",
+                    option: { label: "max output tokens", hint: String(values.maxTokens) },
+                }]),
         { action: "maxSteps", option: { label: "max tool steps", hint: String(values.maxSteps) } },
         {
             action: "reducedMotion",
             option: { label: "reduced motion", hint: values.reducedMotion ? "on" : "off" },
         },
-        { action: "credentials", option: { label: "credentials", hint: "manage API keys" } },
+        {
+            action: "credentials",
+            option: { label: "authentication", hint: "manage API keys and accounts" },
+        },
     ];
 }
 function settingsValues(session) {
@@ -90,7 +99,7 @@ function settingsValues(session) {
         model: session.model,
         ...(session.provider.id === "ollama" ? { ollamaConnection: ollamaConnectionHint() } : {}),
         effort: session.config.effort,
-        maxTokens: session.config.maxTokens,
+        ...(session.provider.id === "openai-codex" ? {} : { maxTokens: session.config.maxTokens }),
         maxSteps: session.config.maxSteps,
         reducedMotion: session.config.reducedMotion,
     };
@@ -101,6 +110,7 @@ async function providerSetting(session, host) {
         model: session.model,
         providerId: session.config.providerId,
         configModel: session.config.model,
+        effort: session.config.effort,
     };
     if (!(await providersCommand(session, host, { announce: false, save: false })))
         return;
@@ -108,40 +118,85 @@ async function providerSetting(session, host) {
     const models = { ...current.models };
     if (session.model !== "")
         models[session.provider.id] = session.model;
-    if (await persist(host, { provider: session.provider.id, models }))
+    const patch = {
+        provider: session.provider.id,
+        models,
+        ...(session.config.effort === before.effort ? {} : { effort: session.config.effort }),
+    };
+    if (await persist(host, patch))
         return;
     session.provider = before.provider;
     session.model = before.model;
     session.config.providerId = before.providerId;
     session.config.model = before.configModel;
+    session.config.effort = before.effort;
 }
 async function modelSetting(session, host) {
-    const before = { model: session.model, configModel: session.config.model };
+    const before = {
+        model: session.model,
+        configModel: session.config.model,
+        effort: session.config.effort,
+    };
     if (!(await modelsCommand(session, host, { announce: false, save: false })))
         return;
     const current = readSettings();
     const models = { ...current.models, [session.provider.id]: session.model };
-    if (await persist(host, { models }))
+    const patch = {
+        models,
+        ...(session.config.effort === before.effort ? {} : { effort: session.config.effort }),
+    };
+    if (await persist(host, patch))
         return;
     session.model = before.model;
     session.config.model = before.configModel;
+    session.config.effort = before.effort;
 }
 async function effortSetting(session, host) {
     const choose = chooser(host);
     if (choose === undefined)
         return;
+    const efforts = await availableEfforts(session, host);
+    if (efforts === undefined)
+        return;
+    if (efforts.length === 0) {
+        host.emit({
+            kind: "notice",
+            text: `${session.model || session.provider.id} controls its own reasoning depth`,
+            tone: "info",
+        });
+        return;
+    }
     const current = session.config.effort;
     const index = await choose({
         title: heading("effort", "saved default", session.palette),
-        options: EFFORTS.map((value) => ({ label: value })),
-        index: Math.max(0, EFFORTS.findIndex((value) => value === current)),
+        options: efforts.map((value) => ({ label: value })),
+        index: Math.max(0, efforts.findIndex((value) => value === current)),
     });
-    const value = index === undefined ? undefined : EFFORTS[index];
+    const value = index === undefined ? undefined : efforts[index];
     if (value === undefined || !(await persist(host, { effort: value })))
         return;
     session.config.effort = value;
     return value;
 }
+async function availableEfforts(session, host) {
+    if (session.provider.efforts === undefined)
+        return EFFORTS;
+    host.status?.(`Asking ${session.provider.id}`);
+    try {
+        return await session.provider.efforts(session.model, host.signal, (status) => host.status?.(status));
+    }
+    catch (error) {
+        host.emit({
+            kind: "notice",
+            text: providerFailure(session.provider, error, true),
+            tone: "error",
+        });
+        return undefined;
+    }
+    finally {
+        host.status?.(undefined);
+    }
+}
 async function motionSetting(session, host) {
     const choose = chooser(host);
     if (choose === undefined)

package/dist/settings.js

@@ -3,10 +3,11 @@ import { readFileSync } from "node:fs";
 import { chmod, mkdir } from "node:fs/promises";
 import * as path from "node:path";
 import { atomicWrite } from "./atomic.js";
+import { EFFORTS } from "./effort.js";
 import { providerNames } from "./providers/index.js";
 import { parseOllamaEndpoint } from "./providers/ollama-endpoint.js";
 import { userDataLabel, userDataPath } from "./user-data.js";
-export const EFFORTS = ["low", "medium", "high", "xhigh", "max"];
+export { EFFORTS } from "./effort.js";
 let saved;
 export function readSettings() {
     if (saved === undefined)

package/dist/tools/args.js

@@ -3,10 +3,11 @@
 //
 // Every throw here becomes an is_error tool result the model can read and
 // correct on the next step, so the messages are written for that reader.
-export function requireString(args, name) {
+export function requireString(args, name, allowEmpty = false) {
     const value = args[name];
-    if (typeof value !== "string" || value === "") {
-        throw new Error(`"${name}" is required and must be a non-empty string`);
+    if (typeof value !== "string" || (!allowEmpty && value === "")) {
+        const kind = allowEmpty ? "a string" : "a non-empty string";
+        throw new Error(`"${name}" is required and must be ${kind}`);
     }
     return value;
 }

package/dist/tools/fs.js

@@ -101,7 +101,7 @@ export const writeFile = {
     async preview(args, ctx) {
         const root = await resolveExistingInRoot(ctx.root, ".");
         const target = await resolveDirectWritableInRoot(root, requireString(args, "path"));
-        const content = requireString(args, "content");
+        const content = requireString(args, "content", true);
         assertEditableText(content);
         // A write against a file that is already there is a replacement, and the
         // user is owed the difference rather than a wall of green.
@@ -110,7 +110,7 @@ export const writeFile = {
     async run(args, ctx) {
         const root = await resolveExistingInRoot(ctx.root, ".");
         const target = await resolveDirectWritableInRoot(root, requireString(args, "path"));
-        const content = requireString(args, "content");
+        const content = requireString(args, "content", true);
         assertEditableText(content);
         await fs.mkdir(path.dirname(target), { recursive: true });
         const validate = () => assertDirectWritableInRoot(root, target);
@@ -248,7 +248,10 @@ function applied(before, args) {
     }
     const made = replaceAll ? occurrences : 1;
     assertReplacementFits(before, oldText, newText, made);
-    const after = replaceAll ? before.replaceAll(oldText, newText) : before.replace(oldText, newText);
+    const replacement = () => newText;
+    const after = replaceAll
+        ? before.replaceAll(oldText, replacement)
+        : before.replace(oldText, replacement);
     assertEditableText(after, "edited content");
     return { after, made };
 }
@@ -270,6 +273,8 @@ async function unchangedSinceApproval(target, approved) {
     }
 }
 function count(text, noun) {
+    if (text === "")
+        return "empty";
     return plural(text.split("\n").length, noun, `${noun}s`);
 }
 function plural(n, one, many) {

package/dist/tools/index.js

@@ -20,8 +20,8 @@ export function toolSpecs(tools) {
 // and gets another turn to fix its call. Only an aborted turn propagates.
 export async function runTool(tool, call, ctx) {
     try {
-        const { output, summary } = await tool.run(call.input, ctx);
-        return { result: { kind: "tool_result", id: call.id, output, isError: false }, summary };
+        const { output, summary, isError = false } = await tool.run(call.input, ctx);
+        return { result: { kind: "tool_result", id: call.id, output, isError }, summary };
     }
     catch (error) {
         if (ctx.signal?.aborted === true)

package/dist/tools/shell.js

@@ -32,6 +32,7 @@ export const runCommand = {
         return {
             output: output === "" ? `[${summary}]` : `${output}\n[${summary}]`,
             summary,
+            isError: result.timedOut || result.code !== 0,
         };
     },
 };
@@ -45,6 +46,7 @@ function execute(command, cwd, timeoutMs, signal, onOutput) {
             shell: true,
             windowsHide: true,
             detached: process.platform !== "win32",
+            stdio: ["ignore", "pipe", "pipe"],
         });
         const output = capture(onOutput);
         let timedOut = false;

package/dist/tui/app-workflows.js

@@ -5,6 +5,7 @@ import { updateSettings } from "../settings.js";
 import { saveTranscript } from "../transcript-export.js";
 import { recordUsage } from "../usage.js";
 import { answerAt } from "./approve.js";
+import { cancel as cancelOpen } from "./overlay.js";
 import { controllerOptions, turnFailure } from "./session-view.js";
 import { transcribe } from "./turn.js";
 const WAITING = "Waiting";
@@ -26,6 +27,10 @@ export function appWorkflows(options) {
                     state.open = { picker, settle: resolve };
                     options.render();
                 }),
+                dismiss: () => {
+                    state.open = state.open === undefined ? undefined : cancelOpen(state.open);
+                    options.render();
+                },
                 type: (field) => new Promise((resolve) => {
                     state.open = { field, settle: resolve };
                     options.render();

package/dist/tui/components/messages.js

@@ -2,6 +2,8 @@ import { blank, row } from "../../ui/render.js";
 import { markdown } from "../../ui/markdown.js";
 const PAD = 1;
 export const REASONING_PREVIEW_ROWS = 3;
+const MIN_REASONING_PREVIEW_CHARS = 4_096;
+const REASONING_PREVIEW_OVERSCAN = 12;
 export function renderUser(block, width, pal) {
     const inner = Math.max(8, width - PAD * 2);
     const content = markdown(block.text, inner, pal, inner);
@@ -21,14 +23,21 @@ export function renderAnswer(block, width, pal) {
 }
 export function renderReasoning(block, width, pal) {
     const inner = Math.max(8, width - PAD * 2);
-    const content = markdown(block.text, inner, pal, inner);
-    const expanded = block.expanded === true;
+    // Expanding a live stream is deferred until it is sealed. Re-parsing an
+    // ever-growing full thought on every token makes the whole TUI stall.
+    const expanded = block.expanded === true && block.live !== true;
+    const source = !expanded
+        ? reasoningPreviewSource(block.text, inner)
+        : { text: block.text, truncated: false };
+    const content = markdown(source.text, inner, pal, inner);
     const visible = expanded ? content : content.slice(-REASONING_PREVIEW_ROWS);
     const action = expanded
         ? "ctrl+o compact"
-        : content.length > REASONING_PREVIEW_ROWS
-            ? "ctrl+o full"
-            : undefined;
+        : block.live === true && block.expanded === true
+            ? "full when done"
+            : source.truncated || content.length > REASONING_PREVIEW_ROWS
+                ? "ctrl+o full"
+                : undefined;
     return [
         "",
         row(width, [
@@ -41,3 +50,15 @@ export function renderReasoning(block, width, pal) {
         ...visible.map((line) => row(width, line.segs.map((seg) => ({ ...seg, fg: pal.ink.muted, italic: true })), [], undefined, PAD)),
     ];
 }
+export function reasoningPreviewSource(text, width) {
+    const limit = Math.max(MIN_REASONING_PREVIEW_CHARS, width * REASONING_PREVIEW_ROWS * REASONING_PREVIEW_OVERSCAN);
+    if (text.length <= limit)
+        return { text, truncated: false };
+    // A compact view only needs its visible tail. The complete text remains on
+    // the block for expansion after the reasoning stream is sealed.
+    let start = text.length - limit;
+    const code = text.charCodeAt(start);
+    if (code >= 0xdc00 && code <= 0xdfff)
+        start--;
+    return { text: text.slice(start), truncated: true };
+}