bare-agent 0.49.0 → 0.50.0

package/bareagent.context.md

@@ -976,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.49.0",
+  "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-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,10 +40,9 @@ 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;
     /**
@@ -86,10 +85,9 @@ 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`

package/src/provider-openai.js

@@ -73,10 +73,9 @@ 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`

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