macro-agent 0.0.17 → 0.1.1

package/src/acp/macro-agent.ts

@@ -20,6 +20,7 @@ import type {
   PromptResponse,
   CancelNotification,
   SessionNotification,
+  SessionModelState,
 } from "@agentclientprotocol/sdk";
 import type { AgentManager } from "../agent/agent-manager.js";
 import type { EventStore } from "../store/event-store.js";
@@ -61,6 +62,8 @@ import type {
   RespondToPermissionResponse,
   CancelPermissionRequest,
   CancelPermissionResponse,
+  SetPermissionModeRequest,
+  SetPermissionModeResponse,
   ResumeAgentRequest,
   ResumeAgentResponse,
   GetHistoryRequest,
@@ -75,6 +78,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
 // ─────────────────────────────────────────────────────────────────
@@ -97,8 +116,10 @@ const SUPPORTED_EXTENSIONS: ACPExtensionMethod[] = [
   "_macro/checkCapability",
   "_macro/respondToPermission",
   "_macro/cancelPermission",
+  "_macro/setPermissionMode",
   "_macro/resume",
   "_macro/getHistory",
+  "_macro/getModels",
 ];
 
 // ─────────────────────────────────────────────────────────────────
@@ -128,6 +149,22 @@ export interface MacroAgentConfig {
   defaultCwd?: string;
 }
 
+// ─────────────────────────────────────────────────────────────────
+// Helpers
+// ─────────────────────────────────────────────────────────────────
+
+/**
+ * Build a SessionModelState from the acp-factory Session.models (string[]).
+ * Returns null if the models array is empty or missing.
+ */
+function buildModelState(models: string[]): SessionModelState | null {
+  if (!models || models.length === 0) return null;
+  return {
+    currentModelId: models[0],
+    availableModels: models.map((id) => ({ modelId: id, name: id })),
+  };
+}
+
 // ─────────────────────────────────────────────────────────────────
 // MacroAgent Implementation
 // ─────────────────────────────────────────────────────────────────
@@ -157,7 +194,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) {
@@ -249,6 +292,7 @@ export class MacroAgent implements Agent {
 
     return {
       sessionId: acpSessionId,
+      models: buildModelState(spawned.session.models),
     };
   }
 
@@ -259,6 +303,7 @@ export class MacroAgent implements Agent {
     let acpSessionId = params.sessionId;
     const cwd = params.cwd ?? this.defaultCwd;
 
+    // DEBUG: Log loadSession params
     // Extension: If _meta.agentId provided, look up session from agent record
     // This allows resuming a stopped head manager by MAP agent ID
     // when the TUI doesn't know the ACP session ID
@@ -292,14 +337,18 @@ export class MacroAgent implements Agent {
         }
         this.ensureConversation(acpSessionId, existing.id);
         await this.emitSessionInfo(acpSessionId);
-        return {};
+        const activeSession = this.agentManager.getSession(existing.id);
+        return {
+          models: activeSession ? buildModelState(activeSession.models) : null,
+        };
       }
 
       // Agent exists but no active session - resume it
       console.log(
         `[MacroAgent] loadSession: Resuming stopped agent ${existing.id}`,
       );
-      const spawned = await this.agentManager.resume(existing.id);
+      const defaultConfig = this.initConfig.defaultSubAgentConfig;
+      const spawned = await this.agentManager.resume(existing.id, defaultConfig?.permissionMode);
 
       // Create session mapping
       this.sessionMapper.createMapping(acpSessionId, spawned.id);
@@ -307,16 +356,20 @@ export class MacroAgent implements Agent {
       this.ensureConversation(acpSessionId, spawned.id);
       await this.emitSessionInfo(acpSessionId);
 
-      return {};
+      return {
+        models: buildModelState(spawned.session.models),
+      };
     }
 
     // No existing agent found - try to get or create with the specific session ID
     console.log(
       `[MacroAgent] loadSession: No existing agent for session ${acpSessionId}, creating new`,
     );
+    const defaultConfig = this.initConfig.defaultSubAgentConfig;
     const spawned = await this.agentManager.getOrCreateHeadManager({
       cwd,
       sessionId: acpSessionId,
+      permissionMode: defaultConfig?.permissionMode,
     });
 
     // Create session mapping
@@ -325,7 +378,9 @@ export class MacroAgent implements Agent {
     this.ensureConversation(acpSessionId, spawned.id);
     await this.emitSessionInfo(acpSessionId);
 
-    return {};
+    return {
+      models: buildModelState(spawned.session.models),
+    };
   }
 
   /**
@@ -360,8 +415,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
@@ -541,6 +597,11 @@ export class MacroAgent implements Agent {
           params as unknown as CancelPermissionRequest,
         ) as unknown as Record<string, unknown>;
 
+      case "_macro/setPermissionMode":
+        return this.handleSetPermissionMode(
+          params as unknown as SetPermissionModeRequest,
+        ) as unknown as Record<string, unknown>;
+
       case "_macro/resume":
         return this.handleResumeAgent(
           params as unknown as ResumeAgentRequest,
@@ -551,6 +612,11 @@ export class MacroAgent implements Agent {
           params as unknown as GetHistoryRequest,
         ) as unknown as Record<string, unknown>;
 
+      case "_macro/getModels":
+        return this.handleGetModels(
+          params as { sessionId: string },
+        ) as unknown as Record<string, unknown>;
+
       default:
         throw new ACPError(
           `Unknown extension method: ${method}`,
@@ -769,9 +835,9 @@ export class MacroAgent implements Agent {
   private async handleForkAgent(
     params: ForkAgentRequest,
   ): Promise<ForkAgentResponse> {
-    const { agentId, name } = params;
+    const { agentId, name, prompt, cwd } = params;
 
-    // Get the original agent
+    // Validate source agent exists
     const originalAgent = this.agentManager.get(agentId);
     if (!originalAgent) {
       throw new ACPError(`Agent not found: ${agentId}`, "AGENT_NOT_FOUND", {
@@ -779,41 +845,48 @@ export class MacroAgent implements Agent {
       });
     }
 
-    // Check if the agent has an active session we can fork from
-    const hasSession = this.agentManager.hasActiveSession(agentId);
-    if (!hasSession) {
+    // Check forkable: needs active session or persisted provider_session_id
+    if (
+      !this.agentManager.hasActiveSession(agentId) &&
+      !originalAgent.provider_session_id
+    ) {
       throw new ACPError(
-        `Agent has no active session to fork: ${agentId}`,
+        `Agent has no session to fork: ${agentId}`,
         "FORK_NOT_SUPPORTED",
         { agentId },
       );
     }
 
-    // For now, create a new agent with the same task as a "fork"
-    // In a full implementation, we would:
-    // 1. Check if acp-factory supports native fork
-    // 2. Use loadSession to clone the conversation state
-    // Since acp-factory doesn't expose these yet, we create a new agent
-    // with the same task description as a simplified fork
-
-    const taskDescription = name
-      ? `[Fork of ${agentId}] ${name}`
-      : `[Fork of ${agentId}] ${originalAgent.task ?? "Forked task"}`;
-
-    const spawned = await this.agentManager.spawn({
-      task: taskDescription,
-      parent: originalAgent.parent ?? null,
-      cwd: this.defaultCwd,
-      subscribeParent: false,
+    // Fork via AgentManager (handles forkWithFlush + new process + loadSession)
+    const forked = await this.agentManager.forkAgent(agentId, {
+      name,
+      cwd: cwd ?? originalAgent.cwd ?? this.defaultCwd,
     });
 
-    // Emit a fork event for tracking (the EventStore records this via spawn)
-    // In a more complete implementation, we'd add a dedicated "fork" event type
+    // Fire-and-forget initial prompt if provided
+    if (prompt) {
+      (async () => {
+        try {
+          for await (const _update of this.agentManager.prompt(
+            forked.id,
+            prompt,
+          )) {
+            // Drain the async iterable
+          }
+        } catch (err) {
+          console.warn(
+            `[MacroAgent] Failed to send initial prompt to forked agent ${forked.id}:`,
+            err,
+          );
+        }
+      })();
+    }
 
     return {
-      newAgentId: spawned.id,
-      newSessionId: spawned.session_id,
+      newAgentId: forked.id,
+      newSessionId: forked.session_id,
       originalAgentId: agentId,
+      providerSessionId: forked.session.id,
     };
   }
 
@@ -1159,6 +1232,41 @@ export class MacroAgent implements Agent {
     }
   }
 
+  /**
+   * Change the permission mode for a running agent at runtime
+   */
+  private async handleSetPermissionMode(
+    params: SetPermissionModeRequest,
+  ): Promise<SetPermissionModeResponse> {
+    const { agentId, permissionMode } = params;
+
+    // Get the current mode before changing
+    const previousMode = this.agentManager.getPermissionMode(
+      agentId as AgentId,
+    );
+
+    // Set the new mode via agent manager
+    const success = this.agentManager.setPermissionMode(
+      agentId as AgentId,
+      permissionMode,
+    );
+
+    if (success) {
+      console.log(
+        `[MacroAgent] Set permission mode for agent ${agentId} from ${previousMode} to ${permissionMode}`,
+      );
+      return {
+        success: true,
+        previousMode: previousMode ?? undefined,
+      };
+    } else {
+      return {
+        success: false,
+        error: `No active session found for agent ${agentId}`,
+      };
+    }
+  }
+
   /**
    * Resume a stopped/failed agent
    */
@@ -1292,7 +1400,7 @@ export class MacroAgent implements Agent {
 
       case "permission_request": {
         // Handle permission_request specially - ACP SDK doesn't recognize it as a session update
-        // We need to call requestPermission on the connection to forward to sudocode
+        // We need to call requestPermission on the connection to forward to the client
 
         // Extract permission request data
         const permReq = sessionUpdate as {
@@ -1311,17 +1419,20 @@ export class MacroAgent implements Agent {
           }>;
         };
 
-        // Get the agent ID for this session to forward the response back
-        const agentId = this.sessionMapper.getAgentId(permReq.sessionId);
+        // Look up agent ID using the ACP session ID (from the client connection),
+        // NOT permReq.sessionId which is the agent's internal session ID.
+        // The session mapper maps ACP session IDs → agent IDs, so using the
+        // internal session ID would fail silently and drop the permission request.
+        const agentId = this.sessionMapper.getAgentId(acpSessionId);
         if (!agentId) {
           console.warn(
-            `[MacroAgent] No agent found for session ${permReq.sessionId}, cannot forward permission request`,
+            `[MacroAgent] No agent found for ACP session ${acpSessionId}, cannot forward permission request`,
           );
           return;
         }
 
-        // Forward to sudocode via requestPermission RPC
-        // This will trigger sudocode's WebSocketClientHandler which will show the prompt
+        // Forward via requestPermission RPC
+        // This will trigger the client's handler which will show the prompt
         try {
           const response = await this.connection.requestPermission({
             sessionId: acpSessionId,
@@ -1396,7 +1507,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 +1515,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 +1757,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,9 +1782,56 @@ 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);
+    }
+  }
+
+  /**
+   * Handle _macro/getModels extension — returns the session's available models.
+   * Claude Code populates models asynchronously after session creation
+   * (via _model_state_update notification), so this allows the TUI to poll
+   * for the model list once it's available.
+   *
+   * Returns full model info (modelId + name) since Claude Code uses shorthand
+   * model IDs ("default", "sonnet") that don't match models.dev. The name
+   * field (e.g., "Claude Sonnet 4") enables better model registry matching.
+   */
+  private handleGetModels(params: { sessionId: string }): {
+    currentModelId: string | null;
+    availableModels: Array<{ modelId: string; name: string }>;
+  } {
+    const { sessionId } = params;
+    const agentId = this.sessionMapper.getAgentId(sessionId);
+    if (!agentId) {
+      return { currentModelId: null, availableModels: [] };
+    }
+    const session = this.agentManager.getSession(agentId);
+    if (!session) {
+      return { currentModelId: null, availableModels: [] };
+    }
+    // Try clientHandler's model info store first (from _model_state_update notification)
+    const clientHandler = (session as unknown as {
+      clientHandler?: {
+        getSessionModelInfo?: (id: string) => {
+          currentModelId: string | null;
+          availableModels: Array<{ modelId: string; name: string }>;
+        } | null;
+      };
+    }).clientHandler;
+    const modelInfo = clientHandler?.getSessionModelInfo?.(session.id);
+    if (modelInfo && modelInfo.availableModels.length > 0) {
+      return modelInfo;
+    }
+    // Fall back to Session.models (from initial session response — just IDs)
+    if (session.models && session.models.length > 0) {
+      return {
+        currentModelId: session.models[0],
+        availableModels: session.models.map((id) => ({ modelId: id, name: id })),
+      };
     }
+    return { currentModelId: null, availableModels: [] };
   }
 
   /**

package/src/acp/types.ts

@@ -291,6 +291,12 @@ export interface ForkAgentRequest {
 
   /** Optional name for the forked agent */
   name?: string;
+
+  /** Optional initial prompt to send after fork */
+  prompt?: string;
+
+  /** Optional working directory override */
+  cwd?: string;
 }
 
 /**
@@ -305,6 +311,9 @@ export interface ForkAgentResponse {
 
   /** Original agent ID (for reference) */
   originalAgentId: AgentId;
+
+  /** Provider session ID (Claude Code UUID) for stream connection */
+  providerSessionId?: string;
 }
 
 // ─────────────────────────────────────────────────────────────────
@@ -605,6 +614,38 @@ export interface CancelPermissionResponse {
   error?: string;
 }
 
+// ─────────────────────────────────────────────────────────────────
+// ACP Extension: _macro/setPermissionMode
+// ─────────────────────────────────────────────────────────────────
+
+/**
+ * Request for _macro/setPermissionMode extension
+ *
+ * Changes the permission mode for a running agent at runtime.
+ * Takes effect on the next permission request; in-flight requests use the old mode.
+ */
+export interface SetPermissionModeRequest {
+  /** Agent ID to change (looked up directly, bypassing session mapper) */
+  agentId: string;
+
+  /** New permission mode */
+  permissionMode: ACPPermissionMode;
+}
+
+/**
+ * Response for _macro/setPermissionMode extension
+ */
+export interface SetPermissionModeResponse {
+  /** Whether the mode was changed successfully */
+  success: boolean;
+
+  /** The previous permission mode (if success) */
+  previousMode?: ACPPermissionMode;
+
+  /** Error message if success is false */
+  error?: string;
+}
+
 // ─────────────────────────────────────────────────────────────────
 // ACP Extension: _macro/resume
 // ─────────────────────────────────────────────────────────────────
@@ -691,8 +732,10 @@ export type ACPExtensionMethod =
   | "_macro/checkCapability"
   | "_macro/respondToPermission"
   | "_macro/cancelPermission"
+  | "_macro/setPermissionMode"
   | "_macro/resume"
-  | "_macro/getHistory";
+  | "_macro/getHistory"
+  | "_macro/getModels";
 
 /**
  * Map of extension methods to their request types
@@ -713,6 +756,7 @@ export interface ACPExtensionRequests {
   "_macro/checkCapability": CheckCapabilityRequest;
   "_macro/respondToPermission": RespondToPermissionRequest;
   "_macro/cancelPermission": CancelPermissionRequest;
+  "_macro/setPermissionMode": SetPermissionModeRequest;
   "_macro/resume": ResumeAgentRequest;
   "_macro/getHistory": GetHistoryRequest;
 }
@@ -736,6 +780,7 @@ export interface ACPExtensionResponses {
   "_macro/checkCapability": CheckCapabilityResponse;
   "_macro/respondToPermission": RespondToPermissionResponse;
   "_macro/cancelPermission": CancelPermissionResponse;
+  "_macro/setPermissionMode": SetPermissionModeResponse;
   "_macro/resume": ResumeAgentResponse;
   "_macro/getHistory": GetHistoryResponse;
 }