@townco/agent 0.1.13 → 0.1.15

package/dist/definition/tools/todo.js

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

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

package/dist/definition/tools/web_search.js

@@ -0,0 +1,26 @@
+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/example.d.ts

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

package/dist/example.js

@@ -0,0 +1,19 @@
+#!/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/index.js

@@ -1,20 +1,19 @@
 import { makeHttpTransport, makeStdioTransport } from "./acp-server";
+
 const exampleAgent = {
-    model: "claude-sonnet-4-5-20250929",
-    systemPrompt: "You are a helpful assistant.",
-    tools: ["todo_write", "get_weather", "web_search"],
-    mcps: [],
+	model: "claude-sonnet-4-5-20250929",
+	systemPrompt: "You are a helpful assistant.",
+	tools: ["todo_write", "get_weather", "web_search"],
+	mcps: [],
 };
 // 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 index.ts [stdio|http]");
-    process.exit(1);
+	makeHttpTransport(exampleAgent);
+} else if (transport === "stdio") {
+	makeStdioTransport(exampleAgent);
+} else {
+	console.error(`Invalid transport: ${transport}`);
+	console.error("Usage: bun run index.ts [stdio|http]");
+	process.exit(1);
 }

package/dist/runner/agent-runner.js

@@ -2,8 +2,8 @@ import { z } from "zod";
 import { McpConfigSchema } from "../definition";
 import { zToolType } from "./tools";
 export const zAgentRunnerParams = z.object({
-    systemPrompt: z.string().nullable(),
-    model: z.string(),
-    tools: z.array(zToolType).optional(),
-    mcps: z.array(McpConfigSchema).optional(),
+	systemPrompt: z.string().nullable(),
+	model: z.string(),
+	tools: z.array(zToolType).optional(),
+	mcps: z.array(McpConfigSchema).optional(),
 });

package/dist/runner/index.d.ts

@@ -1,4 +1,6 @@
 import type { AgentDefinition } from "../definition";
 import { type AgentRunner } from "./agent-runner";
 export type { AgentRunner };
-export declare const makeRunnerFromDefinition: (definition: AgentDefinition) => AgentRunner;
+export declare const makeRunnerFromDefinition: (
+	definition: AgentDefinition,
+) => AgentRunner;

package/dist/runner/index.js

@@ -1,18 +1,22 @@
 import { zAgentRunnerParams } from "./agent-runner";
 import { LangchainAgent } from "./langchain";
 export const makeRunnerFromDefinition = (definition) => {
-    const agentRunnerParams = zAgentRunnerParams.safeParse(definition);
-    if (!agentRunnerParams.success) {
-        throw new Error(`Invalid agent definition: ${agentRunnerParams.error.message}`);
-    }
-    switch (definition.harnessImplementation) {
-        case undefined:
-        case "langchain": {
-            return new LangchainAgent(agentRunnerParams.data);
-        }
-        default: {
-            const _exhaustiveCheck = definition.harnessImplementation;
-            throw new Error(`Unsupported harness implementation: ${definition.harnessImplementation}`);
-        }
-    }
+	const agentRunnerParams = zAgentRunnerParams.safeParse(definition);
+	if (!agentRunnerParams.success) {
+		throw new Error(
+			`Invalid agent definition: ${agentRunnerParams.error.message}`,
+		);
+	}
+	switch (definition.harnessImplementation) {
+		case undefined:
+		case "langchain": {
+			return new LangchainAgent(agentRunnerParams.data);
+		}
+		default: {
+			const _exhaustiveCheck = definition.harnessImplementation;
+			throw new Error(
+				`Unsupported harness implementation: ${definition.harnessImplementation}`,
+			);
+		}
+	}
 };

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

@@ -1,33 +1,49 @@
 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>;
+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/runner/langchain/tools/todo.js

@@ -1,16 +1,18 @@
 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),
+	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.
+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
@@ -71,7 +73,8 @@ NOTE that you should not use this tool if there is only one trivial task to do.
      - 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),
-    }),
-});
+		schema: z.object({
+			todos: z.array(todoItemSchema),
+		}),
+	},
+);

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

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

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

@@ -1,23 +1,26 @@
 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;
+	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/scaffold/copy-gui.d.ts

@@ -1,4 +1,4 @@
 /**
- * Copy GUI app to the agent directory
+ * Copy GUI app to the agent directory from @townco/gui-template
  */
 export declare function copyGuiApp(agentPath: string): Promise<void>;

package/dist/scaffold/copy-gui.js

@@ -1,42 +1,38 @@
 import { cp, mkdir, writeFile } from "node:fs/promises";
+import { createRequire } from "node:module";
 import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
+const require = createRequire(import.meta.url);
 /**
- * Get the source apps/gui directory
+ * Get the GUI template from @townco/gui-template npm package
  */
 function getGuiSourceDir() {
-    const currentFile = fileURLToPath(import.meta.url);
-    // scaffold/copy-gui.ts -> scaffold -> packages/agent -> packages -> root -> apps/gui
-    return join(dirname(currentFile), "..", "..", "..", "apps", "gui");
-}
-/**
- * Get the source packages/ui directory
- */
-function getUiSourceDir() {
-    const currentFile = fileURLToPath(import.meta.url);
-    // scaffold/copy-gui.ts -> scaffold -> packages/agent -> packages -> ui
-    return join(dirname(currentFile), "..", "..", "ui");
+    try {
+        const packagePath = require.resolve("@townco/gui-template/package.json");
+        return dirname(packagePath);
+    }
+    catch {
+        throw new Error("Could not find @townco/gui-template. Please ensure it is installed.");
+    }
 }
 /**
- * Copy GUI app to the agent directory
+ * Copy GUI app to the agent directory from @townco/gui-template
  */
 export async function copyGuiApp(agentPath) {
-    const sourceDir = getGuiSourceDir();
     const guiDir = join(agentPath, "gui");
     // Create gui directory
     await mkdir(guiDir, { recursive: true });
-    // Copy everything except node_modules and dist (exclude tsconfig.json as we'll generate it)
-    const itemsToCopy = ["src", "index.html", "postcss.config.js"];
+    // Get GUI source from @townco/gui-template npm package
+    const sourceDir = getGuiSourceDir();
+    const itemsToCopy = [
+        "src",
+        "index.html",
+        "postcss.config.js",
+        "vite.config.ts",
+    ];
     for (const item of itemsToCopy) {
         const sourcePath = join(sourceDir, item);
         const targetPath = join(guiDir, item);
-        try {
-            await cp(sourcePath, targetPath, { recursive: true });
-        }
-        catch (error) {
-            // Item might not exist, that's okay
-            console.warn(`Warning: Could not copy ${item}:`, error);
-        }
+        await cp(sourcePath, targetPath, { recursive: true });
     }
     // Create a standalone tsconfig.json for the GUI (can't extend from workspace tsconfig)
     const guiTsConfig = {
@@ -74,65 +70,8 @@ export async function copyGuiApp(agentPath) {
         exclude: ["node_modules", "dist"],
     };
     await writeFile(join(guiDir, "tsconfig.json"), JSON.stringify(guiTsConfig, null, 2));
-    // Create a custom vite.config.ts with path aliases
-    const viteConfig = `import { defineConfig } from "vite";
-import react from "@vitejs/plugin-react";
-import { resolve } from "path";
-
-export default defineConfig({
-	plugins: [react()],
-	resolve: {
-		alias: {
-			"@townco/ui": resolve(__dirname, "./ui/src"),
-			// Exclude Node.js-only modules from browser bundle
-			"node:child_process": resolve(__dirname, "./polyfills/child_process.js"),
-			"node:stream": resolve(__dirname, "./polyfills/stream.js"),
-		},
-	},
-	optimizeDeps: {
-		exclude: ["node:child_process", "node:stream"],
-	},
-});
-`;
-    await writeFile(join(guiDir, "vite.config.ts"), viteConfig);
-    // Create polyfills directory with stub modules for Node.js-only imports
-    const polyfillsDir = join(guiDir, "polyfills");
-    await mkdir(polyfillsDir, { recursive: true });
-    // Provide stub exports for child_process module
-    const childProcessPolyfill = `// Polyfill for node:child_process (browser-incompatible)
-export const spawn = () => {
-	throw new Error('child_process.spawn is not available in the browser');
-};
-export class ChildProcess {}
-export default { spawn, ChildProcess };
-`;
-    await writeFile(join(polyfillsDir, "child_process.js"), childProcessPolyfill);
-    // Provide stub exports for stream module
-    const streamPolyfill = `// Polyfill for node:stream (browser-incompatible)
-export class Readable {
-	constructor() {
-		throw new Error('stream.Readable is not available in the browser');
-	}
-}
-export class Writable {
-	constructor() {
-		throw new Error('stream.Writable is not available in the browser');
-	}
-}
-export class Duplex {
-	constructor() {
-		throw new Error('stream.Duplex is not available in the browser');
-	}
-}
-export class Transform {
-	constructor() {
-		throw new Error('stream.Transform is not available in the browser');
-	}
-}
-export default { Readable, Writable, Duplex, Transform };
-`;
-    await writeFile(join(polyfillsDir, "stream.js"), streamPolyfill);
     // Generate a custom package.json for the GUI
+    // Use @townco/ui as a dependency instead of copying files
     const packageJson = {
         name: "agent-gui",
         version: "0.0.1",
@@ -144,6 +83,7 @@ export default { Readable, Writable, Duplex, Transform };
             preview: "vite preview",
         },
         dependencies: {
+            "@townco/ui": "^0.1.0",
             "@agentclientprotocol/sdk": "^0.5.1",
             "@radix-ui/react-dialog": "^1.1.15",
             "@radix-ui/react-label": "^2.1.8",
@@ -174,35 +114,4 @@ export default { Readable, Writable, Duplex, Transform };
         },
     };
     await writeFile(join(guiDir, "package.json"), JSON.stringify(packageJson, null, 2));
-    // Copy UI package components and styles
-    const uiSourceDir = getUiSourceDir();
-    const uiTargetDir = join(guiDir, "ui");
-    await mkdir(uiTargetDir, { recursive: true });
-    // Copy the entire UI src directory (which includes styles)
-    const sourcePath = join(uiSourceDir, "src");
-    const targetPath = join(uiTargetDir, "src");
-    try {
-        await cp(sourcePath, targetPath, { recursive: true });
-    }
-    catch (error) {
-        console.warn(`Warning: Could not copy UI src:`, error);
-    }
-    // Create a tsconfig for the ui directory
-    const uiTsConfig = {
-        compilerOptions: {
-            target: "ESNext",
-            module: "ESNext",
-            jsx: "react-jsx",
-            moduleResolution: "bundler",
-            lib: ["ESNext", "DOM", "DOM.Iterable"],
-            strict: true,
-            esModuleInterop: true,
-            skipLibCheck: true,
-            forceConsistentCasingInFileNames: true,
-            resolveJsonModule: true,
-            allowSyntheticDefaultImports: true,
-        },
-        include: ["**/*.ts", "**/*.tsx"],
-    };
-    await writeFile(join(uiTargetDir, "tsconfig.json"), JSON.stringify(uiTsConfig, null, 2));
 }

package/dist/scaffold/index.d.ts

@@ -1,16 +1,18 @@
 import type { AgentDefinition } from "../definition";
 export interface ScaffoldOptions {
-    name: string;
-    definition: AgentDefinition;
-    overwrite?: boolean;
-    includeGui?: boolean;
+	name: string;
+	definition: AgentDefinition;
+	overwrite?: boolean;
+	includeGui?: boolean;
 }
 export interface ScaffoldResult {
-    success: boolean;
-    path: string;
-    error?: string;
+	success: boolean;
+	path: string;
+	error?: string;
 }
 /**
  * Scaffold a new agent package
  */
-export declare function scaffoldAgent(options: ScaffoldOptions): Promise<ScaffoldResult>;
+export declare function scaffoldAgent(
+	options: ScaffoldOptions,
+): Promise<ScaffoldResult>;

package/dist/scaffold/index.js

@@ -3,7 +3,6 @@ import { chmod, mkdir, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { agentExists, ensureAgentsDir, getAgentPath } from "../storage";
 import { generateAgentJson, generateBinTs, generateEnvExample, generateGitignore, generateIndexTs, generatePackageJson, generateReadme, generateTsConfig, getTemplateVars, } from "../templates";
-import { bundleAgentDependencies } from "./bundle";
 import { copyGuiApp } from "./copy-gui";
 /**
  * Scaffold a new agent package
@@ -50,8 +49,6 @@ export async function scaffoldAgent(options) {
                 await chmod(filePath, 0o755);
             }
         }
-        // Bundle agent dependencies (copy lib files)
-        await bundleAgentDependencies(agentPath);
         // Copy GUI app if requested
         if (includeGui) {
             await copyGuiApp(agentPath);
@@ -59,7 +56,7 @@ export async function scaffoldAgent(options) {
             const guiPath = join(agentPath, "gui");
             await runBunInstall(guiPath);
         }
-        // Run bun install in agent root
+        // Run bun install in agent root to fetch dependencies from npm
         await runBunInstall(agentPath);
         return {
             success: true,