@zergai/ztc 0.4.0-beta.1 → 0.5.0-beta.1

package/dist/agent/backends/http_error.js

@@ -0,0 +1,221 @@
+import { MAX_TIMER_DELAY_MS } from '../../config/api_retry.js';
+const BODY_BYTES = 16 * 1024;
+const DIAGNOSTIC_BYTES = 4 * 1024;
+const BODY_TIMEOUT_MS = 1000;
+const REDACTED = '[REDACTED]';
+const CREDENTIAL_NAME = 'x[-_]api[-_]key|api[-_]?key|access[-_]?token|refresh[-_]?token|token|password|passwd|client[-_]?secret|secret|authorization|proxy-authorization|cookie|set-cookie';
+const CREDENTIAL_KEY = new RegExp(`^(?:${CREDENTIAL_NAME})$`, 'i');
+const CREDENTIAL_ASSIGNMENT = new RegExp(`(?:["']?)(?:${CREDENTIAL_NAME})(?:["']?)\\s*[:=]\\s*`, 'i');
+/** Retains the canonical API-error envelope consumed by admission and OAuth adapters. */
+export class BackendHttpError extends Error {
+    status;
+    body;
+    httpError;
+    /** Transport control only; never copied into the public body diagnostic. */
+    retryAtMs;
+    constructor(status, body, options = {}) {
+        const raw = boundedText(body, BODY_BYTES);
+        const state = options.bodyReadState ?? (raw.truncated ? 'truncated' : 'complete');
+        const safe = boundedCanonicalBody(redact(raw.text, options.headers, state !== 'complete'));
+        super(`${options.prefix ?? 'API'} error (${status}): ${safe.text}`);
+        this.name = 'BackendHttpError';
+        this.status = status;
+        this.body = safe.text;
+        if (status === 429) {
+            const now = Date.now();
+            this.retryAtMs = parseRetryDeadline(options.retryAfter, now, true)
+                ?? parseRetryDeadline(options.rateLimitReset, now, false);
+        }
+        const diagnostic = boundedText(safe.text, DIAGNOSTIC_BYTES);
+        this.httpError = {
+            status,
+            body: diagnostic.text,
+            bodyTruncated: raw.truncated || safe.truncated || diagnostic.truncated || state !== 'complete',
+            bodyReadState: state,
+        };
+    }
+}
+function parseRetryDeadline(header, now, allowDate) {
+    if (header === undefined || header === null || header.length > 128)
+        return undefined;
+    const value = header.trim();
+    let delayMs;
+    if (/^\d+$/.test(value)) {
+        delayMs = Number(value) * 1000;
+    }
+    else if (allowDate && /^[A-Za-z]{3,9},? /.test(value)) {
+        // The obsolete asctime form has no zone; HTTP dates are always UTC.
+        const date = /^[A-Za-z]{3} [A-Za-z]{3} {1,2}\d{1,2} \d{2}:\d{2}:\d{2} \d{4}$/.test(value)
+            ? `${value} GMT` : value;
+        delayMs = Date.parse(date) - now;
+    }
+    else {
+        return undefined;
+    }
+    if (!Number.isFinite(delayMs))
+        return undefined;
+    return now + Math.min(MAX_TIMER_DELAY_MS, Math.max(0, delayMs));
+}
+/** Respect a server's minimum wait, then spread concurrent callers by up to one second. */
+export function retryAfterDelayMs(error) {
+    if (!(error instanceof BackendHttpError) || error.retryAtMs === undefined)
+        return 0;
+    const remaining = error.retryAtMs - Date.now();
+    if (remaining <= 0)
+        return 0;
+    return Math.min(MAX_TIMER_DELAY_MS, remaining + Math.floor(Math.random() * 1000));
+}
+/** Read at most 16 KiB, then cancel. A failed body never erases already-known status. */
+export async function readHttpErrorBody(response, signal) {
+    if (!response.body)
+        return { body: '', bodyReadState: 'complete' };
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let bytes = 0;
+    let body = '';
+    let bodyReadState = 'complete';
+    let stopRead;
+    const stopped = new Promise(resolve => { stopRead = resolve; });
+    const timer = setTimeout(() => stopRead('timeout'), BODY_TIMEOUT_MS);
+    const aborted = () => stopRead('failed');
+    signal?.addEventListener('abort', aborted, { once: true });
+    if (signal?.aborted)
+        aborted();
+    try {
+        while (true) {
+            const next = await Promise.race([reader.read(), stopped]);
+            if (typeof next === 'string') {
+                bodyReadState = next;
+                break;
+            }
+            if (next.done) {
+                body += decoder.decode();
+                break;
+            }
+            const remaining = BODY_BYTES - bytes;
+            body += decoder.decode(next.value.subarray(0, remaining), { stream: true });
+            bytes += Math.min(next.value.byteLength, remaining);
+            if (next.value.byteLength > remaining) {
+                bodyReadState = 'truncated';
+                break;
+            }
+        }
+    }
+    catch {
+        bodyReadState = 'failed';
+    }
+    finally {
+        clearTimeout(timer);
+        signal?.removeEventListener('abort', aborted);
+        // Cancellation is best-effort: a broken peer must not hold diagnostics open.
+        if (bodyReadState !== 'complete')
+            void reader.cancel().catch(() => { });
+        reader.releaseLock();
+    }
+    return { body, bodyReadState };
+}
+function boundedText(text, maxBytes) {
+    const bytes = Buffer.from(text);
+    if (bytes.length <= maxBytes)
+        return { text, truncated: false };
+    // Streaming decode drops a split final code point rather than exceeding the byte cap.
+    return { text: new TextDecoder().decode(bytes.subarray(0, maxBytes), { stream: true }), truncated: true };
+}
+function boundedCanonicalBody(text) {
+    const bounded = boundedText(text, BODY_BYTES);
+    if (!bounded.truncated)
+        return bounded;
+    try {
+        const value = JSON.parse(text);
+        if (!value || typeof value !== 'object' || Array.isArray(value))
+            return bounded;
+        const source = value;
+        // Redaction can expand a complete body. Retain the small canonical fields
+        // used by admission and Kimi rate-limit parsing instead of cutting JSON.
+        const keys = ['type', 'status', 'statusCode', 'code', 'message', 'detail', 'statusMessage', 'retry_after', 'resets_at', 'provider_dispatched', 'source', 'limit', 'resetSeconds'];
+        const project = (record) => Object.fromEntries(keys.flatMap(key => {
+            const item = record[key];
+            // 39 strings × 64 bytes × worst-case JSON escaping stays below 16 KiB.
+            return typeof item === 'string' ? [[key, boundedText(item, 64).text]]
+                : typeof item === 'number' || typeof item === 'boolean' ? [[key, item]] : [];
+        }));
+        const result = project(source);
+        for (const key of ['error', 'data']) {
+            const item = source[key];
+            if (item && typeof item === 'object' && !Array.isArray(item))
+                result[key] = project(item);
+            else if (typeof item === 'string')
+                result[key] = boundedText(item, 64).text;
+            else if (typeof item === 'boolean')
+                result[key] = item;
+        }
+        return { text: JSON.stringify(result), truncated: true };
+    }
+    catch {
+        return bounded;
+    }
+}
+function redact(text, headers, incomplete) {
+    const secrets = new Set();
+    for (const [name, value] of new Headers(headers)) {
+        if (!/authorization|api[-_]?key|token|secret|credential|cookie/i.test(name) || !value)
+            continue;
+        secrets.add(value);
+        if (/^(?:Bearer|Basic)\s+/i.test(value))
+            secrets.add(value.replace(/^\S+\s+/, ''));
+        if (/cookie/i.test(name)) {
+            for (const part of value.split(';')) {
+                const separator = part.indexOf('=');
+                if (separator >= 0 && part.slice(separator + 1).trim())
+                    secrets.add(part.slice(separator + 1).trim());
+            }
+        }
+    }
+    try {
+        // Decode strings first: credential labels embedded in JSON messages may be
+        // escaped on the wire. Sanitizing raw JSON could leave part of that value.
+        return JSON.stringify(JSON.parse(text, (key, value) => {
+            if (CREDENTIAL_KEY.test(key))
+                return REDACTED;
+            if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+                return Object.fromEntries(Object.entries(value).map(([name, item]) => [redactText(name, secrets, false), item]));
+            }
+            return typeof value === 'string' ? redactText(value, secrets, false) : value;
+        }));
+    }
+    catch {
+        // A cut JSON message can leave escaped quote delimiters around a credential
+        // label. Normalize those delimiters before the conservative raw-body pass.
+        return redactText(text.replace(/\\+(["'])/g, '$1'), secrets, incomplete);
+    }
+}
+function redactText(text, secrets, incomplete) {
+    if (incomplete) {
+        // An unfinished quoted credential can contain whitespace. None of the
+        // remaining tail is reliable as a delimiter, so keep only its label.
+        const assignment = CREDENTIAL_ASSIGNMENT.exec(text);
+        if (assignment)
+            text = text.slice(0, assignment.index + assignment[0].length) + REDACTED;
+    }
+    for (const secret of [...secrets].sort((a, b) => b.length - a.length)) {
+        for (const form of new Set([secret, JSON.stringify(secret).slice(1, -1), encodeURIComponent(secret)])) {
+            text = text.split(form).join(REDACTED);
+            if (incomplete) {
+                // A raw capture may end inside an echoed credential. Remove its suffix
+                // even when the full value never arrived inside our byte budget.
+                for (let start = text.lastIndexOf(form[0]); start >= 0; start = text.lastIndexOf(form[0], start - 1)) {
+                    if (form.startsWith(text.slice(start))) {
+                        text = text.slice(0, start) + REDACTED;
+                        break;
+                    }
+                    if (start === 0)
+                        break;
+                }
+            }
+        }
+    }
+    return text
+        .replace(/\b(Bearer|Basic)\s+[A-Za-z0-9._~+/=-]+/gi, '$1 [REDACTED]')
+        .replace(/((?:["']?)(?:x[-_]api[-_]key|api[-_]?key|access[-_]?token|refresh[-_]?token|token|password|passwd|client[-_]?secret|secret|authorization|proxy-authorization|cookie|set-cookie)(?:["']?)\s*[:=]\s*)("(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|[^\s,;}\]]+)/gi, (_match, key, value) => `${key}${value.startsWith('"') ? '"[REDACTED]"' : value.startsWith("'") ? "'[REDACTED]'" : REDACTED}`)
+        .replace(/\bsk-[A-Za-z0-9_-]+/g, REDACTED);
+}

package/dist/agent/backends/index.d.ts

@@ -1,4 +1,5 @@
-export { AnthropicBackend, AnthropicApiError } from './anthropic.js';
+export { AnthropicBackend, AnthropicApiError, createNativeAnthropicMessagesRouterBackend } from './anthropic.js';
+export type { NativeAnthropicMessagesRouterConfig } from './anthropic.js';
 export { OpenAIBackend } from './openai.js';
 export { OpenAICompatibleBackend } from './openai_compatible.js';
 export { OpenAIResponsesBackend } from './openai_responses.js';
@@ -14,7 +15,7 @@ export { ClarifaiBackend, normalizeClarifaiModel, CLARIFAI_BASE_URL } from './cl
 export { ClaudeCodeAuthBackend, ClaudeCodeAuthManager } from './claude_code_auth.js';
 export { KimiCodeAuthBackend, KimiCodeAuthManager, KIMI_CODE_AUTH_SENTINEL, KIMI_CODE_PROVIDER, hasUsableKimiCodeAuth } from './kimi_code_auth.js';
 export { ClaudeCliBackend, ClaudeCliError, CLAUDE_CODE_AUTH_SENTINEL, hasUsableClaudeCodeCliAuth as hasUsableClaudeCodeAuth } from './claude_cli.js';
-export type { AgentBackend, BackendObservation, BackendRequest, BackendResponse, ContentBlock, TextBlock, ToolUseBlock, LlmMessage, RequestContentBlock, RequestVideoBlock, ToolResultBlock, TokenUsage, StreamEvent } from './types.js';
+export type { AgentBackend, BackendObservation, BackendRequest, BackendResponse, ContentBlock, TextBlock, ToolUseBlock, ThinkingBlock, RedactedThinkingBlock, LlmMessage, RequestContentBlock, RequestVideoBlock, ToolResultBlock, TokenUsage, StreamEvent } from './types.js';
 import type { AgentBackend, BackendRequest, BackendResponse, StreamEvent } from './types.js';
 import { AccountPool, type RotationMode } from './account_rotation.js';
 import type { Message } from '../../types.js';
@@ -58,7 +59,10 @@ export interface CreateBackendOptions {
 export declare class TracedBackend implements AgentBackend {
     private readonly provider;
     private readonly backend;
+    get preservesNativeHistory(): boolean;
+    isAuthenticationConfigured(): boolean;
     constructor(provider: string, backend: AgentBackend);
+    getModelCapabilities(model: string): import("../../utils/router_catalog.js").RouterModelCapabilities | undefined;
     steerUserMessage(message: Message): Promise<boolean>;
     /** Forward disposal so a process-backed inner (RotatingBackend, codex child)
      * is closed when the agent is. Without this, tracing (ZTC_BACKEND_TRACE=1)
@@ -66,6 +70,9 @@ export declare class TracedBackend implements AgentBackend {
     close(): void;
     /** Forward the wrapped backend's per-request streaming nature so the agent's path choice is unchanged by tracing. */
     streamsSyntheticallyFor(request: BackendRequest): boolean;
+    allowsRequestRetryAfterFailure(request: BackendRequest): boolean;
+    allowsBufferedFallbackAfterStreamFailure(request: BackendRequest): boolean;
+    handlesTransportRetries(request: BackendRequest): boolean;
     generate(request: BackendRequest): Promise<BackendResponse>;
     generateStream(request: BackendRequest): AsyncIterable<StreamEvent>;
 }

package/dist/agent/backends/index.js

@@ -1,4 +1,4 @@
-export { AnthropicBackend, AnthropicApiError } from './anthropic.js';
+export { AnthropicBackend, AnthropicApiError, createNativeAnthropicMessagesRouterBackend } from './anthropic.js';
 export { OpenAIBackend } from './openai.js';
 export { OpenAICompatibleBackend } from './openai_compatible.js';
 export { OpenAIResponsesBackend } from './openai_responses.js';
@@ -34,10 +34,13 @@ import { RotatingBackend } from './account_rotation.js';
 export class TracedBackend {
     provider;
     backend;
+    get preservesNativeHistory() { return this.backend.preservesNativeHistory ?? false; }
+    isAuthenticationConfigured() { return this.backend.isAuthenticationConfigured?.() ?? false; }
     constructor(provider, backend) {
         this.provider = provider;
         this.backend = backend;
     }
+    getModelCapabilities(model) { return this.backend.getModelCapabilities?.(model); }
     async steerUserMessage(message) {
         return this.backend.steerUserMessage?.(message) ?? false;
     }
@@ -51,6 +54,15 @@ export class TracedBackend {
     streamsSyntheticallyFor(request) {
         return this.backend.streamsSyntheticallyFor?.(request) ?? false;
     }
+    allowsRequestRetryAfterFailure(request) {
+        return this.backend.allowsRequestRetryAfterFailure?.(request) ?? true;
+    }
+    allowsBufferedFallbackAfterStreamFailure(request) {
+        return this.backend.allowsBufferedFallbackAfterStreamFailure?.(request) ?? true;
+    }
+    handlesTransportRetries(request) {
+        return this.backend.handlesTransportRetries?.(request) ?? false;
+    }
     async generate(request) {
         writeBackendTrace({ event: 'request', provider: this.provider, backend: this.backend.constructor.name, model: request.model });
         const startedAt = Date.now();
@@ -148,10 +160,17 @@ export function createBackendForProvider(provider, opts) {
             return traced(provider, new KimiBackend({ apiKey: opts.apiKey }));
         case 'deepseek':
             return traced(provider, new OpenAICompatibleBackend({
+                provider: 'deepseek',
                 apiKey: opts.apiKey,
                 baseUrl: opts.baseUrl || 'https://api.deepseek.com/v1',
                 requestBodyExtras: deepseekRequestParams,
             }));
+        case 'fireworks':
+            return traced(provider, new OpenAICompatibleBackend({
+                apiKey: opts.apiKey,
+                baseUrl: opts.baseUrl || 'https://api.fireworks.ai/inference/v1',
+                provider: 'fireworks',
+            }));
         case 'clarifai':
             return traced(provider, new ClarifaiBackend({ apiKey: opts.apiKey, headers: opts.extraHeaders }));
         case CODEX_APP_SERVER_PROVIDER:
@@ -206,7 +225,8 @@ export function createBackendForProvider(provider, opts) {
         }
         case 'anthropic':
         case 'claude':
-        default:
             return traced(provider, new AnthropicBackend({ apiKey: opts.apiKey, apiEndpoint: opts.apiEndpoint }));
+        default:
+            throw new Error(`Unknown provider: ${provider}. Select a Router integration or a supported direct provider.`);
     }
 }

package/dist/agent/backends/openai.d.ts

@@ -1,9 +1,3 @@
-/**
- * OpenAI backend — smart router between Chat Completions and Responses API.
- *
- * Codex models and GPT-6 Sol/Luna use Responses so reasoning and tool calls
- * can be combined. Everything else goes through Chat Completions.
- */
 import { AgentBackend, BackendRequest, BackendResponse, StreamEvent } from './types.js';
 interface OpenAIConfig {
     apiKey: string;

package/dist/agent/backends/openai.js

@@ -1,7 +1,8 @@
+import { modelContract } from '@zerg/model-contracts';
 /**
  * OpenAI backend — smart router between Chat Completions and Responses API.
  *
- * Codex models and GPT-6 Sol/Luna use Responses so reasoning and tool calls
+ * Codex models and reviewed Responses tool models use Responses so reasoning and tool calls
  * can be combined. Everything else goes through Chat Completions.
  */
 import { OpenAICompatibleBackend } from './openai_compatible.js';
@@ -12,7 +13,8 @@ const RESPONSES_API_PATTERNS = [
     /^gpt-6-(?:sol|luna)$/i,
 ];
 function needsResponsesAPI(model) {
-    return RESPONSES_API_PATTERNS.some(p => p.test(model));
+    return modelContract('openai', model)?.chatToolReasoningEfforts !== undefined
+        || RESPONSES_API_PATTERNS.some(p => p.test(model));
 }
 export class OpenAIBackend {
     chatBackend;
@@ -23,6 +25,7 @@ export class OpenAIBackend {
             apiKey: config.apiKey,
             baseUrl,
             apiPath: '/chat/completions',
+            provider: 'openai',
         });
         this.responsesBackend = new OpenAIResponsesBackend({
             apiKey: config.apiKey,

package/dist/agent/backends/openai_compatible.d.ts

@@ -1,3 +1,4 @@
+import { BackendHttpError } from './http_error.js';
 import { AgentBackend, BackendRequest, BackendResponse, StreamEvent } from './types.js';
 interface OpenAICompatibleConfig {
     apiKey: string;
@@ -18,12 +19,11 @@ interface OpenAICompatibleConfig {
      * Cannot override `model`/`messages`/`tools`/the token limit — those are set
      * after this spread.
      */
+    provider?: string;
     requestBodyExtras?: (request: BackendRequest) => Record<string, unknown>;
 }
-export declare class OpenAICompatibleApiError extends Error {
-    readonly status: number;
-    readonly body: string;
-    constructor(status: number, body: string);
+export declare class OpenAICompatibleApiError extends BackendHttpError {
+    constructor(status: number, body: string, options?: ConstructorParameters<typeof BackendHttpError>[2]);
 }
 export declare class OpenAICompatibleBackend implements AgentBackend {
     private apiKey;
@@ -31,6 +31,7 @@ export declare class OpenAICompatibleBackend implements AgentBackend {
     private apiPath;
     private headers;
     private extraBody;
+    private provider?;
     private requestBodyExtras?;
     private authTokenProvider?;
     constructor(config: OpenAICompatibleConfig);

package/dist/agent/backends/openai_compatible.js

@@ -1,18 +1,16 @@
+import { fireworksRequestModel, modelContract, reasoningRequestParams } from '@zerg/model-contracts';
 import { measureResponse, measureStream } from './request_metrics.js';
+import { BackendHttpError, readHttpErrorBody } from './http_error.js';
 import { parseSSEStream } from './sse.js';
 import { parseTokenUsage } from './token_usage.js';
 import { buildOpenAIMessages, buildOpenAIToolDefs } from './openai_format.js';
 import { isKimiModel } from './kimi_params.js';
 import { normalizeOpenAICompatibleCompletionState } from '../completion_state.js';
 import { DEEPSEEK_FLASH_MAX_OUTPUT, isDeepSeekFlashModel } from '../../utils/deepseek.js';
-export class OpenAICompatibleApiError extends Error {
-    status;
-    body;
-    constructor(status, body) {
-        super(`API error (${status}): ${body}`);
+export class OpenAICompatibleApiError extends BackendHttpError {
+    constructor(status, body, options) {
+        super(status, body, options);
         this.name = 'OpenAICompatibleApiError';
-        this.status = status;
-        this.body = body;
     }
 }
 export class OpenAICompatibleBackend {
@@ -21,6 +19,7 @@ export class OpenAICompatibleBackend {
     apiPath;
     headers;
     extraBody;
+    provider;
     requestBodyExtras;
     authTokenProvider;
     constructor(config) {
@@ -29,6 +28,7 @@ export class OpenAICompatibleBackend {
         this.apiPath = config.apiPath || '/chat/completions';
         this.headers = config.headers || {};
         this.extraBody = config.extraBody || {};
+        this.provider = config.provider;
         this.requestBodyExtras = config.requestBodyExtras;
         this.authTokenProvider = config.authTokenProvider;
     }
@@ -39,29 +39,36 @@ export class OpenAICompatibleBackend {
         // O-series (o1, o3, o4-mini) and GPT-5/6 use max_completion_tokens instead of
         // max_tokens; Moonshot marks max_tokens "Deprecated, please refer to
         // max_completion_tokens" for the Kimi models too.
-        const useCompletionTokens = /^o\d/.test(request.model)
+        const useCompletionTokens = this.provider === 'fireworks' ? false : /^o\d/.test(request.model)
             || /^gpt-[56]/.test(request.model)
             || isKimiModel(request.model);
         // Cap max_tokens for models with lower limits (gpt-4o: 16384)
         const isGpt4o = request.model.startsWith('gpt-4o');
-        const limit = isGpt4o ? 16384 : isDeepSeekFlashModel(request.model) ? DEEPSEEK_FLASH_MAX_OUTPUT : Infinity;
+        const reviewedLimit = this.provider ? modelContract(this.provider, request.model)?.maxOutputTokens?.max : undefined;
+        const limit = reviewedLimit ?? (isGpt4o ? 16384 : isDeepSeekFlashModel(request.model) ? DEEPSEEK_FLASH_MAX_OUTPUT : Infinity);
         const effectiveMaxTokens = request.maxTokens === undefined ? undefined : Math.min(request.maxTokens, limit);
         const tokenParam = effectiveMaxTokens === undefined ? {} : useCompletionTokens
             ? { max_completion_tokens: effectiveMaxTokens }
             : { max_tokens: effectiveMaxTokens };
-        const isGpt6Model = /^gpt-6-(?:sol|luna)$/i.test(request.model);
-        const reasoningEffort = (request.model === 'gpt-5.6-sol' || isGpt6Model) && request.tools.length > 0
-            ? 'none'
-            : isGpt6Model ? request.codexEffort : undefined;
+        // Chat tool support differs from Responses. Never silently downgrade an
+        // explicit grade; default Chat requests use the reviewed tool-safe value.
+        const policyProvider = this.provider ?? 'openai';
+        const chatEfforts = modelContract(policyProvider, request.model)?.chatToolReasoningEfforts;
+        const toolRestricted = request.tools.length > 0 && chatEfforts !== undefined;
+        if (toolRestricted && request.codexEffort !== undefined && !chatEfforts.includes(request.codexEffort)) {
+            throw new Error('Use Responses for graded reasoning with tools on this model. Chat Completions supports effort none.');
+        }
+        const reasoningEffort = toolRestricted ? request.codexEffort ?? 'none' : request.codexEffort;
         const body = {
             ...this.extraBody,
+            ...reasoningRequestParams(policyProvider, request.model, reasoningEffort),
             ...(this.requestBodyExtras?.(request) ?? {}),
-            model: request.model,
+            model: this.provider === 'fireworks' ? fireworksRequestModel(request.model) : request.model,
             ...tokenParam,
             // Chat Completions accepts GPT-6 Sol/Luna function tools only with
             // reasoning disabled. The direct OpenAI backend uses Responses instead;
             // keep this rule for explicitly configured compatible endpoints.
-            ...(reasoningEffort ? { reasoning_effort: reasoningEffort } : {}),
+            ...(toolRestricted ? { reasoning_effort: reasoningEffort } : {}),
             messages: buildOpenAIMessages(request),
             ...(request.tools.length > 0 ? { tools: buildOpenAIToolDefs(request.tools) } : {})
         };
@@ -97,8 +104,8 @@ export class OpenAICompatibleBackend {
                 'Check network access, proxy configuration, and API key/model access.');
         }
         if (!response.ok) {
-            const errorText = await response.text();
-            throw new OpenAICompatibleApiError(response.status, errorText);
+            const failure = await readHttpErrorBody(response, request.signal);
+            throw new OpenAICompatibleApiError(response.status, failure.body, { headers, bodyReadState: failure.bodyReadState });
         }
         const data = await response.json();
         const choice = data.choices?.[0];
@@ -168,8 +175,8 @@ export class OpenAICompatibleBackend {
                 'Check network access, proxy configuration, and API key/model access.');
         }
         if (!response.ok) {
-            const errorText = await response.text();
-            throw new OpenAICompatibleApiError(response.status, errorText);
+            const failure = await readHttpErrorBody(response, request.signal);
+            throw new OpenAICompatibleApiError(response.status, failure.body, { headers, bodyReadState: failure.bodyReadState });
         }
         if (!response.body) {
             throw new Error('API error: no response body for streaming request');

package/dist/agent/backends/openai_responses.d.ts

@@ -72,9 +72,14 @@ export declare function isValidResponsesOutputItem(value: unknown): value is Rec
 export declare function requireValidResponsesOutputItem(value: unknown): asserts value is Record<string, unknown>;
 /** A terminal event must carry a valid response shape or follow real output. */
 export declare function isValidResponsesTerminal(value: unknown, observedOutput?: boolean): value is Record<string, unknown>;
-export declare const MAX_RESPONSES_RESPONSE_BYTES = 1048576;
+export declare const MAX_RESPONSES_RESPONSE_BYTES: number;
+export declare const MAX_PROVIDER_ERROR_BYTES: number;
+export declare const MAX_RESPONSES_SSE_EVENT_BYTES: number;
+export declare const MAX_RESPONSES_SSE_STREAM_BYTES: number;
 /** Read a provider body without allowing fetch helpers to buffer it without limit. */
-export declare function readBoundedResponsesText(response: Response): Promise<string>;
+export declare function readBoundedResponsesText(response: Response, maxBytes?: number): Promise<string>;
+/** Keep the HTTP status authoritative when an oversized diagnostic must be omitted. */
+export declare function readBoundedProviderError(response: Response): Promise<string>;
 interface InputTextContent {
     type: 'input_text';
     text: string;
@@ -128,7 +133,7 @@ export declare function parseResponsesOutput(data: {
  * request was sent with `stream: true`). If the body isn't readable (rare), it
  * buffers the SSE text and parses it whole — the same events, just not live.
  */
-export declare function streamResponsesSSE(response: Response): AsyncIterable<StreamEvent>;
+export declare function streamResponsesSSE(response: Response, maxBytes?: number): AsyncIterable<StreamEvent>;
 export declare class OpenAIResponsesBackend extends BaseBackend {
     private apiKey;
     private baseUrl;