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

package/dist/agent/backends/account_login.js

@@ -11,6 +11,7 @@
  * the user the exact command to run themselves.
  */
 import { spawn } from 'node:child_process';
+import { browserLaunchAllowed } from '../../utils/session_interactivity.js';
 const DEFAULT_TIMEOUT_MS = 150_000;
 /**
  * Whether to auto-run the login on the host. Off when the host is headless or
@@ -22,7 +23,8 @@ export function loginAutoRunEnabled(env = process.env) {
         return false;
     if (env.ZTC_HEADLESS === '1' || env.ZTC_HEADLESS === 'true')
         return false;
-    return true;
+    // A login CLI opens a browser; automated runs never start one.
+    return browserLaunchAllowed(env);
 }
 /** A short human phrase for why an auto-login failed, for the fallback message. */
 export function loginFailureReasonText(attempt) {

package/dist/agent/backends/anthropic.js

@@ -1,3 +1,4 @@
+import { IncompleteStreamError } from './transport_errors.js';
 import { modelContract } from '@zerg/model-contracts';
 import { parseSSEStream } from './sse.js';
 import { readBoundedProviderError } from './openai_responses.js';
@@ -110,7 +111,7 @@ export class AnthropicBackend {
             role: message.role,
             content: typeof message.content === 'string'
                 ? message.content
-                : message.content.map(block => {
+                : message.content.filter(block => block.type !== 'responses_reasoning').map(block => {
                     if (block.type === 'text') {
                         return { type: 'text', text: block.text };
                     }
@@ -370,9 +371,9 @@ export class AnthropicBackend {
             }
         }
         if (blocks.size > 0)
-            throw new Error('Anthropic stream ended before a native content block completed');
+            throw new IncompleteStreamError('Anthropic stream ended before a native content block completed');
         if (!messageCompleted)
-            throw new Error('Anthropic stream ended before message completion');
+            throw new IncompleteStreamError('Anthropic stream ended before message completion');
         yield { type: 'done', stopReason, ...(stopDetails ? { stopDetails } : {}) };
     }
 }

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

@@ -0,0 +1,20 @@
+import type { ConverseCommand, ConverseCommandOutput, ConverseStreamCommand, ConverseStreamCommandOutput } from '@aws-sdk/client-bedrock-runtime';
+import type { AgentBackend, BackendRequest, BackendResponse, StreamEvent } from './types.js';
+export interface BedrockClientLike {
+    send(command: ConverseCommand | ConverseStreamCommand, options?: {
+        abortSignal?: AbortSignal;
+    }): Promise<ConverseCommandOutput | ConverseStreamCommandOutput>;
+}
+export interface BedrockBackendConfig {
+    region?: string;
+    client?: BedrockClientLike;
+}
+export declare class BedrockBackend implements AgentBackend {
+    private client;
+    private readonly region;
+    constructor(config?: BedrockBackendConfig);
+    private send;
+    isAuthenticationConfigured(): boolean;
+    generate(request: BackendRequest): Promise<BackendResponse>;
+    generateStream(request: BackendRequest): AsyncIterable<StreamEvent>;
+}

package/dist/agent/backends/bedrock.js

@@ -0,0 +1,175 @@
+import { IncompleteStreamError } from './transport_errors.js';
+let bedrockSdk;
+// Loaded on first use: the backend registry is in every runtime's module
+// closure, including the headless package, which does not ship the AWS SDK.
+function loadBedrockSdk() {
+    bedrockSdk ??= import('@aws-sdk/client-bedrock-runtime').catch(() => {
+        bedrockSdk = undefined;
+        throw new Error('Bedrock support requires the @aws-sdk/client-bedrock-runtime package');
+    });
+    return bedrockSdk;
+}
+function imageBlock(mediaType, data) {
+    const formats = {
+        'image/png': 'png', 'image/jpeg': 'jpeg', 'image/jpg': 'jpeg', 'image/gif': 'gif', 'image/webp': 'webp',
+    };
+    const format = formats[mediaType.toLowerCase()];
+    if (!format)
+        throw new Error(`Unsupported Bedrock image media type: ${mediaType || '(missing)'}`);
+    return { image: { format, source: { bytes: Buffer.from(data, 'base64') } } };
+}
+function toolResultContent(content) {
+    if (typeof content === 'string')
+        return [{ text: content || ' ' }];
+    return content.length ? content.map(block => block.type === 'text' ? { text: block.text || ' ' }
+        : imageBlock(block.source.media_type, block.source.data)) : [{ text: ' ' }];
+}
+function requestContent(content) {
+    if (typeof content === 'string')
+        return [{ text: content || ' ' }];
+    return content.map(block => {
+        switch (block.type) {
+            case 'text': return { text: block.text || ' ' };
+            case 'image': return imageBlock(block.mediaType, block.data);
+            case 'tool_use': return { toolUse: { toolUseId: block.id, name: block.name,
+                    input: block.input } };
+            case 'tool_result': return { toolResult: { toolUseId: block.tool_use_id,
+                    content: toolResultContent(block.content), status: block.is_error ? 'error' : 'success' } };
+            default: throw new Error(`Unsupported Bedrock request block: ${block.type}`);
+        }
+    });
+}
+function responseContent(output) {
+    return (output?.message?.content ?? []).flatMap((block) => {
+        if (typeof block.text === 'string')
+            return [{ type: 'text', text: block.text }];
+        if (block.toolUse)
+            return [{ type: 'tool_use', id: block.toolUse.toolUseId ?? '',
+                    name: block.toolUse.name ?? '', input: (block.toolUse.input ?? {}) }];
+        return [];
+    });
+}
+function bedrockError(error) {
+    const value = error;
+    const status = value?.$metadata?.httpStatusCode ?? 0;
+    const name = value?.name ?? 'BedrockError';
+    if (status === 401 || status === 403 || /AccessDenied|Unauthorized|Credentials|UnrecognizedClient/i.test(name)) {
+        return new Error('Bedrock model access is not configured for this workload');
+    }
+    if (status === 400 || /ValidationException/i.test(name))
+        return new Error('Bedrock model configuration is invalid');
+    if (status === 429 || /Throttl/i.test(name))
+        return new Error('API error (429): Bedrock request was throttled');
+    if (status >= 500)
+        return new Error(`API error (${status}): Bedrock service is temporarily unavailable`);
+    return new Error('Bedrock request failed');
+}
+function buildInput(request) {
+    if (!request.model.trim())
+        throw new Error('Bedrock model is not configured');
+    return {
+        modelId: request.model,
+        messages: request.messages.map(message => ({ role: message.role, content: requestContent(message.content) })),
+        inferenceConfig: { maxTokens: request.maxTokens },
+        ...(request.system ? { system: [{ text: request.system }] } : {}),
+        ...(request.tools.length ? { toolConfig: { tools: request.tools.map(tool => ({ toolSpec: {
+                        name: tool.name, ...(tool.description ? { description: tool.description } : {}),
+                        inputSchema: { json: tool.parameters },
+                    } })) } } : {}),
+    };
+}
+function tokenUsage(usage) {
+    const inputTokens = usage.inputTokens ?? 0;
+    const outputTokens = usage.outputTokens ?? 0;
+    return { inputTokens, outputTokens, totalTokens: usage.totalTokens ?? inputTokens + outputTokens };
+}
+export class BedrockBackend {
+    client;
+    region;
+    constructor(config = {}) {
+        if (config.client) {
+            this.client = config.client;
+            return;
+        }
+        this.region = config.region || process.env.AWS_BEDROCK_REGION || process.env.AWS_REGION || process.env.AWS_DEFAULT_REGION;
+        if (!this.region)
+            throw new Error('Bedrock region is not configured');
+    }
+    async send(sdk, command, signal) {
+        this.client ??= new sdk.BedrockRuntimeClient({ region: this.region });
+        return this.client.send(command, signal ? { abortSignal: signal } : undefined);
+    }
+    isAuthenticationConfigured() { return true; }
+    async generate(request) {
+        const input = buildInput(request);
+        const sdk = await loadBedrockSdk();
+        let output;
+        try {
+            output = await this.send(sdk, new sdk.ConverseCommand(input), request.signal);
+        }
+        catch (error) {
+            throw bedrockError(error);
+        }
+        return { content: responseContent(output.output), stopReason: output.stopReason ?? 'end_turn',
+            ...(output.usage ? { usage: tokenUsage(output.usage) } : {}) };
+    }
+    async *generateStream(request) {
+        const input = buildInput(request);
+        const sdk = await loadBedrockSdk();
+        let output;
+        try {
+            output = await this.send(sdk, new sdk.ConverseStreamCommand(input), request.signal);
+        }
+        catch (error) {
+            throw bedrockError(error);
+        }
+        if (!output.stream)
+            throw new Error('Bedrock response stream is unavailable');
+        const toolIds = new Map();
+        let stopReason;
+        try {
+            for await (const event of output.stream) {
+                const error = event.internalServerException || event.modelStreamErrorException || event.serviceUnavailableException
+                    || event.throttlingException || event.validationException;
+                if (error)
+                    throw bedrockError(error);
+                if (event.contentBlockStart?.start?.toolUse) {
+                    const index = event.contentBlockStart.contentBlockIndex ?? 0;
+                    const tool = event.contentBlockStart.start.toolUse;
+                    const id = tool.toolUseId ?? `_idx_${index}`;
+                    toolIds.set(index, id);
+                    yield { type: 'tool_use_start', id, name: tool.name ?? '' };
+                }
+                else if (event.contentBlockDelta?.delta?.text !== undefined) {
+                    yield { type: 'text_delta', text: event.contentBlockDelta.delta.text };
+                }
+                else if (event.contentBlockDelta?.delta?.toolUse) {
+                    const index = event.contentBlockDelta.contentBlockIndex ?? 0;
+                    yield { type: 'tool_use_delta', id: toolIds.get(index) ?? `_idx_${index}`,
+                        input_json: event.contentBlockDelta.delta.toolUse.input ?? '' };
+                }
+                else if (event.contentBlockStop) {
+                    const index = event.contentBlockStop.contentBlockIndex ?? 0;
+                    const id = toolIds.get(index);
+                    if (id) {
+                        yield { type: 'tool_use_end', id };
+                        toolIds.delete(index);
+                    }
+                }
+                else if (event.metadata?.usage) {
+                    yield { type: 'usage', usage: tokenUsage(event.metadata.usage) };
+                }
+                else if (event.messageStop?.stopReason)
+                    stopReason = event.messageStop.stopReason;
+            }
+        }
+        catch (error) {
+            if (error instanceof Error && /^(Bedrock|API error)/.test(error.message))
+                throw error;
+            throw bedrockError(error);
+        }
+        if (!stopReason)
+            throw new IncompleteStreamError();
+        yield { type: 'done', stopReason };
+    }
+}

package/dist/agent/backends/claude_cli.js

@@ -1,3 +1,4 @@
+import { IncompleteStreamError } from './transport_errors.js';
 import { spawn, spawnSync } from 'child_process';
 import { randomUUID } from 'node:crypto';
 import { writeBackendTrace } from './trace.js';
@@ -216,6 +217,7 @@ function blockToText(block) {
             return `[assistant tool use ${block.name}] ${JSON.stringify(block.input)}`;
         case 'thinking':
         case 'redacted_thinking':
+        case 'responses_reasoning':
             return ''; // Native signed reasoning belongs only to its originating API.
         default: {
             const neverBlock = block;
@@ -505,6 +507,7 @@ export class ClaudeCliBackend {
         let resultCostUsd;
         let stopReason = 'end_turn';
         let resultText = '';
+        let sawResult = false;
         // Tool-marker guard. `fullText` is everything the model produced; `emittedLen`
         // is how much we've streamed as text_delta; once `toolMode` is set (the
         // `<ztc_tool_call>` marker appeared) we stop streaming text and buffer the rest.
@@ -556,6 +559,7 @@ export class ClaudeCliBackend {
                     push({ type: 'reasoning_delta', text: d.thinking });
             }
             else if (evt.type === 'result') {
+                sawResult = true;
                 if (evt.is_error) {
                     // Mirror the buffered generate() path: a usage/rate limit must surface as
                     // a typed RateLimitError so RotatingBackend cools + fails over. Only the
@@ -597,6 +601,10 @@ export class ClaudeCliBackend {
                 finish(new ClaudeCliError(`Claude Code CLI exited with code ${code}.${detail ? `\n${detail}` : ''}`, 'claude_cli_exit', { exitCode: code ?? undefined, stderr: detail }));
                 return;
             }
+            if (!sawResult) {
+                finish(new IncompleteStreamError());
+                return;
+            }
             // Provider didn't stream deltas (rare) — fold the final result text into the
             // guarded buffer so tool extraction + text emission below still apply.
             if (!streamedText && resultText)

package/dist/agent/backends/codex_app_server.js

@@ -1296,6 +1296,8 @@ export class CodexAppServerClient {
                     trust: 'assistant_context',
                 };
             }
+            if (block.type === 'responses_reasoning')
+                return { type: 'provider_context_omitted' };
             return {
                 type: block.type,
                 mediaType: block.mediaType,

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

@@ -47,6 +47,7 @@ export declare class CodexAuthManager {
     private openaiApiKey;
     /** Full parsed file so fields introduced by newer Codex CLIs survive refresh. */
     private source;
+    private refreshInFlight;
     constructor(authFilePath?: string);
     /** Synchronously load and validate credentials from ~/.codex/auth.json */
     loadCredentialsSync(): void;
@@ -54,8 +55,10 @@ export declare class CodexAuthManager {
     getAccountId(): string | undefined;
     /** Get a valid access token, refreshing if needed */
     getAccessToken(signal?: AbortSignal): Promise<string>;
-    /** Refresh the access token via OAuth */
-    refreshToken(signal?: AbortSignal): Promise<void>;
+    /** Serialize rotating-token updates within this process and across file-sharing processes. */
+    refreshToken(signal?: AbortSignal | boolean, force?: boolean): Promise<void>;
+    private refreshTokenWithLock;
+    private performOAuthRefresh;
     /** Decode JWT payload without a library (local trust boundary) */
     private decodeJwtPayload;
     /** Check if token expires within bufferSec seconds (caches exp to avoid per-request JWT decode) */

package/dist/agent/backends/codex_auth.js

@@ -8,19 +8,30 @@
  * refresh as fallback.
  */
 import { randomBytes } from 'crypto';
-import { chmodSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'fs';
+import { chmodSync, closeSync, fchownSync, fstatSync, fsyncSync, lstatSync, openSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'fs';
 import { homedir } from 'os';
 import { join } from 'path';
-import { buildResponsesInput, isValidResponsesTerminal, parseResponsesOutput, readBoundedResponsesText, readBoundedProviderError, requireValidResponsesOutputItem, streamResponsesSSE, } from './openai_responses.js';
+import { buildResponsesInput, isValidResponsesTerminal, parseResponsesOutput, readBoundedProviderError, readBoundedResponsesText, requireValidResponsesOutputItem, streamResponsesSSE, } from './openai_responses.js';
+import { responsesReasoning } from './responses_reasoning.js';
 import { RateLimitError, parseResetAt } from './rate_limit.js';
 import { CODEX_LEGACY_PROVIDER } from './provider_ids.js';
 import { CodexBufferedRecovery } from './codex_buffered_recovery.js';
+let fileLock;
+// Loaded on first refresh: the headless package shares this module but does
+// not ship proper-lockfile. Without it, refreshes are still serialized within
+// the process, which is what every runtime did before the shared lock.
+function loadFileLock() {
+    fileLock ??= import('proper-lockfile').then(module => module.default ?? module, () => null);
+    return fileLock;
+}
 /**
  * Shared auth file with Codex CLI (~/.codex/auth.json). Both ZTC and Codex CLI
  * read and write this file. ZTC replaces it atomically, so concurrent readers
  * see the old or new credentials and never a truncated JSON document.
  */
-export const CODEX_AUTH_FILE_PATH = join(homedir(), '.codex', 'auth.json');
+export const CODEX_AUTH_FILE_PATH = process.env.CODEX_AUTH_FILE_PATH
+    || process.env.ZTC_CODEX_AUTH_FILE || process.env.CODEX_AUTH_FILE
+    || join(process.env.CODEX_HOME || join(homedir(), '.codex'), 'auth.json');
 export const CODEX_AUTH_SENTINEL = 'codex-subscription-auth';
 const OAUTH_TOKEN_URL = 'https://auth.openai.com/oauth/token';
 const DEFAULT_CODEX_CLIENT_ID = 'app_EMoamEEZ73f0CkXaXp7hrann';
@@ -53,23 +64,32 @@ function optionalTokenField(data, name) {
 }
 function writeCodexAuthFileAtomic(path, data) {
     const temporaryPath = `${path}.tmp.${process.pid}.${randomBytes(8).toString('hex')}`;
+    let descriptor;
     try {
-        writeFileSync(temporaryPath, JSON.stringify(data, null, 2), {
-            encoding: 'utf8',
-            flag: 'wx',
-            mode: 0o600,
-        });
+        const existing = lstatSync(path);
+        if (!existing.isFile() || existing.isSymbolicLink())
+            throw new Error('Codex auth path must remain a regular file during refresh.');
+        descriptor = openSync(temporaryPath, 'wx', 0o600);
+        writeFileSync(descriptor, JSON.stringify(data, null, 2), 'utf8');
+        const temporary = fstatSync(descriptor);
+        if (temporary.uid !== existing.uid || temporary.gid !== existing.gid)
+            fchownSync(descriptor, existing.uid, existing.gid);
+        fsyncSync(descriptor);
+        closeSync(descriptor);
+        descriptor = undefined;
         chmodSync(temporaryPath, 0o600);
         renameSync(temporaryPath, path);
     }
-    catch (error) {
+    finally {
+        if (descriptor !== undefined)
+            closeSync(descriptor);
         try {
             unlinkSync(temporaryPath);
         }
-        catch {
-            // The rename may already have consumed the temporary path.
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
         }
-        throw error;
     }
 }
 function throwIfRefreshAborted(signal) {
@@ -92,6 +112,29 @@ function parseCodexAuthData(data) {
     if (!accessToken || !refreshToken) {
         throw new Error("Codex auth file is incomplete (missing tokens). Run 'codex' to re-authenticate.");
     }
+    const expectedEmail = process.env.CODEX_EXPECTED_EMAIL?.trim().toLowerCase();
+    if (expectedEmail) {
+        let claims;
+        try {
+            const parts = (idToken ?? '').split('.');
+            if (parts.length !== 3)
+                throw new Error('Invalid identity token');
+            const parsed = JSON.parse(Buffer.from(parts[1], 'base64url').toString('utf8'));
+            if (!isRecord(parsed))
+                throw new Error('Invalid identity claims');
+            claims = parsed;
+        }
+        catch {
+            throw new Error('Codex auth account identity is invalid. Re-authenticate the dedicated credential stream.');
+        }
+        const identity = claims['https://api.openai.com/auth'];
+        if (typeof accountId !== 'string' || !accountId.trim() || !isRecord(identity) || identity.chatgpt_account_id !== accountId) {
+            throw new Error('Codex auth account identity is invalid. Re-authenticate the dedicated credential stream.');
+        }
+        if (typeof claims.email !== 'string' || claims.email.trim().toLowerCase() !== expectedEmail || claims.email_verified !== true) {
+            throw new Error('Codex auth does not match the expected verified account. Re-authenticate the dedicated credential stream.');
+        }
+    }
     return {
         credentials: {
             auth_mode: data.auth_mode ?? 'chatgpt',
@@ -133,6 +176,7 @@ export class CodexAuthManager {
     openaiApiKey = undefined;
     /** Full parsed file so fields introduced by newer Codex CLIs survive refresh. */
     source = null;
+    refreshInFlight = null;
     constructor(authFilePath = CODEX_AUTH_FILE_PATH) {
         this.authFilePath = authFilePath;
     }
@@ -175,12 +219,52 @@ export class CodexAuthManager {
         await this.refreshToken(signal);
         return this.credentials.access_token;
     }
-    /** Refresh the access token via OAuth */
-    async refreshToken(signal) {
+    /** Serialize rotating-token updates within this process and across file-sharing processes. */
+    async refreshToken(signal, force = false) {
+        if (signal === true) {
+            force = true;
+            signal = undefined;
+        }
+        if (signal === false)
+            signal = undefined;
         throwIfRefreshAborted(signal);
-        if (!this.credentials) {
+        if (!this.credentials)
             throw new Error('No credentials loaded');
+        if (this.refreshInFlight)
+            return this.refreshInFlight;
+        const refresh = this.refreshTokenWithLock(signal, force);
+        this.refreshInFlight = refresh;
+        try {
+            await refresh;
+        }
+        finally {
+            if (this.refreshInFlight === refresh)
+                this.refreshInFlight = null;
         }
+    }
+    async refreshTokenWithLock(signal, force) {
+        const observed = { ...this.credentials };
+        const lockfile = await loadFileLock();
+        const release = lockfile ? await lockfile.lock(this.authFilePath, {
+            realpath: false, stale: 120_000, update: 10_000,
+            retries: { retries: 20, factor: 1.25, minTimeout: 100, maxTimeout: 2000, randomize: true },
+        }) : async () => { };
+        try {
+            throwIfRefreshAborted(signal);
+            this.loadCredentialsSync();
+            const current = this.credentials;
+            const peerRefreshed = current.access_token !== observed.access_token || current.refresh_token !== observed.refresh_token;
+            if ((peerRefreshed || !force) && !this.isExpiringSoon(current.access_token))
+                return;
+            await this.performOAuthRefresh(signal);
+        }
+        finally {
+            await release();
+        }
+    }
+    async performOAuthRefresh(signal) {
+        if (!this.credentials)
+            throw new Error('No credentials loaded');
         const timeoutSignal = AbortSignal.timeout(CODEX_OAUTH_TIMEOUT_MS);
         const requestSignal = signal
             ? AbortSignal.any([signal, timeoutSignal])
@@ -205,9 +289,10 @@ export class CodexAuthManager {
             if (timeoutSignal.aborted) {
                 throw new Error('Codex token refresh timed out. Run \'codex\' to re-authenticate.');
             }
-            throw new Error(`Failed to refresh Codex token. Run 'codex' to re-authenticate. (${e.message})`);
+            throw new Error("Failed to refresh Codex token. Run 'codex' to re-authenticate.");
         }
         if (!res.ok) {
+            await res.body?.cancel();
             throw new Error(`Failed to refresh Codex token (HTTP ${res.status}). Run 'codex' to re-authenticate.`);
         }
         let rawData;
@@ -222,6 +307,8 @@ export class CodexAuthManager {
             if (timeoutSignal.aborted) {
                 throw new Error('Codex token refresh timed out. Run \'codex\' to re-authenticate.');
             }
+            if (error instanceof SyntaxError)
+                throw new Error("Failed to refresh Codex token. Run 'codex' to re-authenticate.");
             throw error;
         }
         if (!isRecord(rawData)) {
@@ -271,6 +358,9 @@ export class CodexAuthManager {
         if (nextCredentials.client_id)
             onDisk.client_id = nextCredentials.client_id;
         onDisk.last_refresh = nextCredentials.last_refresh;
+        const validated = parseCodexAuthData(onDisk);
+        if (validated.credentials.account_id !== this.credentials.account_id)
+            throw new Error('Refreshed Codex auth changed account identity');
         writeCodexAuthFileAtomic(this.authFilePath, onDisk);
         this.credentials = nextCredentials;
         this.source = onDisk;
@@ -325,6 +415,10 @@ export class CodexAuthBackend {
     }
     /** POST the streaming Responses request, refreshing the token once on 401. */
     async fetchResponses(request, _retried = false, recovery) {
+        const serviceTier = process.env.ZTC_CODEX_SERVICE_TIER;
+        if (serviceTier !== undefined && !['default', 'priority', 'ultrafast'].includes(serviceTier)) {
+            throw new Error('Unsupported Codex service tier; use default, priority, or ultrafast');
+        }
         const headers = await this.buildHeaders(request.signal);
         const input = buildResponsesInput(request.messages);
         const tools = request.tools.map(t => ({
@@ -332,6 +426,7 @@ export class CodexAuthBackend {
             name: t.name,
             description: t.description,
             parameters: t.parameters,
+            strict: false,
         }));
         const system = request.system || 'You are a helpful assistant.';
         const body = {
@@ -356,10 +451,12 @@ export class CodexAuthBackend {
         // Codex/GPT reasoning effort + fast mode (Responses API shape). Always
         // request a reasoning summary so the agent's thinking streams to the UI as a
         // collapsed thinking block (gpt-5.x are reasoning models).
-        body.reasoning = request.codexEffort
-            ? { effort: request.codexEffort, summary: 'auto' }
-            : { summary: 'auto' };
-        if (request.codexFastMode) {
+        body.reasoning = responsesReasoning(request.model, request.codexEffort, 'codex');
+        if (/^gpt-(?:6-astra|6\.1-sol)(?:-|$)/i.test(request.model))
+            body.include = ['reasoning.encrypted_content'];
+        if (serviceTier !== undefined)
+            body.service_tier = serviceTier;
+        else if (request.codexFastMode) {
             body.service_tier = 'priority';
         }
         const response = await (recovery?.fetch ?? fetch)(`${CODEX_API_BASE}/responses`, {
@@ -370,12 +467,17 @@ export class CodexAuthBackend {
         });
         if (!response.ok) {
             if (response.status === 401 && !_retried && (!recovery || recovery.canPost())) {
-                if (recovery)
-                    await response.body?.cancel();
-                await this.authManager.refreshToken(request.signal);
+                await response.body?.cancel();
+                await this.authManager.refreshToken(request.signal, true);
                 return this.fetchResponses(request, true, recovery);
             }
-            const errorText = await readBoundedProviderError(response);
+            // A 429 body only classifies the limit window; provider text is never surfaced.
+            const limitText = response.status === 429 ? await readBoundedProviderError(response).catch(() => '') : '';
+            if (response.status !== 429)
+                await response.body?.cancel();
+            const rawRequestId = response.headers.get('x-request-id') || '';
+            const requestId = /^[A-Za-z0-9._:-]{1,128}$/.test(rawRequestId) ? rawRequestId : '';
+            const errorText = `Codex API error (${response.status})${requestId ? ` request_id=${requestId}` : ''}`;
             if (response.status === 429) {
                 // Typed so the rotation engine can cool this account and fail over.
                 const now = Date.now();
@@ -389,11 +491,11 @@ export class CodexAuthBackend {
                 throw new RateLimitError({
                     provider: CODEX_LEGACY_PROVIDER,
                     resetAt,
-                    weekly: /week/i.test(errorText),
+                    weekly: /week/i.test(limitText),
                     detail: errorText,
                 });
             }
-            throw new Error(`Codex API error (${response.status}): ${errorText}`);
+            throw new Error(errorText);
         }
         return request.maxResponseBytes === undefined ? response : this.boundResponse(response, request.maxResponseBytes);
     }
@@ -452,7 +554,7 @@ export class CodexAuthBackend {
      * tool_use + usage + stopReason assembled from the completed output items.
      */
     async *generateStream(request) {
-        yield* streamResponsesSSE(await this.fetchResponses(request), request.maxResponseBytes);
+        yield* streamResponsesSSE(await this.fetchResponses(request), request.maxResponseBytes, { failureError: 'Codex response stream failed' });
     }
     /**
      * Parse SSE stream and build a BackendResponse.
@@ -525,13 +627,11 @@ export class CodexAuthBackend {
                 }
             }
             else if (event.type === 'response.failed' || event.type === 'error') {
-                const resp = event.response;
-                const errObj = (resp?.error ?? event.error);
-                failure = errObj?.message || 'the provider reported a stream failure';
+                failure = 'Codex response stream failed';
             }
         }
         if (failure)
-            throw new Error(`Responses API stream failed: ${failure}`);
+            throw new Error(failure);
         if (!terminalEventSeen) {
             throw new Error('Responses API stream ended without a valid terminal response event');
         }

package/dist/agent/backends/gemini.js

@@ -14,7 +14,7 @@ export class GeminiBackend extends BaseBackend {
             if (typeof content === 'string') {
                 return [{ text: content }];
             }
-            return content.filter(block => block.type !== 'thinking' && block.type !== 'redacted_thinking').map(block => {
+            return content.filter(block => block.type !== 'thinking' && block.type !== 'redacted_thinking' && block.type !== 'responses_reasoning').map(block => {
                 if (block.type === 'text') {
                     return { text: block.text };
                 }

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

@@ -23,4 +23,6 @@ export declare function readHttpErrorBody(response: Response, signal?: AbortSign
     body: string;
     bodyReadState: BodyReadState;
 }>;
+/** Credentials in error text a person will read: bearer tokens, `key: value` credential pairs and sk- keys. */
+export declare function redactErrorText(text: string): string;
 export {};

package/dist/agent/backends/http_error.js

@@ -189,6 +189,10 @@ function redact(text, headers, incomplete) {
         return redactText(text.replace(/\\+(["'])/g, '$1'), secrets, incomplete);
     }
 }
+/** Credentials in error text a person will read: bearer tokens, `key: value` credential pairs and sk- keys. */
+export function redactErrorText(text) {
+    return redactText(text, new Set(), false);
+}
 function redactText(text, secrets, incomplete) {
     if (incomplete) {
         // An unfinished quoted credential can contain whitespace. None of the

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

@@ -1,3 +1,5 @@
+export { BedrockBackend } from './bedrock.js';
+import { type BedrockBackendConfig } from './bedrock.js';
 export { AnthropicBackend, AnthropicApiError, createNativeAnthropicMessagesRouterBackend } from './anthropic.js';
 export type { NativeAnthropicMessagesRouterConfig } from './anthropic.js';
 export { OpenAIBackend } from './openai.js';
@@ -20,6 +22,7 @@ import type { AgentBackend, BackendRequest, BackendResponse, StreamEvent } from
 import { AccountPool, type RotationMode } from './account_rotation.js';
 import type { Message } from '../../types.js';
 export interface CreateBackendOptions {
+    bedrock?: BedrockBackendConfig;
     apiKey: string;
     baseUrl?: string;
     apiEndpoint?: string;