@townco/agent 0.1.18 → 0.1.20

package/dist/acp-server/http.js

@@ -5,184 +5,200 @@ import { Hono } from "hono";
 import { cors } from "hono/cors";
 import { streamSSE } from "hono/streaming";
 import { makeRunnerFromDefinition } from "../runner";
+import { createLogger } from "../utils/logger.js";
 import { AgentAcpAdapter } from "./adapter";
-
+const logger = createLogger("agent");
 // 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) {
+                    logger.error("Invalid agent message", {
+                        issues: parseResult.error.issues,
+                    });
+                    continue;
+                }
+                //const msg = parseResult.data;
+                if (rawMsg == null || typeof rawMsg !== "object") {
+                    logger.warn("Malformed message, cannot route", { message: 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 {
+                    logger.warn("Message without sessionId, cannot route", {
+                        message: 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) {
+            logger.warn("GET /events - Missing X-Session-ID header");
+            return c.json({ error: "X-Session-ID header required" }, 401);
+        }
+        logger.debug("GET /events - SSE connection opened", { sessionId });
+        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);
+                logger.trace("Sending SSE message", { sessionId, channel });
+                await stream.writeSSE({
+                    event: "message",
+                    data: JSON.stringify(json),
+                });
+            });
+            // Clean up when the client disconnects
+            stream.onAbort(() => {
+                logger.debug("GET /events - SSE connection closed", { sessionId });
+                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) {
+            logger.warn("POST /rpc - Invalid ACP message", {
+                issues: parseResult.error.issues,
+            });
+            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;
+        const method = "method" in body ? body.method : "notification";
+        logger.debug("POST /rpc - Received request", { method, id, isRequest });
+        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]);
+                logger.debug("POST /rpc - Response received", { id });
+                return c.json(response);
+            }
+            catch (error) {
+                logger.error("POST /rpc - Request timeout", {
+                    id,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                throw error;
+            }
+            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();
+            logger.debug("POST /rpc - Notification sent", { method });
+            return c.json({
+                success: true,
+                message: "Notification sent to agent",
+            });
+        }
+    });
+    const port = Number.parseInt(process.env.PORT || "3100", 10);
+    logger.info("Starting HTTP server", { port });
+    Bun.serve({
+        fetch: app.fetch,
+        port,
+    });
+    logger.info("HTTP server listening", {
+        url: `http://localhost:${port}`,
+        port,
+    });
 }

package/dist/definition/index.d.ts

@@ -19,6 +19,9 @@ export declare const AgentDefinitionSchema: z.ZodObject<{
     tools: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
         type: z.ZodLiteral<"custom">;
         modulePath: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"filesystem">;
+        working_directory: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>]>>>;
     mcps: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
         name: z.ZodString;

package/dist/definition/index.js

@@ -29,8 +29,18 @@ const CustomToolSchema = z.object({
     type: z.literal("custom"),
     modulePath: z.string(),
 });
+/** Filesystem tool configuration schema. */
+const FilesystemToolSchema = z.object({
+    type: z.literal("filesystem"),
+    /** If omitted, defaults to process.cwd() at runtime */
+    working_directory: z.string().optional(),
+});
 /** Tool schema - can be a string (built-in tool) or custom tool object. */
-const ToolSchema = z.union([z.string(), CustomToolSchema]);
+const ToolSchema = z.union([
+    z.string(),
+    CustomToolSchema,
+    FilesystemToolSchema,
+]);
 /** Agent definition schema. */
 export const AgentDefinitionSchema = z.object({
     systemPrompt: z.string().nullable(),

package/dist/dev-agent/index.d.ts

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

package/dist/dev-agent/index.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env bun
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { makeHttpTransport, makeStdioTransport } from "../acp-server/index";
+// Load agent definition from JSON file
+const configPath = join(import.meta.dir, "agent.json");
+const agent = JSON.parse(readFileSync(configPath, "utf-8"));
+const transport = process.argv[2] || "stdio";
+if (transport === "http") {
+    makeHttpTransport(agent);
+}
+else if (transport === "stdio") {
+    makeStdioTransport(agent);
+}
+else {
+    console.error(`Invalid transport: ${transport}`);
+    process.exit(1);
+}

package/dist/index.js

@@ -1,19 +1,25 @@
 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",
+        { 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") {
-	makeHttpTransport(exampleAgent);
-} else if (transport === "stdio") {
-	makeStdioTransport(exampleAgent);
-} else {
-	console.error(`Invalid transport: ${transport}`);
-	console.error("Usage: bun run index.ts [stdio|http]");
-	process.exit(1);
+    makeHttpTransport(exampleAgent);
+}
+else if (transport === "stdio") {
+    makeStdioTransport(exampleAgent);
+}
+else {
+    console.error(`Invalid transport: ${transport}`);
+    console.error("Usage: bun run index.ts [stdio|http]");
+    process.exit(1);
 }

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

@@ -3,9 +3,12 @@ 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.ZodUnion<readonly [z.ZodLiteral<"todo_write">, z.ZodLiteral<"get_weather">, z.ZodLiteral<"web_search">]>, z.ZodObject<{
+    tools: z.ZodOptional<z.ZodArray<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">;
         modulePath: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"filesystem">;
+        working_directory: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>]>>>;
     mcps: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
         name: z.ZodString;

package/dist/runner/langchain/index.d.ts

@@ -5,8 +5,9 @@ import type { BuiltInToolType } from "../tools";
 type LangchainTool = DynamicStructuredTool | Tool;
 /** Lazily-loaded langchain tools */
 type LazyLangchainTool = MakeLazy<LangchainTool>;
+type LazyLangchainTools = () => readonly LangchainTool[];
 type MakeLazy<T> = T extends LangchainTool ? () => T : never;
-export declare const TOOL_REGISTRY: Record<BuiltInToolType, LangchainTool | LazyLangchainTool>;
+export declare const TOOL_REGISTRY: Record<BuiltInToolType, LangchainTool | LazyLangchainTool | LazyLangchainTools>;
 export declare class LangchainAgent implements AgentRunner {
     definition: CreateAgentRunnerParams;
     constructor(params: CreateAgentRunnerParams);

package/dist/runner/langchain/index.js

@@ -2,6 +2,7 @@ import { MultiServerMCPClient } from "@langchain/mcp-adapters";
 import { AIMessageChunk, createAgent, ToolMessage, tool, } from "langchain";
 import { z } from "zod";
 import { loadCustomToolModule } from "../tool-loader";
+import { makeFilesystemTools } from "./tools/filesystem";
 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,7 @@ export const TOOL_REGISTRY = {
     todo_write: todoWrite,
     get_weather: getWeather,
     web_search: makeWebSearchTool,
+    filesystem: () => makeFilesystemTools(process.cwd()),
 };
 // ============================================================================
 // Custom tool loading
@@ -47,6 +49,7 @@ export class LangchainAgent {
         const todoWriteToolCallIds = new Set();
         // --------------------------------------------------------------------------
         // Resolve tools: built-ins (string) + custom ({ type: "custom", modulePath })
+        // + filesystem ({ type: "filesystem", working_directory? })
         // --------------------------------------------------------------------------
         const enabledTools = [];
         const toolDefs = this.definition.tools ?? [];
@@ -56,13 +59,18 @@ export class LangchainAgent {
             if (typeof t === "string") {
                 builtInNames.push(t);
             }
-            else if (t &&
-                typeof t === "object" &&
-                "type" in t &&
-                t.type === "custom" &&
-                "modulePath" in t &&
-                typeof t.modulePath === "string") {
-                customToolPaths.push(t.modulePath);
+            else if (t && typeof t === "object" && "type" in t) {
+                const type = t.type;
+                if (type === "custom" &&
+                    "modulePath" in t &&
+                    typeof t.modulePath === "string") {
+                    customToolPaths.push(t.modulePath);
+                }
+                else if (type === "filesystem") {
+                    const wd = t.working_directory ??
+                        process.cwd();
+                    enabledTools.push(...makeFilesystemTools(wd));
+                }
             }
         }
         // Built-in tools from registry
@@ -71,7 +79,18 @@ export class LangchainAgent {
             if (!entry) {
                 throw new Error(`Unknown built-in tool "${name}"`);
             }
-            enabledTools.push(typeof entry === "function" ? entry() : entry);
+            if (typeof entry === "function") {
+                const result = entry();
+                if (Array.isArray(result)) {
+                    enabledTools.push(...result);
+                }
+                else {
+                    enabledTools.push(result);
+                }
+            }
+            else {
+                enabledTools.push(entry);
+            }
         }
         // Custom tools loaded from modulePaths
         if (customToolPaths.length > 0) {

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

@@ -0,0 +1,66 @@
+import { z } from "zod";
+export declare function makeFilesystemTools(workingDirectory: string): readonly [import("langchain").DynamicStructuredTool<z.ZodObject<{
+    pattern: z.ZodString;
+    path: z.ZodOptional<z.ZodString>;
+    glob: z.ZodOptional<z.ZodString>;
+    output_mode: z.ZodOptional<z.ZodEnum<{
+        content: "content";
+        files_with_matches: "files_with_matches";
+        count: "count";
+    }>>;
+    "-B": z.ZodOptional<z.ZodNumber>;
+    "-A": z.ZodOptional<z.ZodNumber>;
+    "-C": z.ZodOptional<z.ZodNumber>;
+    "-n": z.ZodOptional<z.ZodBoolean>;
+    "-i": z.ZodOptional<z.ZodBoolean>;
+    type: z.ZodOptional<z.ZodString>;
+    head_limit: z.ZodOptional<z.ZodNumber>;
+    multiline: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, {
+    pattern: string;
+    path?: string | undefined;
+    glob?: string | undefined;
+    output_mode?: "content" | "files_with_matches" | "count" | undefined;
+    "-B"?: number | undefined;
+    "-A"?: number | undefined;
+    "-C"?: number | undefined;
+    "-n"?: boolean | undefined;
+    "-i"?: boolean | undefined;
+    type?: string | undefined;
+    head_limit?: number | undefined;
+    multiline?: boolean | undefined;
+}, {
+    pattern: string;
+    path?: string | undefined;
+    glob?: string | undefined;
+    output_mode?: "content" | "files_with_matches" | "count" | undefined;
+    "-B"?: number | undefined;
+    "-A"?: number | undefined;
+    "-C"?: number | undefined;
+    "-n"?: boolean | undefined;
+    "-i"?: boolean | undefined;
+    type?: string | undefined;
+    head_limit?: number | undefined;
+    multiline?: boolean | undefined;
+}, unknown>, import("langchain").DynamicStructuredTool<z.ZodObject<{
+    file_path: z.ZodString;
+    offset: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, {
+    file_path: string;
+    offset?: number | undefined;
+    limit?: number | undefined;
+}, {
+    file_path: string;
+    offset?: number | undefined;
+    limit?: number | undefined;
+}, unknown>, import("langchain").DynamicStructuredTool<z.ZodObject<{
+    file_path: z.ZodString;
+    content: z.ZodString;
+}, z.core.$strip>, {
+    file_path: string;
+    content: string;
+}, {
+    file_path: string;
+    content: string;
+}, unknown>];