praxis-agent 0.48.0 → 0.49.0

package/README.md

@@ -215,8 +215,11 @@ troubleshooting. Run `praxis --help` for the authoritative command surface.
   disconnect recovery that never replays an already-dispatched call.
 - **Provider-neutral models** — native Provider Registry/Vault routing, API
   adapters, an experimental Codex OAuth adapter, explicit capability checks,
-  per-attempt bounded deadlines, and token-only/no-API-dollar accounting for
-  subscription runs.
+  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
   interruption or crash.
@@ -301,7 +304,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 68-behavior native contract; 60 behaviors
+type-only modules). `npm run test:fixtures` executes the 69-behavior native contract; 61 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.js

@@ -15,7 +15,7 @@ import { projectNativeSessionEntries } from './native-session-projection.js';
 import { classifyClaudeInterruption, } from '../native/interruption.js';
 import { findUnresolvedClaudeToolCalls, getClaudeContentBlocks, } from '../native/tool-links.js';
 import { createClaudeAgentSettingEntry, createClaudeHookAttachmentEntries, createClaudeLastPromptEntry, createClaudeRuleAttachmentEntry, translateProviderEvents, } from '../native/translation.js';
-import { AgentRunCancelledError, AgentRuntime, ModelProviderError, } from '../core/runtime.js';
+import { AgentRunCancelledError, AgentRuntime, MALFORMED_TOOL_INPUT_MESSAGE, ModelProviderError, } from '../core/runtime.js';
 import { resolveToolSchedulingPolicy } from '../core/tool-scheduling-policy.js';
 import { BackgroundTaskRuntime, } from './background-task-runtime.js';
 import { backgroundAgentNotificationMarkers, } from './background-agent-manager.js';
@@ -3347,7 +3347,11 @@ export class ClaudeSessionService {
                             : {}),
                     };
                     const unresolvedToolCall = unresolvedToolCalls[0];
-                    if (unresolvedToolCall && !approveRecovery) {
+                    if (unresolvedToolCall &&
+                        !unresolvedToolCalls.every((call) => call.inputError?.kind === 'malformed_json' &&
+                            call.inputError?.message ===
+                                MALFORMED_TOOL_INPUT_MESSAGE) &&
+                        !approveRecovery) {
                         throw new Error(`Claude session tool call ${unresolvedToolCall.id} requires explicit recovery approval`);
                     }
                     const recoveryResults = await runtime.recoverToolCalls(unresolvedToolCalls, recoveryRequest);

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/core/runtime.d.ts

@@ -43,7 +43,14 @@ export interface ModelToolCall {
     id: string;
     name: string;
     input: Record<string, unknown>;
+    inputError?: ModelToolInputError;
 }
+export declare const MALFORMED_TOOL_INPUT_MESSAGE = "Malformed tool input";
+export interface ModelToolInputError {
+    kind: 'malformed_json';
+    message: typeof MALFORMED_TOOL_INPUT_MESSAGE;
+}
+export declare function malformedModelToolCall(id: string, name: string): ModelToolCall;
 export type ModelThinkingMode = 'enabled' | 'adaptive' | 'disabled';
 export type ModelThinkingBlock = {
     type: 'thinking';
@@ -530,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

@@ -1,5 +1,17 @@
 import { ToolExecutionScheduler } from './tool-execution-scheduler.js';
 import { resolveToolSchedulingPolicy } from './tool-scheduling-policy.js';
+export const MALFORMED_TOOL_INPUT_MESSAGE = 'Malformed tool input';
+export function malformedModelToolCall(id, name) {
+    return {
+        id,
+        name,
+        input: {},
+        inputError: {
+            kind: 'malformed_json',
+            message: MALFORMED_TOOL_INPUT_MESSAGE,
+        },
+    };
+}
 const permissionDecisionSources = new WeakMap();
 const autoModePermissionOutcomes = new WeakMap();
 export function annotatePermissionDecision(decision, source) {
@@ -23,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;
@@ -32,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 {
@@ -516,7 +531,12 @@ export class AgentRuntime {
                             }
                             toolCalls.push(event.call);
                             this.emit(event);
-                            const policy = resolveToolSchedulingPolicy(this.options.tools, event.call);
+                            const policy = event.call.inputError
+                                ? {
+                                    concurrency: 'exclusive',
+                                    startAfterAssistant: true,
+                                }
+                                : resolveToolSchedulingPolicy(this.options.tools, event.call);
                             toolScheduler.schedule(event.call, request.observer?.toolExecutionStarted
                                 ? { ...policy, startAfterAssistant: true }
                                 : policy);
@@ -863,6 +883,9 @@ export class AgentRuntime {
         try {
             if (emitPresentation)
                 emitProgress(0);
+            if (call.inputError) {
+                return { content: call.inputError.message, isError: true };
+            }
             const executed = await this.executeTool(call, { ...request, signal }, messages);
             const unsupportedImages = executed.images?.length && this.provider.capabilities.images !== true;
             const unsupportedDocuments = executed.documents?.length &&

package/dist/core/transcript-event.js

@@ -1,3 +1,4 @@
+import { MALFORMED_TOOL_INPUT_MESSAGE } from './runtime.js';
 const terminalReasons = new Set([
     'end_turn',
     'tool_use',
@@ -51,11 +52,17 @@ export function isModelContentBlock(value) {
     return isModelMedia(value);
 }
 function isModelToolCall(value) {
+    const inputError = isRecord(value) ? value.inputError : undefined;
     return (isRecord(value) &&
-        hasOnlyKeys(value, ['id', 'name', 'input']) &&
+        hasOnlyKeys(value, ['id', 'name', 'input', 'inputError']) &&
         isNonEmptyString(value.id) &&
         isNonEmptyString(value.name) &&
-        isRecord(value.input));
+        isRecord(value.input) &&
+        (inputError === undefined ||
+            (isRecord(inputError) &&
+                hasOnlyKeys(inputError, ['kind', 'message']) &&
+                inputError.kind === 'malformed_json' &&
+                inputError.message === MALFORMED_TOOL_INPUT_MESSAGE)));
 }
 function isModelThinkingBlock(value) {
     return isRecord(value) && value.type === 'thinking'

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, } from '../core/runtime.js';
+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 [];
@@ -119,8 +130,16 @@ function completedToolCall(state, index) {
         try {
             input = JSON.parse(pending.partialJson);
         }
-        catch (error) {
-            throw new ModelProviderError(`Provider returned malformed tool arguments for ${pending.name}`, { retryable: false, cause: error });
+        catch {
+            if (!pending.id || !pending.name) {
+                throw new ModelProviderError('Provider returned an invalid tool call', {
+                    retryable: false,
+                });
+            }
+            return {
+                type: 'tool-call',
+                call: malformedModelToolCall(pending.id, pending.name),
+            };
         }
     }
     if (!pending.id || !pending.name || !isRecord(input)) {
@@ -625,6 +644,7 @@ export class AnthropicCompatibleProvider {
     maxErrorBodyBytes;
     thinking;
     promptCaching;
+    streaming;
     constructor(options) {
         this.options = options;
         if (options.contextWindowTokens !== undefined) {
@@ -632,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')
@@ -640,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,
@@ -712,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 } }
@@ -753,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);
@@ -784,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 });
@@ -816,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();
@@ -845,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) {
@@ -874,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) {

package/dist/providers/codex-subscription.js

@@ -1,5 +1,6 @@
-import { ModelProviderError, } from '../core/runtime.js';
+import { ModelProviderError, malformedModelToolCall, } from '../core/runtime.js';
 import { CodexOAuthError, } from './codex-oauth.js';
+import { reportProviderTransportActivity } from './provider-transport-activity.js';
 export const CODEX_RESPONSES_ENDPOINT = 'https://chatgpt.com/backend-api/codex/responses';
 const DEFAULT_MAX_STREAM = 1024 * 1024;
 const DEFAULT_MAX_ARGUMENTS = 1024 * 1024;
@@ -572,7 +573,12 @@ function parseEvent(value, state, limits) {
             parsed = JSON.parse(call.arguments || '{}');
         }
         catch {
-            throw invalid('Codex provider returned malformed function arguments');
+            if (!id || !name)
+                throw invalid('Codex provider returned an invalid tool call');
+            call.emitted = true;
+            state.toolCallEmitted = true;
+            events.push({ type: 'tool-call', call: malformedModelToolCall(id, name) });
+            return events;
         }
         if (!isRecord(parsed))
             throw invalid('Codex provider returned non-object function arguments');
@@ -652,7 +658,7 @@ export function parseCodexSseFrame(data) {
         reasoning: DEFAULT_MAX_REASONING,
     });
 }
-async function drainBody(response, maxBytes) {
+async function drainBody(response, maxBytes, request) {
     const reader = response.body?.getReader();
     if (!reader)
         return;
@@ -665,6 +671,8 @@ async function drainBody(response, maxBytes) {
                 ended = true;
                 return;
             }
+            if (next.value.byteLength > 0)
+                reportProviderTransportActivity(request, 'response-chunk');
             total += next.value.byteLength;
             if (total > maxBytes)
                 return;
@@ -736,12 +744,14 @@ export class CodexSubscriptionProvider {
                 'content-type': 'application/json',
             };
             try {
+                reportProviderTransportActivity(request, 'request-started');
                 response = await this.fetchImplementation(CODEX_RESPONSES_ENDPOINT, {
                     method: 'POST',
                     headers,
                     body: JSON.stringify(body),
                     ...(signal ? { signal } : {}),
                 });
+                reportProviderTransportActivity(request, 'response-received');
             }
             catch (error) {
                 throw transportError(error, signal);
@@ -749,12 +759,13 @@ export class CodexSubscriptionProvider {
             if (response.status === 401 && !refreshed) {
                 refreshed = true;
                 try {
-                    await drainBody(response, this.maxErrorBodyBytes);
+                    await drainBody(response, this.maxErrorBodyBytes, request);
                 }
                 catch {
                     /* ignore unread body failures */
                 }
                 try {
+                    reportProviderTransportActivity(request, 'request-started');
                     access = await this.options.access({
                         forceAfter: access.accessToken,
                         ...(signal === undefined ? {} : { signal }),
@@ -767,7 +778,7 @@ export class CodexSubscriptionProvider {
             }
             if (!response.ok) {
                 try {
-                    await drainBody(response, this.maxErrorBodyBytes);
+                    await drainBody(response, this.maxErrorBodyBytes, request);
                 }
                 catch {
                     /* preserve generic error */
@@ -804,6 +815,8 @@ export class CodexSubscriptionProvider {
         try {
             while (true) {
                 const next = await reader.read();
+                if (!next.done && next.value.byteLength > 0)
+                    reportProviderTransportActivity(request, 'response-chunk');
                 buffer += decoder.decode(next.value, { stream: !next.done });
                 buffer = buffer.replaceAll('\r\n', '\n');
                 if (bytes(buffer) > this.maxStreamBufferBytes)

package/dist/providers/deadline-provider.d.ts

@@ -1,13 +1,21 @@
 import { type ModelProvider, type ModelRequest, type ModelStreamEvent } from '../core/runtime.js';
 export declare const DEFAULT_PROVIDER_DEADLINE_MS = 90000;
+export declare const DEFAULT_PROVIDER_CONNECT_TIMEOUT_MS = 90000;
+export declare const DEFAULT_PROVIDER_IDLE_TIMEOUT_MS = 90000;
 export interface DeadlineModelProviderOptions {
     provider: ModelProvider;
     deadlineMs?: number;
+    connectTimeoutMs?: number;
+    idleTimeoutMs?: number;
 }
 /** Bounds each streamed completion while preserving the wrapped provider's API. */
 export declare class DeadlineModelProvider implements ModelProvider {
     private readonly provider;
     private readonly deadlineMs;
+    private readonly connectTimeoutMs;
+    private readonly idleTimeoutMs;
+    private readonly connectTimeoutExplicit;
+    private readonly idleTimeoutExplicit;
     readonly model?: string;
     constructor(options: DeadlineModelProviderOptions);
     get capabilities(): ModelProvider['capabilities'];

package/dist/providers/deadline-provider.js

@@ -1,5 +1,8 @@
 import { ModelProviderError, } from '../core/runtime.js';
+import { detachProviderTransportActivity, observeProviderTransportActivity, } from './provider-transport-activity.js';
 export const DEFAULT_PROVIDER_DEADLINE_MS = 90_000;
+export const DEFAULT_PROVIDER_CONNECT_TIMEOUT_MS = 90_000;
+export const DEFAULT_PROVIDER_IDLE_TIMEOUT_MS = 90_000;
 const MAX_TIMER_DELAY_MS = 2_147_483_647;
 function deferred() {
     let resolve;
@@ -12,6 +15,10 @@ function deferred() {
 export class DeadlineModelProvider {
     provider;
     deadlineMs;
+    connectTimeoutMs;
+    idleTimeoutMs;
+    connectTimeoutExplicit;
+    idleTimeoutExplicit;
     constructor(options) {
         const deadlineMs = options.deadlineMs === undefined
             ? DEFAULT_PROVIDER_DEADLINE_MS
@@ -21,8 +28,22 @@ export class DeadlineModelProvider {
             deadlineMs <= 0) {
             throw new Error('Provider deadline must be a positive integer');
         }
+        const connectTimeoutMs = options.connectTimeoutMs ?? deadlineMs;
+        if (!Number.isFinite(connectTimeoutMs) ||
+            !Number.isInteger(connectTimeoutMs) ||
+            connectTimeoutMs <= 0)
+            throw new Error('Provider connect timeout must be a positive integer');
+        const idleTimeoutMs = options.idleTimeoutMs ?? deadlineMs;
+        if (!Number.isFinite(idleTimeoutMs) ||
+            !Number.isInteger(idleTimeoutMs) ||
+            idleTimeoutMs <= 0)
+            throw new Error('Provider idle timeout must be a positive integer');
         this.provider = options.provider;
         this.deadlineMs = deadlineMs;
+        this.connectTimeoutMs = connectTimeoutMs;
+        this.idleTimeoutMs = idleTimeoutMs;
+        this.connectTimeoutExplicit = options.connectTimeoutMs !== undefined;
+        this.idleTimeoutExplicit = options.idleTimeoutMs !== undefined;
         Object.defineProperty(this, 'model', {
             configurable: false,
             enumerable: true,
@@ -40,15 +61,30 @@ export class DeadlineModelProvider {
         let callerSignal;
         let timer;
         let deadlineStartedAt;
+        let totalDueAt;
+        let phaseDueAt;
+        let phase = 'connect';
+        let pullPending = false;
+        let hasPulled = false;
+        let instrumentedRequest;
         let underlying;
         let cleanupStarted = false;
         const interruptionDeferred = deferred();
         const interruptionError = () => {
             if (interruption?.kind === 'timeout') {
-                return new ModelProviderError('Provider request timed out', {
+                const timeoutPhase = interruption.cause instanceof TimeoutCause
+                    ? interruption.cause.phase
+                    : undefined;
+                const message = timeoutPhase === 'connect'
+                    ? 'Provider connection timed out'
+                    : timeoutPhase === 'idle'
+                        ? 'Provider stream idle timed out'
+                        : 'Provider request timed out';
+                return new ModelProviderError(message, {
                     kind: 'timeout',
                     retryable: true,
                     cause: interruption.cause,
+                    ...(timeoutPhase === undefined ? {} : { timeoutPhase }),
                 });
             }
             return new ModelProviderError('Provider request cancelled', {
@@ -86,6 +122,8 @@ export class DeadlineModelProvider {
                 clearTimeout(timer);
             timer = undefined;
             callerSignal?.removeEventListener('abort', onCallerAbort);
+            if (instrumentedRequest)
+                detachProviderTransportActivity(instrumentedRequest);
         };
         const finish = (outcome) => {
             if (interruption !== undefined)
@@ -99,19 +137,54 @@ export class DeadlineModelProvider {
                 bestEffortUnderlyingReturn();
         };
         const onCallerAbort = () => finish({ kind: 'cancelled', cause: callerSignal?.reason });
-        const timeoutCause = new Error('Provider request timed out');
-        timeoutCause.name = 'TimeoutError';
+        class TimeoutCause extends Error {
+            phase;
+            constructor(timeoutPhase) {
+                super('Provider request timed out');
+                this.name = 'TimeoutError';
+                this.phase = timeoutPhase;
+            }
+        }
         const scheduleDeadline = () => {
             if (deadlineStartedAt === undefined || closed)
                 return;
-            const elapsedMs = Math.max(0, performance.now() - deadlineStartedAt);
-            const remainingMs = this.deadlineMs - elapsedMs;
+            if (timer !== undefined)
+                clearTimeout(timer);
+            const now = performance.now();
+            const remainingTotal = (totalDueAt ?? now) - now;
+            const remainingPhase = pullPending
+                ? (phaseDueAt ?? now) - now
+                : Number.POSITIVE_INFINITY;
+            const remainingMs = Math.min(remainingTotal, remainingPhase);
             if (remainingMs <= 0) {
-                finish({ kind: 'timeout', cause: timeoutCause });
+                const phaseTimeoutExplicit = phase === 'connect'
+                    ? this.connectTimeoutExplicit
+                    : this.idleTimeoutExplicit;
+                finish({
+                    kind: 'timeout',
+                    cause: new TimeoutCause(remainingPhase < remainingTotal ||
+                        (remainingPhase <= remainingTotal && phaseTimeoutExplicit)
+                        ? phase
+                        : 'total'),
+                });
                 return;
             }
             timer = setTimeout(scheduleDeadline, Math.min(remainingMs, MAX_TIMER_DELAY_MS));
         };
+        const onTransportActivity = (reported) => {
+            if (closed || deadlineStartedAt === undefined)
+                return;
+            const now = performance.now();
+            if (reported === 'request-started') {
+                phase = 'connect';
+                phaseDueAt = now + this.connectTimeoutMs;
+            }
+            else {
+                phase = 'idle';
+                phaseDueAt = now + this.idleTimeoutMs;
+            }
+            scheduleDeadline();
+        };
         const start = () => {
             if (started || closed)
                 return;
@@ -125,11 +198,12 @@ export class DeadlineModelProvider {
             if (interruption !== undefined)
                 return;
             deadlineStartedAt = performance.now();
+            totalDueAt = deadlineStartedAt + this.deadlineMs;
+            phaseDueAt = deadlineStartedAt + this.connectTimeoutMs;
             scheduleDeadline();
-            const iterable = this.provider.complete({
-                ...request,
-                signal: controller.signal,
-            });
+            instrumentedRequest = { ...request, signal: controller.signal };
+            observeProviderTransportActivity(instrumentedRequest, onTransportActivity);
+            const iterable = this.provider.complete(instrumentedRequest);
             underlying = iterable[Symbol.asyncIterator]();
             if (interruption !== undefined)
                 bestEffortUnderlyingReturn();
@@ -153,11 +227,23 @@ export class DeadlineModelProvider {
             if (closed || !underlying)
                 return { done: true, value: undefined };
             let nextPromise;
+            pullPending = true;
+            if (hasPulled) {
+                phaseDueAt =
+                    performance.now() +
+                        (phase === 'connect' ? this.connectTimeoutMs : this.idleTimeoutMs);
+            }
+            hasPulled = true;
+            scheduleDeadline();
+            if (interruption !== undefined)
+                throw interruptionError();
             try {
                 const result = underlying.next();
                 nextPromise = Promise.resolve(result);
             }
             catch (error) {
+                pullPending = false;
+                scheduleDeadline();
                 if (interruption !== undefined)
                     throw interruptionError();
                 closed = true;
@@ -176,6 +262,8 @@ export class DeadlineModelProvider {
                     outcome,
                 })),
             ]);
+            pullPending = false;
+            scheduleDeadline();
             const observedInterruption = interruption ??
                 (result.type === 'interruption' ? result.outcome : undefined);
             if (observedInterruption !== undefined) {
@@ -200,6 +288,10 @@ export class DeadlineModelProvider {
                 closed = true;
                 clearResources();
             }
+            else {
+                phase = 'idle';
+                phaseDueAt = performance.now() + this.idleTimeoutMs;
+            }
             return result.value;
         };
         const returnFromConsumer = async () => {

package/dist/providers/environment.d.ts

@@ -2,9 +2,12 @@ export interface ProviderEnvironment {
     provider: 'openai' | 'anthropic';
     baseUrl: string;
     deadlineMs: number;
+    connectTimeoutMs: number;
+    idleTimeoutMs: number;
     maxOutputTokens?: number;
     anthropicVersion?: string;
     webSearch?: boolean;
+    disableNonStreamingFallback: boolean;
 }
 export interface ContextEnvironment {
     contextWindowTokens?: number;

package/dist/providers/environment.js

@@ -1,5 +1,5 @@
 import { createAnthropicPromptCachePolicyResolver } from './anthropic-prompt-cache.js';
-import { DEFAULT_PROVIDER_DEADLINE_MS } from './deadline-provider.js';
+import { DEFAULT_PROVIDER_CONNECT_TIMEOUT_MS, DEFAULT_PROVIDER_DEADLINE_MS, DEFAULT_PROVIDER_IDLE_TIMEOUT_MS, } from './deadline-provider.js';
 export function parseProviderEnvironment(environment) {
     const provider = environment.PRAXIS_PROVIDER ?? 'openai';
     if (provider !== 'openai' && provider !== 'anthropic') {
@@ -15,6 +15,17 @@ export function parseProviderEnvironment(environment) {
     const deadlineMs = rawDeadlineMs === undefined
         ? DEFAULT_PROVIDER_DEADLINE_MS
         : Number(rawDeadlineMs);
+    const parseTimeout = (name, fallback) => {
+        const raw = environment[name];
+        if (raw !== undefined &&
+            (!/^\d+$/.test(raw) ||
+                Number(raw) <= 0 ||
+                !Number.isSafeInteger(Number(raw))))
+            throw new Error(`${name} must be a positive safe integer`);
+        return raw === undefined ? fallback : Number(raw);
+    };
+    const connectTimeoutMs = parseTimeout('PRAXIS_PROVIDER_CONNECT_TIMEOUT_MS', DEFAULT_PROVIDER_CONNECT_TIMEOUT_MS);
+    const idleTimeoutMs = parseTimeout('PRAXIS_PROVIDER_IDLE_TIMEOUT_MS', DEFAULT_PROVIDER_IDLE_TIMEOUT_MS);
     const maxOutputTokens = environment.PRAXIS_MAX_OUTPUT_TOKENS;
     if (maxOutputTokens !== undefined &&
         (!/^\d+$/.test(maxOutputTokens) ||
@@ -38,6 +49,12 @@ export function parseProviderEnvironment(environment) {
         webSearch !== 'false') {
         throw new Error('PRAXIS_ANTHROPIC_WEB_SEARCH must be true or false');
     }
+    const disableFallback = environment.PRAXIS_DISABLE_NONSTREAMING_FALLBACK;
+    if (disableFallback !== undefined &&
+        disableFallback !== 'true' &&
+        disableFallback !== 'false') {
+        throw new Error('PRAXIS_DISABLE_NONSTREAMING_FALLBACK must be true or false');
+    }
     if (provider === 'openai' && webSearch !== undefined) {
         throw new Error('PRAXIS_ANTHROPIC_WEB_SEARCH requires PRAXIS_PROVIDER=anthropic');
     }
@@ -59,11 +76,14 @@ export function parseProviderEnvironment(environment) {
                 ? 'https://api.anthropic.com/v1'
                 : 'https://api.openai.com/v1'),
         deadlineMs,
+        connectTimeoutMs,
+        idleTimeoutMs,
         ...(maxOutputTokens === undefined
             ? {}
             : { maxOutputTokens: Number(maxOutputTokens) }),
         ...(anthropicVersion === undefined ? {} : { anthropicVersion }),
         ...(webSearch === undefined ? {} : { webSearch: webSearch === 'true' }),
+        disableNonStreamingFallback: disableFallback === 'true',
     };
 }
 export function parseContextEnvironment(environment) {

package/dist/providers/non-streaming-fallback-provider.d.ts

@@ -0,0 +1,17 @@
+import { type ModelProvider, type ModelRequest, type ModelStreamEvent } from '../core/runtime.js';
+/** Marks a provider error as safe for the bounded non-streaming replay. */
+export declare function markNonStreamingFallbackEligible<T extends Error>(error: T): T;
+export declare function isNonStreamingFallbackEligible(error: unknown): boolean;
+/** Replays an eligible failed streaming request through one non-streaming call. */
+export declare class NonStreamingFallbackModelProvider implements ModelProvider {
+    private readonly provider;
+    private readonly nonStreamingProvider;
+    constructor(options: {
+        provider: ModelProvider;
+        nonStreamingProvider?: ModelProvider;
+    });
+    readonly model?: string;
+    get capabilities(): ModelProvider['capabilities'];
+    complete(request: ModelRequest): AsyncIterable<ModelStreamEvent>;
+}
+//# sourceMappingURL=non-streaming-fallback-provider.d.ts.map

package/dist/providers/non-streaming-fallback-provider.js

@@ -0,0 +1,107 @@
+import { ModelProviderError, modelProviderErrorKind, } from '../core/runtime.js';
+const eligibleErrors = new WeakSet();
+/** Marks a provider error as safe for the bounded non-streaming replay. */
+export function markNonStreamingFallbackEligible(error) {
+    eligibleErrors.add(error);
+    return error;
+}
+export function isNonStreamingFallbackEligible(error) {
+    return ((typeof error === 'object' &&
+        error !== null &&
+        eligibleErrors.has(error)) ||
+        (error instanceof ModelProviderError && error.timeoutPhase === 'idle'));
+}
+function cancellationError(signal) {
+    return new ModelProviderError('Provider request cancelled', {
+        kind: 'cancelled',
+        retryable: false,
+        cause: signal.reason,
+    });
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted)
+        throw cancellationError(signal);
+}
+/** Replays an eligible failed streaming request through one non-streaming call. */
+export class NonStreamingFallbackModelProvider {
+    provider;
+    nonStreamingProvider;
+    constructor(options) {
+        this.provider = options.provider;
+        this.nonStreamingProvider = options.nonStreamingProvider;
+        Object.defineProperty(this, 'model', {
+            configurable: false,
+            enumerable: true,
+            get: () => this.provider.model,
+        });
+    }
+    get capabilities() {
+        return this.provider.capabilities;
+    }
+    async *complete(request) {
+        const primaryEvents = [];
+        let primaryTerminal = false;
+        try {
+            for await (const event of this.provider.complete(request)) {
+                if (primaryTerminal) {
+                    throw new ModelProviderError(`Provider emitted ${event.type} after its terminal event`, { retryable: false });
+                }
+                if (event.type === 'terminal')
+                    primaryTerminal = true;
+                primaryEvents.push(event);
+            }
+            if (this.provider.capabilities.terminalReasons === true &&
+                !primaryTerminal) {
+                throw new ModelProviderError('Provider stream ended without a terminal reason', { retryable: true });
+            }
+            yield* primaryEvents;
+            return;
+        }
+        catch (error) {
+            throwIfAborted(request.signal);
+            if (!this.nonStreamingProvider ||
+                !isNonStreamingFallbackEligible(error)) {
+                throw error;
+            }
+            throwIfAborted(request.signal);
+            if (error instanceof ModelProviderError) {
+                yield {
+                    type: 'api-retry',
+                    attempt: 1,
+                    maxRetries: 1,
+                    retryDelayMs: 0,
+                    errorStatus: error.status ?? null,
+                    error: modelProviderErrorKind(error),
+                };
+            }
+            else {
+                // The retry event contract carries a typed provider error kind. An
+                // explicitly marked non-ModelProviderError is still replayable.
+                yield {
+                    type: 'api-retry',
+                    attempt: 1,
+                    maxRetries: 1,
+                    retryDelayMs: 0,
+                    errorStatus: null,
+                    error: 'server_error',
+                };
+            }
+            const fallbackEvents = [];
+            let fallbackTerminal = false;
+            for await (const event of this.nonStreamingProvider.complete(request)) {
+                if (fallbackTerminal) {
+                    throw new ModelProviderError(`Provider emitted ${event.type} after its terminal event`, { retryable: false });
+                }
+                if (event.type === 'terminal')
+                    fallbackTerminal = true;
+                fallbackEvents.push(event);
+            }
+            if (this.nonStreamingProvider.capabilities.terminalReasons === true &&
+                !fallbackTerminal) {
+                throw new ModelProviderError('Provider stream ended without a terminal reason', { retryable: true });
+            }
+            yield* fallbackEvents;
+        }
+    }
+}
+//# sourceMappingURL=non-streaming-fallback-provider.js.map

package/dist/providers/openai-compatible.js

@@ -1,5 +1,6 @@
-import { ModelProviderError, } from '../core/runtime.js';
+import { ModelProviderError, malformedModelToolCall, } from '../core/runtime.js';
 import { transportFailureKind } from './provider-errors.js';
+import { reportProviderTransportActivity } from './provider-transport-activity.js';
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
@@ -64,8 +65,16 @@ function completedToolCallEvents(pending) {
         try {
             input = JSON.parse(call.arguments || '{}');
         }
-        catch (error) {
-            throw new ModelProviderError(`Provider returned malformed tool arguments for ${call.name}`, { retryable: false, cause: error });
+        catch {
+            if (!call.id || !call.name) {
+                throw new ModelProviderError('Provider returned an invalid tool call', {
+                    retryable: false,
+                });
+            }
+            return {
+                type: 'tool-call',
+                call: malformedModelToolCall(call.id, call.name),
+            };
         }
         if (!isRecord(input) || !call.id || !call.name) {
             throw new ModelProviderError('Provider returned an invalid tool call', {
@@ -343,7 +352,9 @@ export class OpenAICompatibleProvider {
             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);
@@ -374,6 +385,8 @@ export class OpenAICompatibleProvider {
                                 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 });
@@ -426,6 +439,8 @@ export class OpenAICompatibleProvider {
         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) {

package/dist/providers/provider-registry.js

@@ -2,6 +2,7 @@ import { AnthropicCompatibleProvider } from './anthropic-compatible.js';
 import { OpenAICompatibleProvider } from './openai-compatible.js';
 import { CodexSubscriptionProvider } from './codex-subscription.js';
 import { DeadlineModelProvider } from './deadline-provider.js';
+import { NonStreamingFallbackModelProvider } from './non-streaming-fallback-provider.js';
 import { CodexOAuthCredentialManager, } from './codex-oauth.js';
 import { resolveProviderTarget, } from './provider-settings.js';
 import { ProviderAuthenticationError, resolveProviderCredential, } from './provider-auth.js';
@@ -135,7 +136,7 @@ class NativeProviderRegistry {
             if (this.options.credential.type !== 'api-key') {
                 throw new ProviderAuthenticationError('invalid_credential', 'Provider authentication failed: an API key is required');
             }
-            return this.withDeadline(new AnthropicCompatibleProvider({
+            const anthropicOptions = {
                 baseUrl: target.baseUrl,
                 model: target.modelId,
                 apiKey: this.options.credential.secret,
@@ -173,15 +174,34 @@ class NativeProviderRegistry {
                 ...(this.options.fetchImplementation === undefined
                     ? {}
                     : { fetchImplementation: this.options.fetchImplementation }),
+            };
+            const streaming = this.withDeadline(new AnthropicCompatibleProvider({
+                ...anthropicOptions,
+                streaming: true,
             }));
+            if (this.options.providerEnvironment?.disableNonStreamingFallback === true)
+                return streaming;
+            const nonStreaming = this.withDeadline(new AnthropicCompatibleProvider({
+                ...anthropicOptions,
+                streaming: false,
+            }));
+            return new NonStreamingFallbackModelProvider({
+                provider: streaming,
+                nonStreamingProvider: nonStreaming,
+            });
         }
         throw new ProviderRegistryError('unsupported_provider', `Unsupported provider protocol: ${target.protocol}`);
     }
     withDeadline(provider) {
-        const deadlineMs = this.options.providerEnvironment?.deadlineMs;
-        return deadlineMs === undefined
+        const environment = this.options.providerEnvironment;
+        return environment === undefined
             ? provider
-            : new DeadlineModelProvider({ provider, deadlineMs });
+            : new DeadlineModelProvider({
+                provider,
+                deadlineMs: environment.deadlineMs,
+                connectTimeoutMs: environment.connectTimeoutMs,
+                idleTimeoutMs: environment.idleTimeoutMs,
+            });
     }
 }
 //# sourceMappingURL=provider-registry.js.map

package/dist/providers/provider-transport-activity.d.ts

@@ -0,0 +1,7 @@
+import type { ModelRequest } from '../core/runtime.js';
+export type ProviderTransportActivity = 'request-started' | 'response-received' | 'response-chunk';
+export type ProviderTransportActivityObserver = (activity: ProviderTransportActivity) => void;
+export declare function observeProviderTransportActivity(request: ModelRequest, observer: ProviderTransportActivityObserver): void;
+export declare function reportProviderTransportActivity(request: ModelRequest, activity: ProviderTransportActivity): void;
+export declare function detachProviderTransportActivity(request: ModelRequest): void;
+//# sourceMappingURL=provider-transport-activity.d.ts.map

package/dist/providers/provider-transport-activity.js

@@ -0,0 +1,11 @@
+const observers = new WeakMap();
+export function observeProviderTransportActivity(request, observer) {
+    observers.set(request, observer);
+}
+export function reportProviderTransportActivity(request, activity) {
+    observers.get(request)?.(activity);
+}
+export function detachProviderTransportActivity(request) {
+    observers.delete(request);
+}
+//# sourceMappingURL=provider-transport-activity.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "praxis-agent",
-  "version": "0.48.0",
+  "version": "0.49.0",
   "description": "Local-first, single-user general agent for the command line.",
   "license": "MIT",
   "author": "wuqisen",