macro-agent 0.2.4 → 0.2.6

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

@@ -0,0 +1,1024 @@
+/**
+ * ACP-over-MAP Handler
+ *
+ * Handles ACP protocol messages that arrive via MAP instead of direct WebSocket.
+ * Provides a bridge between MAP messaging and the MacroAgent ACP implementation.
+ *
+ * This allows external clients to communicate with macro-agent agents using
+ * ACP protocol semantics over the MAP transport layer.
+ */
+import { SessionMapper } from "../../acp/session-mapper.js";
+// ─────────────────────────────────────────────────────────────────
+// Helpers
+// ─────────────────────────────────────────────────────────────────
+/** Extract a plain-text output string from `rawOutput` (string | ContentBlock[] | undefined). */
+function extractToolOutput(rawOutput) {
+    if (typeof rawOutput === "string")
+        return rawOutput;
+    if (Array.isArray(rawOutput)) {
+        return (rawOutput
+            .filter((item) => item.type === "text" && typeof item.text === "string")
+            .map((item) => item.text)
+            .join("\n") || undefined);
+    }
+    return undefined;
+}
+// ─────────────────────────────────────────────────────────────────
+// ACP-over-MAP Handler
+// ─────────────────────────────────────────────────────────────────
+export class ACPOverMAPHandler {
+    agentManager;
+    eventStore;
+    taskManager;
+    defaultCwd;
+    onAgentRegistered;
+    /** Stream states by streamId */
+    streams = new Map();
+    /** Session mapper for ACP session -> Agent mapping */
+    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.
+     * Called when an agent is stopped via MAP protocol to interrupt
+     * any in-progress ACP prompt streaming.
+     */
+    abortStreamsForAgent(agentId) {
+        for (const [streamId, streamState] of this.streams) {
+            if (streamState.agentId === agentId) {
+                console.error(`[ACP-over-MAP] Aborting stream ${streamId} for stopped agent ${agentId}`);
+                streamState.abortController.abort();
+            }
+        }
+    }
+    /**
+     * Process an ACP request and return the response.
+     * @param targetAgentId - Target agent for the request
+     * @param envelope - ACP request envelope
+     * @param emitNotification - Optional callback to emit notifications (for streaming updates)
+     */
+    async processRequest(targetAgentId, envelope, emitNotification) {
+        const { acp, acpContext } = envelope;
+        const { streamId, sessionId } = acpContext;
+        const method = acp.method;
+        console.error(`[ACP-over-MAP] Processing - streamId=${streamId} method=${method}`);
+        // Get or create stream state
+        let streamState = this.streams.get(streamId);
+        if (!streamState) {
+            streamState = {
+                initialized: false,
+                streamId,
+                abortController: new AbortController(),
+            };
+            this.streams.set(streamId, streamState);
+        }
+        let result;
+        let error;
+        try {
+            switch (method) {
+                case "initialize":
+                    result = await this.handleInitialize(streamState, acp.params);
+                    break;
+                case "session/new":
+                    result = await this.handleNewSession(streamState, acp.params, emitNotification);
+                    break;
+                case "session/load":
+                    result = await this.handleLoadSession(streamState, acp.params, emitNotification);
+                    break;
+                case "authenticate":
+                    result = await this.handleAuthenticate(acp.params);
+                    break;
+                case "session/prompt":
+                    result = await this.handlePrompt(streamState, acp.params, sessionId, emitNotification);
+                    break;
+                case "session/cancel":
+                    result = await this.handleCancel(streamState, acp.params, sessionId);
+                    break;
+                default:
+                    // Check for extension methods
+                    if (method?.startsWith("_")) {
+                        result = await this.handleExtension(streamState, method, acp.params);
+                    }
+                    else {
+                        throw new Error(`Unknown ACP method: ${method}`);
+                    }
+            }
+        }
+        catch (e) {
+            console.error(`[ACP-over-MAP] Error processing ${method}:`, e);
+            error = {
+                code: -32603,
+                message: e instanceof Error ? e.message : String(e),
+            };
+        }
+        // Build response envelope
+        return {
+            acp: {
+                jsonrpc: "2.0",
+                id: acp.id,
+                ...(error ? { error } : { result }),
+            },
+            acpContext: {
+                streamId,
+                sessionId: streamState.sessionId,
+                direction: "agent-to-client",
+            },
+        };
+    }
+    // ─────────────────────────────────────────────────────────────────
+    // Core ACP Methods
+    // ─────────────────────────────────────────────────────────────────
+    async handleInitialize(streamState, params) {
+        if (streamState.initialized) {
+            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: {
+                loadSession: true,
+                _meta: {
+                    extensions: [
+                        "_macro/spawnAgent",
+                        "_macro/getHierarchy",
+                        "_macro/getTask",
+                    ],
+                    agentType: "macro-agent",
+                    transport: "acp-over-map",
+                },
+            },
+        };
+    }
+    async handleNewSession(streamState, params, emitNotification) {
+        if (!streamState.initialized) {
+            throw new Error("Must call initialize before newSession");
+        }
+        const { cwd, mcpServers } = params ?? {};
+        const workingDir = cwd ?? this.defaultCwd;
+        // Spawn a new head manager for this session
+        const spawned = await this.agentManager.getOrCreateHeadManager({
+            cwd: workingDir,
+            forceNew: true,
+            permissionMode: streamState.permissionMode,
+        });
+        const sessionId = spawned.session_id;
+        streamState.sessionId = sessionId;
+        streamState.agentId = spawned.id;
+        // 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 };
+    }
+    async handleLoadSession(streamState, params, emitNotification) {
+        if (!streamState.initialized) {
+            throw new Error("Must call initialize before loadSession");
+        }
+        const { sessionId: rawSessionId, cwd, _meta, } = params ?? {};
+        if (!rawSessionId) {
+            throw new Error("sessionId required");
+        }
+        // Extension: If _meta.agentId provided, look up session from agent record
+        let sessionId = rawSessionId;
+        const metaAgentId = _meta?.agentId;
+        if (metaAgentId) {
+            const agent = this.eventStore.getAgent(metaAgentId);
+            if (!agent) {
+                throw new Error(`Agent not found: ${metaAgentId}`);
+            }
+            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
+        const headManagers = this.agentManager.listHeadManagers();
+        const existing = headManagers.find((hm) => hm.session_id === sessionId);
+        if (existing) {
+            // Check if the agent already has an active session
+            if (this.agentManager.hasActiveSession(existing.id)) {
+                console.error(`[ACP-over-MAP] loadSession: Reusing existing session for agent ${existing.id}`);
+                streamState.sessionId = sessionId;
+                streamState.agentId = existing.id;
+                this.sessionMapper.createMapping(sessionId, existing.id);
+                this.emitSessionInfo(streamState, sessionId, emitNotification);
+                return { sessionId };
+            }
+            // 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, streamState.permissionMode);
+            streamState.sessionId = sessionId;
+            streamState.agentId = spawned.id;
+            this.sessionMapper.createMapping(sessionId, spawned.id);
+            this.emitSessionInfo(streamState, sessionId, emitNotification);
+            return { sessionId };
+        }
+        // No existing agent found - create new with the specified session ID
+        console.error(`[ACP-over-MAP] loadSession: Creating new agent for session ${sessionId}`);
+        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 };
+    }
+    async handleAuthenticate(_params) {
+        // No authentication required
+        return {};
+    }
+    async handlePrompt(streamState, params, sessionIdFromContext, emitNotification) {
+        const { prompt, sessionId: paramSessionId } = params ?? {};
+        // Prefer the server's resolved session ID (set during loadSession) over the
+        // client's acpContext.sessionId which may be stale (e.g., "_resolve_" sentinel)
+        const sessionId = streamState.sessionId ?? paramSessionId ?? sessionIdFromContext;
+        if (!sessionId) {
+            throw new Error("No session - call newSession or loadSession first");
+        }
+        // Get the mapped agent
+        const agentId = this.sessionMapper.getAgentId(sessionId);
+        if (!agentId) {
+            throw new Error(`No agent mapped for session ${sessionId}`);
+        }
+        // Reset abort controller if needed
+        if (streamState.abortController.signal.aborted) {
+            streamState.abortController = new AbortController();
+        }
+        // Extract message content
+        let messageContent;
+        if (prompt && Array.isArray(prompt)) {
+            messageContent = prompt
+                .filter((block) => block.type === "text" && block.text)
+                .map((block) => block.text)
+                .join("\n");
+        }
+        else if (params?.messages) {
+            // Handle messages format (role/content array)
+            const messages = params.messages;
+            messageContent = messages.map((m) => m.content).join("\n");
+        }
+        else {
+            messageContent = JSON.stringify(params);
+        }
+        console.error(`[ACP-over-MAP] Prompting agent ${agentId} with: ${messageContent.slice(0, 100)}...`);
+        // Mark session as processing
+        this.sessionMapper.setProcessing(sessionId, true);
+        // Helper to emit session update notifications
+        const emitSessionUpdate = (update) => {
+            if (!emitNotification)
+                return;
+            const notification = {
+                acp: {
+                    jsonrpc: "2.0",
+                    method: "session/update",
+                    params: {
+                        sessionId: sessionId,
+                        update: update,
+                    },
+                },
+                acpContext: {
+                    streamId: streamState.streamId,
+                    sessionId: sessionId,
+                    direction: "agent-to-client",
+                },
+            };
+            emitNotification(notification);
+        };
+        // Ensure conversation exists in EventStore for history persistence
+        this.ensureConversation(sessionId, agentId);
+        // Accumulate response content for history recording
+        const buffer = {
+            parts: [],
+        };
+        // Track latest plan for persistence
+        let latestPlan = null;
+        // Track tool info from initial tool_call events (title, name, input)
+        // so we can merge them when tool_call_update arrives with status "completed"
+        const toolInfoCache = new Map();
+        try {
+            // Stream responses from the agent
+            let updateCount = 0;
+            for await (const update of this.agentManager.prompt(agentId, messageContent)) {
+                // Check for cancellation
+                if (streamState.abortController.signal.aborted) {
+                    return { stopReason: "cancelled" };
+                }
+                // 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) {
+                        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 === "plan") {
+                    const entries = u.entries;
+                    if (entries) {
+                        latestPlan = entries;
+                    }
+                }
+                else if (updateType === "tool_call" ||
+                    updateType === "tool_call_update") {
+                    const toolCallId = u.toolCallId;
+                    const status = u.status;
+                    const meta = u._meta;
+                    // Cache tool info from initial tool_call events
+                    if (updateType === "tool_call" && toolCallId) {
+                        toolInfoCache.set(toolCallId, {
+                            title: u.title,
+                            name: meta?.claudeCode?.toolName,
+                            input: u.rawInput,
+                        });
+                    }
+                    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: u.title ?? cached?.title,
+                            name: meta?.claudeCode?.toolName ?? cached?.name,
+                            status: u.status,
+                            input: u.rawInput ?? cached?.input,
+                            output: extractToolOutput(u.rawOutput),
+                        });
+                    }
+                }
+                // Stream the update back to the client
+                emitSessionUpdate(update);
+                updateCount++;
+            }
+            // Check if the loop ended because of cancellation
+            const wasCancelled = streamState.abortController.signal.aborted;
+            const stopReason = wasCancelled ? "cancelled" : "end_turn";
+            console.error(`[ACP-over-MAP] Prompt completed for agent ${agentId}, ${updateCount} updates, stopReason=${stopReason}`);
+            // Persist conversation turns for history
+            this.recordPromptTurns(sessionId, agentId, messageContent, buffer);
+            // Persist latest plan in EventStore for history loading across restarts
+            if (latestPlan) {
+                this.eventStore.updateAgentPlan(agentId, latestPlan);
+            }
+            // Emit updated session info after prompt completes
+            this.emitSessionInfo(streamState, sessionId, emitNotification);
+            return { stopReason };
+        }
+        catch (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: errorMessage,
+            };
+        }
+        finally {
+            this.sessionMapper.setProcessing(sessionId, false);
+        }
+    }
+    async handleCancel(streamState, params, sessionIdFromContext) {
+        const { sessionId: paramSessionId } = params ?? {};
+        // Prefer server's resolved session ID over client's potentially stale one
+        const sessionId = streamState.sessionId ?? paramSessionId ?? sessionIdFromContext;
+        const agentId = sessionId
+            ? this.sessionMapper.getAgentId(sessionId)
+            : streamState.agentId;
+        console.error(`[ACP-over-MAP] Cancel - streamId=${streamState.streamId} sessionId=${sessionId} agentId=${agentId}`);
+        // 1. Abort the for-await loop in handlePrompt so it stops yielding updates
+        streamState.abortController.abort();
+        // 2. Cancel the agent's active session (sends session/cancel to the subprocess)
+        // This does NOT terminate the agent — it only interrupts the current prompt.
+        // The subprocess stays alive and can accept new prompts.
+        // Use map/agents/stop for full agent termination.
+        if (agentId) {
+            const session = this.agentManager.getSession(agentId);
+            if (session) {
+                try {
+                    await session.cancel();
+                    console.error(`[ACP-over-MAP] Session cancelled for agent ${agentId}`);
+                }
+                catch (error) {
+                    console.warn(`[ACP-over-MAP] session.cancel() failed for ${agentId}:`, error);
+                }
+            }
+        }
+        return { cancelled: true };
+    }
+    // ─────────────────────────────────────────────────────────────────
+    // Extension Methods
+    // ─────────────────────────────────────────────────────────────────
+    async handleExtension(streamState, method, params) {
+        const methodParams = params ?? {};
+        switch (method) {
+            case "_macro/spawnAgent": {
+                const { task, cwd, topics, config, parentId } = methodParams;
+                // Use the stream's agent as parent, or find head manager
+                let parent = streamState.agentId;
+                if (parentId) {
+                    parent = parentId;
+                }
+                else if (!parent) {
+                    const headManagers = this.agentManager.listHeadManagers();
+                    if (headManagers.length > 0) {
+                        parent = headManagers[0].id;
+                    }
+                }
+                if (!parent) {
+                    throw new Error("No parent agent available for spawning");
+                }
+                const spawned = await this.agentManager.spawn({
+                    parent,
+                    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,
+                };
+            }
+            case "_macro/getHierarchy": {
+                const agents = this.agentManager.list();
+                return {
+                    agents: agents.map((a) => ({
+                        id: a.id,
+                        role: a.role,
+                        state: a.state,
+                        parent: a.parent,
+                        createdAt: a.created_at,
+                    })),
+                };
+            }
+            case "_macro/getTask": {
+                const { taskId } = methodParams;
+                const task = await this.taskManager.get(taskId);
+                return { task };
+            }
+            case "_macro/resume": {
+                const { agentId } = methodParams;
+                if (!agentId) {
+                    throw new Error("agentId is required");
+                }
+                const agent = this.eventStore.getAgent(agentId);
+                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") {
+                    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 {
+                    success: true,
+                    agentId: spawned.id,
+                    sessionId: spawned.session_id,
+                };
+            }
+            case "_macro/getHistory": {
+                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 (agent) {
+                    conversationId = agent.session_id;
+                }
+                if (!conversationId) {
+                    conversationId = sessionId;
+                }
+                if (!conversationId) {
+                    return { turns: [] };
+                }
+                // 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) => ({
+                        role: turn.contentType === "user_prompt"
+                            ? "user"
+                            : "assistant",
+                        timestamp: turn.timestamp,
+                        content: turn.content,
+                    })),
+                    plan,
+                    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}`);
+        }
+    }
+    // ─────────────────────────────────────────────────────────────────
+    // History Persistence
+    // ─────────────────────────────────────────────────────────────────
+    /**
+     * Ensure a conversation exists in the EventStore for a given session.
+     * This must be called before recording turns.
+     */
+    ensureConversation(acpSessionId, agentId) {
+        if (typeof this.eventStore.getConversation !== "function") {
+            return;
+        }
+        const existing = this.eventStore.getConversation(acpSessionId);
+        if (existing)
+            return;
+        try {
+            this.eventStore.emit({
+                type: "conversation",
+                source: { agent_id: agentId },
+                payload: {
+                    action: "created",
+                    conversation_id: acpSessionId,
+                    conversation_type: "session",
+                    subject: `ACP session ${acpSessionId}`,
+                },
+            });
+        }
+        catch (error) {
+            console.warn(`[ACP-over-MAP] Failed to create conversation for session ${acpSessionId}:`, error instanceof Error ? error.message : String(error));
+        }
+    }
+    /**
+     * Record user and assistant turns after a prompt completes.
+     * Mirrors MacroAgent.recordPromptTurns() for the ACP-over-MAP path.
+     */
+    recordPromptTurns(acpSessionId, agentId, userMessage, buffer) {
+        const now = Date.now();
+        try {
+            // Record user turn
+            if (userMessage) {
+                this.eventStore.emit({
+                    type: "turn",
+                    source: { agent_id: agentId },
+                    payload: {
+                        action: "recorded",
+                        turn_id: `turn_user_${now}_${Math.random().toString(36).slice(2, 8)}`,
+                        conversation_id: acpSessionId,
+                        participant: "user",
+                        timestamp: now,
+                        content_type: "user_prompt",
+                        content: userMessage,
+                        source_type: "explicit",
+                    },
+                });
+            }
+            // Record assistant turn with accumulated content (parts already in order)
+            const parts = buffer.parts;
+            if (parts.length > 0) {
+                this.eventStore.emit({
+                    type: "turn",
+                    source: { agent_id: agentId },
+                    payload: {
+                        action: "recorded",
+                        turn_id: `turn_asst_${now}_${Math.random().toString(36).slice(2, 8)}`,
+                        conversation_id: acpSessionId,
+                        participant: agentId,
+                        timestamp: now + 1,
+                        content_type: "assistant_response",
+                        content: { parts },
+                        source_type: "explicit",
+                    },
+                });
+            }
+        }
+        catch (error) {
+            console.warn(`[ACP-over-MAP] Failed to record turns for session ${acpSessionId}:`, error instanceof Error ? error.message : String(error));
+        }
+    }
+    // ─────────────────────────────────────────────────────────────────
+    // Session Info
+    // ─────────────────────────────────────────────────────────────────
+    /**
+     * Emit a session_info_update notification with title and timestamps.
+     * Uses agent task as title and session mapping timestamps.
+     */
+    emitSessionInfo(streamState, sessionId, emitNotification) {
+        if (!emitNotification)
+            return;
+        const mapping = this.sessionMapper.getMapping(sessionId);
+        const agentId = streamState.agentId;
+        const agent = agentId ? this.eventStore.getAgent(agentId) : null;
+        const title = agent?.task ?? null;
+        const updatedAt = new Date(mapping?.updatedAt ?? Date.now()).toISOString();
+        const notification = {
+            acp: {
+                jsonrpc: "2.0",
+                method: "session/update",
+                params: {
+                    sessionId,
+                    update: {
+                        sessionUpdate: "session_info_update",
+                        title,
+                        updatedAt,
+                    },
+                },
+            },
+            acpContext: {
+                streamId: streamState.streamId,
+                sessionId,
+                direction: "agent-to-client",
+            },
+        };
+        emitNotification(notification);
+    }
+    // ─────────────────────────────────────────────────────────────────
+    // Cleanup
+    // ─────────────────────────────────────────────────────────────────
+    /**
+     * Clean up a stream when it's closed.
+     */
+    closeStream(streamId) {
+        const state = this.streams.get(streamId);
+        if (state) {
+            state.abortController.abort();
+            this.streams.delete(streamId);
+        }
+    }
+    /**
+     * Clean up all streams.
+     */
+    closeAll() {
+        for (const [streamId, state] of this.streams) {
+            state.abortController.abort();
+        }
+        this.streams.clear();
+    }
+}
+//# sourceMappingURL=acp-over-map.js.map