praxis-agent 0.55.2 → 0.55.3

package/dist/cli/protocol.d.ts

@@ -1,4 +1,4 @@
-import type { ModelDocument, ModelDocumentMediaType, ModelImage, ModelImageMediaType, ModelUsage, RuntimeEventSink } from '../core/runtime.js';
+import type { ModelDocument, ModelDocumentMediaType, ModelImage, ModelImageMediaType, ModelTerminalReason, ModelUsage, RuntimeEventSink } from '../core/runtime.js';
 export type CliInputFormat = 'text' | 'stream-json';
 export type CliOutputFormat = 'text' | 'json' | 'stream-json';
 export type CliPermissionMode = 'acceptEdits' | 'auto' | 'bypassPermissions' | 'manual' | 'dontAsk' | 'plan' | 'default';
@@ -225,8 +225,25 @@ export interface ProtocolResult {
      */
     modelCostUsd?: Readonly<Record<string, number>>;
 }
-export declare function createSuccessResult(result: ProtocolResult, info: CliRuntimeInfo, startedAt: number, modelTurns: number): Record<string, unknown>;
-export declare function createErrorResult(message: string, sessionId: string, startedAt: number, modelTurns: number): Record<string, unknown>;
+export interface ProtocolSuccessProjectionContext {
+    localCommand?: boolean;
+    stopReason?: ModelTerminalReason;
+    ttftMs?: number;
+    ttftStreamMs?: number;
+    timeToRequestMs?: number;
+}
+export interface ProtocolErrorProjectionContext {
+    providerApiError?: boolean;
+    apiErrorStatus?: number | null;
+}
+export interface ProtocolTimingProjection {
+    ttftMs?: number;
+    ttftStreamMs?: number;
+    timeToRequestMs?: number;
+}
+export declare function projectProtocolTimings(startedAt: number, requestAt?: number, outputAt?: number): ProtocolTimingProjection;
+export declare function createSuccessResult(result: ProtocolResult, info: CliRuntimeInfo, startedAt: number, modelTurns: number, context?: ProtocolSuccessProjectionContext): Record<string, unknown>;
+export declare function createErrorResult(message: string, sessionId: string, startedAt: number, modelTurns: number, context?: ProtocolErrorProjectionContext): Record<string, unknown>;
 /**
  * Returns the argument text of a headless `/color` prompt, or undefined when
  * the prompt is not a bare `/color` command. A trailing space matches with an
@@ -259,6 +276,11 @@ export declare class StreamJsonOutput {
     private activeThinkingIndex;
     private nextContentIndex;
     private modelTurns;
+    private projectionStartedAt;
+    private firstRequestAt;
+    private firstOutputAt;
+    private turnHasRealContent;
+    private pendingFailureMessage;
     private compacting;
     private sessionState;
     private readonly emitSessionStateEvents;
@@ -272,7 +294,7 @@ export declare class StreamJsonOutput {
     private readonly includePartialMessages;
     private readonly includeHookEvents;
     private write;
-    init(): void;
+    init(startedAt?: number): void;
     replayUser(message: StreamUserMessage['message']): void;
     /**
      * Emits the synthetic assistant message for a provider-free local command
@@ -285,13 +307,14 @@ export declare class StreamJsonOutput {
         request: Record<string, unknown>;
     }): void;
     readonly sink: RuntimeEventSink;
-    result(result: ProtocolResult, startedAt: number): void;
+    result(result: ProtocolResult, startedAt: number, context?: ProtocolSuccessProjectionContext): void;
     promptSuggestion(suggestion: string): void;
-    error(message: string, startedAt: number): void;
+    error(message: string, startedAt: number, context?: ProtocolErrorProjectionContext): void;
     private onEvent;
     private writeSessionState;
     private writeTerminalIdle;
     private ensureTurn;
+    private observeOutput;
     private discardTurn;
     private startTurn;
     private writePartialMessageStart;

package/dist/cli/protocol.js

@@ -1,32 +1,74 @@
 import { randomUUID } from 'node:crypto';
-export function createSuccessResult(result, info, startedAt, modelTurns) {
-    const duration = Date.now() - startedAt;
-    const modelUsage = result.modelUsage ?? { [info.model]: result.usage };
-    const usage = {
-        input_tokens: result.usage.inputTokens,
-        output_tokens: result.usage.outputTokens,
-        ...(result.usage.cacheReadInputTokens === undefined
+export function projectProtocolTimings(startedAt, requestAt, outputAt) {
+    return {
+        ...(requestAt === undefined
             ? {}
-            : { cache_read_input_tokens: result.usage.cacheReadInputTokens }),
-        ...(result.usage.cacheCreationInputTokens === undefined
+            : { timeToRequestMs: requestAt - startedAt }),
+        ...(outputAt === undefined
             ? {}
             : {
-                cache_creation_input_tokens: result.usage.cacheCreationInputTokens,
+                ttftMs: outputAt - startedAt,
+                ttftStreamMs: outputAt - startedAt,
             }),
     };
+}
+function protocolUsage(usage) {
+    return {
+        input_tokens: usage.inputTokens,
+        cache_creation_input_tokens: usage.cacheCreationInputTokens ?? 0,
+        cache_read_input_tokens: usage.cacheReadInputTokens ?? 0,
+        output_tokens: usage.outputTokens,
+        server_tool_use: {
+            web_search_requests: usage.webSearchRequests ?? 0,
+            web_fetch_requests: 0,
+        },
+        service_tier: 'standard',
+        cache_creation: {
+            ephemeral_1h_input_tokens: 0,
+            ephemeral_5m_input_tokens: 0,
+        },
+        inference_geo: '',
+        iterations: [],
+        speed: 'standard',
+    };
+}
+function normalizeApiError(message, status) {
+    const body = message.replace(/^API Error:\s*\d+\s*/u, '');
+    return `API Error: ${status} ${body}`;
+}
+export function createSuccessResult(result, info, startedAt, modelTurns, context = {}) {
+    const duration = Date.now() - startedAt;
+    const localCommand = context.localCommand === true;
+    const modelUsage = result.modelUsage ?? (localCommand ? {} : { [info.model]: result.usage });
+    const usage = protocolUsage(result.usage);
     return {
         type: 'result',
         subtype: 'success',
         is_error: false,
         duration_ms: duration,
-        duration_api_ms: result.durationApiMs === undefined
-            ? null
-            : Math.round(result.durationApiMs),
-        num_turns: modelTurns,
+        ...(localCommand
+            ? {}
+            : {
+                api_error_status: null,
+                ...(context.ttftMs === undefined ? {} : { ttft_ms: context.ttftMs }),
+                ...(context.ttftStreamMs === undefined
+                    ? {}
+                    : { ttft_stream_ms: context.ttftStreamMs }),
+                ...(context.timeToRequestMs === undefined
+                    ? {}
+                    : { time_to_request_ms: context.timeToRequestMs }),
+            }),
+        duration_api_ms: localCommand
+            ? 0
+            : result.durationApiMs === undefined
+                ? 0
+                : Math.round(result.durationApiMs),
+        num_turns: localCommand ? 0 : modelTurns,
         result: result.text,
-        stop_reason: null,
+        stop_reason: localCommand ? null : (context.stopReason ?? null),
+        ...(localCommand ? {} : { terminal_reason: 'completed' }),
         session_id: result.sessionId,
-        total_cost_usd: result.costUsd ?? null,
+        total_cost_usd: result.costUsd ?? 0,
         usage,
         modelUsage: Object.fromEntries(Object.entries(modelUsage).map(([model, modelUsage]) => [
             model,
@@ -35,11 +77,9 @@ export function createSuccessResult(result, info, startedAt, modelTurns) {
                 outputTokens: modelUsage.outputTokens,
                 cacheReadInputTokens: modelUsage.cacheReadInputTokens ?? 0,
                 cacheCreationInputTokens: modelUsage.cacheCreationInputTokens ?? 0,
+                webSearchRequests: modelUsage.webSearchRequests ?? 0,
                 costUSD: result.modelCostUsd?.[model] ??
-                    (model === info.model ? (result.costUsd ?? null) : null),
-                ...(modelUsage.webSearchRequests === undefined
-                    ? {}
-                    : { webSearchRequests: modelUsage.webSearchRequests }),
+                    (model === info.model ? (result.costUsd ?? 0) : 0),
                 contextWindow: modelUsage.contextWindow ??
                     (model === info.model ? (info.contextWindowTokens ?? 0) : 0),
                 maxOutputTokens: modelUsage.maxOutputTokens ??
@@ -63,24 +103,45 @@ function errorResultSubtype(message) {
         return 'error_max_structured_output_retries';
     return 'error_during_execution';
 }
-export function createErrorResult(message, sessionId, startedAt, modelTurns) {
+export function createErrorResult(message, sessionId, startedAt, modelTurns, context = {}) {
     const duration = Date.now() - startedAt;
+    const providerApiError = context.providerApiError === true;
+    const apiErrorStatus = context.apiErrorStatus ?? null;
+    const normalizedMessage = providerApiError && typeof context.apiErrorStatus === 'number'
+        ? normalizeApiError(message, context.apiErrorStatus)
+        : message;
+    if (providerApiError) {
+        return {
+            type: 'result',
+            subtype: 'success',
+            is_error: true,
+            api_error_status: apiErrorStatus,
+            duration_ms: duration,
+            duration_api_ms: 0,
+            num_turns: modelTurns,
+            result: normalizedMessage,
+            stop_reason: 'stop_sequence',
+            terminal_reason: 'api_error',
+            session_id: sessionId,
+            total_cost_usd: 0,
+            usage: protocolUsage({ inputTokens: 0, outputTokens: 0 }),
+            modelUsage: {},
+            permission_denials: [],
+            fast_mode_state: 'off',
+            uuid: randomUUID(),
+        };
+    }
     return {
         type: 'result',
         subtype: errorResultSubtype(message),
         is_error: true,
         duration_ms: duration,
-        duration_api_ms: null,
+        duration_api_ms: 0,
         num_turns: modelTurns,
         stop_reason: null,
         session_id: sessionId,
-        total_cost_usd: null,
-        usage: {
-            input_tokens: 0,
-            output_tokens: 0,
-            cache_creation_input_tokens: 0,
-            cache_read_input_tokens: 0,
-        },
+        total_cost_usd: 0,
+        usage: protocolUsage({ inputTokens: 0, outputTokens: 0 }),
         modelUsage: {},
         permission_denials: [],
         errors: [message],
@@ -1710,6 +1771,11 @@ export class StreamJsonOutput {
     activeThinkingIndex;
     nextContentIndex = 0;
     modelTurns = 0;
+    projectionStartedAt;
+    firstRequestAt;
+    firstOutputAt;
+    turnHasRealContent = false;
+    pendingFailureMessage;
     compacting = false;
     sessionState;
     emitSessionStateEvents;
@@ -1732,7 +1798,11 @@ export class StreamJsonOutput {
             session_id: value.session_id ?? this.sessionId,
         });
     }
-    init() {
+    init(startedAt = Date.now()) {
+        this.projectionStartedAt = startedAt;
+        this.firstRequestAt = undefined;
+        this.firstOutputAt = undefined;
+        this.pendingFailureMessage = undefined;
         this.writeSessionState('running');
         this.write({
             type: 'system',
@@ -1783,9 +1853,21 @@ export class StreamJsonOutput {
         this.write({ type: 'control_request', ...request });
     }
     sink = (event) => this.onEvent(event);
-    result(result, startedAt) {
+    result(result, startedAt, context = {}) {
         this.finishTurn();
-        this.write(createSuccessResult(result, this.info, startedAt, this.modelTurns));
+        const requestAt = this.firstRequestAt;
+        const outputAt = this.firstOutputAt;
+        const stopReason = context.stopReason ?? this.turnTerminalReason;
+        const timing = projectProtocolTimings(this.projectionStartedAt ?? startedAt, requestAt, outputAt);
+        this.write(createSuccessResult(result, this.info, startedAt, this.modelTurns, {
+            ...context,
+            ...(context.localCommand
+                ? {}
+                : {
+                    ...(stopReason === undefined ? {} : { stopReason }),
+                    ...timing,
+                }),
+        }));
         this.writeTerminalIdle();
         this.modelTurns = 0;
     }
@@ -1797,9 +1879,15 @@ export class StreamJsonOutput {
             session_id: this.sessionId,
         });
     }
-    error(message, startedAt) {
+    error(message, startedAt, context = {}) {
+        if (this.pendingFailureMessage !== undefined) {
+            this.turnText =
+                context.providerApiError && typeof context.apiErrorStatus === 'number'
+                    ? normalizeApiError(message, context.apiErrorStatus)
+                    : message;
+        }
         this.finishTurn();
-        this.write(createErrorResult(message, this.sessionId, startedAt, this.modelTurns));
+        this.write(createErrorResult(message, this.sessionId, startedAt, this.modelTurns, context));
         this.writeTerminalIdle();
         this.modelTurns = 0;
     }
@@ -1841,7 +1929,9 @@ export class StreamJsonOutput {
                 event.state === 'completed' ||
                 event.state === 'cancelled' ||
                 event.state === 'failed') {
-                this.flushAssistant();
+                if (event.state !== 'failed' ||
+                    this.pendingFailureMessage === undefined)
+                    this.flushAssistant();
                 if (event.state === 'awaiting-permission')
                     this.writeSessionState('requires_action');
             }
@@ -1849,12 +1939,14 @@ export class StreamJsonOutput {
         }
         if (event.type === 'text-delta') {
             this.ensureTurn();
+            this.observeOutput();
             this.turnText += event.delta;
             this.partialText(event.delta);
             return;
         }
         if (event.type === 'thinking-start') {
             this.ensureTurn();
+            this.observeOutput();
             if (this.includePartialMessages) {
                 if (this.activeThinkingIndex !== undefined) {
                     throw new Error('Thinking content blocks cannot overlap');
@@ -1885,6 +1977,7 @@ export class StreamJsonOutput {
         if (event.type === 'thinking-delta' ||
             event.type === 'thinking-signature-delta') {
             this.ensureTurn();
+            this.observeOutput();
             if (this.includePartialMessages) {
                 if (this.activeThinkingIndex === undefined) {
                     throw new Error('Thinking delta arrived without an active block');
@@ -1906,6 +1999,7 @@ export class StreamJsonOutput {
         }
         if (event.type === 'thinking-stop') {
             this.ensureTurn();
+            this.observeOutput();
             this.turnThinking.push(event.block);
             if (this.includePartialMessages) {
                 if (this.activeThinkingIndex === undefined) {
@@ -1930,6 +2024,7 @@ export class StreamJsonOutput {
         }
         if (event.type === 'tool-call') {
             this.ensureTurn();
+            this.observeOutput();
             this.turnCalls.push(event.call);
             if (this.includePartialMessages) {
                 const index = this.nextContentIndex++;
@@ -2165,13 +2260,16 @@ export class StreamJsonOutput {
         }
         if (event.type === 'failed') {
             this.ensureTurn();
-            if (this.turnText.length === 0 &&
+            if (!this.turnHasRealContent &&
+                this.turnText.length === 0 &&
                 this.turnThinking.length === 0 &&
                 this.turnCalls.length === 0) {
-                this.turnText = event.message;
-                this.partialText(event.message);
+                this.pendingFailureMessage = event.message;
+                this.assistantFlushed = false;
+            }
+            else {
+                this.flushAssistant();
             }
-            this.flushAssistant();
         }
     }
     writeSessionState(state) {
@@ -2204,6 +2302,11 @@ export class StreamJsonOutput {
         if (!this.turnActive)
             this.startTurn();
     }
+    observeOutput() {
+        this.turnHasRealContent = true;
+        if (this.firstOutputAt === undefined)
+            this.firstOutputAt = Date.now();
+    }
     discardTurn(reason) {
         this.write({
             type: 'system',
@@ -2225,6 +2328,8 @@ export class StreamJsonOutput {
         this.nextContentIndex = 0;
         this.partialEvents = [];
         this.pendingPartialStop = undefined;
+        this.turnHasRealContent = false;
+        this.pendingFailureMessage = undefined;
     }
     startTurn() {
         if (this.turnActive)
@@ -2243,6 +2348,9 @@ export class StreamJsonOutput {
         this.nextContentIndex = 0;
         this.partialEvents = [];
         this.pendingPartialStop = undefined;
+        this.turnHasRealContent = false;
+        if (this.firstRequestAt === undefined)
+            this.firstRequestAt = Date.now();
         this.modelTurns += 1;
         if (this.includePartialMessages) {
             this.write({

package/dist/cli-runtime.js

@@ -19,7 +19,7 @@ import { isSessionId } from './core/session.js';
 import { assertNativeDataPlane, resolveDataPlane, resolveDataPlaneRoot, resolveDataPlanePaths, } from './persistence/data-plane.js';
 import { loadNativeContextResources, loadNativeSettings, loadNativeSharedResources, } from './persistence/native-resources.js';
 import { resolveProjectIdentity } from './platform/project-identity.js';
-import { AgentRunCancelledError, } from './core/runtime.js';
+import { AgentRunCancelledError, ModelProviderError, } from './core/runtime.js';
 import { persistTuiPermissionUpdates } from './cli/tui/permission-settings.js';
 import { loadClaudeReleaseNotes } from './cli/tui/release-notes.js';
 import { canonicalClaudeCostModelName, formatCostSummary, } from './cli/tui/cost-summary.js';
@@ -65,7 +65,7 @@ import { WorkspaceContext } from './application/session-worktree.js';
 import { launchTmuxWorktree } from './platform/tmux-worktree.js';
 import { claudeSandboxRuntime } from './sandbox/claude-sandbox-runtime.js';
 import { nativeSandboxTempDirectory, loadClaudeSandboxSettings, } from './sandbox/claude-sandbox-settings.js';
-import { createErrorResult, createSuccessResult, isHeadlessCostCommand, matchHeadlessColorCommand, parseCliInvocation, readStreamJsonMessages, StreamJsonOutput, } from './cli/protocol.js';
+import { createErrorResult, createSuccessResult, isHeadlessCostCommand, matchHeadlessColorCommand, parseCliInvocation, projectProtocolTimings, readStreamJsonMessages, StreamJsonOutput, } from './cli/protocol.js';
 import { executeProviderAuthCommand } from './cli/provider-auth-command.js';
 import { describeClaudePlugin, initClaudePlugin, installClaudePlugin, loadClaudePlugins, readPluginRegistry, setClaudePluginEnabled, uninstallClaudePlugin, updateClaudePlugin, validateClaudePlugin, } from './plugins/claude-plugin-runtime.js';
 import { addClaudeMarketplace, disableAllNativePlugins, installClaudeMarketplacePlugin, listClaudeMarketplaceAvailablePlugins, listNativePluginRecords, readClaudeKnownMarketplaces, removeClaudeMarketplace, setNativePluginEnabled, saveClaudePluginConfig, uninstallNativePlugin, updateClaudeMarketplace, updateNativePlugin, validateClaudeMarketplace, } from './plugins/claude-plugin-marketplace.js';
@@ -5412,6 +5412,9 @@ async function execute(argv, io, dependencies, signal) {
     }
     let streamOutput;
     let jsonModelTurns = 0;
+    let jsonRequestAt;
+    let jsonOutputAt;
+    let jsonTerminalReason;
     const pendingEvents = [];
     let streamIterator;
     let firstStreamMessage;
@@ -5615,10 +5618,10 @@ async function execute(argv, io, dependencies, signal) {
             output.init();
             output.sink({ type: 'text-delta', delta: text });
             output.sink({ type: 'usage', usage: result.usage });
-            output.result(result, startedAt);
+            output.result(result, startedAt, { localCommand: true });
         }
         else if (outputFormat === 'json' || invocation.legacyJson) {
-            writeJson(io, createSuccessResult(result, info, startedAt, 0));
+            writeJson(io, createSuccessResult(result, info, startedAt, 0, { localCommand: true }));
         }
         else {
             io.stdout(`${text}\n`);
@@ -5663,6 +5666,20 @@ async function execute(argv, io, dependencies, signal) {
                 ? (event) => {
                     if (event.type === 'state' && event.state === 'awaiting-model') {
                         jsonModelTurns += 1;
+                        if (jsonRequestAt === undefined)
+                            jsonRequestAt = Date.now();
+                    }
+                    if (event.type === 'terminal') {
+                        jsonTerminalReason = event.reason;
+                    }
+                    if ((event.type === 'text-delta' ||
+                        event.type === 'thinking-start' ||
+                        event.type === 'thinking-delta' ||
+                        event.type === 'thinking-signature-delta' ||
+                        event.type === 'thinking-stop' ||
+                        event.type === 'tool-call') &&
+                        jsonOutputAt === undefined) {
+                        jsonOutputAt = Date.now();
                     }
                     if (event.type === 'warning') {
                         io.stderr(`Warning: ${redactSensitiveText(event.message, sensitiveEnvironmentValues(process.env))}\n`);
@@ -5816,8 +5833,12 @@ async function execute(argv, io, dependencies, signal) {
             currentTurnAbort = streamIterator ? turnAbort : undefined;
             const runSignal = streamIterator ? turnAbort.signal : signal;
             await ensureCostBaseline(activeSessionId);
+            jsonModelTurns = 0;
+            jsonRequestAt = undefined;
+            jsonOutputAt = undefined;
+            jsonTerminalReason = undefined;
             if (streamOutput) {
-                streamOutput.init();
+                streamOutput.init(startedAt);
                 if (isFirstTurn) {
                     for (const event of pendingEvents)
                         streamOutput.sink(event);
@@ -5902,10 +5923,20 @@ async function execute(argv, io, dependencies, signal) {
                     throw error;
                 }
                 const message = redactSensitiveText(error instanceof Error ? error.message : String(error), sensitiveEnvironmentValues(process.env));
+                const providerApiError = error instanceof ModelProviderError &&
+                    (error.status !== undefined || error.kind === 'api_error');
+                const errorContext = providerApiError
+                    ? {
+                        providerApiError: true,
+                        apiErrorStatus: error instanceof ModelProviderError
+                            ? (error.status ?? null)
+                            : null,
+                    }
+                    : {};
                 if (streamOutput)
-                    streamOutput.error(message, startedAt);
+                    streamOutput.error(message, startedAt, errorContext);
                 else if (outputFormat === 'json') {
-                    writeJson(io, createErrorResult(message, activeSessionId, startedAt, jsonModelTurns));
+                    writeJson(io, createErrorResult(message, activeSessionId, startedAt, jsonModelTurns, errorContext));
                 }
                 else {
                     if (currentTurnAbort === turnAbort)
@@ -5925,11 +5956,17 @@ async function execute(argv, io, dependencies, signal) {
                 if (localCommand) {
                     streamOutput.syntheticAssistant(result.text);
                 }
-                streamOutput.result(result, startedAt);
+                streamOutput.result(result, startedAt, { localCommand });
             }
             else if (outputFormat === 'json') {
                 const resultRuntimeInfo = service.runtimeInfo?.() ?? runtimeInfo;
-                writeJson(io, createSuccessResult(result, resultRuntimeInfo, startedAt, localCommand ? 0 : Math.max(1, jsonModelTurns)));
+                writeJson(io, createSuccessResult(result, resultRuntimeInfo, startedAt, localCommand ? 0 : Math.max(1, jsonModelTurns), {
+                    localCommand,
+                    ...(jsonTerminalReason === undefined
+                        ? {}
+                        : { stopReason: jsonTerminalReason }),
+                    ...projectProtocolTimings(startedAt, jsonRequestAt, jsonOutputAt),
+                }));
             }
             else if (outputFormat !== 'text')
                 writeJson(io, { type: 'result', ...result });

package/package.json

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