remote-codex 0.1.9 → 0.11.0

package/packages/codex/src/appServerManager.ts

@@ -52,8 +52,15 @@ function mapThread(record: any): CodexThreadRecord {
     status: record.status,
     cwd: record.cwd,
     name: record.name ?? null,
+    totalTurnCount: typeof record.totalTurnCount === 'number'
+      ? record.totalTurnCount
+      : typeof record.total_turn_count === 'number'
+        ? record.total_turn_count
+        : typeof record.turnsTotal === 'number'
+          ? record.turnsTotal
+          : null,
     turns: Array.isArray(record.turns) ? record.turns.map(mapTurn) : []
-  };
+  } as CodexThreadRecord;
 }
 
 function mapTurn(record: any): CodexTurnRecord {
@@ -395,11 +402,13 @@ export class CodexAppServerManager extends EventEmitter {
     };
   }
 
-  async readThread(threadId: string) {
+  async readThread(threadId: string, input: { limit?: number; beforeTurnId?: string | null } = {}) {
     await this.ensureReady();
     const response = await this.client!.request<{ thread: any }>('thread/read', {
       threadId,
-      includeTurns: true
+      includeTurns: true,
+      ...(input.limit !== undefined ? { limit: input.limit } : {}),
+      ...(input.beforeTurnId ? { beforeTurnId: input.beforeTurnId } : {}),
     });
     return mapThread(response.thread);
   }

package/packages/codex/src/historyItems.test.ts

@@ -0,0 +1,110 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  markTransientAgentHistoryItem,
+  type AgentHistoryItem,
+} from '../../agent-runtime/src/index';
+import {
+  agentTurnToThreadTurnDto,
+  codexTurnToAgentTurn,
+  liveCodexItemToHistoryItem,
+  shouldPersistLiveHistoryItem,
+  shouldPersistRuntimeFinalHistoryItem,
+} from './historyItems';
+
+describe('codex history item persistence policy', () => {
+  it('keeps streamed assistant text out of live history persistence', () => {
+    expect(
+      shouldPersistLiveHistoryItem({
+        id: 'agent-live-1',
+        kind: 'agentMessage',
+        text: 'Streaming draft',
+      }),
+    ).toBe(false);
+  });
+
+  it('keeps transient streamed assistant text out of final runtime persistence', () => {
+    const transientMessage = markTransientAgentHistoryItem<AgentHistoryItem>({
+      id: 'agent-live-1',
+      kind: 'agentMessage',
+      text: 'Streaming draft',
+    });
+
+    expect(shouldPersistRuntimeFinalHistoryItem(transientMessage, [transientMessage])).toBe(
+      false,
+    );
+  });
+
+  it('hides transient streamed assistant text once a final assistant message exists', () => {
+    const transientMessage = markTransientAgentHistoryItem<AgentHistoryItem>({
+      id: 'agent-live-1',
+      kind: 'agentMessage',
+      text: 'Streaming draft',
+    });
+    const finalMessage: AgentHistoryItem = {
+      id: 'agent-final-1',
+      kind: 'agentMessage',
+      text: 'Final answer',
+    };
+
+    expect(
+      agentTurnToThreadTurnDto({
+        providerTurnId: 'turn-1',
+        status: 'completed',
+        error: null,
+        items: [transientMessage, finalMessage],
+      }).items,
+    ).toEqual([finalMessage]);
+  });
+
+  it('maps Codex collab agent tool calls to dedicated agent tool call items', () => {
+    const turn = codexTurnToAgentTurn({
+      id: 'turn-1',
+      status: 'inProgress',
+      error: null,
+      items: [
+        {
+          id: 'agent-tool-1',
+          type: 'collabAgentToolCall',
+          status: 'running',
+          action: {
+            name: 'Review checkout flow',
+            input: {
+              prompt: 'Inspect checkout UI regressions.',
+            },
+          },
+        },
+      ],
+    });
+
+    expect(turn.items[0]).toMatchObject({
+      id: 'agent-tool-1',
+      kind: 'agentToolCall',
+      text: 'Agent: Review checkout flow',
+      previewText: 'Agent',
+      status: 'running',
+    });
+  });
+
+  it('keeps Codex collab agent tool calls visible while running', () => {
+    expect(
+      liveCodexItemToHistoryItem(
+        {
+          id: 'agent-tool-1',
+          type: 'collabAgentToolCall',
+          status: 'running',
+          action: {
+            name: 'Inspect backend runtime boundaries',
+          },
+        },
+        'started',
+      ),
+    ).toMatchObject({
+      id: 'agent-tool-1',
+      kind: 'agentToolCall',
+      text: 'Agent: Inspect backend runtime boundaries',
+      previewText: 'Agent',
+      status: 'running',
+    });
+  });
+});

package/packages/codex/src/historyItems.ts

@@ -3,6 +3,7 @@ import type {
   CodexTurnItem,
 } from './types';
 import type { AgentTurn } from '../../agent-runtime/src/index';
+import { isTransientAgentHistoryItem } from '../../agent-runtime/src/index';
 import type {
   ThreadHistoryItemDetailDto,
   ThreadHistoryItemDto,
@@ -13,6 +14,7 @@ import { parseCodexHookPromptText } from './hookHistory';
 
 const DEFERRED_COMMAND_DETAIL_TITLE = 'Command Output';
 const DEFERRED_TOOL_DETAIL_TITLE = 'Tool Call Details';
+const DEFERRED_AGENT_TOOL_DETAIL_TITLE = 'Agent Details';
 
 export type TurnItemOrderSnapshot = Map<string, Map<string, number>>;
 
@@ -213,14 +215,19 @@ function formatCommandHistoryItem(
 }
 
 function deferToolCallHistoryItem(
-  item: ThreadHistoryItemDto & { kind: 'toolCall' },
+  item: ThreadHistoryItemDto & { kind: 'toolCall' | 'agentToolCall' | 'skillToolCall' },
   deferredDetails: Map<string, ThreadHistoryItemDetailDto>,
 ): ThreadHistoryItemDto {
   const fullText = item.detailText?.trim() || item.text || 'Tool call';
   deferredDetails.set(item.id, {
     id: item.id,
     kind: item.kind,
-    title: DEFERRED_TOOL_DETAIL_TITLE,
+    title:
+      item.kind === 'agentToolCall'
+        ? DEFERRED_AGENT_TOOL_DETAIL_TITLE
+        : item.kind === 'skillToolCall'
+          ? 'Skill Details'
+          : DEFERRED_TOOL_DETAIL_TITLE,
     text: fullText,
   });
 
@@ -267,6 +274,7 @@ function valueFromNestedRecords(
 function formatToolCallHistoryItem(
   item: CodexTurnItem,
   deferredDetails?: Map<string, ThreadHistoryItemDetailDto>,
+  kind: 'toolCall' | 'agentToolCall' | 'skillToolCall' = 'toolCall',
 ): ThreadHistoryItemDto {
   const { action, result, input, output } = extractToolCallRecords(item);
   const nestedRecords = [item, action, result, input, output];
@@ -295,14 +303,18 @@ function formatToolCallHistoryItem(
   const summaryLine = serverName && toolName
     ? `${serverName}/${toolName}`
     : toolName ?? serverName ?? stringOrNull(item.text) ?? item.type;
+  const displaySummary =
+    kind === 'agentToolCall' && !/^agent\b/i.test(summaryLine)
+      ? `Agent: ${summaryLine}`
+      : summaryLine;
 
-  const detailLines = [summaryLine];
+  const detailLines = [displaySummary];
   if (status) {
     detailLines.push(`Status: ${status}`);
   }
 
   const text = stringOrNull(item.text);
-  if (text && text !== summaryLine) {
+  if (text && text !== summaryLine && text !== displaySummary) {
     detailLines.push('', text);
   }
 
@@ -320,9 +332,9 @@ function formatToolCallHistoryItem(
 
   const historyItem: ThreadHistoryItemDto = {
     id: item.id,
-    kind: 'toolCall',
-    text: summaryLine,
-    previewText: summaryLine,
+    kind,
+    text: displaySummary,
+    previewText: kind === 'agentToolCall' ? 'Agent' : displaySummary,
     detailText: detailLines.join('\n'),
     status,
   };
@@ -334,7 +346,9 @@ function formatToolCallHistoryItem(
       (historyItem.detailText?.length ?? 0) > 240)
   ) {
     return deferToolCallHistoryItem(
-      historyItem as ThreadHistoryItemDto & { kind: 'toolCall' },
+      historyItem as ThreadHistoryItemDto & {
+        kind: 'toolCall' | 'agentToolCall' | 'skillToolCall';
+      },
       deferredDetails,
     );
   }
@@ -355,8 +369,12 @@ export function deferLargeHistoryItemDetails(
             deferredDetails,
           )
         : item.kind === 'toolCall'
+          || item.kind === 'agentToolCall'
+          || item.kind === 'skillToolCall'
           ? deferToolCallHistoryItem(
-              item as ThreadHistoryItemDto & { kind: 'toolCall' },
+              item as ThreadHistoryItemDto & {
+                kind: 'toolCall' | 'agentToolCall' | 'skillToolCall';
+              },
               deferredDetails,
             )
         : item,
@@ -366,15 +384,45 @@ export function deferLargeHistoryItemDetails(
 
 export function shouldPersistLiveHistoryItem(item: ThreadHistoryItemDto) {
   return (
-    item.kind === 'agentMessage' ||
     item.kind === 'commandExecution' ||
     item.kind === 'fileChange' ||
+    item.kind === 'fileRead' ||
     item.kind === 'hook' ||
+    item.kind === 'agentToolCall' ||
+    item.kind === 'skillToolCall' ||
     item.kind === 'toolCall' ||
     item.kind === 'webSearch'
   );
 }
 
+export function shouldPersistFinalHistoryItem(item: ThreadHistoryItemDto) {
+  return item.kind === 'agentMessage' || shouldPersistLiveHistoryItem(item);
+}
+
+export function shouldPersistRuntimeFinalHistoryItem(
+  item: ThreadHistoryItemDto,
+  allItems: ThreadHistoryItemDto[],
+) {
+  if (item.kind === 'agentMessage' && isTransientAgentHistoryItem(item)) {
+    return false;
+  }
+
+  return shouldPersistFinalHistoryItem(item);
+}
+
+function visibleRuntimeTurnItems(items: ThreadHistoryItemDto[]) {
+  const hasFinalAgentMessage = items.some(
+    (item) => item.kind === 'agentMessage' && !isTransientAgentHistoryItem(item),
+  );
+  if (!hasFinalAgentMessage) {
+    return items;
+  }
+
+  return items.filter(
+    (item) => !(item.kind === 'agentMessage' && isTransientAgentHistoryItem(item)),
+  );
+}
+
 export function parseStoredHistoryItem(value: string): ThreadHistoryItemDto | null {
   try {
     const parsed = JSON.parse(value);
@@ -562,6 +610,24 @@ function copyPersistedSequence(
   return item.sequence === sequence ? item : { ...item, sequence };
 }
 
+function shouldAppendPersistedMissingItem(
+  turn: ThreadTurnDto,
+  item: ThreadHistoryItemDto,
+) {
+  if (item.kind !== 'agentMessage') {
+    return true;
+  }
+
+  // Older builds persisted streaming assistant drafts. Once the provider
+  // transcript has final assistant text, do not resurrect those draft rows.
+  const isCrossTurnProjection = Boolean(item.sourceTurnId && item.sourceTurnId !== turn.id);
+  return !(
+    turn.status === 'completed' &&
+    turn.items.some((turnItem) => turnItem.kind === 'agentMessage') &&
+    !isCrossTurnProjection
+  );
+}
+
 export function mergePersistedHistoryItemsIntoTurns(
   turns: ThreadTurnDto[],
   persistedItemsByTurnId: Map<string, ThreadHistoryItemDto[]>,
@@ -596,7 +662,12 @@ export function mergePersistedHistoryItemsIntoTurns(
         changed = true;
       }
 
-      if (persistedItem.kind === 'commandExecution' || persistedItem.kind === 'toolCall') {
+      if (
+        persistedItem.kind === 'commandExecution' ||
+        persistedItem.kind === 'toolCall' ||
+        persistedItem.kind === 'agentToolCall' ||
+        persistedItem.kind === 'skillToolCall'
+      ) {
         const existingText = item.detailText?.trim() || item.text.trim();
         const persistedText = persistedItem.detailText?.trim() || persistedItem.text.trim();
         if (persistedText.length > existingText.length) {
@@ -607,7 +678,9 @@ export function mergePersistedHistoryItemsIntoTurns(
                 deferredDetails,
               )
             : deferToolCallHistoryItem(
-                persistedItem as ThreadHistoryItemDto & { kind: 'toolCall' },
+                persistedItem as ThreadHistoryItemDto & {
+                  kind: 'toolCall' | 'agentToolCall' | 'skillToolCall';
+                },
                 deferredDetails,
               );
         }
@@ -619,6 +692,7 @@ export function mergePersistedHistoryItemsIntoTurns(
     const existingItemIds = new Set(nextItems.map((item) => item.id));
     const missingItems = [...persistedItemsById.values()]
       .filter((item) => !existingItemIds.has(item.id))
+      .filter((item) => shouldAppendPersistedMissingItem(turn, item))
       .map((item) =>
         item.kind === 'commandExecution'
           ? deferCommandHistoryItem(
@@ -626,8 +700,12 @@ export function mergePersistedHistoryItemsIntoTurns(
               deferredDetails,
             )
           : item.kind === 'toolCall'
+            || item.kind === 'agentToolCall'
+            || item.kind === 'skillToolCall'
             ? deferToolCallHistoryItem(
-                item as ThreadHistoryItemDto & { kind: 'toolCall' },
+                item as ThreadHistoryItemDto & {
+                  kind: 'toolCall' | 'agentToolCall' | 'skillToolCall';
+                },
                 deferredDetails,
               )
             : item,
@@ -1175,8 +1253,9 @@ function itemToHistoryItem(
       return formatFileChangeHistoryItem(item);
     case 'mcpToolCall':
     case 'dynamicToolCall':
-    case 'collabAgentToolCall':
       return formatToolCallHistoryItem(item, deferredDetails);
+    case 'collabAgentToolCall':
+      return formatToolCallHistoryItem(item, deferredDetails, 'agentToolCall');
     default:
       return {
         id: item.id,
@@ -1195,6 +1274,8 @@ export function liveCodexItemToHistoryItem(
   if (
     historyItem.kind !== 'commandExecution' &&
     historyItem.kind !== 'toolCall' &&
+    historyItem.kind !== 'agentToolCall' &&
+    historyItem.kind !== 'skillToolCall' &&
     historyItem.kind !== 'fileChange' &&
     historyItem.kind !== 'webSearch'
   ) {
@@ -1215,10 +1296,10 @@ export function agentTurnToThreadTurnDto(
 ): ThreadTurnDto {
   const baseTurn: ThreadTurnDto = {
     id: turn.providerTurnId,
-    startedAt: parseUuidV7Timestamp(turn.providerTurnId),
+    startedAt: turn.startedAt ?? parseUuidV7Timestamp(turn.providerTurnId),
     status: turn.status,
     error: turn.error?.message ?? null,
-    items: turn.items,
+    items: visibleRuntimeTurnItems(turn.items),
   };
 
   return deferredDetails ? deferLargeHistoryItemDetails(baseTurn, deferredDetails) : baseTurn;

package/packages/codex/src/hookHistory.test.ts

@@ -0,0 +1,59 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  codexHookRunToHistoryItem,
+  parseCodexHookPromptText,
+} from './index';
+
+describe('codex hook history mapping', () => {
+  it('parses hook prompt XML emitted as assistant text', () => {
+    expect(
+      parseCodexHookPromptText(
+        '<hook_prompt hook_run_id="stop:0:/tmp/demo/.codex/hooks.json">remote-codex hook ran</hook_prompt>',
+      ),
+    ).toMatchObject({
+      hookRunId: 'stop:0:/tmp/demo/.codex/hooks.json',
+      output: 'remote-codex hook ran',
+      eventName: 'stop',
+      eventLabel: 'Stop',
+      sourcePath: '/tmp/demo/.codex/hooks.json',
+      outputEntries: [{ kind: 'warning', text: 'remote-codex hook ran' }],
+    });
+  });
+
+  it('maps Codex hook runs into provider-neutral history items', () => {
+    expect(
+      codexHookRunToHistoryItem({
+        id: 'run-1',
+        eventName: 'preToolUse',
+        handlerType: 'command',
+        executionMode: 'blocking',
+        scope: 'project',
+        sourcePath: '/tmp/demo/.codex/hooks.json',
+        source: 'project',
+        status: 'completed',
+        statusMessage: 'Checking Bash',
+        durationMs: 42,
+        outputEntries: [{ kind: 'context', text: 'allowed' }],
+        stderr: 'diagnostic',
+      }),
+    ).toMatchObject({
+      id: 'hook:run-1',
+      kind: 'hook',
+      text: 'PreToolUse hook',
+      previewText: 'Checking Bash',
+      status: 'Completed',
+      hookEventName: 'preToolUse',
+      hookEventLabel: 'PreToolUse',
+      hookHandlerType: 'command',
+      hookScope: 'project',
+      hookSource: 'project',
+      hookSourcePath: '/tmp/demo/.codex/hooks.json',
+      hookStatusMessage: 'Checking Bash',
+      hookOutputEntries: [
+        { kind: 'context', text: 'allowed' },
+        { kind: 'warning', text: 'diagnostic' },
+      ],
+    });
+  });
+});

package/packages/codex/src/index.ts

@@ -2,5 +2,12 @@ export * from './appServerManager';
 export * from './historyItems';
 export * from './hookHistory';
 export * from './jsonrpc';
+export * from './local-session-store';
+export * from './management/codex-management-service';
+export * from './management/codexHostConfig';
+export * from './management/errors';
+export * from './modelPricing';
+export * from './runtime-errors';
 export * from './runtimeAdapter';
+export * from './thread-title';
 export * from './types';