teapot-coding-agent 0.29.11 → 0.29.12

package/dist/agent/llm.js

@@ -10,44 +10,82 @@ const clients = new WeakMap();
 /**
  * Reasoning effort for a request body (#47, #150).
  *
- * MEASURED against the live endpoints in use (one probe per provider, `max_tokens:
- * 3` with `reasoning_effort: "low"`):
+ * MEASURED against the live endpoints (one probe each, `max_tokens: 3` with
+ * `reasoning_effort: "low"`):
  *
- *   openrouter          — documented, catalogue advertises the field
- *   commandcode-goat    — 200 OK and the reply carried `reasoning_content`
- *   google              — 400 "Thinking level is not supported for this model"
- *   orcarouter / opencode / experientiallabs — refused before reaching the field
+ *   commandcode-goat   200 OK, reply carried `reasoning_content`   -> accepts
+ *   google             400 "Thinking level is not supported for this model."
+ *   openrouter         documented, catalogue advertises the field
  *
- * So "OpenRouter only" was too narrow (#150: `commandcode-goat` offers no options
- * at all), but "send it everywhere" would break Google, which REJECTS the field
- * with a 400 rather than ignoring it. The gate therefore stays opt-in:
+ * and — the fact that decides the design — what each endpoint PUBLISHES in
+ * `/models`:
  *
- *   1. the configured value must be a level the API documents, AND
- *   2. EITHER the endpoint's catalogue advertises `reasoning_effort` (OpenRouter
- *      and compatible gateways), OR the provider is explicitly marked
- *      `reasoningEffort: true` in the config for an endpoint that accepts the field
- *      but publishes no catalogue capability list (#150).
+ *   openrouter         `supported_parameters: [… "reasoning_effort" …]` per model
+ *   commandcode-goat   only `id`, `name`, `context_length`, `supported_endpoints`
+ *   google             no capability list either
  *
- * Implemented here rather than via model-meta to avoid an import cycle —
- * model-meta already imports providerHeaders from this file.
+ * So for a gateway that publishes nothing there is NO per-model signal to gate on,
+ * and the only honest way to find out whether it accepts the field is to TRY it.
+ * A wrong guess is cheap to recover from: the endpoint answers 400 with a
+ * recognisable message, and `isEffortUnsupported()` + the retry in `chat()` drop
+ * the field for that request. That is better than a config flag the operator has to
+ * know about, and better than hiding the control behind a capability list most
+ * endpoints do not publish.
+ *
+ * Consequences, in order:
+ *   1. a catalogue that explicitly EXCLUDES `reasoning_effort` is respected (no
+ *      point provoking a 400 for a model that tells us up front it will refuse);
+ *   2. a catalogue that INCLUDES it, or publishes no capability list at all, gets
+ *      the field — and self-corrects on refusal;
+ *   3. an invalid or absent level is never sent, whatever the endpoint says.
  */
 export function effortForRequest(cfg, supported = cfg.supportedParameters) {
     const e = cfg.reasoningEffort;
     if (!e || !REASONING_EFFORTS.includes(e))
         return {};
-    // the catalogue is a capability claim from a GATEWAY, so trust it only where the
-    // gateway format is the one that carries it. MEASURED: of the endpoints in use,
-    // only OpenRouter-family ones publish `supported_parameters` at all — google,
-    // commandcode, orcarouter and opencode all return 0 models with the field, so
-    // this cannot silently widen the blast radius.
-    if (supported?.includes("reasoning_effort") && isOpenRouterEndpoint(cfg.baseUrl)) {
-        return { reasoning_effort: e };
-    }
-    // #150: an endpoint that ACCEPTS the field but publishes no capability list needs
-    // the provider to say so explicitly (provider.reasoningEffort: true in config).
-    if (cfg.reasoningEffortOptIn === true)
-        return { reasoning_effort: e };
-    return {};
+    // a catalogue that names the parameter it supports and does NOT list this one is
+    // a definite "no" — only the ones that omit the question are worth a probe
+    if (supported && !supported.includes("reasoning_effort"))
+        return {};
+    // Clamp into the model's own levels when it publishes them (#150). The USER's input
+    // is validated against the four levels we offer, but the CLAMPED result may be a
+    // provider-specific one (`xhigh`, `max`) — deepseek advertises `["max","high","low"]`,
+    // so refusing to send `max` because it is not in our own four would throw away the
+    // model's real top tier.
+    const clamped = clampEffort(e, cfg.supportedEfforts);
+    if (!EFFORT_LADDER.includes(clamped))
+        return {};
+    return { reasoning_effort: clamped };
+}
+/**
+ * Did the endpoint refuse `reasoning_effort` as an unsupported PARAMETER? (#150)
+ *
+ * Google's wording is "Thinking level is not supported for this model."; other
+ * gateways phrase it as an unknown/unsupported parameter or field. Matched
+ * narrowly: a retry that drops the field is only correct when THIS is the
+ * complaint, and misreading an unrelated 400 as one would silently discard the
+ * operator's choice instead of surfacing the real error.
+ */
+export function isEffortUnsupported(err) {
+    const msg = String(err?.message ?? err ?? "");
+    if (!/reasoning_effort|thinking level|effort/i.test(msg))
+        return false;
+    return /not supported|unsupported|unknown (parameter|field)|invalid/i.test(msg);
+}
+/**
+ * Is this model OFFERED a reasoning-effort control? (#150)
+ *
+ * The right panel shows the row when it can do something. A model whose catalogue
+ * says it does not take the parameter hides it; one whose catalogue is silent
+ * still shows it, because the endpoints that publish nothing (measured: commandcode,
+ * google) accept the field for some models and refuse it for others, and a silent
+ * 400 with an automatic retry is a better experience than a control that is missing
+ * where it would have worked.
+ */
+export function effortChoosable(supported) {
+    if (!supported)
+        return true; // no capability list published: worth a try
+    return supported.includes("reasoning_effort");
 }
 function isOpenRouterEndpoint(baseUrl) {
     try {
@@ -80,21 +118,85 @@ export function cacheControlForRequest(cfg) {
 }
 const REASONING_EFFORTS = ["minimal", "low", "medium", "high"];
 /**
+ * Canonical low→high ordering used for clamping, including the levels this harness
+ * does not itself offer (`none`, `xhigh`, `max`) because a provider's own list is
+ * spelled in those terms and the comparison needs the full ladder.
+ *
+ * Same ladder and the same rules as Hermes' `EFFORT_LADDER` / `clamp_effort`, which
+ * is the clearest statement of the problem: a provider that does not have the
+ * requested level should not receive a request it will refuse, and should not be
+ * silently escalated either.
+ */
+const EFFORT_LADDER = ["none", "minimal", "low", "medium", "high", "xhigh", "max"];
+/**
+ * Map a requested level onto the levels a MODEL actually accepts (#150).
+ *
+ * Measured: OpenRouter publishes `reasoning.supported_efforts` per model (198 of 458
+ * models), and the levels are not the four a naive UI would offer — deepseek-v4.1-flash
+ * advertises `["max","high","low"]`, so `minimal` and `medium` do not exist for it and
+ * `max` does. Sending an absent level is a refused turn; offering one is a control that
+ * does nothing.
+ *
+ * Rules, matching Hermes:
+ *   - unknown or empty support → the request passes through (we cannot judge it)
+ *   - already supported → unchanged
+ *   - a level that is not on the ladder at all → unchanged (custom providers use
+ *     bespoke names, and rewriting one would be guesswork)
+ *   - otherwise the nearest WEAKER level, so a clamp never escalates cost; if nothing
+ *     weaker exists, the weakest supported level
+ *   - never to `none`, which would silently switch thinking OFF for a caller who asked
+ *     for it to be on
+ */
+export function clampEffort(requested, supported) {
+    if (!requested || !supported?.length)
+        return requested;
+    const norm = supported.map((s) => String(s).toLowerCase());
+    if (norm.includes(requested))
+        return requested;
+    const reqIdx = EFFORT_LADDER.indexOf(requested);
+    if (reqIdx < 0)
+        return requested; // not a ladder level: not ours to rewrite
+    const candidates = norm.filter((l) => l !== "none" && EFFORT_LADDER.includes(l));
+    if (!candidates.length)
+        return requested;
+    const weaker = candidates.filter((l) => EFFORT_LADDER.indexOf(l) < reqIdx);
+    if (weaker.length) {
+        return weaker.reduce((best, l) => EFFORT_LADDER.indexOf(l) > EFFORT_LADDER.indexOf(best) ? l : best);
+    }
+    return candidates.reduce((best, l) => EFFORT_LADDER.indexOf(l) < EFFORT_LADDER.indexOf(best) ? l : best);
+}
+/**
+ * Per-endpoint request headers. Empty (harmless no-op) for every provider that
+ * does not ask for any.
+ *
  * OpenRouter app attribution (https://openrouter.ai/docs/app-attribution):
  * `HTTP-Referer` is the required identifier that puts teapot's usage on the
  * public rankings/analytics; the title names it; `programming-app` files it
- * under coding tools. Empty (harmless no-op) for every other provider.
+ * under coding tools.
+ *
+ * OpenCode Go (https://opencode.ai/docs/go/#where-can-i-use-it) identifies a
+ * conversation by `x-opencode-session` and returns HTTP 400 without it —
+ * "Request is missing x-opencode-session and cannot be routed efficiently" —
+ * so a turn on that endpoint must name the session it belongs to. The value is
+ * the session directory name, which is stable for the whole conversation:
+ * a compaction is a new request but not a new conversation, so it keeps the id,
+ * while a fork/incarnation switch (`currentSession`) gets its own.
  */
-export function providerHeaders(baseUrl) {
+export function providerHeaders(baseUrl, sessionId) {
     try {
         const host = new URL(baseUrl).host;
-        if (!/(^|\.)openrouter\.ai$/i.test(host))
-            return {};
-        return {
-            "HTTP-Referer": "https://github.com/akku1139/teapot",
-            "X-OpenRouter-Title": "teapot",
-            "X-OpenRouter-Categories": "programming-app",
-        };
+        if (/(^|\.)openrouter\.ai$/i.test(host)) {
+            return {
+                "HTTP-Referer": "https://github.com/akku1139/teapot",
+                "X-OpenRouter-Title": "teapot",
+                "X-OpenRouter-Categories": "programming-app",
+            };
+        }
+        // scoped to this host so the id cannot follow the operator to another
+        // provider, and skipped entirely when there is no session to name
+        if (sessionId && /(^|\.)opencode\.ai$/i.test(host))
+            return { "x-opencode-session": sessionId };
+        return {};
     }
     catch {
         return {}; // unparseable baseUrl — never block a request over metadata
@@ -108,7 +210,7 @@ function client(cfg) {
             apiKey: cfg.apiKey,
             timeout: cfg.timeoutMs ?? 120_000,
             maxRetries: 4, // SDK handles backoff for 429/5xx/network errors
-            defaultHeaders: providerHeaders(cfg.baseUrl),
+            defaultHeaders: providerHeaders(cfg.baseUrl, cfg.sessionId),
         });
         clients.set(cfg, c);
     }
@@ -302,6 +404,11 @@ export async function chat(cfg, messages, tools, signal, onDelta) {
         };
     }
     catch (err) {
+        // #150: retry ONCE without the effort field when the endpoint says it does not
+        // take it, so a level that a particular model refuses never costs a turn
+        if (!signal?.aborted && isEffortUnsupported(err) && effortForRequest(cfg).reasoning_effort) {
+            return chat({ ...cfg, reasoningEffort: "" }, messages, tools, signal);
+        }
         const e = err;
         // #50: our own shape-diagnosis reads as a full sentence but carries no HTTP
         // status (the request SUCCEEDED — that is the whole problem), so the generic
@@ -425,6 +532,12 @@ export async function chatStream(cfg, messages, tools, signal, onDelta) {
         // Everything else — 5xx, an error frame, a mid-stream failure — is the ANSWER,
         // rethrown untouched so overflow recovery can see it.
         const status = err?.status;
+        // #150: the endpoint refused `reasoning_effort` itself. Retry ONCE without it,
+        // so choosing a level never costs a turn — this is what makes the control safe
+        // to offer on an endpoint whose capabilities cannot be known in advance.
+        if (!signal?.aborted && isEffortUnsupported(err) && effortForRequest(cfg).reasoning_effort) {
+            return chatStream({ ...cfg, reasoningEffort: "" }, messages, tools, signal, onDelta);
+        }
         const rejectedByProvider = typeof status === "number" && STREAM_REJECTED_STATUS.has(status);
         const emptyStream = err?.emptyStream === true;
         if (!gotChunk && !signal?.aborted && (rejectedByProvider || emptyStream)) {

package/dist/config-schema.js

@@ -11,15 +11,6 @@ export const ProviderSchema = z.object({
     baseUrl: z.union([z.string().url("baseUrl must be a valid URL"), z.literal("")]).optional(),
     apiKey: z.string().optional(),
     model: z.string().optional(),
-    /**
-     * Does this endpoint accept `reasoning_effort`? (#150)
-     *
-     * Needed for gateways that ACCEPT the field but publish no capability list in
-     * their /models response, so the gateway-style catalogue check cannot see it.
-     * Off by default because some endpoints (Google) reject the field with a 400
-     * rather than ignoring it — an unset field is safer than a wrong one.
-     */
-    reasoningEffort: z.boolean().optional(),
 });
 export const AgentEntrySchema = z.object({
     id: z

package/dist/master.js

@@ -804,9 +804,8 @@ export class Master {
             ...(modelMeta?.supportedParameters
                 ? { supportedParameters: modelMeta.supportedParameters }
                 : {}),
-            // #150: the provider opts in explicitly when its catalogue does not carry
-            // capability metadata, so the gate above cannot see the support
-            ...(prov?.reasoningEffort ? { reasoningEffortOptIn: true } : {}),
+            // #150: the model's own reasoning levels, so the picker offers exactly those
+            ...(modelMeta?.supportedEfforts?.length ? { supportedEfforts: modelMeta.supportedEfforts } : {}),
         });
         // pricing metadata (USD/token) for the runtime cost estimate — best
         // effort: providers without pricing in /models simply show no cost
@@ -1664,11 +1663,9 @@ When this task is done (or truly blocked), call finish() with a summary for @${p
             if (cfgEntry)
                 cfgEntry.reasoningEffort = opts.opts.reasoningEffort || undefined;
         }
-        opts.opts.supportedParameters = meta?.supportedParameters ?? [];
-        // #150: keep the explicit provider opt-in in step with the (possibly new)
-        // provider, so switching to an opted-in gateway enables the dropdown at once
-        const nowProv = this.config.providers?.[effectiveProvider];
-        opts.opts.reasoningEffortOptIn = nowProv?.reasoningEffort === true;
+        // keep `undefined` for "published nothing" — see the note on the option (#150)
+        opts.opts.supportedParameters = meta?.supportedParameters;
+        opts.opts.supportedEfforts = meta?.supportedEfforts;
         if (!llm.model)
             throw new Error("no model resolved (pass model or set one on the provider)");
         if (!llm.baseUrl)

package/dist/model-meta.js

@@ -92,6 +92,16 @@ export async function fetchModelList(baseUrl, apiKey) {
                 supportedParameters: Array.isArray(m.supported_parameters)
                     ? m.supported_parameters.filter((p) => typeof p === "string")
                     : undefined,
+                // per-model reasoning levels when published (OpenRouter): the UI offers
+                // exactly these, and the request is clamped into them — offering a level the
+                // model does not have is a control that does nothing (#150)
+                supportedEfforts: Array.isArray(m.reasoning?.supported_efforts)
+                    ? m.reasoning.supported_efforts.filter((e) => typeof e === "string")
+                    : undefined,
+                ...(typeof m.reasoning?.default_effort === "string"
+                    ? { defaultEffort: m.reasoning.default_effort }
+                    : {}),
+                ...(m.reasoning?.mandatory === true ? { reasoningMandatory: true } : {}),
             }))
                 .filter((m) => m.id);
             cache.set(root, { at: Date.now(), list });

package/dist/server/api.js

@@ -749,9 +749,6 @@ export function buildApp(master) {
                     baseUrl: p.baseUrl ?? "",
                     apiKey: masked ? prev[name]?.apiKey : p.apiKey,
                     ...(p.model ? { model: p.model } : {}),
-                    // #150: the opt-in must survive a config PUT, or saving anything else
-                    // would silently disable the effort dropdown for that provider
-                    ...(p.reasoningEffort ? { reasoningEffort: true } : {}),
                 };
             }
             master.updateConfig({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teapot-coding-agent",
-  "version": "0.29.11",
+  "version": "0.29.12",
   "description": "A lightweight, always-on multi-agent harness for AI coding agents",
   "type": "module",
   "license": "AGPL-3.0-or-later",