@townco/agent 0.1.88 → 0.1.98

package/dist/acp-server/adapter.js

@@ -2,6 +2,7 @@ import * as acp from "@agentclientprotocol/sdk";
 import { context, trace } from "@opentelemetry/api";
 import { createLogger } from "../logger.js";
 import { getModelContextWindow, HookExecutor, loadHookCallback, } from "../runner/hooks";
+import { getToolGroupChildren } from "../runner/langchain/index.js";
 import { telemetry } from "../telemetry/index.js";
 import { calculateContextSize, } from "../utils/context-size-calculator.js";
 import { countToolResultTokens } from "../utils/token-counter.js";
@@ -142,13 +143,20 @@ export class AgentAcpAdapter {
     /**
      * Extract tool metadata from the agent definition for exposing to clients.
      * This provides basic info about available tools without loading them fully.
+     * For tool groups (like town_e2b, filesystem), dynamically extracts children
+     * tools info from the actual tool factories.
      */
     getToolsMetadata() {
         const tools = this.agent.definition.tools ?? [];
         return tools.map((tool) => {
             if (typeof tool === "string") {
-                // Built-in tool - return basic info
-                return { name: tool, description: `Built-in tool: ${tool}` };
+                // Built-in tool - dynamically get children if it's a tool group
+                const children = getToolGroupChildren(tool);
+                return {
+                    name: tool,
+                    description: `Built-in tool: ${tool}`,
+                    ...(children ? { children } : {}),
+                };
             }
             else if (tool.type === "direct") {
                 return {
@@ -159,9 +167,12 @@ export class AgentAcpAdapter {
                 };
             }
             else if (tool.type === "filesystem") {
+                // Filesystem is a tool group - dynamically get children
+                const children = getToolGroupChildren("filesystem");
                 return {
                     name: "filesystem",
                     description: "File system access tools",
+                    ...(children ? { children } : {}),
                 };
             }
             else if (tool.type === "custom") {
@@ -215,6 +226,418 @@ export class AgentAcpAdapter {
         }
         return [];
     }
+    /**
+     * Extract citation sources from tool output.
+     * Supports WebSearch (Exa results), WebFetch, library/document retrieval tools,
+     * and generic URL extraction from MCP tools.
+     */
+    extractSourcesFromToolOutput(toolName, rawOutput, toolCallId, session) {
+        const sources = [];
+        // Log all tool names to debug source extraction
+        logger.info("extractSourcesFromToolOutput called", {
+            toolName,
+            hasRawOutput: !!rawOutput,
+            rawOutputType: typeof rawOutput,
+            isLibraryTool: toolName.startsWith("library__"),
+        });
+        if (!rawOutput || typeof rawOutput !== "object") {
+            return sources;
+        }
+        const output = rawOutput;
+        // Handle WebSearch (Exa) results
+        if (toolName === "WebSearch" || toolName === "web_search") {
+            // Check for formatted results with citation IDs first
+            const formattedResults = output.formattedForCitation;
+            if (Array.isArray(formattedResults)) {
+                for (const result of formattedResults) {
+                    if (result &&
+                        typeof result === "object" &&
+                        "url" in result &&
+                        typeof result.url === "string") {
+                        // Use the citationId from the tool output if available
+                        const citationId = typeof result.citationId === "number"
+                            ? String(result.citationId)
+                            : (session.sourceCounter++, String(session.sourceCounter));
+                        const url = result.url;
+                        const title = typeof result.title === "string" ? result.title : "Untitled";
+                        const snippet = typeof result.text === "string"
+                            ? result.text.slice(0, 200)
+                            : undefined;
+                        sources.push({
+                            id: citationId,
+                            url,
+                            title,
+                            snippet,
+                            favicon: this.getFaviconUrl(url),
+                            toolCallId,
+                            sourceName: this.getSourceName(url),
+                        });
+                    }
+                }
+            }
+            else {
+                // Fallback to raw results (backwards compatibility)
+                const results = output.results;
+                if (Array.isArray(results)) {
+                    for (const result of results) {
+                        if (result &&
+                            typeof result === "object" &&
+                            "url" in result &&
+                            typeof result.url === "string") {
+                            session.sourceCounter++;
+                            const url = result.url;
+                            const title = typeof result.title === "string" ? result.title : "Untitled";
+                            const snippet = typeof result.text === "string"
+                                ? result.text.slice(0, 200)
+                                : undefined;
+                            sources.push({
+                                id: String(session.sourceCounter),
+                                url,
+                                title,
+                                snippet,
+                                favicon: this.getFaviconUrl(url),
+                                toolCallId,
+                                sourceName: this.getSourceName(url),
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        // Handle WebFetch - extract URL from rawInput if available
+        if (toolName === "WebFetch" || toolName === "web_fetch") {
+            // WebFetch might have URL in rawInput, or we can try to extract from output
+            // For now, we'll extract URLs from the output text if present
+            const content = output.content;
+            if (typeof content === "string") {
+                const urls = this.extractUrlsFromText(content);
+                for (const url of urls.slice(0, 3)) {
+                    // Limit to 3 URLs
+                    session.sourceCounter++;
+                    sources.push({
+                        id: String(session.sourceCounter),
+                        url,
+                        title: url, // Use URL as title for fetched pages
+                        toolCallId,
+                        favicon: this.getFaviconUrl(url),
+                        sourceName: this.getSourceName(url),
+                    });
+                }
+            }
+        }
+        // Handle library/document retrieval tools (e.g., library__get_document, library__search_keyword)
+        // These return structured data with document_url, title, summary, document_id, etc.
+        const isLibraryTool = toolName.startsWith("library__") ||
+            toolName.includes("get_document") ||
+            toolName.includes("retrieve_document");
+        logger.info("Library tool check", {
+            toolName,
+            isLibraryTool,
+            startsWithLibrary: toolName.startsWith("library__"),
+        });
+        if (isLibraryTool) {
+            logger.info("Processing library tool output for sources", {
+                toolName,
+                hasContent: "content" in output,
+                contentType: typeof output.content,
+                outputKeys: Object.keys(output).slice(0, 10),
+            });
+            // Content may be:
+            // 1. Nested in output.content as an object
+            // 2. A JSON string in output.content (MCP tools wrap results as JSON strings)
+            // 3. Directly in output
+            let outputContent;
+            if (typeof output.content === "object" && output.content !== null) {
+                // Content is already an object
+                outputContent = output.content;
+            }
+            else if (typeof output.content === "string") {
+                // Content is a JSON string - parse it (common for MCP tools)
+                try {
+                    const parsed = JSON.parse(output.content);
+                    if (typeof parsed === "object" && parsed !== null) {
+                        outputContent = parsed;
+                        logger.info("Parsed library tool JSON content", {
+                            toolName,
+                            parsedKeys: Object.keys(outputContent).slice(0, 10),
+                        });
+                    }
+                    else {
+                        outputContent = output;
+                    }
+                }
+                catch {
+                    // Not valid JSON, use output directly
+                    outputContent = output;
+                }
+            }
+            else {
+                outputContent = output;
+            }
+            // Helper to extract a single document source
+            const extractDocSource = (doc) => {
+                // Extract document URL (may be document_url, url, or source_url)
+                const docUrl = typeof doc.document_url === "string"
+                    ? doc.document_url
+                    : typeof doc.url === "string"
+                        ? doc.url
+                        : typeof doc.source_url === "string"
+                            ? doc.source_url
+                            : null;
+                // Extract title
+                const docTitle = typeof doc.title === "string" ? doc.title : null;
+                // Extract document_id for use as citation ID
+                const docId = typeof doc.document_id === "number"
+                    ? String(doc.document_id)
+                    : typeof doc.document_id === "string"
+                        ? doc.document_id
+                        : null;
+                // Only add as source if we have at least a URL or title
+                if (!docUrl && !docTitle)
+                    return null;
+                // Use document_id as the citation ID if available, otherwise use counter
+                const citationId = docId || (session.sourceCounter++, String(session.sourceCounter));
+                // Extract snippet from summary or content
+                let snippet;
+                if (typeof doc.summary === "string") {
+                    snippet = doc.summary.slice(0, 200);
+                }
+                else if (typeof doc.content === "string") {
+                    snippet = doc.content.slice(0, 200);
+                }
+                // Extract source name from the source field or derive from URL
+                let sourceName;
+                if (typeof doc.source === "string") {
+                    sourceName = doc.source
+                        .split("_")
+                        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+                        .join(" ");
+                }
+                else if (docUrl) {
+                    sourceName = this.getSourceName(docUrl);
+                }
+                const citationSource = {
+                    id: citationId,
+                    url: docUrl || "",
+                    title: docTitle || "Document",
+                    toolCallId,
+                };
+                if (snippet)
+                    citationSource.snippet = snippet;
+                if (sourceName)
+                    citationSource.sourceName = sourceName;
+                if (docUrl)
+                    citationSource.favicon = this.getFaviconUrl(docUrl);
+                logger.debug("Extracted library document source", {
+                    citationId,
+                    docId,
+                    docTitle,
+                    docUrl: docUrl?.slice(0, 50),
+                    toolName,
+                });
+                return citationSource;
+            };
+            // Check if this is a search results array (library__search_keyword)
+            const results = outputContent.results ?? outputContent.documents;
+            if (Array.isArray(results)) {
+                // Handle array of search results
+                logger.debug("Processing library search results array", {
+                    resultCount: results.length,
+                    toolName,
+                });
+                for (const result of results) {
+                    if (result && typeof result === "object") {
+                        const source = extractDocSource(result);
+                        if (source)
+                            sources.push(source);
+                    }
+                }
+            }
+            else {
+                // Handle single document (library__get_document)
+                logger.debug("Processing single library document", {
+                    hasDocumentId: "document_id" in outputContent,
+                    hasTitle: "title" in outputContent,
+                    hasDocUrl: "document_url" in outputContent ||
+                        "url" in outputContent ||
+                        "source_url" in outputContent,
+                    contentKeys: Object.keys(outputContent).slice(0, 10),
+                    toolName,
+                });
+                const source = extractDocSource(outputContent);
+                if (source)
+                    sources.push(source);
+            }
+        }
+        // Handle MCP tools - try to extract URLs from any output
+        if (sources.length === 0 && output.content) {
+            const content = output.content;
+            if (typeof content === "string") {
+                logger.info("Fallback URL extraction running (no sources from tool handler)", {
+                    toolName,
+                    contentLength: content.length,
+                });
+                const urls = this.extractUrlsFromText(content);
+                for (const url of urls.slice(0, 5)) {
+                    // Limit to 5 URLs for generic extraction
+                    session.sourceCounter++;
+                    logger.info("Extracted URL via fallback", {
+                        id: String(session.sourceCounter),
+                        url: url.slice(0, 80),
+                    });
+                    sources.push({
+                        id: String(session.sourceCounter),
+                        url,
+                        title: url,
+                        toolCallId,
+                        favicon: this.getFaviconUrl(url),
+                        sourceName: this.getSourceName(url),
+                    });
+                }
+            }
+        }
+        return sources;
+    }
+    /**
+     * Extract citation sources from a subagent result.
+     * The sources are already re-numbered by the runner with unique IDs (1001+, 2001+, etc.)
+     * to avoid conflicts with parent agent sources.
+     */
+    extractSubagentSources(rawOutput, toolCallId) {
+        if (!rawOutput) {
+            logger.debug("extractSubagentSources: no rawOutput");
+            return null;
+        }
+        let output;
+        // Handle both string (JSON-serialized) and object formats
+        if (typeof rawOutput === "string") {
+            try {
+                const parsed = JSON.parse(rawOutput);
+                if (typeof parsed !== "object" || parsed === null) {
+                    logger.debug("extractSubagentSources: string parsed to non-object");
+                    return null;
+                }
+                output = parsed;
+            }
+            catch {
+                logger.debug("extractSubagentSources: failed to parse string as JSON");
+                return null;
+            }
+        }
+        else if (typeof rawOutput === "object") {
+            output = rawOutput;
+        }
+        else {
+            logger.debug("extractSubagentSources: rawOutput is neither string nor object", {
+                type: typeof rawOutput,
+            });
+            return null;
+        }
+        logger.info("extractSubagentSources: initial output structure", {
+            outputKeys: Object.keys(output).slice(0, 10),
+            hasText: "text" in output,
+            hasSources: "sources" in output,
+            hasContent: "content" in output,
+            contentType: typeof output.content,
+        });
+        // Check if output is wrapped in { content: "..." } format
+        if (typeof output.content === "string" &&
+            !("text" in output) &&
+            !("sources" in output)) {
+            try {
+                const parsed = JSON.parse(output.content);
+                if (typeof parsed === "object" && parsed !== null) {
+                    output = parsed;
+                    logger.info("extractSubagentSources: unwrapped content", {
+                        newOutputKeys: Object.keys(output).slice(0, 10),
+                        hasText: "text" in output,
+                        hasSources: "sources" in output,
+                    });
+                }
+            }
+            catch {
+                logger.debug("extractSubagentSources: content is not JSON");
+                // Not JSON, continue with original output
+            }
+        }
+        // Check if this looks like a SubagentResult with sources
+        if (typeof output.text !== "string" || !Array.isArray(output.sources)) {
+            logger.info("extractSubagentSources: not a SubagentResult", {
+                textType: typeof output.text,
+                sourcesIsArray: Array.isArray(output.sources),
+                outputKeys: Object.keys(output).slice(0, 10),
+            });
+            return null;
+        }
+        const subagentSources = output.sources;
+        if (subagentSources.length === 0) {
+            return { text: output.text, sources: [] };
+        }
+        // Sources are already numbered uniquely by the runner
+        // Just convert them to CitationSource format with parent's toolCallId
+        const sources = subagentSources.map((source) => {
+            const citationSource = {
+                id: source.id,
+                url: source.url,
+                title: source.title,
+                toolCallId, // Use parent's toolCallId for association
+            };
+            if (source.snippet)
+                citationSource.snippet = source.snippet;
+            if (source.favicon)
+                citationSource.favicon = source.favicon;
+            if (source.sourceName)
+                citationSource.sourceName = source.sourceName;
+            return citationSource;
+        });
+        return { text: output.text, sources };
+    }
+    /**
+     * Helper to derive favicon URL from a domain
+     */
+    getFaviconUrl(url) {
+        try {
+            const domain = new URL(url).hostname;
+            return `https://www.google.com/s2/favicons?domain=${domain}&sz=32`;
+        }
+        catch {
+            return "";
+        }
+    }
+    /**
+     * Helper to extract domain name from URL
+     */
+    getSourceName(url) {
+        try {
+            const hostname = new URL(url).hostname;
+            // Remove www. prefix and capitalize first letter
+            const name = hostname.replace(/^www\./, "").split(".")[0] || hostname;
+            return name.charAt(0).toUpperCase() + name.slice(1);
+        }
+        catch {
+            return "Unknown";
+        }
+    }
+    /**
+     * Helper to extract URLs from text content
+     */
+    extractUrlsFromText(text) {
+        const urlRegex = /https?:\/\/[^\s<>"')\]]+/g;
+        const matches = text.match(urlRegex);
+        if (!matches)
+            return [];
+        // Deduplicate and filter out common non-page URLs
+        const seen = new Set();
+        return matches.filter((url) => {
+            if (seen.has(url))
+                return false;
+            seen.add(url);
+            // Filter out common non-content URLs
+            if (url.includes("favicon") || url.includes("logo"))
+                return false;
+            return true;
+        });
+    }
     /**
      * Helper to save session to disk
      * Call this after any modification to session.messages or session.context
@@ -274,6 +697,9 @@ export class AgentAcpAdapter {
             ...(toolsMetadata.length > 0 ? { tools: toolsMetadata } : {}),
             ...(mcpsMetadata.length > 0 ? { mcps: mcpsMetadata } : {}),
             ...(subagentsMetadata.length > 0 ? { subagents: subagentsMetadata } : {}),
+            ...(this.agent.definition.promptParameters
+                ? { promptParameters: this.agent.definition.promptParameters }
+                : {}),
         };
         return response;
     }
@@ -290,6 +716,9 @@ export class AgentAcpAdapter {
             context: [],
             requestParams: params,
             configOverrides,
+            isCancelled: false,
+            sourceCounter: 0,
+            sources: [],
         };
         this.sessions.set(sessionId, sessionData);
         // Note: Initial message is sent by the HTTP transport when SSE connection is established
@@ -332,12 +761,45 @@ export class AgentAcpAdapter {
         if (!storedSession) {
             throw new Error(`Session ${params.sessionId} not found`);
         }
+        // Repair any incomplete tool calls in the session (e.g., from cancelled turns)
+        // This is required because Claude's API requires every tool_use to have a tool_result
+        let sessionRepaired = false;
+        for (const msg of storedSession.messages) {
+            if (msg.role === "assistant") {
+                for (const block of msg.content) {
+                    if (block.type === "tool_call") {
+                        const toolCall = block;
+                        if ((toolCall.status === "pending" ||
+                            toolCall.status === "in_progress") &&
+                            !toolCall.rawOutput) {
+                            toolCall.status = "failed";
+                            toolCall.rawOutput = { content: "[Cancelled]" };
+                            toolCall.error = "Tool execution was interrupted";
+                            sessionRepaired = true;
+                            logger.info("Repaired incomplete tool call in loaded session", {
+                                sessionId: params.sessionId,
+                                toolCallId: toolCall.id,
+                                toolName: toolCall.title,
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        // Save repaired session if changes were made
+        if (sessionRepaired && this.storage) {
+            await this.storage.saveSession(params.sessionId, storedSession.messages, storedSession.context);
+            logger.info("Saved repaired session", { sessionId: params.sessionId });
+        }
         // Restore session in active sessions map
         this.sessions.set(params.sessionId, {
             pendingPrompt: null,
             messages: storedSession.messages,
             context: storedSession.context,
             requestParams: { cwd: process.cwd(), mcpServers: [] },
+            isCancelled: false,
+            sourceCounter: 0,
+            sources: [],
         });
         // Replay conversation history to client with ordered content blocks
         logger.info(`Replaying ${storedSession.messages.length} messages for session ${params.sessionId}`);
@@ -428,6 +890,27 @@ export class AgentAcpAdapter {
                             sessionId: params.sessionId,
                             update: outputUpdate,
                         });
+                        // Extract sources from replayed tool output
+                        const session = this.sessions.get(params.sessionId);
+                        if (session) {
+                            const extractedSources = this.extractSourcesFromToolOutput(block.title, block.rawOutput, block.id, session);
+                            if (extractedSources.length > 0) {
+                                session.sources.push(...extractedSources);
+                                // Emit sources notification to client during replay
+                                this.connection.sessionUpdate({
+                                    sessionId: params.sessionId,
+                                    update: {
+                                        sessionUpdate: "sources",
+                                        sources: extractedSources,
+                                    },
+                                });
+                                logger.info("Extracted sources during session replay", {
+                                    toolCallId: block.id,
+                                    toolName: block.title,
+                                    sourcesCount: extractedSources.length,
+                                });
+                            }
+                        }
                     }
                     // Also emit tool_call_update with final status for consistency
                     this.connection.sessionUpdate({
@@ -512,11 +995,16 @@ export class AgentAcpAdapter {
                 messages: [],
                 context: [],
                 requestParams: { cwd: process.cwd(), mcpServers: [] },
+                isCancelled: false,
+                sourceCounter: 0,
+                sources: [],
             };
             this.sessions.set(params.sessionId, session);
         }
         session.pendingPrompt?.abort();
         session.pendingPrompt = new AbortController();
+        // Reset cancelled flag for new prompt
+        session.isCancelled = false;
         // Reset tool overhead for new turn (will be set by harness)
         this.currentToolOverheadTokens = 0;
         this.currentMcpOverheadTokens = 0;
@@ -622,6 +1110,52 @@ export class AgentAcpAdapter {
                 pendingText = "";
             }
         };
+        // Helper to save cancelled message to session
+        const saveCancelledMessage = async () => {
+            if (this.noSession)
+                return;
+            // Flush any pending text
+            flushPendingText();
+            // Find and complete any incomplete tool calls with cancelled status
+            // This is required because Claude's API requires every tool_use to have a tool_result
+            for (const block of contentBlocks) {
+                if (block.type === "tool_call") {
+                    const toolCall = block;
+                    if (toolCall.status === "pending" ||
+                        toolCall.status === "in_progress") {
+                        toolCall.status = "failed";
+                        toolCall.rawOutput = { content: "[Cancelled]" };
+                        toolCall.error = "Tool execution cancelled by user";
+                        logger.debug("Marked incomplete tool call as cancelled", {
+                            toolCallId: toolCall.id,
+                            toolName: toolCall.title,
+                        });
+                    }
+                }
+            }
+            // Add "[Cancelled]" text block
+            contentBlocks.push({ type: "text", text: "\n\n[Cancelled]" });
+            if (contentBlocks.length > 0) {
+                const cancelledMessage = {
+                    role: "assistant",
+                    content: contentBlocks,
+                    timestamp: new Date().toISOString(),
+                };
+                // Check if we already have a partial assistant message
+                const lastMessage = session.messages[session.messages.length - 1];
+                if (lastMessage && lastMessage.role === "assistant") {
+                    session.messages[session.messages.length - 1] = cancelledMessage;
+                }
+                else {
+                    session.messages.push(cancelledMessage);
+                }
+                await this.saveSessionToDisk(params.sessionId, session);
+                logger.info("Saved cancelled message to session", {
+                    sessionId: params.sessionId,
+                    contentBlocks: contentBlocks.length,
+                });
+            }
+        };
         // Declare agentResponse and turnTokenUsage outside try block so they're accessible after catch
         let _agentResponse;
         // Track accumulated token usage during the turn
@@ -670,6 +1204,8 @@ export class AgentAcpAdapter {
                 ...(this.agentDir ? { agentDir: this.agentDir } : {}),
                 // Pass resolved context messages to agent
                 contextMessages,
+                // Pass abort signal for cancellation
+                abortSignal: session.pendingPrompt?.signal,
             };
             // Only add sessionMeta if it's defined
             if (session.requestParams._meta) {
@@ -679,12 +1215,25 @@ export class AgentAcpAdapter {
             if (session.configOverrides) {
                 invokeParams.configOverrides = session.configOverrides;
             }
+            // Extract and pass promptParameters from the prompt request _meta
+            const promptParameters = params._meta?.promptParameters;
+            if (promptParameters) {
+                invokeParams.promptParameters = promptParameters;
+            }
             const generator = this.agent.invoke(invokeParams);
             // Track the invocation span for parenting hook spans
             let invocationSpan = null;
             // Manually iterate to capture the return value
             let iterResult = await generator.next();
             while (!iterResult.done) {
+                // Check for cancellation at start of each iteration
+                if (session.pendingPrompt?.signal.aborted) {
+                    logger.info("Cancellation detected in generator loop, stopping iteration", {
+                        sessionId: params.sessionId,
+                    });
+                    await saveCancelledMessage();
+                    return { stopReason: "cancelled" };
+                }
                 const msg = iterResult.value;
                 // Capture the invocation span so we can use it for parenting hook spans
                 if ("sessionUpdate" in msg &&
@@ -993,7 +1542,7 @@ export class AgentAcpAdapter {
                                         },
                                     });
                                 };
-                                const hookExecutor = new HookExecutor(hooks, this.agent.definition.model, (callbackRef) => loadHookCallback(callbackRef, this.agentDir), sendHookNotification);
+                                const hookExecutor = new HookExecutor(hooks, this.agent.definition.model, (callbackRef) => loadHookCallback(callbackRef, this.agentDir), sendHookNotification, this.agent.definition);
                                 const hookResult = await hookExecutor.executeToolResponseHooks({
                                     messages: session.messages,
                                     context: session.context,
@@ -1072,6 +1621,60 @@ export class AgentAcpAdapter {
                         if (rawOutput) {
                             toolCallBlock.rawOutput = rawOutput;
                         }
+                        // Handle subagent tool outputs - extract citation sources
+                        // Subagent tools return { text: string, sources: CitationSource[] }
+                        // Sources are already re-numbered by the runner with unique IDs (1001+, 2001+, etc.)
+                        const rawOutputForLog = rawOutput;
+                        logger.debug("Checking for subagent sources in tool output", {
+                            toolCallId: outputMsg.toolCallId,
+                            toolName: toolCallBlock.title,
+                            rawOutputType: typeof rawOutputForLog,
+                            rawOutputPreview: typeof rawOutputForLog === "string"
+                                ? rawOutputForLog.slice(0, 200)
+                                : typeof rawOutputForLog === "object" && rawOutputForLog
+                                    ? JSON.stringify(rawOutputForLog).slice(0, 200)
+                                    : String(rawOutputForLog),
+                        });
+                        const subagentResult = this.extractSubagentSources(rawOutput, outputMsg.toolCallId);
+                        if (subagentResult && subagentResult.sources.length > 0) {
+                            // Add sources to session (already uniquely numbered)
+                            session.sources.push(...subagentResult.sources);
+                            // Emit sources notification to client
+                            this.connection.sessionUpdate({
+                                sessionId: params.sessionId,
+                                update: {
+                                    sessionUpdate: "sources",
+                                    sources: subagentResult.sources,
+                                },
+                            });
+                            logger.info("Extracted citation sources from subagent", {
+                                toolCallId: outputMsg.toolCallId,
+                                sourcesCount: subagentResult.sources.length,
+                            });
+                        }
+                        // Extract citation sources from tool output (WebSearch, WebFetch, MCP tools)
+                        // Skip if we already extracted sources from a subagent result (with actual sources)
+                        const subagentHadSources = subagentResult && subagentResult.sources.length > 0;
+                        if (!subagentHadSources) {
+                            const extractedSources = this.extractSourcesFromToolOutput(toolCallBlock.title, rawOutput, outputMsg.toolCallId, session);
+                            if (extractedSources.length > 0) {
+                                // Add to session sources
+                                session.sources.push(...extractedSources);
+                                // Emit sources notification to client
+                                this.connection.sessionUpdate({
+                                    sessionId: params.sessionId,
+                                    update: {
+                                        sessionUpdate: "sources",
+                                        sources: extractedSources,
+                                    },
+                                });
+                                logger.info("Extracted citation sources from tool output", {
+                                    toolCallId: outputMsg.toolCallId,
+                                    toolName: toolCallBlock.title,
+                                    sourcesCount: extractedSources.length,
+                                });
+                            }
+                        }
                         // Store truncation warning if present (for UI display)
                         if (truncationWarning) {
                             if (!toolCallBlock._meta) {
@@ -1271,6 +1874,7 @@ export class AgentAcpAdapter {
         }
         catch (err) {
             if (session.pendingPrompt.signal.aborted) {
+                await saveCancelledMessage();
                 return { stopReason: "cancelled" };
             }
             throw err;
@@ -1396,7 +2000,7 @@ export class AgentAcpAdapter {
                 },
             });
         };
-        const hookExecutor = new HookExecutor(hooks, this.agent.definition.model, (callbackRef) => loadHookCallback(callbackRef, this.agentDir), sendHookNotification);
+        const hookExecutor = new HookExecutor(hooks, this.agent.definition.model, (callbackRef) => loadHookCallback(callbackRef, this.agentDir), sendHookNotification, this.agent.definition);
         // Create read-only session view for hooks
         const readonlySession = {
             messages: session.messages,
@@ -1441,6 +2045,90 @@ export class AgentAcpAdapter {
         return hookResult.newContextEntries;
     }
     async cancel(params) {
-        this.sessions.get(params.sessionId)?.pendingPrompt?.abort();
+        logger.info("Cancel requested", { sessionId: params.sessionId });
+        const session = this.sessions.get(params.sessionId);
+        if (session) {
+            // Mark session as cancelled so tools can check this flag
+            session.isCancelled = true;
+            if (session.pendingPrompt) {
+                logger.info("Aborting pending prompt", { sessionId: params.sessionId });
+                session.pendingPrompt.abort();
+            }
+        }
+        else {
+            logger.warn("No session found to cancel", {
+                sessionId: params.sessionId,
+            });
+        }
+    }
+    /**
+     * Edit and resend a message from a specific point in the conversation.
+     * This truncates the session history to the specified user message
+     * and then prompts with the new content.
+     *
+     * @param sessionId - The session to edit
+     * @param userMessageIndex - The index of which user message to edit (0-based, counting only user messages)
+     * @param newPrompt - The new prompt content to send
+     * @returns PromptResponse from the agent
+     */
+    async editAndResend(sessionId, userMessageIndex, newPrompt) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            throw new Error(`Session ${sessionId} not found`);
+        }
+        logger.info("Edit and resend requested", {
+            sessionId,
+            userMessageIndex,
+            currentMessageCount: session.messages.length,
+            currentContextCount: session.context.length,
+        });
+        // Find the Nth user message (0-indexed)
+        let userMessageCount = 0;
+        let targetMessageIndex = -1;
+        for (let i = 0; i < session.messages.length; i++) {
+            if (session.messages[i]?.role === "user") {
+                if (userMessageCount === userMessageIndex) {
+                    targetMessageIndex = i;
+                    break;
+                }
+                userMessageCount++;
+            }
+        }
+        if (targetMessageIndex === -1) {
+            throw new Error(`User message ${userMessageIndex} not found. Session has ${userMessageCount} user messages.`);
+        }
+        logger.info("Found target user message", {
+            sessionId,
+            userMessageIndex,
+            targetMessageIndex,
+            totalMessages: session.messages.length,
+        });
+        // Truncate messages - keep everything BEFORE the target user message
+        session.messages = session.messages.slice(0, targetMessageIndex);
+        // Truncate context entries - filter to only those that reference messages
+        // that are still in the truncated message list
+        session.context = session.context.filter((entry) => {
+            // Find the maximum message index referenced by this context entry
+            let maxPointerIndex = -1;
+            for (const msgEntry of entry.messages) {
+                if (msgEntry.type === "pointer" && msgEntry.index > maxPointerIndex) {
+                    maxPointerIndex = msgEntry.index;
+                }
+            }
+            // Keep context entries that only reference messages we still have
+            return maxPointerIndex < targetMessageIndex;
+        });
+        logger.info("Session truncated", {
+            sessionId,
+            newMessageCount: session.messages.length,
+            newContextCount: session.context.length,
+        });
+        // Save the truncated session to disk
+        await this.saveSessionToDisk(sessionId, session);
+        // Now proceed with normal prompt handling
+        return this.prompt({
+            sessionId,
+            prompt: newPrompt,
+        });
     }
 }