agent-contracts 0.22.9 → 0.23.1

package/dist/index.js

@@ -49856,12 +49856,18 @@ var MergeError = class extends Error {
 function isRecord2(v2) {
   return typeof v2 === "object" && v2 !== null && !Array.isArray(v2);
 }
-function hasOperator(obj) {
+function hasOperator(obj, path) {
   const ops = ["$append", "$prepend", "$insert_after", "$replace", "$remove"];
+  const found = [];
   for (const op of ops) {
-    if (op in obj) return op;
+    if (op in obj) found.push(op);
   }
-  return null;
+  if (found.length > 1) {
+    throw new MergeError(
+      `Multiple merge operators in the same object at ${path ?? "unknown"}: ${found.join(", ")}`
+    );
+  }
+  return found.length === 1 ? found[0] : null;
 }
 function findIndexByIdOrValue(arr, target) {
   return arr.findIndex((item) => {
@@ -49872,7 +49878,7 @@ function findIndexByIdOrValue(arr, target) {
   });
 }
 function applyArrayMergeOperator(baseArray, operatorObj, path) {
-  const op = hasOperator(operatorObj);
+  const op = hasOperator(operatorObj, path);
   if (!op) return baseArray;
   switch (op) {
     case "$append": {
@@ -49946,9 +49952,13 @@ function applyArrayMergeOperator(baseArray, operatorObj, path) {
   }
 }
 function orderedInsertAfter(base, afterKey, entries) {
+  const entryKeys = new Set(Object.keys(entries));
   const result = {};
   let inserted = false;
   for (const key of Object.keys(base)) {
+    if (inserted && entryKeys.has(key)) {
+      continue;
+    }
     result[key] = base[key];
     if (key === afterKey) {
       for (const [ek, ev] of Object.entries(entries)) {
@@ -49957,13 +49967,10 @@ function orderedInsertAfter(base, afterKey, entries) {
       inserted = true;
     }
   }
-  if (!inserted) {
-    return result;
-  }
   return result;
 }
 function applyMapMergeOperator(baseMap, operatorObj, path) {
-  const op = hasOperator(operatorObj);
+  const op = hasOperator(operatorObj, path);
   if (!op) return baseMap;
   switch (op) {
     case "$append": {
@@ -50014,7 +50021,7 @@ function deepMergeEntities(base, project, path, hasExtends) {
   for (const key of Object.keys(project)) {
     const baseVal = result[key];
     const projVal = project[key];
-    if (isRecord2(projVal) && hasOperator(projVal)) {
+    if (isRecord2(projVal) && hasOperator(projVal, `${path}.${key}`)) {
       if (!hasExtends) {
         throw new MergeError(
           `Merge operator used without extends at ${path}.${key}`
@@ -50025,7 +50032,12 @@ function deepMergeEntities(base, project, path, hasExtends) {
       } else if (isRecord2(baseVal)) {
         result[key] = applyMapMergeOperator(baseVal, projVal, `${path}.${key}`);
       } else {
-        result[key] = applyArrayMergeOperator([], projVal, `${path}.${key}`);
+        const op = hasOperator(projVal, `${path}.${key}`);
+        if (op === "$replace") {
+          result[key] = projVal["$replace"];
+        } else {
+          result[key] = applyArrayMergeOperator([], projVal, `${path}.${key}`);
+        }
       }
     } else if (isRecord2(projVal) && isRecord2(baseVal) && !Array.isArray(projVal) && !Array.isArray(baseVal)) {
       result[key] = deepMergeEntities(
@@ -50041,10 +50053,44 @@ function deepMergeEntities(base, project, path, hasExtends) {
   return result;
 }
 var OPERATOR_KEYS = /* @__PURE__ */ new Set(["$append", "$prepend", "$insert_after", "$replace", "$remove"]);
+function mergeSection(base, project, path, hasExtends, mode) {
+  switch (mode) {
+    case "map": {
+      const baseMap = isRecord2(base) ? base : {};
+      return mergeEntityMaps(baseMap, project, path, hasExtends);
+    }
+    case "array": {
+      const baseArr = Array.isArray(base) ? base : [];
+      if (isRecord2(project) && hasOperator(project, path)) {
+        if (!hasExtends) {
+          throw new MergeError(
+            `Merge operator used without extends at ${path}`
+          );
+        }
+        return applyArrayMergeOperator(baseArr, project, path);
+      }
+      const projArr = Array.isArray(project) ? project : [];
+      return [...baseArr, ...projArr];
+    }
+    case "object": {
+      const baseObj = isRecord2(base) ? base : {};
+      const projObj = isRecord2(project) ? project : {};
+      if (hasOperator(projObj, path)) {
+        if (!hasExtends) {
+          throw new MergeError(
+            `Merge operator used without extends at ${path}`
+          );
+        }
+        return applyMapMergeOperator(baseObj, projObj, path);
+      }
+      return deepMergeEntities(baseObj, projObj, path, hasExtends);
+    }
+  }
+}
 function mergeEntityMaps(baseMap, projectMap, path, hasExtends) {
   let result;
   if (isRecord2(projectMap) && !Array.isArray(projectMap)) {
-    const op = hasOperator(projectMap);
+    const op = hasOperator(projectMap, path);
     if (op) {
       if (!hasExtends) {
         throw new MergeError(
@@ -50061,9 +50107,10 @@ function mergeEntityMaps(baseMap, projectMap, path, hasExtends) {
   for (const [key, projVal] of Object.entries(projectMap)) {
     if (OPERATOR_KEYS.has(key)) continue;
     const baseVal = result[key];
-    if (baseVal !== void 0 && isRecord2(baseVal) && isRecord2(projVal)) {
+    if (isRecord2(projVal) && !Array.isArray(projVal)) {
+      const baseObj = isRecord2(baseVal) ? baseVal : {};
       result[key] = deepMergeEntities(
-        baseVal,
+        baseObj,
         projVal,
         `${path}.${key}`,
         hasExtends
@@ -50074,44 +50121,33 @@ function mergeEntityMaps(baseMap, projectMap, path, hasExtends) {
   }
   return result;
 }
-var MERGE_SECTIONS = [
-  "agents",
-  "tasks",
-  "artifacts",
-  "tools",
-  "validations",
-  "handoff_types",
-  "imports",
-  "workflow",
-  "policies",
-  "guardrails",
-  "guardrail_policies",
-  "components",
-  "extensions"
-];
+var DSL_SECTIONS = {
+  agents: "map",
+  tasks: "map",
+  artifacts: "map",
+  tools: "map",
+  validations: "map",
+  handoff_types: "map",
+  imports: "map",
+  workflow: "map",
+  policies: "map",
+  guardrails: "map",
+  guardrail_policies: "map",
+  components: "map",
+  extensions: "map",
+  system: "object"
+};
 function mergeDsl(base, project) {
   const hasExtends = typeof project["extends"] === "string";
   const result = { ...base, ...project };
-  if (project["system"] && base["system"]) {
-    result["system"] = deepMergeEntities(
-      base["system"],
-      project["system"],
-      "system",
-      hasExtends
-    );
-  }
-  for (const section of MERGE_SECTIONS) {
-    const baseVal = base[section];
-    const projVal = project[section];
-    if (projVal === void 0) {
-      continue;
-    }
-    const baseMap = isRecord2(baseVal) ? baseVal : {};
-    result[section] = mergeEntityMaps(
-      baseMap,
-      projVal,
+  for (const [section, mode] of Object.entries(DSL_SECTIONS)) {
+    if (project[section] === void 0) continue;
+    result[section] = mergeSection(
+      base[section],
+      project[section],
       section,
-      hasExtends
+      hasExtends,
+      mode
     );
   }
   delete result["extends"];
@@ -54464,42 +54500,23 @@ function resolveDslPath(dirArg, dirArgDefault, config) {
 }
 
 // src/config/binding-merger.ts
-function isRecord5(v2) {
-  return typeof v2 === "object" && v2 !== null && !Array.isArray(v2);
-}
-var BINDING_MAP_MERGE_SECTIONS = ["guardrail_impl", "outputs"];
-var BINDING_ARRAY_MERGE_SECTIONS = ["renders"];
+var BINDING_SECTIONS = {
+  guardrail_impl: "map",
+  outputs: "map",
+  renders: "array",
+  reporting: "object"
+};
 function mergeBinding(base, project) {
   const hasExtends = typeof project["extends"] === "string";
   const result = { ...base, ...project };
-  for (const section of BINDING_MAP_MERGE_SECTIONS) {
-    const baseVal = base[section];
-    const projVal = project[section];
-    if (projVal === void 0) {
-      continue;
-    }
-    const baseMap = isRecord5(baseVal) ? baseVal : {};
-    result[section] = mergeEntityMaps(
-      baseMap,
-      projVal,
+  for (const [section, mode] of Object.entries(BINDING_SECTIONS)) {
+    if (project[section] === void 0) continue;
+    result[section] = mergeSection(
+      base[section],
+      project[section],
       section,
-      hasExtends
-    );
-  }
-  for (const section of BINDING_ARRAY_MERGE_SECTIONS) {
-    const baseVal = base[section];
-    const projVal = project[section];
-    if (projVal === void 0) continue;
-    const baseArr = Array.isArray(baseVal) ? baseVal : [];
-    const projArr = Array.isArray(projVal) ? projVal : [];
-    result[section] = [...baseArr, ...projArr];
-  }
-  if (project["reporting"] !== void 0 && isRecord5(base["reporting"]) && isRecord5(project["reporting"])) {
-    result["reporting"] = deepMergeEntities(
-      base["reporting"],
-      project["reporting"],
-      "reporting",
-      hasExtends
+      hasExtends,
+      mode
     );
   }
   delete result["extends"];
@@ -54990,7 +55007,7 @@ function formatDslOverview(dsl) {
     `- Validations: ${Object.keys(dsl.validations).join(", ")}`
   ].join("\n");
 }
-function isRecord6(v2) {
+function isRecord5(v2) {
   return typeof v2 === "object" && v2 !== null && !Array.isArray(v2);
 }
 function collectAllXUsages(dsl) {
@@ -55003,7 +55020,7 @@ function collectAllXUsages(dsl) {
     }
   }
   walk(dsl, "", "root");
-  if (isRecord6(dsl.system)) walk(dsl.system, "system", "system");
+  if (isRecord5(dsl.system)) walk(dsl.system, "system", "system");
   for (const [id, a3] of Object.entries(dsl.agents))
     walk(a3, `agents.${id}`, "agent");
   for (const [id, t3] of Object.entries(dsl.tasks))