@xbbg/langgraph 1.2.6

package/dist/index.js

@@ -0,0 +1,2543 @@
+'use strict';
+
+var tools = require('@langchain/core/tools');
+var z2 = require('zod');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var z2__namespace = /*#__PURE__*/_interopNamespace(z2);
+
+// src/options.ts
+var BLOOMBERG_TOOL_NAMES = [
+  "xbbg_bdp",
+  "xbbg_bdh",
+  "xbbg_bds",
+  "xbbg_bdib",
+  "xbbg_bdtick",
+  "xbbg_bql",
+  "xbbg_bsrch",
+  "xbbg_bqr",
+  "xbbg_bflds",
+  "xbbg_beqs",
+  "xbbg_yas",
+  "xbbg_preferreds",
+  "xbbg_corporate_bonds",
+  "xbbg_index_members",
+  "xbbg_resolve_isins",
+  "xbbg_issuer_isins",
+  "xbbg_etf_holdings",
+  "xbbg_stream_snapshot",
+  "xbbg_mktbar_snapshot",
+  "xbbg_depth_snapshot",
+  "xbbg_ext_ticker",
+  "xbbg_ext_futures",
+  "xbbg_ext_cdx",
+  "xbbg_ext_currency",
+  "xbbg_ext_bql_builder",
+  "xbbg_ext_market_session",
+  "xbbg_ext_yas_overrides",
+  "xbbg_ext_constants",
+  "xbbg_ext_columns",
+  "xbbg_ext_calculate"
+];
+var DEFAULT_MAX_SECURITIES = 25;
+var DEFAULT_MAX_FIELDS = 25;
+var DEFAULT_MAX_ROWS = 500;
+var DEFAULT_MAX_STRING_CHARS = 2e3;
+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;
+function positiveInteger(value, fallback, name) {
+  if (value === void 0) {
+    return fallback;
+  }
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new RangeError(`${name} must be a positive integer; got ${String(value)}`);
+  }
+  return value;
+}
+function disabledToolSet(tools) {
+  return new Set(tools ?? []);
+}
+function normalizeBloombergToolsOptions(options = {}) {
+  return {
+    core: options.core,
+    disabledTools: disabledToolSet(options.disabledTools),
+    engine: options.engine,
+    engineConfig: options.engineConfig,
+    maxBqlQueryChars: positiveInteger(
+      options.maxBqlQueryChars,
+      DEFAULT_MAX_BQL_QUERY_CHARS,
+      "maxBqlQueryChars"
+    ),
+    maxFields: positiveInteger(options.maxFields, DEFAULT_MAX_FIELDS, "maxFields"),
+    maxRows: positiveInteger(options.maxRows, DEFAULT_MAX_ROWS, "maxRows"),
+    maxSearchSpecChars: positiveInteger(
+      options.maxSearchSpecChars,
+      DEFAULT_MAX_SEARCH_SPEC_CHARS,
+      "maxSearchSpecChars"
+    ),
+    maxStreamUpdates: positiveInteger(
+      options.maxStreamUpdates,
+      DEFAULT_MAX_STREAM_UPDATES,
+      "maxStreamUpdates"
+    ),
+    maxStreamWaitMs: positiveInteger(
+      options.maxStreamWaitMs,
+      DEFAULT_MAX_STREAM_WAIT_MS,
+      "maxStreamWaitMs"
+    ),
+    maxSecurities: positiveInteger(options.maxSecurities, DEFAULT_MAX_SECURITIES, "maxSecurities"),
+    maxStringChars: positiveInteger(
+      options.maxStringChars,
+      DEFAULT_MAX_STRING_CHARS,
+      "maxStringChars"
+    ),
+    validateFields: options.validateFields
+  };
+}
+function isToolDisabled(options, name) {
+  return options.disabledTools.has(name);
+}
+
+// src/core-loader.ts
+async function importCore() {
+  return await import('@xbbg/core');
+}
+function createCoreResolver(options = {}) {
+  const normalized = normalizeBloombergToolsOptions(options);
+  let corePromise;
+  let enginePromise;
+  async function getCore() {
+    if (normalized.core !== void 0) {
+      return normalized.core;
+    }
+    corePromise ??= importCore();
+    return await corePromise;
+  }
+  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 {
+    getCore,
+    getEngine,
+    options: normalized
+  };
+}
+
+// src/cdx-fields.ts
+var CDX_INFO_FIELDS = Object.freeze([
+  "ROLLING_SERIES",
+  "VERSION",
+  "ON_THE_RUN_CURRENT_BD_INDICATOR",
+  "CDS_FIRST_ACCRUAL_START_DATE",
+  "NAME",
+  "NUM_CURRENT_COMPANIES_CCY_TKR",
+  "NUM_ORIG_COMPANIES_CRNCY_TKR",
+  "PX_LAST"
+]);
+var CDX_PRICING_FIELDS = Object.freeze([
+  "PX_LAST",
+  "PX_BID",
+  "PX_ASK",
+  "UPFRONT_LAST",
+  "UPFRONT_BID",
+  "UPFRONT_ASK",
+  "CDS_FLAT_SPREAD",
+  "UPFRONT_FEE",
+  "PV_CDS_PREMIUM_LEG",
+  "PV_CDS_DEFAULT_LEG"
+]);
+var CDX_RISK_FIELDS = Object.freeze([
+  "SW_CNV_BPV",
+  "SW_EQV_BPV",
+  "CDS_SPREAD_MID_MODIFIED_DURATION",
+  "CDS_SPREAD_MID_CONVEXITY",
+  "RECOVERY_RATE_SEN",
+  "CDS_RECOVERY_RT"
+]);
+
+// src/descriptions.ts
+var REQUIRED_TOOL_INSTRUCTIONS = [
+  "# Bloomberg tool usage",
+  "- 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.",
+  "",
+  "## 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.",
+  "",
+  "## 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_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_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_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_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_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.",
+  "- xbbg_mktbar_snapshot: bounded live market-bar observation from //blp/mktbar for one ticker. Requires explicit maxUpdates and always terminates/unsubscribes.",
+  "- xbbg_depth_snapshot: bounded market-depth observation from //blp/mktdepthdata for one ticker. Requires explicit maxUpdates and always terminates/unsubscribes.",
+  "",
+  "## 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)).",
+  "- 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.",
+  "- 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_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.",
+  "- xbbg_ext_bql_builder: safe BQL generators for common xbbg workflows. Use build_preferreds_query for preferred-stock discovery from an equity, build_corporate_bonds_query for company bond universes with optional currency/active filters, and build_etf_holdings_query for ETF constituents. Prefer these builders over hand-writing those BQL shapes.",
+  "- xbbg_ext_market_session: exchange calendar/timezone support. derive_sessions turns day session times into session blocks, infer_timezone maps country codes to timezones, session_times_to_utc converts local sessions to UTC, get_market_rule gets MIC/exchange rules, default_turnover_dates and default_bqr_datetimes provide bounded defaults, and get/list_exchange_override inspect configured exchange metadata.",
+  "- xbbg_ext_yas_overrides: builds flat YAS override maps for fixed-income BDP requests when the lower-level BDP workflow is required. Prefer xbbg_yas for actual YAS recipe fields.",
+  "- xbbg_ext_constants: static lookup/format helpers for date parsing/formatting, futures month code/name mappings, dividend type mappings, and known dividend/ETF output columns.",
+  "- xbbg_ext_columns: post-processing helpers for Bloomberg-shaped tables. Use rename_dividend_columns, rename_etf_columns, or build_earning_header_rename when explaining or normalizing response column names after a request.",
+  "- xbbg_ext_calculate: small numeric helper for Bloomberg workflows. calculate_level_percentages pairs observed values with levels; values and levels must have the same length."
+];
+var OPTIONAL_LIMIT_INSTRUCTIONS = [
+  "",
+  "## Request limits and inputs",
+  "- Keep Bloomberg requests bounded: explicit securities, explicit fields, explicit dates, limited rows, and no broad exploratory pulls unless the user narrows the universe.",
+  "- Respect configured tool limits for securities, fields, rows, string size, BQL length, and search spec length. Ask the user to narrow the request rather than exceeding them.",
+  "- Use flat primitive overrides and kwargs only: string, number, or boolean values. Do not send nested objects, arrays, or inferred defaults as overrides."
+];
+var BLOOMBERG_TOOL_INSTRUCTIONS = [
+  ...REQUIRED_TOOL_INSTRUCTIONS,
+  ...OPTIONAL_EXTENSION_INSTRUCTIONS,
+  ...OPTIONAL_LIMIT_INSTRUCTIONS
+].join("\n");
+function getBloombergToolInstructions(options = {}) {
+  const includeExtensionGuidance = options.includeExtensionGuidance ?? true;
+  const includeLimitReminder = options.includeLimitReminder ?? true;
+  const lines = [...REQUIRED_TOOL_INSTRUCTIONS];
+  if (includeExtensionGuidance) {
+    lines.push(...OPTIONAL_EXTENSION_INSTRUCTIONS);
+  }
+  if (includeLimitReminder) {
+    lines.push(...OPTIONAL_LIMIT_INSTRUCTIONS);
+  }
+  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 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 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 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_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_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 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.")
+});
+function nonEmptyString(options, description) {
+  return z2__namespace.string().trim().pipe(z2__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);
+}
+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()
+  });
+}
+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.")
+  });
+}
+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.")
+  });
+}
+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.")
+  });
+}
+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.")
+  });
+}
+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.")
+  });
+}
+function yasOverridesSchema(options) {
+  return z2__namespace.object({
+    benchmark: optionalString(options, "Optional YAS benchmark."),
+    price: z2__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.")
+  });
+}
+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.")
+  });
+}
+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.")
+  });
+}
+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.")
+  });
+}
+
+// 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);
+}
+function recoveryOverrides(recoveryRate) {
+  return recoveryRate === void 0 ? void 0 : { CDS_RR: recoveryRate };
+}
+var EXT_TOOL_DEFINITIONS = Object.freeze([
+  { create: extTickerWithResolver, name: "xbbg_ext_ticker" },
+  { create: extFuturesWithResolver, name: "xbbg_ext_futures" },
+  { create: extCdxWithResolver, name: "xbbg_ext_cdx" },
+  { create: extCurrencyWithResolver, name: "xbbg_ext_currency" },
+  { create: extBqlBuilderWithResolver, name: "xbbg_ext_bql_builder" },
+  { create: extMarketSessionWithResolver, name: "xbbg_ext_market_session" },
+  { create: extYasOverridesWithResolver, name: "xbbg_ext_yas_overrides" },
+  { create: extConstantsWithResolver, name: "xbbg_ext_constants" },
+  { create: extColumnsWithResolver, name: "xbbg_ext_columns" },
+  { create: extCalculateWithResolver, name: "xbbg_ext_calculate" }
+]);
+var BLOOMBERG_EXT_TOOL_NAMES = Object.freeze(
+  EXT_TOOL_DEFINITIONS.map((definition) => definition.name)
+);
+function extTickerWithResolver(resolver) {
+  const name = "xbbg_ext_ticker";
+  return tools.tool(
+    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"))
+            );
+          case "normalize_tickers":
+            return resultString(
+              resolver,
+              name,
+              core.ext.normalizeTickers(requireStringArray(name, args, "tickers"))
+            );
+          case "filter_equity_tickers":
+            return resultString(
+              resolver,
+              name,
+              core.ext.filterEquityTickers(requireStringArray(name, args, "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 });
+          }
+        }
+      } catch (error) {
+        throwWithToolContext(name, error);
+      }
+    },
+    {
+      responseFormat: "content_and_artifact",
+      description: EXT_TICKER_DESCRIPTION,
+      name,
+      schema: tickerSchema(resolver.options)
+    }
+  );
+}
+function extFuturesWithResolver(resolver) {
+  const name = "xbbg_ext_futures";
+  return tools.tool(
+    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")
+              )
+            );
+          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.freq,
+                input.count
+              )
+            );
+          case "contract_index":
+            return resultString(
+              resolver,
+              name,
+              core.ext.contractIndex(requireString(name, args, "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")
+              )
+            );
+          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")
+              )
+            );
+          case "get_futures_months":
+            return resultString(resolver, name, core.ext.getFuturesMonths());
+        }
+      } catch (error) {
+        throwWithToolContext(name, error);
+      }
+    },
+    {
+      responseFormat: "content_and_artifact",
+      description: EXT_FUTURES_DESCRIPTION,
+      name,
+      schema: futuresSchema(resolver.options)
+    }
+  );
+}
+function extCdxWithResolver(resolver) {
+  const name = "xbbg_ext_cdx";
+  return tools.tool(
+    async (input) => {
+      try {
+        const args = asRecord(input);
+        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, {
+            backend: "json",
+            overrides: recoveryOverrides(input.recoveryRate)
+          });
+          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"))
+            );
+          case "previous_cdx_series":
+            return resultString(
+              resolver,
+              name,
+              core.ext.previousCdxSeries(requireString(name, args, "ticker"))
+            );
+          case "cdx_gen_to_specific":
+            return resultString(
+              resolver,
+              name,
+              core.ext.cdxGenToSpecific(
+                requireString(name, args, "genTicker"),
+                requireInteger(name, args, "series")
+              )
+            );
+        }
+      } catch (error) {
+        throwWithToolContext(name, error);
+      }
+    },
+    {
+      responseFormat: "content_and_artifact",
+      description: EXT_CDX_DESCRIPTION,
+      name,
+      schema: cdxSchema(resolver.options)
+    }
+  );
+}
+function extCurrencyWithResolver(resolver) {
+  const name = "xbbg_ext_currency";
+  return tools.tool(
+    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")
+              )
+            );
+          case "same_currency":
+            return resultString(
+              resolver,
+              name,
+              core.ext.sameCurrency(
+                requireString(name, args, "ccy1"),
+                requireString(name, args, "ccy2")
+              )
+            );
+          case "currencies_needing_conversion":
+            return resultString(
+              resolver,
+              name,
+              core.ext.currenciesNeedingConversion(
+                requireStringArray(name, args, "currencies"),
+                requireString(name, args, "target")
+              )
+            );
+        }
+      } catch (error) {
+        throwWithToolContext(name, error);
+      }
+    },
+    {
+      responseFormat: "content_and_artifact",
+      description: EXT_CURRENCY_DESCRIPTION,
+      name,
+      schema: currencySchema(resolver.options)
+    }
+  );
+}
+function extBqlBuilderWithResolver(resolver) {
+  const name = "xbbg_ext_bql_builder";
+  return tools.tool(
+    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
+              )
+            );
+          case "build_corporate_bonds_query":
+            return resultString(
+              resolver,
+              name,
+              core.ext.buildCorporateBondsQuery(
+                requireString(name, args, "ticker"),
+                input.ccy,
+                input.extraFields,
+                input.activeOnly
+              )
+            );
+          case "build_etf_holdings_query":
+            return resultString(
+              resolver,
+              name,
+              core.ext.buildEtfHoldingsQuery(
+                requireString(name, args, "etfTicker"),
+                input.extraFields
+              )
+            );
+        }
+      } catch (error) {
+        throwWithToolContext(name, error);
+      }
+    },
+    {
+      responseFormat: "content_and_artifact",
+      description: EXT_BQL_BUILDER_DESCRIPTION,
+      name,
+      schema: bqlBuilderSchema(resolver.options)
+    }
+  );
+}
+function extMarketSessionWithResolver(resolver) {
+  const name = "xbbg_ext_market_session";
+  return tools.tool(
+    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
+              )
+            );
+          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"))
+            );
+          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")
+              )
+            );
+          case "default_turnover_dates":
+            return resultString(
+              resolver,
+              name,
+              core.ext.defaultTurnoverDates(input.startDate, input.endDate)
+            );
+          case "default_bqr_datetimes":
+            return resultString(
+              resolver,
+              name,
+              core.ext.defaultBqrDatetimes(input.startDatetime, input.endDatetime)
+            );
+          case "get_exchange_override":
+            return resultString(
+              resolver,
+              name,
+              core.ext.getExchangeOverride(requireString(name, args, "ticker"))
+            );
+          case "list_exchange_overrides":
+            return resultString(resolver, name, core.ext.listExchangeOverrides());
+        }
+      } catch (error) {
+        throwWithToolContext(name, error);
+      }
+    },
+    {
+      responseFormat: "content_and_artifact",
+      description: EXT_MARKET_SESSION_DESCRIPTION,
+      name,
+      schema: marketSessionSchema(resolver.options)
+    }
+  );
+}
+function extYasOverridesWithResolver(resolver) {
+  const name = "xbbg_ext_yas_overrides";
+  return tools.tool(
+    async (input) => {
+      try {
+        const core = await resolver.getCore();
+        return resultString(
+          resolver,
+          name,
+          core.ext.buildYasOverrides(
+            input.settleDt,
+            input.yieldType,
+            input.spread,
+            input.yieldVal,
+            input.price,
+            input.benchmark
+          )
+        );
+      } catch (error) {
+        throwWithToolContext(name, error);
+      }
+    },
+    {
+      responseFormat: "content_and_artifact",
+      description: EXT_YAS_OVERRIDES_DESCRIPTION,
+      name,
+      schema: yasOverridesSchema(resolver.options)
+    }
+  );
+}
+function extConstantsWithResolver(resolver) {
+  const name = "xbbg_ext_constants";
+  return tools.tool(
+    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"))
+            );
+          case "fmt_date":
+            return resultString(
+              resolver,
+              name,
+              core.ext.fmtDate(
+                requireInteger(name, args, "year"),
+                requireInteger(name, args, "month"),
+                requireInteger(name, args, "day"),
+                input.fmt
+              )
+            );
+          case "get_month_code":
+            return resultString(
+              resolver,
+              name,
+              core.ext.getMonthCode(requireString(name, args, "monthName"))
+            );
+          case "get_month_name":
+            return resultString(
+              resolver,
+              name,
+              core.ext.getMonthName(requireString(name, args, "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"))
+            );
+          case "get_dvd_types":
+            return resultString(resolver, name, core.ext.getDvdTypes());
+          case "get_dvd_cols":
+            return resultString(resolver, name, core.ext.getDvdCols());
+          case "get_etf_cols":
+            return resultString(resolver, name, core.ext.getEtfCols());
+        }
+      } catch (error) {
+        throwWithToolContext(name, error);
+      }
+    },
+    {
+      responseFormat: "content_and_artifact",
+      description: EXT_CONSTANTS_DESCRIPTION,
+      name,
+      schema: constantsSchema(resolver.options)
+    }
+  );
+}
+function extColumnsWithResolver(resolver) {
+  const name = "xbbg_ext_columns";
+  return tools.tool(
+    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"))
+            );
+          case "rename_etf_columns":
+            return resultString(
+              resolver,
+              name,
+              core.ext.renameEtfColumns(requireStringArray(name, args, "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")
+              )
+            );
+        }
+      } catch (error) {
+        throwWithToolContext(name, error);
+      }
+    },
+    {
+      responseFormat: "content_and_artifact",
+      description: EXT_COLUMNS_DESCRIPTION,
+      name,
+      schema: columnsSchema(resolver.options)
+    }
+  );
+}
+function extCalculateWithResolver(resolver) {
+  const name = "xbbg_ext_calculate";
+  return tools.tool(
+    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,
+          name,
+          core.ext.calculateLevelPercentages(input.values, input.levels)
+        );
+      } catch (error) {
+        throwWithToolContext(name, error);
+      }
+    },
+    {
+      responseFormat: "content_and_artifact",
+      description: EXT_CALCULATE_DESCRIPTION,
+      name,
+      schema: calculateSchema(resolver.options)
+    }
+  );
+}
+function createExtTickerTool(options = {}) {
+  return extTickerWithResolver(createCoreResolver(options));
+}
+function createExtFuturesTool(options = {}) {
+  return extFuturesWithResolver(createCoreResolver(options));
+}
+function createExtCdxTool(options = {}) {
+  return extCdxWithResolver(createCoreResolver(options));
+}
+function createExtCurrencyTool(options = {}) {
+  return extCurrencyWithResolver(createCoreResolver(options));
+}
+function createExtBqlBuilderTool(options = {}) {
+  return extBqlBuilderWithResolver(createCoreResolver(options));
+}
+function createExtMarketSessionTool(options = {}) {
+  return extMarketSessionWithResolver(createCoreResolver(options));
+}
+function createExtYasOverridesTool(options = {}) {
+  return extYasOverridesWithResolver(createCoreResolver(options));
+}
+function createExtConstantsTool(options = {}) {
+  return extConstantsWithResolver(createCoreResolver(options));
+}
+function createExtColumnsTool(options = {}) {
+  return extColumnsWithResolver(createCoreResolver(options));
+}
+function createExtCalculateTool(options = {}) {
+  return extCalculateWithResolver(createCoreResolver(options));
+}
+function createBloombergExtToolsForResolver(resolver) {
+  return EXT_TOOL_DEFINITIONS.filter(
+    (definition) => !isToolDisabled(resolver.options, definition.name)
+  ).map((definition) => definition.create(resolver));
+}
+function createBloombergExtTools(options = {}) {
+  return createBloombergExtToolsForResolver(createCoreResolver(options));
+}
+var REFERENCE_FORMATS = ["long", "long_typed", "long_metadata"];
+var HISTORICAL_FORMATS = [
+  "long",
+  "long_typed",
+  "long_metadata",
+  "semi_long",
+  "wide"
+];
+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()
+]);
+function dateFromParts(year, month, day) {
+  const formatted = `${year}${month}${day}`;
+  const parsed = new Date(Date.UTC(Number(year), Number(month) - 1, Number(day)));
+  if (Number.isNaN(parsed.getTime()) || parsed.getUTCFullYear() !== Number(year) || parsed.getUTCMonth() + 1 !== Number(month) || parsed.getUTCDate() !== Number(day)) {
+    throw new TypeError(`Invalid date ${formatted}; expected a real calendar date like 2024-01-31`);
+  }
+  return formatted;
+}
+function dateToBbg(value) {
+  const date2 = value instanceof Date ? value : new Date(value);
+  if (Number.isNaN(date2.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");
+  return `${year}${month}${day}`;
+}
+function normalizeDate(value) {
+  if (value instanceof Date || typeof value === "number") {
+    return dateToBbg(value);
+  }
+  const text = value.trim();
+  if (text.length === 0) {
+    throw new TypeError("Date must be non-empty; use YYYY-MM-DD or YYYYMMDD");
+  }
+  if (AMBIGUOUS_DATE_RE.test(text)) {
+    throw new TypeError(`Ambiguous date ${JSON.stringify(text)}; use YYYY-MM-DD or YYYYMMDD`);
+  }
+  if (BBG_DATE_RE.test(text)) {
+    return dateFromParts(text.slice(0, 4), text.slice(4, 6), text.slice(6, 8));
+  }
+  if (ISO_DATE_RE.test(text)) {
+    return dateFromParts(text.slice(0, 4), text.slice(5, 7), text.slice(8, 10));
+  }
+  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");
+    }
+    return date2.toISOString();
+  }
+  const text = value.trim();
+  if (text.length === 0) {
+    throw new TypeError("Datetime must be non-empty; use an ISO 8601 datetime");
+  }
+  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 (!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(
+      maxChars,
+      `${tool3}: ${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 primitiveMap(tool3, field) {
+  return z2__namespace.record(z2__namespace.string().min(1), primitiveSchema).optional().transform((value) => {
+    if (value === void 0) {
+      return void 0;
+    }
+    const normalized = {};
+    for (const [key, entry] of Object.entries(value)) {
+      const normalizedKey = key.trim();
+      if (normalizedKey.length === 0) {
+        throw new TypeError(`${tool3}: ${field} contains an empty key`);
+      }
+      if (typeof entry === "string" && entry.length === 0) {
+        throw new TypeError(`${tool3}: ${field}.${normalizedKey} must not be an empty string`);
+      }
+      normalized[normalizedKey] = entry;
+    }
+    return normalized;
+  });
+}
+function dateField(tool3, field) {
+  return z2__namespace.union([z2__namespace.string(), z2__namespace.date(), z2__namespace.number()]).transform((value) => normalizeDate(value)).describe(
+    `${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 referenceFormat(tool3) {
+  return z2__namespace.enum(REFERENCE_FORMATS, {
+    error: `${tool3}: 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(", ")}`
+  }).optional();
+}
+function createBdpSchema(options) {
+  const tool3 = "xbbg_bdp";
+  return z2__namespace.object({
+    fields: stringArray2(
+      tool3,
+      "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(
+      "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(
+      "Advanced Bloomberg request kwargs as flat string/number/boolean values only."
+    ),
+    overrides: primitiveMap(tool3, "overrides").describe(
+      "Bloomberg field overrides as flat string/number/boolean values only."
+    ),
+    securities: stringArray2(
+      tool3,
+      "securities",
+      options.maxSecurities,
+      options.maxStringChars,
+      '["AAPL US Equity"]'
+    ).describe(
+      'Fully qualified Bloomberg securities, for example ["AAPL US Equity"]; use /isin/{isin} for ISINs and /cusip/{cusip} for CUSIPs. Do not invent tickers.'
+    ),
+    validateFields: z2__namespace.boolean().optional().describe("Override field validation for this request.")
+  });
+}
+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."),
+    fields: stringArray2(
+      tool3,
+      "fields",
+      options.maxFields,
+      options.maxStringChars,
+      '["PX_LAST"]'
+    ).describe('Bloomberg historical field mnemonics, for example ["PX_LAST"].'),
+    format: historicalFormat(tool3).describe(
+      "Historical JSON output shape. Use wide only when the user asks for a table by date."
+    ),
+    kwargs: primitiveMap(tool3, "kwargs").describe(
+      "Advanced Bloomberg request kwargs as flat string/number/boolean values only."
+    ),
+    overrides: primitiveMap(tool3, "overrides").describe(
+      "Bloomberg overrides as flat string/number/boolean values only."
+    ),
+    securities: stringArray2(
+      tool3,
+      "securities",
+      options.maxSecurities,
+      options.maxStringChars,
+      '["AAPL US Equity"]'
+    ).describe(
+      'Fully qualified Bloomberg securities, for example ["AAPL US Equity"]; use /isin/{isin} for ISINs and /cusip/{cusip} for CUSIPs.'
+    ),
+    start: dateField(tool3, "start").describe("Required start date. Use YYYY-MM-DD or YYYYMMDD."),
+    validateFields: z2__namespace.boolean().optional().describe("Override field validation for this request.")
+  }).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"`,
+        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."
+    ),
+    format: referenceFormat(tool3).describe("JSON output shape. Usually omit."),
+    kwargs: primitiveMap(tool3, "kwargs").describe(
+      "Advanced Bloomberg request kwargs as flat string/number/boolean values only."
+    ),
+    overrides: primitiveMap(tool3, "overrides").describe(
+      "Bloomberg overrides as flat string/number/boolean values only."
+    ),
+    securities: stringArray2(
+      tool3,
+      "securities",
+      options.maxSecurities,
+      options.maxStringChars,
+      '["SPX Index"]'
+    ).describe(
+      'Fully qualified Bloomberg securities, for example ["SPX Index"]; use /isin/{isin} for ISINs and /cusip/{cusip} for CUSIPs.'
+    ),
+    validateFields: z2__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(
+      "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(
+      "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(
+      "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."
+    )
+  });
+}
+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(
+      "Required intraday tick end datetime. Use ISO 8601 with timezone when possible."
+    ),
+    eventTypes: stringArray2(
+      tool3,
+      "eventTypes",
+      options.maxFields,
+      options.maxStringChars,
+      '["TRADE"]'
+    ).optional().describe('Bloomberg tick event types, for example ["TRADE"] or ["BID", "ASK"].'),
+    includeBicMicCodes: includeFlag,
+    includeBloombergStandardConditionCodes: includeFlag,
+    includeBrokerCodes: includeFlag,
+    includeConditionCodes: includeFlag,
+    includeExchangeCodes: includeFlag,
+    includeNonPlottableEvents: includeFlag,
+    includeRpsCodes: includeFlag,
+    kwargs: primitiveMap(tool3, "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(
+      "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."
+    )
+  });
+}
+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(
+      "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."
+    )
+  });
+}
+function createBqrSchema(options) {
+  const tool3 = "xbbg_bqr";
+  return z2__namespace.object({
+    end: dateTimeField(tool3, "end").describe(
+      "Required BQR end datetime. Use ISO 8601 with timezone when possible."
+    ),
+    eventTypes: stringArray2(
+      tool3,
+      "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(
+      "Required BQR start datetime. Use ISO 8601 with timezone when possible."
+    ),
+    ticker: nonEmptyString2(
+      tool3,
+      "ticker",
+      options.maxStringChars,
+      "/isin/US037833FB15@MSG1 Corp"
+    ).describe(
+      "Fixed-income ticker or identifier with dealer quote source, for example /isin/US037833FB15@MSG1 Corp."
+    )
+  });
+}
+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(
+      "Search-grid kwargs as flat string/number/boolean values only."
+    ),
+    overrides: primitiveMap(tool3, "overrides").describe(
+      "Search-grid overrides as flat string/number/boolean values only."
+    ),
+    searchSpec: nonEmptyString2(
+      tool3,
+      "searchSpec",
+      options.maxSearchSpecChars,
+      "COMDTY:NG"
+    ).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.'
+    ),
+    format: referenceFormat(tool3).describe("JSON output shape. Usually omit."),
+    kwargs: primitiveMap(tool3, "kwargs").describe(
+      "Advanced Bloomberg request kwargs as flat string/number/boolean values only."
+    ),
+    searchSpec: nonEmptyString2(tool3, "searchSpec", options.maxSearchSpecChars, "last price").optional().describe(
+      "Field search text when the field mnemonic is unknown. Provide either searchSpec or fields, not both."
+    )
+  }).superRefine((value, ctx) => {
+    const hasFields = value.fields !== void 0;
+    const hasSearchSpec = value.searchSpec !== void 0;
+    if (hasFields === hasSearchSpec) {
+      ctx.addIssue({
+        code: "custom",
+        message: `${tool3}: provide exactly one of fields or searchSpec. Example: {"fields":["PX_LAST"]}`,
+        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(
+      "Advanced BEQS request kwargs as flat string/number/boolean values only."
+    ),
+    overrides: primitiveMap(tool3, "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.")
+  });
+}
+function createYasSchema(options) {
+  const tool3 = "xbbg_yas";
+  return z2__namespace.object({
+    benchmark: nonEmptyString2(tool3, "benchmark", options.maxStringChars, "USGG10YR Index").optional().describe("Optional YAS benchmark."),
+    fields: stringArray2(
+      tool3,
+      "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."),
+    tickers: stringArray2(
+      tool3,
+      "tickers",
+      options.maxSecurities,
+      options.maxStringChars,
+      '["/isin/US037833FB15 Corp"]'
+    ).describe(
+      'Fully qualified fixed-income Bloomberg securities, for example ["/isin/US037833FB15 Corp"].'
+    ),
+    yieldType: z2__namespace.number().int().optional().describe("Optional YAS yield type."),
+    yieldVal: z2__namespace.number().optional().describe("Optional YAS yield value input.")
+  });
+}
+function createPreferredsSchema(options) {
+  const tool3 = "xbbg_preferreds";
+  return z2__namespace.object({
+    equityTicker: nonEmptyString2(
+      tool3,
+      "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.")
+  });
+}
+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."
+    )
+  });
+}
+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."
+    )
+  });
+}
+function createResolveIsinsSchema(options) {
+  const tool3 = "xbbg_resolve_isins";
+  return z2__namespace.object({
+    isins: stringArray2(
+      tool3,
+      "isins",
+      options.maxSecurities,
+      options.maxStringChars,
+      '["US0378331005"]'
+    ).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({
+    bondIsins: stringArray2(
+      tool3,
+      "bondIsins",
+      options.maxSecurities,
+      options.maxStringChars,
+      '["US037833FB15"]'
+    ).describe("Raw bond ISIN strings for issuer-level ISIN discovery.")
+  });
+}
+function createEtfHoldingsSchema(options) {
+  const tool3 = "xbbg_etf_holdings";
+  return z2__namespace.object({
+    etfTicker: nonEmptyString2(tool3, "etfTicker", options.maxStringChars, "SPY US Equity").describe(
+      "One fully qualified Bloomberg ETF ticker."
+    ),
+    fields: stringArray2(tool3, "fields", options.maxFields, options.maxStringChars, '["id"]').optional().describe("Optional fields to include in the ETF holdings recipe result.")
+  });
+}
+function snapshotControlFields(tool3, 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."
+    ),
+    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(
+      options.maxStreamUpdates,
+      `${tool3}: maxUpdates can be at most ${options.maxStreamUpdates}.`
+    ).describe("Required maximum number of updates to collect before unsubscribing."),
+    options: stringArray2(
+      tool3,
+      "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.")
+  };
+}
+function createStreamSnapshotSchema(options) {
+  const tool3 = "xbbg_stream_snapshot";
+  return z2__namespace.object({
+    fields: stringArray2(
+      tool3,
+      "fields",
+      options.maxFields,
+      options.maxStringChars,
+      '["LAST_PRICE"]'
+    ).describe("Bloomberg market-data fields to observe."),
+    tickers: stringArray2(
+      tool3,
+      "tickers",
+      options.maxSecurities,
+      options.maxStringChars,
+      '["AAPL US Equity"]'
+    ).describe("Fully qualified Bloomberg securities to observe."),
+    ...snapshotControlFields(tool3, options)
+  });
+}
+function createMktbarSnapshotSchema(options) {
+  const tool3 = "xbbg_mktbar_snapshot";
+  return z2__namespace.object({
+    fields: stringArray2(tool3, "fields", options.maxFields, options.maxStringChars, '["LAST_PRICE"]').optional().describe("Optional market-bar fields. Omit for Bloomberg defaults."),
+    ticker: nonEmptyString2(tool3, "ticker", options.maxStringChars, "AAPL US Equity").describe(
+      "One fully qualified Bloomberg security to observe."
+    ),
+    ...snapshotControlFields(tool3, options)
+  });
+}
+function createDepthSnapshotSchema(options) {
+  const tool3 = "xbbg_depth_snapshot";
+  return z2__namespace.object({
+    fields: stringArray2(tool3, "fields", options.maxFields, options.maxStringChars, '["BID"]').optional().describe("Optional market-depth fields. Omit for Bloomberg defaults."),
+    ticker: nonEmptyString2(tool3, "ticker", options.maxStringChars, "AAPL US Equity").describe(
+      "One fully qualified Bloomberg security to observe."
+    ),
+    ...snapshotControlFields(tool3, options)
+  });
+}
+
+// src/tools.ts
+function resultString2(resolver, name, value) {
+  return createToolResult(name, value, resolver.options.maxRows, resolver.options.maxStringChars);
+}
+var STREAM_TIMEOUT = /* @__PURE__ */ Symbol("stream_timeout");
+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 isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function rowsFromArrowTable(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const toArray = value.toArray;
+  if (typeof toArray === "function") {
+    return Array.from(toArray.call(value));
+  }
+  const numRows = value.numRows;
+  const get = value.get;
+  if (typeof numRows === "number" && Number.isInteger(numRows) && typeof get === "function") {
+    const rows = [];
+    for (let index = 0; index < numRows; index += 1) {
+      rows.push(get.call(value, index));
+    }
+    return rows;
+  }
+  return void 0;
+}
+function jsonCompatible(value) {
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  if (Array.isArray(value)) {
+    return value.map(jsonCompatible);
+  }
+  if (!isRecord(value)) {
+    return value;
+  }
+  const toJSON = value.toJSON;
+  if (typeof toJSON === "function") {
+    return jsonCompatible(toJSON.call(value));
+  }
+  const output = {};
+  for (const [key, entry] of Object.entries(value)) {
+    output[key] = jsonCompatible(entry);
+  }
+  return output;
+}
+function normalizeStreamUpdate(value) {
+  if (isRecord(value)) {
+    const toObject = value.toObject;
+    if (typeof toObject === "function") {
+      return jsonCompatible(toObject.call(value));
+    }
+  }
+  const rows = rowsFromArrowTable(value);
+  return rows === void 0 ? jsonCompatible(value) : rows.map(jsonCompatible);
+}
+async function nextWithinTimeout(iterator, deadlineMs) {
+  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]);
+  if (timer !== void 0) {
+    clearTimeout(timer);
+  }
+  if (result === STREAM_TIMEOUT) {
+    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) {
+  const updates = [];
+  const deadlineMs = Date.now() + input.timeoutMs;
+  let reason = "max_updates";
+  let caught;
+  try {
+    while (updates.length < input.maxUpdates) {
+      const next = await nextWithinTimeout(subscription, deadlineMs);
+      if (next === STREAM_TIMEOUT) {
+        reason = "timeout";
+        break;
+      }
+      if (next.done === true) {
+        reason = "done";
+        break;
+      }
+      updates.push(normalizeStreamUpdate(next.value));
+    }
+    return {
+      maxUpdates: input.maxUpdates,
+      reason,
+      timeoutMs: input.timeoutMs,
+      updateCount: updates.length,
+      updates
+    };
+  } catch (error) {
+    caught = error;
+    throw error;
+  } finally {
+    await unsubscribeSnapshot(subscription, input.drain === true, caught);
+  }
+}
+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(
+    async (input) => {
+      try {
+        const engine = await resolver.getEngine();
+        const result = await engine.bdp(input.securities, input.fields, {
+          backend: "json",
+          format: input.format,
+          includeSecurityErrors: input.includeSecurityErrors,
+          kwargs: input.kwargs,
+          overrides: input.overrides,
+          validateFields: validationSetting(resolver, input.validateFields)
+        });
+        return resultString2(resolver, name, result);
+      } catch (error) {
+        throwWithToolContext(name, error);
+      }
+    },
+    {
+      description: BDP_DESCRIPTION,
+      name,
+      responseFormat: "content_and_artifact",
+      schema: createBdpSchema(resolver.options)
+    }
+  );
+}
+function bdhWithResolver(resolver) {
+  const name = "xbbg_bdh";
+  return tools.tool(
+    async (input) => {
+      try {
+        const engine = await resolver.getEngine();
+        const result = await engine.bdh(input.securities, input.fields, {
+          backend: "json",
+          end: input.end,
+          format: input.format,
+          kwargs: input.kwargs,
+          overrides: input.overrides,
+          start: input.start,
+          validateFields: validationSetting(resolver, input.validateFields)
+        });
+        return resultString2(resolver, name, result);
+      } catch (error) {
+        throwWithToolContext(name, error);
+      }
+    },
+    {
+      description: BDH_DESCRIPTION,
+      name,
+      responseFormat: "content_and_artifact",
+      schema: createBdhSchema(resolver.options)
+    }
+  );
+}
+function bdsWithResolver(resolver) {
+  const name = "xbbg_bds";
+  return tools.tool(
+    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)
+        });
+        return resultString2(resolver, name, result);
+      } catch (error) {
+        throwWithToolContext(name, error);
+      }
+    },
+    {
+      description: BDS_DESCRIPTION,
+      name,
+      responseFormat: "content_and_artifact",
+      schema: createBdsSchema(resolver.options)
+    }
+  );
+}
+function bdibWithResolver(resolver) {
+  const name = "xbbg_bdib";
+  return tools.tool(
+    async (input) => {
+      try {
+        const engine = await resolver.getEngine();
+        const result = await engine.bdib(input.ticker, {
+          backend: "json",
+          end: input.end,
+          eventType: input.eventType,
+          interval: input.interval,
+          kwargs: input.kwargs,
+          outputTz: input.outputTz,
+          requestTz: input.requestTz,
+          start: input.start
+        });
+        return resultString2(resolver, name, result);
+      } catch (error) {
+        throwWithToolContext(name, error);
+      }
+    },
+    {
+      description: BDIB_DESCRIPTION,
+      name,
+      responseFormat: "content_and_artifact",
+      schema: createBdibSchema(resolver.options)
+    }
+  );
+}
+function bdtickWithResolver(resolver) {
+  const name = "xbbg_bdtick";
+  return tools.tool(
+    async (input) => {
+      try {
+        const engine = await resolver.getEngine();
+        const result = await engine.bdtick(input.ticker, {
+          backend: "json",
+          end: input.end,
+          eventTypes: input.eventTypes,
+          includeBicMicCodes: input.includeBicMicCodes,
+          includeBloombergStandardConditionCodes: input.includeBloombergStandardConditionCodes,
+          includeBrokerCodes: input.includeBrokerCodes,
+          includeConditionCodes: input.includeConditionCodes,
+          includeExchangeCodes: input.includeExchangeCodes,
+          includeNonPlottableEvents: input.includeNonPlottableEvents,
+          includeRpsCodes: input.includeRpsCodes,
+          kwargs: input.kwargs,
+          outputTz: input.outputTz,
+          requestTz: input.requestTz,
+          start: input.start
+        });
+        return resultString2(resolver, name, result);
+      } catch (error) {
+        throwWithToolContext(name, error);
+      }
+    },
+    {
+      description: BDTICK_DESCRIPTION,
+      name,
+      responseFormat: "content_and_artifact",
+      schema: createBdtickSchema(resolver.options)
+    }
+  );
+}
+function bqlWithResolver(resolver) {
+  const name = "xbbg_bql";
+  return tools.tool(
+    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);
+      } catch (error) {
+        throwWithToolContext(name, error);
+      }
+    },
+    {
+      description: BQL_DESCRIPTION,
+      name,
+      responseFormat: "content_and_artifact",
+      schema: createBqlSchema(resolver.options)
+    }
+  );
+}
+function bsrchWithResolver(resolver) {
+  const name = "xbbg_bsrch";
+  return tools.tool(
+    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
+        });
+        return resultString2(resolver, name, result);
+      } catch (error) {
+        throwWithToolContext(name, error);
+      }
+    },
+    {
+      description: BSRCH_DESCRIPTION,
+      name,
+      responseFormat: "content_and_artifact",
+      schema: createBsrchSchema(resolver.options)
+    }
+  );
+}
+function bqrWithResolver(resolver) {
+  const name = "xbbg_bqr";
+  return tools.tool(
+    async (input) => {
+      try {
+        const engine = await resolver.getEngine();
+        const result = await engine.bqr(input.ticker, {
+          backend: "json",
+          endDatetime: input.end,
+          eventTypes: input.eventTypes,
+          includeBrokerCodes: input.includeBrokerCodes,
+          startDatetime: input.start
+        });
+        return resultString2(resolver, name, result);
+      } catch (error) {
+        throwWithToolContext(name, error);
+      }
+    },
+    {
+      description: BQR_DESCRIPTION,
+      name,
+      responseFormat: "content_and_artifact",
+      schema: createBqrSchema(resolver.options)
+    }
+  );
+}
+function bfldsWithResolver(resolver) {
+  const name = "xbbg_bflds";
+  return tools.tool(
+    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
+        });
+        return resultString2(resolver, name, result);
+      } catch (error) {
+        throwWithToolContext(name, error);
+      }
+    },
+    {
+      description: BFLDS_DESCRIPTION,
+      name,
+      responseFormat: "content_and_artifact",
+      schema: createBfldsSchema(resolver.options)
+    }
+  );
+}
+function beqsWithResolver(resolver) {
+  const name = "xbbg_beqs";
+  return tools.tool(
+    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,
+          screenType: input.screenType
+        });
+        return resultString2(resolver, name, result);
+      } catch (error) {
+        throwWithToolContext(name, error);
+      }
+    },
+    {
+      description: BEQS_DESCRIPTION,
+      name,
+      responseFormat: "content_and_artifact",
+      schema: createBeqsSchema(resolver.options)
+    }
+  );
+}
+function yasWithResolver(resolver) {
+  const name = "xbbg_yas";
+  return tools.tool(
+    async (input) => {
+      try {
+        const engine = await resolver.getEngine();
+        const result = await engine.yas(input.tickers, input.fields, {
+          backend: "json",
+          benchmark: input.benchmark,
+          price: input.price,
+          settleDt: input.settleDt,
+          spread: input.spread,
+          yieldType: input.yieldType,
+          yieldVal: input.yieldVal
+        });
+        return resultString2(resolver, name, result);
+      } catch (error) {
+        throwWithToolContext(name, error);
+      }
+    },
+    {
+      description: YAS_DESCRIPTION,
+      name,
+      responseFormat: "content_and_artifact",
+      schema: createYasSchema(resolver.options)
+    }
+  );
+}
+function preferredsWithResolver(resolver) {
+  const name = "xbbg_preferreds";
+  return tools.tool(
+    async (input) => {
+      try {
+        const engine = await resolver.getEngine();
+        const result = await engine.preferreds(input.equityTicker, {
+          backend: "json",
+          fields: input.fields
+        });
+        return resultString2(resolver, name, result);
+      } catch (error) {
+        throwWithToolContext(name, error);
+      }
+    },
+    {
+      description: PREFERREDS_DESCRIPTION,
+      name,
+      responseFormat: "content_and_artifact",
+      schema: createPreferredsSchema(resolver.options)
+    }
+  );
+}
+function corporateBondsWithResolver(resolver) {
+  const name = "xbbg_corporate_bonds";
+  return tools.tool(
+    async (input) => {
+      try {
+        const engine = await resolver.getEngine();
+        const result = await engine.corporateBonds(input.ticker, {
+          activeOnly: input.activeOnly,
+          backend: "json",
+          ccy: input.ccy,
+          fields: input.fields
+        });
+        return resultString2(resolver, name, result);
+      } catch (error) {
+        throwWithToolContext(name, error);
+      }
+    },
+    {
+      description: CORPORATE_BONDS_DESCRIPTION,
+      name,
+      responseFormat: "content_and_artifact",
+      schema: createCorporateBondsSchema(resolver.options)
+    }
+  );
+}
+function indexMembersWithResolver(resolver) {
+  const name = "xbbg_index_members";
+  return tools.tool(
+    async (input) => {
+      try {
+        const engine = await resolver.getEngine();
+        const result = await engine.indexMembers(input.index, {
+          asof: input.asof,
+          backend: "json",
+          field: input.field
+        });
+        return resultString2(resolver, name, result);
+      } catch (error) {
+        throwWithToolContext(name, error);
+      }
+    },
+    {
+      description: INDEX_MEMBERS_DESCRIPTION,
+      name,
+      responseFormat: "content_and_artifact",
+      schema: createIndexMembersSchema(resolver.options)
+    }
+  );
+}
+function resolveIsinsWithResolver(resolver) {
+  const name = "xbbg_resolve_isins";
+  return tools.tool(
+    async (input) => {
+      try {
+        const engine = await resolver.getEngine();
+        const result = await engine.resolveIsins(input.isins, { backend: "json" });
+        return resultString2(resolver, name, result);
+      } catch (error) {
+        throwWithToolContext(name, error);
+      }
+    },
+    {
+      description: RESOLVE_ISINS_DESCRIPTION,
+      name,
+      responseFormat: "content_and_artifact",
+      schema: createResolveIsinsSchema(resolver.options)
+    }
+  );
+}
+function issuerIsinsWithResolver(resolver) {
+  const name = "xbbg_issuer_isins";
+  return tools.tool(
+    async (input) => {
+      try {
+        const engine = await resolver.getEngine();
+        const result = await engine.issuerIsins(input.bondIsins, { backend: "json" });
+        return resultString2(resolver, name, result);
+      } catch (error) {
+        throwWithToolContext(name, error);
+      }
+    },
+    {
+      description: ISSUER_ISINS_DESCRIPTION,
+      name,
+      responseFormat: "content_and_artifact",
+      schema: createIssuerIsinsSchema(resolver.options)
+    }
+  );
+}
+function etfHoldingsWithResolver(resolver) {
+  const name = "xbbg_etf_holdings";
+  return tools.tool(
+    async (input) => {
+      try {
+        const engine = await resolver.getEngine();
+        const result = await engine.etfHoldings(input.etfTicker, {
+          backend: "json",
+          fields: input.fields
+        });
+        return resultString2(resolver, name, result);
+      } catch (error) {
+        throwWithToolContext(name, error);
+      }
+    },
+    {
+      description: ETF_HOLDINGS_DESCRIPTION,
+      name,
+      responseFormat: "content_and_artifact",
+      schema: createEtfHoldingsSchema(resolver.options)
+    }
+  );
+}
+function streamSnapshotWithResolver(resolver) {
+  const name = "xbbg_stream_snapshot";
+  return tools.tool(
+    async (input) => {
+      try {
+        const engine = await resolver.getEngine();
+        const subscription = await engine.stream(input.tickers, input.fields, streamOptions(input));
+        const result = await collectSnapshot(subscription, input);
+        return resultString2(resolver, name, result);
+      } catch (error) {
+        throwWithToolContext(name, error);
+      }
+    },
+    {
+      description: STREAM_SNAPSHOT_DESCRIPTION,
+      name,
+      responseFormat: "content_and_artifact",
+      schema: createStreamSnapshotSchema(resolver.options)
+    }
+  );
+}
+function mktbarSnapshotWithResolver(resolver) {
+  const name = "xbbg_mktbar_snapshot";
+  return tools.tool(
+    async (input) => {
+      try {
+        const engine = await resolver.getEngine();
+        const subscription = await engine.mktbar(input.ticker, streamOptions(input));
+        const result = await collectSnapshot(subscription, input);
+        return resultString2(resolver, name, result);
+      } catch (error) {
+        throwWithToolContext(name, error);
+      }
+    },
+    {
+      description: MKTBAR_SNAPSHOT_DESCRIPTION,
+      name,
+      responseFormat: "content_and_artifact",
+      schema: createMktbarSnapshotSchema(resolver.options)
+    }
+  );
+}
+function depthSnapshotWithResolver(resolver) {
+  const name = "xbbg_depth_snapshot";
+  return tools.tool(
+    async (input) => {
+      try {
+        const engine = await resolver.getEngine();
+        const subscription = await engine.depth(input.ticker, streamOptions(input));
+        const result = await collectSnapshot(subscription, input);
+        return resultString2(resolver, name, result);
+      } catch (error) {
+        throwWithToolContext(name, error);
+      }
+    },
+    {
+      description: DEPTH_SNAPSHOT_DESCRIPTION,
+      name,
+      responseFormat: "content_and_artifact",
+      schema: createDepthSnapshotSchema(resolver.options)
+    }
+  );
+}
+function createBdpTool(options = {}) {
+  return bdpWithResolver(createCoreResolver(options));
+}
+function createBdhTool(options = {}) {
+  return bdhWithResolver(createCoreResolver(options));
+}
+function createBdsTool(options = {}) {
+  return bdsWithResolver(createCoreResolver(options));
+}
+function createBdibTool(options = {}) {
+  return bdibWithResolver(createCoreResolver(options));
+}
+function createBdtickTool(options = {}) {
+  return bdtickWithResolver(createCoreResolver(options));
+}
+function createBqlTool(options = {}) {
+  return bqlWithResolver(createCoreResolver(options));
+}
+function createBsrchTool(options = {}) {
+  return bsrchWithResolver(createCoreResolver(options));
+}
+function createBqrTool(options = {}) {
+  return bqrWithResolver(createCoreResolver(options));
+}
+function createBfldsTool(options = {}) {
+  return bfldsWithResolver(createCoreResolver(options));
+}
+function createBeqsTool(options = {}) {
+  return beqsWithResolver(createCoreResolver(options));
+}
+function createYasTool(options = {}) {
+  return yasWithResolver(createCoreResolver(options));
+}
+function createPreferredsTool(options = {}) {
+  return preferredsWithResolver(createCoreResolver(options));
+}
+function createCorporateBondsTool(options = {}) {
+  return corporateBondsWithResolver(createCoreResolver(options));
+}
+function createIndexMembersTool(options = {}) {
+  return indexMembersWithResolver(createCoreResolver(options));
+}
+function createResolveIsinsTool(options = {}) {
+  return resolveIsinsWithResolver(createCoreResolver(options));
+}
+function createIssuerIsinsTool(options = {}) {
+  return issuerIsinsWithResolver(createCoreResolver(options));
+}
+function createEtfHoldingsTool(options = {}) {
+  return etfHoldingsWithResolver(createCoreResolver(options));
+}
+function createStreamSnapshotTool(options = {}) {
+  return streamSnapshotWithResolver(createCoreResolver(options));
+}
+function createMktbarSnapshotTool(options = {}) {
+  return mktbarSnapshotWithResolver(createCoreResolver(options));
+}
+function createDepthSnapshotTool(options = {}) {
+  return depthSnapshotWithResolver(createCoreResolver(options));
+}
+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)
+  ];
+}
+function createBloombergTools(options = {}) {
+  return createBloombergToolsForResolver(createCoreResolver(options));
+}
+
+// src/index.ts
+function createAllBloombergTools(options = {}) {
+  const resolver = createCoreResolver(options);
+  return [
+    ...createBloombergToolsForResolver(resolver),
+    ...createBloombergExtToolsForResolver(resolver)
+  ];
+}
+
+exports.BLOOMBERG_EXT_TOOL_NAMES = BLOOMBERG_EXT_TOOL_NAMES;
+exports.BLOOMBERG_TOOL_INSTRUCTIONS = BLOOMBERG_TOOL_INSTRUCTIONS;
+exports.BLOOMBERG_TOOL_NAMES = BLOOMBERG_TOOL_NAMES;
+exports.createAllBloombergTools = createAllBloombergTools;
+exports.createBdhTool = createBdhTool;
+exports.createBdibTool = createBdibTool;
+exports.createBdpTool = createBdpTool;
+exports.createBdsTool = createBdsTool;
+exports.createBdtickTool = createBdtickTool;
+exports.createBeqsTool = createBeqsTool;
+exports.createBfldsTool = createBfldsTool;
+exports.createBloombergExtTools = createBloombergExtTools;
+exports.createBloombergTools = createBloombergTools;
+exports.createBqlTool = createBqlTool;
+exports.createBqrTool = createBqrTool;
+exports.createBsrchTool = createBsrchTool;
+exports.createCorporateBondsTool = createCorporateBondsTool;
+exports.createDepthSnapshotTool = createDepthSnapshotTool;
+exports.createEtfHoldingsTool = createEtfHoldingsTool;
+exports.createExtBqlBuilderTool = createExtBqlBuilderTool;
+exports.createExtCalculateTool = createExtCalculateTool;
+exports.createExtCdxTool = createExtCdxTool;
+exports.createExtColumnsTool = createExtColumnsTool;
+exports.createExtConstantsTool = createExtConstantsTool;
+exports.createExtCurrencyTool = createExtCurrencyTool;
+exports.createExtFuturesTool = createExtFuturesTool;
+exports.createExtMarketSessionTool = createExtMarketSessionTool;
+exports.createExtTickerTool = createExtTickerTool;
+exports.createExtYasOverridesTool = createExtYasOverridesTool;
+exports.createIndexMembersTool = createIndexMembersTool;
+exports.createIssuerIsinsTool = createIssuerIsinsTool;
+exports.createMktbarSnapshotTool = createMktbarSnapshotTool;
+exports.createPreferredsTool = createPreferredsTool;
+exports.createResolveIsinsTool = createResolveIsinsTool;
+exports.createStreamSnapshotTool = createStreamSnapshotTool;
+exports.createYasTool = createYasTool;
+exports.getBloombergToolInstructions = getBloombergToolInstructions;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map