praxis-agent 0.55.1 → 0.55.2

package/dist/cli/protocol.d.ts

@@ -243,11 +243,9 @@ export declare function parseCliInvocation(argv: readonly string[]): CliInvocati
 export declare function readStreamJsonMessages(input: AsyncIterable<string | Uint8Array>): AsyncGenerator<StreamJsonMessage>;
 export declare function readStreamUserMessages(input: AsyncIterable<string | Uint8Array>): AsyncGenerator<StreamUserMessage>;
 export declare class StreamJsonOutput {
-    private readonly write;
+    private readonly emitRaw;
     private readonly info;
     private readonly sessionId;
-    private readonly includePartialMessages;
-    private readonly includeHookEvents;
     private turnId;
     private turnText;
     private turnThinking;
@@ -263,7 +261,17 @@ export declare class StreamJsonOutput {
     private modelTurns;
     private compacting;
     private sessionState;
-    constructor(write: (value: unknown) => void, info: CliRuntimeInfo, sessionId: string, includePartialMessages: boolean, includeHookEvents?: boolean);
+    private readonly emitSessionStateEvents;
+    private partialEvents;
+    private pendingPartialStop;
+    constructor(emitRaw: (value: unknown) => void, info: CliRuntimeInfo, sessionId: string, options: {
+        includePartialMessages: boolean;
+        includeHookEvents?: boolean;
+        emitSessionStateEvents?: boolean;
+    });
+    private readonly includePartialMessages;
+    private readonly includeHookEvents;
+    private write;
     init(): void;
     replayUser(message: StreamUserMessage['message']): void;
     /**
@@ -282,11 +290,15 @@ export declare class StreamJsonOutput {
     error(message: string, startedAt: number): void;
     private onEvent;
     private writeSessionState;
+    private writeTerminalIdle;
     private ensureTurn;
     private discardTurn;
     private startTurn;
+    private writePartialMessageStart;
     private partialText;
+    private beginPartialBlock;
     private finishPartial;
+    private finishPartialTail;
     private flushAssistant;
     private finishTurn;
 }

package/dist/cli/protocol.js

@@ -1694,11 +1694,9 @@ export async function* readStreamUserMessages(input) {
 }
 const emptyUsage = () => ({ inputTokens: 0, outputTokens: 0 });
 export class StreamJsonOutput {
-    write;
+    emitRaw;
     info;
     sessionId;
-    includePartialMessages;
-    includeHookEvents;
     turnId = randomUUID();
     turnText = '';
     turnThinking = [];
@@ -1714,14 +1712,28 @@ export class StreamJsonOutput {
     modelTurns = 0;
     compacting = false;
     sessionState;
-    constructor(write, info, sessionId, includePartialMessages, includeHookEvents = false) {
-        this.write = write;
+    emitSessionStateEvents;
+    partialEvents = [];
+    pendingPartialStop;
+    constructor(emitRaw, info, sessionId, options) {
+        this.emitRaw = emitRaw;
         this.info = info;
         this.sessionId = sessionId;
-        this.includePartialMessages = includePartialMessages;
-        this.includeHookEvents = includeHookEvents;
+        this.includePartialMessages = options.includePartialMessages;
+        this.includeHookEvents = options.includeHookEvents ?? false;
+        this.emitSessionStateEvents = options.emitSessionStateEvents ?? false;
+    }
+    includePartialMessages;
+    includeHookEvents;
+    write(value) {
+        this.emitRaw({
+            ...value,
+            uuid: value.uuid ?? randomUUID(),
+            session_id: value.session_id ?? this.sessionId,
+        });
     }
     init() {
+        this.writeSessionState('running');
         this.write({
             type: 'system',
             subtype: 'init',
@@ -1740,7 +1752,6 @@ export class StreamJsonOutput {
             output_style: 'default',
             plugins: this.info.plugins ?? [],
             fast_mode_state: 'off',
-            uuid: randomUUID(),
         });
     }
     replayUser(message) {
@@ -1775,6 +1786,7 @@ export class StreamJsonOutput {
     result(result, startedAt) {
         this.finishTurn();
         this.write(createSuccessResult(result, this.info, startedAt, this.modelTurns));
+        this.writeTerminalIdle();
         this.modelTurns = 0;
     }
     promptSuggestion(suggestion) {
@@ -1788,6 +1800,7 @@ export class StreamJsonOutput {
     error(message, startedAt) {
         this.finishTurn();
         this.write(createErrorResult(message, this.sessionId, startedAt, this.modelTurns));
+        this.writeTerminalIdle();
         this.modelTurns = 0;
     }
     onEvent(event) {
@@ -1831,11 +1844,6 @@ export class StreamJsonOutput {
                 this.flushAssistant();
                 if (event.state === 'awaiting-permission')
                     this.writeSessionState('requires_action');
-                else if (event.state === 'completed' ||
-                    event.state === 'cancelled' ||
-                    event.state === 'failed') {
-                    this.writeSessionState('idle');
-                }
             }
             return;
         }
@@ -1853,7 +1861,7 @@ export class StreamJsonOutput {
                 }
                 this.activeThinkingIndex = this.nextContentIndex;
                 this.nextContentIndex += 1;
-                this.write({
+                this.beginPartialBlock({
                     type: 'stream_event',
                     event: {
                         type: 'content_block_start',
@@ -1862,6 +1870,14 @@ export class StreamJsonOutput {
                     },
                     parent_tool_use_id: null,
                     session_id: this.sessionId,
+                }, {
+                    type: 'stream_event',
+                    event: {
+                        type: 'content_block_stop',
+                        index: this.activeThinkingIndex,
+                    },
+                    parent_tool_use_id: null,
+                    session_id: this.sessionId,
                 });
             }
             return;
@@ -1873,7 +1889,7 @@ export class StreamJsonOutput {
                 if (this.activeThinkingIndex === undefined) {
                     throw new Error('Thinking delta arrived without an active block');
                 }
-                this.write({
+                this.partialEvents.push({
                     type: 'stream_event',
                     event: {
                         type: 'content_block_delta',
@@ -1895,22 +1911,13 @@ export class StreamJsonOutput {
                 if (this.activeThinkingIndex === undefined) {
                     throw new Error('Thinking block stopped without an active block');
                 }
-                this.write({
-                    type: 'stream_event',
-                    event: {
-                        type: 'content_block_stop',
-                        index: this.activeThinkingIndex,
-                    },
-                    parent_tool_use_id: null,
-                    session_id: this.sessionId,
-                });
                 this.activeThinkingIndex = undefined;
             }
             return;
         }
         if (event.type === 'user-message') {
             this.write({
-                type: 'user_message',
+                type: 'user',
                 message: event.message,
                 status: event.status,
                 ...(event.attachments?.length
@@ -1924,6 +1931,42 @@ export class StreamJsonOutput {
         if (event.type === 'tool-call') {
             this.ensureTurn();
             this.turnCalls.push(event.call);
+            if (this.includePartialMessages) {
+                const index = this.nextContentIndex++;
+                this.beginPartialBlock({
+                    type: 'stream_event',
+                    event: {
+                        type: 'content_block_start',
+                        index,
+                        content_block: {
+                            type: 'tool_use',
+                            id: event.call.id,
+                            name: event.call.name,
+                            input: {},
+                        },
+                    },
+                    parent_tool_use_id: null,
+                    session_id: this.sessionId,
+                }, {
+                    type: 'stream_event',
+                    event: { type: 'content_block_stop', index },
+                    parent_tool_use_id: null,
+                    session_id: this.sessionId,
+                });
+                this.partialEvents.push({
+                    type: 'stream_event',
+                    event: {
+                        type: 'content_block_delta',
+                        index,
+                        delta: {
+                            type: 'input_json_delta',
+                            partial_json: JSON.stringify(event.call.input),
+                        },
+                    },
+                    parent_tool_use_id: null,
+                    session_id: this.sessionId,
+                });
+            }
             return;
         }
         if (event.type === 'usage') {
@@ -2062,13 +2105,7 @@ export class StreamJsonOutput {
             return;
         }
         if (event.type === 'session-state-changed') {
-            this.write({
-                type: 'system',
-                subtype: 'session_state_changed',
-                state: event.state,
-                uuid: randomUUID(),
-                session_id: this.sessionId,
-            });
+            this.writeSessionState(event.state);
             return;
         }
         if (event.type === 'api-retry') {
@@ -2135,12 +2172,15 @@ export class StreamJsonOutput {
                 this.partialText(event.message);
             }
             this.flushAssistant();
-            this.writeSessionState('idle');
         }
     }
     writeSessionState(state) {
+        if (!this.emitSessionStateEvents)
+            return;
         if (this.sessionState === state)
             return;
+        if (state === 'idle')
+            return;
         this.sessionState = state;
         this.write({
             type: 'system',
@@ -2150,6 +2190,16 @@ export class StreamJsonOutput {
             session_id: this.sessionId,
         });
     }
+    writeTerminalIdle() {
+        if (!this.emitSessionStateEvents || this.sessionState === 'idle')
+            return;
+        this.sessionState = 'idle';
+        this.write({
+            type: 'system',
+            subtype: 'session_state_changed',
+            state: 'idle',
+        });
+    }
     ensureTurn() {
         if (!this.turnActive)
             this.startTurn();
@@ -2173,6 +2223,8 @@ export class StreamJsonOutput {
         this.textContentIndex = undefined;
         this.activeThinkingIndex = undefined;
         this.nextContentIndex = 0;
+        this.partialEvents = [];
+        this.pendingPartialStop = undefined;
     }
     startTurn() {
         if (this.turnActive)
@@ -2189,28 +2241,37 @@ export class StreamJsonOutput {
         this.textContentIndex = undefined;
         this.activeThinkingIndex = undefined;
         this.nextContentIndex = 0;
+        this.partialEvents = [];
+        this.pendingPartialStop = undefined;
         this.modelTurns += 1;
         if (this.includePartialMessages) {
             this.write({
-                type: 'stream_event',
-                event: {
-                    type: 'message_start',
-                    message: {
-                        id: this.turnId,
-                        type: 'message',
-                        role: 'assistant',
-                        model: this.info.model,
-                        content: [],
-                        stop_reason: null,
-                        stop_sequence: null,
-                        usage: { input_tokens: 0, output_tokens: 0 },
-                    },
-                },
-                parent_tool_use_id: null,
-                session_id: this.sessionId,
+                type: 'system',
+                subtype: 'status',
+                status: 'requesting',
             });
         }
     }
+    writePartialMessageStart() {
+        this.write({
+            type: 'stream_event',
+            event: {
+                type: 'message_start',
+                message: {
+                    id: this.turnId,
+                    type: 'message',
+                    role: 'assistant',
+                    model: this.info.model,
+                    content: [],
+                    stop_reason: null,
+                    stop_sequence: null,
+                    usage: { input_tokens: this.turnUsage.inputTokens, output_tokens: 0 },
+                },
+            },
+            parent_tool_use_id: null,
+            session_id: this.sessionId,
+        });
+    }
     partialText(delta) {
         if (!this.includePartialMessages)
             return;
@@ -2218,7 +2279,7 @@ export class StreamJsonOutput {
             this.contentStarted = true;
             this.textContentIndex = this.nextContentIndex;
             this.nextContentIndex += 1;
-            this.write({
+            this.beginPartialBlock({
                 type: 'stream_event',
                 event: {
                     type: 'content_block_start',
@@ -2227,9 +2288,14 @@ export class StreamJsonOutput {
                 },
                 parent_tool_use_id: null,
                 session_id: this.sessionId,
+            }, {
+                type: 'stream_event',
+                event: { type: 'content_block_stop', index: this.textContentIndex },
+                parent_tool_use_id: null,
+                session_id: this.sessionId,
             });
         }
-        this.write({
+        this.partialEvents.push({
             type: 'stream_event',
             event: {
                 type: 'content_block_delta',
@@ -2240,57 +2306,26 @@ export class StreamJsonOutput {
             session_id: this.sessionId,
         });
     }
+    beginPartialBlock(start, stop) {
+        if (this.pendingPartialStop)
+            this.partialEvents.push(this.pendingPartialStop);
+        this.pendingPartialStop = stop;
+        this.partialEvents.push(start);
+    }
     finishPartial() {
         if (!this.includePartialMessages)
             return;
-        if (this.contentStarted) {
-            this.write({
-                type: 'stream_event',
-                event: {
-                    type: 'content_block_stop',
-                    index: this.textContentIndex,
-                },
-                parent_tool_use_id: null,
-                session_id: this.sessionId,
-            });
-        }
-        for (const [toolIndex, call] of this.turnCalls.entries()) {
-            const index = this.nextContentIndex + toolIndex;
-            this.write({
-                type: 'stream_event',
-                event: {
-                    type: 'content_block_start',
-                    index,
-                    content_block: {
-                        type: 'tool_use',
-                        id: call.id,
-                        name: call.name,
-                        input: {},
-                    },
-                },
-                parent_tool_use_id: null,
-                session_id: this.sessionId,
-            });
-            this.write({
-                type: 'stream_event',
-                event: {
-                    type: 'content_block_delta',
-                    index,
-                    delta: {
-                        type: 'input_json_delta',
-                        partial_json: JSON.stringify(call.input),
-                    },
-                },
-                parent_tool_use_id: null,
-                session_id: this.sessionId,
-            });
-            this.write({
-                type: 'stream_event',
-                event: { type: 'content_block_stop', index },
-                parent_tool_use_id: null,
-                session_id: this.sessionId,
-            });
-        }
+        this.writePartialMessageStart();
+        for (const event of this.partialEvents)
+            this.write(event);
+        this.partialEvents = [];
+    }
+    finishPartialTail() {
+        if (!this.includePartialMessages)
+            return;
+        if (this.pendingPartialStop)
+            this.write(this.pendingPartialStop);
+        this.pendingPartialStop = undefined;
         this.write({
             type: 'stream_event',
             event: {
@@ -2341,12 +2376,13 @@ export class StreamJsonOutput {
                 stop_sequence: null,
                 usage: {
                     input_tokens: this.turnUsage.inputTokens,
-                    output_tokens: this.turnUsage.outputTokens,
+                    output_tokens: 0,
                 },
             },
             parent_tool_use_id: null,
             session_id: this.sessionId,
         });
+        this.finishPartialTail();
     }
     finishTurn() {
         this.flushAssistant();

package/dist/cli-runtime.js

@@ -5607,7 +5607,11 @@ async function execute(argv, io, dependencies, signal) {
             claudeCodeVersion: '2.1.208',
         };
         if (outputFormat === 'stream-json') {
-            const output = new StreamJsonOutput((value) => writeJson(io, value), info, sessionId, includePartialMessages, invocation.includeHookEvents);
+            const output = new StreamJsonOutput((value) => writeJson(io, value), info, sessionId, {
+                includePartialMessages,
+                includeHookEvents: invocation.includeHookEvents,
+                emitSessionStateEvents: process.env.CLAUDE_CODE_EMIT_SESSION_STATE_EVENTS === '1',
+            });
             output.init();
             output.sink({ type: 'text-delta', delta: text });
             output.sink({ type: 'usage', usage: result.usage });
@@ -5787,7 +5791,11 @@ async function execute(argv, io, dependencies, signal) {
         }
         let activeSessionId = existingSessionId ?? invocation.sessionId ?? randomUUID();
         if (outputFormat === 'stream-json' && !invocation.legacyJson) {
-            streamOutput = new StreamJsonOutput((value) => writeJson(io, value), runtimeInfo, activeSessionId, includePartialMessages, invocation.includeHookEvents);
+            streamOutput = new StreamJsonOutput((value) => writeJson(io, value), runtimeInfo, activeSessionId, {
+                includePartialMessages,
+                includeHookEvents: invocation.includeHookEvents,
+                emitSessionStateEvents: process.env.CLAUDE_CODE_EMIT_SESSION_STATE_EVENTS === '1',
+            });
         }
         if (streamInputExhausted)
             return 0;

package/package.json

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