@giovannijecha/jecode 0.8.5 → 0.8.6

package/README.md

@@ -26,9 +26,9 @@
   <a href="https://github.com/giovannijecha/jecode/releases">Releases</a>
 </p>
 
-> Jecode is currently pre-1.0. The core loop is usable today, but commands and
-> terminal interactions may still evolve before 1.0. The release-candidate
-> surface is now frozen in the [compatibility contract](https://github.com/giovannijecha/jecode/blob/main/docs/COMPATIBILITY.md).
+> Jecode is stabilizing for 1.0. New capabilities are deferred while correctness,
+> recovery, performance, accessibility, and interface refinements continue within
+> the [compatibility contract](https://github.com/giovannijecha/jecode/blob/main/docs/COMPATIBILITY.md).
 
 ## Why Jecode
 
@@ -37,8 +37,16 @@ follow tool calls and diffs, steer the model while it runs, and resume the same
 conversation later. One controller carries each turn from prompt to result—no
 delegated agents or hidden model workers.
 
-Choose Anthropic API, OpenAI API, an eligible ChatGPT account, or Ollama without
-changing the workflow. API connections and account access stay separate, and
+Tool records keep the target, outcome, and compact evidence together. Expand a
+record to inspect its complete output or diff while the composer stays ready
+at the full width of the terminal.
+
+Menus keep the selected choice and its details together. Approvals separate
+the target from the decision and make the scope of remembered access explicit.
+
+Choose Anthropic API, OpenAI API, OpenAI Account with eligible ChatGPT access,
+or Ollama API without changing the workflow. Ollama uses its cloud API only.
+API connections and account access stay separate, and
 the footer always names the route selected for the next request. Jecode is
 written in TypeScript and released as plain JavaScript for Node.js, with no
 installation scripts and zero third-party runtime dependencies. The runtime
@@ -166,6 +174,15 @@ The [user guide](https://github.com/giovannijecha/jecode/blob/main/docs/USAGE.md
 covers provider access, TUI controls, sessions and compaction, batch mode,
 configuration, and safety boundaries.
 
+The [architecture guide](https://github.com/giovannijecha/jecode/blob/main/docs/ARCHITECTURE.md)
+explains the current implementation and module boundaries. Maintainers use the
+[release guide](https://github.com/giovannijecha/jecode/blob/main/docs/RELEASING.md)
+for publishing and release recovery.
+
+The [development environments](https://github.com/giovannijecha/jecode/blob/main/dev/README.md)
+provide the TUI lab, current interface direction, and manual performance probes
+for working from a source checkout.
+
 ## Community
 
 - Ask questions, share workflows, and explore early ideas in

package/dist/batch-view.js

@@ -1,9 +1,14 @@
 // Project semantic blocks into a compact transcript for pipes.
-import { render } from "./tui/blocks.js";
+import { renderAnswer, renderReasoning, renderUser } from "./tui/components/messages.js";
+import { renderNotice } from "./tui/components/misc.js";
+import { renderDetail } from "./tui/components/tool-evidence.js";
+import { stateInk, stateMark } from "./tui/components/tool-motion.js";
+import { toolDuration } from "./duration.js";
+import { row } from "./ui/render.js";
 export function renderBatch(block, width, pal) {
     const rows = [];
     let lastWasBlank = false;
-    for (const rendered of render(block, width, pal)) {
+    for (const rendered of batchRows(block, width, pal)) {
         const line = rendered.trimEnd();
         const blank = line === "";
         if (blank && lastWasBlank)
@@ -15,3 +20,23 @@ export function renderBatch(block, width, pal) {
         rows.pop();
     return rows;
 }
+function batchRows(block, width, pal) {
+    switch (block.kind) {
+        case "answer": return renderAnswer(block, width, pal);
+        case "reasoning": return renderReasoning(block, width, pal);
+        case "user": return renderUser(block, width, pal);
+        case "notice": return renderNotice(block, width, pal);
+        case "tool": {
+            // Pipes cannot expand records or repaint a running connector.
+            const mark = stateMark(block);
+            const result = [block.right, block.durationMs === undefined ? "" : toolDuration(block.durationMs)]
+                .filter(Boolean).join(" · ");
+            return ["", row(width, [
+                    { text: `${mark} `, fg: stateInk(block, pal) },
+                    { text: block.name, fg: pal.ink.bright },
+                    { text: block.target === "" ? "" : `  ${block.target}`, fg: pal.technical },
+                ], [{ text: result, fg: pal.ink.muted }]),
+                ...(block.body ?? []).map((detail) => renderDetail(detail, block.tone, width, pal))];
+        }
+    }
+}

package/dist/batch.js

@@ -68,6 +68,7 @@ export async function runBatch(session, environment = {}) {
                     provider: session.provider,
                     model: session.model,
                     compactionPercent: session.config.compactionPercent,
+                    signal,
                 });
             };
             const user = { role: "user", content: [{ kind: "text", text: line }] };
@@ -106,6 +107,7 @@ export async function runBatch(session, environment = {}) {
                     provider: session.provider,
                     model: session.model,
                     effort: session.config.effort,
+                    signal,
                     context: projected,
                     turn: checkpoint.slice(before),
                     nodeId: nodeId ?? prospectiveNodeId,

package/dist/cli-info.js

@@ -12,7 +12,6 @@ Options:
   --root <path>          workspace root (default: current directory)
   --provider <id>        anthropic, openai, openai-codex, or ollama
   --model <id>           model for the selected provider
-  --ollama-host <url>    Ollama Cloud, local, or custom endpoint
   --effort <level>       low, medium, high, xhigh, or max
   --max-tokens <number>  output-token ceiling
   --max-steps <number>   optional per-turn model-request budget

package/dist/config.js

@@ -2,11 +2,10 @@
 import * as path from "node:path";
 import { DEFAULT_COMPACTION_PERCENT, MAX_COMPACTION_PERCENT, MIN_COMPACTION_PERCENT, } from "./context/policy.js";
 import { EFFORTS, readSettings } from "./settings.js";
-import { parseOllamaEndpoint } from "./providers/ollama-endpoint.js";
+import { isLegacyOllamaCloudHost } from "./providers/ollama-endpoint.js";
 const VALUE_FLAGS = [
     "provider",
     "model",
-    "ollama-host",
     "effort",
     "max-tokens",
     "max-steps",
@@ -21,8 +20,8 @@ const BOOLEAN_FLAGS = [
 const FLAGS = [...VALUE_FLAGS, ...BOOLEAN_FLAGS];
 export function loadConfig(argv, saved = readSettings()) {
     const flags = parseFlags(argv);
+    assertRetiredOllamaSettings(saved);
     const providerId = pick(flags.provider, process.env.JECODE_PROVIDER, saved.provider ?? "anthropic");
-    const ollamaHost = optional(flags["ollama-host"], process.env.OLLAMA_HOST, saved.ollamaHost);
     const effort = pick(flags.effort, process.env.JECODE_EFFORT, saved.effort ?? "high");
     if (!EFFORTS.includes(effort)) {
         throw new Error(`unknown effort "${effort}" (expected one of: ${EFFORTS.join(", ")})`);
@@ -31,9 +30,6 @@ export function loadConfig(argv, saved = readSettings()) {
     return {
         providerId,
         model: pick(flags.model, process.env.JECODE_MODEL, saved.models?.[providerId] ?? ""),
-        ...(ollamaHost === undefined
-            ? {}
-            : { ollamaHost: parseOllamaEndpoint(ollamaHost).baseUrl }),
         reducedMotion: bool(flags["reduced-motion"], process.env.JECODE_REDUCED_MOTION, saved.reducedMotion ?? false),
         effort,
         // This is a ceiling, not a target. Request budgeting may lower it to fit
@@ -48,6 +44,15 @@ export function loadConfig(argv, saved = readSettings()) {
         ephemeral: bool(flags.ephemeral, process.env.JECODE_EPHEMERAL, false),
     };
 }
+function assertRetiredOllamaSettings(saved) {
+    const host = process.env.OLLAMA_HOST;
+    if (host !== undefined && host !== "" && !isLegacyOllamaCloudHost(host)) {
+        throw new Error("OLLAMA_HOST no longer selects an endpoint; remove it to use Ollama API at https://ollama.com");
+    }
+    if (saved.ollamaHost !== undefined && !isLegacyOllamaCloudHost(saved.ollamaHost)) {
+        throw new Error("settings.json has a retired Ollama endpoint; remove ollamaHost to use Ollama API at https://ollama.com");
+    }
+}
 function bool(flag, env, fallback) {
     if (flag !== undefined)
         return flag === "true" || flag === "1";
@@ -105,6 +110,9 @@ function parseFlags(argv) {
         const eq = body.indexOf("=");
         const name = eq === -1 ? body : body.slice(0, eq);
         const inline = eq === -1 ? undefined : body.slice(eq + 1);
+        if (name === "ollama-host") {
+            throw new Error("--ollama-host is no longer supported; remove it to use Ollama API at https://ollama.com");
+        }
         if (!FLAGS.includes(name)) {
             throw new Error(`unknown flag --${name} (known: ${FLAGS.map((flag) => `--${flag}`).join(", ")})`);
         }

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/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;

package/dist/openai-oauth-callback.js

@@ -3,6 +3,8 @@ import { timingSafeEqual } from "node:crypto";
 import { readFileSync } from "node:fs";
 import { createServer } from "node:http";
 import { leadingText } from "./text-boundary.js";
+import { providerLabel } from "./provider-label.js";
+const ACCOUNT_LABEL = providerLabel("openai-codex");
 const CALLBACK_PORTS = [1455, 1457];
 export const OPENAI_CALLBACK_PATH = "/auth/callback";
 export async function openAICallback(state) {
@@ -26,7 +28,14 @@ export async function openAICallback(state) {
             outgoing.writeHead(400).end("Invalid sign-in callback.");
             return;
         }
-        const incoming = new URL(request.url, "http://localhost");
+        let incoming;
+        try {
+            incoming = new URL(request.url, "http://localhost");
+        }
+        catch {
+            outgoing.writeHead(400).end("Invalid sign-in callback.");
+            return;
+        }
         if (incoming.pathname !== OPENAI_CALLBACK_PATH) {
             outgoing.writeHead(404).end("Not found.");
             return;
@@ -43,10 +52,10 @@ export async function openAICallback(state) {
         const authError = incoming.searchParams.get("error_description") ?? incoming.searchParams.get("error");
         const authorizationCode = incoming.searchParams.get("code");
         if (authError !== null) {
-            rejectCode(new Error(`ChatGPT sign-in was rejected · ${leadingText(authError, 300)}`));
+            rejectCode(new Error(`${ACCOUNT_LABEL} sign-in was rejected · ${leadingText(authError, 300)}`));
         }
         else if (authorizationCode === null || authorizationCode === "") {
-            rejectCode(new Error("ChatGPT sign-in returned no authorization code"));
+            rejectCode(new Error(`${ACCOUNT_LABEL} sign-in returned no authorization code`));
         }
         else {
             resolveCode(authorizationCode);
@@ -94,7 +103,7 @@ async function firstAvailableServer(handler) {
                 throw error;
         }
     }
-    throw new Error("ChatGPT sign-in could not open callback ports 1455 or 1457");
+    throw new Error(`${ACCOUNT_LABEL} sign-in could not open callback ports 1455 or 1457`);
 }
 function listen(server, port) {
     return new Promise((resolve, reject) => {

package/dist/openai-oauth-tokens.js

@@ -1,15 +1,17 @@
 // Validate OAuth token responses and extract the ChatGPT account claims.
+import { providerLabel } from "./provider-label.js";
+const ACCOUNT_LABEL = providerLabel("openai-codex");
 const CLAIMS = "https://api.openai.com/auth";
 export function openAITokenReply(value, previousRefresh) {
     if (!record(value))
-        throw new Error("OpenAI sign-in returned an invalid token response");
+        throw new Error(`${ACCOUNT_LABEL} sign-in returned an invalid token response`);
     const accessToken = required(value["access_token"], "access token");
     const refreshToken = optional(value["refresh_token"]) ?? previousRefresh;
     const expiresIn = value["expires_in"];
     if (refreshToken === undefined)
-        throw new Error("OpenAI sign-in did not return a refresh token");
+        throw new Error(`${ACCOUNT_LABEL} sign-in did not return a refresh token`);
     if (typeof expiresIn !== "number" || !Number.isFinite(expiresIn) || expiresIn <= 0) {
-        throw new Error("OpenAI sign-in did not return a valid token lifetime");
+        throw new Error(`${ACCOUNT_LABEL} sign-in did not return a valid token lifetime`);
     }
     const idToken = optional(value["id_token"]);
     return {
@@ -25,7 +27,7 @@ export function openAIAccountFromTokens(token) {
     const auth = record(access[CLAIMS]) ? access[CLAIMS] : {};
     const accountId = optional(auth["chatgpt_account_id"]) ?? optional(identity?.["chatgpt_account_id"]);
     if (accountId === undefined)
-        throw new Error("OpenAI sign-in did not identify a ChatGPT account");
+        throw new Error(`${ACCOUNT_LABEL} sign-in did not identify an account`);
     const email = optional(identity?.["email"]);
     const plan = optional(auth["chatgpt_plan_type"]) ?? optional(identity?.["chatgpt_plan_type"]);
     return {
@@ -40,7 +42,7 @@ export function openAIAccountFromTokens(token) {
 function jwt(token) {
     const part = token.split(".")[1];
     if (part === undefined)
-        throw new Error("OpenAI sign-in returned an unreadable token");
+        throw new Error(`${ACCOUNT_LABEL} sign-in returned an unreadable token`);
     try {
         const value = JSON.parse(Buffer.from(part, "base64url").toString("utf8"));
         if (!record(value))
@@ -48,13 +50,13 @@ function jwt(token) {
         return value;
     }
     catch {
-        throw new Error("OpenAI sign-in returned an unreadable token");
+        throw new Error(`${ACCOUNT_LABEL} sign-in returned an unreadable token`);
     }
 }
 function required(value, label) {
     const found = optional(value);
     if (found === undefined)
-        throw new Error(`OpenAI sign-in returned no ${label}`);
+        throw new Error(`${ACCOUNT_LABEL} sign-in returned no ${label}`);
     return found;
 }
 function optional(value) {

package/dist/openai-oauth.js

@@ -5,8 +5,10 @@
 // an account on disk.
 import { createHash, randomBytes } from "node:crypto";
 import { oauthRequest } from "./oauth-http.js";
+import { providerLabel } from "./provider-label.js";
 import { OPENAI_CALLBACK_PATH, openAICallback } from "./openai-oauth-callback.js";
 import { openAIAccountFromTokens, openAITokenReply, } from "./openai-oauth-tokens.js";
+const ACCOUNT_LABEL = providerLabel("openai-codex");
 const CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
 const AUTHORITY = "https://auth.openai.com";
 const AUTHORIZE = `${AUTHORITY}/oauth/authorize`;
@@ -91,7 +93,7 @@ export async function refreshOpenAITokens(account, signal) {
     const token = openAITokenReply(response.value, account.refreshToken);
     const refreshed = openAIAccountFromTokens(token);
     if (refreshed.accountId !== account.accountId) {
-        throw new Error("OpenAI refreshed a different ChatGPT account · sign in again");
+        throw new Error(`${ACCOUNT_LABEL} refresh returned a different account · sign in again`);
     }
     return {
         ...refreshed,
@@ -125,7 +127,7 @@ async function exchange(code, signal) {
 async function pollDevice(deviceAuthId, userCode, interval, signal) {
     const deadline = new AbortController();
     const timer = setTimeout(() => {
-        deadline.abort(new Error("ChatGPT device sign-in timed out after 15 minutes"));
+        deadline.abort(new Error(`${ACCOUNT_LABEL} device sign-in timed out after 15 minutes`));
     }, LOGIN_LIMIT_MS);
     const combined = signal === undefined
         ? deadline.signal
@@ -149,10 +151,10 @@ async function pollDevice(deviceAuthId, userCode, interval, signal) {
             }
             const errorCode = deviceErrorCode(response.value);
             if (errorCode === "access_denied") {
-                throw new Error("ChatGPT device sign-in was denied");
+                throw new Error(`${ACCOUNT_LABEL} device sign-in was denied`);
             }
             if (errorCode === "expired_token") {
-                throw new Error("ChatGPT device sign-in code expired");
+                throw new Error(`${ACCOUNT_LABEL} device sign-in code expired`);
             }
             const pending = errorCode === "authorization_pending" ||
                 errorCode === "deviceauth_authorization_pending" ||
@@ -160,7 +162,7 @@ async function pollDevice(deviceAuthId, userCode, interval, signal) {
             const slowDown = errorCode === "slow_down" ||
                 (response.status === 429 && errorCode === undefined);
             if (!pending && !slowDown) {
-                throw new Error(`ChatGPT device sign-in failed (${response.status})`);
+                throw new Error(`${ACCOUNT_LABEL} device sign-in failed (${response.status})`);
             }
             if (slowDown)
                 intervalMs += SLOW_DOWN_INCREMENT_MS;
@@ -192,7 +194,7 @@ function intervalSeconds(value) {
 function required(value, label) {
     const found = optional(value);
     if (found === undefined)
-        throw new Error(`OpenAI sign-in returned no ${label}`);
+        throw new Error(`${ACCOUNT_LABEL} sign-in returned no ${label}`);
     return found;
 }
 function optional(value) {

package/dist/permission-command.js

@@ -42,7 +42,7 @@ export function permissionsPicker(tools, index = 0, adjust) {
         index: Math.min(Math.max(0, index), Math.max(0, tools.length - 1)),
     };
 }
-function permissionControlPicker(control, host, selected) {
+export function permissionControlPicker(control, host, selected) {
     return permissionsPicker(control.listTools(), selected, (index, step) => {
         const tool = control.listTools()[index];
         if (tool === undefined)

package/dist/provider-commands.js

@@ -1,16 +1,12 @@
 // Provider access and connection management. Runtime selection lives in /models.
-import { saveCommandSettings } from "./command-settings.js";
 import { apiKeyCommand } from "./credential-commands.js";
 import { credentialSource } from "./credentials.js";
-import { ollamaConnectionHint, ollamaConnectionSetting, } from "./ollama-settings-command.js";
 import { openAIAccountHint } from "./openai-account.js";
 import { openAIAccountCommand } from "./openai-account-command.js";
 import { providerLabel, providerRouteLabel } from "./provider-label.js";
 import { PROVIDERS } from "./providers/index.js";
-import { ollamaConnection } from "./providers/ollama.js";
 import { heading } from "./tui/picker.js";
-const OLLAMA_KEY = "OLLAMA_API_KEY";
-/** The single control plane for API keys, OAuth accounts, and Ollama endpoints. */
+/** The single control plane for API keys and OAuth accounts. */
 export async function providersCommand(session, host) {
     const choose = chooser(host);
     if (choose === undefined)
@@ -81,45 +77,17 @@ function providerGroupHint(group, activeId) {
     return active === undefined ? count : `${count} · current ${providerRouteLabel(active)}`;
 }
 export function providerAccessHint(provider) {
-    if (provider.id === "ollama") {
-        const connection = ollamaConnection();
-        if (connection.loopback)
-            return `${ollamaConnectionHint()} · no key needed`;
-        return `${ollamaConnectionHint()} · API key ${credentialSource(OLLAMA_KEY) ?? "missing"}`;
-    }
     if (provider.auth.kind === "oauth")
         return openAIAccountHint();
     return `API key · ${credentialSource(provider.auth.keyVar) ?? "missing"}`;
 }
 async function manageProvider(provider, session, host) {
-    if (provider.id === "ollama") {
-        await ollamaProviderCommand(session, host);
-        return;
-    }
     if (provider.auth.kind === "oauth") {
         await openAIAccountCommand(session, host);
         return;
     }
     await apiKeyCommand(provider.auth.keyVar, providerLabel(provider.id), session, host, provider.id);
 }
-async function ollamaProviderCommand(session, host) {
-    if (host.choose === undefined)
-        return;
-    const index = await host.choose({
-        title: heading("Ollama", "access and connection", session.palette),
-        options: [
-            { label: "connection", hint: ollamaConnectionHint() },
-            { label: "API key", hint: credentialSource(OLLAMA_KEY) ?? "missing" },
-        ],
-        index: 0,
-    });
-    if (index === 0) {
-        await ollamaConnectionSetting(session, host, (patch) => saveCommandSettings(host, patch));
-    }
-    else if (index === 1) {
-        await apiKeyCommand(OLLAMA_KEY, "Ollama", session, host, "ollama");
-    }
-}
 function chooser(host) {
     if (host.choose === undefined) {
         host.emit({ kind: "notice", text: "that command needs the screen", tone: "warn" });

package/dist/provider-errors.js

@@ -4,21 +4,12 @@ import { providerLabel } from "./provider-label.js";
 import { leadingText } from "./text-boundary.js";
 import { terminalText } from "./ui/terminal-text.js";
 import { providerFailureDetails, } from "./providers/failure.js";
-const CONNECTION_FAILURE = /network error calling|timed out waiting for response headers|response body was idle/i;
 const MAX_MESSAGE_CHARS = 1_000;
 const MAX_REASON_CHARS = 500;
 const HTML = /<!doctype\s|<\/?[a-z][^>]*>/i;
 export function providerFailure(provider, error, labelProvider = false) {
     const details = providerFailureDetails(provider.id, error);
-    let failure;
-    if (provider.id === "ollama" && details.kind === "network" && CONNECTION_FAILURE.test(error.message)) {
-        failure = provider.location?.() === "local"
-            ? "Ollama is not reachable on this computer · start Ollama or choose cloud in /providers"
-            : "Ollama is not reachable · check its connection in /providers";
-    }
-    else {
-        failure = actionableFailure(provider.id, details.kind) ?? rawFailure(error);
-    }
+    let failure = actionableFailure(provider.id, details.kind) ?? rawFailure(error);
     if (details.requestId !== undefined)
         failure += ` · request ${details.requestId}`;
     const label = providerLabel(provider.id);

package/dist/provider-label.js

@@ -1,23 +1,16 @@
 // Stable human-facing names for provider identifiers.
 export function providerLabel(id) {
     switch (id) {
-        case "anthropic": return "Anthropic";
+        case "anthropic": return "Anthropic API";
         case "openai": return "OpenAI API";
-        case "openai-codex": return "ChatGPT";
-        case "ollama": return "Ollama";
+        case "openai-codex": return "OpenAI Account";
+        case "ollama": return "Ollama API";
         default: return id === "" ? "Provider" : `${id[0]?.toUpperCase() ?? ""}${id.slice(1)}`;
     }
 }
 /** Name the actual connection a model request will use. */
 export function providerRouteLabel(provider) {
-    if (provider.auth.kind === "oauth")
-        return `${providerLabel(provider.id)} account`;
     if (provider.id === "openai")
         return "OpenAI API · billed usage";
-    if (provider.id === "anthropic")
-        return "Anthropic API";
-    if (provider.id === "ollama") {
-        return provider.location?.() === "local" ? "Ollama · local" : "Ollama API";
-    }
     return providerLabel(provider.id);
 }

package/dist/providers/anthropic.js

@@ -72,7 +72,6 @@ export const anthropic = {
             throwProviderError(ID, signal, error);
         }
     },
-    location: () => "cloud",
     async send(req) {
         const key = requireKey();
         const body = {

package/dist/providers/index.js

@@ -1,7 +1,7 @@
 import { anthropic } from "./anthropic.js";
 import { openai } from "./openai.js";
 import { openaiCodex } from "./openai-codex.js";
-import { configureOllama, ollama } from "./ollama.js";
+import { ollama } from "./ollama.js";
 export const PROVIDERS = [anthropic, openai, openaiCodex, ollama];
 export function providerNames() {
     return PROVIDERS.map((provider) => provider.id);
@@ -13,7 +13,3 @@ export function selectProvider(id) {
     }
     return found;
 }
-/** Apply provider-specific process state after startup precedence is resolved. */
-export function configureProviders(config) {
-    configureOllama(config.ollamaHost);
-}