[Init] Initial commit - NetMesh terminal manager

infrastructure/ai/harness/agentEventAdapter.ts

@@ -0,0 +1,317 @@
+import type { AgentEvent, AgentEventListener } from './types';
+import { resolveStreamChunkToolCallId } from '../aiChatStreamingSupport';
+
+let eventCounter = 0;
+
+function nextEventId(prefix: string): string {
+  eventCounter += 1;
+  return `${prefix}-${Date.now()}-${eventCounter}`;
+}
+
+export interface StreamEventContext {
+  sessionId: string;
+  chatSessionId?: string;
+  turnId?: string;
+}
+
+export interface CattyStreamChunk {
+  type: string;
+  text?: string;
+  textDelta?: string;
+  delta?: string;
+  toolCallId?: string;
+  toolName?: string;
+  input?: unknown;
+  args?: unknown;
+  output?: unknown;
+  result?: unknown;
+  error?: unknown;
+  approved?: boolean;
+  stepNumber?: number;
+}
+
+const STEP_HANDLE_NOTICE_RE = /^\[step \d+\] Tool output handles available:/;
+
+function isStepHandleNoticeMessage(content: unknown): boolean {
+  return typeof content === 'string' && STEP_HANDLE_NOTICE_RE.test(content);
+}
+
+function isToolResultError(output: unknown): boolean {
+  if (output == null) return false;
+  if (typeof output === 'object') {
+    const obj = output as Record<string, unknown>;
+    if ('error' in obj && typeof obj.error === 'string') return true;
+    if ('ok' in obj && obj.ok === false) return true;
+  }
+  if (typeof output === 'string') {
+    try {
+      const parsed = JSON.parse(output) as Record<string, unknown>;
+      if ('error' in parsed && typeof parsed.error === 'string') return true;
+      if ('ok' in parsed && parsed.ok === false) return true;
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+
+export function mapSdkStreamEventToAgentEvents(
+  event: Record<string, unknown>,
+  ctx: StreamEventContext,
+): AgentEvent[] {
+  const base = {
+    sessionId: ctx.sessionId,
+    chatSessionId: ctx.chatSessionId,
+    backend: 'external-sdk' as const,
+    timestamp: Date.now(),
+    turnId: ctx.turnId,
+  };
+
+  switch (event.type) {
+    case 'text-delta':
+      return [{
+        ...base,
+        id: nextEventId('model-delta'),
+        type: 'model_delta',
+        text: String(event.text ?? event.textDelta ?? event.delta ?? ''),
+      }];
+    case 'thinking-delta':
+    case 'reasoning-delta':
+      return [{
+        ...base,
+        id: nextEventId('reasoning-delta'),
+        type: 'reasoning_delta',
+        text: String(event.text ?? event.textDelta ?? event.delta ?? ''),
+      }];
+    case 'tool-call':
+      return [{
+        ...base,
+        id: nextEventId('tool-call'),
+        type: 'tool_call',
+        toolCallId: String(event.toolCallId ?? event.id ?? ''),
+        toolName: String(event.toolName ?? event.name ?? 'unknown'),
+        args: (event.args ?? event.input ?? {}) as Record<string, unknown>,
+      }];
+    case 'tool-result':
+      {
+        const output = event.result ?? event.output ?? '';
+      return [{
+        ...base,
+        id: nextEventId('tool-result'),
+        type: 'tool_result',
+        toolCallId: String(event.toolCallId ?? ''),
+        toolName: typeof event.toolName === 'string' ? event.toolName : undefined,
+        result: typeof output === 'string' ? output : JSON.stringify(output),
+        isError: Boolean(event.isError) || isToolResultError(output),
+      }];
+      }
+    case 'file-change':
+      return [{
+        ...base,
+        id: nextEventId('file-change'),
+        type: 'file_change',
+        itemId: String(event.itemId ?? ''),
+        status: event.status === 'failed' ? 'failed' : 'completed',
+        changes: Array.isArray(event.changes)
+          ? event.changes as Array<{ path: string; kind: 'add' | 'delete' | 'update' }>
+          : [],
+      }];
+    case 'web-search':
+      return [{
+        ...base,
+        id: nextEventId('web-search'),
+        type: 'web_search',
+        itemId: String(event.itemId ?? ''),
+        query: String(event.query ?? ''),
+        status: event.status === 'completed' ? 'completed' : 'running',
+      }];
+    case 'plan-update':
+      return [{
+        ...base,
+        id: nextEventId('plan-update'),
+        type: 'plan_update',
+        itemId: String(event.itemId ?? ''),
+        status: event.status === 'completed' ? 'completed' : 'running',
+        items: Array.isArray(event.items)
+          ? event.items as Array<{ text: string; completed: boolean }>
+          : [],
+      }];
+    case 'warning':
+      return [{
+        ...base,
+        id: nextEventId('warning'),
+        type: 'error',
+        message: String(event.message ?? 'Unknown SDK warning'),
+        recoverable: true,
+      }];
+    case 'usage': {
+      const promptTokens = Number(event.inputTokens) || 0;
+      const completionTokens = Number(event.outputTokens) || 0;
+      return [{
+        ...base,
+        id: nextEventId('usage'),
+        type: 'usage',
+        promptTokens,
+        cachedPromptTokens: Number(event.cachedInputTokens) || 0,
+        completionTokens,
+        reasoningTokens: Number(event.reasoningTokens) || 0,
+        totalTokens: Number(event.totalTokens) || promptTokens + completionTokens,
+        estimated: false,
+      }];
+    }
+    case 'error':
+      return [{
+        ...base,
+        id: nextEventId('error'),
+        type: 'error',
+        message: String(event.error ?? event.message ?? 'Unknown SDK error'),
+        recoverable: false,
+      }];
+    default:
+      return [];
+  }
+}
+
+export function mapCattyStreamChunkToAgentEvents(
+  chunk: CattyStreamChunk,
+  ctx: StreamEventContext,
+): AgentEvent[] {
+  const base = {
+    sessionId: ctx.sessionId,
+    chatSessionId: ctx.chatSessionId,
+    backend: 'catty' as const,
+    timestamp: Date.now(),
+    turnId: ctx.turnId,
+  };
+
+  if (chunk.type === 'text' || chunk.type === 'text-delta') {
+    const text = chunk.text ?? chunk.textDelta ?? '';
+    if (!text) return [];
+    return [{ ...base, id: nextEventId('model-delta'), type: 'model_delta', text }];
+  }
+
+  if (chunk.type === 'reasoning' || chunk.type === 'reasoning-start' || chunk.type === 'reasoning-delta') {
+    const text = chunk.text ?? chunk.textDelta ?? chunk.delta ?? '';
+    if (!text) return [];
+    return [{ ...base, id: nextEventId('reasoning-delta'), type: 'reasoning_delta', text }];
+  }
+
+  if (chunk.type === 'tool-call' && chunk.toolCallId && chunk.toolName) {
+    return [{
+      ...base,
+      id: nextEventId('tool-call'),
+      type: 'tool_call',
+      toolCallId: chunk.toolCallId,
+      toolName: chunk.toolName,
+      args: (chunk.input ?? chunk.args ?? {}) as Record<string, unknown>,
+    }];
+  }
+
+  if (chunk.type === 'tool-result' && chunk.toolCallId) {
+    const output = chunk.output ?? chunk.result;
+    const resultText = typeof output === 'string' ? output : JSON.stringify(output ?? '');
+    return [{
+      ...base,
+      id: nextEventId('tool-result'),
+      type: 'tool_result',
+      toolCallId: chunk.toolCallId,
+      toolName: typeof chunk.toolName === 'string' ? chunk.toolName : undefined,
+      result: resultText,
+      isError: isToolResultError(output),
+    }];
+  }
+
+  if (chunk.type === 'tool-error' && chunk.toolCallId) {
+    const resultText = chunk.error instanceof Error
+      ? JSON.stringify({ error: chunk.error.message })
+      : typeof chunk.error === 'string'
+        ? JSON.stringify({ error: chunk.error })
+        : JSON.stringify({ error: String(chunk.error ?? 'Tool execution failed.') });
+    return [{
+      ...base,
+      id: nextEventId('tool-result'),
+      type: 'tool_result',
+      toolCallId: chunk.toolCallId,
+      toolName: typeof chunk.toolName === 'string' ? chunk.toolName : undefined,
+      result: resultText,
+      isError: true,
+    }];
+  }
+
+  if (chunk.type === 'error') {
+    const message = chunk.error instanceof Error
+      ? chunk.error.message
+      : String(chunk.error ?? 'Unknown stream error');
+    return [{ ...base, id: nextEventId('error'), type: 'error', message }];
+  }
+
+  if (chunk.type === 'tool-approval-request') {
+    const toolCallId = resolveStreamChunkToolCallId(chunk);
+    const toolName = chunk.toolName ?? chunk.toolCall?.toolName;
+    if (!toolCallId || !toolName) return [];
+    return [{
+      ...base,
+      id: nextEventId('approval-requested'),
+      type: 'approval_requested',
+      toolCallId,
+      toolName,
+      args: (chunk.input ?? chunk.args ?? chunk.toolCall?.input ?? {}) as Record<string, unknown>,
+    }];
+  }
+
+  if (chunk.type === 'tool-approval-response') {
+    const toolCallId = resolveStreamChunkToolCallId(chunk);
+    if (!toolCallId) return [];
+    const approved = chunk.approved === true;
+    const events: AgentEvent[] = [{
+      ...base,
+      id: nextEventId('approval-resolved'),
+      type: 'approval_resolved',
+      toolCallId,
+      toolName: String(chunk.toolName ?? chunk.toolCall?.toolName ?? 'unknown'),
+      outcome: approved ? 'approved' : 'denied',
+    }];
+    if (!approved) {
+      events.push({
+        ...base,
+        id: nextEventId('tool-result'),
+        type: 'tool_result',
+        toolCallId,
+        result: JSON.stringify({ error: chunk.reason ?? 'Tool execution denied.' }),
+        isError: true,
+      });
+    }
+    return events;
+  }
+
+  if (chunk.type === 'tool-output-denied' && chunk.toolCallId) {
+    return [
+      {
+        ...base,
+        id: nextEventId('approval-resolved'),
+        type: 'approval_resolved',
+        toolCallId: chunk.toolCallId,
+        toolName: String(chunk.toolName ?? 'unknown'),
+        outcome: 'denied',
+      },
+      {
+        ...base,
+        id: nextEventId('tool-result'),
+        type: 'tool_result',
+        toolCallId: chunk.toolCallId,
+        result: JSON.stringify({ error: 'Tool execution denied.' }),
+        isError: true,
+      },
+    ];
+  }
+
+  return [];
+}
+
+export { isStepHandleNoticeMessage };
+
+export function createHarnessEventSink(
+  listener: AgentEventListener,
+): AgentEventListener {
+  return (event) => listener(event);
+}