teapot-coding-agent 0.29.9 → 0.29.11

package/dist/agent/agent.js

@@ -74,6 +74,43 @@ export const PROGRESS_REQUEST =
  * meta tools instead. The cache rationale itself stays HERE in a comment —
  * the model does not need our cost-engineering notes every turn.
  */
+/**
+ * Recent context kept VERBATIM through a compaction, in tokens.
+ *
+ * Pi defaults `keepRecentTokens` to 20000 and opencode to `keep: 15000` for the
+ * same reason: the newest exchanges are what the model needs to continue
+ * accurately, and a verbatim copy beats a summary of them.
+ */
+const KEEP_RECENT_TOKENS = 15_000;
+/**
+ * The summarize call is skipped when the summarizable prefix is a small share of
+ * the budget, because the call cannot reuse any prefix cache (its system prompt is
+ * its instructions) and so re-bills the whole history uncached. Below this share,
+ * dropping the prefix outright reclaims the budget for free and the model can
+ * recover the details by re-reading the goal or the files.
+ *
+ * A SHARE rather than an absolute token count: what counts as "a lot to lose"
+ * scales with the window a session is configured for. An absolute constant
+ * calibrated for the 96k default would disable summarization entirely for a
+ * session with a small budget (measured: a 200-token budget with a 654-token
+ * history is over every bar, yet its prefix is a few hundred tokens).
+ *
+ * Manual compaction and overflow recovery bypass this — those are not cost
+ * decisions.
+ */
+const SUMMARIZE_MIN_SHARE = 0.02;
+/** the absolute floor for the bar above (see the note where it is applied) */
+const SUMMARIZE_MIN_TOKENS = 2_000;
+/**
+ * How much of the budget to KEEP on each successive overflow recovery.
+ *
+ * An overflow means the estimate was too low, so a single fixed cut can still
+ * leave the request too large — and the old code turned that second failure into a
+ * hard error. opencode uses the same shape (`SHRINK_STEPS [0.7, 0.5, 0.35]`): each
+ * retry keeps less, so the request shrinks even when the first attempt did not
+ * shrink it enough. The last entry repeats for any further attempt.
+ */
+const OVERFLOW_SHRINK_STEPS = [0.5, 0.35, 0.2];
 const SYSTEM_TEMPLATE = `You are a coding agent working autonomously inside a workspace.
 
 Most session state is not injected into prompts — fetch it with tools instead:
@@ -271,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
@@ -334,6 +372,17 @@ export class Agent {
     skillsCache = [];
     /** fingerprint of the roots that produced skillsCache ("" = not scanned yet) */
     skillsStamp = "";
+    /**
+     * The notes the LAST compaction produced, if any.
+     *
+     * Compaction UPDATES these rather than re-deriving notes from scratch: a fresh
+     * summary each pass loses whatever the previous one distilled (every
+     * implementation surveyed — opencode, Kilo, Pi — updates for this reason).
+     * Recovered from the log so the continuity survives a restart.
+     */
+    lastCompactSummary;
+    /** overflow recoveries used in the current turn; reset when a turn succeeds */
+    overflowRecoveries = 0;
     /**
      * Rescan skill roots — but only when something actually changed (#14).
      * This used to run a readdir per root plus a read of every SKILL.md at the
@@ -856,6 +905,13 @@ export class Agent {
                 if (d.event === "context-compacted")
                     this.stats.compactions++;
             }
+            else if (e.type === "compaction") {
+                // keep the NEWEST notes: they are what the next compaction updates, and
+                // without this a restart would silently fall back to re-summarizing
+                const d = e.data;
+                if (typeof d.summary === "string" && d.summary)
+                    this.lastCompactSummary = d.summary;
+            }
         }
         // newest usage event seeds the context gauge right after reload —
         // inputTokens from the LAST turn is the live context size, and cached
@@ -1207,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(),
@@ -1918,20 +1975,27 @@ export class Agent {
                         detail: "stopped before any output arrived",
                     });
                 }
-                // Provider context overflow → compact ONCE and retry the turn
-                // (OpenCode-style overflow recovery). even with autoCompact off, an
-                // actual overflow is proof the estimate missed; a second overflow is
-                // returned as a real error instead of looping.
+                // Provider context overflow → compact and retry (OpenCode-style recovery).
+                // Even with autoCompact off, an actual overflow is proof the estimate
+                // missed. Staged rather than single-shot (opencode: SHRINK_STEPS
+                // [0.7, 0.5, 0.35]): one fixed cut can still be too shallow, and the old
+                // code returned the second overflow as a hard error even though cutting
+                // deeper would have worked.
                 if (isContextOverflow(err) && !this.stopRequested) {
+                    const attempt = (this.overflowRecoveries += 1);
                     await this.log.append("system_note", this.currentSession, this.currentBranch, {
                         event: "overflow-recovery",
+                        attempt,
                         detail: String(err.message).slice(0, 200),
                     });
                     const before = this.stats.compactions;
-                    await this.maybeCompact(true);
+                    // each retry cuts deeper: 1x, then the staged fractions of the budget
+                    const shrink = OVERFLOW_SHRINK_STEPS[Math.min(attempt - 1, OVERFLOW_SHRINK_STEPS.length - 1)];
+                    await this.maybeCompact(true, shrink);
                     if (this.stats.compactions > before) {
                         await this.log.append("system_note", this.currentSession, this.currentBranch, {
                             event: "overflow-recovered",
+                            attempt,
                         });
                         guard--; // the retry does not count against this round's cap
                         continue;
@@ -1939,6 +2003,9 @@ export class Agent {
                 }
                 throw err;
             }
+            // a request the provider accepted: the current depth is enough, so the next
+            // overflow starts its staircase over rather than cutting from the deepest step
+            this.overflowRecoveries = 0;
             if (res.usage) {
                 const inTok = res.usage.inputTokens ?? 0;
                 const cached = res.usage.cachedInputTokens ?? 0;
@@ -2908,7 +2975,7 @@ export class Agent {
      * token/char — the old flat /4 underestimated Japanese sessions ~4x.
      * Adds a small per-message overhead for role/framing tokens.
      */
-    estimateTokens() {
+    estimateTokens(msgs = this.messages) {
         let ascii = 0;
         let wide = 0;
         const count = (s) => {
@@ -2919,14 +2986,14 @@ export class Agent {
                     ascii++;
             }
         };
-        for (const m of this.messages) {
+        for (const m of msgs) {
             count(m.content ?? "");
             for (const t of m.tool_calls ?? []) {
                 count(t.function.name);
                 count(t.function.arguments);
             }
         }
-        return Math.ceil(ascii / 4 + wide * 1.2 + this.messages.length * 8);
+        return Math.ceil(ascii / 4 + wide * 1.2 + msgs.length * 8);
     }
     /**
      * Latest index whose message may START the kept tail of a compacted
@@ -3032,8 +3099,13 @@ export class Agent {
             });
         return count;
     }
-    /** Compact history when the real prompt size exceeds the budget. */
-    async maybeCompact(force = false) {
+    /**
+     * Compact history when the real prompt size exceeds the budget.
+     *
+     * @param keepFraction share of the budget to keep verbatim; the overflow path
+     *                     lowers it on each retry so a too-shallow cut is not fatal
+     */
+    async maybeCompact(force = false, keepFraction) {
         // prefer the provider's own count from the last response — it is exactly
         // what would overflow the window; the char heuristic is only a fallback
         // for providers that omit usage
@@ -3050,12 +3122,27 @@ export class Agent {
             return;
         this.lastUsage = undefined; // stale after compaction — re-armed next turn
         // keep roughly the most recent quarter of the budget as live context
-        const keepCharBudget = (this.opts.contextTokenBudget / 4) * 4;
-        let keepChars = 0;
+        // Keep the most recent stretch VERBATIM, as every implementation surveyed
+        // does (Pi: keepRecentTokens 20000, opencode: keep 15000). Recency is what the
+        // model needs to continue accurately, and verbatim beats a summary of it.
+        //
+        // Size: a quarter of the budget, but never less than KEEP_RECENT_TOKENS — a
+        // small budget would otherwise keep so little that the model loses the turn it
+        // is in the middle of. Measured in TOKENS rather than characters, so the choice
+        // matches the published defaults instead of depending on the char heuristic.
+        const keepTokens = keepFraction !== undefined
+            // an explicit retry (overflow recovery): shrink toward a share of the budget
+            ? Math.max(1, Math.floor(this.opts.contextTokenBudget * keepFraction))
+            // otherwise keep the newest stretch verbatim, but never more than a quarter
+            // of the budget — a fixed floor GREATER than the budget would keep everything
+            // and compaction would never fire at all (measured: a 500-token budget kept
+            // a 7.5k-token history intact)
+            : Math.min(KEEP_RECENT_TOKENS, Math.max(1, Math.floor(this.opts.contextTokenBudget / 4)));
         let cut = -1;
         for (let i = this.messages.length - 1; i >= 1; i--) {
-            keepChars += (this.messages[i].content?.length ?? 0) + JSON.stringify(this.messages[i].tool_calls ?? "").length;
-            if (keepChars > keepCharBudget)
+            // token-aware boundary, using the SAME estimate the budget uses — a raw char
+            // ratio would disagree with it for wide (CJK) text and per-message overhead
+            if (this.estimateTokens(this.messages.slice(i)) > keepTokens)
                 break;
             cut = i;
         }
@@ -3064,10 +3151,62 @@ export class Agent {
             return; // nothing safely compactable (phase never armed yet)
         const old = this.messages.slice(0, cut);
         const oldCount = old.length;
+        // The prefix's share of the size the budget check ACTED on (which floors our
+        // estimate against the provider's reported prompt_tokens). Scaling by character
+        // share rather than message count: messages vary hugely in size, and the point
+        // is to avoid treating an unmeasurably large context as small.
+        const totalChars = this.messages.reduce((n, m) => n + (m.content?.length ?? 0), 0);
+        const oldChars = old.reduce((n, m) => n + (m.content?.length ?? 0), 0);
+        const oldShareOfBefore = totalChars > 0 ? Math.round((before * oldChars) / totalChars) : 0;
         let summary = "";
         let mode = "summarize";
         let summarizedCount = oldCount;
         let droppedCount = 0;
+        // COST GATE (measured). The summarize call shares NO cacheable prefix with the
+        // main loop: the summarizer's system prompt IS its instructions, so message[0]
+        // differs and the entire history is re-prefilled and re-billed at full size.
+        // Sharing the prefix would mean gutting the summarizer's role, so the lever is
+        // not to PAY for a shallow saving.
+        //
+        // The criterion is the ABSOLUTE amount of context the cut would discard, not
+        // how far over the budget we are. A ratio test gets it backwards: a small
+        // window overflowing slightly is exactly the case where a full-history call
+        // buys almost nothing (there is little knowledge to lose), while a large
+        // window overflowing slightly still has a lot to lose. `oldTokens` is the
+        // summarizable prefix — the thing the call is actually paid for.
+        //
+        // Below the threshold the DROP alone reclaims the budget, for free.
+        //
+        // MANUAL is exempt: an explicit /compact is a user command, not a cost
+        // decision, and opencode draws the line in the same place ("only the user
+        // compacts when automatic compaction is off"). An overflow recovery is exempt
+        // too — the provider just told us the prompt was too big, so the question is
+        // not whether the saving is worth a call.
+        // Use BOTH sizes. `oldTokens` is our estimate of the prefix being summarized;
+        // `before` is the size the budget check acted on, which already floors that
+        // estimate against the provider's REPORTED prompt_tokens. Gating on the local
+        // estimate alone would silently truncate a context the provider says is large
+        // but we cannot measure (caught by a test: provider reports 5000 tokens for a
+        // 300-token local estimate). The provider tokenizes for real; our count is a
+        // guess, so the larger of the two is the honest figure.
+        const oldTokens = Math.max(this.estimateTokens(old), oldShareOfBefore);
+        // The bar is a SHARE of the budget with an absolute floor, so it scales with a
+        // realistic window while never sitting above a small session's entire history
+        // (measured: a budget of 200 made a pure-share bar 10 tokens, while the whole
+        // summarizable prefix in that fixture was an 8-token prompt — summarization
+        // would have been silently disabled).
+        //
+        // Below the bar the prefix is a turn or two, and dropping it costs the model
+        // nothing it cannot recover by re-reading the goal or the files; a full-history
+        // LLM call to preserve that is not worth its price.
+        const summarizeBar = Math.max(SUMMARIZE_MIN_TOKENS, this.opts.contextTokenBudget * SUMMARIZE_MIN_SHARE);
+        const worthSummarizing = force || oldTokens >= summarizeBar;
+        // UPDATE mode: carry the previous notes forward instead of re-deriving them.
+        // Every implementation surveyed (opencode, Kilo, Pi) updates rather than
+        // re-summarizes, because a fresh summary each time loses whatever the previous
+        // pass had already distilled. Recovered from the LAST compaction event, so it
+        // survives a restart.
+        const previousSummary = this.lastCompactSummary;
         // progress is visible: announce the phase up front, then stream the
         // summarizer's output as it generates (a long summarize used to look like
         // the agent silently hung — hundreds of thousands of tokens take a while)
@@ -3101,18 +3240,32 @@ export class Agent {
                 tokensBefore: before,
                 messages: oldCount,
                 reason: force ? "manual" : "auto",
+                worthSummarizing, // makes the cost decision auditable
+                updating: Boolean(previousSummary),
             });
             try {
-                summary = await this.summarize(old, (text) => {
-                    bus.emit("update", {
-                        kind: "llm-delta",
-                        agentId: this.opts.id,
-                        // #146: the bubble is session-scoped, so the stream must say which session
-                        sessionId: this.currentSession,
-                        text: `[compact] ${text}`,
-                        reasoning: "",
+                if (worthSummarizing) {
+                    summary = await this.summarize(old, (text) => {
+                        bus.emit("update", {
+                            kind: "llm-delta",
+                            agentId: this.opts.id,
+                            // #146: the bubble is session-scoped, so the stream must say which session
+                            sessionId: this.currentSession,
+                            text: `[compact] ${text}`,
+                            reasoning: "",
+                        });
+                    }, previousSummary);
+                }
+                else {
+                    // shallow saving: truncation reclaims the budget for free, so skip the
+                    // one full-history LLM call the summary would cost
+                    await this.log.append("system_note", this.currentSession, this.currentBranch, {
+                        event: "context-compaction-skipped-summarize",
+                        reason: "shallow: truncation reclaims the budget without a full-history LLM call",
+                        tokensBefore: before,
+                        budget: this.opts.contextTokenBudget,
                     });
-                });
+                }
                 this.compactPhase = "harvesting";
                 bus.emit("update", { kind: "compaction-progress", agentId: this.opts.id, phase: "harvesting" });
                 if (summary)
@@ -3145,7 +3298,23 @@ export class Agent {
                     return; // the finally clears the phase and tells the UI it ended
                 }
                 droppedCount = halfCut;
-                this.messages = this.messages.slice(halfCut);
+                // Tell the model its history was cut. Dropping a prefix SILENTLY is the
+                // one failure it cannot detect or work around: it would see a conversation
+                // that simply starts mid-way and could not distinguish "I forgot this" from
+                // "this never happened", then confidently act on a gap. Truncation is now
+                // the COMMON path (the cost gate keeps the summarize call for deep cuts
+                // only), which makes this the difference between a known gap and a wrong
+                // belief. The dropped text stays in the log — nothing durable is lost.
+                this.messages = [
+                    {
+                        role: "user",
+                        content: `[harness] ${droppedCount} earlier messages were DROPPED, not summarized (no room to ` +
+                            "summarize, or the saving would not have justified the call). Your earlier work is " +
+                            "in the session log but is NOT in your context any more: re-read files or the goal " +
+                            "before assuming what happened, and do not rely on memory of the dropped part.",
+                    },
+                    ...this.messages.slice(halfCut),
+                ];
             }
             else {
                 this.messages = [
@@ -3226,6 +3395,9 @@ export class Agent {
                 mode,
                 ...(summary ? { summary: String(summary).slice(0, 20_000) } : {}),
             });
+            // remember the notes for the NEXT compaction to update (and for a restore)
+            if (summary)
+                this.lastCompactSummary = summary;
             await this.log.append("system_note", this.currentSession, this.currentBranch, {
                 event: "context-compacted",
                 tokensBefore: before,
@@ -3245,7 +3417,7 @@ export class Agent {
         }
     }
     /** Ask the model for dense continuation notes over the compacted range. */
-    async summarize(old, onDelta) {
+    async summarize(old, onDelta, previousSummary) {
         const full = old
             .map((m) => {
             const who = m.role === "tool" ? "tool" : m.role;
@@ -3286,10 +3458,25 @@ export class Agent {
         // where "pending tasks" vs "user messages" live, so nothing silently
         // merges away. The <analysis> scratchpad gives the model a thinking space;
         // it is stripped from the stored summary (formatCompactSummary).
-        const res = await fn(this.opts.llm, [
+        const res = await fn({ ...this.opts.llm, oneOff: true }, // one-off prompt: ask the provider not to retain it
+        [
             {
                 role: "system",
-                content: "You compress a coding agent's conversation into dense notes for it to continue working.\n\n" +
+                content: 
+                // Both variants OPEN with the same sentence. Tests (and any future caller)
+                // identify the summarizer by this text, and a shared prefix keeps that
+                // detection working across the initial/update split — the first version of
+                // update mode changed it to "You UPDATE…", which silently made every
+                // update pass look like an ordinary turn.
+                "You compress a coding agent's conversation into dense notes for it to continue working.\n\n" +
+                    (previousSummary
+                        ? "This is an UPDATE: the current notes are under `## Current notes`. They are your\n" +
+                            "output from an earlier compaction and are the ONLY record of everything before the\n" +
+                            "messages you are about to read — so carry them forward. PRESERVE what is still\n" +
+                            "true, ADD what the new messages establish, and REMOVE only what they resolve or\n" +
+                            "supersede. Never drop a constraint or a user request just because the new\n" +
+                            "messages do not repeat it: an unanswered request stays, an answered one goes.\n\n"
+                        : "") +
                     "First think inside an <analysis> block: what mattered, what changed, what is unresolved.\n" +
                     "Then output ONLY the following sections, each starting with its exact heading:\n\n" +
                     "## Primary request and intent\n" +
@@ -3307,7 +3494,14 @@ export class Agent {
                     'Durable lessons lists reusable insights worth keeping forever (gotchas, preferences, what worked); omit the section if empty. ' +
                     "The <analysis> block is discarded before your notes are stored, so think freely there.",
             },
-            { role: "user", content: `Conversation:\n\n${transcript}\n\nWrite the continuation notes now.` },
+            {
+                role: "user",
+                content: (previousSummary ? `## Current notes\n\n${previousSummary}\n\n` : "") +
+                    `## Conversation\n\n${transcript}\n\n` +
+                    (previousSummary
+                        ? "Update the current notes to cover this conversation as well. Return the FULL updated notes."
+                        : "Write the continuation notes now."),
+            },
         ], [], undefined, // never abortable by stop(): losing the summary would lose history
         onDelta
             ? (s) => onDelta(s.text)

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 {
@@ -37,6 +57,27 @@ function isOpenRouterEndpoint(baseUrl) {
         return false;
     }
 }
+/**
+ * Ask the endpoint NOT to retain a one-off request (Pi does the same with
+ * `cacheRetention: "none"`; its docs say "summarization requests disable
+ * prompt-cache writes because these one-off prompts are unlikely to be reused").
+ *
+ * Sent ONLY to OpenRouter, which is the one endpoint in use here that both
+ * accepts the field and documents it. Every other OpenAI-compatible endpoint gets
+ * nothing: an unrecognised body field is a 400 on strict providers, and "send
+ * nothing" is exactly today's behaviour, so this can only ever add a saving.
+ *
+ * `24h` is the value that means "do not retain beyond this request's lifetime" for
+ * an organisation with zero-data-retention off; with ZDR on the default is already
+ * `in_memory` and this is a no-op.
+ */
+export function cacheControlForRequest(cfg) {
+    if (!cfg.oneOff)
+        return {};
+    if (!isOpenRouterEndpoint(cfg.baseUrl))
+        return {};
+    return { prompt_cache_retention: "24h" };
+}
 const REASONING_EFFORTS = ["minimal", "low", "medium", "high"];
 /**
  * OpenRouter app attribution (https://openrouter.ai/docs/app-attribution):
@@ -194,6 +235,7 @@ export async function chat(cfg, messages, tools, signal, onDelta) {
             messages: sanitize(messages),
             ...(tools.length ? { tools } : {}),
             ...effortForRequest(cfg),
+            ...cacheControlForRequest(cfg),
         }, { signal });
         // #50: a gateway may answer with `null` (or any non-object) on some proxy
         // error paths, so the guard is on `rm`, not on `res` being truthy —
@@ -289,6 +331,7 @@ export async function chatStream(cfg, messages, tools, signal, onDelta) {
             messages: sanitize(messages),
             ...(tools.length ? { tools } : {}),
             ...effortForRequest(cfg),
+            ...cacheControlForRequest(cfg),
             stream: true,
             // ask providers to include the final usage chunk in streaming mode
             // (OpenAI-compatible; harmless where unsupported)

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