@townco/agent 0.1.123 → 0.1.125

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@townco/agent",
-  "version": "0.1.123",
+  "version": "0.1.125",
   "type": "module",
   "module": "index.ts",
   "files": [
@@ -83,12 +83,12 @@
     "@opentelemetry/sdk-trace-base": "^1.28.0",
     "@opentelemetry/sdk-trace-node": "^1.28.0",
     "@opentelemetry/semantic-conventions": "^1.28.0",
-    "@townco/apiclient": "0.0.35",
-    "@townco/core": "0.0.93",
-    "@townco/gui-template": "0.1.112",
-    "@townco/tsconfig": "0.1.112",
-    "@townco/tui-template": "0.1.112",
-    "@townco/ui": "0.1.115",
+    "@townco/apiclient": "0.0.37",
+    "@townco/core": "0.0.95",
+    "@townco/gui-template": "0.1.114",
+    "@townco/tsconfig": "0.1.114",
+    "@townco/tui-template": "0.1.114",
+    "@townco/ui": "0.1.117",
     "ai-tokenizer": "^1.0.6",
     "exa-js": "^2.0.0",
     "hono": "^4.10.4",

package/templates/index.ts

@@ -4,6 +4,14 @@ 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;
@@ -24,6 +32,7 @@ export interface TemplateVars {
       }
   >;
   mcps?: McpConfig[];
+  subagents?: SubagentConfig[];
   systemPrompt: string | null;
   hasWebSearch: boolean;
   hasGenerateImage: boolean;
@@ -83,6 +92,14 @@ export function getTemplateVars(
     result.mcps = definition.mcps;
   }
 
+  // Handle subagents if defined (using type assertion since AgentDefinition may not have subagents yet)
+  const defWithSubagents = definition as AgentDefinition & {
+    subagents?: SubagentConfig[];
+  };
+  if (defWithSubagents.subagents && defWithSubagents.subagents.length > 0) {
+    result.subagents = defWithSubagents.subagents;
+  }
+
   return result;
 }
 
@@ -123,41 +140,67 @@ export function generatePackageJson(vars: TemplateVars): string {
 }
 
 export async function generateIndexTs(vars: TemplateVars): Promise<string> {
-  // Build agent definition with fields in a logical order
-  const agentDef: Record<string, unknown> = {
-    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: string = (() => {
+    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: string[] = [];
   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 agent: AgentDefinition = ${JSON.stringify(agentDef)};
+  const code = `${imports}
+
+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(): string {

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

@@ -1,22 +0,0 @@
-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

@@ -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;
-}