praxis-agent 0.48.1 → 0.50.0

package/README.md

@@ -212,11 +212,17 @@ troubleshooting. Run `praxis --help` for the authoritative command surface.
   imports, memory, skills, commands, agents, hooks, settings, MCP servers,
   plugins, and append-only `praxis.transcript` JSONL sessions under `~/.praxis`,
   with bounded MCP connection, discovery, and tool operations plus safe
-  disconnect recovery that never replays an already-dispatched call.
+  disconnect recovery that never replays an already-dispatched call. Default
+  tool selection defers `mcp__*` schemas behind a turn-scoped `ToolSearch`;
+  each query activates at most eight deterministic matches for the next model
+  request. Explicit concrete `--tools` selections load selected tools directly, while
+  `--disallowedTools ToolSearch` restores the complete tool list.
 - **Provider-neutral models** — native Provider Registry/Vault routing, API
   adapters, an experimental Codex OAuth adapter, explicit capability checks,
-  per-attempt bounded deadlines, typed recovery for malformed streamed tool
-  arguments without tool execution or lost resumability, and
+  separate per-attempt connect, byte-idle, and absolute-total timeouts, typed
+  recovery for malformed streamed tool arguments without tool execution or
+  lost resumability, one default-on bounded Anthropic non-streaming replay for
+  eligible stream/idle failures without exposing failed-attempt output, and
   token-only/no-API-dollar accounting for subscription runs.
 - **Transactional self-update** — `praxis update` verifies the package before
   installing it, rejects concurrent updates, and can roll back after an
@@ -302,7 +308,7 @@ normal/low-capability full-frame p95 budgets of `<16.7/<33 ms`.
 `npm run test:coverage` measures all production code under `src/**` with V8 and
 enforces global floors of 79% statements, 70% branches, 85% functions, and 81% lines,
 and rejects any production runtime module with zero covered statements (while allowing
-type-only modules). `npm run test:fixtures` executes the 69-behavior native contract; 61 behaviors
+type-only modules). `npm run test:fixtures` executes the 70-behavior native contract; 62 behaviors
 are qualified and 8 are explicitly excluded. `npm run verify:fixture-contracts`
 performs the structural check and is part of `npm run check`.
 `npm run test:core-completion` is retained as a compatibility alias for

package/dist/application/session-service.d.ts

@@ -39,6 +39,7 @@ export interface ClaudeSessionServiceOptions {
     claudeVersion: string;
     provider?: ModelProvider;
     tools?: ToolRegistry;
+    deferMcpTools?: boolean;
     permissions?: PermissionResolver;
     permissionResolverForMode?: (mode: AgentPermissionMode) => PermissionResolver;
     permissionMode?: ClaudePermissionMode;

package/dist/application/session-service.js

@@ -49,6 +49,7 @@ import { ClaudeWorktreeToolRegistry } from '../tools/claude-worktree-tools.js';
 import { completeMeteredModelRequest } from './metered-model-completion.js';
 import { SessionMemoryController, SessionMemoryStateError, SessionMemoryStore, } from './session-memory.js';
 import { FilteredToolRegistry } from '../tools/filtered-tool-registry.js';
+import { DeferredToolCatalog } from '../tools/deferred-tool-catalog.js';
 import { ClaudeCapabilityToolRegistry, resolveClaudeToolCapabilities, } from '../tools/claude-capabilities.js';
 import { generateToolUseSummary } from './tool-use-summary.js';
 import { ClaudeUserMessageToolRegistry, } from '../tools/claude-user-message.js';
@@ -1108,6 +1109,9 @@ export class ClaudeSessionService {
                     ? { providerForModel: this.options.providerForModel }
                     : {}),
                 baseTools: wrappedBase,
+                ...(this.options.deferMcpTools === undefined
+                    ? {}
+                    : { deferMcpTools: this.options.deferMcpTools }),
                 permissions: this.options.permissions,
                 ...(this.options.permissionResolverForMode
                     ? {
@@ -2846,6 +2850,9 @@ export class ClaudeSessionService {
                             ? { providerForModel: this.options.providerForModel }
                             : {}),
                         baseTools,
+                        ...(this.options.deferMcpTools === undefined
+                            ? {}
+                            : { deferMcpTools: this.options.deferMcpTools }),
                         permissions: turnPermissions,
                         ...(this.options.permissionResolverForMode
                             ? {
@@ -3024,9 +3031,16 @@ export class ClaudeSessionService {
                 const structuredTools = this.options.structuredOutputSchema && structuredCapture
                     ? new StructuredOutputRegistry(agentScopedTools ?? this.options.tools ?? emptyToolRegistry, this.options.structuredOutputSchema, structuredCapture)
                     : agentScopedTools;
-                const hookTools = this.options.hooks && structuredTools && turnPermissions
+                const activeTurnTools = structuredTools
+                    ? new DeferredToolCatalog(structuredTools).startTurn({
+                        enabled: this.options.deferMcpTools !== false &&
+                            !(agent && agent.tools !== undefined),
+                        restoredToolNames: unresolvedToolCalls.map((call) => call.name),
+                    })
+                    : undefined;
+                const hookTools = this.options.hooks && activeTurnTools && turnPermissions
                     ? new ClaudeHookToolCoordinator({
-                        tools: structuredTools,
+                        tools: activeTurnTools,
                         permissions: turnPermissions,
                         hooks: this.options.hooks,
                         session: hookSession,
@@ -3063,7 +3077,7 @@ export class ClaudeSessionService {
                     ...(hookTools
                         ? { tools: hookTools, permissions: hookTools }
                         : {
-                            ...(structuredTools ? { tools: structuredTools } : {}),
+                            ...(activeTurnTools ? { tools: activeTurnTools } : {}),
                             ...(turnPermissions ? { permissions: turnPermissions } : {}),
                         }),
                 });
@@ -3446,8 +3460,8 @@ export class ClaudeSessionService {
                     let compactionDurationMs;
                     let compactionDurationWithoutRetriesMs;
                     let compactionModelUsage;
-                    const definitions = provider.capabilities.tools
-                        ? (structuredTools?.definitions() ?? [])
+                    const currentDefinitions = () => provider.capabilities.tools
+                        ? (activeTurnTools?.definitions() ?? [])
                         : [];
                     const budget = this.contextBudget(provider);
                     const contextEngine = new ContextEngine({
@@ -3526,7 +3540,7 @@ export class ClaudeSessionService {
                                         ...pendingMessages,
                                     ]),
                                 ],
-                                tools: definitions,
+                                tools: currentDefinitions(),
                             };
                         },
                         irreducible: () => ({
@@ -3540,12 +3554,13 @@ export class ClaudeSessionService {
                                     })),
                                 ]),
                             ],
-                            tools: definitions,
+                            tools: currentDefinitions(),
                         }),
                         propose: async () => {
                             const activeNativeLease = nativeLease;
                             if (!budget)
                                 throw new Error('Context budget is unavailable');
+                            const definitions = currentDefinitions();
                             const historyMessages = activeTurnMessages();
                             if (historyMessages.length === 0)
                                 throw new Error('Cannot compact an empty native transcript');
@@ -3754,7 +3769,10 @@ export class ClaudeSessionService {
                                 ]),
                             ];
                             return {
-                                envelope: { messages: proposedMessages, tools: definitions },
+                                envelope: {
+                                    messages: proposedMessages,
+                                    tools: definitions,
+                                },
                                 commit: async () => {
                                     if (signal?.aborted)
                                         throw new AgentRunCancelledError();
@@ -4062,6 +4080,7 @@ export class ClaudeSessionService {
                         };
                     }
                     if (shellCommand === undefined && budget) {
+                        const definitions = currentDefinitions();
                         await contextEngine.prepare(contextTransitionPort([], currentTurnUserMessages ?? []), signal);
                         budget.assertFits(budget.evaluate([
                             ...contextMessages,
@@ -4387,6 +4406,7 @@ export class ClaudeSessionService {
                         ...contextMessages,
                         ...injectTurnContext(memorySnapshot),
                     ];
+                    const definitions = currentDefinitions();
                     const currentContextTokens = contextEngine.report({
                         messages: providerVisibleMessages,
                         tools: definitions,

package/dist/application/subagent-service.d.ts

@@ -59,6 +59,7 @@ export interface ClaudeSubagentExecutorOptions {
     claudeVersion: string;
     provider: ModelProvider;
     baseTools: ToolRegistry;
+    deferMcpTools?: boolean;
     permissions: PermissionResolver;
     permissionResolverForMode?: (mode: AgentPermissionMode) => PermissionResolver;
     parentPermissionMode?: () => AgentPermissionMode;

package/dist/application/subagent-service.js

@@ -10,6 +10,7 @@ import { ContextBudget } from '../core/context-budget.js';
 import { AgentRuntime, } from '../core/runtime.js';
 import { composePermissionResolvers } from '../core/permission-policy.js';
 import { resolveToolSchedulingPolicy } from '../core/tool-scheduling-policy.js';
+import { DeferredToolCatalog } from '../tools/deferred-tool-catalog.js';
 import { BUILTIN_STATUSLINE_AGENT_PATH, } from '../extensions/claude-extensions.js';
 import { ClaudeHookToolCoordinator } from '../hooks/claude-hook-tools.js';
 import { InMemorySidechainStore } from '../persistence/in-memory-sidechain-store.js';
@@ -2059,9 +2060,14 @@ export class ClaudeSubagentExecutor {
                 ? new RestrictedToolRegistry(structuredOnlyTools, ['Read', 'Edit'])
                 : structuredOnlyTools, options.outputSchema, options.structuredOutput)
             : scopedTools;
+        const activeAgentTools = new DeferredToolCatalog(agentTools).startTurn({
+            enabled: this.options.deferMcpTools !== false &&
+                customAgent?.tools === undefined,
+            restoredToolNames: nativeRecoveryCalls.map((call) => call.name),
+        });
         const runtimeTools = scopedHooks
             ? new ClaudeHookToolCoordinator({
-                tools: agentTools,
+                tools: activeAgentTools,
                 permissions,
                 hooks: scopedHooks,
                 session: hookSession,
@@ -2072,7 +2078,7 @@ export class ClaudeSubagentExecutor {
                     }
                     : {}),
             })
-            : agentTools;
+            : activeAgentTools;
         const runtimePermissions = scopedHooks
             ? runtimeTools
             : permissions;
@@ -2241,9 +2247,7 @@ export class ClaudeSubagentExecutor {
                         : { reserveTokens: this.options.contextReserveTokens }),
                 })
                 : null;
-            const definitions = options.provider.capabilities.tools
-                ? runtimeTools.definitions()
-                : [];
+            const currentDefinitions = () => options.provider.capabilities.tools ? runtimeTools.definitions() : [];
             let observedMessages;
             let stableSystemMessageCount = 0;
             const assembleMessages = async () => {
@@ -2272,6 +2276,7 @@ export class ClaudeSubagentExecutor {
                 ];
                 observedMessages = messages;
                 if (contextBudget) {
+                    const definitions = currentDefinitions();
                     contextBudget.assertFits(contextBudget.evaluate(messages, definitions));
                 }
                 return messages;
@@ -2393,7 +2398,7 @@ export class ClaudeSubagentExecutor {
                 ...(options.signal ? { signal: options.signal } : {}),
             };
             const result = await runtime.run(runtimeRequest);
-            contextBudget?.observeUsage(result.usage, observedMessages ?? [], definitions);
+            contextBudget?.observeUsage(result.usage, observedMessages ?? [], currentDefinitions());
             this.options.eventSink?.({
                 type: 'task-progress',
                 taskId: options.agentId,

package/dist/application/top-level-agent-manager.js

@@ -29,10 +29,13 @@ const WORKER_RUNTIME_ENVIRONMENT = [
     'PRAXIS_PROVIDER',
     'PRAXIS_PROVIDER_PROFILE',
     'PRAXIS_PROVIDER_DEADLINE_MS',
+    'PRAXIS_PROVIDER_CONNECT_TIMEOUT_MS',
+    'PRAXIS_PROVIDER_IDLE_TIMEOUT_MS',
     'PRAXIS_BASE_URL',
     'PRAXIS_MAX_OUTPUT_TOKENS',
     'PRAXIS_ANTHROPIC_VERSION',
     'PRAXIS_ANTHROPIC_WEB_SEARCH',
+    'PRAXIS_DISABLE_NONSTREAMING_FALLBACK',
     'PRAXIS_ANTHROPIC_PROMPT_CACHING',
     'PRAXIS_ANTHROPIC_PROMPT_CACHE_TTL',
     'PRAXIS_CONTEXT_WINDOW_TOKENS',

package/dist/cli-runtime.d.ts

@@ -24,6 +24,11 @@ import { executeProviderAuthCommand } from './cli/provider-auth-command.js';
 import { type PluginEvalDependencies } from './plugins/claude-plugin-eval.js';
 import { type ProjectEvalDependencies } from './evals/project-eval.js';
 import { type SelfUpdateResult } from './maintenance/self-update.js';
+export declare function shouldDeferMcpTools(input: {
+    simpleMode: boolean;
+    tools?: readonly string[] | undefined;
+    disallowedTools: readonly string[];
+}): boolean;
 export { parseContextEnvironment, parseProviderEnvironment };
 export interface CliIO {
     stdout(message: string | Uint8Array): void;

package/dist/cli-runtime.js

@@ -77,6 +77,16 @@ import { formatDoctorReport, runDoctor } from './maintenance/doctor.js';
 import { runSelfUpdate, } from './maintenance/self-update.js';
 import { executeClaudeProjectPurge, planClaudeProjectPurge, } from './application/claude-project-purge.js';
 const VERSION = createRequire(import.meta.url)('../package.json').version;
+export function shouldDeferMcpTools(input) {
+    if (input.tools?.includes('ToolSearch')) {
+        throw new Error('Unknown tool in --tools: ToolSearch');
+    }
+    return (!input.simpleMode &&
+        !input.disallowedTools.includes('ToolSearch') &&
+        (input.tools === undefined ||
+            (input.tools.length > 0 &&
+                input.tools.every((tool) => tool === 'default'))));
+}
 function fileResourceBaseUrl(environment, providerEnvironment) {
     return (environment.PRAXIS_FILES_BASE_URL ??
         providerEnvironment?.baseUrl ??
@@ -981,6 +991,11 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
             ? {}
             : { permissionMode: interactivePermissionMode }),
     }, cwd);
+    const deferMcpTools = shouldDeferMcpTools({
+        simpleMode,
+        tools: cli.tools,
+        disallowedTools: cli.disallowedTools,
+    });
     if (experimentalNativeTranscriptWrites) {
         const incompatible = [
             ['sessionPersistence', cli.sessionPersistence === false],
@@ -1208,6 +1223,7 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
                 pricing: ModelPricingRegistry.fromEnvironment(runtimeEnvironment.PRAXIS_PRICING_JSON),
             }),
         collectMetrics: true,
+        deferMcpTools,
         ...(!experimentalNativeTranscriptWrites && sessionMemoryProviderFactory
             ? { sessionMemoryProviderFactory }
             : {}),

package/dist/core/runtime.d.ts

@@ -537,14 +537,17 @@ export declare class ModelProviderError extends Error {
     readonly status?: number;
     readonly retryDelayMs?: number;
     readonly kind?: ProviderErrorKind;
+    readonly timeoutPhase?: ProviderTimeoutPhase;
     constructor(message: string, options: {
         retryable: boolean;
         kind?: ProviderErrorKind;
         status?: number;
         retryDelayMs?: number;
+        timeoutPhase?: ProviderTimeoutPhase;
         cause?: unknown;
     });
 }
+export type ProviderTimeoutPhase = 'connect' | 'idle' | 'total';
 export declare class AgentRunCancelledError extends Error {
     readonly name = "AgentRunCancelledError";
     constructor();

package/dist/core/runtime.js

@@ -35,6 +35,7 @@ export class ModelProviderError extends Error {
     status;
     retryDelayMs;
     kind;
+    timeoutPhase;
     constructor(message, options) {
         super(message, options.cause === undefined ? undefined : { cause: options.cause });
         this.retryable = options.retryable;
@@ -44,6 +45,8 @@ export class ModelProviderError extends Error {
             this.status = options.status;
         if (options.retryDelayMs !== undefined)
             this.retryDelayMs = options.retryDelayMs;
+        if (options.timeoutPhase !== undefined)
+            this.timeoutPhase = options.timeoutPhase;
     }
 }
 export class AgentRunCancelledError extends Error {
@@ -334,9 +337,6 @@ export class AgentRuntime {
         let linesRemoved = 0;
         let activeAttemptHasPresentation = false;
         let activeAttemptDiscarded = false;
-        const definitions = this.provider.capabilities.tools
-            ? (this.options.tools?.definitions() ?? [])
-            : [];
         const maxModelTurns = request.maxModelTurns ?? this.options.maxModelTurns;
         if (maxModelTurns !== undefined &&
             (!Number.isSafeInteger(maxModelTurns) || maxModelTurns <= 0)) {
@@ -411,6 +411,9 @@ export class AgentRuntime {
                             stableSystemMessageCount: request.stableSystemMessageCount,
                         }),
                 };
+                const definitions = this.provider.capabilities.tools
+                    ? (this.options.tools?.definitions() ?? [])
+                    : [];
                 if (definitions.length > 0)
                     providerRequest.tools = definitions;
                 if (request.signal)

package/dist/hooks/claude-hook-tools.d.ts

@@ -20,9 +20,11 @@ export declare class ClaudeHookToolCoordinator implements ToolRegistry, Permissi
     private readonly prepared;
     constructor(options: ClaudeHookToolCoordinatorOptions);
     definitions(): readonly import("../core/runtime.js").ModelToolDefinition[];
-    schedulingPolicy(): {
+    schedulingPolicy(call: ModelToolCall): {
         concurrency: "exclusive";
         startAfterAssistant: boolean;
+        abortGroupOnError?: boolean;
+        cancelOnInterrupt?: boolean;
     };
     prepare(call: ModelToolCall, context: ToolExecutionContext): Promise<ModelToolCall>;
     resolve(call: ModelToolCall, context?: PermissionResolutionContext): Promise<PermissionDecision>;

package/dist/hooks/claude-hook-tools.js

@@ -8,8 +8,15 @@ export class ClaudeHookToolCoordinator {
     definitions() {
         return this.options.tools.definitions();
     }
-    schedulingPolicy() {
+    schedulingPolicy(call) {
+        const wrapped = this.options.tools.schedulingPolicy?.(call);
         return {
+            ...(wrapped?.cancelOnInterrupt === undefined
+                ? {}
+                : { cancelOnInterrupt: wrapped.cancelOnInterrupt }),
+            ...(wrapped?.abortGroupOnError === undefined
+                ? {}
+                : { abortGroupOnError: wrapped.abortGroupOnError }),
             concurrency: 'exclusive',
             startAfterAssistant: true,
         };

package/dist/permissions/claude-permission-resolver.js

@@ -12,6 +12,7 @@ import { validateSedSafety } from './sed-safety.js';
 import { parseShellRule, shellRuleMatches } from './shell-rule-matching.js';
 import { effectiveAdditionalDirectories, effectivePermissionMode, filePermissionSuggestions, permissionRuleValueFromString, permissionRuleStringIsValid, permissionRuleValueToString, shellInputIsReadOnly, shellPermissionSuggestions, shellSubcommands, skillPermissionSuggestions, } from './permission-updates.js';
 const DEFAULT_BEHAVIOR = {
+    ToolSearch: 'allow',
     Agent: 'allow',
     SendMessage: 'allow',
     SendUserMessage: 'allow',

package/dist/providers/anthropic-compatible.d.ts

@@ -16,6 +16,7 @@ export interface AnthropicCompatibleProviderOptions {
     maxToolMetadataBytes?: number;
     maxErrorBodyBytes?: number;
     fetchImplementation?: typeof fetch;
+    streaming?: boolean;
 }
 export declare class AnthropicCompatibleProvider implements ModelProvider {
     private readonly options;
@@ -32,6 +33,7 @@ export declare class AnthropicCompatibleProvider implements ModelProvider {
     private readonly maxErrorBodyBytes;
     private readonly thinking;
     private readonly promptCaching;
+    private readonly streaming;
     constructor(options: AnthropicCompatibleProviderOptions);
     complete(request: ModelRequest): AsyncIterable<ModelStreamEvent>;
 }

package/dist/providers/anthropic-compatible.js

@@ -1,9 +1,20 @@
 import { ModelProviderError, malformedModelToolCall, } from '../core/runtime.js';
 import { transportFailureKind } from './provider-errors.js';
+import { reportProviderTransportActivity } from './provider-transport-activity.js';
+import { markNonStreamingFallbackEligible } from './non-streaming-fallback-provider.js';
 import { createAnthropicPromptCachePolicyResolver, } from './anthropic-prompt-cache.js';
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
+function readNonNegativeTokenCount(usage, field, required) {
+    const value = usage[field];
+    if (value === undefined && !required)
+        return undefined;
+    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 0) {
+        throw new ModelProviderError(`Provider returned an invalid ${field} counter`, { retryable: false });
+    }
+    return value;
+}
 function webSearchLinks(value) {
     if (!Array.isArray(value))
         return [];
@@ -633,6 +644,7 @@ export class AnthropicCompatibleProvider {
     maxErrorBodyBytes;
     thinking;
     promptCaching;
+    streaming;
     constructor(options) {
         this.options = options;
         if (options.contextWindowTokens !== undefined) {
@@ -640,6 +652,7 @@ export class AnthropicCompatibleProvider {
         }
         this.endpoint = `${options.baseUrl.replace(/\/+$/, '')}/messages`;
         this.model = options.model;
+        this.streaming = options.streaming ?? true;
         this.fetchImplementation = options.fetchImplementation ?? fetch;
         this.maxOutputTokens = positiveInteger(options.maxOutputTokens ??
             (options.model.includes('claude-opus-4-6')
@@ -648,7 +661,7 @@ export class AnthropicCompatibleProvider {
                     ? 32_000
                     : 8192), 'Max output tokens');
         this.capabilities = {
-            streaming: true,
+            streaming: this.streaming,
             usage: true,
             tools: true,
             images: true,
@@ -720,7 +733,7 @@ export class AnthropicCompatibleProvider {
                 model: this.options.model,
                 max_tokens: maxTokens,
                 messages: serialized.messages,
-                stream: true,
+                stream: this.streaming,
                 ...(thinkingPayload ? { thinking: thinkingPayload } : {}),
                 ...(request.effort
                     ? { output_config: { effort: request.effort } }
@@ -761,7 +774,9 @@ export class AnthropicCompatibleProvider {
             requestInit.signal = request.signal;
         let response;
         try {
+            reportProviderTransportActivity(request, 'request-started');
             response = await this.fetchImplementation(this.endpoint, requestInit);
+            reportProviderTransportActivity(request, 'response-received');
         }
         catch (error) {
             const kind = transportFailureKind(error, request.signal);
@@ -792,6 +807,8 @@ export class AnthropicCompatibleProvider {
                                 ended = true;
                                 break;
                             }
+                            if (value.byteLength > 0)
+                                reportProviderTransportActivity(request, 'response-chunk');
                             size += value.byteLength;
                             if (size > this.maxErrorBodyBytes) {
                                 throw new ModelProviderError(`Provider error response exceeded ${this.maxErrorBodyBytes} bytes`, { retryable: false, status: response.status });
@@ -824,11 +841,144 @@ export class AnthropicCompatibleProvider {
                 status: response.status,
             });
         }
+        if (!this.streaming) {
+            if (!response.body) {
+                throw new ModelProviderError('Provider response has no body', {
+                    kind: 'transport_error',
+                    retryable: true,
+                });
+            }
+            const reader = response.body.getReader();
+            const chunks = [];
+            let size = 0;
+            let ended = false;
+            try {
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done) {
+                        ended = true;
+                        break;
+                    }
+                    if (value.byteLength > 0)
+                        reportProviderTransportActivity(request, 'response-chunk');
+                    size += value.byteLength;
+                    if (size > this.maxStreamBufferBytes) {
+                        throw new ModelProviderError(`Provider stream buffer exceeded ${this.maxStreamBufferBytes} bytes`, { retryable: false });
+                    }
+                    if (value.byteLength > 0)
+                        chunks.push(value);
+                }
+                let payload;
+                try {
+                    payload = JSON.parse(Buffer.concat(chunks.map((chunk) => Buffer.from(chunk))).toString('utf8'));
+                }
+                catch (error) {
+                    throw new ModelProviderError('Provider returned malformed JSON', {
+                        retryable: false,
+                        cause: error,
+                    });
+                }
+                if (!isRecord(payload) ||
+                    payload.type !== 'message' ||
+                    payload.role !== 'assistant' ||
+                    !Array.isArray(payload.content) ||
+                    !isRecord(payload.usage)) {
+                    throw new ModelProviderError('Provider returned an invalid message', {
+                        retryable: false,
+                    });
+                }
+                const state = {
+                    blocks: new Map(),
+                    thinking: new Map(),
+                    tools: new Map(),
+                    toolCallsSeen: 0,
+                    metadataBytes: 0,
+                    inputTokens: 0,
+                    cacheReadInputTokens: 0,
+                    cacheCreationInputTokens: 0,
+                    outputTokens: 0,
+                    webSearchRequests: 0,
+                    usageSeen: false,
+                    messageStarted: false,
+                    messageDeltaSeen: false,
+                    terminal: false,
+                };
+                const inputTokens = readNonNegativeTokenCount(payload.usage, 'input_tokens', true);
+                const outputTokens = readNonNegativeTokenCount(payload.usage, 'output_tokens', true);
+                const cacheReadInputTokens = readNonNegativeTokenCount(payload.usage, 'cache_read_input_tokens', false);
+                const cacheCreationInputTokens = readNonNegativeTokenCount(payload.usage, 'cache_creation_input_tokens', false);
+                const usage = {
+                    input_tokens: inputTokens,
+                    output_tokens: outputTokens,
+                    ...(cacheReadInputTokens === undefined
+                        ? {}
+                        : { cache_read_input_tokens: cacheReadInputTokens }),
+                    ...(cacheCreationInputTokens === undefined
+                        ? {}
+                        : { cache_creation_input_tokens: cacheCreationInputTokens }),
+                    ...(payload.usage.server_tool_use === undefined
+                        ? {}
+                        : { server_tool_use: payload.usage.server_tool_use }),
+                };
+                const synthetic = [
+                    {
+                        type: 'message_start',
+                        message: { usage },
+                    },
+                    ...payload.content.flatMap((block, index) => {
+                        if (!isRecord(block) || typeof block.type !== 'string') {
+                            throw new ModelProviderError('Provider returned an invalid content block', { retryable: false });
+                        }
+                        return [
+                            { type: 'content_block_start', index, content_block: block },
+                            { type: 'content_block_stop', index },
+                        ];
+                    }),
+                    {
+                        type: 'message_delta',
+                        delta: { stop_reason: payload.stop_reason },
+                        usage: {
+                            output_tokens: outputTokens,
+                            ...(usage.server_tool_use === undefined
+                                ? {}
+                                : { server_tool_use: usage.server_tool_use }),
+                        },
+                    },
+                    { type: 'message_stop' },
+                ];
+                for (const event of synthetic) {
+                    for (const normalized of parseSseEvent(JSON.stringify(event), state, this.maxToolArgumentsBytes, this.maxToolCallsPerResponse, this.maxToolMetadataBytes))
+                        yield normalized;
+                }
+            }
+            catch (error) {
+                if (error instanceof ModelProviderError)
+                    throw error;
+                const kind = transportFailureKind(error, request.signal);
+                throw new ModelProviderError('Provider response failed', {
+                    kind,
+                    retryable: kind === 'timeout' || kind === 'transport_error',
+                    cause: error,
+                });
+            }
+            finally {
+                if (!ended) {
+                    try {
+                        await reader.cancel();
+                    }
+                    catch {
+                        // Preserve the primary provider error.
+                    }
+                }
+                reader.releaseLock();
+            }
+            return;
+        }
         if (!response.body) {
-            throw new ModelProviderError('Provider response has no body', {
+            throw markNonStreamingFallbackEligible(new ModelProviderError('Provider response has no body', {
                 kind: 'transport_error',
                 retryable: true,
-            });
+            }));
         }
         const reader = response.body.getReader();
         const decoder = new TextDecoder();
@@ -853,6 +1003,8 @@ export class AnthropicCompatibleProvider {
         try {
             stream: while (true) {
                 const { done, value } = await reader.read();
+                if (!done && value.byteLength > 0)
+                    reportProviderTransportActivity(request, 'response-chunk');
                 buffer += decoder.decode(value, { stream: !done });
                 buffer = buffer.replaceAll('\r\n', '\n');
                 if (Buffer.byteLength(buffer) > this.maxStreamBufferBytes) {
@@ -882,18 +1034,21 @@ export class AnthropicCompatibleProvider {
                 }
             }
             if (!state.terminal) {
-                throw new ModelProviderError('Provider stream ended before a terminal event', { retryable: true });
+                throw markNonStreamingFallbackEligible(new ModelProviderError('Provider stream ended before a terminal event', { retryable: true }));
             }
         }
         catch (error) {
             if (error instanceof ModelProviderError)
                 throw error;
             const kind = transportFailureKind(error, request.signal);
-            throw new ModelProviderError('Provider stream failed', {
+            const streamError = new ModelProviderError('Provider stream failed', {
                 kind,
                 retryable: kind === 'timeout' || kind === 'transport_error',
                 cause: error,
             });
+            throw kind === 'timeout' || kind === 'transport_error'
+                ? markNonStreamingFallbackEligible(streamError)
+                : streamError;
         }
         finally {
             if (!streamEnded) {