@xbbg/langgraph 1.3.1 → 1.4.2

package/dist/index.js

@@ -888,7 +888,7 @@ var OPTIONAL_LIMIT_INSTRUCTIONS = [
   "## Request limits and inputs",
   "- Keep Bloomberg requests bounded: explicit securities, explicit fields, explicit dates, limited rows, and no broad exploratory pulls unless the user narrows the universe.",
   "- Respect configured tool limits for securities, fields, rows, string size, BQL length, and search spec length. Ask the user to narrow the request rather than exceeding them.",
-  "- Use flat primitive overrides and kwargs only: string, number, or boolean values. Do not send nested objects, arrays, or inferred defaults as overrides."
+  "- Use primitive kwargs only: string, number, or boolean values. For overrides on xbbg_bdp/xbbg_bdh/xbbg_bds, use primitive values for global overrides and nested primitive maps keyed by exact security for per-security overrides. Do not send other nested objects, arrays, or inferred defaults."
 ];
 var BLOOMBERG_TOOL_INSTRUCTIONS = [
   ...REQUIRED_TOOL_INSTRUCTIONS,
@@ -1176,10 +1176,19 @@ function columnsSchema(options) {
 }
 function calculateSchema(options) {
   return z__namespace.object({
-    levels: z__namespace.array(z__namespace.number().nullable()).min(1).max(options.maxFields).describe("Reference level values."),
+    levels: z__namespace.array(z__namespace.number().nullable()).min(1).max(options.maxFields).describe("Hierarchy level values; supported levels are 1, 2, or null."),
     operation: z__namespace.literal("calculate_level_percentages").describe("Numeric helper operation to run."),
     values: z__namespace.array(z__namespace.number().nullable()).min(1).max(options.maxFields).describe("Observed values.")
   }).strict().superRefine((input, ctx) => {
+    input.levels.forEach((level, index) => {
+      if (level !== null && level !== 1 && level !== 2) {
+        ctx.addIssue({
+          code: z__namespace.ZodIssueCode.custom,
+          message: "levels must contain only 1, 2, or null",
+          path: ["levels", index]
+        });
+      }
+    });
     if (input.values.length !== input.levels.length) {
       ctx.addIssue({
         code: z__namespace.ZodIssueCode.custom,
@@ -1820,6 +1829,60 @@ function primitiveMap(tool2, field) {
     return normalized;
   });
 }
+function overridesMap(tool2, field) {
+  return z__namespace.record(
+    z__namespace.string().min(1),
+    z__namespace.union([primitiveSchema, z__namespace.record(z__namespace.string().min(1), primitiveSchema)])
+  ).optional().transform((value, context) => {
+    if (value === void 0) {
+      return void 0;
+    }
+    const normalized = {};
+    for (const [key, entry] of Object.entries(value)) {
+      const normalizedKey = key.trim();
+      if (normalizedKey.length === 0) {
+        return normalizationIssue(context, tool2, field, new TypeError("contains an empty key"));
+      }
+      if (typeof entry !== "object") {
+        if (typeof entry === "string" && entry.length === 0) {
+          return normalizationIssue(
+            context,
+            tool2,
+            field,
+            new TypeError(`${normalizedKey} must not be an empty string`)
+          );
+        }
+        normalized[normalizedKey] = entry;
+        continue;
+      }
+      const normalizedOverrides = {};
+      for (const [overrideKey, overrideValue] of Object.entries(entry)) {
+        const normalizedOverrideKey = overrideKey.trim();
+        if (normalizedOverrideKey.length === 0) {
+          return normalizationIssue(
+            context,
+            tool2,
+            field,
+            new TypeError(`${normalizedKey} contains an empty override key`)
+          );
+        }
+        if (typeof overrideValue === "string" && overrideValue.length === 0) {
+          return normalizationIssue(
+            context,
+            tool2,
+            field,
+            new TypeError(
+              `${normalizedKey}.${normalizedOverrideKey} must not be an empty string`
+            )
+          );
+        }
+        normalizedOverrides[normalizedOverrideKey] = overrideValue;
+      }
+      normalized[normalizedKey] = normalizedOverrides;
+    }
+    return normalized;
+  });
+}
 function dateField(tool2, field) {
   return z__namespace.union([z__namespace.string(), z__namespace.number()]).transform((value, context) => {
     try {
@@ -1882,8 +1945,8 @@ function createBdpSchema(options) {
     kwargs: primitiveMap(tool2, "kwargs").describe(
       "Advanced Bloomberg request kwargs as flat string/number/boolean values only."
     ),
-    overrides: primitiveMap(tool2, "overrides").describe(
-      "Bloomberg field overrides as flat string/number/boolean values only."
+    overrides: overridesMap(tool2, "overrides").describe(
+      "Bloomberg field overrides. Use primitive values for global overrides and nested primitive maps keyed by exact security for per-security overrides."
     ),
     securities: stringArray2(
       tool2,
@@ -1914,8 +1977,8 @@ function createBdhSchema(options) {
     kwargs: primitiveMap(tool2, "kwargs").describe(
       "Advanced Bloomberg request kwargs as flat string/number/boolean values only."
     ),
-    overrides: primitiveMap(tool2, "overrides").describe(
-      "Bloomberg overrides as flat string/number/boolean values only."
+    overrides: overridesMap(tool2, "overrides").describe(
+      "Bloomberg overrides. Use primitive values for global overrides and nested primitive maps keyed by exact security for per-security overrides."
     ),
     securities: stringArray2(
       tool2,
@@ -1947,8 +2010,8 @@ function createBdsSchema(options) {
     kwargs: primitiveMap(tool2, "kwargs").describe(
       "Advanced Bloomberg request kwargs as flat string/number/boolean values only."
     ),
-    overrides: primitiveMap(tool2, "overrides").describe(
-      "Bloomberg overrides as flat string/number/boolean values only."
+    overrides: overridesMap(tool2, "overrides").describe(
+      "Bloomberg overrides. Use primitive values for global overrides and nested primitive maps keyed by exact security for per-security overrides."
     ),
     securities: stringArray2(
       tool2,
@@ -2488,14 +2551,15 @@ function bdpWithResolver(resolver) {
     async (input) => {
       try {
         const engine = await resolver.getEngine();
-        const result = await engine.bdp(input.securities, input.fields, {
+        const options = {
           backend: "json",
           format: input.format,
           includeSecurityErrors: input.includeSecurityErrors,
           kwargs: input.kwargs,
           overrides: input.overrides,
           validateFields: validationSetting(resolver, input.validateFields)
-        });
+        };
+        const result = await engine.bdp(input.securities, input.fields, options);
         return resultString2(resolver, name, result);
       } catch (error) {
         throwWithToolContext(name, error);
@@ -2515,7 +2579,7 @@ function bdhWithResolver(resolver) {
     async (input) => {
       try {
         const engine = await resolver.getEngine();
-        const result = await engine.bdh(input.securities, input.fields, {
+        const options = {
           backend: "json",
           end: input.end,
           format: input.format,
@@ -2523,7 +2587,8 @@ function bdhWithResolver(resolver) {
           overrides: input.overrides,
           start: input.start,
           validateFields: validationSetting(resolver, input.validateFields)
-        });
+        };
+        const result = await engine.bdh(input.securities, input.fields, options);
         return resultString2(resolver, name, result);
       } catch (error) {
         throwWithToolContext(name, error);
@@ -2543,12 +2608,13 @@ function bdsWithResolver(resolver) {
     async (input) => {
       try {
         const engine = await resolver.getEngine();
-        const result = await engine.bds(input.securities, [input.field], {
+        const options = {
           backend: "json",
           kwargs: input.kwargs,
           overrides: input.overrides,
           validateFields: validationSetting(resolver, input.validateFields)
-        });
+        };
+        const result = await engine.bds(input.securities, [input.field], options);
         return resultString2(resolver, name, result);
       } catch (error) {
         throwWithToolContext(name, error);