@synova-cloud/sdk 1.9.1 → 2.0.0

package/dist/index.js

@@ -1,5 +1,3 @@
-import 'reflect-metadata';
-
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
 }) : x)(function(x) {
@@ -94,18 +92,9 @@ var ExecutionSynovaError = class extends SynovaError {
     this.details = error.details;
   }
 };
-var ValidationSynovaError = class extends SynovaError {
-  violations;
-  constructor(violations) {
-    const message = `Validation failed: ${violations.map((v) => v.property).join(", ")}`;
-    super(message);
-    this.name = "ValidationSynovaError";
-    this.violations = violations;
-  }
-};
 
 // src/version.ts
-var SDK_VERSION = "1.9.1" ;
+var SDK_VERSION = "2.0.0" ;
 
 // src/utils/http.ts
 var HttpClient = class {
@@ -316,462 +305,262 @@ var HttpClient = class {
   }
 };
 
-// src/schema/types.ts
-var SCHEMA_METADATA_KEYS = {
-  // Metadata
-  DESCRIPTION: "synova:schema:description",
-  EXAMPLES: "synova:schema:examples",
-  DEFAULT: "synova:schema:default",
-  // Type helpers
-  FORMAT: "synova:schema:format",
-  ARRAY_ITEM_TYPE: "synova:schema:arrayItemType",
-  NULLABLE: "synova:schema:nullable",
-  ENUM: "synova:schema:enum",
-  // String constraints
-  MIN_LENGTH: "synova:schema:minLength",
-  MAX_LENGTH: "synova:schema:maxLength",
-  PATTERN: "synova:schema:pattern",
-  // Number constraints
-  MINIMUM: "synova:schema:minimum",
-  MAXIMUM: "synova:schema:maximum",
-  EXCLUSIVE_MINIMUM: "synova:schema:exclusiveMinimum",
-  EXCLUSIVE_MAXIMUM: "synova:schema:exclusiveMaximum",
-  MULTIPLE_OF: "synova:schema:multipleOf",
-  // Array constraints
-  MIN_ITEMS: "synova:schema:minItems",
-  MAX_ITEMS: "synova:schema:maxItems",
-  UNIQUE_ITEMS: "synova:schema:uniqueItems",
-  // Object constraints
-  ADDITIONAL_PROPERTIES: "synova:schema:additionalProperties"
+// src/schema/adapters/zod.adapter.ts
+var ZodAdapter = class {
+  canHandle(schema) {
+    if (typeof schema !== "object" || schema === null) return false;
+    const s = schema;
+    return typeof s._def === "object" && s._def !== null && typeof s._def.typeName === "string" && s._def.typeName.startsWith("Zod") && typeof s.safeParse === "function";
+  }
+  toJsonSchema(schema) {
+    try {
+      const { zodToJsonSchema } = __require("zod-to-json-schema");
+      const result = { ...zodToJsonSchema(schema, { $refStrategy: "none" }) };
+      delete result.$schema;
+      return result;
+    } catch (error) {
+      if (error.code === "MODULE_NOT_FOUND") {
+        throw new Error(
+          "zod-to-json-schema is required to convert Zod schemas. Install it with: npm install zod-to-json-schema"
+        );
+      }
+      throw new Error(`Failed to convert Zod schema: ${error.message}`);
+    }
+  }
 };
-function createMetadataDecorator(key, value) {
-  return function(target, propertyKey) {
-    Reflect.defineMetadata(key, value, target, propertyKey);
-  };
-}
-function Description(description) {
-  return createMetadataDecorator(SCHEMA_METADATA_KEYS.DESCRIPTION, description);
-}
-function Example(...examples) {
-  return createMetadataDecorator(SCHEMA_METADATA_KEYS.EXAMPLES, examples);
-}
-function Default(value) {
-  return createMetadataDecorator(SCHEMA_METADATA_KEYS.DEFAULT, value);
-}
-function ArrayItems(itemType) {
-  return createMetadataDecorator(SCHEMA_METADATA_KEYS.ARRAY_ITEM_TYPE, itemType);
-}
-function Format(format) {
-  return createMetadataDecorator(SCHEMA_METADATA_KEYS.FORMAT, format);
-}
-function Nullable() {
-  return createMetadataDecorator(SCHEMA_METADATA_KEYS.NULLABLE, true);
-}
-function SchemaMinLength(length) {
-  return createMetadataDecorator(SCHEMA_METADATA_KEYS.MIN_LENGTH, length);
-}
-function SchemaMaxLength(length) {
-  return createMetadataDecorator(SCHEMA_METADATA_KEYS.MAX_LENGTH, length);
-}
-function SchemaPattern(pattern) {
-  return createMetadataDecorator(SCHEMA_METADATA_KEYS.PATTERN, pattern);
-}
-function SchemaMin(value) {
-  return createMetadataDecorator(SCHEMA_METADATA_KEYS.MINIMUM, value);
-}
-function SchemaMax(value) {
-  return createMetadataDecorator(SCHEMA_METADATA_KEYS.MAXIMUM, value);
-}
-function ExclusiveMin(value) {
-  return createMetadataDecorator(SCHEMA_METADATA_KEYS.EXCLUSIVE_MINIMUM, value);
-}
-function ExclusiveMax(value) {
-  return createMetadataDecorator(SCHEMA_METADATA_KEYS.EXCLUSIVE_MAXIMUM, value);
-}
-function MultipleOf(value) {
-  return createMetadataDecorator(SCHEMA_METADATA_KEYS.MULTIPLE_OF, value);
-}
-function SchemaMinItems(count) {
-  return createMetadataDecorator(SCHEMA_METADATA_KEYS.MIN_ITEMS, count);
-}
-function SchemaMaxItems(count) {
-  return createMetadataDecorator(SCHEMA_METADATA_KEYS.MAX_ITEMS, count);
-}
-function SchemaUniqueItems() {
-  return createMetadataDecorator(SCHEMA_METADATA_KEYS.UNIQUE_ITEMS, true);
-}
-function SchemaEnum(values) {
-  return createMetadataDecorator(SCHEMA_METADATA_KEYS.ENUM, values);
-}
-function getSchemaMetadata(key, target, propertyKey) {
-  return Reflect.getMetadata(key, target, propertyKey);
-}
 
-// src/schema/class-schema.ts
-var ClassSchema = class {
-  /**
-   * Generate JSON Schema from a class
-   */
-  static generate(targetClass, options = {}) {
-    const { additionalProperties = false } = options;
-    const properties = this.getProperties(targetClass);
-    const required = this.getRequiredProperties(targetClass, properties);
-    return {
-      type: "object",
-      properties,
-      required: required.length > 0 ? required : void 0,
-      additionalProperties
-    };
+// src/schema/adapters/yup.adapter.ts
+var YupAdapter = class {
+  canHandle(schema) {
+    if (typeof schema !== "object" || schema === null) return false;
+    return schema.__isYupSchema__ === true;
   }
-  /**
-   * Get all properties with their schemas
-   */
-  static getProperties(targetClass) {
-    const properties = {};
-    const prototype = targetClass.prototype;
-    const classValidatorProperties = this.getClassValidatorProperties(targetClass);
-    const decoratorProperties = this.getDecoratorProperties(prototype);
-    const allProperties = /* @__PURE__ */ new Set([...classValidatorProperties, ...decoratorProperties]);
-    for (const propertyName of allProperties) {
-      properties[propertyName] = this.getPropertySchema(targetClass, propertyName);
+  toJsonSchema(schema) {
+    try {
+      const { convertSchema } = __require("@sodaru/yup-to-json-schema");
+      return convertSchema(schema);
+    } catch (error) {
+      if (error.code === "MODULE_NOT_FOUND") {
+        throw new Error(
+          "@sodaru/yup-to-json-schema is required to convert Yup schemas. Install it with: npm install @sodaru/yup-to-json-schema"
+        );
+      }
+      throw new Error(`Failed to convert Yup schema: ${error.message}`);
     }
-    return properties;
   }
-  /**
-   * Get property names from class-validator metadata
-   */
-  static getClassValidatorProperties(targetClass) {
+};
+
+// src/schema/adapters/joi.adapter.ts
+var JoiAdapter = class {
+  canHandle(schema) {
+    if (typeof schema !== "object" || schema === null) return false;
     try {
-      const { getMetadataStorage } = __require("class-validator");
-      const metadataStorage = getMetadataStorage();
-      const targetMetadatas = metadataStorage.getTargetValidationMetadatas(
-        targetClass,
-        "",
-        true,
-        false
-      );
-      const propertyNames = targetMetadatas.map((m) => m.propertyName);
-      return [...new Set(propertyNames)];
+      const { isSchema } = __require("joi");
+      return isSchema(schema);
     } catch {
-      return [];
+      return false;
     }
   }
-  /**
-   * Get property names from our decorator metadata
-   */
-  static getDecoratorProperties(prototype) {
-    const properties = [];
-    const ownKeys = Reflect.ownKeys(prototype);
-    for (const key of ownKeys) {
-      if (typeof key === "string" && key !== "constructor") {
-        for (const metaKey of Object.values(SCHEMA_METADATA_KEYS)) {
-          if (Reflect.hasMetadata(metaKey, prototype, key)) {
-            properties.push(key);
-            break;
-          }
-        }
+  toJsonSchema(schema) {
+    try {
+      const joiToJson = __require("joi-to-json");
+      return joiToJson(schema);
+    } catch (error) {
+      if (error.code === "MODULE_NOT_FOUND") {
+        throw new Error(
+          "joi-to-json is required to convert Joi schemas. Install it with: npm install joi-to-json"
+        );
       }
+      throw new Error(`Failed to convert Joi schema: ${error.message}`);
     }
-    return properties;
   }
-  /**
-   * Get JSON Schema for a single property
-   */
-  static getPropertySchema(targetClass, propertyName) {
-    const prototype = targetClass.prototype;
-    const schema = {};
-    const designType = Reflect.getMetadata("design:type", prototype, propertyName);
-    const baseSchema = this.getBaseTypeSchema(designType, targetClass, propertyName);
-    Object.assign(schema, baseSchema);
-    this.applyClassValidatorConstraints(schema, targetClass, propertyName);
-    this.applyDecoratorMetadata(schema, prototype, propertyName);
-    const isNullable = getSchemaMetadata(
-      SCHEMA_METADATA_KEYS.NULLABLE,
-      prototype,
-      propertyName
-    );
-    if (isNullable && schema.type && typeof schema.type === "string") {
-      schema.type = [schema.type, "null"];
+};
+
+// src/schema/adapters/json-schema.adapter.ts
+var JsonSchemaAdapter = class _JsonSchemaAdapter {
+  static VALID_JSON_SCHEMA_TYPES = [
+    "string",
+    "number",
+    "integer",
+    "boolean",
+    "object",
+    "array",
+    "null"
+  ];
+  canHandle(schema) {
+    if (typeof schema !== "object" || schema === null) {
+      return false;
+    }
+    const obj = schema;
+    if ("type" in obj) {
+      const type = obj.type;
+      if (typeof type === "string" && _JsonSchemaAdapter.VALID_JSON_SCHEMA_TYPES.includes(type)) {
+        return true;
+      }
+      if (Array.isArray(type) && type.every((t) => _JsonSchemaAdapter.VALID_JSON_SCHEMA_TYPES.includes(t))) {
+        return true;
+      }
+    }
+    if ("properties" in obj && typeof obj.properties === "object" && obj.properties !== null && !Array.isArray(obj.properties)) {
+      return true;
     }
-    return schema;
+    if ("items" in obj && typeof obj.items === "object" && obj.items !== null && !Array.isArray(obj.items)) {
+      return true;
+    }
+    if ("anyOf" in obj && Array.isArray(obj.anyOf)) return true;
+    if ("oneOf" in obj && Array.isArray(obj.oneOf)) return true;
+    if ("allOf" in obj && Array.isArray(obj.allOf)) return true;
+    if ("enum" in obj && Array.isArray(obj.enum)) return true;
+    return false;
+  }
+  toJsonSchema(schema) {
+    return this.transformNullable(schema);
   }
   /**
-   * Get base schema from TypeScript type
+   * Recursively transform `nullable: true` to `type: ["...", "null"]`
    */
-  static getBaseTypeSchema(designType, targetClass, propertyName) {
-    if (designType === String) {
-      return { type: "string" };
-    }
-    if (designType === Number) {
-      return { type: "number" };
-    }
-    if (designType === Boolean) {
-      return { type: "boolean" };
-    }
-    if (designType === Array) {
-      const itemType = getSchemaMetadata(
-        SCHEMA_METADATA_KEYS.ARRAY_ITEM_TYPE,
-        targetClass.prototype,
-        propertyName
+  transformNullable(schema) {
+    const result = { ...schema };
+    const schemaWithNullable = schema;
+    if (schemaWithNullable.nullable === true && result.type) {
+      if (typeof result.type === "string") {
+        result.type = [result.type, "null"];
+      } else if (Array.isArray(result.type) && !result.type.includes("null")) {
+        result.type = [...result.type, "null"];
+      }
+      delete result.nullable;
+    }
+    if (result.properties) {
+      result.properties = Object.fromEntries(
+        Object.entries(result.properties).map(([key, value]) => [
+          key,
+          this.transformNullable(value)
+        ])
       );
-      return {
-        type: "array",
-        items: this.getArrayItemSchema(itemType)
-      };
     }
-    if (designType === Object) {
-      return { type: "object" };
+    if (result.items) {
+      result.items = this.transformNullable(result.items);
     }
-    if (typeof designType === "function" && designType.prototype) {
-      return this.generate(designType);
+    if (result.additionalProperties && typeof result.additionalProperties === "object") {
+      result.additionalProperties = this.transformNullable(result.additionalProperties);
     }
-    return { type: "string" };
-  }
-  /**
-   * Get schema for array items
-   */
-  static getArrayItemSchema(itemType) {
-    if (!itemType) {
-      return { type: "string" };
+    if (result.allOf) {
+      result.allOf = result.allOf.map((s) => this.transformNullable(s));
     }
-    if (itemType === String) {
-      return { type: "string" };
+    if (result.anyOf) {
+      result.anyOf = result.anyOf.map((s) => this.transformNullable(s));
     }
-    if (itemType === Number) {
-      return { type: "number" };
+    if (result.oneOf) {
+      result.oneOf = result.oneOf.map((s) => this.transformNullable(s));
     }
-    if (itemType === Boolean) {
-      return { type: "boolean" };
+    if (result.not) {
+      result.not = this.transformNullable(result.not);
     }
-    return this.generate(itemType);
+    return result;
   }
+};
+
+// src/schema/resolver.ts
+var SchemaResolver = class {
+  static adapters = [
+    // Order matters: Zod → Yup → Joi → JsonSchema (fallback)
+    new ZodAdapter(),
+    new YupAdapter(),
+    new JoiAdapter(),
+    new JsonSchemaAdapter()
+  ];
   /**
-   * Apply class-validator constraints to schema
+   * Register a custom adapter.
+   *
+   * @param adapter - The adapter to register
+   * @param position - Where to insert: 'first' adds at the beginning,
+   *                   'last' adds before JsonSchemaAdapter (fallback)
+   *
+   * @example
+   * ```typescript
+   * SchemaResolver.registerAdapter(new MyCustomAdapter(), 'first');
+   * ```
    */
-  static applyClassValidatorConstraints(schema, targetClass, propertyName) {
-    try {
-      const { getMetadataStorage } = __require("class-validator");
-      const metadataStorage = getMetadataStorage();
-      const targetMetadatas = metadataStorage.getTargetValidationMetadatas(
-        targetClass,
-        "",
-        true,
-        false
-      );
-      const propertyMetadatas = targetMetadatas.filter(
-        (m) => m.propertyName === propertyName
-      );
-      for (const metadata of propertyMetadatas) {
-        this.applyValidationConstraint(schema, metadata);
-      }
-    } catch {
+  static registerAdapter(adapter, position = "first") {
+    if (position === "first") {
+      this.adapters.unshift(adapter);
+    } else {
+      this.adapters.splice(-1, 0, adapter);
     }
   }
   /**
-   * Apply a single class-validator constraint
+   * Reset adapters to default configuration.
+   * Removes all custom adapters.
    */
-  static applyValidationConstraint(schema, metadata) {
-    const constraintType = metadata.name || metadata.type || "";
-    const constraints = metadata.constraints || [];
-    switch (constraintType) {
-      case "isString":
-        schema.type = "string";
-        break;
-      case "isNumber":
-      case "isInt":
-        schema.type = constraintType === "isInt" ? "integer" : "number";
-        break;
-      case "isBoolean":
-        schema.type = "boolean";
-        break;
-      case "isArray":
-        schema.type = "array";
-        break;
-      case "isEnum":
-        if (constraints[0]) {
-          schema.enum = Object.values(constraints[0]);
-        }
-        break;
-      case "minLength":
-        schema.minLength = constraints[0];
-        break;
-      case "maxLength":
-        schema.maxLength = constraints[0];
-        break;
-      case "min":
-        schema.minimum = constraints[0];
-        break;
-      case "max":
-        schema.maximum = constraints[0];
-        break;
-      case "isEmail":
-        schema.format = "email";
-        break;
-      case "isUrl":
-      case "isURL":
-        schema.format = "uri";
-        break;
-      case "isUUID":
-        schema.format = "uuid";
-        break;
-      case "isDateString":
-      case "isISO8601":
-        schema.format = "date-time";
-        break;
-      case "matches":
-        if (constraints[0] instanceof RegExp) {
-          schema.pattern = constraints[0].source;
-        } else if (typeof constraints[0] === "string") {
-          schema.pattern = constraints[0];
-        }
-        break;
-      case "arrayMinSize":
-        schema.minItems = constraints[0];
-        break;
-      case "arrayMaxSize":
-        schema.maxItems = constraints[0];
-        break;
-      case "arrayUnique":
-        schema.uniqueItems = true;
-        break;
-    }
+  static resetAdapters() {
+    this.adapters = [new ZodAdapter(), new YupAdapter(), new JoiAdapter(), new JsonSchemaAdapter()];
   }
   /**
-   * Apply our decorator metadata to schema.
-   * Our decorators take precedence over class-validator if both are used.
+   * Resolve a schema input to JSON Schema format.
+   *
+   * @param schema - Schema from Zod, Yup, Joi, or raw JSON Schema
+   * @returns JSON Schema representation
+   * @throws Error if schema type is not supported
+   *
+   * @example
+   * ```typescript
+   * // Zod
+   * const zodSchema = z.object({ title: z.string() });
+   * const jsonSchema = SchemaResolver.resolve(zodSchema);
+   *
+   * // Yup
+   * const yupSchema = yup.object({ title: yup.string().required() });
+   * const jsonSchema = SchemaResolver.resolve(yupSchema);
+   *
+   * // Joi
+   * const joiSchema = Joi.object({ title: Joi.string() });
+   * const jsonSchema = SchemaResolver.resolve(joiSchema);
+   *
+   * // Raw JSON Schema (passthrough)
+   * const rawSchema = { type: 'object', properties: { title: { type: 'string' } } };
+   * const jsonSchema = SchemaResolver.resolve(rawSchema);
+   * ```
    */
-  static applyDecoratorMetadata(schema, prototype, propertyName) {
-    const description = getSchemaMetadata(
-      SCHEMA_METADATA_KEYS.DESCRIPTION,
-      prototype,
-      propertyName
-    );
-    if (description) schema.description = description;
-    const examples = getSchemaMetadata(
-      SCHEMA_METADATA_KEYS.EXAMPLES,
-      prototype,
-      propertyName
-    );
-    if (examples) schema.examples = examples;
-    const defaultValue = getSchemaMetadata(
-      SCHEMA_METADATA_KEYS.DEFAULT,
-      prototype,
-      propertyName
-    );
-    if (defaultValue !== void 0) schema.default = defaultValue;
-    const format = getSchemaMetadata(SCHEMA_METADATA_KEYS.FORMAT, prototype, propertyName);
-    if (format) schema.format = format;
-    const enumValues = getSchemaMetadata(
-      SCHEMA_METADATA_KEYS.ENUM,
-      prototype,
-      propertyName
-    );
-    if (enumValues) schema.enum = enumValues;
-    const minLength = getSchemaMetadata(
-      SCHEMA_METADATA_KEYS.MIN_LENGTH,
-      prototype,
-      propertyName
-    );
-    if (minLength !== void 0) schema.minLength = minLength;
-    const maxLength = getSchemaMetadata(
-      SCHEMA_METADATA_KEYS.MAX_LENGTH,
-      prototype,
-      propertyName
-    );
-    if (maxLength !== void 0) schema.maxLength = maxLength;
-    const pattern = getSchemaMetadata(
-      SCHEMA_METADATA_KEYS.PATTERN,
-      prototype,
-      propertyName
-    );
-    if (pattern) schema.pattern = pattern;
-    const minimum = getSchemaMetadata(
-      SCHEMA_METADATA_KEYS.MINIMUM,
-      prototype,
-      propertyName
-    );
-    if (minimum !== void 0) schema.minimum = minimum;
-    const maximum = getSchemaMetadata(
-      SCHEMA_METADATA_KEYS.MAXIMUM,
-      prototype,
-      propertyName
-    );
-    if (maximum !== void 0) schema.maximum = maximum;
-    const exclusiveMinimum = getSchemaMetadata(
-      SCHEMA_METADATA_KEYS.EXCLUSIVE_MINIMUM,
-      prototype,
-      propertyName
-    );
-    if (exclusiveMinimum !== void 0) schema.exclusiveMinimum = exclusiveMinimum;
-    const exclusiveMaximum = getSchemaMetadata(
-      SCHEMA_METADATA_KEYS.EXCLUSIVE_MAXIMUM,
-      prototype,
-      propertyName
-    );
-    if (exclusiveMaximum !== void 0) schema.exclusiveMaximum = exclusiveMaximum;
-    const multipleOf = getSchemaMetadata(
-      SCHEMA_METADATA_KEYS.MULTIPLE_OF,
-      prototype,
-      propertyName
-    );
-    if (multipleOf !== void 0) schema.multipleOf = multipleOf;
-    const minItems = getSchemaMetadata(
-      SCHEMA_METADATA_KEYS.MIN_ITEMS,
-      prototype,
-      propertyName
-    );
-    if (minItems !== void 0) schema.minItems = minItems;
-    const maxItems = getSchemaMetadata(
-      SCHEMA_METADATA_KEYS.MAX_ITEMS,
-      prototype,
-      propertyName
-    );
-    if (maxItems !== void 0) schema.maxItems = maxItems;
-    const uniqueItems = getSchemaMetadata(
-      SCHEMA_METADATA_KEYS.UNIQUE_ITEMS,
-      prototype,
-      propertyName
-    );
-    if (uniqueItems) schema.uniqueItems = uniqueItems;
-    const additionalProperties = getSchemaMetadata(
-      SCHEMA_METADATA_KEYS.ADDITIONAL_PROPERTIES,
-      prototype,
-      propertyName
-    );
-    if (additionalProperties !== void 0) {
-      if (schema.type === "array" && schema.items) {
-        schema.items.additionalProperties = additionalProperties;
-      } else {
-        schema.additionalProperties = additionalProperties;
+  static resolve(schema) {
+    for (const adapter of this.adapters) {
+      if (adapter.canHandle(schema)) {
+        return adapter.toJsonSchema(schema);
       }
     }
+    throw new Error(
+      "Unsupported schema type. Supported types: Zod, Yup, Joi, or raw JSON Schema object."
+    );
   }
   /**
-   * Get required properties (properties without @IsOptional)
+   * Check if a schema is supported.
+   *
+   * @param schema - Schema to check
+   * @returns true if the schema is supported
    */
-  static getRequiredProperties(targetClass, properties) {
-    const required = [];
-    try {
-      const { getMetadataStorage } = __require("class-validator");
-      const metadataStorage = getMetadataStorage();
-      const targetMetadatas = metadataStorage.getTargetValidationMetadatas(
-        targetClass,
-        "",
-        true,
-        false
-      );
-      for (const propertyName of Object.keys(properties)) {
-        const isOptional = targetMetadatas.some(
-          (m) => m.propertyName === propertyName && (m.type === "isOptional" || m.type === "conditionalValidation")
-        );
-        if (!isOptional) {
-          required.push(propertyName);
-        }
-      }
-    } catch {
-      required.push(...Object.keys(properties));
+  static isSupported(schema) {
+    return this.adapters.some((adapter) => adapter.canHandle(schema));
+  }
+  /**
+   * Get the type of a schema.
+   *
+   * @param schema - Schema to identify
+   * @returns Schema type identifier
+   */
+  static getSchemaType(schema) {
+    const adapters = this.adapters;
+    if (adapters[0].canHandle(schema)) {
+      return "zod";
+    }
+    if (adapters[1].canHandle(schema)) {
+      return "yup";
     }
-    return required;
+    if (adapters[2].canHandle(schema)) {
+      return "joi";
+    }
+    if (adapters[3].canHandle(schema)) {
+      return "json-schema";
+    }
+    return "unknown";
   }
 };
 
@@ -803,22 +592,6 @@ var PromptsResource = class {
     });
   }
   async execute(promptId, options) {
-    if ("responseClass" in options && options.responseClass) {
-      return this.executeTyped(promptId, options);
-    }
-    return this.executeRaw(promptId, options);
-  }
-  async executeByTag(promptId, tag, options) {
-    return this.execute(promptId, { ...options, tag });
-  }
-  async executeByVersion(promptId, version, options) {
-    return this.execute(promptId, { ...options, version });
-  }
-  /**
-   * Execute raw request without typed response
-   * @throws {ExecutionSynovaError} If LLM returns an error
-   */
-  async executeRaw(promptId, options) {
     const body = {
       provider: options.provider,
       model: options.model
@@ -831,8 +604,10 @@ var PromptsResource = class {
     if (options.version !== void 0) body.version = options.version;
     if (options.metadata !== void 0) body.metadata = options.metadata;
     if (options.parameters !== void 0) body.parameters = options.parameters;
-    if (options.responseSchema !== void 0) body.responseSchema = options.responseSchema;
     if (options.sessionId !== void 0) body.sessionId = options.sessionId;
+    if (options.responseSchema !== void 0) {
+      body.responseSchema = SchemaResolver.resolve(options.responseSchema);
+    }
     const response = await this.http.request({
       method: "POST",
       path: `/api/v1/prompts/${promptId}/run`,
@@ -841,51 +616,19 @@ var PromptsResource = class {
     if (response.type === "error" && response.error) {
       throw new ExecutionSynovaError(response.error);
     }
+    if (options.responseSchema !== void 0) {
+      if (response.object === void 0) {
+        throw new Error("Expected structured response but received undefined");
+      }
+      return response.object;
+    }
     return response;
   }
-  /**
-   * Execute with typed response class
-   */
-  async executeTyped(promptId, options) {
-    const { responseClass, validate = true, ...executeOptions } = options;
-    const responseSchema = ClassSchema.generate(responseClass);
-    const response = await this.executeRaw(promptId, {
-      ...executeOptions,
-      responseSchema
-    });
-    const object = response.object;
-    if (validate) {
-      await this.validateObject(object, responseClass);
-    }
-    return object;
+  async executeByTag(promptId, tag, options) {
+    return this.execute(promptId, { ...options, tag });
   }
-  /**
-   * Validate object using class-validator
-   */
-  async validateObject(object, responseClass) {
-    try {
-      const { plainToInstance } = __require("class-transformer");
-      const { validate } = __require("class-validator");
-      const instance = plainToInstance(responseClass, object);
-      const errors = await validate(instance);
-      if (errors.length > 0) {
-        const violations = errors.map(
-          (error) => ({
-            property: error.property,
-            constraints: error.constraints || {},
-            value: error.value
-          })
-        );
-        throw new ValidationSynovaError(violations);
-      }
-    } catch (error) {
-      if (error instanceof ValidationSynovaError) {
-        throw error;
-      }
-      console.warn(
-        "[Synova SDK] Validation skipped: class-validator or class-transformer not installed. Install them with: npm install class-validator class-transformer"
-      );
-    }
+  async executeByVersion(promptId, version, options) {
+    return this.execute(promptId, { ...options, version });
   }
 };
 
@@ -1201,6 +944,6 @@ var SynovaCloudSdk = class {
   }
 };
 
-export { ApiSynovaError, ArrayItems, AuthSynovaError, ClassSchema, Default, Description, Example, ExclusiveMax, ExclusiveMin, ExecutionSynovaError, Format, MultipleOf, NetworkSynovaError, NotFoundSynovaError, Nullable, RateLimitSynovaError, SCHEMA_METADATA_KEYS, SchemaEnum, SchemaMax, SchemaMaxItems, SchemaMaxLength, SchemaMin, SchemaMinItems, SchemaMinLength, SchemaPattern, SchemaUniqueItems, ServerSynovaError, SynovaCloudSdk, SynovaError, TimeoutSynovaError, ValidationSynovaError };
+export { ApiSynovaError, AuthSynovaError, ExecutionSynovaError, JoiAdapter, JsonSchemaAdapter, NetworkSynovaError, NotFoundSynovaError, RateLimitSynovaError, SchemaResolver, ServerSynovaError, SynovaCloudSdk, SynovaError, TimeoutSynovaError, YupAdapter, ZodAdapter };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map