@robota-sdk/agent-tools 3.0.0-beta.52 → 3.0.0-beta.54

package/dist/node/index.cjs

@@ -294,6 +294,87 @@ 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) {
+  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) {
+      errors.push(`Unknown parameter: ${key}`);
+      continue;
+    }
+    const typeError = validateParameterType(key, value, paramSchema);
+    if (typeError) {
+      errors.push(typeError);
+    }
+  }
+  return errors;
+}
+function validateToolParameters(parameters, schemaRequired, schemaProperties) {
+  const errors = getValidationErrors(parameters, schemaRequired, schemaProperties);
+  return {
+    isValid: errors.length === 0,
+    errors
+  };
+}
+
 // src/implementations/function-tool.ts
 var FunctionTool = class {
   schema;
@@ -324,7 +405,11 @@ 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 || {}
+      );
       throw new import_agent_core3.ValidationError(`Invalid parameters for tool "${toolName}": ${errors.join(", ")}`);
     }
     const startTime = Date.now();
@@ -360,17 +445,21 @@ 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 || {}
+    ).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 || {}
+    );
   }
   /**
    * Get tool description
@@ -378,86 +467,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
    */
@@ -501,6 +510,132 @@ function createZodFunctionTool(name, description, zodSchema, fn) {
 
 // src/implementations/openapi-tool.ts
 var import_agent_core4 = require("@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;
@@ -607,36 +742,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
    */
@@ -708,121 +820,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) {

package/dist/node/index.d.cts

@@ -174,14 +174,6 @@ declare class FunctionTool implements IFunctionTool {
      * Get tool description
      */
     getDescription(): string;
-    /**
-     * Get detailed validation errors
-     */
-    private getValidationErrors;
-    /**
-     * Validate individual parameter type
-     */
-    private validateParameterType;
     /**
      * Validate constructor inputs
      */
@@ -240,10 +232,6 @@ declare class OpenAPITool implements ITool {
      * @private
      */
     private executeAPICall;
-    /**
-     * Find the operation in the OpenAPI specification
-     */
-    private findOperation;
     /**
      * Build HTTP request configuration from OpenAPI operation and parameters
      */
@@ -252,18 +240,6 @@ declare class OpenAPITool implements ITool {
      * Create tool schema from OpenAPI operation specification
      */
     private createSchemaFromOpenAPI;
-    /**
-     * Convert OpenAPI parameter to tool parameter schema
-     */
-    private convertOpenAPIParamToSchema;
-    /**
-     * Convert OpenAPI schema to parameter schema
-     */
-    private convertOpenAPISchemaToParameterSchema;
-    /**
-     * Map OpenAPI type to JSON schema type
-     */
-    private mapOpenAPIType;
 }
 /**
  * Factory function to create OpenAPI tools from specification

package/dist/node/index.d.ts

@@ -174,14 +174,6 @@ declare class FunctionTool implements IFunctionTool {
      * Get tool description
      */
     getDescription(): string;
-    /**
-     * Get detailed validation errors
-     */
-    private getValidationErrors;
-    /**
-     * Validate individual parameter type
-     */
-    private validateParameterType;
     /**
      * Validate constructor inputs
      */
@@ -240,10 +232,6 @@ declare class OpenAPITool implements ITool {
      * @private
      */
     private executeAPICall;
-    /**
-     * Find the operation in the OpenAPI specification
-     */
-    private findOperation;
     /**
      * Build HTTP request configuration from OpenAPI operation and parameters
      */
@@ -252,18 +240,6 @@ declare class OpenAPITool implements ITool {
      * Create tool schema from OpenAPI operation specification
      */
     private createSchemaFromOpenAPI;
-    /**
-     * Convert OpenAPI parameter to tool parameter schema
-     */
-    private convertOpenAPIParamToSchema;
-    /**
-     * Convert OpenAPI schema to parameter schema
-     */
-    private convertOpenAPISchemaToParameterSchema;
-    /**
-     * Map OpenAPI type to JSON schema type
-     */
-    private mapOpenAPIType;
 }
 /**
  * Factory function to create OpenAPI tools from specification

package/dist/node/index.js

@@ -244,6 +244,87 @@ 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) {
+  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) {
+      errors.push(`Unknown parameter: ${key}`);
+      continue;
+    }
+    const typeError = validateParameterType(key, value, paramSchema);
+    if (typeError) {
+      errors.push(typeError);
+    }
+  }
+  return errors;
+}
+function validateToolParameters(parameters, schemaRequired, schemaProperties) {
+  const errors = getValidationErrors(parameters, schemaRequired, schemaProperties);
+  return {
+    isValid: errors.length === 0,
+    errors
+  };
+}
+
 // src/implementations/function-tool.ts
 var FunctionTool = class {
   schema;
@@ -274,7 +355,11 @@ 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 || {}
+      );
       throw new ValidationError2(`Invalid parameters for tool "${toolName}": ${errors.join(", ")}`);
     }
     const startTime = Date.now();
@@ -310,17 +395,21 @@ 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 || {}
+    ).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 || {}
+    );
   }
   /**
    * Get tool description
@@ -328,86 +417,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 +460,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 +692,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 +770,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) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@robota-sdk/agent-tools",
-  "version": "3.0.0-beta.52",
+  "version": "3.0.0-beta.54",
   "description": "Tool registry and implementations for Robota SDK",
   "type": "module",
   "main": "dist/node/index.js",
@@ -34,7 +34,7 @@
     "zod": "^3.24.0"
   },
   "peerDependencies": {
-    "@robota-sdk/agent-core": "3.0.0-beta.52"
+    "@robota-sdk/agent-core": "3.0.0-beta.54"
   },
   "devDependencies": {
     "openapi-types": "^12.1.3",
@@ -42,7 +42,7 @@
     "tsup": "^8.0.1",
     "typescript": "^5.3.3",
     "vitest": "^1.6.1",
-    "@robota-sdk/agent-core": "3.0.0-beta.52"
+    "@robota-sdk/agent-core": "3.0.0-beta.54"
   },
   "license": "MIT",
   "publishConfig": {
@@ -50,6 +50,8 @@
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm,cjs --dts --out-dir dist/node --clean",
+    "build:js": "tsup src/index.ts --format esm,cjs --out-dir dist/node --clean",
+    "build:types": "tsup src/index.ts --format esm,cjs --dts-only --out-dir dist/node",
     "test": "vitest run --passWithNoTests",
     "typecheck": "tsc --noEmit",
     "lint": "eslint src/ --ext .ts,.tsx",