@townco/agent 0.1.120 → 0.1.122

package/dist/runner/langchain/tools/subagent.js

@@ -2,25 +2,28 @@ import * as crypto from "node:crypto";
 import * as fs from "node:fs/promises";
 import { mkdir } from "node:fs/promises";
 import * as path from "node:path";
-import { ChatAnthropic } from "@langchain/anthropic";
+import Anthropic from "@anthropic-ai/sdk";
 import { context, propagation, trace } from "@opentelemetry/api";
 import { createLogger } from "@townco/core";
 import { z } from "zod";
-import { SUBAGENT_MODE_KEY, } from "../../../acp-server/adapter.js";
+import { AgentAcpAdapter, SUBAGENT_MODE_KEY, } from "../../../acp-server/adapter.js";
 import { makeRunnerFromDefinition } from "../../index.js";
-import { bindGeneratorToSessionContext, getAbortSignal, } from "../../session-context.js";
+import { bindGeneratorToSessionContext, getAbortSignal, getSessionContext, } from "../../session-context.js";
 import { emitSubagentMessages, hashQuery, } from "./subagent-connections.js";
 const logger = createLogger("subagent-tool", "debug");
 /**
  * Generate status message using Haiku (fast, cheap model)
+ *
+ * Important: Uses Anthropic SDK directly (not LangChain) to completely isolate
+ * from the LangChain streaming context and prevent status text from leaking
+ * into the subagent's content stream.
  */
 async function generateStatusMessage(recentContent, toolCalls) {
     try {
         const activeTool = toolCalls.find((tc) => tc.status === "in_progress");
-        const model = new ChatAnthropic({
-            modelName: "claude-3-haiku-20240307",
-            temperature: 0.3,
-            maxTokens: 30,
+        // Use Anthropic SDK directly to bypass LangChain callbacks entirely
+        const anthropic = new Anthropic({
+            apiKey: process.env.ANTHROPIC_API_KEY,
         });
         const prompt = `Summarize the current activity in 5-7 words for a progress indicator:
 
@@ -34,9 +37,20 @@ Requirements:
 - Return ONLY the status, no explanation
 
 Status:`;
-        const response = await model.invoke(prompt);
-        const status = response.content.toString().trim().slice(0, 80);
-        return status;
+        const response = await anthropic.messages.create({
+            model: "claude-haiku-4-5-20251001",
+            max_tokens: 30,
+            temperature: 0.3,
+            messages: [
+                {
+                    role: "user",
+                    content: prompt,
+                },
+            ],
+        });
+        const textContent = response.content.find((block) => block.type === "text");
+        const status = textContent?.type === "text" ? textContent.text.trim().slice(0, 80) : "";
+        return status || extractHeuristicStatus(recentContent, toolCalls);
     }
     catch (error) {
         logger.warn("Failed to generate status message", { error });
@@ -381,116 +395,19 @@ assistant: "I'm going to use the Task tool to launch the greeting-responder agen
     };
 }
 /**
- * Internal function that runs a subagent in-process and queries it.
+ * Creates an ACP connection that forwards streaming updates to emitSubagentMessages.
+ * This allows subagents to run through the adapter layer (getting full session persistence
+ * and hook execution) while still providing real-time streaming updates to the parent.
  */
-async function querySubagent(agentName, agentPath, agentWorkingDirectory, query, taskName) {
-    // Get the abort signal from context (set by parent agent's cancellation)
-    const parentAbortSignal = getAbortSignal();
-    // Check if already cancelled before starting
-    if (parentAbortSignal?.aborted) {
-        throw new Error(`Subagent query cancelled before starting (agent: ${agentName})`);
-    }
-    // Validate that the agent exists
-    try {
-        await fs.access(agentPath);
-    }
-    catch (_error) {
-        throw new Error(`Subagent '${agentName}' not found at ${agentPath}. Make sure the agent exists and has an index.ts file.`);
-    }
-    // Load agent definition dynamically
-    const agentModule = await import(agentPath);
-    const agentDefinition = agentModule.default || agentModule.agent;
-    // Create runner instance
-    const runner = makeRunnerFromDefinition(agentDefinition);
-    // Generate unique session ID for isolation
-    const subagentSessionId = crypto.randomUUID();
-    // Setup session paths
-    const sessionDir = path.join(agentWorkingDirectory, ".sessions", subagentSessionId);
-    const artifactsDir = path.join(sessionDir, "artifacts");
-    await mkdir(artifactsDir, { recursive: true });
-    // Prepare OTEL context for distributed tracing
-    const activeCtx = context.active();
-    const activeSpan = trace.getSpan(activeCtx);
-    const otelCarrier = {};
-    if (activeSpan) {
-        propagation.inject(trace.setSpan(activeCtx, activeSpan), otelCarrier);
-        // Set span attributes for observability
-        activeSpan.setAttributes({
-            "subagent.semantic_name": taskName,
-            "subagent.agent_definition": agentName,
-        });
-    }
-    // Create invoke request
-    const invokeRequest = {
-        sessionId: subagentSessionId,
-        messageId: crypto.randomUUID(),
-        prompt: [{ type: "text", text: query }],
-        agentDir: agentWorkingDirectory,
-        contextMessages: [],
-        ...(parentAbortSignal ? { abortSignal: parentAbortSignal } : {}),
-        sessionMeta: {
-            [SUBAGENT_MODE_KEY]: true,
-            ...(Object.keys(otelCarrier).length > 0
-                ? { otelTraceContext: otelCarrier }
-                : {}),
-        },
-    };
-    // Bind session context and invoke
-    let generator = runner.invoke(invokeRequest);
-    generator = bindGeneratorToSessionContext({ sessionId: subagentSessionId, sessionDir, artifactsDir }, generator);
-    // Consume stream, accumulate results, and emit incremental updates
-    let responseText = "";
-    const collectedSources = [];
-    const sourceCounter = { value: 0 }; // Mutable counter for source ID generation
-    const currentMessage = {
-        id: `subagent-${Date.now()}`,
-        content: "",
-        contentBlocks: [],
-        toolCalls: [],
-        _meta: {
-            semanticName: taskName,
-            agentDefinitionName: agentName,
-            statusGenerating: true,
-        },
-    };
-    const toolCallMap = new Map();
-    const toolNameMap = new Map(); // Map toolCallId -> toolName
-    const queryHash = hashQuery(query);
-    // Emit initial message with semantic name immediately
-    emitSubagentMessages(queryHash, [currentMessage]);
-    // Track status updates for periodic generation
-    let lastStatusUpdate = Date.now();
-    let statusUpdateInProgress = false;
-    const STATUS_UPDATE_INTERVAL = 5000; // 5 seconds
-    // Fire async initial status generation (don't await)
-    generateStatusMessage(query, [])
-        .then((status) => {
-        if (currentMessage._meta) {
-            currentMessage._meta.currentActivity = status;
-            currentMessage._meta.statusGenerating = false;
-        }
-        // Emit update with status
-        emitSubagentMessages(queryHash, [currentMessage]);
-    })
-        .catch((error) => {
-        logger.warn("Initial status generation failed", { error });
-        if (currentMessage._meta) {
-            currentMessage._meta.statusGenerating = false;
-        }
-    });
-    logger.info("[DEBUG] Starting subagent generator loop", {
-        agentName,
-        queryHash,
-        sessionId: subagentSessionId,
-    });
-    try {
-        for await (const update of generator) {
+function createStreamingConnection(queryHash, currentMessage, toolCallMap, toolNameMap, collectedSources, sourceCounter) {
+    return {
+        sessionUpdate: (notification) => {
+            const update = notification.update;
             let shouldEmit = false;
             // Handle agent_message_chunk
             if (update.sessionUpdate === "agent_message_chunk") {
                 const content = update.content;
                 if (content?.type === "text" && typeof content.text === "string") {
-                    responseText += content.text;
                     currentMessage.content += content.text;
                     const lastBlock = currentMessage.contentBlocks[currentMessage.contentBlocks.length - 1];
                     if (lastBlock && lastBlock.type === "text") {
@@ -502,15 +419,13 @@ async function querySubagent(agentName, agentPath, agentWorkingDirectory, query,
                             text: content.text,
                         });
                     }
-                    shouldEmit = true; // Emit after each text chunk
+                    shouldEmit = true;
                 }
             }
             // Handle tool_call
             if (update.sessionUpdate === "tool_call" && update.toolCallId) {
                 const meta = update._meta;
-                // Extract rawInput from the update
-                const rawInput = update
-                    .rawInput;
+                const rawInput = update.rawInput;
                 const toolCall = {
                     id: update.toolCallId,
                     title: update.title || "Tool call",
@@ -521,12 +436,11 @@ async function querySubagent(agentName, agentPath, agentWorkingDirectory, query,
                 };
                 currentMessage.toolCalls.push(toolCall);
                 toolCallMap.set(update.toolCallId, currentMessage.toolCalls.length - 1);
-                // Store tool name for source extraction when output arrives
                 if (update.title) {
                     toolNameMap.set(update.toolCallId, update.title);
                 }
                 currentMessage.contentBlocks.push({ type: "tool_call", toolCall });
-                shouldEmit = true; // Emit when new tool call appears
+                shouldEmit = true;
             }
             // Handle tool_call_update
             if (update.sessionUpdate === "tool_call_update" && update.toolCallId) {
@@ -540,25 +454,22 @@ async function querySubagent(agentName, agentPath, agentWorkingDirectory, query,
                     if (block && update.status) {
                         block.toolCall.status = update.status;
                     }
-                    shouldEmit = true; // Emit when tool status changes
+                    shouldEmit = true;
                 }
             }
-            // Handle tool_output - capture rawOutput and extract sources
-            // (rawOutput will be included in final emit when subagent completes)
+            // Handle tool_output
             if (update.sessionUpdate === "tool_output" && update.toolCallId) {
-                const outputUpdate = update;
                 const idx = toolCallMap.get(update.toolCallId);
                 if (idx !== undefined && currentMessage.toolCalls[idx]) {
-                    if (outputUpdate.rawOutput) {
-                        currentMessage.toolCalls[idx].rawOutput = outputUpdate.rawOutput;
-                        // Also update the content block
+                    const rawOutput = update.rawOutput;
+                    if (rawOutput) {
+                        currentMessage.toolCalls[idx].rawOutput = rawOutput;
                         const block = currentMessage.contentBlocks.find((b) => b.type === "tool_call" && b.toolCall.id === update.toolCallId);
                         if (block) {
-                            block.toolCall.rawOutput = outputUpdate.rawOutput;
+                            block.toolCall.rawOutput = rawOutput;
                         }
-                        // Extract citation sources from tool output (WebSearch, WebFetch, library tools)
                         const toolName = toolNameMap.get(update.toolCallId) || "";
-                        const extractedSources = extractSourcesFromToolOutput(toolName, outputUpdate.rawOutput, update.toolCallId, sourceCounter);
+                        const extractedSources = extractSourcesFromToolOutput(toolName, rawOutput, update.toolCallId, sourceCounter);
                         if (extractedSources.length > 0) {
                             collectedSources.push(...extractedSources);
                             logger.info("Extracted sources from subagent tool output", {
@@ -566,69 +477,21 @@ async function querySubagent(agentName, agentPath, agentWorkingDirectory, query,
                                 toolCallId: update.toolCallId,
                                 sourcesCount: extractedSources.length,
                             });
-                            shouldEmit = true; // Emit when sources are extracted
+                            shouldEmit = true;
                         }
                     }
-                    // NOTE: Don't set shouldEmit for rawOutput alone - rawOutput is large and will be
-                    // included in the final emit when the subagent completes
                 }
             }
-            // Handle sources (from ACP protocol)
-            if ("sources" in update &&
-                Array.isArray(update.sources)) {
-                const sources = update
-                    .sources;
+            // Handle sources from ACP
+            if (update.sessionUpdate === "sources" && Array.isArray(update.sources)) {
+                const sources = update.sources;
                 for (const source of sources) {
-                    const citationSource = {
-                        id: source.id,
-                        url: source.url,
-                        title: source.title,
-                        toolCallId: source.toolCallId,
-                    };
-                    if (source.snippet)
-                        citationSource.snippet = source.snippet;
-                    if (source.favicon)
-                        citationSource.favicon = source.favicon;
-                    if (source.sourceName)
-                        citationSource.sourceName = source.sourceName;
-                    collectedSources.push(citationSource);
+                    collectedSources.push(source);
                 }
-                shouldEmit = true; // Emit when sources are added
-            }
-            // Periodic status update check
-            const now = Date.now();
-            const shouldUpdateStatus = !statusUpdateInProgress &&
-                now - lastStatusUpdate > STATUS_UPDATE_INTERVAL &&
-                currentMessage.content.length > 100; // Only if there's meaningful content
-            if (shouldUpdateStatus) {
-                statusUpdateInProgress = true;
-                lastStatusUpdate = now;
-                // Fire async status update (don't await)
-                generateStatusMessage(currentMessage.content, currentMessage.toolCalls)
-                    .then((status) => {
-                    if (currentMessage._meta) {
-                        currentMessage._meta.currentActivity = status;
-                    }
-                    // Emit update
-                    emitSubagentMessages(queryHash, [currentMessage]);
-                    statusUpdateInProgress = false;
-                })
-                    .catch((error) => {
-                    logger.warn("Status update failed", { error });
-                    statusUpdateInProgress = false;
-                });
+                shouldEmit = true;
             }
-            // Emit incremental update to parent (for live streaming)
+            // Emit incremental update
             if (shouldEmit) {
-                logger.debug("[SUBAGENT-ACCUMULATION] Emitting incremental update", {
-                    agentName,
-                    queryHash,
-                    contentLength: currentMessage.content.length,
-                    contentBlocksCount: currentMessage.contentBlocks.length,
-                    toolCallsCount: currentMessage.toolCalls.length,
-                });
-                // Strip rawOutput from streamed messages to avoid OOM in browser
-                // rawOutput is preserved in currentMessage for final session save
                 const streamMessage = {
                     ...currentMessage,
                     toolCalls: currentMessage.toolCalls.map((tc) => {
@@ -645,8 +508,108 @@ async function querySubagent(agentName, agentPath, agentWorkingDirectory, query,
                 };
                 emitSubagentMessages(queryHash, [streamMessage]);
             }
+        },
+    };
+}
+/**
+ * Internal function that runs a subagent in-process and queries it.
+ */
+async function querySubagent(agentName, agentPath, agentWorkingDirectory, query, taskName) {
+    // Get the abort signal from context (set by parent agent's cancellation)
+    const parentAbortSignal = getAbortSignal();
+    // Check if already cancelled before starting
+    if (parentAbortSignal?.aborted) {
+        throw new Error(`Subagent query cancelled before starting (agent: ${agentName})`);
+    }
+    // Validate that the agent exists
+    try {
+        await fs.access(agentPath);
+    }
+    catch (_error) {
+        throw new Error(`Subagent '${agentName}' not found at ${agentPath}. Make sure the agent exists and has an index.ts file.`);
+    }
+    // Load agent definition dynamically
+    const agentModule = await import(agentPath);
+    const agentDefinition = agentModule.default || agentModule.agent;
+    // Create runner instance
+    const runner = makeRunnerFromDefinition(agentDefinition);
+    // Generate unique session ID for isolation
+    const subagentSessionId = crypto.randomUUID();
+    // Prepare OTEL context for distributed tracing
+    const activeCtx = context.active();
+    const activeSpan = trace.getSpan(activeCtx);
+    const otelCarrier = {};
+    if (activeSpan) {
+        propagation.inject(trace.setSpan(activeCtx, activeSpan), otelCarrier);
+        // Set span attributes for observability
+        activeSpan.setAttributes({
+            "subagent.semantic_name": taskName,
+            "subagent.agent_definition": agentName,
+        });
+    }
+    // Setup state for streaming connection
+    const collectedSources = [];
+    const sourceCounter = { value: 0 };
+    const currentMessage = {
+        id: `subagent-${Date.now()}`,
+        content: "",
+        contentBlocks: [],
+        toolCalls: [],
+        _meta: {
+            semanticName: taskName,
+            agentDefinitionName: agentName,
+            statusGenerating: true,
+        },
+    };
+    const toolCallMap = new Map();
+    const toolNameMap = new Map();
+    const queryHash = hashQuery(query);
+    // Create streaming connection that forwards updates to emitSubagentMessages
+    const connection = createStreamingConnection(queryHash, currentMessage, toolCallMap, toolNameMap, collectedSources, sourceCounter);
+    // Create adapter with session storage (subagents get full session persistence)
+    const adapter = new AgentAcpAdapter(runner, connection, agentWorkingDirectory, agentName);
+    // Get parent session context for linking
+    const parentSessionContext = getSessionContext();
+    // Prepare prompt request (ACP format)
+    const promptRequest = {
+        sessionId: subagentSessionId,
+        prompt: [{ type: "text", text: query }],
+        _meta: {
+            isSubagentSession: true, // For UI filtering
+            parentSessionId: parentSessionContext?.sessionId, // For session linking
+            [SUBAGENT_MODE_KEY]: true, // 🚨 CRITICAL: Prevents nested subagents via tool filtering
+            ...(Object.keys(otelCarrier).length > 0
+                ? { otelTraceContext: otelCarrier }
+                : {}),
+        },
+    };
+    // Emit initial message with semantic name immediately
+    emitSubagentMessages(queryHash, [currentMessage]);
+    // Fire async initial status generation (don't await)
+    generateStatusMessage(query, [])
+        .then((status) => {
+        if (currentMessage._meta) {
+            currentMessage._meta.currentActivity = status;
+            currentMessage._meta.statusGenerating = false;
+        }
+        emitSubagentMessages(queryHash, [currentMessage]);
+    })
+        .catch((error) => {
+        logger.warn("Initial status generation failed", { error });
+        if (currentMessage._meta) {
+            currentMessage._meta.statusGenerating = false;
         }
-        logger.info("[DEBUG] Subagent generator loop finished", {
+    });
+    logger.info("[DEBUG] Starting subagent via adapter", {
+        agentName,
+        queryHash,
+        sessionId: subagentSessionId,
+    });
+    try {
+        // Invoke through adapter (gets full session tracking + hook execution)
+        // The adapter will call connection.sessionUpdate() for streaming updates
+        const response = await adapter.prompt(promptRequest);
+        logger.info("[DEBUG] Subagent adapter.prompt() completed", {
             agentName,
             queryHash,
             sessionId: subagentSessionId,
@@ -664,7 +627,6 @@ async function querySubagent(agentName, agentPath, agentWorkingDirectory, query,
             emitSubagentMessages(queryHash, [currentMessage], true);
         }
         else {
-            // Even if no messages, emit completion sentinel
             logger.info("[DEBUG] Emitting empty completion flag", {
                 agentName,
                 queryHash,
@@ -678,8 +640,9 @@ async function querySubagent(agentName, agentPath, agentWorkingDirectory, query,
             queryHash,
             sessionId: subagentSessionId,
         });
+        // Return accumulated result from streaming connection
         return {
-            text: responseText,
+            text: currentMessage.content,
             sources: collectedSources,
         };
     }