@xbbg/langgraph 1.2.6 → 1.3.0

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 = [
@@ -64,6 +65,13 @@ var DEFAULT_MAX_BQL_QUERY_CHARS = 4e3;
 var DEFAULT_MAX_SEARCH_SPEC_CHARS = 1e3;
 var DEFAULT_MAX_STREAM_UPDATES = 10;
 var DEFAULT_MAX_STREAM_WAIT_MS = 15e3;
+var DEFAULT_ENGINE_REQUEST_TIMEOUT_MS = 6e4;
+function engineConfigWithDefaults(config) {
+  if (config?.requestTimeoutMs !== void 0) {
+    return config;
+  }
+  return { ...config, requestTimeoutMs: DEFAULT_ENGINE_REQUEST_TIMEOUT_MS };
+}
 function positiveInteger(value, fallback, name) {
   if (value === void 0) {
     return fallback;
@@ -81,7 +89,7 @@ function normalizeBloombergToolsOptions(options = {}) {
     core: options.core,
     disabledTools: disabledToolSet(options.disabledTools),
     engine: options.engine,
-    engineConfig: options.engineConfig,
+    engineConfig: engineConfigWithDefaults(options.engineConfig),
     maxBqlQueryChars: positiveInteger(
       options.maxBqlQueryChars,
       DEFAULT_MAX_BQL_QUERY_CHARS,
@@ -125,22 +133,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,
@@ -149,6 +175,232 @@ function createCoreResolver(options = {}) {
   };
 }
 
+// src/result-limits.ts
+var MAX_RESULT_DEPTH = 32;
+function isPlainObject(value) {
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function truncateString(value, maxStringChars, state) {
+  if (value.length <= maxStringChars) {
+    return value;
+  }
+  state.truncated = true;
+  return `${value.slice(0, maxStringChars)}\u2026[truncated ${value.length - maxStringChars} chars]`;
+}
+function limitValue(value, maxRows, maxStringChars, state, depth = 0, seen = /* @__PURE__ */ new WeakSet()) {
+  if (typeof value === "string") {
+    return truncateString(value, maxStringChars, state);
+  }
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  if (depth > MAX_RESULT_DEPTH) {
+    state.truncated = true;
+    return "[Max result depth exceeded]";
+  }
+  if (Array.isArray(value)) {
+    if (seen.has(value)) {
+      state.truncated = true;
+      return "[Circular]";
+    }
+    seen.add(value);
+    const capped = value.length > maxRows ? value.slice(0, maxRows) : value;
+    if (capped.length !== value.length) {
+      state.truncated = true;
+    }
+    return capped.map((item) => limitValue(item, maxRows, maxStringChars, state, depth + 1, seen));
+  }
+  if (typeof value === "object" && value !== null) {
+    if (seen.has(value)) {
+      state.truncated = true;
+      return "[Circular]";
+    }
+    if (ArrayBuffer.isView(value) || value instanceof ArrayBuffer) {
+      state.truncated = true;
+      return `[binary data: ${value.byteLength} bytes]`;
+    }
+    if (!isPlainObject(value)) {
+      const toJSON = value.toJSON;
+      if (typeof toJSON === "function") {
+        seen.add(value);
+        return limitValue(toJSON.call(value), maxRows, maxStringChars, state, depth + 1, seen);
+      }
+      return value;
+    }
+    seen.add(value);
+    const output = {};
+    for (const [key, entry] of Object.entries(value)) {
+      output[key] = limitValue(entry, maxRows, maxStringChars, state, depth + 1, seen);
+    }
+    return output;
+  }
+  return value;
+}
+function rowCountOf(value) {
+  if (Array.isArray(value)) {
+    return value.length;
+  }
+  if (typeof value !== "object" || value === null) {
+    return null;
+  }
+  const record2 = value;
+  const rowCount = record2.rowCount;
+  if (typeof rowCount === "number" && Number.isInteger(rowCount) && rowCount >= 0) {
+    return rowCount;
+  }
+  const updateCount = record2.updateCount;
+  if (typeof updateCount === "number" && Number.isInteger(updateCount) && updateCount >= 0) {
+    return updateCount;
+  }
+  return null;
+}
+var ERROR_SHAPE_KEYS = /* @__PURE__ */ new Set([
+  "error",
+  "errors",
+  "fielderrors",
+  "fieldexception",
+  "fieldexceptions",
+  "responseerror",
+  "securityerror"
+]);
+function hasErrorShape(value) {
+  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);
+    }
+  }
+  return false;
+}
+function limitResult(value, maxRows, maxStringChars) {
+  const state = { truncated: false };
+  const rowCount = rowCountOf(value);
+  const limitedValue = limitValue(value, maxRows, maxStringChars, state);
+  return {
+    rowCount,
+    truncated: state.truncated,
+    value: limitedValue
+  };
+}
+function summarizeEnvelope(envelope) {
+  const rowText = envelope.rowCount === null ? "row count unknown" : `${envelope.rowCount} row${envelope.rowCount === 1 ? "" : "s"}`;
+  const notes = [];
+  if (envelope.rowCount === 0 || envelope.data === null || envelope.data === void 0) {
+    notes.push(
+      "empty result; verify identifiers, fields, and date range before concluding no data exists"
+    );
+  }
+  if (envelope.truncated) {
+    notes.push("artifact truncated to configured limits");
+  }
+  if (hasErrorShape(envelope.data)) {
+    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 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: tool2,
+    rowCount: limited.rowCount,
+    truncated: limited.truncated,
+    data: limited.value
+  };
+  return [formatToolContent(envelope), envelope];
+}
+function throwWithToolContext(tool2, error) {
+  const prefix = `${tool2} failed`;
+  if (error instanceof Error) {
+    if (error.message.startsWith(prefix)) {
+      throw error;
+    }
+    const wrapped = new Error(`${prefix}: ${error.message}`, { cause: error });
+    wrapped.name = error.name;
+    throw wrapped;
+  }
+  throw new Error(`${prefix}: ${String(error)}`);
+}
+
+// src/langchain-tool.ts
+function inputJsonSchema(schema) {
+  const jsonSchema = zodToJsonSchema.zodToJsonSchema(schema, {
+    $refStrategy: "none",
+    effectStrategy: "input",
+    pipeStrategy: "input"
+  });
+  delete jsonSchema.$schema;
+  delete jsonSchema.definitions;
+  return jsonSchema;
+}
+function toolParameterJsonSchema(toolInstance) {
+  const schema = toolInstance.schema;
+  if (schema !== null && typeof schema === "object" && !("safeParse" in schema)) {
+    return schema;
+  }
+  return inputJsonSchema(schema);
+}
+function createBloombergStructuredTool(func, fields) {
+  const providerToolDefinition = {
+    type: "function",
+    function: {
+      description: fields.description,
+      name: fields.name,
+      parameters: inputJsonSchema(fields.schema)
+    }
+  };
+  const guarded = async (input, config) => {
+    try {
+      config?.signal?.throwIfAborted();
+    } catch (error) {
+      throwWithToolContext(fields.name, error);
+    }
+    return await func(input, config);
+  };
+  return tools.tool(
+    guarded,
+    {
+      ...fields,
+      extras: { providerToolDefinition }
+    }
+  );
+}
+
 // src/cdx-fields.ts
 var CDX_INFO_FIELDS = Object.freeze([
   "ROLLING_SERIES",
@@ -187,29 +439,34 @@ var REQUIRED_TOOL_INSTRUCTIONS = [
   "- Use these tools only for server-side Bloomberg data access through @xbbg/core. Never imply Bloomberg data was retrieved unless a tool call actually returned it.",
   "- Ask a clarifying question before calling a tool when any security identity, field mnemonic, date range, currency, periodicity, intraday interval, timezone, override, or universe is ambiguous.",
   "- 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.",
+  "- Issue one tool call per dataset and read any error before retrying; never probe parameter variants in parallel. Omit optional output-shape parameters such as format unless the user asked for a specific shape.",
   "",
   "## 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.",
-  "- 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.",
+  "- Pass each security in the form the user supplied it; never translate between identifier kinds on your own.",
+  "- User supplied a Bloomberg ticker: pass it through fully qualified as <TICKER> <MARKET_SECTOR>, for example <TICKER> <EXCHANGE> Equity, <INDEX_TICKER> Index, or <CCY_PAIR> Curncy.",
+  "- The market sector ending (Bloomberg yellow key) is part of the security string. The sectors are: Equity, Index, Curncy, Comdty, Corp, Govt, Muni, Mtge, M-Mkt, and Pfd. Equity securities carry an exchange or composite code before the sector (<TICKER> <EXCHANGE> Equity); preferred securities use the Pfd sector; corporate and government bonds use Corp and Govt. Request tools pass the security through to Bloomberg without validating the sector, so copy it exactly as the user supplied it.",
+  "- User supplied a raw ISIN or CUSIP: pass Bloomberg identifier syntax directly: /isin/<ISIN> or /cusip/<CUSIP>. Never pass the bare identifier without its prefix, except to xbbg_resolve_isins and xbbg_issuer_isins, which take raw ISIN strings.",
+  "- <TICKER> <MARKET_SECTOR> is a format template, not authorization to construct a ticker. Never invent, recall from memory, or guess the Bloomberg ticker behind an identifier the user gave; identifier syntax is already a complete, valid security input. Use xbbg_resolve_isins only when the user wants the resolved Bloomberg security itself.",
+  "- Recipe tools that take tickers (xbbg_preferreds, xbbg_corporate_bonds, xbbg_index_members, xbbg_etf_holdings) do not accept identifier syntax. When the user supplied an ISIN or CUSIP for those workflows, resolve it with xbbg_resolve_isins first and use the returned Bloomberg security; never guess the ticker.",
+  "- 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/<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_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_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 the issuer's common equity ticker, never a guessed preferred ('Pfd') ticker. Resolve a supplied ISIN/CUSIP with xbbg_resolve_isins first. 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,19 +475,19 @@ 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 = [
   "",
   "## Extension helper tools",
-  "- xbbg_ext_ticker: ticker hygiene before live calls. parse_ticker splits a Bloomberg ticker, normalize_tickers trims/canonicalizes lists, filter_equity_tickers keeps equity-like tickers, is_specific_contract checks futures specificity, and validate_generic_ticker rejects malformed generic futures tickers.",
+  "- xbbg_ext_ticker: ticker hygiene before live calls. parse_ticker splits generic futures-style tickers only \u2014 asset endings Index, Curncy, Comdty, or Corp as <ROOT><N> <ASSET>, or <ROOT><N> <EXCHANGE> Equity \u2014 and rejects other market sectors (Pfd, Govt, Muni, Mtge, M-Mkt) and non-futures securities. normalize_tickers trims/canonicalizes lists, filter_equity_tickers keeps equity-like tickers, is_specific_contract checks futures specificity, and validate_generic_ticker rejects malformed generic futures tickers.",
   "- xbbg_ext_futures: futures contract construction and selection. Use build_futures_ticker for root/month/year/asset assembly, get_futures_months for month-code lookup, generate_candidates for generic-to-specific candidates, contract_index for generic contract rank, filter_candidates_by_cycle for HMUZ/quarterly cycles, and filter_valid_contracts to keep contracts valid for a date.",
   "- xbbg_ext_cdx: CDX ticker workflow support. Use parse_cdx_ticker to understand a CDX ticker, previous_cdx_series to roll back a series, cdx_gen_to_specific to resolve a generic CDX to a target series, and cdx_info/cdx_pricing/cdx_risk for predefined BDP field bundles. cdx_pricing and cdx_risk accept recoveryRate, which becomes the CDS_RR override.",
   "- xbbg_ext_currency: currency-planning helpers. build_fx_pair constructs the Bloomberg FX pair and conversion factor, same_currency avoids unnecessary conversion, and currencies_needing_conversion identifies which currencies differ from a target before requesting converted values.",
@@ -265,387 +522,288 @@ 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 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.";
+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. Pass securities as supplied: '<TICKER> <MARKET_SECTOR>' or identifier syntax such as '/isin/<ISIN> <MARKET_SECTOR>'.";
+var PREFERREDS_DESCRIPTION = "Preferred stock discovery for one issuer. Takes the issuer's common equity ticker such as '<TICKER> US Equity', never a preferred ('Pfd') ticker and never a guessed one. If the user supplied an ISIN or CUSIP, resolve it with xbbg_resolve_isins first.";
+var CORPORATE_BONDS_DESCRIPTION = "Corporate bond universe query for one issuer/company equity ticker, with optional currency, active-only filter, and result fields. Prefer this over generic BQL for company debt discovery. If the user supplied an ISIN or CUSIP, resolve it with xbbg_resolve_isins first; never guess the ticker.";
+var INDEX_MEMBERS_DESCRIPTION = "Index constituent recipe for one Bloomberg index ticker such as '<INDEX_TICKER> Index'. Use for bounded member lists and optional historical/as-of constituent membership; never guess index tickers.";
 var RESOLVE_ISINS_DESCRIPTION = "Resolve raw ISIN strings to Bloomberg securities through the core ISIN recipe. Do not add /isin/ prefixes in this tool; pass the exact ISIN strings supplied by the user.";
 var ISSUER_ISINS_DESCRIPTION = "Issuer/bond ISIN workflow for supplied bond ISIN strings. Use for issuer-level ISIN discovery starting from known bond ISINs.";
-var ETF_HOLDINGS_DESCRIPTION = "ETF holdings recipe for one ETF ticker. Use when the user asks for ETF constituents or holdings and wants the bounded holdings result.";
+var ETF_HOLDINGS_DESCRIPTION = "ETF holdings recipe for one ETF ticker such as '<ETF_TICKER> <MARKET_SECTOR>'. Use when the user asks for ETF constituents or holdings and wants the bounded holdings result. Resolve a supplied ISIN/CUSIP with xbbg_resolve_isins first; never guess the ticker.";
 var STREAM_SNAPSHOT_DESCRIPTION = "Bounded live market-data snapshot from //blp/mktdata. Collects at most maxUpdates updates until timeout/done, then always unsubscribes; use for finite observations, not open subscriptions.";
 var MKTBAR_SNAPSHOT_DESCRIPTION = "Bounded live market-bar snapshot from //blp/mktbar for one ticker. Collects at most maxUpdates updates until timeout/done, then always unsubscribes.";
 var DEPTH_SNAPSHOT_DESCRIPTION = "Bounded live market-depth snapshot from //blp/mktdepthdata for one ticker. Collects at most maxUpdates updates until timeout/done, then always unsubscribes.";
-var EXT_TICKER_DESCRIPTION = "Ticker hygiene helpers: parse_ticker, normalize_tickers, filter_equity_tickers, is_specific_contract, and validate_generic_ticker.";
+var EXT_TICKER_DESCRIPTION = "Ticker hygiene helpers: parse_ticker (generic futures-style tickers ending in Index, Curncy, Comdty, or Corp, or <ROOT><N> <EXCHANGE> Equity; other market sectors are rejected), normalize_tickers, filter_equity_tickers, is_specific_contract, and validate_generic_ticker.";
 var EXT_FUTURES_DESCRIPTION = "Futures helpers for contract construction and selection: build_futures_ticker, generate_candidates, contract_index, filter_candidates_by_cycle, filter_valid_contracts, and get_futures_months.";
 var EXT_CDX_DESCRIPTION = "CDX helpers for parsing, series rolling/resolution, and predefined info/pricing/risk BDP field bundles.";
 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.";
-
-// src/result-limits.ts
-var MAX_RESULT_DEPTH = 32;
-function isPlainObject(value) {
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
-}
-function truncateString(value, maxStringChars, state) {
-  if (value.length <= maxStringChars) {
-    return value;
-  }
-  state.truncated = true;
-  return `${value.slice(0, maxStringChars)}\u2026[truncated ${value.length - maxStringChars} chars]`;
-}
-function limitValue(value, maxRows, maxStringChars, state, depth = 0, seen = /* @__PURE__ */ new WeakSet()) {
-  if (typeof value === "string") {
-    return truncateString(value, maxStringChars, state);
-  }
-  if (value instanceof Date) {
-    return value.toISOString();
-  }
-  if (depth > MAX_RESULT_DEPTH) {
-    state.truncated = true;
-    return "[Max result depth exceeded]";
-  }
-  if (Array.isArray(value)) {
-    if (seen.has(value)) {
-      state.truncated = true;
-      return "[Circular]";
-    }
-    seen.add(value);
-    const capped = value.length > maxRows ? value.slice(0, maxRows) : value;
-    if (capped.length !== value.length) {
-      state.truncated = true;
-    }
-    return capped.map((item) => limitValue(item, maxRows, maxStringChars, state, depth + 1, seen));
-  }
-  if (typeof value === "object" && value !== null) {
-    if (seen.has(value)) {
-      state.truncated = true;
-      return "[Circular]";
-    }
-    if (!isPlainObject(value)) {
-      return value;
-    }
-    seen.add(value);
-    const output = {};
-    for (const [key, entry] of Object.entries(value)) {
-      output[key] = limitValue(entry, maxRows, maxStringChars, state, depth + 1, seen);
-    }
-    return output;
-  }
-  return value;
-}
-function rowCountOf(value) {
-  if (Array.isArray(value)) {
-    return value.length;
-  }
-  if (typeof value !== "object" || value === null) {
-    return null;
-  }
-  const record2 = value;
-  const rowCount = record2.rowCount;
-  if (typeof rowCount === "number" && Number.isInteger(rowCount) && rowCount >= 0) {
-    return rowCount;
-  }
-  const updateCount = record2.updateCount;
-  if (typeof updateCount === "number" && Number.isInteger(updateCount) && updateCount >= 0) {
-    return updateCount;
-  }
-  return null;
-}
-function hasErrorShape(value) {
-  if (typeof value !== "object" || value === null) {
-    return false;
-  }
-  const record2 = value;
-  return record2.error !== void 0 || record2.errors !== void 0 || record2.securityError !== void 0;
-}
-function limitResult(value, maxRows, maxStringChars) {
-  const state = { truncated: false };
-  const rowCount = rowCountOf(value);
-  const limitedValue = limitValue(value, maxRows, maxStringChars, state);
-  return {
-    rowCount,
-    truncated: state.truncated,
-    value: limitedValue
-  };
-}
-function summarizeEnvelope(envelope) {
-  const rowText = envelope.rowCount === null ? "row count unknown" : `${envelope.rowCount} row${envelope.rowCount === 1 ? "" : "s"}`;
-  const notes = [];
-  if (envelope.rowCount === 0) {
-    notes.push("empty result");
-  }
-  if (envelope.truncated) {
-    notes.push("artifact truncated to configured limits");
-  }
-  if (hasErrorShape(envelope.data)) {
-    notes.push("inspect artifact 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) {
-  const limited = limitResult(value, maxRows, maxStringChars);
-  const envelope = {
-    tool: tool3,
-    rowCount: limited.rowCount,
-    truncated: limited.truncated,
-    data: limited.value
-  };
-  return [summarizeEnvelope(envelope), envelope];
-}
-function throwWithToolContext(tool3, error) {
-  const prefix = `${tool3} failed`;
-  if (error instanceof Error) {
-    if (!error.message.startsWith(prefix)) {
-      Object.defineProperty(error, "message", {
-        configurable: true,
-        value: `${prefix}: ${error.message}`
-      });
-    }
-    throw 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 generic futures-style Bloomberg ticker: <ROOT><N> ending in Index, Curncy, Comdty, or Corp, or <ROOT><N> <EXCHANGE> Equity. parse_ticker rejects other market sectors (Pfd, Govt, Muni, Mtge, M-Mkt) and non-futures securities."
+  );
+  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."),
-    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."),
-    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."),
-    monthCode: optionalString(options, "Bloomberg futures month code, for example H."),
-    operation: z2__namespace.enum([
-      "build_futures_ticker",
-      "generate_candidates",
-      "contract_index",
-      "filter_candidates_by_cycle",
-      "filter_valid_contracts",
-      "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.")
-  });
+  const genTicker = nonEmptyString(
+    options,
+    "Generic Bloomberg futures ticker, for example ES1 Index."
+  );
+  const year = z__namespace.number().int().describe("Contract year, for example 2024.");
+  const month = z__namespace.number().int().min(1).max(12).describe("Month number, 1-12.");
+  const day = z__namespace.number().int().min(1).max(31).describe("Day number, 1-31.");
+  return z__namespace.discriminatedUnion("operation", [
+    z__namespace.object({
+      asset: nonEmptyString(
+        options,
+        "Bloomberg asset class suffix, for example Index or Comdty."
+      ),
+      monthCode: nonEmptyString(options, "Bloomberg futures month code, for example H."),
+      operation: z__namespace.literal("build_futures_ticker"),
+      prefix: nonEmptyString(options, "Futures ticker root prefix, for example ES."),
+      year: z__namespace.union([z__namespace.string().trim().min(1), z__namespace.number().int().transform(String)]).describe("Contract year, full or abbreviated, as a string or integer.")
+    }).strict(),
+    z__namespace.object({
+      count: z__namespace.number().int().positive().optional().describe("Maximum number of futures candidates to generate."),
+      day,
+      freq: optionalString(options, "Futures frequency/cycle hint."),
+      genTicker,
+      month,
+      operation: z__namespace.literal("generate_candidates"),
+      year
+    }).strict(),
+    z__namespace.object({ genTicker, operation: z__namespace.literal("contract_index") }).strict(),
+    z__namespace.object({
+      candidates: z__namespace.array(futuresCandidateSchema).min(1).max(options.maxFields).describe("Candidate futures contracts."),
+      cycle: nonEmptyString(options, "Futures cycle code to filter candidates by."),
+      operation: z__namespace.literal("filter_candidates_by_cycle")
+    }).strict(),
+    z__namespace.object({
+      contracts: z__namespace.array(stringPairSchema).min(1).max(options.maxFields).describe("Contract pairs for validity filtering."),
+      day,
+      month,
+      operation: z__namespace.literal("filter_valid_contracts"),
+      year
+    }).strict(),
+    z__namespace.object({ operation: z__namespace.literal("get_futures_months") }).strict()
+  ]);
 }
 function cdxSchema(options) {
-  return z2__namespace.object({
-    genTicker: optionalString(options, "Generic CDX ticker."),
-    operation: z2__namespace.enum([
-      "parse_cdx_ticker",
-      "previous_cdx_series",
-      "cdx_gen_to_specific",
-      "cdx_info",
-      "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."),
-    ticker: optionalString(options, "CDX ticker.")
-  });
+  const ticker = nonEmptyString(options, "CDX ticker, generic or specific.");
+  const recoveryRate = z__namespace.number().min(0).max(1).optional().describe("Decimal recovery rate override, e.g. 0.4 for 40%; sent as the CDS_RR override.");
+  return z__namespace.discriminatedUnion("operation", [
+    z__namespace.object({ operation: z__namespace.literal("parse_cdx_ticker"), ticker }).strict(),
+    z__namespace.object({ operation: z__namespace.literal("previous_cdx_series"), ticker }).strict(),
+    z__namespace.object({ operation: z__namespace.literal("cdx_info"), ticker }).strict(),
+    z__namespace.object({ operation: z__namespace.literal("cdx_pricing"), recoveryRate, ticker }).strict(),
+    z__namespace.object({ operation: z__namespace.literal("cdx_risk"), recoveryRate, ticker }).strict(),
+    z__namespace.object({
+      genTicker: nonEmptyString(
+        options,
+        "Generic CDX ticker, for example CDX IG CDSI GEN 5Y Corp."
+      ),
+      operation: z__namespace.literal("cdx_gen_to_specific"),
+      series: z__namespace.number().int().positive().describe("Specific CDX series number.")
+    }).strict()
+  ]);
 }
 function currencySchema(options) {
-  return z2__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."),
-    target: optionalString(options, "Target ISO currency code."),
-    toCcy: optionalString(options, "Destination ISO currency code.")
-  });
+  return z__namespace.discriminatedUnion("operation", [
+    z__namespace.object({
+      fromCcy: nonEmptyString(options, "Source ISO currency code."),
+      operation: z__namespace.literal("build_fx_pair"),
+      toCcy: nonEmptyString(options, "Destination ISO currency code.")
+    }).strict(),
+    z__namespace.object({
+      ccy1: nonEmptyString(options, "First ISO currency code."),
+      ccy2: nonEmptyString(options, "Second ISO currency code."),
+      operation: z__namespace.literal("same_currency")
+    }).strict(),
+    z__namespace.object({
+      currencies: stringArray(options, "ISO currency codes to check."),
+      operation: z__namespace.literal("currencies_needing_conversion"),
+      target: nonEmptyString(options, "Target ISO currency code.")
+    }).strict()
+  ]);
 }
 function bqlBuilderSchema(options) {
-  return z2__namespace.object({
-    activeOnly: z2__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."),
-    ticker: optionalString(options, "Ticker for corporate bond query.")
-  });
+  const extraFields = stringArray(options, "Extra BQL fields to include.").optional();
+  return z__namespace.discriminatedUnion("operation", [
+    z__namespace.object({
+      equityTicker: nonEmptyString(options, "Equity ticker for preferreds query."),
+      extraFields,
+      operation: z__namespace.literal("build_preferreds_query")
+    }).strict(),
+    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."),
+      extraFields,
+      operation: z__namespace.literal("build_corporate_bonds_query"),
+      ticker: nonEmptyString(options, "Ticker for corporate bond query.")
+    }).strict(),
+    z__namespace.object({
+      etfTicker: nonEmptyString(options, "ETF ticker for holdings query."),
+      extraFields,
+      operation: z__namespace.literal("build_etf_holdings_query")
+    }).strict()
+  ]);
 }
 function marketSessionSchema(options) {
-  return z2__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."),
-    dayStart: optionalString(options, "Exchange day start time, for example 09:30."),
-    endDate: optionalString(options, "Optional end date."),
-    endDatetime: optionalString(options, "Optional end datetime."),
-    endTime: optionalString(options, "Session end time, for example 16:00."),
-    exchCode: optionalString(options, "Bloomberg exchange code."),
-    exchangeTz: optionalString(options, "IANA exchange timezone."),
-    mic: optionalString(options, "Market Identifier Code."),
-    operation: z2__namespace.enum([
-      "derive_sessions",
-      "get_market_rule",
-      "infer_timezone",
-      "session_times_to_utc",
-      "default_turnover_dates",
-      "default_bqr_datetimes",
-      "get_exchange_override",
-      "list_exchange_overrides"
-    ]).describe("Market session helper operation to run."),
-    startDate: optionalString(options, "Optional start date."),
-    startDatetime: optionalString(options, "Optional start datetime."),
-    startTime: optionalString(options, "Session start time, for example 09:30."),
-    ticker: optionalString(options, "Ticker for exchange override lookup.")
-  });
+  const mic = optionalString(options, "Market Identifier Code, for example XNYS.");
+  const exchCode = optionalString(options, "Bloomberg exchange code.");
+  return z__namespace.discriminatedUnion("operation", [
+    z__namespace.object({
+      dayEnd: nonEmptyString(options, "Exchange day end time, for example 16:00."),
+      dayStart: nonEmptyString(options, "Exchange day start time, for example 09:30."),
+      exchCode,
+      mic,
+      operation: z__namespace.literal("derive_sessions")
+    }).strict(),
+    z__namespace.object({ exchCode, mic, operation: z__namespace.literal("get_market_rule") }).strict(),
+    z__namespace.object({
+      countryIso: nonEmptyString(options, "ISO country code for timezone inference."),
+      operation: z__namespace.literal("infer_timezone")
+    }).strict(),
+    z__namespace.object({
+      date: nonEmptyString(options, "Date for UTC session conversion, YYYY-MM-DD or YYYYMMDD."),
+      endTime: nonEmptyString(options, "Session end time, for example 16:00."),
+      exchangeTz: nonEmptyString(
+        options,
+        "IANA exchange timezone, for example America/New_York."
+      ),
+      operation: z__namespace.literal("session_times_to_utc"),
+      startTime: nonEmptyString(options, "Session start time, for example 09:30.")
+    }).strict(),
+    z__namespace.object({
+      endDate: optionalString(options, "Optional end date."),
+      operation: z__namespace.literal("default_turnover_dates"),
+      startDate: optionalString(options, "Optional start date.")
+    }).strict(),
+    z__namespace.object({
+      endDatetime: optionalString(options, "Optional end datetime."),
+      operation: z__namespace.literal("default_bqr_datetimes"),
+      startDatetime: optionalString(options, "Optional start datetime.")
+    }).strict(),
+    z__namespace.object({
+      operation: z__namespace.literal("get_exchange_override"),
+      ticker: nonEmptyString(options, "Ticker for exchange override lookup.")
+    }).strict(),
+    z__namespace.object({ operation: z__namespace.literal("list_exchange_overrides") }).strict()
+  ]);
 }
 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.")
+  }).strict();
 }
 function constantsSchema(options) {
-  return z2__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."),
-    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."),
-    monthName: optionalString(options, "Month name."),
-    operation: z2__namespace.enum([
-      "parse_date",
-      "fmt_date",
-      "get_month_code",
-      "get_month_name",
-      "get_futures_months",
-      "get_dvd_type",
-      "get_dvd_types",
-      "get_dvd_cols",
-      "get_etf_cols"
-    ]).describe("Constants helper operation to run."),
-    year: z2__namespace.number().int().min(1).optional().describe("Year number.")
-  });
+  return z__namespace.discriminatedUnion("operation", [
+    z__namespace.object({
+      dateStr: nonEmptyString(options, "Date string to parse."),
+      operation: z__namespace.literal("parse_date")
+    }).strict(),
+    z__namespace.object({
+      day: z__namespace.number().int().min(1).max(31).describe("Day number, 1-31."),
+      fmt: optionalString(options, "Date output format."),
+      month: z__namespace.number().int().min(1).max(12).describe("Month number, 1-12."),
+      operation: z__namespace.literal("fmt_date"),
+      year: z__namespace.number().int().min(1).describe("Year number.")
+    }).strict(),
+    z__namespace.object({
+      monthName: nonEmptyString(options, "Month name, for example March."),
+      operation: z__namespace.literal("get_month_code")
+    }).strict(),
+    z__namespace.object({
+      code: nonEmptyString(options, "Month code, for example H."),
+      operation: z__namespace.literal("get_month_name")
+    }).strict(),
+    z__namespace.object({
+      dvdType: nonEmptyString(options, "Dividend type code or label."),
+      operation: z__namespace.literal("get_dvd_type")
+    }).strict(),
+    z__namespace.object({ operation: z__namespace.literal("get_futures_months") }).strict(),
+    z__namespace.object({ operation: z__namespace.literal("get_dvd_types") }).strict(),
+    z__namespace.object({ operation: z__namespace.literal("get_dvd_cols") }).strict(),
+    z__namespace.object({ operation: z__namespace.literal("get_etf_cols") }).strict()
+  ]);
 }
 function columnsSchema(options) {
-  return z2__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.")
-  });
+  const columns = stringArray(options, "Column names to rename.");
+  return z__namespace.discriminatedUnion("operation", [
+    z__namespace.object({ columns, operation: z__namespace.literal("rename_dividend_columns") }).strict(),
+    z__namespace.object({ columns, operation: z__namespace.literal("rename_etf_columns") }).strict(),
+    z__namespace.object({
+      dataColumns: stringArray(options, "Earnings data column names."),
+      headerRow: z__namespace.array(stringPairSchema).min(1).max(options.maxFields).describe("Earnings header row key/value pairs."),
+      operation: z__namespace.literal("build_earning_header_rename")
+    }).strict()
+  ]);
 }
 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.")
+  }).strict().superRefine((input, ctx) => {
+    if (input.values.length !== input.levels.length) {
+      ctx.addIssue({
+        code: z__namespace.ZodIssueCode.custom,
+        message: "values and levels must have the same length"
+      });
+    }
   });
 }
 
 // src/ext-tools.ts
-function asRecord(value) {
-  return value;
-}
-function requireString(toolName, input, field) {
-  const value = input[field];
-  if (typeof value !== "string" || value.trim().length === 0) {
-    throw new TypeError(`${toolName}: ${field} is required and must be a non-empty string`);
-  }
-  return value.trim();
-}
-function requireNumber(toolName, input, field) {
-  const value = input[field];
-  if (typeof value !== "number" || !Number.isFinite(value)) {
-    throw new TypeError(`${toolName}: ${field} is required and must be a finite number`);
-  }
-  return value;
-}
-function requireInteger(toolName, input, field) {
-  const value = requireNumber(toolName, input, field);
-  if (!Number.isInteger(value)) {
-    throw new TypeError(`${toolName}: ${field} must be an integer`);
-  }
-  return value;
-}
-function requireYearString(toolName, input, field) {
-  const value = input[field];
-  if (typeof value === "number" && Number.isInteger(value)) {
-    return String(value);
-  }
-  if (typeof value === "string" && value.trim().length > 0) {
-    return value.trim();
-  }
-  throw new TypeError(`${toolName}: ${field} is required and must be a year string or integer`);
-}
-function requireStringArray(toolName, input, field) {
-  const value = input[field];
-  if (!Array.isArray(value) || value.length === 0) {
-    throw new TypeError(`${toolName}: ${field} is required and must be a non-empty string array`);
-  }
-  return value.map((entry) => {
-    if (typeof entry !== "string" || entry.trim().length === 0) {
-      throw new TypeError(`${toolName}: ${field} entries must be non-empty strings`);
-    }
-    return entry.trim();
-  });
-}
 function resultString(resolver, name, value) {
   return createToolResult(name, value, resolver.options.maxRows, resolver.options.maxStringChars);
 }
@@ -669,41 +827,22 @@ 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();
-        const args = asRecord(input);
         switch (input.operation) {
           case "parse_ticker":
-            return resultString(
-              resolver,
-              name,
-              core.ext.parseTicker(requireString(name, args, "ticker"))
-            );
+            return resultString(resolver, name, core.ext.parseTicker(input.ticker));
           case "normalize_tickers":
-            return resultString(
-              resolver,
-              name,
-              core.ext.normalizeTickers(requireStringArray(name, args, "tickers"))
-            );
+            return resultString(resolver, name, core.ext.normalizeTickers(input.tickers));
           case "filter_equity_tickers":
-            return resultString(
-              resolver,
-              name,
-              core.ext.filterEquityTickers(requireStringArray(name, args, "tickers"))
-            );
+            return resultString(resolver, name, core.ext.filterEquityTickers(input.tickers));
           case "is_specific_contract":
-            return resultString(
-              resolver,
-              name,
-              core.ext.isSpecificContract(requireString(name, args, "ticker"))
-            );
-          case "validate_generic_ticker": {
-            const ticker = requireString(name, args, "ticker");
-            core.ext.validateGenericTicker(ticker);
-            return resultString(resolver, name, { ticker, valid: true });
-          }
+            return resultString(resolver, name, core.ext.isSpecificContract(input.ticker));
+          case "validate_generic_ticker":
+            core.ext.validateGenericTicker(input.ticker);
+            return resultString(resolver, name, { ticker: input.ticker, valid: true });
         }
       } catch (error) {
         throwWithToolContext(name, error);
@@ -719,67 +858,43 @@ function extTickerWithResolver(resolver) {
 }
 function extFuturesWithResolver(resolver) {
   const name = "xbbg_ext_futures";
-  return tools.tool(
+  return createBloombergStructuredTool(
     async (input) => {
       try {
         const core = await resolver.getCore();
-        const args = asRecord(input);
         switch (input.operation) {
           case "build_futures_ticker":
             return resultString(
               resolver,
               name,
-              core.ext.buildFuturesTicker(
-                requireString(name, args, "prefix"),
-                requireString(name, args, "monthCode"),
-                requireYearString(name, args, "year"),
-                requireString(name, args, "asset")
-              )
+              core.ext.buildFuturesTicker(input.prefix, input.monthCode, input.year, input.asset)
             );
           case "generate_candidates":
             return resultString(
               resolver,
               name,
               core.ext.generateFuturesCandidates(
-                requireString(name, args, "genTicker"),
-                requireInteger(name, args, "year"),
-                requireInteger(name, args, "month"),
-                requireInteger(name, args, "day"),
+                input.genTicker,
+                input.year,
+                input.month,
+                input.day,
                 input.freq,
                 input.count
               )
             );
           case "contract_index":
-            return resultString(
-              resolver,
-              name,
-              core.ext.contractIndex(requireString(name, args, "genTicker"))
-            );
+            return resultString(resolver, name, core.ext.contractIndex(input.genTicker));
           case "filter_candidates_by_cycle":
-            if (input.candidates === void 0) {
-              throw new TypeError(`${name}: candidates is required`);
-            }
             return resultString(
               resolver,
               name,
-              core.ext.filterCandidatesByCycle(
-                input.candidates,
-                requireString(name, args, "cycle")
-              )
+              core.ext.filterCandidatesByCycle(input.candidates, input.cycle)
             );
           case "filter_valid_contracts":
-            if (input.contracts === void 0) {
-              throw new TypeError(`${name}: contracts is required`);
-            }
             return resultString(
               resolver,
               name,
-              core.ext.filterValidContracts(
-                input.contracts,
-                requireInteger(name, args, "year"),
-                requireInteger(name, args, "month"),
-                requireInteger(name, args, "day")
-              )
+              core.ext.filterValidContracts(input.contracts, input.year, input.month, input.day)
             );
           case "get_futures_months":
             return resultString(resolver, name, core.ext.getFuturesMonths());
@@ -798,42 +913,32 @@ function extFuturesWithResolver(resolver) {
 }
 function extCdxWithResolver(resolver) {
   const name = "xbbg_ext_cdx";
-  return tools.tool(
-    async (input) => {
+  return createBloombergStructuredTool(
+    async (input, config) => {
       try {
-        const args = asRecord(input);
+        config?.signal?.throwIfAborted();
         if (input.operation === "cdx_info" || input.operation === "cdx_pricing" || input.operation === "cdx_risk") {
           const engine = await resolver.getEngine();
-          const ticker = requireString(name, args, "ticker");
           const fields = input.operation === "cdx_info" ? CDX_INFO_FIELDS : input.operation === "cdx_pricing" ? CDX_PRICING_FIELDS : CDX_RISK_FIELDS;
-          const result = await engine.bdp([ticker], fields, {
+          const result = await engine.bdp([input.ticker], fields, {
             backend: "json",
-            overrides: recoveryOverrides(input.recoveryRate)
+            overrides: recoveryOverrides(
+              input.operation === "cdx_pricing" || input.operation === "cdx_risk" ? input.recoveryRate : void 0
+            )
           });
           return resultString(resolver, name, result);
         }
         const core = await resolver.getCore();
         switch (input.operation) {
           case "parse_cdx_ticker":
-            return resultString(
-              resolver,
-              name,
-              core.ext.parseCdxTicker(requireString(name, args, "ticker"))
-            );
+            return resultString(resolver, name, core.ext.parseCdxTicker(input.ticker));
           case "previous_cdx_series":
-            return resultString(
-              resolver,
-              name,
-              core.ext.previousCdxSeries(requireString(name, args, "ticker"))
-            );
+            return resultString(resolver, name, core.ext.previousCdxSeries(input.ticker));
           case "cdx_gen_to_specific":
             return resultString(
               resolver,
               name,
-              core.ext.cdxGenToSpecific(
-                requireString(name, args, "genTicker"),
-                requireInteger(name, args, "series")
-              )
+              core.ext.cdxGenToSpecific(input.genTicker, input.series)
             );
         }
       } catch (error) {
@@ -850,38 +955,20 @@ function extCdxWithResolver(resolver) {
 }
 function extCurrencyWithResolver(resolver) {
   const name = "xbbg_ext_currency";
-  return tools.tool(
+  return createBloombergStructuredTool(
     async (input) => {
       try {
         const core = await resolver.getCore();
-        const args = asRecord(input);
         switch (input.operation) {
           case "build_fx_pair":
-            return resultString(
-              resolver,
-              name,
-              core.ext.buildFxPair(
-                requireString(name, args, "fromCcy"),
-                requireString(name, args, "toCcy")
-              )
-            );
+            return resultString(resolver, name, core.ext.buildFxPair(input.fromCcy, input.toCcy));
           case "same_currency":
-            return resultString(
-              resolver,
-              name,
-              core.ext.sameCurrency(
-                requireString(name, args, "ccy1"),
-                requireString(name, args, "ccy2")
-              )
-            );
+            return resultString(resolver, name, core.ext.sameCurrency(input.ccy1, input.ccy2));
           case "currencies_needing_conversion":
             return resultString(
               resolver,
               name,
-              core.ext.currenciesNeedingConversion(
-                requireStringArray(name, args, "currencies"),
-                requireString(name, args, "target")
-              )
+              core.ext.currenciesNeedingConversion(input.currencies, input.target)
             );
         }
       } catch (error) {
@@ -898,27 +985,23 @@ 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();
-        const args = asRecord(input);
         switch (input.operation) {
           case "build_preferreds_query":
             return resultString(
               resolver,
               name,
-              core.ext.buildPreferredsQuery(
-                requireString(name, args, "equityTicker"),
-                input.extraFields
-              )
+              core.ext.buildPreferredsQuery(input.equityTicker, input.extraFields)
             );
           case "build_corporate_bonds_query":
             return resultString(
               resolver,
               name,
               core.ext.buildCorporateBondsQuery(
-                requireString(name, args, "ticker"),
+                input.ticker,
                 input.ccy,
                 input.extraFields,
                 input.activeOnly
@@ -928,10 +1011,7 @@ function extBqlBuilderWithResolver(resolver) {
             return resultString(
               resolver,
               name,
-              core.ext.buildEtfHoldingsQuery(
-                requireString(name, args, "etfTicker"),
-                input.extraFields
-              )
+              core.ext.buildEtfHoldingsQuery(input.etfTicker, input.extraFields)
             );
         }
       } catch (error) {
@@ -948,40 +1028,30 @@ 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();
-        const args = asRecord(input);
         switch (input.operation) {
           case "derive_sessions":
             return resultString(
               resolver,
               name,
-              core.ext.deriveSessions(
-                requireString(name, args, "dayStart"),
-                requireString(name, args, "dayEnd"),
-                input.mic,
-                input.exchCode
-              )
+              core.ext.deriveSessions(input.dayStart, input.dayEnd, input.mic, input.exchCode)
             );
           case "get_market_rule":
             return resultString(resolver, name, core.ext.getMarketRule(input.mic, input.exchCode));
           case "infer_timezone":
-            return resultString(
-              resolver,
-              name,
-              core.ext.inferTimezone(requireString(name, args, "countryIso"))
-            );
+            return resultString(resolver, name, core.ext.inferTimezone(input.countryIso));
           case "session_times_to_utc":
             return resultString(
               resolver,
               name,
               core.ext.sessionTimesToUtc(
-                requireString(name, args, "startTime"),
-                requireString(name, args, "endTime"),
-                requireString(name, args, "exchangeTz"),
-                requireString(name, args, "date")
+                input.startTime,
+                input.endTime,
+                input.exchangeTz,
+                input.date
               )
             );
           case "default_turnover_dates":
@@ -997,11 +1067,7 @@ function extMarketSessionWithResolver(resolver) {
               core.ext.defaultBqrDatetimes(input.startDatetime, input.endDatetime)
             );
           case "get_exchange_override":
-            return resultString(
-              resolver,
-              name,
-              core.ext.getExchangeOverride(requireString(name, args, "ticker"))
-            );
+            return resultString(resolver, name, core.ext.getExchangeOverride(input.ticker));
           case "list_exchange_overrides":
             return resultString(resolver, name, core.ext.listExchangeOverrides());
         }
@@ -1019,7 +1085,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,49 +1115,27 @@ function extYasOverridesWithResolver(resolver) {
 }
 function extConstantsWithResolver(resolver) {
   const name = "xbbg_ext_constants";
-  return tools.tool(
+  return createBloombergStructuredTool(
     async (input) => {
       try {
         const core = await resolver.getCore();
-        const args = asRecord(input);
         switch (input.operation) {
           case "parse_date":
-            return resultString(
-              resolver,
-              name,
-              core.ext.parseDate(requireString(name, args, "dateStr"))
-            );
+            return resultString(resolver, name, core.ext.parseDate(input.dateStr));
           case "fmt_date":
             return resultString(
               resolver,
               name,
-              core.ext.fmtDate(
-                requireInteger(name, args, "year"),
-                requireInteger(name, args, "month"),
-                requireInteger(name, args, "day"),
-                input.fmt
-              )
+              core.ext.fmtDate(input.year, input.month, input.day, input.fmt)
             );
           case "get_month_code":
-            return resultString(
-              resolver,
-              name,
-              core.ext.getMonthCode(requireString(name, args, "monthName"))
-            );
+            return resultString(resolver, name, core.ext.getMonthCode(input.monthName));
           case "get_month_name":
-            return resultString(
-              resolver,
-              name,
-              core.ext.getMonthName(requireString(name, args, "code"))
-            );
+            return resultString(resolver, name, core.ext.getMonthName(input.code));
           case "get_futures_months":
             return resultString(resolver, name, core.ext.getFuturesMonths());
           case "get_dvd_type":
-            return resultString(
-              resolver,
-              name,
-              core.ext.getDvdType(requireString(name, args, "dvdType"))
-            );
+            return resultString(resolver, name, core.ext.getDvdType(input.dvdType));
           case "get_dvd_types":
             return resultString(resolver, name, core.ext.getDvdTypes());
           case "get_dvd_cols":
@@ -1113,35 +1157,20 @@ function extConstantsWithResolver(resolver) {
 }
 function extColumnsWithResolver(resolver) {
   const name = "xbbg_ext_columns";
-  return tools.tool(
+  return createBloombergStructuredTool(
     async (input) => {
       try {
         const core = await resolver.getCore();
-        const args = asRecord(input);
         switch (input.operation) {
           case "rename_dividend_columns":
-            return resultString(
-              resolver,
-              name,
-              core.ext.renameDividendColumns(requireStringArray(name, args, "columns"))
-            );
+            return resultString(resolver, name, core.ext.renameDividendColumns(input.columns));
           case "rename_etf_columns":
-            return resultString(
-              resolver,
-              name,
-              core.ext.renameEtfColumns(requireStringArray(name, args, "columns"))
-            );
+            return resultString(resolver, name, core.ext.renameEtfColumns(input.columns));
           case "build_earning_header_rename":
-            if (input.headerRow === void 0) {
-              throw new TypeError(`${name}: headerRow is required`);
-            }
             return resultString(
               resolver,
               name,
-              core.ext.buildEarningHeaderRename(
-                input.headerRow,
-                requireStringArray(name, args, "dataColumns")
-              )
+              core.ext.buildEarningHeaderRename(input.headerRow, input.dataColumns)
             );
         }
       } catch (error) {
@@ -1158,12 +1187,9 @@ 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) {
-          throw new TypeError(`${name}: values and levels must have the same length`);
-        }
         const core = await resolver.getCore();
         return resultString(
           resolver,
@@ -1231,11 +1257,14 @@ 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 MIN_NUMERIC_BBG_DATE = 19000101;
+var MAX_NUMERIC_BBG_DATE = 29991231;
+var MIN_EPOCH_MS = 1e11;
+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}`;
@@ -1246,18 +1275,30 @@ function dateFromParts(year, month, day) {
   return formatted;
 }
 function dateToBbg(value) {
-  const date2 = value instanceof Date ? value : new Date(value);
-  if (Number.isNaN(date2.getTime())) {
+  const date = value instanceof Date ? value : new Date(value);
+  if (Number.isNaN(date.getTime())) {
     throw new TypeError("Invalid date value; expected YYYY-MM-DD, YYYYMMDD, Date, or epoch ms");
   }
-  const year = String(date2.getUTCFullYear()).padStart(4, "0");
-  const month = String(date2.getUTCMonth() + 1).padStart(2, "0");
-  const day = String(date2.getUTCDate()).padStart(2, "0");
+  const year = String(date.getUTCFullYear()).padStart(4, "0");
+  const month = String(date.getUTCMonth() + 1).padStart(2, "0");
+  const day = String(date.getUTCDate()).padStart(2, "0");
   return `${year}${month}${day}`;
 }
+function numericDateToBbg(value, unit) {
+  if (Number.isFinite(value) && value >= MIN_EPOCH_MS) {
+    return new Date(value);
+  }
+  throw new TypeError(
+    `Ambiguous numeric ${unit} ${String(value)}; use "YYYY-MM-DD" text or epoch milliseconds`
+  );
+}
 function normalizeDate(value) {
-  if (value instanceof Date || typeof value === "number") {
-    return dateToBbg(value);
+  if (typeof value === "number") {
+    if (Number.isInteger(value) && value >= MIN_NUMERIC_BBG_DATE && value <= MAX_NUMERIC_BBG_DATE) {
+      const text2 = String(value);
+      return dateFromParts(text2.slice(0, 4), text2.slice(4, 6), text2.slice(6, 8));
+    }
+    return dateToBbg(numericDateToBbg(value, "date"));
   }
   const text = value.trim();
   if (text.length === 0) {
@@ -1275,12 +1316,13 @@ function normalizeDate(value) {
   throw new TypeError(`Invalid date ${JSON.stringify(text)}; use YYYY-MM-DD or YYYYMMDD`);
 }
 function normalizeDateTime(value) {
-  if (value instanceof Date || typeof value === "number") {
-    const date2 = value instanceof Date ? value : new Date(value);
-    if (Number.isNaN(date2.getTime())) {
-      throw new TypeError("Invalid datetime value; expected ISO 8601 datetime, Date, or epoch ms");
+  if (typeof value === "number") {
+    if (Number.isInteger(value) && value >= MIN_NUMERIC_BBG_DATE && value <= MAX_NUMERIC_BBG_DATE) {
+      throw new TypeError(
+        `Invalid numeric datetime ${String(value)}; include an explicit time component such as "2024-01-02T09:30:00"`
+      );
     }
-    return date2.toISOString();
+    return numericDateToBbg(value, "datetime").toISOString();
   }
   const text = value.trim();
   if (text.length === 0) {
@@ -1289,27 +1331,36 @@ 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 normalizationIssue(context, tool2, field, error) {
+  context.addIssue({
+    code: "custom",
+    message: `${tool2}: ${field}: ${error instanceof Error ? error.message : String(error)}`
+  });
+  return z__namespace.NEVER;
 }
-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, context) => {
     if (value === void 0) {
       return void 0;
     }
@@ -1317,169 +1368,203 @@ 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`);
+        return normalizationIssue(context, tool2, field, new TypeError("contains an empty key"));
       }
       if (typeof entry === "string" && entry.length === 0) {
-        throw new TypeError(`${tool3}: ${field}.${normalizedKey} must not be an empty string`);
+        return normalizationIssue(
+          context,
+          tool2,
+          field,
+          new TypeError(`${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.number()]).transform((value, context) => {
+    try {
+      return normalizeDate(value);
+    } catch (error) {
+      return normalizationIssue(context, tool2, field, error);
+    }
+  }).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.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, context) => {
+    try {
+      return normalizeDateTime(value);
+    } catch (error) {
+      return normalizationIssue(context, tool2, field, error);
+    }
+  }).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.'
+      "Securities exactly as the user supplied them: '<TICKER> <MARKET_SECTOR>' for Bloomberg tickers, '/isin/<ISIN>' for raw ISINs, '/cusip/<CUSIP>' for raw CUSIPs. Never invent, guess, or convert identifiers into 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.'
+      "Securities exactly as the user supplied them: '<TICKER> <MARKET_SECTOR>' for Bloomberg tickers, '/isin/<ISIN>' for raw ISINs, '/cusip/<CUSIP>' for raw CUSIPs. Never invent, guess, or convert identifiers into tickers."
     ),
-    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(
+    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.'
+      "Securities exactly as the user supplied them: '<TICKER> <MARKET_SECTOR>' for Bloomberg tickers, '/isin/<ISIN>' for raw ISINs, '/cusip/<CUSIP>' for raw CUSIPs. Never invent, guess, or convert identifiers into 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 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 security exactly as the user supplied it: '<TICKER> <MARKET_SECTOR>', '/isin/<ISIN>', or '/cusip/<CUSIP>'. Never invent, guess, or convert identifiers into tickers."
     )
   });
 }
 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 +1572,96 @@ 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 security exactly as the user supplied it: '<TICKER> <MARKET_SECTOR>', '/isin/<ISIN>', or '/cusip/<CUSIP>'. Never invent, guess, or convert identifiers into tickers."
     )
   });
 }
 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({
+    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({
+    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(
+    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 +1670,213 @@ 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."),
+    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"]'
+      '["/isin/<ISIN> <MARKET_SECTOR>"]'
     ).describe(
-      'Fully qualified fixed-income Bloomberg securities, for example ["/isin/US037833FB15 Corp"].'
+      "Fixed-income securities exactly as the user supplied them: '<TICKER> <MARKET_SECTOR>' or identifier syntax such as '/isin/<ISIN> <MARKET_SECTOR>'. Never invent or guess tickers."
     ),
-    yieldType: z2__namespace.number().int().optional().describe("Optional YAS yield type."),
-    yieldVal: z2__namespace.number().optional().describe("Optional YAS yield value input.")
+    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(
+      "The issuer's common equity ticker as '<TICKER> <MARKET_SECTOR>', never a preferred ('Pfd') ticker and never a guessed one. Resolve a supplied ISIN/CUSIP with xbbg_resolve_isins first."
+    ),
+    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(
+      "The issuer/company equity ticker as '<TICKER> <MARKET_SECTOR>' supplied by the user. Resolve a supplied ISIN/CUSIP with xbbg_resolve_isins first; never guess tickers."
     )
   });
 }
 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 Bloomberg index ticker as '<INDEX_TICKER> <MARKET_SECTOR>' supplied by the user; never guess index tickers."
     )
   });
 }
 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."
+  const tool2 = "xbbg_etf_holdings";
+  return z__namespace.object({
+    etfTicker: nonEmptyString2(
+      tool2,
+      "etfTicker",
+      options.maxStringChars,
+      "<ETF_TICKER> <MARKET_SECTOR>"
+    ).describe(
+      "One Bloomberg ETF ticker as '<ETF_TICKER> <MARKET_SECTOR>' supplied by the user. Resolve a supplied ISIN/CUSIP with xbbg_resolve_isins first; never guess tickers."
     ),
-    fields: stringArray2(tool3, "fields", options.maxFields, options.maxStringChars, '["id"]').optional().describe("Optional fields to include in the ETF holdings recipe result.")
+    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(
-      "Pass drain=true to unsubscribe. Defaults to false; collected output remains bounded."
+    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(
+      "Flush buffered backlog while closing the subscription. The subscription always closes; collected output stays bounded either way. Defaults to false."
     ),
-    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(
+      "Securities to observe, exactly as the user supplied them: '<TICKER> <MARKET_SECTOR>', '/isin/<ISIN>', or '/cusip/<CUSIP>'. Never invent or guess tickers."
+    ),
+    ...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."
+  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 security to observe, exactly as the user supplied it: '<TICKER> <MARKET_SECTOR>', '/isin/<ISIN>', or '/cusip/<CUSIP>'. Never invent or guess tickers."
     ),
-    ...snapshotControlFields(tool3, options)
+    ...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."
+  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 security to observe, exactly as the user supplied it: '<TICKER> <MARKET_SECTOR>', '/isin/<ISIN>', or '/cusip/<CUSIP>'. Never invent or guess tickers."
     ),
-    ...snapshotControlFields(tool3, options)
+    ...snapshotControlFields(tool2, options)
   });
 }
 
@@ -1773,17 +1885,24 @@ function resultString2(resolver, name, value) {
   return createToolResult(name, value, resolver.options.maxRows, resolver.options.maxStringChars);
 }
 var STREAM_TIMEOUT = /* @__PURE__ */ Symbol("stream_timeout");
+var STREAM_ABORTED = /* @__PURE__ */ Symbol("stream_aborted");
+function abortError(signal) {
+  const reason = signal?.reason;
+  return reason instanceof Error ? reason : new Error("Tool call aborted");
+}
 function streamOptions(input) {
   return {
     allFields: input.allFields,
     conflate: input.conflate,
-    fields: input.fields,
     flushThreshold: input.flushThreshold,
     options: input.options,
     overflowPolicy: input.overflowPolicy,
     streamCapacity: input.streamCapacity
   };
 }
+function singleTickerStreamOptions(input) {
+  return { ...streamOptions(input), fields: input.fields };
+}
 function isRecord(value) {
   return typeof value === "object" && value !== null;
 }
@@ -1839,42 +1958,55 @@ function normalizeStreamUpdate(value) {
   const rows = rowsFromArrowTable(value);
   return rows === void 0 ? jsonCompatible(value) : rows.map(jsonCompatible);
 }
-async function nextWithinTimeout(iterator, deadlineMs) {
+async function nextWithinTimeout(iterator, deadlineMs, signal) {
+  if (signal?.aborted === true) {
+    return STREAM_ABORTED;
+  }
   const remainingMs = deadlineMs - Date.now();
   if (remainingMs <= 0) {
     return STREAM_TIMEOUT;
   }
   const nextPromise = iterator.next();
   let timer;
-  const timeoutPromise = new Promise((resolve) => {
-    timer = setTimeout(() => resolve(STREAM_TIMEOUT), remainingMs);
-  });
-  const result = await Promise.race([nextPromise, timeoutPromise]);
+  let onAbort;
+  const racers = [
+    nextPromise,
+    new Promise((resolve) => {
+      timer = setTimeout(() => resolve(STREAM_TIMEOUT), remainingMs);
+    })
+  ];
+  if (signal !== void 0) {
+    racers.push(
+      new Promise((resolve) => {
+        onAbort = () => resolve(STREAM_ABORTED);
+        signal.addEventListener("abort", onAbort, { once: true });
+      })
+    );
+  }
+  const result = await Promise.race(racers);
   if (timer !== void 0) {
     clearTimeout(timer);
   }
-  if (result === STREAM_TIMEOUT) {
+  if (signal !== void 0 && onAbort !== void 0) {
+    signal.removeEventListener("abort", onAbort);
+  }
+  if (result === STREAM_TIMEOUT || result === STREAM_ABORTED) {
     void nextPromise.catch(() => void 0);
   }
   return result;
 }
-async function unsubscribeSnapshot(subscription, drain, priorError) {
-  try {
-    await subscription.unsubscribe(drain);
-  } catch (error) {
-    if (priorError === void 0) {
-      throw error;
-    }
-  }
-}
-async function collectSnapshot(subscription, input) {
+async function collectSnapshot(subscription, input, signal) {
   const updates = [];
   const deadlineMs = Date.now() + input.timeoutMs;
   let reason = "max_updates";
+  let failed = false;
   let caught;
   try {
     while (updates.length < input.maxUpdates) {
-      const next = await nextWithinTimeout(subscription, deadlineMs);
+      const next = await nextWithinTimeout(subscription, deadlineMs, signal);
+      if (next === STREAM_ABORTED) {
+        throw abortError(signal);
+      }
       if (next === STREAM_TIMEOUT) {
         reason = "timeout";
         break;
@@ -1885,29 +2017,37 @@ async function collectSnapshot(subscription, input) {
       }
       updates.push(normalizeStreamUpdate(next.value));
     }
-    return {
-      maxUpdates: input.maxUpdates,
-      reason,
-      timeoutMs: input.timeoutMs,
-      updateCount: updates.length,
-      updates
-    };
   } catch (error) {
+    failed = true;
     caught = error;
-    throw error;
-  } finally {
-    await unsubscribeSnapshot(subscription, input.drain === true, caught);
   }
+  const drain = input.drain === true && signal?.aborted !== true;
+  let unsubscribeError;
+  try {
+    await subscription.unsubscribe(drain);
+  } catch (error) {
+    if (!failed) {
+      unsubscribeError = error instanceof Error ? error.message : String(error);
+    }
+  }
+  if (failed) {
+    throw caught;
+  }
+  return {
+    maxUpdates: input.maxUpdates,
+    reason,
+    timeoutMs: input.timeoutMs,
+    updateCount: updates.length,
+    updates,
+    ...unsubscribeError === void 0 ? {} : { unsubscribeError }
+  };
 }
 function validationSetting(resolver, value) {
   return value ?? resolver.options.validateFields;
 }
-function enabledTool(resolver, name, creator) {
-  return isToolDisabled(resolver.options, name) ? [] : [creator(resolver)];
-}
 function bdpWithResolver(resolver) {
   const name = "xbbg_bdp";
-  return tools.tool(
+  return createBloombergStructuredTool(
     async (input) => {
       try {
         const engine = await resolver.getEngine();
@@ -1934,7 +2074,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,13 +2102,12 @@ function bdhWithResolver(resolver) {
 }
 function bdsWithResolver(resolver) {
   const name = "xbbg_bds";
-  return tools.tool(
+  return createBloombergStructuredTool(
     async (input) => {
       try {
         const engine = await resolver.getEngine();
         const result = await engine.bds(input.securities, [input.field], {
           backend: "json",
-          format: input.format,
           kwargs: input.kwargs,
           overrides: input.overrides,
           validateFields: validationSetting(resolver, input.validateFields)
@@ -1988,7 +2127,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 +2156,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,13 +2191,12 @@ function bdtickWithResolver(resolver) {
 }
 function bqlWithResolver(resolver) {
   const name = "xbbg_bql";
-  return tools.tool(
+  return createBloombergStructuredTool(
     async (input) => {
       try {
         const engine = await resolver.getEngine();
         const result = await engine.bql(input.query, {
           backend: "json",
-          format: input.format,
           kwargs: input.kwargs
         });
         return resultString2(resolver, name, result);
@@ -2076,13 +2214,12 @@ function bqlWithResolver(resolver) {
 }
 function bsrchWithResolver(resolver) {
   const name = "xbbg_bsrch";
-  return tools.tool(
+  return createBloombergStructuredTool(
     async (input) => {
       try {
         const engine = await resolver.getEngine();
         const result = await engine.bsrch(input.searchSpec, {
           backend: "json",
-          format: input.format,
           kwargs: input.kwargs,
           overrides: input.overrides
         });
@@ -2101,7 +2238,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,14 +2264,13 @@ function bqrWithResolver(resolver) {
 }
 function bfldsWithResolver(resolver) {
   const name = "xbbg_bflds";
-  return tools.tool(
+  return createBloombergStructuredTool(
     async (input) => {
       try {
         const engine = await resolver.getEngine();
         const result = await engine.bflds({
           backend: "json",
           fields: input.fields,
-          format: input.format,
           kwargs: input.kwargs,
           searchSpec: input.searchSpec
         });
@@ -2153,14 +2289,13 @@ function bfldsWithResolver(resolver) {
 }
 function beqsWithResolver(resolver) {
   const name = "xbbg_beqs";
-  return tools.tool(
+  return createBloombergStructuredTool(
     async (input) => {
       try {
         const engine = await resolver.getEngine();
         const result = await engine.beqs(input.screen, {
           asof: input.asof,
           backend: "json",
-          format: input.format,
           group: input.group,
           kwargs: input.kwargs,
           overrides: input.overrides,
@@ -2181,7 +2316,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 +2344,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 +2367,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 +2392,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 +2416,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 +2436,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 +2456,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,12 +2479,14 @@ function etfHoldingsWithResolver(resolver) {
 }
 function streamSnapshotWithResolver(resolver) {
   const name = "xbbg_stream_snapshot";
-  return tools.tool(
-    async (input) => {
+  return createBloombergStructuredTool(
+    async (input, config) => {
+      const signal = config?.signal;
       try {
         const engine = await resolver.getEngine();
+        signal?.throwIfAborted();
         const subscription = await engine.stream(input.tickers, input.fields, streamOptions(input));
-        const result = await collectSnapshot(subscription, input);
+        const result = await collectSnapshot(subscription, input, signal);
         return resultString2(resolver, name, result);
       } catch (error) {
         throwWithToolContext(name, error);
@@ -2365,12 +2502,14 @@ function streamSnapshotWithResolver(resolver) {
 }
 function mktbarSnapshotWithResolver(resolver) {
   const name = "xbbg_mktbar_snapshot";
-  return tools.tool(
-    async (input) => {
+  return createBloombergStructuredTool(
+    async (input, config) => {
+      const signal = config?.signal;
       try {
         const engine = await resolver.getEngine();
-        const subscription = await engine.mktbar(input.ticker, streamOptions(input));
-        const result = await collectSnapshot(subscription, input);
+        signal?.throwIfAborted();
+        const subscription = await engine.mktbar(input.ticker, singleTickerStreamOptions(input));
+        const result = await collectSnapshot(subscription, input, signal);
         return resultString2(resolver, name, result);
       } catch (error) {
         throwWithToolContext(name, error);
@@ -2386,12 +2525,14 @@ function mktbarSnapshotWithResolver(resolver) {
 }
 function depthSnapshotWithResolver(resolver) {
   const name = "xbbg_depth_snapshot";
-  return tools.tool(
-    async (input) => {
+  return createBloombergStructuredTool(
+    async (input, config) => {
+      const signal = config?.signal;
       try {
         const engine = await resolver.getEngine();
-        const subscription = await engine.depth(input.ticker, streamOptions(input));
-        const result = await collectSnapshot(subscription, input);
+        signal?.throwIfAborted();
+        const subscription = await engine.depth(input.ticker, singleTickerStreamOptions(input));
+        const result = await collectSnapshot(subscription, input, signal);
         return resultString2(resolver, name, result);
       } catch (error) {
         throwWithToolContext(name, error);
@@ -2465,29 +2606,32 @@ function createMktbarSnapshotTool(options = {}) {
 function createDepthSnapshotTool(options = {}) {
   return depthSnapshotWithResolver(createCoreResolver(options));
 }
+var CORE_TOOL_DEFINITIONS = Object.freeze([
+  { create: bdpWithResolver, name: "xbbg_bdp" },
+  { create: bdhWithResolver, name: "xbbg_bdh" },
+  { create: bdsWithResolver, name: "xbbg_bds" },
+  { create: bdibWithResolver, name: "xbbg_bdib" },
+  { create: bdtickWithResolver, name: "xbbg_bdtick" },
+  { create: bqlWithResolver, name: "xbbg_bql" },
+  { create: bsrchWithResolver, name: "xbbg_bsrch" },
+  { create: bqrWithResolver, name: "xbbg_bqr" },
+  { create: bfldsWithResolver, name: "xbbg_bflds" },
+  { create: beqsWithResolver, name: "xbbg_beqs" },
+  { create: yasWithResolver, name: "xbbg_yas" },
+  { create: preferredsWithResolver, name: "xbbg_preferreds" },
+  { create: corporateBondsWithResolver, name: "xbbg_corporate_bonds" },
+  { create: indexMembersWithResolver, name: "xbbg_index_members" },
+  { create: resolveIsinsWithResolver, name: "xbbg_resolve_isins" },
+  { create: issuerIsinsWithResolver, name: "xbbg_issuer_isins" },
+  { create: etfHoldingsWithResolver, name: "xbbg_etf_holdings" },
+  { create: streamSnapshotWithResolver, name: "xbbg_stream_snapshot" },
+  { create: mktbarSnapshotWithResolver, name: "xbbg_mktbar_snapshot" },
+  { create: depthSnapshotWithResolver, name: "xbbg_depth_snapshot" }
+]);
 function createBloombergToolsForResolver(resolver) {
-  return [
-    ...enabledTool(resolver, "xbbg_bdp", bdpWithResolver),
-    ...enabledTool(resolver, "xbbg_bdh", bdhWithResolver),
-    ...enabledTool(resolver, "xbbg_bds", bdsWithResolver),
-    ...enabledTool(resolver, "xbbg_bdib", bdibWithResolver),
-    ...enabledTool(resolver, "xbbg_bdtick", bdtickWithResolver),
-    ...enabledTool(resolver, "xbbg_bql", bqlWithResolver),
-    ...enabledTool(resolver, "xbbg_bsrch", bsrchWithResolver),
-    ...enabledTool(resolver, "xbbg_bqr", bqrWithResolver),
-    ...enabledTool(resolver, "xbbg_bflds", bfldsWithResolver),
-    ...enabledTool(resolver, "xbbg_beqs", beqsWithResolver),
-    ...enabledTool(resolver, "xbbg_yas", yasWithResolver),
-    ...enabledTool(resolver, "xbbg_preferreds", preferredsWithResolver),
-    ...enabledTool(resolver, "xbbg_corporate_bonds", corporateBondsWithResolver),
-    ...enabledTool(resolver, "xbbg_index_members", indexMembersWithResolver),
-    ...enabledTool(resolver, "xbbg_resolve_isins", resolveIsinsWithResolver),
-    ...enabledTool(resolver, "xbbg_issuer_isins", issuerIsinsWithResolver),
-    ...enabledTool(resolver, "xbbg_etf_holdings", etfHoldingsWithResolver),
-    ...enabledTool(resolver, "xbbg_stream_snapshot", streamSnapshotWithResolver),
-    ...enabledTool(resolver, "xbbg_mktbar_snapshot", mktbarSnapshotWithResolver),
-    ...enabledTool(resolver, "xbbg_depth_snapshot", depthSnapshotWithResolver)
-  ];
+  return CORE_TOOL_DEFINITIONS.filter(
+    (definition) => !isToolDisabled(resolver.options, definition.name)
+  ).map((definition) => definition.create(resolver));
 }
 function createBloombergTools(options = {}) {
   return createBloombergToolsForResolver(createCoreResolver(options));
@@ -2505,6 +2649,7 @@ function createAllBloombergTools(options = {}) {
 exports.BLOOMBERG_EXT_TOOL_NAMES = BLOOMBERG_EXT_TOOL_NAMES;
 exports.BLOOMBERG_TOOL_INSTRUCTIONS = BLOOMBERG_TOOL_INSTRUCTIONS;
 exports.BLOOMBERG_TOOL_NAMES = BLOOMBERG_TOOL_NAMES;
+exports.DEFAULT_ENGINE_REQUEST_TIMEOUT_MS = DEFAULT_ENGINE_REQUEST_TIMEOUT_MS;
 exports.createAllBloombergTools = createAllBloombergTools;
 exports.createBdhTool = createBdhTool;
 exports.createBdibTool = createBdibTool;
@@ -2539,5 +2684,6 @@ exports.createResolveIsinsTool = createResolveIsinsTool;
 exports.createStreamSnapshotTool = createStreamSnapshotTool;
 exports.createYasTool = createYasTool;
 exports.getBloombergToolInstructions = getBloombergToolInstructions;
+exports.toolParameterJsonSchema = toolParameterJsonSchema;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map