@townco/agent 0.1.53 → 0.1.55

package/index.ts

@@ -1,7 +1,7 @@
 import { basename } from "node:path";
-import { createLogger } from "@townco/core";
 import { makeHttpTransport, makeStdioTransport } from "./acp-server";
 import type { AgentDefinition } from "./definition";
+import { createLogger } from "./logger.js";
 import { initializeOpenTelemetryFromEnv } from "./telemetry/setup.js";
 import { makeSubagentsTool } from "./utils";
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@townco/agent",
-  "version": "0.1.53",
+  "version": "0.1.55",
   "type": "module",
   "module": "index.ts",
   "files": [
@@ -42,6 +42,10 @@
     "./utils": {
       "import": "./dist/utils/index.js",
       "types": "./dist/utils/index.d.ts"
+    },
+    "./logger": {
+      "import": "./dist/logger.js",
+      "types": "./dist/logger.d.ts"
     }
   },
   "scripts": {
@@ -55,6 +59,7 @@
     "@agentclientprotocol/sdk": "^0.5.1",
     "@anthropic-ai/sandbox-runtime": "^0.0.2",
     "@anthropic-ai/sdk": "^0.70.0",
+    "@google/genai": "^0.14.1",
     "@anthropic-ai/tokenizer": "^0.0.4",
     "@electric-sql/pglite": "^0.2.15",
     "@langchain/anthropic": "1.0.1",
@@ -73,11 +78,11 @@
     "@opentelemetry/sdk-trace-base": "^1.28.0",
     "@opentelemetry/sdk-trace-node": "^1.28.0",
     "@opentelemetry/semantic-conventions": "^1.28.0",
-    "@townco/core": "0.0.26",
-    "@townco/gui-template": "0.1.45",
-    "@townco/tsconfig": "0.1.45",
-    "@townco/tui-template": "0.1.45",
-    "@townco/ui": "0.1.48",
+    "@townco/core": "0.0.28",
+    "@townco/gui-template": "0.1.47",
+    "@townco/tsconfig": "0.1.47",
+    "@townco/tui-template": "0.1.47",
+    "@townco/ui": "0.1.50",
     "exa-js": "^2.0.0",
     "hono": "^4.10.4",
     "langchain": "^1.0.3",

package/templates/index.ts

@@ -4,6 +4,9 @@ import type { AgentDefinition } from "../definition";
 export interface TemplateVars {
   name: string;
   model: string;
+  displayName?: string;
+  description?: string;
+  suggestedPrompts?: string[];
   tools: Array<
     | string
     | { type: "custom"; modulePath: string }
@@ -45,7 +48,7 @@ export function getTemplateVars(
   definition: AgentDefinition,
 ): TemplateVars {
   const tools = definition.tools ?? [];
-  return {
+  const result: TemplateVars = {
     name,
     model: definition.model,
     tools,
@@ -55,6 +58,18 @@ export function getTemplateVars(
     ),
     hooks: definition.hooks as TemplateVars["hooks"],
   };
+
+  if (definition.displayName) {
+    result.displayName = definition.displayName;
+  }
+  if (definition.description) {
+    result.description = definition.description;
+  }
+  if (definition.suggestedPrompts) {
+    result.suggestedPrompts = definition.suggestedPrompts;
+  }
+
+  return result;
 }
 
 export function generatePackageJson(vars: TemplateVars): string {
@@ -94,17 +109,33 @@ export function generatePackageJson(vars: TemplateVars): string {
 }
 
 export async function generateIndexTs(vars: TemplateVars): Promise<string> {
-  const agentDef = {
+  // Build agent definition with fields in a logical order
+  const agentDef: Record<string, unknown> = {
     model: vars.model,
-    systemPrompt: vars.systemPrompt,
-    tools: vars.tools,
-    hooks: vars.hooks,
   };
+
+  if (vars.displayName) {
+    agentDef.displayName = vars.displayName;
+  }
+  if (vars.description) {
+    agentDef.description = vars.description;
+  }
+  if (vars.suggestedPrompts) {
+    agentDef.suggestedPrompts = vars.suggestedPrompts;
+  }
+
+  agentDef.systemPrompt = vars.systemPrompt;
+  agentDef.tools = vars.tools;
+
+  if (vars.hooks) {
+    agentDef.hooks = vars.hooks;
+  }
+
   return prettier.format(
     `import { makeHttpTransport, makeStdioTransport } from "@townco/agent/acp-server";
 import type { AgentDefinition } from "@townco/agent/definition";
+import { createLogger } from "@townco/agent/logger";
 import { basename } from "node:path";
-import { createLogger } from "@townco/core";
 
 const logger = createLogger("agent-index");
 

package/dist/definition/tools/todo.d.ts

@@ -1,49 +0,0 @@
-import { z } from "zod";
-export declare const todoItemSchema: z.ZodObject<
-	{
-		content: z.ZodString;
-		status: z.ZodEnum<{
-			pending: "pending";
-			in_progress: "in_progress";
-			completed: "completed";
-		}>;
-		activeForm: z.ZodString;
-	},
-	z.core.$strip
->;
-export declare const todoWrite: import("langchain").DynamicStructuredTool<
-	z.ZodObject<
-		{
-			todos: z.ZodArray<
-				z.ZodObject<
-					{
-						content: z.ZodString;
-						status: z.ZodEnum<{
-							pending: "pending";
-							in_progress: "in_progress";
-							completed: "completed";
-						}>;
-						activeForm: z.ZodString;
-					},
-					z.core.$strip
-				>
-			>;
-		},
-		z.core.$strip
-	>,
-	{
-		todos: {
-			content: string;
-			status: "pending" | "in_progress" | "completed";
-			activeForm: string;
-		}[];
-	},
-	{
-		todos: {
-			content: string;
-			status: "pending" | "in_progress" | "completed";
-			activeForm: string;
-		}[];
-	},
-	string
->;

package/dist/definition/tools/todo.js

@@ -1,80 +0,0 @@
-import { tool } from "langchain";
-import { z } from "zod";
-export const todoItemSchema = z.object({
-	content: z.string().min(1),
-	status: z.enum(["pending", "in_progress", "completed"]),
-	activeForm: z.string().min(1),
-});
-export const todoWrite = tool(
-	({ todos }) => {
-		// Simple implementation that confirms the todos were written
-		return `Successfully updated todo list with ${todos.length} items`;
-	},
-	{
-		name: "todo_write",
-		description: `Use this tool to create and manage a structured task list for your current coding session. This helps you track progress, organize complex tasks, and demonstrate thoroughness to the user.
-It also helps the user understand the progress of the task and overall progress of their requests.
-
-## When to Use This Tool
-Use this tool proactively in these scenarios:
-
-1. Complex multi-step tasks - When a task requires 3 or more distinct steps or actions
-2. Non-trivial and complex tasks - Tasks that require careful planning or multiple operations
-3. User explicitly requests todo list - When the user directly asks you to use the todo list
-4. User provides multiple tasks - When users provide a list of things to be done (numbered or comma-separated)
-5. After receiving new instructions - Immediately capture user requirements as todos
-6. When you start working on a task - Mark it as in_progress BEFORE beginning work. Ideally you should only have one todo as in_progress at a time
-7. After completing a task - Mark it as completed and add any new follow-up tasks discovered during implementation
-
-## When NOT to Use This Tool
-
-Skip using this tool when:
-1. There is only a single, straightforward task
-2. The task is trivial and tracking it provides no organizational benefit
-3. The task can be completed in less than 3 trivial steps
-4. The task is purely conversational or informational
-
-NOTE that you should not use this tool if there is only one trivial task to do. In this case you are better off just doing the task directly.
-
-## Task States and Management
-
-1. **Task States**: Use these states to track progress:
-   - pending: Task not yet started
-   - in_progress: Currently working on (limit to ONE task at a time)
-   - completed: Task finished successfully
-
-   **IMPORTANT**: Task descriptions must have two forms:
-   - content: The imperative form describing what needs to be done (e.g., "Run tests", "Build the project")
-   - activeForm: The present continuous form shown during execution (e.g., "Running tests", "Building the project")
-
-2. **Task Management**:
-   - Update task status in real-time as you work
-   - Mark tasks complete IMMEDIATELY after finishing (don't batch completions)
-   - Exactly ONE task must be in_progress at any time (not less, not more)
-   - Complete current tasks before starting new ones
-   - Remove tasks that are no longer relevant from the list entirely
-
-3. **Task Completion Requirements**:
-   - ONLY mark a task as completed when you have FULLY accomplished it
-   - If you encounter errors, blockers, or cannot finish, keep the task as in_progress
-   - When blocked, create a new task describing what needs to be resolved
-   - Never mark a task as completed if:
-     - Tests are failing
-     - Implementation is partial
-     - You encountered unresolved errors
-     - You couldn't find necessary files or dependencies
-
-4. **Task Breakdown**:
-   - Create specific, actionable items
-   - Break complex tasks into smaller, manageable steps
-   - Use clear, descriptive task names
-   - Always provide both forms:
-     - content: "Fix authentication bug"
-     - activeForm: "Fixing authentication bug"
-
-When in doubt, use this tool. Being proactive with task management demonstrates attentiveness and ensures you complete all requirements successfully.`,
-		schema: z.object({
-			todos: z.array(todoItemSchema),
-		}),
-	},
-);

package/dist/definition/tools/web_search.d.ts

@@ -1,4 +0,0 @@
-import { ExaSearchResults } from "@langchain/exa";
-export declare function makeWebSearchTool(): ExaSearchResults<{
-	text: true;
-}>;

package/dist/definition/tools/web_search.js

@@ -1,26 +0,0 @@
-import { ExaSearchResults } from "@langchain/exa";
-import Exa from "exa-js";
-
-let _webSearchInstance = null;
-export function makeWebSearchTool() {
-	if (_webSearchInstance) {
-		return _webSearchInstance;
-	}
-	const apiKey = process.env.EXA_API_KEY;
-	if (!apiKey) {
-		throw new Error(
-			"EXA_API_KEY environment variable is required to use the web_search tool. " +
-				"Please set it to your Exa API key from https://exa.ai",
-		);
-	}
-	const client = new Exa(apiKey);
-	_webSearchInstance = new ExaSearchResults({
-		client,
-		searchArgs: {
-			numResults: 5,
-			type: "auto",
-			text: true,
-		},
-	});
-	return _webSearchInstance;
-}

package/dist/dev-agent/index.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env bun
-export {};

package/dist/dev-agent/index.js

@@ -1,18 +0,0 @@
-#!/usr/bin/env bun
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-import { makeHttpTransport, makeStdioTransport } from "../acp-server/index";
-// Load agent definition from JSON file
-const configPath = join(import.meta.dir, "agent.json");
-const agent = JSON.parse(readFileSync(configPath, "utf-8"));
-const transport = process.argv[2] || "stdio";
-if (transport === "http") {
-    makeHttpTransport(agent);
-}
-else if (transport === "stdio") {
-    makeStdioTransport(agent);
-}
-else {
-    console.error(`Invalid transport: ${transport}`);
-    process.exit(1);
-}

package/dist/example.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env bun
-export {};

package/dist/example.js

@@ -1,19 +0,0 @@
-#!/usr/bin/env bun
-import { makeHttpTransport, makeStdioTransport } from "./acp-server/index.js";
-
-const exampleAgent = {
-	model: "claude-sonnet-4-5-20250929",
-	systemPrompt: "You are a helpful assistant.",
-	tools: ["todo_write", "get_weather", "web_search"],
-};
-// Parse transport type from command line argument
-const transport = process.argv[2] || "stdio";
-if (transport === "http") {
-	makeHttpTransport(exampleAgent);
-} else if (transport === "stdio") {
-	makeStdioTransport(exampleAgent);
-} else {
-	console.error(`Invalid transport: ${transport}`);
-	console.error("Usage: bun run example.ts [stdio|http]");
-	process.exit(1);
-}

package/dist/scaffold/link-local.d.ts

@@ -1 +0,0 @@
-export declare function linkLocalPackages(projectPath: string): Promise<void>;

package/dist/scaffold/link-local.js

@@ -1,54 +0,0 @@
-import { exists } from "node:fs/promises";
-import { join } from "node:path";
-import { $ } from "bun";
-const PACKAGE_PATHS = {
-    "@townco/ui": "packages/ui",
-    "@townco/core": "packages/core",
-    "@townco/tsconfig": "packages/tsconfig",
-    "@townco/tui-template": "apps/tui",
-    "@townco/gui-template": "apps/gui",
-    "@townco/secret": "packages/secret",
-    "@townco/agent": "packages/agent",
-    "@townco/cli": "apps/cli",
-};
-async function getMonorepoRoot() {
-    try {
-        // 1. Get git repo root
-        const result = await $ `git rev-parse --show-toplevel`.quiet();
-        const repoRoot = result.text().trim();
-        // 2. Check package.json name === "town"
-        const pkgJsonPath = join(repoRoot, "package.json");
-        const pkgJson = await Bun.file(pkgJsonPath).json();
-        if (pkgJson.name !== "town")
-            return null;
-        // 3. Check packages/agent and packages/ui exist
-        const agentExists = await exists(join(repoRoot, "packages/agent"));
-        const uiExists = await exists(join(repoRoot, "packages/ui"));
-        if (!agentExists || !uiExists)
-            return null;
-        return repoRoot;
-    }
-    catch {
-        return null;
-    }
-}
-export async function linkLocalPackages(projectPath) {
-    const repoRoot = await getMonorepoRoot();
-    if (!repoRoot)
-        return; // Not in monorepo, no-op
-    console.log("Detected town monorepo, linking local packages...");
-    // 1. Register each local package globally
-    for (const [, localPath] of Object.entries(PACKAGE_PATHS)) {
-        const pkgPath = join(repoRoot, localPath);
-        await $ `bun link`.cwd(pkgPath).quiet();
-    }
-    // 2. Parse project's package.json for @townco/* deps
-    const pkgJson = await Bun.file(join(projectPath, "package.json")).json();
-    const deps = { ...pkgJson.dependencies, ...pkgJson.devDependencies };
-    const towncoPackages = Object.keys(deps).filter((name) => name.startsWith("@townco/"));
-    // 3. Link each package in the project
-    for (const pkgName of towncoPackages) {
-        await $ `bun link ${pkgName}`.cwd(projectPath);
-        console.log(`Linked ${pkgName}`);
-    }
-}

package/dist/utils/__tests__/tool-overhead-calculator.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/utils/__tests__/tool-overhead-calculator.test.js

@@ -1,153 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { estimateAllToolsOverhead, estimateToolDefinitionTokens, extractToolMetadata, } from "../tool-overhead-calculator.js";
-describe("tool-overhead-calculator", () => {
-    describe("estimateToolDefinitionTokens", () => {
-        test("estimates tokens for a simple tool", () => {
-            const tool = {
-                name: "simple_tool",
-                description: "A simple tool",
-                schema: {
-                    type: "object",
-                    properties: {
-                        param1: { type: "string" },
-                    },
-                },
-            };
-            const tokens = estimateToolDefinitionTokens(tool);
-            // Should return a positive number
-            expect(tokens).toBeGreaterThan(0);
-            // Rough sanity check: a simple tool should be at least 20 tokens
-            expect(tokens).toBeGreaterThanOrEqual(20);
-        });
-        test("estimates more tokens for a complex tool", () => {
-            const simpleTool = {
-                name: "simple",
-                description: "Simple",
-                schema: { type: "object" },
-            };
-            const complexTool = {
-                name: "complex_tool_with_long_name",
-                description: "A very complex tool with a long description that explains what it does in great detail and provides usage notes and examples.",
-                schema: {
-                    type: "object",
-                    properties: {
-                        param1: {
-                            type: "string",
-                            description: "First parameter description",
-                        },
-                        param2: {
-                            type: "number",
-                            description: "Second parameter description",
-                        },
-                        param3: {
-                            type: "array",
-                            items: { type: "string" },
-                            description: "Third parameter description",
-                        },
-                    },
-                    required: ["param1", "param2"],
-                },
-            };
-            const simpleTokens = estimateToolDefinitionTokens(simpleTool);
-            const complexTokens = estimateToolDefinitionTokens(complexTool);
-            expect(complexTokens).toBeGreaterThan(simpleTokens);
-        });
-        test("handles empty description", () => {
-            const tool = {
-                name: "test",
-                description: "",
-                schema: {},
-            };
-            const tokens = estimateToolDefinitionTokens(tool);
-            expect(tokens).toBeGreaterThan(0);
-        });
-    });
-    describe("estimateAllToolsOverhead", () => {
-        test("returns 0 for empty array", () => {
-            const tools = [];
-            const tokens = estimateAllToolsOverhead(tools);
-            expect(tokens).toBe(0);
-        });
-        test("sums tokens for multiple tools", () => {
-            const tools = [
-                {
-                    name: "tool1",
-                    description: "First tool",
-                    schema: { type: "object" },
-                },
-                {
-                    name: "tool2",
-                    description: "Second tool",
-                    schema: { type: "object" },
-                },
-            ];
-            const totalTokens = estimateAllToolsOverhead(tools);
-            const tool1Tokens = estimateToolDefinitionTokens(tools[0]);
-            const tool2Tokens = estimateToolDefinitionTokens(tools[1]);
-            expect(totalTokens).toBe(tool1Tokens + tool2Tokens);
-        });
-        test("handles large tool collections", () => {
-            const tools = Array.from({ length: 10 }, (_, i) => ({
-                name: `tool_${i}`,
-                description: `Tool number ${i} with description`,
-                schema: {
-                    type: "object",
-                    properties: {
-                        param: { type: "string" },
-                    },
-                },
-            }));
-            const totalTokens = estimateAllToolsOverhead(tools);
-            // With 10 tools, should be substantial
-            expect(totalTokens).toBeGreaterThan(100);
-        });
-    });
-    describe("extractToolMetadata", () => {
-        test("extracts metadata from LangChain tool object", () => {
-            const langchainTool = {
-                name: "test_tool",
-                description: "Test description",
-                schema: {
-                    type: "object",
-                    properties: { x: { type: "number" } },
-                },
-            };
-            const metadata = extractToolMetadata(langchainTool);
-            expect(metadata.name).toBe("test_tool");
-            expect(metadata.description).toBe("Test description");
-            expect(metadata.schema).toEqual({
-                type: "object",
-                properties: { x: { type: "number" } },
-            });
-        });
-        test("handles missing description", () => {
-            const langchainTool = {
-                name: "test_tool",
-                schema: { type: "object" },
-            };
-            const metadata = extractToolMetadata(langchainTool);
-            expect(metadata.name).toBe("test_tool");
-            expect(metadata.description).toBe("");
-            expect(metadata.schema).toEqual({ type: "object" });
-        });
-        test("handles missing schema", () => {
-            const langchainTool = {
-                name: "test_tool",
-                description: "Test",
-            };
-            const metadata = extractToolMetadata(langchainTool);
-            expect(metadata.name).toBe("test_tool");
-            expect(metadata.description).toBe("Test");
-            expect(metadata.schema).toEqual({});
-        });
-        test("handles missing description and schema", () => {
-            const langchainTool = {
-                name: "test_tool",
-            };
-            const metadata = extractToolMetadata(langchainTool);
-            expect(metadata.name).toBe("test_tool");
-            expect(metadata.description).toBe("");
-            expect(metadata.schema).toEqual({});
-        });
-    });
-});

package/dist/utils/logger.d.ts

@@ -1,39 +0,0 @@
-/**
- * Node.js logger with file rotation support
- * Outputs to both stdout and .logs/<service>.log files
- */
-export type LogLevel = "trace" | "debug" | "info" | "warn" | "error" | "fatal";
-export declare class Logger {
-    private service;
-    private minLevel;
-    private logFilePath;
-    private logsDir;
-    private writeQueue;
-    private isWriting;
-    private silent;
-    constructor(service: string, minLevel?: LogLevel, options?: {
-        silent?: boolean;
-        logsDir?: string;
-    });
-    private ensureLogsDirectory;
-    private shouldLog;
-    private rotateLogFile;
-    private writeToFile;
-    private log;
-    trace(message: string, metadata?: Record<string, unknown>): void;
-    debug(message: string, metadata?: Record<string, unknown>): void;
-    info(message: string, metadata?: Record<string, unknown>): void;
-    warn(message: string, metadata?: Record<string, unknown>): void;
-    error(message: string, metadata?: Record<string, unknown>): void;
-    fatal(message: string, metadata?: Record<string, unknown>): void;
-}
-/**
- * Create a logger instance for a service
- * @param service - Service name (e.g., "gui", "http-agent", "tui")
- * @param minLevel - Minimum log level to display (default: "debug")
- * @param options - Logger options (silent mode, custom logs directory, etc.)
- */
-export declare function createLogger(service: string, minLevel?: LogLevel, options?: {
-    silent?: boolean;
-    logsDir?: string;
-}): Logger;