macro-agent 0.1.2 → 0.1.3

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

@@ -1,1024 +0,0 @@
-/**
- * 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