@townco/agent 0.1.88 → 0.1.101

package/dist/runner/langchain/index.js

@@ -8,13 +8,14 @@ import { z } from "zod";
 import { SUBAGENT_MODE_KEY } from "../../acp-server/adapter";
 import { createLogger } from "../../logger.js";
 import { telemetry } from "../../telemetry/index.js";
-import { bindGeneratorToSessionContext } from "../session-context";
+import { bindGeneratorToAbortSignal, bindGeneratorToSessionContext, getAbortSignal, runWithAbortSignal, } from "../session-context";
 import { loadCustomToolModule, } from "../tool-loader.js";
 import { createModelFromString, detectProvider } from "./model-factory.js";
 import { makeOtelCallbacks } from "./otel-callbacks.js";
 import { makeArtifactsTools } from "./tools/artifacts";
 import { makeBrowserTools } from "./tools/browser";
 import { makeDocumentExtractTool } from "./tools/document_extract";
+import { makeTownE2BTools } from "./tools/e2b";
 import { makeFilesystemTools } from "./tools/filesystem";
 import { makeGenerateImageTool, makeTownGenerateImageTool, } from "./tools/generate_image";
 import { SUBAGENT_TOOL_NAME } from "./tools/subagent";
@@ -44,6 +45,7 @@ export const TOOL_REGISTRY = {
     town_generate_image: () => makeTownGenerateImageTool(),
     browser: () => makeBrowserTools(),
     document_extract: () => makeDocumentExtractTool(),
+    town_e2b: () => makeTownE2BTools(),
 };
 // ============================================================================
 // Custom tool loading
@@ -82,6 +84,12 @@ export class LangchainAgent {
         return telemetry.bindGeneratorToContext(sessionAttributes, generator);
     }
     async *invokeInternal(req) {
+        // Start with the base generator
+        let generator = this.invokeWithContext(req);
+        // Bind abort signal if available (for cancellation support)
+        if (req.abortSignal) {
+            generator = bindGeneratorToAbortSignal(req.abortSignal, generator);
+        }
         // Set up session context for session-scoped file storage
         // This allows tools to access getSessionContext() / getToolOutputDir()
         if (req.agentDir && req.sessionId) {
@@ -95,11 +103,9 @@ export class LangchainAgent {
                 sessionDir,
                 artifactsDir,
             };
-            const boundGenerator = bindGeneratorToSessionContext(sessionContext, this.invokeWithContext(req));
-            return yield* boundGenerator;
+            generator = bindGeneratorToSessionContext(sessionContext, generator);
         }
-        // Fallback: no session context (e.g., missing agentDir)
-        return yield* this.invokeWithContext(req);
+        return yield* generator;
     }
     async *invokeWithContext(req) {
         // Derive the parent OTEL context for this invocation.
@@ -384,6 +390,10 @@ export class LangchainAgent {
             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;
+            // 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");
@@ -426,6 +436,7 @@ export class LangchainAgent {
                             maxTokens,
                             percentage: (currentTokens / maxTokens) * 100,
                             model: this.definition.model,
+                            agent: this.definition,
                             toolResponse: {
                                 toolCallId: "pending",
                                 toolName: originalTool.name,
@@ -510,6 +521,65 @@ export class LangchainAgent {
                         allowedToolNames.has(t.name));
                 });
             }
+            // Wrap the subagent tool to re-number citation sources
+            // This ensures sources from subagents get unique IDs that don't conflict
+            // with the parent agent's own sources or other subagent calls
+            // Each subagent call gets a unique ID range (1000+, 2000+, etc.)
+            finalTools = finalTools.map((t) => {
+                if (t.name !== SUBAGENT_TOOL_NAME) {
+                    return t;
+                }
+                const wrappedFunc = async (input) => {
+                    const result = (await t.invoke(input));
+                    // Check if result has sources to re-number
+                    if (!result ||
+                        typeof result !== "object" ||
+                        !Array.isArray(result.sources) ||
+                        result.sources.length === 0) {
+                        return result;
+                    }
+                    // Increment subagent call counter and calculate base offset
+                    subagentCallCounter++;
+                    const baseOffset = subagentCallCounter * 1000;
+                    let sourceIndex = 0;
+                    // Create ID mapping and re-number sources with offset
+                    const idMapping = new Map();
+                    const renumberedSources = result.sources.map((source) => {
+                        sourceIndex++;
+                        const newId = String(baseOffset + sourceIndex);
+                        idMapping.set(source.id, newId);
+                        return { ...source, id: newId };
+                    });
+                    // Update citation references in the text [[oldId]] -> [[newId]]
+                    let updatedText = result.text;
+                    for (const [oldId, newId] of idMapping) {
+                        const pattern = new RegExp(`\\[\\[${oldId}\\]\\]`, "g");
+                        updatedText = updatedText.replace(pattern, `[[${newId}]]`);
+                    }
+                    _logger.info("Re-numbered subagent citation sources", {
+                        subagentCall: subagentCallCounter,
+                        originalCount: result.sources.length,
+                        idRange: `${baseOffset + 1}-${baseOffset + sourceIndex}`,
+                    });
+                    return { text: updatedText, sources: renumberedSources };
+                };
+                // Create new tool with wrapped function
+                // biome-ignore lint/suspicious/noExplicitAny: Need to pass function with dynamic signature
+                const wrappedTool = tool(wrappedFunc, {
+                    name: t.name,
+                    description: t.description,
+                    // biome-ignore lint/suspicious/noExplicitAny: Accessing internal schema property
+                    schema: t.schema,
+                });
+                // Preserve metadata
+                // biome-ignore lint/suspicious/noExplicitAny: Need to add custom properties to LangChain tool
+                wrappedTool.prettyName = t.prettyName;
+                // biome-ignore lint/suspicious/noExplicitAny: Need to add custom properties to LangChain tool
+                wrappedTool.icon = t.icon;
+                // biome-ignore lint/suspicious/noExplicitAny: Need to preserve subagentConfigs for metadata
+                wrappedTool.subagentConfigs = t.subagentConfigs;
+                return wrappedTool;
+            });
             // Create the model instance using the factory
             // This detects the provider from the model string:
             // - "gemini-2.0-flash" → Google Generative AI
@@ -532,6 +602,32 @@ export class LangchainAgent {
             if (hasTodoWrite) {
                 agentConfig.systemPrompt = `${agentConfig.systemPrompt ?? ""}\n\n${TODO_WRITE_INSTRUCTIONS}`;
             }
+            // Inject citation instructions when web search tools are enabled
+            const hasWebSearch = builtInNames.includes("web_search") ||
+                builtInNames.includes("town_web_search");
+            if (hasWebSearch) {
+                agentConfig.systemPrompt = `${agentConfig.systemPrompt ?? ""}\n\n${CITATION_INSTRUCTIONS}`;
+            }
+            // Inject citation instructions when library/document retrieval tools are enabled
+            // These are typically MCP tools for searching and retrieving internal documents
+            const hasLibraryTools = finalTools.some((t) => t.name.startsWith("library__") ||
+                t.name.includes("get_document") ||
+                t.name.includes("retrieve_document") ||
+                t.name.includes("search_document"));
+            if (hasLibraryTools && !hasWebSearch) {
+                // Only add if not already covered by web search instructions
+                agentConfig.systemPrompt = `${agentConfig.systemPrompt ?? ""}\n\n${DOCUMENT_CITATION_INSTRUCTIONS}`;
+            }
+            else if (hasLibraryTools && hasWebSearch) {
+                // Append document-specific instructions to existing citation instructions
+                agentConfig.systemPrompt = `${agentConfig.systemPrompt ?? ""}\n\n${DOCUMENT_CITATION_ADDENDUM}`;
+            }
+            // Inject subagent citation instructions when agent has subagent tools
+            // This tells the parent agent to preserve citations from subagent responses
+            const hasSubagentTool = finalTools.some((t) => t.name === SUBAGENT_TOOL_NAME);
+            if (hasSubagentTool) {
+                agentConfig.systemPrompt = `${agentConfig.systemPrompt ?? ""}\n\n${SUBAGENT_CITATION_INSTRUCTIONS}`;
+            }
             // Process template variables in system prompt and inject current date/time
             if (agentConfig.systemPrompt) {
                 const currentDateTime = getCurrentDateTimeString();
@@ -540,6 +636,18 @@ export class LangchainAgent {
                 // Replace {{.CurrentDateTime}} template variable (alias)
                 agentConfig.systemPrompt = agentConfig.systemPrompt.replace(/\{\{\.CurrentDateTime\}\}/g, currentDateTime);
             }
+            // Apply prompt parameters from request (user-selected per-message options)
+            if (req.promptParameters && this.definition.promptParameters) {
+                for (const param of this.definition.promptParameters) {
+                    const selectedOptionId = req.promptParameters[param.id];
+                    if (selectedOptionId) {
+                        const option = param.options.find((o) => o.id === selectedOptionId);
+                        if (option?.systemPromptAddendum) {
+                            agentConfig.systemPrompt = `${agentConfig.systemPrompt ?? ""}\n\n${option.systemPromptAddendum}`;
+                        }
+                    }
+                }
+            }
             const agent = createAgent(agentConfig);
             // Build messages from context history if available, otherwise use just the prompt
             // Type includes tool messages for sending tool results
@@ -687,11 +795,17 @@ export class LangchainAgent {
             }
             // Create the stream within the invocation context so AsyncLocalStorage
             // propagates the context to all tool executions and callbacks
+            _logger.info("Starting agent.stream", {
+                messageCount: messages.length,
+                effectiveModel,
+                sessionId: req.sessionId,
+            });
             const stream = context.with(invocationContext, () => agent.stream({ messages }, {
                 streamMode: ["updates", "messages"],
                 recursionLimit: 200,
                 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;
@@ -961,6 +1075,10 @@ export class LangchainAgent {
                             continue; // Skip the rest of the processing for this chunk
                         }
                         if (typeof aiMessage.content === "string") {
+                            console.log("[DEBUG] Yielding agent_message_chunk (string)", {
+                                content: aiMessage.content.slice(0, 100),
+                                hasTokenUsage: !!messageTokenUsage,
+                            });
                             const msgToYield = messageTokenUsage
                                 ? {
                                     sessionUpdate: "agent_message_chunk",
@@ -982,8 +1100,16 @@ export class LangchainAgent {
                             yield msgToYield;
                         }
                         else if (Array.isArray(aiMessage.content)) {
+                            console.log("[DEBUG] Processing array content", {
+                                partCount: aiMessage.content.length,
+                                partTypes: aiMessage.content.map((p) => p.type),
+                            });
                             for (const part of aiMessage.content) {
                                 if (part.type === "text" && typeof part.text === "string") {
+                                    console.log("[DEBUG] Yielding agent_message_chunk (array text)", {
+                                        text: part.text.slice(0, 100),
+                                        hasTokenUsage: !!messageTokenUsage,
+                                    });
                                     const msgToYield = messageTokenUsage
                                         ? {
                                             sessionUpdate: "agent_message_chunk",
@@ -1280,6 +1406,61 @@ I've found some existing telemetry code. Let me mark the first todo as in_progre
 [Assistant continues implementing the feature step by step, marking todos as in_progress and completed as they go]
 </example>
 `.trim();
+// System prompt instructions to inject when WebSearch/WebFetch tools are enabled
+const CITATION_INSTRUCTIONS = `
+# Citations
+When referencing information from web search results or fetched web pages, you MUST cite your sources using double-bracket notation: [[1]], [[2]], etc.
+
+Each number corresponds to a source from your search results. Always cite when:
+- Quoting or paraphrasing information from a source
+- Stating facts or statistics from search results
+- Referencing specific claims from fetched pages
+
+Example:
+"According to recent reports, the company's revenue increased by 15% [[1]]. This growth was primarily driven by their expansion into new markets [[2]]."
+
+Place citations immediately after the relevant claim or at the end of the sentence. Use multiple citations if information comes from multiple sources.
+`.trim();
+// System prompt instructions for agents that use document retrieval tools (library, internal docs, etc.)
+const DOCUMENT_CITATION_INSTRUCTIONS = `
+# Citations
+When referencing information from retrieved documents, you MUST cite your sources using double-bracket notation: [[1]], [[2]], etc.
+
+The document_id from each retrieved document serves as its citation number. Always cite when:
+- Quoting or paraphrasing information from a document
+- Stating facts or data from retrieved documents
+- Referencing specific claims or findings
+
+Example:
+If you retrieve a document with document_id 19448 titled "Q3 Financial Report", cite it as:
+"Revenue grew by 20% in Q3 [[19448]], exceeding analyst expectations."
+
+When summarizing multiple documents, cite each source appropriately:
+"The product roadmap [[19448]] aligns with the strategy outlined in the board memo [[19449]]."
+`.trim();
+// Addendum for agents that have both web search and document retrieval tools
+const DOCUMENT_CITATION_ADDENDUM = `
+# Document Citations
+In addition to web search citations, when referencing information from retrieved internal documents, cite using the document_id:
+- Retrieved documents include a document_id field - use this as the citation number
+- Example: "According to the internal memo [[19448]], the project is on track."
+`.trim();
+// System prompt instructions for agents that use subagents with web search capabilities
+const SUBAGENT_CITATION_INSTRUCTIONS = `
+# Preserving Citations from Subagents
+When subagents return results that include citations (in the format [[N]]), you MUST preserve these citations in your final response. The subagent's output includes a "sources" array that maps citation numbers to their source URLs.
+
+Important guidelines:
+- When summarizing or quoting information from a subagent's response, preserve the original citation numbers exactly as they appear (e.g., [[1001]], [[1002]])
+- These citation numbers link to sources that will be displayed to the user
+- Do not remove or renumber citations - the numbers are already unique across all subagent responses
+- If you paraphrase information that had a citation, include that citation with your paraphrase
+- Facts, statistics, quotes, and specific claims from subagent responses should retain their citations
+
+Example:
+If a subagent returns: "Revenue increased 15% [[1001]] driven by cloud growth [[1002]]"
+Your response should preserve those citations: "The company saw 15% revenue growth [[1001]], primarily from cloud services [[1002]]."
+`.trim();
 /**
  * Returns a human-readable string of the current date and time.
  * Example: "Monday, December 9, 2024 at 2:30 PM PST"
@@ -1299,6 +1480,35 @@ const getCurrentDateTimeString = () => {
 };
 // Re-export subagent tool utility
 export { makeSubagentsTool } from "./tools/subagent.js";
+/**
+ * Get metadata for children tools of a built-in tool group.
+ * This dynamically loads the tool factory and extracts metadata from each tool.
+ * Returns undefined if the tool is not a group (returns single tool or not found).
+ */
+export function getToolGroupChildren(toolName) {
+    const entry = TOOL_REGISTRY[toolName];
+    if (!entry) {
+        return undefined;
+    }
+    // If it's a function, call it to get the tool(s)
+    if (typeof entry === "function") {
+        const result = entry();
+        // Check if it returns an array (tool group)
+        if (Array.isArray(result)) {
+            return result.map((tool) => ({
+                name: tool.name,
+                // biome-ignore lint/suspicious/noExplicitAny: Accessing custom property on LangChain tool
+                prettyName: tool.prettyName || tool.name,
+                // biome-ignore lint/suspicious/noExplicitAny: Accessing custom property on LangChain tool
+                icon: tool.icon,
+            }));
+        }
+        // Single tool factory - not a group
+        return undefined;
+    }
+    // Direct tool reference - not a group
+    return undefined;
+}
 /**
  * Wraps a LangChain tool with OpenTelemetry tracing and session_id injection.
  * This ensures the tool executes within its own span context,
@@ -1318,6 +1528,12 @@ function wrapToolWithTracing(originalTool, getIterationContext, sessionId) {
     ];
     const needsSessionId = TOOLS_NEEDING_SESSION_ID.includes(originalTool.name);
     const wrappedFunc = async (input) => {
+        // Capture the abort signal from the current context BEFORE LangChain breaks AsyncLocalStorage
+        const abortSignal = getAbortSignal();
+        // Check if already cancelled before starting tool
+        if (abortSignal?.aborted) {
+            throw new Error(`Tool ${originalTool.name} cancelled before execution`);
+        }
         // Inject session_id if needed
         let finalInput = input;
         if (needsSessionId && sessionId) {
@@ -1347,8 +1563,12 @@ function wrapToolWithTracing(originalTool, getIterationContext, sessionId) {
                 ? trace.setSpan(iterationContext, toolSpan)
                 : iterationContext;
             try {
-                // Execute within the tool span's context
-                const result = await context.with(spanContext, () => originalTool.invoke(finalInput));
+                // Execute within the tool span's context AND with abort signal context restored
+                const executeWithContext = () => context.with(spanContext, () => originalTool.invoke(finalInput));
+                // Wrap with abort signal context if available
+                const result = abortSignal
+                    ? await runWithAbortSignal(abortSignal, executeWithContext)
+                    : await executeWithContext();
                 const resultStr = typeof result === "string" ? result : JSON.stringify(result);
                 if (toolSpan) {
                     telemetry.setSpanAttributes(toolSpan, {

package/dist/runner/langchain/model-factory.js

@@ -1,3 +1,5 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
 import { ChatAnthropic } from "@langchain/anthropic";
 import { ChatGoogleGenerativeAI } from "@langchain/google-genai";
 import { ChatVertexAI } from "@langchain/google-vertexai";
@@ -104,11 +106,36 @@ export function createModelFromString(modelString) {
         case "openai":
             throw new Error("OpenAI provider is not yet supported. Please install @langchain/openai and add implementation.");
         case "anthropic":
-        case "claude":
+        case "claude": {
+            // Read the expected key from .env file for comparison
+            const envPath = path.resolve(process.cwd(), ".env");
+            let expectedKey = "";
+            try {
+                const envContents = fs.readFileSync(envPath, "utf8");
+                const match = envContents.match(/ANTHROPIC_API_KEY="?([^"\n]+)"?/);
+                if (match) {
+                    expectedKey = match[1] || "";
+                }
+            }
+            catch {
+                expectedKey = "[could not read .env]";
+            }
+            const actualKey = process.env.ANTHROPIC_API_KEY || "";
+            console.log("[DEBUG] Creating Anthropic model", {
+                modelName,
+                hasApiKey: !!actualKey,
+                keysMatch: actualKey === expectedKey,
+                actualKeyLength: actualKey.length,
+                expectedKeyLength: expectedKey.length,
+                actualKeyPrefix: actualKey.slice(0, 15),
+                expectedKeyPrefix: expectedKey.slice(0, 15),
+                cwd: process.cwd(),
+            });
             return new ChatAnthropic({
                 model: modelName,
                 // Use default Anthropic settings
             });
+        }
         default:
             // Fallback to Anthropic for unknown providers (backward compatibility)
             logger.warn(`Unknown provider "${provider}" in model string "${modelString}". Defaulting to Anthropic.`);

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

@@ -31,7 +31,10 @@ import { z } from "zod";
 function getArtifactsKeyPrefix() {
     // 1. Explicit override (highest priority)
     const explicitPrefix = process.env.ARTIFACTS_KEY_PREFIX;
-    if (explicitPrefix) {
+    // Check for valid prefix (not empty, not just quotes from env parsing)
+    if (explicitPrefix &&
+        explicitPrefix !== '""' &&
+        explicitPrefix.trim() !== "") {
         return explicitPrefix.replace(/\/+$/, ""); // Remove trailing slashes
     }
     // 2. Check deployment vs local mode
@@ -393,8 +396,8 @@ const artifactsUrl = tool(async ({ session_id, path, }) => {
     try {
         validateStoragePath(path);
         const storageKey = buildStorageKey(session_id, path);
-        const _url = await generateSignedUrl(storageKey);
-        return `Signed URL for ${path}`;
+        const url = await generateSignedUrl(storageKey);
+        return `Signed URL for ${path}:\n${url}`;
     }
     catch (error) {
         return handleStorageError(error, `Failed to generate URL for ${path}`);

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

@@ -0,0 +1,54 @@
+import { z } from "zod";
+/**
+ * Create E2B tools using Town proxy authentication.
+ * Fetches E2B API key from Town server using user credentials.
+ */
+export declare function makeTownE2BTools(): readonly [import("langchain").DynamicStructuredTool<z.ZodObject<{
+    code: z.ZodString;
+    language: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        javascript: "javascript";
+        python: "python";
+    }>>>;
+}, z.core.$strip>, {
+    code: string;
+    language: "javascript" | "python";
+}, {
+    code: string;
+    language?: "javascript" | "python" | undefined;
+}, string>, import("langchain").DynamicStructuredTool<z.ZodObject<{
+    command: z.ZodString;
+}, z.core.$strip>, {
+    command: string;
+}, {
+    command: string;
+}, string>, import("langchain").DynamicStructuredTool<z.ZodObject<{
+    path: z.ZodString;
+}, z.core.$strip>, {
+    path: string;
+}, {
+    path: string;
+}, string>, import("langchain").DynamicStructuredTool<z.ZodObject<{
+    path: z.ZodString;
+    content: z.ZodString;
+}, z.core.$strip>, {
+    path: string;
+    content: string;
+}, {
+    path: string;
+    content: string;
+}, string>, import("langchain").DynamicStructuredTool<z.ZodObject<{
+    sandboxPath: z.ZodString;
+    fileName: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, {
+    sandboxPath: string;
+    fileName?: string | undefined;
+}, {
+    sandboxPath: string;
+    fileName?: string | undefined;
+}, string>, import("langchain").DynamicStructuredTool<z.ZodObject<{
+    document_id: z.ZodString;
+}, z.core.$strip>, {
+    document_id: string;
+}, {
+    document_id: string;
+}, string>];