@giovannijecha/jecode 0.8.5 → 0.8.7

package/dist/context/tokenizer/o200k.js

@@ -0,0 +1,54 @@
+// Owned o200k_base ordinary-text counter. Special-looking user text stays literal.
+import { createHash } from "node:crypto";
+import { countPiece } from "./bpe.js";
+import { vocabulary } from "./vocabulary.js";
+// OpenAI tiktoken's o200k_base split, with scoped ASCII case-insensitivity
+// expanded for JavaScript. Vocabulary and expression attribution: assets/tokenizers/LICENSE.
+const pattern = /[^\r\n\p{L}\p{N}]?[\p{Lu}\p{Lt}\p{Lm}\p{Lo}\p{M}]*[\p{Ll}\p{Lm}\p{Lo}\p{M}]+(?:'[sStTmMdD]|'[rR][eE]|'[vV][eE]|'[lL][lL])?|[^\r\n\p{L}\p{N}]?[\p{Lu}\p{Lt}\p{Lm}\p{Lo}\p{M}]+[\p{Ll}\p{Lm}\p{Lo}\p{M}]*(?:'[sStTmMdD]|'[rR][eE]|'[vV][eE]|'[lL][lL])?|\p{N}{1,3}| ?[^\p{White_Space}\p{L}\p{N}]+[\r\n/]*|\p{White_Space}*[\r\n]+|\p{White_Space}+(?!\P{White_Space})|\p{White_Space}+/gu;
+const cache = new Map();
+const CHUNK = 8_192;
+export async function countO200k(text, signal) {
+    signal?.throwIfAborted();
+    const key = createHash("sha256").update(text).digest("hex");
+    const cached = cache.get(key);
+    if (cached !== undefined)
+        return cached;
+    const ranks = await vocabulary();
+    signal?.throwIfAborted();
+    let count = 0;
+    // Repetitive logs or minified data must not repeat the same merge work.
+    // Keep text only within this call, bounded independently of input size.
+    const chunks = new Map();
+    let chunkUnits = 0;
+    for (let start = 0; start < text.length;) {
+        let end = Math.min(start + CHUNK, text.length);
+        if (end < text.length && /[\uD800-\uDBFF]/u.test(text[end - 1]))
+            end--;
+        const chunk = text.slice(start, end);
+        let tokens = chunks.get(chunk);
+        if (tokens === undefined) {
+            tokens = 0;
+            for (const match of chunk.matchAll(pattern))
+                tokens += countPiece(Buffer.from(match[0], "utf8"), ranks);
+            while (chunkUnits + chunk.length > 131_072) {
+                const oldest = chunks.keys().next().value;
+                chunks.delete(oldest);
+                chunkUnits -= oldest.length;
+            }
+            chunks.set(chunk, tokens);
+            chunkUnits += chunk.length;
+        }
+        count += tokens;
+        // Bounded slices may split a token/pre-token. Reserve boundary room; this
+        // is an input estimate, not a claim of exact whole-request tokenization.
+        if (end < text.length)
+            count += 8;
+        start = end;
+        await new Promise((resolve) => setImmediate(resolve));
+        signal?.throwIfAborted();
+    }
+    if (cache.size >= 2_048)
+        cache.delete(cache.keys().next().value);
+    cache.set(key, count);
+    return count;
+}

package/dist/context/tokenizer/vocabulary.js

@@ -0,0 +1,34 @@
+// Pinned data, loaded once on demand. No network, executable data, or user cache.
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { promisify } from "node:util";
+import { gunzip } from "node:zlib";
+let loading;
+const unpack = promisify(gunzip);
+const digest = "446a9538cb6c348e3516120d7c08b09f57c36495e2acfffe59a5bf8b0cfb1a2d";
+export function vocabulary() {
+    loading ??= load();
+    return loading;
+}
+async function load() {
+    const compressed = await readFile(new URL("../../../assets/tokenizers/o200k-base.tiktoken.gz", import.meta.url));
+    if (compressed.length > 2_000_000)
+        throw new Error("token vocabulary exceeds its size limit");
+    const data = await unpack(compressed, { maxOutputLength: 4_000_000 });
+    if (createHash("sha256").update(data).digest("hex") !== digest) {
+        throw new Error("token vocabulary checksum mismatch");
+    }
+    const ranks = new Map();
+    const lines = data.toString("ascii").trimEnd().split("\n");
+    for (let index = 0; index < lines.length; index++) {
+        const [encoded, rank] = lines[index].split(" ");
+        if (encoded === undefined || Number(rank) !== index)
+            throw new Error("invalid token vocabulary");
+        ranks.set(Buffer.from(encoded, "base64").toString("latin1"), index);
+        if (index % 2_048 === 0)
+            await new Promise((resolve) => setImmediate(resolve));
+    }
+    if (ranks.size !== 199_998)
+        throw new Error("incomplete token vocabulary");
+    return ranks;
+}

package/dist/controller-request.js

@@ -1,18 +1,22 @@
 // One streamed provider request with a single safe context-overflow recovery.
-import { budgetRequestFromInputTokens, estimateRequestInputTokensResponsive, } from "./context/budget.js";
+import { budgetRequestFromInputTokens, } from "./context/budget.js";
 import { isContextOverflow } from "./context/policy.js";
-import { projectToolResults, projectToolResultsNewest, toolResultProjectionBudget, } from "./context/request-projection.js";
-export async function requestAssistant(history, current, specs, options, events, signal) {
+import { fitRequestInput } from "./context/request.js";
+import { observePreparation, sendObserved } from "./context/request-observation.js";
+export async function requestAssistant(history, current, specs, options, events, meter, signal) {
+    let preparing = performance.now();
     let policy = await options.contextPolicy();
-    const prepared = await prepareContext(history, current, specs, options, events, policy, "budget", signal);
+    const prepared = await prepareContext(history, current, specs, options, events, meter, policy, "budget", signal);
     let context = prepared.context;
     let requestMessages = prepared.requestMessages;
     let inputTokens = prepared.inputTokens;
+    let measurement = prepared.measurement;
+    let clippedResults = prepared.clippedResults;
     let recovered = false;
     for (;;) {
         const budget = budgetRequestFromInputTokens(inputTokens, options.maxTokens, policy);
         try {
-            const message = await options.provider.send({
+            const message = await sendObserved(options.provider, {
                 model: options.model,
                 system: options.system,
                 messages: requestMessages,
@@ -25,59 +29,57 @@ export async function requestAssistant(history, current, specs, options, events,
                 signal,
                 onStream: (event) => events.onStream(event),
                 onStatus: (status) => events.onStatus?.(status),
-            });
-            return { message, context, inputTokens: budget.inputTokens };
+            }, measurement, policy, performance.now() - preparing, clippedResults);
+            return { message, context, inputTokens: budget.inputTokens, measurement };
         }
         catch (error) {
-            if (recovered)
+            if (recovered || !isContextOverflow(error))
                 throw error;
-            if (isContextOverflow(error))
-                policy = await options.contextPolicy();
-            const next = await prepareContext(history, context, specs, options, events, policy, "overflow", signal, error);
+            preparing = performance.now();
+            policy = await options.contextPolicy();
+            const next = await prepareContext(history, context, specs, options, events, meter, policy, "overflow", signal, error);
             if (sameContext(next.context, context))
                 throw error;
             context = next.context;
             requestMessages = next.requestMessages;
             inputTokens = next.inputTokens;
+            measurement = next.measurement;
+            clippedResults = next.clippedResults;
             recovered = true;
         }
     }
 }
-async function prepareContext(history, context, specs, options, events, policy, reason, signal, error) {
-    const projectionBudget = toolResultProjectionBudget(policy);
-    const initialProjection = projectToolResults(context, projectionBudget);
-    const initialRequest = initialProjection.messages;
-    const inputTokens = await estimateRequestInputTokensResponsive({
-        system: options.system,
-        messages: initialRequest,
-        tools: specs,
-    }, signal);
-    const projected = await events.onContext?.(history, context, {
-        reason,
-        policy,
-        inputTokens,
-        projectionSaturated: initialProjection.saturated,
-        ...(error === undefined ? {} : { error }),
+async function prepareContext(history, context, specs, options, events, meter, policy, reason, signal, error) {
+    return observePreparation(policy, reason, signal, async () => {
+        const input = {
+            model: options.model,
+            effort: options.effort,
+            system: options.system,
+            messages: [...context],
+            tools: specs,
+        };
+        const initial = await meter.measure(input, signal);
+        const projected = await events.onContext?.(history, context, {
+            reason,
+            policy,
+            inputTokens: initial.inputTokens,
+            ...(error === undefined ? {} : { error }),
+        });
+        const semantic = projected === undefined ? clone(context) : clone(projected);
+        if (projected !== undefined)
+            meter.reset();
+        const semanticInput = { ...input, messages: semantic };
+        const measurement = projected === undefined ? initial : await meter.measure(semanticInput, signal);
+        const fitted = await fitRequestInput(semanticInput, meter, policy, measurement, signal);
+        budgetRequestFromInputTokens(fitted.measurement.inputTokens, options.maxTokens, policy);
+        return {
+            context: semantic,
+            requestMessages: fitted.messages,
+            inputTokens: fitted.measurement.inputTokens,
+            measurement: fitted.measurement,
+            clippedResults: fitted.clippedResults,
+        };
     });
-    const semantic = projected === undefined ? clone(context) : clone(projected);
-    const stableProjection = projected === undefined
-        ? initialProjection
-        : projectToolResults(semantic, projectionBudget);
-    const requestMessages = stableProjection.saturated
-        ? projectToolResultsNewest(semantic, projectionBudget).messages
-        : stableProjection.messages;
-    const canReuseEstimate = projected === undefined && !stableProjection.saturated;
-    return {
-        context: semantic,
-        requestMessages,
-        inputTokens: canReuseEstimate
-            ? inputTokens
-            : await estimateRequestInputTokensResponsive({
-                system: options.system,
-                messages: requestMessages,
-                tools: specs,
-            }, signal),
-    };
 }
 function clone(messages) {
     return structuredClone([...messages]);

package/dist/controller.js

@@ -6,6 +6,7 @@
 import { isToolCall } from "./types.js";
 import { findTool, runTool, toolSpecs } from "./tools/index.js";
 import { requestAssistant } from "./controller-request.js";
+import { inputMeter } from "./context/measurement.js";
 export const MAX_TOOL_CALLS_PER_RESPONSE = 32;
 /** Independent read calls share one bounded execution wave. */
 export const MAX_CONCURRENT_TOOL_CALLS = 4;
@@ -16,6 +17,7 @@ export const MAX_CONCURRENT_TOOL_CALLS = 4;
  */
 export async function runTurn(history, options, events, signal, modelHistory = history) {
     const specs = toolSpecs(options.tools);
+    const meter = options.inputMeter ?? inputMeter(options.provider);
     let context = modelHistory;
     throwIfAborted(signal);
     const append = (message) => {
@@ -43,13 +45,13 @@ export async function runTurn(history, options, events, signal, modelHistory = h
         if (options.maxModelRequests !== undefined &&
             requests >= options.maxModelRequests) {
             const requestLabel = options.maxModelRequests === 1 ? "request" : "requests";
-            throw new Error(`stopped after ${options.maxModelRequests} model ${requestLabel} (--max-steps limit reached)`);
+            throw new Error(`stopped after ${options.maxModelRequests} model ${requestLabel} (request budget reached)`);
         }
         appendSteering(options.steering?.drain() ?? []);
         requests++;
         // The message is displayed as it streams; what comes back here is the
         // assembled version, which exists to be appended to the history.
-        const response = await requestAssistant(history, context, specs, options, events, signal);
+        const response = await requestAssistant(history, context, specs, options, events, meter, signal);
         const assistant = response.message;
         context = response.context;
         throwIfAborted(signal);
@@ -63,6 +65,7 @@ export async function runTurn(history, options, events, signal, modelHistory = h
         assertToolCallIds(calls);
         if (assistant.usage !== undefined)
             events.onUsage?.(assistant.usage);
+        meter.observe(response.measurement, assistant.usage?.inputTokens);
         events.onRequestInput?.(assistant.usage !== undefined && assistant.usage.inputTokens > 0
             ? assistant.usage.inputTokens
             : response.inputTokens);
@@ -193,11 +196,17 @@ async function settle(call, current, total, options, events, signal, preview) {
     if (tool === undefined) {
         return refuse(call, `no such tool: ${call.name}`, "unknown tool");
     }
+    if (options.toolAllowed?.(call) === false) {
+        return refuse(call, "this tool is denied by the current session permissions", "denied");
+    }
     const approved = !tool.dangerous || await events.approve(call);
     throwIfAborted(signal);
     if (!approved) {
         return refuse(call, "the user declined this call — ask them how to proceed", "declined");
     }
+    if (options.toolAllowed?.(call) === false) {
+        return refuse(call, "this tool is denied by the current session permissions", "denied");
+    }
     throwIfAborted(signal);
     events.onToolStart?.(call, current, total);
     return runTool(tool, call, {
@@ -223,6 +232,8 @@ function refuse(call, reason, summary) {
 async function look(call, options, signal) {
     if (call.inputError !== undefined)
         return undefined;
+    if (options.toolAllowed?.(call) === false)
+        return undefined;
     const tool = findTool(options.tools, call.name);
     if (tool?.preview === undefined)
         return undefined;

package/dist/credential-commands.js

@@ -64,13 +64,13 @@ export async function apiKeyCommand(name, label, session, host, providerId) {
         if (!hasSaved(name)) {
             host.emit({
                 kind: "notice",
-                text: `${label} API key comes from the environment · restart after changing it`,
+                text: `${label} key comes from the environment · restart after changing it`,
                 tone: "info",
             });
             return;
         }
         const action = await choose({
-            title: heading(`${label} API key`, `${name} · environment`, session.palette),
+            title: heading(`${label} key`, `${name} · environment`, session.palette),
             description: "The environment value is read-only. A saved copy is currently shadowed.",
             options: [{ label: "forget saved copy", hint: storeLabel(), key: "f" }],
             index: 0,
@@ -93,7 +93,7 @@ export async function apiKeyCommand(name, label, session, host, providerId) {
             : []),
     ];
     const index = await choose({
-        title: heading(`${label} API key`, `${name} · ${source ?? "missing"}`, session.palette),
+        title: heading(`${label} key`, `${name} · ${source ?? "missing"}`, session.palette),
         options: actions,
         index: 0,
     });

package/dist/input-boundary.js

@@ -1,6 +1,4 @@
 // One bounded ingress for text that can become a user prompt.
-import { Buffer } from "node:buffer";
-import { StringDecoder } from "node:string_decoder";
 import { MAX_TEXT_CODE_UNITS } from "./text-boundary.js";
 export const MAX_PROMPT_CODE_UNITS = MAX_TEXT_CODE_UNITS;
 export const PROMPT_LIMIT_MESSAGE = `Prompt cannot exceed ${MAX_PROMPT_CODE_UNITS.toLocaleString("en-US")} UTF-16 code units`;
@@ -18,63 +16,3 @@ export function assertPromptAppend(current, added) {
     if (added > MAX_PROMPT_CODE_UNITS - current)
         throw new PromptLimitError();
 }
-/**
- * Split raw UTF-8 input without letting one unterminated line grow past the
- * prompt boundary. Newline, CRLF, and a final line without a newline match the
- * line semantics used by batch mode.
- */
-export async function* boundedInputLines(source) {
-    const decoder = new StringDecoder("utf8");
-    let line = "";
-    let pendingCr = false;
-    const append = (text, from, to) => {
-        const length = to - from;
-        assertPromptAppend(line.length, length);
-        if (length > 0)
-            line += text.slice(from, to);
-    };
-    const consume = function* (text) {
-        if (text === "")
-            return;
-        let from = 0;
-        if (pendingCr) {
-            if (text.startsWith("\n"))
-                from = 1;
-            pendingCr = false;
-            yield line;
-            line = "";
-        }
-        while (from < text.length) {
-            const cr = text.indexOf("\r", from);
-            const lf = text.indexOf("\n", from);
-            const newline = cr === -1 ? lf : lf === -1 ? cr : Math.min(cr, lf);
-            if (newline === -1) {
-                append(text, from, text.length);
-                return;
-            }
-            append(text, from, newline);
-            if (text[newline] === "\r" && newline + 1 === text.length) {
-                pendingCr = true;
-                return;
-            }
-            yield line;
-            line = "";
-            from = text[newline] === "\r" && text[newline + 1] === "\n"
-                ? newline + 2
-                : newline + 1;
-        }
-    };
-    for await (const chunk of source) {
-        const text = typeof chunk === "string" ? chunk : decoder.write(Buffer.from(chunk));
-        yield* consume(text);
-    }
-    const tail = decoder.end();
-    if (tail !== "")
-        yield* consume(tail);
-    if (pendingCr) {
-        yield line;
-        line = "";
-    }
-    if (line !== "")
-        yield line;
-}

package/dist/launch.js

@@ -1,19 +1,23 @@
 export function parseLaunch(argv) {
+    if (argv.includes("--latest")) {
+        throw new Error("--latest has been renamed to --last; use `jecode -c` or `jecode resume --last`");
+    }
     const first = argv[0];
-    if (first !== undefined && !first.startsWith("--") && first !== "-h" && first !== "-v") {
-        if (first !== "resume")
-            throw new Error(`unknown command ${first}`);
-        const rest = argv.slice(1);
-        const latest = rest.filter((value) => value === "--latest").length;
+    if (first === "resume" || first === "-c") {
+        const rest = first === "-c" ? ["--last", ...argv.slice(1)] : argv.slice(1);
+        const latest = rest.filter((value) => value === "--last").length;
         if (latest > 1)
-            throw new Error("--latest may be passed only once");
+            throw new Error("--last may be passed only once; -c already selects the last session");
         return {
             kind: "resume",
             latest: latest === 1,
-            configArgs: rest.filter((value) => value !== "--latest"),
+            configArgs: rest.filter((value) => value !== "--last"),
         };
     }
-    if (argv.includes("--latest"))
-        throw new Error("--latest requires `jecode resume`");
+    if (first !== undefined && !first.startsWith("--") && first !== "-h" && first !== "-v") {
+        throw new Error(`unknown command ${first}`);
+    }
+    if (argv.includes("--last"))
+        throw new Error("--last requires `jecode resume`; use `jecode -c` to continue directly");
     return { kind: "new", latest: false, configArgs: [...argv] };
 }

package/dist/model-command.js

@@ -17,9 +17,6 @@ export async function modelsCommand(session, host, behavior = {}, providers = PR
     const connected = availability
         .filter((entry) => entry.blocked === undefined)
         .map((entry) => entry.provider);
-    const disconnected = availability
-        .filter((entry) => entry.blocked !== undefined)
-        .map((entry) => entry.provider);
     if (connected.length === 0) {
         host.emit({
             kind: "notice",
@@ -68,10 +65,15 @@ export async function modelsCommand(session, host, behavior = {}, providers = PR
         });
         return false;
     }
-    const description = catalogDescription(disconnected, failed);
+    if (failed.length > 0) {
+        host.emit({
+            kind: "notice",
+            text: `model catalogs unavailable: ${failed.map((entry) => providerLabel(entry.provider.id)).join(", ")}`,
+            tone: "warn",
+        });
+    }
     const index = await choose({
         title: [],
-        ...(description === undefined ? {} : { description }),
         options: choices.map((choice) => ({
             label: choice.model,
             // Provider identity is part of the choice, not optional help: keep it
@@ -136,18 +138,6 @@ async function alignEffort(provider, model, effort, host) {
         return { ok: false };
     }
 }
-function catalogDescription(disconnected, failed) {
-    const parts = [
-        "The connection on the right will run this model; API and account usage stay separate",
-        disconnected.length === 0
-            ? undefined
-            : `Not connected: ${disconnected.map((provider) => providerLabel(provider.id)).join(", ")}`,
-        failed.length === 0
-            ? undefined
-            : `Unavailable: ${failed.map((entry) => providerLabel(entry.provider.id)).join(", ")}`,
-    ].filter((part) => part !== undefined);
-    return `${parts.join(" · ")} · manage access in /providers`;
-}
 function emptyCatalogMessage(connected, failed) {
     if (failed.length === 1 && connected.length === 1) {
         const one = failed[0];

package/dist/oauth-result-page.js

@@ -0,0 +1,68 @@
+// The browser handoff back to the terminal after account sign-in.
+import { readFileSync } from "node:fs";
+export function oauthResultPage(success) {
+    const title = success ? "You're signed in" : "Sign-in failed";
+    const detail = success
+        ? "Return to your terminal. You can close this tab."
+        : "Return to your terminal to try again.";
+    return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <meta name="color-scheme" content="dark">
+  <title>${title} · Jecode</title>
+  <style>
+    :root {
+      color-scheme: dark;
+      --background: #1c2026;
+      --text: #ebeff4;
+      --muted: #9ca9b7;
+      --accent: #669bd2;
+      --error: #e87070;
+    }
+    * { box-sizing: border-box; }
+    body {
+      margin: 0;
+      min-height: 100vh;
+      min-height: 100svh;
+      display: grid;
+      place-items: center;
+      background: var(--background);
+      color: var(--text);
+      font-family: "Segoe UI", system-ui, sans-serif;
+    }
+    main { width: min(28rem, 100%); padding: 2rem; }
+    .identity { display: flex; align-items: center; gap: .75rem; margin-bottom: 2rem; }
+    .identity img { display: block; width: 3rem; height: 3rem; }
+    .identity span {
+      color: var(--accent);
+      font: 600 1.25rem/1 ui-monospace, "Cascadia Mono", Consolas, monospace;
+      letter-spacing: -.04em;
+    }
+    h1 { margin: 0; font-size: 1.75rem; font-weight: 600; line-height: 1.25; letter-spacing: -.025em; }
+    p { margin: .75rem 0 0; color: var(--muted); font-size: 1rem; line-height: 1.6; }
+    .failure h1 { color: var(--error); }
+  </style>
+</head>
+<body>
+  <main${success ? "" : ' class="failure"'}>
+    <div class="identity">
+      <img src="${mascotDataUri()}" width="48" height="48" alt="">
+      <span>jecode</span>
+    </div>
+    <h1>${title}</h1>
+    <p>${detail}</p>
+  </main>
+  <script>history.replaceState(null,"","/auth/complete")</script>
+</body>
+</html>`;
+}
+let mascot;
+function mascotDataUri() {
+    if (mascot === undefined) {
+        const file = new URL("../assets/jeco-256.png", import.meta.url);
+        mascot = `data:image/png;base64,${readFileSync(file).toString("base64")}`;
+    }
+    return mascot;
+}

package/dist/openai-account-command.js

@@ -1,9 +1,11 @@
-// Interactive ChatGPT account management for the OpenAI Codex provider.
+// Interactive account management for the OpenAI Codex provider.
 import { openAICodexAccount } from "./accounts.js";
 import { headlessEnvironment, openExternal } from "./external-browser.js";
 import { openAIAccountHint, removeOpenAIAccount, saveOpenAIAccount, } from "./openai-account.js";
 import { beginBrowserLogin, beginDeviceLogin, } from "./openai-oauth.js";
+import { providerLabel } from "./provider-label.js";
 import { heading } from "./tui/picker.js";
+const ACCOUNT_LABEL = providerLabel("openai-codex");
 const DEFAULT_DEPENDENCIES = {
     beginBrowser: beginBrowserLogin,
     beginDevice: beginDeviceLogin,
@@ -16,12 +18,12 @@ export async function openAIAccountCommand(session, host, dependencies = DEFAULT
     const connected = openAICodexAccount() !== undefined;
     const actions = connected
         ? [
-            { label: "reconnect ChatGPT", hint: "replace the current sign-in", key: "r" },
+            { label: `reconnect ${ACCOUNT_LABEL}`, hint: "replace the current sign-in", key: "r" },
             { label: "sign out", hint: "remove the saved account", key: "s" },
         ]
-        : [{ label: "connect ChatGPT", hint: "sign in with OpenAI", key: "c" }];
+        : [{ label: `connect ${ACCOUNT_LABEL}`, hint: "sign in with OpenAI", key: "c" }];
     const action = await host.choose({
-        title: heading("ChatGPT", openAIAccountHint(), session.palette),
+        title: heading(ACCOUNT_LABEL, openAIAccountHint(), session.palette),
         options: actions,
         index: 0,
     });
@@ -35,8 +37,8 @@ export async function openAIAccountCommand(session, host, dependencies = DEFAULT
         host.emit({
             kind: "notice",
             text: result.revokeFailed
-                ? `ChatGPT disconnected · remote sign-out could not be confirmed${route}`
-                : `ChatGPT disconnected${route}`,
+                ? `${ACCOUNT_LABEL} disconnected · remote sign-out could not be confirmed${route}`
+                : `${ACCOUNT_LABEL} disconnected${route}`,
             tone: result.revokeFailed ? "warn" : "info",
         });
         return result.removed;
@@ -56,14 +58,14 @@ async function connectOpenAIAccount(session, host, dependencies) {
         { label: "sign in with device code", hint: "WSL, SSH, or headless", key: "d" },
     ];
     const choice = await host.choose({
-        title: heading("connect ChatGPT", "OpenAI OAuth", session.palette),
+        title: heading(`connect ${ACCOUNT_LABEL}`, "OpenAI OAuth", session.palette),
         description: "Choose the flow for this terminal. Your password stays on OpenAI's website.",
         options: methods,
         index: dependencies.headless() ? 1 : 0,
     });
     if (choice === undefined)
         return false;
-    host.status?.("Starting ChatGPT sign-in");
+    host.status?.(`Starting ${ACCOUNT_LABEL} sign-in`);
     let login;
     try {
         login = choice === 1
@@ -97,8 +99,8 @@ async function waitForLogin(login, session, host, openUrl) {
                 host.emit({
                     kind: "notice",
                     text: session.provider.id === "openai-codex"
-                        ? "ChatGPT connected · current provider route"
-                        : "ChatGPT connected · choose a ChatGPT model in /models to use this account",
+                        ? `${ACCOUNT_LABEL} connected · current provider route`
+                        : `${ACCOUNT_LABEL} connected · choose an ${ACCOUNT_LABEL} model in /models to use this account`,
                     tone: "info",
                 });
                 return true;
@@ -111,7 +113,7 @@ async function waitForLogin(login, session, host, openUrl) {
                 await openUrl(login.url);
                 continue;
             }
-            local.abort(new Error("ChatGPT sign-in cancelled"));
+            local.abort(new Error(`${ACCOUNT_LABEL} sign-in cancelled`));
             return false;
         }
     }
@@ -124,7 +126,7 @@ function waitingPicker(login, session) {
         ? "Finish sign-in in your browser. Jecode will continue automatically."
         : `Enter ${login.code} on OpenAI's device page. Jecode will continue automatically.`;
     return {
-        title: heading("ChatGPT sign-in", login.code ?? "waiting for browser", session.palette),
+        title: heading(`${ACCOUNT_LABEL} sign-in`, login.code ?? "waiting for browser", session.palette),
         description: detail,
         options: [
             { label: "open browser again", key: "o" },

package/dist/openai-account.js

@@ -1,6 +1,8 @@
-// The live ChatGPT account: persistence, proactive refresh, and logout.
+// The live OpenAI account: persistence, proactive refresh, and logout.
 import { openAICodexAccount, updateOpenAICodexAccount } from "./accounts.js";
 import { refreshOpenAITokens, revokeOpenAITokens } from "./openai-oauth.js";
+import { providerLabel } from "./provider-label.js";
+const ACCOUNT_LABEL = providerLabel("openai-codex");
 const REFRESH_EARLY_MS = 5 * 60_000;
 let refreshing;
 export function openAIAccountHint() {
@@ -33,7 +35,7 @@ export async function removeOpenAIAccount(signal) {
 export async function openAIAuthorization(rejectedToken, signal, onStatus) {
     const account = openAICodexAccount();
     if (account === undefined)
-        throw new Error("ChatGPT account is not connected");
+        throw new Error(`${ACCOUNT_LABEL} is not connected`);
     const mustRefresh = rejectedToken !== undefined || expiresSoon(account);
     const ready = mustRefresh
         ? await refreshAccount(rejectedToken, signal, onStatus)
@@ -47,14 +49,14 @@ async function refreshAccount(rejectedToken, signal, onStatus) {
         throw abortReason(signal);
     const task = updateOpenAICodexAccount(async (current) => {
         if (current === undefined)
-            throw new Error("ChatGPT account is not connected");
+            throw new Error(`${ACCOUNT_LABEL} is not connected`);
         if (!requiresAuthorityRefresh(current, rejectedToken))
             return current;
-        onStatus?.("Refreshing ChatGPT sign-in");
+        onStatus?.(`Refreshing ${ACCOUNT_LABEL} sign-in`);
         return refreshOpenAITokens(current);
     }).then((account) => {
         if (account === undefined)
-            throw new Error("ChatGPT account is not connected");
+            throw new Error(`${ACCOUNT_LABEL} is not connected`);
         return account;
     });
     refreshing = task;