@genesislcap/foundation-ai 14.488.0 → 14.488.1

package/dist/dts/transports/anthropic-transport.d.ts

@@ -28,26 +28,36 @@ export interface AnthropicTransportConfig {
     maxTokens?: number;
 }
 /**
- * Thrown when a response stops at `stop_reason: 'max_tokens'` while it still
- * carries tool calls. The model ran out of its output-token budget mid-stream,
- * so the truncated tool call's argument JSON was cut off before it closed — the
- * arguments are incomplete and the call is unusable (e.g. a `vfs_write` whose
- * `content` never finished serializing). Rather than hand a corrupt tool call to
- * the caller — which silently runs with missing args and tends to be retried into
- * an identical wall — the transport raises this so the failure is loud and
- * diagnosable.
+ * Thrown when a response was cut off at the output-token limit (Anthropic
+ * `stop_reason: 'max_tokens'`, Gemini `finishReason: 'MAX_TOKENS'`) in a way
+ * that leaves nothing safe to keep. Both transports raise it when the truncated
+ * turn carries tool calls: the model ran out of its output-token budget
+ * mid-stream, so the cut-off call's arguments are incomplete or untrustworthy
+ * (e.g. a `vfs_write` whose `content` never finished serializing) — rather than
+ * hand a corrupt tool call to the caller, which silently runs with missing args
+ * and tends to be retried into an identical wall, the failure is loud and
+ * diagnosable. The Gemini transport also raises it when truncation leaves no
+ * usable answer text (a blank or thinking-only response), which would otherwise
+ * be misclassified — and pointlessly retried — as an "empty" response.
  *
  * It is deterministic: re-issuing the same request hits the same cap. The remedy
- * is to raise the provider's `maxTokens` (see {@link AnthropicAIConfig.maxTokens})
- * or to split the work into smaller outputs — not to retry verbatim.
+ * is to raise the provider's `maxTokens` where configurable (see
+ * {@link AnthropicAIConfig.maxTokens}) or to split the work into smaller
+ * outputs — not to retry verbatim.
+ *
+ * Shared by both transports; it lives here with the transport that introduced it.
  *
  * @beta
  */
 export declare class ResponseTruncatedError extends Error {
     /** The model that produced the truncated response. */
     readonly model: string;
-    /** The `max_tokens` cap the request was sent with. */
-    readonly maxTokens: number;
+    /**
+     * The `max_tokens` cap the request was sent with, when the transport sends
+     * one (Anthropic). Undefined when no explicit cap was requested and the
+     * model's own output-token limit applied instead (Gemini).
+     */
+    readonly maxTokens: number | undefined;
     /** Output tokens generated before truncation, when the usage block is present. */
     readonly outputTokens: number | undefined;
     /** Names of the tool call(s) on the truncated turn (the last is the cut-off one). */
@@ -55,8 +65,12 @@ export declare class ResponseTruncatedError extends Error {
     constructor(
     /** The model that produced the truncated response. */
     model: string, 
-    /** The `max_tokens` cap the request was sent with. */
-    maxTokens: number, 
+    /**
+     * The `max_tokens` cap the request was sent with, when the transport sends
+     * one (Anthropic). Undefined when no explicit cap was requested and the
+     * model's own output-token limit applied instead (Gemini).
+     */
+    maxTokens: number | undefined, 
     /** Output tokens generated before truncation, when the usage block is present. */
     outputTokens: number | undefined, 
     /** Names of the tool call(s) on the truncated turn (the last is the cut-off one). */

package/dist/dts/transports/anthropic-transport.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"anthropic-transport.d.ts","sourceRoot":"","sources":["../../../src/transports/anthropic-transport.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"anthropic-transport.d.ts","sourceRoot":"","sources":["../../../src/transports/anthropic-transport.ts"],"names":[],"mappings":"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"}

package/dist/dts/transports/gemini-transport.d.ts

@@ -82,6 +82,21 @@ export declare class GeminiTransport implements AITransport, ChatTransport, Cost
     private logTokenUsage;
     private toGeminiContents;
     private fromGeminiResponse;
+    /**
+     * Raises {@link ResponseTruncatedError} when a `MAX_TOKENS` finish left nothing
+     * safe to keep. A MAX_TOKENS finish means generation was cut off at the
+     * output-token limit (no explicit cap is requested, so this is the model's own
+     * output ceiling — which thinking tokens share). Truncation is DETERMINISTIC:
+     * re-issuing the identical request hits the same limit, so it must not fall
+     * through to the caller's empty-response retry. Mirrors the Anthropic
+     * transport's contract: with tool calls the cut-off call's args can't be
+     * trusted, and with no usable answer text (blank or thinking-only) there is
+     * nothing to keep either — the typed truncation error is raised for both.
+     * Partial answer TEXT is instead returned by `fromGeminiResponse`, flagged via
+     * `responseMeta.finishReason`, for the caller to decide. Usage/cost is logged
+     * before this check runs, so the spent tokens stay accounted for.
+     */
+    private guardMaxTokensTruncation;
     /**
      * Log the full shape of a blank or non-STOP response so its cause is legible
      * without re-deriving it: a thinking-only STOP (substantial `thoughtsTokenCount`,
@@ -96,6 +111,18 @@ export declare class GeminiTransport implements AITransport, ChatTransport, Cost
     private static readonly MAX_RETRIES;
     private static readonly RATE_LIMIT_STATUS;
     private static readonly SERVICE_UNAVAILABLE_STATUS;
+    /**
+     * 502 BAD_GATEWAY is a cleanly transient fault from an intermediate proxy or load
+     * balancer fronting the API — back off and retry it alongside 429/503.
+     *
+     * Deliberately NOT retried: 500 INTERNAL and 504 DEADLINE_EXCEEDED. Google documents
+     * both as also carrying a deterministic cause ("input context is too long" / "prompt
+     * too large to process in time"); re-issuing the identical request just re-hits the
+     * same wall and burns the whole backoff ladder — the same deterministic-retry trap
+     * this transport avoids for MAX_TOKENS, and especially wasteful on the large-context
+     * agent path. They fail fast instead.
+     */
+    private static readonly BAD_GATEWAY_STATUS;
     private static readonly RETRYABLE_STATUSES;
     private static readonly BACKOFF_BASE_MS;
     private post;

package/dist/dts/transports/gemini-transport.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gemini-transport.d.ts","sourceRoot":"","sources":["../../../src/transports/gemini-transport.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,WAAW,EAChB,KAAK,sBAAsB,EAC3B,KAAK,aAAa,EAClB,KAAK,uBAAuB,EAC7B,MAAM,UAAU,CAAC;AAClB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AACnE,OAAO,KAAK,EAEV,WAAW,EACX,kBAAkB,EAInB,MAAM,qBAAqB,CAAC;AAyI7B,MAAM,WAAW,qBAAqB;IACpC;;OAEG;IACH,KAAK,CAAC,EAAE,aAAa,CAAC;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AA0CD;;;;;;GAMG;AACH,qBAAa,0BAA2B,SAAQ,KAAK;IACvC,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM;gBAAtB,aAAa,CAAC,EAAE,MAAM;CAI5C;AAED;;;;;;;;GAQG;AACH,qBAAa,eAAgB,YAAW,WAAW,EAAE,aAAa,EAAE,sBAAsB;IACxF,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAgB;IACtC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAqB;IAC5C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAqB;IACpD;;;;;OAKG;IACH,OAAO,CAAC,eAAe,CAAK;IAC5B;;;;OAIG;IACH,OAAO,CAAC,kBAAkB,CAAK;gBAEnB,MAAM,GAAE,qBAA0B;IAc9C,SAAS,IAAI;QAAE,QAAQ,EAAE,QAAQ,CAAC;QAAC,KAAK,EAAE,aAAa,CAAC;QAAC,YAAY,EAAE,MAAM,CAAA;KAAE;IAQ/E,iGAAiG;IACjG,eAAe,IAAI,MAAM;IAIzB,mGAAmG;IACnG,kBAAkB,IAAI,MAAM;IAI5B,+FAA+F;IAC/F,iBAAiB,IAAI,IAAI;IAOnB,oBAAoB,CAAC,OAAO,EAAE,uBAAuB,GAAG,OAAO,CAAC,MAAM,CAAC;IAgBvE,eAAe,CACnB,OAAO,EAAE,WAAW,EAAE,EACtB,WAAW,EAAE,MAAM,EACnB,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,WAAW,CAAC;IAsEvB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,kBAAkB,CAAa;IACvD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,mBAAmB,CAAK;IAEhD;;;;OAIG;IACH,OAAO,CAAC,aAAa;IAgDrB,OAAO,CAAC,gBAAgB;IAmFxB,OAAO,CAAC,kBAAkB;IAoJ1B;;;;;;;;OAQG;IACH,OAAO,CAAC,mBAAmB;IAkC3B,OAAO,CAAC,aAAa;IAyBrB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,WAAW,CAAK;IACxC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,iBAAiB,CAAO;IAChD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,0BAA0B,CAAO;IACzD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,kBAAkB,CAGxC;IACF,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,eAAe,CAAQ;YAEjC,IAAI;IA+DlB,OAAO,CAAC,eAAe;CAexB"}
+{"version":3,"file":"gemini-transport.d.ts","sourceRoot":"","sources":["../../../src/transports/gemini-transport.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,WAAW,EAChB,KAAK,sBAAsB,EAC3B,KAAK,aAAa,EAClB,KAAK,uBAAuB,EAC7B,MAAM,UAAU,CAAC;AAClB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AACnE,OAAO,KAAK,EAEV,WAAW,EACX,kBAAkB,EAInB,MAAM,qBAAqB,CAAC;AA0I7B,MAAM,WAAW,qBAAqB;IACpC;;OAEG;IACH,KAAK,CAAC,EAAE,aAAa,CAAC;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AA0CD;;;;;;GAMG;AACH,qBAAa,0BAA2B,SAAQ,KAAK;IACvC,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM;gBAAtB,aAAa,CAAC,EAAE,MAAM;CAI5C;AAED;;;;;;;;GAQG;AACH,qBAAa,eAAgB,YAAW,WAAW,EAAE,aAAa,EAAE,sBAAsB;IACxF,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAgB;IACtC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAqB;IAC5C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAqB;IACpD;;;;;OAKG;IACH,OAAO,CAAC,eAAe,CAAK;IAC5B;;;;OAIG;IACH,OAAO,CAAC,kBAAkB,CAAK;gBAEnB,MAAM,GAAE,qBAA0B;IAc9C,SAAS,IAAI;QAAE,QAAQ,EAAE,QAAQ,CAAC;QAAC,KAAK,EAAE,aAAa,CAAC;QAAC,YAAY,EAAE,MAAM,CAAA;KAAE;IAQ/E,iGAAiG;IACjG,eAAe,IAAI,MAAM;IAIzB,mGAAmG;IACnG,kBAAkB,IAAI,MAAM;IAI5B,+FAA+F;IAC/F,iBAAiB,IAAI,IAAI;IAOnB,oBAAoB,CAAC,OAAO,EAAE,uBAAuB,GAAG,OAAO,CAAC,MAAM,CAAC;IAgBvE,eAAe,CACnB,OAAO,EAAE,WAAW,EAAE,EACtB,WAAW,EAAE,MAAM,EACnB,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,WAAW,CAAC;IAsEvB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,kBAAkB,CAAa;IACvD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,mBAAmB,CAAK;IAEhD;;;;OAIG;IACH,OAAO,CAAC,aAAa;IAgDrB,OAAO,CAAC,gBAAgB;IAmFxB,OAAO,CAAC,kBAAkB;IAsJ1B;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,wBAAwB;IAkBhC;;;;;;;;OAQG;IACH,OAAO,CAAC,mBAAmB;IAkC3B,OAAO,CAAC,aAAa;IAyBrB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,WAAW,CAAK;IACxC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,iBAAiB,CAAO;IAChD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,0BAA0B,CAAO;IACzD;;;;;;;;;;OAUG;IACH,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,kBAAkB,CAAO;IACjD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,kBAAkB,CAIxC;IACF,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,eAAe,CAAQ;YAEjC,IAAI;IAsElB,OAAO,CAAC,eAAe;CAexB"}

package/dist/esm/transports/anthropic-transport.js

@@ -97,18 +97,24 @@ const ANTHROPIC_CACHE_READ_MULTIPLIER = 0.1;
 const ANTHROPIC_CACHE_WRITE_5M_MULTIPLIER = 1.25;
 const ANTHROPIC_CACHE_WRITE_1H_MULTIPLIER = 2;
 /**
- * Thrown when a response stops at `stop_reason: 'max_tokens'` while it still
- * carries tool calls. The model ran out of its output-token budget mid-stream,
- * so the truncated tool call's argument JSON was cut off before it closed — the
- * arguments are incomplete and the call is unusable (e.g. a `vfs_write` whose
- * `content` never finished serializing). Rather than hand a corrupt tool call to
- * the caller — which silently runs with missing args and tends to be retried into
- * an identical wall — the transport raises this so the failure is loud and
- * diagnosable.
+ * Thrown when a response was cut off at the output-token limit (Anthropic
+ * `stop_reason: 'max_tokens'`, Gemini `finishReason: 'MAX_TOKENS'`) in a way
+ * that leaves nothing safe to keep. Both transports raise it when the truncated
+ * turn carries tool calls: the model ran out of its output-token budget
+ * mid-stream, so the cut-off call's arguments are incomplete or untrustworthy
+ * (e.g. a `vfs_write` whose `content` never finished serializing) — rather than
+ * hand a corrupt tool call to the caller, which silently runs with missing args
+ * and tends to be retried into an identical wall, the failure is loud and
+ * diagnosable. The Gemini transport also raises it when truncation leaves no
+ * usable answer text (a blank or thinking-only response), which would otherwise
+ * be misclassified — and pointlessly retried — as an "empty" response.
  *
  * It is deterministic: re-issuing the same request hits the same cap. The remedy
- * is to raise the provider's `maxTokens` (see {@link AnthropicAIConfig.maxTokens})
- * or to split the work into smaller outputs — not to retry verbatim.
+ * is to raise the provider's `maxTokens` where configurable (see
+ * {@link AnthropicAIConfig.maxTokens}) or to split the work into smaller
+ * outputs — not to retry verbatim.
+ *
+ * Shared by both transports; it lives here with the transport that introduced it.
  *
  * @beta
  */
@@ -116,15 +122,19 @@ export class ResponseTruncatedError extends Error {
     constructor(
     /** The model that produced the truncated response. */
     model, 
-    /** The `max_tokens` cap the request was sent with. */
+    /**
+     * The `max_tokens` cap the request was sent with, when the transport sends
+     * one (Anthropic). Undefined when no explicit cap was requested and the
+     * model's own output-token limit applied instead (Gemini).
+     */
     maxTokens, 
     /** Output tokens generated before truncation, when the usage block is present. */
     outputTokens, 
     /** Names of the tool call(s) on the truncated turn (the last is the cut-off one). */
     toolNames) {
-        super(`Anthropic response truncated at the max_tokens cap (${maxTokens}) for model ${model}` +
+        super(`Response truncated at ${maxTokens != null ? `the max_tokens cap (${maxTokens})` : "the model's output-token limit"} for model ${model}` +
             (toolNames.length > 0 ? ` while emitting tool call(s): ${toolNames.join(', ')}` : '') +
-            '. The output exceeds the per-response limit — raise the provider maxTokens or split the work into smaller outputs.');
+            '. The output exceeds the per-response limit — raise the provider maxTokens (where configurable) or split the work into smaller outputs.');
         this.model = model;
         this.maxTokens = maxTokens;
         this.outputTokens = outputTokens;

package/dist/esm/transports/gemini-transport.js

@@ -3,6 +3,7 @@ import { SUPPORTED_GEMINI_MODEL_IDS, } from '../types';
 import { combineSignals } from '../utils/combine-signals';
 import { logger } from '../utils/logger';
 import { scaleTemperature } from '../utils/temperature';
+import { ResponseTruncatedError } from './anthropic-transport';
 import { repairMalformedFunctionCall } from './gemini-malformed-call';
 const GEMINI_DIRECT_URL = (model) => `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent`;
 const DEFAULT_MODEL = 'gemini-2.5-flash-lite';
@@ -460,6 +461,7 @@ export class GeminiTransport {
                 textParts: textParts.length,
             });
         }
+        this.guardMaxTokensTruncation(finishReason, toolCalls, narration, outputTokens);
         if (inputTokens != null)
             base.inputTokens = inputTokens;
         if (outputTokens != null)
@@ -484,6 +486,29 @@ export class GeminiTransport {
         }
         return base;
     }
+    /**
+     * Raises {@link ResponseTruncatedError} when a `MAX_TOKENS` finish left nothing
+     * safe to keep. A MAX_TOKENS finish means generation was cut off at the
+     * output-token limit (no explicit cap is requested, so this is the model's own
+     * output ceiling — which thinking tokens share). Truncation is DETERMINISTIC:
+     * re-issuing the identical request hits the same limit, so it must not fall
+     * through to the caller's empty-response retry. Mirrors the Anthropic
+     * transport's contract: with tool calls the cut-off call's args can't be
+     * trusted, and with no usable answer text (blank or thinking-only) there is
+     * nothing to keep either — the typed truncation error is raised for both.
+     * Partial answer TEXT is instead returned by `fromGeminiResponse`, flagged via
+     * `responseMeta.finishReason`, for the caller to decide. Usage/cost is logged
+     * before this check runs, so the spent tokens stay accounted for.
+     */
+    guardMaxTokensTruncation(finishReason, toolCalls, narration, outputTokens) {
+        if (finishReason !== 'MAX_TOKENS')
+            return;
+        // A truncated text-only answer is partial but legible — keep it (the driver's
+        // emptiness rule is `!content.trim()`, so whitespace-only does NOT count).
+        if (toolCalls.length === 0 && narration.trim() !== '')
+            return;
+        throw new ResponseTruncatedError(this.model, undefined, outputTokens, toolCalls.map((tc) => tc.name));
+    }
     /**
      * Log the full shape of a blank or non-STOP response so its cause is legible
      * without re-deriving it: a thinking-only STOP (substantial `thoughtsTokenCount`,
@@ -572,9 +597,19 @@ export class GeminiTransport {
                 dispose();
                 if (GeminiTransport.RETRYABLE_STATUSES.includes(response.status) &&
                     attempt < GeminiTransport.MAX_RETRIES) {
-                    // Exponential backoff: 1s, 2s, 4s, 8s, 16s
-                    yield new Promise((resolve) => {
-                        setTimeout(resolve, GeminiTransport.BACKOFF_BASE_MS * (1 << attempt));
+                    // Exponential backoff: 1s, 2s, 4s, 8s, 16s — abortable, so a caller cancel
+                    // mid-wait rejects promptly instead of being ignored until the next fetch.
+                    yield new Promise((resolve, reject) => {
+                        const timer = setTimeout(resolve, GeminiTransport.BACKOFF_BASE_MS * (1 << attempt));
+                        const onAbort = () => {
+                            var _a;
+                            clearTimeout(timer);
+                            reject((_a = signal === null || signal === void 0 ? void 0 : signal.reason) !== null && _a !== void 0 ? _a : new DOMException('The operation was aborted.', 'AbortError'));
+                        };
+                        if (signal === null || signal === void 0 ? void 0 : signal.aborted)
+                            onAbort();
+                        else
+                            signal === null || signal === void 0 ? void 0 : signal.addEventListener('abort', onAbort, { once: true });
                     });
                     continue;
                 }
@@ -604,8 +639,21 @@ GeminiTransport.COST_DECIMAL_PLACES = 6;
 GeminiTransport.MAX_RETRIES = 5;
 GeminiTransport.RATE_LIMIT_STATUS = 429;
 GeminiTransport.SERVICE_UNAVAILABLE_STATUS = 503;
+/**
+ * 502 BAD_GATEWAY is a cleanly transient fault from an intermediate proxy or load
+ * balancer fronting the API — back off and retry it alongside 429/503.
+ *
+ * Deliberately NOT retried: 500 INTERNAL and 504 DEADLINE_EXCEEDED. Google documents
+ * both as also carrying a deterministic cause ("input context is too long" / "prompt
+ * too large to process in time"); re-issuing the identical request just re-hits the
+ * same wall and burns the whole backoff ladder — the same deterministic-retry trap
+ * this transport avoids for MAX_TOKENS, and especially wasteful on the large-context
+ * agent path. They fail fast instead.
+ */
+GeminiTransport.BAD_GATEWAY_STATUS = 502;
 GeminiTransport.RETRYABLE_STATUSES = [
     GeminiTransport.RATE_LIMIT_STATUS,
     GeminiTransport.SERVICE_UNAVAILABLE_STATUS,
+    GeminiTransport.BAD_GATEWAY_STATUS,
 ];
 GeminiTransport.BACKOFF_BASE_MS = 1000;

package/dist/foundation-ai.api.json

@@ -8816,7 +8816,7 @@
         {
           "kind": "Class",
           "canonicalReference": "@genesislcap/foundation-ai!ResponseTruncatedError:class",
-          "docComment": "/**\n * Thrown when a response stops at `stop_reason: 'max_tokens'` while it still carries tool calls. The model ran out of its output-token budget mid-stream, so the truncated tool call's argument JSON was cut off before it closed — the arguments are incomplete and the call is unusable (e.g. a `vfs_write` whose `content` never finished serializing). Rather than hand a corrupt tool call to the caller — which silently runs with missing args and tends to be retried into an identical wall — the transport raises this so the failure is loud and diagnosable.\n *\n * It is deterministic: re-issuing the same request hits the same cap. The remedy is to raise the provider's `maxTokens` (see {@link AnthropicAIConfig.maxTokens}) or to split the work into smaller outputs — not to retry verbatim.\n *\n * @beta\n */\n",
+          "docComment": "/**\n * Thrown when a response was cut off at the output-token limit (Anthropic `stop_reason: 'max_tokens'`, Gemini `finishReason: 'MAX_TOKENS'`) in a way that leaves nothing safe to keep. Both transports raise it when the truncated turn carries tool calls: the model ran out of its output-token budget mid-stream, so the cut-off call's arguments are incomplete or untrustworthy (e.g. a `vfs_write` whose `content` never finished serializing) — rather than hand a corrupt tool call to the caller, which silently runs with missing args and tends to be retried into an identical wall, the failure is loud and diagnosable. The Gemini transport also raises it when truncation leaves no usable answer text (a blank or thinking-only response), which would otherwise be misclassified — and pointlessly retried — as an \"empty\" response.\n *\n * It is deterministic: re-issuing the same request hits the same cap. The remedy is to raise the provider's `maxTokens` where configurable (see {@link AnthropicAIConfig.maxTokens}) or to split the work into smaller outputs — not to retry verbatim.\n *\n * Shared by both transports; it lives here with the transport that introduced it.\n *\n * @beta\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -8857,7 +8857,7 @@
                 },
                 {
                   "kind": "Content",
-                  "text": "number"
+                  "text": "number | undefined"
                 },
                 {
                   "kind": "Content",
@@ -8921,7 +8921,7 @@
             {
               "kind": "Property",
               "canonicalReference": "@genesislcap/foundation-ai!ResponseTruncatedError#maxTokens:member",
-              "docComment": "/**\n * The `max_tokens` cap the request was sent with.\n */\n",
+              "docComment": "/**\n * The `max_tokens` cap the request was sent with, when the transport sends one (Anthropic). Undefined when no explicit cap was requested and the model's own output-token limit applied instead (Gemini).\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -8929,7 +8929,7 @@
                 },
                 {
                   "kind": "Content",
-                  "text": "number"
+                  "text": "number | undefined"
                 },
                 {
                   "kind": "Content",

package/dist/foundation-ai.d.ts

@@ -1503,6 +1503,21 @@ export declare class GeminiTransport implements AITransport, ChatTransport, Cost
     private logTokenUsage;
     private toGeminiContents;
     private fromGeminiResponse;
+    /**
+     * Raises {@link ResponseTruncatedError} when a `MAX_TOKENS` finish left nothing
+     * safe to keep. A MAX_TOKENS finish means generation was cut off at the
+     * output-token limit (no explicit cap is requested, so this is the model's own
+     * output ceiling — which thinking tokens share). Truncation is DETERMINISTIC:
+     * re-issuing the identical request hits the same limit, so it must not fall
+     * through to the caller's empty-response retry. Mirrors the Anthropic
+     * transport's contract: with tool calls the cut-off call's args can't be
+     * trusted, and with no usable answer text (blank or thinking-only) there is
+     * nothing to keep either — the typed truncation error is raised for both.
+     * Partial answer TEXT is instead returned by `fromGeminiResponse`, flagged via
+     * `responseMeta.finishReason`, for the caller to decide. Usage/cost is logged
+     * before this check runs, so the spent tokens stay accounted for.
+     */
+    private guardMaxTokensTruncation;
     /**
      * Log the full shape of a blank or non-STOP response so its cause is legible
      * without re-deriving it: a thinking-only STOP (substantial `thoughtsTokenCount`,
@@ -1517,6 +1532,18 @@ export declare class GeminiTransport implements AITransport, ChatTransport, Cost
     private static readonly MAX_RETRIES;
     private static readonly RATE_LIMIT_STATUS;
     private static readonly SERVICE_UNAVAILABLE_STATUS;
+    /**
+     * 502 BAD_GATEWAY is a cleanly transient fault from an intermediate proxy or load
+     * balancer fronting the API — back off and retry it alongside 429/503.
+     *
+     * Deliberately NOT retried: 500 INTERNAL and 504 DEADLINE_EXCEEDED. Google documents
+     * both as also carrying a deterministic cause ("input context is too long" / "prompt
+     * too large to process in time"); re-issuing the identical request just re-hits the
+     * same wall and burns the whole backoff ladder — the same deterministic-retry trap
+     * this transport avoids for MAX_TOKENS, and especially wasteful on the large-context
+     * agent path. They fail fast instead.
+     */
+    private static readonly BAD_GATEWAY_STATUS;
     private static readonly RETRYABLE_STATUSES;
     private static readonly BACKOFF_BASE_MS;
     private post;
@@ -1866,26 +1893,36 @@ export declare interface ResolveAIConfigOptions {
 }
 
 /**
- * Thrown when a response stops at `stop_reason: 'max_tokens'` while it still
- * carries tool calls. The model ran out of its output-token budget mid-stream,
- * so the truncated tool call's argument JSON was cut off before it closed — the
- * arguments are incomplete and the call is unusable (e.g. a `vfs_write` whose
- * `content` never finished serializing). Rather than hand a corrupt tool call to
- * the caller — which silently runs with missing args and tends to be retried into
- * an identical wall — the transport raises this so the failure is loud and
- * diagnosable.
+ * Thrown when a response was cut off at the output-token limit (Anthropic
+ * `stop_reason: 'max_tokens'`, Gemini `finishReason: 'MAX_TOKENS'`) in a way
+ * that leaves nothing safe to keep. Both transports raise it when the truncated
+ * turn carries tool calls: the model ran out of its output-token budget
+ * mid-stream, so the cut-off call's arguments are incomplete or untrustworthy
+ * (e.g. a `vfs_write` whose `content` never finished serializing) — rather than
+ * hand a corrupt tool call to the caller, which silently runs with missing args
+ * and tends to be retried into an identical wall, the failure is loud and
+ * diagnosable. The Gemini transport also raises it when truncation leaves no
+ * usable answer text (a blank or thinking-only response), which would otherwise
+ * be misclassified — and pointlessly retried — as an "empty" response.
  *
  * It is deterministic: re-issuing the same request hits the same cap. The remedy
- * is to raise the provider's `maxTokens` (see {@link AnthropicAIConfig.maxTokens})
- * or to split the work into smaller outputs — not to retry verbatim.
+ * is to raise the provider's `maxTokens` where configurable (see
+ * {@link AnthropicAIConfig.maxTokens}) or to split the work into smaller
+ * outputs — not to retry verbatim.
+ *
+ * Shared by both transports; it lives here with the transport that introduced it.
  *
  * @beta
  */
 export declare class ResponseTruncatedError extends Error {
     /** The model that produced the truncated response. */
     readonly model: string;
-    /** The `max_tokens` cap the request was sent with. */
-    readonly maxTokens: number;
+    /**
+     * The `max_tokens` cap the request was sent with, when the transport sends
+     * one (Anthropic). Undefined when no explicit cap was requested and the
+     * model's own output-token limit applied instead (Gemini).
+     */
+    readonly maxTokens: number | undefined;
     /** Output tokens generated before truncation, when the usage block is present. */
     readonly outputTokens: number | undefined;
     /** Names of the tool call(s) on the truncated turn (the last is the cut-off one). */
@@ -1893,8 +1930,12 @@ export declare class ResponseTruncatedError extends Error {
     constructor(
     /** The model that produced the truncated response. */
     model: string, 
-    /** The `max_tokens` cap the request was sent with. */
-    maxTokens: number, 
+    /**
+     * The `max_tokens` cap the request was sent with, when the transport sends
+     * one (Anthropic). Undefined when no explicit cap was requested and the
+     * model's own output-token limit applied instead (Gemini).
+     */
+    maxTokens: number | undefined, 
     /** Output tokens generated before truncation, when the usage block is present. */
     outputTokens: number | undefined, 
     /** Names of the tool call(s) on the truncated turn (the last is the cut-off one). */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@genesislcap/foundation-ai",
   "description": "Genesis Foundation AI - Provider-agnostic AI configuration and shared utilities",
-  "version": "14.488.0",
+  "version": "14.488.1",
   "sideEffects": false,
   "license": "SEE LICENSE IN license.txt",
   "main": "dist/esm/index.js",
@@ -52,17 +52,17 @@
     }
   },
   "devDependencies": {
-    "@genesislcap/foundation-testing": "14.488.0",
-    "@genesislcap/genx": "14.488.0",
-    "@genesislcap/rollup-builder": "14.488.0",
-    "@genesislcap/ts-builder": "14.488.0",
-    "@genesislcap/uvu-playwright-builder": "14.488.0",
-    "@genesislcap/vite-builder": "14.488.0",
-    "@genesislcap/webpack-builder": "14.488.0"
+    "@genesislcap/foundation-testing": "14.488.1",
+    "@genesislcap/genx": "14.488.1",
+    "@genesislcap/rollup-builder": "14.488.1",
+    "@genesislcap/ts-builder": "14.488.1",
+    "@genesislcap/uvu-playwright-builder": "14.488.1",
+    "@genesislcap/vite-builder": "14.488.1",
+    "@genesislcap/webpack-builder": "14.488.1"
   },
   "dependencies": {
-    "@genesislcap/foundation-logger": "14.488.0",
-    "@genesislcap/foundation-utils": "14.488.0",
+    "@genesislcap/foundation-logger": "14.488.1",
+    "@genesislcap/foundation-utils": "14.488.1",
     "@microsoft/fast-foundation": "2.50.0"
   },
   "repository": {
@@ -73,5 +73,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "621daeb7e3612007d300f8510bb6d12b80a5cb53"
+  "gitHead": "59f08be328928035b4591fa97da580cc650f96c3"
 }