@townco/agent 0.1.119 → 0.1.121

package/dist/acp-server/adapter.js

@@ -676,12 +676,23 @@ export class AgentAcpAdapter {
                     sources: session.sources,
                     nextId: session.sourceCounter + 1,
                 };
-                await this.storage.saveSession(sessionId, session.messages, session.context, citations);
+                // Pass session metadata for subagent sessions
+                const metadata = {
+                    ...(session.parentSessionId && {
+                        parentSessionId: session.parentSessionId,
+                    }),
+                    ...(session.isSubagentSession && {
+                        isSubagentSession: session.isSubagentSession,
+                    }),
+                };
+                await this.storage.saveSession(sessionId, session.messages, session.context, citations, Object.keys(metadata).length > 0 ? metadata : undefined);
                 logger.debug("Saved session to disk", {
                     sessionId,
                     messageCount: session.messages.length,
                     contextCount: session.context.length,
                     citationsCount: session.sources.length,
+                    isSubagentSession: session.isSubagentSession,
+                    parentSessionId: session.parentSessionId,
                 });
             }
             catch (error) {
@@ -1046,6 +1057,8 @@ export class AgentAcpAdapter {
         // If session not found (e.g., after server restart), create a new one
         if (!session) {
             logger.info(`Session ${params.sessionId} not found, creating new session`);
+            const parentSessionId = params._meta?.parentSessionId;
+            const isSubagentSession = params._meta?.isSubagentSession === true;
             session = {
                 pendingPrompt: null,
                 messages: [],
@@ -1054,6 +1067,9 @@ export class AgentAcpAdapter {
                 isCancelled: false,
                 sourceCounter: 0,
                 sources: [],
+                // Extract subagent metadata from _meta (only add if defined)
+                ...(parentSessionId && { parentSessionId }),
+                ...(isSubagentSession && { isSubagentSession }),
             };
             this.sessions.set(params.sessionId, session);
         }
@@ -1299,6 +1315,8 @@ export class AgentAcpAdapter {
                 ...(this.agentDir ? { agentDir: this.agentDir } : {}),
                 // Pass resolved context messages to agent
                 contextMessages,
+                // Pass context entries for hook execution (compaction tracking)
+                contextEntries: session.context,
                 // Pass abort signal for cancellation
                 abortSignal: session.pendingPrompt?.signal,
                 // Pass emitUpdate callback for file change events

package/dist/acp-server/http.js

@@ -259,19 +259,7 @@ export function createAcpHttpApp(agent, agentDir, agentName) {
                                 const stream = sseStreams.get(msgSessionId);
                                 if (stream) {
                                     try {
-                                        // Check if this is a sources message
-                                        const isSourcesMsg = rawMsg &&
-                                            typeof rawMsg === "object" &&
-                                            "params" in rawMsg &&
-                                            rawMsg.params?.update?.sessionUpdate === "sources";
-                                        if (isSourcesMsg) {
-                                            const sourcesCount = rawMsg.params?.update?.sources?.length;
-                                            logger.info("🔶 SENDING LARGE SOURCES VIA DIRECT SSE", {
-                                                sessionId: msgSessionId,
-                                                sourcesCount,
-                                                compressedSize,
-                                            });
-                                        }
+                                        // Send large messages directly via SSE
                                         await stream.writeSSE({
                                             event: "message",
                                             data: JSON.stringify(rawMsg),
@@ -811,21 +799,7 @@ export function createAcpHttpApp(agent, agentDir, agentName) {
                         return;
                     }
                 }
-                // Check if this is a sources message and log prominently
-                const isSourcesMsg = json &&
-                    typeof json === "object" &&
-                    "params" in json &&
-                    json.params?.update?.sessionUpdate === "sources";
-                if (isSourcesMsg) {
-                    logger.info("🔶 SENDING SOURCES VIA SSE", {
-                        sessionId,
-                        channel,
-                        sourcesCount: json.params?.update?.sources?.length,
-                    });
-                }
-                else {
-                    logger.trace("Sending SSE message", { sessionId, channel });
-                }
+                logger.trace("Sending SSE message", { sessionId, channel });
                 await stream.writeSSE({
                     event: "message",
                     data: JSON.stringify(json),

package/dist/acp-server/session-storage.d.ts

@@ -142,6 +142,10 @@ export interface SessionMetadata {
     agentName: string;
     /** E2B sandbox ID for persistent sandbox reconnection */
     sandboxId?: string | undefined;
+    /** Parent session ID for subagent sessions (enables session linking) */
+    parentSessionId?: string | undefined;
+    /** Flag indicating this is a subagent session (for UI filtering) */
+    isSubagentSession?: boolean | undefined;
 }
 /**
  * Complete session data stored in JSON files
@@ -207,7 +211,7 @@ export declare class SessionStorage {
      * Save a session to disk
      * Uses atomic write (write to temp file, then rename)
      */
-    saveSession(sessionId: string, messages: SessionMessage[], context: ContextEntry[], citations?: CitationStorage): Promise<void>;
+    saveSession(sessionId: string, messages: SessionMessage[], context: ContextEntry[], citations?: CitationStorage, extraMetadata?: Partial<SessionMetadata>): Promise<void>;
     /**
      * Load a session from disk
      */
@@ -242,6 +246,8 @@ export declare class SessionStorage {
         updatedAt: string;
         messageCount: number;
         firstUserMessage?: string;
+        parentSessionId?: string;
+        isSubagentSession?: boolean;
     }>>;
     /**
      * Get the directory for storing large content files for a session (artifacts folder)

package/dist/acp-server/session-storage.js

@@ -135,6 +135,8 @@ const sessionMetadataSchema = z.object({
     updatedAt: z.string(),
     agentName: z.string(),
     sandboxId: z.string().optional(),
+    parentSessionId: z.string().optional(),
+    isSubagentSession: z.boolean().optional(),
 });
 // Citation schemas - matches SourceSchema from packages/ui/src/core/schemas/source.ts
 const persistedCitationSourceSchema = z.object({
@@ -200,7 +202,7 @@ export class SessionStorage {
      * Save a session to disk
      * Uses atomic write (write to temp file, then rename)
      */
-    async saveSession(sessionId, messages, context, citations) {
+    async saveSession(sessionId, messages, context, citations, extraMetadata) {
         // Debug: log subagent data being saved
         const messagesWithSubagents = messages.filter((msg) => msg.content.some((block) => block.type === "tool_call" &&
             "subagentMessages" in block &&
@@ -239,6 +241,7 @@ export class SessionStorage {
                 createdAt: existingSession?.metadata.createdAt || now,
                 updatedAt: now,
                 agentName: this.agentName,
+                ...extraMetadata,
             },
             ...(citations && { citations }),
         };
@@ -386,6 +389,13 @@ export class SessionStorage {
                     if (firstUserText && "text" in firstUserText) {
                         entry.firstUserMessage = firstUserText.text.slice(0, 100);
                     }
+                    // Include sub-agent metadata if present
+                    if (session.metadata.parentSessionId) {
+                        entry.parentSessionId = session.metadata.parentSessionId;
+                    }
+                    if (session.metadata.isSubagentSession) {
+                        entry.isSubagentSession = session.metadata.isSubagentSession;
+                    }
                     sessions.push(entry);
                 }
             }

package/dist/runner/agent-runner.d.ts

@@ -1,7 +1,7 @@
 import type { PromptRequest, PromptResponse, SessionNotification } from "@agentclientprotocol/sdk";
 import type { Span } from "@opentelemetry/api";
 import { z } from "zod";
-import type { ContentBlock } from "../acp-server/session-storage.js";
+import type { ContentBlock, ContextEntry } from "../acp-server/session-storage.js";
 export declare const zAgentRunnerParams: z.ZodObject<{
     displayName: z.ZodOptional<z.ZodString>;
     version: z.ZodOptional<z.ZodString>;
@@ -99,6 +99,7 @@ export type InvokeRequest = Omit<PromptRequest, "_meta"> & {
     agentDir?: string;
     sessionMeta?: Record<string, unknown>;
     contextMessages?: SessionMessage[];
+    contextEntries?: ContextEntry[];
     configOverrides?: ConfigOverrides;
     /** Abort signal for cancellation - tools can listen for this to stop early */
     abortSignal?: AbortSignal;

package/dist/runner/e2b-sandbox-manager.d.ts

@@ -3,6 +3,9 @@ import type { Sandbox } from "@e2b/code-interpreter";
  * Get or create an E2B sandbox for the current session.
  * Sandboxes are session-scoped and reused across tool calls.
  * Attempts to reconnect to persisted sandboxes when resuming sessions.
+ *
+ * Uses promise caching to prevent race conditions when multiple tools
+ * are called in parallel - all concurrent calls will share the same sandbox.
  */
 export declare function getSessionSandbox(apiKey: string): Promise<Sandbox>;
 /**

package/dist/runner/e2b-sandbox-manager.js

@@ -8,6 +8,8 @@ const sessionSandboxes = new Map();
 const sandboxActivity = new Map();
 // Map sessionId -> cleanup timeout handle
 const cleanupTimeouts = new Map();
+// Map sessionId -> Promise<Sandbox> for in-flight creations (prevents race condition)
+const sandboxCreationPromises = new Map();
 // Sandbox timeout in milliseconds (default: 15 minutes)
 const SANDBOX_TIMEOUT_MS = 15 * 60 * 1000;
 /**
@@ -58,24 +60,10 @@ function getSessionStorage() {
     }
 }
 /**
- * Get or create an E2B sandbox for the current session.
- * Sandboxes are session-scoped and reused across tool calls.
- * Attempts to reconnect to persisted sandboxes when resuming sessions.
+ * Internal function to create or reconnect to a sandbox for a session.
+ * This should only be called from getSessionSandbox() with proper promise tracking.
  */
-export async function getSessionSandbox(apiKey) {
-    if (!hasSessionContext()) {
-        throw new Error("E2B tools require session context");
-    }
-    const { sessionId } = getSessionContext();
-    // Check for existing in-memory sandbox
-    let sandbox = sessionSandboxes.get(sessionId);
-    if (sandbox) {
-        // Update activity timestamp and reschedule cleanup
-        sandboxActivity.set(sessionId, Date.now());
-        rescheduleCleanup(sessionId);
-        logger.debug("Reusing existing sandbox", { sessionId });
-        return sandbox;
-    }
+async function createSandboxForSession(sessionId, apiKey) {
     // Try to reconnect to persisted sandbox
     const storage = getSessionStorage();
     const persistedSandboxId = storage?.getSandboxId(sessionId);
@@ -86,7 +74,9 @@ export async function getSessionSandbox(apiKey) {
         });
         try {
             const { Sandbox: SandboxClass } = await import("@e2b/code-interpreter");
-            sandbox = await SandboxClass.connect(persistedSandboxId, { apiKey });
+            const sandbox = await SandboxClass.connect(persistedSandboxId, {
+                apiKey,
+            });
             logger.info("Successfully reconnected to sandbox", {
                 sessionId,
                 sandboxId: persistedSandboxId,
@@ -131,7 +121,7 @@ export async function getSessionSandbox(apiKey) {
         config.template = templateId;
         logger.info("Using custom E2B template", { templateId });
     }
-    sandbox = await SandboxClass.create(config);
+    const sandbox = await SandboxClass.create(config);
     logger.info("Created new sandbox", {
         sessionId,
         sandboxId: sandbox.sandboxId,
@@ -167,6 +157,45 @@ logging.basicConfig(
     scheduleCleanup(sessionId);
     return sandbox;
 }
+/**
+ * Get or create an E2B sandbox for the current session.
+ * Sandboxes are session-scoped and reused across tool calls.
+ * Attempts to reconnect to persisted sandboxes when resuming sessions.
+ *
+ * Uses promise caching to prevent race conditions when multiple tools
+ * are called in parallel - all concurrent calls will share the same sandbox.
+ */
+export async function getSessionSandbox(apiKey) {
+    if (!hasSessionContext()) {
+        throw new Error("E2B tools require session context");
+    }
+    const { sessionId } = getSessionContext();
+    // Check for existing in-memory sandbox
+    const existingSandbox = sessionSandboxes.get(sessionId);
+    if (existingSandbox) {
+        // Update activity timestamp and reschedule cleanup
+        sandboxActivity.set(sessionId, Date.now());
+        rescheduleCleanup(sessionId);
+        logger.debug("Reusing existing sandbox", { sessionId });
+        return existingSandbox;
+    }
+    // Check for in-flight creation (prevents race condition when tools run in parallel)
+    const existingPromise = sandboxCreationPromises.get(sessionId);
+    if (existingPromise) {
+        logger.debug("Waiting for in-flight sandbox creation", { sessionId });
+        return existingPromise;
+    }
+    // Create new sandbox with promise tracking
+    const creationPromise = createSandboxForSession(sessionId, apiKey);
+    sandboxCreationPromises.set(sessionId, creationPromise);
+    try {
+        const sandbox = await creationPromise;
+        return sandbox;
+    }
+    finally {
+        sandboxCreationPromises.delete(sessionId);
+    }
+}
 /**
  * Explicitly destroy a session's sandbox (called on session end).
  * Also clears the persisted sandboxId from storage.

package/dist/runner/langchain/index.js

@@ -412,122 +412,36 @@ export class LangchainAgent {
                 baseContextTokens,
                 modelContextWindow,
             });
-            // Wrap tools with response compaction if hook is configured
-            const hooks = this.definition.hooks ?? [];
-            const hasToolResponseHook = hooks.some((h) => h.type === "tool_response");
-            const noSession = req.sessionMeta?.[SUBAGENT_MODE_KEY] === true; // Subagents don't have session storage
-            // Track cumulative tool output tokens in this turn for proper context calculation
-            let cumulativeToolOutputTokens = 0;
+            // Hook execution removed from tool wrapper - hooks are now executed only at the adapter layer
+            // The adapter has proper MidTurnRestartError handling that can restart the turn
+            // Executing hooks here in the runner was causing restart signals to be caught as tool failures
             // Counter for subagent calls - used to create unique source ID ranges
             // Each subagent call gets a unique offset (1000, 2000, 3000, etc.)
             // to ensure sources never conflict with parent's sources (typically < 100)
             let subagentCallCounter = 0;
-            let wrappedTools = enabledTools;
-            if (hasToolResponseHook && !noSession) {
-                const { countToolResultTokens } = await import("../../utils/token-counter.js");
-                const { toolResponseCompactor } = await import("../hooks/predefined/tool-response-compactor.js");
-                wrappedTools = enabledTools.map((originalTool) => {
-                    const wrappedFunc = async (input) => {
-                        // Execute the original tool
-                        const result = await originalTool.invoke(input);
-                        // Check if result should be compacted
-                        const resultStr = typeof result === "string" ? result : JSON.stringify(result);
-                        const rawOutput = { content: resultStr };
-                        const outputTokens = countToolResultTokens(rawOutput);
-                        // Skip compaction for small results (under 10k tokens)
-                        if (outputTokens < 10000) {
-                            // Still track this in cumulative total
-                            cumulativeToolOutputTokens += outputTokens;
-                            return result;
-                        }
-                        _logger.info("Tool wrapper: compacting large tool result", {
-                            toolName: originalTool.name,
-                            originalTokens: outputTokens,
-                            cumulativeToolOutputTokens,
-                        });
-                        // Calculate current context including all tool outputs so far in this turn
-                        // Uses accurate baseContextTokens calculated earlier (system prompt, tool overhead, MCP overhead, message history)
-                        // This ensures we account for multiple large tool calls in the same turn
-                        const currentTokens = baseContextTokens + cumulativeToolOutputTokens;
-                        // Build proper hook context with all required fields
-                        const hookContext = {
-                            session: {
-                                messages: req.contextMessages || [],
-                                context: [],
-                                requestParams: {
-                                    hookSettings: hooks.find((h) => h.type === "tool_response")
-                                        ?.setting,
-                                },
-                            },
-                            currentTokens,
-                            maxTokens: modelContextWindow,
-                            percentage: (currentTokens / modelContextWindow) * 100,
-                            model: this.definition.model,
-                            agent: this.definition,
-                            toolResponse: {
-                                toolCallId: "pending",
-                                toolName: originalTool.name,
-                                toolInput: input,
-                                rawOutput,
-                                outputTokens,
-                            },
-                        };
-                        // Call the tool response compactor directly
-                        const hookResult = await toolResponseCompactor(hookContext);
-                        // Extract modified output from metadata
-                        if (hookResult?.metadata?.modifiedOutput) {
-                            const modifiedOutput = hookResult.metadata
-                                .modifiedOutput;
-                            const compactedTokens = countToolResultTokens(modifiedOutput);
-                            // Update cumulative total with the compacted size (not original!)
-                            cumulativeToolOutputTokens += compactedTokens;
-                            _logger.info("Tool wrapper: compaction complete", {
-                                toolName: originalTool.name,
-                                originalTokens: outputTokens,
-                                compactedTokens,
-                                reduction: `${((1 - compactedTokens / outputTokens) * 100).toFixed(1)}%`,
-                                totalCumulativeTokens: cumulativeToolOutputTokens,
-                            });
-                            // Include compaction metadata in the output for the adapter to extract
-                            // Also include original content so adapter can store it
-                            const originalContentStr = typeof rawOutput === "object" &&
-                                rawOutput !== null &&
-                                "content" in rawOutput
-                                ? String(rawOutput.content)
-                                : JSON.stringify(rawOutput);
-                            const outputWithMeta = {
-                                ...modifiedOutput,
-                                _compactionMeta: {
-                                    action: hookResult.metadata.action,
-                                    originalTokens: hookResult.metadata.originalTokens,
-                                    finalTokens: hookResult.metadata.finalTokens,
-                                    tokensSaved: hookResult.metadata.tokensSaved,
-                                    originalContent: originalContentStr,
-                                },
-                            };
-                            // Always return JSON string to preserve metadata
-                            return JSON.stringify(outputWithMeta);
-                        }
-                        // No compaction happened, count original size
-                        cumulativeToolOutputTokens += outputTokens;
-                        return result;
-                    };
-                    // Create new tool with wrapped function
-                    // biome-ignore lint/suspicious/noExplicitAny: Need to pass function with dynamic signature
-                    const wrappedTool = tool(wrappedFunc, {
-                        name: originalTool.name,
-                        description: originalTool.description,
-                        // biome-ignore lint/suspicious/noExplicitAny: Accessing internal schema property
-                        schema: originalTool.schema,
-                    });
-                    // Preserve metadata
-                    // biome-ignore lint/suspicious/noExplicitAny: Need to add custom properties to LangChain tool
-                    wrappedTool.prettyName = originalTool.prettyName;
-                    // biome-ignore lint/suspicious/noExplicitAny: Need to add custom properties to LangChain tool
-                    wrappedTool.icon = originalTool.icon;
-                    return wrappedTool;
+            // Simple tool wrapper that just passes through to the original tool
+            // All hook execution (compaction, restart logic) happens at the adapter layer
+            const wrappedTools = enabledTools.map((originalTool) => {
+                const wrappedFunc = async (input) => {
+                    // Execute the original tool and return raw result
+                    const result = await originalTool.invoke(input);
+                    return result;
+                };
+                // Create new tool with wrapped function
+                // biome-ignore lint/suspicious/noExplicitAny: Need to pass function with dynamic signature
+                const wrappedTool = tool(wrappedFunc, {
+                    name: originalTool.name,
+                    description: originalTool.description,
+                    // biome-ignore lint/suspicious/noExplicitAny: Accessing internal schema property
+                    schema: originalTool.schema,
                 });
-            }
+                // Preserve metadata
+                // biome-ignore lint/suspicious/noExplicitAny: Need to add custom properties to LangChain tool
+                wrappedTool.prettyName = originalTool.prettyName;
+                // biome-ignore lint/suspicious/noExplicitAny: Need to add custom properties to LangChain tool
+                wrappedTool.icon = originalTool.icon;
+                return wrappedTool;
+            });
             // Filter tools if running in subagent mode
             const isSubagent = req.sessionMeta?.[SUBAGENT_MODE_KEY] === true;
             const filteredTools = isSubagent

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

@@ -50,11 +50,11 @@ export declare function makeTownE2BTools(): readonly [import("langchain").Dynami
     sandboxPath: string;
     fileName?: string | undefined;
 }, string>, import("langchain").DynamicStructuredTool<z.ZodObject<{
-    document_id: z.ZodString;
+    document_ids: z.ZodArray<z.ZodString>;
 }, z.core.$strip>, {
-    document_id: string;
+    document_ids: string[];
 }, {
-    document_id: string;
+    document_ids: string[];
 }, string>, import("langchain").DynamicStructuredTool<z.ZodObject<{
     prompt: z.ZodString;
 }, z.core.$strip>, {

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

@@ -403,8 +403,8 @@ function makeE2BToolsInternal(getSandbox) {
     shareSandboxFile.prettyName = "Share from Sandbox";
     // biome-ignore lint/suspicious/noExplicitAny: Need to add custom properties to LangChain tool
     shareSandboxFile.icon = "Share";
-    // Tool 6: Upload Library Document to Sandbox
-    const uploadLibraryDocument = tool(async ({ document_id }) => {
+    // Tool 6: Load Library Documents to Sandbox
+    const loadLibraryDocuments = tool(async ({ document_ids }) => {
         const sandbox = await getSandbox();
         try {
             const libraryApiUrl = process.env.LIBRARY_API_URL;
@@ -412,14 +412,14 @@ function makeE2BToolsInternal(getSandbox) {
             if (!libraryApiUrl || !libraryApiKey) {
                 throw new Error("LIBRARY_API_URL and LIBRARY_API_KEY environment variables are required");
             }
-            const response = await fetch(`${libraryApiUrl}/sandbox/upload_document_to_sandbox`, {
+            const response = await fetch(`${libraryApiUrl}/sandbox/upload_documents_to_sandbox`, {
                 method: "POST",
                 headers: {
                     "Content-Type": "application/json",
                     Authorization: `Bearer ${libraryApiKey}`,
                 },
                 body: JSON.stringify({
-                    document_id,
+                    document_ids,
                     sandbox_id: sandbox.sandboxId,
                 }),
             });
@@ -428,34 +428,50 @@ function makeE2BToolsInternal(getSandbox) {
                 throw new Error(`Library API error: ${response.status} - ${text}`);
             }
             const result = await response.json();
-            return result.path;
+            // Format the response
+            const successfulUploads = result.results
+                .filter((r) => r.status === "success")
+                .map((r) => r.file_path);
+            const failedUploads = result.results
+                .filter((r) => r.status === "error")
+                .map((r) => `${r.document_id}: ${r.error}`);
+            let output = `Status: ${result.status}\n`;
+            output += `Uploaded ${result.successful_uploads}/${result.total_requested} documents\n`;
+            if (successfulUploads.length > 0) {
+                output += `\nSuccessful uploads:\n${successfulUploads.join("\n")}`;
+            }
+            if (failedUploads.length > 0) {
+                output += `\nFailed uploads:\n${failedUploads.join("\n")}`;
+            }
+            return output;
         }
         catch (error) {
-            logger.error("Error uploading library document to sandbox", {
+            logger.error("Error loading library documents to sandbox", {
                 error,
-                document_id,
+                document_ids,
             });
-            return `Error uploading document: ${error instanceof Error ? error.message : String(error)}`;
+            return `Error loading documents: ${error instanceof Error ? error.message : String(error)}`;
         }
     }, {
-        name: "Sandbox_UploadLibraryDocument",
-        description: "Upload a document from the library to the cloud sandbox. " +
-            "Use this to make library documents available for processing in the sandbox environment.",
+        name: "Sandbox_LoadLibraryDocuments",
+        description: "Load multiple documents from the library to the cloud sandbox. " +
+            "Use this to make library documents available for processing in the sandbox environment. " +
+            "Supports batch uploads - some documents may succeed while others fail.",
         schema: z.object({
-            document_id: z
-                .string()
-                .describe("The ID of the document to upload from the library"),
+            document_ids: z
+                .array(z.string())
+                .describe("The IDs of the documents to load from the library"),
         }),
     });
     // biome-ignore lint/suspicious/noExplicitAny: Need to add custom properties to LangChain tool
-    uploadLibraryDocument.prettyName = "Upload Library Document";
+    loadLibraryDocuments.prettyName = "Load Library Documents";
     // biome-ignore lint/suspicious/noExplicitAny: Need to add custom properties to LangChain tool
-    uploadLibraryDocument.icon = "Upload";
+    loadLibraryDocuments.icon = "FileText";
     // biome-ignore lint/suspicious/noExplicitAny: Need to add custom properties to LangChain tool
-    uploadLibraryDocument.verbiage = {
-        active: "Uploading document {document_id}",
-        past: "Uploaded document {document_id}",
-        paramKey: "document_id",
+    loadLibraryDocuments.verbiage = {
+        active: "Loading {document_ids.length} documents",
+        past: "Loaded {document_ids.length} documents",
+        paramKey: "document_ids",
     };
     // Tool 7: Generate Image in Sandbox
     const generateImage = tool(async ({ prompt }) => {
@@ -634,7 +650,7 @@ generateImage();
         readSandboxFile,
         writeSandboxFile,
         shareSandboxFile,
-        uploadLibraryDocument,
+        loadLibraryDocuments,
         generateImage,
     ];
 }

package/dist/runner/langchain/tools/subagent-connections.d.ts

@@ -28,6 +28,12 @@ export interface SubagentMessage {
     content: string;
     contentBlocks: SubagentContentBlock[];
     toolCalls: SubagentToolCall[];
+    _meta?: {
+        semanticName?: string;
+        agentDefinitionName?: string;
+        currentActivity?: string;
+        statusGenerating?: boolean;
+    };
 }
 /**
  * Maps query hash to toolCallId.