teapot-coding-agent 0.29.10 → 0.29.11

package/dist/agent/agent.js

@@ -308,6 +308,7 @@ export class Agent {
             // effort field is then never sent, which is the safe default
             reasoningEffort: "",
             supportedParameters: [],
+            reasoningEffortOptIn: false,
             maxConsecutiveToolErrors: 5,
             maxTurnsPerRound: 200,
             maxAuditRejects: 3, // #128: bound the reject loop
@@ -1262,9 +1263,10 @@ export class Agent {
             stats: { ...this.stats, costUsd: this.modelPricing ? this.stats.costUsd : undefined },
             model: this.opts.llm.model,
             provider: this.opts.provider,
-            // #47: the effort in force, and whether this model can take one at all
+            // #47/#150: the effort in force, and whether this model can take one at all
             ...(this.opts.reasoningEffort ? { reasoningEffort: this.opts.reasoningEffort } : {}),
-            effortSupported: (this.opts.supportedParameters ?? []).includes("reasoning_effort"),
+            effortSupported: (this.opts.supportedParameters ?? []).includes("reasoning_effort") ||
+                this.opts.reasoningEffortOptIn === true,
             sessionDir: this.opts.sessionDir,
             ctx: {
                 usedTokens: this.lastUsage?.input ?? this.estimateTokens(),

package/dist/agent/llm.js

@@ -8,13 +8,25 @@
 import OpenAI from "openai";
 const clients = new WeakMap();
 /**
- * Reasoning effort for a request body (#47).
+ * Reasoning effort for a request body (#47, #150).
  *
- * Kept local and deliberately conservative: the setting is only honoured when
- * the endpoint is OpenRouter, the value is one OpenRouter documents, and the
- * catalogue says this model advertises `reasoning_effort`. Support is far from
- * universal (verified against the live /models endpoint: 196 of 462 models),
- * so an unsent field is much safer than a wrong one.
+ * MEASURED against the live endpoints in use (one probe per provider, `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
+ *
+ * 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:
+ *
+ *   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).
  *
  * Implemented here rather than via model-meta to avoid an import cycle —
  * model-meta already imports providerHeaders from this file.
@@ -23,11 +35,19 @@ export function effortForRequest(cfg, supported = cfg.supportedParameters) {
     const e = cfg.reasoningEffort;
     if (!e || !REASONING_EFFORTS.includes(e))
         return {};
-    if (!isOpenRouterEndpoint(cfg.baseUrl))
-        return {};
-    if (!supported?.includes("reasoning_effort"))
-        return {};
-    return { reasoning_effort: e };
+    // 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 {};
 }
 function isOpenRouterEndpoint(baseUrl) {
     try {

package/dist/config-schema.js

@@ -11,6 +11,15 @@ 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,6 +804,9 @@ 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 } : {}),
         });
         // pricing metadata (USD/token) for the runtime cost estimate — best
         // effort: providers without pricing in /models simply show no cost
@@ -1662,6 +1665,10 @@ When this task is done (or truly blocked), call finish() with a summary for @${p
                 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;
         if (!llm.model)
             throw new Error("no model resolved (pass model or set one on the provider)");
         if (!llm.baseUrl)

package/dist/server/api.js

@@ -749,6 +749,9 @@ 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.10",
+  "version": "0.29.11",
   "description": "A lightweight, always-on multi-agent harness for AI coding agents",
   "type": "module",
   "license": "AGPL-3.0-or-later",