repoburg 1.3.196 → 1.3.197

package/agent-pane/backend/src/claude/claude-message-mapper.ts

@@ -23,14 +23,19 @@ export interface ItemDescriptor {
   externalId: string;       // Claude content block ID (or UUID)
 }
 
-/** Map assistant content blocks to item descriptors. */
+/** Map assistant content blocks to item descriptors.
+ *  @param thinkingTexts — Optional map of content-block index → accumulated thinking_delta text.
+ *    When a `thinking` block has empty `thinking` (signed-empty), the mapper falls back to
+ *    the accumulated text from stream events.  */
 export function mapAssistantContent(
   content: BetaContentBlock[],
   messageId: string,
+  thinkingTexts?: Map<number, string>,
 ): ItemDescriptor[] {
   const descriptors: ItemDescriptor[] = [];
 
-  for (const block of content) {
+  for (let i = 0; i < content.length; i++) {
+    const block = content[i];
     switch (block.type) {
       case 'text': {
         const tb = block as BetaTextBlock;
@@ -44,9 +49,13 @@ export function mapAssistantContent(
 
       case 'thinking': {
         const tb = block as BetaThinkingBlock;
+        let text = tb.thinking;
+        if (!text && thinkingTexts) {
+          text = thinkingTexts.get(i) ?? '';
+        }
         descriptors.push({
           type: 'reasoning',
-          data: { text: tb.thinking },
+          data: { text },
           externalId: messageId,
         });
         break;
@@ -92,10 +101,7 @@ function mapToolUse(block: BetaToolUseBlock): ItemDescriptor {
   if (block.name === 'Edit' || block.name === 'Write' || block.name === 'MultiEdit' || block.name === 'NotebookEdit') {
     return {
       type: 'file_change',
-      data: {
-        changes: input,
-        status: 'in_progress',
-      },
+      data: deriveFileChangeData(input, block.name),
       externalId: block.id,
     };
   }
@@ -115,10 +121,109 @@ function mapToolUse(block: BetaToolUseBlock): ItemDescriptor {
   };
 }
 
+// ---------------------------------------------------------------------------
+// Tool-result mapping — pure functions shared by the live provider and the
+// JSONL backfill script. Kept free of DB / SDK-specific types so both callers
+// (which hold different shapes: typed SDK blocks vs parsed JSON) can use them.
+// ---------------------------------------------------------------------------
+
+/** Derive the canonical file_change data from a Claude file-edit tool_use input.
+ *  Each Edit/Write/MultiEdit/NotebookEdit touches a single file → one change.
+ *  Frontend expects `changes: Array<{ path, kind }>` (matches Codex app-server). */
+export function deriveFileChangeData(
+  input: Record<string, unknown>,
+  toolName: string,
+): { changes: Array<{ path: string; kind: string }>; status: string } {
+  const path = (input.file_path ?? input.notebook_path ?? '') as string;
+  const kind = toolName === 'Write' ? 'add' : 'modify';
+  return { changes: [{ path, kind }], status: 'in_progress' };
+}
+
+/** Loose shape of a `tool_result` content block — works for SDK blocks and parsed JSONL. */
+export interface ToolResultLike {
+  tool_use_id?: string;
+  is_error?: boolean;
+  content?: unknown;
+}
+
+/** Extract concatenated text from a tool_result `content` (string or array of text blocks). */
+export function extractToolResultText(content: unknown): string {
+  if (!content) return '';
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) {
+    return content
+      .map((b) => {
+        if (b && typeof b === 'object' && (b as { type?: string }).type === 'text') {
+          return String((b as { text?: unknown }).text ?? '');
+        }
+        return '';
+      })
+      .filter(Boolean)
+      .join('\n');
+  }
+  return '';
+}
+
+/** Build the updated item `data` after a tool_result arrives. Pure; no DB access.
+ *
+ *  - `command_execution`: aggregated_output from the result text (Bash stdout) plus
+ *    structured stderr when present; exit_code heuristically from is_error (the Claude
+ *    SDK does not expose a real exit code for Bash).
+ *  - `mcp_tool_call`: result text from the tool_result content; error when is_error.
+ *  - `file_change`: the `changes` array was set at tool_use time — just mark status.
+ *  @param itemType — DB item type ('command_execution' | 'file_change' | 'mcp_tool_call').
+ *  @param existingData — current `data` object stored on the item.
+ *  @param toolResult — the tool_result content block (may be null if only structured output exists).
+ *  @param toolUseResult — the SDK `tool_use_result` structured object (per-tool shape; Bash → {stdout, stderr}).
+ *  @param isError — whether the tool_result flagged an error. */
+export function applyToolResult(
+  itemType: string,
+  existingData: Record<string, unknown>,
+  toolResult: ToolResultLike | null,
+  toolUseResult: unknown,
+  isError: boolean,
+): Record<string, unknown> {
+  switch (itemType) {
+    case 'command_execution': {
+      const text = extractToolResultText(toolResult?.content);
+      const tur = (toolUseResult && typeof toolUseResult === 'object' ? toolUseResult : {}) as Record<string, unknown>;
+      const stdout = typeof tur.stdout === 'string' ? tur.stdout : '';
+      const stderr = typeof tur.stderr === 'string' ? tur.stderr : '';
+      let aggregated = text || stdout;
+      if (stderr) aggregated = aggregated ? `${aggregated}\n${stderr}` : stderr;
+      return {
+        ...existingData,
+        aggregated_output: aggregated,
+        exit_code: isError ? 1 : 0,
+        status: isError ? 'failed' : 'completed',
+      };
+    }
+
+    case 'mcp_tool_call': {
+      const text = extractToolResultText(toolResult?.content);
+      return {
+        ...existingData,
+        result: text ? [{ type: 'text', text }] : (toolUseResult ?? null),
+        error: isError ? (text || 'Tool error') : null,
+        status: isError ? 'failed' : 'completed',
+      };
+    }
+
+    case 'file_change': {
+      // `changes` was derived at tool_use time; only flip the inner status.
+      return { ...existingData, status: isError ? 'failed' : 'completed' };
+    }
+
+    default:
+      return existingData;
+  }
+}
+
 /** Result of mapping a partial (streaming) delta event. */
 export interface DeltaResult {
   kind: 'text' | 'thinking';
   text: string;
+  index: number;
 }
 
 /** Map a streaming delta event to a text or thinking fragment. Returns null for non-delta events. */
@@ -128,10 +233,10 @@ export function mapPartialDelta(event: unknown): DeltaResult | null {
 
   const delta = e.delta as unknown as Record<string, unknown>;
   if (delta.type === 'text_delta') {
-    return { kind: 'text', text: delta.text as string };
+    return { kind: 'text', text: delta.text as string, index: e.index };
   }
   if (delta.type === 'thinking_delta') {
-    return { kind: 'thinking', text: delta.thinking as string };
+    return { kind: 'thinking', text: delta.thinking as string, index: e.index };
   }
 
   return null;