macro-agent 0.0.16 → 0.1.0

package/src/acp/macro-agent.ts

@@ -75,6 +75,22 @@ import type { RoleRegistry, Capability } from "../roles/types.js";
 import { AGENT_CAPABILITIES } from "../roles/capabilities.js";
 import { DefaultRoleRegistry } from "../roles/registry.js";
 
+// ─────────────────────────────────────────────────────────────────
+// Helpers
+// ─────────────────────────────────────────────────────────────────
+
+/** Extract a plain-text output string from `rawOutput` (string | ContentBlock[] | undefined). */
+function extractToolOutput(rawOutput: unknown): string | undefined {
+  if (typeof rawOutput === "string") return rawOutput;
+  if (Array.isArray(rawOutput)) {
+    return rawOutput
+      .filter((item: any) => item.type === "text" && typeof item.text === "string")
+      .map((item: any) => item.text as string)
+      .join("\n") || undefined;
+  }
+  return undefined;
+}
+
 // ─────────────────────────────────────────────────────────────────
 // Protocol Constants
 // ─────────────────────────────────────────────────────────────────
@@ -157,7 +173,13 @@ export class MacroAgent implements Agent {
   /** Accumulates assistant response parts during prompt streaming for history persistence */
   private promptBuffers: Map<
     ACPSessionId,
-    { textChunks: string[]; toolCalls: Record<string, unknown>[] }
+    { parts: Array<{ type: "text"; text: string } | ({ type: "tool" } & Record<string, unknown>)> }
+  > = new Map();
+
+  /** Caches tool info (title, name, input) from initial tool_call events per session */
+  private toolInfoCaches: Map<
+    ACPSessionId,
+    Map<string, { title?: string; name?: string; input?: unknown }>
   > = new Map();
 
   constructor(connection: AgentSideConnection, config: MacroAgentConfig) {
@@ -360,8 +382,9 @@ export class MacroAgent implements Agent {
     // Mark session as processing (for health monitoring)
     this.sessionMapper.setProcessing(acpSessionId, true);
 
-    // Initialize prompt buffer for history accumulation
-    this.promptBuffers.set(acpSessionId, { textChunks: [], toolCalls: [] });
+    // Initialize prompt buffer and tool info cache for history accumulation
+    this.promptBuffers.set(acpSessionId, { parts: [] });
+    this.toolInfoCaches.set(acpSessionId, new Map());
 
     try {
       // Stream responses from the agent
@@ -1396,7 +1419,7 @@ export class MacroAgent implements Agent {
         console.log(`[MacroAgent] Forwarding ${updateType}`);
     }
 
-    // Accumulate content for history persistence
+    // Accumulate content for history persistence (preserving text/tool interleaving order)
     const buffer = this.promptBuffers.get(acpSessionId);
     if (buffer) {
       if (updateType === "agent_message_chunk") {
@@ -1404,23 +1427,42 @@ export class MacroAgent implements Agent {
           | { type?: string; text?: string }
           | undefined;
         if (content?.text) {
-          buffer.textChunks.push(content.text);
+          const last = buffer.parts[buffer.parts.length - 1];
+          if (last && last.type === "text") {
+            last.text += content.text;
+          } else {
+            buffer.parts.push({ type: "text", text: content.text });
+          }
         }
       } else if (
         updateType === "tool_call" ||
         updateType === "tool_call_update"
       ) {
+        const toolCallId = sessionUpdate.toolCallId as string | undefined;
         const status = sessionUpdate.status as string | undefined;
-        if (
-          status === "completed" ||
-          (updateType === "tool_call" && status !== "running")
-        ) {
-          buffer.toolCalls.push({
-            toolCallId: sessionUpdate.toolCallId,
-            title: sessionUpdate.title,
-            status: sessionUpdate.status,
+        const meta = sessionUpdate._meta as { claudeCode?: { toolName?: string } } | undefined;
+        const toolInfoCache = this.toolInfoCaches.get(acpSessionId);
+
+        // Cache tool info from initial tool_call events
+        if (updateType === "tool_call" && toolCallId && toolInfoCache) {
+          toolInfoCache.set(toolCallId, {
+            title: sessionUpdate.title as string | undefined,
+            name: meta?.claudeCode?.toolName,
             input: sessionUpdate.rawInput,
-            output: sessionUpdate.output,
+          });
+        }
+
+        if (status === "completed" || status === "failed") {
+          // Merge cached info for tool_call_update events that lack title/input
+          const cached = toolCallId ? toolInfoCache?.get(toolCallId) : undefined;
+          buffer.parts.push({
+            type: "tool",
+            toolCallId,
+            title: sessionUpdate.title ?? cached?.title,
+            name: meta?.claudeCode?.toolName ?? cached?.name,
+            status: sessionUpdate.status,
+            input: sessionUpdate.rawInput ?? cached?.input,
+            output: extractToolOutput(sessionUpdate.rawOutput),
           });
         }
       }
@@ -1627,17 +1669,8 @@ export class MacroAgent implements Agent {
         });
       }
 
-      // Record assistant turn with accumulated content
-      const assistantText = buffer.textChunks.join("");
-      const parts: unknown[] = [];
-
-      if (assistantText) {
-        parts.push({ type: "text", text: assistantText });
-      }
-
-      for (const tool of buffer.toolCalls) {
-        parts.push({ type: "tool", ...tool });
-      }
+      // Record assistant turn with accumulated content (parts already in order)
+      const parts = buffer.parts;
 
       if (parts.length > 0) {
         this.eventStore.emit({
@@ -1661,8 +1694,9 @@ export class MacroAgent implements Agent {
         error instanceof Error ? error.message : String(error),
       );
     } finally {
-      // Clean up the buffer
+      // Clean up the buffer and tool info cache
       this.promptBuffers.delete(acpSessionId);
+      this.toolInfoCaches.delete(acpSessionId);
     }
   }
 

package/src/agent/__tests__/agent-manager.test.ts

@@ -720,7 +720,7 @@ describe("AgentManager Integration (with mocked acp-factory)", () => {
       );
     });
 
-    it("should fall back to session_id if provider_session_id is not set", async () => {
+    it("should create new session if provider_session_id is not set", async () => {
       // Create agent directly without provider_session_id
       const agentId = "agent_no_provider";
       const sessionId = "session_no_provider";
@@ -744,11 +744,9 @@ describe("AgentManager Integration (with mocked acp-factory)", () => {
 
       await agentManager.resume(agentId);
 
-      // Should fall back to the macro-agent session_id
-      expect(mockHandle.loadSession).toHaveBeenCalledWith(
-        sessionId,
-        "/tmp",
-      );
+      // Should create a new session instead of loading with invalid macro-agent session_id
+      expect(mockHandle.createSession).toHaveBeenCalledWith("/tmp");
+      expect(mockHandle.loadSession).not.toHaveBeenCalled();
     });
   });
 

package/src/agent/agent-manager.ts

@@ -901,16 +901,34 @@ export function createAgentManager(
       );
     }
 
-    // Spawn new process and load existing session
+    // Spawn new process
     const handle = await AgentFactory.spawn(defaultAgentType, {
       permissionMode: defaultPermissionMode,
     });
 
-    // Load the existing session using the provider's session ID (e.g., Claude Code UUID)
-    // Falls back to macro-agent session_id for backwards compatibility
-    const loadSessionId = agent.provider_session_id ?? agent.session_id;
     const agentCwd = agent.cwd ?? defaultCwd;
-    const session = await handle.loadSession(loadSessionId, agentCwd);
+    let session;
+
+    if (agent.provider_session_id) {
+      // Load existing session using the provider's session ID (e.g., Claude Code UUID)
+      session = await handle.loadSession(agent.provider_session_id, agentCwd);
+    } else {
+      // No provider session ID available (agent predates this feature or wasn't persisted).
+      // Create a new session instead of loading with the macro-agent session_id
+      // which is not a valid provider session ID (e.g., Claude Code expects UUIDs).
+      session = await handle.createSession(agentCwd);
+
+      // Store the provider session ID for future resumes
+      eventStore.emit({
+        type: "status",
+        source: { agent_id: agentId },
+        payload: {
+          status_type: "started",
+          summary: "Agent session created (no provider session to resume)",
+          provider_session_id: session.id,
+        },
+      });
+    }
 
     // Track active session
     const activeSession: ActiveSession = {
@@ -929,6 +947,7 @@ export function createAgentManager(
       payload: {
         status_type: "started",
         summary: "Agent session resumed",
+        provider_session_id: session.id,
       },
     });