maka-agent 0.2.0-dev.9.20260831 → 0.2.1-dev.82.20261014

package/node_modules/@maka/runtime/dist/provider-error-classification.js

@@ -17,8 +17,11 @@
  * under the License.
  */
 import { RetryError } from 'ai';
+import { MODEL_FAILURE_MESSAGE_MAX_BYTES } from '@maka/core/model-failure';
 import { truncateUtf8 } from '@maka/core/diagnostic-log';
-import { isAuthenticationErrorText, redactSecrets } from '@maka/core/redaction';
+import { isAuthenticationErrorText } from '@maka/core/redaction';
+import { providerRetryDecision, responseHeadersFromError } from './provider-retry-policy.js';
+import { OPENAI_RESPONSES_TRANSPORT_CODES, PROVIDER_BILLING_PROVIDER_CODES, } from './provider-error-signals.js';
 /**
  * Structured provider error identifiers that mean the INPUT exceeded the
  * model's context window. These come from the provider's error JSON and are
@@ -45,6 +48,17 @@ const TRANSPORT_FAILURE_CODES = new Set([
     'EHOSTUNREACH',
     'ENETUNREACH',
 ]);
+// A successful status acknowledges the headers, not a complete response body.
+// Unlike pre-response failures, require an explicit interruption code here:
+// neither SDK retryability nor arbitrary TLS/undici errors prove a transient cut.
+const RESPONSE_TRANSPORT_FAILURE_CODES = new Set([
+    'ECONNRESET',
+    'EPIPE',
+    'ETIMEDOUT',
+    'ECONNABORTED',
+    'UND_ERR_SOCKET',
+    'UND_ERR_BODY_TIMEOUT',
+]);
 /**
  * xAI emits this code for transient model capacity failures, including when
  * the same payload is relayed through an OpenAI-compatible gateway. Do not
@@ -52,18 +66,6 @@ const TRANSPORT_FAILURE_CODES = new Set([
  * represents quota exhaustion and needs different user guidance.
  */
 const PROVIDER_CAPACITY_CODES = new Set(['resource-exhausted']);
-/**
- * Structured provider error identifiers that mean an ACCOUNT-level usage or
- * billing condition — exhausted credits or a closed plan/quota window —
- * rather than an invalid credential. Providers disagree on which HTTP status
- * travels with them (402, 401/403, even 429); the structured code is the
- * stable evidence, so it outranks every numeric fallback below.
- */
-const PROVIDER_BILLING_PROVIDER_CODES = new Set([
-    'insufficient_quota', // OpenAI & OpenAI-compatible: error.code
-    'insufficient_balance', // DeepSeek: error.code
-    'quota_exceeded', // OpenAI-compatible variants: error.code
-]);
 /**
  * Free-text usage/billing wording that overrides a credential-shaped HTTP
  * status (401/403): some providers report exhausted plan windows, credits,
@@ -80,26 +82,21 @@ const USAGE_LIMIT_TEXT_PATTERNS = [
     /(?:credit|balance|allowance)[^.]{0,40}(?:exhaust|reached)|exhaust[^.]{0,20}(?:credit|balance)/i,
     /subscription/i,
 ];
-const PROVIDER_FAILURE_SUMMARY_MAX_BYTES = 2 * 1024;
 const PROVIDER_FAILURE_FIELD_MAX_BYTES = 256;
-const MAX_SAFE_TIMER_DELAY_MS = 2_147_483_647;
-const OPENAI_RESPONSES_WEBSOCKET_TRANSPORT_ERROR = 'OPENAI_RESPONSES_WEBSOCKET_TRANSPORT_ERROR';
-const RUNTIME_RETRYABLE_ERROR_CODES = new Set([
-    OPENAI_RESPONSES_WEBSOCKET_TRANSPORT_ERROR,
-    'OPENAI_RESPONSES_CONTINUATION_UNAVAILABLE',
-]);
 function providerErrorTarget(error) {
     return RetryError.isInstance(error) && error.lastError !== undefined && error.lastError !== error
         ? error.lastError
         : error;
 }
 function isTransportFailure(target, statusCode) {
-    if (statusCode)
+    const successfulResponse = /^2\d\d$/.test(statusCode);
+    if (statusCode && !successfulResponse)
         return false;
     const record = objectRecord(target);
     if (!record)
         return false;
-    if (target instanceof Error &&
+    if (!successfulResponse &&
+        target instanceof Error &&
         target.name === 'AI_APICallError' &&
         safeField(record, 'isRetryable') === true) {
         return true;
@@ -111,91 +108,42 @@ function isTransportFailure(target, statusCode) {
         const currentRecord = objectRecord(current);
         if (!currentRecord)
             return false;
+        if (successfulResponse) {
+            const nestedStatus = safeField(currentRecord, 'statusCode') ?? safeField(currentRecord, 'status');
+            // Do not reinterpret a cancellation or a nested HTTP rejection as a
+            // recoverable body interruption merely because it has a socket cause.
+            if (safeField(currentRecord, 'name') === 'AbortError' ||
+                ((typeof nestedStatus === 'number' || typeof nestedStatus === 'string') &&
+                    nestedStatus !== '' &&
+                    !/^2\d\d$/.test(String(nestedStatus)))) {
+                return false;
+            }
+        }
         const code = safeField(currentRecord, 'code');
         if (typeof code === 'string' &&
-            (TRANSPORT_FAILURE_CODES.has(code) ||
-                code.startsWith('ERR_SSL_') ||
-                code.startsWith('ERR_TLS_') ||
-                code.startsWith('UND_ERR_'))) {
+            (successfulResponse
+                ? RESPONSE_TRANSPORT_FAILURE_CODES.has(code)
+                : TRANSPORT_FAILURE_CODES.has(code) ||
+                    code.startsWith('ERR_SSL_') ||
+                    code.startsWith('ERR_TLS_') ||
+                    code.startsWith('UND_ERR_'))) {
             return true;
         }
         current = safeField(currentRecord, 'cause');
     }
     return false;
 }
-function responseHeadersFromError(error) {
-    if (typeof error !== 'object' || error === null)
-        return undefined;
-    const value = error.responseHeaders;
-    if (typeof value !== 'object' || value === null)
-        return undefined;
-    const headers = {};
-    for (const [key, header] of Object.entries(value)) {
-        if (typeof header === 'string')
-            headers[key.toLowerCase()] = header;
-    }
-    return headers;
-}
-function parseRetryAfterMs(headers) {
-    const rawMilliseconds = headers['retry-after-ms'];
-    const rawRetryAfter = headers['retry-after'];
-    if (rawMilliseconds === undefined && rawRetryAfter === undefined)
-        return undefined;
-    let delayMs;
-    if (rawMilliseconds !== undefined) {
-        delayMs = Number(rawMilliseconds);
-    }
-    else {
-        const seconds = Number(rawRetryAfter);
-        delayMs = Number.isFinite(seconds) ? seconds * 1_000 : Date.parse(rawRetryAfter) - Date.now();
-    }
-    if (!Number.isFinite(delayMs) || delayMs <= 0 || delayMs > MAX_SAFE_TIMER_DELAY_MS)
-        return null;
-    return Math.ceil(delayMs);
-}
-/**
- * Normalizes provider retry facts without leaking SDK error objects or raw
- * response headers across the ModelAdapter boundary.
- */
-export function providerRetryMetadata(error) {
-    const facts = normalizeProviderError(error);
-    if (!facts)
+function retryMetadataFromFacts(facts, errorClass = classifyProviderFacts(facts)) {
+    if (facts.aborted)
         return { retryable: false };
-    const { evidence } = facts;
-    if (RUNTIME_RETRYABLE_ERROR_CODES.has(evidence.code))
-        return { retryable: true };
     // The Codex transport already spent its complete 2/10/30-second budget.
     // Do not let the outer model loop restart that same transport budget.
     if (isTrustedCodexEdgeRejection(facts))
         return { retryable: false };
-    const status = Number(evidence.statusCode || evidence.code);
-    const errorClass = classifyProviderFacts(facts);
-    const retryAfterMs = parseRetryAfterMs(facts.responseHeaders ?? {});
-    if (errorClass === 'ProviderCapacity') {
-        // Capacity is transient even when the provider sends a malformed delay;
-        // fall back to the adapter's bounded local backoff in that case.
-        return {
-            retryable: true,
-            ...(retryAfterMs !== undefined && retryAfterMs !== null ? { retryAfterMs } : {}),
-        };
-    }
-    if (errorClass === 'RateLimit' || status === 429) {
-        if (retryAfterMs === undefined || retryAfterMs === null)
-            return { retryable: false };
-        return { retryable: true, retryAfterMs };
-    }
-    const retryable = errorClass === 'Network' ||
-        errorClass === 'ProviderUnavailable' ||
-        status === 408 ||
-        status === 409 ||
-        (status >= 500 && status <= 599);
-    if (!retryable)
-        return { retryable: false };
-    if (retryAfterMs === null)
-        return { retryable: false };
+    const decision = providerRetryDecision(errorClass, facts.responseHeaders ?? {});
     return {
-        retryable: true,
-        ...(retryAfterMs !== undefined ? { retryAfterMs } : {}),
+        retryable: decision.reason !== null,
+        ...(decision.retryAfterMs === undefined ? {} : { retryAfterMs: decision.retryAfterMs }),
     };
 }
 /** Collects `code`/`type` strings from a payload and from its `error` wrapper. */
@@ -312,15 +260,7 @@ function normalizeProviderError(error) {
     }
     return undefined;
 }
-/**
- * Retains only allowlisted provider failure fields. The provider value may also
- * contain request bodies, headers, or credentials, so it must never be copied
- * or serialized as diagnostic output wholesale.
- */
-export function providerFailureSummary(error) {
-    const facts = normalizeProviderError(error);
-    if (!facts)
-        return undefined;
+function failureSummaryFromFacts(facts) {
     const sources = facts.summarySources;
     const message = firstProviderMessage(facts);
     const code = firstProviderField(sources, ['code']) ?? firstProviderField(sources, ['type']);
@@ -335,41 +275,25 @@ export function providerFailureSummary(error) {
     if (!message && metadata.length === 0)
         return undefined;
     const suffix = metadata.length > 0 ? ` (${metadata.join(', ')})` : '';
-    const messageBudget = Math.max(1, PROVIDER_FAILURE_SUMMARY_MAX_BYTES - Buffer.byteLength(suffix, 'utf8'));
-    const summary = `${truncateUtf8(redactSecrets(message ?? 'Provider request failed'), messageBudget, '…')}${suffix}`;
+    const messageBudget = Math.max(1, MODEL_FAILURE_MESSAGE_MAX_BYTES - Buffer.byteLength(suffix, 'utf8'));
+    const summary = `${truncateUtf8(message ?? 'Provider request failed', messageBudget, '…')}${suffix}`;
     return {
-        message: truncateUtf8(summary, PROVIDER_FAILURE_SUMMARY_MAX_BYTES, '…'),
+        message: truncateUtf8(summary, MODEL_FAILURE_MESSAGE_MAX_BYTES, '…'),
         ...(code || statusCode ? { code: code ?? statusCode } : {}),
     };
 }
-const DURABLE_PROVIDER_ERROR_CLASSES = new Set([
-    'Abort',
-    'Auth',
-    'ContextLength',
-    'Network',
-    'ProviderCapacity',
-    'ProviderBilling',
-    'ProviderUnavailable',
-    'RateLimit',
-    'Timeout',
-]);
 /**
  * Projects provider errors into a small durable fingerprint. Unlike the
  * presentation summary, this intentionally excludes provider messages and
- * response bodies: even redacted free text can echo prompts or credentials.
+ * response bodies: free text can echo prompts or credentials.
  */
 export function providerFailureDiagnostic(error) {
-    const facts = providerFailureDiagnosticFacts(error);
+    const facts = extractProviderErrorFacts(error);
     if (!facts)
-        return { errorClass: 'Other', retryable: false };
+        return { errorClass: 'unknown', retryable: false };
     const sources = facts.summarySources;
-    const rawStatus = facts.evidence.statusCode || firstProviderField(sources, ['statusCode', 'status']);
-    const numericStatus = Number(rawStatus);
-    const httpStatus = Number.isInteger(numericStatus) && numericStatus >= 100 && numericStatus <= 599
-        ? numericStatus
-        : undefined;
-    const classified = classifyProviderFacts(facts);
-    const errorClass = durableProviderErrorClass(facts, classified, httpStatus);
+    const httpStatus = providerHttpStatus(facts);
+    const errorClass = classifyProviderFacts(facts);
     const providerCode = firstProviderField(sources, ['code']) ?? firstProviderField(sources, ['type']);
     const providerRequestId = firstProviderField(sources, ['requestId', 'request_id']) ??
         boundedProviderField(facts.responseHeaders?.['x-request-id']);
@@ -378,36 +302,14 @@ export function providerFailureDiagnostic(error) {
         ...(httpStatus !== undefined ? { httpStatus } : {}),
         ...(providerCode !== undefined ? { providerCode } : {}),
         ...(providerRequestId !== undefined ? { providerRequestId } : {}),
-        retryable: providerRetryMetadata(facts.target).retryable,
+        retryable: retryMetadataFromFacts(facts, errorClass).retryable,
     };
 }
-function durableProviderErrorClass(facts, classified, httpStatus) {
-    // Structured context-overflow and capacity evidence can legitimately arrive
-    // behind a generic 4xx/5xx proxy response and remains stronger than the wrapper code.
-    if (classified === 'ContextLength' ||
-        classified === 'ProviderCapacity' ||
-        (classified === 'ProviderUnavailable' && isTrustedCodexEdgeRejection(facts))) {
-        return classified;
-    }
-    if (httpStatus === 401 || httpStatus === 403)
-        return 'Auth';
-    if (httpStatus === 402)
-        return 'ProviderBilling';
-    if (httpStatus === 408)
-        return 'Timeout';
-    if (httpStatus === 413)
-        return 'ContextLength';
-    if (httpStatus === 429)
-        return 'RateLimit';
-    if (httpStatus !== undefined && httpStatus >= 400 && httpStatus <= 499) {
-        return 'RequestRejected';
+function extractProviderErrorFacts(error) {
+    if (RetryError.isInstance(error) && error.reason === 'abort') {
+        const facts = normalizeProviderError(error);
+        return facts ? { ...facts, aborted: true } : undefined;
     }
-    if (httpStatus !== undefined && httpStatus >= 500 && httpStatus <= 599) {
-        return 'ProviderUnavailable';
-    }
-    return DURABLE_PROVIDER_ERROR_CLASSES.has(classified) ? classified : 'Other';
-}
-function providerFailureDiagnosticFacts(error) {
     let current = providerErrorTarget(error);
     let fallback;
     let codedFallback;
@@ -503,7 +405,7 @@ function boundedProviderField(value) {
     const normalized = String(value).trim();
     if (!normalized)
         return undefined;
-    return truncateUtf8(redactSecrets(normalized), PROVIDER_FAILURE_FIELD_MAX_BYTES, '…');
+    return truncateUtf8(normalized, PROVIDER_FAILURE_FIELD_MAX_BYTES, '…');
 }
 function boundedProviderMessage(value, parseJson = true) {
     if (typeof value !== 'string')
@@ -531,7 +433,7 @@ function boundedProviderMessage(value, parseJson = true) {
     }
     if (!normalized)
         return undefined;
-    return truncateUtf8(redactSecrets(normalized), PROVIDER_FAILURE_SUMMARY_MAX_BYTES, '…');
+    return truncateUtf8(normalized, MODEL_FAILURE_MESSAGE_MAX_BYTES, '…');
 }
 /**
  * Provider context-length overflow signatures. A request-level 400/413 whose
@@ -567,6 +469,7 @@ const CONTEXT_OVERFLOW_PATTERNS = [
     /greater than the context length/i, // LM Studio
     /context window exceeds limit/i, // MiniMax
     /exceeded model token limit/i, // Kimi For Coding
+    /exceeded [\w.-]+ model token limit:\s*[\d,]+/i, // Kimi model-qualified limit
     /too large for model with \d+ maximum context length/i, // Mistral
     /prompt has [\d,]+ tokens?, but the configured context size is [\d,]+ tokens?/i, // DS4 server
     /model_context_window_exceeded/i, // z.ai non-standard finish_reason surfaced as error text
@@ -633,110 +536,129 @@ export function isContextOverflowErrorText(text) {
  * wrap a provider failure in a misleading status or message; the weak
  * heuristics rank last so "generate" can never become a rate limit.
  */
+export function providerModelFailure(error) {
+    const facts = extractProviderErrorFacts(error);
+    const kind = facts ? classifyProviderFacts(facts) : 'unknown';
+    const summary = facts ? failureSummaryFromFacts(facts) : undefined;
+    const retry = facts ? retryMetadataFromFacts(facts, kind) : { retryable: false };
+    return {
+        type: 'model_failure',
+        kind,
+        ...retry,
+        ...(summary?.code !== undefined ? { code: summary.code } : {}),
+        message: summary?.message ?? 'Model request failed',
+    };
+}
 export function classifyError(error) {
-    if (RetryError.isInstance(error) && error.reason === 'abort')
-        return 'Abort';
-    const facts = normalizeProviderError(error);
-    return facts ? classifyProviderFacts(facts) : 'Other';
+    const facts = extractProviderErrorFacts(error);
+    return facts ? classifyProviderFacts(facts) : 'unknown';
 }
 function classifyProviderFacts(facts) {
-    const { target: classificationTarget, evidence } = facts;
+    if (facts.aborted)
+        return 'abort';
+    const { evidence } = facts;
     const { text, statusCode, code, structuredCodes } = evidence;
     const normalizedCode = code.toLowerCase();
-    if (code === OPENAI_RESPONSES_WEBSOCKET_TRANSPORT_ERROR)
-        return 'Network';
+    if (OPENAI_RESPONSES_TRANSPORT_CODES.has(code))
+        return 'network';
+    if (code === 'MODEL_STREAM_TIMEOUT')
+        return 'timeout';
+    if (structuredCodes.includes('gateway_stream_terminated'))
+        return 'stream_truncated';
     if (PROVIDER_CAPACITY_CODES.has(normalizedCode) ||
         structuredCodes.some((c) => PROVIDER_CAPACITY_CODES.has(c))) {
-        return 'ProviderCapacity';
+        return 'provider_capacity';
     }
     // Structured provider evidence: the parsed error JSON's code/type is the
     // only unconditional signal for a context overflow.
     if (structuredCodes.some((c) => CONTEXT_OVERFLOW_PROVIDER_CODES.has(c)))
-        return 'ContextLength';
+        return 'context_overflow';
     if (PROVIDER_BILLING_PROVIDER_CODES.has(normalizedCode) ||
         structuredCodes.some((c) => PROVIDER_BILLING_PROVIDER_CODES.has(c))) {
-        return 'ProviderBilling';
+        return 'provider_billing';
     }
     if (text.includes('abort'))
-        return 'Abort';
+        return 'abort';
     if (statusCode === '402' || code === '402')
-        return 'ProviderBilling';
+        return 'provider_billing';
     if (statusCode === '429' || code === '429')
-        return 'RateLimit';
+        return 'rate_limit';
     if (structuredCodes.includes(OPENAI_CODEX_EDGE_REJECTION_CODE) &&
         isTrustedCodexEdgeRejection(facts)) {
-        return 'ProviderUnavailable';
+        return 'provider_unavailable';
     }
     if (statusCode === '401' || statusCode === '403' || code === '401' || code === '403') {
         // Credential-shaped statuses can still carry account-level usage
         // evidence: an exhausted plan/credit window for a validly signed-in
         // user must not tell them to re-authenticate (#2516).
         if (USAGE_LIMIT_TEXT_PATTERNS.some((pattern) => pattern.test(text))) {
-            return 'ProviderBilling';
+            return 'provider_billing';
         }
-        return 'Auth';
+        return 'auth';
     }
     if (statusCode === '413' || code === '413')
-        return 'ContextLength';
+        return 'context_overflow';
     // Free-text overflow relations on the composite text, veto-first inside.
     if (isContextOverflowErrorText(text))
-        return 'ContextLength';
+        return 'context_overflow';
     if (/^5\d\d$/.test(statusCode) || /^5\d\d$/.test(code))
-        return 'ProviderUnavailable';
+        return 'provider_unavailable';
     if (structuredCodes.some((c) => PROVIDER_UNAVAILABLE_PROVIDER_CODES.has(c))) {
-        return 'ProviderUnavailable';
+        return 'provider_unavailable';
     }
     if (evidence.transportFailure)
-        return 'Network';
+        return 'network';
+    if (isTruncatedStreamText(text))
+        return 'stream_truncated';
+    const httpStatus = providerHttpStatus(facts);
+    if (httpStatus === 408)
+        return 'timeout';
+    if (httpStatus !== undefined && httpStatus >= 500 && httpStatus <= 599) {
+        return 'provider_unavailable';
+    }
+    if (httpStatus !== undefined && httpStatus >= 400 && httpStatus <= 499) {
+        return 'request_rejected';
+    }
     // Weak word heuristics, last: they only catch errors that carried no
     // stronger evidence for any other class. `rate` must be word-shaped
     // ("generate"/"separate" are not rate limits) while still matching the
     // rate_limit/RateLimitError identifier spellings.
     if (/\brate\b|rate[_-]?limit/.test(text))
-        return 'RateLimit';
+        return 'rate_limit';
     if (isAuthenticationErrorText(text))
-        return 'Auth';
+        return 'auth';
     if (text.includes('timeout'))
-        return 'Timeout';
+        return 'timeout';
     if (text.includes('network') ||
         text.includes('fetch') ||
         /\btypeerror\b.*\bterminated\b/.test(text))
-        return 'Network';
-    return classificationTarget instanceof Error ? classificationTarget.name || 'Other' : 'Other';
+        return 'network';
+    return 'unknown';
+}
+function isTruncatedStreamText(text) {
+    return (text.includes('response stream ended without a finish reason') ||
+        text.includes('model stream ended without a finish chunk') ||
+        (text.includes('stream disconnected before completion') &&
+            text.includes('stream closed before response.completed')));
+}
+function providerHttpStatus(facts) {
+    const raw = facts.evidence.statusCode || firstProviderField(facts.summarySources, ['statusCode', 'status']);
+    const numeric = Number(raw);
+    return Number.isInteger(numeric) && numeric >= 100 && numeric <= 599 ? numeric : undefined;
 }
 function isTrustedCodexEdgeRejection(facts) {
     let current = facts.target;
     const seen = new Set();
     for (let depth = 0; depth < 5 && current !== undefined && !seen.has(current); depth += 1) {
         seen.add(current);
-        if (current instanceof Error && current.name === 'OpenAiCodexEdgeRejectionError')
+        if (current instanceof Error &&
+            safeField(current, 'name') ===
+                'OpenAiCodexEdgeRejectionError')
             return true;
         current =
             typeof current === 'object' && current !== null
-                ? current.cause
+                ? safeField(current, 'cause')
                 : undefined;
     }
     return false;
 }
-export function errorPresentationFromClass(errorClass) {
-    switch (errorClass) {
-        case 'ContextLength':
-            return { reason: 'context_overflow', message: 'Context window exceeded' };
-        case 'Timeout':
-            return { reason: 'timeout', message: 'Request timed out' };
-        case 'Auth':
-            return { reason: 'auth', message: 'Authentication failed' };
-        case 'ProviderBilling':
-            return { reason: 'provider_billing', message: 'Provider billing required' };
-        case 'ProviderCapacity':
-            return { reason: 'provider_capacity', message: 'Model service is temporarily at capacity' };
-        case 'ProviderUnavailable':
-            return { reason: 'provider_unavailable', message: 'Provider returned an error' };
-        case 'RateLimit':
-            return { reason: 'rate_limit', message: 'Rate limit exceeded' };
-        case 'Network':
-            return { reason: 'network', message: 'Network error' };
-        default:
-            return {};
-    }
-}

package/node_modules/@maka/runtime/dist/provider-error-signals.js

@@ -0,0 +1,31 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+/** Provider codes that identify an account-level usage or billing condition. */
+export const PROVIDER_BILLING_PROVIDER_CODES = new Set([
+    'insufficient_quota',
+    'insufficient_balance',
+    'quota_exceeded',
+    'freeusagelimiterror',
+    'upgrade_required',
+]);
+/** Codes emitted by the incremental Responses transport before an HTTP response. */
+export const OPENAI_RESPONSES_TRANSPORT_CODES = new Set([
+    'OPENAI_RESPONSES_WEBSOCKET_TRANSPORT_ERROR',
+    'OPENAI_RESPONSES_CONTINUATION_UNAVAILABLE',
+]);

package/node_modules/@maka/runtime/dist/provider-image-overflow-recovery.js

@@ -16,50 +16,31 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+import { decodeEffectiveToolResultProjection, effectiveToolResultMedia, } from './durable-tool-result-projection.js';
 function isRecord(value) {
     return value !== null && typeof value === 'object';
 }
-function storageRefLabel(value) {
-    if (!isRecord(value) || typeof value.kind !== 'string')
-        return undefined;
-    if ((value.kind === 'session_file' || value.kind === 'workspace_file') &&
-        typeof value.relativePath === 'string' &&
-        value.relativePath.length > 0) {
-        return value.relativePath;
-    }
-    if (value.kind === 'session_context' &&
-        typeof value.refId === 'string' &&
-        value.refId.length > 0) {
-        return value.refId;
-    }
-    if (value.kind === 'external_file' &&
-        typeof value.absolutePath === 'string' &&
-        value.absolutePath.length > 0) {
-        return value.absolutePath;
-    }
-    return undefined;
-}
+/**
+ * The image Tool Results a rejected request can give back, read through the
+ * same decode the budget measures — not from the raw execution fact, which the
+ * durable projection may already have bounded or redacted.
+ */
 export function collectHistoricalImageToolResults(events) {
     const collected = new Map();
     for (const event of events) {
         const content = event.content;
         if (content?.kind !== 'function_response' || content.isError === true)
             continue;
-        const result = content.result;
-        if (!isRecord(result) ||
-            result.kind !== 'image' ||
-            typeof result.mimeType !== 'string' ||
-            result.mimeType.length === 0) {
-            continue;
-        }
-        const artifactLabel = storageRefLabel(result.ref);
-        if (!artifactLabel)
+        const effective = decodeEffectiveToolResultProjection(content, event.sessionId);
+        const [media] = effectiveToolResultMedia(effective, event.sessionId);
+        if (!media || media.label.length === 0)
             continue;
-        collected.set(content.id, { toolName: content.name, artifactLabel });
+        collected.set(content.id, { toolName: content.name, artifactLabel: media.label });
     }
     return collected;
 }
-function isInlineImageFilePart(value) {
+/** A `file` part carrying inline image bytes, not a URL the provider fetches. */
+export function isInlineImageFilePart(value) {
     if (!isRecord(value) ||
         value.type !== 'file' ||
         typeof value.mediaType !== 'string' ||