@townco/agent 0.1.81 → 0.1.83

package/dist/runner/langchain/index.js

@@ -1,3 +1,5 @@
+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";
@@ -6,12 +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 { 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") {
@@ -418,13 +456,17 @@ export class LangchainAgent {
                         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 +476,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));
@@ -472,6 +515,7 @@ export class LangchainAgent {
             }
             const agent = createAgent(agentConfig);
             // Build messages from context history if available, otherwise use just the prompt
+            // Type includes tool messages for sending tool results
             let messages;
             // Helper to convert content blocks to LangChain format
             // LangChain expects image_url type with data URL, not Claude's native image+source format
@@ -489,26 +533,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";
                                 }
@@ -535,15 +581,66 @@ 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)
-                // Convert to LangChain format
-                messages = req.contextMessages.map((msg) => ({
-                    type: msg.role === "user" ? "human" : "ai",
-                    content: convertContentBlocks(msg.content),
-                }));
+                // Convert to LangChain format, including tool calls and their results
+                messages = [];
+                for (const msg of req.contextMessages) {
+                    if (msg.role === "user") {
+                        messages.push({
+                            type: "human",
+                            content: convertContentBlocks(msg.content),
+                        });
+                    }
+                    else if (msg.role === "assistant") {
+                        // Check if message has tool calls
+                        const toolCalls = msg.content.filter((block) => block.type === "tool_call");
+                        const textBlocks = msg.content.filter((block) => block.type === "text" || block.type === "image");
+                        if (toolCalls.length > 0) {
+                            // Build AI message with tool_use blocks
+                            const aiContent = [];
+                            // Add any text content first
+                            for (const block of textBlocks) {
+                                if (block.type === "text") {
+                                    aiContent.push({ type: "text", text: block.text });
+                                }
+                            }
+                            // Add tool_use blocks
+                            for (const tc of toolCalls) {
+                                if (tc.type === "tool_call") {
+                                    aiContent.push({
+                                        type: "tool_use",
+                                        id: tc.id,
+                                        name: tc.title,
+                                        input: tc.rawInput || {},
+                                    });
+                                }
+                            }
+                            messages.push({ type: "ai", content: aiContent });
+                            // Add tool result messages for each tool call that has output
+                            for (const tc of toolCalls) {
+                                if (tc.type === "tool_call" && tc.rawOutput) {
+                                    messages.push({
+                                        type: "tool",
+                                        tool_call_id: tc.id,
+                                        content: typeof tc.rawOutput === "string"
+                                            ? tc.rawOutput
+                                            : JSON.stringify(tc.rawOutput),
+                                    });
+                                }
+                            }
+                        }
+                        else {
+                            // No tool calls - simple AI message
+                            messages.push({
+                                type: "ai",
+                                content: convertContentBlocks(msg.content),
+                            });
+                        }
+                    }
+                }
                 // Add the current prompt as the final human message
                 const promptContent = convertContentBlocks(req.prompt);
                 messages.push({
@@ -615,6 +712,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);
@@ -689,8 +787,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 &&
@@ -704,6 +805,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;
@@ -1120,16 +1222,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();
@@ -1151,7 +1270,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, {
@@ -1170,14 +1289,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>)[];