@genesislcap/foundation-ai 15.6.2 → 15.7.0-ts7.1

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

@@ -3,6 +3,7 @@ import { SUPPORTED_GEMINI_MODEL_IDS, } from '../types';
 import { logger } from '../utils/logger';
 import { scaleTemperature } from '../utils/temperature';
 import { ResponseTruncatedError } from './anthropic-transport';
+import { VENDOR_LABELS } from './budget-exhausted-error';
 import { repairMalformedFunctionCall } from './gemini-malformed-call';
 import { postWithRetry } from './post-with-retry';
 const GEMINI_DIRECT_URL = (model) => `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent`;
@@ -207,7 +208,8 @@ export class GeminiTransport {
     // ── ChatTransport (multi-turn chat) ────────────────────────────────────
     sendChatMessage(history, userMessage, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
+            var _a;
+            var _b;
             // NOTE: `options.cachePolicy` is intentionally NOT read here. Gemini 2.5+ does *implicit*
             // caching automatically and always-on — it caches as much of the stable request prefix as it
             // can on every call, regardless of the policy's `scope` (including `'default'`). We issue no
@@ -309,7 +311,8 @@ export class GeminiTransport {
         return totalCost;
     }
     toGeminiContents(history, userMessage, attachments) {
-        var _a, _b, _c;
+        var _a, _b;
+        var _c;
         const contents = [];
         // Gemini requires functionResponse.name to match the original functionCall.name.
         // Our internal IDs are UUIDs, so build a lookup from ID → function name as we go.
@@ -326,7 +329,7 @@ export class GeminiTransport {
                 continue;
             const role = msg.role === 'user' ? 'user' : 'model';
             if (msg.toolResult) {
-                const fnName = (_a = toolCallNameById.get(msg.toolResult.toolCallId)) !== null && _a !== void 0 ? _a : msg.toolResult.toolCallId;
+                const fnName = (_c = toolCallNameById.get(msg.toolResult.toolCallId)) !== null && _c !== void 0 ? _c : msg.toolResult.toolCallId;
                 contents.push({
                     role: 'user',
                     parts: [
@@ -339,7 +342,7 @@ export class GeminiTransport {
                     ],
                 });
             }
-            else if ((_b = msg.toolCalls) === null || _b === void 0 ? void 0 : _b.length) {
+            else if ((_a = msg.toolCalls) === null || _a === void 0 ? void 0 : _a.length) {
                 for (const tc of msg.toolCalls) {
                     toolCallNameById.set(tc.id, tc.name);
                 }
@@ -366,7 +369,7 @@ export class GeminiTransport {
                     }),
                 });
             }
-            else if (role === 'user' && ((_c = msg.attachments) === null || _c === void 0 ? void 0 : _c.length)) {
+            else if (role === 'user' && ((_b = msg.attachments) === null || _b === void 0 ? void 0 : _b.length)) {
                 const msgAttachmentParts = msg.attachments.map((att) => ({
                     text: `[File: ${att.name}]\n${att.content}`,
                 }));
@@ -420,11 +423,12 @@ export class GeminiTransport {
         };
     }
     fromGeminiResponse(response, offeredToolNames = new Set()) {
-        var _a, _b, _c, _d;
+        var _a, _b;
+        var _c, _d;
         const { inputTokens, outputTokens, thoughtsTokens, cacheReadTokens, cost } = this.usageFromGemini(response.usageMetadata);
         const candidates = response === null || response === void 0 ? void 0 : response.candidates;
         const firstCandidate = candidates === null || candidates === void 0 ? void 0 : candidates[0];
-        const parts = (_b = (_a = firstCandidate === null || firstCandidate === void 0 ? void 0 : firstCandidate.content) === null || _a === void 0 ? void 0 : _a.parts) !== null && _b !== void 0 ? _b : [];
+        const parts = (_c = (_a = firstCandidate === null || firstCandidate === void 0 ? void 0 : firstCandidate.content) === null || _a === void 0 ? void 0 : _a.parts) !== null && _c !== void 0 ? _c : [];
         const toolCalls = [];
         const thoughtParts = [];
         const textParts = [];
@@ -441,7 +445,7 @@ export class GeminiTransport {
                 toolCalls.push({
                     id: crypto.randomUUID(),
                     name: part.functionCall.name,
-                    args: (_c = part.functionCall.args) !== null && _c !== void 0 ? _c : {},
+                    args: (_d = part.functionCall.args) !== null && _d !== void 0 ? _d : {},
                     providerMetadata: { [GEMINI_PROVIDER_KEY]: state },
                 });
             }
@@ -502,7 +506,7 @@ export class GeminiTransport {
         // Surface the provider diagnostic on the message so the driver can fold it
         // into the debug-log meta events (the console log above is dev-only). Only
         // when there's signal — a finish reason, thinking tokens, or a block reason.
-        const blockReason = (_d = response.promptFeedback) === null || _d === void 0 ? void 0 : _d.blockReason;
+        const blockReason = (_b = response.promptFeedback) === null || _b === void 0 ? void 0 : _b.blockReason;
         if (finishReason != null || thoughtsTokens != null || blockReason != null) {
             base.responseMeta = {
                 finishReason,
@@ -550,9 +554,10 @@ export class GeminiTransport {
      * without answering" signature.
      */
     logAbnormalResponse(response, parsed) {
-        var _a, _b, _c;
-        const usage = ((_a = response.usageMetadata) !== null && _a !== void 0 ? _a : {});
-        const candidate = (_c = (_b = response.candidates) === null || _b === void 0 ? void 0 : _b[0]) !== null && _c !== void 0 ? _c : {};
+        var _a;
+        var _b, _c;
+        const usage = ((_b = response.usageMetadata) !== null && _b !== void 0 ? _b : {});
+        const candidate = (_c = (_a = response.candidates) === null || _a === void 0 ? void 0 : _a[0]) !== null && _c !== void 0 ? _c : {};
         logger.warn('GeminiTransport: blank/non-STOP response', {
             model: this.model,
             finishReason: parsed.finishReason,
@@ -604,7 +609,7 @@ export class GeminiTransport {
                 headers,
                 body: payload,
                 credentials,
-                vendorLabel: 'Gemini',
+                vendorLabel: VENDOR_LABELS.gemini,
                 retryableStatuses: GeminiTransport.RETRYABLE_STATUSES,
                 timeout: this.timeout,
                 stallTimeout: this.stallTimeout,

package/dist/esm/transports/post-with-retry.js

@@ -3,6 +3,7 @@ import { authoritativeAbortReason } from '../utils/abort-reason';
 import { abortableDelay } from '../utils/abortable-delay';
 import { combineSignals } from '../utils/combine-signals';
 import { logger } from '../utils/logger';
+import { budgetExhaustedFrom, codeOf, isBudgetRejection, parseJsonOrUndefined, } from './budget-exhausted-error';
 import { readFramedBody } from './ndjson-frames';
 const MAX_RETRIES = 5;
 /**
@@ -15,7 +16,8 @@ const MAX_RETRIES = 5;
  */
 export function postWithRetry(options) {
     return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b, _c, _d;
+        var _a, _b;
+        var _c, _d;
         const { url, headers, body, credentials, vendorLabel, retryableStatuses, timeout, stallTimeout, backoffBaseMs, signal, } = options;
         // Exponential backoff between retries: base, 2×, 4×, 8×, 16×. Abortable on the
         // CALLER signal only — the timeout is cleared before each backoff, so a caller
@@ -56,15 +58,44 @@ export function postWithRetry(options) {
                     signal: combinedSignal,
                     credentials,
                 });
-                if (retryableStatuses.includes(response.status) && attempt < MAX_RETRIES) {
-                    logger.warn(`${vendorLabel}Transport: retryable status ${response.status}, retrying (attempt ${attempt + 1}/${MAX_RETRIES})`);
-                    clearTimeout(timeoutId); // this attempt is over — don't let its timer tick through the backoff
-                    yield backoff(attempt);
-                    continue;
-                }
                 if (!response.ok) {
-                    const err = yield response.text();
-                    throw new Error(`${vendorLabel} request error ${response.status}: ${err}`);
+                    // One read of the error body per failing attempt — it feeds BOTH the
+                    // budget classification and the thrown message, and the response is
+                    // discarded either way. Note this means a retryable attempt now reads
+                    // the (small, proxy-authored) error body before backing off. That is the
+                    // price of the classification winning over the ladder in this branch as
+                    // well as the framed one; the attempt's wall-clock timer is still armed
+                    // and the read runs on the fetch's combined signal, so a pathological
+                    // non-terminating body times out rather than hanging.
+                    //
+                    // That timeout is a real behaviour change for a RETRYABLE status, and the
+                    // accepted cost of the symmetry: a 503 used to reach the ladder without
+                    // the body being touched, so a non-terminating one still backed off and
+                    // retried. Now the abort propagates out of `postWithRetry` instead.
+                    // Acceptable because these bodies are proxy-authored and small — if that
+                    // ever stops being true, read the body only when the status is
+                    // non-retryable or already budget-shaped.
+                    const errText = yield response.text();
+                    const parsed = parseJsonOrUndefined(errText);
+                    // The budget wall (GENC-1464) wins over ANY status-based retry — the same
+                    // rule the framed branch below applies, now symmetric. It must be
+                    // classified BEFORE the ladder, not after it: 402 is absent from every
+                    // RETRYABLE_STATUSES today, but a proxy that maps the refusal onto a
+                    // retryable status (or a future set that includes 402) would otherwise
+                    // cost five doomed requests and ~31s of backoff before an opaque error —
+                    // exactly the bug this classification exists to remove. Parsing is
+                    // best-effort: an unparseable or plain-text 402 still classifies, just
+                    // without the budget/spent figures.
+                    if (isBudgetRejection(response.status, codeOf(parsed))) {
+                        throw budgetExhaustedFrom(vendorLabel, parsed, errText || undefined);
+                    }
+                    if (retryableStatuses.includes(response.status) && attempt < MAX_RETRIES) {
+                        logger.warn(`${vendorLabel}Transport: retryable status ${response.status}, retrying (attempt ${attempt + 1}/${MAX_RETRIES})`);
+                        clearTimeout(timeoutId); // this attempt is over — don't let its timer tick through the backoff
+                        yield backoff(attempt);
+                        continue;
+                    }
+                    throw new Error(`${vendorLabel} request error ${response.status}: ${errText}`);
                 }
                 // The proxy streams NDJSON heartbeat frames when it supports them; an old
                 // proxy ignores our Accept header and returns plain JSON, so branch on
@@ -83,6 +114,15 @@ export function postWithRetry(options) {
                         // local stall, so the driver's TimeoutError branch handles both.
                         throw new DOMException(`${vendorLabel} request stalled: ${(_c = frame.error) !== null && _c !== void 0 ? _c : 'no upstream data'}`, 'TimeoutError');
                     }
+                    // The budget wall, framed (GENC-1464) — the in-band twin of the 402 above,
+                    // through the same predicate, keyed on status OR code. Classified before
+                    // the retryable ladder for the same reason UPSTREAM_STALLED is: the
+                    // classification must win over any status-based retry. That ordering is
+                    // no longer unique to this branch — the legacy branch above now applies
+                    // the identical rule, so the two read as one policy rather than two.
+                    if (isBudgetRejection(frame.status, frame.code)) {
+                        throw budgetExhaustedFrom(vendorLabel, frame);
+                    }
                     // An in-band retryable status joins the same attempt/backoff ladder as
                     // its HTTP-status equivalent (shared attempt counter).
                     if (retryableStatuses.includes(frame.status) && attempt < MAX_RETRIES) {

package/dist/esm/transports/server-openai-transport.js

@@ -1,4 +1,5 @@
 import { __awaiter } from "tslib";
+import { budgetExhaustedFrom, codeOf, isBudgetRejection, parseJsonOrUndefined, VENDOR_LABELS, } from './budget-exhausted-error';
 const AI_SERVER_PATH = '/gwf/ai-service/chat-completions';
 const DEFAULT_MODEL = 'gpt-4o-mini';
 const DEFAULT_TIMEOUT = 30000;
@@ -56,6 +57,24 @@ export class ServerOpenAITransport {
             clearTimeout(timeoutId);
             if (!response.ok) {
                 const err = yield response.text();
+                const parsed = parseJsonOrUndefined(err);
+                // This transport does its own bare `fetch` rather than going through
+                // `postWithRetry` (it has no retry ladder, no stall timer and no framed
+                // mode), so it would otherwise be the one proxy call where a 402 stays an
+                // opaque `AI proxy error 402`. Classify it through the same shared
+                // predicate the envelope uses, so the typed error is uniform across
+                // transports even though the envelope is not.
+                //
+                // Scope, stated plainly: this transport serves only `sendStructuredPrompt`
+                // — it has no `chat()` — and its single caller
+                // (`OpenAIProvider.interpretCriteria`) catches everything and returns
+                // null. So a 402 here degrades smart-search silently and can never latch
+                // the assistant's `blocked` state, before or after this change. The typed
+                // throw improves the log line and any host that catches it directly. See
+                // `docs/migration-GENC-1464.md` §"Transport coverage".
+                if (isBudgetRejection(response.status, codeOf(parsed))) {
+                    throw budgetExhaustedFrom(VENDOR_LABELS.openai, parsed, err || undefined);
+                }
                 throw new Error(`AI proxy error ${response.status}: ${err}`);
             }
             const data = (yield response.json());