clauderipple 0.7.0 → 0.8.0

package/dist/router/src/agents.js

@@ -15,6 +15,7 @@ import path from "node:path";
 import { homeDir } from "./config.js";
 import { declaredBy } from "./routing.js";
 import { adminPort } from "./admin.js";
+import { shortName } from "../../cli/src/hooks/agent-title.js";
 /** Where Claude Code's Agent tool reads its worker definitions. */
 export function defaultAgentDir() {
     return path.join(os.homedir(), ".claude", "agents");
@@ -147,18 +148,33 @@ function capsEffortLevels(provider) {
     return provider.caps?.effortLevels;
 }
 /**
- * The `@effort` suffix a generated file's `model:` carries: `@medium` when the provider or the model
- * offers medium reasoning, otherwise none. An empty `model.effortLevels` disables the provider
- * fallback (config.ts), so it is honoured rather than ignored.
+ * The `@effort` suffix a generated file's `model:` carries: `@high` when the provider or the model
+ * offers any reasoning effort, otherwise none. A ladder without `high` is fine — the request is
+ * clamped to the nearest level the model takes (compat.ts). It used to be `@medium`, which a ladder
+ * from the catalogue such as `low`/`high`/`max` does not hold, and the operator wants workers at
+ * high unless a marker says otherwise (2026-10-02). An empty `model.effortLevels` disables the
+ * provider fallback (config.ts), so it is honoured rather than ignored.
  */
 function effortSuffix(provider, modelId) {
     const modelLevels = provider.models?.find((m) => m.id === modelId)?.effortLevels;
     const levels = modelLevels !== undefined ? modelLevels : capsEffortLevels(provider);
-    return levels?.includes("medium") ? "@medium" : "";
+    return levels && levels.length > 0 ? "@high" : "";
 }
-function fileContent(name, modelId, provider, suffix, limitTools, imagePort) {
+/**
+ * What the parent is asked to start the Agent `description` with. The Desktop task panel names only
+ * Claude models, and rebuilt from the transcript it shows the description as the parent wrote it,
+ * so the agent-title hook's live correction is lost (app web bundle, 2026-09-30); a prefix the
+ * parent writes itself survives. Same form as the hook's: the display name's last word, `·level`.
+ */
+function titlePrefix(title, suffix) {
+    return suffix
+        ? `Start the Agent description with "${title}·<level> · " (the marker's level, else ${suffix.slice(1)}) so the app's task list shows the model.`
+        : `Start the Agent description with "${title} · " so the app's task list shows the model.`;
+}
+function fileContent(name, modelId, title, provider, suffix, limitTools, imagePort) {
     const description = `${modelId} via ${provider}. Generated by ClaudeRipple from config.json — edits are overwritten; ` +
-        `to customise, copy to another name. Set effort with [[ripple: ${name}@<level>]] on the first line.`;
+        `to customise, copy to another name. Set effort with [[ripple: ${name}@<level>]] on the first line. ` +
+        titlePrefix(title, suffix);
     const tools = limitTools ? `tools: ${TOOLS.join(", ")}\n` : "";
     const body = imagePort === null ? BODY : `${BODY}\n${imageLine(imagePort)}`;
     return `---\nname: ${name}\ndescription: ${description}\nmodel: ${modelId}${suffix}\n${tools}---\n${body}\n`;
@@ -220,7 +236,7 @@ export function syncAgentFiles(cfg, dir, log, opts = {}) {
                 log?.warn(`agent files: "${model.id}" and "${clash.modelId}" both map to "${name}"; skipping "${model.id}"`);
                 continue;
             }
-            targets.set(name, { modelId: model.id, provider: providerName, suffix: effortSuffix(provider, model.id) });
+            targets.set(name, { modelId: model.id, title: shortName(model.name ?? model.id), provider: providerName, suffix: effortSuffix(provider, model.id) });
         }
     }
     const imagePort = Object.values(cfg.providers).some((p) => p.type === "chatgpt") ? adminPort(cfg) : null;
@@ -231,7 +247,7 @@ export function syncAgentFiles(cfg, dir, log, opts = {}) {
             continue;
         }
         const file = path.join(dir, `${name}.md`);
-        const content = fileContent(name, t.modelId, t.provider, t.suffix, cfg.cli.limitWorkerTools === true, imagePort);
+        const content = fileContent(name, t.modelId, t.title, t.provider, t.suffix, cfg.cli.limitWorkerTools === true, imagePort);
         const existing = scanned.get(`${name}.md`);
         if (existing) {
             let current = null;

package/dist/router/src/catalog.js

@@ -0,0 +1,80 @@
+// What OpenCode itself knows about each model, read from the catalogue its own client is built on.
+//
+// OpenCode's docs publish an endpoint per model and no effort ladder at all, and its `/models`
+// reports ids alone, so `capabilities.ts` established both by sending requests: about ten per
+// model, one after another. With upstream latency swinging from 0.5s to 25s on identical one-token
+// requests (glm-5.3-flash, measured 2026-10-02), three models took 2m33s.
+//
+// models.dev (https://models.dev/api.json, maintained by the team behind OpenCode) states both for
+// every model OpenCode serves: `reasoning_options` lists the effort values, and `provider.npm` names
+// the SDK the OpenCode client speaks to it with. It is also more accurate than asking: a 200 only
+// says a level was not refused, and glm-5.3-flash answered 200 to seven levels where the catalogue
+// lists `low`/`high`/`max` — the rest were accepted and, as far as anything can tell, ignored. And
+// muse-spark-1.3-contributor names `max` in its own error message, refuses it when sent, and the
+// catalogue never lists it.
+//
+// The catalogue is community-maintained and a new model can arrive a day late; a model it does not
+// list is measured exactly as before.
+/** Which models.dev provider describes the endpoint a preset points at. Only presets whose base URL
+ * is the one the catalogue entry names (`api`) are listed, so the catalogue never describes a
+ * different endpoint from the one the request goes to. */
+const CATALOG_PROVIDER = {
+    "opencode-go": "opencode-go", // api https://opencode.ai/zen/go/v1
+    "opencode-zen": "opencode", // api https://opencode.ai/zen/v1
+};
+export const CATALOG_URL = "https://models.dev/api.json";
+const CATALOG_TIMEOUT_MS = 10_000;
+/** The catalogue changes when a model is added, not minute to minute. */
+const CATALOG_TTL_MS = 60 * 60 * 1000;
+/** The SDK packages that map onto a wire this router sends. Any other (`@ai-sdk/google`, …) says
+ * nothing we can use, and leaves the wire to measurement. */
+function wireOf(npm) {
+    if (npm === "@ai-sdk/openai-compatible")
+        return "chat";
+    if (npm === "@ai-sdk/openai")
+        return "responses";
+    if (npm === "@ai-sdk/anthropic")
+        return "anthropic";
+    return undefined;
+}
+/** One model as the catalogue describes it, or nothing when the preset has no catalogue or the model is not in it. */
+export function catalogEntry(catalog, preset, modelId) {
+    const providerId = preset ? CATALOG_PROVIDER[preset] : undefined;
+    if (!providerId || !catalog || typeof catalog !== "object")
+        return undefined;
+    const provider = catalog[providerId];
+    const model = provider?.models?.[modelId];
+    if (!model || typeof model !== "object")
+        return undefined;
+    // A model with no SDK of its own is spoken to with the provider's.
+    const wire = wireOf(model.provider?.npm ?? provider?.npm);
+    let effortLevels;
+    if (Array.isArray(model.reasoning_options)) {
+        const effort = model.reasoning_options.find((option) => option?.type === "effort" && Array.isArray(option.values));
+        effortLevels = effort ? effort.values.filter((value) => typeof value === "string") : [];
+    }
+    else if (model.reasoning === false) {
+        effortLevels = [];
+    }
+    return { ...(wire ? { wire } : {}), ...(effortLevels ? { effortLevels } : {}) };
+}
+let cached;
+/**
+ * The catalogue, fetched at most once an hour. Undefined when it cannot be had: the caller measures
+ * instead, so a catalogue outage costs time and never a wrong answer.
+ */
+export async function loadModelCatalog(fetchImpl = fetch) {
+    if (cached && Date.now() - cached.at < CATALOG_TTL_MS)
+        return cached.catalog;
+    try {
+        const response = await fetchImpl(CATALOG_URL, { signal: AbortSignal.timeout(CATALOG_TIMEOUT_MS) });
+        if (!response.ok)
+            return cached?.catalog;
+        const catalog = await response.json();
+        cached = { at: Date.now(), catalog };
+        return catalog;
+    }
+    catch {
+        return cached?.catalog;
+    }
+}

package/dist/router/src/compat.js

@@ -1,6 +1,7 @@
 // Sanitise Claude Code's Anthropic-only request extensions for providers that expose
 // an Anthropic-shaped Messages endpoint without implementing Anthropic's full feature set.
 // Pure: callers receive a new object and an audit list; the input is never mutated.
+import { droppedServerToolNote } from "./providers/chatgpt/translate.js";
 export const EFFORT_LEVELS = ["low", "medium", "high", "xhigh", "max", "ultra"];
 export const STRICT_COMPAT_CAPS = {
     effortLevels: [],
@@ -28,6 +29,10 @@ export function forwardCompatibleHeader(name, caps) {
 /**
  * Return the nearest supported canonical effort level. Unknown requested levels fall back
  * to the provider's lowest listed level, which is safer than forwarding a rejected value.
+ *
+ * Equally near on both sides goes up: `medium` on a `low`/`high`/`max` ladder — the shape most
+ * OpenCode Go models list (models.dev, 2026-10-02) — is `high`. Asking for medium means "more
+ * than low", and rounding it down cost a worker its reasoning for the sake of a tie.
  */
 export function clampEffort(effort, supported) {
     if (supported.includes(effort))
@@ -38,7 +43,11 @@ export function clampEffort(effort, supported) {
         .filter((entry) => entry.index >= 0);
     if (requested < 0 || canonical.length === 0)
         return supported[0] ?? effort;
-    return canonical.reduce((best, candidate) => Math.abs(candidate.index - requested) < Math.abs(best.index - requested) ? candidate : best).value;
+    return canonical.reduce((best, candidate) => {
+        const distance = Math.abs(candidate.index - requested);
+        const bestDistance = Math.abs(best.index - requested);
+        return distance < bestDistance || (distance === bestDistance && candidate.index > best.index) ? candidate : best;
+    }).value;
 }
 function stripCacheControl(value) {
     if (Array.isArray(value)) {
@@ -77,6 +86,15 @@ function stripCacheControl(value) {
 // translated providers drop it for the same reason (`systemText` in providers/chatgpt/translate.ts,
 // measured 2026-09-13), and it means nothing to a provider that is not Anthropic.
 const BILLING_BLOCK = /^x-anthropic-billing-header:/;
+function appendSystemText(system, text) {
+    if (system === undefined || system === null || system === "")
+        return text;
+    if (typeof system === "string")
+        return `${system}\n\n${text}`;
+    if (Array.isArray(system))
+        return [...system, { type: "text", text }];
+    return system;
+}
 function stripBillingHeader(system) {
     if (typeof system === "string") {
         const value = system.replace(/^x-anthropic-billing-header:[^\n]*\n*/, "");
@@ -183,6 +201,14 @@ export function sanitizeForCompatible(json, caps) {
             delete out.tool_choice;
             changes.push("tool_choice");
         }
+        // The instruction text for a dropped tool stays in the prompt unless withdrawn (see the note's
+        // own comment). Appended after the caller's blocks, without cache_control, so the prefix up to
+        // Claude Code's breakpoints is untouched.
+        const note = droppedServerToolNote(droppedNames);
+        if (note) {
+            out.system = appendSystemText(out.system, note);
+            changes.push("server_tool_note");
+        }
     }
     if ("system" in out) {
         const next = stripBillingHeader(out.system);

package/dist/router/src/config.js

@@ -239,6 +239,22 @@ function foldSplitProviders(c) {
 }
 export function validate(c) {
     const errors = [];
+    if (c.autoModeClassifier !== undefined) {
+        const target = c.autoModeClassifier;
+        if (!target || typeof target !== "object")
+            errors.push("autoModeClassifier must be an object");
+        else {
+            const provider = c.providers[target.provider];
+            if (!provider)
+                errors.push("autoModeClassifier: unknown provider");
+            else if (provider.type === "anthropic" && !provider.accountPool)
+                errors.push("autoModeClassifier: provider is ingress-only");
+            if (typeof target.model !== "string" || !target.model.trim())
+                errors.push("autoModeClassifier: missing model");
+            if (target.effort !== undefined && typeof target.effort !== "string")
+                errors.push("autoModeClassifier: effort must be a string");
+        }
+    }
     for (const [alias, r] of Object.entries(c.routes)) {
         if (!c.providers[r.provider])
             errors.push(`route ${alias}: unknown provider "${r.provider}"`);
@@ -360,6 +376,21 @@ export function validate(c) {
                 errors.push(`provider ${name}: caps must contain effortLevels?: string[], reasoning?: "effort"|"none"`);
             }
         }
+        else if (p.type === "google") {
+            if (p.auth !== "api-key" && p.auth !== "antigravity")
+                errors.push(`provider ${name}: auth must be "api-key" or "antigravity"`);
+            // The api-key is required, but a key may also come from the environment. The router, not the
+            // GUI save, is where that is settled — so this only refuses a key of the wrong type.
+            if (p.apiKey !== undefined && typeof p.apiKey !== "string")
+                errors.push(`provider ${name}: apiKey must be a string`);
+            if (p.url !== undefined && !/^https?:\/\//.test(p.url))
+                errors.push(`provider ${name}: url must start with http:// or https://`);
+            if (p.defaultEffort !== undefined && typeof p.defaultEffort !== "string")
+                errors.push(`provider ${name}: defaultEffort must be a string`);
+            if (p.models !== undefined && !validModels(p.models)) {
+                errors.push(`provider ${name}: ${MODELS_SHAPE}`);
+            }
+        }
         else if (p.type === "anthropic") {
             if (p.auth !== "api-key" && p.auth !== "claude-code")
                 errors.push(`provider ${name}: auth must be "api-key" or "claude-code"`);

package/dist/router/src/index.js

@@ -6,7 +6,7 @@
 // Exit codes: 0 clean, 2 bad config/certs, 75 upstream unreachable (supervisor should restart).
 import fs from "node:fs";
 import path from "node:path";
-import { codexEnabled, writeCodexCatalog } from "../../cli/src/codex.js";
+import { codexEnabled, followCodexCache, writeCodexCatalog } from "../../cli/src/codex.js";
 import { ingressModels } from "./ingress/models.js";
 import { ConfigStore, configPath, homeDir, terminateHosts } from "./config.js";
 import { defaultAgentDir, syncAgentFiles } from "./agents.js";
@@ -15,6 +15,7 @@ import { Logger } from "./log.js";
 import { UpstreamHealth, EXIT_UPSTREAM_UNREACHABLE } from "./health.js";
 import { Proxy } from "./proxy.js";
 import { startAdmin } from "./admin.js";
+import { loadModelCatalog } from "./catalog.js";
 import { RequestLog } from "./requestlog.js";
 import { OpenAiIngress } from "./ingress/server.js";
 import { ObservedClaudeCodeAuth } from "./providers/anthropic-observed.js";
@@ -123,6 +124,9 @@ setInterval(() => {
     const oi = ingress.stats;
     log.info(`stats proxy=${s.started}/${s.completed}/${s.failed} inFlight=${s.inFlight} ingress=${oi.started}/${oi.completed}/${oi.failed} inFlight=${oi.inFlight} consecutiveUpstreamFailures=${health.consecutiveFailures}`);
 }, statsEvery).unref();
+// The config callback above rewrites the Codex catalog when *our* models change; this covers
+// Codex's side (a new OpenAI model arriving in its cache).
+followCodexCache(() => ingressModels(store.get()), undefined, undefined, (e) => log.warn(`codex catalog: ${e.message}`));
 proxy
     .listen()
     .then(async () => {
@@ -150,11 +154,18 @@ proxy
             accounts: () => proxy.chatgptAccounts(),
             clearCooldown: (id) => proxy.chatgptClearCooldown(id),
         }),
+        google: () => ({
+            accounts: () => proxy.googleAccounts(),
+            models: (name) => proxy.googleFetchModels(name),
+            clearCooldown: (id) => proxy.googleClearCooldown(id),
+            recheckVerification: (id) => proxy.googleRecheckVerification(id),
+        }),
         credentials: () => proxy.credentialHealth(),
         picker: () => ({ enabled: !!store.get().picker?.enabled, hosts: terminateHosts(store.get()).slice(1), last: proxy.lastPickerInjection }),
         observedClaudeCodeAuth,
         claudeUsage: () => proxy.claudeUsage.snapshot(),
         image: (req, signal) => proxy.generateImage(req, signal),
+        modelCatalog: () => loadModelCatalog(),
         shutdown: () => beginDrain("shutdown requested"),
     });
     log.info(`clauderipple admin GUI on http://127.0.0.1:${admin.port}/`);

package/dist/router/src/ingress/server.js

@@ -332,8 +332,9 @@ export class OpenAiIngress {
             // is an OpenAI wire, which the refusal below would otherwise turn away on the provider's type
             // alone. One subscription is one provider, so the model decides.
             const provider = providerFor(configured, route.model);
-            if (provider.type === "chatgpt" || provider.type === "openai-compatible") {
-                const bytes = sendJson(res, 400, openAiError(`${provider.type === "chatgpt" ? "ChatGPT" : "OpenAI-compatible"} provider is not available through OpenAI ingress`, "invalid_request_error", "unsupported_provider"));
+            if (provider.type === "chatgpt" || provider.type === "openai-compatible" || provider.type === "google") {
+                const label = provider.type === "chatgpt" ? "ChatGPT" : provider.type === "google" ? "Google" : "OpenAI-compatible";
+                const bytes = sendJson(res, 400, openAiError(`${label} provider is not available through OpenAI ingress`, "invalid_request_error", "unsupported_provider"));
                 finish(400, bytes, { note: `model ${requested} -> ${provider.type} provider unsupported` });
                 return;
             }

package/dist/router/src/picker.js

@@ -9,6 +9,7 @@
 // entry as a template and override the identifying fields. Surfaces are matched by id
 // heuristically (anything that is not the claude.ai chat surface); the ids we saw are
 // logged once so the heuristic can be tightened.
+import { clampEffort } from "./compat.js";
 export const BOOTSTRAP_PATHS = ["/edge-api/bootstrap", "/api/bootstrap"];
 export function isBootstrapPath(path) {
     return BOOTSTRAP_PATHS.some((p) => path === p || path.startsWith(p + "/") || path.startsWith(p + "?"));
@@ -23,8 +24,35 @@ function isClaudeEntry(m) {
 function pickTemplate(models) {
     return models.find((m) => isClaudeEntry(m) && !m.disabled && m.section !== "deprecated" && m.section !== "legacy") ?? models.find(isClaudeEntry) ?? null;
 }
-/** Mutates `json` in place; returns what was done for logging. */
-export function injectPickerModels(json, extra, contextWindow) {
+/**
+ * The effort menu for one routed model: the template's own options, narrowed to the levels the
+ * model takes.
+ *
+ * The app builds the menu per entry from `thinking.effort_options` (`effortOptionsFor: e =>
+ * …effort_options ?? []` in the Code tab bundle, read 2026-10-02), so a cloned Claude entry offered
+ * Claude's whole ladder for a model that takes three of it. The template's option objects are kept
+ * as they are — they carry the app's localised labels, and an id the app does not know (its list is
+ * low/medium/high/xhigh/max) is not invented here. `recommended` moves to high, or the level nearest
+ * it: when the selected level is not on the list, the app switches to the recommended one (`uw`).
+ * A model that takes none of them gets no `thinking` at all, which the app reads as "no effort".
+ */
+function narrowThinking(entry, levels) {
+    const thinking = entry.thinking;
+    if (!thinking || !Array.isArray(thinking.effort_options))
+        return;
+    const kept = thinking.effort_options.filter((option) => typeof option.id === "string" && levels.includes(option.id));
+    if (kept.length === 0) {
+        delete entry.thinking;
+        return;
+    }
+    const preferred = clampEffort("high", kept.map((option) => option.id));
+    entry.thinking = { ...thinking, effort_options: kept.map(({ recommended: _recommended, ...option }) => (option.id === preferred ? { ...option, recommended: true } : option)) };
+}
+/**
+ * Mutates `json` in place; returns what was done for logging. `effortFor` names the levels a model
+ * takes (by its id without an `@effort` suffix); undefined leaves the template's menu as it is.
+ */
+export function injectPickerModels(json, extra, contextWindow, effortFor) {
     const result = { injected: 0, surfaces: [] };
     const msc = json.model_selector_config;
     if (!Array.isArray(msc) || extra.length === 0)
@@ -60,6 +88,9 @@ export function injectPickerModels(json, extra, contextWindow) {
             for (const k of ["disabled", "disabled_reason", "notice", "selection_notice", "badge", "badge_tooltip", "tooltip", "minimum_tier", "is_default"])
                 delete entry[k];
             entry.section = "main";
+            const levels = effortFor?.(e.model.split("@")[0]);
+            if (levels)
+                narrowThinking(entry, levels);
             surface.models.push(entry);
             result.injected++;
         }

package/dist/router/src/presets.js

@@ -207,7 +207,8 @@ export const PRESETS = [
         // assumption rather than a measurement, and it was wrong: deepseek-v4.1-flash accepts all eight
         // levels including max, and mimo-v2.6-pro accepts none/low/medium/high (measured 2026-09-22).
         // It could not correct itself either — an empty ladder is never measured. Left unstated, each
-        // model's ladder is established on the first save.
+        // model's ladder is established on the first save: from models.dev when it lists the model
+        // (catalog.ts — OpenCode's own catalogue, which does state ladders), by request otherwise.
         fallbackModels: [
             // Responses — the preset's own wire, so these carry no override.
             { id: "muse-spark-1.3-contributor", name: "Muse Spark 1.3 (Contributor)" },

package/dist/router/src/providers/chatgpt/index.js

@@ -15,6 +15,8 @@ import path from "node:path";
 import { homeDir } from "../../config.js";
 export const DEFAULT_BASE = "https://chatgpt.com/backend-api";
 const PING_MS = 15_000;
+/** How long a stream may hold its headers waiting for upstream's first item (see `handle`). Tests shorten it. */
+export const streamHold = { ms: 5_000 };
 /** Active quota lookup. Measured 2026-09-20: GET {base}/wham/usage → 200 JSON. The binary also
  * carries `/api/codex/usage`, but that path answers 403 here; `wham` is the one that works. */
 const USAGE_PATH = "/wham/usage";
@@ -1018,12 +1020,41 @@ export class ChatGptAdapter {
         const parser = new SseParser();
         let bytes = 0;
         let ping = null;
-        if (wantStream) {
+        // Keep early rejection as an HTTP error until an actual content block arrives.
+        // A 200 followed by an error loses the status Claude uses for overflow recovery.
+        const pendingEvents = [];
+        const openStream = () => {
             res.writeHead(200, { "content-type": "text/event-stream", "cache-control": "no-cache", connection: "keep-alive" });
-            for (const ev of mapper.start())
+        };
+        const sendEvents = (events) => {
+            if (!wantStream)
+                return;
+            pendingEvents.push(...events);
+            if (!res.headersSent) {
+                if (mapper.failure?.type === "invalid_request_error")
+                    return;
+                if (!pendingEvents.some((e) => e.event !== "message_start"))
+                    return;
+                openStream();
+            }
+            for (const ev of pendingEvents.splice(0))
                 bytes += write(res, formatSse(ev));
+        };
+        // The hold waits for upstream's first item, which normally follows the request within a second
+        // — and an overflow rejection comes before it. Should it not come, the client must still hear
+        // something: past this deadline the stream opens with message_start and the pings keep it alive,
+        // as they did before the hold.
+        let holdDeadline = null;
+        if (wantStream) {
+            holdDeadline = setTimeout(() => {
+                if (res.headersSent || res.writableEnded || mapper.failure)
+                    return;
+                openStream();
+                for (const ev of [...pendingEvents.splice(0), ...mapper.start()])
+                    bytes += write(res, formatSse(ev));
+            }, streamHold.ms);
             ping = setInterval(() => {
-                if (!res.writableEnded)
+                if (res.headersSent && !res.writableEnded)
                     bytes += write(res, formatSse({ event: "ping", data: { type: "ping" } }));
             }, PING_MS);
         }
@@ -1039,9 +1070,7 @@ export class ChatGptAdapter {
                     if (mapper.rateLimits && mapper.rateLimits !== this.rateLimitsByAccount.get(credential.ownerId))
                         this.noteRateLimits(credential, mapper.rateLimits);
                     this.rememberInput(cacheKey, mapper.usage);
-                    if (wantStream)
-                        for (const o of outEvents)
-                            bytes += write(res, formatSse(o));
+                    sendEvents(outEvents);
                     if (mapper.isFinished)
                         break;
                 }
@@ -1055,22 +1084,20 @@ export class ChatGptAdapter {
                 const tail = parser.sawDone
                     ? mapper.finish()
                     : mapper.fail(`${model}: upstream stream ended before the response completed`, "server_is_overloaded");
-                if (wantStream)
-                    for (const o of tail)
-                        bytes += write(res, formatSse(o));
+                sendEvents(tail);
             }
         }
         catch (e) {
             if (!ac.signal.aborted) {
                 const tail = mapper.fail(`stream interrupted: ${e.message}`, "server_is_overloaded");
-                if (wantStream)
-                    for (const o of tail)
-                        bytes += write(res, formatSse(o));
+                sendEvents(tail);
             }
         }
         finally {
             if (ping)
                 clearInterval(ping);
+            if (holdDeadline)
+                clearTimeout(holdDeadline);
             res.off("close", onClose);
             try {
                 await reader.cancel();
@@ -1080,8 +1107,8 @@ export class ChatGptAdapter {
             }
         }
         const failure = mapper.failure;
-        const failedStatus = failure?.type === "overloaded_error" ? 529 : failure?.type === "rate_limit_error" ? 429 : 502;
-        if (!wantStream) {
+        const failedStatus = failure?.type === "invalid_request_error" ? 400 : failure?.type === "overloaded_error" ? 529 : failure?.type === "rate_limit_error" ? 429 : 502;
+        if (!wantStream || (failure && !res.headersSent)) {
             // A failed turn is an error here too, not a 200 carrying whatever arrived before it failed.
             const msg = failure ? anthropicError(failedStatus, failure.type, failure.message).body : JSON.stringify(mapper.message());
             res.writeHead(failure ? failedStatus : 200, { "content-type": "application/json", "content-length": String(Buffer.byteLength(msg)) }).end(msg);
@@ -1097,7 +1124,7 @@ export class ChatGptAdapter {
             bytes,
             note: failure
                 ? `${wantStream ? "mid-stream " : ""}${failure.type}: ${failure.message} (in=${u.input_tokens} cached=${u.cache_read_input_tokens} out=${u.output_tokens})`
-                : `in=${u.input_tokens} cached=${u.cache_read_input_tokens} out=${u.output_tokens} stop=${mapper.stopReason}`,
+                : `in=${u.input_tokens} cached=${u.cache_read_input_tokens} out=${u.output_tokens} stop=${mapper.stopReason}${upstreamReq.service_tier ? " fast" : ""}`,
             usage: {
                 input: u.input_tokens,
                 cached: u.cache_read_input_tokens,

package/dist/router/src/providers/chatgpt/translate.js

@@ -161,10 +161,11 @@ export function toolNameForResponses(name) {
 // worst failure shape there is. `compat.ts` has dropped them on the anthropic-compatible path from
 // the start; the rule belongs here too, and is the same rule, not a second one.
 //
-// These do not arrive today. Claude Code runs its web search as a separate side request on a fixed
-// small model — measured 2026-09-17: an Opus session and a DeepSeek-routed session both sent it to
-// `claude-haiku-4-5`, which passes through to Anthropic and never reaches an adapter. Which model
-// that is, is a server-side flag we do not own, so this guards the day it changes.
+// `web_search` does not arrive today. Claude Code runs its web search as a separate side request on a
+// fixed small model — measured 2026-09-17: an Opus session and a DeepSeek-routed session both sent it
+// to `claude-haiku-4-5`, which passes through to Anthropic and never reaches an adapter. Which model
+// that is, is a server-side flag we do not own, so this guards the day it changes. The `advisor`
+// server tool does arrive: see `droppedServerToolNote`.
 export function isServerTool(tool) {
     const type = tool.type;
     return type !== undefined && type !== "custom";
@@ -177,6 +178,26 @@ export function serverToolNames(tools) {
             names.add(t.name);
     return names;
 }
+// Dropping the declaration is half of it (issue #47). Claude Code also tells the model, in text, how
+// to use the tool: the advisor comes with an `isMeta` user message ("# Advisor Tool / You have access
+// to an `advisor` tool…") on every subagent, whatever its `tools:` list says (CLI 2.1.286, measured
+// 2026-10-04: `dropped server tools for gpt-6-astra: advisor` on every worker request). A routed
+// worker reads the instruction, finds no such tool, and says so in each report. The CLI withdraws its
+// own instruction with one line when it removes the tool ("The advisor tool is no longer available;
+// disregard the earlier advisor instructions."); a line does the same here, without matching wording
+// that changes from release to release. Sorted, so one set always yields the same bytes and the
+// cached prefix does not move.
+/** One line withdrawing the instructions for the server tools a request had to drop; "" when none. */
+export function droppedServerToolNote(dropped) {
+    if (dropped.size === 0)
+        return "";
+    const names = [...dropped].sort().map((n) => `\`${n}\``).join(", ");
+    return `Not available in this session: ${names}. Anthropic runs these tools on its own servers, so this model cannot call them. Disregard any instruction to use them and carry on without them; there is no need to mention that they are missing.`;
+}
+/** The caller's system text with that line after it, so every translator places it the same way. */
+export function systemWithDroppedToolNote(req) {
+    return [systemText(req.system), droppedServerToolNote(serverToolNames(req.tools))].filter(Boolean).join("\n\n");
+}
 /**
  * Mangled name → original, for the tools declared in this request. The model echoes the name it was
  * given and Claude Code matches `tool_use.name` against its own tool list, so the response path has
@@ -199,7 +220,7 @@ export function toResponsesRequest(req, opts) {
     // Constant per (model, effort): changing effort mid-session costs one cache miss, which is acceptable.
     if (opts.identity)
         parts.push(identityLine(opts.model, opts.effort));
-    const sys = systemText(req.system);
+    const sys = systemWithDroppedToolNote(req);
     if (sys)
         parts.push(sys);
     if (opts.instructionsAppend)
@@ -308,6 +329,10 @@ export function toResponsesRequest(req, opts) {
     }
     if (tool_choice)
         out.tool_choice = tool_choice;
+    // Claude Code's `/fast` arrives as `speed: "fast"` (Anthropic fast mode). The ChatGPT backend's
+    // equivalent is the Codex CLI's Fast mode, which bills the plan at a higher rate (Codex docs, Speed).
+    if (req.speed === "fast")
+        out.service_tier = "priority";
     return out;
 }
 /** Rough token estimate for /v1/messages/count_tokens when the model is not Anthropic's. */
@@ -506,7 +531,10 @@ export class StreamMapper {
         if (this.finished)
             return [];
         this.finished = true;
-        const type = code === "server_is_overloaded" ? "overloaded_error" : code === "rate_limit_exceeded" || code === "usage_limit_reached" ? "rate_limit_error" : "api_error";
+        const contextOverflow = code === "context_length_exceeded" || /input exceeds the context window/i.test(message);
+        const type = contextOverflow ? "invalid_request_error" : code === "server_is_overloaded" ? "overloaded_error" : code === "rate_limit_exceeded" || code === "usage_limit_reached" ? "rate_limit_error" : "api_error";
+        if (contextOverflow)
+            message = `prompt is too long: ${message}`;
         this.failure = { type, message };
         return [...this.start(), ...this.closeBlock(), { event: "error", data: { type: "error", error: { type, message } } }];
     }