@robota-sdk/agent-tools 3.0.0-beta.1

package/dist/node/index.js

@@ -0,0 +1,1303 @@
+// src/registry/tool-registry.ts
+import { ValidationError } from "@robota-sdk/agent-core";
+import { logger } from "@robota-sdk/agent-core";
+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`
+          );
+        }
+      }
+    }
+  }
+};
+
+// src/implementations/function-tool.ts
+import { ToolExecutionError, ValidationError as ValidationError2 } from "@robota-sdk/agent-core";
+
+// src/implementations/function-tool/schema-converter.ts
+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 && { additionalProperties: true }
+  };
+}
+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.");
+    default:
+      throw new Error(`Unsupported Zod type: ${String(typeDef.typeName)}`);
+  }
+}
+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";
+}
+
+// src/implementations/function-tool.ts
+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 = this.getValidationErrors(parameters);
+      throw new ValidationError2(`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 ValidationError2) {
+        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 this.getValidationErrors(parameters).length === 0;
+  }
+  /**
+   * Validate tool parameters with detailed result
+   */
+  validateParameters(parameters) {
+    const errors = this.getValidationErrors(parameters);
+    return {
+      isValid: errors.length === 0,
+      errors
+    };
+  }
+  /**
+   * Get tool description
+   */
+  getDescription() {
+    return this.schema.description;
+  }
+  /**
+   * Get detailed validation errors
+   */
+  getValidationErrors(parameters) {
+    const errors = [];
+    const required = this.schema.parameters.required || [];
+    const properties = this.schema.parameters.properties || {};
+    for (const field of required) {
+      if (!(field in parameters)) {
+        errors.push(`Missing required parameter: ${field}`);
+      }
+    }
+    for (const [key, value] of Object.entries(parameters)) {
+      const paramSchema = properties[key];
+      if (!paramSchema) {
+        errors.push(`Unknown parameter: ${key}`);
+        continue;
+      }
+      const typeError = this.validateParameterType(key, value, paramSchema);
+      if (typeError) {
+        errors.push(typeError);
+      }
+    }
+    return errors;
+  }
+  /**
+   * Validate individual parameter type
+   */
+  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 = this.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;
+  }
+  /**
+   * Validate constructor inputs
+   */
+  validateConstructorInputs() {
+    if (!this.schema) {
+      throw new ValidationError2("Tool schema is required");
+    }
+    if (!this.fn || typeof this.fn !== "function") {
+      throw new ValidationError2("Tool function is required and must be a function");
+    }
+    if (!this.schema.name) {
+      throw new ValidationError2("Tool schema must have a name");
+    }
+  }
+};
+function createFunctionTool(name, description, parameters, fn) {
+  const schema = {
+    name,
+    description,
+    parameters
+  };
+  return new FunctionTool(schema, fn);
+}
+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 ValidationError2(`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);
+}
+
+// src/implementations/openapi-tool.ts
+import { ToolExecutionError as ToolExecutionError2, ValidationError as ValidationError3 } from "@robota-sdk/agent-core";
+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 ValidationError3(
+        `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 ToolExecutionError2 || error instanceof ValidationError3) {
+        throw error;
+      }
+      const safeError = error instanceof Error ? error : new Error(String(error));
+      throw new ToolExecutionError2(
+        `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 = this.findOperation();
+    if (!operation) {
+      throw new Error(`Operation ${this.operationId} not found in OpenAPI spec`);
+    }
+    const requestConfig = this.buildRequestConfig(operation, parameters);
+    throw new Error("Not implemented: actual API execution is not yet available");
+  }
+  /**
+   * Find the operation in the OpenAPI specification
+   */
+  findOperation() {
+    for (const [path, pathItem] of Object.entries(this.apiSpec.paths || {})) {
+      if (!pathItem) continue;
+      for (const method of [
+        "get",
+        "post",
+        "put",
+        "delete",
+        "patch",
+        "head",
+        "options"
+      ]) {
+        const operation = pathItem[method];
+        if (operation?.operationId === this.operationId) {
+          return { method, path, operation };
+        }
+      }
+    }
+    return void 0;
+  }
+  /**
+   * 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 = this.findOperation();
+    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.`
+      );
+    }
+    const { operation: opSpec } = operation;
+    const properties = {};
+    const required = [];
+    const params = opSpec.parameters || [];
+    for (const param of params) {
+      properties[param.name] = this.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 = this.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: this.operationId,
+      description: opSpec.summary || opSpec.description || `OpenAPI operation: ${this.operationId}`,
+      parameters: schemaParams
+    };
+  }
+  /**
+   * Convert OpenAPI parameter to tool parameter schema
+   */
+  convertOpenAPIParamToSchema(param) {
+    const schema = param.schema;
+    return this.convertOpenAPISchemaToParameterSchema(schema);
+  }
+  /**
+   * Convert OpenAPI schema to parameter schema
+   */
+  convertOpenAPISchemaToParameterSchema(schema) {
+    if ("$ref" in schema) {
+      return { type: "object" };
+    }
+    const result = {
+      type: this.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 = this.convertOpenAPISchemaToParameterSchema(schema.items);
+    }
+    if (schema.type === "object" && schema.properties) {
+      result.properties = {};
+      for (const [propName, propSchema] of Object.entries(schema.properties)) {
+        result.properties[propName] = this.convertOpenAPISchemaToParameterSchema(propSchema);
+      }
+      if (schema.required && schema.required.length > 0) {
+        result.required = schema.required;
+      }
+    }
+    return result;
+  }
+  /**
+   * Map OpenAPI type to JSON schema type
+   */
+  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";
+    }
+  }
+};
+function createOpenAPITool(config) {
+  return new OpenAPITool(config);
+}
+
+// src/builtins/bash-tool.ts
+import { spawn } from "child_process";
+import { z } from "zod";
+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")
+});
+async function runBash(args) {
+  const { command, timeout = DEFAULT_TIMEOUT_MS, workingDirectory } = args;
+  return new Promise((resolve3) => {
+    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");
+    }, timeout);
+    function settle(result) {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve3(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
+      });
+    });
+  });
+}
+var bashTool = 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);
+  }
+);
+
+// src/builtins/read-tool.ts
+import { readFile, stat } from "fs/promises";
+import { z as z2 } from "zod";
+var DEFAULT_LIMIT = 2e3;
+var ReadSchema = z2.object({
+  filePath: z2.string().describe("The absolute path to the file to read"),
+  offset: z2.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: z2.number().optional().describe(
+    `The number of lines to read (default: ${DEFAULT_LIMIT}). Only provide if the file is too large to read at once`
+  )
+});
+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;
+}
+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");
+}
+async function readFileTool(args) {
+  const { filePath, offset, limit = DEFAULT_LIMIT } = args;
+  const startLine = offset !== void 0 && offset > 0 ? offset : 1;
+  let fileStats;
+  try {
+    fileStats = await stat(filePath);
+  } catch (err) {
+    const result2 = {
+      success: false,
+      output: "",
+      error: `File not found: ${filePath}`
+    };
+    return JSON.stringify(result2);
+  }
+  if (!fileStats.isFile()) {
+    const result2 = {
+      success: false,
+      output: "",
+      error: `Path is not a file: ${filePath}`
+    };
+    return JSON.stringify(result2);
+  }
+  let buffer;
+  try {
+    buffer = await readFile(filePath);
+  } catch (err) {
+    const result2 = {
+      success: false,
+      output: "",
+      error: err instanceof Error ? err.message : String(err)
+    };
+    return JSON.stringify(result2);
+  }
+  if (isBinary(buffer)) {
+    const result2 = {
+      success: false,
+      output: "",
+      error: `Binary file not supported: ${filePath}`
+    };
+    return JSON.stringify(result2);
+  }
+  const content = buffer.toString("utf8");
+  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);
+}
+var readTool = 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);
+  }
+);
+
+// src/builtins/write-tool.ts
+import { writeFile, mkdir } from "fs/promises";
+import { dirname } from "path";
+import { z as z3 } from "zod";
+var WriteSchema = z3.object({
+  filePath: z3.string().describe("The absolute path to the file to write"),
+  content: z3.string().describe("The content to write to the file")
+});
+async function writeFileTool(args) {
+  const { filePath, content } = args;
+  try {
+    await mkdir(dirname(filePath), { recursive: true });
+    await writeFile(filePath, content, "utf8");
+    const result = {
+      success: true,
+      output: `Written ${content.length} 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);
+  }
+}
+var writeTool = 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);
+  }
+);
+
+// src/builtins/edit-tool.ts
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { z as z4 } from "zod";
+var EditSchema = z4.object({
+  filePath: z4.string().describe("The absolute path to the file to modify"),
+  oldString: z4.string().describe("The text to replace (must be an exact match of existing content)"),
+  newString: z4.string().describe("The text to replace it with (must be different from old_string)"),
+  replaceAll: z4.boolean().optional().describe(
+    "Replace all occurrences of old_string (default: false). Useful for renaming variables"
+  )
+});
+async function editFileTool(args) {
+  const { filePath, oldString, newString, replaceAll = false } = args;
+  let content;
+  try {
+    content = await readFile2(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 {
+    await writeFile2(filePath, updated, "utf8");
+  } 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 result = {
+    success: true,
+    output: `Replaced ${count} occurrence(s) in ${filePath}`
+  };
+  return JSON.stringify(result);
+}
+var editTool = 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);
+  }
+);
+
+// src/builtins/glob-tool.ts
+import { stat as stat2 } from "fs/promises";
+import { resolve } from "path";
+import fg from "fast-glob";
+import { z as z5 } from "zod";
+var DEFAULT_MAX_RESULTS = 1e3;
+var GlobSchema = z5.object({
+  pattern: z5.string().describe('The glob pattern to match files against (e.g. "**/*.ts", "src/**/*.tsx")'),
+  path: z5.string().optional().describe(
+    "The directory to search in. Defaults to the current working directory. Must be a valid directory path if provided"
+  ),
+  limit: z5.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 stat2(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);
+}
+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);
+  }
+);
+
+// src/builtins/grep-tool.ts
+import { readFile as readFile3, readdir, stat as stat3 } from "fs/promises";
+import { join, resolve as resolve2 } from "path";
+import { z as z6 } from "zod";
+var GrepSchema = z6.object({
+  pattern: z6.string().describe("The regular expression pattern to search for in file contents"),
+  path: z6.string().optional().describe("File or directory to search in. Defaults to the current working directory"),
+  glob: z6.string().optional().describe(
+    'Glob pattern to filter files (e.g. "*.ts", "*.{ts,tsx}"). Only files matching this pattern will be searched'
+  ),
+  contextLines: z6.number().optional().describe(
+    'Number of context lines to show before and after each match. Only applies when outputMode is "content". Default: 0'
+  ),
+  outputMode: z6.enum(["files_with_matches", "content"]).optional().describe(
+    'Output mode: "files_with_matches" shows only file paths (default), "content" shows matching lines with context'
+  )
+});
+function globToRegex(glob) {
+  const escaped = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, ".+").replace(/\*/g, "[^/]*");
+  return new RegExp(`^${escaped}$`);
+}
+function matchesGlob(filename, glob) {
+  if (glob === void 0) return true;
+  return globToRegex(glob).test(filename);
+}
+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 stat3(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;
+}
+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;
+}
+async function grepFileTool(args) {
+  const {
+    pattern,
+    path: searchPath,
+    glob,
+    contextLines = 0,
+    outputMode = "files_with_matches"
+  } = args;
+  const targetPath = searchPath ? resolve2(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 stat3(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 readFile3(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);
+  }
+);
+export {
+  FunctionTool,
+  OpenAPITool,
+  ToolRegistry,
+  bashTool,
+  createFunctionTool,
+  createOpenAPITool,
+  createZodFunctionTool,
+  editTool,
+  globTool,
+  grepTool,
+  readTool,
+  writeTool,
+  zodToJsonSchema
+};