@agentforge/core 0.18.0 → 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;
 }
 
@@ -4244,6 +4202,23 @@ function createInitialPoolStats() {
     healthChecksFailed: 0
   };
 }
+function checkoutConnection(runtime, pooled) {
+  const previousLastUsedAt = pooled.lastUsedAt;
+  pooled.inUse = true;
+  pooled.lastUsedAt = Date.now();
+  runtime.stats.available--;
+  runtime.stats.acquired++;
+  try {
+    runtime.options.onAcquire?.(pooled.connection);
+    return pooled.connection;
+  } catch (error) {
+    pooled.inUse = false;
+    pooled.lastUsedAt = previousLastUsedAt;
+    runtime.stats.available++;
+    runtime.stats.acquired--;
+    throw error;
+  }
+}
 async function initializeConnections(runtime, count) {
   runtime.creating += count;
   const promises = Array.from({ length: count }, async () => {
@@ -4265,23 +4240,22 @@ async function initializeConnections(runtime, count) {
   await Promise.all(promises);
 }
 function assignConnectionToPendingAcquire(runtime, connection) {
-  const pending = runtime.pending.shift();
-  if (!pending) {
-    return;
-  }
   const pooled = runtime.connections.find((item) => item.connection === connection);
   if (!pooled) {
-    runtime.pending.unshift(pending);
     return;
   }
-  clearTimeout(pending.timeout);
-  runtime.stats.pending--;
-  pooled.inUse = true;
-  pooled.lastUsedAt = Date.now();
-  runtime.stats.available--;
-  runtime.stats.acquired++;
-  runtime.options.onAcquire?.(connection);
-  pending.resolve(connection);
+  let pending = runtime.pending.shift();
+  while (pending) {
+    clearTimeout(pending.timeout);
+    runtime.stats.pending--;
+    try {
+      pending.resolve(checkoutConnection(runtime, pooled));
+      return;
+    } catch (error) {
+      pending.reject(error instanceof Error ? error : new Error(String(error)));
+      pending = runtime.pending.shift();
+    }
+  }
 }
 async function createConnection(runtime) {
   const connection = await runtime.options.factory();
@@ -4297,22 +4271,30 @@ async function createConnection(runtime) {
   runtime.stats.available++;
   return connection;
 }
+function finalizeDestroyedConnection(runtime, pooled) {
+  runtime.stats.destroyed++;
+  runtime.stats.size--;
+  if (pooled.inUse) {
+    runtime.stats.acquired--;
+  } else {
+    runtime.stats.available--;
+  }
+}
 async function destroyConnection(runtime, pooled) {
   const index = runtime.connections.indexOf(pooled);
   if (index !== -1) {
     runtime.connections.splice(index, 1);
   }
   if (runtime.options.destroyer) {
-    await runtime.options.destroyer(pooled.connection);
+    try {
+      await runtime.options.destroyer(pooled.connection);
+    } catch (error) {
+      finalizeDestroyedConnection(runtime, pooled);
+      throw error;
+    }
   }
   runtime.options.onDestroy?.(pooled.connection);
-  runtime.stats.destroyed++;
-  runtime.stats.size--;
-  if (pooled.inUse) {
-    runtime.stats.acquired--;
-  } else {
-    runtime.stats.available--;
-  }
+  finalizeDestroyedConnection(runtime, pooled);
 }
 function getPoolConfig(runtime) {
   return runtime.options.pool || {};
@@ -4331,12 +4313,7 @@ async function acquireConnection(runtime) {
   }
   const available = runtime.connections.find((connection) => !connection.inUse);
   if (available) {
-    available.inUse = true;
-    available.lastUsedAt = Date.now();
-    runtime.stats.available--;
-    runtime.stats.acquired++;
-    runtime.options.onAcquire?.(available.connection);
-    return available.connection;
+    return checkoutConnection(runtime, available);
   }
   const poolConfig = getPoolConfig(runtime);
   const max = poolConfig.max || 10;
@@ -4352,12 +4329,7 @@ async function acquireConnection(runtime) {
         await destroyConnection(runtime, pooled);
         throw new Error("Pool is draining");
       }
-      pooled.inUse = true;
-      pooled.lastUsedAt = Date.now();
-      runtime.stats.available--;
-      runtime.stats.acquired++;
-      runtime.options.onAcquire?.(connection);
-      return connection;
+      return checkoutConnection(runtime, pooled);
     } finally {
       runtime.creating--;
     }
@@ -4389,18 +4361,7 @@ async function releaseConnection(runtime, connection) {
   runtime.stats.available++;
   runtime.stats.acquired--;
   runtime.options.onRelease?.(connection);
-  const pending = runtime.pending.shift();
-  if (!pending) {
-    return;
-  }
-  clearTimeout(pending.timeout);
-  runtime.stats.pending--;
-  pooled.inUse = true;
-  pooled.lastUsedAt = Date.now();
-  runtime.stats.available--;
-  runtime.stats.acquired++;
-  runtime.options.onAcquire?.(connection);
-  pending.resolve(connection);
+  assignConnectionToPendingAcquire(runtime, connection);
 }
 
 // src/resources/pool-eviction.ts

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;
 }
 
@@ -4068,6 +4026,23 @@ function createInitialPoolStats() {
     healthChecksFailed: 0
   };
 }
+function checkoutConnection(runtime, pooled) {
+  const previousLastUsedAt = pooled.lastUsedAt;
+  pooled.inUse = true;
+  pooled.lastUsedAt = Date.now();
+  runtime.stats.available--;
+  runtime.stats.acquired++;
+  try {
+    runtime.options.onAcquire?.(pooled.connection);
+    return pooled.connection;
+  } catch (error) {
+    pooled.inUse = false;
+    pooled.lastUsedAt = previousLastUsedAt;
+    runtime.stats.available++;
+    runtime.stats.acquired--;
+    throw error;
+  }
+}
 async function initializeConnections(runtime, count) {
   runtime.creating += count;
   const promises = Array.from({ length: count }, async () => {
@@ -4089,23 +4064,22 @@ async function initializeConnections(runtime, count) {
   await Promise.all(promises);
 }
 function assignConnectionToPendingAcquire(runtime, connection) {
-  const pending = runtime.pending.shift();
-  if (!pending) {
-    return;
-  }
   const pooled = runtime.connections.find((item) => item.connection === connection);
   if (!pooled) {
-    runtime.pending.unshift(pending);
     return;
   }
-  clearTimeout(pending.timeout);
-  runtime.stats.pending--;
-  pooled.inUse = true;
-  pooled.lastUsedAt = Date.now();
-  runtime.stats.available--;
-  runtime.stats.acquired++;
-  runtime.options.onAcquire?.(connection);
-  pending.resolve(connection);
+  let pending = runtime.pending.shift();
+  while (pending) {
+    clearTimeout(pending.timeout);
+    runtime.stats.pending--;
+    try {
+      pending.resolve(checkoutConnection(runtime, pooled));
+      return;
+    } catch (error) {
+      pending.reject(error instanceof Error ? error : new Error(String(error)));
+      pending = runtime.pending.shift();
+    }
+  }
 }
 async function createConnection(runtime) {
   const connection = await runtime.options.factory();
@@ -4121,22 +4095,30 @@ async function createConnection(runtime) {
   runtime.stats.available++;
   return connection;
 }
+function finalizeDestroyedConnection(runtime, pooled) {
+  runtime.stats.destroyed++;
+  runtime.stats.size--;
+  if (pooled.inUse) {
+    runtime.stats.acquired--;
+  } else {
+    runtime.stats.available--;
+  }
+}
 async function destroyConnection(runtime, pooled) {
   const index = runtime.connections.indexOf(pooled);
   if (index !== -1) {
     runtime.connections.splice(index, 1);
   }
   if (runtime.options.destroyer) {
-    await runtime.options.destroyer(pooled.connection);
+    try {
+      await runtime.options.destroyer(pooled.connection);
+    } catch (error) {
+      finalizeDestroyedConnection(runtime, pooled);
+      throw error;
+    }
   }
   runtime.options.onDestroy?.(pooled.connection);
-  runtime.stats.destroyed++;
-  runtime.stats.size--;
-  if (pooled.inUse) {
-    runtime.stats.acquired--;
-  } else {
-    runtime.stats.available--;
-  }
+  finalizeDestroyedConnection(runtime, pooled);
 }
 function getPoolConfig(runtime) {
   return runtime.options.pool || {};
@@ -4155,12 +4137,7 @@ async function acquireConnection(runtime) {
   }
   const available = runtime.connections.find((connection) => !connection.inUse);
   if (available) {
-    available.inUse = true;
-    available.lastUsedAt = Date.now();
-    runtime.stats.available--;
-    runtime.stats.acquired++;
-    runtime.options.onAcquire?.(available.connection);
-    return available.connection;
+    return checkoutConnection(runtime, available);
   }
   const poolConfig = getPoolConfig(runtime);
   const max = poolConfig.max || 10;
@@ -4176,12 +4153,7 @@ async function acquireConnection(runtime) {
         await destroyConnection(runtime, pooled);
         throw new Error("Pool is draining");
       }
-      pooled.inUse = true;
-      pooled.lastUsedAt = Date.now();
-      runtime.stats.available--;
-      runtime.stats.acquired++;
-      runtime.options.onAcquire?.(connection);
-      return connection;
+      return checkoutConnection(runtime, pooled);
     } finally {
       runtime.creating--;
     }
@@ -4213,18 +4185,7 @@ async function releaseConnection(runtime, connection) {
   runtime.stats.available++;
   runtime.stats.acquired--;
   runtime.options.onRelease?.(connection);
-  const pending = runtime.pending.shift();
-  if (!pending) {
-    return;
-  }
-  clearTimeout(pending.timeout);
-  runtime.stats.pending--;
-  pooled.inUse = true;
-  pooled.lastUsedAt = Date.now();
-  runtime.stats.available--;
-  runtime.stats.acquired++;
-  runtime.options.onAcquire?.(connection);
-  pending.resolve(connection);
+  assignConnectionToPendingAcquire(runtime, connection);
 }
 
 // src/resources/pool-eviction.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentforge/core",
-  "version": "0.18.0",
+  "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",