@townco/agent 0.1.22 → 0.1.24

package/dist/acp-server/adapter.d.ts

@@ -2,18 +2,14 @@ import * as acp from "@agentclientprotocol/sdk";
 import type { AgentRunner } from "../runner";
 /** Adapts an Agent to speak the ACP protocol */
 export declare class AgentAcpAdapter implements acp.Agent {
-	private connection;
-	private sessions;
-	private agent;
-	constructor(agent: AgentRunner, connection: acp.AgentSideConnection);
-	initialize(_params: acp.InitializeRequest): Promise<acp.InitializeResponse>;
-	newSession(_params: acp.NewSessionRequest): Promise<acp.NewSessionResponse>;
-	authenticate(
-		_params: acp.AuthenticateRequest,
-	): Promise<acp.AuthenticateResponse | undefined>;
-	setSessionMode(
-		_params: acp.SetSessionModeRequest,
-	): Promise<acp.SetSessionModeResponse>;
-	prompt(params: acp.PromptRequest): Promise<acp.PromptResponse>;
-	cancel(params: acp.CancelNotification): Promise<void>;
+    private connection;
+    private sessions;
+    private agent;
+    constructor(agent: AgentRunner, connection: acp.AgentSideConnection);
+    initialize(_params: acp.InitializeRequest): Promise<acp.InitializeResponse>;
+    newSession(_params: acp.NewSessionRequest): Promise<acp.NewSessionResponse>;
+    authenticate(_params: acp.AuthenticateRequest): Promise<acp.AuthenticateResponse | undefined>;
+    setSessionMode(_params: acp.SetSessionModeRequest): Promise<acp.SetSessionModeResponse>;
+    prompt(params: acp.PromptRequest): Promise<acp.PromptResponse>;
+    cancel(params: acp.CancelNotification): Promise<void>;
 }

package/dist/acp-server/cli.d.ts

@@ -1,5 +1,3 @@
 import type { AgentDefinition } from "../definition";
 import { type AgentRunner } from "../runner";
-export declare function makeStdioTransport(
-	agent: AgentRunner | AgentDefinition,
-): void;
+export declare function makeStdioTransport(agent: AgentRunner | AgentDefinition): void;

package/dist/acp-server/cli.js

@@ -3,13 +3,9 @@ import * as acp from "@agentclientprotocol/sdk";
 import { makeRunnerFromDefinition } from "../runner";
 import { AgentAcpAdapter } from "./adapter";
 export function makeStdioTransport(agent) {
-	const agentRunner =
-		"definition" in agent ? agent : makeRunnerFromDefinition(agent);
-	const input = Writable.toWeb(process.stdout);
-	const output = Readable.toWeb(process.stdin);
-	const stream = acp.ndJsonStream(input, output);
-	new acp.AgentSideConnection(
-		(conn) => new AgentAcpAdapter(agentRunner, conn),
-		stream,
-	);
+    const agentRunner = "definition" in agent ? agent : makeRunnerFromDefinition(agent);
+    const input = Writable.toWeb(process.stdout);
+    const output = Readable.toWeb(process.stdin);
+    const stream = acp.ndJsonStream(input, output);
+    new acp.AgentSideConnection((conn) => new AgentAcpAdapter(agentRunner, conn), stream);
 }

package/dist/acp-server/http.d.ts

@@ -1,5 +1,3 @@
 import type { AgentDefinition } from "../definition";
 import { type AgentRunner } from "../runner";
-export declare function makeHttpTransport(
-	agent: AgentRunner | AgentDefinition,
-): void;
+export declare function makeHttpTransport(agent: AgentRunner | AgentDefinition): void;

package/dist/acp-server/http.js

@@ -384,8 +384,8 @@ export function makeHttpTransport(agent) {
             const writer = inbound.writable.getWriter();
             await writer.write(encoder.encode(`${JSON.stringify(body)}\n`));
             writer.releaseLock();
-            // Wait for response with 30 second timeout
-            const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error("Request timeout")), 30000));
+            // Wait for response with ten minute timeout
+            const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error("Request timeout")), 10 * 60 * 1000));
             try {
                 const response = await Promise.race([responsePromise, timeoutPromise]);
                 logger.debug("POST /rpc - Response received", { id });

package/dist/definition/index.d.ts

@@ -22,6 +22,12 @@ export declare const AgentDefinitionSchema: z.ZodObject<{
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<"filesystem">;
         working_directory: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"direct">;
+        name: z.ZodString;
+        description: z.ZodString;
+        fn: z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
+        schema: z.ZodAny;
     }, z.core.$strip>]>>>;
     mcps: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
         name: z.ZodString;

package/dist/definition/index.js

@@ -35,11 +35,20 @@ const FilesystemToolSchema = z.object({
     /** If omitted, defaults to process.cwd() at runtime */
     working_directory: z.string().optional(),
 });
+/** Direct tool configuration schema (for tools imported directly in code). */
+const DirectToolSchema = z.object({
+    type: z.literal("direct"),
+    name: z.string(),
+    description: z.string(),
+    fn: z.function(),
+    schema: z.any(), // Accept any Zod schema
+});
 /** Tool schema - can be a string (built-in tool) or custom tool object. */
 const ToolSchema = z.union([
     z.string(),
     CustomToolSchema,
     FilesystemToolSchema,
+    DirectToolSchema,
 ]);
 /** Agent definition schema. */
 export const AgentDefinitionSchema = z.object({

package/dist/index.js

@@ -1,9 +1,15 @@
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
 import { makeHttpTransport, makeStdioTransport } from "./acp-server";
-// Load agent definition from shared JSON file at repo root
-const configPath = join(import.meta.dir, "../../agent.json");
-const exampleAgent = JSON.parse(readFileSync(configPath, "utf-8"));
+const exampleAgent = {
+    model: "claude-sonnet-4-5-20250929",
+    systemPrompt: "You are a helpful assistant.",
+    tools: [
+        "todo_write",
+        "get_weather",
+        "web_search",
+        { type: "filesystem", working_directory: "/Users/michael/code/town" },
+    ],
+    mcps: [],
+};
 // Parse transport type from command line argument
 const transport = process.argv[2] || "stdio";
 if (transport === "http") {

package/dist/runner/agent-runner.d.ts

@@ -9,6 +9,12 @@ export declare const zAgentRunnerParams: z.ZodObject<{
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<"filesystem">;
         working_directory: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"direct">;
+        name: z.ZodString;
+        description: z.ZodString;
+        fn: z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
+        schema: z.ZodAny;
     }, z.core.$strip>]>>>;
     mcps: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
         name: z.ZodString;

package/dist/runner/index.d.ts

@@ -1,6 +1,4 @@
 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,22 +1,18 @@
 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/index.js

@@ -73,6 +73,16 @@ export class LangchainAgent {
                         process.cwd();
                     enabledTools.push(...makeFilesystemTools(wd));
                 }
+                else if (type === "direct") {
+                    // Handle direct tool objects (imported in code)
+                    // biome-ignore lint/suspicious/noExplicitAny: mlai unsure how to best type this
+                    const addedTool = tool(t.fn, {
+                        name: t.name,
+                        description: t.description,
+                        schema: t.schema,
+                    });
+                    enabledTools.push(addedTool);
+                }
             }
         }
         // Built-in tools from registry
@@ -147,30 +157,32 @@ export class LangchainAgent {
                         if (toolCall.id == null) {
                             throw new Error(`Tool call is missing id: ${JSON.stringify(toolCall)}`);
                         }
+                        // TODO: re-add this suppression of the todo_write tool call when we
+                        // are rendering the agent-plan update in the UIs
                         // If this is a todo_write tool call, yield an agent-plan update
-                        if (toolCall.name === "todo_write" && toolCall.args?.todos) {
-                            const entries = toolCall.args.todos.flatMap((todo) => {
-                                const validation = todoItemSchema.safeParse(todo);
-                                if (!validation.success) {
-                                    // Invalid todo - filter it out
-                                    return [];
-                                }
-                                return [
-                                    {
-                                        content: validation.data.content,
-                                        status: validation.data.status,
-                                        priority: "medium",
-                                    },
-                                ];
-                            });
-                            yield {
-                                sessionUpdate: "plan",
-                                entries: entries,
-                            };
-                            // Track this tool call ID to suppress tool_call notifications
-                            todoWriteToolCallIds.add(toolCall.id);
-                            continue;
-                        }
+                        //if (toolCall.name === "todo_write" && toolCall.args?.todos) {
+                        //  const entries = toolCall.args.todos.flatMap((todo: unknown) => {
+                        //    const validation = todoItemSchema.safeParse(todo);
+                        //    if (!validation.success) {
+                        //      // Invalid todo - filter it out
+                        //      return [];
+                        //    }
+                        //    return [
+                        //      {
+                        //        content: validation.data.content,
+                        //        status: validation.data.status,
+                        //        priority: "medium" as const,
+                        //      },
+                        //    ];
+                        //  });
+                        //  yield {
+                        //    sessionUpdate: "plan",
+                        //    entries: entries,
+                        //  };
+                        //  // Track this tool call ID to suppress tool_call notifications
+                        //  todoWriteToolCallIds.add(toolCall.id);
+                        //  continue;
+                        //}
                         yield {
                             sessionUpdate: "tool_call",
                             toolCallId: toolCall.id,

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

@@ -1,49 +1,33 @@
 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/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/tools.d.ts

@@ -1,6 +1,14 @@
 import { z } from "zod";
 /** Built-in tool types. */
 export declare const zBuiltInToolType: z.ZodUnion<readonly [z.ZodLiteral<"todo_write">, z.ZodLiteral<"get_weather">, z.ZodLiteral<"web_search">, z.ZodLiteral<"filesystem">]>;
+/** Direct tool object schema (for tools imported directly in code). */
+declare const zDirectTool: z.ZodObject<{
+    type: z.ZodLiteral<"direct">;
+    name: z.ZodString;
+    description: z.ZodString;
+    fn: z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
+    schema: z.ZodAny;
+}, z.core.$strip>;
 /** Tool type - can be a built-in tool string or custom tool object. */
 export declare const zToolType: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodLiteral<"todo_write">, z.ZodLiteral<"get_weather">, z.ZodLiteral<"web_search">, z.ZodLiteral<"filesystem">]>, z.ZodObject<{
     type: z.ZodLiteral<"custom">;
@@ -8,6 +16,14 @@ export declare const zToolType: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodL
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"filesystem">;
     working_directory: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"direct">;
+    name: z.ZodString;
+    description: z.ZodString;
+    fn: z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
+    schema: z.ZodAny;
 }, z.core.$strip>]>;
 export type ToolType = z.infer<typeof zToolType>;
 export type BuiltInToolType = z.infer<typeof zBuiltInToolType>;
+export type DirectTool = z.infer<typeof zDirectTool>;
+export {};

package/dist/runner/tools.js

@@ -6,7 +6,7 @@ export const zBuiltInToolType = z.union([
     z.literal("web_search"),
     z.literal("filesystem"),
 ]);
-/** Custom tool schema. */
+/** Custom tool schema (loaded from module path). */
 const zCustomTool = z.object({
     type: z.literal("custom"),
     modulePath: z.string(),
@@ -16,9 +16,18 @@ const zFilesystemTool = z.object({
     type: z.literal("filesystem"),
     working_directory: z.string().optional(),
 });
+/** Direct tool object schema (for tools imported directly in code). */
+const zDirectTool = z.object({
+    type: z.literal("direct"),
+    name: z.string(),
+    description: z.string(),
+    fn: z.function(),
+    schema: z.any(), // Accept any Zod schema
+});
 /** Tool type - can be a built-in tool string or custom tool object. */
 export const zToolType = z.union([
     zBuiltInToolType,
     zCustomTool,
     zFilesystemTool,
+    zDirectTool,
 ]);

package/dist/scaffold/claude-scaffold.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Initialize Claude Code workspace integration by creating AGENTS.town.md
+ * and adding references to it in CLAUDE.md and AGENTS.md.
+ *
+ * @param targetPath - The root directory of the Town project
+ * @throws Error if target path doesn't exist
+ */
+export declare function initForClaudeCode(targetPath: string): Promise<void>;

package/dist/scaffold/claude-scaffold.js

@@ -0,0 +1,58 @@
+import { existsSync } from "node:fs";
+import { appendFile, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+/**
+ * Initialize Claude Code workspace integration by creating AGENTS.town.md
+ * and adding references to it in CLAUDE.md and AGENTS.md.
+ *
+ * @param targetPath - The root directory of the Town project
+ * @throws Error if target path doesn't exist
+ */
+export async function initForClaudeCode(targetPath) {
+    // Verify target path exists
+    if (!existsSync(targetPath)) {
+        throw new Error(`Target path does not exist: ${targetPath}`);
+    }
+    // Source template directory (dot-claude in the scaffold package)
+    const templateDir = join(__dirname, "templates", "dot-claude");
+    const appendTemplatePath = join(templateDir, "CLAUDE-append.md");
+    if (!existsSync(appendTemplatePath)) {
+        throw new Error(`Claude template not found: ${appendTemplatePath}. This is a bug in the Town CLI.`);
+    }
+    // Handle AGENTS.town.md and references
+    const claudeMdPath = join(targetPath, "CLAUDE.md");
+    const agentsMdPath = join(targetPath, "AGENTS.md");
+    const agentsTownMdPath = join(targetPath, "AGENTS.town.md");
+    const townContent = await readFile(appendTemplatePath, "utf-8");
+    // Create AGENTS.town.md with the Town-specific content
+    await writeFile(agentsTownMdPath, townContent, "utf-8");
+    console.log("✓ Created AGENTS.town.md");
+    // Add reference to AGENTS.town.md in both CLAUDE.md and AGENTS.md
+    const referenceText = "\n\nThis repo uses the Town agent SDK -- please reference @AGENTS.town.md for more information\n";
+    // Handle CLAUDE.md
+    if (existsSync(claudeMdPath)) {
+        // CLAUDE.md exists, append reference
+        await appendFile(claudeMdPath, referenceText);
+        console.log("✓ Added Town SDK reference to CLAUDE.md");
+    }
+    else {
+        // CLAUDE.md doesn't exist, create it with just the reference
+        await writeFile(claudeMdPath, `${referenceText.trim()}\n`, "utf-8");
+        console.log("✓ Created CLAUDE.md with Town SDK reference");
+    }
+    // Handle AGENTS.md
+    if (existsSync(agentsMdPath)) {
+        // AGENTS.md exists, append reference
+        await appendFile(agentsMdPath, referenceText);
+        console.log("✓ Added Town SDK reference to AGENTS.md");
+    }
+    else {
+        // AGENTS.md doesn't exist, create it with just the reference
+        await writeFile(agentsMdPath, `${referenceText.trim()}\n`, "utf-8");
+        console.log("✓ Created AGENTS.md with Town SDK reference");
+    }
+    console.log("✓ Claude Code workspace initialized");
+}

package/dist/scaffold/copy-gui.js

@@ -1,4 +1,4 @@
-import { cp, mkdir, writeFile } from "node:fs/promises";
+import { cp, mkdir, readFile, writeFile } from "node:fs/promises";
 import { createRequire } from "node:module";
 import { dirname, join } from "node:path";
 const require = createRequire(import.meta.url);
@@ -34,84 +34,10 @@ export async function copyGuiApp(agentPath) {
         const targetPath = join(guiDir, item);
         await cp(sourcePath, targetPath, { recursive: true });
     }
-    // Create a standalone tsconfig.json for the GUI (can't extend from workspace tsconfig)
-    const guiTsConfig = {
-        compilerOptions: {
-            allowArbitraryExtensions: true,
-            allowUnreachableCode: false,
-            allowUnusedLabels: false,
-            declaration: true,
-            emitDecoratorMetadata: true,
-            esModuleInterop: true,
-            exactOptionalPropertyTypes: true,
-            experimentalDecorators: true,
-            jsx: "react-jsx",
-            lib: ["DOM", "ESNext"],
-            module: "ESNext",
-            moduleResolution: "bundler",
-            noFallthroughCasesInSwitch: true,
-            noImplicitAny: true,
-            noImplicitOverride: true,
-            noImplicitReturns: true,
-            noUncheckedIndexedAccess: true,
-            noUncheckedSideEffectImports: true,
-            noUnusedLocals: false,
-            noUnusedParameters: true,
-            resolveJsonModule: true,
-            skipLibCheck: true,
-            strict: true,
-            stripInternal: true,
-            target: "ESNext",
-            verbatimModuleSyntax: true,
-            outDir: "./dist",
-            rootDir: "./src",
-        },
-        include: ["src/**/*"],
-        exclude: ["node_modules", "dist"],
-    };
-    await writeFile(join(guiDir, "tsconfig.json"), JSON.stringify(guiTsConfig, null, 2));
-    // 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",
-        type: "module",
-        private: true,
-        scripts: {
-            dev: "vite",
-            build: "vite build",
-            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",
-            "@radix-ui/react-select": "^2.2.6",
-            "@radix-ui/react-slot": "^1.2.4",
-            "@radix-ui/react-tabs": "^1.1.13",
-            "class-variance-authority": "^0.7.1",
-            clsx: "^2.1.1",
-            "lucide-react": "^0.552.0",
-            react: "^19.2.0",
-            "react-dom": "^19.2.0",
-            "react-markdown": "^10.1.0",
-            "remark-gfm": "^4.0.1",
-            "tailwind-merge": "^3.3.1",
-            zod: "^4.1.12",
-            zustand: "^5.0.8",
-        },
-        devDependencies: {
-            "@tailwindcss/postcss": "^4.1.17",
-            "@types/react": "^19.2.2",
-            "@types/react-dom": "^19.2.2",
-            "@vitejs/plugin-react": "^5.1.0",
-            autoprefixer: "^10.4.21",
-            postcss: "^8.5.6",
-            tailwindcss: "^4.1.17",
-            typescript: "^5.9.3",
-            vite: "^7.2.1",
-        },
-    };
-    await writeFile(join(guiDir, "package.json"), JSON.stringify(packageJson, null, 2));
+    // Fix the @source path in index.css to point to the correct node_modules location
+    // In agent projects, node_modules is at the project root (4 levels up from gui/src/)
+    const indexCssPath = join(guiDir, "src", "index.css");
+    const indexCssContent = await readFile(indexCssPath, "utf-8");
+    const updatedContent = indexCssContent.replace('@source "../node_modules/@townco/ui/dist/**/*.{js,d.ts}";', '@source "../../../../node_modules/@townco/ui/dist/**/*.{js,d.ts}";');
+    await writeFile(indexCssPath, updatedContent, "utf-8");
 }