@townco/agent 0.1.53 → 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
@@ -74,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,
@@ -286,7 +290,7 @@ export class LangchainAgent {
             // Filter tools if running in subagent mode
             const isSubagent = req.sessionMeta?.[SUBAGENT_MODE_KEY] === true;
             const filteredTools = isSubagent
-                ? wrappedTools.filter((t) => t.name !== TODO_WRITE_TOOL_NAME && t.name !== TASK_TOOL_NAME)
+                ? 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.
@@ -314,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({
@@ -391,7 +453,12 @@ 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)}`);
                             }
@@ -427,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,
@@ -556,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)}`);
@@ -576,14 +698,22 @@ export class LangchainAgent {
                                 // Skip tool_call_update for todo_write tools
                                 continue;
                             }
-                            telemetry.log("info", "Tool call completed", {
+                            // 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)
@@ -645,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,

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;
 };
 /**

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

@@ -9,7 +9,7 @@ import { SUBAGENT_MODE_KEY } from "../../../acp-server/adapter.js";
 /**
  * Name of the Task tool created by makeSubagentsTool
  */
-export const TASK_TOOL_NAME = "Task";
+export const SUBAGENT_TOOL_NAME = "subagent";
 /**
  * Creates a DirectTool that delegates work to one of multiple configured subagents.
  *
@@ -61,9 +61,17 @@ export function makeSubagentsTool(configs) {
         .map((config) => `"${config.agentName}": ${config.description}`)
         .join("\n");
     const agentNames = configs.map((c) => c.agentName);
+    // Extract subagent configs for metadata (agentName, description, displayName)
+    const subagentConfigs = configs.map((config) => ({
+        agentName: config.agentName,
+        description: config.description,
+        displayName: config.displayName,
+    }));
     return {
         type: "direct",
-        name: TASK_TOOL_NAME,
+        name: SUBAGENT_TOOL_NAME,
+        prettyName: "Subagent",
+        icon: "BrainCircuit",
         description: `Launch a new agent to handle complex, multi-step tasks autonomously.
 
 The Task tool launches specialized agents (subprocesses) that autonomously handle complex tasks. Each agent type has specific capabilities and tools available to it.
@@ -129,6 +137,8 @@ assistant: "I'm going to use the Task tool to launch the greeting-responder agen
                 .describe("The name of the subagent to use"),
             query: z.string().describe("The query or task to send to the subagent"),
         }),
+        // Expose subagent configs for metadata extraction by the adapter
+        subagentConfigs,
         fn: async (input) => {
             const { agentName, query } = input;
             const agent = agentMap.get(agentName);

package/dist/runner/tools.d.ts

@@ -1,6 +1,12 @@
 import { z } from "zod";
 /** Built-in tool types. */
-export declare const zBuiltInToolType: z.ZodUnion<readonly [z.ZodLiteral<"todo_write">, z.ZodLiteral<"get_weather">, z.ZodLiteral<"web_search">, z.ZodLiteral<"filesystem">]>;
+export declare const zBuiltInToolType: z.ZodUnion<readonly [z.ZodLiteral<"todo_write">, z.ZodLiteral<"get_weather">, z.ZodLiteral<"web_search">, z.ZodLiteral<"filesystem">, z.ZodLiteral<"generate_image">]>;
+/** Subagent configuration schema for Task tools. */
+export declare const zSubagentConfig: z.ZodObject<{
+    agentName: z.ZodString;
+    description: z.ZodString;
+    displayName: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
 /** Direct tool object schema (for tools imported directly in code). */
 declare const zDirectTool: z.ZodObject<{
     type: z.ZodLiteral<"direct">;
@@ -10,9 +16,14 @@ declare const zDirectTool: z.ZodObject<{
     schema: z.ZodAny;
     prettyName: z.ZodOptional<z.ZodString>;
     icon: z.ZodOptional<z.ZodString>;
+    subagentConfigs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        agentName: z.ZodString;
+        description: z.ZodString;
+        displayName: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
 }, z.core.$strip>;
 /** Tool type - can be a built-in tool string or custom tool object. */
-export declare const zToolType: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodLiteral<"todo_write">, z.ZodLiteral<"get_weather">, z.ZodLiteral<"web_search">, z.ZodLiteral<"filesystem">]>, z.ZodObject<{
+export declare const zToolType: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodLiteral<"todo_write">, z.ZodLiteral<"get_weather">, z.ZodLiteral<"web_search">, z.ZodLiteral<"filesystem">, z.ZodLiteral<"generate_image">]>, z.ZodObject<{
     type: z.ZodLiteral<"custom">;
     modulePath: z.ZodString;
 }, z.core.$strip>, z.ZodObject<{
@@ -26,8 +37,14 @@ export declare const zToolType: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodL
     schema: z.ZodAny;
     prettyName: z.ZodOptional<z.ZodString>;
     icon: z.ZodOptional<z.ZodString>;
+    subagentConfigs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        agentName: z.ZodString;
+        description: z.ZodString;
+        displayName: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
 }, z.core.$strip>]>;
 export type ToolType = z.infer<typeof zToolType>;
 export type BuiltInToolType = z.infer<typeof zBuiltInToolType>;
 export type DirectTool = z.infer<typeof zDirectTool>;
+export type SubagentConfig = z.infer<typeof zSubagentConfig>;
 export {};

package/dist/runner/tools.js

@@ -5,6 +5,7 @@ export const zBuiltInToolType = z.union([
     z.literal("get_weather"),
     z.literal("web_search"),
     z.literal("filesystem"),
+    z.literal("generate_image"),
 ]);
 /** Custom tool schema (loaded from module path). */
 const zCustomTool = z.object({
@@ -16,6 +17,12 @@ const zFilesystemTool = z.object({
     type: z.literal("filesystem"),
     working_directory: z.string().optional(),
 });
+/** Subagent configuration schema for Task tools. */
+export const zSubagentConfig = z.object({
+    agentName: z.string(),
+    description: z.string(),
+    displayName: z.string().optional(),
+});
 /** Direct tool object schema (for tools imported directly in code). */
 const zDirectTool = z.object({
     type: z.literal("direct"),
@@ -25,6 +32,8 @@ const zDirectTool = z.object({
     schema: z.any(), // Accept any Zod schema
     prettyName: z.string().optional(),
     icon: z.string().optional(),
+    /** Subagent configurations (only present for Task tools created by makeSubagentsTool). */
+    subagentConfigs: z.array(zSubagentConfig).optional(),
 });
 /** Tool type - can be a built-in tool string or custom tool object. */
 export const zToolType = z.union([

package/dist/telemetry/index.js

@@ -3,7 +3,7 @@
  * Provides tracing and logging capabilities for agent operations
  */
 import { context, SpanStatusCode, trace, } from "@opentelemetry/api";
-import { logs } from "@opentelemetry/api-logs";
+import { logs, SeverityNumber, } from "@opentelemetry/api-logs";
 class AgentTelemetry {
     tracer = null;
     logger = null;
@@ -115,7 +115,13 @@ class AgentTelemetry {
         if (!this.enabled || !this.logger) {
             return;
         }
+        const severityNumber = {
+            info: SeverityNumber.INFO,
+            warn: SeverityNumber.WARN,
+            error: SeverityNumber.ERROR,
+        }[level];
         this.logger.emit({
+            severityNumber,
             severityText: level.toUpperCase(),
             body: message,
             attributes: {

package/dist/templates/index.d.ts

@@ -2,6 +2,9 @@ import type { AgentDefinition } from "../definition";
 export interface TemplateVars {
     name: string;
     model: string;
+    displayName?: string;
+    description?: string;
+    suggestedPrompts?: string[];
     tools: Array<string | {
         type: "custom";
         modulePath: string;