@robota-sdk/agent-tools 3.0.0-beta.6 → 3.0.0-beta.60

package/dist/node/index.js

@@ -165,7 +165,9 @@ function zodToJsonSchema(schema, options = {}) {
     type: "object",
     properties,
     required,
-    ...options.allowAdditionalProperties && { additionalProperties: true }
+    ...(options.allowAdditionalProperties || schemaDef.unknownKeys === "passthrough") && {
+      additionalProperties: true
+    }
   };
 }
 function convertZodTypeToProperty(typeObj) {
@@ -244,6 +246,100 @@ function isRequiredField(typeObj) {
   return typeDef.typeName !== "ZodOptional" && typeDef.typeName !== "ZodNullable" && typeDef.typeName !== "ZodDefault";
 }
 
+// src/implementations/function-tool/parameter-validator.ts
+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;
+}
+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;
+}
+function validateToolParameters(parameters, schemaRequired, schemaProperties, additionalProperties) {
+  const errors = getValidationErrors(
+    parameters,
+    schemaRequired,
+    schemaProperties,
+    additionalProperties
+  );
+  return {
+    isValid: errors.length === 0,
+    errors
+  };
+}
+
 // src/implementations/function-tool.ts
 var FunctionTool = class {
   schema;
@@ -274,7 +370,12 @@ var FunctionTool = class {
   async execute(parameters, context) {
     const toolName = this.schema.name;
     if (!this.validate(parameters)) {
-      const errors = this.getValidationErrors(parameters);
+      const errors = getValidationErrors(
+        parameters,
+        this.schema.parameters.required || [],
+        this.schema.parameters.properties || {},
+        this.schema.parameters.additionalProperties
+      );
       throw new ValidationError2(`Invalid parameters for tool "${toolName}": ${errors.join(", ")}`);
     }
     const startTime = Date.now();
@@ -310,17 +411,23 @@ var FunctionTool = class {
    * Validate parameters (simple boolean result)
    */
   validate(parameters) {
-    return this.getValidationErrors(parameters).length === 0;
+    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) {
-    const errors = this.getValidationErrors(parameters);
-    return {
-      isValid: errors.length === 0,
-      errors
-    };
+    return validateToolParameters(
+      parameters,
+      this.schema.parameters.required || [],
+      this.schema.parameters.properties || {},
+      this.schema.parameters.additionalProperties
+    );
   }
   /**
    * Get tool description
@@ -328,86 +435,6 @@ var FunctionTool = class {
   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
    */
@@ -451,6 +478,132 @@ function createZodFunctionTool(name, description, zodSchema, fn) {
 
 // src/implementations/openapi-tool.ts
 import { ToolExecutionError as ToolExecutionError2, ValidationError as ValidationError3 } from "@robota-sdk/agent-core";
+
+// src/implementations/openapi-schema-converter.ts
+var HTTP_METHODS = [
+  "get",
+  "post",
+  "put",
+  "delete",
+  "patch",
+  "head",
+  "options"
+];
+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;
+}
+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";
+  }
+}
+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;
+}
+function convertOpenAPIParamToSchema(param) {
+  const schema = param.schema;
+  return convertOpenAPISchemaToParameterSchema(schema);
+}
+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
+  };
+}
+
+// src/implementations/openapi-tool.ts
 var OpenAPITool = class {
   schema;
   apiSpec;
@@ -557,36 +710,13 @@ var OpenAPITool = class {
    * @private
    */
   async executeAPICall(parameters, _context) {
-    const operation = this.findOperation();
+    const operation = findOperation(this.apiSpec, this.operationId);
     if (!operation) {
       throw new Error(`Operation ${this.operationId} not found in OpenAPI spec`);
     }
-    const requestConfig = this.buildRequestConfig(operation, parameters);
+    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
    */
@@ -658,121 +788,13 @@ var OpenAPITool = class {
    * Create tool schema from OpenAPI operation specification
    */
   createSchemaFromOpenAPI() {
-    const operation = this.findOperation();
+    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.`
       );
     }
-    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";
-    }
+    return createSchemaFromOperation(this.operationId, operation.operation);
   }
 };
 function createOpenAPITool(config) {
@@ -809,6 +831,11 @@ async function runBash(args) {
     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;
@@ -954,9 +981,51 @@ var readTool = createZodFunctionTool(
 );
 
 // src/builtins/write-tool.ts
-import { writeFile, mkdir } from "fs/promises";
-import { dirname } from "path";
 import { z as z3 } from "zod";
+
+// src/builtins/atomic-file-write.ts
+import { randomBytes } from "crypto";
+import { chmod, mkdir, rename, rm, stat as stat2, writeFile } from "fs/promises";
+import { basename, dirname, join } from "path";
+var TEMP_RANDOM_BYTES = 6;
+var PRESERVED_MODE_BITS = 4095;
+var 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}`);
+}
+async function readExistingMode(filePath) {
+  try {
+    const fileStats = await stat2(filePath);
+    return fileStats.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;
+}
+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;
+  }
+}
+
+// src/builtins/write-tool.ts
 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")
@@ -964,8 +1033,7 @@ var WriteSchema = z3.object({
 async function writeFileTool(args) {
   const { filePath, content } = args;
   try {
-    await mkdir(dirname(filePath), { recursive: true });
-    await writeFile(filePath, content, "utf8");
+    await atomicWriteUtf8File(filePath, content);
     const result = {
       success: true,
       output: `Written ${Buffer.byteLength(content, "utf8")} bytes to ${filePath}`
@@ -990,7 +1058,7 @@ var writeTool = createZodFunctionTool(
 );
 
 // src/builtins/edit-tool.ts
-import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { readFile as readFile2 } 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"),
@@ -1036,7 +1104,7 @@ async function editFileTool(args) {
   }
   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");
+    await atomicWriteUtf8File(filePath, updated);
   } catch (err) {
     const result2 = {
       success: false,
@@ -1046,9 +1114,12 @@ async function editFileTool(args) {
     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}`
+    output: `Replaced ${count} occurrence(s) in ${filePath}`,
+    startLine
   };
   return JSON.stringify(result);
 }
@@ -1062,7 +1133,7 @@ var editTool = createZodFunctionTool(
 );
 
 // src/builtins/glob-tool.ts
-import { stat as stat2 } from "fs/promises";
+import { stat as stat3 } from "fs/promises";
 import { resolve } from "path";
 import fg from "fast-glob";
 import { z as z5 } from "zod";
@@ -1099,7 +1170,7 @@ async function globFileTool(args) {
     matches.map(async (p) => {
       const absPath = resolve(cwd, p);
       try {
-        const s = await stat2(absPath);
+        const s = await stat3(absPath);
         return { path: p, mtime: s.mtimeMs };
       } catch {
         return { path: p, mtime: 0 };
@@ -1134,8 +1205,8 @@ var globTool = createZodFunctionTool(
 );
 
 // src/builtins/grep-tool.ts
-import { readFile as readFile3, readdir, stat as stat3 } from "fs/promises";
-import { join, resolve as resolve2 } from "path";
+import { readFile as readFile3, readdir, stat as stat4 } from "fs/promises";
+import { join as join2, 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"),
@@ -1169,10 +1240,10 @@ async function collectFiles(dirPath, glob) {
     }
     for (const name of entryNames) {
       if (name === "node_modules" || name === ".git") continue;
-      const fullPath = join(current, name);
+      const fullPath = join2(current, name);
       let fileStat;
       try {
-        fileStat = await stat3(fullPath);
+        fileStat = await stat4(fullPath);
       } catch {
         continue;
       }
@@ -1242,7 +1313,7 @@ async function grepFileTool(args) {
   }
   let targetStat;
   try {
-    targetStat = await stat3(targetPath);
+    targetStat = await stat4(targetPath);
   } catch {
     const result2 = {
       success: false,