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

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

@@ -101,8 +101,12 @@ export declare class RotatingBackend implements AgentBackend {
      */
     private current;
     private steeringAccepted;
+    private lastRequestRetryAllowed;
     constructor(opts: RotatingBackendOptions);
     steerUserMessage(message: Message): Promise<boolean>;
+    /** Preserve the admission decision of the backend that actually dispatched,
+     * even after rotation selects a different account for the next user turn. */
+    allowsRequestRetryAfterFailure(): boolean;
     /** Close a per-turn inner and forget it as current if it still is. */
     private releaseInner;
     /**

package/dist/agent/backends/account_rotation.js

@@ -121,6 +121,7 @@ export class RotatingBackend {
      */
     current = null;
     steeringAccepted = false;
+    lastRequestRetryAllowed = true;
     constructor(opts) {
         this.opts = opts;
         this.now = opts.now ?? (() => Date.now());
@@ -131,6 +132,9 @@ export class RotatingBackend {
             this.steeringAccepted = true;
         return accepted;
     }
+    /** Preserve the admission decision of the backend that actually dispatched,
+     * even after rotation selects a different account for the next user turn. */
+    allowsRequestRetryAfterFailure() { return this.lastRequestRetryAllowed; }
     /** Close a per-turn inner and forget it as current if it still is. */
     releaseInner(inner) {
         if (this.current === inner) {
@@ -229,6 +233,7 @@ export class RotatingBackend {
             if (!account)
                 throw this.terminalError();
             const inner = this.current = this.opts.buildInner(account);
+            this.lastRequestRetryAllowed = inner.allowsRequestRetryAfterFailure?.(req) !== false;
             this.steeringAccepted = false;
             try {
                 return await inner.generate(req);
@@ -250,7 +255,7 @@ export class RotatingBackend {
                 const next = this.rotate(account, sig);
                 // A dynamic tool already ran this turn -> replaying re-fires its side
                 // effect. Cool the failed account for the next turn, but surface this error.
-                if (replayUnsafe || this.steeringAccepted)
+                if (!this.lastRequestRetryAllowed || replayUnsafe || this.steeringAccepted)
                     throw error;
                 if (!next)
                     throw this.terminalError();
@@ -273,6 +278,7 @@ export class RotatingBackend {
                 throw this.terminalError();
             let emitted = false;
             const inner = this.current = this.opts.buildInner(account);
+            this.lastRequestRetryAllowed = inner.allowsRequestRetryAfterFailure?.(req) !== false;
             this.steeringAccepted = false;
             try {
                 // generateStream is required on AgentBackend — no fallback probe.
@@ -299,7 +305,7 @@ export class RotatingBackend {
                 const next = this.rotate(account, sig);
                 // Mid-stream partial output OR a dynamic tool that already ran -> can't
                 // replay cleanly. Pool is rotated for the next turn; surface this error.
-                if (emitted || replayUnsafe || this.steeringAccepted)
+                if (!this.lastRequestRetryAllowed || emitted || replayUnsafe || this.steeringAccepted)
                     throw error;
                 if (!next)
                     throw this.terminalError();

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

@@ -4,14 +4,27 @@ interface AnthropicBackendConfig {
     authToken?: string;
     authTokenProvider?: () => Promise<string>;
     apiEndpoint?: string;
+    validateStrictTools?: boolean;
+    preserveNativeHistory?: boolean;
 }
+export interface NativeAnthropicMessagesRouterConfig {
+    baseUrl: string;
+    authToken?: string;
+    authTokenProvider?: () => Promise<string>;
+}
+/** Hosted transport with no provider-key or ambient-credential path. */
+export declare function createNativeAnthropicMessagesRouterBackend(config: NativeAnthropicMessagesRouterConfig): AnthropicBackend;
 export declare class AnthropicBackend implements AgentBackend {
+    readonly preservesNativeHistory: boolean;
     private apiKey?;
     private authToken?;
     private authTokenProvider?;
     private apiEndpoint;
     private cacheControl;
+    private readonly validateStrictTools;
     constructor(config: AnthropicBackendConfig);
+    isAuthenticationConfigured(): boolean;
+    allowsBufferedFallbackAfterStreamFailure(): boolean;
     private buildHeaders;
     private buildBody;
     generate(request: BackendRequest): Promise<BackendResponse>;

package/dist/agent/backends/anthropic.js

@@ -1,5 +1,57 @@
+import { modelContract } from '@zerg/model-contracts';
 import { parseSSEStream } from './sse.js';
-import { getSupportedClaudeReasoningEfforts } from '../../utils/models.js';
+import { readBoundedProviderError } from './openai_responses.js';
+/** Hosted transport with no provider-key or ambient-credential path. */
+export function createNativeAnthropicMessagesRouterBackend(config) {
+    const url = new URL(config.baseUrl);
+    if (!['https:', 'http:'].includes(url.protocol) || url.username || url.password || url.search || url.hash) {
+        throw new Error('Native Anthropic Router requires an HTTP(S) base URL without credentials, query or fragment');
+    }
+    if (!config.authToken?.trim() && !config.authTokenProvider) {
+        throw new Error('Native Anthropic Router requires a scoped bearer credential');
+    }
+    return new AnthropicBackend({
+        apiEndpoint: `${url.toString().replace(/\/+$/, '')}/v1/messages`,
+        authToken: config.authToken,
+        authTokenProvider: config.authTokenProvider,
+        validateStrictTools: true,
+        preserveNativeHistory: true,
+    });
+}
+/** Reject unsupported strict constraints; never silently narrow an open map. */
+function validateNativeStrictSchema(name, schema) {
+    if ((schema.type === 'object' || schema.properties !== undefined || schema.additionalProperties !== undefined)
+        && schema.additionalProperties !== false) {
+        throw new Error(`Native Anthropic Router tool "${name}" requires additionalProperties:false on every object; use a closed schema or a validated JSON string`);
+    }
+    for (const key of ['minimum', 'maximum', 'exclusiveMinimum', 'exclusiveMaximum', 'multipleOf',
+        'minLength', 'maxLength', 'maxItems', 'uniqueItems', 'contains', 'minContains', 'maxContains']) {
+        if (schema[key] !== undefined)
+            throw new Error(`Native Anthropic Router tool "${name}" does not support ${key}; validate that constraint in the host`);
+    }
+    if (schema.minItems !== undefined && schema.minItems !== 0 && schema.minItems !== 1) {
+        throw new Error(`Native Anthropic Router tool "${name}" supports only minItems 0 or 1`);
+    }
+    if (typeof schema.$ref === 'string' && !schema.$ref.startsWith('#/')) {
+        throw new Error(`Native Anthropic Router tool "${name}" does not support external schema references`);
+    }
+    for (const key of ['properties', '$defs', 'definitions']) {
+        const definitions = schema[key];
+        if (definitions && typeof definitions === 'object' && !Array.isArray(definitions)) {
+            for (const child of Object.values(definitions)) {
+                if (child && typeof child === 'object' && !Array.isArray(child))
+                    validateNativeStrictSchema(name, child);
+            }
+        }
+    }
+    for (const key of ['items', 'anyOf', 'allOf', 'oneOf']) {
+        const children = schema[key];
+        for (const child of Array.isArray(children) ? children : [children]) {
+            if (child && typeof child === 'object' && !Array.isArray(child))
+                validateNativeStrictSchema(name, child);
+        }
+    }
+}
 // The TRUE context size for a request = uncached input + cache-read + cache-write.
 // Reading only input_tokens makes the context bar jump BACKWARDS on a cache hit
 // (input_tokens is then just the small uncached delta), which looks non-monotonic.
@@ -10,29 +62,37 @@ function anthropicInputTokens(usage) {
 }
 const EXTENDED_CACHE_BETA = 'extended-cache-ttl-2025-04-11';
 export class AnthropicBackend {
+    preservesNativeHistory;
     apiKey;
     authToken;
     authTokenProvider;
     apiEndpoint;
     cacheControl;
+    validateStrictTools;
     constructor(config) {
         this.apiKey = config.apiKey;
         this.authToken = config.authToken;
         this.authTokenProvider = config.authTokenProvider;
         this.apiEndpoint = config.apiEndpoint || 'https://api.anthropic.com/v1/messages';
+        this.validateStrictTools = config.validateStrictTools ?? false;
+        this.preservesNativeHistory = config.preserveNativeHistory ?? false;
         const ttl = (process.env.ZTC_PROMPT_CACHE_TTL || '1h').toLowerCase();
         this.cacheControl = ttl === 'off' ? null : ttl === '5m' ? { type: 'ephemeral' } : { type: 'ephemeral', ttl: '1h' };
     }
+    isAuthenticationConfigured() {
+        return Boolean(this.apiKey || this.authToken || this.authTokenProvider);
+    }
+    allowsBufferedFallbackAfterStreamFailure() { return false; }
     async buildHeaders() {
         const headers = {
             'Content-Type': 'application/json',
             'anthropic-version': '2023-06-01'
         };
         const authToken = this.authTokenProvider ? await this.authTokenProvider() : this.authToken;
-        if (authToken) {
+        if (authToken?.trim()) {
             headers.Authorization = `Bearer ${authToken}`;
         }
-        else if (this.apiKey) {
+        else if (this.apiKey && !this.authTokenProvider) {
             headers['x-api-key'] = this.apiKey;
         }
         else {
@@ -60,6 +120,9 @@ export class AnthropicBackend {
                     if (block.type === 'tool_use') {
                         return block;
                     }
+                    if (block.type === 'thinking' || block.type === 'redacted_thinking') {
+                        return block;
+                    }
                     if (block.type === 'video') {
                         return { type: 'video', source: { type: 'base64', media_type: block.mediaType, data: block.data } };
                     }
@@ -67,11 +130,28 @@ export class AnthropicBackend {
                     return { type: 'image', source: { type: 'base64', media_type: block.mediaType, data: block.data } };
                 })
         }));
-        const tools = request.tools.map(t => ({
-            name: t.name,
-            description: t.description,
-            input_schema: t.parameters
-        }));
+        const opus55 = /^claude-opus-5-5(?:$|-)/.test(request.model);
+        const tools = request.tools.map(t => {
+            let strict = false;
+            if (opus55) {
+                try {
+                    validateNativeStrictSchema(t.name, t.parameters);
+                    strict = true;
+                }
+                catch (error) {
+                    // The hosted native transport requires closed, supported schemas.
+                    // Direct credentials retain the caller's valid non-strict schemas.
+                    if (this.validateStrictTools)
+                        throw error;
+                }
+            }
+            return {
+                name: t.name,
+                description: t.description,
+                input_schema: t.parameters,
+                ...(strict ? { strict: true } : {}),
+            };
+        });
         // Render order is tools → system → messages. A breakpoint on the last system
         // block caches tools+system together; a breakpoint on the last message block
         // caches the conversation prefix. On the next turn (or a wake within the TTL)
@@ -89,8 +169,12 @@ export class AnthropicBackend {
                     lastMsg.content = [{ type: 'text', text: lastMsg.content, cache_control: cc }];
                 }
                 else if (Array.isArray(lastMsg.content) && lastMsg.content.length > 0) {
-                    const i = lastMsg.content.length - 1;
-                    lastMsg.content[i] = { ...lastMsg.content[i], cache_control: cc };
+                    // Signed blocks cannot accept cache-control or any other mutation.
+                    let i = lastMsg.content.length - 1;
+                    while (i >= 0 && ['thinking', 'redacted_thinking'].includes(lastMsg.content[i].type))
+                        i--;
+                    if (i >= 0)
+                        lastMsg.content[i] = { ...lastMsg.content[i], cache_control: cc };
                 }
             }
             // With no system to anchor it, the tools cache needs its own breakpoint on
@@ -99,16 +183,11 @@ export class AnthropicBackend {
                 tools[tools.length - 1] = { ...tools[tools.length - 1], cache_control: cc };
             }
         }
-        // Reasoning effort (GA on Opus 4.5+/Sonnet 4.6): output_config.effort. The
-        // value rides on request.codexEffort (the generic per-pane effort). 'minimal'
-        // is codex-only; the Anthropic API accepts low|medium|high|xhigh|max. Gate on
-        // the target model too: Haiku exposes NO effort parameter, so sending one
-        // hard-400s every turn — getSupportedClaudeReasoningEfforts returns [] for it
-        // (drop) and undefined for unrecognized ids (stay permissive).
-        const effort = request.codexEffort;
-        const supportedEfforts = getSupportedClaudeReasoningEfforts(request.model);
-        const modelAllowsEffort = supportedEfforts === undefined ||
-            (effort !== undefined && supportedEfforts.includes(effort));
+        // Exact reviewed families, including dated aliases, own the effort ladder.
+        // Unknown families and Haiku expose no unverified effort parameter.
+        const effort = request.codexEffort ?? (opus55 ? 'high' : undefined);
+        const supportedEfforts = modelContract('anthropic', request.model)?.reasoningEfforts ?? [];
+        const modelAllowsEffort = effort !== undefined && supportedEfforts.includes(effort);
         const outputConfig = effort && ['low', 'medium', 'high', 'xhigh', 'max'].includes(effort) && modelAllowsEffort
             ? { output_config: { effort } }
             : {};
@@ -119,6 +198,7 @@ export class AnthropicBackend {
             system,
             messages,
             tools,
+            ...(opus55 ? { thinking: { type: 'adaptive' }, tool_choice: { type: 'auto' } } : {}),
             ...outputConfig,
         };
     }
@@ -131,7 +211,7 @@ export class AnthropicBackend {
             signal: request.signal,
         });
         if (!response.ok) {
-            const errorText = await response.text();
+            const errorText = await readBoundedProviderError(response);
             throw new AnthropicApiError(response.status, errorText);
         }
         const data = await response.json();
@@ -140,6 +220,7 @@ export class AnthropicBackend {
         return {
             content: data.content,
             stopReason: data.stop_reason,
+            ...(data.stop_details ? { stopDetails: data.stop_details } : {}),
             usage: data.usage ? {
                 inputTokens,
                 outputTokens,
@@ -156,13 +237,18 @@ export class AnthropicBackend {
             signal: request.signal,
         });
         if (!response.ok) {
-            const errorText = await response.text();
+            const errorText = await readBoundedProviderError(response);
             throw new AnthropicApiError(response.status, errorText);
         }
         if (!response.body) {
             throw new Error('API error: no response body for streaming request');
         }
         let stopReason = 'end_turn';
+        let messageCompleted = false;
+        let stopDetails;
+        let accumulatedUsage = {};
+        const blocks = new Map();
+        const toolInputs = new Map();
         // Track index → real tool ID mapping (Anthropic sends real ID only in content_block_start)
         const indexToId = new Map();
         for await (const jsonStr of parseSSEStream(response.body)) {
@@ -171,12 +257,28 @@ export class AnthropicBackend {
                 event = JSON.parse(jsonStr);
             }
             catch {
+                if (this.validateStrictTools)
+                    throw new Error('Anthropic stream contained malformed JSON');
                 continue;
             }
             const eventType = event.type;
-            if (eventType === 'content_block_start') {
+            request.onActivity?.();
+            if (eventType === 'error') {
+                const providerError = event.error;
+                if (providerError?.type === 'overloaded_error') {
+                    throw new AnthropicApiError(529, JSON.stringify({ error: { type: 'overloaded_error', message: 'Anthropic stream failed' } }));
+                }
+                throw new Error('Anthropic stream failed');
+            }
+            else if (eventType === 'message_stop') {
+                messageCompleted = true;
+            }
+            else if (eventType === 'content_block_start') {
                 const index = event.index;
                 const block = event.content_block;
+                if (['thinking', 'redacted_thinking', 'text', 'tool_use'].includes(String(block.type))) {
+                    blocks.set(index, { ...block });
+                }
                 if (block.type === 'tool_use') {
                     const id = block.id;
                     indexToId.set(index, id);
@@ -185,17 +287,43 @@ export class AnthropicBackend {
             }
             else if (eventType === 'content_block_delta') {
                 const delta = event.delta;
+                const index = event.index;
+                const block = blocks.get(index);
                 if (delta.type === 'text_delta') {
+                    if (block?.type === 'text')
+                        block.text += delta.text;
                     yield { type: 'text_delta', text: delta.text };
                 }
+                else if (delta.type === 'thinking_delta') {
+                    if (block?.type === 'thinking')
+                        block.thinking += delta.thinking;
+                    yield { type: 'reasoning_delta', text: delta.thinking };
+                }
+                else if (delta.type === 'signature_delta') {
+                    if (block?.type === 'thinking')
+                        block.signature += delta.signature;
+                }
                 else if (delta.type === 'input_json_delta') {
-                    const index = event.index;
+                    toolInputs.set(index, (toolInputs.get(index) ?? '') + String(delta.partial_json ?? ''));
                     const id = indexToId.get(index) || `_idx_${index}`;
                     yield { type: 'tool_use_delta', id, input_json: delta.partial_json };
                 }
             }
             else if (eventType === 'content_block_stop') {
                 const index = event.index;
+                const block = blocks.get(index);
+                if (block) {
+                    if (block.type === 'tool_use' && toolInputs.has(index)) {
+                        try {
+                            block.input = JSON.parse(toolInputs.get(index));
+                        }
+                        catch {
+                            throw new Error('Anthropic stream ended a tool block with invalid JSON');
+                        }
+                    }
+                    yield { type: 'content_block', block };
+                    blocks.delete(index);
+                }
                 if (indexToId.has(index)) {
                     yield { type: 'tool_use_end', id: indexToId.get(index) };
                 }
@@ -204,15 +332,23 @@ export class AnthropicBackend {
                 const delta = event.delta;
                 if (delta.stop_reason) {
                     stopReason = delta.stop_reason;
+                    // A terminal message_delta is also a complete response boundary;
+                    // older compatible relays omit the trailing message_stop frame.
+                    messageCompleted = true;
                 }
+                if (delta.stop_details && typeof delta.stop_details === 'object')
+                    stopDetails = delta.stop_details;
                 const usage = event.usage;
                 if (usage) {
+                    accumulatedUsage = { ...accumulatedUsage, ...usage };
                     yield {
                         type: 'usage',
                         usage: {
-                            inputTokens: anthropicInputTokens(usage),
-                            outputTokens: usage.output_tokens ?? 0,
-                            totalTokens: anthropicInputTokens(usage) + (usage.output_tokens ?? 0)
+                            inputTokens: anthropicInputTokens(accumulatedUsage),
+                            outputTokens: accumulatedUsage.output_tokens ?? 0,
+                            totalTokens: anthropicInputTokens(accumulatedUsage) + (accumulatedUsage.output_tokens ?? 0),
+                            ...(accumulatedUsage.cache_read_input_tokens === undefined ? {} : { cachedInputTokens: accumulatedUsage.cache_read_input_tokens }),
+                            ...(accumulatedUsage.cache_creation_input_tokens === undefined ? {} : { cacheWriteInputTokens: accumulatedUsage.cache_creation_input_tokens }),
                         }
                     };
                 }
@@ -221,6 +357,7 @@ export class AnthropicBackend {
                 const message = event.message;
                 const usage = message.usage;
                 if (usage) {
+                    accumulatedUsage = { ...accumulatedUsage, ...usage };
                     yield {
                         type: 'usage',
                         usage: {
@@ -232,7 +369,11 @@ export class AnthropicBackend {
                 }
             }
         }
-        yield { type: 'done', stopReason };
+        if (blocks.size > 0)
+            throw new Error('Anthropic stream ended before a native content block completed');
+        if (!messageCompleted)
+            throw new Error('Anthropic stream ended before message completion');
+        yield { type: 'done', stopReason, ...(stopDetails ? { stopDetails } : {}) };
     }
 }
 export class AnthropicApiError extends Error {

package/dist/agent/backends/claude_cli.js

@@ -160,18 +160,17 @@ export function normalizeClaudeCliModel(model) {
     const trimmed = model.trim();
     if (!trimmed)
         return 'claude-sonnet-4-5';
-    // Claude Code CLI's `sonnet` alias currently selects the 1M context model,
-    // which requires usage credits. Use the standard-context Sonnet model for ZTC's picker.
-    if (trimmed === 'claude-opus-4-20250514' || trimmed === 'claude-3-opus-20240229') {
-        return 'opus';
-    }
-    if (trimmed === 'claude-code-sonnet' || trimmed === 'sonnet' || trimmed.startsWith('claude-sonnet-') || trimmed.includes('sonnet')) {
+    // Retain ZTC's standard-context choice for its exact legacy Sonnet aliases.
+    // Do not reinterpret other Sonnet selections as these legacy aliases.
+    if (trimmed === 'claude-code-sonnet' || trimmed === 'sonnet') {
         return 'claude-sonnet-4-5';
     }
-    if (trimmed.startsWith('claude-opus-') || trimmed.includes('opus')) {
+    // Reserve compatibility mappings for exact picker aliases; explicit names
+    // and context suffixes are selections for the CLI to resolve or reject.
+    if (trimmed === 'claude-code-opus' || trimmed === 'opus') {
         return 'opus';
     }
-    if (trimmed.startsWith('claude-haiku-') || trimmed.includes('haiku')) {
+    if (trimmed === 'claude-code-haiku' || trimmed === 'haiku') {
         return 'haiku';
     }
     return trimmed;
@@ -215,6 +214,9 @@ function blockToText(block) {
             return `[tool result ${block.tool_use_id}] ${typeof block.content === 'string' ? block.content : JSON.stringify(block.content)}`;
         case 'tool_use':
             return `[assistant tool use ${block.name}] ${JSON.stringify(block.input)}`;
+        case 'thinking':
+        case 'redacted_thinking':
+            return ''; // Native signed reasoning belongs only to its originating API.
         default: {
             const neverBlock = block;
             return JSON.stringify(neverBlock);
@@ -301,6 +303,8 @@ export function parseClaudeCliOutput(stdout) {
             usage: typeof inputTokens === 'number' && typeof outputTokens === 'number'
                 ? { inputTokens, outputTokens, totalTokens: inputTokens + outputTokens }
                 : undefined,
+            ...(typeof parsed.total_cost_usd === 'number' && Number.isFinite(parsed.total_cost_usd)
+                && parsed.total_cost_usd >= 0 ? { costUsd: parsed.total_cost_usd } : {}),
         };
     }
     catch (error) {
@@ -455,6 +459,7 @@ export class ClaudeCliBackend {
             content: [{ type: 'tool_use', id: `cli_${randomUUID()}`, name: call.name, input: call.input }],
             stopReason: 'tool_use',
             usage: resp.usage,
+            costUsd: resp.costUsd,
         };
     }
     /**
@@ -497,6 +502,7 @@ export class ClaudeCliBackend {
         let stderr = '';
         let streamedText = false;
         let resultUsage;
+        let resultCostUsd;
         let stopReason = 'end_turn';
         let resultText = '';
         // Tool-marker guard. `fullText` is everything the model produced; `emittedLen`
@@ -565,6 +571,8 @@ export class ClaudeCliBackend {
                     return;
                 }
                 resultUsage = evt.usage;
+                resultCostUsd = typeof evt.total_cost_usd === 'number' && Number.isFinite(evt.total_cost_usd)
+                    && evt.total_cost_usd >= 0 ? evt.total_cost_usd : undefined;
                 stopReason = evt.stop_reason || 'end_turn';
                 resultText = typeof evt.result === 'string' ? evt.result : '';
             }
@@ -616,6 +624,8 @@ export class ClaudeCliBackend {
                 const inputTokens = resultUsage.input_tokens + (resultUsage.cache_read_input_tokens ?? 0) + (resultUsage.cache_creation_input_tokens ?? 0);
                 push({ type: 'usage', usage: { inputTokens, outputTokens: resultUsage.output_tokens, totalTokens: inputTokens + resultUsage.output_tokens } });
             }
+            if (resultCostUsd !== undefined)
+                push({ type: 'cost', costUsd: resultCostUsd });
             push({ type: 'done', stopReason });
             finish();
         });

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

@@ -215,6 +215,7 @@ export declare class CodexAppServerClient {
 export declare class CodexAppServerBackend implements AgentBackend {
     private client;
     constructor(client?: CodexAppServerClient, options?: CodexAppServerClientOptions);
+    allowsRequestRetryAfterFailure(): boolean;
     /** The sandbox this backend's thread runs under. Observable so the factory's
      * plan-mode read-only downgrade can be asserted. */
     get sandbox(): CodexSandboxMode;

package/dist/agent/backends/codex_app_server.js

@@ -2,6 +2,7 @@ import { spawn } from 'node:child_process';
 import { createHash } from 'node:crypto';
 import { RateLimitError, parseResetAt } from './rate_limit.js';
 import { CODEX_APP_SERVER_PROVIDER } from './provider_ids.js';
+import { NativeObservationLimitError } from '../runtime/provider_native_evidence.js';
 export const MAX_CODEX_APP_SERVER_FRAME_BYTES = 1_048_576;
 export const MAX_CODEX_APP_SERVER_QUEUED_FRAMES = 1_024;
 /** Keep managed profiles on their own auth.json and ChatGPT subscription. */
@@ -14,6 +15,7 @@ const MAX_CODEX_APP_SERVER_REQUEST_TIMEOUT_MS = 120_000;
 const DEFAULT_CODEX_APP_SERVER_TURN_TIMEOUT_MS = 30 * 60_000;
 const MAX_CODEX_APP_SERVER_TURN_TIMEOUT_MS = 60 * 60_000;
 const MAX_CODEX_APP_SERVER_TOOL_CALLS_PER_TURN = 64;
+const MAX_CODEX_APP_SERVER_OBSERVATIONS_PER_TURN = 128;
 const MAX_CODEX_APP_SERVER_MODEL_PAGES = 20;
 const MAX_CODEX_APP_SERVER_MODELS = 2_000;
 /**
@@ -119,7 +121,30 @@ export function codexItemToObservation(rawItem) {
             const { type: _t, id: _i, ...detail } = item;
             void _t;
             void _i;
-            return { kind: 'action', id, label: type, detail };
+            const changes = Array.isArray(item.changes) ? item.changes : [];
+            const artifact = (value) => ({ path: value.path,
+                ...(typeof value.sha256 === 'string' ? { sha256: value.sha256 } : {}) });
+            const artifacts = changes.filter((change) => !!change && typeof change === 'object'
+                && typeof change.path === 'string').map(artifact);
+            let partial = changes.length !== artifacts.length;
+            if (typeof item.path === 'string')
+                artifacts.unshift(artifact({ path: item.path, sha256: item.sha256 }));
+            let output = typeof item.output === 'string' ? item.output : undefined;
+            let isError;
+            if (type === 'mcpToolCall' && item.result && typeof item.result === 'object') {
+                const result = item.result;
+                if (Array.isArray(result.content)) {
+                    const content = result.content.filter((entry) => !!entry
+                        && typeof entry === 'object' && entry.type === 'text' && typeof entry.text === 'string').map(entry => ({ type: entry.type, text: entry.text }));
+                    isError = result.isError === true;
+                    partial ||= content.length !== result.content.length;
+                    output = JSON.stringify({ content, isError });
+                }
+            }
+            return { kind: 'action', id, label: type, detail,
+                ...(typeof item.status === 'string' ? { status: item.status } : {}),
+                ...(output === undefined ? {} : { output }), ...(partial === undefined ? {} : { partial }),
+                ...(isError === undefined ? {} : { isError }), artifacts };
         }
     }
 }
@@ -587,6 +612,8 @@ export class CodexAppServerClient {
                     onToolCall: toolsActive ? options.onToolCall : undefined,
                     toolChain: Promise.resolve(),
                     toolCallCount: 0,
+                    observationCount: 0,
+                    observationFailure: false,
                     terminalReceived: false,
                     toolCancellation: new AbortController(),
                 };
@@ -994,7 +1021,29 @@ export class CodexAppServerClient {
             if (observation) {
                 for (const waiter of this.turnWaiters) {
                     if (waiter.threadId === params.threadId && waiter.turnId === nonEmptyId(params.turnId)) {
-                        waiter.onObservation?.(observation);
+                        if (waiter.terminalReceived)
+                            continue;
+                        if (++waiter.observationCount > MAX_CODEX_APP_SERVER_OBSERVATIONS_PER_TURN) {
+                            waiter.terminalReceived = true;
+                            waiter.toolCancellation.abort();
+                            waiter.toolChain = waiter.toolChain.then(() => {
+                                waiter.queue.fail(new NativeObservationLimitError(MAX_CODEX_APP_SERVER_OBSERVATIONS_PER_TURN));
+                            });
+                            continue;
+                        }
+                        const scoped = { ...observation, native: { provider: CODEX_APP_SERVER_PROVIDER,
+                                threadId: waiter.threadId, turnId: waiter.turnId } };
+                        // Completed reports join the same drain as native dynamic calls. A
+                        // terminal response cannot outrun durable report capture.
+                        waiter.toolChain = waiter.toolChain.then(async () => {
+                            if (!waiter.observationFailure)
+                                await waiter.onObservation?.(scoped);
+                        }).catch(error => {
+                            waiter.observationFailure = true;
+                            waiter.terminalReceived = true;
+                            waiter.toolCancellation.abort();
+                            waiter.queue.fail(error instanceof Error ? error : new Error(String(error)));
+                        });
                     }
                 }
             }
@@ -1222,7 +1271,7 @@ export class CodexAppServerClient {
                 trust: message.role === 'user' ? 'authorized_user_request' : 'assistant_context',
             };
         }
-        const content = message.content.map((block) => {
+        const content = message.content.filter(block => block.type !== 'thinking' && block.type !== 'redacted_thinking').map((block) => {
             if (block.type === 'text') {
                 return {
                     type: block.type,
@@ -1309,6 +1358,9 @@ export class CodexAppServerBackend {
     constructor(client, options = {}) {
         this.client = client || new CodexAppServerClient(options);
     }
+    // Dispatch starts a native tool loop. A failed turn can have effects even
+    // before a completed-item observation; generic retries must not regenerate it.
+    allowsRequestRetryAfterFailure() { return false; }
     /** The sandbox this backend's thread runs under. Observable so the factory's
      * plan-mode read-only downgrade can be asserted. */
     get sandbox() {

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

@@ -71,6 +71,7 @@ export declare class CodexAuthBackend implements AgentBackend {
     private buildHeaders;
     /** POST the streaming Responses request, refreshing the token once on 401. */
     private fetchResponses;
+    private boundResponse;
     /** Buffered path — kept as the fallback when streaming can't run. */
     generate(request: BackendRequest): Promise<BackendResponse>;
     /**