@agentforge/tools 0.16.33 → 0.16.35

package/dist/index.cjs

@@ -53,7 +53,7 @@ var httpRequestSchema = zod.z.object({
   url: zod.z.string().url().describe("The URL to make the request to"),
   method: HttpMethod.default("GET").describe("HTTP method to use"),
   headers: zod.z.record(zod.z.string()).optional().describe("Optional HTTP headers"),
-  body: zod.z.any().optional().describe("Optional request body (for POST, PUT, PATCH)"),
+  body: zod.z.unknown().optional().describe("Optional request body (for POST, PUT, PATCH)"),
   timeout: zod.z.number().default(3e4).describe("Request timeout in milliseconds"),
   params: zod.z.record(zod.z.string()).optional().describe("Optional URL query parameters")
 });
@@ -64,7 +64,7 @@ var httpGetSchema = zod.z.object({
 });
 var httpPostSchema = zod.z.object({
   url: zod.z.string().url().describe("The URL to post to"),
-  body: zod.z.any().describe("The request body (will be sent as JSON)"),
+  body: zod.z.unknown().describe("The request body (will be sent as JSON)"),
   headers: zod.z.record(zod.z.string()).optional().describe("Optional HTTP headers")
 });
 
@@ -1671,19 +1671,21 @@ var jsonParserSchema = zod.z.object({
   strict: zod.z.boolean().default(true).describe("Use strict JSON parsing (no trailing commas, etc.)")
 });
 var jsonStringifySchema = zod.z.object({
-  data: zod.z.any().describe("Data to convert to JSON string"),
+  data: zod.z.unknown().describe("Data to convert to JSON string"),
   pretty: zod.z.boolean().default(false).describe("Format with indentation for readability"),
   indent: zod.z.number().default(2).describe("Number of spaces for indentation (when pretty is true)")
 });
 var jsonQuerySchema = zod.z.object({
-  data: zod.z.any().describe("JSON data to query"),
+  data: zod.z.unknown().describe("JSON data to query"),
   path: zod.z.string().describe('Dot notation path to query (e.g., "user.name" or "items[0].id")')
 });
 var jsonValidatorSchema = zod.z.object({
   json: zod.z.string().describe("JSON string to validate")
 });
 var jsonMergeSchema = zod.z.object({
-  objects: zod.z.array(zod.z.any().describe("Object to merge")).describe("Array of objects to merge"),
+  objects: zod.z.array(
+    zod.z.record(zod.z.unknown().describe("Value associated with the object key")).describe("Object to merge")
+  ).describe("Array of objects to merge"),
   deep: zod.z.boolean().default(false).describe("Perform deep merge (nested objects)")
 });
 function createJsonParserTool() {
@@ -1706,18 +1708,33 @@ function createJsonStringifyTool(defaultIndent = 2, defaultPretty = false) {
     };
   }).build();
 }
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getPathValue(current, part) {
+  const arrayMatch = part.match(/^(\w+)\[(\d+)\]$/);
+  if (arrayMatch) {
+    const [, key, index] = arrayMatch;
+    if (!isRecord(current)) {
+      return void 0;
+    }
+    const candidate = current[key];
+    if (!Array.isArray(candidate)) {
+      return void 0;
+    }
+    return candidate[parseInt(index, 10)];
+  }
+  if (!isRecord(current)) {
+    return void 0;
+  }
+  return current[part];
+}
 function createJsonQueryTool() {
   return core.toolBuilder().name("json-query").description('Query JSON data using dot notation path (e.g., "user.address.city"). Supports array indexing.').category(core.ToolCategory.UTILITY).tags(["json", "query", "path", "data"]).schema(jsonQuerySchema).implementSafe(async (input) => {
     const parts = input.path.split(".");
     let current = input.data;
     for (const part of parts) {
-      const arrayMatch = part.match(/^(\w+)\[(\d+)\]$/);
-      if (arrayMatch) {
-        const [, key, index] = arrayMatch;
-        current = current[key][parseInt(index, 10)];
-      } else {
-        current = current[part];
-      }
+      current = getPathValue(current, part);
       if (current === void 0) {
         throw new Error(`Path not found: ${input.path}`);
       }
@@ -1737,23 +1754,59 @@ function createJsonValidatorTool() {
     };
   }).build();
 }
+function isMergeObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function setMergeProperty(target, key, value) {
+  Object.defineProperty(target, key, {
+    value,
+    enumerable: true,
+    configurable: true,
+    writable: true
+  });
+}
+function cloneMergeObject(source) {
+  const output = {};
+  for (const [key, value] of Object.entries(source)) {
+    if (isMergeObject(value)) {
+      setMergeProperty(output, key, cloneMergeObject(value));
+      continue;
+    }
+    setMergeProperty(output, key, value);
+  }
+  return output;
+}
+function deepMerge(target, source) {
+  const output = cloneMergeObject(target);
+  for (const [key, sourceValue] of Object.entries(source)) {
+    const targetValue = output[key];
+    if (isMergeObject(sourceValue) && isMergeObject(targetValue)) {
+      setMergeProperty(output, key, deepMerge(targetValue, sourceValue));
+      continue;
+    }
+    if (isMergeObject(sourceValue)) {
+      setMergeProperty(output, key, cloneMergeObject(sourceValue));
+      continue;
+    }
+    setMergeProperty(output, key, sourceValue);
+  }
+  return output;
+}
+function shallowMerge(objects) {
+  const output = {};
+  for (const object of objects) {
+    for (const [key, value] of Object.entries(object)) {
+      setMergeProperty(output, key, value);
+    }
+  }
+  return output;
+}
 function createJsonMergeTool() {
   return core.toolBuilder().name("json-merge").description("Merge two or more JSON objects. Later objects override earlier ones for conflicting keys.").category(core.ToolCategory.UTILITY).tags(["json", "merge", "combine", "data"]).schema(jsonMergeSchema).implement(async (input) => {
     if (input.deep) {
-      const deepMerge = (target, source) => {
-        const output = { ...target };
-        for (const key in source) {
-          if (source[key] && typeof source[key] === "object" && !Array.isArray(source[key])) {
-            output[key] = deepMerge(output[key] || {}, source[key]);
-          } else {
-            output[key] = source[key];
-          }
-        }
-        return output;
-      };
       return input.objects.reduce((acc, obj) => deepMerge(acc, obj), {});
     } else {
-      return Object.assign({}, ...input.objects);
+      return shallowMerge(input.objects);
     }
   }).build();
 }
@@ -1914,31 +1967,34 @@ function createXmlTools(config = {}) {
     createJsonToXmlTool(defaultRootName, defaultFormat)
   ];
 }
+var transformerValueSchema = zod.z.unknown().describe("Transformer value");
+var transformerArraySchema = zod.z.array(transformerValueSchema).describe("Array to transform");
+var transformerObjectSchema = zod.z.record(zod.z.string(), transformerValueSchema).describe("Source object");
 var arrayFilterSchema = zod.z.object({
-  array: zod.z.array(zod.z.any().describe("Array element")).describe("Array to filter"),
+  array: transformerArraySchema.describe("Array to filter"),
   property: zod.z.string().describe("Property name to filter by (use dot notation for nested properties)"),
   operator: zod.z.enum(["equals", "not-equals", "greater-than", "less-than", "contains", "starts-with", "ends-with"]).describe("Comparison operator"),
-  value: zod.z.any().describe("Value to compare against")
+  value: transformerValueSchema.describe("Value to compare against")
 });
 var arrayMapSchema = zod.z.object({
-  array: zod.z.array(zod.z.any().describe("Array element")).describe("Array to map"),
+  array: transformerArraySchema.describe("Array to map"),
   properties: zod.z.array(zod.z.string().describe("String value")).describe("List of property names to extract from each object")
 });
 var arraySortSchema = zod.z.object({
-  array: zod.z.array(zod.z.any().describe("Array element")).describe("Array to sort"),
+  array: transformerArraySchema.describe("Array to sort"),
   property: zod.z.string().describe("Property name to sort by (use dot notation for nested properties)"),
   order: zod.z.enum(["asc", "desc"]).default("asc").describe("Sort order: ascending or descending")
 });
 var arrayGroupBySchema = zod.z.object({
-  array: zod.z.array(zod.z.any().describe("Array element")).describe("Array to group"),
+  array: transformerArraySchema.describe("Array to group"),
   property: zod.z.string().describe("Property name to group by")
 });
 var objectPickSchema = zod.z.object({
-  object: zod.z.record(zod.z.any().describe("Property value")).describe("Source object"),
+  object: transformerObjectSchema,
   properties: zod.z.array(zod.z.string().describe("String value")).describe("List of property names to pick")
 });
 var objectOmitSchema = zod.z.object({
-  object: zod.z.record(zod.z.any().describe("Property value")).describe("Source object"),
+  object: transformerObjectSchema,
   properties: zod.z.array(zod.z.string().describe("String value")).describe("List of property names to omit")
 });
 
@@ -2020,8 +2076,12 @@ function createArrayMapTool() {
     const mapped = input.array.map((item) => {
       const result = {};
       for (const prop of input.properties) {
-        const value = prop.split(".").reduce((current, key) => current?.[key], item);
-        result[prop] = value;
+        Object.defineProperty(result, prop, {
+          value: getNestedValue(item, prop),
+          enumerable: true,
+          configurable: true,
+          writable: true
+        });
       }
       return result;
     });
@@ -2052,9 +2112,17 @@ function createArrayGroupByTool() {
   return core.toolBuilder().name("array-group-by").description("Group an array of objects by a property value. Returns an object with groups as keys.").category(core.ToolCategory.UTILITY).tags(["array", "group", "data", "transform"]).schema(arrayGroupBySchema).implement(async (input) => {
     const groups = {};
     for (const item of input.array) {
-      const key = String(item[input.property]);
-      if (!groups[key]) {
-        groups[key] = [];
+      if (item == null) {
+        throw new TypeError(`Cannot read properties of ${item} (reading '${input.property}')`);
+      }
+      const key = String(Reflect.get(Object(item), input.property));
+      if (!Object.hasOwn(groups, key)) {
+        Object.defineProperty(groups, key, {
+          value: [],
+          enumerable: true,
+          configurable: true,
+          writable: true
+        });
       }
       groups[key].push(item);
     }
@@ -10162,11 +10230,11 @@ var AskHumanInputSchema = zod.z.object({
 });
 var logLevel3 = process.env.LOG_LEVEL?.toLowerCase() || core.LogLevel.INFO;
 var logger22 = core.createLogger("agentforge:tools:agent:ask-human", { level: logLevel3 });
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null;
 }
 function resolveInterrupt(module) {
-  if (!isRecord(module)) {
+  if (!isRecord2(module)) {
     return void 0;
   }
   const candidate = module.interrupt;
@@ -10584,7 +10652,10 @@ exports.stringSplit = stringSplit;
 exports.stringSubstring = stringSubstring;
 exports.stringTrim = stringTrim;
 exports.stringUtilityTools = stringUtilityTools;
+exports.transformerArraySchema = transformerArraySchema;
+exports.transformerObjectSchema = transformerObjectSchema;
 exports.transformerTools = transformerTools;
+exports.transformerValueSchema = transformerValueSchema;
 exports.updateConfluencePage = updateConfluencePage;
 exports.urlBuilder = urlBuilder;
 exports.urlBuilderSchema = urlBuilderSchema;