praxis-agent 0.55.2 → 0.56.0

package/README.md

@@ -172,8 +172,9 @@ troubleshooting. Run `praxis --help` for the authoritative command surface.
   deterministic resize-aware URL/form elicitation rendering, and measured
   context budgets; print mode,
   structured JSON/JSONL, context compaction, tool loops, and bounded execution.
-- **Built-in tools** — read, write, edit, glob, search, shell, notebook, PDF,
-  image, web, scheduled prompts, workflows, and worktrees.
+- **Built-in tools** — read, write, edit, `ApplyPatch` for bounded ordered exact
+  multi-file replacements, glob, search, shell, notebook, PDF, image, web,
+  scheduled prompts, workflows, and worktrees.
 - **Shell lifecycle** — foreground Bash allows up to 10 minutes and carries a
   validated final working directory across calls in the same session without
   leaking state across sessions or overriding an explicit `/cd`.

package/dist/application/session-service.js

@@ -51,6 +51,7 @@ 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 { parseApplyPatchInput } from '../tools/apply-patch.js';
 import { ClaudeCapabilityToolRegistry, resolveClaudeToolCapabilities, } from '../tools/claude-capabilities.js';
 import { generateToolUseSummary } from './tool-use-summary.js';
 import { ClaudeUserMessageToolRegistry, } from '../tools/claude-user-message.js';
@@ -88,6 +89,21 @@ function mainAgentToolNames(tools, agent) {
         .map(({ name }) => name)
         .filter((name) => (!requested || requested.has(name)) && !disallowed.has(name));
 }
+function mutationPaths(call) {
+    if (call.name === 'ApplyPatch')
+        return parseApplyPatchInput(call.input).map((edit) => edit.file_path);
+    if (call.name === 'Write' || call.name === 'Edit') {
+        return typeof call.input.file_path === 'string'
+            ? [call.input.file_path]
+            : [];
+    }
+    if (call.name === 'NotebookEdit') {
+        return typeof call.input.notebook_path === 'string'
+            ? [call.input.notebook_path]
+            : [];
+    }
+    return [];
+}
 function isSessionCandidateError(error) {
     return (error instanceof NativeTranscriptIndexCandidateError ||
         ['ENOENT', 'ENOTDIR', 'ELOOP'].includes(error.code ?? ''));
@@ -1168,6 +1184,7 @@ export class ClaudeSessionService {
             'Read',
             'LSP',
             'Edit',
+            'ApplyPatch',
             'Write',
             'NotebookEdit',
             'WebFetch',
@@ -2869,16 +2886,18 @@ export class ClaudeSessionService {
                         }),
                         prepare: (call, context) => interactiveMessageTools.prepare(call, context),
                         execute: async (call, context) => {
-                            const path = call.name === 'Write' || call.name === 'Edit'
-                                ? call.input.file_path
-                                : call.name === 'NotebookEdit'
-                                    ? call.input.notebook_path
-                                    : undefined;
-                            if (typeof path !== 'string') {
+                            const paths = mutationPaths(call);
+                            if (paths.length === 0) {
                                 return interactiveMessageTools.execute(call, context);
                             }
-                            if ((call.name === 'Write' || call.name === 'Edit') &&
-                                (await this.options.interactiveTools?.isPlanFile(sessionId, path))) {
+                            const historyPaths = call.name === 'Write' ||
+                                call.name === 'Edit' ||
+                                call.name === 'ApplyPatch'
+                                ? (await Promise.all(paths.map(async (path) => (await this.options.interactiveTools?.isPlanFile(sessionId, path))
+                                    ? null
+                                    : path))).filter((path) => path !== null)
+                                : paths;
+                            if (historyPaths.length === 0) {
                                 return interactiveMessageTools.execute(call, context);
                             }
                             const snapshotMessageId = currentPromptId ??
@@ -2888,21 +2907,31 @@ export class ClaudeSessionService {
                             if (!snapshotMessageId || !assistantMessageId) {
                                 throw new Error('Claude file history could not link tool call');
                             }
-                            const prepared = await fileHistory.prepareMutation(projectionSnapshot().entries, snapshotMessageId, path);
+                            const preparedMutations = [];
+                            try {
+                                for (const path of [...new Set(historyPaths)])
+                                    preparedMutations.push(await fileHistory.prepareMutation(projectionSnapshot().entries, snapshotMessageId, path));
+                            }
+                            catch (error) {
+                                await Promise.all(preparedMutations.map((mutation) => mutation.rollback()));
+                                throw error;
+                            }
                             let result;
                             try {
                                 result = await interactiveMessageTools.execute(call, context);
                             }
                             catch (error) {
-                                await prepared.rollback();
+                                await Promise.all(preparedMutations.map((mutation) => mutation.rollback()));
                                 throw error;
                             }
                             if (result.isError) {
-                                await prepared.rollback();
+                                await Promise.all(preparedMutations.map((mutation) => mutation.rollback()));
                                 return result;
                             }
-                            const entry = prepared.commit(assistantMessageId);
-                            if (entry) {
+                            const entries = preparedMutations
+                                .map((mutation) => mutation.commit(assistantMessageId))
+                                .filter((entry) => entry !== null);
+                            for (const entry of entries) {
                                 await persistence.commit({
                                     kind: 'messages',
                                     input: {
@@ -3105,7 +3134,9 @@ export class ClaudeSessionService {
                                 if (call.name === 'Read') {
                                     turnMemory.recordRead(path);
                                 }
-                                else if (call.name === 'Write' || call.name === 'Edit') {
+                                else if (call.name === 'Write' ||
+                                    call.name === 'Edit' ||
+                                    call.name === 'ApplyPatch') {
                                     projectMemoryMaintained = true;
                                 }
                             }
@@ -3117,6 +3148,14 @@ export class ClaudeSessionService {
                                     }
                                 }
                             }
+                            else if (call.name === 'ApplyPatch') {
+                                for (const accessedPath of toolResult.accessedPaths ?? []) {
+                                    const resolvedAccessedPath = resolve(this.activeCwd(), accessedPath);
+                                    if (isPathWithin(this.options.projectMemoryDirectory, resolvedAccessedPath)) {
+                                        projectMemoryMaintained = true;
+                                    }
+                                }
+                            }
                         }
                         if (toolResult.isError ||
                             call.name !== 'Read' ||

package/dist/application/subagent-service.js

@@ -299,6 +299,7 @@ const BACKGROUND_AGENT_TOOLS = new Set([
     'Glob',
     'Bash',
     'Edit',
+    'ApplyPatch',
     'Write',
     'NotebookEdit',
     'Skill',

package/dist/cli/interactive.js

@@ -1885,7 +1885,7 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
                 }
                 break;
             case 'tool-call':
-                if (['Edit', 'Write', 'NotebookEdit'].includes(event.call.name))
+                if (['Edit', 'Write', 'ApplyPatch', 'NotebookEdit'].includes(event.call.name))
                     turnMutatedFilesRef.current = true;
                 permissionCallsRef.current.set(event.call.id, event.call);
                 append({
@@ -4055,7 +4055,7 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
                 }
                 if (permission.kind === 'tool' &&
                     selected.action === 'allow-session-edits') {
-                    for (const rule of ['Write', 'Edit', 'NotebookEdit']) {
+                    for (const rule of ['Write', 'Edit', 'ApplyPatch', 'NotebookEdit']) {
                         if (!immediatePermissionRulesRef.current.includes(rule))
                             immediatePermissionRulesRef.current.push(rule);
                     }

package/dist/cli/process-signal.d.ts

@@ -0,0 +1,3 @@
+export declare const DIRECT_PROCESS_SIGINT: unique symbol;
+export declare function isDirectProcessSigint(signal: AbortSignal | undefined): boolean;
+//# sourceMappingURL=process-signal.d.ts.map

package/dist/cli/process-signal.js

@@ -0,0 +1,5 @@
+export const DIRECT_PROCESS_SIGINT = Symbol('praxis.direct-process-sigint');
+export function isDirectProcessSigint(signal) {
+    return signal?.aborted === true && signal.reason === DIRECT_PROCESS_SIGINT;
+}
+//# sourceMappingURL=process-signal.js.map

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;
@@ -300,6 +323,7 @@ export declare class StreamJsonOutput {
     private finishPartial;
     private finishPartialTail;
     private flushAssistant;
+    private flushPartialOnly;
     private finishTurn;
 }
 //# sourceMappingURL=protocol.d.ts.map

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,16 @@ export class StreamJsonOutput {
                 event.state === 'completed' ||
                 event.state === 'cancelled' ||
                 event.state === 'failed') {
-                this.flushAssistant();
+                const shouldFlush = event.state === 'cancelled'
+                    ? this.turnText.length > 0 ||
+                        this.turnThinking.length > 0 ||
+                        this.turnCalls.length > 0
+                    : event.state !== 'failed' ||
+                        this.pendingFailureMessage === undefined;
+                if (shouldFlush)
+                    this.flushAssistant();
+                else if (event.state === 'cancelled')
+                    this.flushPartialOnly();
                 if (event.state === 'awaiting-permission')
                     this.writeSessionState('requires_action');
             }
@@ -1849,12 +1946,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 +1984,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 +2006,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 +2031,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 +2267,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 +2309,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 +2335,8 @@ export class StreamJsonOutput {
         this.nextContentIndex = 0;
         this.partialEvents = [];
         this.pendingPartialStop = undefined;
+        this.turnHasRealContent = false;
+        this.pendingFailureMessage = undefined;
     }
     startTurn() {
         if (this.turnActive)
@@ -2243,6 +2355,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({
@@ -2384,6 +2499,18 @@ export class StreamJsonOutput {
         });
         this.finishPartialTail();
     }
+    flushPartialOnly() {
+        if (!this.includePartialMessages ||
+            this.assistantFlushed ||
+            this.partialEvents.length === 0)
+            return;
+        this.assistantFlushed = true;
+        this.writePartialMessageStart();
+        for (const event of this.partialEvents)
+            this.write(event);
+        this.partialEvents = [];
+        this.pendingPartialStop = undefined;
+    }
     finishTurn() {
         this.flushAssistant();
         this.turnActive = false;