macro-agent 0.1.0 → 0.1.2

package/dist/map/adapter/acp-over-map.js

@@ -16,10 +16,10 @@ function extractToolOutput(rawOutput) {
     if (typeof rawOutput === "string")
         return rawOutput;
     if (Array.isArray(rawOutput)) {
-        return rawOutput
+        return (rawOutput
             .filter((item) => item.type === "text" && typeof item.text === "string")
             .map((item) => item.text)
-            .join("\n") || undefined;
+            .join("\n") || undefined);
     }
     return undefined;
 }
@@ -31,15 +31,39 @@ export class ACPOverMAPHandler {
     eventStore;
     taskManager;
     defaultCwd;
+    onAgentRegistered;
     /** Stream states by streamId */
     streams = new Map();
     /** Session mapper for ACP session -> Agent mapping */
-    sessionMapper = new SessionMapper();
+    sessionMapper;
     constructor(config) {
         this.agentManager = config.agentManager;
         this.eventStore = config.eventStore;
         this.taskManager = config.taskManager;
         this.defaultCwd = config.defaultCwd ?? process.cwd();
+        this.onAgentRegistered = config.onAgentRegistered;
+        // Initialize session mapper with EventStore for persistence and recovery
+        this.sessionMapper = new SessionMapper(this.eventStore);
+        const recovered = this.sessionMapper.recoverFromStore();
+        if (recovered > 0) {
+            console.error(`[ACP-over-MAP] Recovered ${recovered} session(s) from store`);
+        }
+    }
+    /**
+     * Notify subscribers that a new agent was registered.
+     * Looks up agent details from EventStore and calls the onAgentRegistered callback.
+     */
+    notifyAgentRegistered(agentId) {
+        if (!this.onAgentRegistered)
+            return;
+        const agent = this.eventStore.getAgent(agentId);
+        this.onAgentRegistered({
+            id: agentId,
+            name: agent?.name,
+            role: agent?.role,
+            parent: agent?.parent ?? undefined,
+            metadata: agent?.metadata,
+        });
     }
     /**
      * Abort all active streams targeting a specific agent.
@@ -136,6 +160,14 @@ export class ACPOverMAPHandler {
             throw new Error("Stream already initialized");
         }
         streamState.initialized = true;
+        // Extract permission mode from _meta.macroConfig if provided
+        const meta = params?._meta;
+        const macroConfig = meta?.macroConfig;
+        const defaultSubAgentConfig = macroConfig?.defaultSubAgentConfig;
+        if (defaultSubAgentConfig?.permissionMode) {
+            streamState.permissionMode =
+                defaultSubAgentConfig.permissionMode;
+        }
         return {
             protocolVersion: 1,
             agentCapabilities: {
@@ -162,6 +194,7 @@ export class ACPOverMAPHandler {
         const spawned = await this.agentManager.getOrCreateHeadManager({
             cwd: workingDir,
             forceNew: true,
+            permissionMode: streamState.permissionMode,
         });
         const sessionId = spawned.session_id;
         streamState.sessionId = sessionId;
@@ -169,6 +202,8 @@ export class ACPOverMAPHandler {
         // Create session mapping
         this.sessionMapper.createMapping(sessionId, spawned.id);
         console.error(`[ACP-over-MAP] Created session ${sessionId} -> agent ${spawned.id}`);
+        // Notify subscribers that a new agent was registered
+        this.notifyAgentRegistered(spawned.id);
         // Emit session_info_update so client has title/timestamps
         this.emitSessionInfo(streamState, sessionId, emitNotification);
         return { sessionId };
@@ -177,7 +212,7 @@ export class ACPOverMAPHandler {
         if (!streamState.initialized) {
             throw new Error("Must call initialize before loadSession");
         }
-        const { sessionId: rawSessionId, cwd, _meta } = params ?? {};
+        const { sessionId: rawSessionId, cwd, _meta, } = params ?? {};
         if (!rawSessionId) {
             throw new Error("sessionId required");
         }
@@ -191,6 +226,32 @@ export class ACPOverMAPHandler {
             }
             sessionId = agent.session_id;
             console.error(`[ACP-over-MAP] loadSession: Resolved agentId ${metaAgentId} to session ${sessionId}`);
+            // Handle the agent directly — works for both head managers and sub-agents.
+            // The previous code only searched listHeadManagers(), so sub-agents
+            // were never found and a new head manager was created instead.
+            if (this.agentManager.hasActiveSession(metaAgentId)) {
+                console.error(`[ACP-over-MAP] loadSession: Reusing active session for agent ${metaAgentId}`);
+            }
+            else {
+                // Agent exists but no active session — resume it
+                console.error(`[ACP-over-MAP] loadSession: Resuming agent ${metaAgentId}`);
+                try {
+                    await this.agentManager.resume(metaAgentId, streamState.permissionMode);
+                }
+                catch (resumeErr) {
+                    // ALREADY_RUNNING can happen in a race — safe to ignore
+                    const code = resumeErr.code;
+                    if (code !== "ALREADY_RUNNING") {
+                        throw resumeErr;
+                    }
+                    console.error(`[ACP-over-MAP] loadSession: Agent ${metaAgentId} already running (race), continuing`);
+                }
+            }
+            streamState.sessionId = sessionId;
+            streamState.agentId = metaAgentId;
+            this.sessionMapper.createMapping(sessionId, metaAgentId);
+            this.emitSessionInfo(streamState, sessionId, emitNotification);
+            return { sessionId };
         }
         const workingDir = cwd ?? this.defaultCwd;
         // Try to find an existing head manager with this session ID
@@ -208,7 +269,7 @@ export class ACPOverMAPHandler {
             }
             // Agent exists but no active session - resume it
             console.error(`[ACP-over-MAP] loadSession: Resuming stopped agent ${existing.id}`);
-            const spawned = await this.agentManager.resume(existing.id);
+            const spawned = await this.agentManager.resume(existing.id, streamState.permissionMode);
             streamState.sessionId = sessionId;
             streamState.agentId = spawned.id;
             this.sessionMapper.createMapping(sessionId, spawned.id);
@@ -220,10 +281,13 @@ export class ACPOverMAPHandler {
         const spawned = await this.agentManager.getOrCreateHeadManager({
             cwd: workingDir,
             sessionId,
+            permissionMode: streamState.permissionMode,
         });
         streamState.sessionId = sessionId;
         streamState.agentId = spawned.id;
         this.sessionMapper.createMapping(sessionId, spawned.id);
+        // Notify subscribers that a new agent was registered
+        this.notifyAgentRegistered(spawned.id);
         this.emitSessionInfo(streamState, sessionId, emitNotification);
         return { sessionId };
     }
@@ -310,6 +374,10 @@ export class ACPOverMAPHandler {
                 // Accumulate content for history persistence (preserving text/tool interleaving order)
                 const u = update;
                 const updateType = u.sessionUpdate ?? u.type;
+                // Annotate permission_request updates with agentId so clients can respond
+                if (updateType === "permission_request") {
+                    u._agentId = agentId;
+                }
                 if (updateType === "agent_message_chunk") {
                     const content = u.content;
                     if (content?.text) {
@@ -328,7 +396,8 @@ export class ACPOverMAPHandler {
                         latestPlan = entries;
                     }
                 }
-                else if (updateType === "tool_call" || updateType === "tool_call_update") {
+                else if (updateType === "tool_call" ||
+                    updateType === "tool_call_update") {
                     const toolCallId = u.toolCallId;
                     const status = u.status;
                     const meta = u._meta;
@@ -342,7 +411,9 @@ export class ACPOverMAPHandler {
                     }
                     if (status === "completed" || status === "failed") {
                         // Merge cached info for tool_call_update events that lack title/input
-                        const cached = toolCallId ? toolInfoCache.get(toolCallId) : undefined;
+                        const cached = toolCallId
+                            ? toolInfoCache.get(toolCallId)
+                            : undefined;
                         buffer.parts.push({
                             type: "tool",
                             toolCallId,
@@ -373,10 +444,30 @@ export class ACPOverMAPHandler {
             return { stopReason };
         }
         catch (error) {
-            console.error(`[ACP-over-MAP] Prompt error:`, error);
+            // Extract a meaningful error message — errors from the ACP SDK may be
+            // plain objects ({code, message}) rather than Error instances.
+            let errorMessage;
+            if (error instanceof Error) {
+                errorMessage = error.message;
+            }
+            else if (typeof error === "object" &&
+                error !== null &&
+                "message" in error &&
+                typeof error.message === "string") {
+                errorMessage = error.message;
+            }
+            else {
+                try {
+                    errorMessage = JSON.stringify(error);
+                }
+                catch {
+                    errorMessage = String(error);
+                }
+            }
+            console.error(`[ACP-over-MAP] Prompt error for agent ${agentId}:`, errorMessage);
             return {
                 stopReason: "end_turn",
-                error: error instanceof Error ? error.message : String(error),
+                error: errorMessage,
             };
         }
         finally {
@@ -438,7 +529,11 @@ export class ACPOverMAPHandler {
                     task,
                     cwd: cwd ?? this.defaultCwd,
                     role: "worker",
+                    topics,
+                    config,
                 });
+                // Notify subscribers that a new agent was registered
+                this.notifyAgentRegistered(spawned.id);
                 return {
                     agentId: spawned.id,
                     sessionId: spawned.session_id,
@@ -470,8 +565,17 @@ export class ACPOverMAPHandler {
                 if (!agent) {
                     throw new Error(`Agent not found: ${agentId}`);
                 }
+                // If the agent is already running, return its current state
+                // instead of throwing. The caller likely just wants to ensure
+                // the agent is active, which it already is.
                 if (agent.state !== "stopped" && agent.state !== "failed") {
-                    throw new Error(`Agent ${agentId} is ${agent.state} — only stopped or failed agents can be resumed`);
+                    console.error(`[ACP-over-MAP] _macro/resume: Agent ${agentId} is already ${agent.state}, returning current state`);
+                    return {
+                        success: true,
+                        agentId: agent.id,
+                        sessionId: agent.session_id,
+                        alreadyRunning: true,
+                    };
                 }
                 const spawned = await this.agentManager.resume(agentId);
                 return {
@@ -481,18 +585,18 @@ export class ACPOverMAPHandler {
                 };
             }
             case "_macro/getHistory": {
-                const { sessionId, agentId: historyAgentId, limit } = methodParams;
+                const { sessionId, agentId: historyAgentId, limit, } = methodParams;
                 // Resolve conversationId: prefer agentId lookup (resolves to the
                 // original session_id where turns were recorded), fall back to
                 // explicit sessionId. This allows history to survive across server
                 // restarts even when the ACP session ID changes (e.g., resume()
                 // fails → TUI creates new session with different ID).
+                const agent = historyAgentId
+                    ? this.eventStore.getAgent(historyAgentId)
+                    : undefined;
                 let conversationId;
-                if (historyAgentId) {
-                    const agent = this.eventStore.getAgent(historyAgentId);
-                    if (agent) {
-                        conversationId = agent.session_id;
-                    }
+                if (agent) {
+                    conversationId = agent.session_id;
                 }
                 if (!conversationId) {
                     conversationId = sessionId;
@@ -500,13 +604,39 @@ export class ACPOverMAPHandler {
                 if (!conversationId) {
                     return { turns: [] };
                 }
-                const turns = this.eventStore.listTurns({
-                    conversationId,
-                    order: "asc",
-                    limit: limit ?? 200,
-                });
-                // Include persisted plan and agent cwd if available
-                const agent = historyAgentId ? this.eventStore.getAgent(historyAgentId) : undefined;
+                // For forked agents, include the source agent's conversation history
+                // (pre-fork turns) followed by this agent's own turns.
+                // Only include source turns from before the fork to avoid leaking
+                // turns that the source recorded after the fork point.
+                const sourceAgentId = agent?.metadata?.fork_of;
+                let turns;
+                if (sourceAgentId) {
+                    const sourceAgent = this.eventStore.getAgent(sourceAgentId);
+                    const sourceConversationId = sourceAgent?.session_id;
+                    const forkTimestamp = agent.created_at;
+                    const sourceTurns = sourceConversationId
+                        ? this.eventStore
+                            .listTurns({
+                            conversationId: sourceConversationId,
+                            order: "asc",
+                            limit: limit ?? 200,
+                        })
+                            .filter((t) => t.timestamp <= forkTimestamp)
+                        : [];
+                    const ownTurns = this.eventStore.listTurns({
+                        conversationId,
+                        order: "asc",
+                        limit: limit ?? 200,
+                    });
+                    turns = [...sourceTurns, ...ownTurns];
+                }
+                else {
+                    turns = this.eventStore.listTurns({
+                        conversationId,
+                        order: "asc",
+                        limit: limit ?? 200,
+                    });
+                }
                 const plan = agent?.plan ?? [];
                 return {
                     turns: turns.map((turn) => ({
@@ -520,6 +650,237 @@ export class ACPOverMAPHandler {
                     cwd: agent?.cwd ?? null,
                 };
             }
+            case "_macro/respondToPermission": {
+                const { agentId: targetAgentId, requestId, optionId, } = methodParams;
+                if (!targetAgentId || !requestId || !optionId) {
+                    throw new Error("agentId, requestId, and optionId are required");
+                }
+                const success = this.agentManager.respondToPermission(targetAgentId, requestId, optionId);
+                return { success };
+            }
+            case "_macro/cancelPermission": {
+                const { agentId: targetAgentId, requestId } = methodParams;
+                if (!targetAgentId || !requestId) {
+                    throw new Error("agentId and requestId are required");
+                }
+                const success = this.agentManager.cancelPermission(targetAgentId, requestId);
+                return { success };
+            }
+            case "_macro/setPermissionMode": {
+                const { agentId: targetAgentId, permissionMode } = methodParams;
+                if (!targetAgentId || !permissionMode) {
+                    throw new Error("agentId and permissionMode are required");
+                }
+                const previousMode = this.agentManager.getPermissionMode(targetAgentId);
+                const success = this.agentManager.setPermissionMode(targetAgentId, permissionMode);
+                if (success) {
+                    return { success: true, previousMode: previousMode ?? undefined };
+                }
+                return {
+                    success: false,
+                    error: `No active session found for agent ${targetAgentId}`,
+                };
+            }
+            case "_macro/forkAgent": {
+                const { agentId, name, prompt, cwd } = methodParams;
+                if (!agentId) {
+                    throw new Error("agentId is required");
+                }
+                const sourceAgent = this.eventStore.getAgent(agentId);
+                if (!sourceAgent) {
+                    throw new Error(`Agent not found: ${agentId}`);
+                }
+                const forked = await this.agentManager.forkAgent(agentId, {
+                    name,
+                    prompt,
+                    cwd: cwd ?? sourceAgent.cwd ?? this.defaultCwd,
+                });
+                // Fire-and-forget initial prompt if provided
+                if (prompt) {
+                    (async () => {
+                        try {
+                            for await (const _update of this.agentManager.prompt(forked.id, prompt)) {
+                                // drain iterator
+                            }
+                        }
+                        catch {
+                            // best-effort
+                        }
+                    })();
+                }
+                return {
+                    newAgentId: forked.id,
+                    newSessionId: forked.session_id,
+                    originalAgentId: agentId,
+                    providerSessionId: forked.session?.id,
+                };
+            }
+            case "_macro/agents/update": {
+                const { agentId, name, plan, metadata } = methodParams;
+                if (!agentId) {
+                    throw new Error("agentId is required");
+                }
+                if (name === undefined &&
+                    plan === undefined &&
+                    metadata === undefined) {
+                    throw new Error("At least one field to update is required (name, plan, or metadata)");
+                }
+                if (name !== undefined && !name.trim()) {
+                    throw new Error("name must not be empty");
+                }
+                const agent = this.eventStore.getAgent(agentId);
+                if (!agent) {
+                    throw new Error(`Agent not found: ${agentId}`);
+                }
+                const updates = {};
+                const updatedFields = [];
+                if (name !== undefined) {
+                    updates.name = name.trim();
+                    updatedFields.push("name");
+                }
+                if (plan !== undefined) {
+                    updates.plan = plan;
+                    updatedFields.push("plan");
+                }
+                if (metadata !== undefined) {
+                    updates.metadata = metadata;
+                    updatedFields.push("metadata");
+                }
+                this.eventStore.updateAgentMetadata(agentId, updates);
+                return {
+                    success: true,
+                    agentId,
+                    updated: updatedFields,
+                };
+            }
+            case "_macro/getModels": {
+                const { sessionId } = methodParams;
+                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.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: [] };
+            }
+            case "_session/setCompaction": {
+                // Compaction is handled internally by the agent process.
+                // Accept the request as a no-op so the client doesn't get an error.
+                // TODO: Make sure this overrides if needed.
+                return { success: true };
+            }
+            // ── Task Management Extensions ────────────────────────────────
+            // These mirror the registered adapter extensions (_macro/task/*)
+            // so they're accessible via ACP-over-MAP streams.
+            case "_macro/task/list": {
+                const { filter } = (methodParams ?? {});
+                const taskFilter = filter
+                    ? {
+                        status: filter.status,
+                        assigned_agent: filter.assignedAgent,
+                        parent_task: filter.parentTask,
+                        created_by: filter.createdBy,
+                        rootTasksOnly: filter.rootTasksOnly,
+                    }
+                    : undefined;
+                const tasks = this.taskManager.list(taskFilter);
+                return {
+                    tasks: tasks.map((t) => ({
+                        id: t.id,
+                        description: t.description,
+                        status: t.status,
+                        assignedAgent: t.assigned_agent,
+                        createdBy: t.created_by,
+                        createdAt: t.created_at,
+                        parentTask: t.parent_task,
+                        isBlocked: t.isBlocked,
+                        externalId: t.external_id,
+                    })),
+                };
+            }
+            case "_macro/task/get": {
+                const { taskId } = methodParams;
+                if (!taskId)
+                    throw new Error("taskId is required");
+                const task = this.taskManager.get(taskId);
+                if (!task)
+                    throw new Error(`Task not found: ${taskId}`);
+                return {
+                    task: {
+                        id: task.id,
+                        description: task.description,
+                        status: task.status,
+                        assignedAgent: task.assigned_agent,
+                        createdBy: task.created_by,
+                        createdAt: task.created_at,
+                        parentTask: task.parent_task,
+                        isBlocked: task.isBlocked,
+                        externalId: task.external_id,
+                    },
+                };
+            }
+            case "_macro/task/create": {
+                const { description, parentTask, externalId } = methodParams;
+                if (!description)
+                    throw new Error("description is required");
+                // Determine who is creating the task — use the stream's agent or a default
+                const createdBy = (streamState.agentId ?? "tui");
+                const task = this.taskManager.create({
+                    description,
+                    created_by: createdBy,
+                    parent_task: parentTask,
+                });
+                return {
+                    task: {
+                        id: task.id,
+                        description: task.description,
+                        status: task.status,
+                        assignedAgent: task.assigned_agent,
+                        createdBy: task.created_by,
+                        createdAt: task.created_at,
+                        parentTask: task.parent_task,
+                    },
+                };
+            }
+            case "_macro/task/assign": {
+                const { taskId, agentId, role } = methodParams;
+                if (!taskId)
+                    throw new Error("taskId is required");
+                if (!agentId)
+                    throw new Error("agentId is required");
+                this.taskManager.assign(taskId, agentId, role);
+                return { success: true };
+            }
+            case "_macro/task/complete": {
+                const { taskId, outputs } = methodParams;
+                if (!taskId)
+                    throw new Error("taskId is required");
+                // Update status to completed
+                this.taskManager.updateStatus(taskId, "completed");
+                // If outputs provided, update task metadata
+                if (outputs) {
+                    this.taskManager.update(taskId, { outputs });
+                }
+                return { success: true };
+            }
             default:
                 throw new Error(`Unknown extension method: ${method}`);
         }