@myagentroam/node 0.9.6 → 0.9.8

package/dist/connector.js

@@ -276,6 +276,7 @@ export class NodeConnector {
             setCommandState: (sessionId, state) => this.commandStates.set(sessionId, state),
             clearCommandState: (sessionId, commandId) => this.commandStates.clear(sessionId, commandId),
             commandStates: (sessionId) => this.commandStates.list(sessionId),
+            hasActiveSessionLease: (sessionId) => this.runtime.hasActiveSessionLease(sessionId),
             fast: (input) => this.executeNodeOperation('runner.command.execute', {
                 runner: 'codex',
                 commandId: 'fast',
@@ -489,7 +490,8 @@ export class NodeConnector {
             projection: this.nativeSessionProjectionService,
             resume: this.externalSessionResumeService,
             profiles: () => this.runnerService.profiles(),
-            present: (session) => this.sessionPresentationService.present(session)
+            present: (session) => this.sessionPresentationService.present(session),
+            resumeQueueAfterCommandRun: (sessionId) => this.workspaceQueueWorkbenchService.resumeAfterCommandRun(sessionId)
         });
         this.sessionMessageService = new SessionMessageService({
             runtime: this.runtime,

package/dist/runner/codex/conversation-parser.d.ts

@@ -1,7 +1,7 @@
 import type { NodeAgentSession, NodeConversationItem, NodeConversationTurn, NodeMessageAttachmentInput } from '../../database.js';
 export type PublicConversationItem = {
     readonly itemId: string;
-    readonly kind: 'reasoning_summary' | 'tool_call' | 'command_execution' | 'user_input_request' | 'plan' | 'context_compaction' | 'file_change' | 'error' | 'unknown';
+    readonly kind: 'assistant_message' | 'reasoning_summary' | 'tool_call' | 'command_execution' | 'user_input_request' | 'plan' | 'context_compaction' | 'file_change' | 'error' | 'unknown';
     readonly status: 'PENDING' | 'IN_PROGRESS' | 'COMPLETED' | 'FAILED' | 'DECLINED';
     readonly payload: Record<string, unknown>;
     readonly merge?: boolean;

package/dist/runner/codex/conversation-parser.js

@@ -1,5 +1,6 @@
 const MAX_COMPOSER_ATTACHMENT_BYTES = 5 * 1024 * 1024;
 const MAX_COMPOSER_ATTACHMENTS_BYTES = 10 * 1024 * 1024;
+const MAX_ASSISTANT_MESSAGE_CHARACTERS = 64 * 1024;
 export * from '../../util/runner-native-session-parsers.js';
 export function codexOfficialConversationPage(session, result, input, managedTurnForNative) {
     if (!isPlainRecord(result) || !isPlainRecord(result.thread))
@@ -43,7 +44,7 @@ export function codexOfficialTurn(session, value, sequence, managedTurn) {
         const officialNativeItemIds = codexNativeItemIds(value.items);
         const officialAssistantCount = items.filter((item) => item.kind === 'assistant_message').length;
         const officialAssistantMessage = officialAssistantCount > 0;
-        const managedAssistants = managedTurn.items.filter((item) => item.kind === 'assistant_message');
+        const managedAssistants = managedTurn.items.filter((item) => item.kind === 'assistant_message' && conversationItemNativeId(item.id) === undefined);
         const managedAssistantCandidates = officialAssistantCount === 0 ? [] : managedAssistants.slice(-officialAssistantCount);
         const assistantLength = (values) => values.reduce((length, item) => {
             if (item.kind !== 'assistant_message' || !isPlainRecord(item.payload))
@@ -108,6 +109,15 @@ export function codexOfficialTurn(session, value, sequence, managedTurn) {
                     replacement = officialAssistants.find((item) => !consumedOfficialIds.has(item.id));
             }
             if (replacement !== undefined) {
+                if (managedItem.kind === 'assistant_message' &&
+                    replacement.kind === 'assistant_message' &&
+                    (assistantLength([managedItem]) > assistantLength([replacement]) ||
+                        ((managedTurn.completedAt ?? 0) > (completedAt ?? 0) &&
+                            assistantLength([managedItem]) > 0))) {
+                    reconciledItems.push(managedItem);
+                    consumedOfficialIds.add(replacement.id);
+                    continue;
+                }
                 if (!consumedOfficialIds.has(replacement.id)) {
                     reconciledItems.push(replacement);
                     consumedOfficialIds.add(replacement.id);
@@ -504,6 +514,20 @@ export function codexLiveConversationItem(value, completed, imageAttachments = [
             status: completed ? 'COMPLETED' : 'IN_PROGRESS',
             payload: { explanation: compactRunnerText(planText, 20_000), steps: [] }
         };
+    if (value.type === 'agentMessage') {
+        if (!completed || typeof value.text !== 'string' || value.text.length === 0)
+            return undefined;
+        return {
+            itemId,
+            kind: 'assistant_message',
+            status: 'COMPLETED',
+            payload: {
+                text: compactRunnerText(value.text, MAX_ASSISTANT_MESSAGE_CHARACTERS),
+                format: 'markdown',
+                model: null
+            }
+        };
+    }
     if (value.type === 'commandExecution') {
         const output = typeof value.aggregatedOutput === 'string' ? value.aggregatedOutput : '';
         return {

package/dist/runner/codex/managed-run-controller.d.ts

@@ -53,7 +53,7 @@ export interface CodexManagedRunHost<TAttachment> {
     }): void;
     emitItem(runId: string, item: {
         readonly itemId: string;
-        readonly kind: 'reasoning_summary' | 'tool_call' | 'command_execution' | 'user_input_request' | 'plan' | 'context_compaction' | 'file_change' | 'error' | 'unknown';
+        readonly kind: 'reasoning_summary' | 'tool_call' | 'command_execution' | 'user_input_request' | 'assistant_message' | 'plan' | 'context_compaction' | 'file_change' | 'error' | 'unknown';
         readonly status: 'PENDING' | 'IN_PROGRESS' | 'COMPLETED' | 'FAILED' | 'DECLINED';
         readonly payload: Record<string, unknown>;
         readonly merge?: boolean;
@@ -65,6 +65,7 @@ export interface CodexManagedRunHost<TAttachment> {
     setCommandState(sessionId: string, state: RunnerCommandState): void;
     clearCommandState(sessionId: string, commandId: string): void;
     commandStates(sessionId: string): readonly RunnerCommandState[];
+    hasActiveSessionLease(sessionId: string): boolean;
     fast(input: string): Promise<unknown>;
 }
 export declare class CodexManagedRunController<TAttachment> {

package/dist/runner/codex/managed-run-controller.js

@@ -80,6 +80,8 @@ export class CodexManagedRunController {
         throw new Error('RUNNER_COMMAND_UNAVAILABLE');
     }
     async compact(session, threadId, runId) {
+        if (this.host.hasActiveSessionLease(session.id))
+            throw new Error('RUNNER_COMMAND_UNAVAILABLE');
         this.host.adopt({
             runId,
             sessionId: session.id,
@@ -153,7 +155,13 @@ export class CodexManagedRunController {
             return;
         }
         if (notification.method === 'item/agentMessage/delta' && typeof params.delta === 'string') {
-            this.host.emit(runId, 'text.delta', { text: params.delta });
+            const itemId = typeof params.itemId === 'string'
+                ? boundedConversationItemId('codex', params.itemId)
+                : undefined;
+            this.host.emit(runId, 'text.delta', {
+                text: params.delta,
+                ...(itemId === undefined ? {} : { itemId })
+            });
             return;
         }
         if (notification.method === 'item/reasoning/summaryTextDelta' &&

package/dist/runner/opencode/conversation-parser.js

@@ -1,4 +1,5 @@
 import { boundedConversationItemId, compactRunnerText, compactRunnerValue } from '../codex/conversation-parser.js';
+import { runtimeAssistantProjectionMoreComplete } from '../../util/runner-native-session-parsers.js';
 export function openCodeConversationPage(session, messages, input, managedTurn) {
     const records = messages.flatMap((value) => {
         const entry = record(value);
@@ -63,6 +64,9 @@ function openCodeTurn(session, user, userParts, assistants, sequence, managed) {
     const completedAt = Math.max(startedAt ?? 0, ...assistants.map(({ info }) => number(record(info.time)?.completed) ?? 0)) || startedAt;
     const id = managed?.id ?? `${session.id}:official:${nativeTurnId}`;
     const runId = managed?.runId ?? null;
+    const projectedItems = runtimeAssistantProjectionMoreComplete(managed, items)
+        ? managed.items
+        : items;
     return {
         id,
         sessionId: session.id,
@@ -72,7 +76,7 @@ function openCodeTurn(session, user, userParts, assistants, sequence, managed) {
         model: assistants.find(({ info }) => typeof info.modelID === 'string')?.info.modelID ?? null,
         effort: managed?.effort ?? null,
         access: managed?.access ?? null,
-        items: items.map((value) => ({ ...value, turnId: id, runId })),
+        items: projectedItems.map((value) => ({ ...value, turnId: id, runId })),
         startedAt,
         completedAt
     };

package/dist/runtime-state.js

@@ -630,7 +630,13 @@ export class NodeRuntimeState {
         }
         this.runs.delete(runId);
         this.events.delete(runId);
-        const turns = this.turns.get(run.sessionId) ?? [];
+        const turns = (this.turns.get(run.sessionId) ?? []).filter((turn) => {
+            const hasVisibleError = turn.items.some((item) => item.kind === 'error');
+            if (turn.runId === runId)
+                return run.status === 'SUCCEEDED' || run.status === 'INTERRUPTED' || hasVisibleError;
+            const isTransientErrorTurn = hasVisibleError && turn.status !== 'SUCCEEDED' && turn.status !== 'INTERRUPTED';
+            return run.status !== 'SUCCEEDED' || !isTransientErrorTurn;
+        });
         const completed = turns.filter((turn) => terminalTurn(turn.status));
         const retainedCompleted = new Set(completed.slice(-NodeRuntimeState.MAX_COMPLETED_TURNS_PER_SESSION).map((turn) => turn.id));
         this.turns.set(run.sessionId, turns.filter((turn) => !terminalTurn(turn.status) || retainedCompleted.has(turn.id)));
@@ -742,13 +748,19 @@ export class NodeRuntimeState {
             if (event.eventType === 'text.delta' &&
                 isRecord(event.payload) &&
                 typeof event.payload.text === 'string') {
-                const lastItem = turn.items.at(-1);
-                const existing = lastItem?.kind === 'assistant_message' && activeConversationItem(lastItem.status)
-                    ? lastItem
+                const nativeItemId = typeof event.payload.itemId === 'string' && event.payload.itemId.length <= 88
+                    ? event.payload.itemId
                     : undefined;
+                const stableItemId = nativeItemId === undefined ? undefined : `${event.runId}:${nativeItemId}`;
+                const lastItem = turn.items.at(-1);
+                const existing = stableItemId === undefined
+                    ? lastItem?.kind === 'assistant_message' && activeConversationItem(lastItem.status)
+                        ? lastItem
+                        : undefined
+                    : turn.items.find((item) => item.id === stableItemId && item.kind === 'assistant_message');
                 const text = `${existing === undefined ? '' : readableText(existing.payload)}${event.payload.text}`;
                 const item = {
-                    id: existing?.id ?? `${event.runId}:assistant:${event.sequence}`,
+                    id: existing?.id ?? stableItemId ?? `${event.runId}:assistant:${event.sequence}`,
                     sessionId: run.sessionId,
                     turnId: turn.id,
                     runId: event.runId,
@@ -829,7 +841,7 @@ function terminal(status) {
     return ['SUCCEEDED', 'FAILED', 'CANCELLED', 'INTERRUPTED', 'LOST'].includes(status);
 }
 function terminalTurn(status) {
-    return ['SUCCEEDED', 'FAILED', 'CANCELLED', 'INTERRUPTED'].includes(status);
+    return ['SUCCEEDED', 'FAILED', 'CANCELLED', 'INTERRUPTED', 'LOST'].includes(status);
 }
 function transitionAllowed(from, to) {
     return !terminal(from) || from === to;
@@ -869,7 +881,8 @@ function conversationItemFromEvent(event) {
     };
 }
 function projectableConversationKind(value) {
-    return (value === 'reasoning_summary' ||
+    return (value === 'assistant_message' ||
+        value === 'reasoning_summary' ||
         value === 'tool_call' ||
         value === 'command_execution' ||
         value === 'user_input_request' ||

package/dist/service/run-event-service.js

@@ -14,7 +14,7 @@ export class RunEventService {
             status === undefined &&
             isPlainRecord(payload) &&
             typeof payload.text === 'string') {
-            this.enqueueText(runId, payload.text);
+            this.enqueueText(runId, payload.text, typeof payload.itemId === 'string' ? payload.itemId : undefined);
             return;
         }
         this.flushText(runId);
@@ -28,18 +28,20 @@ export class RunEventService {
     flushPendingText(runId) {
         this.flushText(runId);
     }
-    enqueueText(runId, text) {
+    enqueueText(runId, text, itemId) {
         if (text.length === 0)
             return;
         const pending = this.pendingText.get(runId);
-        if (pending !== undefined) {
+        if (pending !== undefined && pending.itemId === itemId) {
             pending.text += text;
             if (pending.text.length >= MAX_BATCH_CHARS)
                 this.flushText(runId);
             return;
         }
+        if (pending !== undefined)
+            this.flushText(runId);
         const timer = setTimeout(() => this.flushText(runId), COALESCE_MS);
-        this.pendingText.set(runId, { text, timer });
+        this.pendingText.set(runId, { text, ...(itemId === undefined ? {} : { itemId }), timer });
     }
     flushText(runId) {
         const pending = this.pendingText.get(runId);
@@ -47,7 +49,10 @@ export class RunEventService {
             return;
         clearTimeout(pending.timer);
         this.pendingText.delete(runId);
-        this.emitNow(runId, 'text.delta', { text: pending.text });
+        this.emitNow(runId, 'text.delta', {
+            text: pending.text,
+            ...(pending.itemId === undefined ? {} : { itemId: pending.itemId })
+        });
     }
     emitNow(runId, eventType, payload, status) {
         if (this.options.runtime.getRun(runId) === undefined)

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

@@ -12,6 +12,7 @@ interface SessionCommandServiceOptions {
     readonly resume: ExternalSessionResumeService;
     readonly profiles: () => readonly RunnerProfile[];
     readonly present: (session: NodeAgentSession) => unknown;
+    readonly resumeQueueAfterCommandRun: (sessionId: string) => void;
 }
 export declare class SessionCommandService {
     private readonly options;

package/dist/service/session-command-service.js

@@ -48,6 +48,9 @@ export class SessionCommandService {
             ?.commands.find((candidate) => isPlainRecord(candidate) && candidate.id === input.commandId);
         if (command?.available !== true)
             throw new Error('RUNNER_COMMAND_UNAVAILABLE');
+        if (command.interaction === 'IMMEDIATE_ACTION' &&
+            this.options.runtime.hasActiveSessionLease(session.id))
+            throw new Error('RUNNER_COMMAND_UNAVAILABLE');
         const invocation = parseCommandInvocation({ descriptor: command }, input.input);
         const secretEnvironment = parseSecretEnvironment(input.secretEnvironment);
         const runner = this.options.runners.product(session.runner);
@@ -56,6 +59,10 @@ export class SessionCommandService {
         const result = await runner.executeCommand(session, command, invocation.input, {
             secretEnvironment
         });
+        if (command.interaction === 'IMMEDIATE_ACTION' &&
+            isPlainRecord(result) &&
+            isPlainRecord(result.run))
+            this.options.resumeQueueAfterCommandRun(session.id);
         return {
             ...(isPlainRecord(result) ? result : { result }),
             session: this.options.present(session)

package/dist/service/workspace-queue-workbench-service.d.ts

@@ -66,6 +66,7 @@ export declare class WorkspaceQueueWorkbenchService<TAttachment> {
     migrateSession(previousId: string, nextId: string): void;
     cancelQueued(runId: string): void;
     pauseForInterrupt(sessionId: string): void;
+    resumeAfterCommandRun(sessionId: string): void;
     operations(): Readonly<Record<string, NodeOperationHandler>>;
     private get;
     private pauseOrResume;

package/dist/service/workspace-queue-workbench-service.js

@@ -64,6 +64,16 @@ export class WorkspaceQueueWorkbenchService {
         this.options.runtime.pauseSessionQueue(session.id);
         this.publish(session.id);
     }
+    resumeAfterCommandRun(sessionId) {
+        const session = this.options.runtime.getAgentSession(sessionId);
+        if (session === undefined)
+            throw new Error('SESSION_NOT_FOUND');
+        if (!this.options.runtime.sessionQueue(session.id).paused)
+            return;
+        this.options.runtime.resumeSessionQueue(session.id);
+        this.publish(session.id);
+        this.schedule(session.id);
+    }
     operations() {
         return {
             'workspace.queue.get': (data) => this.get(record(data)),

package/dist/util/runner-native-session-parsers.d.ts

@@ -1,5 +1,5 @@
 import type { SessionActivityState } from '@myagentroam/protocol';
-import type { NodeAgentSession, NodeConversationTurn } from '../database.js';
+import type { NodeAgentSession, NodeConversationItem, NodeConversationTurn } from '../database.js';
 import type { NativeSessionHistory, NativeTranscriptImageAttachment } from '../native-session-history.js';
 export interface SessionContextUsage {
     readonly model: string | null;
@@ -46,6 +46,7 @@ export declare function nativeConversationPage(session: NodeAgentSession, histor
     readonly turns: readonly NodeConversationTurn[];
     readonly nextCursor: string | null;
 };
+export declare function runtimeAssistantProjectionMoreComplete(runtimeTurn: NodeConversationTurn | undefined, projectedItems: readonly NodeConversationItem[]): boolean;
 /**
  * Claude JSONL does not retain browser request IDs. While the Node process is alive, match current
  * runtime user messages by content and creation time so native history replaces the optimistic Turn.

package/dist/util/runner-native-session-parsers.js

@@ -156,19 +156,6 @@ export function nativeConversationPage(session, history, input, runtimeTurns = [
     const effectiveCursor = history.cursorReset === true ? undefined : input.cursor;
     const nativeTurns = nativeTranscriptTurns(history.items);
     const nativeTurnIds = nativeTranscriptTurnIds(session.id, nativeTurns);
-    const representedClientMessageIds = new Set(nativeTurns.flatMap((entries) => entries.flatMap(({ entry, index }) => {
-        if (entry.kind !== 'message' || entry.role !== 'USER')
-            return [];
-        const clientMessageId = nativeUserClientMessageId(entry, entry.createdAt ?? index, runtimeTurns);
-        return clientMessageId === null ? [] : [clientMessageId];
-    })));
-    const missingRuntimeErrorTurns = effectiveCursor === undefined
-        ? runtimeTurns.filter((turn) => {
-            const clientMessageId = runtimeTurnClientMessageId(turn);
-            return (turn.items.some((item) => item.kind === 'error') &&
-                (clientMessageId === undefined || !representedClientMessageIds.has(clientMessageId)));
-        })
-        : [];
     const end = nativePageEnd(effectiveCursor, session.id, nativeTurns.length);
     const start = Math.max(0, end - limit);
     const nativePageTurns = nativeTurns
@@ -190,10 +177,16 @@ export function nativeConversationPage(session, history, input, runtimeTurns = [
         const runtimeErrors = (runtimeTurn?.items ?? [])
             .filter((item) => item.kind === 'error')
             .map((item) => ({ ...item, turnId, runId: runtimeTurn?.runId ?? null }));
-        const items = [
-            ...nativeItems,
-            ...runtimeErrors.filter((error) => !nativeItems.some((item) => item.id === error.id))
-        ];
+        const items = runtimeAssistantProjectionMoreComplete(runtimeTurn, nativeItems)
+            ? runtimeTurn.items.map((item) => ({
+                ...item,
+                turnId,
+                runId: runtimeTurn.runId
+            }))
+            : [
+                ...nativeItems,
+                ...runtimeErrors.filter((error) => !nativeItems.some((item) => item.id === error.id))
+            ];
         const startedAt = items[0]?.startedAt ?? null;
         const completedAt = items.at(-1)?.completedAt ?? startedAt;
         const after = lastNativeItemId(entries);
@@ -219,11 +212,8 @@ export function nativeConversationPage(session, history, input, runtimeTurns = [
             completedAt
         };
     });
-    const combined = [...nativePageTurns, ...missingRuntimeErrorTurns];
-    const dropped = combined.slice(0, Math.max(0, combined.length - limit));
-    const turns = combined.slice(-limit);
-    const nativePageIds = new Set(nativePageTurns.map((turn) => turn.id));
-    const nextEnd = start + dropped.filter((turn) => nativePageIds.has(turn.id)).length;
+    const turns = nativePageTurns;
+    const nextEnd = start;
     const cursorBase = {
         sessionId: session.id,
         ...(history.snapshotEnd === undefined ? {} : { snapshotEnd: history.snapshotEnd }),
@@ -253,6 +243,22 @@ export function nativeConversationPage(session, history, input, runtimeTurns = [
             : precedingWindow
     };
 }
+export function runtimeAssistantProjectionMoreComplete(runtimeTurn, projectedItems) {
+    if (runtimeTurn === undefined)
+        return false;
+    const assistantStats = (items) => items.reduce((stats, item) => {
+        if (item.kind !== 'assistant_message' || !isPlainRecord(item.payload))
+            return stats;
+        return {
+            count: stats.count + 1,
+            characters: stats.characters +
+                (typeof item.payload.text === 'string' ? item.payload.text.length : 0)
+        };
+    }, { count: 0, characters: 0 });
+    const runtime = assistantStats(runtimeTurn.items);
+    const projected = assistantStats(projectedItems);
+    return runtime.count > projected.count || runtime.characters > projected.characters;
+}
 function runtimeTurnClientMessageId(turn) {
     const user = turn.items.find((item) => item.kind === 'user_message');
     return isPlainRecord(user?.payload) && typeof user.payload.clientMessageId === 'string'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/node",
-  "version": "0.9.6",
+  "version": "0.9.8",
   "description": "MyAgentRoam Node runtime CLI.",
   "type": "module",
   "files": [
@@ -24,7 +24,7 @@
     "node-pty": "1.1.0",
     "ws": "^8.21.3",
     "zod": "4.4.3",
-    "@myagentroam/protocol": "^0.9.6"
+    "@myagentroam/protocol": "^0.9.8"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"