@townco/agent 0.1.82 → 0.1.84

package/dist/runner/langchain/index.js

@@ -1,17 +1,21 @@
+import { mkdir } from "node:fs/promises";
+import * as path from "node:path";
 import { MultiServerMCPClient } from "@langchain/mcp-adapters";
 import { context, propagation, trace } from "@opentelemetry/api";
-import { getShedAuth } from "@townco/core/auth";
+import { ensureAuthenticated } from "@townco/core/auth";
 import { AIMessageChunk, createAgent, ToolMessage, tool, } from "langchain";
 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 { 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 { makeFilesystemTools } from "./tools/filesystem";
-import { makeGenerateImageTool } from "./tools/generate_image";
+import { makeGenerateImageTool, makeTownGenerateImageTool, } from "./tools/generate_image";
 import { SUBAGENT_TOOL_NAME } from "./tools/subagent";
 import { hashQuery, queryToToolCallId, subagentEvents, } from "./tools/subagent-connections";
 import { makeTodoWriteTool, TODO_WRITE_TOOL_NAME } from "./tools/todo";
@@ -24,15 +28,19 @@ const getWeather = tool(({ city }) => `It's always sunny in ${city}!`, {
         city: z.string(),
     }),
 });
+// biome-ignore lint/suspicious/noExplicitAny: Need to add custom properties to LangChain tool
 getWeather.prettyName = "Get Weather";
+// biome-ignore lint/suspicious/noExplicitAny: Need to add custom properties to LangChain tool
 getWeather.icon = "Cloud";
 export const TOOL_REGISTRY = {
+    artifacts: () => makeArtifactsTools(),
     todo_write: () => makeTodoWriteTool(), // Factory function to create fresh instance per invocation
     get_weather: getWeather, // TODO: Convert to factory function for full concurrency safety
     web_search: () => makeWebSearchTools(),
     town_web_search: () => makeTownWebSearchTools(),
-    filesystem: () => makeFilesystemTools(process.cwd()),
+    filesystem: () => makeFilesystemTools(),
     generate_image: () => makeGenerateImageTool(),
+    town_generate_image: () => makeTownGenerateImageTool(),
     browser: () => makeBrowserTools(),
 };
 // ============================================================================
@@ -44,7 +52,9 @@ function toLangchainTool(resolved) {
         description: resolved.description,
         schema: resolved.schema,
     });
+    // biome-ignore lint/suspicious/noExplicitAny: Need to add custom properties to LangChain tool
     t.prettyName = resolved.prettyName;
+    // biome-ignore lint/suspicious/noExplicitAny: Need to add custom properties to LangChain tool
     t.icon = resolved.icon;
     return t;
 }
@@ -70,6 +80,26 @@ export class LangchainAgent {
         return telemetry.bindGeneratorToContext(sessionAttributes, generator);
     }
     async *invokeInternal(req) {
+        // Set up session context for session-scoped file storage
+        // This allows tools to access getSessionContext() / getToolOutputDir()
+        if (req.agentDir && req.sessionId) {
+            const sessionDir = path.join(req.agentDir, ".sessions", req.sessionId);
+            const artifactsDir = path.join(sessionDir, "artifacts");
+            // Ensure artifacts directory exists
+            await mkdir(artifactsDir, { recursive: true });
+            // Bind the generator to session context so every iteration has access
+            const sessionContext = {
+                sessionId: req.sessionId,
+                sessionDir,
+                artifactsDir,
+            };
+            const boundGenerator = bindGeneratorToSessionContext(sessionContext, this.invokeWithContext(req));
+            return yield* boundGenerator;
+        }
+        // Fallback: no session context (e.g., missing agentDir)
+        return yield* this.invokeWithContext(req);
+    }
+    async *invokeWithContext(req) {
         // 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;
@@ -136,6 +166,7 @@ export class LangchainAgent {
         // 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());
             }
             return new Promise((resolve) => {
@@ -146,6 +177,8 @@ export class LangchainAgent {
         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,
@@ -164,6 +197,8 @@ export class LangchainAgent {
             // Also yield any pending messages updates
             while (subagentMessagesQueue.length > 0) {
                 const messagesUpdate = subagentMessagesQueue.shift();
+                if (!messagesUpdate)
+                    continue;
                 _logger.info("Yielding queued subagent messages update", {
                     toolCallId: messagesUpdate.toolCallId,
                     messageCount: messagesUpdate.messages.length,
@@ -246,11 +281,11 @@ export class LangchainAgent {
                         customToolPaths.push(t.modulePath);
                     }
                     else if (type === "filesystem") {
-                        const wd = t.working_directory ??
-                            process.cwd();
-                        const fsTools = makeFilesystemTools(wd);
+                        // Note: working_directory is ignored - filesystem tools now use session context
+                        const fsTools = makeFilesystemTools();
                         // Tag filesystem tools with their group name for tool override filtering
                         for (const fsTool of fsTools) {
+                            // biome-ignore lint/suspicious/noExplicitAny: Need to add custom property for tool grouping
                             fsTool.__groupName = "filesystem";
                         }
                         enabledTools.push(...fsTools);
@@ -263,7 +298,9 @@ export class LangchainAgent {
                             description: t.description,
                             schema: t.schema,
                         });
+                        // biome-ignore lint/suspicious/noExplicitAny: Need to add custom properties to LangChain tool
                         addedTool.prettyName = t.prettyName;
+                        // biome-ignore lint/suspicious/noExplicitAny: Need to add custom properties to LangChain tool
                         addedTool.icon = t.icon;
                         enabledTools.push(addedTool);
                     }
@@ -279,6 +316,7 @@ export class LangchainAgent {
                     // Track which built-in group produced this tool so overrides can
                     // filter by the original config name (e.g. "web_search" filters
                     // both WebSearch and WebFetch helpers).
+                    // biome-ignore lint/suspicious/noExplicitAny: Need to add custom property for tool grouping
                     tool.__groupName = name;
                 };
                 if (typeof entry === "function") {
@@ -318,7 +356,8 @@ export class LangchainAgent {
             // MCP tools - calculate overhead separately
             let mcpOverheadTokens = 0;
             if ((this.definition.mcps?.length ?? 0) > 0) {
-                const mcpTools = await makeMcpToolsClient(this.definition.mcps).getTools();
+                const client = await makeMcpToolsClient(this.definition.mcps);
+                const mcpTools = await client.getTools();
                 const mcpToolMetadata = mcpTools.map(extractToolMetadata);
                 mcpOverheadTokens = estimateAllToolsOverhead(mcpToolMetadata);
                 enabledTools.push(...mcpTools);
@@ -409,22 +448,42 @@ export class LangchainAgent {
                                 reduction: `${((1 - compactedTokens / outputTokens) * 100).toFixed(1)}%`,
                                 totalCumulativeTokens: cumulativeToolOutputTokens,
                             });
-                            return typeof result === "string"
-                                ? modifiedOutput.content
-                                : JSON.stringify(modifiedOutput);
+                            // 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;
                 });
@@ -434,15 +493,16 @@ export class LangchainAgent {
             const filteredTools = isSubagent
                 ? wrappedTools.filter((t) => t.name !== TODO_WRITE_TOOL_NAME && t.name !== SUBAGENT_TOOL_NAME)
                 : wrappedTools;
-            // Wrap tools with tracing so each tool executes within its own span context.
+            // Wrap tools with tracing and session_id injection (combined in one wrapper)
             // This ensures subagent spans are children of the Task tool span.
             // Pass the context getter so tools can nest under the current iteration span.
             let finalTools = filteredTools.map((t) => wrapToolWithTracing(t, otelCallbacks?.getCurrentIterationContext ??
-                (() => invocationContext)));
+                (() => invocationContext), req.sessionId));
             // Apply tool overrides if provided (Town Hall comparison feature)
             if (req.configOverrides?.tools && req.configOverrides.tools.length > 0) {
                 const allowedToolNames = new Set(req.configOverrides.tools);
                 finalTools = finalTools.filter((t) => {
+                    // biome-ignore lint/suspicious/noExplicitAny: Accessing custom property for tool grouping
                     const groupName = t.__groupName;
                     return (allowedToolNames.has(groupName ?? "") ||
                         allowedToolNames.has(t.name));
@@ -490,26 +550,28 @@ export class LangchainAgent {
                 // LangChain uses image_url type with data URL format
                 return blocks
                     .map((block) => {
-                    if (block.type === "text") {
+                    const typedBlock = block;
+                    if (typedBlock.type === "text") {
                         return {
                             type: "text",
-                            text: block.text,
+                            text: typedBlock.text,
                         };
                     }
-                    else if (block.type === "image") {
+                    else if (typedBlock.type === "image") {
                         // Extract base64 data and media type from various formats
                         let base64Data;
                         let mediaType = "image/png";
                         // Check if it has the source format (Claude API format)
-                        if ("source" in block && block.source) {
-                            base64Data = block.source.data;
-                            mediaType = block.source.media_type || "image/png";
+                        if ("source" in typedBlock && typedBlock.source) {
+                            const source = typedBlock.source;
+                            base64Data = source.data;
+                            mediaType = source.media_type || "image/png";
                         }
                         // ACP format: { type: "image", data: "...", mimeType: "..." }
-                        else if ("data" in block && block.data) {
-                            base64Data = block.data;
-                            if (block.mimeType) {
-                                const mt = block.mimeType.toLowerCase();
+                        else if ("data" in typedBlock && typedBlock.data) {
+                            base64Data = typedBlock.data;
+                            if (typedBlock.mimeType) {
+                                const mt = typedBlock.mimeType.toLowerCase();
                                 if (mt === "image/jpeg" || mt === "image/jpg") {
                                     mediaType = "image/jpeg";
                                 }
@@ -536,7 +598,7 @@ export class LangchainAgent {
                     }
                     return null;
                 })
-                    .filter(Boolean);
+                    .filter((item) => item !== null);
             };
             if (req.contextMessages && req.contextMessages.length > 0) {
                 // Use context messages (already resolved from context entries)
@@ -667,6 +729,7 @@ export class LangchainAgent {
                 }
                 // Also yield any queued subagent updates before processing stream item
                 yield* yieldPendingSubagentUpdates();
+                // biome-ignore lint/suspicious/noExplicitAny: LangChain stream items are tuples with dynamic types
                 const [streamMode, chunk] = streamItem;
                 if (streamMode === "updates") {
                     const updatesChunk = modelRequestSchema.safeParse(chunk);
@@ -741,8 +804,11 @@ export class LangchainAgent {
                             //  continue;
                             //}
                             const matchingTool = finalTools.find((t) => t.name === toolCall.name);
+                            // biome-ignore lint/suspicious/noExplicitAny: Accessing custom property on LangChain tool
                             let prettyName = matchingTool?.prettyName;
+                            // biome-ignore lint/suspicious/noExplicitAny: Accessing custom property on LangChain tool
                             const icon = matchingTool?.icon;
+                            // biome-ignore lint/suspicious/noExplicitAny: Accessing custom property on LangChain tool
                             const verbiage = matchingTool?.verbiage;
                             // For the Task tool, use the displayName (or agentName as fallback) as the prettyName
                             if (toolCall.name === SUBAGENT_TOOL_NAME &&
@@ -756,6 +822,7 @@ export class LangchainAgent {
                                 const taskTool = this.definition.tools?.find((t) => typeof t === "object" &&
                                     t.type === "direct" &&
                                     t.name === SUBAGENT_TOOL_NAME);
+                                // biome-ignore lint/suspicious/noExplicitAny: Accessing custom property on tool definition
                                 const subagentConfigs = taskTool?.subagentConfigs;
                                 const subagentConfig = subagentConfigs?.find((config) => config.agentName === agentName);
                                 prettyName = subagentConfig?.displayName ?? agentName;
@@ -987,6 +1054,40 @@ export class LangchainAgent {
                                 _meta: { messageId: req.messageId },
                             });
                             // Buffer tool output separately
+                            // Check if the content contains compaction metadata and extract it
+                            let rawOutput = {
+                                content: aiMessage.content,
+                            };
+                            let compactionMeta;
+                            try {
+                                const parsed = JSON.parse(aiMessage.content);
+                                if (typeof parsed === "object" &&
+                                    parsed !== null &&
+                                    "_compactionMeta" in parsed) {
+                                    // Extract compaction metadata to top level of rawOutput
+                                    const { _compactionMeta, ...contentWithoutMeta } = parsed;
+                                    compactionMeta = _compactionMeta;
+                                    rawOutput = {
+                                        content: JSON.stringify(contentWithoutMeta),
+                                        _compactionMeta,
+                                    };
+                                }
+                            }
+                            catch {
+                                // Not valid JSON, use original content
+                            }
+                            // For content display, use cleaned version if compaction occurred
+                            let displayContent = aiMessage.content;
+                            if (compactionMeta) {
+                                try {
+                                    const parsed = JSON.parse(aiMessage.content);
+                                    const { _compactionMeta: _, ...cleanParsed } = parsed;
+                                    displayContent = JSON.stringify(cleanParsed);
+                                }
+                                catch {
+                                    // Keep original if parsing fails
+                                }
+                            }
                             pendingToolCallNotifications.push({
                                 sessionUpdate: "tool_output",
                                 toolCallId: aiMessage.tool_call_id,
@@ -995,11 +1096,11 @@ export class LangchainAgent {
                                         type: "content",
                                         content: {
                                             type: "text",
-                                            text: aiMessage.content,
+                                            text: displayContent,
                                         },
                                     },
                                 ],
-                                rawOutput: { content: aiMessage.content },
+                                rawOutput,
                                 _meta: { messageId: req.messageId },
                             });
                             // Flush tool outputs after buffering
@@ -1069,11 +1170,11 @@ const modelRequestSchema = z.object({
         messages: z.array(z.any()),
     }),
 });
-const makeMcpToolsClient = (mcpConfigs) => {
-    const mcpServers = mcpConfigs?.map((config) => {
+const makeMcpToolsClient = async (mcpConfigs) => {
+    const mcpServers = await Promise.all((mcpConfigs ?? []).map(async (config) => {
         if (typeof config === "string") {
             // String configs use the centralized MCP proxy with auth
-            const shedAuth = getShedAuth();
+            const shedAuth = await ensureAuthenticated();
             if (!shedAuth) {
                 throw new Error("Not logged in. Run 'town login' or set SHED_API_KEY to use cloud MCP servers.");
             }
@@ -1105,7 +1206,7 @@ const makeMcpToolsClient = (mcpConfigs) => {
                 args: config.args ?? [],
             },
         ];
-    });
+    }));
     const client = new MultiServerMCPClient({
         // Global tool configuration options
         // Whether to throw on errors if a tool fails to load (optional, default: true)
@@ -1172,16 +1273,33 @@ I've found some existing telemetry code. Let me mark the first todo as in_progre
 // Re-export subagent tool utility
 export { makeSubagentsTool } from "./tools/subagent.js";
 /**
- * Wraps a LangChain tool with OpenTelemetry tracing.
+ * Wraps a LangChain tool with OpenTelemetry tracing and session_id injection.
  * This ensures the tool executes within its own span context,
  * so any child operations (like subagent spawning) become children
  * of the tool span rather than the parent invocation span.
  * @param originalTool The tool to wrap
  * @param getIterationContext Function that returns the current iteration context
+ * @param sessionId Optional session ID to inject for artifact tools
  */
-function wrapToolWithTracing(originalTool, getIterationContext) {
+function wrapToolWithTracing(originalTool, getIterationContext, sessionId) {
+    // Check if this tool needs session_id injection
+    const TOOLS_NEEDING_SESSION_ID = [
+        "artifacts_cp",
+        "artifacts_del",
+        "artifacts_ls",
+        "artifacts_url",
+    ];
+    const needsSessionId = TOOLS_NEEDING_SESSION_ID.includes(originalTool.name);
     const wrappedFunc = async (input) => {
-        const toolInputJson = JSON.stringify(input);
+        // Inject session_id if needed
+        let finalInput = input;
+        if (needsSessionId && sessionId) {
+            finalInput = {
+                ...input,
+                session_id: sessionId,
+            };
+        }
+        const toolInputJson = JSON.stringify(finalInput);
         // CRITICAL: Get the iteration context synchronously when the tool is invoked.
         // We must capture both the context AND the parent span at this moment.
         const iterationContext = getIterationContext();
@@ -1203,7 +1321,7 @@ function wrapToolWithTracing(originalTool, getIterationContext) {
                 : iterationContext;
             try {
                 // Execute within the tool span's context
-                const result = await context.with(spanContext, () => originalTool.invoke(input));
+                const result = await context.with(spanContext, () => originalTool.invoke(finalInput));
                 const resultStr = typeof result === "string" ? result : JSON.stringify(result);
                 if (toolSpan) {
                     telemetry.setSpanAttributes(toolSpan, {
@@ -1222,14 +1340,19 @@ function wrapToolWithTracing(originalTool, getIterationContext) {
         });
     };
     // 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 copy custom properties between LangChain tools
     wrappedTool.prettyName = originalTool.prettyName;
+    // biome-ignore lint/suspicious/noExplicitAny: Need to copy custom properties between LangChain tools
     wrappedTool.icon = originalTool.icon;
+    // biome-ignore lint/suspicious/noExplicitAny: Need to copy custom properties between LangChain tools
     wrappedTool.__groupName = originalTool.__groupName;
     return wrappedTool;
 }

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<{
+        upload: "upload";
+        download: "download";
+    }>;
+}, z.core.$strip>, {
+    session_id: string;
+    source: string;
+    destination: string;
+    direction: "upload" | "download";
+}, {
+    source: string;
+    destination: string;
+    direction: "upload" | "download";
+    session_id?: string | undefined;
+}, string> | import("langchain").DynamicStructuredTool<z.ZodObject<{
+    session_id: z.ZodOptional<z.ZodString>;
+    path: z.ZodString;
+}, z.core.$strip>, {
+    session_id: string;
+    path: string;
+}, {
+    path: string;
+    session_id?: string | undefined;
+}, 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;
+}, {
+    path: string;
+    session_id?: string | undefined;
+    expires_in?: number | undefined;
+}, string>)[];