@xbbg/langgraph 1.2.6 → 1.2.7

package/dist/index.js

@@ -1,7 +1,8 @@
 'use strict';
 
 var tools = require('@langchain/core/tools');
-var z2 = require('zod');
+var zodToJsonSchema = require('zod-to-json-schema');
+var z = require('zod/v3');
 
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
@@ -21,7 +22,7 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var z2__namespace = /*#__PURE__*/_interopNamespace(z2);
+var z__namespace = /*#__PURE__*/_interopNamespace(z);
 
 // src/options.ts
 var BLOOMBERG_TOOL_NAMES = [
@@ -125,22 +126,40 @@ function createCoreResolver(options = {}) {
   const normalized = normalizeBloombergToolsOptions(options);
   let corePromise;
   let enginePromise;
+  async function cacheCoreImport() {
+    const promise = importCore();
+    corePromise = promise;
+    promise.catch(() => {
+      if (corePromise === promise) {
+        corePromise = void 0;
+      }
+    });
+    return await promise;
+  }
+  async function cacheEngineConnect() {
+    const promise = (async () => {
+      const core = await getCore();
+      return await core.connect(normalized.engineConfig);
+    })();
+    enginePromise = promise;
+    promise.catch(() => {
+      if (enginePromise === promise) {
+        enginePromise = void 0;
+      }
+    });
+    return await promise;
+  }
   async function getCore() {
     if (normalized.core !== void 0) {
       return normalized.core;
     }
-    corePromise ??= importCore();
-    return await corePromise;
+    return await (corePromise ?? cacheCoreImport());
   }
   async function getEngine() {
     if (normalized.engine !== void 0) {
       return normalized.engine;
     }
-    enginePromise ??= (async () => {
-      const core = await getCore();
-      return await core.connect(normalized.engineConfig);
-    })();
-    return await enginePromise;
+    return await (enginePromise ?? cacheEngineConnect());
   }
   return {
     getCore,
@@ -148,6 +167,33 @@ function createCoreResolver(options = {}) {
     options: normalized
   };
 }
+function inputJsonSchema(schema) {
+  const jsonSchema = zodToJsonSchema.zodToJsonSchema(schema, {
+    $refStrategy: "none",
+    effectStrategy: "input",
+    pipeStrategy: "input"
+  });
+  delete jsonSchema.$schema;
+  delete jsonSchema.definitions;
+  return jsonSchema;
+}
+function createBloombergStructuredTool(func, fields) {
+  const providerToolDefinition = {
+    type: "function",
+    function: {
+      description: fields.description,
+      name: fields.name,
+      parameters: inputJsonSchema(fields.schema)
+    }
+  };
+  return tools.tool(
+    func,
+    {
+      ...fields,
+      extras: { providerToolDefinition }
+    }
+  );
+}
 
 // src/cdx-fields.ts
 var CDX_INFO_FIELDS = Object.freeze([
@@ -189,27 +235,27 @@ var REQUIRED_TOOL_INSTRUCTIONS = [
   "- Do not invent Bloomberg tickers, field mnemonics, overrides, or BQL functions. If the user gives a field description rather than a confident mnemonic, call xbbg_bflds first.",
   "",
   "## Security identifiers",
-  "- Prefer fully qualified Bloomberg securities such as AAPL US Equity, SPX Index, or CDX IG CDSI GEN 5Y Corp when the user provides them.",
-  "- For raw security identifiers, request or pass Bloomberg identifier syntax directly: /isin/{isin} for ISINs, for example /isin/US0378331005; /cusip/{cusip} for CUSIPs, for example /cusip/037833100.",
+  "- Prefer fully qualified Bloomberg securities supplied by the user, such as <TICKER> <MARKET_SECTOR>, <INDEX_TICKER> <MARKET_SECTOR>, or <CREDIT_INDEX_TICKER> <MARKET_SECTOR>.",
+  "- For raw security identifiers, request or pass Bloomberg identifier syntax directly: /isin/<ISIN> for ISINs or /cusip/<CUSIP> for CUSIPs.",
   "- Do not pass raw ISIN or CUSIP strings when the request is meant to identify a security. Do not use xbbg_bsrch as a replacement for a known ticker, ISIN, or CUSIP.",
-  "- For dealer quote / BQR workflows, use xbbg_bqr with a fixed-income identifier plus a dealer quote source such as /isin/US037833FB15@MSG1 Corp. For raw intraday ticks, use xbbg_bdtick.",
+  "- For dealer quote / BQR workflows, use xbbg_bqr with a fixed-income identifier plus a dealer quote source such as /isin/<ISIN>@<QUOTE_SOURCE> <MARKET_SECTOR>. For raw intraday ticks, use xbbg_bdtick.",
   "",
   "## Core request tools",
-  "- xbbg_bdp: current or reference point-in-time fields, e.g. PX_LAST, NAME, CUR_MKT_CAP. Use a small explicit securities list and a small explicit fields list. Use includeSecurityErrors only when the caller wants Bloomberg security errors in the response.",
+  "- xbbg_bdp: current or reference point-in-time fields. Use a small explicit securities list and a small explicit fields list. Use includeSecurityErrors only when the caller wants Bloomberg security errors in the response.",
   "- xbbg_bdh: historical daily or periodic time series. Always provide explicit start and end dates in YYYY-MM-DD or YYYYMMDD form. Ask before choosing periodicity, currency, fill behavior, adjustment overrides, or a wide output table.",
-  "- xbbg_bds: Bloomberg bulk/table fields such as index members. Provide exactly one bulk field; do not use bds for ordinary multi-field reference data.",
-  "- xbbg_bdib: intraday bars only. Provide one ticker, explicit ISO start/end datetimes, a positive interval in minutes, and timezone context when datetimes are naive. TRADE is the usual event type unless the user asks otherwise.",
-  "- xbbg_bdtick: intraday tick data. Provide one ticker, explicit ISO start/end datetimes, and explicit eventTypes when not asking for TRADE ticks. Use includeBrokerCodes or includeConditionCodes only when those columns are needed.",
+  "- xbbg_bds: Bloomberg bulk/table fields. Provide exactly one bulk field; do not use bds for ordinary multi-field reference data.",
+  "- xbbg_bdib: intraday bars only. Provide one ticker, explicit ISO start/end datetimes with time components, a positive interval in minutes, and timezone context when datetimes are naive.",
+  "- xbbg_bdtick: intraday tick data. Provide one ticker, explicit ISO start/end datetimes with time components, and explicit eventTypes unless the default event stream is intended. Use includeBrokerCodes or includeConditionCodes only when those columns are needed.",
   "- xbbg_bql: BQL expressions only when the user asks for BQL or the request is naturally expressed as a bounded BQL query. Keep queries short, explicit, and scoped to the requested universe.",
-  "- xbbg_bsrch: Bloomberg search-grid or saved-search workflows only, such as ExcelGetGrid-style searches. Do not use it for ordinary security lookup.",
-  "- xbbg_bqr: Bloomberg Quote Request / dealer quotes. Prefer fixed-income ISIN inputs with a dealer quote source such as /isin/US037833FB15@MSG1 Corp, explicit start/end datetimes, and BID/ASK event types. includeBrokerCodes defaults to true.",
+  "- xbbg_bsrch: Bloomberg search-grid or saved-search workflows only. Do not use it for ordinary security lookup.",
+  "- xbbg_bqr: Bloomberg Quote Request / dealer quotes. Prefer fixed-income identifier inputs with a dealer quote source such as /isin/<ISIN>@<QUOTE_SOURCE> <MARKET_SECTOR>, explicit start/end datetimes with time components, and explicit event types.",
   "- xbbg_bflds: Bloomberg field metadata/search. Provide exactly one of fields or searchSpec; use searchSpec for natural-language field names and fields for known mnemonics.",
   "- xbbg_beqs: Bloomberg equity screening by named BEQS screen. Prefer this over hand-written BQL when the user names an existing Bloomberg screen.",
-  "- xbbg_yas: fixed-income YAS recipe fields such as YAS_BOND_YLD, YAS_MOD_DUR, YAS_ZSPREAD, or YAS_BOND_PX. Prefer this over manual YAS_BOND_* BDP requests when the user asks for YAS yield, duration, spread, or price analytics.",
+  "- xbbg_yas: fixed-income YAS recipe fields. Prefer this over manual YAS-style BDP requests when the user asks for yield, duration, spread, or price analytics.",
   "- xbbg_preferreds: preferred stock discovery from an equity ticker. Prefer this over xbbg_ext_bql_builder plus xbbg_bql when the user wants the actual preferreds result.",
   "- xbbg_corporate_bonds: bounded corporate bond universe query for a company ticker. Prefer this over generic BQL for company debt discovery.",
   "- xbbg_index_members: index constituents through the core index recipe. Prefer this over generic BDS/BQL members when the user asks for constituents.",
-  "- xbbg_resolve_isins: resolves supplied ISIN strings to Bloomberg securities. Pass raw ISIN strings only for this recipe; otherwise use /isin/{isin} syntax with data tools.",
+  "- xbbg_resolve_isins: resolves supplied ISIN strings to Bloomberg securities. Pass raw ISIN strings only for this recipe; otherwise use /isin/<ISIN> syntax with data tools.",
   "- xbbg_issuer_isins: issuer/bond ISIN workflow for supplied bond ISIN strings.",
   "- xbbg_etf_holdings: ETF holdings recipe for a single ETF ticker. Prefer this over generic BQL holdings when the user asks for ETF constituents.",
   "- xbbg_stream_snapshot: bounded live market-data observation from //blp/mktdata. Requires explicit maxUpdates and always terminates/unsubscribes.",
@@ -218,13 +264,13 @@ var REQUIRED_TOOL_INSTRUCTIONS = [
   "",
   "## BQL guidance",
   "- BQL is a complete Bloomberg Query Language expression sent as one query string; the tool does not assemble get/for/with clauses for you.",
-  "- Basic shape: get(field1, field2) for(universe). Examples: get(px_last) for('AAPL US Equity') and get(px_last, volume) for(['IBM US Equity', 'AAPL US Equity']).",
-  "- Use BQL for universe-oriented analytics and screens such as holdings('SPY US Equity'), members('SPX Index'), debt universes, filters with with(...), and date ranges such as with(dates=range(-5d, 0d)).",
+  "- Basic shape: get(<FIELD_1>, <FIELD_2>) for(<UNIVERSE>). Use placeholders such as '<TICKER> <MARKET_SECTOR>', holdings('<ETF_TICKER> <MARKET_SECTOR>'), or members('<INDEX_TICKER> <MARKET_SECTOR>') until the user supplies real inputs.",
+  "- Use BQL for universe-oriented analytics and screens only when the user provides a bounded universe, filters, and date range.",
   "- Prefer xbbg_ext_bql_builder instead of hand-writing BQL for supported workflows: preferred stocks, corporate bonds, and ETF holdings.",
   "- Do not use BQL just because the user asks for normal reference data; xbbg_bdp is simpler for current fields and xbbg_bdh is simpler for historical time series.",
   "",
   "## Output handling",
-  "- Tool results use LangChain content_and_artifact output: content is a compact summary, artifact is a bounded envelope with tool, rowCount, truncated, and data. Inspect the artifact before summarizing.",
+  "- Tool results use LangChain content_and_artifact output: content starts with a compact summary and then includes bounded model-readable JSON; artifact is the structured bounded envelope with tool, rowCount, truncated, and data for application code.",
   "- If a response is empty, truncated, or contains Bloomberg/security errors, say that directly. Do not fill gaps from memory or assumptions."
 ];
 var OPTIONAL_EXTENSION_INSTRUCTIONS = [
@@ -265,17 +311,17 @@ function getBloombergToolInstructions(options = {}) {
   }
   return lines.join("\n");
 }
-var BDP_DESCRIPTION = 'Bloomberg reference data for current or point-in-time fields such as PX_LAST, NAME, or CUR_MKT_CAP. Use for a small bounded list of fully qualified securities. Use /isin/{isin} for ISINs and /cusip/{cusip} for CUSIPs. Example: securities ["AAPL US Equity"], fields ["PX_LAST"].';
-var BDH_DESCRIPTION = 'Bloomberg historical time series. Requires explicit start and end dates; ask before using if the date range or periodicity is ambiguous. Use /isin/{isin} for ISINs and /cusip/{cusip} for CUSIPs. Example: securities ["AAPL US Equity"], fields ["PX_LAST"], start "2024-01-01", end "2024-01-31".';
-var BDS_DESCRIPTION = 'Bloomberg bulk/table reference data such as index members. Requires exactly one bulk field, not a field list. Use /isin/{isin} for ISINs and /cusip/{cusip} for CUSIPs. Example: securities ["SPX Index"], field "INDX_MEMBERS".';
-var BDIB_DESCRIPTION = 'Bloomberg intraday bars. Requires one ticker plus explicit ISO start/end datetimes and a positive interval in minutes. Use /isin/{isin} for ISINs and /cusip/{cusip} for CUSIPs. Example: ticker "AAPL US Equity", start "2024-01-31T09:30:00-05:00", end "2024-01-31T16:00:00-05:00", interval 5.';
-var BDTICK_DESCRIPTION = 'Bloomberg intraday tick data. Requires one ticker plus explicit ISO start/end datetimes. Defaults eventTypes to ["TRADE"]; use ["BID", "ASK"] for quote ticks and includeBrokerCodes/includeConditionCodes only when needed.';
-var BQL_DESCRIPTION = "Bloomberg Query Language expression sent as one complete query string. Use for bounded universe analytics such as get(px_last) for('AAPL US Equity'), get(px_last, volume) for(['IBM US Equity', 'AAPL US Equity']), holdings('SPY US Equity'), members('SPX Index'), filters with with(...), or dates=range(...). Prefer xbbg_bdp/xbbg_bdh for simple reference or historical requests.";
-var BSRCH_DESCRIPTION = 'Bloomberg search/grid request. Use for saved-search or ExcelGetGrid-style Bloomberg searches, not ordinary security lookup. Example searchSpec "COMDTY:NG".';
-var BQR_DESCRIPTION = 'Bloomberg Quote Request / dealer quotes. Use for fixed-income dealer quote ticks, preferably with an ISIN plus dealer source such as "/isin/US037833FB15@MSG1 Corp"; requires explicit ISO start/end datetimes. Defaults eventTypes to ["BID", "ASK"] and includeBrokerCodes to true.';
-var BFLDS_DESCRIPTION = 'Bloomberg field metadata and field search. Use first when a field mnemonic is uncertain. Provide exactly one of fields or searchSpec. Example: fields ["PX_LAST"] or searchSpec "last price".';
+var BDP_DESCRIPTION = 'Bloomberg reference data for current or point-in-time fields. Use for a small bounded list of fully qualified securities. Use /isin/<ISIN> for ISINs and /cusip/<CUSIP> for CUSIPs. Example: securities ["<TICKER> <MARKET_SECTOR>"], fields ["<FIELD>"].';
+var BDH_DESCRIPTION = 'Bloomberg historical time series. Requires explicit start and end dates; ask before using if the date range or periodicity is ambiguous. Use /isin/<ISIN> for ISINs and /cusip/<CUSIP> for CUSIPs. Example: securities ["<TICKER> <MARKET_SECTOR>"], fields ["<FIELD>"], start "<START_DATE>", end "<END_DATE>".';
+var BDS_DESCRIPTION = 'Bloomberg bulk/table reference data. Requires exactly one bulk field, not a field list. Use /isin/<ISIN> for ISINs and /cusip/<CUSIP> for CUSIPs. Example: securities ["<INDEX_TICKER> <MARKET_SECTOR>"], field "<BULK_FIELD>".';
+var BDIB_DESCRIPTION = 'Bloomberg intraday bars. Requires one ticker plus explicit ISO start/end datetimes with time components and a positive interval in minutes. Use /isin/<ISIN> for ISINs and /cusip/<CUSIP> for CUSIPs. Example: ticker "<TICKER> <MARKET_SECTOR>", start "<START_DATETIME>", end "<END_DATETIME>", interval <MINUTES>.';
+var BDTICK_DESCRIPTION = 'Bloomberg intraday tick data. Requires one ticker plus explicit ISO start/end datetimes with time components. Set eventTypes explicitly, for example ["<EVENT_TYPE>"], and includeBrokerCodes/includeConditionCodes only when needed.';
+var BQL_DESCRIPTION = "Bloomberg Query Language expression sent as one complete query string. Use for bounded universe analytics with placeholder-shaped syntax such as get(<FIELD>) for('<TICKER> <MARKET_SECTOR>'), holdings('<ETF_TICKER> <MARKET_SECTOR>'), members('<INDEX_TICKER> <MARKET_SECTOR>'), filters with with(...), or dates=range(...). Prefer xbbg_bdp/xbbg_bdh for simple reference or historical requests.";
+var BSRCH_DESCRIPTION = 'Bloomberg search/grid request. Use for saved-search or ExcelGetGrid-style Bloomberg searches, not ordinary security lookup. Example searchSpec "<SEARCH_SPEC>".';
+var BQR_DESCRIPTION = 'Bloomberg Quote Request / dealer quotes. Use for fixed-income dealer quote ticks, preferably with an ISIN plus dealer source such as "/isin/<ISIN>@<QUOTE_SOURCE> <MARKET_SECTOR>"; requires explicit ISO start/end datetimes with time components. Set eventTypes explicitly, for example ["<EVENT_TYPE>"].';
+var BFLDS_DESCRIPTION = 'Bloomberg field metadata and field search. Use first when a field mnemonic is uncertain. Provide exactly one of fields or searchSpec. Example: fields ["<FIELD>"] or searchSpec "<FIELD_SEARCH_TEXT>".';
 var BEQS_DESCRIPTION = "Bloomberg equity screening by named BEQS screen. Use when the user names an existing Bloomberg screen and wants its bounded result set. Prefer this over hand-written BQL for saved Bloomberg screens.";
-var YAS_DESCRIPTION = "Bloomberg fixed-income YAS recipe fields for one or more bonds. Use for YAS yield, duration, spread, benchmark, or price analytics; provide explicit fields and optional settlement/yield/price inputs.";
+var YAS_DESCRIPTION = "Bloomberg fixed-income YAS recipe fields for one or more bonds. Use for yield, duration, spread, benchmark, or price analytics; provide explicit fields and optional settlement/yield/price inputs.";
 var PREFERREDS_DESCRIPTION = "Preferred stock discovery for one equity ticker. Use when the user asks for preferred shares or preferred stock securities related to an issuer.";
 var CORPORATE_BONDS_DESCRIPTION = "Corporate bond universe query for one issuer/company ticker, with optional currency, active-only filter, and result fields. Prefer this over generic BQL for company debt discovery.";
 var INDEX_MEMBERS_DESCRIPTION = "Index constituent recipe for one Bloomberg index. Use for bounded member lists and optional historical/as-of constituent membership.";
@@ -291,7 +337,7 @@ var EXT_CDX_DESCRIPTION = "CDX helpers for parsing, series rolling/resolution, a
 var EXT_CURRENCY_DESCRIPTION = "Currency planning helpers: build FX pairs, test same-currency requests, and find currencies needing conversion.";
 var EXT_BQL_BUILDER_DESCRIPTION = "BQL builders for preferred stocks, corporate bonds, and ETF holdings. Prefer to construct those bounded BQL shapes before xbbg_bql.";
 var EXT_MARKET_SESSION_DESCRIPTION = "Market session and timezone helpers for deriving sessions, UTC windows, market rules, exchange metadata, turnover defaults, and BQR datetime defaults.";
-var EXT_YAS_OVERRIDES_DESCRIPTION = "Build flat Bloomberg YAS override maps for fixed income fields such as YAS_BOND_YLD, YAS_MOD_DUR, YAS_ZSPREAD, or YAS_BOND_PX.";
+var EXT_YAS_OVERRIDES_DESCRIPTION = "Build flat Bloomberg YAS override maps for fixed-income analytics fields.";
 var EXT_CONSTANTS_DESCRIPTION = "Static Bloomberg helper constants for date parsing/formatting, futures months, dividend types, and ETF/dividend columns.";
 var EXT_COLUMNS_DESCRIPTION = "Column rename helpers for dividend, ETF, and earnings-shaped Bloomberg responses.";
 var EXT_CALCULATE_DESCRIPTION = "Small numeric helper operations for Bloomberg workflows, including level percentage calculations.";
@@ -367,12 +413,41 @@ function rowCountOf(value) {
   }
   return null;
 }
+var ERROR_SHAPE_KEYS = /* @__PURE__ */ new Set([
+  "error",
+  "errors",
+  "fielderrors",
+  "fieldexception",
+  "fieldexceptions",
+  "responseerror",
+  "securityerror"
+]);
 function hasErrorShape(value) {
-  if (typeof value !== "object" || value === null) {
-    return false;
+  const pending = [value];
+  const seen = /* @__PURE__ */ new WeakSet();
+  while (pending.length > 0) {
+    const entry = pending.pop();
+    if (typeof entry !== "object" || entry === null) {
+      continue;
+    }
+    if (seen.has(entry)) {
+      continue;
+    }
+    seen.add(entry);
+    if (Array.isArray(entry)) {
+      for (const child of entry) {
+        pending.push(child);
+      }
+      continue;
+    }
+    for (const [key, child] of Object.entries(entry)) {
+      if (ERROR_SHAPE_KEYS.has(key.toLowerCase()) && child !== void 0) {
+        return true;
+      }
+      pending.push(child);
+    }
   }
-  const record2 = value;
-  return record2.error !== void 0 || record2.errors !== void 0 || record2.securityError !== void 0;
+  return false;
 }
 function limitResult(value, maxRows, maxStringChars) {
   const state = { truncated: false };
@@ -394,23 +469,39 @@ function summarizeEnvelope(envelope) {
     notes.push("artifact truncated to configured limits");
   }
   if (hasErrorShape(envelope.data)) {
-    notes.push("inspect artifact for Bloomberg error details");
+    notes.push("inspect result payload for Bloomberg error details");
   }
   const noteText = notes.length === 0 ? "" : `; ${notes.join("; ")}`;
   return `${envelope.tool}: ${rowText}; truncated=${String(envelope.truncated)}${noteText}`;
 }
-function createToolResult(tool3, value, maxRows, maxStringChars) {
+function resultJsonReplacer(_key, value) {
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  return value;
+}
+function formatToolContent(envelope) {
+  const payload = {
+    tool: envelope.tool,
+    rowCount: envelope.rowCount,
+    truncated: envelope.truncated,
+    data: envelope.data
+  };
+  return `${summarizeEnvelope(envelope)}
+${JSON.stringify(payload, resultJsonReplacer)}`;
+}
+function createToolResult(tool2, value, maxRows, maxStringChars) {
   const limited = limitResult(value, maxRows, maxStringChars);
   const envelope = {
-    tool: tool3,
+    tool: tool2,
     rowCount: limited.rowCount,
     truncated: limited.truncated,
     data: limited.value
   };
-  return [summarizeEnvelope(envelope), envelope];
+  return [formatToolContent(envelope), envelope];
 }
-function throwWithToolContext(tool3, error) {
-  const prefix = `${tool3} failed`;
+function throwWithToolContext(tool2, error) {
+  const prefix = `${tool2} failed`;
   if (error instanceof Error) {
     if (!error.message.startsWith(prefix)) {
       Object.defineProperty(error, "message", {
@@ -422,57 +513,55 @@ function throwWithToolContext(tool3, error) {
   }
   throw new Error(`${prefix}: ${String(error)}`);
 }
-var stringPairSchema = z2__namespace.object({
-  key: z2__namespace.string().trim().min(1).describe("String pair key."),
-  value: z2__namespace.string().trim().min(1).describe("String pair value.")
+var stringPairSchema = z__namespace.object({
+  key: z__namespace.string().trim().min(1).describe("String pair key."),
+  value: z__namespace.string().trim().min(1).describe("String pair value.")
 });
-var futuresCandidateSchema = z2__namespace.object({
-  month: z2__namespace.number().int().min(1).max(12).describe("Contract month number, 1-12."),
-  ticker: z2__namespace.string().trim().min(1).describe("Specific Bloomberg futures ticker."),
-  year: z2__namespace.number().int().min(1900).describe("Contract year.")
+var futuresCandidateSchema = z__namespace.object({
+  month: z__namespace.number().int().min(1).max(12).describe("Contract month number, 1-12."),
+  ticker: z__namespace.string().trim().min(1).describe("Specific Bloomberg futures ticker."),
+  year: z__namespace.number().int().min(1900).describe("Contract year.")
 });
 function nonEmptyString(options, description) {
-  return z2__namespace.string().trim().pipe(z2__namespace.string().min(1).max(options.maxStringChars).describe(description));
+  return z__namespace.string().trim().pipe(z__namespace.string().min(1).max(options.maxStringChars).describe(description));
 }
 function stringArray(options, description, maxItems = options.maxFields) {
-  return z2__namespace.array(nonEmptyString(options, description)).min(1).max(maxItems).describe(description);
+  return z__namespace.array(nonEmptyString(options, description)).min(1).max(maxItems).describe(description);
 }
 function optionalString(options, description) {
   return nonEmptyString(options, description).optional();
 }
 function tickerSchema(options) {
-  return z2__namespace.object({
-    operation: z2__namespace.enum([
-      "parse_ticker",
-      "normalize_tickers",
-      "filter_equity_tickers",
-      "is_specific_contract",
-      "validate_generic_ticker"
-    ]).describe("Ticker helper operation to run."),
-    ticker: optionalString(
-      options,
-      "One Bloomberg ticker for parse/contract validation operations."
-    ),
-    tickers: stringArray(
-      options,
-      "Bloomberg tickers to normalize or filter.",
-      options.maxSecurities
-    ).optional()
-  });
+  const ticker = nonEmptyString(
+    options,
+    "One Bloomberg ticker for parse/contract validation operations."
+  );
+  const tickers = stringArray(
+    options,
+    "Bloomberg tickers to normalize or filter.",
+    options.maxSecurities
+  );
+  return z__namespace.discriminatedUnion("operation", [
+    z__namespace.object({ operation: z__namespace.literal("parse_ticker"), ticker }).strict(),
+    z__namespace.object({ operation: z__namespace.literal("is_specific_contract"), ticker }).strict(),
+    z__namespace.object({ operation: z__namespace.literal("validate_generic_ticker"), ticker }).strict(),
+    z__namespace.object({ operation: z__namespace.literal("normalize_tickers"), tickers }).strict(),
+    z__namespace.object({ operation: z__namespace.literal("filter_equity_tickers"), tickers }).strict()
+  ]);
 }
 function futuresSchema(options) {
-  return z2__namespace.object({
-    asset: optionalString(options, "Bloomberg asset class suffix, for example Comdty."),
-    candidates: z2__namespace.array(futuresCandidateSchema).min(1).max(options.maxFields).optional().describe("Candidate futures contracts."),
-    contracts: z2__namespace.array(stringPairSchema).min(1).max(options.maxFields).optional().describe("Contract pairs for validity filtering."),
-    count: z2__namespace.number().int().positive().optional().describe("Maximum number of futures candidates to generate."),
+  return z__namespace.object({
+    asset: optionalString(options, "Bloomberg asset class suffix supplied by the user."),
+    candidates: z__namespace.array(futuresCandidateSchema).min(1).max(options.maxFields).optional().describe("Candidate futures contracts."),
+    contracts: z__namespace.array(stringPairSchema).min(1).max(options.maxFields).optional().describe("Contract pairs for validity filtering."),
+    count: z__namespace.number().int().positive().optional().describe("Maximum number of futures candidates to generate."),
     cycle: optionalString(options, "Futures cycle code to filter candidates by."),
-    day: z2__namespace.number().int().min(1).max(31).optional().describe("Day number for contract filtering."),
+    day: z__namespace.number().int().min(1).max(31).optional().describe("Day number for contract filtering."),
     freq: optionalString(options, "Futures frequency/cycle hint."),
     genTicker: optionalString(options, "Generic Bloomberg futures ticker."),
-    month: z2__namespace.number().int().min(1).max(12).optional().describe("Month number, 1-12."),
+    month: z__namespace.number().int().min(1).max(12).optional().describe("Month number, 1-12."),
     monthCode: optionalString(options, "Bloomberg futures month code, for example H."),
-    operation: z2__namespace.enum([
+    operation: z__namespace.enum([
       "build_futures_ticker",
       "generate_candidates",
       "contract_index",
@@ -481,13 +570,13 @@ function futuresSchema(options) {
       "get_futures_months"
     ]).describe("Futures helper operation to run."),
     prefix: optionalString(options, "Futures ticker root prefix."),
-    year: z2__namespace.union([z2__namespace.string().trim().min(1), z2__namespace.number().int()]).optional().describe("Contract year.")
+    year: z__namespace.union([z__namespace.string().trim().min(1), z__namespace.number().int()]).optional().describe("Contract year.")
   });
 }
 function cdxSchema(options) {
-  return z2__namespace.object({
+  return z__namespace.object({
     genTicker: optionalString(options, "Generic CDX ticker."),
-    operation: z2__namespace.enum([
+    operation: z__namespace.enum([
       "parse_cdx_ticker",
       "previous_cdx_series",
       "cdx_gen_to_specific",
@@ -495,35 +584,35 @@ function cdxSchema(options) {
       "cdx_pricing",
       "cdx_risk"
     ]).describe("CDX helper operation to run."),
-    recoveryRate: z2__namespace.number().optional().describe("Optional recovery rate override for pricing/risk lookups."),
-    series: z2__namespace.number().int().positive().optional().describe("Specific CDX series number."),
+    recoveryRate: z__namespace.number().optional().describe("Optional recovery rate override for pricing/risk lookups."),
+    series: z__namespace.number().int().positive().optional().describe("Specific CDX series number."),
     ticker: optionalString(options, "CDX ticker.")
   });
 }
 function currencySchema(options) {
-  return z2__namespace.object({
+  return z__namespace.object({
     ccy1: optionalString(options, "First ISO currency code."),
     ccy2: optionalString(options, "Second ISO currency code."),
     currencies: stringArray(options, "ISO currency codes.").optional(),
     fromCcy: optionalString(options, "Source ISO currency code."),
-    operation: z2__namespace.enum(["build_fx_pair", "same_currency", "currencies_needing_conversion"]).describe("Currency helper operation to run."),
+    operation: z__namespace.enum(["build_fx_pair", "same_currency", "currencies_needing_conversion"]).describe("Currency helper operation to run."),
     target: optionalString(options, "Target ISO currency code."),
     toCcy: optionalString(options, "Destination ISO currency code.")
   });
 }
 function bqlBuilderSchema(options) {
-  return z2__namespace.object({
-    activeOnly: z2__namespace.boolean().optional().describe("Restrict corporate bond query to active bonds."),
+  return z__namespace.object({
+    activeOnly: z__namespace.boolean().optional().describe("Restrict corporate bond query to active bonds."),
     ccy: optionalString(options, "Currency filter for corporate bond query."),
     equityTicker: optionalString(options, "Equity ticker for preferreds query."),
     etfTicker: optionalString(options, "ETF ticker for holdings query."),
     extraFields: stringArray(options, "Extra BQL fields to include.").optional(),
-    operation: z2__namespace.enum(["build_preferreds_query", "build_corporate_bonds_query", "build_etf_holdings_query"]).describe("BQL builder operation to run."),
+    operation: z__namespace.enum(["build_preferreds_query", "build_corporate_bonds_query", "build_etf_holdings_query"]).describe("BQL builder operation to run."),
     ticker: optionalString(options, "Ticker for corporate bond query.")
   });
 }
 function marketSessionSchema(options) {
-  return z2__namespace.object({
+  return z__namespace.object({
     countryIso: optionalString(options, "ISO country code for timezone inference."),
     date: optionalString(options, "Date for UTC session conversion, YYYY-MM-DD or YYYYMMDD."),
     dayEnd: optionalString(options, "Exchange day end time, for example 16:00."),
@@ -534,7 +623,7 @@ function marketSessionSchema(options) {
     exchCode: optionalString(options, "Bloomberg exchange code."),
     exchangeTz: optionalString(options, "IANA exchange timezone."),
     mic: optionalString(options, "Market Identifier Code."),
-    operation: z2__namespace.enum([
+    operation: z__namespace.enum([
       "derive_sessions",
       "get_market_rule",
       "infer_timezone",
@@ -551,25 +640,25 @@ function marketSessionSchema(options) {
   });
 }
 function yasOverridesSchema(options) {
-  return z2__namespace.object({
+  return z__namespace.object({
     benchmark: optionalString(options, "Optional YAS benchmark."),
-    price: z2__namespace.number().optional().describe("YAS price override."),
+    price: z__namespace.number().optional().describe("YAS price override."),
     settleDt: optionalString(options, "YAS settlement date."),
-    spread: z2__namespace.number().optional().describe("YAS spread override."),
-    yieldType: z2__namespace.number().int().optional().describe("YAS yield type override."),
-    yieldVal: z2__namespace.number().optional().describe("YAS yield value override.")
+    spread: z__namespace.number().optional().describe("YAS spread override."),
+    yieldType: z__namespace.number().int().optional().describe("YAS yield type override."),
+    yieldVal: z__namespace.number().optional().describe("YAS yield value override.")
   });
 }
 function constantsSchema(options) {
-  return z2__namespace.object({
+  return z__namespace.object({
     code: optionalString(options, "Month code."),
     dateStr: optionalString(options, "Date string to parse."),
-    day: z2__namespace.number().int().min(1).max(31).optional().describe("Day number."),
+    day: z__namespace.number().int().min(1).max(31).optional().describe("Day number."),
     dvdType: optionalString(options, "Dividend type code or label."),
     fmt: optionalString(options, "Date output format."),
-    month: z2__namespace.number().int().min(1).max(12).optional().describe("Month number."),
+    month: z__namespace.number().int().min(1).max(12).optional().describe("Month number."),
     monthName: optionalString(options, "Month name."),
-    operation: z2__namespace.enum([
+    operation: z__namespace.enum([
       "parse_date",
       "fmt_date",
       "get_month_code",
@@ -580,22 +669,22 @@ function constantsSchema(options) {
       "get_dvd_cols",
       "get_etf_cols"
     ]).describe("Constants helper operation to run."),
-    year: z2__namespace.number().int().min(1).optional().describe("Year number.")
+    year: z__namespace.number().int().min(1).optional().describe("Year number.")
   });
 }
 function columnsSchema(options) {
-  return z2__namespace.object({
+  return z__namespace.object({
     columns: stringArray(options, "Column names to rename.").optional(),
     dataColumns: stringArray(options, "Earnings data column names.").optional(),
-    headerRow: z2__namespace.array(stringPairSchema).min(1).max(options.maxFields).optional().describe("Earnings header row key/value pairs."),
-    operation: z2__namespace.enum(["rename_dividend_columns", "rename_etf_columns", "build_earning_header_rename"]).describe("Column helper operation to run.")
+    headerRow: z__namespace.array(stringPairSchema).min(1).max(options.maxFields).optional().describe("Earnings header row key/value pairs."),
+    operation: z__namespace.enum(["rename_dividend_columns", "rename_etf_columns", "build_earning_header_rename"]).describe("Column helper operation to run.")
   });
 }
 function calculateSchema(options) {
-  return z2__namespace.object({
-    levels: z2__namespace.array(z2__namespace.number().nullable()).min(1).max(options.maxFields).describe("Reference level values."),
-    operation: z2__namespace.literal("calculate_level_percentages").describe("Numeric helper operation to run."),
-    values: z2__namespace.array(z2__namespace.number().nullable()).min(1).max(options.maxFields).describe("Observed values.")
+  return z__namespace.object({
+    levels: z__namespace.array(z__namespace.number().nullable()).min(1).max(options.maxFields).describe("Reference level values."),
+    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.")
   });
 }
 
@@ -669,7 +758,7 @@ var BLOOMBERG_EXT_TOOL_NAMES = Object.freeze(
 );
 function extTickerWithResolver(resolver) {
   const name = "xbbg_ext_ticker";
-  return tools.tool(
+  return createBloombergStructuredTool(
     async (input) => {
       try {
         const core = await resolver.getCore();
@@ -719,7 +808,7 @@ function extTickerWithResolver(resolver) {
 }
 function extFuturesWithResolver(resolver) {
   const name = "xbbg_ext_futures";
-  return tools.tool(
+  return createBloombergStructuredTool(
     async (input) => {
       try {
         const core = await resolver.getCore();
@@ -798,7 +887,7 @@ function extFuturesWithResolver(resolver) {
 }
 function extCdxWithResolver(resolver) {
   const name = "xbbg_ext_cdx";
-  return tools.tool(
+  return createBloombergStructuredTool(
     async (input) => {
       try {
         const args = asRecord(input);
@@ -850,7 +939,7 @@ function extCdxWithResolver(resolver) {
 }
 function extCurrencyWithResolver(resolver) {
   const name = "xbbg_ext_currency";
-  return tools.tool(
+  return createBloombergStructuredTool(
     async (input) => {
       try {
         const core = await resolver.getCore();
@@ -898,7 +987,7 @@ function extCurrencyWithResolver(resolver) {
 }
 function extBqlBuilderWithResolver(resolver) {
   const name = "xbbg_ext_bql_builder";
-  return tools.tool(
+  return createBloombergStructuredTool(
     async (input) => {
       try {
         const core = await resolver.getCore();
@@ -948,7 +1037,7 @@ function extBqlBuilderWithResolver(resolver) {
 }
 function extMarketSessionWithResolver(resolver) {
   const name = "xbbg_ext_market_session";
-  return tools.tool(
+  return createBloombergStructuredTool(
     async (input) => {
       try {
         const core = await resolver.getCore();
@@ -1019,7 +1108,7 @@ function extMarketSessionWithResolver(resolver) {
 }
 function extYasOverridesWithResolver(resolver) {
   const name = "xbbg_ext_yas_overrides";
-  return tools.tool(
+  return createBloombergStructuredTool(
     async (input) => {
       try {
         const core = await resolver.getCore();
@@ -1049,7 +1138,7 @@ function extYasOverridesWithResolver(resolver) {
 }
 function extConstantsWithResolver(resolver) {
   const name = "xbbg_ext_constants";
-  return tools.tool(
+  return createBloombergStructuredTool(
     async (input) => {
       try {
         const core = await resolver.getCore();
@@ -1113,7 +1202,7 @@ function extConstantsWithResolver(resolver) {
 }
 function extColumnsWithResolver(resolver) {
   const name = "xbbg_ext_columns";
-  return tools.tool(
+  return createBloombergStructuredTool(
     async (input) => {
       try {
         const core = await resolver.getCore();
@@ -1158,7 +1247,7 @@ function extColumnsWithResolver(resolver) {
 }
 function extCalculateWithResolver(resolver) {
   const name = "xbbg_ext_calculate";
-  return tools.tool(
+  return createBloombergStructuredTool(
     async (input) => {
       try {
         if (input.values.length !== input.levels.length) {
@@ -1231,11 +1320,11 @@ var HISTORICAL_FORMATS = [
 var ISO_DATE_RE = /^\d{4}-\d{2}-\d{2}$/u;
 var BBG_DATE_RE = /^\d{8}$/u;
 var AMBIGUOUS_DATE_RE = /^\d{1,2}[-/]\d{1,2}[-/]\d{2,4}([T \D]|$)/u;
-var ISO_DATE_TIME_RE = /^\d{4}-\d{2}-\d{2}(?:[T ]\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:?\d{2})?)?$/u;
-var primitiveSchema = z2__namespace.union([
-  z2__namespace.string().transform((value) => value.trim()),
-  z2__namespace.number(),
-  z2__namespace.boolean()
+var ISO_DATE_TIME_RE = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:?\d{2})?$/u;
+var primitiveSchema = z__namespace.union([
+  z__namespace.string().transform((value) => value.trim()),
+  z__namespace.number(),
+  z__namespace.boolean()
 ]);
 function dateFromParts(year, month, day) {
   const formatted = `${year}${month}${day}`;
@@ -1289,27 +1378,29 @@ function normalizeDateTime(value) {
   if (AMBIGUOUS_DATE_RE.test(text)) {
     throw new TypeError(`Ambiguous datetime ${JSON.stringify(text)}; use ISO 8601`);
   }
-  if (BBG_DATE_RE.test(text)) {
-    return `${text.slice(0, 4)}-${text.slice(4, 6)}-${text.slice(6, 8)}T00:00:00`;
+  if (BBG_DATE_RE.test(text) || ISO_DATE_RE.test(text)) {
+    throw new TypeError(
+      `Invalid datetime ${JSON.stringify(text)}; include an explicit time component such as YYYY-MM-DDT09:30:00`
+    );
   }
   if (!ISO_DATE_TIME_RE.test(text)) {
     throw new TypeError(`Invalid datetime ${JSON.stringify(text)}; use ISO 8601`);
   }
   return text.replace(" ", "T");
 }
-function nonEmptyString2(tool3, field, maxChars, example) {
-  return z2__namespace.string().transform((value) => value.trim()).pipe(
-    z2__namespace.string().min(1, `${tool3}: ${field} must be a non-empty string. Example: ${example}`).max(
+function nonEmptyString2(tool2, field, maxChars, example) {
+  return z__namespace.string().transform((value) => value.trim()).pipe(
+    z__namespace.string().min(1, `${tool2}: ${field} must be a non-empty string. Example: ${example}`).max(
       maxChars,
-      `${tool3}: ${field} is too long; expected at most ${maxChars} characters. Example: ${example}`
+      `${tool2}: ${field} is too long; expected at most ${maxChars} characters. Example: ${example}`
     )
   );
 }
-function stringArray2(tool3, field, maxItems, maxChars, example) {
-  return z2__namespace.array(nonEmptyString2(tool3, field, maxChars, example)).min(1, `${tool3}: ${field} must contain at least one non-empty string. Example: ${example}`).max(maxItems, `${tool3}: ${field} can contain at most ${maxItems} values`);
+function stringArray2(tool2, field, maxItems, maxChars, example) {
+  return z__namespace.array(nonEmptyString2(tool2, field, maxChars, example)).min(1, `${tool2}: ${field} must contain at least one non-empty string. Example: ${example}`).max(maxItems, `${tool2}: ${field} can contain at most ${maxItems} values`);
 }
-function primitiveMap(tool3, field) {
-  return z2__namespace.record(z2__namespace.string().min(1), primitiveSchema).optional().transform((value) => {
+function primitiveMap(tool2, field) {
+  return z__namespace.record(z__namespace.string().min(1), primitiveSchema).optional().transform((value) => {
     if (value === void 0) {
       return void 0;
     }
@@ -1317,169 +1408,187 @@ function primitiveMap(tool3, field) {
     for (const [key, entry] of Object.entries(value)) {
       const normalizedKey = key.trim();
       if (normalizedKey.length === 0) {
-        throw new TypeError(`${tool3}: ${field} contains an empty key`);
+        throw new TypeError(`${tool2}: ${field} contains an empty key`);
       }
       if (typeof entry === "string" && entry.length === 0) {
-        throw new TypeError(`${tool3}: ${field}.${normalizedKey} must not be an empty string`);
+        throw new TypeError(`${tool2}: ${field}.${normalizedKey} must not be an empty string`);
       }
       normalized[normalizedKey] = entry;
     }
     return normalized;
   });
 }
-function dateField(tool3, field) {
-  return z2__namespace.union([z2__namespace.string(), z2__namespace.date(), z2__namespace.number()]).transform((value) => normalizeDate(value)).describe(
+function dateField(tool2, field) {
+  return z__namespace.union([z__namespace.string(), z__namespace.date(), z__namespace.number()]).transform((value) => normalizeDate(value)).describe(
     `${field} date. Use YYYY-MM-DD or Bloomberg-native YYYYMMDD, never ambiguous MM/DD/YYYY.`
   );
 }
-function dateTimeField(tool3, field) {
-  return z2__namespace.union([z2__namespace.string(), z2__namespace.date(), z2__namespace.number()]).transform((value) => normalizeDateTime(value)).describe(`${field} datetime. Use ISO 8601, for example 2024-01-31T09:30:00-05:00.`);
+function dateTimeField(tool2, field) {
+  return z__namespace.union([z__namespace.string(), z__namespace.date(), z__namespace.number()]).superRefine((value, context) => {
+    if (typeof value !== "string") {
+      return;
+    }
+    const text = value.trim();
+    if (BBG_DATE_RE.test(text) || ISO_DATE_RE.test(text)) {
+      context.addIssue({
+        code: "custom",
+        message: `${tool2}: ${field} datetime requires an explicit time component; use ISO 8601 such as YYYY-MM-DDT09:30:00`
+      });
+    }
+  }).transform((value) => normalizeDateTime(value)).describe(`${field} datetime. Use ISO 8601 with an explicit time component.`);
 }
-function referenceFormat(tool3) {
-  return z2__namespace.enum(REFERENCE_FORMATS, {
-    error: `${tool3}: format must be one of ${REFERENCE_FORMATS.join(", ")}`
+function referenceFormat(tool2) {
+  return z__namespace.enum(REFERENCE_FORMATS, {
+    errorMap: () => ({
+      message: `${tool2}: format must be one of ${REFERENCE_FORMATS.join(", ")}`
+    })
   }).optional();
 }
-function historicalFormat(tool3) {
-  return z2__namespace.enum(HISTORICAL_FORMATS, {
-    error: `${tool3}: format must be one of ${HISTORICAL_FORMATS.join(", ")}`
+function historicalFormat(tool2) {
+  return z__namespace.enum(HISTORICAL_FORMATS, {
+    errorMap: () => ({
+      message: `${tool2}: format must be one of ${HISTORICAL_FORMATS.join(", ")}`
+    })
   }).optional();
 }
 function createBdpSchema(options) {
-  const tool3 = "xbbg_bdp";
-  return z2__namespace.object({
+  const tool2 = "xbbg_bdp";
+  return z__namespace.object({
     fields: stringArray2(
-      tool3,
+      tool2,
       "fields",
       options.maxFields,
       options.maxStringChars,
-      '["PX_LAST"]'
-    ).describe(
-      'Bloomberg field mnemonics to retrieve, for example ["PX_LAST", "NAME"]. Use xbbg_bflds first if uncertain.'
-    ),
-    format: referenceFormat(tool3).describe(
+      '["<FIELD>"]'
+    ).describe("Bloomberg field mnemonics to retrieve. Use xbbg_bflds first if uncertain."),
+    format: referenceFormat(tool2).describe(
       "JSON output shape. Usually omit; use long_typed if downstream needs Bloomberg value types."
     ),
-    includeSecurityErrors: z2__namespace.boolean().optional().describe("Include Bloomberg security errors in the response when supported."),
-    kwargs: primitiveMap(tool3, "kwargs").describe(
+    includeSecurityErrors: z__namespace.boolean().optional().describe("Include Bloomberg security errors in the response when supported."),
+    kwargs: primitiveMap(tool2, "kwargs").describe(
       "Advanced Bloomberg request kwargs as flat string/number/boolean values only."
     ),
-    overrides: primitiveMap(tool3, "overrides").describe(
+    overrides: primitiveMap(tool2, "overrides").describe(
       "Bloomberg field overrides as flat string/number/boolean values only."
     ),
     securities: stringArray2(
-      tool3,
+      tool2,
       "securities",
       options.maxSecurities,
       options.maxStringChars,
-      '["AAPL US Equity"]'
+      '["<TICKER> <MARKET_SECTOR>"]'
     ).describe(
-      'Fully qualified Bloomberg securities, for example ["AAPL US Equity"]; use /isin/{isin} for ISINs and /cusip/{cusip} for CUSIPs. Do not invent tickers.'
+      "Fully qualified Bloomberg securities supplied by the user; use /isin/<ISIN> for ISINs and /cusip/<CUSIP> for CUSIPs. Do not invent tickers."
     ),
-    validateFields: z2__namespace.boolean().optional().describe("Override field validation for this request.")
+    validateFields: z__namespace.boolean().optional().describe("Override field validation for this request.")
   });
 }
 function createBdhSchema(options) {
-  const tool3 = "xbbg_bdh";
-  return z2__namespace.object({
-    end: dateField(tool3, "end").describe("Required end date. Use YYYY-MM-DD or YYYYMMDD."),
+  const tool2 = "xbbg_bdh";
+  return z__namespace.object({
+    end: dateField(tool2, "end").describe("Required end date. Use YYYY-MM-DD or YYYYMMDD."),
     fields: stringArray2(
-      tool3,
+      tool2,
       "fields",
       options.maxFields,
       options.maxStringChars,
-      '["PX_LAST"]'
-    ).describe('Bloomberg historical field mnemonics, for example ["PX_LAST"].'),
-    format: historicalFormat(tool3).describe(
+      '["<FIELD>"]'
+    ).describe("Bloomberg historical field mnemonics supplied by the user."),
+    format: historicalFormat(tool2).describe(
       "Historical JSON output shape. Use wide only when the user asks for a table by date."
     ),
-    kwargs: primitiveMap(tool3, "kwargs").describe(
+    kwargs: primitiveMap(tool2, "kwargs").describe(
       "Advanced Bloomberg request kwargs as flat string/number/boolean values only."
     ),
-    overrides: primitiveMap(tool3, "overrides").describe(
+    overrides: primitiveMap(tool2, "overrides").describe(
       "Bloomberg overrides as flat string/number/boolean values only."
     ),
     securities: stringArray2(
-      tool3,
+      tool2,
       "securities",
       options.maxSecurities,
       options.maxStringChars,
-      '["AAPL US Equity"]'
+      '["<TICKER> <MARKET_SECTOR>"]'
     ).describe(
-      'Fully qualified Bloomberg securities, for example ["AAPL US Equity"]; use /isin/{isin} for ISINs and /cusip/{cusip} for CUSIPs.'
+      "Fully qualified Bloomberg securities supplied by the user; use /isin/<ISIN> for ISINs and /cusip/<CUSIP> for CUSIPs."
     ),
-    start: dateField(tool3, "start").describe("Required start date. Use YYYY-MM-DD or YYYYMMDD."),
-    validateFields: z2__namespace.boolean().optional().describe("Override field validation for this request.")
+    start: dateField(tool2, "start").describe("Required start date. Use YYYY-MM-DD or YYYYMMDD."),
+    validateFields: z__namespace.boolean().optional().describe("Override field validation for this request.")
   }).superRefine((value, ctx) => {
     if (value.start > value.end) {
       ctx.addIssue({
         code: "custom",
-        message: `${tool3}: start must be on or before end. Example: start "2024-01-01", end "2024-01-31"`,
+        message: `${tool2}: start must be on or before end. Use an explicit start/end date range.`,
         path: ["start"]
       });
     }
   });
 }
 function createBdsSchema(options) {
-  const tool3 = "xbbg_bds";
-  return z2__namespace.object({
-    field: nonEmptyString2(tool3, "field", options.maxStringChars, "INDX_MEMBERS").describe(
-      "Exactly one Bloomberg bulk/table field, for example INDX_MEMBERS."
+  const tool2 = "xbbg_bds";
+  return z__namespace.object({
+    field: nonEmptyString2(tool2, "field", options.maxStringChars, "<BULK_FIELD>").describe(
+      "Exactly one Bloomberg bulk/table field supplied by the user."
     ),
-    format: referenceFormat(tool3).describe("JSON output shape. Usually omit."),
-    kwargs: primitiveMap(tool3, "kwargs").describe(
+    format: referenceFormat(tool2).describe("JSON output shape. Usually omit."),
+    kwargs: primitiveMap(tool2, "kwargs").describe(
       "Advanced Bloomberg request kwargs as flat string/number/boolean values only."
     ),
-    overrides: primitiveMap(tool3, "overrides").describe(
+    overrides: primitiveMap(tool2, "overrides").describe(
       "Bloomberg overrides as flat string/number/boolean values only."
     ),
     securities: stringArray2(
-      tool3,
+      tool2,
       "securities",
       options.maxSecurities,
       options.maxStringChars,
-      '["SPX Index"]'
+      '["<INDEX_TICKER> <MARKET_SECTOR>"]'
     ).describe(
-      'Fully qualified Bloomberg securities, for example ["SPX Index"]; use /isin/{isin} for ISINs and /cusip/{cusip} for CUSIPs.'
+      "Fully qualified Bloomberg securities supplied by the user; use /isin/<ISIN> for ISINs and /cusip/<CUSIP> for CUSIPs."
     ),
-    validateFields: z2__namespace.boolean().optional().describe("Override field validation for this request.")
+    validateFields: z__namespace.boolean().optional().describe("Override field validation for this request.")
   });
 }
 function createBdibSchema(options) {
-  const tool3 = "xbbg_bdib";
-  return z2__namespace.object({
-    end: dateTimeField(tool3, "end").describe(
+  const tool2 = "xbbg_bdib";
+  return z__namespace.object({
+    end: dateTimeField(tool2, "end").describe(
       "Required intraday end datetime. Use ISO 8601 with timezone when possible."
     ),
-    eventType: nonEmptyString2(tool3, "eventType", options.maxStringChars, "TRADE").optional().describe("Bloomberg event type. Usually TRADE."),
-    interval: z2__namespace.number().int(`${tool3}: interval must be a positive integer number of minutes. Example: 5`).positive(`${tool3}: interval must be greater than zero. Example: 5`).describe("Bar interval in minutes. Must be a positive integer."),
-    kwargs: primitiveMap(tool3, "kwargs").describe(
+    eventType: nonEmptyString2(tool2, "eventType", options.maxStringChars, "<EVENT_TYPE>").optional().describe("Bloomberg event type supplied by the user."),
+    interval: z__namespace.number().int(`${tool2}: interval must be a positive integer number of minutes. Example: 5`).positive(`${tool2}: interval must be greater than zero. Example: 5`).describe("Bar interval in minutes. Must be a positive integer."),
+    kwargs: primitiveMap(tool2, "kwargs").describe(
       "Advanced Bloomberg request kwargs as flat string/number/boolean values only."
     ),
-    outputTz: nonEmptyString2(tool3, "outputTz", options.maxStringChars, "America/New_York").optional().describe("Optional output timezone, for example America/New_York."),
-    requestTz: nonEmptyString2(tool3, "requestTz", options.maxStringChars, "America/New_York").optional().describe("Timezone for naive start/end datetimes, for example America/New_York."),
-    start: dateTimeField(tool3, "start").describe(
+    outputTz: nonEmptyString2(tool2, "outputTz", options.maxStringChars, "<TIMEZONE>").optional().describe("Optional output timezone."),
+    requestTz: nonEmptyString2(tool2, "requestTz", options.maxStringChars, "<TIMEZONE>").optional().describe("Timezone for naive start/end datetimes."),
+    start: dateTimeField(tool2, "start").describe(
       "Required intraday start datetime. Use ISO 8601 with timezone when possible."
     ),
-    ticker: nonEmptyString2(tool3, "ticker", options.maxStringChars, "AAPL US Equity").describe(
-      "One fully qualified Bloomberg security, for example AAPL US Equity; use /isin/{isin} for ISINs and /cusip/{cusip} for CUSIPs."
+    ticker: nonEmptyString2(
+      tool2,
+      "ticker",
+      options.maxStringChars,
+      "<TICKER> <MARKET_SECTOR>"
+    ).describe(
+      "One fully qualified Bloomberg security supplied by the user; use /isin/<ISIN> for ISINs and /cusip/<CUSIP> for CUSIPs."
     )
   });
 }
 function createBdtickSchema(options) {
-  const tool3 = "xbbg_bdtick";
-  const includeFlag = z2__namespace.boolean().optional().describe("Optional IntradayTickRequest include flag.");
-  return z2__namespace.object({
-    end: dateTimeField(tool3, "end").describe(
+  const tool2 = "xbbg_bdtick";
+  const includeFlag = z__namespace.boolean().optional().describe("Optional IntradayTickRequest include flag.");
+  return z__namespace.object({
+    end: dateTimeField(tool2, "end").describe(
       "Required intraday tick end datetime. Use ISO 8601 with timezone when possible."
     ),
     eventTypes: stringArray2(
-      tool3,
+      tool2,
       "eventTypes",
       options.maxFields,
       options.maxStringChars,
-      '["TRADE"]'
-    ).optional().describe('Bloomberg tick event types, for example ["TRADE"] or ["BID", "ASK"].'),
+      '["<EVENT_TYPE>"]'
+    ).optional().describe('Bloomberg tick event types, for example ["<EVENT_TYPE>"].'),
     includeBicMicCodes: includeFlag,
     includeBloombergStandardConditionCodes: includeFlag,
     includeBrokerCodes: includeFlag,
@@ -1487,94 +1596,99 @@ function createBdtickSchema(options) {
     includeExchangeCodes: includeFlag,
     includeNonPlottableEvents: includeFlag,
     includeRpsCodes: includeFlag,
-    kwargs: primitiveMap(tool3, "kwargs").describe(
+    kwargs: primitiveMap(tool2, "kwargs").describe(
       "Advanced IntradayTickRequest kwargs as flat string/number/boolean values only."
     ),
-    outputTz: nonEmptyString2(tool3, "outputTz", options.maxStringChars, "America/New_York").optional().describe("Optional output timezone, for example America/New_York."),
-    requestTz: nonEmptyString2(tool3, "requestTz", options.maxStringChars, "America/New_York").optional().describe("Timezone for naive start/end datetimes, for example America/New_York."),
-    start: dateTimeField(tool3, "start").describe(
+    outputTz: nonEmptyString2(tool2, "outputTz", options.maxStringChars, "<TIMEZONE>").optional().describe("Optional output timezone."),
+    requestTz: nonEmptyString2(tool2, "requestTz", options.maxStringChars, "<TIMEZONE>").optional().describe("Timezone for naive start/end datetimes."),
+    start: dateTimeField(tool2, "start").describe(
       "Required intraday tick start datetime. Use ISO 8601 with timezone when possible."
     ),
-    ticker: nonEmptyString2(tool3, "ticker", options.maxStringChars, "AAPL US Equity").describe(
-      "One fully qualified Bloomberg security, for example AAPL US Equity; use /isin/{isin} for ISINs and /cusip/{cusip} for CUSIPs."
+    ticker: nonEmptyString2(
+      tool2,
+      "ticker",
+      options.maxStringChars,
+      "<TICKER> <MARKET_SECTOR>"
+    ).describe(
+      "One fully qualified Bloomberg security supplied by the user; use /isin/<ISIN> for ISINs and /cusip/<CUSIP> for CUSIPs."
     )
   });
 }
 function createBqlSchema(options) {
-  const tool3 = "xbbg_bql";
-  return z2__namespace.object({
-    format: referenceFormat(tool3).describe("JSON output shape. Usually omit."),
-    kwargs: primitiveMap(tool3, "kwargs").describe(
+  const tool2 = "xbbg_bql";
+  return z__namespace.object({
+    format: referenceFormat(tool2).describe("JSON output shape. Usually omit."),
+    kwargs: primitiveMap(tool2, "kwargs").describe(
       "Advanced Bloomberg request kwargs as flat string/number/boolean values only."
     ),
-    query: nonEmptyString2(
-      tool3,
-      "query",
-      options.maxBqlQueryChars,
-      "get(px_last) for('AAPL US Equity')"
-    ).describe(
-      "Complete BQL expression string. Use get(...) for(...) with an explicit bounded universe; prefer BDP/BDH for simple reference or historical requests."
+    query: nonEmptyString2(tool2, "query", options.maxBqlQueryChars, "<BQL_QUERY>").describe(
+      "Complete BQL expression string with an explicit bounded universe; prefer BDP/BDH for simple reference or historical requests."
     )
   });
 }
 function createBqrSchema(options) {
-  const tool3 = "xbbg_bqr";
-  return z2__namespace.object({
-    end: dateTimeField(tool3, "end").describe(
+  const tool2 = "xbbg_bqr";
+  return z__namespace.object({
+    end: dateTimeField(tool2, "end").describe(
       "Required BQR end datetime. Use ISO 8601 with timezone when possible."
     ),
     eventTypes: stringArray2(
-      tool3,
+      tool2,
       "eventTypes",
       options.maxFields,
       options.maxStringChars,
-      '["BID", "ASK"]'
-    ).optional().describe('BQR event types. Usually ["BID", "ASK"].'),
-    includeBrokerCodes: z2__namespace.boolean().optional().describe("Include broker/dealer attribution columns. Defaults to true in @xbbg/core."),
-    start: dateTimeField(tool3, "start").describe(
+      '["<EVENT_TYPE>"]'
+    ).optional().describe('BQR event types, for example ["<EVENT_TYPE>"].'),
+    includeBrokerCodes: z__namespace.boolean().optional().describe("Include broker/dealer attribution columns. Defaults to true in @xbbg/core."),
+    start: dateTimeField(tool2, "start").describe(
       "Required BQR start datetime. Use ISO 8601 with timezone when possible."
     ),
     ticker: nonEmptyString2(
-      tool3,
+      tool2,
       "ticker",
       options.maxStringChars,
-      "/isin/US037833FB15@MSG1 Corp"
+      "/isin/<ISIN>@<QUOTE_SOURCE> <MARKET_SECTOR>"
     ).describe(
-      "Fixed-income ticker or identifier with dealer quote source, for example /isin/US037833FB15@MSG1 Corp."
+      "Fixed-income ticker or identifier with dealer quote source, for example /isin/<ISIN>@<QUOTE_SOURCE> <MARKET_SECTOR>."
     )
   });
 }
 function createBsrchSchema(options) {
-  const tool3 = "xbbg_bsrch";
-  return z2__namespace.object({
-    format: referenceFormat(tool3).describe("JSON output shape. Usually omit."),
-    kwargs: primitiveMap(tool3, "kwargs").describe(
+  const tool2 = "xbbg_bsrch";
+  return z__namespace.object({
+    format: referenceFormat(tool2).describe("JSON output shape. Usually omit."),
+    kwargs: primitiveMap(tool2, "kwargs").describe(
       "Search-grid kwargs as flat string/number/boolean values only."
     ),
-    overrides: primitiveMap(tool3, "overrides").describe(
+    overrides: primitiveMap(tool2, "overrides").describe(
       "Search-grid overrides as flat string/number/boolean values only."
     ),
     searchSpec: nonEmptyString2(
-      tool3,
+      tool2,
       "searchSpec",
       options.maxSearchSpecChars,
-      "COMDTY:NG"
+      "<SEARCH_SPEC>"
     ).describe(
       "Bloomberg search/grid domain or saved-search spec. Not for normal security lookup."
     )
   });
 }
 function createBfldsSchema(options) {
-  const tool3 = "xbbg_bflds";
-  return z2__namespace.object({
-    fields: stringArray2(tool3, "fields", options.maxFields, options.maxStringChars, '["PX_LAST"]').optional().describe(
-      'Specific field mnemonics to inspect, for example ["PX_LAST"]. Provide either fields or searchSpec, not both.'
+  const tool2 = "xbbg_bflds";
+  return z__namespace.object({
+    fields: stringArray2(tool2, "fields", options.maxFields, options.maxStringChars, '["<FIELD>"]').optional().describe(
+      "Specific field mnemonics to inspect. Provide either fields or searchSpec, not both."
     ),
-    format: referenceFormat(tool3).describe("JSON output shape. Usually omit."),
-    kwargs: primitiveMap(tool3, "kwargs").describe(
+    format: referenceFormat(tool2).describe("JSON output shape. Usually omit."),
+    kwargs: primitiveMap(tool2, "kwargs").describe(
       "Advanced Bloomberg request kwargs as flat string/number/boolean values only."
     ),
-    searchSpec: nonEmptyString2(tool3, "searchSpec", options.maxSearchSpecChars, "last price").optional().describe(
+    searchSpec: nonEmptyString2(
+      tool2,
+      "searchSpec",
+      options.maxSearchSpecChars,
+      "<FIELD_SEARCH_TEXT>"
+    ).optional().describe(
       "Field search text when the field mnemonic is unknown. Provide either searchSpec or fields, not both."
     )
   }).superRefine((value, ctx) => {
@@ -1583,188 +1697,198 @@ function createBfldsSchema(options) {
     if (hasFields === hasSearchSpec) {
       ctx.addIssue({
         code: "custom",
-        message: `${tool3}: provide exactly one of fields or searchSpec. Example: {"fields":["PX_LAST"]}`,
+        message: `${tool2}: provide exactly one of fields or searchSpec. Example: {"fields":["<FIELD>"]}`,
         path: ["fields"]
       });
     }
   });
 }
 function createBeqsSchema(options) {
-  const tool3 = "xbbg_beqs";
-  return z2__namespace.object({
-    asof: dateField(tool3, "asof").optional().describe("Optional as-of date for the screen."),
-    format: referenceFormat(tool3).describe("JSON output shape. Usually omit."),
-    group: nonEmptyString2(tool3, "group", options.maxStringChars, "General").optional().describe("Bloomberg BEQS group. Defaults to General in @xbbg/core."),
-    kwargs: primitiveMap(tool3, "kwargs").describe(
+  const tool2 = "xbbg_beqs";
+  return z__namespace.object({
+    asof: dateField(tool2, "asof").optional().describe("Optional as-of date for the screen."),
+    format: referenceFormat(tool2).describe("JSON output shape. Usually omit."),
+    group: nonEmptyString2(tool2, "group", options.maxStringChars, "<BEQS_GROUP>").optional().describe("Bloomberg BEQS group when required by the screen."),
+    kwargs: primitiveMap(tool2, "kwargs").describe(
       "Advanced BEQS request kwargs as flat string/number/boolean values only."
     ),
-    overrides: primitiveMap(tool3, "overrides").describe(
+    overrides: primitiveMap(tool2, "overrides").describe(
       "BEQS overrides as flat string/number/boolean values only."
     ),
-    screen: nonEmptyString2(
-      tool3,
-      "screen",
-      options.maxStringChars,
-      "Core Capital Goods Makers"
-    ).describe("Existing Bloomberg BEQS screen name."),
-    screenType: nonEmptyString2(tool3, "screenType", options.maxStringChars, "PRIVATE").optional().describe("Bloomberg BEQS screen type. Defaults to PRIVATE in @xbbg/core.")
+    screen: nonEmptyString2(tool2, "screen", options.maxStringChars, "<BEQS_SCREEN>").describe(
+      "Existing Bloomberg BEQS screen name supplied by the user."
+    ),
+    screenType: nonEmptyString2(tool2, "screenType", options.maxStringChars, "<SCREEN_TYPE>").optional().describe("Bloomberg BEQS screen type when required by the screen.")
   });
 }
 function createYasSchema(options) {
-  const tool3 = "xbbg_yas";
-  return z2__namespace.object({
-    benchmark: nonEmptyString2(tool3, "benchmark", options.maxStringChars, "USGG10YR Index").optional().describe("Optional YAS benchmark."),
+  const tool2 = "xbbg_yas";
+  return z__namespace.object({
+    benchmark: nonEmptyString2(tool2, "benchmark", options.maxStringChars, "<BENCHMARK_TICKER>").optional().describe("Optional YAS benchmark supplied by the user."),
     fields: stringArray2(
-      tool3,
+      tool2,
       "fields",
       options.maxFields,
       options.maxStringChars,
-      '["YAS_BOND_YLD"]'
-    ).describe('YAS field mnemonics, for example ["YAS_BOND_YLD", "YAS_MOD_DUR"].'),
-    price: z2__namespace.number().optional().describe("Optional YAS price input."),
-    settleDt: dateField(tool3, "settleDt").optional().describe("Optional YAS settlement date."),
-    spread: z2__namespace.number().optional().describe("Optional YAS spread input."),
+      '["<YAS_FIELD>"]'
+    ).describe("YAS field mnemonics supplied by the user."),
+    price: z__namespace.number().optional().describe("Optional YAS price input."),
+    settleDt: dateField(tool2, "settleDt").optional().describe("Optional YAS settlement date."),
+    spread: z__namespace.number().optional().describe("Optional YAS spread input."),
     tickers: stringArray2(
-      tool3,
+      tool2,
       "tickers",
       options.maxSecurities,
       options.maxStringChars,
-      '["/isin/US037833FB15 Corp"]'
-    ).describe(
-      'Fully qualified fixed-income Bloomberg securities, for example ["/isin/US037833FB15 Corp"].'
-    ),
-    yieldType: z2__namespace.number().int().optional().describe("Optional YAS yield type."),
-    yieldVal: z2__namespace.number().optional().describe("Optional YAS yield value input.")
+      '["/isin/<ISIN> <MARKET_SECTOR>"]'
+    ).describe("Fully qualified fixed-income Bloomberg securities supplied by the user."),
+    yieldType: z__namespace.number().int().optional().describe("Optional YAS yield type."),
+    yieldVal: z__namespace.number().optional().describe("Optional YAS yield value input.")
   });
 }
 function createPreferredsSchema(options) {
-  const tool3 = "xbbg_preferreds";
-  return z2__namespace.object({
+  const tool2 = "xbbg_preferreds";
+  return z__namespace.object({
     equityTicker: nonEmptyString2(
-      tool3,
+      tool2,
       "equityTicker",
       options.maxStringChars,
-      "AAPL US Equity"
-    ).describe("One fully qualified issuer equity ticker."),
-    fields: stringArray2(tool3, "fields", options.maxFields, options.maxStringChars, '["id"]').optional().describe("Optional fields to include in the preferreds recipe result.")
+      "<ISSUER_TICKER> <MARKET_SECTOR>"
+    ).describe("One fully qualified issuer equity ticker supplied by the user."),
+    fields: stringArray2(tool2, "fields", options.maxFields, options.maxStringChars, '["<FIELD>"]').optional().describe("Optional fields to include in the preferreds recipe result.")
   });
 }
 function createCorporateBondsSchema(options) {
-  const tool3 = "xbbg_corporate_bonds";
-  return z2__namespace.object({
-    activeOnly: z2__namespace.boolean().optional().describe("Restrict to active bonds. Defaults to true in @xbbg/core."),
-    ccy: nonEmptyString2(tool3, "ccy", options.maxStringChars, "USD").optional().describe("Optional currency filter."),
-    fields: stringArray2(tool3, "fields", options.maxFields, options.maxStringChars, '["id"]').optional().describe("Optional fields to include in the corporate bond result."),
-    ticker: nonEmptyString2(tool3, "ticker", options.maxStringChars, "AAPL US Equity").describe(
-      "One fully qualified issuer/company ticker."
-    )
+  const tool2 = "xbbg_corporate_bonds";
+  return z__namespace.object({
+    activeOnly: z__namespace.boolean().optional().describe("Restrict to active bonds. Defaults to true in @xbbg/core."),
+    ccy: nonEmptyString2(tool2, "ccy", options.maxStringChars, "<CCY>").optional().describe("Optional currency filter supplied by the user."),
+    fields: stringArray2(tool2, "fields", options.maxFields, options.maxStringChars, '["<FIELD>"]').optional().describe("Optional fields to include in the corporate bond result."),
+    ticker: nonEmptyString2(
+      tool2,
+      "ticker",
+      options.maxStringChars,
+      "<ISSUER_TICKER> <MARKET_SECTOR>"
+    ).describe("One fully qualified issuer/company ticker supplied by the user.")
   });
 }
 function createIndexMembersSchema(options) {
-  const tool3 = "xbbg_index_members";
-  return z2__namespace.object({
-    asof: dateField(tool3, "asof").optional().describe("Optional index membership as-of date."),
-    field: z2__namespace.enum(["INDX_MWEIGHT", "INDX_MEMBERS", "INDX_MEMBERS3"]).optional().describe("Bloomberg index members field. Omit for @xbbg/core default."),
-    index: nonEmptyString2(tool3, "index", options.maxStringChars, "SPX Index").describe(
-      "One fully qualified Bloomberg index ticker."
-    )
+  const tool2 = "xbbg_index_members";
+  return z__namespace.object({
+    asof: dateField(tool2, "asof").optional().describe("Optional index membership as-of date."),
+    field: z__namespace.enum(["INDX_MWEIGHT", "INDX_MEMBERS", "INDX_MEMBERS3"]).optional().describe("Bloomberg index members field. Omit for @xbbg/core default."),
+    index: nonEmptyString2(
+      tool2,
+      "index",
+      options.maxStringChars,
+      "<INDEX_TICKER> <MARKET_SECTOR>"
+    ).describe("One fully qualified Bloomberg index ticker supplied by the user.")
   });
 }
 function createResolveIsinsSchema(options) {
-  const tool3 = "xbbg_resolve_isins";
-  return z2__namespace.object({
+  const tool2 = "xbbg_resolve_isins";
+  return z__namespace.object({
     isins: stringArray2(
-      tool3,
+      tool2,
       "isins",
       options.maxSecurities,
       options.maxStringChars,
-      '["US0378331005"]'
+      '["<ISIN>"]'
     ).describe("Raw ISIN strings to resolve. Do not add /isin/ prefixes for this recipe.")
   });
 }
 function createIssuerIsinsSchema(options) {
-  const tool3 = "xbbg_issuer_isins";
-  return z2__namespace.object({
+  const tool2 = "xbbg_issuer_isins";
+  return z__namespace.object({
     bondIsins: stringArray2(
-      tool3,
+      tool2,
       "bondIsins",
       options.maxSecurities,
       options.maxStringChars,
-      '["US037833FB15"]'
+      '["<BOND_ISIN>"]'
     ).describe("Raw bond ISIN strings for issuer-level ISIN discovery.")
   });
 }
 function createEtfHoldingsSchema(options) {
-  const tool3 = "xbbg_etf_holdings";
-  return z2__namespace.object({
-    etfTicker: nonEmptyString2(tool3, "etfTicker", options.maxStringChars, "SPY US Equity").describe(
-      "One fully qualified Bloomberg ETF ticker."
-    ),
-    fields: stringArray2(tool3, "fields", options.maxFields, options.maxStringChars, '["id"]').optional().describe("Optional fields to include in the ETF holdings recipe result.")
+  const tool2 = "xbbg_etf_holdings";
+  return z__namespace.object({
+    etfTicker: nonEmptyString2(
+      tool2,
+      "etfTicker",
+      options.maxStringChars,
+      "<ETF_TICKER> <MARKET_SECTOR>"
+    ).describe("One fully qualified Bloomberg ETF ticker supplied by the user."),
+    fields: stringArray2(tool2, "fields", options.maxFields, options.maxStringChars, '["<FIELD>"]').optional().describe("Optional fields to include in the ETF holdings recipe result.")
   });
 }
-function snapshotControlFields(tool3, options) {
+function snapshotControlFields(tool2, options) {
   return {
-    allFields: z2__namespace.boolean().optional().describe("Request all Bloomberg fields when supported."),
-    conflate: z2__namespace.boolean().optional().describe("Enable Bloomberg conflated streaming when supported."),
-    drain: z2__namespace.boolean().optional().describe(
+    allFields: z__namespace.boolean().optional().describe("Request all Bloomberg fields when supported."),
+    conflate: z__namespace.boolean().optional().describe("Enable Bloomberg conflated streaming when supported."),
+    drain: z__namespace.boolean().optional().describe(
       "Pass drain=true to unsubscribe. Defaults to false; collected output remains bounded."
     ),
-    flushThreshold: z2__namespace.number().int().positive().optional().describe("Optional stream flush threshold."),
-    maxUpdates: z2__namespace.number().int(`${tool3}: maxUpdates must be a positive integer.`).positive(`${tool3}: maxUpdates must be greater than zero.`).max(
+    flushThreshold: z__namespace.number().int().positive().optional().describe("Optional stream flush threshold."),
+    maxUpdates: z__namespace.number().int(`${tool2}: maxUpdates must be a positive integer.`).positive(`${tool2}: maxUpdates must be greater than zero.`).max(
       options.maxStreamUpdates,
-      `${tool3}: maxUpdates can be at most ${options.maxStreamUpdates}.`
+      `${tool2}: maxUpdates can be at most ${options.maxStreamUpdates}.`
     ).describe("Required maximum number of updates to collect before unsubscribing."),
     options: stringArray2(
-      tool3,
+      tool2,
       "options",
       options.maxFields,
       options.maxStringChars,
       '["interval=5"]'
     ).optional().describe("Advanced Bloomberg subscription options."),
-    overflowPolicy: nonEmptyString2(tool3, "overflowPolicy", options.maxStringChars, "drop_oldest").optional().describe("Optional stream overflow policy."),
-    streamCapacity: z2__namespace.number().int().positive().optional().describe("Optional stream capacity."),
-    timeoutMs: z2__namespace.number().int().positive().max(options.maxStreamWaitMs, `${tool3}: timeoutMs can be at most ${options.maxStreamWaitMs}.`).optional().default(options.maxStreamWaitMs).describe("Maximum total wait in milliseconds before unsubscribing.")
+    overflowPolicy: nonEmptyString2(tool2, "overflowPolicy", options.maxStringChars, "drop_oldest").optional().describe("Optional stream overflow policy."),
+    streamCapacity: z__namespace.number().int().positive().optional().describe("Optional stream capacity."),
+    timeoutMs: z__namespace.number().int().positive().max(options.maxStreamWaitMs, `${tool2}: timeoutMs can be at most ${options.maxStreamWaitMs}.`).optional().default(options.maxStreamWaitMs).describe("Maximum total wait in milliseconds before unsubscribing.")
   };
 }
 function createStreamSnapshotSchema(options) {
-  const tool3 = "xbbg_stream_snapshot";
-  return z2__namespace.object({
+  const tool2 = "xbbg_stream_snapshot";
+  return z__namespace.object({
     fields: stringArray2(
-      tool3,
+      tool2,
       "fields",
       options.maxFields,
       options.maxStringChars,
-      '["LAST_PRICE"]'
+      '["<FIELD>"]'
     ).describe("Bloomberg market-data fields to observe."),
     tickers: stringArray2(
-      tool3,
+      tool2,
       "tickers",
       options.maxSecurities,
       options.maxStringChars,
-      '["AAPL US Equity"]'
-    ).describe("Fully qualified Bloomberg securities to observe."),
-    ...snapshotControlFields(tool3, options)
+      '["<TICKER> <MARKET_SECTOR>"]'
+    ).describe("Fully qualified Bloomberg securities supplied by the user to observe."),
+    ...snapshotControlFields(tool2, options)
   });
 }
 function createMktbarSnapshotSchema(options) {
-  const tool3 = "xbbg_mktbar_snapshot";
-  return z2__namespace.object({
-    fields: stringArray2(tool3, "fields", options.maxFields, options.maxStringChars, '["LAST_PRICE"]').optional().describe("Optional market-bar fields. Omit for Bloomberg defaults."),
-    ticker: nonEmptyString2(tool3, "ticker", options.maxStringChars, "AAPL US Equity").describe(
-      "One fully qualified Bloomberg security to observe."
-    ),
-    ...snapshotControlFields(tool3, options)
+  const tool2 = "xbbg_mktbar_snapshot";
+  return z__namespace.object({
+    fields: stringArray2(tool2, "fields", options.maxFields, options.maxStringChars, '["<FIELD>"]').optional().describe("Optional market-bar fields. Omit for Bloomberg defaults."),
+    ticker: nonEmptyString2(
+      tool2,
+      "ticker",
+      options.maxStringChars,
+      "<TICKER> <MARKET_SECTOR>"
+    ).describe("One fully qualified Bloomberg security supplied by the user to observe."),
+    ...snapshotControlFields(tool2, options)
   });
 }
 function createDepthSnapshotSchema(options) {
-  const tool3 = "xbbg_depth_snapshot";
-  return z2__namespace.object({
-    fields: stringArray2(tool3, "fields", options.maxFields, options.maxStringChars, '["BID"]').optional().describe("Optional market-depth fields. Omit for Bloomberg defaults."),
-    ticker: nonEmptyString2(tool3, "ticker", options.maxStringChars, "AAPL US Equity").describe(
-      "One fully qualified Bloomberg security to observe."
-    ),
-    ...snapshotControlFields(tool3, options)
+  const tool2 = "xbbg_depth_snapshot";
+  return z__namespace.object({
+    fields: stringArray2(tool2, "fields", options.maxFields, options.maxStringChars, '["<FIELD>"]').optional().describe("Optional market-depth fields. Omit for Bloomberg defaults."),
+    ticker: nonEmptyString2(
+      tool2,
+      "ticker",
+      options.maxStringChars,
+      "<TICKER> <MARKET_SECTOR>"
+    ).describe("One fully qualified Bloomberg security supplied by the user to observe."),
+    ...snapshotControlFields(tool2, options)
   });
 }
 
@@ -1907,7 +2031,7 @@ function enabledTool(resolver, name, creator) {
 }
 function bdpWithResolver(resolver) {
   const name = "xbbg_bdp";
-  return tools.tool(
+  return createBloombergStructuredTool(
     async (input) => {
       try {
         const engine = await resolver.getEngine();
@@ -1934,7 +2058,7 @@ function bdpWithResolver(resolver) {
 }
 function bdhWithResolver(resolver) {
   const name = "xbbg_bdh";
-  return tools.tool(
+  return createBloombergStructuredTool(
     async (input) => {
       try {
         const engine = await resolver.getEngine();
@@ -1962,7 +2086,7 @@ function bdhWithResolver(resolver) {
 }
 function bdsWithResolver(resolver) {
   const name = "xbbg_bds";
-  return tools.tool(
+  return createBloombergStructuredTool(
     async (input) => {
       try {
         const engine = await resolver.getEngine();
@@ -1988,7 +2112,7 @@ function bdsWithResolver(resolver) {
 }
 function bdibWithResolver(resolver) {
   const name = "xbbg_bdib";
-  return tools.tool(
+  return createBloombergStructuredTool(
     async (input) => {
       try {
         const engine = await resolver.getEngine();
@@ -2017,7 +2141,7 @@ function bdibWithResolver(resolver) {
 }
 function bdtickWithResolver(resolver) {
   const name = "xbbg_bdtick";
-  return tools.tool(
+  return createBloombergStructuredTool(
     async (input) => {
       try {
         const engine = await resolver.getEngine();
@@ -2052,7 +2176,7 @@ function bdtickWithResolver(resolver) {
 }
 function bqlWithResolver(resolver) {
   const name = "xbbg_bql";
-  return tools.tool(
+  return createBloombergStructuredTool(
     async (input) => {
       try {
         const engine = await resolver.getEngine();
@@ -2076,7 +2200,7 @@ function bqlWithResolver(resolver) {
 }
 function bsrchWithResolver(resolver) {
   const name = "xbbg_bsrch";
-  return tools.tool(
+  return createBloombergStructuredTool(
     async (input) => {
       try {
         const engine = await resolver.getEngine();
@@ -2101,7 +2225,7 @@ function bsrchWithResolver(resolver) {
 }
 function bqrWithResolver(resolver) {
   const name = "xbbg_bqr";
-  return tools.tool(
+  return createBloombergStructuredTool(
     async (input) => {
       try {
         const engine = await resolver.getEngine();
@@ -2127,7 +2251,7 @@ function bqrWithResolver(resolver) {
 }
 function bfldsWithResolver(resolver) {
   const name = "xbbg_bflds";
-  return tools.tool(
+  return createBloombergStructuredTool(
     async (input) => {
       try {
         const engine = await resolver.getEngine();
@@ -2153,7 +2277,7 @@ function bfldsWithResolver(resolver) {
 }
 function beqsWithResolver(resolver) {
   const name = "xbbg_beqs";
-  return tools.tool(
+  return createBloombergStructuredTool(
     async (input) => {
       try {
         const engine = await resolver.getEngine();
@@ -2181,7 +2305,7 @@ function beqsWithResolver(resolver) {
 }
 function yasWithResolver(resolver) {
   const name = "xbbg_yas";
-  return tools.tool(
+  return createBloombergStructuredTool(
     async (input) => {
       try {
         const engine = await resolver.getEngine();
@@ -2209,7 +2333,7 @@ function yasWithResolver(resolver) {
 }
 function preferredsWithResolver(resolver) {
   const name = "xbbg_preferreds";
-  return tools.tool(
+  return createBloombergStructuredTool(
     async (input) => {
       try {
         const engine = await resolver.getEngine();
@@ -2232,7 +2356,7 @@ function preferredsWithResolver(resolver) {
 }
 function corporateBondsWithResolver(resolver) {
   const name = "xbbg_corporate_bonds";
-  return tools.tool(
+  return createBloombergStructuredTool(
     async (input) => {
       try {
         const engine = await resolver.getEngine();
@@ -2257,7 +2381,7 @@ function corporateBondsWithResolver(resolver) {
 }
 function indexMembersWithResolver(resolver) {
   const name = "xbbg_index_members";
-  return tools.tool(
+  return createBloombergStructuredTool(
     async (input) => {
       try {
         const engine = await resolver.getEngine();
@@ -2281,7 +2405,7 @@ function indexMembersWithResolver(resolver) {
 }
 function resolveIsinsWithResolver(resolver) {
   const name = "xbbg_resolve_isins";
-  return tools.tool(
+  return createBloombergStructuredTool(
     async (input) => {
       try {
         const engine = await resolver.getEngine();
@@ -2301,7 +2425,7 @@ function resolveIsinsWithResolver(resolver) {
 }
 function issuerIsinsWithResolver(resolver) {
   const name = "xbbg_issuer_isins";
-  return tools.tool(
+  return createBloombergStructuredTool(
     async (input) => {
       try {
         const engine = await resolver.getEngine();
@@ -2321,7 +2445,7 @@ function issuerIsinsWithResolver(resolver) {
 }
 function etfHoldingsWithResolver(resolver) {
   const name = "xbbg_etf_holdings";
-  return tools.tool(
+  return createBloombergStructuredTool(
     async (input) => {
       try {
         const engine = await resolver.getEngine();
@@ -2344,7 +2468,7 @@ function etfHoldingsWithResolver(resolver) {
 }
 function streamSnapshotWithResolver(resolver) {
   const name = "xbbg_stream_snapshot";
-  return tools.tool(
+  return createBloombergStructuredTool(
     async (input) => {
       try {
         const engine = await resolver.getEngine();
@@ -2365,7 +2489,7 @@ function streamSnapshotWithResolver(resolver) {
 }
 function mktbarSnapshotWithResolver(resolver) {
   const name = "xbbg_mktbar_snapshot";
-  return tools.tool(
+  return createBloombergStructuredTool(
     async (input) => {
       try {
         const engine = await resolver.getEngine();
@@ -2386,7 +2510,7 @@ function mktbarSnapshotWithResolver(resolver) {
 }
 function depthSnapshotWithResolver(resolver) {
   const name = "xbbg_depth_snapshot";
-  return tools.tool(
+  return createBloombergStructuredTool(
     async (input) => {
       try {
         const engine = await resolver.getEngine();