@townco/agent 0.1.53 → 0.1.55

package/dist/runner/hooks/executor.js

@@ -1,4 +1,4 @@
-import { createLogger } from "@townco/core";
+import { createLogger } from "../../logger.js";
 import { DEFAULT_CONTEXT_SIZE, MODEL_CONTEXT_WINDOWS } from "./constants";
 const logger = createLogger("hook-executor");
 /**

package/dist/runner/hooks/loader.js

@@ -1,5 +1,5 @@
 import { resolve } from "node:path";
-import { createLogger } from "@townco/core";
+import { createLogger } from "../../logger.js";
 import { getPredefinedHook, isPredefinedHook } from "./registry";
 const logger = createLogger("hook-loader");
 /**

package/dist/runner/hooks/predefined/compaction-tool.js

@@ -1,6 +1,6 @@
 import { ChatAnthropic } from "@langchain/anthropic";
 import { HumanMessage, SystemMessage } from "@langchain/core/messages";
-import { createLogger } from "@townco/core";
+import { createLogger } from "../../../logger.js";
 import { createContextEntry, createFullMessageEntry, } from "../types";
 const logger = createLogger("compaction-tool");
 /**

package/dist/runner/hooks/predefined/tool-response-compactor.js

@@ -1,6 +1,6 @@
 import { ChatAnthropic } from "@langchain/anthropic";
 import { HumanMessage, SystemMessage } from "@langchain/core/messages";
-import { createLogger } from "@townco/core";
+import { createLogger } from "../../../logger.js";
 import { countToolResultTokens } from "../../../utils/token-counter.js";
 const logger = createLogger("tool-response-compactor");
 // Haiku 4.5 for compaction (fast and cost-effective)

package/dist/runner/index.d.ts

@@ -1,6 +1,4 @@
 import type { AgentDefinition } from "../definition";
 import { type AgentRunner } from "./agent-runner";
 export type { AgentRunner };
-export declare const makeRunnerFromDefinition: (
-	definition: AgentDefinition,
-) => AgentRunner;
+export declare const makeRunnerFromDefinition: (definition: AgentDefinition) => AgentRunner;

package/dist/runner/langchain/index.js

@@ -1,15 +1,16 @@
 import { MultiServerMCPClient } from "@langchain/mcp-adapters";
 import { context, propagation, trace } from "@opentelemetry/api";
-import { createLogger } from "@townco/core";
 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 { 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/model-factory.js

@@ -1,7 +1,7 @@
 import { ChatAnthropic } from "@langchain/anthropic";
 import { ChatGoogleGenerativeAI } from "@langchain/google-genai";
 import { ChatVertexAI } from "@langchain/google-vertexai";
-import { createLogger } from "@townco/core";
+import { createLogger } from "../../logger.js";
 const logger = createLogger("model-factory");
 /**
  * Detects the provider from a model string and returns the appropriate

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/port-utils.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Check if a port is available
+ */
+export declare function isPortAvailable(port: number): Promise<boolean>;
+/**
+ * Find the next available port starting from the given port
+ */
+export declare function findAvailablePort(startPort: number, maxAttempts?: number): Promise<number>;

package/dist/runner/langchain/tools/port-utils.js

@@ -0,0 +1,35 @@
+import { createServer } from "node:net";
+/**
+ * Check if a port is available
+ */
+export async function isPortAvailable(port) {
+    return new Promise((resolve) => {
+        const server = createServer();
+        server.once("error", (err) => {
+            if (err.code === "EADDRINUSE") {
+                resolve(false);
+            }
+            else {
+                resolve(false);
+            }
+        });
+        server.once("listening", () => {
+            server.close();
+            resolve(true);
+        });
+        server.listen(port);
+    });
+}
+/**
+ * Find the next available port starting from the given port
+ */
+export async function findAvailablePort(startPort, maxAttempts = 100) {
+    for (let i = 0; i < maxAttempts; i++) {
+        const port = startPort + i;
+        const available = await isPortAvailable(port);
+        if (available) {
+            return port;
+        }
+    }
+    throw new Error(`Could not find an available port between ${startPort} and ${startPort + maxAttempts - 1}`);
+}

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