@townco/agent 0.1.9 → 0.1.12

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

@@ -3,7 +3,10 @@ import { z } from "zod";
 export declare const zAgentRunnerParams: z.ZodObject<{
     systemPrompt: z.ZodNullable<z.ZodString>;
     model: z.ZodString;
-    tools: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodLiteral<"todo_write">, z.ZodLiteral<"get_weather">, z.ZodLiteral<"web_search">]>>>;
+    tools: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodLiteral<"todo_write">, z.ZodLiteral<"get_weather">, z.ZodLiteral<"web_search">]>, z.ZodObject<{
+        type: z.ZodLiteral<"custom">;
+        modulePath: z.ZodString;
+    }, z.core.$strip>]>>>;
     mcps: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
         name: z.ZodString;
         transport: z.ZodLiteral<"stdio">;

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,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.d.ts

@@ -1,26 +1,15 @@
-import type {
-	PromptResponse,
-	SessionNotification,
-} from "@agentclientprotocol/sdk";
+import type { PromptResponse, SessionNotification } from "@agentclientprotocol/sdk";
 import { type DynamicStructuredTool, type Tool } from "langchain";
-import type {
-	AgentRunner,
-	CreateAgentRunnerParams,
-	InvokeRequest,
-} from "../agent-runner";
-import type { ToolType } from "../tools";
+import type { AgentRunner, CreateAgentRunnerParams, InvokeRequest } from "../agent-runner";
+import type { BuiltInToolType } from "../tools";
 type LangchainTool = DynamicStructuredTool | Tool;
 /** Lazily-loaded langchain tools */
 type LazyLangchainTool = MakeLazy<LangchainTool>;
 type MakeLazy<T> = T extends LangchainTool ? () => T : never;
-export declare const TOOL_REGISTRY: Record<
-	ToolType,
-	LangchainTool | LazyLangchainTool
->;
+export declare const TOOL_REGISTRY: Record<BuiltInToolType, LangchainTool | LazyLangchainTool>;
 export declare class LangchainAgent implements AgentRunner {
-	definition: CreateAgentRunnerParams;
-	constructor(params: CreateAgentRunnerParams);
-	invoke(
-		req: InvokeRequest,
-	): AsyncGenerator<SessionNotification["update"], PromptResponse, undefined>;
+    definition: CreateAgentRunnerParams;
+    constructor(params: CreateAgentRunnerParams);
+    invoke(req: InvokeRequest): AsyncGenerator<SessionNotification["update"], PromptResponse, undefined>;
 }
+export {};

package/dist/runner/langchain/index.js

@@ -1,6 +1,7 @@
 import { MultiServerMCPClient } from "@langchain/mcp-adapters";
 import { AIMessageChunk, createAgent, ToolMessage, tool, } from "langchain";
 import { z } from "zod";
+import { loadCustomToolModule } from "../tool-loader";
 import { todoItemSchema, todoWrite } from "./tools/todo";
 import { makeWebSearchTool } from "./tools/web_search";
 const getWeather = tool(({ city }) => `It's always sunny in ${city}!`, {
@@ -15,6 +16,27 @@ export const TOOL_REGISTRY = {
     get_weather: getWeather,
     web_search: makeWebSearchTool,
 };
+// ============================================================================
+// Custom tool loading
+// ============================================================================
+function toLangchainTool(resolved) {
+    return tool(resolved.fn, {
+        name: resolved.name,
+        description: resolved.description,
+        schema: resolved.schema,
+    });
+}
+async function loadCustomTool(modulePath) {
+    const resolved = await loadCustomToolModule(modulePath);
+    return toLangchainTool(resolved);
+}
+async function loadCustomTools(modulePaths) {
+    const tools = [];
+    for (const modulePath of modulePaths) {
+        tools.push(await loadCustomTool(modulePath));
+    }
+    return tools;
+}
 export class LangchainAgent {
     definition;
     constructor(params) {
@@ -23,13 +45,40 @@ export class LangchainAgent {
     async *invoke(req) {
         // Track todo_write tool call IDs to suppress their tool_call notifications
         const todoWriteToolCallIds = new Set();
-        const enabledTools = (this.definition.tools ?? []).map((name) => {
-            const tool = TOOL_REGISTRY[name];
-            if (typeof tool === "function") {
-                return tool();
+        // --------------------------------------------------------------------------
+        // Resolve tools: built-ins (string) + custom ({ type: "custom", modulePath })
+        // --------------------------------------------------------------------------
+        const enabledTools = [];
+        const toolDefs = this.definition.tools ?? [];
+        const builtInNames = [];
+        const customToolPaths = [];
+        for (const t of toolDefs) {
+            if (typeof t === "string") {
+                builtInNames.push(t);
             }
-            return tool;
-        });
+            else if (t &&
+                typeof t === "object" &&
+                "type" in t &&
+                t.type === "custom" &&
+                "modulePath" in t &&
+                typeof t.modulePath === "string") {
+                customToolPaths.push(t.modulePath);
+            }
+        }
+        // Built-in tools from registry
+        for (const name of builtInNames) {
+            const entry = TOOL_REGISTRY[name];
+            if (!entry) {
+                throw new Error(`Unknown built-in tool "${name}"`);
+            }
+            enabledTools.push(typeof entry === "function" ? entry() : entry);
+        }
+        // Custom tools loaded from modulePaths
+        if (customToolPaths.length > 0) {
+            const customTools = await loadCustomTools(customToolPaths);
+            enabledTools.push(...customTools);
+        }
+        // MCP tools
         if ((this.definition.mcps?.length ?? 0) > 0) {
             enabledTools.push(...(await makeMcpToolsClient(this.definition.mcps).getTools()));
         }

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/todo.js

@@ -1,18 +1,16 @@
 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
@@ -73,8 +71,7 @@ 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,26 +1,23 @@
 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/runner/tool-loader.d.ts

@@ -0,0 +1,14 @@
+import { z } from "zod";
+export type CustomToolModule = {
+    default: (input: unknown) => unknown | Promise<unknown>;
+    schema: z.ZodTypeAny | ((z: typeof import("zod").z) => z.ZodTypeAny);
+    name: string;
+    description: string;
+};
+export type ResolvedCustomTool = {
+    fn: (input: unknown) => unknown | Promise<unknown>;
+    schema: z.ZodTypeAny;
+    name: string;
+    description: string;
+};
+export declare function loadCustomToolModule(modulePath: string): Promise<ResolvedCustomTool>;

package/dist/runner/tool-loader.js

@@ -0,0 +1,42 @@
+import { pathToFileURL } from "node:url";
+import { z } from "zod";
+// Cache for resolved custom tools (keyed by modulePath)
+const customToolCache = new Map();
+export async function loadCustomToolModule(modulePath) {
+    // Check cache first
+    const cached = customToolCache.get(modulePath);
+    if (cached != null) {
+        return cached;
+    }
+    const moduleUrl = pathToFileURL(modulePath).href;
+    let mod;
+    try {
+        mod = (await import(moduleUrl));
+    }
+    catch (error) {
+        throw new Error(`Failed to import custom tool from ${modulePath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (typeof mod.default !== "function") {
+        throw new Error(`Custom tool module "${modulePath}" must export a default function.`);
+    }
+    if (!mod.schema) {
+        throw new Error(`Custom tool module "${modulePath}" must export a "schema" (zod schema).`);
+    }
+    if (!mod.name) {
+        throw new Error(`Custom tool module "${modulePath}" must export a "name" string.`);
+    }
+    if (!mod.description) {
+        throw new Error(`Custom tool module "${modulePath}" must export a "description" string.`);
+    }
+    // Resolve schema: if it's a function, call it with z injected
+    const resolvedSchema = typeof mod.schema === "function" ? mod.schema(z) : mod.schema;
+    const resolved = {
+        fn: mod.default,
+        schema: resolvedSchema,
+        name: mod.name,
+        description: mod.description,
+    };
+    // Cache the resolved tool
+    customToolCache.set(modulePath, resolved);
+    return resolved;
+}

package/dist/runner/tools.d.ts

@@ -1,9 +1,10 @@
 import { z } from "zod";
-export declare const zToolType: z.ZodUnion<
-	readonly [
-		z.ZodLiteral<"todo_write">,
-		z.ZodLiteral<"get_weather">,
-		z.ZodLiteral<"web_search">,
-	]
->;
+/** Built-in tool types. */
+export declare const zBuiltInToolType: z.ZodUnion<readonly [z.ZodLiteral<"todo_write">, z.ZodLiteral<"get_weather">, z.ZodLiteral<"web_search">]>;
+/** 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.ZodObject<{
+    type: z.ZodLiteral<"custom">;
+    modulePath: z.ZodString;
+}, z.core.$strip>]>;
 export type ToolType = z.infer<typeof zToolType>;
+export type BuiltInToolType = z.infer<typeof zBuiltInToolType>;

package/dist/runner/tools.js

@@ -1,6 +1,14 @@
 import { z } from "zod";
-export const zToolType = z.union([
-	z.literal("todo_write"),
-	z.literal("get_weather"),
-	z.literal("web_search"),
+/** Built-in tool types. */
+export const zBuiltInToolType = z.union([
+    z.literal("todo_write"),
+    z.literal("get_weather"),
+    z.literal("web_search"),
 ]);
+/** Custom tool schema. */
+const zCustomTool = z.object({
+    type: z.literal("custom"),
+    modulePath: z.string(),
+});
+/** Tool type - can be a built-in tool string or custom tool object. */
+export const zToolType = z.union([zBuiltInToolType, zCustomTool]);

package/dist/scaffold/bundle.d.ts

@@ -1,4 +1,4 @@
 /**
- * Copy necessary files from @town/agent to the agent directory
+ * Copy necessary files from @townco/agent to the agent directory
  */
 export declare function bundleAgentDependencies(agentPath: string): Promise<void>;

package/dist/scaffold/bundle.js

@@ -10,7 +10,7 @@ function getAgentPackageDir() {
     return join(dirname(currentFile), "..");
 }
 /**
- * Copy necessary files from @town/agent to the agent directory
+ * Copy necessary files from @townco/agent to the agent directory
  */
 export async function bundleAgentDependencies(agentPath) {
     const sourceDir = getAgentPackageDir();

package/dist/scaffold/copy-gui.js

@@ -83,7 +83,7 @@ export default defineConfig({
 	plugins: [react()],
 	resolve: {
 		alias: {
-			"@town/ui": resolve(__dirname, "./ui/src"),
+			"@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"),

package/dist/scaffold/index.d.ts

@@ -1,18 +1,16 @@
 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>;