@townco/agent 0.1.111 → 0.1.113

package/dist/acp-server/adapter.js

@@ -1411,7 +1411,22 @@ export class AgentAcpAdapter {
                 if ("sessionUpdate" in msg &&
                     msg.sessionUpdate === "tool_call_update") {
                     const updateMsg = msg;
+                    logger.info("[SUBAGENT] Adapter received tool_call_update", {
+                        sessionId: params.sessionId,
+                        toolCallId: updateMsg.toolCallId,
+                        status: updateMsg.status,
+                        hasMeta: !!updateMsg._meta,
+                        hasSubagentMessages: !!updateMsg._meta?.subagentMessages,
+                        subagentMessageCount: updateMsg._meta?.subagentMessages?.length ||
+                            0,
+                    });
                     const toolCallBlock = contentBlocks.find((block) => block.type === "tool_call" && block.id === updateMsg.toolCallId);
+                    logger.info("[SUBAGENT] Tool call block lookup result", {
+                        sessionId: params.sessionId,
+                        toolCallId: updateMsg.toolCallId,
+                        found: !!toolCallBlock,
+                        blockStatus: toolCallBlock?.status,
+                    });
                     if (toolCallBlock) {
                         if (updateMsg.status) {
                             toolCallBlock.status =
@@ -1444,19 +1459,30 @@ export class AgentAcpAdapter {
                             toolCallBlock.subagentSessionId = meta.subagentSessionId;
                         }
                         if (meta?.subagentMessages) {
-                            logger.info("Storing subagent messages for session replay", {
+                            logger.info("[SUBAGENT] Storing subagent messages for session replay", {
+                                sessionId: params.sessionId,
                                 toolCallId: updateMsg.toolCallId,
                                 messageCount: meta.subagentMessages.length,
+                                contentPreview: meta.subagentMessages[0]?.content?.substring(0, 100),
                             });
                             toolCallBlock.subagentMessages = meta.subagentMessages;
+                            logger.info("[SUBAGENT] Successfully stored messages", {
+                                sessionId: params.sessionId,
+                                toolCallId: updateMsg.toolCallId,
+                                storedCount: toolCallBlock.subagentMessages?.length,
+                            });
                         }
                     }
                     // Forward tool_call_update with _meta to the client (for subagent connection info, etc.)
                     if (updateMsg._meta) {
-                        logger.info("Forwarding tool_call_update with _meta to client", {
+                        logger.info("[SUBAGENT] Forwarding tool_call_update with _meta to client", {
+                            sessionId: params.sessionId,
                             toolCallId: updateMsg.toolCallId,
                             status: updateMsg.status,
-                            _meta: updateMsg._meta,
+                            hasSubagentMessages: !!updateMsg._meta
+                                ?.subagentMessages,
+                            subagentMessageCount: updateMsg._meta?.subagentMessages
+                                ?.length || 0,
                         });
                         this.connection.sessionUpdate({
                             sessionId: params.sessionId,
@@ -1467,22 +1493,9 @@ export class AgentAcpAdapter {
                                 _meta: updateMsg._meta,
                             },
                         });
-                    }
-                    // Forward tool_call_update with _meta to the client (for subagent connection info, etc.)
-                    if (updateMsg._meta) {
-                        logger.info("Forwarding tool_call_update with _meta to client", {
-                            toolCallId: updateMsg.toolCallId,
-                            status: updateMsg.status,
-                            _meta: updateMsg._meta,
-                        });
-                        this.connection.sessionUpdate({
+                        logger.info("[SUBAGENT] Successfully forwarded to client", {
                             sessionId: params.sessionId,
-                            update: {
-                                sessionUpdate: "tool_call_update",
-                                toolCallId: updateMsg.toolCallId,
-                                status: updateMsg.status,
-                                _meta: updateMsg._meta,
-                            },
+                            toolCallId: updateMsg.toolCallId,
                         });
                     }
                 }
@@ -2111,6 +2124,56 @@ export class AgentAcpAdapter {
                 },
             });
         }
+        // Proactive compaction based on actual LLM token usage
+        // If actual input tokens from LLM exceed threshold, compact now to prevent overflow on next turn
+        const PROACTIVE_COMPACTION_THRESHOLD = 70; // Trigger at 70% of context window
+        const modelContextWindow = getModelContextWindow(this.agent.definition.model);
+        if (turnTokenUsage.inputTokens > 0 && !this.noSession) {
+            const actualPercentage = (turnTokenUsage.inputTokens / modelContextWindow) * 100;
+            const latestContext = session.context.length > 0
+                ? session.context[session.context.length - 1]
+                : undefined;
+            const estimatedTokens = latestContext?.context_size.totalEstimated ?? 0;
+            // Log the difference between estimated and actual tokens
+            const tokenDifference = turnTokenUsage.inputTokens - estimatedTokens;
+            const differencePercentage = estimatedTokens > 0
+                ? ((tokenDifference / estimatedTokens) * 100).toFixed(1)
+                : "N/A";
+            logger.info("Token usage comparison (actual vs estimated)", {
+                sessionId: params.sessionId,
+                actualInputTokens: turnTokenUsage.inputTokens,
+                estimatedTokens,
+                tokenDifference,
+                differencePercentage: `${differencePercentage}%`,
+                actualPercentage: `${actualPercentage.toFixed(1)}%`,
+                modelContextWindow,
+                threshold: `${PROACTIVE_COMPACTION_THRESHOLD}%`,
+            });
+            // Proactively compact if actual tokens exceed threshold
+            if (actualPercentage >= PROACTIVE_COMPACTION_THRESHOLD) {
+                logger.warn("Actual token usage exceeds threshold - proactively compacting for next turn", {
+                    sessionId: params.sessionId,
+                    actualPercentage: `${actualPercentage.toFixed(1)}%`,
+                    threshold: `${PROACTIVE_COMPACTION_THRESHOLD}%`,
+                    actualTokens: turnTokenUsage.inputTokens,
+                    modelContextWindow,
+                });
+                // Force compaction to reduce context for next turn
+                const compactionResult = await this.forceCompaction(session, params.sessionId);
+                if (compactionResult.success) {
+                    logger.info("Proactive compaction succeeded", {
+                        sessionId: params.sessionId,
+                    });
+                    // Save the updated session with new context entry
+                    await this.saveSessionToDisk(params.sessionId, session);
+                }
+                else {
+                    logger.warn("Proactive compaction failed - continuing without compaction", {
+                        sessionId: params.sessionId,
+                    });
+                }
+            }
+        }
         session.pendingPrompt = null;
         return {
             stopReason: "end_turn",
@@ -2118,8 +2181,8 @@ export class AgentAcpAdapter {
     }
     /**
      * Force compaction of the session context.
-     * Used for error recovery when the Claude API returns "prompt is too long".
-     * This bypasses the normal threshold check and always compacts.
+     * Used for error recovery when the Claude API returns "prompt is too long",
+     * and for proactive compaction when actual token usage exceeds threshold.
      */
     async forceCompaction(session, sessionId) {
         logger.info("Force compaction started", {

package/dist/acp-server/http.js

@@ -406,6 +406,27 @@ export function createAcpHttpApp(agent, agentDir, agentName) {
         allowMethods: ["GET", "POST", "OPTIONS"],
     }));
     app.get("/health", (c) => c.json({ ok: true }));
+    // Receive browser console logs and write to agent.log
+    const browserLogger = createLogger("gui-console");
+    app.post("/logs/browser", async (c) => {
+        try {
+            const { logs } = await c.req.json();
+            if (Array.isArray(logs)) {
+                for (const log of logs) {
+                    const level = log.level;
+                    const method = browserLogger[level];
+                    if (typeof method === "function") {
+                        method.call(browserLogger, log.message, log.metadata);
+                    }
+                }
+            }
+            return c.json({ ok: true });
+        }
+        catch (error) {
+            logger.error("Failed to process browser logs", { error });
+            return c.json({ ok: false }, 400);
+        }
+    });
     // List available sessions
     app.get("/sessions", async (c) => {
         if (!agentDir || !agentName) {

package/dist/runner/langchain/index.js

@@ -1,3 +1,4 @@
+import { EventEmitter } from "node:events";
 import { mkdir } from "node:fs/promises";
 import * as path from "node:path";
 import { MultiServerMCPClient } from "@langchain/mcp-adapters";
@@ -11,7 +12,7 @@ import { telemetry } from "../../telemetry/index.js";
 import { calculateContextSize } from "../../utils/context-size-calculator.js";
 import { getModelContextWindow } from "../hooks/constants.js";
 import { isContextOverflowError } from "../hooks/predefined/context-validator.js";
-import { bindGeneratorToAbortSignal, bindGeneratorToEmitUpdate, bindGeneratorToSessionContext, getAbortSignal, runWithAbortSignal, } from "../session-context";
+import { bindGeneratorToAbortSignal, bindGeneratorToEmitUpdate, bindGeneratorToInvocationContext, bindGeneratorToSessionContext, getAbortSignal, getInvocationContext, runWithAbortSignal, } from "../session-context";
 import { loadCustomToolModule, } from "../tool-loader.js";
 import { createModelFromString, detectProvider } from "./model-factory.js";
 import { makeOtelCallbacks } from "./otel-callbacks.js";
@@ -19,7 +20,7 @@ import { makeBrowserTools } from "./tools/browser";
 import { makeDocumentExtractTool } from "./tools/document_extract";
 import { makeTownE2BTools } from "./tools/e2b";
 import { SUBAGENT_TOOL_NAME } from "./tools/subagent";
-import { hashQuery, queryToToolCallId, subagentEvents, } from "./tools/subagent-connections";
+import { hashQuery, queryToToolCallId, } from "./tools/subagent-connections";
 import { makeTodoWriteTool, TODO_WRITE_TOOL_NAME } from "./tools/todo";
 import { makeTownWebSearchTools, makeWebSearchTools } from "./tools/web_search";
 const _logger = createLogger("agent-runner");
@@ -82,6 +83,14 @@ export class LangchainAgent {
     async *invokeInternal(req) {
         // Start with the base generator
         let generator = this.invokeWithContext(req);
+        // Create invocation-scoped context for subagent event routing
+        // This must be done here so it's available before invokeWithContext starts
+        const subagentInvocationContext = {
+            invocationId: req.sessionId,
+            subagentEventEmitter: new EventEmitter(),
+        };
+        // Bind invocation context first so it's available to all nested operations
+        generator = bindGeneratorToInvocationContext(subagentInvocationContext, generator);
         // Bind abort signal if available (for cancellation support)
         if (req.abortSignal) {
             generator = bindGeneratorToAbortSignal(req.abortSignal, generator);
@@ -108,6 +117,11 @@ export class LangchainAgent {
         return yield* generator;
     }
     async *invokeWithContext(req) {
+        // Get subagent invocation context from AsyncLocalStorage (created in invokeInternal)
+        const subagentInvCtx = getInvocationContext();
+        if (!subagentInvCtx) {
+            throw new Error("No subagent invocation context available - invokeWithContext called outside of invocation binding");
+        }
         // Derive the parent OTEL context for this invocation.
         // If this is a subagent and the parent process propagated an OTEL trace
         // context via sessionMeta.otelTraceContext, use that as the parent;
@@ -140,78 +154,50 @@ export class LangchainAgent {
             // Clear the buffer after flushing
             pendingToolCallNotifications.length = 0;
         }
-        const subagentUpdateQueue = [];
-        let subagentUpdateResolver = null;
         const subagentMessagesQueue = [];
-        // Listen for subagent connection events - resolve any waiting promise immediately
-        const onSubagentConnection = (event) => {
-            _logger.info("Received subagent connection event", {
-                toolCallId: event.toolCallId,
-                port: event.port,
-                sessionId: event.sessionId,
-            });
-            if (subagentUpdateResolver) {
-                // If someone is waiting, resolve immediately
-                const resolver = subagentUpdateResolver;
-                subagentUpdateResolver = null;
-                resolver(event);
-            }
-            else {
-                // Otherwise queue for later
-                subagentUpdateQueue.push(event);
-            }
-        };
-        subagentEvents.on("connection", onSubagentConnection);
-        // Listen for subagent messages events (for session storage)
+        const completedSubagentToolCalls = new Set();
+        const activeSubagentToolCalls = new Set();
+        // Listen for subagent messages events (for live streaming)
+        // Use the invocation-scoped EventEmitter to ensure messages route correctly
         const onSubagentMessages = (event) => {
-            _logger.info("Received subagent messages event", {
+            _logger.info("✓ Received subagent messages event from scoped emitter", {
                 toolCallId: event.toolCallId,
                 messageCount: event.messages.length,
+                completed: event.completed,
+                invocationId: subagentInvCtx.invocationId,
+                sessionId: req.sessionId,
             });
-            subagentMessagesQueue.push(event);
-        };
-        subagentEvents.on("messages", onSubagentMessages);
-        // Helper to get next subagent update (returns immediately if queued, otherwise waits)
-        const waitForSubagentUpdate = () => {
-            if (subagentUpdateQueue.length > 0) {
-                // biome-ignore lint/style/noNonNullAssertion: We check length > 0, so shift() will return a value
-                return Promise.resolve(subagentUpdateQueue.shift());
+            // Track completion
+            if (event.completed) {
+                completedSubagentToolCalls.add(event.toolCallId);
+                _logger.info("✓ Subagent stream completed", {
+                    toolCallId: event.toolCallId,
+                    sessionId: req.sessionId,
+                    totalCompleted: completedSubagentToolCalls.size,
+                });
             }
-            return new Promise((resolve) => {
-                subagentUpdateResolver = resolve;
-            });
+            subagentMessagesQueue.push(event);
         };
-        // Helper to check and yield all pending subagent updates
+        subagentInvCtx.subagentEventEmitter.on("messages", onSubagentMessages);
+        // Helper to check and yield all pending subagent message updates
         async function* yieldPendingSubagentUpdates() {
-            while (subagentUpdateQueue.length > 0) {
-                const update = subagentUpdateQueue.shift();
-                if (!update)
-                    continue;
-                _logger.info("Yielding queued subagent connection update", {
-                    toolCallId: update.toolCallId,
-                    subagentPort: update.port,
-                    subagentSessionId: update.sessionId,
-                });
-                yield {
-                    sessionUpdate: "tool_call_update",
-                    toolCallId: update.toolCallId,
-                    _meta: {
-                        messageId: req.messageId,
-                        subagentPort: update.port,
-                        subagentSessionId: update.sessionId,
-                    },
-                };
-            }
-            // Also yield any pending messages updates
+            _logger.info("[SUBAGENT] yieldPendingSubagentUpdates called", {
+                sessionId: req.sessionId,
+                queueLength: subagentMessagesQueue.length,
+            });
             while (subagentMessagesQueue.length > 0) {
                 const messagesUpdate = subagentMessagesQueue.shift();
                 if (!messagesUpdate)
                     continue;
-                _logger.info("Yielding queued subagent messages update", {
+                _logger.info("[SUBAGENT] Yielding queued subagent messages update", {
+                    sessionId: req.sessionId,
                     toolCallId: messagesUpdate.toolCallId,
                     messageCount: messagesUpdate.messages.length,
+                    contentPreview: messagesUpdate.messages[0]?.content?.substring(0, 100),
+                    hasContentBlocks: (messagesUpdate.messages[0]?.contentBlocks?.length ?? 0) > 0,
+                    toolCallCount: messagesUpdate.messages[0]?.toolCalls?.length ?? 0,
                 });
-                yield {
+                const updateToYield = {
                     sessionUpdate: "tool_call_update",
                     toolCallId: messagesUpdate.toolCallId,
                     _meta: {
@@ -219,6 +205,17 @@ export class LangchainAgent {
                         subagentMessages: messagesUpdate.messages,
                     },
                 };
+                _logger.info("[SUBAGENT] About to yield update object", {
+                    sessionId: req.sessionId,
+                    toolCallId: messagesUpdate.toolCallId,
+                    updateType: updateToYield.sessionUpdate,
+                    hasMetaSubagentMessages: !!updateToYield._meta?.subagentMessages,
+                });
+                yield updateToYield;
+                _logger.info("[SUBAGENT] Successfully yielded update", {
+                    sessionId: req.sessionId,
+                    toolCallId: messagesUpdate.toolCallId,
+                });
             }
         }
         // Add agent.session_id as a base attribute so it propagates to all child spans
@@ -871,53 +868,63 @@ export class LangchainAgent {
                 callbacks: [otelCallbacks],
             }));
             _logger.info("agent.stream created, starting iteration");
-            // Use manual iteration with Promise.race to interleave stream events with subagent updates
-            const streamIterator = (await stream)[Symbol.asyncIterator]();
-            let streamDone = false;
-            let pendingStreamPromise = null;
-            while (!streamDone) {
-                // Get or create the stream promise (reuse if still pending from last iteration)
-                const nextStreamPromise = pendingStreamPromise ?? streamIterator.next();
-                pendingStreamPromise = nextStreamPromise; // Track it
-                // Create subagent wait promise (only if no queued updates)
-                const subagentPromise = waitForSubagentUpdate();
-                // Use Promise.race, but we need to handle both outcomes
-                const result = await Promise.race([
-                    nextStreamPromise.then((r) => ({
-                        type: "stream",
-                        result: r,
-                    })),
-                    subagentPromise.then((u) => ({ type: "subagent", update: u })),
-                ]);
-                if (result.type === "subagent") {
-                    // Got a subagent update - yield it immediately
-                    const update = result.update;
-                    _logger.info("Yielding subagent connection update (via race)", {
-                        toolCallId: update.toolCallId,
-                        subagentPort: update.port,
-                        subagentSessionId: update.sessionId,
+            // Merge the LangChain stream with subagent event stream
+            // This allows both to yield concurrently without polling
+            async function* mergeStreams() {
+                const streamIterator = (await stream)[Symbol.asyncIterator]();
+                const _pending = [];
+                let streamDone = false;
+                let subagentListenerActive = true;
+                // Create a promise that resolves when the next subagent event arrives
+                function createSubagentEventPromise() {
+                    return new Promise((resolve) => {
+                        const handler = (event) => {
+                            subagentInvCtx?.subagentEventEmitter.off("messages", handler);
+                            resolve({ source: "subagent", value: event, done: false });
+                        };
+                        subagentInvCtx?.subagentEventEmitter.once("messages", handler);
                     });
-                    yield {
-                        sessionUpdate: "tool_call_update",
-                        toolCallId: update.toolCallId,
-                        _meta: {
-                            messageId: req.messageId,
-                            subagentPort: update.port,
-                            subagentSessionId: update.sessionId,
-                        },
-                    };
-                    // Continue - the stream promise is still pending, will be reused
-                    continue;
                 }
-                // Got a stream item - clear the pending promise
-                pendingStreamPromise = null;
-                const { done, value: streamItem } = result.result;
-                if (done) {
-                    streamDone = true;
-                    break;
+                // Start listening for subagent events
+                let subagentPromise = createSubagentEventPromise();
+                while (!streamDone || subagentListenerActive) {
+                    // Race between next stream item and next subagent event
+                    const streamPromise = streamIterator.next().then((result) => ({
+                        source: "stream",
+                        value: result.value,
+                        done: result.done ?? false,
+                    }));
+                    const result = await Promise.race([streamPromise, subagentPromise]);
+                    if (result.source === "stream") {
+                        if (result.done) {
+                            streamDone = true;
+                            // Continue to drain remaining subagent events
+                            subagentListenerActive = false;
+                            // Yield any remaining queued messages
+                            while (subagentMessagesQueue.length > 0) {
+                                yield { source: "subagent" };
+                            }
+                            break;
+                        }
+                        yield { source: "stream", value: result.value };
+                    }
+                    else if (result.source === "subagent") {
+                        // Subagent event arrived - it's already in the queue
+                        yield { source: "subagent" };
+                        // Start listening for the next subagent event
+                        subagentPromise = createSubagentEventPromise();
+                    }
                 }
-                // Also yield any queued subagent updates before processing stream item
-                yield* yieldPendingSubagentUpdates();
+            }
+            // Iterate through the merged stream
+            for await (const item of mergeStreams()) {
+                if (item.source === "subagent") {
+                    // Yield any queued subagent messages
+                    yield* yieldPendingSubagentUpdates();
+                    continue;
+                }
+                // Process the stream item
+                const streamItem = item.value;
                 // biome-ignore lint/suspicious/noExplicitAny: LangChain stream items are tuples with dynamic types
                 const [streamMode, chunk] = streamItem;
                 if (streamMode === "updates") {
@@ -1020,10 +1027,19 @@ export class LangchainAgent {
                                     typeof toolCall.args.query === "string") {
                                     const qHash = hashQuery(toolCall.args.query);
                                     queryToToolCallId.set(qHash, toolCall.id);
-                                    telemetry.log("info", "Registered subagent query hash mapping", {
+                                    activeSubagentToolCalls.add(toolCall.id);
+                                    telemetry.log("info", "✓ Registered subagent query hash mapping", {
                                         queryHash: qHash,
                                         toolCallId: toolCall.id,
                                         queryPreview: toolCall.args.query.slice(0, 50),
+                                        timestamp: new Date().toISOString(),
+                                    });
+                                }
+                                else {
+                                    telemetry.log("warn", "✗ Subagent tool call missing query parameter", {
+                                        toolCallId: toolCall.id,
+                                        hasQuery: "query" in (toolCall.args || {}),
+                                        argsKeys: Object.keys(toolCall.args || {}),
                                     });
                                 }
                             }
@@ -1225,9 +1241,10 @@ export class LangchainAgent {
                                 continue;
                             }
                             // Check if the tool execution failed
-                            // LangChain may set status: "error" OR the content may start with "Error:"
+                            // LangChain may set status: "error" OR the content looks like an error message
+                            // Matches: "Error...", "Error:...", "SomethingError:..." (e.g. RateLimitError:, TypeError:)
                             const contentLooksLikeError = typeof aiMessage.content === "string" &&
-                                aiMessage.content.trim().startsWith("Error:");
+                                /^(\w*Error:|Error\b)/i.test(aiMessage.content.trim());
                             const isError = aiMessage.status === "error" || contentLooksLikeError;
                             const status = isError ? "failed" : "completed";
                             telemetry.log(isError ? "error" : "info", `Tool call ${status}`, {
@@ -1311,15 +1328,62 @@ export class LangchainAgent {
             }
             // Yield any remaining pending subagent connection updates after stream ends
             yield* yieldPendingSubagentUpdates();
+            // Keep polling for subagent messages after stream ends
+            // This ensures we capture messages that arrive after LangChain stream completes
+            _logger.info("[SUBAGENT] Starting post-stream polling for subagent messages", {
+                sessionId: req.sessionId,
+                activeSubagentCount: activeSubagentToolCalls.size,
+            });
+            const checkInterval = 100; // Check every 100ms
+            const maxIdleTime = 5000; // Stop if no messages for 5 seconds (fallback)
+            const maxWaitTime = 300000; // Absolute max 5 minutes
+            const startTime = Date.now();
+            let lastMessageTime = Date.now();
+            while (Date.now() - startTime < maxWaitTime) {
+                // Check if all subagent tool calls have completed
+                if (activeSubagentToolCalls.size > 0 &&
+                    completedSubagentToolCalls.size >= activeSubagentToolCalls.size) {
+                    _logger.info("[SUBAGENT] All subagent tool calls completed", {
+                        sessionId: req.sessionId,
+                        totalSubagents: activeSubagentToolCalls.size,
+                        completedCount: completedSubagentToolCalls.size,
+                    });
+                    break;
+                }
+                // Check if there are pending messages
+                if (subagentMessagesQueue.length > 0) {
+                    _logger.info("[SUBAGENT] Found pending messages, yielding", {
+                        sessionId: req.sessionId,
+                        queueLength: subagentMessagesQueue.length,
+                    });
+                    yield* yieldPendingSubagentUpdates();
+                    lastMessageTime = Date.now();
+                }
+                // Stop if we haven't seen messages for maxIdleTime (fallback for no subagents)
+                if (Date.now() - lastMessageTime > maxIdleTime) {
+                    _logger.info("[SUBAGENT] No new messages for 5 seconds, finishing", {
+                        sessionId: req.sessionId,
+                        hasActiveSubagents: activeSubagentToolCalls.size > 0,
+                    });
+                    break;
+                }
+                // Wait a bit before checking again
+                await new Promise((resolve) => setTimeout(resolve, checkInterval));
+            }
+            if (Date.now() - startTime >= maxWaitTime) {
+                _logger.warn("[SUBAGENT] Timeout waiting for subagents", {
+                    sessionId: req.sessionId,
+                });
+            }
+            // Final yield of any remaining messages
+            yield* yieldPendingSubagentUpdates();
+            _logger.info("[SUBAGENT] Finished post-stream polling", {
+                sessionId: req.sessionId,
+            });
             // Now that content streaming is complete, yield all buffered tool call notifications
             yield* flushPendingToolCalls();
-            // Clean up subagent event listeners
-            subagentEvents.off("connection", onSubagentConnection);
-            subagentEvents.off("messages", onSubagentMessages);
-            // Cancel any pending wait
-            if (subagentUpdateResolver) {
-                subagentUpdateResolver = null;
-            }
+            // Clean up subagent event listener from invocation-scoped emitter
+            subagentInvCtx.subagentEventEmitter.off("messages", onSubagentMessages);
             // Clean up any remaining iteration span
             otelCallbacks?.cleanup();
             // Log successful completion
@@ -1335,9 +1399,8 @@ export class LangchainAgent {
             };
         }
         catch (error) {
-            // Clean up subagent event listeners on error
-            subagentEvents.off("connection", onSubagentConnection);
-            subagentEvents.off("messages", onSubagentMessages);
+            // Clean up subagent event listener on error from invocation-scoped emitter
+            subagentInvCtx.subagentEventEmitter.off("messages", onSubagentMessages);
             // Clean up any remaining iteration span
             otelCallbacks?.cleanup();
             // Check if this is a context overflow error - wrap it for retry handling

package/dist/runner/langchain/tools/artifacts.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Supabase Storage-backed artifacts tool for agent backend
+ *
+ * Provides file storage capabilities using Supabase Storage with the following operations:
+ * - artifacts_cp: Copy files to/from Supabase Storage
+ * - artifacts_del: Delete files from Supabase Storage
+ * - artifacts_ls: List files in Supabase Storage
+ * - artifacts_url: Generate signed URLs
+ *
+ * Storage keys are scoped by: <deploying_user>/<agent_name>/<session_id>/<file_path>
+ */
+import { z } from "zod";
+/**
+ * Factory function to create the artifacts tools
+ * Returns an array of all four artifact management tools
+ */
+export declare function makeArtifactsTools(): (import("langchain").DynamicStructuredTool<z.ZodObject<{
+    session_id: z.ZodOptional<z.ZodString>;
+    source: z.ZodString;
+    destination: z.ZodString;
+    direction: z.ZodEnum<{
+        download: "download";
+        upload: "upload";
+    }>;
+}, z.core.$strip>, {
+    session_id: string;
+    source: string;
+    destination: string;
+    direction: "download" | "upload";
+}, {
+    session_id?: string | undefined;
+    source: string;
+    destination: string;
+    direction: "download" | "upload";
+}, string> | import("langchain").DynamicStructuredTool<z.ZodObject<{
+    session_id: z.ZodOptional<z.ZodString>;
+    path: z.ZodString;
+}, z.core.$strip>, {
+    session_id: string;
+    path: string;
+}, {
+    session_id?: string | undefined;
+    path: string;
+}, string> | import("langchain").DynamicStructuredTool<z.ZodObject<{
+    session_id: z.ZodOptional<z.ZodString>;
+    path: z.ZodOptional<z.ZodString>;
+    recursive: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, {
+    session_id: string;
+    path?: string;
+    recursive?: boolean;
+}, {
+    session_id?: string | undefined;
+    path?: string | undefined;
+    recursive?: boolean | undefined;
+}, string> | import("langchain").DynamicStructuredTool<z.ZodObject<{
+    session_id: z.ZodOptional<z.ZodString>;
+    path: z.ZodString;
+    expires_in: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, {
+    session_id: string;
+    path: string;
+    expires_in?: number;
+}, {
+    session_id?: string | undefined;
+    path: string;
+    expires_in?: number | undefined;
+}, string>)[];