agent-contracts 0.12.4 → 0.13.0

package/dist/index.js

@@ -49863,7 +49863,7 @@ var require_dist12 = __commonJS({
     var draft4MetaSchema = require_json_schema_draft_04();
     var META_SUPPORT_DATA = ["/properties"];
     var META_SCHEMA_ID = "http://json-schema.org/draft-04/schema";
-    var Ajv2 = class extends core_1.default {
+    var Ajv3 = class extends core_1.default {
       constructor(opts = {}) {
         super({
           ...opts,
@@ -49888,9 +49888,9 @@ var require_dist12 = __commonJS({
         return this.opts.defaultMeta = super.defaultMeta() || (this.getSchema(META_SCHEMA_ID) ? META_SCHEMA_ID : void 0);
       }
     };
-    module.exports = exports = Ajv2;
+    module.exports = exports = Ajv3;
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.default = Ajv2;
+    exports.default = Ajv3;
     var core_2 = __require("ajv/dist/core");
     Object.defineProperty(exports, "KeywordCxt", { enumerable: true, get: function() {
       return core_2.KeywordCxt;
@@ -50087,8 +50087,8 @@ var require_ajv2 = __commonJS({
       log: console.log,
       error: console.error
     };
-    function createAjvInstance(Ajv2, allErrors) {
-      const ajv2 = new Ajv2({
+    function createAjvInstance(Ajv3, allErrors) {
+      const ajv2 = new Ajv3({
         allErrors,
         meta: true,
         messages: true,
@@ -50101,22 +50101,22 @@ var require_ajv2 = __commonJS({
       if (allErrors) {
         (0, ajv_errors_1.default)(ajv2);
       }
-      if (Ajv2 === ajv_1.default) {
+      if (Ajv3 === ajv_1.default) {
         ajv2.addSchema(draft4MetaSchema);
         ajv2.addSchema(draft6MetaSchema);
       }
       return ajv2;
     }
-    function _createAjvInstances(Ajv2) {
+    function _createAjvInstances(Ajv3) {
       let _default;
       let _allErrors;
       return {
         get default() {
-          _default !== null && _default !== void 0 ? _default : _default = createAjvInstance(Ajv2, false);
+          _default !== null && _default !== void 0 ? _default : _default = createAjvInstance(Ajv3, false);
           return _default;
         },
         get allErrors() {
-          _allErrors !== null && _allErrors !== void 0 ? _allErrors : _allErrors = createAjvInstance(Ajv2, true);
+          _allErrors !== null && _allErrors !== void 0 ? _allErrors : _allErrors = createAjvInstance(Ajv3, true);
           return _allErrors;
         }
       };
@@ -50748,10 +50748,34 @@ var WorkflowSchema = z11.object({
 var ComponentsSchema = z12.object({
   schemas: z12.record(z12.string(), z12.record(z12.string(), z12.any())).default({})
 }).passthrough();
+var SCOPE_NODE_TYPES = [
+  "root",
+  "system",
+  "agent",
+  "task",
+  "execution_step",
+  "artifact",
+  "tool",
+  "tool_command",
+  "validation",
+  "handoff_type",
+  "workflow",
+  "workflow_step",
+  "policy",
+  "guardrail",
+  "guardrail_policy",
+  "rule",
+  "escalation_criterion",
+  "prerequisite"
+];
+var ScopeNodeTypeSchema = z12.enum(SCOPE_NODE_TYPES);
 var XExtensionDeclSchema = z12.object({
   type: z12.string(),
   items: z12.string().optional(),
-  description: z12.string().optional()
+  description: z12.string().optional(),
+  scope: z12.array(ScopeNodeTypeSchema).optional(),
+  schema: z12.record(z12.string(), z12.any()).optional(),
+  required: z12.boolean().default(false)
 });
 var DslSchema = z12.object({
   version: z12.literal(1),
@@ -50768,7 +50792,8 @@ var DslSchema = z12.object({
   guardrails: z12.record(z12.string(), GuardrailSchema).default({}),
   guardrail_policies: z12.record(z12.string(), GuardrailPolicySchema).default({}),
   components: ComponentsSchema.default({ schemas: {} }),
-  "x-extensions": z12.record(z12.string(), XExtensionDeclSchema).optional()
+  extensions: z12.record(z12.string(), XExtensionDeclSchema).default({}),
+  extensions_strict: z12.boolean().default(false)
 }).passthrough();
 
 // src/schema/json-schema-utils.ts
@@ -51387,7 +51412,8 @@ var MERGE_SECTIONS = [
   "policies",
   "guardrails",
   "guardrail_policies",
-  "components"
+  "components",
+  "extensions"
 ];
 function mergeDsl(base, project) {
   const hasExtends = typeof project["extends"] === "string";
@@ -51449,6 +51475,7 @@ function expandDefaults(data) {
 }
 
 // src/validator/schema-validator.ts
+import Ajv from "ajv";
 import { z as z14 } from "zod";
 function unwrap(schema) {
   if (schema instanceof z14.ZodOptional) return unwrap(schema.unwrap());
@@ -51510,14 +51537,14 @@ function checkCustomPropsRecursive(data, schema, path) {
   }
   return [];
 }
-function checkXExtensionsKeys(data) {
-  const extensions = data["x-extensions"];
+function checkExtensionsKeys(data) {
+  const extensions = data["extensions"];
   if (typeof extensions !== "object" || extensions === null) return [];
   const diagnostics = [];
   for (const key of Object.keys(extensions)) {
     if (!key.startsWith("x-")) {
       diagnostics.push({
-        path: `x-extensions.${key}`,
+        path: `extensions.${key}`,
         message: `Extension key "${key}" must start with "x-" prefix.`,
         code: "x-extension-key-prefix"
       });
@@ -51551,29 +51578,634 @@ function checkDecisionStepRoutingKey(data) {
   }
   return diagnostics;
 }
-function validateSchema(data) {
-  const result = DslSchema.safeParse(data);
-  if (!result.success) {
-    const diagnostics = result.error.issues.map((issue) => ({
-      path: issue.path.join("."),
-      message: issue.message,
-      code: "schema-validation"
-    }));
-    return { success: false, diagnostics };
+function isRecord3(v2) {
+  return typeof v2 === "object" && v2 !== null && !Array.isArray(v2);
+}
+function* enumerateEntitiesByType(data, nodeType) {
+  switch (nodeType) {
+    case "root":
+      yield { path: "", obj: data };
+      return;
+    case "system": {
+      const sys = data["system"];
+      if (isRecord3(sys)) yield { path: "system", obj: sys };
+      return;
+    }
+    case "agent": {
+      const agents = data["agents"];
+      if (!isRecord3(agents)) return;
+      for (const [id, a3] of Object.entries(agents)) {
+        if (isRecord3(a3)) yield { path: `agents.${id}`, obj: a3 };
+      }
+      return;
+    }
+    case "rule": {
+      const agents = data["agents"];
+      if (!isRecord3(agents)) return;
+      for (const [aid, a3] of Object.entries(agents)) {
+        if (!isRecord3(a3)) continue;
+        const rules = a3["rules"];
+        if (!Array.isArray(rules)) continue;
+        for (let i3 = 0; i3 < rules.length; i3++) {
+          const r3 = rules[i3];
+          if (isRecord3(r3)) yield { path: `agents.${aid}.rules[${i3}]`, obj: r3 };
+        }
+      }
+      return;
+    }
+    case "escalation_criterion": {
+      const agents = data["agents"];
+      if (!isRecord3(agents)) return;
+      for (const [aid, a3] of Object.entries(agents)) {
+        if (!isRecord3(a3)) continue;
+        const esc = a3["escalation_criteria"];
+        if (!Array.isArray(esc)) continue;
+        for (let i3 = 0; i3 < esc.length; i3++) {
+          const e3 = esc[i3];
+          if (isRecord3(e3)) {
+            yield {
+              path: `agents.${aid}.escalation_criteria[${i3}]`,
+              obj: e3
+            };
+          }
+        }
+      }
+      return;
+    }
+    case "prerequisite": {
+      const agents = data["agents"];
+      if (!isRecord3(agents)) return;
+      for (const [aid, a3] of Object.entries(agents)) {
+        if (!isRecord3(a3)) continue;
+        const pre = a3["prerequisites"];
+        if (!Array.isArray(pre)) continue;
+        for (let i3 = 0; i3 < pre.length; i3++) {
+          const p2 = pre[i3];
+          if (isRecord3(p2)) {
+            yield { path: `agents.${aid}.prerequisites[${i3}]`, obj: p2 };
+          }
+        }
+      }
+      return;
+    }
+    case "task": {
+      const tasks = data["tasks"];
+      if (!isRecord3(tasks)) return;
+      for (const [id, t3] of Object.entries(tasks)) {
+        if (isRecord3(t3)) yield { path: `tasks.${id}`, obj: t3 };
+      }
+      return;
+    }
+    case "execution_step": {
+      const tasks = data["tasks"];
+      if (!isRecord3(tasks)) return;
+      for (const [tid, t3] of Object.entries(tasks)) {
+        if (!isRecord3(t3)) continue;
+        const steps = t3["execution_steps"];
+        if (!Array.isArray(steps)) continue;
+        for (let i3 = 0; i3 < steps.length; i3++) {
+          const s2 = steps[i3];
+          if (isRecord3(s2)) {
+            yield {
+              path: `tasks.${tid}.execution_steps[${i3}]`,
+              obj: s2
+            };
+          }
+        }
+      }
+      return;
+    }
+    case "artifact": {
+      const arts = data["artifacts"];
+      if (!isRecord3(arts)) return;
+      for (const [id, a3] of Object.entries(arts)) {
+        if (isRecord3(a3)) yield { path: `artifacts.${id}`, obj: a3 };
+      }
+      return;
+    }
+    case "tool": {
+      const tools = data["tools"];
+      if (!isRecord3(tools)) return;
+      for (const [id, t3] of Object.entries(tools)) {
+        if (isRecord3(t3)) yield { path: `tools.${id}`, obj: t3 };
+      }
+      return;
+    }
+    case "tool_command": {
+      const tools = data["tools"];
+      if (!isRecord3(tools)) return;
+      for (const [tid, t3] of Object.entries(tools)) {
+        if (!isRecord3(t3)) continue;
+        const cmds = t3["commands"];
+        if (!Array.isArray(cmds)) continue;
+        for (let i3 = 0; i3 < cmds.length; i3++) {
+          const c2 = cmds[i3];
+          if (isRecord3(c2)) {
+            yield { path: `tools.${tid}.commands[${i3}]`, obj: c2 };
+          }
+        }
+      }
+      return;
+    }
+    case "validation": {
+      const vals = data["validations"];
+      if (!isRecord3(vals)) return;
+      for (const [id, v2] of Object.entries(vals)) {
+        if (isRecord3(v2)) yield { path: `validations.${id}`, obj: v2 };
+      }
+      return;
+    }
+    case "handoff_type": {
+      const ht = data["handoff_types"];
+      if (!isRecord3(ht)) return;
+      for (const [id, h2] of Object.entries(ht)) {
+        if (isRecord3(h2)) yield { path: `handoff_types.${id}`, obj: h2 };
+      }
+      return;
+    }
+    case "workflow": {
+      const wf = data["workflow"];
+      if (!isRecord3(wf)) return;
+      for (const [id, w2] of Object.entries(wf)) {
+        if (isRecord3(w2)) yield { path: `workflow.${id}`, obj: w2 };
+      }
+      return;
+    }
+    case "workflow_step": {
+      const wf = data["workflow"];
+      if (!isRecord3(wf)) return;
+      for (const [wid, w2] of Object.entries(wf)) {
+        if (!isRecord3(w2)) continue;
+        const steps = w2["steps"];
+        if (!Array.isArray(steps)) continue;
+        for (let i3 = 0; i3 < steps.length; i3++) {
+          const s2 = steps[i3];
+          if (isRecord3(s2)) {
+            yield { path: `workflow.${wid}.steps[${i3}]`, obj: s2 };
+          }
+        }
+      }
+      return;
+    }
+    case "policy": {
+      const pol = data["policies"];
+      if (!isRecord3(pol)) return;
+      for (const [id, p2] of Object.entries(pol)) {
+        if (isRecord3(p2)) yield { path: `policies.${id}`, obj: p2 };
+      }
+      return;
+    }
+    case "guardrail": {
+      const gr = data["guardrails"];
+      if (!isRecord3(gr)) return;
+      for (const [id, g2] of Object.entries(gr)) {
+        if (isRecord3(g2)) yield { path: `guardrails.${id}`, obj: g2 };
+      }
+      return;
+    }
+    case "guardrail_policy": {
+      const gp = data["guardrail_policies"];
+      if (!isRecord3(gp)) return;
+      for (const [id, p2] of Object.entries(gp)) {
+        if (isRecord3(p2)) yield { path: `guardrail_policies.${id}`, obj: p2 };
+      }
+      return;
+    }
+    default:
+      return;
+  }
+}
+function validateDeclaredExtension(parentPath, nodeType, key, val, declMap, diagnostics, ajvInstance, strict) {
+  const path = parentPath ? `${parentPath}.${key}` : key;
+  const decl = declMap[key];
+  if (decl === void 0) {
+    diagnostics.push({
+      path,
+      message: `Extension "${key}" is not declared in extensions.`,
+      code: "undeclared-extension",
+      ...!strict ? { severity: "warning" } : {}
+    });
+    return;
+  }
+  const scope = decl.scope;
+  if (scope && scope.length > 0 && !scope.includes(nodeType)) {
+    diagnostics.push({
+      path,
+      message: `Extension "${key}" is not allowed on ${nodeType} (declared scope: ${scope.join(", ")}).`,
+      code: "extension-scope-mismatch"
+    });
+    return;
+  }
+  if (decl.schema && typeof decl.schema === "object" && decl.schema !== null && Object.keys(decl.schema).length > 0) {
+    try {
+      const validate = ajvInstance.compile(decl.schema);
+      if (!validate(val)) {
+        diagnostics.push({
+          path,
+          message: `Extension "${key}" value does not match declared schema: ${ajvInstance.errorsText(validate.errors)}`,
+          code: "extension-schema-violation"
+        });
+      }
+    } catch (e3) {
+      diagnostics.push({
+        path,
+        message: `Extension "${key}" has invalid JSON Schema in declaration: ${e3 instanceof Error ? e3.message : String(e3)}`,
+        code: "extension-schema-violation"
+      });
+    }
+  }
+}
+function walkExtensionNodes(value, path, nodeType, declMap, diagnostics, ajvInstance, strict) {
+  if (!isRecord3(value)) return;
+  const obj = value;
+  for (const key of Object.keys(obj)) {
+    if (key === "extensions" || key === "extensions_strict" || key === "x-extensions" || key === "x-extensions-strict") {
+      continue;
+    }
+    if (key.startsWith("x-")) {
+      validateDeclaredExtension(
+        path,
+        nodeType,
+        key,
+        obj[key],
+        declMap,
+        diagnostics,
+        ajvInstance,
+        strict
+      );
+    }
+  }
+  switch (nodeType) {
+    case "root": {
+      const sys = obj["system"];
+      if (isRecord3(sys)) {
+        walkExtensionNodes(
+          sys,
+          "system",
+          "system",
+          declMap,
+          diagnostics,
+          ajvInstance,
+          strict
+        );
+      }
+      const agents = obj["agents"];
+      if (isRecord3(agents)) {
+        for (const [id, a3] of Object.entries(agents)) {
+          if (isRecord3(a3)) {
+            walkExtensionNodes(
+              a3,
+              `agents.${id}`,
+              "agent",
+              declMap,
+              diagnostics,
+              ajvInstance,
+              strict
+            );
+          }
+        }
+      }
+      const tasks = obj["tasks"];
+      if (isRecord3(tasks)) {
+        for (const [id, t3] of Object.entries(tasks)) {
+          if (isRecord3(t3)) {
+            walkExtensionNodes(
+              t3,
+              `tasks.${id}`,
+              "task",
+              declMap,
+              diagnostics,
+              ajvInstance,
+              strict
+            );
+          }
+        }
+      }
+      const artifacts = obj["artifacts"];
+      if (isRecord3(artifacts)) {
+        for (const [id, a3] of Object.entries(artifacts)) {
+          if (isRecord3(a3)) {
+            walkExtensionNodes(
+              a3,
+              `artifacts.${id}`,
+              "artifact",
+              declMap,
+              diagnostics,
+              ajvInstance,
+              strict
+            );
+          }
+        }
+      }
+      const tools = obj["tools"];
+      if (isRecord3(tools)) {
+        for (const [id, t3] of Object.entries(tools)) {
+          if (isRecord3(t3)) {
+            walkExtensionNodes(
+              t3,
+              `tools.${id}`,
+              "tool",
+              declMap,
+              diagnostics,
+              ajvInstance,
+              strict
+            );
+          }
+        }
+      }
+      const validations = obj["validations"];
+      if (isRecord3(validations)) {
+        for (const [id, v2] of Object.entries(validations)) {
+          if (isRecord3(v2)) {
+            walkExtensionNodes(
+              v2,
+              `validations.${id}`,
+              "validation",
+              declMap,
+              diagnostics,
+              ajvInstance,
+              strict
+            );
+          }
+        }
+      }
+      const handoffTypes = obj["handoff_types"];
+      if (isRecord3(handoffTypes)) {
+        for (const [id, h2] of Object.entries(handoffTypes)) {
+          if (isRecord3(h2)) {
+            walkExtensionNodes(
+              h2,
+              `handoff_types.${id}`,
+              "handoff_type",
+              declMap,
+              diagnostics,
+              ajvInstance,
+              strict
+            );
+          }
+        }
+      }
+      const workflow = obj["workflow"];
+      if (isRecord3(workflow)) {
+        for (const [id, w2] of Object.entries(workflow)) {
+          if (isRecord3(w2)) {
+            walkExtensionNodes(
+              w2,
+              `workflow.${id}`,
+              "workflow",
+              declMap,
+              diagnostics,
+              ajvInstance,
+              strict
+            );
+          }
+        }
+      }
+      const policies = obj["policies"];
+      if (isRecord3(policies)) {
+        for (const [id, p2] of Object.entries(policies)) {
+          if (isRecord3(p2)) {
+            walkExtensionNodes(
+              p2,
+              `policies.${id}`,
+              "policy",
+              declMap,
+              diagnostics,
+              ajvInstance,
+              strict
+            );
+          }
+        }
+      }
+      const guardrails = obj["guardrails"];
+      if (isRecord3(guardrails)) {
+        for (const [id, g2] of Object.entries(guardrails)) {
+          if (isRecord3(g2)) {
+            walkExtensionNodes(
+              g2,
+              `guardrails.${id}`,
+              "guardrail",
+              declMap,
+              diagnostics,
+              ajvInstance,
+              strict
+            );
+          }
+        }
+      }
+      const guardrailPolicies = obj["guardrail_policies"];
+      if (isRecord3(guardrailPolicies)) {
+        for (const [id, p2] of Object.entries(guardrailPolicies)) {
+          if (isRecord3(p2)) {
+            walkExtensionNodes(
+              p2,
+              `guardrail_policies.${id}`,
+              "guardrail_policy",
+              declMap,
+              diagnostics,
+              ajvInstance,
+              strict
+            );
+          }
+        }
+      }
+      break;
+    }
+    case "agent": {
+      const rules = obj["rules"];
+      if (Array.isArray(rules)) {
+        for (let i3 = 0; i3 < rules.length; i3++) {
+          const r3 = rules[i3];
+          if (isRecord3(r3)) {
+            walkExtensionNodes(
+              r3,
+              `${path}.rules[${i3}]`,
+              "rule",
+              declMap,
+              diagnostics,
+              ajvInstance,
+              strict
+            );
+          }
+        }
+      }
+      const esc = obj["escalation_criteria"];
+      if (Array.isArray(esc)) {
+        for (let i3 = 0; i3 < esc.length; i3++) {
+          const e3 = esc[i3];
+          if (isRecord3(e3)) {
+            walkExtensionNodes(
+              e3,
+              `${path}.escalation_criteria[${i3}]`,
+              "escalation_criterion",
+              declMap,
+              diagnostics,
+              ajvInstance,
+              strict
+            );
+          }
+        }
+      }
+      const pre = obj["prerequisites"];
+      if (Array.isArray(pre)) {
+        for (let i3 = 0; i3 < pre.length; i3++) {
+          const p2 = pre[i3];
+          if (isRecord3(p2)) {
+            walkExtensionNodes(
+              p2,
+              `${path}.prerequisites[${i3}]`,
+              "prerequisite",
+              declMap,
+              diagnostics,
+              ajvInstance,
+              strict
+            );
+          }
+        }
+      }
+      break;
+    }
+    case "task": {
+      const steps = obj["execution_steps"];
+      if (Array.isArray(steps)) {
+        for (let i3 = 0; i3 < steps.length; i3++) {
+          const s2 = steps[i3];
+          if (isRecord3(s2)) {
+            walkExtensionNodes(
+              s2,
+              `${path}.execution_steps[${i3}]`,
+              "execution_step",
+              declMap,
+              diagnostics,
+              ajvInstance,
+              strict
+            );
+          }
+        }
+      }
+      break;
+    }
+    case "tool": {
+      const cmds = obj["commands"];
+      if (Array.isArray(cmds)) {
+        for (let i3 = 0; i3 < cmds.length; i3++) {
+          const c2 = cmds[i3];
+          if (isRecord3(c2)) {
+            walkExtensionNodes(
+              c2,
+              `${path}.commands[${i3}]`,
+              "tool_command",
+              declMap,
+              diagnostics,
+              ajvInstance,
+              strict
+            );
+          }
+        }
+      }
+      break;
+    }
+    case "workflow": {
+      const steps = obj["steps"];
+      if (Array.isArray(steps)) {
+        for (let i3 = 0; i3 < steps.length; i3++) {
+          const s2 = steps[i3];
+          if (isRecord3(s2)) {
+            walkExtensionNodes(
+              s2,
+              `${path}.steps[${i3}]`,
+              "workflow_step",
+              declMap,
+              diagnostics,
+              ajvInstance,
+              strict
+            );
+          }
+        }
+      }
+      break;
+    }
+    default:
+      break;
   }
-  const customPropDiagnostics = checkCustomPropsRecursive(data, DslSchema, "");
-  if (customPropDiagnostics.length > 0) {
-    return { success: false, diagnostics: customPropDiagnostics };
+}
+function checkExtensionValidation(data) {
+  const strict = data["extensions_strict"] === true;
+  const raw = data["extensions"];
+  let declMap;
+  if (!isRecord3(raw) || Object.keys(raw).length === 0) {
+    if (!strict) return [];
+    declMap = {};
+  } else {
+    declMap = raw;
   }
-  const decisionDiagnostics = checkDecisionStepRoutingKey(data);
-  if (decisionDiagnostics.length > 0) {
-    return { success: false, diagnostics: decisionDiagnostics };
+  const diagnostics = [];
+  const ajvInstance = new Ajv({ allErrors: true, strict: false });
+  walkExtensionNodes(data, "", "root", declMap, diagnostics, ajvInstance, strict);
+  for (const [extKey, decl] of Object.entries(declMap)) {
+    if (!decl.required) continue;
+    const applicableTypes = decl.scope && decl.scope.length > 0 ? decl.scope : [...SCOPE_NODE_TYPES];
+    for (const t3 of applicableTypes) {
+      for (const { path, obj } of enumerateEntitiesByType(data, t3)) {
+        if (!(extKey in obj)) {
+          diagnostics.push({
+            path,
+            message: `Required extension "${extKey}" is missing on ${t3}.`,
+            code: "extension-required-missing"
+          });
+        }
+      }
+    }
   }
-  const xExtDiagnostics = checkXExtensionsKeys(data);
-  if (xExtDiagnostics.length > 0) {
-    return { success: false, diagnostics: xExtDiagnostics };
+  return diagnostics;
+}
+function hasBlockingDiagnostic(diagnostics) {
+  return diagnostics.some((d2) => d2.severity !== "warning");
+}
+function validateSchema(data) {
+  const deprecationWarnings = [];
+  if ("x-extensions" in data && !("extensions" in data)) {
+    data["extensions"] = data["x-extensions"];
+    deprecationWarnings.push({
+      path: "x-extensions",
+      message: '"x-extensions" is deprecated. Use "extensions" instead.',
+      code: "deprecated-property",
+      severity: "warning"
+    });
   }
-  return { success: true, data: result.data, diagnostics: [] };
+  if ("x-extensions-strict" in data && !("extensions_strict" in data)) {
+    data["extensions_strict"] = data["x-extensions-strict"];
+    deprecationWarnings.push({
+      path: "x-extensions-strict",
+      message: '"x-extensions-strict" is deprecated. Use "extensions_strict" instead.',
+      code: "deprecated-property",
+      severity: "warning"
+    });
+  }
+  const result = DslSchema.safeParse(data);
+  if (!result.success) {
+    const diagnostics2 = [
+      ...deprecationWarnings,
+      ...result.error.issues.map((issue) => ({
+        path: issue.path.join("."),
+        message: issue.message,
+        code: "schema-validation"
+      }))
+    ];
+    return { success: false, diagnostics: diagnostics2 };
+  }
+  const diagnostics = [
+    ...deprecationWarnings,
+    ...checkCustomPropsRecursive(data, DslSchema, ""),
+    ...checkDecisionStepRoutingKey(data),
+    ...checkExtensionsKeys(data),
+    ...checkExtensionValidation(data)
+  ];
+  return {
+    success: !hasBlockingDiagnostic(diagnostics),
+    data: result.data,
+    diagnostics
+  };
 }
 
 // src/validator/reference-resolver.ts
@@ -51881,8 +52513,8 @@ function checkReferences(dsl) {
 }
 
 // src/validator/handoff-schema-validator.ts
-import Ajv from "ajv";
-var ajv = new Ajv({ allErrors: true, strict: false });
+import Ajv2 from "ajv";
+var ajv = new Ajv2({ allErrors: true, strict: false });
 function validateHandoffSchemas(dsl) {
   const diagnostics = [];
   for (const [kind, ht] of Object.entries(dsl.handoff_types)) {
@@ -54838,7 +55470,7 @@ function resolveDslPath(dirArg, dirArgDefault, config) {
 }
 
 // src/config/binding-merger.ts
-function isRecord3(v2) {
+function isRecord4(v2) {
   return typeof v2 === "object" && v2 !== null && !Array.isArray(v2);
 }
 var BINDING_MERGE_SECTIONS = ["guardrail_impl", "outputs"];
@@ -54851,7 +55483,7 @@ function mergeBinding(base, project) {
     if (projVal === void 0) {
       continue;
     }
-    const baseMap = isRecord3(baseVal) ? baseVal : {};
+    const baseMap = isRecord4(baseVal) ? baseVal : {};
     result[section] = mergeEntityMaps(
       baseMap,
       projVal,
@@ -54859,7 +55491,7 @@ function mergeBinding(base, project) {
       hasExtends
     );
   }
-  if (project["reporting"] !== void 0 && isRecord3(base["reporting"]) && isRecord3(project["reporting"])) {
+  if (project["reporting"] !== void 0 && isRecord4(base["reporting"]) && isRecord4(project["reporting"])) {
     result["reporting"] = deepMergeEntities(
       base["reporting"],
       project["reporting"],
@@ -55664,6 +56296,8 @@ export {
   ReplaceOperatorSchema,
   ReportingSchema,
   RuleSchema,
+  SCOPE_NODE_TYPES,
+  ScopeNodeTypeSchema,
   SoftwareBindingSchema,
   SystemSchema,
   TaskSchema,