[Init] Initial commit - NetMesh terminal manager

infrastructure/ai/harness/turnDrivers/externalSdkTurnDriver.test.ts

@@ -0,0 +1,491 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import type { AISession, AgentActivity, ChatMessage, ExternalAgentConfig } from '../../types';
+import { SessionStateStore } from '../sessionState';
+import { ToolOutputStore } from '../toolOutputStore';
+import { ToolResultDedup } from '../toolResultDedup';
+import { externalSdkTurnDriver } from './externalSdkTurnDriver';
+import { resolveEstimatedUsageFallback, upsertAgentActivity } from './externalSdkEventState';
+import type { TurnUiCallbacks } from './types';
+
+async function waitFor(predicate: () => boolean): Promise<void> {
+  for (let index = 0; index < 50; index += 1) {
+    if (predicate()) return;
+    await new Promise<void>(resolve => setImmediate(resolve));
+  }
+  throw new Error('condition not reached');
+}
+
+test('upsertAgentActivity replaces streaming updates by stable item id', () => {
+  const running: AgentActivity = {
+    id: 'plan-1',
+    type: 'plan_update',
+    status: 'running',
+    items: [{ text: 'Map events', completed: false }],
+  };
+  const completed: AgentActivity = {
+    ...running,
+    status: 'completed',
+    items: [{ text: 'Map events', completed: true }],
+  };
+
+  const first = upsertAgentActivity(undefined, running);
+  const second = upsertAgentActivity(first, completed);
+
+  assert.equal(second.length, 1);
+  assert.deepEqual(second[0], completed);
+});
+
+test('upsertAgentActivity preserves the order of unrelated activities', () => {
+  const search: AgentActivity = {
+    id: 'search-1',
+    type: 'web_search',
+    status: 'completed',
+    query: 'Codex events',
+  };
+  const warning: AgentActivity = {
+    id: 'warning-1',
+    type: 'warning',
+    status: 'completed',
+    message: 'Search result unavailable',
+  };
+
+  assert.deepEqual(upsertAgentActivity([search], warning), [search, warning]);
+});
+
+test('estimated usage is used only when the SDK did not report actual usage', () => {
+  assert.deepEqual(resolveEstimatedUsageFallback('12345678', false), {
+    inputTokens: 2,
+    outputTokens: 0,
+    totalTokens: 2,
+    estimated: true,
+  });
+  assert.equal(resolveEstimatedUsageFallback('12345678', true), null);
+});
+
+test('plan updates replace the same activity across tool message boundaries', async () => {
+  let onEvent: ((event: Record<string, unknown>) => void) | undefined;
+  let onDone: (() => void) | undefined;
+  const bridge: Record<string, (...args: unknown[]) => unknown> = {
+    onAiSdkAgentEvent: (_requestId, callback) => {
+      onEvent = callback as (event: Record<string, unknown>) => void;
+      return () => {};
+    },
+    onAiSdkAgentDone: (_requestId, callback) => {
+      onDone = callback as () => void;
+      return () => {};
+    },
+    onAiSdkAgentError: () => () => {},
+    aiSdkAgentCancel: async () => ({ ok: true }),
+    aiSdkAgentStream: async () => {
+      queueMicrotask(() => {
+        onEvent?.({
+          type: 'plan-update',
+          itemId: 'plan-1',
+          status: 'running',
+          items: [{ text: 'Run command', completed: false }],
+        });
+        onEvent?.({
+          type: 'tool-call',
+          toolName: 'shell',
+          toolCallId: 'tool-1',
+          args: { command: 'true' },
+        });
+        onEvent?.({
+          type: 'tool-result',
+          toolName: 'shell',
+          toolCallId: 'tool-1',
+          output: 'ok',
+        });
+        onEvent?.({
+          type: 'plan-update',
+          itemId: 'plan-1',
+          status: 'completed',
+          items: [{ text: 'Run command', completed: true }],
+        });
+        onDone?.();
+      });
+      return { ok: true };
+    },
+  };
+
+  const session: AISession = {
+    id: 'chat-1',
+    title: 'Test',
+    agentId: 'codex',
+    scope: { type: 'global' },
+    messages: [{ id: 'assistant-1', role: 'assistant', content: '', timestamp: 1 }],
+    createdAt: 1,
+    updatedAt: 1,
+  };
+  const ui: TurnUiCallbacks = {
+    addMessageToSession: (_sessionId, message) => {
+      session.messages.push(message);
+    },
+    updateLastMessage: (_sessionId, updater) => {
+      const lastIndex = session.messages.length - 1;
+      session.messages[lastIndex] = updater(session.messages[lastIndex]);
+    },
+    updateMessageById: (_sessionId, messageId, updater) => {
+      const messageIndex = session.messages.findIndex((message) => message.id === messageId);
+      if (messageIndex >= 0) {
+        session.messages[messageIndex] = updater(session.messages[messageIndex]);
+      }
+    },
+    reportStreamError: () => {},
+    setStreamingForScope: () => {},
+    getLatestSession: () => session,
+  };
+  const agentConfig: ExternalAgentConfig = {
+    id: 'codex',
+    name: 'Codex',
+    command: 'codex',
+    enabled: true,
+    sdkBackend: 'codex',
+  };
+  const controller = new AbortController();
+
+  await externalSdkTurnDriver.run({
+    backend: 'external-sdk',
+    chatSessionId: session.id,
+    assistantMsgId: 'assistant-1',
+    userText: 'Run the plan',
+    signal: controller.signal,
+    agentConfig,
+    attachedImages: [],
+    context: {
+      terminalSessions: [],
+      providers: [],
+      toolIntegrationMode: 'mcp',
+      selectedUserSkillSlugs: [],
+      permissionMode: 'confirm',
+    },
+    bridge,
+    ui,
+  }, {
+    turnId: 'turn-1',
+    chatSessionId: session.id,
+    sessionId: session.id,
+    backend: 'external-sdk',
+    signal: controller.signal,
+    emit: () => {},
+    toolOutputStore: new ToolOutputStore(),
+    toolResultDedup: new ToolResultDedup(),
+    sessionStateStore: new SessionStateStore(),
+  });
+
+  const planActivities = session.messages
+    .flatMap((message: ChatMessage) => message.agentActivities ?? [])
+    .filter((activity) => activity.id === 'plan-1');
+
+  assert.equal(planActivities.length, 1);
+  assert.equal(planActivities[0].status, 'completed');
+  assert.deepEqual(planActivities[0].type === 'plan_update' ? planActivities[0].items : [], [
+    { text: 'Run command', completed: true },
+  ]);
+});
+
+test('accepted steering persists a user bubble and routes buffered output to a continuation', async () => {
+  let onEvent: ((event: Record<string, unknown>) => void) | undefined;
+  let onDone: (() => void) | undefined;
+  let releaseSteer: (() => void) | undefined;
+  const bridge: Record<string, (...args: unknown[]) => unknown> = {
+    onAiSdkAgentEvent: (_requestId, callback) => {
+      onEvent = callback as (event: Record<string, unknown>) => void;
+      return () => {};
+    },
+    onAiSdkAgentDone: (_requestId, callback) => {
+      onDone = callback as () => void;
+      return () => {};
+    },
+    onAiSdkAgentError: () => () => {},
+    aiSdkAgentCancel: async () => ({ ok: true }),
+    aiSdkAgentStream: async () => ({ ok: true }),
+    aiSdkAgentSteer: async () => {
+      onEvent?.({ type: 'text-delta', textDelta: 'after steer' });
+      await new Promise<void>(resolve => { releaseSteer = resolve; });
+      return { status: 'accepted' };
+    },
+  };
+  const session: AISession = {
+    id: 'chat-steer',
+    title: 'Steer',
+    agentId: 'codex',
+    scope: { type: 'global' },
+    messages: [{ id: 'assistant-initial', role: 'assistant', content: '', timestamp: 1 }],
+    createdAt: 1,
+    updatedAt: 1,
+  };
+  const ui: TurnUiCallbacks = {
+    addMessageToSession: (_sessionId, message) => session.messages.push(message),
+    updateLastMessage: () => { throw new Error('steering must not update the last message implicitly'); },
+    updateMessageById: (_sessionId, messageId, updater) => {
+      const index = session.messages.findIndex(message => message.id === messageId);
+      if (index >= 0) session.messages[index] = updater(session.messages[index]);
+    },
+    reportStreamError: () => {},
+    setStreamingForScope: () => {},
+    getLatestSession: () => session,
+  };
+  const controller = new AbortController();
+  const run = externalSdkTurnDriver.run({
+    backend: 'external-sdk',
+    chatSessionId: session.id,
+    assistantMsgId: 'assistant-initial',
+    userText: 'initial prompt',
+    signal: controller.signal,
+    agentConfig: {
+      id: 'codex',
+      name: 'Codex',
+      command: 'codex',
+      enabled: true,
+      sdkBackend: 'codex',
+      codexRuntime: 'app-server',
+    },
+    attachedImages: [],
+    context: {
+      terminalSessions: [],
+      providers: [],
+      toolIntegrationMode: 'mcp',
+      selectedUserSkillSlugs: [],
+      permissionMode: 'confirm',
+    },
+    bridge,
+    ui,
+  }, {
+    turnId: 'turn-steer',
+    chatSessionId: session.id,
+    sessionId: session.id,
+    backend: 'external-sdk',
+    signal: controller.signal,
+    emit: () => {},
+    toolOutputStore: new ToolOutputStore(),
+    toolResultDedup: new ToolResultDedup(),
+    sessionStateStore: new SessionStateStore(),
+  });
+  await waitFor(() => Boolean(onEvent));
+  onEvent?.({ type: 'text-delta', textDelta: 'before steer' });
+
+  const steer = externalSdkTurnDriver.steer({
+    chatSessionId: session.id,
+    userMessageId: 'user-steer',
+    userText: 'change direction',
+    prompt: 'change direction',
+    attachments: [],
+    attachedImages: [],
+  });
+  await waitFor(() => Boolean(releaseSteer));
+  assert.equal(session.messages.length, 1);
+  releaseSteer?.();
+  const result = await steer;
+
+  assert.equal(result.status, 'accepted');
+  assert.deepEqual(session.messages.map(message => message.role), ['assistant', 'user', 'assistant']);
+  assert.equal(session.messages[0].content, 'before steer');
+  assert.equal(session.messages[1].content, 'change direction');
+  assert.equal(session.messages[2].content, 'after steer');
+
+  onDone?.();
+  await run;
+});
+
+test('accepted steering keeps buffered results for existing tool calls on their original assistant message', async () => {
+  let onEvent: ((event: Record<string, unknown>) => void) | undefined;
+  let onDone: (() => void) | undefined;
+  let releaseSteer: (() => void) | undefined;
+  const bridge: Record<string, (...args: unknown[]) => unknown> = {
+    onAiSdkAgentEvent: (_requestId, callback) => {
+      onEvent = callback as (event: Record<string, unknown>) => void;
+      return () => {};
+    },
+    onAiSdkAgentDone: (_requestId, callback) => {
+      onDone = callback as () => void;
+      return () => {};
+    },
+    onAiSdkAgentError: () => () => {},
+    aiSdkAgentCancel: async () => ({ ok: true }),
+    aiSdkAgentStream: async () => ({ ok: true }),
+    aiSdkAgentSteer: async () => {
+      onEvent?.({
+        type: 'tool-result',
+        toolName: 'shell',
+        toolCallId: 'tool-before-steer',
+        output: 'completed before steer acceptance',
+      });
+      await new Promise<void>(resolve => { releaseSteer = resolve; });
+      return { status: 'accepted' };
+    },
+  };
+  const session: AISession = {
+    id: 'chat-steer-tool-result',
+    title: 'Steer tool result',
+    agentId: 'codex',
+    scope: { type: 'global' },
+    messages: [{ id: 'assistant-initial', role: 'assistant', content: '', timestamp: 1 }],
+    createdAt: 1,
+    updatedAt: 1,
+  };
+  const ui: TurnUiCallbacks = {
+    addMessageToSession: (_sessionId, message) => session.messages.push(message),
+    updateLastMessage: () => { throw new Error('steering must not update the last message implicitly'); },
+    updateMessageById: (_sessionId, messageId, updater) => {
+      const index = session.messages.findIndex(message => message.id === messageId);
+      if (index >= 0) session.messages[index] = updater(session.messages[index]);
+    },
+    reportStreamError: () => {},
+    setStreamingForScope: () => {},
+    getLatestSession: () => session,
+  };
+  const controller = new AbortController();
+  const run = externalSdkTurnDriver.run({
+    backend: 'external-sdk',
+    chatSessionId: session.id,
+    assistantMsgId: 'assistant-initial',
+    userText: 'initial prompt',
+    signal: controller.signal,
+    agentConfig: {
+      id: 'codex', name: 'Codex', command: 'codex', enabled: true,
+      sdkBackend: 'codex', codexRuntime: 'app-server',
+    },
+    attachedImages: [],
+    context: {
+      terminalSessions: [], providers: [], toolIntegrationMode: 'mcp',
+      selectedUserSkillSlugs: [], permissionMode: 'confirm',
+    },
+    bridge,
+    ui,
+  }, {
+    turnId: 'turn-steer-tool-result', chatSessionId: session.id, sessionId: session.id,
+    backend: 'external-sdk', signal: controller.signal, emit: () => {},
+    toolOutputStore: new ToolOutputStore(), toolResultDedup: new ToolResultDedup(),
+    sessionStateStore: new SessionStateStore(),
+  });
+  await waitFor(() => Boolean(onEvent));
+  onEvent?.({
+    type: 'tool-call',
+    toolName: 'shell',
+    toolCallId: 'tool-before-steer',
+    args: { command: 'sleep 1' },
+  });
+  assert.equal(session.messages[0].executionStatus, 'running');
+
+  const steer = externalSdkTurnDriver.steer({
+    chatSessionId: session.id,
+    userMessageId: 'user-steer-tool-result',
+    userText: 'change direction',
+    prompt: 'change direction',
+    attachments: [],
+    attachedImages: [],
+  });
+  await waitFor(() => Boolean(releaseSteer));
+  assert.equal(session.messages.length, 1);
+  assert.equal(session.messages[0].executionStatus, 'running');
+
+  releaseSteer?.();
+  const result = await steer;
+
+  assert.equal(result.status, 'accepted');
+  assert.deepEqual(
+    session.messages.map(message => message.role),
+    ['assistant', 'tool', 'user', 'assistant'],
+  );
+  assert.equal(session.messages[0].executionStatus, 'completed');
+  assert.equal(session.messages[0].toolCalls?.[0]?.id, 'tool-before-steer');
+  assert.equal(session.messages[1].toolResults?.[0]?.toolCallId, 'tool-before-steer');
+  assert.equal(session.messages[2].content, 'change direction');
+  assert.equal(session.messages[3].content, '');
+
+  onEvent?.({ type: 'text-delta', textDelta: 'continued after steer' });
+  // Text deltas are rAF-batched like Catty; wait one frame before asserting.
+  await new Promise<void>((resolve) => {
+    if (typeof requestAnimationFrame === 'function') {
+      requestAnimationFrame(() => resolve());
+      return;
+    }
+    setTimeout(resolve, 0);
+  });
+  assert.equal(session.messages[3].content, 'continued after steer');
+
+  onDone?.();
+  await run;
+});
+
+test('failed steering keeps buffered output on the original assistant message', async () => {
+  let onEvent: ((event: Record<string, unknown>) => void) | undefined;
+  let onDone: (() => void) | undefined;
+  const bridge: Record<string, (...args: unknown[]) => unknown> = {
+    onAiSdkAgentEvent: (_requestId, callback) => {
+      onEvent = callback as (event: Record<string, unknown>) => void;
+      return () => {};
+    },
+    onAiSdkAgentDone: (_requestId, callback) => {
+      onDone = callback as () => void;
+      return () => {};
+    },
+    onAiSdkAgentError: () => () => {},
+    aiSdkAgentCancel: async () => ({ ok: true }),
+    aiSdkAgentStream: async () => ({ ok: true }),
+    aiSdkAgentSteer: async () => {
+      onEvent?.({ type: 'text-delta', textDelta: 'kept output' });
+      return { status: 'not-steerable', turnKind: 'compact' };
+    },
+  };
+  const session: AISession = {
+    id: 'chat-steer-failed',
+    title: 'Steer failed',
+    agentId: 'codex',
+    scope: { type: 'global' },
+    messages: [{ id: 'assistant-initial', role: 'assistant', content: '', timestamp: 1 }],
+    createdAt: 1,
+    updatedAt: 1,
+  };
+  const ui: TurnUiCallbacks = {
+    addMessageToSession: (_sessionId, message) => session.messages.push(message),
+    updateLastMessage: () => { throw new Error('steering must not update the last message implicitly'); },
+    updateMessageById: (_sessionId, messageId, updater) => {
+      const index = session.messages.findIndex(message => message.id === messageId);
+      if (index >= 0) session.messages[index] = updater(session.messages[index]);
+    },
+    reportStreamError: () => {},
+    setStreamingForScope: () => {},
+  };
+  const controller = new AbortController();
+  const run = externalSdkTurnDriver.run({
+    backend: 'external-sdk',
+    chatSessionId: session.id,
+    assistantMsgId: 'assistant-initial',
+    userText: 'initial prompt',
+    signal: controller.signal,
+    agentConfig: {
+      id: 'codex', name: 'Codex', command: 'codex', enabled: true,
+      sdkBackend: 'codex', codexRuntime: 'app-server',
+    },
+    attachedImages: [],
+    context: {
+      terminalSessions: [], providers: [], toolIntegrationMode: 'mcp',
+      selectedUserSkillSlugs: [], permissionMode: 'confirm',
+    },
+    bridge,
+    ui,
+  }, {
+    turnId: 'turn-steer-failed', chatSessionId: session.id, sessionId: session.id,
+    backend: 'external-sdk', signal: controller.signal, emit: () => {},
+    toolOutputStore: new ToolOutputStore(), toolResultDedup: new ToolResultDedup(),
+    sessionStateStore: new SessionStateStore(),
+  });
+  await waitFor(() => Boolean(onEvent));
+  const result = await externalSdkTurnDriver.steer({
+    chatSessionId: session.id,
+    userMessageId: 'user-not-added',
+    userText: 'cannot apply',
+    prompt: 'cannot apply',
+    attachments: [],
+    attachedImages: [],
+  });
+
+  assert.deepEqual(result, { status: 'not-steerable', turnKind: 'compact' });
+  assert.equal(session.messages.length, 1);
+  assert.equal(session.messages[0].content, 'kept output');
+  onDone?.();
+  await run;
+});