bare-agent 0.41.1 → 0.43.0

package/bareagent.context.md

@@ -1,7 +1,7 @@
 # bareagent — Integration Guide
 
 > For AI assistants and developers wiring bareagent into a project.
-> v0.41.1 | Node.js >= 18 | zero required deps (`bareguard >=0.9.0 <0.16.0` optional peer for governance) | Apache 2.0
+> v0.43.0 | Node.js >= 18 | zero required deps (`bareguard >=0.9.0 <0.16.0` optional peer for governance) | Apache 2.0
 >
 > Full human guide with composition examples, design philosophy, and recipes: [Usage Guide](docs/archive/usage-guide.md)
 

package/package.json

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

package/src/errors.d.ts

@@ -21,6 +21,10 @@ export type ProviderErrorOptions = {
      * - Raw response body.
      */
     body?: any;
+    /**
+     * - Override the status-derived retryability (for transport-class failures with no status).
+     */
+    retryable?: boolean | undefined;
     /**
      * - Arbitrary structured context.
      */
@@ -50,6 +54,7 @@ export type HaltErrorOptions = {
  * @typedef {object} ProviderErrorOptions
  * @property {number} [status] - HTTP status from the provider.
  * @property {any} [body] - Raw response body.
+ * @property {boolean} [retryable] - Override the status-derived retryability (for transport-class failures with no status).
  * @property {Record<string, any>} [context] - Arbitrary structured context.
  */
 /**
@@ -73,7 +78,7 @@ export class ProviderError extends BareAgentError {
      * @param {string} message
      * @param {ProviderErrorOptions} [options]
      */
-    constructor(message: string, { status, body, context }?: ProviderErrorOptions);
+    constructor(message: string, { status, body, retryable, context }?: ProviderErrorOptions);
     status: number | undefined;
     body: any;
 }

package/src/errors.js

@@ -11,6 +11,7 @@
  * @typedef {object} ProviderErrorOptions
  * @property {number} [status] - HTTP status from the provider.
  * @property {any} [body] - Raw response body.
+ * @property {boolean} [retryable] - Override the status-derived retryability (for transport-class failures with no status).
  * @property {Record<string, any>} [context] - Arbitrary structured context.
  */
 
@@ -40,9 +41,11 @@ class ProviderError extends BareAgentError {
    * @param {string} message
    * @param {ProviderErrorOptions} [options]
    */
-  constructor(message, { status, body, context = {} } = {}) {
-    const retryable = status === 429 || (status != null && status >= 500 && status <= 504);
-    super(message, { code: 'PROVIDER_ERROR', retryable, context });
+  constructor(message, { status, body, retryable, context = {} } = {}) {
+    // A transport-class failure (BA-25: socket aborted / closed before the body completed) carries no
+    // HTTP status, so the status-derived default can't classify it — an explicit `retryable` overrides.
+    const derived = status === 429 || (status != null && status >= 500 && status <= 504);
+    super(message, { code: 'PROVIDER_ERROR', retryable: retryable != null ? retryable : derived, context });
     this.status = status;
     this.body = body;
   }

package/src/loop.d.ts

@@ -161,7 +161,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, msgs: Message[], metrics: RunMetrics, 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?: {name: string|undefined, error: string}, 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
@@ -196,10 +196,16 @@ export class Loop {
         cost: number;
         error: string | null;
         stopReason: string | null;
+        model: string | null;
         msgs: Message[];
         metrics: RunMetrics;
+        malformedToolCall?: {
+            name: string | undefined;
+            error: string;
+        };
         temperatureDropped?: boolean;
     }>;
+    _warnedTruncated: boolean | undefined;
     /**
      * Health check — validates provider, store, and tools without throwing.
      * @param {ToolDef[]} [tools=[]] - Tool definitions to validate.
@@ -226,7 +232,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, msgs: Message[], metrics: RunMetrics, 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?: {name: string|undefined, error: string}, temperatureDropped?: boolean}>}
      */
     chat(text: string, tools?: ToolDef[], options?: Record<string, any>): Promise<{
         text: string;
@@ -235,8 +241,13 @@ export class Loop {
         cost: number;
         error: string | null;
         stopReason: string | null;
+        model: string | null;
         msgs: Message[];
         metrics: RunMetrics;
+        malformedToolCall?: {
+            name: string | undefined;
+            error: string;
+        };
         temperatureDropped?: boolean;
     }>;
     /**

package/src/loop.js

@@ -449,7 +449,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, msgs: Message[], metrics: RunMetrics, 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?: {name: string|undefined, error: string}, 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
@@ -543,6 +543,18 @@ class Loop {
     // says which kind). Stays null until the first round completes, and across a provider error / a
     // pre-round stop() it holds the last round's value (or null if none ran).
     let lastStopReason = null;
+    // ASK 3 / fwdloop F3: the resolved model id of the most recent completed round (from the provider
+    // RESPONSE, not the provider object — a wrapped/fallback provider can lose `.model`). Surfaced on
+    // every return so a caller reads which model produced the result without the onLlmResult side channel.
+    let lastModel = null;
+    // BA-27: the most recent round's malformed-tool-call marker, or null. A model can emit a tool call
+    // whose arguments are syntactically-broken JSON; the provider returns NO usable tool calls plus this
+    // marker (rather than throwing and losing the billed round). Surfaced on the run's return like
+    // lastStopReason, so a Loop caller (e.g. the bareloop adopter — which reads run(), not generate())
+    // can tell "the model sent a broken call" apart from "the model sent no call at all" — both present
+    // as `toolCalls: []`. Reset each completed round; a malformed round always terminates the run (no
+    // usable call to continue with), so it can only be non-null on the round that returns.
+    let lastMalformedToolCall = null;
     // BA-10: sticky across rounds — true if ANY round's `temperature` was dropped by the model (400,
     // unsupported/deprecated) and retried without it. Surfaced on the result so an upstream receipt
     // (recurse's refineLeaf) can report the EFFECTIVE temperature rather than the ignored request.
@@ -579,7 +591,7 @@ class Loop {
         sealDanglingToolCalls(msgs, `[halted:${stuckTag}]`);
         this._reportError('stuck', new Error(`tool "${tc.name}" failed ${identicalErrors} times with identical arguments`), { rule: stuckTag, attempts: identicalErrors });
         this._safeEmit({ type: 'loop:done', data: { text: lastText, stuck: true, rule: stuckTag, cost: totalCost } });
-        return { text: lastText, toolCalls: [], usage: lastUsage, cost: totalCost, error: stuckTag, stopReason: lastStopReason, msgs, metrics: finalizeMetrics(), ...(temperatureDropped && { temperatureDropped: true }) };
+        return { text: lastText, toolCalls: [], usage: lastUsage, cost: totalCost, error: stuckTag, stopReason: lastStopReason, model: lastModel, msgs, metrics: finalizeMetrics(), ...(lastMalformedToolCall && { malformedToolCall: lastMalformedToolCall }), ...(temperatureDropped && { temperatureDropped: true }) };
       }
       return null;
     };
@@ -826,7 +838,7 @@ class Loop {
         this._reportError('provider', err, { round });
         if (this.throwOnError) throw err;
         // BA-5: a mid-run provider failure must not erase the work of the rounds that succeeded.
-        return { text: lastText, toolCalls: [], usage: lastUsage, cost: totalCost, error: err.message, stopReason: lastStopReason, msgs, metrics: finalizeMetrics(), ...(temperatureDropped && { temperatureDropped: true }) };
+        return { text: lastText, toolCalls: [], usage: lastUsage, cost: totalCost, error: err.message, stopReason: lastStopReason, model: lastModel, msgs, metrics: finalizeMetrics(), ...(lastMalformedToolCall && { malformedToolCall: lastMalformedToolCall }), ...(temperatureDropped && { temperatureDropped: true }) };
       }
 
       lastUsage = result.usage || lastUsage;
@@ -838,6 +850,10 @@ class Loop {
       // BA-13: capture this round's neutral stop reason for surfacing on the run's return (every exit
       // path reads lastStopReason). Non-string / absent ⇒ null (the provider's pre-BA-6 degrade).
       lastStopReason = typeof result.stopReason === 'string' ? result.stopReason : null;
+      if (typeof result.model === 'string' && result.model) lastModel = result.model;
+      // BA-27: capture (and reset) this round's malformed-tool-call marker for surfacing on the return.
+      lastMalformedToolCall = (result.malformedToolCall && typeof result.malformedToolCall === 'object')
+        ? result.malformedToolCall : null;
       if (result.temperatureDropped) temperatureDropped = true;
       // Publish the latest measured usage to ctx (non-enumerable, fail-open) so a transcript-bound seam —
       // e.g. F2 stash auto-compaction — can read EXACT provider-counted `inputTokens` to gauge context
@@ -897,6 +913,10 @@ class Loop {
             // a silent guess stamped as if it were a real rate (BA-21). `pricing` keeps its two values.
             pricing: roundCost === null ? 'unpriced' : 'priced',
             rateSource, // 'provider'|'caller'|'tier'|'default'|null
+            // ASK 3 (fwdloop F4): carry the round's neutral stop reason on the metering payload so an
+            // audit row records a `max_tokens`/`refusal`/etc. terminal WITHOUT awaiting the run result —
+            // a cut reasoning round (empty text, no tool call) is otherwise indistinguishable from a refusal.
+            stopReason: typeof result.stopReason === 'string' ? result.stopReason : null,
             durationMs: Date.now() - llmStartedAt,
             ctx,
             kind: 'turn',
@@ -918,7 +938,7 @@ class Loop {
         sealDanglingToolCalls(msgs, `[halted:${session.error}]`);
         this._reportError('session', new Error(`provider session terminated: ${session.error}`), { rule: session.error, sessionTurns: session.turns ?? null });
         this._safeEmit({ type: 'loop:done', data: { text: lastText, rule: session.error, sessionTurns: session.turns ?? null, cost: totalCost } });
-        return { text: lastText, toolCalls: [], usage: lastUsage, cost: totalCost, error: session.error, stopReason: lastStopReason, msgs, metrics: finalizeMetrics(), ...(temperatureDropped && { temperatureDropped: true }) };
+        return { text: lastText, toolCalls: [], usage: lastUsage, cost: totalCost, error: session.error, stopReason: lastStopReason, model: lastModel, msgs, metrics: finalizeMetrics(), ...(lastMalformedToolCall && { malformedToolCall: lastMalformedToolCall }), ...(temperatureDropped && { temperatureDropped: true }) };
       }
 
       // BA-13: classify this round's terminal signal against the neutral stop-reason vocabulary. BA-6
@@ -964,6 +984,18 @@ class Loop {
         // `error:null` + `stopReason:'refusal'` would re-breed BA-6 for these legs.
         const errorTag = terminal === 'truncated' ? 'truncated:max_tokens' : terminal;
         const dropped = (result.toolCalls || []).length;
+        // ASK 3 (fwdloop F4): a `max_tokens`/`length` round has empty text and no tool call, so it reads
+        // exactly like a refusal — fwdloop misdiagnosed a cut-mid-think drafter for an hour. Make it LOUD:
+        // a dedicated `loop:truncated` event AND one console.warn per Loop (mirrors the temperature-drop /
+        // unpriced-round precedent). The awaited result already error-tags it (BA-13); this surfaces it
+        // to a stream consumer and to the console without reading the return value.
+        if (terminal === 'truncated') {
+          this._safeEmit({ type: 'loop:truncated', data: { round, stopReason: lastStopReason, droppedToolCalls: dropped, outputTokens: lastUsage && lastUsage.outputTokens } });
+          if (!this._warnedTruncated) {
+            this._warnedTruncated = true;
+            console.warn(`[Loop] a round stopped at the output cap (stopReason='${lastStopReason}') with no completed tool call — the response was cut off (often reasoning billed as output). Raise maxTokens or lower reasoning effort. Further truncations from this Loop are silent.`);
+          }
+        }
         // Seal the transcript with the partial text only. Deliberately NOT the tool_calls: pushing a call
         // we refuse to execute would orphan it (a tool_call with no tool_result is a wire-invalid
         // transcript on Anthropic). Empty text pushes nothing — a bare empty assistant turn is also invalid.
@@ -971,7 +1003,7 @@ class Loop {
           msgs.push({ role: 'assistant', content: result.text });
         }
         this._safeEmit({ type: 'loop:done', data: { text: lastText, ...(terminal === 'truncated' && { truncated: true }), terminal, stopReason: lastStopReason, droppedToolCalls: dropped, cost: totalCost } });
-        return { text: lastText, toolCalls: [], usage: lastUsage, cost: totalCost, error: errorTag, stopReason: lastStopReason, msgs, metrics: finalizeMetrics(), ...(temperatureDropped && { temperatureDropped: true }) };
+        return { text: lastText, toolCalls: [], usage: lastUsage, cost: totalCost, error: errorTag, stopReason: lastStopReason, model: lastModel, msgs, metrics: finalizeMetrics(), ...(lastMalformedToolCall && { malformedToolCall: lastMalformedToolCall }), ...(temperatureDropped && { temperatureDropped: true }) };
       }
 
       // No tool calls — LLM gave a final text response
@@ -991,7 +1023,7 @@ class Loop {
           try { await flush(msgs, ctx); }
           catch (err) { if (err instanceof HaltError) throw err; this._reportError('trim-flush', err, { round }); }
         }
-        return { text: result.text, toolCalls: [], usage: lastUsage, cost: totalCost, error: null, stopReason: lastStopReason, msgs, metrics: finalizeMetrics(), ...(temperatureDropped && { temperatureDropped: true }) };
+        return { text: result.text, toolCalls: [], usage: lastUsage, cost: totalCost, error: null, stopReason: lastStopReason, model: lastModel, msgs, metrics: finalizeMetrics(), ...(lastMalformedToolCall && { malformedToolCall: lastMalformedToolCall }), ...(temperatureDropped && { temperatureDropped: true }) };
       }
 
       // Execute tool calls
@@ -1100,7 +1132,7 @@ class Loop {
               sealDanglingToolCalls(msgs, `[halted:${denyTag}]`);
               this._reportError('denied', new Error(`policy denied ${consecutiveDenials} consecutive tool calls (${tc.name})`), { rule: denyTag, denials: consecutiveDenials });
               this._safeEmit({ type: 'loop:done', data: { text: lastText, denied: true, rule: denyTag, cost: totalCost } });
-              return { text: lastText, toolCalls: [], usage: lastUsage, cost: totalCost, error: denyTag, stopReason: lastStopReason, msgs, metrics: finalizeMetrics(), ...(temperatureDropped && { temperatureDropped: true }) };
+              return { text: lastText, toolCalls: [], usage: lastUsage, cost: totalCost, error: denyTag, stopReason: lastStopReason, model: lastModel, msgs, metrics: finalizeMetrics(), ...(lastMalformedToolCall && { malformedToolCall: lastMalformedToolCall }), ...(temperatureDropped && { temperatureDropped: true }) };
             }
             continue;
           }
@@ -1174,7 +1206,7 @@ class Loop {
         // BA-5: the rule tag survives on `error`; so does the work. A halt is how a bounded attempt is
         // SUPPOSED to end — the caller reads `error` to know it was bounded and `text` to learn from it.
         this._safeEmit({ type: 'loop:done', data: { text: lastText, halted: true, rule, cost: totalCost } });
-        return { text: lastText, toolCalls: [], usage: lastUsage, cost: totalCost, error: `halt:${rule}`, stopReason: lastStopReason, msgs, metrics: finalizeMetrics(), ...(temperatureDropped && { temperatureDropped: true }) };
+        return { text: lastText, toolCalls: [], usage: lastUsage, cost: totalCost, error: `halt:${rule}`, stopReason: lastStopReason, model: lastModel, msgs, metrics: finalizeMetrics(), ...(lastMalformedToolCall && { malformedToolCall: lastMalformedToolCall }), ...(temperatureDropped && { temperatureDropped: true }) };
       }
       throw err;
     }
@@ -1204,20 +1236,20 @@ class Loop {
             const rule = err.rule || 'unknown';
             this._reportError('halt', err, { rule, reason: err.decision?.reason ?? null });
             this._safeEmit({ type: 'loop:done', data: { text: lastText, halted: true, rule, cost: totalCost } });
-            return { text: lastText, toolCalls: [], usage: lastUsage, cost: totalCost, error: `halt:${rule}`, stopReason: lastStopReason, msgs, metrics: finalizeMetrics(), ...(temperatureDropped && { temperatureDropped: true }) };
+            return { text: lastText, toolCalls: [], usage: lastUsage, cost: totalCost, error: `halt:${rule}`, stopReason: lastStopReason, model: lastModel, msgs, metrics: finalizeMetrics(), ...(lastMalformedToolCall && { malformedToolCall: lastMalformedToolCall }), ...(temperatureDropped && { temperatureDropped: true }) };
           }
           this._reportError('trim-flush', err, { phase: 'stop' });
         }
       }
       this._safeEmit({ type: 'loop:done', data: { text: lastText, stopped: true, cost: totalCost } });
-      return { text: lastText, toolCalls: [], usage: lastUsage, cost: totalCost, error: null, stopReason: lastStopReason, msgs, metrics: finalizeMetrics(), ...(temperatureDropped && { temperatureDropped: true }) };
+      return { text: lastText, toolCalls: [], usage: lastUsage, cost: totalCost, error: null, stopReason: lastStopReason, model: lastModel, msgs, metrics: finalizeMetrics(), ...(lastMalformedToolCall && { malformedToolCall: lastMalformedToolCall }), ...(temperatureDropped && { temperatureDropped: true }) };
     }
 
     // Hard safety limit — should never fire under normal usage; bareguard's
     // limits.maxTurns (or the LLM's natural completion) ends the loop first.
     const warning = `[Loop] hit internal safety limit of ${HARD_ROUND_LIMIT} rounds. Wire bareguard for proper governance — see bare-agent/bareguard.`;
     this._safeEmit({ type: 'loop:done', data: { text: lastText, warning, cost: totalCost } });
-    return { text: lastText, toolCalls: [], usage: lastUsage, cost: totalCost, error: warning, stopReason: lastStopReason, msgs, metrics: finalizeMetrics(), ...(temperatureDropped && { temperatureDropped: true }) };
+    return { text: lastText, toolCalls: [], usage: lastUsage, cost: totalCost, error: warning, stopReason: lastStopReason, model: lastModel, msgs, metrics: finalizeMetrics(), ...(lastMalformedToolCall && { malformedToolCall: lastMalformedToolCall }), ...(temperatureDropped && { temperatureDropped: true }) };
   }
 
   /**
@@ -1290,7 +1322,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, msgs: Message[], metrics: RunMetrics, 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?: {name: string|undefined, error: string}, temperatureDropped?: boolean}>}
    */
   async chat(text, tools = [], options = {}) {
     this._history.push({ role: 'user', content: text });

package/src/provider-anthropic.js

@@ -5,7 +5,7 @@ const http = require('http');
 const { ProviderError } = require('./errors');
 const { requestWithTemperatureFallback } = require('./provider-temperature');
 const { normalizeStopReason } = require('./provider-stop-reason');
-const { resolveTimeoutMs, applyRequestBounds } = require('./provider-http');
+const { resolveTimeoutMs, applyRequestBounds, guardResponseSettles } = require('./provider-http');
 const { hasUsageSignal } = require('./provider-usage');
 
 // BA-24: the raw Anthropic usage field names. Presence of any (even value 0) means the API reported a
@@ -318,8 +318,11 @@ class AnthropicProvider {
         },
       }, (res) => {
         let chunks = '';
+        // BA-25: reject (retryable) if the body is cut after headers, so generate() always settles.
+        const { markEnded } = guardResponseSettles(res, reject, 'AnthropicProvider');
         res.on('data', d => chunks += d);
         res.on('end', () => {
+          markEnded();
           try {
             const parsed = JSON.parse(chunks);
             if ((res.statusCode ?? 0) >= 400) {

package/src/provider-gemini.js

@@ -5,7 +5,7 @@ const http = require('http');
 const { ProviderError } = require('./errors');
 const { requestWithTemperatureFallback } = require('./provider-temperature');
 const { normalizeStopReason } = require('./provider-stop-reason');
-const { resolveTimeoutMs, applyRequestBounds } = require('./provider-http');
+const { resolveTimeoutMs, applyRequestBounds, guardResponseSettles } = require('./provider-http');
 const { hasUsageSignal } = require('./provider-usage');
 
 // BA-24: raw Gemini usageMetadata fields. Any present (even 0) ⇒ a usage signal; none ⇒ null.
@@ -215,8 +215,11 @@ class GeminiProvider {
         },
       }, (res) => {
         let chunks = '';
+        // BA-25: reject (retryable) if the body is cut after headers, so generate() always settles.
+        const { markEnded } = guardResponseSettles(res, reject, 'GeminiProvider');
         res.on('data', d => (chunks += d));
         res.on('end', () => {
+          markEnded();
           try {
             const parsed = JSON.parse(chunks);
             if ((res.statusCode ?? 0) >= 400) {

package/src/provider-http.d.ts

@@ -78,3 +78,28 @@ export function applyRequestBounds(req: import("http").ClientRequest, bounds: {
     timeoutMs?: number;
     deadlineMs?: number;
 }, providerName: string): void;
+/**
+ * BA-25 — guarantee the response promise SETTLES when the body is cut after headers. The provider
+ * `_request` handlers wired only `res 'data'` + `res 'end'` (and `req 'error'`), so a socket the
+ * server aborts or closes AFTER sending headers but BEFORE 'end' fired neither resolved nor rejected:
+ * 'end' never came, and the BA-18 idle timer can't rescue it because the socket is already dead (no
+ * further activity to time out against). The process then drains with an unsettled top-level await.
+ *
+ * Three terminal response events are the miss: `res 'aborted'` (peer reset mid-body), `res 'error'`
+ * (stream error), and `res 'close'` WITHOUT a prior 'end' (clean-looking FIN before the body
+ * completed). Each rejects with a RETRYABLE transport-class `ProviderError` (no HTTP status → the
+ * status-derived retryability can't classify it, so `retryable:true` is explicit) so a wired
+ * `Retry`/one-retry ladder (which keys on `err.retryable === true`) sees it instead of hanging.
+ *
+ * Returns `markEnded` — the 'end' handler MUST call it (before its own resolve/reject) so a normal
+ * 'close' firing after 'end' does not spuriously reject an already-settled promise. Extra rejects
+ * after settle are no-ops (Promise semantics), so ordering is safe either way; `markEnded` only
+ * suppresses the benign post-'end' 'close'.
+ * @param {import('http').IncomingMessage} res
+ * @param {(err: Error) => void} reject - the _request Promise's reject
+ * @param {string} providerName - for the error message (e.g. 'OpenAIProvider')
+ * @returns {{ markEnded: () => void }}
+ */
+export function guardResponseSettles(res: import("http").IncomingMessage, reject: (err: Error) => void, providerName: string): {
+    markEnded: () => void;
+};

package/src/provider-http.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { TimeoutError, ValidationError } = require('./errors');
+const { TimeoutError, ValidationError, ProviderError } = require('./errors');
 
 /**
  * BA-18 — shared request-timeout helper for the http(s)-based providers (Anthropic, OpenAI,
@@ -123,4 +123,38 @@ function applyRequestBounds(req, bounds, providerName) {
   applyRequestDeadline(req, (bounds && bounds.deadlineMs) || 0, providerName);
 }
 
-module.exports = { DEFAULT_TIMEOUT_MS, resolveTimeoutMs, applyRequestTimeout, applyRequestDeadline, applyRequestBounds };
+/**
+ * BA-25 — guarantee the response promise SETTLES when the body is cut after headers. The provider
+ * `_request` handlers wired only `res 'data'` + `res 'end'` (and `req 'error'`), so a socket the
+ * server aborts or closes AFTER sending headers but BEFORE 'end' fired neither resolved nor rejected:
+ * 'end' never came, and the BA-18 idle timer can't rescue it because the socket is already dead (no
+ * further activity to time out against). The process then drains with an unsettled top-level await.
+ *
+ * Three terminal response events are the miss: `res 'aborted'` (peer reset mid-body), `res 'error'`
+ * (stream error), and `res 'close'` WITHOUT a prior 'end' (clean-looking FIN before the body
+ * completed). Each rejects with a RETRYABLE transport-class `ProviderError` (no HTTP status → the
+ * status-derived retryability can't classify it, so `retryable:true` is explicit) so a wired
+ * `Retry`/one-retry ladder (which keys on `err.retryable === true`) sees it instead of hanging.
+ *
+ * Returns `markEnded` — the 'end' handler MUST call it (before its own resolve/reject) so a normal
+ * 'close' firing after 'end' does not spuriously reject an already-settled promise. Extra rejects
+ * after settle are no-ops (Promise semantics), so ordering is safe either way; `markEnded` only
+ * suppresses the benign post-'end' 'close'.
+ * @param {import('http').IncomingMessage} res
+ * @param {(err: Error) => void} reject - the _request Promise's reject
+ * @param {string} providerName - for the error message (e.g. 'OpenAIProvider')
+ * @returns {{ markEnded: () => void }}
+ */
+function guardResponseSettles(res, reject, providerName) {
+  let ended = false;
+  const fail = (/** @type {string} */ event, /** @type {any} */ cause = null) => reject(new ProviderError(
+    `[${providerName}] response stream ${event} before the body completed`,
+    { retryable: true, context: { bound: 'transport', event, ...(cause && cause.code && { causeCode: cause.code }) } },
+  ));
+  res.on('aborted', () => fail('aborted'));
+  res.on('error', (e) => fail('error', e));
+  res.on('close', () => { if (!ended) fail('close'); });
+  return { markEnded: () => { ended = true; } };
+}
+
+module.exports = { DEFAULT_TIMEOUT_MS, resolveTimeoutMs, applyRequestTimeout, applyRequestDeadline, applyRequestBounds, guardResponseSettles };

package/src/provider-ollama.js

@@ -4,8 +4,9 @@ const http = require('http');
 const { ProviderError } = require('./errors');
 const { requestWithTemperatureFallback } = require('./provider-temperature');
 const { normalizeStopReason } = require('./provider-stop-reason');
-const { resolveTimeoutMs, applyRequestBounds } = require('./provider-http');
+const { resolveTimeoutMs, applyRequestBounds, guardResponseSettles } = require('./provider-http');
 const { hasUsageSignal } = require('./provider-usage');
+const { parseToolCalls } = require('./provider-toolcalls');
 
 // 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'];
@@ -85,8 +86,11 @@ class OllamaProvider {
     });
     const msg = data.message || {};
 
-    /** @type {import('../types').ToolCall[]} */
-    const toolCalls = (msg.tool_calls || []).map((/** @type {any} */ tc) => ({
+    // BA-27: Ollama returns `function.arguments` as an OBJECT for well-formed calls, but some builds
+    // pass it through as a model-generated STRING — a malformed one must not throw here (the round
+    // already billed; a throw loses usage + hangs metering). Mirror the OpenAI path: no usable calls
+    // + a marker, never repair. The object case is untouched (JSON.parse only runs on a string).
+    const { toolCalls, malformedToolCall } = parseToolCalls(msg.tool_calls, (/** @type {any} */ tc) => ({
       id: tc.id || `call_${Date.now()}`,
       name: tc.function.name,
       arguments: typeof tc.function.arguments === 'string'
@@ -97,6 +101,7 @@ class OllamaProvider {
     return {
       text: msg.content || '',
       toolCalls,
+      ...(malformedToolCall && { malformedToolCall }),
       model: data.model || this.model,
       // BA-6: `length` ⇒ cut off at num_predict. VERIFIED LIVE on qwen2.5:0.5b
       // (`poc/ba6-stop-reason-gemini-ollama.mjs`): stop→end_turn, length→max_tokens. Lifecycle values
@@ -141,8 +146,11 @@ class OllamaProvider {
         },
       }, (res) => {
         let chunks = '';
+        // BA-25: reject (retryable) if the body is cut after headers, so generate() always settles.
+        const { markEnded } = guardResponseSettles(res, reject, 'OllamaProvider');
         res.on('data', d => chunks += d);
         res.on('end', () => {
+          markEnded();
           try {
             const parsed = JSON.parse(chunks);
             if ((res.statusCode ?? 0) >= 400) {

package/src/provider-openai.d.ts

@@ -30,6 +30,14 @@ export type OpenAIOptions = {
      * `generate(..., { deadlineMs })`.
      */
     deadlineMs?: number | undefined;
+    /**
+     * - BA-24 (fwdloop): send the legacy `max_tokens` request
+     * key instead of `max_completion_tokens`. The default is `max_completion_tokens` because current
+     * OpenAI GPT-5 models 400 on `max_tokens` ("Unsupported parameter … Use 'max_completion_tokens'").
+     * 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.
+     */
+    legacyMaxTokens?: boolean | undefined;
 };
 /**
  * @typedef {object} OpenAIOptions
@@ -51,6 +59,11 @@ export type OpenAIOptions = {
  *   rejects with a TERMINAL `TimeoutError` (`code: 'EDEADLINE'`, `context.bound: 'deadline'`,
  *   `retryable: false`). DISABLED by default; `0`/`Infinity` disable. Overridable per call via
  *   `generate(..., { deadlineMs })`.
+ * @property {boolean} [legacyMaxTokens=false] - BA-24 (fwdloop): send the legacy `max_tokens` request
+ *   key instead of `max_completion_tokens`. The default is `max_completion_tokens` because current
+ *   OpenAI GPT-5 models 400 on `max_tokens` ("Unsupported parameter … Use 'max_completion_tokens'").
+ *   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.
  */
 export class OpenAIProvider {
     /**
@@ -63,11 +76,12 @@ export class OpenAIProvider {
     exposeErrorBody: boolean;
     timeoutMs: number | undefined;
     deadlineMs: number | undefined;
+    legacyMaxTokens: boolean;
     /**
      * 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).
+     * @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).
      * @returns {Promise<GenerateResult>}
      * @throws {Error} `[OpenAIProvider] ...` — on HTTP errors (4xx/5xx) or invalid JSON response.
      */

package/src/provider-openai.js

@@ -5,8 +5,9 @@ const http = require('http');
 const { ProviderError } = require('./errors');
 const { requestWithTemperatureFallback } = require('./provider-temperature');
 const { normalizeStopReason } = require('./provider-stop-reason');
-const { resolveTimeoutMs, applyRequestBounds } = require('./provider-http');
+const { resolveTimeoutMs, applyRequestBounds, guardResponseSettles } = require('./provider-http');
 const { hasUsageSignal } = require('./provider-usage');
+const { parseToolCalls } = require('./provider-toolcalls');
 
 // 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'];
@@ -16,6 +17,29 @@ const OPENAI_USAGE_KEYS = ['prompt_tokens', 'completion_tokens', 'prompt_tokens_
 /** @typedef {import('../types').ToolCall} ToolCall */
 /** @typedef {import('../types').GenerateResult} GenerateResult */
 
+/**
+ * Map a neutral `toolChoice` option to OpenAI's `tool_choice` wire shape (Ask 4, fwdloop).
+ * `'auto'`/`'required'` pass through; `{ name }` becomes `{ type:'function', function:{ name } }`.
+ * `null`/`undefined` ⇒ omit the field (the API default `auto`). An unrecognized shape throws — a
+ * silently-dropped force would read as "the model chose not to call", the exact confusion Ask 3 fixes.
+ * @param {undefined|null|'auto'|'required'|{name: string}} choice
+ * @returns {undefined|'auto'|'required'|{type:'function', function:{name:string}}}
+ */
+function toOpenAIToolChoice(choice) {
+  if (choice == null) return undefined;
+  if (choice === 'auto' || choice === 'required') return choice;
+  if (typeof choice === 'object' && typeof choice.name === 'string' && choice.name) {
+    return { type: 'function', function: { name: choice.name } };
+  }
+  let describedChoice;
+  try {
+    describedChoice = JSON.stringify(choice);
+  } catch {
+    describedChoice = '<unserializable>';
+  }
+  throw new ProviderError(`[OpenAIProvider] invalid toolChoice: expected 'auto', 'required', or { name }, got ${describedChoice}`);
+}
+
 /** @param {string} hostname @returns {boolean} */
 function isLoopbackHost(hostname) {
   const h = hostname.replace(/^\[|\]$/g, ''); // strip IPv6 brackets
@@ -42,6 +66,11 @@ function isLoopbackHost(hostname) {
  *   rejects with a TERMINAL `TimeoutError` (`code: 'EDEADLINE'`, `context.bound: 'deadline'`,
  *   `retryable: false`). DISABLED by default; `0`/`Infinity` disable. Overridable per call via
  *   `generate(..., { deadlineMs })`.
+ * @property {boolean} [legacyMaxTokens=false] - BA-24 (fwdloop): send the legacy `max_tokens` request
+ *   key instead of `max_completion_tokens`. The default is `max_completion_tokens` because current
+ *   OpenAI GPT-5 models 400 on `max_tokens` ("Unsupported parameter … Use 'max_completion_tokens'").
+ *   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.
  */
 
 class OpenAIProvider {
@@ -57,29 +86,40 @@ class OpenAIProvider {
     this.timeoutMs = options.timeoutMs;
     // BA-19: total call-duration deadline (ms). Resolved at call time (default 0 = disabled).
     this.deadlineMs = options.deadlineMs;
+    // BA-24 (fwdloop): use the legacy `max_tokens` key. Default false ⇒ `max_completion_tokens` (GPT-5-safe).
+    this.legacyMaxTokens = options.legacyMaxTokens === true;
   }
 
   /**
    * 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).
+   * @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).
    * @returns {Promise<GenerateResult>}
    * @throws {Error} `[OpenAIProvider] ...` — on HTTP errors (4xx/5xx) or invalid JSON response.
    */
   async generate(messages, tools = [], options = {}) {
+    // BA-24 (fwdloop): GPT-5 models 400 on `max_tokens` and want `max_completion_tokens`; the legacy
+    // key stays reachable via the constructor's `legacyMaxTokens` for compat servers. No model sniffing.
+    const maxTokensKey = this.legacyMaxTokens ? 'max_tokens' : 'max_completion_tokens';
     /** @type {Record<string, any>} */
     const body = {
       model: this.model,
       messages,
       ...(options.temperature != null && { temperature: options.temperature }),
-      ...(options.maxTokens && { max_tokens: options.maxTokens }),
+      ...(options.maxTokens && { [maxTokensKey]: options.maxTokens }),
     };
+    // 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
+    // valid choice with nothing to force is dropped (documented), while absent ⇒ the API default 'auto'.
+    const toolChoice = toOpenAIToolChoice(options.toolChoice);
     if (tools.length > 0) {
       body.tools = tools.map(t => ({
         type: 'function',
         function: { name: t.name, description: t.description, parameters: t.parameters },
       }));
+      if (toolChoice != null) body.tool_choice = toolChoice;
     }
 
     // BA-10: newer models (o1/gpt-5-class) reject a non-default `temperature` with a 400 — drop it and
@@ -92,11 +132,27 @@ class OpenAIProvider {
       stripTemperature: () => { delete body.temperature; },
       warnOnce: () => this._warnTemperatureDropped(),
     });
+    // BA-27: a successful 200 whose body carries no `choices` (some OpenAI-compat servers return a
+    // 4xx-shaped error object with HTTP 200) reached `data.choices[0]` as a bare TypeError with no
+    // context. Throw a ProviderError carrying the first ~300 bytes of the body so it can be told apart.
+    if (!Array.isArray(data.choices) || data.choices.length === 0) {
+      // The `context.bound:'no-choices'` marker ALWAYS distinguishes a 4xx-in-200 from other failures.
+      // The raw body snippet is gated behind `exposeErrorBody` (default off) like every other error path
+      // here — an unexpected field in a compat server's error body must not leak into logs/audit rows
+      // (err.message flows into Loop.run().error) unless the caller opts in.
+      throw new ProviderError(
+        `[OpenAIProvider] response has no choices` +
+          (this.exposeErrorBody ? `: ${JSON.stringify(data).slice(0, 300)}` : ''),
+        /** @type {any} */ ({ context: { bound: 'no-choices' }, body: this.exposeErrorBody ? data : undefined })
+      );
+    }
     const choice = data.choices[0];
     const msg = choice.message;
 
-    /** @type {import('../types').ToolCall[]} */
-    const toolCalls = (msg.tool_calls || []).map((/** @type {any} */ tc) => ({
+    // BA-27: `function.arguments` is a model-generated JSON STRING — a malformed one (extra brace,
+    // truncated object) must NOT throw here (the round already billed; a throw loses usage + hangs
+    // metering). parseToolCalls returns no usable calls + a marker; usage/model still flow below.
+    const { toolCalls, malformedToolCall } = parseToolCalls(msg.tool_calls, (/** @type {any} */ tc) => ({
       id: tc.id,
       name: tc.function.name,
       arguments: JSON.parse(tc.function.arguments),
@@ -105,6 +161,7 @@ class OpenAIProvider {
     return {
       text: msg.content || '',
       toolCalls,
+      ...(malformedToolCall && { malformedToolCall }),
       model: data.model || this.model,
       // BA-6: `length` ⇒ cut off at the output cap (normalized to 'max_tokens'). Note OpenAI refuses to
       // emit a tool call it cannot finish — it 400s instead — so a truncated round here carries no
@@ -178,8 +235,11 @@ class OpenAIProvider {
         },
       }, (res) => {
         let chunks = '';
+        // BA-25: reject (retryable) if the body is cut after headers, so generate() always settles.
+        const { markEnded } = guardResponseSettles(res, reject, 'OpenAIProvider');
         res.on('data', d => chunks += d);
         res.on('end', () => {
+          markEnded();
           try {
             const parsed = JSON.parse(chunks);
             if ((res.statusCode ?? 0) >= 400) {

package/src/provider-toolcalls.d.ts

@@ -0,0 +1,29 @@
+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.
+ *
+ * OpenAI-compatible providers return `function.arguments` as a JSON STRING the model generated, so a
+ * model that emits syntactically-broken JSON (an extra brace, a truncated object — seen live on
+ * deepseek-flash and other compat servers) makes a bare `JSON.parse` throw a `SyntaxError`. That throw
+ * lands AFTER the HTTP round already succeeded and `usage` came back, so it loses the billed round and
+ * hangs any metering, and no caller can tell "the model emitted bad arguments" from a transport fault.
+ *
+ * Instead: on the FIRST unparseable call, return NO usable tool calls (`toolCalls: []`) plus a marker
+ * `{ name, error }`. The caller treats it as "no usable tool call" and retries; usage/model still flow
+ * so the round is metered. We NEVER repair the JSON — a guessed brace could execute the wrong action.
+ * All-or-nothing (mirrors BA-4's refusal to execute a truncated round's calls): a partial set risks
+ * running half a decomposed intent, so one bad call voids the whole round's calls.
+ *
+ * @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
+ * @returns {{ toolCalls: ToolCall[], malformedToolCall?: { name: string|undefined, error: string } }}
+ */
+export function parseToolCalls(rawToolCalls: any[], mapOne: (tc: any) => ToolCall): {
+    toolCalls: ToolCall[];
+    malformedToolCall?: {
+        name: string | undefined;
+        error: string;
+    };
+};

package/src/provider-toolcalls.js

@@ -0,0 +1,45 @@
+'use strict';
+
+/** @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.
+ *
+ * OpenAI-compatible providers return `function.arguments` as a JSON STRING the model generated, so a
+ * model that emits syntactically-broken JSON (an extra brace, a truncated object — seen live on
+ * deepseek-flash and other compat servers) makes a bare `JSON.parse` throw a `SyntaxError`. That throw
+ * lands AFTER the HTTP round already succeeded and `usage` came back, so it loses the billed round and
+ * hangs any metering, and no caller can tell "the model emitted bad arguments" from a transport fault.
+ *
+ * Instead: on the FIRST unparseable call, return NO usable tool calls (`toolCalls: []`) plus a marker
+ * `{ name, error }`. The caller treats it as "no usable tool call" and retries; usage/model still flow
+ * so the round is metered. We NEVER repair the JSON — a guessed brace could execute the wrong action.
+ * All-or-nothing (mirrors BA-4's refusal to execute a truncated round's calls): a partial set risks
+ * running half a decomposed intent, so one bad call voids the whole round's calls.
+ *
+ * @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
+ * @returns {{ toolCalls: ToolCall[], malformedToolCall?: { name: string|undefined, error: string } }}
+ */
+function parseToolCalls(rawToolCalls, mapOne) {
+  const raw = rawToolCalls || [];
+  /** @type {ToolCall[]} */
+  const toolCalls = [];
+  for (const tc of raw) {
+    try {
+      toolCalls.push(mapOne(tc));
+    } catch (e) {
+      return {
+        toolCalls: [],
+        malformedToolCall: {
+          name: tc && tc.function ? tc.function.name : undefined,
+          error: e instanceof Error ? e.message : String(e),
+        },
+      };
+    }
+  }
+  return { toolCalls };
+}
+
+module.exports = { parseToolCalls };

package/types/index.d.ts

@@ -134,6 +134,16 @@ export interface GenerateResult {
    * temperature, not the one requested — callers reporting an effective temperature must honor this.
    */
   temperatureDropped?: boolean;
+  /**
+   * BA-27 — present ONLY when the model emitted a tool call whose `function.arguments` was
+   * syntactically-broken JSON (an extra brace, a truncated object). The billed round already
+   * succeeded, so rather than throw (which loses the round's usage and hangs metering), the provider
+   * returns NO usable tool calls (`toolCalls: []`) plus this marker. A caller treats it as "no usable
+   * tool call" and retries; `usage`/`model` still flow so the round is metered. The JSON is NEVER
+   * repaired. Absent on a clean round. OpenAI-compatible + Ollama string-arguments only; Anthropic
+   * arrives pre-parsed and cannot hit this.
+   */
+  malformedToolCall?: { name: string | undefined; error: string };
   /**
    * 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