@townco/agent 0.1.121 → 0.1.122

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

@@ -1,137 +0,0 @@
-import { existsSync, readdirSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { tool } from "langchain";
-import { z } from "zod";
-export const CONVERSATION_SEARCH_TOOL_NAME = "conversation_search";
-const conversationSearchSchema = z.object({
-    query: z
-        .string()
-        .min(1)
-        .describe("The text to search for in conversation messages (case-insensitive)"),
-    date_from: z
-        .string()
-        .optional()
-        .describe("ISO date string to filter conversations from this date onwards"),
-    date_to: z
-        .string()
-        .optional()
-        .describe("ISO date string to filter conversations up to this date"),
-    max_results: z
-        .number()
-        .optional()
-        .describe("Maximum number of matching conversations to return (default: 10)"),
-});
-/**
- * Creates a conversation search tool that searches past agent chat sessions.
- * @param agentDir - The directory of the current agent (e.g., agents/researcher)
- */
-export function makeConversationSearchTool(agentDir) {
-    const conversationSearch = tool(async ({ query, date_from, date_to, max_results = 10 }) => {
-        const results = [];
-        const queryLower = query.toLowerCase();
-        const dateFromParsed = date_from ? new Date(date_from) : null;
-        const dateToParsed = date_to ? new Date(date_to) : null;
-        const sessionsDir = join(agentDir, ".sessions");
-        if (!existsSync(sessionsDir)) {
-            return `No conversations found matching "${query}".`;
-        }
-        let sessionFiles;
-        try {
-            sessionFiles = readdirSync(sessionsDir).filter((f) => f.endsWith(".json") && !f.endsWith(".tmp"));
-        }
-        catch {
-            return `No conversations found matching "${query}".`;
-        }
-        for (const file of sessionFiles) {
-            if (results.length >= max_results)
-                break;
-            try {
-                const content = readFileSync(join(sessionsDir, file), "utf-8");
-                const session = JSON.parse(content);
-                // Date filtering
-                const sessionDate = new Date(session.metadata.updatedAt);
-                if (dateFromParsed && sessionDate < dateFromParsed)
-                    continue;
-                if (dateToParsed && sessionDate > dateToParsed)
-                    continue;
-                // Search messages
-                const matches = [];
-                for (let i = 0; i < session.messages.length; i++) {
-                    const msg = session.messages[i];
-                    if (!msg)
-                        continue;
-                    const textBlocks = msg.content.filter((c) => c.type === "text");
-                    for (const block of textBlocks) {
-                        if (block.text.toLowerCase().includes(queryLower)) {
-                            // Extract matched snippet with surrounding context
-                            const matchIndex = block.text.toLowerCase().indexOf(queryLower);
-                            const snippetStart = Math.max(0, matchIndex - 50);
-                            const snippetEnd = Math.min(block.text.length, matchIndex + query.length + 50);
-                            const matchedText = block.text.slice(snippetStart, snippetEnd);
-                            matches.push({
-                                messageIndex: i,
-                                role: msg.role,
-                                timestamp: msg.timestamp,
-                                matchedText: (snippetStart > 0 ? "..." : "") +
-                                    matchedText +
-                                    (snippetEnd < block.text.length ? "..." : ""),
-                            });
-                            break; // One match per message is enough
-                        }
-                    }
-                }
-                if (matches.length > 0) {
-                    results.push({
-                        sessionId: session.sessionId,
-                        agentName: session.metadata.agentName,
-                        createdAt: session.metadata.createdAt,
-                        updatedAt: session.metadata.updatedAt,
-                        matches,
-                    });
-                }
-            }
-            catch {
-                // Skip invalid session files
-                continue;
-            }
-        }
-        if (results.length === 0) {
-            return `No conversations found matching "${query}".`;
-        }
-        // Format results as readable string
-        let output = `Found ${results.length} conversation(s) matching "${query}":\n\n`;
-        for (const result of results) {
-            output += `=== Session: ${result.sessionId} (${result.agentName}) ===\n`;
-            output += `Created: ${result.createdAt} | Updated: ${result.updatedAt}\n\n`;
-            for (const match of result.matches) {
-                output += `[Message ${match.messageIndex + 1} - ${match.role} @ ${match.timestamp}]\n`;
-                output += `"${match.matchedText}"\n\n`;
-            }
-            output += "---\n\n";
-        }
-        return output;
-    }, {
-        name: CONVERSATION_SEARCH_TOOL_NAME,
-        description: `Search across past chat conversations to find previous discussions on specific topics.
-
-Use this tool to:
-- Find previous conversations that discussed specific topics
-- Recall information from past sessions
-- Search for patterns or recurring themes across conversations
-
-Parameters:
-- query: The text to search for (case-insensitive)
-- date_from: (optional) Only search conversations from this date onwards (ISO format, e.g., "2025-01-01")
-- date_to: (optional) Only search conversations up to this date (ISO format)
-- max_results: (optional) Maximum results to return (default: 10)`,
-        schema: conversationSearchSchema,
-    });
-    conversationSearch.prettyName = "Conversation Search";
-    conversationSearch.icon = "MessageSquare";
-    conversationSearch.verbiage = {
-        active: "Searching conversations for {query}",
-        past: "Searched conversations for {query}",
-        paramKey: "query",
-    };
-    return conversationSearch;
-}

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

@@ -1,47 +0,0 @@
-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;
-}
-/** Create generate image tool using direct GEMINI_API_KEY/GOOGLE_API_KEY */
-export declare function makeGenerateImageTool(): import("langchain").DynamicStructuredTool<z.ZodObject<{
-    prompt: z.ZodString;
-    aspectRatio: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-        "16:9": "16:9";
-        "1:1": "1:1";
-        "3:4": "3:4";
-        "4:3": "4:3";
-        "5:4": "5:4";
-        "9:16": "9:16";
-    }>>>;
-}, z.core.$strip>, {
-    prompt: string;
-    aspectRatio: "16:9" | "1:1" | "3:4" | "4:3" | "5:4" | "9:16";
-}, {
-    prompt: string;
-    aspectRatio?: "16:9" | "1:1" | "3:4" | "4:3" | "5:4" | "9:16" | undefined;
-}, GenerateImageResult>;
-/** Create generate image tool using Town proxy */
-export declare function makeTownGenerateImageTool(): import("langchain").DynamicStructuredTool<z.ZodObject<{
-    prompt: z.ZodString;
-    aspectRatio: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-        "16:9": "16:9";
-        "1:1": "1:1";
-        "3:4": "3:4";
-        "4:3": "4:3";
-        "5:4": "5:4";
-        "9:16": "9:16";
-    }>>>;
-}, z.core.$strip>, {
-    prompt: string;
-    aspectRatio: "16:9" | "1:1" | "3:4" | "4:3" | "5:4" | "9:16";
-}, {
-    prompt: string;
-    aspectRatio?: "16:9" | "1:1" | "3:4" | "4:3" | "5:4" | "9:16" | undefined;
-}, GenerateImageResult>;
-export {};

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

@@ -1,175 +0,0 @@
-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/port-utils.d.ts

@@ -1,8 +0,0 @@
-/**
- * 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

@@ -1,35 +0,0 @@
-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}`);
-}