@townco/agent 0.1.111 → 0.1.113

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

@@ -0,0 +1,175 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { GoogleGenAI } from "@google/genai";
+import { getShedAuth } from "@townco/core/auth";
+import { tool } from "langchain";
+import { z } from "zod";
+import { getSessionContext, getToolOutputDir, hasSessionContext, } from "../../session-context";
+let _directGenaiClient = null;
+let _townGenaiClient = null;
+/** Get Google GenAI client using direct GEMINI_API_KEY/GOOGLE_API_KEY environment variable */
+function getDirectGenAIClient() {
+    if (_directGenaiClient) {
+        return _directGenaiClient;
+    }
+    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.");
+    }
+    _directGenaiClient = new GoogleGenAI({ apiKey });
+    return _directGenaiClient;
+}
+/** Get Google GenAI client using Town proxy with authenticated credentials */
+function getTownGenAIClient() {
+    if (_townGenaiClient) {
+        return _townGenaiClient;
+    }
+    const shedAuth = getShedAuth();
+    if (!shedAuth) {
+        throw new Error("Not logged in. Run 'town login' or set SHED_API_KEY to use the town_generate_image tool.");
+    }
+    // Configure the client to use shed as proxy
+    // The SDK will send requests to {shedUrl}/api/gemini/{apiVersion}/{path}
+    _townGenaiClient = new GoogleGenAI({
+        apiKey: shedAuth.accessToken,
+        httpOptions: {
+            baseUrl: `${shedAuth.shedUrl}/api/gemini/`,
+        },
+    });
+    return _townGenaiClient;
+}
+function makeGenerateImageToolInternal(getClient) {
+    const generateImage = tool(async ({ prompt, aspectRatio = "1:1" }) => {
+        try {
+            if (!hasSessionContext()) {
+                throw new Error("GenerateImage tool requires session context. Ensure the tool is called within a session.");
+            }
+            const { sessionId } = getSessionContext();
+            const toolOutputDir = getToolOutputDir("GenerateImage");
+            const client = getClient();
+            // 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 session-scoped tool output directory
+            await mkdir(toolOutputDir, { recursive: true });
+            // Generate unique filename
+            const timestamp = Date.now();
+            const extension = mimeType === "image/jpeg" ? "jpg" : "png";
+            const fileName = `image-${timestamp}.${extension}`;
+            const filePath = join(toolOutputDir, 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
+            // Use AGENT_BASE_URL if set (for production), otherwise construct from BIND_HOST/PORT
+            const port = process.env.PORT || "3100";
+            const hostname = process.env.BIND_HOST || "localhost";
+            const baseUrl = process.env.AGENT_BASE_URL || `http://${hostname}:${port}`;
+            const imageUrl = `${baseUrl}/static/.sessions/${sessionId}/artifacts/tool-GenerateImage/${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 to the session directory 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."),
+        }),
+    });
+    // biome-ignore lint/suspicious/noExplicitAny: Need to add custom properties to LangChain tool
+    generateImage.prettyName = "Generate Image";
+    // biome-ignore lint/suspicious/noExplicitAny: Need to add custom properties to LangChain tool
+    generateImage.icon = "Image";
+    return generateImage;
+}
+/** Create generate image tool using direct GEMINI_API_KEY/GOOGLE_API_KEY */
+export function makeGenerateImageTool() {
+    return makeGenerateImageToolInternal(getDirectGenAIClient);
+}
+/** Create generate image tool using Town proxy */
+export function makeTownGenerateImageTool() {
+    return makeGenerateImageToolInternal(getTownGenAIClient);
+}

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

@@ -1,12 +1,3 @@
-import { EventEmitter } from "node:events";
-/**
- * Registry for subagent connection info.
- * Maps query hash to connection info so the runner can emit tool_call_update.
- */
-export interface SubagentConnectionInfo {
-    port: number;
-    sessionId: string;
-}
 /**
  * Sub-agent tool call tracked during streaming
  */
@@ -36,14 +27,11 @@ export interface SubagentMessage {
     contentBlocks: SubagentContentBlock[];
     toolCalls: SubagentToolCall[];
 }
-/**
- * Event emitter for subagent connection events.
- * The runner listens to these events and emits tool_call_update.
- */
-export declare const subagentEvents: EventEmitter<[never]>;
 /**
  * Maps query hash to toolCallId.
  * Set by the runner when it sees a subagent tool_call.
+ * This is still global because the registration happens in the parent runner
+ * before subagent execution begins.
  */
 export declare const queryToToolCallId: Map<string, string>;
 /**
@@ -51,12 +39,9 @@ export declare const queryToToolCallId: Map<string, string>;
  */
 export declare function hashQuery(query: string): string;
 /**
- * Called by the subagent tool when connection is established.
- * Emits an event that the runner can listen to.
- */
-export declare function emitSubagentConnection(queryHash: string, connectionInfo: SubagentConnectionInfo): void;
-/**
- * Called by the subagent tool when it completes with accumulated messages.
- * Emits an event with the messages for session storage.
+ * Called by the subagent tool during execution to emit incremental messages.
+ * Emits an event with the messages for live streaming to the UI.
+ * Uses the invocation context's EventEmitter to ensure messages go to the correct parent.
+ * @param completed - If true, signals that the subagent stream has finished
  */
-export declare function emitSubagentMessages(queryHash: string, messages: SubagentMessage[]): void;
+export declare function emitSubagentMessages(queryHash: string, messages: SubagentMessage[], completed?: boolean): void;

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

@@ -1,22 +1,14 @@
 import { createHash } from "node:crypto";
-import { EventEmitter } from "node:events";
 import { createLogger } from "@townco/core";
+import { getInvocationContext } from "../../session-context.js";
 const logger = createLogger("subagent-connections");
-/**
- * Event emitter for subagent connection events.
- * The runner listens to these events and emits tool_call_update.
- */
-export const subagentEvents = new EventEmitter();
 /**
  * Maps query hash to toolCallId.
  * Set by the runner when it sees a subagent tool_call.
+ * This is still global because the registration happens in the parent runner
+ * before subagent execution begins.
  */
 export const queryToToolCallId = new Map();
-/**
- * Maps query hash to resolved toolCallId (preserved after connection event).
- * Used to correlate messages when the tool completes.
- */
-const queryToResolvedToolCallId = new Map();
 /**
  * Generate a hash from the query string for correlation.
  */
@@ -29,61 +21,45 @@ export function hashQuery(query) {
     return hash;
 }
 /**
- * Called by the subagent tool when connection is established.
- * Emits an event that the runner can listen to.
+ * Called by the subagent tool during execution to emit incremental messages.
+ * Emits an event with the messages for live streaming to the UI.
+ * Uses the invocation context's EventEmitter to ensure messages go to the correct parent.
+ * @param completed - If true, signals that the subagent stream has finished
  */
-export function emitSubagentConnection(queryHash, connectionInfo) {
-    logger.info("emitSubagentConnection called", {
-        queryHash,
-        port: connectionInfo.port,
-        sessionId: connectionInfo.sessionId,
-        registeredHashes: Array.from(queryToToolCallId.keys()),
-    });
+export function emitSubagentMessages(queryHash, messages, completed = false) {
     const toolCallId = queryToToolCallId.get(queryHash);
-    if (toolCallId) {
-        logger.info("Found toolCallId for queryHash, emitting connection event", {
-            queryHash,
-            toolCallId,
-            port: connectionInfo.port,
-            sessionId: connectionInfo.sessionId,
-        });
-        subagentEvents.emit("connection", {
-            toolCallId,
-            ...connectionInfo,
-        });
-        // Preserve the toolCallId for message emission, but remove from pending lookup
-        queryToResolvedToolCallId.set(queryHash, toolCallId);
-        queryToToolCallId.delete(queryHash);
-    }
-    else {
-        logger.warn("No toolCallId found for queryHash", {
+    const invocationCtx = getInvocationContext();
+    if (!invocationCtx) {
+        logger.warn("✗ No invocation context found - cannot emit subagent messages", {
             queryHash,
-            registeredHashes: Array.from(queryToToolCallId.keys()),
+            hasToolCallId: !!toolCallId,
         });
+        return;
     }
-}
-/**
- * Called by the subagent tool when it completes with accumulated messages.
- * Emits an event with the messages for session storage.
- */
-export function emitSubagentMessages(queryHash, messages) {
-    const toolCallId = queryToResolvedToolCallId.get(queryHash);
     if (toolCallId) {
-        logger.info("Emitting subagent messages for storage", {
+        const firstMessage = messages[0];
+        logger.info("✓ Emitting subagent messages for live streaming", {
             queryHash,
             toolCallId,
             messageCount: messages.length,
+            hasContent: firstMessage ? firstMessage.content.length > 0 : false,
+            hasToolCalls: firstMessage ? firstMessage.toolCalls.length > 0 : false,
+            completed,
+            invocationId: invocationCtx.invocationId,
         });
-        subagentEvents.emit("messages", {
+        // Emit to the parent's invocation-scoped EventEmitter
+        invocationCtx.subagentEventEmitter.emit("messages", {
             toolCallId,
             messages,
+            completed,
         });
-        // Clean up the resolved mapping
-        queryToResolvedToolCallId.delete(queryHash);
     }
     else {
-        logger.warn("No resolved toolCallId for messages emission", {
+        logger.warn("✗ No toolCallId found for messages emission (RACE CONDITION)", {
             queryHash,
+            registeredHashes: Array.from(queryToToolCallId.keys()),
+            mapSize: queryToToolCallId.size,
+            invocationId: invocationCtx.invocationId,
         });
     }
 }