bare-agent 0.48.1 → 0.50.0

package/bareagent.context.md

@@ -505,6 +505,14 @@ The blocks now ride the transcript on `Message.providerBlocks` (`{provider, mode
 
 `AnthropicProvider({ thinking })` is a separate, opt-in knob, forwarded to `body.thinking` verbatim (e.g. `{type:'adaptive', display:'summarized'}` to surface the reasoning; the default `display` is `'omitted'`). **It does not "turn thinking on"** — it's already on. Use it to pin the mode or reach `display`/`effort`. It is passed through unvalidated on purpose: `budget_tokens` was removed from the API and now **400s** on sonnet-5/Opus 4.7+, so a library that reshaped this parameter would need a release every time Anthropic moved.
 
+`OpenAIProvider({ thinking })` is the OpenAI-compatible counterpart: same verbatim/unvalidated forwarding to `body.thinking`, overridable per call (`loop.run(msgs, tools, { thinking })` / `generate(..., { thinking })`), and per-call `null` suppresses the constructor default. Needed for DeepSeek, which runs thinking mode by default and 400s "Thinking mode does not support this tool_choice" on a forced `toolChoice`:
+
+```js
+new OpenAIProvider({ baseUrl: 'https://api.deepseek.com', model: 'deepseek-flash', legacyMaxTokens: true, thinking: { type: 'disabled' } })
+```
+
+> **Fallback caveat:** per-call options (incl. `thinking`) are forwarded to EVERY provider in a `FallbackProvider` chain. For a mixed-vendor chain set `thinking` on each provider's constructor, not per-call.
+
 > **Honesty note, and we mean it.** This is a **protocol/data-loss fix, not a capability fix.** A head-to-head with thinking fully preserved vs. stock bare-agent produced **indistinguishable** outcomes. Do not adopt 0.27 expecting better reasoning — you will not get it, and we have the measurement.
 
 Legacy `wrapTool` / `wrapTools` are retained as deprecation shims (one-shot console warning, removal in 1.0). Migration: replace `wrapTools(tools)` at `loop.run()` with `filterTools(tools)` once upfront + `onLlmResult` / `onToolResult` on `new Loop({...})` to pick up LLM-cost recording and `_ctx` threading.
@@ -968,6 +976,8 @@ All return `{ text, toolCalls, usage: { inputTokens, outputTokens }, model?, cos
 
 **Error body (v0.11.0):** on an HTTP error the OpenAI/Anthropic/Ollama providers throw a `ProviderError` whose `message` carries the upstream error string. The full parsed response is **not** attached to `err.body` by default (so an unexpected field can't leak through logs that dump the error object). Pass `{ exposeErrorBody: true }` to attach it for debugging.
 
+**Malformed tool-call arguments (BA-27):** when an OpenAI-compatible or Ollama model emits `function.arguments` that is not valid JSON, the provider returns `toolCalls: []` plus a `malformedToolCall: { name, error }` marker (round still metered; JSON never repaired); `Loop.run()` surfaces the same marker on its result. Pass `{ exposeMalformedArgs: true }` (OpenAI/Ollama; default off, independent of `exposeErrorBody`) to also get `malformedToolCall.rawArguments` — the FULL raw arguments string, verbatim and uncapped (since 0.50.0; earlier it was the first 500 chars plus `rawTruncated`, which hid the broken tail). Model-generated and possibly large or sensitive: bare-agent only returns it to you and never logs it, but anything you forward it to (logs, audit rows) is your call. `rawTruncated` is deprecated and never set.
+
 **Request/idle timeout (BA-18, v0.34.0):** the four http(s) providers (Anthropic, OpenAI, Gemini, Ollama) accept a `timeoutMs` option — constructor default **600000 (10 min)**, overridable per call via `generate(..., { timeoutMs })`, and `0`/`Infinity` disables it. Before this they wired only `req.on('error')`, so a socket the server silently dropped — or a response that never starts — hung `generate()` until the OS TCP timeout (~2h): a hang, not an error, so retry/casualty policy above it never fired. `timeoutMs` bounds on socket **inactivity** (`req.setTimeout`), so a slow-but-streaming response is not killed — only a silent/never-answering socket trips it; the 10-min default clears any single non-streaming completion (TTFB ≈ generation time). On trip, `generate()` rejects with a retryable `TimeoutError` (`code: 'ETIMEDOUT'`, `context.bound: 'idle'`, `retryable: true`). **Retry is caller-side and already wired:** `new Loop({ provider, retry: new Retry() })` wraps `provider.generate`, and `DEFAULT_RETRY_ON` classifies `ETIMEDOUT` (and `ECONNRESET`/`ENOTFOUND`/429/5xx) as transient — so a wired `Retry` retries a timed-out request and rethrows under `retryOn: () => false`, with no extra wiring (`run-plan`'s `stepRetry` is a second consumer of the same seam). CLIPipe already bounded its child process (`timeout`, default 30000 for one-shot) and is unchanged.
 
 **Total call-duration deadline (BA-19, v0.35.0):** `timeoutMs` bounds socket *inactivity*, and `req.setTimeout` resets on any activity by design — so a "zombie stream" that trickles a byte forever (bytes arriving, the response never completing) never trips it and hangs the caller for hours (an adopter saw one `generate()` run **274 min** and end in `ECONNRESET`, not a `TimeoutError`: the reset proves bytes *were* flowing, so the idle timer never fired). The four http(s) providers now also accept a `deadlineMs` option — an absolute, **non-resetting** wall-clock ceiling on the whole request. **Disabled by default** (a deliberately long single call — large `maxTokens`, slow model — is legitimate; a default here would kill it), overridable per call via `generate(..., { deadlineMs })`, `0`/`Infinity` disable. An *unset* deadline resolves to disabled, but an *explicitly-set* garbage value (`NaN`, a non-numeric string) throws a `ValidationError` at resolve time rather than silently disabling the bound and running unbounded — unlike `timeoutMs`, the deadline has no safe default to fall back to, so a config mistake must surface loudly. On trip, `generate()` rejects with a **terminal** `TimeoutError` distinguishable from the idle trip: `code: 'EDEADLINE'`, `context.bound: 'deadline'`, `retryable: false` — a deadline is a hard ceiling meant to STOP, so it is *not* auto-retried (retrying would re-spend up to another full `deadlineMs`); a consumer that wants retry opts in via `retryOn`. When both are armed and `timeoutMs < deadlineMs`, a silent socket trips the idle bound first; only a still-active-but-never-completing stream reaches the deadline. The idle bound (BA-18) and the deadline (BA-19) are two independent failure modes — a silent socket vs a zombie stream.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bare-agent",
-  "version": "0.48.1",
+  "version": "0.50.0",
   "files": [
     "index.js",
     "index.d.ts",

package/src/loop.d.ts

@@ -167,7 +167,7 @@ export class Loop {
      *   thunk is re-evaluated each round (D4/eval-assist F2) so a tool set that grows mid-run — e.g. a skill
      *   unlocking its tools — is offered on the next round; a static array is resolved once at wire time.
      * @param {Record<string, any>} [options={}] - Per-run overrides (system, temperature, ctx, etc.).
-     * @returns {Promise<{text: string, toolCalls: ToolCall[], usage: Usage, cost: number, error: string|null, stopReason: string|null, model: string|null, msgs: Message[], metrics: RunMetrics, malformedToolCall?: {name: string|undefined, error: string, rawArguments?: string, rawTruncated?: true}, temperatureDropped?: boolean}>}
+     * @returns {Promise<{text: string, toolCalls: ToolCall[], usage: Usage, cost: number, error: string|null, stopReason: string|null, model: string|null, msgs: Message[], metrics: RunMetrics, malformedToolCall?: GenerateResult['malformedToolCall'], temperatureDropped?: boolean}>}
      *   On halt the returned `error` is `halt:<rule>` (or `halt:unknown` if the
      *   thrown HaltError carried no `rule`), and `msgs` is sanitized so any
      *   dangling assistant `tool_calls` from the halted round are paired with
@@ -205,12 +205,7 @@ export class Loop {
         model: string | null;
         msgs: Message[];
         metrics: RunMetrics;
-        malformedToolCall?: {
-            name: string | undefined;
-            error: string;
-            rawArguments?: string;
-            rawTruncated?: true;
-        };
+        malformedToolCall?: GenerateResult["malformedToolCall"];
         temperatureDropped?: boolean;
     }>;
     _warnedTruncated: boolean | undefined;
@@ -240,7 +235,7 @@ export class Loop {
      * @param {string} text - User message.
      * @param {ToolDef[]} [tools=[]] - Tool definitions.
      * @param {Record<string, any>} [options={}] - Per-run overrides.
-     * @returns {Promise<{text: string, toolCalls: ToolCall[], usage: Usage, cost: number, error: string|null, stopReason: string|null, model: string|null, msgs: Message[], metrics: RunMetrics, malformedToolCall?: {name: string|undefined, error: string, rawArguments?: string, rawTruncated?: true}, temperatureDropped?: boolean}>}
+     * @returns {Promise<{text: string, toolCalls: ToolCall[], usage: Usage, cost: number, error: string|null, stopReason: string|null, model: string|null, msgs: Message[], metrics: RunMetrics, malformedToolCall?: GenerateResult['malformedToolCall'], temperatureDropped?: boolean}>}
      */
     chat(text: string, tools?: ToolDef[], options?: Record<string, any>): Promise<{
         text: string;
@@ -252,12 +247,7 @@ export class Loop {
         model: string | null;
         msgs: Message[];
         metrics: RunMetrics;
-        malformedToolCall?: {
-            name: string | undefined;
-            error: string;
-            rawArguments?: string;
-            rawTruncated?: true;
-        };
+        malformedToolCall?: GenerateResult["malformedToolCall"];
         temperatureDropped?: boolean;
     }>;
     /**

package/src/loop.js

@@ -455,7 +455,7 @@ class Loop {
    *   thunk is re-evaluated each round (D4/eval-assist F2) so a tool set that grows mid-run — e.g. a skill
    *   unlocking its tools — is offered on the next round; a static array is resolved once at wire time.
    * @param {Record<string, any>} [options={}] - Per-run overrides (system, temperature, ctx, etc.).
-   * @returns {Promise<{text: string, toolCalls: ToolCall[], usage: Usage, cost: number, error: string|null, stopReason: string|null, model: string|null, msgs: Message[], metrics: RunMetrics, malformedToolCall?: {name: string|undefined, error: string, rawArguments?: string, rawTruncated?: true}, temperatureDropped?: boolean}>}
+   * @returns {Promise<{text: string, toolCalls: ToolCall[], usage: Usage, cost: number, error: string|null, stopReason: string|null, model: string|null, msgs: Message[], metrics: RunMetrics, malformedToolCall?: GenerateResult['malformedToolCall'], temperatureDropped?: boolean}>}
    *   On halt the returned `error` is `halt:<rule>` (or `halt:unknown` if the
    *   thrown HaltError carried no `rule`), and `msgs` is sanitized so any
    *   dangling assistant `tool_calls` from the halted round are paired with
@@ -1328,7 +1328,7 @@ class Loop {
    * @param {string} text - User message.
    * @param {ToolDef[]} [tools=[]] - Tool definitions.
    * @param {Record<string, any>} [options={}] - Per-run overrides.
-   * @returns {Promise<{text: string, toolCalls: ToolCall[], usage: Usage, cost: number, error: string|null, stopReason: string|null, model: string|null, msgs: Message[], metrics: RunMetrics, malformedToolCall?: {name: string|undefined, error: string, rawArguments?: string, rawTruncated?: true}, temperatureDropped?: boolean}>}
+   * @returns {Promise<{text: string, toolCalls: ToolCall[], usage: Usage, cost: number, error: string|null, stopReason: string|null, model: string|null, msgs: Message[], metrics: RunMetrics, malformedToolCall?: GenerateResult['malformedToolCall'], temperatureDropped?: boolean}>}
    */
   async chat(text, tools = [], options = {}) {
     this._history.push({ role: 'user', content: text });

package/src/provider-anthropic.d.ts

@@ -24,6 +24,8 @@ export type AnthropicOptions = {
     cacheMessages?: boolean | undefined;
     /**
      * - Opt-in extended thinking (BA-7), forwarded to `body.thinking` VERBATIM and unvalidated — e.g. `{ type: 'adaptive' }`, or `{ type: 'adaptive', display: 'summarized' }` to surface the reasoning (the default `display` is `'omitted'`). Deliberately opaque: this parameter has already broken once (`budget_tokens` was removed and now 400s on `claude-sonnet-5` / Opus 4.7+), and a library that reshapes it would need a release every time the API moves. Overridable per call via `generate(..., { thinking })`; pass `null` there to suppress an instance default.
+     * WARNING: per-call options (incl. `thinking`) are forwarded to EVERY provider in a `FallbackProvider` chain — for a mixed-vendor
+     * chain set `thinking` on each provider's CONSTRUCTOR instead of per-call.
      *
      * **MEASURED CAVEAT — this option does not "turn thinking on".** On `claude-sonnet-5` adaptive thinking is ALREADY the default: sending this changed the observed thinking rate not at all (2/10 rounds with it vs 3/10 without — `poc/ba7-adaptive-default.mjs`). Its real use is pinning the mode and reaching `display`/`effort`. The change that mattered is that thinking blocks are now PRESERVED and replayed (see `Message.providerBlocks`), which happens whether or not you ever set this.
      */
@@ -52,6 +54,8 @@ export type AnthropicOptions = {
  * @property {boolean} [cacheSystem=false] - Opt-in prompt caching: send the system prompt with a `cache_control` breakpoint so Anthropic caches it. Anthropic does NOT auto-cache, so without this its cache tiers are always 0. Overridable per call via `generate(..., { cacheSystem })`. NOTE: on its own this rarely helps a tool loop — Anthropic's minimum cacheable prefix is 1024–4096 tokens (model-dependent) and a typical system persona is a few hundred, so it silently never caches. The transcript is where a tool loop's tokens actually live — see `cacheMessages`.
  * @property {boolean} [cacheMessages=false] - Opt-in TRANSCRIPT caching (BA-1): roll a `cache_control` breakpoint onto the last content block of the last message, so Anthropic caches the whole conversation prefix and the loop stops re-buying it at full price every round. In a tool loop the transcript IS the tool results (file bodies from `shell_read`) and it always ENDS on one, which `_toAnthropicMessage` rebuilds from scratch — so no caller-side seam (`assemble` included) can reach it, and this has to live in the provider. Measured on `claude-sonnet-5` with a ~15k-token tool-result transcript (`poc/ba1-message-caching.mjs`): steady state **$0.0753 → $0.0110 per round, 6.8x cheaper**; round 1 pays a 1.25x cache WRITE once. Off by default — it changes the wire format, so adopters opt in. Overridable per call via `generate(..., { cacheMessages })`. **Interaction:** a destructive `trim`/stash fold that rewrites the transcript PREFIX invalidates the cache (the prefix is the cache key), so a fold must keep the head stable or you re-pay the write premium every round for nothing.
  * @property {any} [thinking] - Opt-in extended thinking (BA-7), forwarded to `body.thinking` VERBATIM and unvalidated — e.g. `{ type: 'adaptive' }`, or `{ type: 'adaptive', display: 'summarized' }` to surface the reasoning (the default `display` is `'omitted'`). Deliberately opaque: this parameter has already broken once (`budget_tokens` was removed and now 400s on `claude-sonnet-5` / Opus 4.7+), and a library that reshapes it would need a release every time the API moves. Overridable per call via `generate(..., { thinking })`; pass `null` there to suppress an instance default.
+ *   WARNING: per-call options (incl. `thinking`) are forwarded to EVERY provider in a `FallbackProvider` chain — for a mixed-vendor
+ *   chain set `thinking` on each provider's CONSTRUCTOR instead of per-call.
  *
  *   **MEASURED CAVEAT — this option does not "turn thinking on".** On `claude-sonnet-5` adaptive thinking is ALREADY the default: sending this changed the observed thinking rate not at all (2/10 rounds with it vs 3/10 without — `poc/ba7-adaptive-default.mjs`). Its real use is pinning the mode and reaching `display`/`effort`. The change that mattered is that thinking blocks are now PRESERVED and replayed (see `Message.providerBlocks`), which happens whether or not you ever set this.
  * @property {boolean} [exposeErrorBody=false] - Attach the full upstream response to `err.body` on HTTP errors (off by default to avoid leaking unexpected fields through error logs; `err.message` still carries the API error).

package/src/provider-anthropic.js

@@ -30,6 +30,8 @@ function isLoopbackHost(hostname) {
  * @property {boolean} [cacheSystem=false] - Opt-in prompt caching: send the system prompt with a `cache_control` breakpoint so Anthropic caches it. Anthropic does NOT auto-cache, so without this its cache tiers are always 0. Overridable per call via `generate(..., { cacheSystem })`. NOTE: on its own this rarely helps a tool loop — Anthropic's minimum cacheable prefix is 1024–4096 tokens (model-dependent) and a typical system persona is a few hundred, so it silently never caches. The transcript is where a tool loop's tokens actually live — see `cacheMessages`.
  * @property {boolean} [cacheMessages=false] - Opt-in TRANSCRIPT caching (BA-1): roll a `cache_control` breakpoint onto the last content block of the last message, so Anthropic caches the whole conversation prefix and the loop stops re-buying it at full price every round. In a tool loop the transcript IS the tool results (file bodies from `shell_read`) and it always ENDS on one, which `_toAnthropicMessage` rebuilds from scratch — so no caller-side seam (`assemble` included) can reach it, and this has to live in the provider. Measured on `claude-sonnet-5` with a ~15k-token tool-result transcript (`poc/ba1-message-caching.mjs`): steady state **$0.0753 → $0.0110 per round, 6.8x cheaper**; round 1 pays a 1.25x cache WRITE once. Off by default — it changes the wire format, so adopters opt in. Overridable per call via `generate(..., { cacheMessages })`. **Interaction:** a destructive `trim`/stash fold that rewrites the transcript PREFIX invalidates the cache (the prefix is the cache key), so a fold must keep the head stable or you re-pay the write premium every round for nothing.
  * @property {any} [thinking] - Opt-in extended thinking (BA-7), forwarded to `body.thinking` VERBATIM and unvalidated — e.g. `{ type: 'adaptive' }`, or `{ type: 'adaptive', display: 'summarized' }` to surface the reasoning (the default `display` is `'omitted'`). Deliberately opaque: this parameter has already broken once (`budget_tokens` was removed and now 400s on `claude-sonnet-5` / Opus 4.7+), and a library that reshapes it would need a release every time the API moves. Overridable per call via `generate(..., { thinking })`; pass `null` there to suppress an instance default.
+ *   WARNING: per-call options (incl. `thinking`) are forwarded to EVERY provider in a `FallbackProvider` chain — for a mixed-vendor
+ *   chain set `thinking` on each provider's CONSTRUCTOR instead of per-call.
  *
  *   **MEASURED CAVEAT — this option does not "turn thinking on".** On `claude-sonnet-5` adaptive thinking is ALREADY the default: sending this changed the observed thinking rate not at all (2/10 rounds with it vs 3/10 without — `poc/ba7-adaptive-default.mjs`). Its real use is pinning the mode and reaching `display`/`effort`. The change that mattered is that thinking blocks are now PRESERVED and replayed (see `Message.providerBlocks`), which happens whether or not you ever set this.
  * @property {boolean} [exposeErrorBody=false] - Attach the full upstream response to `err.body` on HTTP errors (off by default to avoid leaking unexpected fields through error logs; `err.message` still carries the API error).

package/src/provider-fallback.d.ts

@@ -21,6 +21,11 @@ export type FallbackOptions = {
  * @property {(error: any, index: number) => boolean} [shouldFallback] - Return false to stop.
  * @property {(error: any, fromIndex: number, toIndex: number) => void} [onFallback] - Callback.
  */
+/**
+ * NOTE: per-call `generate()` options (incl. `thinking`, `toolChoice`) are forwarded UNCHANGED to EVERY provider in the chain. For a
+ * mixed-vendor chain (e.g. OpenAI-compat DeepSeek + Anthropic) set `thinking` on each provider's CONSTRUCTOR instead of per-call,
+ * or a value shaped for one vendor lands in another's `body.thinking` on fallback.
+ */
 export class FallbackProvider {
     /**
      * Provider that tries multiple providers in order.

package/src/provider-fallback.js

@@ -11,6 +11,11 @@
  * @property {(error: any, fromIndex: number, toIndex: number) => void} [onFallback] - Callback.
  */
 
+/**
+ * NOTE: per-call `generate()` options (incl. `thinking`, `toolChoice`) are forwarded UNCHANGED to EVERY provider in the chain. For a
+ * mixed-vendor chain (e.g. OpenAI-compat DeepSeek + Anthropic) set `thinking` on each provider's CONSTRUCTOR instead of per-call,
+ * or a value shaped for one vendor lands in another's `body.thinking` on fallback.
+ */
 class FallbackProvider {
   /**
    * Provider that tries multiple providers in order.

package/src/provider-ollama.d.ts

@@ -15,8 +15,8 @@ export type OllamaOptions = {
     deadlineMs?: number | undefined;
     /**
      * - BA-27 follow-up: when a tool call's string-shaped
-     * `function.arguments` JSON fails to parse, also attach the raw string (verbatim, capped at 500
-     * chars, `rawTruncated:true` when longer) to `malformedToolCall.rawArguments`. Off by default,
+     * `function.arguments` JSON fails to parse, also attach the FULL raw string (verbatim, uncapped)
+     * to `malformedToolCall.rawArguments` (model-generated; may be large or sensitive). Off by default,
      * independent of `exposeErrorBody`. See `src/provider-toolcalls.js`.
      */
     exposeMalformedArgs?: boolean | undefined;
@@ -32,8 +32,8 @@ export type OllamaOptions = {
  * @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.)
  * @property {boolean} [exposeMalformedArgs=false] - BA-27 follow-up: when a tool call's string-shaped
- *   `function.arguments` JSON fails to parse, also attach the raw string (verbatim, capped at 500
- *   chars, `rawTruncated:true` when longer) to `malformedToolCall.rawArguments`. Off by default,
+ *   `function.arguments` JSON fails to parse, also attach the FULL raw string (verbatim, uncapped)
+ *   to `malformedToolCall.rawArguments` (model-generated; may be large or sensitive). Off by default,
  *   independent of `exposeErrorBody`. See `src/provider-toolcalls.js`.
  */
 export class OllamaProvider {

package/src/provider-ollama.js

@@ -23,8 +23,8 @@ const OLLAMA_USAGE_KEYS = ['prompt_eval_count', 'eval_count'];
  * @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.)
  * @property {boolean} [exposeMalformedArgs=false] - BA-27 follow-up: when a tool call's string-shaped
- *   `function.arguments` JSON fails to parse, also attach the raw string (verbatim, capped at 500
- *   chars, `rawTruncated:true` when longer) to `malformedToolCall.rawArguments`. Off by default,
+ *   `function.arguments` JSON fails to parse, also attach the FULL raw string (verbatim, uncapped)
+ *   to `malformedToolCall.rawArguments` (model-generated; may be large or sensitive). Off by default,
  *   independent of `exposeErrorBody`. See `src/provider-toolcalls.js`.
  */
 

package/src/provider-openai.d.ts

@@ -40,12 +40,24 @@ export type OpenAIOptions = {
     legacyMaxTokens?: boolean | undefined;
     /**
      * - BA-27 follow-up: when a tool call's `function.arguments`
-     * JSON fails to parse, also attach the raw string (verbatim, capped at 500 chars, `rawTruncated:true`
-     * when longer) to `malformedToolCall.rawArguments`. Off by default, independent of `exposeErrorBody` —
-     * the raw blob is model-generated, not an upstream error body, but the same "don't leak an unbounded
-     * unexpected string into logs by default" reasoning applies. See `src/provider-toolcalls.js`.
+     * 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`.
      */
     exposeMalformedArgs?: boolean | 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
+     * OpenAI-compatible endpoints. Motivating case: DeepSeek's OpenAI-compatible API (`baseUrl`
+     * `https://api.deepseek.com`, model `deepseek-flash`) runs thinking mode by default and 400s "Thinking mode
+     * does not support this tool_choice" on a named or `'required'` `toolChoice`; `{ type: 'disabled' }` makes the
+     * forced tool call return 200. Deliberately opaque (no model sniffing, no free-form extra-body field) — a
+     * library that reshapes it would need a release every time a vendor moves. Unset ⇒ request body unchanged.
+     * Overridable per call via `generate(..., { thinking })`; pass `null` there to suppress an instance default.
+     * WARNING: per-call options (incl. `thinking`) are forwarded to EVERY provider in a `FallbackProvider` chain — for a mixed-vendor
+     * chain set `thinking` on each provider's CONSTRUCTOR instead of per-call.
+     */
+    thinking?: any;
 };
 /**
  * @typedef {object} OpenAIOptions
@@ -73,10 +85,19 @@ export type OpenAIOptions = {
  *   Set `true` for an OpenAI-compatible server that only understands the legacy key (e.g. some
  *   self-hosted / proxy endpoints). No model-name sniffing — the caller declares the dialect.
  * @property {boolean} [exposeMalformedArgs=false] - BA-27 follow-up: when a tool call's `function.arguments`
- *   JSON fails to parse, also attach the raw string (verbatim, capped at 500 chars, `rawTruncated:true`
- *   when longer) to `malformedToolCall.rawArguments`. Off by default, independent of `exposeErrorBody` —
- *   the raw blob is model-generated, not an upstream error body, but the same "don't leak an unbounded
- *   unexpected string into logs by default" reasoning applies. See `src/provider-toolcalls.js`.
+ *   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 {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`
+ *   `https://api.deepseek.com`, model `deepseek-flash`) runs thinking mode by default and 400s "Thinking mode
+ *   does not support this tool_choice" on a named or `'required'` `toolChoice`; `{ type: 'disabled' }` makes the
+ *   forced tool call return 200. Deliberately opaque (no model sniffing, no free-form extra-body field) — a
+ *   library that reshapes it would need a release every time a vendor moves. Unset ⇒ request body unchanged.
+ *   Overridable per call via `generate(..., { thinking })`; pass `null` there to suppress an instance default.
+ *   WARNING: per-call options (incl. `thinking`) are forwarded to EVERY provider in a `FallbackProvider` chain — for a mixed-vendor
+ *   chain set `thinking` on each provider's CONSTRUCTOR instead of per-call.
  */
 export class OpenAIProvider {
     /**
@@ -95,11 +116,12 @@ export class OpenAIProvider {
     deadlineMs: number | undefined;
     legacyMaxTokens: boolean;
     exposeMalformedArgs: boolean;
+    thinking: any;
     /**
      * 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).
+     * @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)).
      * @returns {Promise<GenerateResult>}
      * @throws {Error} `[OpenAIProvider] ...` — on HTTP errors (4xx/5xx) or invalid JSON response.
      */

package/src/provider-openai.js

@@ -73,10 +73,19 @@ function isLoopbackHost(hostname) {
  *   Set `true` for an OpenAI-compatible server that only understands the legacy key (e.g. some
  *   self-hosted / proxy endpoints). No model-name sniffing — the caller declares the dialect.
  * @property {boolean} [exposeMalformedArgs=false] - BA-27 follow-up: when a tool call's `function.arguments`
- *   JSON fails to parse, also attach the raw string (verbatim, capped at 500 chars, `rawTruncated:true`
- *   when longer) to `malformedToolCall.rawArguments`. Off by default, independent of `exposeErrorBody` —
- *   the raw blob is model-generated, not an upstream error body, but the same "don't leak an unbounded
- *   unexpected string into logs by default" reasoning applies. See `src/provider-toolcalls.js`.
+ *   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 {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`
+ *   `https://api.deepseek.com`, model `deepseek-flash`) runs thinking mode by default and 400s "Thinking mode
+ *   does not support this tool_choice" on a named or `'required'` `toolChoice`; `{ type: 'disabled' }` makes the
+ *   forced tool call return 200. Deliberately opaque (no model sniffing, no free-form extra-body field) — a
+ *   library that reshapes it would need a release every time a vendor moves. Unset ⇒ request body unchanged.
+ *   Overridable per call via `generate(..., { thinking })`; pass `null` there to suppress an instance default.
+ *   WARNING: per-call options (incl. `thinking`) are forwarded to EVERY provider in a `FallbackProvider` chain — for a mixed-vendor
+ *   chain set `thinking` on each provider's CONSTRUCTOR instead of per-call.
  */
 
 class OpenAIProvider {
@@ -100,13 +109,16 @@ class OpenAIProvider {
     this.legacyMaxTokens = options.legacyMaxTokens === true;
     // BA-27 follow-up: expose the raw malformed tool-call arguments string. Off by default.
     this.exposeMalformedArgs = options.exposeMalformedArgs === true;
+    // 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;
   }
 
   /**
    * 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).
+   * @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)).
    * @returns {Promise<GenerateResult>}
    * @throws {Error} `[OpenAIProvider] ...` — on HTTP errors (4xx/5xx) or invalid JSON response.
    */
@@ -121,6 +133,11 @@ class OpenAIProvider {
       ...(options.temperature != null && { temperature: options.temperature }),
       ...(options.maxTokens && { [maxTokensKey]: options.maxTokens }),
     };
+    // BA-7 (b) / fwdloop: DeepSeek-style compat endpoints default to thinking mode and 400 on a forced
+    // tool_choice; the caller pins it (e.g. `{type:'disabled'}`). Set on `body` before the temperature
+    // fallback so the retry (which only deletes `temperature`) keeps it. Per-call `null` suppresses.
+    const thinking = options.thinking !== undefined ? options.thinking : this.thinking;
+    if (thinking) body.thinking = thinking;
     // Ask 4 (fwdloop): validate the toolChoice SHAPE unconditionally so an invalid value ALWAYS throws
     // (a silently-dropped force is the exact confusion this surfaces) — even when tools happen to be
     // empty. Attach it only when tools are present: OpenAI 400s on a tool_choice with no tools, so a

package/src/provider-toolcalls.d.ts

@@ -1,4 +1,5 @@
 export type ToolCall = import("../types").ToolCall;
+/** @typedef {import('../types').ToolCall} ToolCall */
 /**
  * BA-27 — parse a round's raw tool calls into the neutral {@link ToolCall} shape WITHOUT throwing on
  * malformed arguments.
@@ -16,17 +17,18 @@ export type ToolCall = import("../types").ToolCall;
  * running half a decomposed intent, so one bad call voids the whole round's calls.
  *
  * `opts.exposeMalformedArgs` (default off, mirrors `exposeErrorBody`): when on, the marker also
- * carries `rawArguments` — the raw `function.arguments` VERBATIM, capped at 500 chars (`rawTruncated:
- * true` added only when it was longer). Non-string raw arguments (e.g. Ollama's well-formed object
+ * carries `rawArguments` — the FULL raw `function.arguments` string VERBATIM, uncapped (malformed JSON
+ * usually breaks at the END — a stray trailing brace, a truncation — so a head-only cap hid exactly the
+ * broken part; `rawTruncated` is never set). Non-string raw arguments (e.g. Ollama's well-formed object
  * case reaching this catch some other way) are never exposed — only a string is a model-generated
  * blob worth surfacing for debugging; an object was already structurally valid before whatever else
- * threw. Off by default for the same reason as `exposeErrorBody`: an arbitrary model-generated string
- * landing in a log/audit row unbounded is its own leak surface.
+ * threw. Still opt-in and off by default: the raw text is model-generated and may be large or carry
+ * sensitive content into logs/audit rows, so the caller must choose to accept that.
  *
  * @param {any[]} rawToolCalls - provider-native tool-call entries (may be undefined/empty)
  * @param {(tc: any) => ToolCall} mapOne - maps one raw entry to a ToolCall; MAY throw on bad arguments
  * @param {{ exposeMalformedArgs?: boolean }} [opts]
- * @returns {{ toolCalls: ToolCall[], malformedToolCall?: { name: string|undefined, error: string, rawArguments?: string, rawTruncated?: true } }}
+ * @returns {{ toolCalls: ToolCall[], malformedToolCall?: { name: string|undefined, error: string, rawArguments?: string } }}
  */
 export function parseToolCalls(rawToolCalls: any[], mapOne: (tc: any) => ToolCall, opts?: {
     exposeMalformedArgs?: boolean;
@@ -36,6 +38,5 @@ export function parseToolCalls(rawToolCalls: any[], mapOne: (tc: any) => ToolCal
         name: string | undefined;
         error: string;
         rawArguments?: string;
-        rawTruncated?: true;
     };
 };

package/src/provider-toolcalls.js

@@ -2,11 +2,6 @@
 
 /** @typedef {import('../types').ToolCall} ToolCall */
 
-// Raw-arguments exposure cap. Matches the sibling opt-in error-body exposure pattern
-// (`exposeErrorBody`) elsewhere in the providers: off by default, and even when on, bounded —
-// an arbitrarily long model-generated string reaching a log/receipt unbounded is its own risk.
-const RAW_ARGUMENTS_MAX_CHARS = 500;
-
 /**
  * BA-27 — parse a round's raw tool calls into the neutral {@link ToolCall} shape WITHOUT throwing on
  * malformed arguments.
@@ -24,17 +19,18 @@ const RAW_ARGUMENTS_MAX_CHARS = 500;
  * running half a decomposed intent, so one bad call voids the whole round's calls.
  *
  * `opts.exposeMalformedArgs` (default off, mirrors `exposeErrorBody`): when on, the marker also
- * carries `rawArguments` — the raw `function.arguments` VERBATIM, capped at 500 chars (`rawTruncated:
- * true` added only when it was longer). Non-string raw arguments (e.g. Ollama's well-formed object
+ * carries `rawArguments` — the FULL raw `function.arguments` string VERBATIM, uncapped (malformed JSON
+ * usually breaks at the END — a stray trailing brace, a truncation — so a head-only cap hid exactly the
+ * broken part; `rawTruncated` is never set). Non-string raw arguments (e.g. Ollama's well-formed object
  * case reaching this catch some other way) are never exposed — only a string is a model-generated
  * blob worth surfacing for debugging; an object was already structurally valid before whatever else
- * threw. Off by default for the same reason as `exposeErrorBody`: an arbitrary model-generated string
- * landing in a log/audit row unbounded is its own leak surface.
+ * threw. Still opt-in and off by default: the raw text is model-generated and may be large or carry
+ * sensitive content into logs/audit rows, so the caller must choose to accept that.
  *
  * @param {any[]} rawToolCalls - provider-native tool-call entries (may be undefined/empty)
  * @param {(tc: any) => ToolCall} mapOne - maps one raw entry to a ToolCall; MAY throw on bad arguments
  * @param {{ exposeMalformedArgs?: boolean }} [opts]
- * @returns {{ toolCalls: ToolCall[], malformedToolCall?: { name: string|undefined, error: string, rawArguments?: string, rawTruncated?: true } }}
+ * @returns {{ toolCalls: ToolCall[], malformedToolCall?: { name: string|undefined, error: string, rawArguments?: string } }}
  */
 function parseToolCalls(rawToolCalls, mapOne, opts = {}) {
   const raw = rawToolCalls || [];
@@ -44,7 +40,7 @@ function parseToolCalls(rawToolCalls, mapOne, opts = {}) {
     try {
       toolCalls.push(mapOne(tc));
     } catch (e) {
-      /** @type {{ name: string|undefined, error: string, rawArguments?: string, rawTruncated?: true }} */
+      /** @type {{ name: string|undefined, error: string, rawArguments?: string }} */
       const malformedToolCall = {
         name: tc && tc.function ? tc.function.name : undefined,
         error: e instanceof Error ? e.message : String(e),
@@ -52,8 +48,7 @@ function parseToolCalls(rawToolCalls, mapOne, opts = {}) {
       if (opts.exposeMalformedArgs) {
         const rawArgs = tc && tc.function ? tc.function.arguments : undefined;
         if (typeof rawArgs === 'string') {
-          malformedToolCall.rawArguments = rawArgs.slice(0, RAW_ARGUMENTS_MAX_CHARS);
-          if (rawArgs.length > RAW_ARGUMENTS_MAX_CHARS) malformedToolCall.rawTruncated = true;
+          malformedToolCall.rawArguments = rawArgs;
         }
       }
       return { toolCalls: [], malformedToolCall };

package/types/index.d.ts

@@ -143,12 +143,15 @@ export interface GenerateResult {
    * repaired. Absent on a clean round. OpenAI-compatible + Ollama string-arguments only; Anthropic
    * arrives pre-parsed and cannot hit this.
    *
-   * `rawArguments`/`rawTruncated` (BA-27 follow-up) are present only when the provider was
+   * `rawArguments` (BA-27 follow-up) is present only when the provider was
    * constructed with `exposeMalformedArgs: true` (default off, mirrors `exposeErrorBody`) AND the
-   * raw `function.arguments` was a string: the raw value verbatim, capped at 500 chars, with
-   * `rawTruncated: true` added only when it was longer.
+   * raw `function.arguments` was a string: the FULL raw value verbatim, uncapped (model-generated; may be
+   * large or sensitive).
    */
-  malformedToolCall?: { name: string | undefined; error: string; rawArguments?: string; rawTruncated?: true };
+  malformedToolCall?: { name: string | undefined; error: string; rawArguments?: string;
+    /** @deprecated never set since 0.50.0 (rawArguments is now uncapped) */
+    rawTruncated?: true;
+  };
   /**
    * BA-7 — provider-native content blocks the normalized `{text, toolCalls}` shape cannot express
    * (Anthropic `thinking` / `redacted_thinking`), captured opaquely so the Loop can put them on the