@townco/agent 0.1.52 → 0.1.54

package/dist/runner/langchain/index.js

@@ -9,7 +9,8 @@ import { loadCustomToolModule, } from "../tool-loader.js";
 import { createModelFromString, detectProvider } from "./model-factory.js";
 import { makeOtelCallbacks } from "./otel-callbacks.js";
 import { makeFilesystemTools } from "./tools/filesystem";
-import { TASK_TOOL_NAME } from "./tools/subagent";
+import { makeGenerateImageTool } from "./tools/generate_image";
+import { SUBAGENT_TOOL_NAME } from "./tools/subagent";
 import { TODO_WRITE_TOOL_NAME, todoWrite } from "./tools/todo";
 import { makeWebSearchTools } from "./tools/web_search";
 const _logger = createLogger("agent-runner");
@@ -27,6 +28,7 @@ export const TOOL_REGISTRY = {
     get_weather: getWeather,
     web_search: () => makeWebSearchTools(),
     filesystem: () => makeFilesystemTools(process.cwd()),
+    generate_image: () => makeGenerateImageTool(),
 };
 // ============================================================================
 // Custom tool loading
@@ -54,7 +56,6 @@ async function loadCustomTools(modulePaths) {
 }
 export class LangchainAgent {
     definition;
-    toolSpans = new Map();
     constructor(params) {
         this.definition = params;
     }
@@ -75,6 +76,8 @@ export class LangchainAgent {
             totalTokens: 0,
         };
         const countedMessageIds = new Set();
+        // Track tool calls for which we've emitted preliminary notifications (from early tool_use blocks)
+        const preliminaryToolCallIds = new Set();
         // Start telemetry span for entire invocation
         const invocationSpan = telemetry.startSpan("agent.invoke", {
             "agent.model": this.definition.model,
@@ -157,10 +160,41 @@ export class LangchainAgent {
                 const customTools = await loadCustomTools(customToolPaths);
                 enabledTools.push(...customTools);
             }
-            // MCP tools
+            // Calculate tool overhead tokens for non-MCP tools
+            const { countTokens } = await import("../../utils/token-counter.js");
+            const { extractToolMetadata, estimateAllToolsOverhead } = await import("../../utils/tool-overhead-calculator.js");
+            // Calculate overhead for non-MCP tools (built-in, custom, filesystem)
+            const nonMcpToolMetadata = enabledTools.map(extractToolMetadata);
+            const nonMcpToolDefinitionsTokens = estimateAllToolsOverhead(nonMcpToolMetadata);
+            // Calculate TODO_WRITE_INSTRUCTIONS overhead if applicable
+            const hasTodoWriteTool = builtInNames.includes("todo_write");
+            const todoInstructionsTokens = hasTodoWriteTool
+                ? countTokens(TODO_WRITE_INSTRUCTIONS)
+                : 0;
+            // Total non-MCP tool overhead: tool definitions + TODO instructions
+            const toolOverheadTokens = nonMcpToolDefinitionsTokens + todoInstructionsTokens;
+            // MCP tools - calculate overhead separately
+            let mcpOverheadTokens = 0;
             if ((this.definition.mcps?.length ?? 0) > 0) {
-                enabledTools.push(...(await makeMcpToolsClient(this.definition.mcps).getTools()));
+                const mcpTools = await makeMcpToolsClient(this.definition.mcps).getTools();
+                const mcpToolMetadata = mcpTools.map(extractToolMetadata);
+                mcpOverheadTokens = estimateAllToolsOverhead(mcpToolMetadata);
+                enabledTools.push(...mcpTools);
             }
+            _logger.debug("Calculated tool overhead for context sizing", {
+                enabledToolCount: enabledTools.length,
+                nonMcpToolDefinitionsTokens,
+                mcpToolDefinitionsTokens: mcpOverheadTokens,
+                todoInstructionsTokens,
+                totalNonMcpOverheadTokens: toolOverheadTokens,
+                totalMcpOverheadTokens: mcpOverheadTokens,
+            });
+            // Yield tool overhead info to adapter early in the turn
+            yield {
+                sessionUpdate: "tool_overhead_info",
+                toolOverheadTokens,
+                mcpOverheadTokens,
+            };
             // Wrap tools with response compaction if hook is configured
             const hooks = this.definition.hooks ?? [];
             const hasToolResponseHook = hooks.some((h) => h.type === "tool_response");
@@ -255,9 +289,12 @@ export class LangchainAgent {
             }
             // Filter tools if running in subagent mode
             const isSubagent = req.sessionMeta?.[SUBAGENT_MODE_KEY] === true;
-            const finalTools = isSubagent
-                ? wrappedTools.filter((t) => t.name !== TODO_WRITE_TOOL_NAME && t.name !== TASK_TOOL_NAME)
+            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.
+            // This ensures subagent spans are children of the Task tool span.
+            const finalTools = filteredTools.map((t) => wrapToolWithTracing(t, req.sessionId));
             // Create the model instance using the factory
             // This detects the provider from the model string:
             // - "gemini-2.0-flash" → Google Generative AI
@@ -281,35 +318,93 @@ export class LangchainAgent {
             const provider = detectProvider(this.definition.model);
             // Build messages from context history if available, otherwise use just the prompt
             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
+            const convertContentBlocks = (blocks) => {
+                // Check if we have any image blocks
+                const hasImages = blocks.some((block) => block.type === "image");
+                if (!hasImages) {
+                    // Simple text-only message
+                    return blocks
+                        .filter((block) => block.type === "text")
+                        .map((block) => block.text)
+                        .join("");
+                }
+                // Multi-modal message with images - return as content block array
+                // LangChain uses image_url type with data URL format
+                return blocks
+                    .map((block) => {
+                    if (block.type === "text") {
+                        return {
+                            type: "text",
+                            text: block.text,
+                        };
+                    }
+                    else if (block.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";
+                        }
+                        // ACP format: { type: "image", data: "...", mimeType: "..." }
+                        else if ("data" in block && block.data) {
+                            base64Data = block.data;
+                            if (block.mimeType) {
+                                const mt = block.mimeType.toLowerCase();
+                                if (mt === "image/jpeg" || mt === "image/jpg") {
+                                    mediaType = "image/jpeg";
+                                }
+                                else if (mt === "image/png") {
+                                    mediaType = "image/png";
+                                }
+                                else if (mt === "image/gif") {
+                                    mediaType = "image/gif";
+                                }
+                                else if (mt === "image/webp") {
+                                    mediaType = "image/webp";
+                                }
+                            }
+                        }
+                        if (base64Data) {
+                            // LangChain format: image_url with data URL
+                            return {
+                                type: "image_url",
+                                image_url: {
+                                    url: `data:${mediaType};base64,${base64Data}`,
+                                },
+                            };
+                        }
+                    }
+                    return null;
+                })
+                    .filter(Boolean);
+            };
             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",
-                    // Extract text from content blocks
-                    content: msg.content
-                        .filter((block) => block.type === "text")
-                        .map((block) => block.text)
-                        .join(""),
+                    content: convertContentBlocks(msg.content),
                 }));
                 // Add the current prompt as the final human message
-                const currentPromptText = req.prompt
-                    .filter((promptMsg) => promptMsg.type === "text")
-                    .map((promptMsg) => promptMsg.text)
-                    .join("\n");
+                const promptContent = convertContentBlocks(req.prompt);
                 messages.push({
                     type: "human",
-                    content: currentPromptText,
+                    content: promptContent,
                 });
             }
             else {
                 // Fallback: No context history, use just the prompt
-                messages = req.prompt
-                    .filter((promptMsg) => promptMsg.type === "text")
-                    .map((promptMsg) => ({
-                    type: "human",
-                    content: promptMsg.text,
-                }));
+                const promptContent = convertContentBlocks(req.prompt);
+                messages = [
+                    {
+                        type: "human",
+                        content: promptContent,
+                    },
+                ];
             }
             // Create OTEL callbacks for instrumentation
             const otelCallbacks = makeOtelCallbacks({
@@ -358,20 +453,15 @@ export class LangchainAgent {
                             turnTokenUsage.totalTokens += tokenUsage.totalTokens ?? 0;
                             countedMessageIds.add(msg.id);
                         }
-                        for (const toolCall of msg.tool_calls ?? []) {
+                        // Generate a batch ID if there are multiple tool calls (parallel execution)
+                        const toolCalls = msg.tool_calls ?? [];
+                        const batchId = toolCalls.length > 1
+                            ? `batch-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`
+                            : undefined;
+                        for (const toolCall of toolCalls) {
                             if (toolCall.id == null) {
                                 throw new Error(`Tool call is missing id: ${JSON.stringify(toolCall)}`);
                             }
-                            // Create tool span within the invocation context
-                            // This makes the tool span a child of the invocation span
-                            const toolInputJson = JSON.stringify(toolCall.args);
-                            const toolSpan = context.with(invocationContext, () => telemetry.startSpan("agent.tool_call", {
-                                "tool.name": toolCall.name,
-                                "tool.id": toolCall.id,
-                                "tool.input": toolInputJson,
-                                "agent.session_id": req.sessionId,
-                            }));
-                            this.toolSpans.set(toolCall.id, toolSpan);
                             telemetry.log("info", `Tool call started: ${toolCall.name}`, {
                                 toolCallId: toolCall.id,
                                 toolName: toolCall.name,
@@ -404,22 +494,61 @@ export class LangchainAgent {
                             //  continue;
                             //}
                             const matchingTool = finalTools.find((t) => t.name === toolCall.name);
-                            const prettyName = matchingTool?.prettyName;
+                            let prettyName = matchingTool?.prettyName;
                             const icon = matchingTool?.icon;
-                            yield {
-                                sessionUpdate: "tool_call",
-                                toolCallId: toolCall.id,
-                                title: toolCall.name,
-                                kind: "other",
-                                status: "pending",
-                                rawInput: toolCall.args,
-                                ...(tokenUsage ? { tokenUsage } : {}),
-                                _meta: {
-                                    messageId: req.messageId,
-                                    ...(prettyName ? { prettyName } : {}),
-                                    ...(icon ? { icon } : {}),
-                                },
-                            };
+                            // For the Task tool, use the displayName (or agentName as fallback) as the prettyName
+                            if (toolCall.name === SUBAGENT_TOOL_NAME &&
+                                toolCall.args &&
+                                typeof toolCall.args === "object" &&
+                                "agentName" in toolCall.args &&
+                                typeof toolCall.args.agentName === "string") {
+                                const agentName = toolCall.args.agentName;
+                                // Look up displayName from subagentConfigs in the original tool definition
+                                // (not from matchingTool, which is a LangChain tool without subagentConfigs)
+                                const taskTool = this.definition.tools?.find((t) => typeof t === "object" &&
+                                    t.type === "direct" &&
+                                    t.name === SUBAGENT_TOOL_NAME);
+                                const subagentConfigs = taskTool?.subagentConfigs;
+                                const subagentConfig = subagentConfigs?.find((config) => config.agentName === agentName);
+                                prettyName = subagentConfig?.displayName ?? agentName;
+                            }
+                            // Check if we already emitted a preliminary notification from early tool_use block
+                            const alreadyEmittedPreliminary = preliminaryToolCallIds.has(toolCall.id);
+                            if (alreadyEmittedPreliminary) {
+                                // Update the existing preliminary notification with full details
+                                yield {
+                                    sessionUpdate: "tool_call_update",
+                                    toolCallId: toolCall.id,
+                                    title: toolCall.name,
+                                    rawInput: toolCall.args,
+                                    ...(tokenUsage ? { tokenUsage } : {}),
+                                    _meta: {
+                                        messageId: req.messageId,
+                                        ...(prettyName ? { prettyName } : {}),
+                                        ...(icon ? { icon } : {}),
+                                        ...(batchId ? { batchId } : {}),
+                                    },
+                                };
+                            }
+                            else {
+                                // Emit full tool_call notification (fallback for non-streaming scenarios)
+                                yield {
+                                    sessionUpdate: "tool_call",
+                                    toolCallId: toolCall.id,
+                                    title: toolCall.name,
+                                    kind: "other",
+                                    status: "pending",
+                                    rawInput: toolCall.args,
+                                    ...(tokenUsage ? { tokenUsage } : {}),
+                                    _meta: {
+                                        messageId: req.messageId,
+                                        ...(prettyName ? { prettyName } : {}),
+                                        ...(icon ? { icon } : {}),
+                                        ...(batchId ? { batchId } : {}),
+                                    },
+                                };
+                            }
+                            // Always emit in_progress status update
                             yield {
                                 sessionUpdate: "tool_call_update",
                                 toolCallId: toolCall.id,
@@ -533,10 +662,26 @@ export class LangchainAgent {
                                     yield msgToYield;
                                 }
                                 else if (part.type === "tool_use") {
-                                    // We don't care about tool use chunks -- do nothing
+                                    // Emit early notification for tool use as soon as we detect it
+                                    // The tool_use block contains { type, id, name, input }
+                                    const toolUseBlock = part;
+                                    if (toolUseBlock.id &&
+                                        toolUseBlock.name &&
+                                        !preliminaryToolCallIds.has(toolUseBlock.id)) {
+                                        preliminaryToolCallIds.add(toolUseBlock.id);
+                                        yield {
+                                            sessionUpdate: "tool_call",
+                                            toolCallId: toolUseBlock.id,
+                                            title: toolUseBlock.name,
+                                            kind: "other",
+                                            status: "pending",
+                                            rawInput: {}, // Args not available yet
+                                            _meta: { messageId: req.messageId },
+                                        };
+                                    }
                                 }
                                 else if (part.type === "input_json_delta") {
-                                    // We don't care about tool use input delta chunks -- do nothing
+                                    // Input JSON delta chunks - we don't process these as tool_call is already emitted
                                 }
                                 else {
                                     throw new Error(`Unhandled AIMessageChunk content block type: ${part.type}\n${JSON.stringify(part)}`);
@@ -553,24 +698,22 @@ export class LangchainAgent {
                                 // Skip tool_call_update for todo_write tools
                                 continue;
                             }
-                            // End telemetry span for this tool call
-                            const toolSpan = this.toolSpans.get(aiMessage.tool_call_id);
-                            if (toolSpan) {
-                                // Add tool output to span before ending
-                                telemetry.setSpanAttributes(toolSpan, {
-                                    "tool.output": aiMessage.content,
-                                });
-                                telemetry.log("info", "Tool call completed", {
-                                    toolCallId: aiMessage.tool_call_id,
-                                });
-                                telemetry.endSpan(toolSpan);
-                                this.toolSpans.delete(aiMessage.tool_call_id);
-                            }
+                            // Check if the tool execution failed
+                            // LangChain may set status: "error" OR the content may start with "Error:"
+                            const contentLooksLikeError = typeof aiMessage.content === "string" &&
+                                aiMessage.content.trim().startsWith("Error:");
+                            const isError = aiMessage.status === "error" || contentLooksLikeError;
+                            const status = isError ? "failed" : "completed";
+                            telemetry.log(isError ? "error" : "info", `Tool call ${status}`, {
+                                toolCallId: aiMessage.tool_call_id,
+                                ...(isError ? { error: aiMessage.content } : {}),
+                            });
                             // Send status update (metadata only, no content)
                             yield {
                                 sessionUpdate: "tool_call_update",
                                 toolCallId: aiMessage.tool_call_id,
-                                status: "completed",
+                                status,
+                                ...(isError ? { error: aiMessage.content } : {}),
                                 _meta: { messageId: req.messageId },
                             };
                             // Send tool output separately (via direct SSE, bypassing PostgreSQL NOTIFY)
@@ -632,6 +775,16 @@ const modelRequestSchema = z.object({
 });
 const makeMcpToolsClient = (mcpConfigs) => {
     const mcpServers = mcpConfigs?.map((config) => {
+        if (typeof config === "string") {
+            // Default to localhost:3000/mcp_proxy if not specified
+            const proxyUrl = process.env.MCP_PROXY_URL || "http://localhost:3000/mcp_proxy";
+            return [
+                config,
+                {
+                    url: `${proxyUrl}?server=${config}`,
+                },
+            ];
+        }
         if (config.transport === "http") {
             return [
                 config.name,
@@ -715,3 +868,51 @@ I've found some existing telemetry code. Let me mark the first todo as in_progre
 `.trim();
 // Re-export subagent tool utility
 export { makeSubagentsTool } from "./tools/subagent.js";
+/**
+ * Wraps a LangChain tool with OpenTelemetry tracing.
+ * 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.
+ */
+function wrapToolWithTracing(originalTool, sessionId) {
+    const wrappedFunc = async (input) => {
+        const toolInputJson = JSON.stringify(input);
+        const toolSpan = telemetry.startSpan("agent.tool_call", {
+            "tool.name": originalTool.name,
+            "tool.input": toolInputJson,
+            "agent.session_id": sessionId,
+        });
+        // Create a context with the tool span as active
+        const spanContext = toolSpan
+            ? trace.setSpan(context.active(), toolSpan)
+            : context.active();
+        try {
+            // Execute within the tool span's context
+            const result = await context.with(spanContext, () => originalTool.invoke(input));
+            const resultStr = typeof result === "string" ? result : JSON.stringify(result);
+            if (toolSpan) {
+                telemetry.setSpanAttributes(toolSpan, {
+                    "tool.output": resultStr,
+                });
+                telemetry.endSpan(toolSpan);
+            }
+            return result;
+        }
+        catch (error) {
+            if (toolSpan) {
+                telemetry.endSpan(toolSpan, error);
+            }
+            throw error;
+        }
+    };
+    // Create new tool with wrapped function
+    const wrappedTool = tool(wrappedFunc, {
+        name: originalTool.name,
+        description: originalTool.description,
+        schema: originalTool.schema,
+    });
+    // Preserve metadata
+    wrappedTool.prettyName = originalTool.prettyName;
+    wrappedTool.icon = originalTool.icon;
+    return wrappedTool;
+}

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

@@ -0,0 +1,28 @@
+import { z } from "zod";
+interface GenerateImageResult {
+    success: boolean;
+    filePath?: string | undefined;
+    fileName?: string | undefined;
+    imageUrl?: string | undefined;
+    textResponse?: string | undefined;
+    mimeType?: string | undefined;
+    error?: string | undefined;
+}
+export declare function makeGenerateImageTool(): import("langchain").DynamicStructuredTool<z.ZodObject<{
+    prompt: z.ZodString;
+    aspectRatio: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        "1:1": "1:1";
+        "3:4": "3:4";
+        "4:3": "4:3";
+        "9:16": "9:16";
+        "16:9": "16:9";
+        "5:4": "5:4";
+    }>>>;
+}, z.core.$strip>, {
+    prompt: string;
+    aspectRatio: "1:1" | "3:4" | "4:3" | "9:16" | "16:9" | "5:4";
+}, {
+    prompt: string;
+    aspectRatio?: "1:1" | "3:4" | "4:3" | "9:16" | "16:9" | "5:4" | undefined;
+}, GenerateImageResult>;
+export {};

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

@@ -0,0 +1,135 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { GoogleGenAI } from "@google/genai";
+import { tool } from "langchain";
+import { z } from "zod";
+let _genaiClient = null;
+function getGenAIClient() {
+    if (_genaiClient) {
+        return _genaiClient;
+    }
+    const apiKey = process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY;
+    if (!apiKey) {
+        throw new Error("GEMINI_API_KEY or GOOGLE_API_KEY environment variable is required to use the generate_image tool. " +
+            "Please set one of them to your Google AI API key.");
+    }
+    _genaiClient = new GoogleGenAI({ apiKey });
+    return _genaiClient;
+}
+export function makeGenerateImageTool() {
+    const generateImage = tool(async ({ prompt, aspectRatio = "1:1" }) => {
+        try {
+            const client = getGenAIClient();
+            // Use Gemini 3 Pro Image for image generation
+            // Note: imageConfig is a valid API option but not yet in the TypeScript types
+            // biome-ignore lint/suspicious/noExplicitAny: imageConfig not yet typed in @google/genai
+            const config = {
+                responseModalities: ["TEXT", "IMAGE"],
+                imageConfig: {
+                    aspectRatio: aspectRatio,
+                },
+            };
+            const response = await client.models.generateContent({
+                model: "gemini-3-pro-image-preview",
+                contents: [{ text: prompt }],
+                config,
+            });
+            if (!response.candidates || response.candidates.length === 0) {
+                return {
+                    success: false,
+                    error: "No response from the model. The request may have been filtered.",
+                };
+            }
+            const candidate = response.candidates[0];
+            if (!candidate) {
+                return {
+                    success: false,
+                    error: "No candidate in the response.",
+                };
+            }
+            const parts = candidate.content?.parts;
+            if (!parts || parts.length === 0) {
+                return {
+                    success: false,
+                    error: "No content parts in the response.",
+                };
+            }
+            let imageData;
+            let textResponse;
+            let mimeType;
+            for (const part of parts) {
+                if (part.text) {
+                    textResponse = part.text;
+                }
+                else if (part.inlineData) {
+                    imageData = part.inlineData.data;
+                    mimeType = part.inlineData.mimeType || "image/png";
+                }
+            }
+            if (!imageData) {
+                return {
+                    success: false,
+                    error: "No image was generated in the response.",
+                    ...(textResponse ? { textResponse } : {}),
+                };
+            }
+            // Save image to disk in generated-images directory (relative to cwd)
+            const outputDir = join(process.cwd(), "generated-images");
+            await mkdir(outputDir, { recursive: true });
+            // Generate unique filename
+            const timestamp = Date.now();
+            const extension = mimeType === "image/jpeg" ? "jpg" : "png";
+            const fileName = `image-${timestamp}.${extension}`;
+            const filePath = join(outputDir, fileName);
+            // Save image to file
+            const buffer = Buffer.from(imageData, "base64");
+            await writeFile(filePath, buffer);
+            // Create URL for the static file server
+            // The agent HTTP server serves static files from the agent directory
+            const port = process.env.PORT || "3100";
+            const imageUrl = `http://localhost:${port}/static/generated-images/${fileName}`;
+            return {
+                success: true,
+                filePath,
+                fileName,
+                imageUrl,
+                ...(mimeType ? { mimeType } : {}),
+                ...(textResponse ? { textResponse } : {}),
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+            return {
+                success: false,
+                error: `Image generation failed: ${errorMessage}`,
+            };
+        }
+    }, {
+        name: "GenerateImage",
+        description: "Generate an image based on a text prompt using Google's Gemini image generation model. " +
+            "Returns an imageUrl that can be displayed to the user. After calling this tool, " +
+            "include the imageUrl in your response as a markdown image like ![Description](imageUrl) " +
+            "so the user can see the generated image.\n" +
+            "- Creates images from detailed text descriptions\n" +
+            "- Supports various aspect ratios for different use cases\n" +
+            "- Be specific in prompts about style, composition, colors, and subjects\n" +
+            "\n" +
+            "Usage notes:\n" +
+            "  - Provide detailed, specific prompts for best results\n" +
+            "  - The generated image is saved and served via URL\n" +
+            "  - Always display the result using markdown: ![description](imageUrl)\n",
+        schema: z.object({
+            prompt: z
+                .string()
+                .describe("A detailed description of the image to generate. Be specific about style, composition, colors, and subjects."),
+            aspectRatio: z
+                .enum(["1:1", "3:4", "4:3", "9:16", "16:9", "5:4"])
+                .optional()
+                .default("1:1")
+                .describe("The aspect ratio of the generated image."),
+        }),
+    });
+    generateImage.prettyName = "Generate Image";
+    generateImage.icon = "Image";
+    return generateImage;
+}

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

@@ -2,19 +2,24 @@ import type { DirectTool } from "../../tools.js";
 /**
  * Name of the Task tool created by makeSubagentsTool
  */
-export declare const TASK_TOOL_NAME = "Task";
+export declare const SUBAGENT_TOOL_NAME = "subagent";
 /**
  * Configuration for a single subagent - supports two variants:
  * 1. Agent name with optional working directory
  * 2. Direct path to agent's index.ts file
+ *
+ * The optional displayName field provides a human-readable name for the UI.
+ * If not provided, agentName will be used for display.
  */
 type SubagentConfig = {
     agentName: string;
     description: string;
+    displayName?: string;
     cwd?: string;
 } | {
     agentName: string;
     description: string;
+    displayName?: string;
     path: string;
 };
 /**