@townco/agent 0.1.9 → 0.1.12

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

@@ -1,77 +1,76 @@
 import * as acp from "@agentclientprotocol/sdk";
 /** Adapts an Agent to speak the ACP protocol */
 export class AgentAcpAdapter {
-	connection;
-	sessions;
-	agent;
-	constructor(agent, connection) {
-		this.connection = connection;
-		this.sessions = new Map();
-		this.agent = agent;
-	}
-	async initialize(_params) {
-		return {
-			protocolVersion: acp.PROTOCOL_VERSION,
-			agentCapabilities: {
-				loadSession: false,
-			},
-		};
-	}
-	async newSession(_params) {
-		const sessionId = Math.random().toString(36).substring(2);
-		this.sessions.set(sessionId, {
-			pendingPrompt: null,
-			messages: [],
-		});
-		return {
-			sessionId,
-		};
-	}
-	async authenticate(_params) {
-		// No auth needed - return empty response
-		return {};
-	}
-	async setSessionMode(_params) {
-		// Session mode changes are no-op for us (not related to coding)
-		return {};
-	}
-	async prompt(params) {
-		let session = this.sessions.get(params.sessionId);
-		// If session not found (e.g., after server restart), create a new one
-		if (!session) {
-			console.log(
-				`Session ${params.sessionId} not found, creating new session`,
-			);
-			session = {
-				pendingPrompt: null,
-				messages: [],
-			};
-			this.sessions.set(params.sessionId, session);
-		}
-		session.pendingPrompt?.abort();
-		session.pendingPrompt = new AbortController();
-		try {
-			for await (const msg of this.agent.invoke({
-				prompt: params.prompt,
-				sessionId: params.sessionId,
-			})) {
-				this.connection.sessionUpdate({
-					sessionId: params.sessionId,
-					update: msg,
-				});
-			}
-		} catch (err) {
-			if (session.pendingPrompt.signal.aborted) {
-				return { stopReason: "cancelled" };
-			}
-			throw err;
-		}
-		session.pendingPrompt = null;
-		return {
-			stopReason: "end_turn",
-		};
-	}
-	async cancel(params) {
-		this.sessions.get(params.sessionId)?.pendingPrompt?.abort();
-	}
+    connection;
+    sessions;
+    agent;
+    constructor(agent, connection) {
+        this.connection = connection;
+        this.sessions = new Map();
+        this.agent = agent;
+    }
+    async initialize(_params) {
+        return {
+            protocolVersion: acp.PROTOCOL_VERSION,
+            agentCapabilities: {
+                loadSession: false,
+            },
+        };
+    }
+    async newSession(_params) {
+        const sessionId = Math.random().toString(36).substring(2);
+        this.sessions.set(sessionId, {
+            pendingPrompt: null,
+            messages: [],
+        });
+        return {
+            sessionId,
+        };
+    }
+    async authenticate(_params) {
+        // No auth needed - return empty response
+        return {};
+    }
+    async setSessionMode(_params) {
+        // Session mode changes are no-op for us (not related to coding)
+        return {};
+    }
+    async prompt(params) {
+        let session = this.sessions.get(params.sessionId);
+        // If session not found (e.g., after server restart), create a new one
+        if (!session) {
+            console.log(`Session ${params.sessionId} not found, creating new session`);
+            session = {
+                pendingPrompt: null,
+                messages: [],
+            };
+            this.sessions.set(params.sessionId, session);
+        }
+        session.pendingPrompt?.abort();
+        session.pendingPrompt = new AbortController();
+        try {
+            for await (const msg of this.agent.invoke({
+                prompt: params.prompt,
+                sessionId: params.sessionId,
+            })) {
+                this.connection.sessionUpdate({
+                    sessionId: params.sessionId,
+                    update: msg,
+                });
+            }
+        }
+        catch (err) {
+            if (session.pendingPrompt.signal.aborted) {
+                return { stopReason: "cancelled" };
+            }
+            throw err;
+        }
+        session.pendingPrompt = null;
+        return {
+            stopReason: "end_turn",
+        };
+    }
+    async cancel(params) {
+        this.sessions.get(params.sessionId)?.pendingPrompt?.abort();
+    }
 }

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

@@ -6,183 +6,173 @@ import { cors } from "hono/cors";
 import { streamSSE } from "hono/streaming";
 import { makeRunnerFromDefinition } from "../runner";
 import { AgentAcpAdapter } from "./adapter";
-
 // Use PGlite in-memory database for LISTEN/NOTIFY
 const pg = new PGlite();
 // Helper to create safe channel names from untrusted IDs
 function safeChannelName(prefix, id) {
-	const hash = createHash("sha256").update(id).digest("hex").slice(0, 16);
-	return `${prefix}_${hash}`;
+    const hash = createHash("sha256").update(id).digest("hex").slice(0, 16);
+    return `${prefix}_${hash}`;
 }
 export function makeHttpTransport(agent) {
-	const inbound = new TransformStream();
-	const outbound = new TransformStream();
-	const bridge = acp.ndJsonStream(outbound.writable, inbound.readable);
-	const agentRunner =
-		"definition" in agent ? agent : makeRunnerFromDefinition(agent);
-	new acp.AgentSideConnection(
-		(conn) => new AgentAcpAdapter(agentRunner, conn),
-		bridge,
-	);
-	const app = new Hono();
-	const decoder = new TextDecoder();
-	const encoder = new TextEncoder();
-	(async () => {
-		const reader = outbound.readable.getReader();
-		let buf = "";
-		for (;;) {
-			const { value, done } = await reader.read();
-			if (done) break;
-			buf += decoder.decode(value, { stream: true });
-			for (let nl = buf.indexOf("\n"); nl !== -1; nl = buf.indexOf("\n")) {
-				const line = buf.slice(0, nl).trim();
-				buf = buf.slice(nl + 1);
-				if (!line) continue;
-				let rawMsg;
-				try {
-					rawMsg = JSON.parse(line);
-				} catch {
-					// ignore malformed lines
-					continue;
-				}
-				// Validate the agent message with Zod schema
-				const parseResult = acp.agentOutgoingMessageSchema.safeParse(rawMsg);
-				if (!parseResult.success) {
-					console.error("Invalid agent message:", parseResult.error.issues);
-					continue;
-				}
-				//const msg = parseResult.data;
-				if (rawMsg == null || typeof rawMsg !== "object") {
-					console.warn("Malformed message, cannot route:", rawMsg);
-					continue;
-				}
-				if (
-					"id" in rawMsg &&
-					typeof rawMsg.id === "string" &&
-					rawMsg.id != null
-				) {
-					// This is a response to a request - send to response-specific channel
-					const channel = safeChannelName("response", rawMsg.id);
-					const payload = JSON.stringify(rawMsg).replace(/'/g, "''");
-					await pg.query(`NOTIFY ${channel}, '${payload}'`);
-				} else if (
-					"params" in rawMsg &&
-					rawMsg.params != null &&
-					typeof rawMsg.params === "object" &&
-					"sessionId" in rawMsg.params &&
-					typeof rawMsg.params.sessionId === "string"
-				) {
-					// Other messages (notifications, requests from agent) go to
-					// session-specific channel
-					const sessionId = rawMsg.params.sessionId;
-					const channel = safeChannelName("notifications", sessionId);
-					const payload = JSON.stringify(rawMsg).replace(/'/g, "''");
-					await pg.query(`NOTIFY ${channel}, '${payload}'`);
-				} else {
-					console.warn("Message without sessionId, cannot route:", rawMsg);
-				}
-			}
-		}
-	})();
-	// TODO: fix this for production
-	app.use(
-		"*",
-		cors({
-			origin: "*",
-			allowHeaders: ["content-type", "authorization", "x-session-id"],
-			allowMethods: ["GET", "POST", "OPTIONS"],
-		}),
-	);
-	app.get("/health", (c) => c.json({ ok: true }));
-	app.get("/events", (c) => {
-		const sessionId = c.req.header("X-Session-ID");
-		if (!sessionId) {
-			return c.json({ error: "X-Session-ID header required" }, 401);
-		}
-		return streamSSE(c, async (stream) => {
-			await stream.writeSSE({ event: "ping", data: "{}" });
-			const hb = setInterval(() => {
-				// Heartbeat to keep proxies from terminating idle connections
-				void stream.writeSSE({ event: "ping", data: "{}" });
-			}, 1000);
-			const channel = safeChannelName("notifications", sessionId);
-			const unsub = await pg.listen(channel, async (payload) => {
-				const json = JSON.parse(payload);
-				await stream.writeSSE({
-					event: "message",
-					data: JSON.stringify(json),
-				});
-			});
-			// Clean up when the client disconnects
-			stream.onAbort(() => {
-				console.log("/events connection closed");
-				clearInterval(hb);
-				unsub();
-			});
-			// Keep the connection open indefinitely
-			await stream.sleep(1000 * 60 * 60 * 24);
-		});
-	});
-	app.post("/rpc", async (c) => {
-		// Get and validate the request body
-		const rawBody = await c.req.json();
-		// Validate using Zod schema
-		const parseResult = acp.clientOutgoingMessageSchema.safeParse(rawBody);
-		if (!parseResult.success) {
-			return c.json(
-				{
-					error: "Invalid ACP message",
-					details: parseResult.error.issues,
-				},
-				400,
-			);
-		}
-		const body = parseResult.data;
-		// Ensure the request has an id
-		const id = "id" in body ? body.id : null;
-		const isRequest = id != null;
-		if (isRequest) {
-			// For requests, set up a listener before sending the request
-			const responseChannel = safeChannelName("response", String(id));
-			let responseResolver;
-			const responsePromise = new Promise((resolve) => {
-				responseResolver = resolve;
-			});
-			const unsub = await pg.listen(responseChannel, (payload) => {
-				const rawResponse = JSON.parse(payload);
-				responseResolver(rawResponse);
-			});
-			// Write NDJSON line into the ACP inbound stream
-			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),
-			);
-			try {
-				const response = await Promise.race([responsePromise, timeoutPromise]);
-				return c.json(response);
-			} finally {
-				// Clean up the listener whether we got a response or timed out
-				unsub();
-			}
-		} else {
-			// For notifications, just send and return success
-			const writer = inbound.writable.getWriter();
-			await writer.write(encoder.encode(`${JSON.stringify(body)}\n`));
-			writer.releaseLock();
-			return c.json({
-				success: true,
-				message: "Notification sent to agent",
-			});
-		}
-	});
-	const port = Number.parseInt(process.env.PORT || "3100", 10);
-	console.log(`Starting HTTP server on port ${port}...`);
-	Bun.serve({
-		fetch: app.fetch,
-		port,
-	});
-	console.log(`HTTP server listening on http://localhost:${port}`);
+    const inbound = new TransformStream();
+    const outbound = new TransformStream();
+    const bridge = acp.ndJsonStream(outbound.writable, inbound.readable);
+    const agentRunner = "definition" in agent ? agent : makeRunnerFromDefinition(agent);
+    new acp.AgentSideConnection((conn) => new AgentAcpAdapter(agentRunner, conn), bridge);
+    const app = new Hono();
+    const decoder = new TextDecoder();
+    const encoder = new TextEncoder();
+    (async () => {
+        const reader = outbound.readable.getReader();
+        let buf = "";
+        for (;;) {
+            const { value, done } = await reader.read();
+            if (done)
+                break;
+            buf += decoder.decode(value, { stream: true });
+            for (let nl = buf.indexOf("\n"); nl !== -1; nl = buf.indexOf("\n")) {
+                const line = buf.slice(0, nl).trim();
+                buf = buf.slice(nl + 1);
+                if (!line)
+                    continue;
+                let rawMsg;
+                try {
+                    rawMsg = JSON.parse(line);
+                }
+                catch {
+                    // ignore malformed lines
+                    continue;
+                }
+                // Validate the agent message with Zod schema
+                const parseResult = acp.agentOutgoingMessageSchema.safeParse(rawMsg);
+                if (!parseResult.success) {
+                    console.error("Invalid agent message:", parseResult.error.issues);
+                    continue;
+                }
+                //const msg = parseResult.data;
+                if (rawMsg == null || typeof rawMsg !== "object") {
+                    console.warn("Malformed message, cannot route:", rawMsg);
+                    continue;
+                }
+                if ("id" in rawMsg &&
+                    typeof rawMsg.id === "string" &&
+                    rawMsg.id != null) {
+                    // This is a response to a request - send to response-specific channel
+                    const channel = safeChannelName("response", rawMsg.id);
+                    const payload = JSON.stringify(rawMsg).replace(/'/g, "''");
+                    await pg.query(`NOTIFY ${channel}, '${payload}'`);
+                }
+                else if ("params" in rawMsg &&
+                    rawMsg.params != null &&
+                    typeof rawMsg.params === "object" &&
+                    "sessionId" in rawMsg.params &&
+                    typeof rawMsg.params.sessionId === "string") {
+                    // Other messages (notifications, requests from agent) go to
+                    // session-specific channel
+                    const sessionId = rawMsg.params.sessionId;
+                    const channel = safeChannelName("notifications", sessionId);
+                    const payload = JSON.stringify(rawMsg).replace(/'/g, "''");
+                    await pg.query(`NOTIFY ${channel}, '${payload}'`);
+                }
+                else {
+                    console.warn("Message without sessionId, cannot route:", rawMsg);
+                }
+            }
+        }
+    })();
+    // TODO: fix this for production
+    app.use("*", cors({
+        origin: "*",
+        allowHeaders: ["content-type", "authorization", "x-session-id"],
+        allowMethods: ["GET", "POST", "OPTIONS"],
+    }));
+    app.get("/health", (c) => c.json({ ok: true }));
+    app.get("/events", (c) => {
+        const sessionId = c.req.header("X-Session-ID");
+        if (!sessionId) {
+            return c.json({ error: "X-Session-ID header required" }, 401);
+        }
+        return streamSSE(c, async (stream) => {
+            await stream.writeSSE({ event: "ping", data: "{}" });
+            const hb = setInterval(() => {
+                // Heartbeat to keep proxies from terminating idle connections
+                void stream.writeSSE({ event: "ping", data: "{}" });
+            }, 1000);
+            const channel = safeChannelName("notifications", sessionId);
+            const unsub = await pg.listen(channel, async (payload) => {
+                const json = JSON.parse(payload);
+                await stream.writeSSE({
+                    event: "message",
+                    data: JSON.stringify(json),
+                });
+            });
+            // Clean up when the client disconnects
+            stream.onAbort(() => {
+                console.log("/events connection closed");
+                clearInterval(hb);
+                unsub();
+            });
+            // Keep the connection open indefinitely
+            await stream.sleep(1000 * 60 * 60 * 24);
+        });
+    });
+    app.post("/rpc", async (c) => {
+        // Get and validate the request body
+        const rawBody = await c.req.json();
+        // Validate using Zod schema
+        const parseResult = acp.clientOutgoingMessageSchema.safeParse(rawBody);
+        if (!parseResult.success) {
+            return c.json({
+                error: "Invalid ACP message",
+                details: parseResult.error.issues,
+            }, 400);
+        }
+        const body = parseResult.data;
+        // Ensure the request has an id
+        const id = "id" in body ? body.id : null;
+        const isRequest = id != null;
+        if (isRequest) {
+            // For requests, set up a listener before sending the request
+            const responseChannel = safeChannelName("response", String(id));
+            let responseResolver;
+            const responsePromise = new Promise((resolve) => {
+                responseResolver = resolve;
+            });
+            const unsub = await pg.listen(responseChannel, (payload) => {
+                const rawResponse = JSON.parse(payload);
+                responseResolver(rawResponse);
+            });
+            // Write NDJSON line into the ACP inbound stream
+            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));
+            try {
+                const response = await Promise.race([responsePromise, timeoutPromise]);
+                return c.json(response);
+            }
+            finally {
+                // Clean up the listener whether we got a response or timed out
+                unsub();
+            }
+        }
+        else {
+            // For notifications, just send and return success
+            const writer = inbound.writable.getWriter();
+            await writer.write(encoder.encode(`${JSON.stringify(body)}\n`));
+            writer.releaseLock();
+            return c.json({
+                success: true,
+                message: "Notification sent to agent",
+            });
+        }
+    });
+    const port = Number.parseInt(process.env.PORT || "3100", 10);
+    console.log(`Starting HTTP server on port ${port}...`);
+    Bun.serve({
+        fetch: app.fetch,
+        port,
+    });
+    console.log(`HTTP server listening on http://localhost:${port}`);
 }

package/dist/definition/index.d.ts

@@ -16,7 +16,10 @@ export declare const McpConfigSchema: z.ZodUnion<readonly [z.ZodObject<{
 export declare const AgentDefinitionSchema: z.ZodObject<{
     systemPrompt: z.ZodNullable<z.ZodString>;
     model: z.ZodString;
-    tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    tools: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, 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/definition/index.js

@@ -24,11 +24,18 @@ export const McpConfigSchema = z.union([
     McpStdioConfigSchema,
     McpStreamableHttpConfigSchema,
 ]);
+/** Custom tool configuration schema. */
+const CustomToolSchema = z.object({
+    type: z.literal("custom"),
+    modulePath: z.string(),
+});
+/** Tool schema - can be a string (built-in tool) or custom tool object. */
+const ToolSchema = z.union([z.string(), CustomToolSchema]);
 /** Agent definition schema. */
 export const AgentDefinitionSchema = z.object({
     systemPrompt: z.string().nullable(),
     model: z.string(),
-    tools: z.array(z.string()).optional(),
+    tools: z.array(ToolSchema).optional(),
     mcps: z.array(McpConfigSchema).optional(),
     harnessImplementation: z.literal("langchain").optional(),
 });

package/dist/index.js

@@ -1,19 +1,20 @@
 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);
 }