bare-agent 0.50.0 → 0.51.0

package/src/provider-ollama.js

@@ -7,6 +7,7 @@ const { normalizeStopReason } = require('./provider-stop-reason');
 const { resolveTimeoutMs, applyRequestBounds, guardResponseSettles } = require('./provider-http');
 const { hasUsageSignal } = require('./provider-usage');
 const { parseToolCalls } = require('./provider-toolcalls');
+const { normalizeThinkingMode, resolveThinkingMode, requestWithThinkingMode, assessThinkingApplied } = require('./thinking-mode');
 
 // BA-24: raw Ollama usage fields. Any present (even 0) ⇒ a usage signal; none ⇒ null (unpriceable).
 const OLLAMA_USAGE_KEYS = ['prompt_eval_count', 'eval_count'];
@@ -19,6 +20,8 @@ const OLLAMA_USAGE_KEYS = ['prompt_eval_count', 'eval_count'];
  * @typedef {object} OllamaOptions
  * @property {string} [model='llama3.2']
  * @property {string} [url='http://localhost:11434']
+ * @property {'on'|'off'|null} [thinkingMode] - Normalized thinking switch: `'on'` or `'off'`, and bare-agent sends the right `think` (`/api/chat`; NOT live-verified against a real Ollama thinking model — reply signal `message.thinking`) request field for the provider/model, retries the known alternative shapes if the API rejects the field by name, and THROWS a `ValidationError` (naming what it tried) if every shape is rejected — or before any request when the model is measured as not switchable. Every reply is checked: `GenerateResult.thinkingApplied` is `true`/`false`/`null` (`false` = 'off' was sent but the reply shows thinking happened — warns once per instance, result kept). Unset ⇒ request body byte-identical to before. Overridable per call via `generate(..., { thinkingMode })`; `null` suppresses an instance default. Any value but 'on'/'off' ⇒ `ValidationError`. A NEW field: it does not change the raw `thinking` option; setting both (after per-call override) ⇒ `ValidationError`. See `src/thinking-mode.js` / `thinkingSupport()`.
+ *   Per-call `thinkingMode` reaches EVERY provider in a `FallbackProvider` chain — correct for a normalized field (each provider maps it to its own shape; one that cannot — CLIPipe, a non-switchable model — throws `ValidationError`, which the chain treats like any failure and falls through).
  * @property {boolean} [exposeErrorBody=false]
  * @property {number} [timeoutMs=600000] - BA-18: request/idle timeout in ms. Bounds a silent or never-answering socket on inactivity so `generate()` rejects with a retryable `TimeoutError` (`code: 'ETIMEDOUT'`, `context.bound: 'idle'`) instead of hanging until the OS TCP timeout. `0`/`Infinity` disables it. Overridable per call via `generate(..., { timeoutMs })`. (A local Ollama that is loading a large model cold can be slow to first byte — raise this or disable it for very large local models.)
  * @property {number} [deadlineMs=0] - BA-19: TOTAL call-duration deadline in ms, beside `timeoutMs`. The idle bound resets on any socket activity, so a response that trickles a byte forever never trips it and hangs for hours. This is an absolute, non-resetting ceiling; on trip, `generate()` rejects with a TERMINAL `TimeoutError` (`code: 'EDEADLINE'`, `context.bound: 'deadline'`, `retryable: false`). DISABLED by default; `0`/`Infinity` disable. Overridable per call via `generate(..., { deadlineMs })`. (A cold large-model load is a legitimate long single call — leave this disabled or set it generously for such models.)
@@ -41,6 +44,10 @@ class OllamaProvider {
     this.url = options.url || 'http://localhost:11434';
     // See OpenAIProvider: attach full upstream body to err.body only on opt-in.
     this.exposeErrorBody = options.exposeErrorBody === true;
+    // Normalized on/off switch (src/thinking-mode.js). Ollama has no raw `thinking` option to conflict with.
+    this.thinkingMode = normalizeThinkingMode(options.thinkingMode, 'OllamaProvider');
+    /** @type {Map<string, string>} shape that worked per mode+model (no re-probing) */
+    this._thinkingShapes = new Map();
     // BA-18: request/idle timeout (ms). Resolved at call time (default 600000; 0/Infinity disable).
     this.timeoutMs = options.timeoutMs;
     // BA-19: total call-duration deadline (ms). Resolved at call time (default 0 = disabled).
@@ -53,7 +60,7 @@ class OllamaProvider {
    * Generate a response from a local Ollama instance.
    * @param {Message[]} messages - Conversation messages.
    * @param {ToolDef[]} [tools=[]] - Tool definitions.
-   * @param {Record<string, any>} [options={}] - Options (`temperature`, `maxTokens`, `timeoutMs` — a per-call override of the constructor's `timeoutMs`, see BA-18; `deadlineMs` — a per-call override of the constructor's `deadlineMs`, see BA-19).
+   * @param {Record<string, any>} [options={}] - Options (`thinkingMode` — per-call override of the constructor's, `null` suppresses; `temperature`, `maxTokens`, `timeoutMs` — a per-call override of the constructor's `timeoutMs`, see BA-18; `deadlineMs` — a per-call override of the constructor's `deadlineMs`, see BA-19).
    * @returns {Promise<GenerateResult>}
    * @throws {Error} `[OllamaProvider] ...` — on HTTP errors or invalid JSON response.
    */
@@ -86,10 +93,13 @@ class OllamaProvider {
 
     // BA-10: graceful degrade if a model rejects a non-default `temperature` (Ollama nests it under
     // `options`). Keyed off the API error text, so dormant on models that accept temperature.
+    const thinkingMode = resolveThinkingMode({ label: 'OllamaProvider', instanceMode: this.thinkingMode, options });
     const timeoutMs = resolveTimeoutMs(this.timeoutMs, options.timeoutMs);
     const deadlineMs = resolveTimeoutMs(this.deadlineMs, options.deadlineMs, 0, 'deadlineMs');
     const { data, temperatureDropped } = await requestWithTemperatureFallback({
-      request: () => this._request('/api/chat', body, timeoutMs, deadlineMs),
+      request: () => thinkingMode
+        ? requestWithThinkingMode({ kind: 'ollama', mode: thinkingMode, model: this.model, label: 'OllamaProvider', body, cache: this._thinkingShapes, request: (b) => this._request('/api/chat', b, timeoutMs, deadlineMs) })
+        : this._request('/api/chat', body, timeoutMs, deadlineMs),
       hadTemperature: () => body.options?.temperature != null,
       stripTemperature: () => { if (body.options) delete body.options.temperature; },
       warnOnce: () => this._warnTemperatureDropped(),
@@ -126,6 +136,7 @@ class OllamaProvider {
         ? { inputTokens: data.prompt_eval_count || 0, outputTokens: data.eval_count || 0 }
         : null,
       ...(temperatureDropped && { temperatureDropped: true }),
+      ...(thinkingMode && { thinkingApplied: assessThinkingApplied({ kind: 'ollama', mode: thinkingMode, data, owner: this, label: 'OllamaProvider', model: this.model }) }),
     };
   }
 

package/src/provider-openai.d.ts

@@ -45,6 +45,12 @@ export type OpenAIOptions = {
      * or sensitive, so it only reaches logs/audit rows if the caller opts in. See `src/provider-toolcalls.js`.
      */
     exposeMalformedArgs?: boolean | undefined;
+    /**
+     * - Normalized thinking switch: `'on'` or `'off'`, and bare-agent sends the right `reasoning_effort` (OpenAI) / `thinking` (DeepSeek — selected by model id `deepseek-*` or a `deepseek.com` baseUrl) request field for the provider/model, retries the known alternative shapes if the API rejects the field by name, and THROWS a `ValidationError` (naming what it tried) if every shape is rejected — or before any request when the model is measured as not switchable. Every reply is checked: `GenerateResult.thinkingApplied` is `true`/`false`/`null` (`false` = 'off' was sent but the reply shows thinking happened — warns once per instance, result kept). Unset ⇒ request body byte-identical to before. Overridable per call via `generate(..., { thinkingMode })`; `null` suppresses an instance default. Any value but 'on'/'off' ⇒ `ValidationError`. A NEW field: it does not change the raw `thinking` option; setting both (after per-call override) ⇒ `ValidationError`. See `src/thinking-mode.js` / `thinkingSupport()`.
+     * Per-call `thinkingMode` reaches EVERY provider in a `FallbackProvider` chain — correct for a normalized field (each provider maps it to its own shape; one that cannot — CLIPipe, a non-switchable model — throws `ValidationError`, which the chain treats like any failure and falls through).
+     * DeepSeek: `'on'` + a forced `toolChoice` (`'required'`/`{name}`) ⇒ `ValidationError` before sending (the API 400s thinking mode on a forced tool_choice).
+     */
+    thinkingMode?: "on" | "off" | null | undefined;
     /**
      * - Opt-in `thinking` request field (fwdloop DeepSeek ask — extends BA-7(b)'s Anthropic option), forwarded to `body.thinking`
      * VERBATIM and unvalidated — e.g. `{ type: 'disabled' }`. Generalises the Anthropic provider's option to
@@ -88,6 +94,9 @@ export type OpenAIOptions = {
  *   JSON fails to parse, also attach the FULL raw string (verbatim, uncapped) to `malformedToolCall.rawArguments`.
  *   Off by default, independent of `exposeErrorBody` — the raw blob is model-generated and may be large
  *   or sensitive, so it only reaches logs/audit rows if the caller opts in. See `src/provider-toolcalls.js`.
+ * @property {'on'|'off'|null} [thinkingMode] - Normalized thinking switch: `'on'` or `'off'`, and bare-agent sends the right `reasoning_effort` (OpenAI) / `thinking` (DeepSeek — selected by model id `deepseek-*` or a `deepseek.com` baseUrl) request field for the provider/model, retries the known alternative shapes if the API rejects the field by name, and THROWS a `ValidationError` (naming what it tried) if every shape is rejected — or before any request when the model is measured as not switchable. Every reply is checked: `GenerateResult.thinkingApplied` is `true`/`false`/`null` (`false` = 'off' was sent but the reply shows thinking happened — warns once per instance, result kept). Unset ⇒ request body byte-identical to before. Overridable per call via `generate(..., { thinkingMode })`; `null` suppresses an instance default. Any value but 'on'/'off' ⇒ `ValidationError`. A NEW field: it does not change the raw `thinking` option; setting both (after per-call override) ⇒ `ValidationError`. See `src/thinking-mode.js` / `thinkingSupport()`.
+ *   Per-call `thinkingMode` reaches EVERY provider in a `FallbackProvider` chain — correct for a normalized field (each provider maps it to its own shape; one that cannot — CLIPipe, a non-switchable model — throws `ValidationError`, which the chain treats like any failure and falls through).
+ *   DeepSeek: `'on'` + a forced `toolChoice` (`'required'`/`{name}`) ⇒ `ValidationError` before sending (the API 400s thinking mode on a forced tool_choice).
  * @property {any} [thinking] - Opt-in `thinking` request field (fwdloop DeepSeek ask — extends BA-7(b)'s Anthropic option), forwarded to `body.thinking`
  *   VERBATIM and unvalidated — e.g. `{ type: 'disabled' }`. Generalises the Anthropic provider's option to
  *   OpenAI-compatible endpoints. Motivating case: DeepSeek's OpenAI-compatible API (`baseUrl`
@@ -117,11 +126,14 @@ export class OpenAIProvider {
     legacyMaxTokens: boolean;
     exposeMalformedArgs: boolean;
     thinking: any;
+    thinkingMode: "on" | "off" | null;
+    /** @type {Map<string, string>} shape that worked per mode+model (no re-probing) */
+    _thinkingShapes: Map<string, string>;
     /**
      * Generate a response from the OpenAI API.
      * @param {Message[]} messages - Conversation messages.
      * @param {ToolDef[]} [tools=[]] - Tool definitions.
-     * @param {Record<string, any>} [options={}] - Options (temperature, maxTokens, timeoutMs — a per-call override of the constructor's `timeoutMs`, see BA-18; deadlineMs — a per-call override of the constructor's `deadlineMs`, see BA-19; toolChoice — `'auto'` | `'required'` | `{ name }`, forwarded as OpenAI `tool_choice`, applied only when `tools` are present; thinking — per-call override of the constructor's `thinking`, `null` suppresses an instance default, see BA-7 (b)).
+     * @param {Record<string, any>} [options={}] - Options (thinkingMode — per-call override of the constructor's, `null` suppresses; temperature, maxTokens, timeoutMs — a per-call override of the constructor's `timeoutMs`, see BA-18; deadlineMs — a per-call override of the constructor's `deadlineMs`, see BA-19; toolChoice — `'auto'` | `'required'` | `{ name }`, forwarded as OpenAI `tool_choice`, applied only when `tools` are present; thinking — per-call override of the constructor's `thinking`, `null` suppresses an instance default, see BA-7 (b)).
      * @returns {Promise<GenerateResult>}
      * @throws {Error} `[OpenAIProvider] ...` — on HTTP errors (4xx/5xx) or invalid JSON response.
      */

package/src/provider-openai.js

@@ -2,12 +2,13 @@
 
 const https = require('https');
 const http = require('http');
-const { ProviderError } = require('./errors');
+const { ProviderError, ValidationError } = require('./errors');
 const { requestWithTemperatureFallback } = require('./provider-temperature');
 const { normalizeStopReason } = require('./provider-stop-reason');
 const { resolveTimeoutMs, applyRequestBounds, guardResponseSettles } = require('./provider-http');
 const { hasUsageSignal } = require('./provider-usage');
 const { parseToolCalls } = require('./provider-toolcalls');
+const { normalizeThinkingMode, resolveThinkingMode, requestWithThinkingMode, assessThinkingApplied, isDeepSeek } = require('./thinking-mode');
 
 // BA-24: raw OpenAI usage fields. Any present (even 0) ⇒ a usage signal; none ⇒ null (unpriceable).
 const OPENAI_USAGE_KEYS = ['prompt_tokens', 'completion_tokens', 'prompt_tokens_details'];
@@ -76,6 +77,9 @@ function isLoopbackHost(hostname) {
  *   JSON fails to parse, also attach the FULL raw string (verbatim, uncapped) to `malformedToolCall.rawArguments`.
  *   Off by default, independent of `exposeErrorBody` — the raw blob is model-generated and may be large
  *   or sensitive, so it only reaches logs/audit rows if the caller opts in. See `src/provider-toolcalls.js`.
+ * @property {'on'|'off'|null} [thinkingMode] - Normalized thinking switch: `'on'` or `'off'`, and bare-agent sends the right `reasoning_effort` (OpenAI) / `thinking` (DeepSeek — selected by model id `deepseek-*` or a `deepseek.com` baseUrl) request field for the provider/model, retries the known alternative shapes if the API rejects the field by name, and THROWS a `ValidationError` (naming what it tried) if every shape is rejected — or before any request when the model is measured as not switchable. Every reply is checked: `GenerateResult.thinkingApplied` is `true`/`false`/`null` (`false` = 'off' was sent but the reply shows thinking happened — warns once per instance, result kept). Unset ⇒ request body byte-identical to before. Overridable per call via `generate(..., { thinkingMode })`; `null` suppresses an instance default. Any value but 'on'/'off' ⇒ `ValidationError`. A NEW field: it does not change the raw `thinking` option; setting both (after per-call override) ⇒ `ValidationError`. See `src/thinking-mode.js` / `thinkingSupport()`.
+ *   Per-call `thinkingMode` reaches EVERY provider in a `FallbackProvider` chain — correct for a normalized field (each provider maps it to its own shape; one that cannot — CLIPipe, a non-switchable model — throws `ValidationError`, which the chain treats like any failure and falls through).
+ *   DeepSeek: `'on'` + a forced `toolChoice` (`'required'`/`{name}`) ⇒ `ValidationError` before sending (the API 400s thinking mode on a forced tool_choice).
  * @property {any} [thinking] - Opt-in `thinking` request field (fwdloop DeepSeek ask — extends BA-7(b)'s Anthropic option), forwarded to `body.thinking`
  *   VERBATIM and unvalidated — e.g. `{ type: 'disabled' }`. Generalises the Anthropic provider's option to
  *   OpenAI-compatible endpoints. Motivating case: DeepSeek's OpenAI-compatible API (`baseUrl`
@@ -112,13 +116,18 @@ class OpenAIProvider {
     // BA-7 (b) / fwdloop: forwarded to `body.thinking` VERBATIM — unvalidated, un-reshaped (mirrors the
     // Anthropic provider). Null/unset ⇒ no `thinking` key, byte-identical to the pre-option body.
     this.thinking = options.thinking != null ? options.thinking : null;
+    // Normalized on/off switch (src/thinking-mode.js); conflict with raw `thinking` is a ValidationError.
+    this.thinkingMode = normalizeThinkingMode(options.thinkingMode, 'OpenAIProvider');
+    resolveThinkingMode({ label: 'OpenAIProvider', instanceMode: this.thinkingMode, options: {}, instanceThinking: this.thinking, hasRawThinking: true });
+    /** @type {Map<string, string>} shape that worked per mode+model (no re-probing) */
+    this._thinkingShapes = new Map();
   }
 
   /**
    * Generate a response from the OpenAI API.
    * @param {Message[]} messages - Conversation messages.
    * @param {ToolDef[]} [tools=[]] - Tool definitions.
-   * @param {Record<string, any>} [options={}] - Options (temperature, maxTokens, timeoutMs — a per-call override of the constructor's `timeoutMs`, see BA-18; deadlineMs — a per-call override of the constructor's `deadlineMs`, see BA-19; toolChoice — `'auto'` | `'required'` | `{ name }`, forwarded as OpenAI `tool_choice`, applied only when `tools` are present; thinking — per-call override of the constructor's `thinking`, `null` suppresses an instance default, see BA-7 (b)).
+   * @param {Record<string, any>} [options={}] - Options (thinkingMode — per-call override of the constructor's, `null` suppresses; temperature, maxTokens, timeoutMs — a per-call override of the constructor's `timeoutMs`, see BA-18; deadlineMs — a per-call override of the constructor's `deadlineMs`, see BA-19; toolChoice — `'auto'` | `'required'` | `{ name }`, forwarded as OpenAI `tool_choice`, applied only when `tools` are present; thinking — per-call override of the constructor's `thinking`, `null` suppresses an instance default, see BA-7 (b)).
    * @returns {Promise<GenerateResult>}
    * @throws {Error} `[OpenAIProvider] ...` — on HTTP errors (4xx/5xx) or invalid JSON response.
    */
@@ -143,6 +152,11 @@ class OpenAIProvider {
     // empty. Attach it only when tools are present: OpenAI 400s on a tool_choice with no tools, so a
     // valid choice with nothing to force is dropped (documented), while absent ⇒ the API default 'auto'.
     const toolChoice = toOpenAIToolChoice(options.toolChoice);
+    const thinkingMode = resolveThinkingMode({ label: 'OpenAIProvider', instanceMode: this.thinkingMode, options, instanceThinking: this.thinking, hasRawThinking: true });
+    const thinkingKind = thinkingMode ? (isDeepSeek(this.model, this.baseUrl) ? 'deepseek' : 'openai') : null;
+    if (thinkingKind === 'deepseek' && thinkingMode === 'on' && tools.length > 0 && toolChoice != null && toolChoice !== 'auto') {
+      throw new ValidationError("[OpenAIProvider] thinkingMode 'on' cannot be combined with a forced toolChoice on DeepSeek (the API 400s: thinking mode does not support a forced tool_choice) — use thinkingMode 'off' or toolChoice 'auto'.", { context: { lib: 'bare-agent', provider: 'deepseek', model: this.model } });
+    }
     if (tools.length > 0) {
       body.tools = tools.map(t => ({
         type: 'function',
@@ -156,7 +170,9 @@ class OpenAIProvider {
     const timeoutMs = resolveTimeoutMs(this.timeoutMs, options.timeoutMs);
     const deadlineMs = resolveTimeoutMs(this.deadlineMs, options.deadlineMs, 0, 'deadlineMs');
     const { data, temperatureDropped } = await requestWithTemperatureFallback({
-      request: () => this._request('/chat/completions', body, timeoutMs, deadlineMs),
+      request: () => thinkingKind
+        ? requestWithThinkingMode({ kind: /** @type {'openai'|'deepseek'} */ (thinkingKind), mode: /** @type {'on'|'off'} */ (thinkingMode), model: this.model, label: 'OpenAIProvider', body, cache: this._thinkingShapes, request: (b) => this._request('/chat/completions', b, timeoutMs, deadlineMs) })
+        : this._request('/chat/completions', body, timeoutMs, deadlineMs),
       hadTemperature: () => body.temperature != null,
       stripTemperature: () => { delete body.temperature; },
       warnOnce: () => this._warnTemperatureDropped(),
@@ -199,6 +215,7 @@ class OpenAIProvider {
       stopReason: normalizeStopReason(choice?.finish_reason, 'openai', { hasToolCalls: toolCalls.length > 0 }),
       usage: this._normalizeUsage(data.usage),
       ...(temperatureDropped && { temperatureDropped: true }),
+      ...(thinkingKind && { thinkingApplied: assessThinkingApplied({ kind: /** @type {'openai'|'deepseek'} */ (thinkingKind), mode: /** @type {'on'|'off'} */ (thinkingMode), data, owner: this, label: 'OpenAIProvider', model: this.model }) }),
     };
   }
 

package/src/provider-temperature.d.ts

@@ -4,6 +4,12 @@
  * @returns {boolean}
  */
 export function isTemperatureUnsupported(err: any): boolean;
+/**
+ * Is this a 400 saying `temperature` conflicts with enabled thinking (names both)?
+ * @param {any} err
+ * @returns {boolean}
+ */
+export function isTemperatureThinkingConflict(err: any): boolean;
 /**
  * Issue a provider request; if it 400s because `temperature` is unsupported AND a temperature was
  * actually sent, strip it and retry ONCE. Returns whether the temperature was dropped so the caller
@@ -13,13 +19,15 @@ export function isTemperatureUnsupported(err: any): boolean;
  * @param {() => Promise<any>} opts.request - issues the API call (rejects `ProviderError` on 4xx).
  * @param {() => boolean} opts.hadTemperature - was a temperature actually in the request body?
  * @param {() => void} opts.stripTemperature - mutate the request body to remove the temperature.
+ * @param {boolean} [opts.thinkingOn] - a thinkingMode 'on' shape is being sent: ALSO treat a 400 naming both temperature and thinking as droppable (thinking wins). Default off ⇒ behavior unchanged.
  * @param {() => void} [opts.warnOnce] - emit the one-time degrade warning (caller dedupes per instance).
  * @returns {Promise<{ data: any, temperatureDropped: boolean }>}
  */
-export function requestWithTemperatureFallback({ request, hadTemperature, stripTemperature, warnOnce }: {
+export function requestWithTemperatureFallback({ request, hadTemperature, stripTemperature, thinkingOn, warnOnce }: {
     request: () => Promise<any>;
     hadTemperature: () => boolean;
     stripTemperature: () => void;
+    thinkingOn?: boolean | undefined;
     warnOnce?: (() => void) | undefined;
 }): Promise<{
     data: any;

package/src/provider-temperature.js

@@ -32,6 +32,22 @@ function isTemperatureUnsupported(err) {
   return !!err && err.status === 400 && TEMP_NAMED.test(msg) && TEMP_UNSUPPORTED.test(msg);
 }
 
+// Anthropic with thinking ENABLED rejects any non-default temperature ("`temperature` may only be set to 1
+// when thinking is enabled" — live-confirmed 2026-10-11 on haiku-4-5; sonnet-5 appends "or in adaptive mode"). Thinking-on wins: the
+// caller asked for thinking explicitly, so the temperature is what gets dropped. Narrow: a 400 that names
+// BOTH words (no `.*`, so ReDoS-safe); only consulted when the caller passes `thinkingOn`.
+const THINKING_NAMED = /thinking/i;
+
+/**
+ * Is this a 400 saying `temperature` conflicts with enabled thinking (names both)?
+ * @param {any} err
+ * @returns {boolean}
+ */
+function isTemperatureThinkingConflict(err) {
+  const msg = err && typeof err.message === 'string' ? err.message : '';
+  return !!err && err.status === 400 && TEMP_NAMED.test(msg) && THINKING_NAMED.test(msg);
+}
+
 /**
  * Issue a provider request; if it 400s because `temperature` is unsupported AND a temperature was
  * actually sent, strip it and retry ONCE. Returns whether the temperature was dropped so the caller
@@ -41,14 +57,15 @@ function isTemperatureUnsupported(err) {
  * @param {() => Promise<any>} opts.request - issues the API call (rejects `ProviderError` on 4xx).
  * @param {() => boolean} opts.hadTemperature - was a temperature actually in the request body?
  * @param {() => void} opts.stripTemperature - mutate the request body to remove the temperature.
+ * @param {boolean} [opts.thinkingOn] - a thinkingMode 'on' shape is being sent: ALSO treat a 400 naming both temperature and thinking as droppable (thinking wins). Default off ⇒ behavior unchanged.
  * @param {() => void} [opts.warnOnce] - emit the one-time degrade warning (caller dedupes per instance).
  * @returns {Promise<{ data: any, temperatureDropped: boolean }>}
  */
-async function requestWithTemperatureFallback({ request, hadTemperature, stripTemperature, warnOnce }) {
+async function requestWithTemperatureFallback({ request, hadTemperature, stripTemperature, thinkingOn, warnOnce }) {
   try {
     return { data: await request(), temperatureDropped: false };
   } catch (err) {
-    if (isTemperatureUnsupported(err) && hadTemperature()) {
+    if ((isTemperatureUnsupported(err) || (thinkingOn === true && isTemperatureThinkingConflict(err))) && hadTemperature()) {
       stripTemperature();
       if (warnOnce) warnOnce();
       return { data: await request(), temperatureDropped: true };
@@ -57,4 +74,4 @@ async function requestWithTemperatureFallback({ request, hadTemperature, stripTe
   }
 }
 
-module.exports = { isTemperatureUnsupported, requestWithTemperatureFallback };
+module.exports = { isTemperatureUnsupported, isTemperatureThinkingConflict, requestWithTemperatureFallback };

package/src/providers.d.ts

@@ -5,4 +5,5 @@ import { OllamaProvider } from "./provider-ollama";
 import { CLIPipeProvider } from "./provider-clipipe";
 import { FallbackProvider } from "./provider-fallback";
 import { JevProvider } from "./provider-jev";
-export { OpenAIProvider as OpenAI, AnthropicProvider as Anthropic, GeminiProvider as Gemini, OllamaProvider as Ollama, CLIPipeProvider as CLIPipe, FallbackProvider as Fallback, JevProvider as Jev, OpenAIProvider, AnthropicProvider, GeminiProvider, OllamaProvider, CLIPipeProvider, FallbackProvider, JevProvider };
+import { thinkingSupport } from "./thinking-mode";
+export { OpenAIProvider as OpenAI, AnthropicProvider as Anthropic, GeminiProvider as Gemini, OllamaProvider as Ollama, CLIPipeProvider as CLIPipe, FallbackProvider as Fallback, JevProvider as Jev, OpenAIProvider, AnthropicProvider, GeminiProvider, OllamaProvider, CLIPipeProvider, FallbackProvider, JevProvider, thinkingSupport };

package/src/providers.js

@@ -7,6 +7,7 @@ const { OllamaProvider } = require('./provider-ollama');
 const { CLIPipeProvider } = require('./provider-clipipe');
 const { FallbackProvider } = require('./provider-fallback');
 const { JevProvider } = require('./provider-jev');
+const { thinkingSupport } = require('./thinking-mode');
 
 module.exports = {
   // Short names (canonical — used throughout docs and the integration guide)
@@ -26,4 +27,6 @@ module.exports = {
   CLIPipeProvider,
   FallbackProvider,
   JevProvider,
+  // Pure lookup (no network): what bare-agent knows about switching a model's thinking on/off.
+  thinkingSupport,
 };

package/src/thinking-mode.d.ts

@@ -0,0 +1,142 @@
+export type LadderKind = "anthropic" | "openai" | "deepseek" | "gemini" | "ollama";
+export type Shape = {
+    /**
+     * - Short stable key (the MODELS table refers to shapes by this).
+     */
+    key: string;
+    /**
+     * - Human-readable request-field description (error messages, thinkingSupport).
+     */
+    id: string;
+    /**
+     * - Returns a NEW body with
+     * the field set (copy-on-write; never mutates `body`), or `null` when the shape cannot apply to this body.
+     */
+    apply: (body: Record<string, any>) => (Record<string, any> | null);
+};
+/**
+ * What bare-agent knows about switching a model's thinking on/off, with no network. Measured models
+ * answer true/false; a model not in the measured table on a provider with a shape ladder answers
+ * 'unverified' (the ladder will try the shapes at runtime and fail loudly if all are rejected);
+ * clipipe and unknown providers answer false.
+ * @param {'anthropic'|'openai'|'deepseek'|'gemini'|'ollama'|'clipipe'|string} provider
+ * @param {string} [model]
+ * @returns {{ switchable: boolean|'unverified', off: string|null, on: string|null, note: string }}
+ * @when you need to know, before building a request, whether a provider/model can have thinking turned on or off and which request field does it — pure lookup, no network
+ * @fails returns switchable:false for clipipe and unknown providers (never throws); 'unverified' means not measured, not unsupported; Ollama's shapes are not live-verified.
+ * @category providers
+ * @example
+ *   thinkingSupport('anthropic', 'claude-opus-5-5'); // { switchable: false, off: null, on: "thinking:{type:'adaptive'}", note: '...' }
+ */
+export function thinkingSupport(provider: "anthropic" | "openai" | "deepseek" | "gemini" | "ollama" | "clipipe" | string, model?: string): {
+    switchable: boolean | "unverified";
+    off: string | null;
+    on: string | null;
+    note: string;
+};
+/**
+ * Validate a `thinkingMode` value. `undefined`/`null` ⇒ `null` (unset); anything but 'on'/'off' throws.
+ * @param {any} value
+ * @param {string} label - provider name for the message
+ * @returns {'on'|'off'|null}
+ */
+export function normalizeThinkingMode(value: any, label: string): "on" | "off" | null;
+/**
+ * Resolve the EFFECTIVE mode for one call and reject the raw-`thinking` conflict (no silent precedence).
+ * Per-call overrides the instance default; `null` suppresses it.
+ * @param {object} p
+ * @param {string} p.label
+ * @param {any} p.instanceMode
+ * @param {Record<string, any>} p.options - per-call options
+ * @param {any} [p.instanceThinking] - the instance's raw `thinking` (providers that have one)
+ * @param {boolean} [p.hasRawThinking] - whether this provider has a raw `thinking` option at all
+ * @returns {'on'|'off'|null}
+ */
+export function resolveThinkingMode({ label, instanceMode, options, instanceThinking, hasRawThinking }: {
+    label: string;
+    instanceMode: any;
+    options: Record<string, any>;
+    instanceThinking?: any;
+    hasRawThinking?: boolean | undefined;
+}): "on" | "off" | null;
+/**
+ * Send a request with the `thinkingMode` field applied, walking the shape ladder on a 400 that names
+ * the field. Order: the instance cache (a shape that already worked for this mode+model), else the
+ * table's known-good shape, else the ladder's first; then the remaining shapes in ladder order. A
+ * known-not-switchable model throws BEFORE any request. Every shape rejected ⇒ a loud ValidationError.
+ * A 400 that does not name the field (or any non-400) is an ordinary error and propagates untouched.
+ *
+ * @param {object} p
+ * @param {LadderKind} p.kind
+ * @param {'on'|'off'} p.mode
+ * @param {string} p.model
+ * @param {string} p.label - provider class name
+ * @param {Record<string, any>} p.body - the base body (NOT mutated; each attempt gets a patched copy)
+ * @param {(body: Record<string, any>) => Promise<any>} p.request
+ * @param {Map<string, string>} p.cache - per provider instance
+ * @returns {Promise<any>} the reply data of the accepted shape
+ */
+export function requestWithThinkingMode({ kind, mode, model, label, body, request, cache }: {
+    kind: LadderKind;
+    mode: "on" | "off";
+    model: string;
+    label: string;
+    body: Record<string, any>;
+    request: (body: Record<string, any>) => Promise<any>;
+    cache: Map<string, string>;
+}): Promise<any>;
+/**
+ * The `thinkingApplied` verdict for a reply whose request was accepted. 'on' ⇒ `true` (an adaptive
+ * model may legitimately choose not to think, so 'on' is never flagged). 'off' ⇒ `true` when the reply
+ * shows zero thinking, `false` when thinking happened anyway, `null` when the signal is unreadable.
+ * On `false` it warns ONCE per `owner` (the provider instance) and never throws — the round is paid.
+ * @param {object} p
+ * @param {LadderKind} p.kind
+ * @param {'on'|'off'} p.mode
+ * @param {any} p.data
+ * @param {any} p.owner - provider instance (holds the warn-once flag)
+ * @param {string} p.label
+ * @param {string} p.model
+ * @returns {boolean|null}
+ */
+export function assessThinkingApplied({ kind, mode, data, owner, label, model }: {
+    kind: LadderKind;
+    mode: "on" | "off";
+    data: any;
+    owner: any;
+    label: string;
+    model: string;
+}): boolean | null;
+/**
+ * Read the thinking signal off a raw reply: 'thinking' | 'none' | 'unknown'. "Absent field ⇒ none" is
+ * used ONLY where measured: Gemini thoughtsTokenCount (given usageMetadata is present), DeepSeek
+ * reasoning_content, Ollama message.thinking. Anthropic counts thinking/redacted_thinking blocks.
+ * OpenAI reasoning_tokens absent ⇒ 'unknown'.
+ * @param {LadderKind} kind
+ * @param {any} data - raw provider reply
+ * @returns {'thinking'|'none'|'unknown'}
+ */
+export function readThinkingSignal(kind: LadderKind, data: any): "thinking" | "none" | "unknown";
+/**
+ * @param {LadderKind} kind
+ * @param {any} err
+ * @returns {boolean}
+ */
+export function isShapeRejection(kind: LadderKind, err: any): boolean;
+/**
+ * @param {any} model
+ * @param {any} baseUrl
+ * @returns {boolean}
+ */
+export function isDeepSeek(model: any, baseUrl: any): boolean;
+/**
+ * Longest-prefix lookup of a model's measured facts. A dated/`-latest` suffix of a listed id counts
+ * (`claude-haiku-4-5-20251001`); any other suffix does NOT (so `gpt-5-chat` never inherits `gpt-5`).
+ * @param {LadderKind} kind
+ * @param {string} model
+ * @returns {{ off: string|null, on: string|null }|null}
+ */
+export function lookupModel(kind: LadderKind, model: string): {
+    off: string | null;
+    on: string | null;
+} | null;