@townco/agent 0.1.0

package/README.md

@@ -0,0 +1,15 @@
+# town-agent
+
+To install dependencies:
+
+```bash
+bun install
+```
+
+To run:
+
+```bash
+bun run index.ts
+```
+
+This project was created using `bun init` in bun v1.3.1. [Bun](https://bun.com) is a fast all-in-one JavaScript runtime.

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

@@ -0,0 +1,15 @@
+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>;
+}

package/dist/acp-server/adapter.js

@@ -0,0 +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();
+    }
+}

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

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

package/dist/acp-server/cli.js

@@ -0,0 +1,11 @@
+import { Readable, Writable } from "node:stream";
+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);
+}

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

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

package/dist/acp-server/http.js

@@ -0,0 +1,178 @@
+import { createHash } from "node:crypto";
+import * as acp from "@agentclientprotocol/sdk";
+import { PGlite } from "@electric-sql/pglite";
+import { Hono } from "hono";
+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}`;
+}
+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}`);
+}

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

@@ -0,0 +1,2 @@
+export { makeStdioTransport } from "./cli";
+export { makeHttpTransport } from "./http";

package/dist/acp-server/index.js

@@ -0,0 +1,2 @@
+export { makeStdioTransport } from "./cli";
+export { makeHttpTransport } from "./http";

package/dist/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+import "./acp-server/index";

package/dist/bin.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env bun
+// Simple executable wrapper for the ACP agent
+import "./acp-server/index";

package/dist/definition/index.d.ts

@@ -0,0 +1,30 @@
+import { z } from "zod";
+export type AgentDefinition = z.infer<typeof AgentDefinitionSchema>;
+/** MCP configuration types. */
+export declare const McpConfigSchema: z.ZodUnion<readonly [z.ZodObject<{
+    name: z.ZodString;
+    transport: z.ZodLiteral<"stdio">;
+    command: z.ZodString;
+    args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, z.ZodObject<{
+    name: z.ZodString;
+    transport: z.ZodLiteral<"http">;
+    url: z.ZodString;
+}, z.core.$strip>]>;
+/** Agent definition schema. */
+export declare const AgentDefinitionSchema: z.ZodObject<{
+    systemPrompt: z.ZodNullable<z.ZodString>;
+    model: z.ZodString;
+    tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    mcps: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        name: z.ZodString;
+        transport: z.ZodLiteral<"stdio">;
+        command: z.ZodString;
+        args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>, z.ZodObject<{
+        name: z.ZodString;
+        transport: z.ZodLiteral<"http">;
+        url: z.ZodString;
+    }, z.core.$strip>]>>>;
+    harnessImplementation: z.ZodOptional<z.ZodLiteral<"langchain">>;
+}, z.core.$strip>;

package/dist/definition/index.js

@@ -0,0 +1,33 @@
+import { z } from "zod";
+const McpBaseConfigSchema = z.object({
+    name: z.string(),
+});
+/**
+ * Configuration for a stdio-transport MCP.
+ *
+ * This is only part of `StdioServerParameters` from
+ * @modelcontextprotocol/sdk/client/stdio.js.
+ */
+const McpStdioConfigSchema = McpBaseConfigSchema.extend({
+    transport: z.literal("stdio"),
+    command: z.string(),
+    args: z.array(z.string()).optional(),
+});
+/** Configuration for an Streaming HTTP MCP. */
+const McpStreamableHttpConfigSchema = McpBaseConfigSchema.extend({
+    transport: z.literal("http"),
+    url: z.string(),
+});
+/** MCP configuration types. */
+export const McpConfigSchema = z.union([
+    McpStdioConfigSchema,
+    McpStreamableHttpConfigSchema,
+]);
+/** Agent definition schema. */
+export const AgentDefinitionSchema = z.object({
+    systemPrompt: z.string().nullable(),
+    model: z.string(),
+    tools: z.array(z.string()).optional(),
+    mcps: z.array(McpConfigSchema).optional(),
+    harnessImplementation: z.literal("langchain").optional(),
+});

package/dist/definition/mcp.js

@@ -0,0 +1 @@
+"use strict";

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

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

package/dist/definition/tools/todo.js

@@ -0,0 +1,77 @@
+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,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;
+}

package/dist/example.d.ts

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

package/dist/example.js

@@ -0,0 +1,20 @@
+#!/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.d.ts

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

package/dist/index.js

@@ -0,0 +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: [],
+};
+// 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);
+}

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

@@ -0,0 +1,24 @@
+import type { PromptRequest, PromptResponse, SessionNotification } from "@agentclientprotocol/sdk";
+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">]>>>;
+    mcps: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        name: z.ZodString;
+        transport: z.ZodLiteral<"stdio">;
+        command: z.ZodString;
+        args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>, z.ZodObject<{
+        name: z.ZodString;
+        transport: z.ZodLiteral<"http">;
+        url: z.ZodString;
+    }, z.core.$strip>]>>>;
+}, z.core.$strip>;
+export type CreateAgentRunnerParams = z.infer<typeof zAgentRunnerParams>;
+export type InvokeRequest = Omit<PromptRequest, "_meta">;
+/** Describes an object that can run an agent definition */
+export interface AgentRunner {
+    definition: CreateAgentRunnerParams;
+    invoke(req: InvokeRequest): AsyncGenerator<SessionNotification["update"], PromptResponse, undefined>;
+}

package/dist/runner/agent-runner.js

@@ -0,0 +1,9 @@
+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(),
+});

package/dist/runner/index.d.ts

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

package/dist/runner/index.js

@@ -0,0 +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}`);
+        }
+    }
+};