@robota-sdk/agent-tools 3.0.0-beta.62 → 3.0.0-beta.64

package/dist/node/index.js

@@ -1,1785 +1,1640 @@
-import { readFile, readdir, stat, mkdir, writeFile, chmod, rename, rm } from 'fs/promises';
-import { join, posix, isAbsolute, resolve, dirname, basename } from 'path';
-import { ValidationError, ToolExecutionError, logger } from '@robota-sdk/agent-core';
-import { spawn } from 'child_process';
-import { z } from 'zod';
-import { randomBytes } from 'crypto';
-import fg from 'fast-glob';
-
-// src/sandbox/e2b-sandbox-client.ts
+import { chmod, mkdir, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import { basename, dirname, isAbsolute, join, posix, resolve } from "node:path";
+import { ToolExecutionError, ValidationError, logger } from "@robota-sdk/agent-core";
+import { spawn } from "node:child_process";
+import { z } from "zod";
+import { randomBytes } from "node:crypto";
+import fg from "fast-glob";
+//#region src/sandbox/e2b-sandbox-client.ts
 var E2BSandboxClient = class {
-  sandbox;
-  connectSandbox;
-  createSandboxFromSnapshot;
-  constructor(options) {
-    this.sandbox = options.sandbox;
-    this.connectSandbox = options.connectSandbox;
-    this.createSandboxFromSnapshot = options.createSandboxFromSnapshot;
-  }
-  async run(command, options) {
-    const result = await this.sandbox.commands.run(command, {
-      background: false,
-      timeoutMs: options?.timeoutMs,
-      cwd: options?.workingDirectory
-    });
-    return {
-      stdout: result.stdout ?? "",
-      stderr: result.stderr ?? "",
-      exitCode: result.exitCode ?? result.exit_code ?? 0
-    };
-  }
-  async readFile(path) {
-    const content = await this.sandbox.files.read(path);
-    return typeof content === "string" ? content : Buffer.from(content).toString("utf8");
-  }
-  async writeFile(path, content) {
-    await this.sandbox.files.write(path, content);
-  }
-  async snapshot() {
-    if (this.sandbox.createSnapshot) {
-      const snapshot = await this.sandbox.createSnapshot();
-      const snapshotId = snapshot.snapshotId ?? snapshot.id;
-      if (!snapshotId) {
-        throw new Error("E2B createSnapshot() did not return a snapshot id.");
-      }
-      return snapshotId;
-    }
-    const sandboxId = this.sandbox.sandboxId;
-    if (!sandboxId) {
-      throw new Error("E2B sandboxId is required to create a resumable sandbox snapshot.");
-    }
-    if (!this.sandbox.pause) {
-      throw new Error("E2B sandbox adapter does not expose pause().");
-    }
-    await this.sandbox.pause();
-    return sandboxId;
-  }
-  async restore(snapshotId) {
-    if (this.createSandboxFromSnapshot) {
-      this.sandbox = await this.createSandboxFromSnapshot(snapshotId);
-      return;
-    }
-    if (this.connectSandbox) {
-      this.sandbox = await this.connectSandbox(snapshotId);
-      return;
-    }
-    if (this.sandbox.sandboxId === snapshotId && this.sandbox.connect) {
-      this.sandbox = await this.sandbox.connect();
-      return;
-    }
-    throw new Error(
-      "E2B sandbox restore requires connectSandbox(snapshotId) or sandbox.connect()."
-    );
-  }
+	sandbox;
+	connectSandbox;
+	createSandboxFromSnapshot;
+	constructor(options) {
+		this.sandbox = options.sandbox;
+		this.connectSandbox = options.connectSandbox;
+		this.createSandboxFromSnapshot = options.createSandboxFromSnapshot;
+	}
+	async run(command, options) {
+		const result = await this.sandbox.commands.run(command, {
+			background: false,
+			timeoutMs: options?.timeoutMs,
+			cwd: options?.workingDirectory
+		});
+		return {
+			stdout: result.stdout ?? "",
+			stderr: result.stderr ?? "",
+			exitCode: result.exitCode ?? result.exit_code ?? 0
+		};
+	}
+	async readFile(path) {
+		const content = await this.sandbox.files.read(path);
+		return typeof content === "string" ? content : Buffer.from(content).toString("utf8");
+	}
+	async writeFile(path, content) {
+		await this.sandbox.files.write(path, content);
+	}
+	async snapshot() {
+		if (this.sandbox.createSnapshot) {
+			const snapshot = await this.sandbox.createSnapshot();
+			const snapshotId = snapshot.snapshotId ?? snapshot.id;
+			if (!snapshotId) throw new Error("E2B createSnapshot() did not return a snapshot id.");
+			return snapshotId;
+		}
+		const sandboxId = this.sandbox.sandboxId;
+		if (!sandboxId) throw new Error("E2B sandboxId is required to create a resumable sandbox snapshot.");
+		if (!this.sandbox.pause) throw new Error("E2B sandbox adapter does not expose pause().");
+		await this.sandbox.pause();
+		return sandboxId;
+	}
+	async restore(snapshotId) {
+		if (this.createSandboxFromSnapshot) {
+			this.sandbox = await this.createSandboxFromSnapshot(snapshotId);
+			return;
+		}
+		if (this.connectSandbox) {
+			this.sandbox = await this.connectSandbox(snapshotId);
+			return;
+		}
+		if (this.sandbox.sandboxId === snapshotId && this.sandbox.connect) {
+			this.sandbox = await this.sandbox.connect();
+			return;
+		}
+		throw new Error("E2B sandbox restore requires connectSandbox(snapshotId) or sandbox.connect().");
+	}
 };
-
-// src/sandbox/in-memory-sandbox-client.ts
+//#endregion
+//#region src/sandbox/in-memory-sandbox-client.ts
 var InMemorySandboxClient = class {
-  files = /* @__PURE__ */ new Map();
-  snapshots = /* @__PURE__ */ new Map();
-  runHandler;
-  snapshotSequence = 0;
-  constructor(options = {}) {
-    for (const [path, content] of Object.entries(options.files ?? {})) {
-      this.files.set(path, content);
-    }
-    this.runHandler = options.runHandler;
-  }
-  async run(command, options) {
-    if (this.runHandler) {
-      return this.runHandler(command, options, this.files);
-    }
-    return { stdout: "", stderr: "", exitCode: 0 };
-  }
-  async readFile(path) {
-    const content = this.files.get(path);
-    if (content === void 0) {
-      throw new Error(`Sandbox file not found: ${path}`);
-    }
-    return content;
-  }
-  async writeFile(path, content) {
-    this.files.set(path, content);
-  }
-  async snapshot() {
-    const snapshotId = `snapshot-${++this.snapshotSequence}`;
-    this.snapshots.set(snapshotId, new Map(this.files));
-    return snapshotId;
-  }
-  async restore(snapshotId) {
-    const snapshot = this.snapshots.get(snapshotId);
-    if (!snapshot) {
-      throw new Error(`Sandbox snapshot not found: ${snapshotId}`);
-    }
-    this.files.clear();
-    for (const [path, content] of snapshot.entries()) {
-      this.files.set(path, content);
-    }
-  }
-  getFile(path) {
-    return this.files.get(path);
-  }
+	files = /* @__PURE__ */ new Map();
+	snapshots = /* @__PURE__ */ new Map();
+	runHandler;
+	snapshotSequence = 0;
+	constructor(options = {}) {
+		for (const [path, content] of Object.entries(options.files ?? {})) this.files.set(path, content);
+		this.runHandler = options.runHandler;
+	}
+	async run(command, options) {
+		if (this.runHandler) return this.runHandler(command, options, this.files);
+		return {
+			stdout: "",
+			stderr: "",
+			exitCode: 0
+		};
+	}
+	async readFile(path) {
+		const content = this.files.get(path);
+		if (content === void 0) throw new Error(`Sandbox file not found: ${path}`);
+		return content;
+	}
+	async writeFile(path, content) {
+		this.files.set(path, content);
+	}
+	async snapshot() {
+		const snapshotId = `snapshot-${++this.snapshotSequence}`;
+		this.snapshots.set(snapshotId, new Map(this.files));
+		return snapshotId;
+	}
+	async restore(snapshotId) {
+		const snapshot = this.snapshots.get(snapshotId);
+		if (!snapshot) throw new Error(`Sandbox snapshot not found: ${snapshotId}`);
+		this.files.clear();
+		for (const [path, content] of snapshot.entries()) this.files.set(path, content);
+	}
+	getFile(path) {
+		return this.files.get(path);
+	}
 };
-var DEFAULT_TARGET_ROOT = "/workspace";
-var WINDOWS_ABSOLUTE_PATH_PATTERN = /^[A-Za-z]:[\\/]/;
-var SHELL_QUOTE_PATTERN = /'/g;
+//#endregion
+//#region src/sandbox/workspace-manifest.ts
+const DEFAULT_TARGET_ROOT = "/workspace";
+const WINDOWS_ABSOLUTE_PATH_PATTERN = /^[A-Za-z]:[\\/]/;
+const SHELL_QUOTE_PATTERN = /'/g;
 async function applyWorkspaceManifest(sandboxClient, manifest, options = {}) {
-  if (sandboxClient.applyManifest) {
-    return sandboxClient.applyManifest(manifest, options);
-  }
-  const targetRoot = normalizeSandboxRoot(options.targetRoot ?? DEFAULT_TARGET_ROOT);
-  const appliedEntries = [];
-  for (const [rawPath, entry] of Object.entries(manifest.entries)) {
-    const path = validateWorkspaceManifestPath(rawPath);
-    const targetPath = joinSandboxPath(targetRoot, path);
-    appliedEntries.push(
-      await applyManifestEntry(sandboxClient, path, targetPath, targetRoot, entry, options)
-    );
-  }
-  return { entries: appliedEntries };
+	if (sandboxClient.applyManifest) return sandboxClient.applyManifest(manifest, options);
+	const targetRoot = normalizeSandboxRoot(options.targetRoot ?? DEFAULT_TARGET_ROOT);
+	const appliedEntries = [];
+	for (const [rawPath, entry] of Object.entries(manifest.entries)) {
+		const path = validateWorkspaceManifestPath(rawPath);
+		const targetPath = joinSandboxPath(targetRoot, path);
+		appliedEntries.push(await applyManifestEntry(sandboxClient, path, targetPath, targetRoot, entry, options));
+	}
+	return { entries: appliedEntries };
 }
 function validateWorkspaceManifestPath(path) {
-  if (path.length === 0) {
-    throw new Error("workspace manifest path must not be empty");
-  }
-  if (path.includes("\0")) {
-    throw new Error("workspace manifest path must not contain NUL bytes");
-  }
-  if (path.startsWith("/") || path.startsWith("\\") || WINDOWS_ABSOLUTE_PATH_PATTERN.test(path)) {
-    throw new Error("workspace manifest path must be workspace-relative");
-  }
-  const parts = path.replace(/\\/g, "/").split("/").filter(Boolean);
-  if (parts.length === 0) {
-    throw new Error("workspace manifest path must not resolve to the workspace root");
-  }
-  if (parts.some((part) => part === "..")) {
-    throw new Error("workspace manifest path cannot contain traversal segments");
-  }
-  const normalizedParts = parts.filter((part) => part !== ".");
-  if (normalizedParts.length === 0) {
-    throw new Error("workspace manifest path must not resolve to the workspace root");
-  }
-  return normalizedParts.join("/");
+	if (path.length === 0) throw new Error("workspace manifest path must not be empty");
+	if (path.includes("\0")) throw new Error("workspace manifest path must not contain NUL bytes");
+	if (path.startsWith("/") || path.startsWith("\\") || WINDOWS_ABSOLUTE_PATH_PATTERN.test(path)) throw new Error("workspace manifest path must be workspace-relative");
+	const parts = path.replace(/\\/g, "/").split("/").filter(Boolean);
+	if (parts.length === 0) throw new Error("workspace manifest path must not resolve to the workspace root");
+	if (parts.some((part) => part === "..")) throw new Error("workspace manifest path cannot contain traversal segments");
+	const normalizedParts = parts.filter((part) => part !== ".");
+	if (normalizedParts.length === 0) throw new Error("workspace manifest path must not resolve to the workspace root");
+	return normalizedParts.join("/");
 }
 async function applyManifestEntry(sandboxClient, path, targetPath, targetRoot, entry, options) {
-  switch (entry.type) {
-    case "file":
-      await writeSandboxFile(sandboxClient, targetPath, targetRoot, entry.content);
-      return createAppliedEntry(path, entry.type);
-    case "dir":
-      await createSandboxDirectory(sandboxClient, targetPath);
-      return createAppliedEntry(path, entry.type);
-    case "localFile":
-      await copyLocalFile(sandboxClient, entry.src, targetPath, targetRoot, options);
-      return createAppliedEntry(path, entry.type);
-    case "localDir":
-      await copyLocalDirectory(sandboxClient, entry.src, targetPath, options);
-      return createAppliedEntry(path, entry.type);
-    case "gitRepo":
-      await cloneGitRepository(sandboxClient, entry, targetPath);
-      return createAppliedEntry(path, entry.type);
-    case "s3Mount":
-    case "gcsMount":
-    case "r2Mount":
-    case "azureBlobMount":
-      return {
-        path,
-        type: entry.type,
-        status: "unsupported",
-        message: `${entry.type} requires a provider-specific sandbox adapter.`
-      };
-    default:
-      return assertUnreachable(entry);
-  }
+	switch (entry.type) {
+		case "file":
+			await writeSandboxFile(sandboxClient, targetPath, targetRoot, entry.content);
+			return createAppliedEntry(path, entry.type);
+		case "dir":
+			await createSandboxDirectory(sandboxClient, targetPath);
+			return createAppliedEntry(path, entry.type);
+		case "localFile":
+			await copyLocalFile(sandboxClient, entry.src, targetPath, targetRoot, options);
+			return createAppliedEntry(path, entry.type);
+		case "localDir":
+			await copyLocalDirectory(sandboxClient, entry.src, targetPath, options);
+			return createAppliedEntry(path, entry.type);
+		case "gitRepo":
+			await cloneGitRepository(sandboxClient, entry, targetPath);
+			return createAppliedEntry(path, entry.type);
+		case "s3Mount":
+		case "gcsMount":
+		case "r2Mount":
+		case "azureBlobMount": return {
+			path,
+			type: entry.type,
+			status: "unsupported",
+			message: `${entry.type} requires a provider-specific sandbox adapter.`
+		};
+		default: return assertUnreachable(entry);
+	}
 }
 function createAppliedEntry(path, type) {
-  return { path, type, status: "applied" };
+	return {
+		path,
+		type,
+		status: "applied"
+	};
 }
 async function copyLocalFile(sandboxClient, source, targetPath, targetRoot, options) {
-  const hostSourcePath = resolveHostSourcePath(source, options.hostRoot);
-  const content = await readFile(hostSourcePath, "utf8");
-  await writeSandboxFile(sandboxClient, targetPath, targetRoot, content);
+	await writeSandboxFile(sandboxClient, targetPath, targetRoot, await readFile(resolveHostSourcePath(source, options.hostRoot), "utf8"));
 }
 async function copyLocalDirectory(sandboxClient, source, targetPath, options) {
-  const hostSourcePath = resolveHostSourcePath(source, options.hostRoot);
-  await copyLocalDirectoryRecursive(sandboxClient, hostSourcePath, targetPath);
+	await copyLocalDirectoryRecursive(sandboxClient, resolveHostSourcePath(source, options.hostRoot), targetPath);
 }
 async function copyLocalDirectoryRecursive(sandboxClient, sourcePath, targetPath) {
-  await createSandboxDirectory(sandboxClient, targetPath);
-  const entries = await readdir(sourcePath, { withFileTypes: true });
-  for (const entry of entries) {
-    const childSourcePath = join(sourcePath, entry.name);
-    const childTargetPath = joinSandboxPath(targetPath, entry.name);
-    if (entry.isDirectory()) {
-      await copyLocalDirectoryRecursive(sandboxClient, childSourcePath, childTargetPath);
-      continue;
-    }
-    if (entry.isFile()) {
-      const content = await readFile(childSourcePath, "utf8");
-      await sandboxClient.writeFile(childTargetPath, content);
-    }
-  }
+	await createSandboxDirectory(sandboxClient, targetPath);
+	const entries = await readdir(sourcePath, { withFileTypes: true });
+	for (const entry of entries) {
+		const childSourcePath = join(sourcePath, entry.name);
+		const childTargetPath = joinSandboxPath(targetPath, entry.name);
+		if (entry.isDirectory()) {
+			await copyLocalDirectoryRecursive(sandboxClient, childSourcePath, childTargetPath);
+			continue;
+		}
+		if (entry.isFile()) {
+			const content = await readFile(childSourcePath, "utf8");
+			await sandboxClient.writeFile(childTargetPath, content);
+		}
+	}
 }
 async function cloneGitRepository(sandboxClient, entry, targetPath) {
-  const shallowArgs = entry.shallow === false ? "" : " --depth 1";
-  const refArgs = entry.ref ? ` --branch ${quoteShellArg(entry.ref)}` : "";
-  await runSandboxCommand(
-    sandboxClient,
-    `git clone${shallowArgs}${refArgs} ${quoteShellArg(entry.url)} ${quoteShellArg(targetPath)}`
-  );
+	await runSandboxCommand(sandboxClient, `git clone${entry.shallow === false ? "" : " --depth 1"}${entry.ref ? ` --branch ${quoteShellArg(entry.ref)}` : ""} ${quoteShellArg(entry.url)} ${quoteShellArg(targetPath)}`);
 }
 async function writeSandboxFile(sandboxClient, targetPath, targetRoot, content) {
-  const parentPath = posix.dirname(targetPath);
-  if (parentPath !== targetRoot) {
-    await createSandboxDirectory(sandboxClient, parentPath);
-  }
-  await sandboxClient.writeFile(targetPath, content);
+	const parentPath = posix.dirname(targetPath);
+	if (parentPath !== targetRoot) await createSandboxDirectory(sandboxClient, parentPath);
+	await sandboxClient.writeFile(targetPath, content);
 }
 async function createSandboxDirectory(sandboxClient, targetPath) {
-  await runSandboxCommand(sandboxClient, `mkdir -p ${quoteShellArg(targetPath)}`);
+	await runSandboxCommand(sandboxClient, `mkdir -p ${quoteShellArg(targetPath)}`);
 }
 async function runSandboxCommand(sandboxClient, command) {
-  const result = await sandboxClient.run(command);
-  if (result.exitCode !== 0) {
-    throw new Error(
-      `workspace manifest command failed: ${command}
-${result.stderr ?? result.stdout}`
-    );
-  }
+	const result = await sandboxClient.run(command);
+	if (result.exitCode !== 0) throw new Error(`workspace manifest command failed: ${command}\n${result.stderr ?? result.stdout}`);
 }
 function resolveHostSourcePath(source, hostRoot) {
-  return isAbsolute(source) ? resolve(source) : resolve(hostRoot ?? process.cwd(), source);
+	return isAbsolute(source) ? resolve(source) : resolve(hostRoot ?? process.cwd(), source);
 }
 function normalizeSandboxRoot(root) {
-  const normalized = root.replace(/\\/g, "/").replace(/\/+$/, "");
-  if (!normalized.startsWith("/")) {
-    throw new Error("workspace manifest targetRoot must be an absolute sandbox path");
-  }
-  return normalized.length === 0 ? "/" : normalized;
+	const normalized = root.replace(/\\/g, "/").replace(/\/+$/, "");
+	if (!normalized.startsWith("/")) throw new Error("workspace manifest targetRoot must be an absolute sandbox path");
+	return normalized.length === 0 ? "/" : normalized;
 }
 function joinSandboxPath(root, path) {
-  const normalizedRoot = normalizeSandboxRoot(root);
-  if (normalizedRoot === "/") {
-    return `/${path}`;
-  }
-  return `${normalizedRoot}/${path}`;
+	const normalizedRoot = normalizeSandboxRoot(root);
+	if (normalizedRoot === "/") return `/${path}`;
+	return `${normalizedRoot}/${path}`;
 }
 function quoteShellArg(value) {
-  return `'${value.replace(SHELL_QUOTE_PATTERN, "'\\''")}'`;
+	return `'${value.replace(SHELL_QUOTE_PATTERN, "'\\''")}'`;
 }
 function assertUnreachable(value) {
-  throw new Error(`unsupported workspace manifest entry: ${JSON.stringify(value)}`);
+	throw new Error(`unsupported workspace manifest entry: ${JSON.stringify(value)}`);
 }
+//#endregion
+//#region src/registry/tool-registry.ts
+/**
+* Tool registry implementation
+* Manages tool registration, validation, and retrieval
+*/
 var ToolRegistry = class {
-  tools = /* @__PURE__ */ new Map();
-  /**
-   * Register a tool
-   */
-  register(tool) {
-    if (!tool.schema?.name) {
-      throw new ValidationError("Tool must have a valid schema with name");
-    }
-    const toolName = tool.schema.name;
-    this.validateToolSchema(tool.schema);
-    if (this.tools.has(toolName)) {
-      logger.warn(`Tool "${toolName}" is already registered, overriding`, {
-        toolName,
-        existingTool: this.tools.get(toolName)?.constructor.name
-      });
-    }
-    this.tools.set(toolName, tool);
-    logger.debug(`Tool "${toolName}" registered successfully`, {
-      toolName,
-      toolType: tool.constructor.name,
-      parameters: Object.keys(tool.schema.parameters?.properties || {})
-    });
-  }
-  /**
-   * Unregister a tool
-   */
-  unregister(name) {
-    if (!this.tools.has(name)) {
-      logger.warn(`Attempted to unregister non-existent tool "${name}"`);
-      return;
-    }
-    this.tools.delete(name);
-    logger.debug(`Tool "${name}" unregistered successfully`);
-  }
-  /**
-   * Get tool by name
-   */
-  get(name) {
-    return this.tools.get(name);
-  }
-  /**
-   * Get all registered tools
-   */
-  getAll() {
-    return Array.from(this.tools.values());
-  }
-  /**
-   * Get tool schemas
-   */
-  getSchemas() {
-    const tools = this.getAll();
-    logger.debug("[TOOL-FLOW] ToolRegistry.getSchemas() - Tools before schema extraction", {
-      count: tools.length,
-      tools: tools.map((t) => ({
-        name: t.schema?.name ?? "unnamed",
-        hasSchema: !!t.schema,
-        schemaType: typeof t.schema,
-        toolType: t.constructor?.name || "unknown"
-      }))
-    });
-    return this.getAll().map((tool) => tool.schema);
-  }
-  /**
-   * Check if tool exists
-   */
-  has(name) {
-    return this.tools.has(name);
-  }
-  /**
-   * Clear all tools
-   */
-  clear() {
-    const toolCount = this.tools.size;
-    this.tools.clear();
-    logger.debug(`Cleared ${toolCount} tools from registry`);
-  }
-  /**
-   * Get tool names
-   */
-  getToolNames() {
-    return Array.from(this.tools.keys());
-  }
-  /**
-   * Get tools by pattern
-   */
-  getToolsByPattern(pattern) {
-    const regex = typeof pattern === "string" ? new RegExp(pattern) : pattern;
-    return this.getAll().filter((tool) => regex.test(tool.schema.name));
-  }
-  /**
-   * Get tool count
-   */
-  size() {
-    return this.tools.size;
-  }
-  /**
-   * Validate tool schema
-   */
-  validateToolSchema(schema) {
-    if (!schema.name || typeof schema.name !== "string") {
-      throw new ValidationError("Tool schema must have a valid name");
-    }
-    if (!schema.description || typeof schema.description !== "string") {
-      throw new ValidationError("Tool schema must have a description");
-    }
-    if (!schema.parameters || typeof schema.parameters !== "object" || schema.parameters === null || Array.isArray(schema.parameters)) {
-      throw new ValidationError("Tool schema must have parameters object");
-    }
-    if (schema.parameters.type !== "object") {
-      throw new ValidationError('Tool parameters type must be "object"');
-    }
-    if (schema.parameters.properties) {
-      for (const propName of Object.keys(schema.parameters.properties)) {
-        const propSchema = schema.parameters.properties[propName];
-        if (!propSchema?.type) {
-          throw new ValidationError(`Parameter "${propName}" must have a type`);
-        }
-        const validTypes = ["string", "number", "boolean", "array", "object"];
-        if (!validTypes.includes(propSchema.type)) {
-          throw new ValidationError(
-            `Parameter "${propName}" has invalid type "${propSchema.type}"`
-          );
-        }
-      }
-    }
-    if (schema.parameters.required) {
-      const properties = schema.parameters.properties || {};
-      for (const requiredField of schema.parameters.required) {
-        if (!properties[requiredField]) {
-          throw new ValidationError(
-            `Required parameter "${requiredField}" is not defined in properties`
-          );
-        }
-      }
-    }
-  }
+	tools = /* @__PURE__ */ new Map();
+	/**
+	* Register a tool
+	*/
+	register(tool) {
+		if (!tool.schema?.name) throw new ValidationError("Tool must have a valid schema with name");
+		const toolName = tool.schema.name;
+		this.validateToolSchema(tool.schema);
+		if (this.tools.has(toolName)) logger.warn(`Tool "${toolName}" is already registered, overriding`, {
+			toolName,
+			existingTool: this.tools.get(toolName)?.constructor.name
+		});
+		this.tools.set(toolName, tool);
+		logger.debug(`Tool "${toolName}" registered successfully`, {
+			toolName,
+			toolType: tool.constructor.name,
+			parameters: Object.keys(tool.schema.parameters?.properties || {})
+		});
+	}
+	/**
+	* Unregister a tool
+	*/
+	unregister(name) {
+		if (!this.tools.has(name)) {
+			logger.warn(`Attempted to unregister non-existent tool "${name}"`);
+			return;
+		}
+		this.tools.delete(name);
+		logger.debug(`Tool "${name}" unregistered successfully`);
+	}
+	/**
+	* Get tool by name
+	*/
+	get(name) {
+		return this.tools.get(name);
+	}
+	/**
+	* Get all registered tools
+	*/
+	getAll() {
+		return Array.from(this.tools.values());
+	}
+	/**
+	* Get tool schemas
+	*/
+	getSchemas() {
+		const tools = this.getAll();
+		logger.debug("[TOOL-FLOW] ToolRegistry.getSchemas() - Tools before schema extraction", {
+			count: tools.length,
+			tools: tools.map((t) => ({
+				name: t.schema?.name ?? "unnamed",
+				hasSchema: !!t.schema,
+				schemaType: typeof t.schema,
+				toolType: t.constructor?.name || "unknown"
+			}))
+		});
+		return this.getAll().map((tool) => tool.schema);
+	}
+	/**
+	* Check if tool exists
+	*/
+	has(name) {
+		return this.tools.has(name);
+	}
+	/**
+	* Clear all tools
+	*/
+	clear() {
+		const toolCount = this.tools.size;
+		this.tools.clear();
+		logger.debug(`Cleared ${toolCount} tools from registry`);
+	}
+	/**
+	* Get tool names
+	*/
+	getToolNames() {
+		return Array.from(this.tools.keys());
+	}
+	/**
+	* Get tools by pattern
+	*/
+	getToolsByPattern(pattern) {
+		const regex = typeof pattern === "string" ? new RegExp(pattern) : pattern;
+		return this.getAll().filter((tool) => regex.test(tool.schema.name));
+	}
+	/**
+	* Get tool count
+	*/
+	size() {
+		return this.tools.size;
+	}
+	/**
+	* Validate tool schema
+	*/
+	validateToolSchema(schema) {
+		if (!schema.name || typeof schema.name !== "string") throw new ValidationError("Tool schema must have a valid name");
+		if (!schema.description || typeof schema.description !== "string") throw new ValidationError("Tool schema must have a description");
+		if (!schema.parameters || typeof schema.parameters !== "object" || schema.parameters === null || Array.isArray(schema.parameters)) throw new ValidationError("Tool schema must have parameters object");
+		if (schema.parameters.type !== "object") throw new ValidationError("Tool parameters type must be \"object\"");
+		if (schema.parameters.properties) for (const propName of Object.keys(schema.parameters.properties)) {
+			const propSchema = schema.parameters.properties[propName];
+			if (!propSchema?.type) throw new ValidationError(`Parameter "${propName}" must have a type`);
+			if (![
+				"string",
+				"number",
+				"boolean",
+				"array",
+				"object"
+			].includes(propSchema.type)) throw new ValidationError(`Parameter "${propName}" has invalid type "${propSchema.type}"`);
+		}
+		if (schema.parameters.required) {
+			const properties = schema.parameters.properties || {};
+			for (const requiredField of schema.parameters.required) if (!properties[requiredField]) throw new ValidationError(`Required parameter "${requiredField}" is not defined in properties`);
+		}
+	}
 };
-
-// src/implementations/function-tool/schema-converter.ts
+//#endregion
+//#region src/implementations/function-tool/schema-converter.ts
+/**
+* Convert Zod schema to JSON Schema format with safe undefined handling
+*/
 function zodToJsonSchema(schema, options = {}) {
-  const properties = {};
-  const required = [];
-  const schemaDef = schema._def;
-  if (!schemaDef) {
-    throw new Error("Zod schema is missing _def; cannot convert to JSON schema.");
-  }
-  if (schemaDef.typeName === "ZodObject" && schemaDef.shape) {
-    const shape = typeof schemaDef.shape === "function" ? schemaDef.shape() : schemaDef.shape;
-    for (const [key, typeObj] of Object.entries(shape)) {
-      const property = convertZodTypeToProperty(typeObj);
-      properties[key] = property;
-      if (isRequiredField(typeObj)) {
-        required.push(key);
-      }
-    }
-  }
-  return {
-    type: "object",
-    properties,
-    required,
-    ...(options.allowAdditionalProperties || schemaDef.unknownKeys === "passthrough") && {
-      additionalProperties: true
-    }
-  };
+	const properties = {};
+	const required = [];
+	const schemaDef = schema._def;
+	if (!schemaDef) throw new Error("Zod schema is missing _def; cannot convert to JSON schema.");
+	if (schemaDef.typeName === "ZodObject" && schemaDef.shape) {
+		const shape = typeof schemaDef.shape === "function" ? schemaDef.shape() : schemaDef.shape;
+		for (const [key, typeObj] of Object.entries(shape)) {
+			properties[key] = convertZodTypeToProperty(typeObj);
+			if (isRequiredField(typeObj)) required.push(key);
+		}
+	}
+	return {
+		type: "object",
+		properties,
+		required,
+		...(options.allowAdditionalProperties || schemaDef.unknownKeys === "passthrough") && { additionalProperties: true }
+	};
 }
+/**
+* Convert individual Zod type to parameter schema with safe undefined handling
+*/
 function convertZodTypeToProperty(typeObj) {
-  const typeDef = typeObj._def;
-  if (!typeDef) {
-    throw new Error("Zod type is missing _def; cannot convert to JSON schema.");
-  }
-  const base = {};
-  if (typeDef.description) {
-    base.description = typeDef.description;
-  }
-  switch (typeDef.typeName) {
-    case "ZodString":
-      return { type: "string", ...base };
-    case "ZodNumber":
-      return { type: "number", ...base };
-    case "ZodBoolean":
-      return { type: "boolean", ...base };
-    case "ZodArray": {
-      if (!typeDef.type) {
-        throw new Error("ZodArray is missing item type; cannot convert to JSON schema.");
-      }
-      const arrayItems = convertZodTypeToProperty(typeDef.type);
-      return {
-        type: "array",
-        items: arrayItems,
-        ...base
-      };
-    }
-    case "ZodObject":
-      return { type: "object", ...base };
-    case "ZodEnum": {
-      const enumValues = typeDef.values;
-      if (!enumValues || !Array.isArray(enumValues)) {
-        throw new Error("ZodEnum is missing enum values; cannot convert to JSON schema.");
-      }
-      return {
-        type: "string",
-        enum: enumValues,
-        ...base
-      };
-    }
-    case "ZodOptional":
-      if (typeDef.innerType) {
-        const innerProperty = convertZodTypeToProperty(typeDef.innerType);
-        return { ...innerProperty, ...base };
-      }
-      throw new Error("ZodOptional is missing innerType; cannot convert to JSON schema.");
-    case "ZodNullable":
-      if (typeDef.innerType) {
-        const innerProperty = convertZodTypeToProperty(typeDef.innerType);
-        return { ...innerProperty, ...base };
-      }
-      throw new Error("ZodNullable is missing innerType; cannot convert to JSON schema.");
-    case "ZodDefault":
-      if (typeDef.innerType) {
-        const innerProperty = convertZodTypeToProperty(typeDef.innerType);
-        return { ...innerProperty, ...base };
-      }
-      throw new Error("ZodDefault is missing innerType; cannot convert to JSON schema.");
-    case "ZodRecord":
-      if (typeDef.valueType) {
-        const valueProperty = convertZodTypeToProperty(typeDef.valueType);
-        return { type: "object", additionalProperties: valueProperty, ...base };
-      }
-      return { type: "object", additionalProperties: { type: "string" }, ...base };
-    default:
-      throw new Error(`Unsupported Zod type: ${String(typeDef.typeName)}`);
-  }
+	const typeDef = typeObj._def;
+	if (!typeDef) throw new Error("Zod type is missing _def; cannot convert to JSON schema.");
+	const base = {};
+	if (typeDef.description) base.description = typeDef.description;
+	switch (typeDef.typeName) {
+		case "ZodString": return {
+			type: "string",
+			...base
+		};
+		case "ZodNumber": return {
+			type: "number",
+			...base
+		};
+		case "ZodBoolean": return {
+			type: "boolean",
+			...base
+		};
+		case "ZodArray":
+			if (!typeDef.type) throw new Error("ZodArray is missing item type; cannot convert to JSON schema.");
+			return {
+				type: "array",
+				items: convertZodTypeToProperty(typeDef.type),
+				...base
+			};
+		case "ZodObject": return {
+			type: "object",
+			...base
+		};
+		case "ZodEnum": {
+			const enumValues = typeDef.values;
+			if (!enumValues || !Array.isArray(enumValues)) throw new Error("ZodEnum is missing enum values; cannot convert to JSON schema.");
+			return {
+				type: "string",
+				enum: enumValues,
+				...base
+			};
+		}
+		case "ZodOptional":
+			if (typeDef.innerType) return {
+				...convertZodTypeToProperty(typeDef.innerType),
+				...base
+			};
+			throw new Error("ZodOptional is missing innerType; cannot convert to JSON schema.");
+		case "ZodNullable":
+			if (typeDef.innerType) return {
+				...convertZodTypeToProperty(typeDef.innerType),
+				...base
+			};
+			throw new Error("ZodNullable is missing innerType; cannot convert to JSON schema.");
+		case "ZodDefault":
+			if (typeDef.innerType) return {
+				...convertZodTypeToProperty(typeDef.innerType),
+				...base
+			};
+			throw new Error("ZodDefault is missing innerType; cannot convert to JSON schema.");
+		case "ZodRecord":
+			if (typeDef.valueType) return {
+				type: "object",
+				additionalProperties: convertZodTypeToProperty(typeDef.valueType),
+				...base
+			};
+			return {
+				type: "object",
+				additionalProperties: { type: "string" },
+				...base
+			};
+		default: throw new Error(`Unsupported Zod type: ${String(typeDef.typeName)}`);
+	}
 }
+/**
+* Check if a Zod field is required (not optional or nullable)
+*/
 function isRequiredField(typeObj) {
-  const typeDef = typeObj._def;
-  if (!typeDef) {
-    throw new Error("Zod schema is missing _def; cannot determine required fields.");
-  }
-  return typeDef.typeName !== "ZodOptional" && typeDef.typeName !== "ZodNullable" && typeDef.typeName !== "ZodDefault";
+	const typeDef = typeObj._def;
+	if (!typeDef) throw new Error("Zod schema is missing _def; cannot determine required fields.");
+	return typeDef.typeName !== "ZodOptional" && typeDef.typeName !== "ZodNullable" && typeDef.typeName !== "ZodDefault";
 }
-
-// src/implementations/function-tool/parameter-validator.ts
+//#endregion
+//#region src/implementations/function-tool/parameter-validator.ts
+/**
+* Validate individual parameter type against its schema.
+* Returns an error string if invalid, undefined if valid.
+*/
 function validateParameterType(key, value, schema) {
-  const expectedType = schema["type"];
-  switch (expectedType) {
-    case "string":
-      if (typeof value !== "string") {
-        return `Parameter "${key}" must be a string, got ${typeof value}`;
-      }
-      break;
-    case "number":
-      if (typeof value !== "number" || isNaN(value)) {
-        return `Parameter "${key}" must be a number, got ${typeof value}`;
-      }
-      break;
-    case "boolean":
-      if (typeof value !== "boolean") {
-        return `Parameter "${key}" must be a boolean, got ${typeof value}`;
-      }
-      break;
-    case "array":
-      if (!Array.isArray(value)) {
-        return `Parameter "${key}" must be an array, got ${typeof value}`;
-      }
-      if (schema.items) {
-        for (let i = 0; i < value.length; i++) {
-          const itemError = validateParameterType(`${key}[${i}]`, value[i], schema.items);
-          if (itemError) {
-            return itemError;
-          }
-        }
-      }
-      break;
-    case "object":
-      if (typeof value !== "object" || value === null || Array.isArray(value)) {
-        return `Parameter "${key}" must be an object, got ${typeof value}`;
-      }
-      break;
-  }
-  if (schema.enum && schema.enum.length > 0) {
-    const enumValues = schema.enum;
-    let isValidEnum = false;
-    for (const enumValue of enumValues) {
-      if (value === enumValue) {
-        isValidEnum = true;
-        break;
-      }
-    }
-    if (!isValidEnum) {
-      return `Parameter "${key}" must be one of: ${enumValues.join(", ")}, got ${value}`;
-    }
-  }
-  return void 0;
+	switch (schema["type"]) {
+		case "string":
+			if (typeof value !== "string") return `Parameter "${key}" must be a string, got ${typeof value}`;
+			break;
+		case "number":
+			if (typeof value !== "number" || isNaN(value)) return `Parameter "${key}" must be a number, got ${typeof value}`;
+			break;
+		case "boolean":
+			if (typeof value !== "boolean") return `Parameter "${key}" must be a boolean, got ${typeof value}`;
+			break;
+		case "array":
+			if (!Array.isArray(value)) return `Parameter "${key}" must be an array, got ${typeof value}`;
+			if (schema.items) for (let i = 0; i < value.length; i++) {
+				const itemError = validateParameterType(`${key}[${i}]`, value[i], schema.items);
+				if (itemError) return itemError;
+			}
+			break;
+		case "object":
+			if (typeof value !== "object" || value === null || Array.isArray(value)) return `Parameter "${key}" must be an object, got ${typeof value}`;
+			break;
+	}
+	if (schema.enum && schema.enum.length > 0) {
+		const enumValues = schema.enum;
+		let isValidEnum = false;
+		for (const enumValue of enumValues) if (value === enumValue) {
+			isValidEnum = true;
+			break;
+		}
+		if (!isValidEnum) return `Parameter "${key}" must be one of: ${enumValues.join(", ")}, got ${value}`;
+	}
 }
+/**
+* Collect all validation errors for the given parameters against a schema.
+*/
 function getValidationErrors(parameters, schemaRequired, schemaProperties, additionalProperties) {
-  const errors = [];
-  for (const field of schemaRequired) {
-    if (!(field in parameters)) {
-      errors.push(`Missing required parameter: ${field}`);
-    }
-  }
-  for (const [key, value] of Object.entries(parameters)) {
-    const paramSchema = schemaProperties[key];
-    if (!paramSchema) {
-      if (additionalProperties === true) {
-        continue;
-      }
-      if (additionalProperties && typeof additionalProperties === "object") {
-        const additionalTypeError = validateParameterType(key, value, additionalProperties);
-        if (additionalTypeError) errors.push(additionalTypeError);
-        continue;
-      }
-      errors.push(`Unknown parameter: ${key}`);
-      continue;
-    }
-    const typeError = validateParameterType(key, value, paramSchema);
-    if (typeError) {
-      errors.push(typeError);
-    }
-  }
-  return errors;
+	const errors = [];
+	for (const field of schemaRequired) if (!(field in parameters)) errors.push(`Missing required parameter: ${field}`);
+	for (const [key, value] of Object.entries(parameters)) {
+		const paramSchema = schemaProperties[key];
+		if (!paramSchema) {
+			if (additionalProperties === true) continue;
+			if (additionalProperties && typeof additionalProperties === "object") {
+				const additionalTypeError = validateParameterType(key, value, additionalProperties);
+				if (additionalTypeError) errors.push(additionalTypeError);
+				continue;
+			}
+			errors.push(`Unknown parameter: ${key}`);
+			continue;
+		}
+		const typeError = validateParameterType(key, value, paramSchema);
+		if (typeError) errors.push(typeError);
+	}
+	return errors;
 }
+/**
+* Validate parameters and return a structured result.
+*/
 function validateToolParameters(parameters, schemaRequired, schemaProperties, additionalProperties) {
-  const errors = getValidationErrors(
-    parameters,
-    schemaRequired,
-    schemaProperties,
-    additionalProperties
-  );
-  return {
-    isValid: errors.length === 0,
-    errors
-  };
+	const errors = getValidationErrors(parameters, schemaRequired, schemaProperties, additionalProperties);
+	return {
+		isValid: errors.length === 0,
+		errors
+	};
 }
-
-// src/implementations/function-tool.ts
+//#endregion
+//#region src/implementations/function-tool.ts
+/**
+* Function tool implementation
+* Wraps a JavaScript function as a tool with schema validation
+*
+* Implements IFunctionTool without extending AbstractTool to avoid
+* circular runtime dependency (tools → agents → tools).
+*/
 var FunctionTool = class {
-  schema;
-  fn;
-  eventService;
-  constructor(schema, fn) {
-    this.schema = schema;
-    this.fn = fn;
-    this.validateConstructorInputs();
-  }
-  /**
-   * Get tool name
-   */
-  getName() {
-    return this.schema.name;
-  }
-  /**
-   * Set EventService for post-construction injection.
-   * Accepts EventService as-is without transformation.
-   * Caller is responsible for providing properly configured EventService.
-   */
-  setEventService(eventService) {
-    this.eventService = eventService;
-  }
-  /**
-   * Execute the function tool
-   */
-  async execute(parameters, context) {
-    const toolName = this.schema.name;
-    if (!this.validate(parameters)) {
-      const errors = getValidationErrors(
-        parameters,
-        this.schema.parameters.required || [],
-        this.schema.parameters.properties || {},
-        this.schema.parameters.additionalProperties
-      );
-      throw new ValidationError(`Invalid parameters for tool "${toolName}": ${errors.join(", ")}`);
-    }
-    const startTime = Date.now();
-    let result;
-    try {
-      result = await this.fn(parameters, context);
-    } catch (error) {
-      if (error instanceof ToolExecutionError || error instanceof ValidationError) {
-        throw error;
-      }
-      throw new ToolExecutionError(
-        `Function tool execution failed: ${error instanceof Error ? error.message : String(error)}`,
-        toolName,
-        error instanceof Error ? error : new Error(String(error)),
-        {
-          parameterCount: Object.keys(parameters || {}).length,
-          hasContext: !!context
-        }
-      );
-    }
-    const executionTime = Date.now() - startTime;
-    return {
-      success: true,
-      data: result,
-      metadata: {
-        executionTime,
-        toolName,
-        parameters
-      }
-    };
-  }
-  /**
-   * Validate parameters (simple boolean result)
-   */
-  validate(parameters) {
-    return getValidationErrors(
-      parameters,
-      this.schema.parameters.required || [],
-      this.schema.parameters.properties || {},
-      this.schema.parameters.additionalProperties
-    ).length === 0;
-  }
-  /**
-   * Validate tool parameters with detailed result
-   */
-  validateParameters(parameters) {
-    return validateToolParameters(
-      parameters,
-      this.schema.parameters.required || [],
-      this.schema.parameters.properties || {},
-      this.schema.parameters.additionalProperties
-    );
-  }
-  /**
-   * Get tool description
-   */
-  getDescription() {
-    return this.schema.description;
-  }
-  /**
-   * Validate constructor inputs
-   */
-  validateConstructorInputs() {
-    if (!this.schema) {
-      throw new ValidationError("Tool schema is required");
-    }
-    if (!this.fn || typeof this.fn !== "function") {
-      throw new ValidationError("Tool function is required and must be a function");
-    }
-    if (!this.schema.name) {
-      throw new ValidationError("Tool schema must have a name");
-    }
-  }
+	schema;
+	fn;
+	eventService;
+	constructor(schema, fn) {
+		this.schema = schema;
+		this.fn = fn;
+		this.validateConstructorInputs();
+	}
+	/**
+	* Get tool name
+	*/
+	getName() {
+		return this.schema.name;
+	}
+	/**
+	* Set EventService for post-construction injection.
+	* Accepts EventService as-is without transformation.
+	* Caller is responsible for providing properly configured EventService.
+	*/
+	setEventService(eventService) {
+		this.eventService = eventService;
+	}
+	/**
+	* Execute the function tool
+	*/
+	async execute(parameters, context) {
+		const toolName = this.schema.name;
+		if (!this.validate(parameters)) throw new ValidationError(`Invalid parameters for tool "${toolName}": ${getValidationErrors(parameters, this.schema.parameters.required || [], this.schema.parameters.properties || {}, this.schema.parameters.additionalProperties).join(", ")}`);
+		const startTime = Date.now();
+		let result;
+		try {
+			result = await this.fn(parameters, context);
+		} catch (error) {
+			if (error instanceof ToolExecutionError || error instanceof ValidationError) throw error;
+			throw new ToolExecutionError(`Function tool execution failed: ${error instanceof Error ? error.message : String(error)}`, toolName, error instanceof Error ? error : new Error(String(error)), {
+				parameterCount: Object.keys(parameters || {}).length,
+				hasContext: !!context
+			});
+		}
+		const executionTime = Date.now() - startTime;
+		return {
+			success: true,
+			data: result,
+			metadata: {
+				executionTime,
+				toolName,
+				parameters
+			}
+		};
+	}
+	/**
+	* Validate parameters (simple boolean result)
+	*/
+	validate(parameters) {
+		return getValidationErrors(parameters, this.schema.parameters.required || [], this.schema.parameters.properties || {}, this.schema.parameters.additionalProperties).length === 0;
+	}
+	/**
+	* Validate tool parameters with detailed result
+	*/
+	validateParameters(parameters) {
+		return validateToolParameters(parameters, this.schema.parameters.required || [], this.schema.parameters.properties || {}, this.schema.parameters.additionalProperties);
+	}
+	/**
+	* Get tool description
+	*/
+	getDescription() {
+		return this.schema.description;
+	}
+	/**
+	* Validate constructor inputs
+	*/
+	validateConstructorInputs() {
+		if (!this.schema) throw new ValidationError("Tool schema is required");
+		if (!this.fn || typeof this.fn !== "function") throw new ValidationError("Tool function is required and must be a function");
+		if (!this.schema.name) throw new ValidationError("Tool schema must have a name");
+	}
 };
+/**
+* Helper function to create a function tool from a simple function
+*/
 function createFunctionTool(name, description, parameters, fn) {
-  const schema = {
-    name,
-    description,
-    parameters
-  };
-  return new FunctionTool(schema, fn);
+	return new FunctionTool({
+		name,
+		description,
+		parameters
+	}, fn);
 }
+/**
+* Helper function to create a function tool from Zod schema
+*/
 function createZodFunctionTool(name, description, zodSchema, fn) {
-  const parameters = zodToJsonSchema(zodSchema);
-  const schema = {
-    name,
-    description,
-    parameters
-  };
-  const wrappedFn = async (parameters2, context) => {
-    const parseResult = zodSchema.safeParse(parameters2);
-    if (!parseResult.success) {
-      throw new ValidationError(`Zod validation failed: ${parseResult.error}`);
-    }
-    const result = await fn(parseResult.data || parameters2, context);
-    return typeof result === "string" ? result : JSON.stringify(result);
-  };
-  return new FunctionTool(schema, wrappedFn);
+	const schema = {
+		name,
+		description,
+		parameters: zodToJsonSchema(zodSchema)
+	};
+	const wrappedFn = async (parameters, context) => {
+		const parseResult = zodSchema.safeParse(parameters);
+		if (!parseResult.success) throw new ValidationError(`Zod validation failed: ${parseResult.error}`);
+		const result = await fn(parseResult.data || parameters, context);
+		return typeof result === "string" ? result : JSON.stringify(result);
+	};
+	return new FunctionTool(schema, wrappedFn);
 }
-
-// src/implementations/openapi-schema-converter.ts
-var HTTP_METHODS = [
-  "get",
-  "post",
-  "put",
-  "delete",
-  "patch",
-  "head",
-  "options"
+//#endregion
+//#region src/implementations/openapi-schema-converter.ts
+/**
+* HTTP methods to search when scanning OpenAPI paths
+*/
+const HTTP_METHODS = [
+	"get",
+	"post",
+	"put",
+	"delete",
+	"patch",
+	"head",
+	"options"
 ];
+/**
+* Find an operation in the OpenAPI spec by operationId
+*/
 function findOperation(apiSpec, operationId) {
-  for (const [path, pathItem] of Object.entries(apiSpec.paths || {})) {
-    if (!pathItem) continue;
-    for (const method of HTTP_METHODS) {
-      const operation = pathItem[method];
-      if (operation?.operationId === operationId) {
-        return { method, path, operation };
-      }
-    }
-  }
-  return void 0;
+	for (const [path, pathItem] of Object.entries(apiSpec.paths || {})) {
+		if (!pathItem) continue;
+		for (const method of HTTP_METHODS) {
+			const operation = pathItem[method];
+			if (operation?.operationId === operationId) return {
+				method,
+				path,
+				operation
+			};
+		}
+	}
 }
+/**
+* Map OpenAPI type to JSON schema type
+*/
 function mapOpenAPIType(type) {
-  switch (type) {
-    case "string":
-      return "string";
-    case "number":
-      return "number";
-    case "integer":
-      return "integer";
-    case "boolean":
-      return "boolean";
-    case "array":
-      return "array";
-    case "object":
-      return "object";
-    default:
-      return "string";
-  }
+	switch (type) {
+		case "string": return "string";
+		case "number": return "number";
+		case "integer": return "integer";
+		case "boolean": return "boolean";
+		case "array": return "array";
+		case "object": return "object";
+		default: return "string";
+	}
 }
+/**
+* Convert OpenAPI schema to parameter schema
+*/
 function convertOpenAPISchemaToParameterSchema(schema) {
-  if ("$ref" in schema) {
-    return { type: "object" };
-  }
-  const result = {
-    type: mapOpenAPIType(schema.type)
-  };
-  if (schema.description) {
-    result.description = schema.description;
-  }
-  if (schema.enum) {
-    result.enum = schema.enum;
-  }
-  if (schema.minimum !== void 0) {
-    result.minimum = schema.minimum;
-  }
-  if (schema.maximum !== void 0) {
-    result.maximum = schema.maximum;
-  }
-  if (schema.pattern) {
-    result.pattern = schema.pattern;
-  }
-  if (schema.format) {
-    result.format = schema.format;
-  }
-  if (schema.default !== void 0) {
-    result.default = schema.default;
-  }
-  if (schema.type === "array" && schema.items) {
-    result.items = convertOpenAPISchemaToParameterSchema(schema.items);
-  }
-  if (schema.type === "object" && schema.properties) {
-    result.properties = {};
-    for (const [propName, propSchema] of Object.entries(schema.properties)) {
-      result.properties[propName] = convertOpenAPISchemaToParameterSchema(propSchema);
-    }
-    if (schema.required && schema.required.length > 0) {
-      result.required = schema.required;
-    }
-  }
-  return result;
+	if ("$ref" in schema) return { type: "object" };
+	const result = { type: mapOpenAPIType(schema.type) };
+	if (schema.description) result.description = schema.description;
+	if (schema.enum) result.enum = schema.enum;
+	if (schema.minimum !== void 0) result.minimum = schema.minimum;
+	if (schema.maximum !== void 0) result.maximum = schema.maximum;
+	if (schema.pattern) result.pattern = schema.pattern;
+	if (schema.format) result.format = schema.format;
+	if (schema.default !== void 0) result.default = schema.default;
+	if (schema.type === "array" && schema.items) result.items = convertOpenAPISchemaToParameterSchema(schema.items);
+	if (schema.type === "object" && schema.properties) {
+		result.properties = {};
+		for (const [propName, propSchema] of Object.entries(schema.properties)) result.properties[propName] = convertOpenAPISchemaToParameterSchema(propSchema);
+		if (schema.required && schema.required.length > 0) result.required = schema.required;
+	}
+	return result;
 }
+/**
+* Convert OpenAPI parameter object to tool parameter schema
+*/
 function convertOpenAPIParamToSchema(param) {
-  const schema = param.schema;
-  return convertOpenAPISchemaToParameterSchema(schema);
+	const schema = param.schema;
+	return convertOpenAPISchemaToParameterSchema(schema);
 }
+/**
+* Create a tool schema from an OpenAPI operation specification
+*/
 function createSchemaFromOperation(operationId, opSpec) {
-  const properties = {};
-  const required = [];
-  const params = opSpec.parameters || [];
-  for (const param of params) {
-    properties[param.name] = convertOpenAPIParamToSchema(param);
-    if (param.required) {
-      required.push(param.name);
-    }
-  }
-  if (opSpec.requestBody) {
-    const requestBody = opSpec.requestBody;
-    const jsonContent = requestBody.content?.["application/json"];
-    if (jsonContent?.schema) {
-      const bodySchema = convertOpenAPISchemaToParameterSchema(jsonContent.schema);
-      if (bodySchema.type === "object" && bodySchema.properties) {
-        Object.assign(properties, bodySchema.properties);
-        const schemaWithRequired = bodySchema;
-        if (schemaWithRequired.required) {
-          required.push(...schemaWithRequired.required);
-        }
-      }
-    }
-  }
-  const schemaParams = {
-    type: "object",
-    properties
-  };
-  if (required.length > 0) {
-    schemaParams.required = required;
-  }
-  return {
-    name: operationId,
-    description: opSpec.summary || opSpec.description || `OpenAPI operation: ${operationId}`,
-    parameters: schemaParams
-  };
+	const properties = {};
+	const required = [];
+	const params = opSpec.parameters || [];
+	for (const param of params) {
+		properties[param.name] = convertOpenAPIParamToSchema(param);
+		if (param.required) required.push(param.name);
+	}
+	if (opSpec.requestBody) {
+		const jsonContent = opSpec.requestBody.content?.["application/json"];
+		if (jsonContent?.schema) {
+			const bodySchema = convertOpenAPISchemaToParameterSchema(jsonContent.schema);
+			if (bodySchema.type === "object" && bodySchema.properties) {
+				Object.assign(properties, bodySchema.properties);
+				const schemaWithRequired = bodySchema;
+				if (schemaWithRequired.required) required.push(...schemaWithRequired.required);
+			}
+		}
+	}
+	const schemaParams = {
+		type: "object",
+		properties
+	};
+	if (required.length > 0) schemaParams.required = required;
+	return {
+		name: operationId,
+		description: opSpec.summary || opSpec.description || `OpenAPI operation: ${operationId}`,
+		parameters: schemaParams
+	};
 }
-
-// src/implementations/openapi-tool.ts
+//#endregion
+//#region src/implementations/openapi-tool.ts
+/**
+* OpenAPI tool implementation
+* Executes API calls based on OpenAPI 3.0 specifications
+*
+* Implements ITool without extending AbstractTool to avoid
+* circular runtime dependency (tools → agents → tools).
+*/
 var OpenAPITool = class {
-  schema;
-  apiSpec;
-  operationId;
-  baseURL;
-  config;
-  eventService;
-  constructor(config) {
-    this.config = config;
-    if (typeof config.spec !== "object" || config.spec === null || typeof config.spec.openapi !== "string" || typeof config.spec.paths !== "object") {
-      throw new Error(
-        'Invalid OpenAPI spec: must contain "openapi" (string) and "paths" (object) fields'
-      );
-    }
-    this.apiSpec = config.spec;
-    this.operationId = config.operationId;
-    this.baseURL = config.baseURL;
-    this.schema = this.createSchemaFromOpenAPI();
-  }
-  /**
-   * Execute the OpenAPI tool
-   */
-  async execute(parameters, context) {
-    const toolName = this.schema.name;
-    const validation = this.validateParameters(parameters);
-    if (!validation.isValid) {
-      throw new ValidationError(
-        `Invalid parameters for OpenAPI tool "${toolName}": ${validation.errors.join(", ")}`
-      );
-    }
-    try {
-      const startTime = Date.now();
-      const result = await this.executeAPICall(parameters, context);
-      const executionTime = Date.now() - startTime;
-      return {
-        success: true,
-        data: result,
-        metadata: {
-          executionTime,
-          toolName,
-          operationId: this.operationId,
-          baseURL: this.baseURL
-        }
-      };
-    } catch (error) {
-      if (error instanceof ToolExecutionError || error instanceof ValidationError) {
-        throw error;
-      }
-      const safeError = error instanceof Error ? error : new Error(String(error));
-      throw new ToolExecutionError(
-        `OpenAPI tool execution failed: ${safeError.message}`,
-        toolName,
-        safeError,
-        {
-          operationId: this.operationId,
-          baseURL: this.baseURL,
-          parametersCount: Object.keys(parameters).length
-        }
-      );
-    }
-  }
-  /**
-   * Validate tool parameters
-   */
-  validate(parameters) {
-    return this.validateParameters(parameters).isValid;
-  }
-  /**
-   * Validate tool parameters with detailed result
-   */
-  validateParameters(parameters) {
-    const required = this.schema.parameters.required || [];
-    const errors = [];
-    for (const field of required) {
-      if (!(field in parameters)) {
-        errors.push(`Missing required parameter: ${field}`);
-      }
-    }
-    return {
-      isValid: errors.length === 0,
-      errors
-    };
-  }
-  /**
-   * Get tool name
-   */
-  getName() {
-    return this.schema.name;
-  }
-  /**
-   * Set EventService for post-construction injection.
-   */
-  setEventService(eventService) {
-    this.eventService = eventService;
-  }
-  /**
-   * Get tool description
-   */
-  getDescription() {
-    return this.schema.description;
-  }
-  /**
-   * Execute the actual API call
-   * @private
-   */
-  async executeAPICall(parameters, _context) {
-    const operation = findOperation(this.apiSpec, this.operationId);
-    if (!operation) {
-      throw new Error(`Operation ${this.operationId} not found in OpenAPI spec`);
-    }
-    this.buildRequestConfig(operation, parameters);
-    throw new Error("Not implemented: actual API execution is not yet available");
-  }
-  /**
-   * Build HTTP request configuration from OpenAPI operation and parameters
-   */
-  buildRequestConfig(opInfo, parameters) {
-    const { method, path, operation } = opInfo;
-    let url = this.baseURL + path;
-    const headers = {};
-    let body;
-    const params = operation.parameters || [];
-    for (const param of params) {
-      const value = parameters[param.name];
-      if (value === void 0 && param.required) {
-        throw new Error(`Required parameter ${param.name} is missing`);
-      }
-      if (value !== void 0) {
-        switch (param.in) {
-          case "path":
-            url = url.replace(`{${param.name}}`, encodeURIComponent(String(value)));
-            break;
-          case "query": {
-            const separator = url.includes("?") ? "&" : "?";
-            url += `${separator}${param.name}=${encodeURIComponent(String(value))}`;
-            break;
-          }
-          case "header":
-            headers[param.name] = String(value);
-            break;
-        }
-      }
-    }
-    if (["post", "put", "patch"].includes(method) && operation.requestBody) {
-      const requestBody = operation.requestBody;
-      const jsonContent = requestBody.content?.["application/json"];
-      if (jsonContent) {
-        headers["Content-Type"] = "application/json";
-        const bodyParams = {};
-        for (const [key, value] of Object.entries(parameters)) {
-          const isParamUsed = params.some((p) => p.name === key);
-          if (!isParamUsed) {
-            bodyParams[key] = value;
-          }
-        }
-        body = JSON.stringify(bodyParams);
-      }
-    }
-    if (this.config.auth) {
-      switch (this.config.auth.type) {
-        case "bearer":
-          headers["Authorization"] = `Bearer ${this.config.auth.token}`;
-          break;
-        case "apiKey": {
-          const headerName = this.config.auth.header || "X-API-Key";
-          headers[headerName] = this.config.auth.apiKey || "";
-          break;
-        }
-      }
-    }
-    const result = {
-      method,
-      url,
-      headers
-    };
-    if (body !== void 0) {
-      result.body = body;
-    }
-    return result;
-  }
-  /**
-   * Create tool schema from OpenAPI operation specification
-   */
-  createSchemaFromOpenAPI() {
-    const operation = findOperation(this.apiSpec, this.operationId);
-    if (!operation) {
-      throw new Error(
-        `[STRICT-POLICY][EMITTER-CONTRACT] OpenAPI operation not found: ${this.operationId}. Emitter contract must provide a valid operationId present in the OpenAPI document.`
-      );
-    }
-    return createSchemaFromOperation(this.operationId, operation.operation);
-  }
+	schema;
+	apiSpec;
+	operationId;
+	baseURL;
+	config;
+	eventService;
+	constructor(config) {
+		this.config = config;
+		if (typeof config.spec !== "object" || config.spec === null || typeof config.spec.openapi !== "string" || typeof config.spec.paths !== "object") throw new Error("Invalid OpenAPI spec: must contain \"openapi\" (string) and \"paths\" (object) fields");
+		this.apiSpec = config.spec;
+		this.operationId = config.operationId;
+		this.baseURL = config.baseURL;
+		this.schema = this.createSchemaFromOpenAPI();
+	}
+	/**
+	* Execute the OpenAPI tool
+	*/
+	async execute(parameters, context) {
+		const toolName = this.schema.name;
+		const validation = this.validateParameters(parameters);
+		if (!validation.isValid) throw new ValidationError(`Invalid parameters for OpenAPI tool "${toolName}": ${validation.errors.join(", ")}`);
+		try {
+			const startTime = Date.now();
+			return {
+				success: true,
+				data: await this.executeAPICall(parameters, context),
+				metadata: {
+					executionTime: Date.now() - startTime,
+					toolName,
+					operationId: this.operationId,
+					baseURL: this.baseURL
+				}
+			};
+		} catch (error) {
+			if (error instanceof ToolExecutionError || error instanceof ValidationError) throw error;
+			const safeError = error instanceof Error ? error : new Error(String(error));
+			throw new ToolExecutionError(`OpenAPI tool execution failed: ${safeError.message}`, toolName, safeError, {
+				operationId: this.operationId,
+				baseURL: this.baseURL,
+				parametersCount: Object.keys(parameters).length
+			});
+		}
+	}
+	/**
+	* Validate tool parameters
+	*/
+	validate(parameters) {
+		return this.validateParameters(parameters).isValid;
+	}
+	/**
+	* Validate tool parameters with detailed result
+	*/
+	validateParameters(parameters) {
+		const required = this.schema.parameters.required || [];
+		const errors = [];
+		for (const field of required) if (!(field in parameters)) errors.push(`Missing required parameter: ${field}`);
+		return {
+			isValid: errors.length === 0,
+			errors
+		};
+	}
+	/**
+	* Get tool name
+	*/
+	getName() {
+		return this.schema.name;
+	}
+	/**
+	* Set EventService for post-construction injection.
+	*/
+	setEventService(eventService) {
+		this.eventService = eventService;
+	}
+	/**
+	* Get tool description
+	*/
+	getDescription() {
+		return this.schema.description;
+	}
+	/**
+	* Execute the actual API call
+	* @private
+	*/
+	async executeAPICall(parameters, _context) {
+		const operation = findOperation(this.apiSpec, this.operationId);
+		if (!operation) throw new Error(`Operation ${this.operationId} not found in OpenAPI spec`);
+		this.buildRequestConfig(operation, parameters);
+		throw new Error("Not implemented: actual API execution is not yet available");
+	}
+	/**
+	* Build HTTP request configuration from OpenAPI operation and parameters
+	*/
+	buildRequestConfig(opInfo, parameters) {
+		const { method, path, operation } = opInfo;
+		let url = this.baseURL + path;
+		const headers = {};
+		let body;
+		const params = operation.parameters || [];
+		for (const param of params) {
+			const value = parameters[param.name];
+			if (value === void 0 && param.required) throw new Error(`Required parameter ${param.name} is missing`);
+			if (value !== void 0) switch (param.in) {
+				case "path":
+					url = url.replace(`{${param.name}}`, encodeURIComponent(String(value)));
+					break;
+				case "query": {
+					const separator = url.includes("?") ? "&" : "?";
+					url += `${separator}${param.name}=${encodeURIComponent(String(value))}`;
+					break;
+				}
+				case "header":
+					headers[param.name] = String(value);
+					break;
+			}
+		}
+		if ([
+			"post",
+			"put",
+			"patch"
+		].includes(method) && operation.requestBody) {
+			if (operation.requestBody.content?.["application/json"]) {
+				headers["Content-Type"] = "application/json";
+				const bodyParams = {};
+				for (const [key, value] of Object.entries(parameters)) if (!params.some((p) => p.name === key)) bodyParams[key] = value;
+				body = JSON.stringify(bodyParams);
+			}
+		}
+		if (this.config.auth) switch (this.config.auth.type) {
+			case "bearer":
+				headers["Authorization"] = `Bearer ${this.config.auth.token}`;
+				break;
+			case "apiKey": {
+				const headerName = this.config.auth.header || "X-API-Key";
+				headers[headerName] = this.config.auth.apiKey || "";
+				break;
+			}
+		}
+		const result = {
+			method,
+			url,
+			headers
+		};
+		if (body !== void 0) result.body = body;
+		return result;
+	}
+	/**
+	* Create tool schema from OpenAPI operation specification
+	*/
+	createSchemaFromOpenAPI() {
+		const operation = findOperation(this.apiSpec, this.operationId);
+		if (!operation) throw new Error(`[STRICT-POLICY][EMITTER-CONTRACT] OpenAPI operation not found: ${this.operationId}. Emitter contract must provide a valid operationId present in the OpenAPI document.`);
+		return createSchemaFromOperation(this.operationId, operation.operation);
+	}
 };
+/**
+* Factory function to create OpenAPI tools from specification
+*/
 function createOpenAPITool(config) {
-  return new OpenAPITool(config);
+	return new OpenAPITool(config);
 }
-var DEFAULT_TIMEOUT_MS = 12e4;
-var BashSchema = z.object({
-  command: z.string().describe("The bash command to execute"),
-  timeout: z.number().optional().describe("Optional timeout in milliseconds (max 600000). Default is 120000 (2 minutes)"),
-  workingDirectory: z.string().optional().describe("Working directory for the command. Defaults to the current working directory")
+//#endregion
+//#region src/builtins/bash-tool.ts
+/**
+* BashTool — execute shell commands via child_process.spawn
+*
+* Returns TToolResult JSON string. Non-zero exit is returned as success:true
+* with exitCode set, matching Claude Code behaviour (the command ran, it just
+* exited non-zero — the LLM can decide what to do with that information).
+*/
+const DEFAULT_TIMEOUT_MS$2 = 12e4;
+const BashSchema = z.object({
+	command: z.string().describe("The bash command to execute"),
+	timeout: z.number().optional().describe("Optional timeout in milliseconds (max 600000). Default is 120000 (2 minutes)"),
+	workingDirectory: z.string().optional().describe("Working directory for the command. Defaults to the current working directory")
 });
+/**
+* Run a shell command and return stdout + stderr.
+* Resolves with the TToolResult JSON string.
+*/
 async function runBash(args, options = {}) {
-  const { command, timeout = DEFAULT_TIMEOUT_MS, workingDirectory } = args;
-  if (options.sandboxClient) {
-    try {
-      const sandboxResult = await options.sandboxClient.run(command, {
-        timeoutMs: timeout,
-        workingDirectory
-      });
-      const output = sandboxResult.stderr ? `${sandboxResult.stdout}
-stderr:
-${sandboxResult.stderr}` : sandboxResult.stdout;
-      const result = {
-        success: true,
-        output,
-        exitCode: sandboxResult.exitCode
-      };
-      return JSON.stringify(result);
-    } catch (err) {
-      const result = {
-        success: false,
-        output: "",
-        error: err instanceof Error ? err.message : String(err)
-      };
-      return JSON.stringify(result);
-    }
-  }
-  return new Promise((resolve4) => {
-    const stdoutChunks = [];
-    const stderrChunks = [];
-    let timedOut = false;
-    let settled = false;
-    const child = spawn("sh", ["-c", command], {
-      cwd: workingDirectory ?? process.cwd(),
-      env: process.env,
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    child.stdout.on("data", (chunk) => {
-      stdoutChunks.push(chunk);
-    });
-    child.stderr.on("data", (chunk) => {
-      stderrChunks.push(chunk);
-    });
-    const timer = setTimeout(() => {
-      timedOut = true;
-      child.kill("SIGTERM");
-      settle({
-        success: false,
-        output: Buffer.concat(stdoutChunks).toString("utf8"),
-        error: `Command timed out after ${timeout}ms`
-      });
-    }, timeout);
-    function settle(result) {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      resolve4(JSON.stringify(result));
-    }
-    child.on("error", (err) => {
-      settle({
-        success: false,
-        output: "",
-        error: err.message
-      });
-    });
-    child.on("close", (code) => {
-      if (timedOut) {
-        settle({
-          success: false,
-          output: Buffer.concat(stdoutChunks).toString("utf8"),
-          error: `Command timed out after ${timeout}ms`,
-          exitCode: code ?? void 0
-        });
-        return;
-      }
-      const stdout = Buffer.concat(stdoutChunks).toString("utf8");
-      const stderr = Buffer.concat(stderrChunks).toString("utf8");
-      const exitCode = code ?? 0;
-      const output = stderr ? `${stdout}
-stderr:
-${stderr}` : stdout;
-      settle({
-        success: true,
-        output,
-        exitCode
-      });
-    });
-  });
+	const { command, timeout = DEFAULT_TIMEOUT_MS$2, workingDirectory } = args;
+	if (options.sandboxClient) try {
+		const sandboxResult = await options.sandboxClient.run(command, {
+			timeoutMs: timeout,
+			workingDirectory
+		});
+		const result = {
+			success: true,
+			output: sandboxResult.stderr ? `${sandboxResult.stdout}\nstderr:\n${sandboxResult.stderr}` : sandboxResult.stdout,
+			exitCode: sandboxResult.exitCode
+		};
+		return JSON.stringify(result);
+	} catch (err) {
+		const result = {
+			success: false,
+			output: "",
+			error: err instanceof Error ? err.message : String(err)
+		};
+		return JSON.stringify(result);
+	}
+	return new Promise((resolve) => {
+		const stdoutChunks = [];
+		const stderrChunks = [];
+		let timedOut = false;
+		let settled = false;
+		const child = spawn("sh", ["-c", command], {
+			cwd: workingDirectory ?? process.cwd(),
+			env: process.env,
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			]
+		});
+		child.stdout.on("data", (chunk) => {
+			stdoutChunks.push(chunk);
+		});
+		child.stderr.on("data", (chunk) => {
+			stderrChunks.push(chunk);
+		});
+		const timer = setTimeout(() => {
+			timedOut = true;
+			child.kill("SIGTERM");
+			settle({
+				success: false,
+				output: Buffer.concat(stdoutChunks).toString("utf8"),
+				error: `Command timed out after ${timeout}ms`
+			});
+		}, timeout);
+		function settle(result) {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			resolve(JSON.stringify(result));
+		}
+		child.on("error", (err) => {
+			settle({
+				success: false,
+				output: "",
+				error: err.message
+			});
+		});
+		child.on("close", (code) => {
+			if (timedOut) {
+				settle({
+					success: false,
+					output: Buffer.concat(stdoutChunks).toString("utf8"),
+					error: `Command timed out after ${timeout}ms`,
+					exitCode: code ?? void 0
+				});
+				return;
+			}
+			const stdout = Buffer.concat(stdoutChunks).toString("utf8");
+			const stderr = Buffer.concat(stderrChunks).toString("utf8");
+			const exitCode = code ?? 0;
+			settle({
+				success: true,
+				output: stderr ? `${stdout}\nstderr:\n${stderr}` : stdout,
+				exitCode
+			});
+		});
+	});
 }
+/**
+* Create a BashTool instance — register with Robota agent tools registry.
+*/
 function createBashTool(options = {}) {
-  return createZodFunctionTool(
-    "Bash",
-    "Executes a given bash command and returns its output.\n\nThe working directory persists between commands, but shell state does not.\n\nIMPORTANT: Avoid using this tool to run `find`, `grep`, `cat`, `head`, `tail`, `sed`, `awk`, or `echo` commands. Instead, use the appropriate dedicated tool:\n - File search: Use Glob (NOT find or ls)\n - Content search: Use Grep (NOT grep or rg)\n - Read files: Use Read (NOT cat/head/tail)\n - Edit files: Use Edit (NOT sed/awk)\n\nFor simple commands, keep the description brief (5-10 words). For complex commands, include enough context to clarify what the command does.\n\nOutput is limited to 30,000 characters. Longer output will be middle-truncated.",
-    BashSchema,
-    async (params) => {
-      return runBash(params, options);
-    }
-  );
+	return createZodFunctionTool("Bash", "Executes a given bash command and returns its output.\n\nThe working directory persists between commands, but shell state does not.\n\nIMPORTANT: Avoid using this tool to run `find`, `grep`, `cat`, `head`, `tail`, `sed`, `awk`, or `echo` commands. Instead, use the appropriate dedicated tool:\n - File search: Use Glob (NOT find or ls)\n - Content search: Use Grep (NOT grep or rg)\n - Read files: Use Read (NOT cat/head/tail)\n - Edit files: Use Edit (NOT sed/awk)\n\nFor simple commands, keep the description brief (5-10 words). For complex commands, include enough context to clarify what the command does.\n\nOutput is limited to 30,000 characters. Longer output will be middle-truncated.", BashSchema, async (params) => {
+		return runBash(params, options);
+	});
 }
-var bashTool = createBashTool();
-var DEFAULT_LIMIT = 2e3;
-var ReadSchema = z.object({
-  filePath: z.string().describe("The absolute path to the file to read"),
-  offset: z.number().optional().describe(
-    "The line number to start reading from (1-based). Only provide if the file is too large to read at once"
-  ),
-  limit: z.number().optional().describe(
-    `The number of lines to read (default: ${DEFAULT_LIMIT}). Only provide if the file is too large to read at once`
-  )
+/**
+* BashTool instance — register with Robota agent tools registry.
+*/
+const bashTool = createBashTool();
+//#endregion
+//#region src/builtins/read-tool.ts
+/**
+* ReadTool — read a file and return its contents with line numbers (cat -n style).
+*
+* Supports offset/limit for partial reads. Detects binary files and refuses to
+* return their raw bytes. Default limit is 2000 lines.
+*/
+const DEFAULT_LIMIT$1 = 2e3;
+const ReadSchema = z.object({
+	filePath: z.string().describe("The absolute path to the file to read"),
+	offset: z.number().optional().describe("The line number to start reading from (1-based). Only provide if the file is too large to read at once"),
+	limit: z.number().optional().describe(`The number of lines to read (default: ${DEFAULT_LIMIT$1}). Only provide if the file is too large to read at once`)
 });
+/**
+* Heuristic binary detection: scan the first 8 KB for null bytes.
+*/
 function isBinary(buffer) {
-  const checkLength = Math.min(buffer.length, 8192);
-  for (let i = 0; i < checkLength; i++) {
-    if (buffer[i] === 0) return true;
-  }
-  return false;
+	const checkLength = Math.min(buffer.length, 8192);
+	for (let i = 0; i < checkLength; i++) if (buffer[i] === 0) return true;
+	return false;
 }
+/**
+* Format lines with 1-based line numbers in cat -n style.
+* Pads line number to the width of the highest line number.
+*/
 function formatWithLineNumbers(lines, startLine) {
-  const lastLineNum = startLine + lines.length - 1;
-  const width = String(lastLineNum).length;
-  return lines.map((line, idx) => {
-    const lineNum = String(startLine + idx).padStart(width, " ");
-    return `${lineNum}	${line}`;
-  }).join("\n");
+	const lastLineNum = startLine + lines.length - 1;
+	const width = String(lastLineNum).length;
+	return lines.map((line, idx) => {
+		return `${String(startLine + idx).padStart(width, " ")}\t${line}`;
+	}).join("\n");
 }
 function formatReadResult(filePath, content, startLine, limit) {
-  const allLines = content.split("\n");
-  if (allLines[allLines.length - 1] === "") {
-    allLines.pop();
-  }
-  const zeroBasedStart = startLine - 1;
-  const selectedLines = allLines.slice(zeroBasedStart, zeroBasedStart + limit);
-  const output = formatWithLineNumbers(selectedLines, startLine);
-  const totalLines = allLines.length;
-  const returnedLines = selectedLines.length;
-  const header = returnedLines < totalLines ? `[File: ${filePath} (lines ${startLine}-${startLine + returnedLines - 1} of ${totalLines})]
-` : `[File: ${filePath} (${totalLines} lines)]
-`;
-  const result = {
-    success: true,
-    output: header + output
-  };
-  return JSON.stringify(result);
+	const allLines = content.split("\n");
+	if (allLines[allLines.length - 1] === "") allLines.pop();
+	const zeroBasedStart = startLine - 1;
+	const selectedLines = allLines.slice(zeroBasedStart, zeroBasedStart + limit);
+	const output = formatWithLineNumbers(selectedLines, startLine);
+	const totalLines = allLines.length;
+	const returnedLines = selectedLines.length;
+	const result = {
+		success: true,
+		output: (returnedLines < totalLines ? `[File: ${filePath} (lines ${startLine}-${startLine + returnedLines - 1} of ${totalLines})]\n` : `[File: ${filePath} (${totalLines} lines)]\n`) + output
+	};
+	return JSON.stringify(result);
 }
 async function readFileTool(args, options = {}) {
-  const { filePath, offset, limit = DEFAULT_LIMIT } = args;
-  const startLine = offset !== void 0 && offset > 0 ? offset : 1;
-  if (options.sandboxClient) {
-    try {
-      const content2 = await options.sandboxClient.readFile(filePath);
-      return formatReadResult(filePath, content2, startLine, limit);
-    } catch (err) {
-      const result = {
-        success: false,
-        output: "",
-        error: err instanceof Error ? err.message : String(err)
-      };
-      return JSON.stringify(result);
-    }
-  }
-  let fileStats;
-  try {
-    fileStats = await stat(filePath);
-  } catch (err) {
-    const result = {
-      success: false,
-      output: "",
-      error: `File not found: ${filePath}`
-    };
-    return JSON.stringify(result);
-  }
-  if (!fileStats.isFile()) {
-    const result = {
-      success: false,
-      output: "",
-      error: `Path is not a file: ${filePath}`
-    };
-    return JSON.stringify(result);
-  }
-  let buffer;
-  try {
-    buffer = await readFile(filePath);
-  } catch (err) {
-    const result = {
-      success: false,
-      output: "",
-      error: err instanceof Error ? err.message : String(err)
-    };
-    return JSON.stringify(result);
-  }
-  if (isBinary(buffer)) {
-    const result = {
-      success: false,
-      output: "",
-      error: `Binary file not supported: ${filePath}`
-    };
-    return JSON.stringify(result);
-  }
-  const content = buffer.toString("utf8");
-  return formatReadResult(filePath, content, startLine, limit);
+	const { filePath, offset, limit = DEFAULT_LIMIT$1 } = args;
+	const startLine = offset !== void 0 && offset > 0 ? offset : 1;
+	if (options.sandboxClient) try {
+		return formatReadResult(filePath, await options.sandboxClient.readFile(filePath), startLine, limit);
+	} catch (err) {
+		const result = {
+			success: false,
+			output: "",
+			error: err instanceof Error ? err.message : String(err)
+		};
+		return JSON.stringify(result);
+	}
+	let fileStats;
+	try {
+		fileStats = await stat(filePath);
+	} catch (err) {
+		const result = {
+			success: false,
+			output: "",
+			error: `File not found: ${filePath}`
+		};
+		return JSON.stringify(result);
+	}
+	if (!fileStats.isFile()) {
+		const result = {
+			success: false,
+			output: "",
+			error: `Path is not a file: ${filePath}`
+		};
+		return JSON.stringify(result);
+	}
+	let buffer;
+	try {
+		buffer = await readFile(filePath);
+	} catch (err) {
+		const result = {
+			success: false,
+			output: "",
+			error: err instanceof Error ? err.message : String(err)
+		};
+		return JSON.stringify(result);
+	}
+	if (isBinary(buffer)) {
+		const result = {
+			success: false,
+			output: "",
+			error: `Binary file not supported: ${filePath}`
+		};
+		return JSON.stringify(result);
+	}
+	return formatReadResult(filePath, buffer.toString("utf8"), startLine, limit);
 }
+/**
+* Create a ReadTool instance — register with Robota agent tools registry.
+*/
 function createReadTool(options = {}) {
-  return createZodFunctionTool(
-    "Read",
-    "Reads a file from the local filesystem.\n\nBy default, reads up to 2000 lines from the beginning of the file. You can optionally specify offset and limit for partial reads.\n\nResults are returned using cat -n format, with line numbers starting at 1.\n\nThe file_path parameter must be an absolute path, not a relative path.",
-    ReadSchema,
-    async (params) => {
-      return readFileTool(params, options);
-    }
-  );
+	return createZodFunctionTool("Read", "Reads a file from the local filesystem.\n\nBy default, reads up to 2000 lines from the beginning of the file. You can optionally specify offset and limit for partial reads.\n\nResults are returned using cat -n format, with line numbers starting at 1.\n\nThe file_path parameter must be an absolute path, not a relative path.", ReadSchema, async (params) => {
+		return readFileTool(params, options);
+	});
 }
-var readTool = createReadTool();
-var TEMP_RANDOM_BYTES = 6;
-var PRESERVED_MODE_BITS = 4095;
-var MISSING_FILE_ERROR_CODE = "ENOENT";
+/**
+* ReadTool instance — register with Robota agent tools registry.
+*/
+const readTool = createReadTool();
+//#endregion
+//#region src/builtins/atomic-file-write.ts
+const TEMP_RANDOM_BYTES = 6;
+const PRESERVED_MODE_BITS = 4095;
+const MISSING_FILE_ERROR_CODE = "ENOENT";
 function createTempFilePath(filePath) {
-  const dir = dirname(filePath);
-  const name = basename(filePath);
-  const suffix = randomBytes(TEMP_RANDOM_BYTES).toString("hex");
-  return join(dir, `.${name}.robota-tmp-${process.pid}-${Date.now()}-${suffix}`);
+	const dir = dirname(filePath);
+	const name = basename(filePath);
+	const suffix = randomBytes(TEMP_RANDOM_BYTES).toString("hex");
+	return join(dir, `.${name}.robota-tmp-${process.pid}-${Date.now()}-${suffix}`);
 }
 async function readExistingMode(filePath) {
-  try {
-    const fileStats = await stat(filePath);
-    return fileStats.mode & PRESERVED_MODE_BITS;
-  } catch (error) {
-    if (error instanceof Error && hasErrorCode(error, MISSING_FILE_ERROR_CODE)) return void 0;
-    throw error;
-  }
+	try {
+		return (await stat(filePath)).mode & PRESERVED_MODE_BITS;
+	} catch (error) {
+		if (error instanceof Error && hasErrorCode(error, MISSING_FILE_ERROR_CODE)) return void 0;
+		throw error;
+	}
 }
 function hasErrorCode(error, code) {
-  return "code" in error && error.code === code;
+	return "code" in error && error.code === code;
 }
 async function atomicWriteUtf8File(filePath, content) {
-  const dir = dirname(filePath);
-  await mkdir(dir, { recursive: true });
-  const existingMode = await readExistingMode(filePath);
-  const tempFilePath = createTempFilePath(filePath);
-  try {
-    await writeFile(tempFilePath, content, "utf8");
-    if (existingMode !== void 0) {
-      await chmod(tempFilePath, existingMode);
-    }
-    await rename(tempFilePath, filePath);
-  } catch (error) {
-    await rm(tempFilePath, { force: true }).catch(() => void 0);
-    throw error;
-  }
+	await mkdir(dirname(filePath), { recursive: true });
+	const existingMode = await readExistingMode(filePath);
+	const tempFilePath = createTempFilePath(filePath);
+	try {
+		await writeFile(tempFilePath, content, "utf8");
+		if (existingMode !== void 0) await chmod(tempFilePath, existingMode);
+		await rename(tempFilePath, filePath);
+	} catch (error) {
+		await rm(tempFilePath, { force: true }).catch(() => void 0);
+		throw error;
+	}
 }
-
-// src/builtins/write-tool.ts
-var WriteSchema = z.object({
-  filePath: z.string().describe("The absolute path to the file to write"),
-  content: z.string().describe("The content to write to the file")
+//#endregion
+//#region src/builtins/write-tool.ts
+/**
+* WriteTool — write content to a file, auto-creating parent directories.
+*/
+const WriteSchema = z.object({
+	filePath: z.string().describe("The absolute path to the file to write"),
+	content: z.string().describe("The content to write to the file")
 });
 async function writeFileTool(args, options = {}) {
-  const { filePath, content } = args;
-  try {
-    if (options.sandboxClient) {
-      await options.sandboxClient.writeFile(filePath, content);
-    } else {
-      await atomicWriteUtf8File(filePath, content);
-    }
-    const result = {
-      success: true,
-      output: `Written ${Buffer.byteLength(content, "utf8")} bytes to ${filePath}`
-    };
-    return JSON.stringify(result);
-  } catch (err) {
-    const result = {
-      success: false,
-      output: "",
-      error: err instanceof Error ? err.message : String(err)
-    };
-    return JSON.stringify(result);
-  }
+	const { filePath, content } = args;
+	try {
+		if (options.sandboxClient) await options.sandboxClient.writeFile(filePath, content);
+		else await atomicWriteUtf8File(filePath, content);
+		const result = {
+			success: true,
+			output: `Written ${Buffer.byteLength(content, "utf8")} bytes to ${filePath}`
+		};
+		return JSON.stringify(result);
+	} catch (err) {
+		const result = {
+			success: false,
+			output: "",
+			error: err instanceof Error ? err.message : String(err)
+		};
+		return JSON.stringify(result);
+	}
 }
+/**
+* Create a WriteTool instance — register with Robota agent tools registry.
+*/
 function createWriteTool(options = {}) {
-  return createZodFunctionTool(
-    "Write",
-    "Writes a file to the local filesystem. This will overwrite an existing file if one exists.\n\nALWAYS prefer the Edit tool for modifying existing files \u2014 it only sends the diff. Only use this tool to create new files or for complete rewrites.\n\nNEVER create documentation files (*.md) or README files unless explicitly requested by the user.",
-    WriteSchema,
-    async (params) => {
-      return writeFileTool(params, options);
-    }
-  );
+	return createZodFunctionTool("Write", "Writes a file to the local filesystem. This will overwrite an existing file if one exists.\n\nALWAYS prefer the Edit tool for modifying existing files — it only sends the diff. Only use this tool to create new files or for complete rewrites.\n\nNEVER create documentation files (*.md) or README files unless explicitly requested by the user.", WriteSchema, async (params) => {
+		return writeFileTool(params, options);
+	});
 }
-var writeTool = createWriteTool();
-var EditSchema = z.object({
-  filePath: z.string().describe("The absolute path to the file to modify"),
-  oldString: z.string().describe("The text to replace (must be an exact match of existing content)"),
-  newString: z.string().describe("The text to replace it with (must be different from old_string)"),
-  replaceAll: z.boolean().optional().describe(
-    "Replace all occurrences of old_string (default: false). Useful for renaming variables"
-  )
+/**
+* WriteTool instance — register with Robota agent tools registry.
+*/
+const writeTool = createWriteTool();
+//#endregion
+//#region src/builtins/edit-tool.ts
+/**
+* EditTool — perform string-replace edits on a file.
+*
+* By default, requires the oldString to appear exactly once in the file
+* (ensuring surgical edits). Pass replaceAll:true to replace all occurrences.
+*/
+const EditSchema = z.object({
+	filePath: z.string().describe("The absolute path to the file to modify"),
+	oldString: z.string().describe("The text to replace (must be an exact match of existing content)"),
+	newString: z.string().describe("The text to replace it with (must be different from old_string)"),
+	replaceAll: z.boolean().optional().describe("Replace all occurrences of old_string (default: false). Useful for renaming variables")
 });
 async function editFileTool(args, options = {}) {
-  const { filePath, oldString, newString, replaceAll = false } = args;
-  let content;
-  try {
-    content = options.sandboxClient ? await options.sandboxClient.readFile(filePath) : await readFile(filePath, "utf8");
-  } catch (err) {
-    const result2 = {
-      success: false,
-      output: "",
-      error: `File not found: ${filePath}`
-    };
-    return JSON.stringify(result2);
-  }
-  if (!content.includes(oldString)) {
-    const result2 = {
-      success: false,
-      output: "",
-      error: `oldString not found in file: ${filePath}`
-    };
-    return JSON.stringify(result2);
-  }
-  if (!replaceAll) {
-    const firstIdx = content.indexOf(oldString);
-    const lastIdx = content.lastIndexOf(oldString);
-    if (firstIdx !== lastIdx) {
-      const occurrences = content.split(oldString).length - 1;
-      const result2 = {
-        success: false,
-        output: "",
-        error: `oldString is not unique in file (found ${occurrences} occurrences). Provide more context to make it unique, or use replaceAll:true.`
-      };
-      return JSON.stringify(result2);
-    }
-  }
-  const updated = replaceAll ? content.split(oldString).join(newString) : content.slice(0, content.indexOf(oldString)) + newString + content.slice(content.indexOf(oldString) + oldString.length);
-  try {
-    if (options.sandboxClient) {
-      await options.sandboxClient.writeFile(filePath, updated);
-    } else {
-      await atomicWriteUtf8File(filePath, updated);
-    }
-  } catch (err) {
-    const result2 = {
-      success: false,
-      output: "",
-      error: err instanceof Error ? err.message : String(err)
-    };
-    return JSON.stringify(result2);
-  }
-  const count = replaceAll ? content.split(oldString).length - 1 : 1;
-  const matchIdx = content.indexOf(oldString);
-  const startLine = matchIdx >= 0 ? content.substring(0, matchIdx).split("\n").length : 1;
-  const result = {
-    success: true,
-    output: `Replaced ${count} occurrence(s) in ${filePath}`,
-    startLine
-  };
-  return JSON.stringify(result);
+	const { filePath, oldString, newString, replaceAll = false } = args;
+	let content;
+	try {
+		content = options.sandboxClient ? await options.sandboxClient.readFile(filePath) : await readFile(filePath, "utf8");
+	} catch (err) {
+		const result = {
+			success: false,
+			output: "",
+			error: `File not found: ${filePath}`
+		};
+		return JSON.stringify(result);
+	}
+	if (!content.includes(oldString)) {
+		const result = {
+			success: false,
+			output: "",
+			error: `oldString not found in file: ${filePath}`
+		};
+		return JSON.stringify(result);
+	}
+	if (!replaceAll) {
+		if (content.indexOf(oldString) !== content.lastIndexOf(oldString)) {
+			const result = {
+				success: false,
+				output: "",
+				error: `oldString is not unique in file (found ${content.split(oldString).length - 1} occurrences). Provide more context to make it unique, or use replaceAll:true.`
+			};
+			return JSON.stringify(result);
+		}
+	}
+	const updated = replaceAll ? content.split(oldString).join(newString) : content.slice(0, content.indexOf(oldString)) + newString + content.slice(content.indexOf(oldString) + oldString.length);
+	try {
+		if (options.sandboxClient) await options.sandboxClient.writeFile(filePath, updated);
+		else await atomicWriteUtf8File(filePath, updated);
+	} catch (err) {
+		const result = {
+			success: false,
+			output: "",
+			error: err instanceof Error ? err.message : String(err)
+		};
+		return JSON.stringify(result);
+	}
+	const count = replaceAll ? content.split(oldString).length - 1 : 1;
+	const matchIdx = content.indexOf(oldString);
+	const startLine = matchIdx >= 0 ? content.substring(0, matchIdx).split("\n").length : 1;
+	const result = {
+		success: true,
+		output: `Replaced ${count} occurrence(s) in ${filePath}`,
+		startLine
+	};
+	return JSON.stringify(result);
 }
+/**
+* Create an EditTool instance — register with Robota agent tools registry.
+*/
 function createEditTool(options = {}) {
-  return createZodFunctionTool(
-    "Edit",
-    "Performs exact string replacements in files.\n\nYou must use the Read tool at least once before editing. When editing text from Read output, preserve the exact indentation.\n\nThe edit will FAIL if old_string is not unique in the file. Either provide more surrounding context to make it unique, or use replace_all to change every instance.\n\nALWAYS prefer editing existing files over creating new ones.",
-    EditSchema,
-    async (params) => {
-      return editFileTool(params, options);
-    }
-  );
+	return createZodFunctionTool("Edit", "Performs exact string replacements in files.\n\nYou must use the Read tool at least once before editing. When editing text from Read output, preserve the exact indentation.\n\nThe edit will FAIL if old_string is not unique in the file. Either provide more surrounding context to make it unique, or use replace_all to change every instance.\n\nALWAYS prefer editing existing files over creating new ones.", EditSchema, async (params) => {
+		return editFileTool(params, options);
+	});
 }
-var editTool = createEditTool();
-var DEFAULT_MAX_RESULTS = 1e3;
-var GlobSchema = z.object({
-  pattern: z.string().describe('The glob pattern to match files against (e.g. "**/*.ts", "src/**/*.tsx")'),
-  path: z.string().optional().describe(
-    "The directory to search in. Defaults to the current working directory. Must be a valid directory path if provided"
-  ),
-  limit: z.number().optional().describe(
-    "Maximum number of results to return (default: 1000). Use a smaller limit to save context space"
-  )
+/**
+* EditTool instance — register with Robota agent tools registry.
+*/
+const editTool = createEditTool();
+//#endregion
+//#region src/builtins/glob-tool.ts
+/**
+* GlobTool — fast file pattern search using fast-glob.
+*
+* Excludes node_modules and .git by default.
+* Results are sorted by modification time (most recently modified first).
+*/
+const DEFAULT_MAX_RESULTS = 1e3;
+const GlobSchema = z.object({
+	pattern: z.string().describe("The glob pattern to match files against (e.g. \"**/*.ts\", \"src/**/*.tsx\")"),
+	path: z.string().optional().describe("The directory to search in. Defaults to the current working directory. Must be a valid directory path if provided"),
+	limit: z.number().optional().describe("Maximum number of results to return (default: 1000). Use a smaller limit to save context space")
 });
 async function globFileTool(args) {
-  const { pattern, path: basePath } = args;
-  const cwd = basePath ? resolve(basePath) : process.cwd();
-  let matches;
-  try {
-    matches = await fg(pattern, {
-      cwd,
-      ignore: ["**/node_modules/**", "**/.git/**"],
-      dot: true,
-      absolute: false
-    });
-  } catch (err) {
-    const result2 = {
-      success: false,
-      output: "",
-      error: err instanceof Error ? err.message : String(err)
-    };
-    return JSON.stringify(result2);
-  }
-  const withMtime = await Promise.all(
-    matches.map(async (p) => {
-      const absPath = resolve(cwd, p);
-      try {
-        const s = await stat(absPath);
-        return { path: p, mtime: s.mtimeMs };
-      } catch {
-        return { path: p, mtime: 0 };
-      }
-    })
-  );
-  withMtime.sort((a, b) => b.mtime - a.mtime);
-  const maxResults = args.limit ?? DEFAULT_MAX_RESULTS;
-  const totalMatches = withMtime.length;
-  const truncated = totalMatches > maxResults;
-  const limited = truncated ? withMtime.slice(0, maxResults) : withMtime;
-  const sorted = limited.map((f) => f.path);
-  let output = sorted.length > 0 ? sorted.join("\n") : "(no matches)";
-  if (truncated) {
-    output += `
-
-[Showing ${maxResults} of ${totalMatches} matches. Use limit parameter to see more.]`;
-  }
-  const result = {
-    success: true,
-    output
-  };
-  return JSON.stringify(result);
+	const { pattern, path: basePath } = args;
+	const cwd = basePath ? resolve(basePath) : process.cwd();
+	let matches;
+	try {
+		matches = await fg(pattern, {
+			cwd,
+			ignore: ["**/node_modules/**", "**/.git/**"],
+			dot: true,
+			absolute: false
+		});
+	} catch (err) {
+		const result = {
+			success: false,
+			output: "",
+			error: err instanceof Error ? err.message : String(err)
+		};
+		return JSON.stringify(result);
+	}
+	const withMtime = await Promise.all(matches.map(async (p) => {
+		const absPath = resolve(cwd, p);
+		try {
+			return {
+				path: p,
+				mtime: (await stat(absPath)).mtimeMs
+			};
+		} catch {
+			return {
+				path: p,
+				mtime: 0
+			};
+		}
+	}));
+	withMtime.sort((a, b) => b.mtime - a.mtime);
+	const maxResults = args.limit ?? DEFAULT_MAX_RESULTS;
+	const totalMatches = withMtime.length;
+	const truncated = totalMatches > maxResults;
+	const sorted = (truncated ? withMtime.slice(0, maxResults) : withMtime).map((f) => f.path);
+	let output = sorted.length > 0 ? sorted.join("\n") : "(no matches)";
+	if (truncated) output += `\n\n[Showing ${maxResults} of ${totalMatches} matches. Use limit parameter to see more.]`;
+	return JSON.stringify({
+		success: true,
+		output
+	});
 }
-var globTool = createZodFunctionTool(
-  "Glob",
-  "Fast file pattern matching tool that works with any codebase size.\n\nSupports glob patterns like '**/*.js' or 'src/**/*.ts'. Returns matching file paths sorted by modification time.\n\nUse this tool when you need to find files by name patterns. When doing an open-ended search that may require multiple rounds, use the Agent tool instead.\n\nDefault limit is 1000 results. Use the limit parameter if you need fewer results to save context space.",
-  GlobSchema,
-  async (params) => {
-    return globFileTool(params);
-  }
-);
-var GrepSchema = z.object({
-  pattern: z.string().describe("The regular expression pattern to search for in file contents"),
-  path: z.string().optional().describe("File or directory to search in. Defaults to the current working directory"),
-  glob: z.string().optional().describe(
-    'Glob pattern to filter files (e.g. "*.ts", "*.{ts,tsx}"). Only files matching this pattern will be searched'
-  ),
-  contextLines: z.number().optional().describe(
-    'Number of context lines to show before and after each match. Only applies when outputMode is "content". Default: 0'
-  ),
-  outputMode: z.enum(["files_with_matches", "content"]).optional().describe(
-    'Output mode: "files_with_matches" shows only file paths (default), "content" shows matching lines with context'
-  )
+/**
+* GlobTool instance — register with Robota agent tools registry.
+*/
+const globTool = createZodFunctionTool("Glob", "Fast file pattern matching tool that works with any codebase size.\n\nSupports glob patterns like '**/*.js' or 'src/**/*.ts'. Returns matching file paths sorted by modification time.\n\nUse this tool when you need to find files by name patterns. When doing an open-ended search that may require multiple rounds, use the Agent tool instead.\n\nDefault limit is 1000 results. Use the limit parameter if you need fewer results to save context space.", GlobSchema, async (params) => {
+	return globFileTool(params);
+});
+//#endregion
+//#region src/builtins/grep-tool.ts
+/**
+* GrepTool — recursive regex content search.
+*
+* Supports two output modes:
+* - files_with_matches (default): return only file paths that contain a match
+* - content: return matching lines with optional context lines
+*/
+const GrepSchema = z.object({
+	pattern: z.string().describe("The regular expression pattern to search for in file contents"),
+	path: z.string().optional().describe("File or directory to search in. Defaults to the current working directory"),
+	glob: z.string().optional().describe("Glob pattern to filter files (e.g. \"*.ts\", \"*.{ts,tsx}\"). Only files matching this pattern will be searched"),
+	contextLines: z.number().optional().describe("Number of context lines to show before and after each match. Only applies when outputMode is \"content\". Default: 0"),
+	outputMode: z.enum(["files_with_matches", "content"]).optional().describe("Output mode: \"files_with_matches\" shows only file paths (default), \"content\" shows matching lines with context")
 });
+/** Convert a simple glob to a RegExp for file name filtering. */
 function globToRegex(glob) {
-  const escaped = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, ".+").replace(/\*/g, "[^/]*");
-  return new RegExp(`^${escaped}$`);
+	const escaped = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, ".+").replace(/\*/g, "[^/]*");
+	return new RegExp(`^${escaped}$`);
 }
+/** Check if a file name matches an optional glob filter. */
 function matchesGlob(filename, glob) {
-  if (glob === void 0) return true;
-  return globToRegex(glob).test(filename);
+	if (glob === void 0) return true;
+	return globToRegex(glob).test(filename);
 }
+/** Gather all files under a directory recursively, excluding node_modules/.git. */
 async function collectFiles(dirPath, glob) {
-  const results = [];
-  async function walk(current) {
-    let entryNames;
-    try {
-      entryNames = await readdir(current);
-    } catch {
-      return;
-    }
-    for (const name of entryNames) {
-      if (name === "node_modules" || name === ".git") continue;
-      const fullPath = join(current, name);
-      let fileStat;
-      try {
-        fileStat = await stat(fullPath);
-      } catch {
-        continue;
-      }
-      if (fileStat.isDirectory()) {
-        await walk(fullPath);
-      } else if (fileStat.isFile()) {
-        if (matchesGlob(name, glob)) {
-          results.push(fullPath);
-        }
-      }
-    }
-  }
-  await walk(dirPath);
-  return results;
+	const results = [];
+	async function walk(current) {
+		let entryNames;
+		try {
+			entryNames = await readdir(current);
+		} catch {
+			return;
+		}
+		for (const name of entryNames) {
+			if (name === "node_modules" || name === ".git") continue;
+			const fullPath = join(current, name);
+			let fileStat;
+			try {
+				fileStat = await stat(fullPath);
+			} catch {
+				continue;
+			}
+			if (fileStat.isDirectory()) await walk(fullPath);
+			else if (fileStat.isFile()) {
+				if (matchesGlob(name, glob)) results.push(fullPath);
+			}
+		}
+	}
+	await walk(dirPath);
+	return results;
 }
+/** Search a single file for lines matching the regex. */
 function searchFile(content, filePath, regex, contextLines, outputMode) {
-  const lines = content.split("\n");
-  const matchingIndices = [];
-  for (let i = 0; i < lines.length; i++) {
-    if (regex.test(lines[i])) {
-      matchingIndices.push(i);
-    }
-  }
-  if (matchingIndices.length === 0) return [];
-  if (outputMode === "files_with_matches") {
-    return [filePath];
-  }
-  const includedIndices = /* @__PURE__ */ new Set();
-  for (const idx of matchingIndices) {
-    for (let c = Math.max(0, idx - contextLines); c <= Math.min(lines.length - 1, idx + contextLines); c++) {
-      includedIndices.add(c);
-    }
-  }
-  const outputLines = [];
-  const sortedIndices = Array.from(includedIndices).sort((a, b) => a - b);
-  let prevIdx;
-  for (const idx of sortedIndices) {
-    if (prevIdx !== void 0 && idx > prevIdx + 1) {
-      outputLines.push("--");
-    }
-    const lineNum = idx + 1;
-    const marker = matchingIndices.includes(idx) ? ":" : "-";
-    outputLines.push(`${filePath}:${lineNum}${marker}${lines[idx]}`);
-    prevIdx = idx;
-  }
-  return outputLines;
+	const lines = content.split("\n");
+	const matchingIndices = [];
+	for (let i = 0; i < lines.length; i++) if (regex.test(lines[i])) matchingIndices.push(i);
+	if (matchingIndices.length === 0) return [];
+	if (outputMode === "files_with_matches") return [filePath];
+	const includedIndices = /* @__PURE__ */ new Set();
+	for (const idx of matchingIndices) for (let c = Math.max(0, idx - contextLines); c <= Math.min(lines.length - 1, idx + contextLines); c++) includedIndices.add(c);
+	const outputLines = [];
+	const sortedIndices = Array.from(includedIndices).sort((a, b) => a - b);
+	let prevIdx;
+	for (const idx of sortedIndices) {
+		if (prevIdx !== void 0 && idx > prevIdx + 1) outputLines.push("--");
+		const lineNum = idx + 1;
+		const marker = matchingIndices.includes(idx) ? ":" : "-";
+		outputLines.push(`${filePath}:${lineNum}${marker}${lines[idx]}`);
+		prevIdx = idx;
+	}
+	return outputLines;
 }
 async function grepFileTool(args) {
-  const {
-    pattern,
-    path: searchPath,
-    glob,
-    contextLines = 0,
-    outputMode = "files_with_matches"
-  } = args;
-  const targetPath = searchPath ? resolve(searchPath) : process.cwd();
-  let regex;
-  try {
-    regex = new RegExp(pattern);
-  } catch (err) {
-    const result2 = {
-      success: false,
-      output: "",
-      error: `Invalid regex pattern: ${pattern}`
-    };
-    return JSON.stringify(result2);
-  }
-  let targetStat;
-  try {
-    targetStat = await stat(targetPath);
-  } catch {
-    const result2 = {
-      success: false,
-      output: "",
-      error: `Path not found: ${targetPath}`
-    };
-    return JSON.stringify(result2);
-  }
-  let files;
-  if (targetStat.isFile()) {
-    files = [targetPath];
-  } else {
-    files = await collectFiles(targetPath, glob);
-  }
-  const allOutputLines = [];
-  for (const filePath of files) {
-    let content;
-    try {
-      const buffer = await readFile(filePath);
-      const checkLen = Math.min(buffer.length, 8192);
-      let hasBinary = false;
-      for (let i = 0; i < checkLen; i++) {
-        if (buffer[i] === 0) {
-          hasBinary = true;
-          break;
-        }
-      }
-      if (hasBinary) continue;
-      content = buffer.toString("utf8");
-    } catch {
-      continue;
-    }
-    const fileMatches = searchFile(content, filePath, regex, contextLines, outputMode);
-    allOutputLines.push(...fileMatches);
-  }
-  const result = {
-    success: true,
-    output: allOutputLines.length > 0 ? allOutputLines.join("\n") : "(no matches)"
-  };
-  return JSON.stringify(result);
+	const { pattern, path: searchPath, glob, contextLines = 0, outputMode = "files_with_matches" } = args;
+	const targetPath = searchPath ? resolve(searchPath) : process.cwd();
+	let regex;
+	try {
+		regex = new RegExp(pattern);
+	} catch (err) {
+		const result = {
+			success: false,
+			output: "",
+			error: `Invalid regex pattern: ${pattern}`
+		};
+		return JSON.stringify(result);
+	}
+	let targetStat;
+	try {
+		targetStat = await stat(targetPath);
+	} catch {
+		const result = {
+			success: false,
+			output: "",
+			error: `Path not found: ${targetPath}`
+		};
+		return JSON.stringify(result);
+	}
+	let files;
+	if (targetStat.isFile()) files = [targetPath];
+	else files = await collectFiles(targetPath, glob);
+	const allOutputLines = [];
+	for (const filePath of files) {
+		let content;
+		try {
+			const buffer = await readFile(filePath);
+			const checkLen = Math.min(buffer.length, 8192);
+			let hasBinary = false;
+			for (let i = 0; i < checkLen; i++) if (buffer[i] === 0) {
+				hasBinary = true;
+				break;
+			}
+			if (hasBinary) continue;
+			content = buffer.toString("utf8");
+		} catch {
+			continue;
+		}
+		const fileMatches = searchFile(content, filePath, regex, contextLines, outputMode);
+		allOutputLines.push(...fileMatches);
+	}
+	const result = {
+		success: true,
+		output: allOutputLines.length > 0 ? allOutputLines.join("\n") : "(no matches)"
+	};
+	return JSON.stringify(result);
 }
-var grepTool = createZodFunctionTool(
-  "Grep",
-  "A powerful search tool built on regex matching.\n\nSupports full regex syntax (e.g., 'log.*Error', 'function\\\\s+\\\\w+'). Filter files with glob parameter (e.g., '*.js', '**/*.tsx').\n\nOutput modes: 'content' shows matching lines with context, 'files_with_matches' shows only file paths (default), 'count' shows match counts.\n\nUse this tool for ALL search tasks. NEVER invoke grep or rg as a Bash command.\n\nUse head_limit to control result size and save context space.",
-  GrepSchema,
-  async (params) => {
-    return grepFileTool(params);
-  }
-);
-var DEFAULT_TIMEOUT_MS2 = 3e4;
-var MAX_RESPONSE_BYTES = 5e6;
-var WebFetchSchema = z.object({
-  url: z.string().describe("The URL to fetch"),
-  headers: z.record(z.string()).optional().describe("Optional HTTP headers as key-value pairs")
+/**
+* GrepTool instance — register with Robota agent tools registry.
+*/
+const grepTool = createZodFunctionTool("Grep", "A powerful search tool built on regex matching.\n\nSupports full regex syntax (e.g., 'log.*Error', 'function\\\\s+\\\\w+'). Filter files with glob parameter (e.g., '*.js', '**/*.tsx').\n\nOutput modes: 'content' shows matching lines with context, 'files_with_matches' shows only file paths (default), 'count' shows match counts.\n\nUse this tool for ALL search tasks. NEVER invoke grep or rg as a Bash command.\n\nUse head_limit to control result size and save context space.", GrepSchema, async (params) => {
+	return grepFileTool(params);
 });
+//#endregion
+//#region src/builtins/web-fetch-tool.ts
+/**
+* WebFetchTool — fetch a URL and return its content as text.
+*
+* HTML is stripped to plain text for readability. Uses Node.js native fetch.
+* Output is capped at 30K chars (same as other tools).
+*/
+const DEFAULT_TIMEOUT_MS$1 = 3e4;
+const MAX_RESPONSE_BYTES = 5e6;
+const WebFetchSchema = z.object({
+	url: z.string().describe("The URL to fetch"),
+	headers: z.record(z.string()).optional().describe("Optional HTTP headers as key-value pairs")
+});
+/** Strip HTML tags and decode common entities to produce readable text. */
 function htmlToText(html) {
-  return html.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<[^>]+>/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&nbsp;/g, " ").replace(/\s+/g, " ").trim();
+	return html.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<[^>]+>/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, "\"").replace(/&#39;/g, "'").replace(/&nbsp;/g, " ").replace(/\s+/g, " ").trim();
 }
 async function runWebFetch(args) {
-  const { url, headers } = args;
-  try {
-    new URL(url);
-  } catch {
-    const result = { success: false, output: "", error: `Invalid URL: ${url}` };
-    return JSON.stringify(result);
-  }
-  try {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), DEFAULT_TIMEOUT_MS2);
-    const response = await fetch(url, {
-      headers: {
-        "User-Agent": "Robota-CLI/3.0",
-        ...headers ?? {}
-      },
-      signal: controller.signal,
-      redirect: "follow"
-    });
-    clearTimeout(timeout);
-    if (!response.ok) {
-      const result2 = {
-        success: false,
-        output: "",
-        error: `HTTP ${response.status} ${response.statusText}`
-      };
-      return JSON.stringify(result2);
-    }
-    const contentType = response.headers.get("content-type") ?? "";
-    const buffer = await response.arrayBuffer();
-    if (buffer.byteLength > MAX_RESPONSE_BYTES) {
-      const result2 = {
-        success: false,
-        output: "",
-        error: `Response too large: ${buffer.byteLength} bytes (max ${MAX_RESPONSE_BYTES})`
-      };
-      return JSON.stringify(result2);
-    }
-    let text = new TextDecoder().decode(buffer);
-    if (contentType.includes("html")) {
-      text = htmlToText(text);
-    }
-    const result = { success: true, output: text };
-    return JSON.stringify(result);
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    const result = { success: false, output: "", error: message };
-    return JSON.stringify(result);
-  }
+	const { url, headers } = args;
+	try {
+		new URL(url);
+	} catch {
+		const result = {
+			success: false,
+			output: "",
+			error: `Invalid URL: ${url}`
+		};
+		return JSON.stringify(result);
+	}
+	try {
+		const controller = new AbortController();
+		const timeout = setTimeout(() => controller.abort(), DEFAULT_TIMEOUT_MS$1);
+		const response = await fetch(url, {
+			headers: {
+				"User-Agent": "Robota-CLI/3.0",
+				...headers ?? {}
+			},
+			signal: controller.signal,
+			redirect: "follow"
+		});
+		clearTimeout(timeout);
+		if (!response.ok) {
+			const result = {
+				success: false,
+				output: "",
+				error: `HTTP ${response.status} ${response.statusText}`
+			};
+			return JSON.stringify(result);
+		}
+		const contentType = response.headers.get("content-type") ?? "";
+		const buffer = await response.arrayBuffer();
+		if (buffer.byteLength > MAX_RESPONSE_BYTES) {
+			const result = {
+				success: false,
+				output: "",
+				error: `Response too large: ${buffer.byteLength} bytes (max ${MAX_RESPONSE_BYTES})`
+			};
+			return JSON.stringify(result);
+		}
+		let text = new TextDecoder().decode(buffer);
+		if (contentType.includes("html")) text = htmlToText(text);
+		return JSON.stringify({
+			success: true,
+			output: text
+		});
+	} catch (err) {
+		const result = {
+			success: false,
+			output: "",
+			error: err instanceof Error ? err.message : String(err)
+		};
+		return JSON.stringify(result);
+	}
 }
-var webFetchTool = createZodFunctionTool(
-  "WebFetch",
-  "Fetch a URL and return its content as text. HTML pages are converted to plain text.",
-  WebFetchSchema,
-  async (params) => runWebFetch(params)
-);
-var DEFAULT_LIMIT2 = 10;
-var DEFAULT_TIMEOUT_MS3 = 15e3;
-var WebSearchSchema = z.object({
-  query: z.string().describe("The search query"),
-  limit: z.number().optional().describe(`Maximum number of results to return (default: ${DEFAULT_LIMIT2})`)
+const webFetchTool = createZodFunctionTool("WebFetch", "Fetch a URL and return its content as text. HTML pages are converted to plain text.", WebFetchSchema, async (params) => runWebFetch(params));
+//#endregion
+//#region src/builtins/web-search-tool.ts
+/**
+* WebSearchTool — search the web and return results.
+*
+* Uses Brave Search API when BRAVE_API_KEY is set.
+* Returns an error with setup instructions otherwise.
+*/
+const DEFAULT_LIMIT = 10;
+const DEFAULT_TIMEOUT_MS = 15e3;
+const WebSearchSchema = z.object({
+	query: z.string().describe("The search query"),
+	limit: z.number().optional().describe(`Maximum number of results to return (default: ${DEFAULT_LIMIT})`)
 });
 async function runWebSearch(args) {
-  const { query, limit = DEFAULT_LIMIT2 } = args;
-  const apiKey = process.env["BRAVE_API_KEY"];
-  if (!apiKey) {
-    const result = {
-      success: false,
-      output: "",
-      error: "Web search requires BRAVE_API_KEY environment variable. Get a free API key at https://brave.com/search/api/ (2,000 queries/month free)."
-    };
-    return JSON.stringify(result);
-  }
-  try {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), DEFAULT_TIMEOUT_MS3);
-    const params = new URLSearchParams({
-      q: query,
-      count: String(Math.min(limit, 20))
-    });
-    const response = await fetch(`https://api.search.brave.com/res/v1/web/search?${params}`, {
-      headers: {
-        Accept: "application/json",
-        "Accept-Encoding": "gzip",
-        "X-Subscription-Token": apiKey
-      },
-      signal: controller.signal
-    });
-    clearTimeout(timeout);
-    if (!response.ok) {
-      const result2 = {
-        success: false,
-        output: "",
-        error: `Brave Search API error: HTTP ${response.status} ${response.statusText}`
-      };
-      return JSON.stringify(result2);
-    }
-    const data = await response.json();
-    const results = (data.web?.results ?? []).map((r) => ({
-      title: r.title,
-      url: r.url,
-      snippet: r.description
-    }));
-    const result = { success: true, output: JSON.stringify(results, null, 2) };
-    return JSON.stringify(result);
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    const result = { success: false, output: "", error: message };
-    return JSON.stringify(result);
-  }
+	const { query, limit = DEFAULT_LIMIT } = args;
+	const apiKey = process.env["BRAVE_API_KEY"];
+	if (!apiKey) return JSON.stringify({
+		success: false,
+		output: "",
+		error: "Web search requires BRAVE_API_KEY environment variable. Get a free API key at https://brave.com/search/api/ (2,000 queries/month free)."
+	});
+	try {
+		const controller = new AbortController();
+		const timeout = setTimeout(() => controller.abort(), DEFAULT_TIMEOUT_MS);
+		const params = new URLSearchParams({
+			q: query,
+			count: String(Math.min(limit, 20))
+		});
+		const response = await fetch(`https://api.search.brave.com/res/v1/web/search?${params}`, {
+			headers: {
+				Accept: "application/json",
+				"Accept-Encoding": "gzip",
+				"X-Subscription-Token": apiKey
+			},
+			signal: controller.signal
+		});
+		clearTimeout(timeout);
+		if (!response.ok) {
+			const result = {
+				success: false,
+				output: "",
+				error: `Brave Search API error: HTTP ${response.status} ${response.statusText}`
+			};
+			return JSON.stringify(result);
+		}
+		const results = ((await response.json()).web?.results ?? []).map((r) => ({
+			title: r.title,
+			url: r.url,
+			snippet: r.description
+		}));
+		const result = {
+			success: true,
+			output: JSON.stringify(results, null, 2)
+		};
+		return JSON.stringify(result);
+	} catch (err) {
+		const result = {
+			success: false,
+			output: "",
+			error: err instanceof Error ? err.message : String(err)
+		};
+		return JSON.stringify(result);
+	}
 }
-var webSearchTool = createZodFunctionTool(
-  "WebSearch",
-  "Search the web and return results with title, URL, and snippet.",
-  WebSearchSchema,
-  async (params) => runWebSearch(params)
-);
-
+const webSearchTool = createZodFunctionTool("WebSearch", "Search the web and return results with title, URL, and snippet.", WebSearchSchema, async (params) => runWebSearch(params));
+//#endregion
 export { E2BSandboxClient, FunctionTool, InMemorySandboxClient, OpenAPITool, ToolRegistry, applyWorkspaceManifest, bashTool, createBashTool, createEditTool, createFunctionTool, createOpenAPITool, createReadTool, createWriteTool, createZodFunctionTool, editTool, globTool, grepTool, readTool, validateWorkspaceManifestPath, webFetchTool, webSearchTool, writeTool, zodToJsonSchema };
+
+//# sourceMappingURL=index.js.map