@agentforge/core 0.18.1 → 0.18.2

package/dist/index.cjs

@@ -317,81 +317,64 @@ var MissingDescriptionError = class extends Error {
     this.name = "MissingDescriptionError";
   }
 };
-function validateSchemaDescriptions(schema, fieldPath = []) {
+function* findMissingDescriptions(schema, fieldPath = []) {
   const def = schema._def;
   const typeName = def.typeName;
   if (schema instanceof import_zod2.z.ZodObject) {
-    const shape = schema.shape;
-    Object.entries(shape).forEach(([key, fieldSchema]) => {
-      validateSchemaDescriptions(fieldSchema, [...fieldPath, key]);
-    });
-    return;
-  }
-  if (schema instanceof import_zod2.z.ZodArray) {
-    validateSchemaDescriptions(def.type, [...fieldPath, "[]"]);
-    return;
-  }
-  if (schema instanceof import_zod2.z.ZodOptional) {
-    const wrapperDescription = def.description;
-    const innerDescription = def.innerType._def.description;
-    if (fieldPath.length > 0 && !wrapperDescription && !innerDescription) {
-      throw new MissingDescriptionError(fieldPath, typeName);
-    }
-    if (!wrapperDescription) {
-      validateSchemaDescriptions(def.innerType, fieldPath);
+    for (const [key, fieldSchema] of Object.entries(schema.shape)) {
+      yield* findMissingDescriptions(fieldSchema, [...fieldPath, key]);
     }
     return;
   }
-  if (schema instanceof import_zod2.z.ZodNullable) {
-    const wrapperDescription = def.description;
-    const innerDescription = def.innerType._def.description;
-    if (fieldPath.length > 0 && !wrapperDescription && !innerDescription) {
-      throw new MissingDescriptionError(fieldPath, typeName);
-    }
-    if (!wrapperDescription) {
-      validateSchemaDescriptions(def.innerType, fieldPath);
-    }
+  if (schema instanceof import_zod2.z.ZodArray) {
+    yield* findMissingDescriptions(def.type, [...fieldPath, "[]"]);
     return;
   }
-  if (schema instanceof import_zod2.z.ZodDefault) {
+  if (schema instanceof import_zod2.z.ZodOptional || schema instanceof import_zod2.z.ZodNullable || schema instanceof import_zod2.z.ZodDefault) {
     const wrapperDescription = def.description;
     const innerDescription = def.innerType._def.description;
     if (fieldPath.length > 0 && !wrapperDescription && !innerDescription) {
-      throw new MissingDescriptionError(fieldPath, typeName);
+      yield { fieldPath, fieldType: typeName };
     }
     if (!wrapperDescription) {
-      validateSchemaDescriptions(def.innerType, fieldPath);
+      yield* findMissingDescriptions(def.innerType, fieldPath);
     }
     return;
   }
   if (schema instanceof import_zod2.z.ZodUnion) {
-    def.options.forEach((option, index) => {
-      validateSchemaDescriptions(option, [...fieldPath, `option${index}`]);
-    });
+    for (const [index, option] of def.options.entries()) {
+      yield* findMissingDescriptions(option, [...fieldPath, `option${index}`]);
+    }
     return;
   }
   if (schema instanceof import_zod2.z.ZodIntersection) {
-    validateSchemaDescriptions(def.left, fieldPath);
-    validateSchemaDescriptions(def.right, fieldPath);
+    yield* findMissingDescriptions(def.left, fieldPath);
+    yield* findMissingDescriptions(def.right, fieldPath);
     return;
   }
   if (schema instanceof import_zod2.z.ZodRecord) {
-    validateSchemaDescriptions(def.valueType, [...fieldPath, "[key]"]);
+    yield* findMissingDescriptions(def.valueType, [...fieldPath, "[key]"]);
     return;
   }
   if (schema instanceof import_zod2.z.ZodTuple) {
-    def.items.forEach((item, index) => {
-      validateSchemaDescriptions(item, [...fieldPath, `[${index}]`]);
-    });
+    for (const [index, item] of def.items.entries()) {
+      yield* findMissingDescriptions(item, [...fieldPath, `[${index}]`]);
+    }
     return;
   }
   if (fieldPath.length > 0) {
     const description = def.description;
     if (!description || description.trim() === "") {
-      throw new MissingDescriptionError(fieldPath, typeName);
+      yield { fieldPath, fieldType: typeName };
     }
   }
 }
+function validateSchemaDescriptions(schema, fieldPath = []) {
+  const firstFinding = findMissingDescriptions(schema, fieldPath).next();
+  if (!firstFinding.done) {
+    throw new MissingDescriptionError(firstFinding.value.fieldPath, firstFinding.value.fieldType);
+  }
+}
 function safeValidateSchemaDescriptions(schema) {
   try {
     validateSchemaDescriptions(schema);
@@ -405,39 +388,14 @@ function safeValidateSchemaDescriptions(schema) {
 }
 function getMissingDescriptions(schema) {
   const missing = [];
-  function check(s, path = []) {
-    const def = s._def;
-    const typeName = def.typeName;
-    if (s instanceof import_zod2.z.ZodObject) {
-      const shape = s.shape;
-      Object.entries(shape).forEach(([key, fieldSchema]) => {
-        check(fieldSchema, [...path, key]);
-      });
-      return;
-    }
-    if (s instanceof import_zod2.z.ZodOptional || s instanceof import_zod2.z.ZodNullable || s instanceof import_zod2.z.ZodDefault) {
-      const wrapperDescription = def.description;
-      const innerDescription = def.innerType._def.description;
-      if (path.length > 0 && !wrapperDescription && !innerDescription) {
-        missing.push(path.join("."));
-      }
-      if (!wrapperDescription) {
-        check(def.innerType, path);
-      }
-      return;
-    }
-    if (s instanceof import_zod2.z.ZodArray) {
-      check(def.type, [...path, "[]"]);
-      return;
-    }
-    if (path.length > 0) {
-      const description = def.description;
-      if (!description || description.trim() === "") {
-        missing.push(path.join("."));
-      }
+  const seen = /* @__PURE__ */ new Set();
+  for (const finding of findMissingDescriptions(schema)) {
+    const path = finding.fieldPath.join(".");
+    if (!seen.has(path)) {
+      seen.add(path);
+      missing.push(path);
     }
   }
-  check(schema);
   return missing;
 }
 

package/dist/index.js

@@ -141,81 +141,64 @@ var MissingDescriptionError = class extends Error {
     this.name = "MissingDescriptionError";
   }
 };
-function validateSchemaDescriptions(schema, fieldPath = []) {
+function* findMissingDescriptions(schema, fieldPath = []) {
   const def = schema._def;
   const typeName = def.typeName;
   if (schema instanceof z2.ZodObject) {
-    const shape = schema.shape;
-    Object.entries(shape).forEach(([key, fieldSchema]) => {
-      validateSchemaDescriptions(fieldSchema, [...fieldPath, key]);
-    });
-    return;
-  }
-  if (schema instanceof z2.ZodArray) {
-    validateSchemaDescriptions(def.type, [...fieldPath, "[]"]);
-    return;
-  }
-  if (schema instanceof z2.ZodOptional) {
-    const wrapperDescription = def.description;
-    const innerDescription = def.innerType._def.description;
-    if (fieldPath.length > 0 && !wrapperDescription && !innerDescription) {
-      throw new MissingDescriptionError(fieldPath, typeName);
-    }
-    if (!wrapperDescription) {
-      validateSchemaDescriptions(def.innerType, fieldPath);
+    for (const [key, fieldSchema] of Object.entries(schema.shape)) {
+      yield* findMissingDescriptions(fieldSchema, [...fieldPath, key]);
     }
     return;
   }
-  if (schema instanceof z2.ZodNullable) {
-    const wrapperDescription = def.description;
-    const innerDescription = def.innerType._def.description;
-    if (fieldPath.length > 0 && !wrapperDescription && !innerDescription) {
-      throw new MissingDescriptionError(fieldPath, typeName);
-    }
-    if (!wrapperDescription) {
-      validateSchemaDescriptions(def.innerType, fieldPath);
-    }
+  if (schema instanceof z2.ZodArray) {
+    yield* findMissingDescriptions(def.type, [...fieldPath, "[]"]);
     return;
   }
-  if (schema instanceof z2.ZodDefault) {
+  if (schema instanceof z2.ZodOptional || schema instanceof z2.ZodNullable || schema instanceof z2.ZodDefault) {
     const wrapperDescription = def.description;
     const innerDescription = def.innerType._def.description;
     if (fieldPath.length > 0 && !wrapperDescription && !innerDescription) {
-      throw new MissingDescriptionError(fieldPath, typeName);
+      yield { fieldPath, fieldType: typeName };
     }
     if (!wrapperDescription) {
-      validateSchemaDescriptions(def.innerType, fieldPath);
+      yield* findMissingDescriptions(def.innerType, fieldPath);
     }
     return;
   }
   if (schema instanceof z2.ZodUnion) {
-    def.options.forEach((option, index) => {
-      validateSchemaDescriptions(option, [...fieldPath, `option${index}`]);
-    });
+    for (const [index, option] of def.options.entries()) {
+      yield* findMissingDescriptions(option, [...fieldPath, `option${index}`]);
+    }
     return;
   }
   if (schema instanceof z2.ZodIntersection) {
-    validateSchemaDescriptions(def.left, fieldPath);
-    validateSchemaDescriptions(def.right, fieldPath);
+    yield* findMissingDescriptions(def.left, fieldPath);
+    yield* findMissingDescriptions(def.right, fieldPath);
     return;
   }
   if (schema instanceof z2.ZodRecord) {
-    validateSchemaDescriptions(def.valueType, [...fieldPath, "[key]"]);
+    yield* findMissingDescriptions(def.valueType, [...fieldPath, "[key]"]);
     return;
   }
   if (schema instanceof z2.ZodTuple) {
-    def.items.forEach((item, index) => {
-      validateSchemaDescriptions(item, [...fieldPath, `[${index}]`]);
-    });
+    for (const [index, item] of def.items.entries()) {
+      yield* findMissingDescriptions(item, [...fieldPath, `[${index}]`]);
+    }
     return;
   }
   if (fieldPath.length > 0) {
     const description = def.description;
     if (!description || description.trim() === "") {
-      throw new MissingDescriptionError(fieldPath, typeName);
+      yield { fieldPath, fieldType: typeName };
     }
   }
 }
+function validateSchemaDescriptions(schema, fieldPath = []) {
+  const firstFinding = findMissingDescriptions(schema, fieldPath).next();
+  if (!firstFinding.done) {
+    throw new MissingDescriptionError(firstFinding.value.fieldPath, firstFinding.value.fieldType);
+  }
+}
 function safeValidateSchemaDescriptions(schema) {
   try {
     validateSchemaDescriptions(schema);
@@ -229,39 +212,14 @@ function safeValidateSchemaDescriptions(schema) {
 }
 function getMissingDescriptions(schema) {
   const missing = [];
-  function check(s, path = []) {
-    const def = s._def;
-    const typeName = def.typeName;
-    if (s instanceof z2.ZodObject) {
-      const shape = s.shape;
-      Object.entries(shape).forEach(([key, fieldSchema]) => {
-        check(fieldSchema, [...path, key]);
-      });
-      return;
-    }
-    if (s instanceof z2.ZodOptional || s instanceof z2.ZodNullable || s instanceof z2.ZodDefault) {
-      const wrapperDescription = def.description;
-      const innerDescription = def.innerType._def.description;
-      if (path.length > 0 && !wrapperDescription && !innerDescription) {
-        missing.push(path.join("."));
-      }
-      if (!wrapperDescription) {
-        check(def.innerType, path);
-      }
-      return;
-    }
-    if (s instanceof z2.ZodArray) {
-      check(def.type, [...path, "[]"]);
-      return;
-    }
-    if (path.length > 0) {
-      const description = def.description;
-      if (!description || description.trim() === "") {
-        missing.push(path.join("."));
-      }
+  const seen = /* @__PURE__ */ new Set();
+  for (const finding of findMissingDescriptions(schema)) {
+    const path = finding.fieldPath.join(".");
+    if (!seen.has(path)) {
+      seen.add(path);
+      missing.push(path);
     }
   }
-  check(schema);
   return missing;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentforge/core",
-  "version": "0.18.1",
+  "version": "0.18.2",
   "description": "Production-ready TypeScript agent framework built on LangGraph with orchestration, middleware, and typed abstractions.",
   "type": "module",
   "main": "./dist/index.cjs",