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

package/dist/agent/backends/index.js

@@ -1,3 +1,5 @@
+export { BedrockBackend } from './bedrock.js';
+import { BedrockBackend } from './bedrock.js';
 export { AnthropicBackend, AnthropicApiError, createNativeAnthropicMessagesRouterBackend } from './anthropic.js';
 export { OpenAIBackend } from './openai.js';
 export { OpenAICompatibleBackend } from './openai_compatible.js';
@@ -27,6 +29,7 @@ import { ClarifaiBackend } from './clarifai.js';
 import { ClaudeCodeAuthBackend, ClaudeCodeAuthManager } from './claude_code_auth.js';
 import { KimiCodeAuthBackend, KimiCodeAuthManager } from './kimi_code_auth.js';
 import { ClaudeCliBackend } from './claude_cli.js';
+import { ZRouterStreamBackend } from './zrouter_stream.js';
 import { CODEX_APP_SERVER_PROVIDER, CODEX_LEGACY_PROVIDER, normalizeProviderId } from './provider_ids.js';
 import { writeBackendTrace } from './trace.js';
 import { accountSourceToBackendOptions } from './account_pool.js';
@@ -113,6 +116,18 @@ function traced(provider, backend) {
  * Replaces duplicated switch statements in sim/llm.ts, agent/subagent.ts, optimize/llm.ts, etc.
  */
 export function createBackendForProvider(provider, opts) {
+    if (process.env.ZTC_ROUTER_REQUIRED === '1') {
+        if (provider !== 'openai')
+            throw new Error('Required Router profile permits only openai/gpt-6.1-sol');
+        const proxyUrl = process.env.ZERG_PROXY_URL;
+        const apiKey = process.env.ZERG_AUTH_TOKEN?.trim();
+        if (!proxyUrl || !apiKey)
+            throw new Error('Required Router origin and service credential are unavailable');
+        const origin = new URL(proxyUrl);
+        if (origin.protocol !== 'https:' || origin.username || origin.password || origin.pathname !== '/' || origin.search || origin.hash)
+            throw new Error('Required Router origin must be a credential-free HTTPS origin');
+        return traced(provider, new ZRouterStreamBackend({ provider, model: 'gpt-6.1-sol', apiKey, proxyUrl: origin.origin }));
+    }
     // Auto-rotate non-Codex providers only: when the caller opted in and >1
     // account is REGISTERED, wrap the concrete backend so a 429 cools the active account and
     // fails over. Gate on registered (not ready) count: with one ready account and
@@ -140,6 +155,7 @@ export function createBackendForProvider(provider, opts) {
     }
     const resolvedProvider = normalizeProviderId(provider);
     switch (resolvedProvider) {
+        case 'bedrock': return traced(provider, new BedrockBackend(opts.bedrock));
         case 'modal':
             throw new Error('Modal requires a Zerg Router backend. Run ztc auth login and use the routed agent factory.');
         case 'openai':

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

@@ -0,0 +1,20 @@
+import type { AgentBackend, BackendRequest, BackendResponse, StreamEvent } from './types.js';
+export interface PoolMember {
+    model: string;
+    backend: AgentBackend;
+}
+export declare class ModelPoolBackend implements AgentBackend {
+    private readonly members;
+    private readonly now;
+    private readonly coolingUntil;
+    constructor(members: readonly PoolMember[], now?: () => number);
+    /** Members to try for one request: ready ones in order, then cooling ones by earliest recovery. */
+    private order;
+    /** The failover signal for an error this pool moves past, or null to surface it. */
+    private cool;
+    generate(request: BackendRequest): Promise<BackendResponse>;
+    /** Streams from the first member that starts; a member failing before its first event hands over to the next. */
+    generateStream(request: BackendRequest): AsyncIterable<StreamEvent>;
+    streamsSyntheticallyFor(request: BackendRequest): boolean;
+    close(): void;
+}

package/dist/agent/backends/model_pool.js

@@ -0,0 +1,98 @@
+/**
+ * An ordered pool of models behind one backend, for delegated workers.
+ *
+ * Each request goes to the first model that is not cooling down. A model that
+ * answers with a rate limit or a transient failure (429, 5xx, timeout, dropped
+ * connection) cools down and the next model serves the same request, and so does
+ * one that is gone or unavailable (404, 410, 402: free models are retired without
+ * notice), for longer. An auth failure or another client error is surfaced unchanged. When every model is cooling,
+ * the one whose cooldown ends first is tried anyway rather than failing the
+ * worker. Free models are rate-limited unpredictably (Beam Free answered 429
+ * for over two hours on 2026-10-21 while MiniMax kept serving), so a pool keeps
+ * workers running while one model is out.
+ */
+import { BackendHttpError } from './http_error.js';
+import { classifyFailover } from './failover.js';
+const RATE_LIMIT_COOLDOWN_MS = 60_000;
+const TRANSIENT_COOLDOWN_MS = 15_000;
+// 2026-10-22: OpenCode deprecated a free model (410), retired one upstream (402) and
+// OpenRouter ended a free variant (404) within one run; none came back that day.
+const UNAVAILABLE_STATUS = new Set([402, 404, 410]);
+const UNAVAILABLE_COOLDOWN_MS = 30 * 60_000;
+export class ModelPoolBackend {
+    members;
+    now;
+    coolingUntil = new Map();
+    constructor(members, now = Date.now) {
+        this.members = members;
+        this.now = now;
+        if (members.length === 0)
+            throw new Error('A model pool needs at least one model.');
+    }
+    /** Members to try for one request: ready ones in order, then cooling ones by earliest recovery. */
+    order() {
+        const at = this.now();
+        const ready = this.members.filter(member => (this.coolingUntil.get(member) ?? 0) <= at);
+        const cooling = this.members.filter(member => !ready.includes(member))
+            .sort((a, b) => this.coolingUntil.get(a) - this.coolingUntil.get(b));
+        return [...ready, ...cooling];
+    }
+    /** The failover signal for an error this pool moves past, or null to surface it. */
+    cool(member, error) {
+        if (error instanceof BackendHttpError && UNAVAILABLE_STATUS.has(error.status)) {
+            this.coolingUntil.set(member, this.now() + UNAVAILABLE_COOLDOWN_MS);
+            return { kind: 'transient', reason: error.message };
+        }
+        const signal = classifyFailover(error);
+        if (!signal || signal.kind === 'auth')
+            return null;
+        const wait = signal.kind === 'rate_limit' ? RATE_LIMIT_COOLDOWN_MS : TRANSIENT_COOLDOWN_MS;
+        this.coolingUntil.set(member, signal.resetAt ?? this.now() + wait);
+        return signal;
+    }
+    async generate(request) {
+        let lastError;
+        for (const member of this.order()) {
+            try {
+                const response = await member.backend.generate({ ...request, model: member.model });
+                this.coolingUntil.delete(member);
+                return response;
+            }
+            catch (error) {
+                if (!this.cool(member, error))
+                    throw error;
+                lastError = error;
+            }
+        }
+        throw lastError;
+    }
+    /** Streams from the first member that starts; a member failing before its first event hands over to the next. */
+    async *generateStream(request) {
+        let lastError;
+        for (const member of this.order()) {
+            let started = false;
+            try {
+                for await (const event of member.backend.generateStream({ ...request, model: member.model })) {
+                    started = true;
+                    yield event;
+                }
+                this.coolingUntil.delete(member);
+                return;
+            }
+            catch (error) {
+                if (started || !this.cool(member, error))
+                    throw error;
+                lastError = error;
+            }
+        }
+        throw lastError;
+    }
+    streamsSyntheticallyFor(request) {
+        const first = this.order()[0];
+        return first.backend.streamsSyntheticallyFor?.({ ...request, model: first.model }) ?? false;
+    }
+    close() {
+        for (const member of this.members)
+            member.backend.close?.();
+    }
+}

package/dist/agent/backends/openai.js

@@ -9,6 +9,8 @@ import { OpenAICompatibleBackend } from './openai_compatible.js';
 import { OpenAIResponsesBackend } from './openai_responses.js';
 /** Models routed to the Responses API. */
 const RESPONSES_API_PATTERNS = [
+    /^gpt-6-astra(?:-|$)/i,
+    /^gpt-6\.1-sol(?:-|$)/i,
     /codex/i, // codex-mini-latest, gpt-5.1-codex-mini, gpt-5.2-codex, etc.
     /^gpt-6-(?:sol|luna)$/i,
 ];

package/dist/agent/backends/openai_compatible.js

@@ -6,7 +6,8 @@ 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';
+import { IncompleteStreamError } from './transport_errors.js';
+import { clampCompletionTokens } from '../../utils/deepseek.js';
 export class OpenAICompatibleApiError extends BackendHttpError {
     constructor(status, body, options) {
         super(status, body, options);
@@ -45,8 +46,8 @@ export class OpenAICompatibleBackend {
         // Cap max_tokens for models with lower limits (gpt-4o: 16384)
         const isGpt4o = request.model.startsWith('gpt-4o');
         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 limit = reviewedLimit ?? (isGpt4o ? 16384 : Infinity);
+        const effectiveMaxTokens = clampCompletionTokens(request.model, request.maxTokens === undefined ? undefined : Math.min(request.maxTokens, limit));
         const tokenParam = effectiveMaxTokens === undefined ? {} : useCompletionTokens
             ? { max_completion_tokens: effectiveMaxTokens }
             : { max_tokens: effectiveMaxTokens };
@@ -263,6 +264,10 @@ export class OpenAICompatibleBackend {
             count: toolCalls.size,
             allStructurallyValid: [...toolCalls.values()].every(isCompleteStreamedToolCall),
         });
+        if (stopReason === 'incomplete'
+            && (!providerFinishReason || providerFinishReason === 'tool_calls' || providerFinishReason === 'stop')) {
+            throw new IncompleteStreamError();
+        }
         if (stopReason === 'tool_calls') {
             for (const entry of toolCalls.values()) {
                 if (entry.started)

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

@@ -21,6 +21,11 @@ interface OpenAIResponsesConfig {
     extraHeaders?: Record<string, string>;
     /** Extra body fields merged into every request (e.g. store: false). */
     extraBody?: Record<string, unknown>;
+    /** Injectable HTTP boundary used by the Router's existing request meter. */
+    fetcher?: typeof fetch;
+    preserveNativeHistory?: boolean;
+    /** Validated host routing owns reasoning instead of ambient direct-provider overrides. */
+    reasoningFromRequestOnly?: boolean;
 }
 interface ResponsesOutputText {
     type: 'output_text';
@@ -107,9 +112,9 @@ interface InputFunctionCall {
 interface InputFunctionCallOutput {
     type: 'function_call_output';
     call_id: string;
-    output: string;
+    output: string | InputContentPart[];
 }
-type InputItem = InputUserMessage | InputAssistantMessage | InputFunctionCall | InputFunctionCallOutput;
+type InputItem = InputUserMessage | InputAssistantMessage | InputFunctionCall | InputFunctionCallOutput | Record<string, unknown>;
 /** Convert internal LlmMessage[] into Responses API input items. */
 export declare function buildResponsesInput(messages: LlmMessage[]): InputItem[];
 /** Parse Responses API output into internal BackendResponse. */
@@ -133,12 +138,18 @@ 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, maxBytes?: number): AsyncIterable<StreamEvent>;
+export declare function streamResponsesSSE(response: Response, maxBytes?: number, options?: {
+    rejectIncomplete?: boolean;
+    failureError?: string;
+}): AsyncIterable<StreamEvent>;
 export declare class OpenAIResponsesBackend extends BaseBackend {
+    readonly preservesNativeHistory: boolean;
+    private readonly reasoningFromRequestOnly;
     private apiKey;
     private baseUrl;
     private extraHeaders;
     private extraBody;
+    private fetcher;
     constructor(config: OpenAIResponsesConfig);
     /** Build the Responses API request body, optionally in streaming mode. */
     private buildBody;

package/dist/agent/backends/openai_responses.js

@@ -1,17 +1,6 @@
-/**
- * OpenAI Responses API backend.
- *
- * Used for models that only support the Responses API (codex models,
- * gpt-5.x-codex-*, etc.) rather than Chat Completions.
- *
- * Key format differences from Chat Completions:
- *   - Endpoint: POST /v1/responses
- *   - System prompt → `instructions` field
- *   - Messages → `input` array (with inline function_call / function_call_output items)
- *   - Tool defs → `tools` with {type, name, description, parameters} at top level
- *   - Response → `output` array of reasoning / message / function_call items
- *   - Token param → `max_output_tokens`
- */
+import { IncompleteStreamError } from './transport_errors.js';
+import { isDeepStrictEqual } from 'node:util';
+import { responsesReasoning } from './responses_reasoning.js';
 import { BaseBackend } from './base.js';
 import { parseTokenUsage } from './token_usage.js';
 function isRecord(value) {
@@ -20,6 +9,8 @@ function isRecord(value) {
 function hasValidUsageShape(value) {
     if (!isRecord(value))
         return false;
+    if (!['input_tokens', 'output_tokens'].every(key => typeof value[key] === 'number' && Number.isSafeInteger(value[key]) && Number(value[key]) >= 0))
+        return false;
     let sawCounter = false;
     for (const key of ['input_tokens', 'output_tokens', 'total_tokens']) {
         const tokenCount = value[key];
@@ -27,10 +18,19 @@ function hasValidUsageShape(value) {
             continue;
         sawCounter = true;
         if (typeof tokenCount !== 'number'
-            || !Number.isFinite(tokenCount)
+            || !Number.isSafeInteger(tokenCount)
             || tokenCount < 0)
             return false;
     }
+    if (value.total_tokens !== undefined && value.total_tokens !== Number(value.input_tokens) + Number(value.output_tokens))
+        return false;
+    if (value.input_tokens_details !== undefined) {
+        if (!isRecord(value.input_tokens_details))
+            return false;
+        const cached = value.input_tokens_details.cached_tokens;
+        if (cached !== undefined && (typeof cached !== 'number' || !Number.isSafeInteger(cached) || cached < 0 || cached > Number(value.input_tokens)))
+            return false;
+    }
     return sawCounter;
 }
 function isValidOutputText(value) {
@@ -172,6 +172,27 @@ export async function readBoundedProviderError(response) {
 export function buildResponsesInput(messages) {
     const input = [];
     for (const msg of messages) {
+        if (msg.role === 'assistant' && msg.responseItems?.length) {
+            const items = msg.responseItems;
+            if (!items.every(isValidResponsesOutputItem))
+                throw new Error('Invalid persisted Responses continuation');
+            const calls = items.filter(item => item.type === 'function_call');
+            const blocks = Array.isArray(msg.content) ? msg.content.filter(block => block.type === 'tool_use') : [];
+            if (calls.length !== blocks.length || calls.some((call, index) => {
+                const block = blocks[index];
+                let args;
+                try {
+                    args = JSON.parse(String(call.arguments));
+                }
+                catch {
+                    return true;
+                }
+                return call.call_id !== block.id || call.name !== block.name || !isDeepStrictEqual(args, block.input);
+            }))
+                throw new Error('Persisted Responses calls do not match assistant tool history');
+            input.push(...structuredClone(items));
+            continue;
+        }
         if (typeof msg.content === 'string') {
             input.push({ role: msg.role, content: msg.content });
             continue;
@@ -189,7 +210,7 @@ export function buildResponsesInput(messages) {
                     }
                     break;
                 case 'tool_use':
-                    input.push({
+                    input.push(block.responsesItem ? structuredClone(block.responsesItem) : {
                         type: 'function_call',
                         id: `fc_${block.id}`,
                         call_id: block.id,
@@ -201,13 +222,20 @@ export function buildResponsesInput(messages) {
                     const resultText = typeof block.content === 'string'
                         ? block.content
                         : block.content.map(b => b.type === 'text' ? b.text : '[image]').join('\n');
+                    const parts = Array.isArray(block.content)
+                        && block.content.some(part => part.type === 'image') ? block.content.map(part => part.type === 'text'
+                        ? { type: 'input_text', text: block.is_error && !/^error\b/i.test(part.text) ? `Error: ${part.text}` : part.text }
+                        : { type: 'input_image', image_url: `data:${part.source.media_type};base64,${part.source.data}` }) : undefined;
                     input.push({
                         type: 'function_call_output',
                         call_id: block.tool_use_id,
-                        output: block.is_error && !/^error\b/i.test(resultText) ? `Error: ${resultText}` : resultText,
+                        output: parts ?? (block.is_error && !/^error\b/i.test(resultText) ? `Error: ${resultText}` : resultText),
                     });
                     break;
                 }
+                case 'responses_reasoning':
+                    input.push(structuredClone(block.item));
+                    break;
                 case 'image':
                     if (msg.role === 'user') {
                         userParts.push({
@@ -238,7 +266,10 @@ export function parseResponsesOutput(data) {
     const blocks = [];
     const reasoningParts = [];
     let hasToolUse = false;
+    if (data.usage !== undefined && !hasValidUsageShape(data.usage))
+        throw new Error('Responses API received invalid token usage');
     for (const item of data.output) {
+        requireValidResponsesOutputItem(item);
         switch (item.type) {
             case 'message':
                 for (const c of item.content) {
@@ -254,20 +285,30 @@ export function parseResponsesOutput(data) {
                 let args = {};
                 try {
                     args = JSON.parse(item.arguments);
+                    if (!isRecord(args))
+                        throw new Error('Invalid function arguments');
                 }
                 catch {
-                    args = { _raw: item.arguments };
+                    // Parser errors can include raw business values or secrets. Retain
+                    // incomplete output for visibility but never execute malformed calls.
+                    if (data.status !== 'incomplete')
+                        throw new Error('Responses API received invalid function arguments');
+                    args = {};
                 }
                 blocks.push({
                     type: 'tool_use',
                     id: item.call_id,
                     name: item.name,
                     input: args,
+                    responsesItem: structuredClone(item),
                 });
                 hasToolUse = true;
                 break;
             }
             case 'reasoning': {
+                if (typeof item.encrypted_content === 'string') {
+                    blocks.push({ type: 'responses_reasoning', item: structuredClone(item) });
+                }
                 const summaries = (item.summary || [])
                     .filter((s) => s?.type === 'summary_text' && s.text)
                     .map((s) => s.text);
@@ -288,6 +329,7 @@ export function parseResponsesOutput(data) {
             : 'end_turn';
     return {
         content: blocks,
+        responseItems: structuredClone(data.output),
         stopReason,
         usage: data.usage ? parseTokenUsage(data.usage) : undefined,
         ...(reasoningParts.length > 0 ? { reasoning: reasoningParts.join('\n\n') } : {}),
@@ -306,7 +348,7 @@ export 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 async function* streamResponsesSSE(response, maxBytes = MAX_RESPONSES_SSE_STREAM_BYTES) {
+export async function* streamResponsesSSE(response, maxBytes = MAX_RESPONSES_SSE_STREAM_BYTES, options = {}) {
     rejectOversizedDeclaredBody(response, maxBytes);
     const streamLimit = Math.min(maxBytes, MAX_RESPONSES_SSE_STREAM_BYTES);
     const outputItems = [];
@@ -365,6 +407,8 @@ export async function* streamResponsesSSE(response, maxBytes = MAX_RESPONSES_SSE
         else if (t === 'response.completed' || t === 'response.incomplete') {
             // Preserve partial output for visibility, while keeping the terminal
             // state distinct so the Agent cannot promote it to a successful turn.
+            if (options.rejectIncomplete && t === 'response.incomplete')
+                throw new Error('Codex response stream was incomplete');
             const rawResponse = event.response;
             const observedOutput = outputItems.length > 0 || streamedText || streamedReasoning;
             if (isRecord(rawResponse) && Array.isArray(rawResponse.output)) {
@@ -391,7 +435,7 @@ export async function* streamResponsesSSE(response, maxBytes = MAX_RESPONSES_SSE
             const resp = event.response;
             const errObj = (resp?.error ?? event.error);
             const msg = errObj?.message || 'the provider reported a stream failure';
-            throw new Error(`Responses API stream failed: ${msg}`);
+            throw new Error(options.failureError ?? `Responses API stream failed: ${msg}`);
         }
     };
     if (response.body) {
@@ -465,7 +509,7 @@ export async function* streamResponsesSSE(response, maxBytes = MAX_RESPONSES_SSE
         }
     }
     if (!terminalEventSeen) {
-        throw new Error('Responses API stream ended without a valid terminal response event');
+        throw new IncompleteStreamError('Responses API stream ended without a valid terminal response event');
     }
     const parsed = parseResponsesOutput({
         status: terminalStatus,
@@ -486,7 +530,11 @@ export async function* streamResponsesSSE(response, maxBytes = MAX_RESPONSES_SSE
     if (!streamedReasoning && parsed.reasoning) {
         yield { type: 'reasoning_delta', text: parsed.reasoning };
     }
+    yield { type: 'response_items', items: parsed.responseItems };
     for (const block of parsed.content) {
+        // Native history is distinct from rendered deltas. The agent must retain
+        // exact provider IDs and encrypted reasoning even when the turn streamed.
+        yield { type: 'content_block', block };
         if (block.type === 'tool_use') {
             yield { type: 'tool_use_start', id: block.id, name: block.name };
             yield { type: 'tool_use_delta', id: block.id, input_json: JSON.stringify(block.input) };
@@ -499,16 +547,22 @@ export async function* streamResponsesSSE(response, maxBytes = MAX_RESPONSES_SSE
 }
 // ─── Backend implementation ──────────────────────────────────────────
 export class OpenAIResponsesBackend extends BaseBackend {
+    preservesNativeHistory;
+    reasoningFromRequestOnly;
     apiKey;
     baseUrl;
     extraHeaders;
     extraBody;
+    fetcher;
     constructor(config) {
         super();
         this.apiKey = config.apiKey;
         this.baseUrl = (config.baseUrl || 'https://api.openai.com/v1').replace(/\/+$/, '');
         this.extraHeaders = config.extraHeaders || {};
         this.extraBody = config.extraBody || {};
+        this.fetcher = config.fetcher ?? ((...args) => fetch(...args));
+        this.preservesNativeHistory = config.preserveNativeHistory ?? false;
+        this.reasoningFromRequestOnly = config.reasoningFromRequestOnly ?? false;
     }
     /** Build the Responses API request body, optionally in streaming mode. */
     buildBody(request, stream) {
@@ -518,6 +572,7 @@ export class OpenAIResponsesBackend extends BaseBackend {
             name: t.name,
             description: t.description,
             parameters: t.parameters,
+            strict: false,
         }));
         const body = {
             model: request.model,
@@ -527,9 +582,9 @@ export class OpenAIResponsesBackend extends BaseBackend {
             // codex / gpt-5.x are reasoning models: always request a reasoning summary
             // so the agent's thinking surfaces (streamed as reasoning_delta, or parsed
             // from the buffered output). Mirrors the ChatGPT-auth codex path.
-            reasoning: request.codexEffort
-                ? { effort: request.codexEffort, summary: 'auto' }
-                : { summary: 'auto' },
+            store: false,
+            reasoning: responsesReasoning(request.model, request.codexEffort, 'openai', !this.reasoningFromRequestOnly),
+            ...(/^gpt-(?:6-astra|6\.1-sol)(?:-|$)/i.test(request.model) ? { include: ['reasoning.encrypted_content'] } : {}),
             ...this.extraBody,
         };
         if (stream)
@@ -539,8 +594,17 @@ export class OpenAIResponsesBackend extends BaseBackend {
         // Only include tools if there are any
         if (tools.length > 0) {
             body.tools = tools;
-            body.tool_choice = 'auto';
+            const required = process.env.ZTC_REQUIRED_TOOL_CHOICE;
+            const requiredCallIds = new Set(request.messages.flatMap(message => Array.isArray(message.content)
+                ? message.content.flatMap(block => block.type === 'tool_use' && block.name === required ? [block.id] : []) : []));
+            const requiredObserved = request.messages.some(message => Array.isArray(message.content)
+                && message.content.some(block => block.type === 'tool_result' && requiredCallIds.has(block.tool_use_id)));
+            if (required && !requiredObserved && !tools.some(tool => tool.name === required))
+                throw new Error('Required Router tool is not available in this request');
+            body.tool_choice = required && !requiredObserved ? { type: 'function', name: required } : 'auto';
         }
+        if (request.outputFormat)
+            body.text = { format: request.outputFormat };
         return body;
     }
     /** POST to /responses, throwing a descriptive error on transport / API failure. */
@@ -548,7 +612,7 @@ export class OpenAIResponsesBackend extends BaseBackend {
         const url = `${this.baseUrl}/responses`;
         let response;
         try {
-            response = await fetch(url, {
+            response = await this.fetcher(url, {
                 method: 'POST',
                 headers: {
                     'Content-Type': 'application/json',
@@ -557,6 +621,7 @@ export class OpenAIResponsesBackend extends BaseBackend {
                 },
                 body: JSON.stringify(this.buildBody(request, stream)),
                 signal: request.signal,
+                redirect: 'error',
             });
         }
         catch (err) {

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

@@ -0,0 +1,5 @@
+/** Shared direct Responses and Codex subscription reasoning controls. */
+export declare function responsesReasoning(model: string, explicitEffort?: string, provider?: string, useEnvironment?: boolean): {
+    effort?: string;
+    summary?: string;
+};

package/dist/agent/backends/responses_reasoning.js

@@ -0,0 +1,23 @@
+import { modelContract } from '@zerg/model-contracts';
+import { CODEX_LEGACY_EFFORTS } from '../../utils/models.js';
+/** Shared direct Responses and Codex subscription reasoning controls. */
+export function responsesReasoning(model, explicitEffort, provider = 'openai', useEnvironment = true) {
+    const astra = /^gpt-6-astra(?:-|$)/i.test(model);
+    const sol = /^gpt-6\.1-sol(?:-|$)/i.test(model);
+    const configured = useEnvironment ? process.env.ZTC_OPENAI_REASONING_EFFORT : undefined;
+    // GPT-5.6's API default is "none"; the Codex subscription contract has no such
+    // level, so Codex keeps the provider's own default as it did before.
+    const effort = configured ?? explicitEffort
+        ?? (astra ? 'low' : sol ? 'medium' : provider === 'openai' && /^gpt-5\.6(?:-|$)/i.test(model) ? 'none' : undefined);
+    if (effort === undefined)
+        return { summary: 'auto' };
+    const contract = modelContract(provider, model)?.reasoningEfforts;
+    // The Codex subscription backend also accepts its legacy levels (none, minimal),
+    // which the app-server contract does not list.
+    const supported = astra || sol ? ['low', 'medium', 'high', 'xhigh', 'max']
+        : contract && provider === 'codex' ? [...new Set([...CODEX_LEGACY_EFFORTS, ...contract])]
+            : contract ?? ['none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max', 'ultra'];
+    if (!supported.includes(effort))
+        throw new Error(`Unsupported reasoning effort "${effort}" for ${model}; use ${supported.join(', ')}`);
+    return { effort, ...(explicitEffort && configured === undefined ? { summary: 'auto' } : {}) };
+}

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

@@ -18,3 +18,9 @@ export declare function isTransportCodeError(error: unknown): boolean;
 export declare function isTransportMessageError(error: unknown): boolean;
 /** True when an error is a raw socket/DNS failure rather than an HTTP response. */
 export declare function isTransportError(error: unknown): boolean;
+export declare class IncompleteStreamError extends Error {
+    readonly incompleteStream = true;
+    readonly code = "INCOMPLETE_STREAM";
+    constructor(message?: string);
+}
+export declare function isIncompleteStreamError(error: unknown): boolean;

package/dist/agent/backends/transport_errors.js

@@ -39,3 +39,14 @@ export function isTransportMessageError(error) {
 export function isTransportError(error) {
     return isTransportCodeError(error) || isTransportMessageError(error);
 }
+export class IncompleteStreamError extends Error {
+    incompleteStream = true;
+    code = 'INCOMPLETE_STREAM';
+    constructor(message = 'The model stream ended before its completion signal.') {
+        super(message);
+        this.name = 'IncompleteStreamError';
+    }
+}
+export function isIncompleteStreamError(error) {
+    return error instanceof Error && error.incompleteStream === true;
+}