@cadenza.io/core 3.19.4 → 3.20.0

package/dist/index.d.mts

@@ -342,7 +342,8 @@ type SchemaDefinition = {
     description?: string;
     strict?: boolean;
 };
-type Schema = SchemaDefinition | SchemaDefinition[];
+type SchemaMap = Record<string, SchemaDefinition>;
+type Schema = SchemaDefinition | SchemaMap;
 
 interface Intent {
     name: string;
@@ -934,6 +935,10 @@ declare class Task extends SignalEmitter implements Graph {
      * @return {void} This method does not return any value.
      */
     emitMetricsWithMetadata(signal: string, ctx?: AnyObject): void;
+    private isSchemaDefinition;
+    private isDefaultAnyObjectSchema;
+    private mergeSchemaVariant;
+    private validateValueAgainstSchema;
     /**
      * Validates a data object against a specified schema definition and returns validation results.
      *

package/dist/index.d.ts

@@ -342,7 +342,8 @@ type SchemaDefinition = {
     description?: string;
     strict?: boolean;
 };
-type Schema = SchemaDefinition | SchemaDefinition[];
+type SchemaMap = Record<string, SchemaDefinition>;
+type Schema = SchemaDefinition | SchemaMap;
 
 interface Intent {
     name: string;
@@ -934,6 +935,10 @@ declare class Task extends SignalEmitter implements Graph {
      * @return {void} This method does not return any value.
      */
     emitMetricsWithMetadata(signal: string, ctx?: AnyObject): void;
+    private isSchemaDefinition;
+    private isDefaultAnyObjectSchema;
+    private mergeSchemaVariant;
+    private validateValueAgainstSchema;
     /**
      * Validates a data object against a specified schema definition and returns validation results.
      *

package/dist/index.js

@@ -3753,8 +3753,8 @@ var Task = class _Task extends SignalEmitter {
           isSubMeta: this.isSubMeta,
           validateInputContext: this.validateInputContext,
           validateOutputContext: this.validateOutputContext,
-          // inputContextSchemaId: this.inputContextSchema,
-          // outputContextSchemaId: this.outputContextSchema,
+          inputContextSchema: this.inputContextSchema,
+          outputContextSchema: this.outputContextSchema,
           signals: {
             emits: Array.from(this.emitsSignals),
             signalsToEmitAfter: Array.from(this.signalsToEmitAfter),
@@ -3883,6 +3883,51 @@ var Task = class _Task extends SignalEmitter {
     }
     this.emitMetrics(signal, data);
   }
+  isSchemaDefinition(schema) {
+    return !!schema && typeof schema === "object" && "type" in schema;
+  }
+  isDefaultAnyObjectSchema(schema) {
+    return schema.type === "object" && !schema.strict && !schema.properties && !schema.required?.length && !schema.items && !schema.constraints && !schema.description;
+  }
+  mergeSchemaVariant(currentSchema, schemaKey, variant) {
+    const schemaMap = {};
+    if (this.isSchemaDefinition(currentSchema)) {
+      if (!this.isDefaultAnyObjectSchema(currentSchema)) {
+        schemaMap.default = currentSchema;
+      }
+    } else if (currentSchema && typeof currentSchema === "object") {
+      Object.assign(schemaMap, currentSchema);
+    }
+    schemaMap[schemaKey] = variant;
+    return schemaMap;
+  }
+  validateValueAgainstSchema(schema, key, value, path = "context") {
+    if (this.isSchemaDefinition(schema)) {
+      return this.validateProp(schema, key, value, path);
+    }
+    const errors = {};
+    let checkedSchemas = 0;
+    for (const candidate of Object.values(schema)) {
+      if (!candidate || typeof candidate !== "object") {
+        continue;
+      }
+      checkedSchemas += 1;
+      const candidateErrors = this.validateValueAgainstSchema(
+        candidate,
+        key,
+        value,
+        path
+      );
+      if (Object.keys(candidateErrors).length === 0) {
+        return {};
+      }
+      Object.assign(errors, candidateErrors);
+    }
+    if (checkedSchemas === 0) {
+      return {};
+    }
+    return errors;
+  }
   /**
    * Validates a data object against a specified schema definition and returns validation results.
    *
@@ -3894,10 +3939,16 @@ var Task = class _Task extends SignalEmitter {
    */
   validateSchema(data, schema, path = "context") {
     const errors = {};
-    if (!schema || typeof schema !== "object" && !Array.isArray(schema))
+    if (!schema || typeof schema !== "object") {
       return { valid: true, errors };
-    if (Array.isArray(schema)) {
-      for (const s of schema) {
+    }
+    if (!this.isSchemaDefinition(schema)) {
+      let checkedSchemas = 0;
+      for (const s of Object.values(schema)) {
+        if (!s || typeof s !== "object") {
+          continue;
+        }
+        checkedSchemas += 1;
         const subValidation = this.validateSchema(data, s, path);
         if (!subValidation.valid) {
           Object.assign(errors, subValidation.errors);
@@ -3906,6 +3957,13 @@ var Task = class _Task extends SignalEmitter {
           return { valid: true, errors: {} };
         }
       }
+      if (checkedSchemas === 0) {
+        return { valid: true, errors };
+      }
+      return { valid: false, errors };
+    }
+    if (schema.type === "object" && (typeof data !== "object" || data === null || Array.isArray(data))) {
+      errors[path] = `Expected 'object' for '${path}', got '${typeof data}'`;
       return { valid: false, errors };
     }
     const required = schema.required || [];
@@ -3918,13 +3976,10 @@ var Task = class _Task extends SignalEmitter {
     for (const [key, value] of Object.entries(data)) {
       if (key in properties) {
         const prop = properties[key];
-        if (Array.isArray(prop)) {
-          for (const p of prop) {
-            Object.assign(errors, this.validateProp(p, key, value, path));
-          }
-        } else {
-          Object.assign(errors, this.validateProp(prop, key, value, path));
-        }
+        Object.assign(
+          errors,
+          this.validateValueAgainstSchema(prop, key, value, path)
+        );
       } else if (schema.strict) {
         errors[`${path}.${key}`] = `Key '${key}' is not allowed`;
       }
@@ -3955,13 +4010,13 @@ var Task = class _Task extends SignalEmitter {
       errors[`${path}.${key}`] = `Expected 'object' for '${key}', got '${typeof value}'`;
     } else if (propType === "array" && prop.items) {
       value.forEach((item, index) => {
-        const subValidation = this.validateSchema(
+        const validation = this.validateSchema(
           item,
           prop.items,
           `${path}.${key}[${index}]`
         );
-        if (!subValidation.valid) {
-          Object.assign(errors, subValidation.errors);
+        if (!validation.valid) {
+          Object.assign(errors, validation.errors);
         }
       });
     } else if (propType === "object" && !Array.isArray(value) && value !== null) {
@@ -4444,10 +4499,18 @@ var Task = class _Task extends SignalEmitter {
       Cadenza.inquiryBroker.observe(intentName, this);
       const intent = Cadenza.inquiryBroker.intents.get(intentName);
       if (intent?.input) {
-        this.inputContextSchema = intent.input;
+        this.inputContextSchema = this.mergeSchemaVariant(
+          this.inputContextSchema,
+          intentName,
+          intent.input
+        );
       }
       if (intent?.output) {
-        this.outputContextSchema = intent.output;
+        this.outputContextSchema = this.mergeSchemaVariant(
+          this.outputContextSchema,
+          intentName,
+          intent.output
+        );
       }
     }
     return this;
@@ -5832,12 +5895,14 @@ var InquiryBroker = class _InquiryBroker extends SignalEmitter {
         tasks: /* @__PURE__ */ new Set(),
         registered: false
       });
-      this.addIntent({
-        name: inquiry,
-        description: "",
-        input: { type: "object" },
-        output: { type: "object" }
-      });
+      if (!this.intents.has(inquiry)) {
+        this.addIntent({
+          name: inquiry,
+          description: "",
+          input: { type: "object" },
+          output: { type: "object" }
+        });
+      }
     }
   }
   addIntent(intent) {