@townco/agent 0.1.124 → 0.1.126

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

@@ -0,0 +1,22 @@
+import { z } from "zod";
+export declare const CONVERSATION_SEARCH_TOOL_NAME = "conversation_search";
+/**
+ * Creates a conversation search tool that searches past agent chat sessions.
+ * @param agentDir - The directory of the current agent (e.g., agents/researcher)
+ */
+export declare function makeConversationSearchTool(agentDir: string): import("langchain").DynamicStructuredTool<z.ZodObject<{
+    query: z.ZodString;
+    date_from: z.ZodOptional<z.ZodString>;
+    date_to: z.ZodOptional<z.ZodString>;
+    max_results: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, {
+    query: string;
+    date_from?: string | undefined;
+    date_to?: string | undefined;
+    max_results?: number | undefined;
+}, {
+    query: string;
+    date_from?: string | undefined;
+    date_to?: string | undefined;
+    max_results?: number | undefined;
+}, string>;

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

@@ -0,0 +1,137 @@
+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/templates/index.d.ts

@@ -1,6 +1,13 @@
 import type { z } from "zod";
 import type { AgentDefinition, McpConfigSchema } from "../definition";
 type McpConfig = z.infer<typeof McpConfigSchema>;
+/** Config for a subagent to wire up via makeSubagentsTool */
+export interface SubagentConfig {
+    agentName: string;
+    toolDescription: string;
+    displayName?: string;
+    path: string;
+}
 export interface TemplateVars {
     name: string;
     model: string;
@@ -21,6 +28,7 @@ export interface TemplateVars {
         schema: unknown;
     }>;
     mcps?: McpConfig[];
+    subagents?: SubagentConfig[];
     systemPrompt: string | null;
     hasWebSearch: boolean;
     hasGenerateImage: boolean;

package/dist/templates/index.js

@@ -23,6 +23,11 @@ export function getTemplateVars(name, definition) {
     if (definition.mcps && definition.mcps.length > 0) {
         result.mcps = definition.mcps;
     }
+    // Handle subagents if defined (using type assertion since AgentDefinition may not have subagents yet)
+    const defWithSubagents = definition;
+    if (defWithSubagents.subagents && defWithSubagents.subagents.length > 0) {
+        result.subagents = defWithSubagents.subagents;
+    }
     return result;
 }
 export function generatePackageJson(vars) {
@@ -59,33 +64,57 @@ export function generatePackageJson(vars) {
     return JSON.stringify(pkg, null, 2);
 }
 export async function generateIndexTs(vars) {
-    // Build agent definition with fields in a logical order
-    const agentDef = {
-        model: vars.model,
-    };
+    const hasSubagents = vars.subagents && vars.subagents.length > 0;
+    let imports = 'import type { AgentDefinition } from "@townco/agent/definition";';
+    if (hasSubagents) {
+        imports += '\nimport { makeSubagentsTool } from "@townco/agent/utils";';
+    }
+    // Build tools code - either plain JSON or with makeSubagentsTool call
+    const toolsCode = (() => {
+        if (!hasSubagents) {
+            return JSON.stringify(vars.tools);
+        }
+        // makeSubagentsTool expects 'description' not 'toolDescription'
+        const subagentConfigs = vars.subagents?.map((s) => ({
+            agentName: s.agentName,
+            description: s.toolDescription,
+            ...(s.displayName && { displayName: s.displayName }),
+            path: s.path,
+        })) ?? [];
+        const subagentToolCall = `makeSubagentsTool(${JSON.stringify(subagentConfigs, null, 2)})`;
+        const toolItems = vars.tools.map((t) => JSON.stringify(t));
+        toolItems.push(subagentToolCall);
+        return `[${toolItems.join(", ")}]`;
+    })();
+    // Build optional fields
+    const optionalFields = [];
     if (vars.displayName) {
-        agentDef.displayName = vars.displayName;
+        optionalFields.push(`displayName: ${JSON.stringify(vars.displayName)},`);
     }
     if (vars.description) {
-        agentDef.description = vars.description;
+        optionalFields.push(`description: ${JSON.stringify(vars.description)},`);
     }
     if (vars.suggestedPrompts) {
-        agentDef.suggestedPrompts = vars.suggestedPrompts;
+        optionalFields.push(`suggestedPrompts: ${JSON.stringify(vars.suggestedPrompts)},`);
     }
-    agentDef.systemPrompt = vars.systemPrompt;
-    agentDef.tools = vars.tools;
     if (vars.mcps && vars.mcps.length > 0) {
-        agentDef.mcps = vars.mcps;
+        optionalFields.push(`mcps: ${JSON.stringify(vars.mcps)},`);
     }
     if (vars.hooks) {
-        agentDef.hooks = vars.hooks;
+        optionalFields.push(`hooks: ${JSON.stringify(vars.hooks)},`);
     }
-    return prettier.format(`import type { AgentDefinition } from "@townco/agent/definition";
+    const optionalFieldsStr = optionalFields.length > 0 ? `\n  ${optionalFields.join("\n  ")}` : "";
+    const code = `${imports}
 
-const agent: AgentDefinition = ${JSON.stringify(agentDef)};
+const agent: AgentDefinition = {
+  model: ${JSON.stringify(vars.model)},${optionalFieldsStr}
+  systemPrompt: ${JSON.stringify(vars.systemPrompt)},
+  tools: ${toolsCode},
+};
 
 export default agent;
-`, { parser: "typescript" });
+`;
+    return prettier.format(code, { parser: "typescript" });
 }
 export function generateBinTs() {
     return `#!/usr/bin/env bun