@xbbg/langgraph 1.2.7 → 1.3.1

package/dist/index.js

@@ -51,6 +51,7 @@ var BLOOMBERG_TOOL_NAMES = [
   "xbbg_ext_cdx",
   "xbbg_ext_currency",
   "xbbg_ext_bql_builder",
+  "xbbg_ext_chart_spec",
   "xbbg_ext_market_session",
   "xbbg_ext_yas_overrides",
   "xbbg_ext_constants",
@@ -65,6 +66,13 @@ var DEFAULT_MAX_BQL_QUERY_CHARS = 4e3;
 var DEFAULT_MAX_SEARCH_SPEC_CHARS = 1e3;
 var DEFAULT_MAX_STREAM_UPDATES = 10;
 var DEFAULT_MAX_STREAM_WAIT_MS = 15e3;
+var DEFAULT_ENGINE_REQUEST_TIMEOUT_MS = 6e4;
+function engineConfigWithDefaults(config) {
+  if (config?.requestTimeoutMs !== void 0) {
+    return config;
+  }
+  return { ...config, requestTimeoutMs: DEFAULT_ENGINE_REQUEST_TIMEOUT_MS };
+}
 function positiveInteger(value, fallback, name) {
   if (value === void 0) {
     return fallback;
@@ -82,7 +90,7 @@ function normalizeBloombergToolsOptions(options = {}) {
     core: options.core,
     disabledTools: disabledToolSet(options.disabledTools),
     engine: options.engine,
-    engineConfig: options.engineConfig,
+    engineConfig: engineConfigWithDefaults(options.engineConfig),
     maxBqlQueryChars: positiveInteger(
       options.maxBqlQueryChars,
       DEFAULT_MAX_BQL_QUERY_CHARS,
@@ -167,180 +175,6 @@ function createCoreResolver(options = {}) {
     options: normalized
   };
 }
-function inputJsonSchema(schema) {
-  const jsonSchema = zodToJsonSchema.zodToJsonSchema(schema, {
-    $refStrategy: "none",
-    effectStrategy: "input",
-    pipeStrategy: "input"
-  });
-  delete jsonSchema.$schema;
-  delete jsonSchema.definitions;
-  return jsonSchema;
-}
-function createBloombergStructuredTool(func, fields) {
-  const providerToolDefinition = {
-    type: "function",
-    function: {
-      description: fields.description,
-      name: fields.name,
-      parameters: inputJsonSchema(fields.schema)
-    }
-  };
-  return tools.tool(
-    func,
-    {
-      ...fields,
-      extras: { providerToolDefinition }
-    }
-  );
-}
-
-// src/cdx-fields.ts
-var CDX_INFO_FIELDS = Object.freeze([
-  "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 supplied by the user, such as <TICKER> <MARKET_SECTOR>, <INDEX_TICKER> <MARKET_SECTOR>, or <CREDIT_INDEX_TICKER> <MARKET_SECTOR>.",
-  "- For raw security identifiers, request or pass Bloomberg identifier syntax directly: /isin/<ISIN> for ISINs or /cusip/<CUSIP> for CUSIPs.",
-  "- Do not pass raw ISIN or CUSIP strings when the request is meant to identify a security. Do not use xbbg_bsrch as a replacement for a known ticker, ISIN, or CUSIP.",
-  "- For dealer quote / BQR workflows, use xbbg_bqr with a fixed-income identifier plus a dealer quote source such as /isin/<ISIN>@<QUOTE_SOURCE> <MARKET_SECTOR>. For raw intraday ticks, use xbbg_bdtick.",
-  "",
-  "## Core request tools",
-  "- xbbg_bdp: current or reference point-in-time fields. Use a small explicit securities list and a small explicit fields list. Use includeSecurityErrors only when the caller wants Bloomberg security errors in the response.",
-  "- xbbg_bdh: historical daily or periodic time series. Always provide explicit start and end dates in YYYY-MM-DD or YYYYMMDD form. Ask before choosing periodicity, currency, fill behavior, adjustment overrides, or a wide output table.",
-  "- xbbg_bds: Bloomberg bulk/table fields. Provide exactly one bulk field; do not use bds for ordinary multi-field reference data.",
-  "- xbbg_bdib: intraday bars only. Provide one ticker, explicit ISO start/end datetimes with time components, a positive interval in minutes, and timezone context when datetimes are naive.",
-  "- xbbg_bdtick: intraday tick data. Provide one ticker, explicit ISO start/end datetimes with time components, and explicit eventTypes unless the default event stream is intended. Use includeBrokerCodes or includeConditionCodes only when those columns are needed.",
-  "- xbbg_bql: BQL expressions only when the user asks for BQL or the request is naturally expressed as a bounded BQL query. Keep queries short, explicit, and scoped to the requested universe.",
-  "- xbbg_bsrch: Bloomberg search-grid or saved-search workflows only. Do not use it for ordinary security lookup.",
-  "- xbbg_bqr: Bloomberg Quote Request / dealer quotes. Prefer fixed-income identifier inputs with a dealer quote source such as /isin/<ISIN>@<QUOTE_SOURCE> <MARKET_SECTOR>, explicit start/end datetimes with time components, and explicit event types.",
-  "- xbbg_bflds: Bloomberg field metadata/search. Provide exactly one of fields or searchSpec; use searchSpec for natural-language field names and fields for known mnemonics.",
-  "- xbbg_beqs: Bloomberg equity screening by named BEQS screen. Prefer this over hand-written BQL when the user names an existing Bloomberg screen.",
-  "- xbbg_yas: fixed-income YAS recipe fields. Prefer this over manual YAS-style BDP requests when the user asks for yield, duration, spread, or price analytics.",
-  "- xbbg_preferreds: preferred stock discovery from an equity ticker. Prefer this over xbbg_ext_bql_builder plus xbbg_bql when the user wants the actual preferreds result.",
-  "- xbbg_corporate_bonds: bounded corporate bond universe query for a company ticker. Prefer this over generic BQL for company debt discovery.",
-  "- xbbg_index_members: index constituents through the core index recipe. Prefer this over generic BDS/BQL members when the user asks for constituents.",
-  "- xbbg_resolve_isins: resolves supplied ISIN strings to Bloomberg securities. Pass raw ISIN strings only for this recipe; otherwise use /isin/<ISIN> syntax with data tools.",
-  "- xbbg_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(<FIELD_1>, <FIELD_2>) for(<UNIVERSE>). Use placeholders such as '<TICKER> <MARKET_SECTOR>', holdings('<ETF_TICKER> <MARKET_SECTOR>'), or members('<INDEX_TICKER> <MARKET_SECTOR>') until the user supplies real inputs.",
-  "- Use BQL for universe-oriented analytics and screens only when the user provides a bounded universe, filters, and date range.",
-  "- Prefer xbbg_ext_bql_builder instead of hand-writing BQL for supported workflows: preferred stocks, corporate bonds, and ETF holdings.",
-  "- Do not use BQL just because the user asks for normal reference data; xbbg_bdp is simpler for current fields and xbbg_bdh is simpler for historical time series.",
-  "",
-  "## Output handling",
-  "- Tool results use LangChain content_and_artifact output: content starts with a compact summary and then includes bounded model-readable JSON; artifact is the structured bounded envelope with tool, rowCount, truncated, and data for application code.",
-  "- If a response is empty, truncated, or contains Bloomberg/security errors, say that directly. Do not fill gaps from memory or assumptions."
-];
-var OPTIONAL_EXTENSION_INSTRUCTIONS = [
-  "",
-  "## Extension helper tools",
-  "- xbbg_ext_ticker: ticker hygiene before live calls. parse_ticker splits a Bloomberg ticker, normalize_tickers trims/canonicalizes lists, filter_equity_tickers keeps equity-like tickers, is_specific_contract checks futures specificity, and validate_generic_ticker rejects malformed generic futures tickers.",
-  "- xbbg_ext_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. Use for a small bounded list of fully qualified securities. Use /isin/<ISIN> for ISINs and /cusip/<CUSIP> for CUSIPs. Example: securities ["<TICKER> <MARKET_SECTOR>"], fields ["<FIELD>"].';
-var BDH_DESCRIPTION = 'Bloomberg historical time series. Requires explicit start and end dates; ask before using if the date range or periodicity is ambiguous. Use /isin/<ISIN> for ISINs and /cusip/<CUSIP> for CUSIPs. Example: securities ["<TICKER> <MARKET_SECTOR>"], fields ["<FIELD>"], start "<START_DATE>", end "<END_DATE>".';
-var BDS_DESCRIPTION = 'Bloomberg bulk/table reference data. Requires exactly one bulk field, not a field list. Use /isin/<ISIN> for ISINs and /cusip/<CUSIP> for CUSIPs. Example: securities ["<INDEX_TICKER> <MARKET_SECTOR>"], field "<BULK_FIELD>".';
-var BDIB_DESCRIPTION = 'Bloomberg intraday bars. Requires one ticker plus explicit ISO start/end datetimes with time components and a positive interval in minutes. Use /isin/<ISIN> for ISINs and /cusip/<CUSIP> for CUSIPs. Example: ticker "<TICKER> <MARKET_SECTOR>", start "<START_DATETIME>", end "<END_DATETIME>", interval <MINUTES>.';
-var BDTICK_DESCRIPTION = 'Bloomberg intraday tick data. Requires one ticker plus explicit ISO start/end datetimes with time components. Set eventTypes explicitly, for example ["<EVENT_TYPE>"], and includeBrokerCodes/includeConditionCodes only when needed.';
-var BQL_DESCRIPTION = "Bloomberg Query Language expression sent as one complete query string. Use for bounded universe analytics with placeholder-shaped syntax such as get(<FIELD>) for('<TICKER> <MARKET_SECTOR>'), holdings('<ETF_TICKER> <MARKET_SECTOR>'), members('<INDEX_TICKER> <MARKET_SECTOR>'), filters with with(...), or dates=range(...). Prefer xbbg_bdp/xbbg_bdh for simple reference or historical requests.";
-var BSRCH_DESCRIPTION = 'Bloomberg search/grid request. Use for saved-search or ExcelGetGrid-style Bloomberg searches, not ordinary security lookup. Example searchSpec "<SEARCH_SPEC>".';
-var BQR_DESCRIPTION = 'Bloomberg Quote Request / dealer quotes. Use for fixed-income dealer quote ticks, preferably with an ISIN plus dealer source such as "/isin/<ISIN>@<QUOTE_SOURCE> <MARKET_SECTOR>"; requires explicit ISO start/end datetimes with time components. Set eventTypes explicitly, for example ["<EVENT_TYPE>"].';
-var BFLDS_DESCRIPTION = 'Bloomberg field metadata and field search. Use first when a field mnemonic is uncertain. Provide exactly one of fields or searchSpec. Example: fields ["<FIELD>"] or searchSpec "<FIELD_SEARCH_TEXT>".';
-var BEQS_DESCRIPTION = "Bloomberg equity screening by named BEQS screen. Use when the user names an existing Bloomberg screen and wants its bounded result set. Prefer this over hand-written BQL for saved Bloomberg screens.";
-var YAS_DESCRIPTION = "Bloomberg fixed-income YAS recipe fields for one or more bonds. Use for 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 analytics fields.";
-var EXT_CONSTANTS_DESCRIPTION = "Static Bloomberg helper constants for date parsing/formatting, futures months, dividend types, and ETF/dividend columns.";
-var EXT_COLUMNS_DESCRIPTION = "Column rename helpers for dividend, ETF, and earnings-shaped Bloomberg responses.";
-var EXT_CALCULATE_DESCRIPTION = "Small numeric helper operations for Bloomberg workflows, including level percentage calculations.";
 
 // src/result-limits.ts
 var MAX_RESULT_DEPTH = 32;
@@ -383,7 +217,16 @@ function limitValue(value, maxRows, maxStringChars, state, depth = 0, seen = /*
       state.truncated = true;
       return "[Circular]";
     }
+    if (ArrayBuffer.isView(value) || value instanceof ArrayBuffer) {
+      state.truncated = true;
+      return `[binary data: ${value.byteLength} bytes]`;
+    }
     if (!isPlainObject(value)) {
+      const toJSON = value.toJSON;
+      if (typeof toJSON === "function") {
+        seen.add(value);
+        return limitValue(toJSON.call(value), maxRows, maxStringChars, state, depth + 1, seen);
+      }
       return value;
     }
     seen.add(value);
@@ -402,12 +245,12 @@ function rowCountOf(value) {
   if (typeof value !== "object" || value === null) {
     return null;
   }
-  const record2 = value;
-  const rowCount = record2.rowCount;
+  const record3 = value;
+  const rowCount = record3.rowCount;
   if (typeof rowCount === "number" && Number.isInteger(rowCount) && rowCount >= 0) {
     return rowCount;
   }
-  const updateCount = record2.updateCount;
+  const updateCount = record3.updateCount;
   if (typeof updateCount === "number" && Number.isInteger(updateCount) && updateCount >= 0) {
     return updateCount;
   }
@@ -462,8 +305,10 @@ function limitResult(value, maxRows, maxStringChars) {
 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.rowCount === 0 || envelope.data === null || envelope.data === void 0) {
+    notes.push(
+      "empty result; verify identifiers, fields, and date range before concluding no data exists"
+    );
   }
   if (envelope.truncated) {
     notes.push("artifact truncated to configured limits");
@@ -503,16 +348,596 @@ function createToolResult(tool2, value, maxRows, maxStringChars) {
 function throwWithToolContext(tool2, error) {
   const prefix = `${tool2} failed`;
   if (error instanceof Error) {
-    if (!error.message.startsWith(prefix)) {
-      Object.defineProperty(error, "message", {
-        configurable: true,
-        value: `${prefix}: ${error.message}`
-      });
+    if (error.message.startsWith(prefix)) {
+      throw error;
+    }
+    const wrapped = new Error(`${prefix}: ${error.message}`, { cause: error });
+    wrapped.name = error.name;
+    throw wrapped;
+  }
+  throw new Error(`${prefix}: ${String(error)}`);
+}
+
+// src/langchain-tool.ts
+function inputJsonSchema(schema) {
+  const jsonSchema = zodToJsonSchema.zodToJsonSchema(schema, {
+    $refStrategy: "none",
+    effectStrategy: "input",
+    pipeStrategy: "input"
+  });
+  delete jsonSchema.$schema;
+  delete jsonSchema.definitions;
+  return jsonSchema;
+}
+function toolParameterJsonSchema(toolInstance) {
+  const schema = toolInstance.schema;
+  if (schema !== null && typeof schema === "object" && !("safeParse" in schema)) {
+    return schema;
+  }
+  return inputJsonSchema(schema);
+}
+function createBloombergStructuredTool(func, fields) {
+  const providerToolDefinition = {
+    type: "function",
+    function: {
+      description: fields.description,
+      name: fields.name,
+      parameters: inputJsonSchema(fields.schema)
+    }
+  };
+  const guarded = async (input, config) => {
+    try {
+      config?.signal?.throwIfAborted();
+    } catch (error) {
+      throwWithToolContext(fields.name, error);
+    }
+    return await func(input, config);
+  };
+  return tools.tool(
+    guarded,
+    {
+      ...fields,
+      extras: { providerToolDefinition }
+    }
+  );
+}
+
+// src/chart-spec.ts
+var VEGA_SCHEMA = "https://vega.github.io/schema/vega-lite/v5.json";
+var COMPONENT_NAME = "xbbg_chart";
+var X_FIELD_CANDIDATES = ["date", "time", "datetime", "timestamp"];
+var LABEL_FIELD_CANDIDATES = ["ticker", "security", "member", "name", "label"];
+var SERIES_FIELD_CANDIDATES = ["ticker", "security", "field", "side", "category"];
+var VALUE_FIELD_CANDIDATES = [
+  "value",
+  "PX_LAST",
+  "close",
+  "price",
+  "weight",
+  "marketValue",
+  "market_value"
+];
+var OPEN_FIELD_CANDIDATES = ["open", "OPEN", "PX_OPEN"];
+var HIGH_FIELD_CANDIDATES = ["high", "HIGH", "PX_HIGH"];
+var LOW_FIELD_CANDIDATES = ["low", "LOW", "PX_LOW"];
+var CLOSE_FIELD_CANDIDATES = ["close", "CLOSE", "PX_LAST", "last", "value"];
+var SIDE_FIELD_CANDIDATES = ["side", "SIDE", "type"];
+var PRICE_FIELD_CANDIDATES = ["price", "PRICE", "px", "PX"];
+var SIZE_FIELD_CANDIDATES = ["size", "SIZE", "quantity", "qty", "volume"];
+function defaultChartForSource(source) {
+  switch (source) {
+    case "bdib":
+      return "candlestick";
+    case "depth":
+      return "depth";
+    case "holdings":
+      return "bar";
+    case "bdh":
+    case "rows":
+      return "line";
+  }
+}
+function fieldExists(rows, field) {
+  for (const row of rows) {
+    if (Object.prototype.hasOwnProperty.call(row, field)) {
+      return true;
+    }
+  }
+  return false;
+}
+function findCandidateField(rows, candidates) {
+  for (const candidate of candidates) {
+    if (fieldExists(rows, candidate)) {
+      return candidate;
+    }
+  }
+  const first = rows[0];
+  if (first === void 0) {
+    return void 0;
+  }
+  const keys = Object.keys(first);
+  for (const candidate of candidates) {
+    const lower = candidate.toLowerCase();
+    const match = keys.find((key) => key.toLowerCase() === lower);
+    if (match !== void 0 && fieldExists(rows, match)) {
+      return match;
+    }
+  }
+  return void 0;
+}
+function requireField(rows, field, label, candidates) {
+  const resolved = field ?? findCandidateField(rows, candidates);
+  if (resolved === void 0 || !fieldExists(rows, resolved)) {
+    throw new Error(
+      `Missing ${label}; pass ${label} explicitly or include one of: ${candidates.join(", ")}`
+    );
+  }
+  return resolved;
+}
+function hasFiniteNumber(rows, field) {
+  for (const row of rows) {
+    if (typeof row[field] === "number" && Number.isFinite(row[field])) {
+      return true;
+    }
+  }
+  return false;
+}
+function firstNumericField(rows, excludedField) {
+  const first = rows[0];
+  if (first === void 0) {
+    return void 0;
+  }
+  for (const key of Object.keys(first)) {
+    if (key !== excludedField && hasFiniteNumber(rows, key)) {
+      return key;
+    }
+  }
+  return void 0;
+}
+function requireNumericField(rows, field, label) {
+  if (!hasFiniteNumber(rows, field)) {
+    throw new Error(`${label} (${field}) must contain at least one finite numeric value`);
+  }
+}
+function inferVegaType(rows, field) {
+  for (const row of rows) {
+    const value = row[field];
+    if (typeof value === "number") {
+      return "quantitative";
+    }
+    if (typeof value === "string" && (/^\d{4}-\d{2}-\d{2}(?:$|[T\s])/u.test(value) || /^\d{8}$/u.test(value))) {
+      return "temporal";
+    }
+  }
+  return "nominal";
+}
+function normalizeTemporalRows(rows, field) {
+  let normalized;
+  for (let index = 0; index < rows.length; index += 1) {
+    const row = rows[index];
+    if (row === void 0) {
+      continue;
+    }
+    const value = row[field];
+    if (typeof value !== "string" || !/^\d{8}$/u.test(value)) {
+      normalized?.push(row);
+      continue;
+    }
+    normalized ??= rows.slice(0, index);
+    normalized.push({
+      ...row,
+      [field]: `${value.slice(0, 4)}-${value.slice(4, 6)}-${value.slice(6, 8)}`
+    });
+  }
+  return normalized ?? rows;
+}
+function tooltip(fields) {
+  return fields.map((field) => ({
+    field,
+    type: field === "_xbbg_value" ? "quantitative" : "nominal"
+  }));
+}
+function datumField(field) {
+  return `datum[${JSON.stringify(field)}]`;
+}
+function buildGenericSpec(input, rows, chart, title) {
+  const xField = requireField(rows, input.xField, "xField", X_FIELD_CANDIDATES);
+  let yFields;
+  if (input.yFields !== void 0) {
+    yFields = input.yFields;
+  } else {
+    const yField = findCandidateField(rows, VALUE_FIELD_CANDIDATES) ?? firstNumericField(rows, xField);
+    if (yField === void 0) {
+      throw new Error("Missing yFields; include at least one numeric value field");
+    }
+    yFields = [yField];
+  }
+  if (yFields.length === 0) {
+    throw new Error("Missing yFields; include at least one numeric value field");
+  }
+  for (const field of yFields) {
+    if (!fieldExists(rows, field)) {
+      throw new Error(`Missing y field: ${field}`);
+    }
+    requireNumericField(rows, field, "yField");
+  }
+  const normalizedRows = inferVegaType(rows, xField) === "temporal" ? normalizeTemporalRows(rows, xField) : rows;
+  const seriesField = input.seriesField ?? (yFields.length === 1 ? findCandidateField(rows, SERIES_FIELD_CANDIDATES) : void 0);
+  if (seriesField !== void 0 && !fieldExists(rows, seriesField)) {
+    throw new Error(`Missing series field: ${seriesField}`);
+  }
+  const mark = chart === "scatter" ? "point" : chart;
+  const encoding = {
+    x: { field: xField, title: xField, type: inferVegaType(normalizedRows, xField) }
+  };
+  const transform = [];
+  if (yFields.length === 1) {
+    const yField = yFields[0];
+    if (yField === void 0) {
+      throw new Error("Missing yFields; include at least one numeric value field");
+    }
+    encoding.y = { field: yField, title: yField, type: "quantitative" };
+    if (seriesField !== void 0) {
+      encoding.color = { field: seriesField, title: seriesField, type: "nominal" };
     }
-    throw error;
+    encoding.tooltip = tooltip([
+      xField,
+      ...seriesField === void 0 ? [] : [seriesField],
+      yField
+    ]);
+  } else {
+    transform.push({ as: ["_xbbg_series", "_xbbg_value"], fold: yFields });
+    encoding.y = { field: "_xbbg_value", title: "value", type: "quantitative" };
+    encoding.color = { field: "_xbbg_series", title: "series", type: "nominal" };
+    if (seriesField !== void 0) {
+      encoding.detail = { field: seriesField, type: "nominal" };
+    }
+    encoding.tooltip = tooltip([
+      xField,
+      ...seriesField === void 0 ? [] : [seriesField],
+      "_xbbg_series",
+      "_xbbg_value"
+    ]);
+  }
+  const spec = {
+    $schema: VEGA_SCHEMA,
+    data: { values: normalizedRows },
+    description: `xbbg ${chart} chart spec for ${input.source}`,
+    mark: { type: mark, tooltip: true },
+    title,
+    ...transform.length === 0 ? {} : { transform },
+    encoding
+  };
+  return { spec, xField, yFields, ...seriesField === void 0 ? {} : { seriesField } };
+}
+function buildBarSpec(input, rows, title) {
+  const xField = requireField(
+    rows,
+    input.xField ?? input.labelField,
+    "labelField",
+    LABEL_FIELD_CANDIDATES
+  );
+  const yField = requireField(
+    rows,
+    input.valueField ?? input.yFields?.[0],
+    "valueField",
+    VALUE_FIELD_CANDIDATES
+  );
+  requireNumericField(rows, yField, "valueField");
+  const seriesField = input.seriesField;
+  if (seriesField !== void 0 && !fieldExists(rows, seriesField)) {
+    throw new Error(`Missing series field: ${seriesField}`);
+  }
+  const encoding = {
+    x: { field: xField, sort: "-y", title: xField, type: inferVegaType(rows, xField) },
+    y: { field: yField, title: yField, type: "quantitative" },
+    tooltip: tooltip([xField, ...seriesField === void 0 ? [] : [seriesField], yField])
+  };
+  if (seriesField !== void 0) {
+    encoding.color = { field: seriesField, title: seriesField, type: "nominal" };
+  }
+  return {
+    spec: {
+      $schema: VEGA_SCHEMA,
+      data: { values: rows },
+      description: `xbbg bar chart spec for ${input.source}`,
+      encoding,
+      mark: { type: "bar", tooltip: true },
+      title
+    },
+    xField,
+    yFields: [yField],
+    ...seriesField === void 0 ? {} : { seriesField }
+  };
+}
+function buildCandlestickSpec(input, rows, title) {
+  const xField = requireField(rows, input.xField, "xField", X_FIELD_CANDIDATES);
+  const openField = requireField(rows, input.openField, "openField", OPEN_FIELD_CANDIDATES);
+  const highField = requireField(rows, input.highField, "highField", HIGH_FIELD_CANDIDATES);
+  const lowField = requireField(rows, input.lowField, "lowField", LOW_FIELD_CANDIDATES);
+  const closeField = requireField(rows, input.closeField, "closeField", CLOSE_FIELD_CANDIDATES);
+  for (const [label, field] of [
+    ["openField", openField],
+    ["highField", highField],
+    ["lowField", lowField],
+    ["closeField", closeField]
+  ]) {
+    requireNumericField(rows, field, label);
+  }
+  const normalizedRows = inferVegaType(rows, xField) === "temporal" ? normalizeTemporalRows(rows, xField) : rows;
+  const color = {
+    condition: { test: `${datumField(closeField)} >= ${datumField(openField)}`, value: "#137333" },
+    value: "#c5221f"
+  };
+  return {
+    spec: {
+      $schema: VEGA_SCHEMA,
+      data: { values: normalizedRows },
+      description: `xbbg candlestick chart spec for ${input.source}`,
+      encoding: {
+        x: { field: xField, title: xField, type: inferVegaType(normalizedRows, xField) }
+      },
+      layer: [
+        {
+          mark: "rule",
+          encoding: {
+            color,
+            tooltip: tooltip([xField, openField, highField, lowField, closeField]),
+            y: { field: lowField, title: "price", type: "quantitative" },
+            y2: { field: highField }
+          }
+        },
+        {
+          mark: "bar",
+          encoding: {
+            color,
+            y: { field: openField, title: "price", type: "quantitative" },
+            y2: { field: closeField }
+          }
+        }
+      ],
+      title
+    },
+    xField,
+    yFields: [openField, highField, lowField, closeField]
+  };
+}
+function buildDepthSpec(input, rows, title) {
+  const priceField = requireField(
+    rows,
+    input.priceField ?? input.xField,
+    "priceField",
+    PRICE_FIELD_CANDIDATES
+  );
+  const sizeField = requireField(
+    rows,
+    input.sizeField ?? input.valueField ?? input.yFields?.[0],
+    "sizeField",
+    SIZE_FIELD_CANDIDATES
+  );
+  const sideField = requireField(
+    rows,
+    input.sideField ?? input.seriesField,
+    "sideField",
+    SIDE_FIELD_CANDIDATES
+  );
+  requireNumericField(rows, priceField, "priceField");
+  requireNumericField(rows, sizeField, "sizeField");
+  return {
+    spec: {
+      $schema: VEGA_SCHEMA,
+      data: { values: rows },
+      description: `xbbg market depth chart spec for ${input.source}`,
+      encoding: {
+        color: { field: sideField, title: sideField, type: "nominal" },
+        tooltip: tooltip([sideField, priceField, sizeField]),
+        x: { field: priceField, title: priceField, type: "quantitative" },
+        y: { field: sizeField, title: sizeField, type: "quantitative" }
+      },
+      mark: { type: "bar", tooltip: true },
+      title
+    },
+    xField: priceField,
+    yFields: [sizeField],
+    seriesField: sideField
+  };
+}
+function createChartSpec(input) {
+  const maxPoints = input.maxPoints ?? input.rows.length;
+  const rows = input.rows.length > maxPoints ? input.rows.slice(0, maxPoints) : input.rows;
+  if (rows.length === 0) {
+    throw new Error("rows must contain at least one chart data row");
+  }
+  const chart = input.chart ?? defaultChartForSource(input.source);
+  const title = input.title ?? `${input.source} ${chart}`;
+  const warnings = [];
+  if (rows.length !== input.rows.length) {
+    warnings.push(
+      `Chart spec contains first ${rows.length} of ${input.rows.length} rows; narrow the upstream request for a complete visualization.`
+    );
+  }
+  const built = chart === "candlestick" ? buildCandlestickSpec(input, rows, title) : chart === "depth" ? buildDepthSpec(input, rows, title) : chart === "bar" ? buildBarSpec(input, rows, title) : buildGenericSpec(input, rows, chart, title);
+  const summary = {
+    chart,
+    inputRows: input.rows.length,
+    renderer: "vega-lite",
+    rowCount: rows.length,
+    source: input.source,
+    title,
+    truncatedInput: rows.length !== input.rows.length,
+    xField: built.xField,
+    yFields: built.yFields,
+    ...built.seriesField === void 0 ? {} : { seriesField: built.seriesField }
+  };
+  return {
+    kind: "xbbg.visualization",
+    version: 1,
+    component: COMPONENT_NAME,
+    renderer: "vega-lite",
+    rowCount: rows.length,
+    inputRowCount: input.rows.length,
+    truncatedInput: rows.length !== input.rows.length,
+    source: input.source,
+    chart,
+    summary,
+    spec: built.spec,
+    warnings
+  };
+}
+
+// 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.",
+  "- Issue one tool call per dataset and read any error before retrying; never probe parameter variants in parallel. Omit optional output-shape parameters such as format unless the user asked for a specific shape.",
+  "",
+  "## Security identifiers",
+  "- Pass each security in the form the user supplied it; never translate between identifier kinds on your own.",
+  "- User supplied a Bloomberg ticker: pass it through fully qualified as <TICKER> <MARKET_SECTOR>, for example <TICKER> <EXCHANGE> Equity, <INDEX_TICKER> Index, or <CCY_PAIR> Curncy.",
+  "- The market sector ending (Bloomberg yellow key) is part of the security string. The sectors are: Equity, Index, Curncy, Comdty, Corp, Govt, Muni, Mtge, M-Mkt, and Pfd. Equity securities carry an exchange or composite code before the sector (<TICKER> <EXCHANGE> Equity); preferred securities use the Pfd sector; corporate and government bonds use Corp and Govt. Request tools pass the security through to Bloomberg without validating the sector, so copy it exactly as the user supplied it.",
+  "- User supplied a raw ISIN or CUSIP: pass Bloomberg identifier syntax directly: /isin/<ISIN> or /cusip/<CUSIP>. Never pass the bare identifier without its prefix, except to xbbg_resolve_isins and xbbg_issuer_isins, which take raw ISIN strings.",
+  "- <TICKER> <MARKET_SECTOR> is a format template, not authorization to construct a ticker. Never invent, recall from memory, or guess the Bloomberg ticker behind an identifier the user gave; identifier syntax is already a complete, valid security input. Use xbbg_resolve_isins only when the user wants the resolved Bloomberg security itself.",
+  "- Recipe tools that take tickers (xbbg_preferreds, xbbg_corporate_bonds, xbbg_index_members, xbbg_etf_holdings) do not accept identifier syntax. When the user supplied an ISIN or CUSIP for those workflows, resolve it with xbbg_resolve_isins first and use the returned Bloomberg security; never guess the ticker.",
+  "- Do not use xbbg_bsrch as a replacement for a known ticker, ISIN, or CUSIP.",
+  "- For dealer quote / BQR workflows, use xbbg_bqr with a fixed-income identifier plus a dealer quote source such as /isin/<ISIN>@<QUOTE_SOURCE> <MARKET_SECTOR>. For raw intraday ticks, use xbbg_bdtick.",
+  "",
+  "## Core request tools",
+  "- xbbg_bdp: current or reference point-in-time fields. 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. Provide exactly one bulk field; do not use bds for ordinary multi-field reference data.",
+  "- xbbg_bdib: intraday bars only. Provide one ticker, explicit ISO start/end datetimes with time components, a positive interval in minutes, and timezone context when datetimes are naive.",
+  "- xbbg_bdtick: intraday tick data. Provide one ticker, explicit ISO start/end datetimes with time components, and explicit eventTypes unless the default event stream is intended. Use includeBrokerCodes or includeConditionCodes only when those columns are needed.",
+  "- xbbg_bql: BQL expressions only when the user asks for BQL or the request is naturally expressed as a bounded BQL query. Keep queries short, explicit, and scoped to the requested universe.",
+  "- xbbg_bsrch: Bloomberg search-grid or saved-search workflows only. Do not use it for ordinary security lookup.",
+  "- xbbg_bqr: Bloomberg Quote Request / dealer quotes. Prefer fixed-income identifier inputs with a dealer quote source such as /isin/<ISIN>@<QUOTE_SOURCE> <MARKET_SECTOR>, explicit start/end datetimes with time components, and explicit event types.",
+  "- xbbg_bflds: Bloomberg field metadata/search. Provide exactly one of fields or searchSpec; use searchSpec for natural-language field names and fields for known mnemonics.",
+  "- xbbg_beqs: Bloomberg equity screening by named BEQS screen. Prefer this over hand-written BQL when the user names an existing Bloomberg screen.",
+  "- xbbg_yas: fixed-income YAS recipe fields. Prefer this over manual YAS-style BDP requests when the user asks for yield, duration, spread, or price analytics.",
+  "- xbbg_preferreds: preferred stock discovery from the issuer's common equity ticker, never a guessed preferred ('Pfd') ticker. Resolve a supplied ISIN/CUSIP with xbbg_resolve_isins first. Prefer this over xbbg_ext_bql_builder plus xbbg_bql when the user wants the actual preferreds result.",
+  "- xbbg_corporate_bonds: bounded corporate bond universe query for a company ticker. Prefer this over generic BQL for company debt discovery.",
+  "- xbbg_index_members: index constituents through the core index recipe. Prefer this over generic BDS/BQL members when the user asks for constituents.",
+  "- xbbg_resolve_isins: resolves supplied ISIN strings to Bloomberg securities. Pass raw ISIN strings only for this recipe; otherwise use /isin/<ISIN> syntax with data tools.",
+  "- xbbg_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(<FIELD_1>, <FIELD_2>) for(<UNIVERSE>). Use placeholders such as '<TICKER> <MARKET_SECTOR>', holdings('<ETF_TICKER> <MARKET_SECTOR>'), or members('<INDEX_TICKER> <MARKET_SECTOR>') until the user supplies real inputs.",
+  "- Use BQL for universe-oriented analytics and screens only when the user provides a bounded universe, filters, and date range.",
+  "- Prefer xbbg_ext_bql_builder instead of hand-writing BQL for supported workflows: preferred stocks, corporate bonds, and ETF holdings.",
+  "- Do not use BQL just because the user asks for normal reference data; xbbg_bdp is simpler for current fields and xbbg_bdh is simpler for historical time series.",
+  "",
+  "## Output handling",
+  "- Tool results use LangChain content_and_artifact output: content starts with a compact summary and then includes bounded model-readable JSON; artifact is the structured bounded envelope with tool, rowCount, truncated, and data for application code.",
+  "- If a response is empty, truncated, or contains Bloomberg/security errors, say that directly. Do not fill gaps from memory or assumptions."
+];
+var OPTIONAL_EXTENSION_INSTRUCTIONS = [
+  "",
+  "## Extension helper tools",
+  "- xbbg_ext_ticker: ticker hygiene before live calls. parse_ticker splits generic futures-style tickers only \u2014 asset endings Index, Curncy, Comdty, or Corp as <ROOT><N> <ASSET>, or <ROOT><N> <EXCHANGE> Equity \u2014 and rejects other market sectors (Pfd, Govt, Muni, Mtge, M-Mkt) and non-futures securities. normalize_tickers trims/canonicalizes lists, filter_equity_tickers keeps equity-like tickers, is_specific_contract checks futures specificity, and validate_generic_ticker rejects malformed generic futures tickers.",
+  "- xbbg_ext_futures: futures contract construction and selection. Use build_futures_ticker for root/month/year/asset assembly, get_futures_months for month-code lookup, generate_candidates for generic-to-specific candidates, contract_index for generic contract rank, filter_candidates_by_cycle for HMUZ/quarterly cycles, and filter_valid_contracts to keep contracts valid for a date.",
+  "- xbbg_ext_cdx: CDX ticker workflow support. Use parse_cdx_ticker to understand a CDX ticker, previous_cdx_series to roll back a series, cdx_gen_to_specific to resolve a generic CDX to a target series, and cdx_info/cdx_pricing/cdx_risk for predefined BDP field bundles. cdx_pricing and cdx_risk accept recoveryRate, which becomes the CDS_RR override.",
+  "- xbbg_ext_currency: currency-planning helpers. build_fx_pair constructs the Bloomberg FX pair and conversion factor, same_currency avoids unnecessary conversion, and currencies_needing_conversion identifies which currencies differ from a target before requesting converted values.",
+  "- 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_chart_spec: renderer-neutral chart spec helper. Convert bounded rows from xbbg_bdh, xbbg_bdib, holdings, depth, or already-shaped row data into a Vega-Lite JSON spec for frontend rendering; do not use it as proof that Bloomberg data was fetched.",
+  "- 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);
   }
-  throw new Error(`${prefix}: ${String(error)}`);
+  if (includeLimitReminder) {
+    lines.push(...OPTIONAL_LIMIT_INSTRUCTIONS);
+  }
+  return lines.join("\n");
 }
+var BDP_DESCRIPTION = 'Bloomberg reference data for current or point-in-time fields. Use for a small bounded list of fully qualified securities. Use /isin/<ISIN> for ISINs and /cusip/<CUSIP> for CUSIPs. Example: securities ["<TICKER> <MARKET_SECTOR>"], fields ["<FIELD>"].';
+var BDH_DESCRIPTION = 'Bloomberg historical time series. Requires explicit start and end dates; ask before using if the date range or periodicity is ambiguous. Use /isin/<ISIN> for ISINs and /cusip/<CUSIP> for CUSIPs. Example: securities ["<TICKER> <MARKET_SECTOR>"], fields ["<FIELD>"], start "<START_DATE>", end "<END_DATE>".';
+var BDS_DESCRIPTION = 'Bloomberg bulk/table reference data. Requires exactly one bulk field, not a field list. Use /isin/<ISIN> for ISINs and /cusip/<CUSIP> for CUSIPs. Example: securities ["<INDEX_TICKER> <MARKET_SECTOR>"], field "<BULK_FIELD>".';
+var BDIB_DESCRIPTION = 'Bloomberg intraday bars. Requires one ticker plus explicit ISO start/end datetimes with time components and a positive interval in minutes. Use /isin/<ISIN> for ISINs and /cusip/<CUSIP> for CUSIPs. Example: ticker "<TICKER> <MARKET_SECTOR>", start "<START_DATETIME>", end "<END_DATETIME>", interval <MINUTES>.';
+var BDTICK_DESCRIPTION = 'Bloomberg intraday tick data. Requires one ticker plus explicit ISO start/end datetimes with time components. Set eventTypes explicitly, for example ["<EVENT_TYPE>"], and includeBrokerCodes/includeConditionCodes only when needed.';
+var BQL_DESCRIPTION = "Bloomberg Query Language expression sent as one complete query string. Use for bounded universe analytics with placeholder-shaped syntax such as get(<FIELD>) for('<TICKER> <MARKET_SECTOR>'), holdings('<ETF_TICKER> <MARKET_SECTOR>'), members('<INDEX_TICKER> <MARKET_SECTOR>'), filters with with(...), or dates=range(...). Prefer xbbg_bdp/xbbg_bdh for simple reference or historical requests.";
+var BSRCH_DESCRIPTION = 'Bloomberg search/grid request. Use for saved-search or ExcelGetGrid-style Bloomberg searches, not ordinary security lookup. Example searchSpec "<SEARCH_SPEC>".';
+var BQR_DESCRIPTION = 'Bloomberg Quote Request / dealer quotes. Use for fixed-income dealer quote ticks, preferably with an ISIN plus dealer source such as "/isin/<ISIN>@<QUOTE_SOURCE> <MARKET_SECTOR>"; requires explicit ISO start/end datetimes with time components. Set eventTypes explicitly, for example ["<EVENT_TYPE>"].';
+var BFLDS_DESCRIPTION = 'Bloomberg field metadata and field search. Use first when a field mnemonic is uncertain. Provide exactly one of fields or searchSpec. Example: fields ["<FIELD>"] or searchSpec "<FIELD_SEARCH_TEXT>".';
+var BEQS_DESCRIPTION = "Bloomberg equity screening by named BEQS screen. Use when the user names an existing Bloomberg screen and wants its bounded result set. Prefer this over hand-written BQL for saved Bloomberg screens.";
+var YAS_DESCRIPTION = "Bloomberg fixed-income YAS recipe fields for one or more bonds. Use for yield, duration, spread, benchmark, or price analytics; provide explicit fields and optional settlement/yield/price inputs. Pass securities as supplied: '<TICKER> <MARKET_SECTOR>' or identifier syntax such as '/isin/<ISIN> <MARKET_SECTOR>'.";
+var PREFERREDS_DESCRIPTION = "Preferred stock discovery for one issuer. Takes the issuer's common equity ticker such as '<TICKER> US Equity', never a preferred ('Pfd') ticker and never a guessed one. If the user supplied an ISIN or CUSIP, resolve it with xbbg_resolve_isins first.";
+var CORPORATE_BONDS_DESCRIPTION = "Corporate bond universe query for one issuer/company equity ticker, with optional currency, active-only filter, and result fields. Prefer this over generic BQL for company debt discovery. If the user supplied an ISIN or CUSIP, resolve it with xbbg_resolve_isins first; never guess the ticker.";
+var INDEX_MEMBERS_DESCRIPTION = "Index constituent recipe for one Bloomberg index ticker such as '<INDEX_TICKER> Index'. Use for bounded member lists and optional historical/as-of constituent membership; never guess index tickers.";
+var RESOLVE_ISINS_DESCRIPTION = "Resolve raw ISIN strings to Bloomberg securities through the core ISIN recipe. Do not add /isin/ prefixes in this tool; pass the exact ISIN strings supplied by the user.";
+var ISSUER_ISINS_DESCRIPTION = "Issuer/bond ISIN workflow for supplied bond ISIN strings. Use for issuer-level ISIN discovery starting from known bond ISINs.";
+var ETF_HOLDINGS_DESCRIPTION = "ETF holdings recipe for one ETF ticker such as '<ETF_TICKER> <MARKET_SECTOR>'. Use when the user asks for ETF constituents or holdings and wants the bounded holdings result. Resolve a supplied ISIN/CUSIP with xbbg_resolve_isins first; never guess the ticker.";
+var STREAM_SNAPSHOT_DESCRIPTION = "Bounded live market-data snapshot from //blp/mktdata. Collects at most maxUpdates updates until timeout/done, then always unsubscribes; use for finite observations, not open subscriptions.";
+var MKTBAR_SNAPSHOT_DESCRIPTION = "Bounded live market-bar snapshot from //blp/mktbar for one ticker. Collects at most maxUpdates updates until timeout/done, then always unsubscribes.";
+var DEPTH_SNAPSHOT_DESCRIPTION = "Bounded live market-depth snapshot from //blp/mktdepthdata for one ticker. Collects at most maxUpdates updates until timeout/done, then always unsubscribes.";
+var EXT_TICKER_DESCRIPTION = "Ticker hygiene helpers: parse_ticker (generic futures-style tickers ending in Index, Curncy, Comdty, or Corp, or <ROOT><N> <EXCHANGE> Equity; other market sectors are rejected), normalize_tickers, filter_equity_tickers, is_specific_contract, and validate_generic_ticker.";
+var EXT_FUTURES_DESCRIPTION = "Futures helpers for contract construction and selection: build_futures_ticker, generate_candidates, contract_index, filter_candidates_by_cycle, filter_valid_contracts, and get_futures_months.";
+var EXT_CDX_DESCRIPTION = "CDX helpers for parsing, series rolling/resolution, and predefined info/pricing/risk BDP field bundles.";
+var EXT_CURRENCY_DESCRIPTION = "Currency planning helpers: build FX pairs, test same-currency requests, and find currencies needing conversion.";
+var EXT_BQL_BUILDER_DESCRIPTION = "BQL builders for preferred stocks, corporate bonds, and ETF holdings. Prefer to construct those bounded BQL shapes before xbbg_bql.";
+var EXT_CHART_SPEC_DESCRIPTION = "Renderer-neutral chart spec helper for frontend generative UI. Converts bounded Bloomberg rows from bdh, bdib, holdings, depth, or already-shaped row data into a Vega-Lite JSON spec; it does not fetch Bloomberg data or render images.";
+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 analytics fields.";
+var EXT_CONSTANTS_DESCRIPTION = "Static Bloomberg helper constants for date parsing/formatting, futures months, dividend types, and ETF/dividend columns.";
+var EXT_COLUMNS_DESCRIPTION = "Column rename helpers for dividend, ETF, and earnings-shaped Bloomberg responses.";
+var EXT_CALCULATE_DESCRIPTION = "Small numeric helper operations for Bloomberg workflows, including level percentage calculations.";
 var stringPairSchema = z__namespace.object({
   key: z__namespace.string().trim().min(1).describe("String pair key."),
   value: z__namespace.string().trim().min(1).describe("String pair value.")
@@ -534,7 +959,7 @@ function optionalString(options, description) {
 function tickerSchema(options) {
   const ticker = nonEmptyString(
     options,
-    "One Bloomberg ticker for parse/contract validation operations."
+    "One generic futures-style Bloomberg ticker: <ROOT><N> ending in Index, Curncy, Comdty, or Corp, or <ROOT><N> <EXCHANGE> Equity. parse_ticker rejects other market sectors (Pfd, Govt, Muni, Mtge, M-Mkt) and non-futures securities."
   );
   const tickers = stringArray(
     options,
@@ -550,94 +975,151 @@ function tickerSchema(options) {
   ]);
 }
 function futuresSchema(options) {
-  return z__namespace.object({
-    asset: optionalString(options, "Bloomberg asset class suffix supplied by the user."),
-    candidates: z__namespace.array(futuresCandidateSchema).min(1).max(options.maxFields).optional().describe("Candidate futures contracts."),
-    contracts: z__namespace.array(stringPairSchema).min(1).max(options.maxFields).optional().describe("Contract pairs for validity filtering."),
-    count: z__namespace.number().int().positive().optional().describe("Maximum number of futures candidates to generate."),
-    cycle: optionalString(options, "Futures cycle code to filter candidates by."),
-    day: z__namespace.number().int().min(1).max(31).optional().describe("Day number for contract filtering."),
-    freq: optionalString(options, "Futures frequency/cycle hint."),
-    genTicker: optionalString(options, "Generic Bloomberg futures ticker."),
-    month: z__namespace.number().int().min(1).max(12).optional().describe("Month number, 1-12."),
-    monthCode: optionalString(options, "Bloomberg futures month code, for example H."),
-    operation: z__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: z__namespace.union([z__namespace.string().trim().min(1), z__namespace.number().int()]).optional().describe("Contract year.")
-  });
+  const genTicker = nonEmptyString(
+    options,
+    "Generic Bloomberg futures ticker, for example ES1 Index."
+  );
+  const year = z__namespace.number().int().describe("Contract year, for example 2024.");
+  const month = z__namespace.number().int().min(1).max(12).describe("Month number, 1-12.");
+  const day = z__namespace.number().int().min(1).max(31).describe("Day number, 1-31.");
+  return z__namespace.discriminatedUnion("operation", [
+    z__namespace.object({
+      asset: nonEmptyString(
+        options,
+        "Bloomberg asset class suffix, for example Index or Comdty."
+      ),
+      monthCode: nonEmptyString(options, "Bloomberg futures month code, for example H."),
+      operation: z__namespace.literal("build_futures_ticker"),
+      prefix: nonEmptyString(options, "Futures ticker root prefix, for example ES."),
+      year: z__namespace.union([z__namespace.string().trim().min(1), z__namespace.number().int().transform(String)]).describe("Contract year, full or abbreviated, as a string or integer.")
+    }).strict(),
+    z__namespace.object({
+      count: z__namespace.number().int().positive().optional().describe("Maximum number of futures candidates to generate."),
+      day,
+      freq: optionalString(options, "Futures frequency/cycle hint."),
+      genTicker,
+      month,
+      operation: z__namespace.literal("generate_candidates"),
+      year
+    }).strict(),
+    z__namespace.object({ genTicker, operation: z__namespace.literal("contract_index") }).strict(),
+    z__namespace.object({
+      candidates: z__namespace.array(futuresCandidateSchema).min(1).max(options.maxFields).describe("Candidate futures contracts."),
+      cycle: nonEmptyString(options, "Futures cycle code to filter candidates by."),
+      operation: z__namespace.literal("filter_candidates_by_cycle")
+    }).strict(),
+    z__namespace.object({
+      contracts: z__namespace.array(stringPairSchema).min(1).max(options.maxFields).describe("Contract pairs for validity filtering."),
+      day,
+      month,
+      operation: z__namespace.literal("filter_valid_contracts"),
+      year
+    }).strict(),
+    z__namespace.object({ operation: z__namespace.literal("get_futures_months") }).strict()
+  ]);
 }
 function cdxSchema(options) {
-  return z__namespace.object({
-    genTicker: optionalString(options, "Generic CDX ticker."),
-    operation: z__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: z__namespace.number().optional().describe("Optional recovery rate override for pricing/risk lookups."),
-    series: z__namespace.number().int().positive().optional().describe("Specific CDX series number."),
-    ticker: optionalString(options, "CDX ticker.")
-  });
+  const ticker = nonEmptyString(options, "CDX ticker, generic or specific.");
+  const recoveryRate = z__namespace.number().min(0).max(1).optional().describe("Decimal recovery rate override, e.g. 0.4 for 40%; sent as the CDS_RR override.");
+  return z__namespace.discriminatedUnion("operation", [
+    z__namespace.object({ operation: z__namespace.literal("parse_cdx_ticker"), ticker }).strict(),
+    z__namespace.object({ operation: z__namespace.literal("previous_cdx_series"), ticker }).strict(),
+    z__namespace.object({ operation: z__namespace.literal("cdx_info"), ticker }).strict(),
+    z__namespace.object({ operation: z__namespace.literal("cdx_pricing"), recoveryRate, ticker }).strict(),
+    z__namespace.object({ operation: z__namespace.literal("cdx_risk"), recoveryRate, ticker }).strict(),
+    z__namespace.object({
+      genTicker: nonEmptyString(
+        options,
+        "Generic CDX ticker, for example CDX IG CDSI GEN 5Y Corp."
+      ),
+      operation: z__namespace.literal("cdx_gen_to_specific"),
+      series: z__namespace.number().int().positive().describe("Specific CDX series number.")
+    }).strict()
+  ]);
 }
 function currencySchema(options) {
-  return z__namespace.object({
-    ccy1: optionalString(options, "First ISO currency code."),
-    ccy2: optionalString(options, "Second ISO currency code."),
-    currencies: stringArray(options, "ISO currency codes.").optional(),
-    fromCcy: optionalString(options, "Source ISO currency code."),
-    operation: z__namespace.enum(["build_fx_pair", "same_currency", "currencies_needing_conversion"]).describe("Currency helper operation to run."),
-    target: optionalString(options, "Target ISO currency code."),
-    toCcy: optionalString(options, "Destination ISO currency code.")
-  });
+  return z__namespace.discriminatedUnion("operation", [
+    z__namespace.object({
+      fromCcy: nonEmptyString(options, "Source ISO currency code."),
+      operation: z__namespace.literal("build_fx_pair"),
+      toCcy: nonEmptyString(options, "Destination ISO currency code.")
+    }).strict(),
+    z__namespace.object({
+      ccy1: nonEmptyString(options, "First ISO currency code."),
+      ccy2: nonEmptyString(options, "Second ISO currency code."),
+      operation: z__namespace.literal("same_currency")
+    }).strict(),
+    z__namespace.object({
+      currencies: stringArray(options, "ISO currency codes to check."),
+      operation: z__namespace.literal("currencies_needing_conversion"),
+      target: nonEmptyString(options, "Target ISO currency code.")
+    }).strict()
+  ]);
 }
 function bqlBuilderSchema(options) {
-  return z__namespace.object({
-    activeOnly: z__namespace.boolean().optional().describe("Restrict corporate bond query to active bonds."),
-    ccy: optionalString(options, "Currency filter for corporate bond query."),
-    equityTicker: optionalString(options, "Equity ticker for preferreds query."),
-    etfTicker: optionalString(options, "ETF ticker for holdings query."),
-    extraFields: stringArray(options, "Extra BQL fields to include.").optional(),
-    operation: z__namespace.enum(["build_preferreds_query", "build_corporate_bonds_query", "build_etf_holdings_query"]).describe("BQL builder operation to run."),
-    ticker: optionalString(options, "Ticker for corporate bond query.")
-  });
+  const extraFields = stringArray(options, "Extra BQL fields to include.").optional();
+  return z__namespace.discriminatedUnion("operation", [
+    z__namespace.object({
+      equityTicker: nonEmptyString(options, "Equity ticker for preferreds query."),
+      extraFields,
+      operation: z__namespace.literal("build_preferreds_query")
+    }).strict(),
+    z__namespace.object({
+      activeOnly: z__namespace.boolean().optional().describe("Restrict corporate bond query to active bonds."),
+      ccy: optionalString(options, "Currency filter for corporate bond query."),
+      extraFields,
+      operation: z__namespace.literal("build_corporate_bonds_query"),
+      ticker: nonEmptyString(options, "Ticker for corporate bond query.")
+    }).strict(),
+    z__namespace.object({
+      etfTicker: nonEmptyString(options, "ETF ticker for holdings query."),
+      extraFields,
+      operation: z__namespace.literal("build_etf_holdings_query")
+    }).strict()
+  ]);
 }
 function marketSessionSchema(options) {
-  return z__namespace.object({
-    countryIso: optionalString(options, "ISO country code for timezone inference."),
-    date: optionalString(options, "Date for UTC session conversion, YYYY-MM-DD or YYYYMMDD."),
-    dayEnd: optionalString(options, "Exchange day end time, for example 16:00."),
-    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: z__namespace.enum([
-      "derive_sessions",
-      "get_market_rule",
-      "infer_timezone",
-      "session_times_to_utc",
-      "default_turnover_dates",
-      "default_bqr_datetimes",
-      "get_exchange_override",
-      "list_exchange_overrides"
-    ]).describe("Market session helper operation to run."),
-    startDate: optionalString(options, "Optional start date."),
-    startDatetime: optionalString(options, "Optional start datetime."),
-    startTime: optionalString(options, "Session start time, for example 09:30."),
-    ticker: optionalString(options, "Ticker for exchange override lookup.")
-  });
+  const mic = optionalString(options, "Market Identifier Code, for example XNYS.");
+  const exchCode = optionalString(options, "Bloomberg exchange code.");
+  return z__namespace.discriminatedUnion("operation", [
+    z__namespace.object({
+      dayEnd: nonEmptyString(options, "Exchange day end time, for example 16:00."),
+      dayStart: nonEmptyString(options, "Exchange day start time, for example 09:30."),
+      exchCode,
+      mic,
+      operation: z__namespace.literal("derive_sessions")
+    }).strict(),
+    z__namespace.object({ exchCode, mic, operation: z__namespace.literal("get_market_rule") }).strict(),
+    z__namespace.object({
+      countryIso: nonEmptyString(options, "ISO country code for timezone inference."),
+      operation: z__namespace.literal("infer_timezone")
+    }).strict(),
+    z__namespace.object({
+      date: nonEmptyString(options, "Date for UTC session conversion, YYYY-MM-DD or YYYYMMDD."),
+      endTime: nonEmptyString(options, "Session end time, for example 16:00."),
+      exchangeTz: nonEmptyString(
+        options,
+        "IANA exchange timezone, for example America/New_York."
+      ),
+      operation: z__namespace.literal("session_times_to_utc"),
+      startTime: nonEmptyString(options, "Session start time, for example 09:30.")
+    }).strict(),
+    z__namespace.object({
+      endDate: optionalString(options, "Optional end date."),
+      operation: z__namespace.literal("default_turnover_dates"),
+      startDate: optionalString(options, "Optional start date.")
+    }).strict(),
+    z__namespace.object({
+      endDatetime: optionalString(options, "Optional end datetime."),
+      operation: z__namespace.literal("default_bqr_datetimes"),
+      startDatetime: optionalString(options, "Optional start datetime.")
+    }).strict(),
+    z__namespace.object({
+      operation: z__namespace.literal("get_exchange_override"),
+      ticker: nonEmptyString(options, "Ticker for exchange override lookup.")
+    }).strict(),
+    z__namespace.object({ operation: z__namespace.literal("list_exchange_overrides") }).strict()
+  ]);
 }
 function yasOverridesSchema(options) {
   return z__namespace.object({
@@ -647,94 +1129,96 @@ function yasOverridesSchema(options) {
     spread: z__namespace.number().optional().describe("YAS spread override."),
     yieldType: z__namespace.number().int().optional().describe("YAS yield type override."),
     yieldVal: z__namespace.number().optional().describe("YAS yield value override.")
-  });
+  }).strict();
 }
 function constantsSchema(options) {
-  return z__namespace.object({
-    code: optionalString(options, "Month code."),
-    dateStr: optionalString(options, "Date string to parse."),
-    day: z__namespace.number().int().min(1).max(31).optional().describe("Day number."),
-    dvdType: optionalString(options, "Dividend type code or label."),
-    fmt: optionalString(options, "Date output format."),
-    month: z__namespace.number().int().min(1).max(12).optional().describe("Month number."),
-    monthName: optionalString(options, "Month name."),
-    operation: z__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: z__namespace.number().int().min(1).optional().describe("Year number.")
-  });
+  return z__namespace.discriminatedUnion("operation", [
+    z__namespace.object({
+      dateStr: nonEmptyString(options, "Date string to parse."),
+      operation: z__namespace.literal("parse_date")
+    }).strict(),
+    z__namespace.object({
+      day: z__namespace.number().int().min(1).max(31).describe("Day number, 1-31."),
+      fmt: optionalString(options, "Date output format."),
+      month: z__namespace.number().int().min(1).max(12).describe("Month number, 1-12."),
+      operation: z__namespace.literal("fmt_date"),
+      year: z__namespace.number().int().min(1).describe("Year number.")
+    }).strict(),
+    z__namespace.object({
+      monthName: nonEmptyString(options, "Month name, for example March."),
+      operation: z__namespace.literal("get_month_code")
+    }).strict(),
+    z__namespace.object({
+      code: nonEmptyString(options, "Month code, for example H."),
+      operation: z__namespace.literal("get_month_name")
+    }).strict(),
+    z__namespace.object({
+      dvdType: nonEmptyString(options, "Dividend type code or label."),
+      operation: z__namespace.literal("get_dvd_type")
+    }).strict(),
+    z__namespace.object({ operation: z__namespace.literal("get_futures_months") }).strict(),
+    z__namespace.object({ operation: z__namespace.literal("get_dvd_types") }).strict(),
+    z__namespace.object({ operation: z__namespace.literal("get_dvd_cols") }).strict(),
+    z__namespace.object({ operation: z__namespace.literal("get_etf_cols") }).strict()
+  ]);
 }
 function columnsSchema(options) {
-  return z__namespace.object({
-    columns: stringArray(options, "Column names to rename.").optional(),
-    dataColumns: stringArray(options, "Earnings data column names.").optional(),
-    headerRow: z__namespace.array(stringPairSchema).min(1).max(options.maxFields).optional().describe("Earnings header row key/value pairs."),
-    operation: z__namespace.enum(["rename_dividend_columns", "rename_etf_columns", "build_earning_header_rename"]).describe("Column helper operation to run.")
-  });
+  const columns = stringArray(options, "Column names to rename.");
+  return z__namespace.discriminatedUnion("operation", [
+    z__namespace.object({ columns, operation: z__namespace.literal("rename_dividend_columns") }).strict(),
+    z__namespace.object({ columns, operation: z__namespace.literal("rename_etf_columns") }).strict(),
+    z__namespace.object({
+      dataColumns: stringArray(options, "Earnings data column names."),
+      headerRow: z__namespace.array(stringPairSchema).min(1).max(options.maxFields).describe("Earnings header row key/value pairs."),
+      operation: z__namespace.literal("build_earning_header_rename")
+    }).strict()
+  ]);
 }
 function calculateSchema(options) {
   return z__namespace.object({
     levels: z__namespace.array(z__namespace.number().nullable()).min(1).max(options.maxFields).describe("Reference level values."),
     operation: z__namespace.literal("calculate_level_percentages").describe("Numeric helper operation to run."),
     values: z__namespace.array(z__namespace.number().nullable()).min(1).max(options.maxFields).describe("Observed values.")
+  }).strict().superRefine((input, ctx) => {
+    if (input.values.length !== input.levels.length) {
+      ctx.addIssue({
+        code: z__namespace.ZodIssueCode.custom,
+        message: "values and levels must have the same length"
+      });
+    }
   });
 }
+function chartSpecSchema(options) {
+  const chartScalar = z__namespace.union([
+    z__namespace.string().trim().max(options.maxStringChars),
+    z__namespace.number(),
+    z__namespace.boolean(),
+    z__namespace.null()
+  ]);
+  const fieldName = nonEmptyString(options, "Input row field name.");
+  return z__namespace.object({
+    chart: z__namespace.enum(["line", "area", "bar", "scatter", "candlestick", "depth"]).optional().describe("Chart shape to generate. Defaults from source."),
+    closeField: fieldName.optional().describe("Candlestick close-value field."),
+    highField: fieldName.optional().describe("Candlestick high-value field."),
+    labelField: fieldName.optional().describe("Categorical label field for bar charts."),
+    lowField: fieldName.optional().describe("Candlestick low-value field."),
+    maxPoints: z__namespace.number().int().positive().max(options.maxRows).optional().describe("Maximum rows to include in the frontend spec; defaults to all provided rows."),
+    openField: fieldName.optional().describe("Candlestick open-value field."),
+    priceField: fieldName.optional().describe("Market-depth price field."),
+    renderer: z__namespace.literal("vega-lite").optional().describe("Visualization spec renderer. Currently only vega-lite is generated."),
+    rows: z__namespace.array(z__namespace.record(chartScalar)).min(1).max(options.maxRows).describe("Chart data rows copied from a bounded Bloomberg tool result."),
+    seriesField: fieldName.optional().describe("Optional series/color field."),
+    sideField: fieldName.optional().describe("Market-depth bid/ask side field."),
+    sizeField: fieldName.optional().describe("Market-depth size field."),
+    source: z__namespace.enum(["bdh", "bdib", "holdings", "depth", "rows"]).describe("Bloomberg result shape that produced rows."),
+    title: nonEmptyString(options, "Chart title.").optional(),
+    valueField: fieldName.optional().describe("Primary numeric value field."),
+    xField: fieldName.optional().describe("X-axis field."),
+    yFields: stringArray(options, "Numeric value fields to plot.").optional()
+  }).strict();
+}
 
 // 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);
 }
@@ -747,6 +1231,7 @@ var EXT_TOOL_DEFINITIONS = Object.freeze([
   { create: extCdxWithResolver, name: "xbbg_ext_cdx" },
   { create: extCurrencyWithResolver, name: "xbbg_ext_currency" },
   { create: extBqlBuilderWithResolver, name: "xbbg_ext_bql_builder" },
+  { create: extChartSpecWithResolver, name: "xbbg_ext_chart_spec" },
   { create: extMarketSessionWithResolver, name: "xbbg_ext_market_session" },
   { create: extYasOverridesWithResolver, name: "xbbg_ext_yas_overrides" },
   { create: extConstantsWithResolver, name: "xbbg_ext_constants" },
@@ -756,43 +1241,42 @@ var EXT_TOOL_DEFINITIONS = Object.freeze([
 var BLOOMBERG_EXT_TOOL_NAMES = Object.freeze(
   EXT_TOOL_DEFINITIONS.map((definition) => definition.name)
 );
+function extChartSpecWithResolver(resolver) {
+  const name = "xbbg_ext_chart_spec";
+  return createBloombergStructuredTool(
+    async (input) => {
+      try {
+        return await Promise.resolve(resultString(resolver, name, createChartSpec(input)));
+      } catch (error) {
+        throwWithToolContext(name, error);
+      }
+    },
+    {
+      responseFormat: "content_and_artifact",
+      description: EXT_CHART_SPEC_DESCRIPTION,
+      name,
+      schema: chartSpecSchema(resolver.options)
+    }
+  );
+}
 function extTickerWithResolver(resolver) {
   const name = "xbbg_ext_ticker";
   return createBloombergStructuredTool(
     async (input) => {
       try {
         const core = await resolver.getCore();
-        const args = asRecord(input);
         switch (input.operation) {
           case "parse_ticker":
-            return resultString(
-              resolver,
-              name,
-              core.ext.parseTicker(requireString(name, args, "ticker"))
-            );
+            return resultString(resolver, name, core.ext.parseTicker(input.ticker));
           case "normalize_tickers":
-            return resultString(
-              resolver,
-              name,
-              core.ext.normalizeTickers(requireStringArray(name, args, "tickers"))
-            );
+            return resultString(resolver, name, core.ext.normalizeTickers(input.tickers));
           case "filter_equity_tickers":
-            return resultString(
-              resolver,
-              name,
-              core.ext.filterEquityTickers(requireStringArray(name, args, "tickers"))
-            );
+            return resultString(resolver, name, core.ext.filterEquityTickers(input.tickers));
           case "is_specific_contract":
-            return resultString(
-              resolver,
-              name,
-              core.ext.isSpecificContract(requireString(name, args, "ticker"))
-            );
-          case "validate_generic_ticker": {
-            const ticker = requireString(name, args, "ticker");
-            core.ext.validateGenericTicker(ticker);
-            return resultString(resolver, name, { ticker, valid: true });
-          }
+            return resultString(resolver, name, core.ext.isSpecificContract(input.ticker));
+          case "validate_generic_ticker":
+            core.ext.validateGenericTicker(input.ticker);
+            return resultString(resolver, name, { ticker: input.ticker, valid: true });
         }
       } catch (error) {
         throwWithToolContext(name, error);
@@ -812,63 +1296,39 @@ function extFuturesWithResolver(resolver) {
     async (input) => {
       try {
         const core = await resolver.getCore();
-        const args = asRecord(input);
         switch (input.operation) {
           case "build_futures_ticker":
             return resultString(
               resolver,
               name,
-              core.ext.buildFuturesTicker(
-                requireString(name, args, "prefix"),
-                requireString(name, args, "monthCode"),
-                requireYearString(name, args, "year"),
-                requireString(name, args, "asset")
-              )
+              core.ext.buildFuturesTicker(input.prefix, input.monthCode, input.year, input.asset)
             );
           case "generate_candidates":
             return resultString(
               resolver,
               name,
               core.ext.generateFuturesCandidates(
-                requireString(name, args, "genTicker"),
-                requireInteger(name, args, "year"),
-                requireInteger(name, args, "month"),
-                requireInteger(name, args, "day"),
+                input.genTicker,
+                input.year,
+                input.month,
+                input.day,
                 input.freq,
                 input.count
               )
             );
           case "contract_index":
-            return resultString(
-              resolver,
-              name,
-              core.ext.contractIndex(requireString(name, args, "genTicker"))
-            );
+            return resultString(resolver, name, core.ext.contractIndex(input.genTicker));
           case "filter_candidates_by_cycle":
-            if (input.candidates === void 0) {
-              throw new TypeError(`${name}: candidates is required`);
-            }
             return resultString(
               resolver,
               name,
-              core.ext.filterCandidatesByCycle(
-                input.candidates,
-                requireString(name, args, "cycle")
-              )
+              core.ext.filterCandidatesByCycle(input.candidates, input.cycle)
             );
           case "filter_valid_contracts":
-            if (input.contracts === void 0) {
-              throw new TypeError(`${name}: contracts is required`);
-            }
             return resultString(
               resolver,
               name,
-              core.ext.filterValidContracts(
-                input.contracts,
-                requireInteger(name, args, "year"),
-                requireInteger(name, args, "month"),
-                requireInteger(name, args, "day")
-              )
+              core.ext.filterValidContracts(input.contracts, input.year, input.month, input.day)
             );
           case "get_futures_months":
             return resultString(resolver, name, core.ext.getFuturesMonths());
@@ -888,41 +1348,31 @@ function extFuturesWithResolver(resolver) {
 function extCdxWithResolver(resolver) {
   const name = "xbbg_ext_cdx";
   return createBloombergStructuredTool(
-    async (input) => {
+    async (input, config) => {
       try {
-        const args = asRecord(input);
+        config?.signal?.throwIfAborted();
         if (input.operation === "cdx_info" || input.operation === "cdx_pricing" || input.operation === "cdx_risk") {
           const engine = await resolver.getEngine();
-          const ticker = requireString(name, args, "ticker");
           const fields = input.operation === "cdx_info" ? CDX_INFO_FIELDS : input.operation === "cdx_pricing" ? CDX_PRICING_FIELDS : CDX_RISK_FIELDS;
-          const result = await engine.bdp([ticker], fields, {
+          const result = await engine.bdp([input.ticker], fields, {
             backend: "json",
-            overrides: recoveryOverrides(input.recoveryRate)
+            overrides: recoveryOverrides(
+              input.operation === "cdx_pricing" || input.operation === "cdx_risk" ? input.recoveryRate : void 0
+            )
           });
           return resultString(resolver, name, result);
         }
         const core = await resolver.getCore();
         switch (input.operation) {
           case "parse_cdx_ticker":
-            return resultString(
-              resolver,
-              name,
-              core.ext.parseCdxTicker(requireString(name, args, "ticker"))
-            );
+            return resultString(resolver, name, core.ext.parseCdxTicker(input.ticker));
           case "previous_cdx_series":
-            return resultString(
-              resolver,
-              name,
-              core.ext.previousCdxSeries(requireString(name, args, "ticker"))
-            );
+            return resultString(resolver, name, core.ext.previousCdxSeries(input.ticker));
           case "cdx_gen_to_specific":
             return resultString(
               resolver,
               name,
-              core.ext.cdxGenToSpecific(
-                requireString(name, args, "genTicker"),
-                requireInteger(name, args, "series")
-              )
+              core.ext.cdxGenToSpecific(input.genTicker, input.series)
             );
         }
       } catch (error) {
@@ -943,34 +1393,16 @@ function extCurrencyWithResolver(resolver) {
     async (input) => {
       try {
         const core = await resolver.getCore();
-        const args = asRecord(input);
         switch (input.operation) {
           case "build_fx_pair":
-            return resultString(
-              resolver,
-              name,
-              core.ext.buildFxPair(
-                requireString(name, args, "fromCcy"),
-                requireString(name, args, "toCcy")
-              )
-            );
+            return resultString(resolver, name, core.ext.buildFxPair(input.fromCcy, input.toCcy));
           case "same_currency":
-            return resultString(
-              resolver,
-              name,
-              core.ext.sameCurrency(
-                requireString(name, args, "ccy1"),
-                requireString(name, args, "ccy2")
-              )
-            );
+            return resultString(resolver, name, core.ext.sameCurrency(input.ccy1, input.ccy2));
           case "currencies_needing_conversion":
             return resultString(
               resolver,
               name,
-              core.ext.currenciesNeedingConversion(
-                requireStringArray(name, args, "currencies"),
-                requireString(name, args, "target")
-              )
+              core.ext.currenciesNeedingConversion(input.currencies, input.target)
             );
         }
       } catch (error) {
@@ -991,23 +1423,19 @@ function extBqlBuilderWithResolver(resolver) {
     async (input) => {
       try {
         const core = await resolver.getCore();
-        const args = asRecord(input);
         switch (input.operation) {
           case "build_preferreds_query":
             return resultString(
               resolver,
               name,
-              core.ext.buildPreferredsQuery(
-                requireString(name, args, "equityTicker"),
-                input.extraFields
-              )
+              core.ext.buildPreferredsQuery(input.equityTicker, input.extraFields)
             );
           case "build_corporate_bonds_query":
             return resultString(
               resolver,
               name,
               core.ext.buildCorporateBondsQuery(
-                requireString(name, args, "ticker"),
+                input.ticker,
                 input.ccy,
                 input.extraFields,
                 input.activeOnly
@@ -1017,10 +1445,7 @@ function extBqlBuilderWithResolver(resolver) {
             return resultString(
               resolver,
               name,
-              core.ext.buildEtfHoldingsQuery(
-                requireString(name, args, "etfTicker"),
-                input.extraFields
-              )
+              core.ext.buildEtfHoldingsQuery(input.etfTicker, input.extraFields)
             );
         }
       } catch (error) {
@@ -1041,36 +1466,26 @@ function extMarketSessionWithResolver(resolver) {
     async (input) => {
       try {
         const core = await resolver.getCore();
-        const args = asRecord(input);
         switch (input.operation) {
           case "derive_sessions":
             return resultString(
               resolver,
               name,
-              core.ext.deriveSessions(
-                requireString(name, args, "dayStart"),
-                requireString(name, args, "dayEnd"),
-                input.mic,
-                input.exchCode
-              )
+              core.ext.deriveSessions(input.dayStart, input.dayEnd, input.mic, input.exchCode)
             );
           case "get_market_rule":
             return resultString(resolver, name, core.ext.getMarketRule(input.mic, input.exchCode));
           case "infer_timezone":
-            return resultString(
-              resolver,
-              name,
-              core.ext.inferTimezone(requireString(name, args, "countryIso"))
-            );
+            return resultString(resolver, name, core.ext.inferTimezone(input.countryIso));
           case "session_times_to_utc":
             return resultString(
               resolver,
               name,
               core.ext.sessionTimesToUtc(
-                requireString(name, args, "startTime"),
-                requireString(name, args, "endTime"),
-                requireString(name, args, "exchangeTz"),
-                requireString(name, args, "date")
+                input.startTime,
+                input.endTime,
+                input.exchangeTz,
+                input.date
               )
             );
           case "default_turnover_dates":
@@ -1086,11 +1501,7 @@ function extMarketSessionWithResolver(resolver) {
               core.ext.defaultBqrDatetimes(input.startDatetime, input.endDatetime)
             );
           case "get_exchange_override":
-            return resultString(
-              resolver,
-              name,
-              core.ext.getExchangeOverride(requireString(name, args, "ticker"))
-            );
+            return resultString(resolver, name, core.ext.getExchangeOverride(input.ticker));
           case "list_exchange_overrides":
             return resultString(resolver, name, core.ext.listExchangeOverrides());
         }
@@ -1142,45 +1553,23 @@ function extConstantsWithResolver(resolver) {
     async (input) => {
       try {
         const core = await resolver.getCore();
-        const args = asRecord(input);
         switch (input.operation) {
           case "parse_date":
-            return resultString(
-              resolver,
-              name,
-              core.ext.parseDate(requireString(name, args, "dateStr"))
-            );
+            return resultString(resolver, name, core.ext.parseDate(input.dateStr));
           case "fmt_date":
             return resultString(
               resolver,
               name,
-              core.ext.fmtDate(
-                requireInteger(name, args, "year"),
-                requireInteger(name, args, "month"),
-                requireInteger(name, args, "day"),
-                input.fmt
-              )
+              core.ext.fmtDate(input.year, input.month, input.day, input.fmt)
             );
           case "get_month_code":
-            return resultString(
-              resolver,
-              name,
-              core.ext.getMonthCode(requireString(name, args, "monthName"))
-            );
+            return resultString(resolver, name, core.ext.getMonthCode(input.monthName));
           case "get_month_name":
-            return resultString(
-              resolver,
-              name,
-              core.ext.getMonthName(requireString(name, args, "code"))
-            );
+            return resultString(resolver, name, core.ext.getMonthName(input.code));
           case "get_futures_months":
             return resultString(resolver, name, core.ext.getFuturesMonths());
           case "get_dvd_type":
-            return resultString(
-              resolver,
-              name,
-              core.ext.getDvdType(requireString(name, args, "dvdType"))
-            );
+            return resultString(resolver, name, core.ext.getDvdType(input.dvdType));
           case "get_dvd_types":
             return resultString(resolver, name, core.ext.getDvdTypes());
           case "get_dvd_cols":
@@ -1206,31 +1595,16 @@ function extColumnsWithResolver(resolver) {
     async (input) => {
       try {
         const core = await resolver.getCore();
-        const args = asRecord(input);
         switch (input.operation) {
           case "rename_dividend_columns":
-            return resultString(
-              resolver,
-              name,
-              core.ext.renameDividendColumns(requireStringArray(name, args, "columns"))
-            );
+            return resultString(resolver, name, core.ext.renameDividendColumns(input.columns));
           case "rename_etf_columns":
-            return resultString(
-              resolver,
-              name,
-              core.ext.renameEtfColumns(requireStringArray(name, args, "columns"))
-            );
+            return resultString(resolver, name, core.ext.renameEtfColumns(input.columns));
           case "build_earning_header_rename":
-            if (input.headerRow === void 0) {
-              throw new TypeError(`${name}: headerRow is required`);
-            }
             return resultString(
               resolver,
               name,
-              core.ext.buildEarningHeaderRename(
-                input.headerRow,
-                requireStringArray(name, args, "dataColumns")
-              )
+              core.ext.buildEarningHeaderRename(input.headerRow, input.dataColumns)
             );
         }
       } catch (error) {
@@ -1250,9 +1624,6 @@ function extCalculateWithResolver(resolver) {
   return createBloombergStructuredTool(
     async (input) => {
       try {
-        if (input.values.length !== input.levels.length) {
-          throw new TypeError(`${name}: values and levels must have the same length`);
-        }
         const core = await resolver.getCore();
         return resultString(
           resolver,
@@ -1301,6 +1672,9 @@ function createExtColumnsTool(options = {}) {
 function createExtCalculateTool(options = {}) {
   return extCalculateWithResolver(createCoreResolver(options));
 }
+function createExtChartSpecTool(options = {}) {
+  return extChartSpecWithResolver(createCoreResolver(options));
+}
 function createBloombergExtToolsForResolver(resolver) {
   return EXT_TOOL_DEFINITIONS.filter(
     (definition) => !isToolDisabled(resolver.options, definition.name)
@@ -1321,6 +1695,9 @@ 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 MIN_NUMERIC_BBG_DATE = 19000101;
+var MAX_NUMERIC_BBG_DATE = 29991231;
+var MIN_EPOCH_MS = 1e11;
 var primitiveSchema = z__namespace.union([
   z__namespace.string().transform((value) => value.trim()),
   z__namespace.number(),
@@ -1335,18 +1712,30 @@ function dateFromParts(year, month, day) {
   return formatted;
 }
 function dateToBbg(value) {
-  const date2 = value instanceof Date ? value : new Date(value);
-  if (Number.isNaN(date2.getTime())) {
+  const date = value instanceof Date ? value : new Date(value);
+  if (Number.isNaN(date.getTime())) {
     throw new TypeError("Invalid date value; expected YYYY-MM-DD, YYYYMMDD, Date, or epoch ms");
   }
-  const year = String(date2.getUTCFullYear()).padStart(4, "0");
-  const month = String(date2.getUTCMonth() + 1).padStart(2, "0");
-  const day = String(date2.getUTCDate()).padStart(2, "0");
+  const year = String(date.getUTCFullYear()).padStart(4, "0");
+  const month = String(date.getUTCMonth() + 1).padStart(2, "0");
+  const day = String(date.getUTCDate()).padStart(2, "0");
   return `${year}${month}${day}`;
 }
+function numericDateToBbg(value, unit) {
+  if (Number.isFinite(value) && value >= MIN_EPOCH_MS) {
+    return new Date(value);
+  }
+  throw new TypeError(
+    `Ambiguous numeric ${unit} ${String(value)}; use "YYYY-MM-DD" text or epoch milliseconds`
+  );
+}
 function normalizeDate(value) {
-  if (value instanceof Date || typeof value === "number") {
-    return dateToBbg(value);
+  if (typeof value === "number") {
+    if (Number.isInteger(value) && value >= MIN_NUMERIC_BBG_DATE && value <= MAX_NUMERIC_BBG_DATE) {
+      const text2 = String(value);
+      return dateFromParts(text2.slice(0, 4), text2.slice(4, 6), text2.slice(6, 8));
+    }
+    return dateToBbg(numericDateToBbg(value, "date"));
   }
   const text = value.trim();
   if (text.length === 0) {
@@ -1364,12 +1753,13 @@ function normalizeDate(value) {
   throw new TypeError(`Invalid date ${JSON.stringify(text)}; use YYYY-MM-DD or YYYYMMDD`);
 }
 function normalizeDateTime(value) {
-  if (value instanceof Date || typeof value === "number") {
-    const date2 = value instanceof Date ? value : new Date(value);
-    if (Number.isNaN(date2.getTime())) {
-      throw new TypeError("Invalid datetime value; expected ISO 8601 datetime, Date, or epoch ms");
+  if (typeof value === "number") {
+    if (Number.isInteger(value) && value >= MIN_NUMERIC_BBG_DATE && value <= MAX_NUMERIC_BBG_DATE) {
+      throw new TypeError(
+        `Invalid numeric datetime ${String(value)}; include an explicit time component such as "2024-01-02T09:30:00"`
+      );
     }
-    return date2.toISOString();
+    return numericDateToBbg(value, "datetime").toISOString();
   }
   const text = value.trim();
   if (text.length === 0) {
@@ -1399,8 +1789,15 @@ function nonEmptyString2(tool2, field, maxChars, example) {
 function stringArray2(tool2, field, maxItems, maxChars, example) {
   return z__namespace.array(nonEmptyString2(tool2, field, maxChars, example)).min(1, `${tool2}: ${field} must contain at least one non-empty string. Example: ${example}`).max(maxItems, `${tool2}: ${field} can contain at most ${maxItems} values`);
 }
+function normalizationIssue(context, tool2, field, error) {
+  context.addIssue({
+    code: "custom",
+    message: `${tool2}: ${field}: ${error instanceof Error ? error.message : String(error)}`
+  });
+  return z__namespace.NEVER;
+}
 function primitiveMap(tool2, field) {
-  return z__namespace.record(z__namespace.string().min(1), primitiveSchema).optional().transform((value) => {
+  return z__namespace.record(z__namespace.string().min(1), primitiveSchema).optional().transform((value, context) => {
     if (value === void 0) {
       return void 0;
     }
@@ -1408,10 +1805,15 @@ function primitiveMap(tool2, field) {
     for (const [key, entry] of Object.entries(value)) {
       const normalizedKey = key.trim();
       if (normalizedKey.length === 0) {
-        throw new TypeError(`${tool2}: ${field} contains an empty key`);
+        return normalizationIssue(context, tool2, field, new TypeError("contains an empty key"));
       }
       if (typeof entry === "string" && entry.length === 0) {
-        throw new TypeError(`${tool2}: ${field}.${normalizedKey} must not be an empty string`);
+        return normalizationIssue(
+          context,
+          tool2,
+          field,
+          new TypeError(`${normalizedKey} must not be an empty string`)
+        );
       }
       normalized[normalizedKey] = entry;
     }
@@ -1419,12 +1821,18 @@ function primitiveMap(tool2, field) {
   });
 }
 function dateField(tool2, field) {
-  return z__namespace.union([z__namespace.string(), z__namespace.date(), z__namespace.number()]).transform((value) => normalizeDate(value)).describe(
+  return z__namespace.union([z__namespace.string(), z__namespace.number()]).transform((value, context) => {
+    try {
+      return normalizeDate(value);
+    } catch (error) {
+      return normalizationIssue(context, tool2, field, error);
+    }
+  }).describe(
     `${field} date. Use YYYY-MM-DD or Bloomberg-native YYYYMMDD, never ambiguous MM/DD/YYYY.`
   );
 }
 function dateTimeField(tool2, field) {
-  return z__namespace.union([z__namespace.string(), z__namespace.date(), z__namespace.number()]).superRefine((value, context) => {
+  return z__namespace.union([z__namespace.string(), z__namespace.number()]).superRefine((value, context) => {
     if (typeof value !== "string") {
       return;
     }
@@ -1435,7 +1843,13 @@ function dateTimeField(tool2, field) {
         message: `${tool2}: ${field} datetime requires an explicit time component; use ISO 8601 such as YYYY-MM-DDT09:30:00`
       });
     }
-  }).transform((value) => normalizeDateTime(value)).describe(`${field} datetime. Use ISO 8601 with an explicit time component.`);
+  }).transform((value, context) => {
+    try {
+      return normalizeDateTime(value);
+    } catch (error) {
+      return normalizationIssue(context, tool2, field, error);
+    }
+  }).describe(`${field} datetime. Use ISO 8601 with an explicit time component.`);
 }
 function referenceFormat(tool2) {
   return z__namespace.enum(REFERENCE_FORMATS, {
@@ -1478,7 +1892,7 @@ function createBdpSchema(options) {
       options.maxStringChars,
       '["<TICKER> <MARKET_SECTOR>"]'
     ).describe(
-      "Fully qualified Bloomberg securities supplied by the user; use /isin/<ISIN> for ISINs and /cusip/<CUSIP> for CUSIPs. Do not invent tickers."
+      "Securities exactly as the user supplied them: '<TICKER> <MARKET_SECTOR>' for Bloomberg tickers, '/isin/<ISIN>' for raw ISINs, '/cusip/<CUSIP>' for raw CUSIPs. Never invent, guess, or convert identifiers into tickers."
     ),
     validateFields: z__namespace.boolean().optional().describe("Override field validation for this request.")
   });
@@ -1510,7 +1924,7 @@ function createBdhSchema(options) {
       options.maxStringChars,
       '["<TICKER> <MARKET_SECTOR>"]'
     ).describe(
-      "Fully qualified Bloomberg securities supplied by the user; use /isin/<ISIN> for ISINs and /cusip/<CUSIP> for CUSIPs."
+      "Securities exactly as the user supplied them: '<TICKER> <MARKET_SECTOR>' for Bloomberg tickers, '/isin/<ISIN>' for raw ISINs, '/cusip/<CUSIP>' for raw CUSIPs. Never invent, guess, or convert identifiers into tickers."
     ),
     start: dateField(tool2, "start").describe("Required start date. Use YYYY-MM-DD or YYYYMMDD."),
     validateFields: z__namespace.boolean().optional().describe("Override field validation for this request.")
@@ -1530,7 +1944,6 @@ function createBdsSchema(options) {
     field: nonEmptyString2(tool2, "field", options.maxStringChars, "<BULK_FIELD>").describe(
       "Exactly one Bloomberg bulk/table field supplied by the user."
     ),
-    format: referenceFormat(tool2).describe("JSON output shape. Usually omit."),
     kwargs: primitiveMap(tool2, "kwargs").describe(
       "Advanced Bloomberg request kwargs as flat string/number/boolean values only."
     ),
@@ -1544,7 +1957,7 @@ function createBdsSchema(options) {
       options.maxStringChars,
       '["<INDEX_TICKER> <MARKET_SECTOR>"]'
     ).describe(
-      "Fully qualified Bloomberg securities supplied by the user; use /isin/<ISIN> for ISINs and /cusip/<CUSIP> for CUSIPs."
+      "Securities exactly as the user supplied them: '<TICKER> <MARKET_SECTOR>' for Bloomberg tickers, '/isin/<ISIN>' for raw ISINs, '/cusip/<CUSIP>' for raw CUSIPs. Never invent, guess, or convert identifiers into tickers."
     ),
     validateFields: z__namespace.boolean().optional().describe("Override field validation for this request.")
   });
@@ -1571,7 +1984,7 @@ function createBdibSchema(options) {
       options.maxStringChars,
       "<TICKER> <MARKET_SECTOR>"
     ).describe(
-      "One fully qualified Bloomberg security supplied by the user; use /isin/<ISIN> for ISINs and /cusip/<CUSIP> for CUSIPs."
+      "One security exactly as the user supplied it: '<TICKER> <MARKET_SECTOR>', '/isin/<ISIN>', or '/cusip/<CUSIP>'. Never invent, guess, or convert identifiers into tickers."
     )
   });
 }
@@ -1610,14 +2023,13 @@ function createBdtickSchema(options) {
       options.maxStringChars,
       "<TICKER> <MARKET_SECTOR>"
     ).describe(
-      "One fully qualified Bloomberg security supplied by the user; use /isin/<ISIN> for ISINs and /cusip/<CUSIP> for CUSIPs."
+      "One security exactly as the user supplied it: '<TICKER> <MARKET_SECTOR>', '/isin/<ISIN>', or '/cusip/<CUSIP>'. Never invent, guess, or convert identifiers into tickers."
     )
   });
 }
 function createBqlSchema(options) {
   const tool2 = "xbbg_bql";
   return z__namespace.object({
-    format: referenceFormat(tool2).describe("JSON output shape. Usually omit."),
     kwargs: primitiveMap(tool2, "kwargs").describe(
       "Advanced Bloomberg request kwargs as flat string/number/boolean values only."
     ),
@@ -1656,7 +2068,6 @@ function createBqrSchema(options) {
 function createBsrchSchema(options) {
   const tool2 = "xbbg_bsrch";
   return z__namespace.object({
-    format: referenceFormat(tool2).describe("JSON output shape. Usually omit."),
     kwargs: primitiveMap(tool2, "kwargs").describe(
       "Search-grid kwargs as flat string/number/boolean values only."
     ),
@@ -1679,7 +2090,6 @@ function createBfldsSchema(options) {
     fields: stringArray2(tool2, "fields", options.maxFields, options.maxStringChars, '["<FIELD>"]').optional().describe(
       "Specific field mnemonics to inspect. Provide either fields or searchSpec, not both."
     ),
-    format: referenceFormat(tool2).describe("JSON output shape. Usually omit."),
     kwargs: primitiveMap(tool2, "kwargs").describe(
       "Advanced Bloomberg request kwargs as flat string/number/boolean values only."
     ),
@@ -1707,7 +2117,6 @@ function createBeqsSchema(options) {
   const tool2 = "xbbg_beqs";
   return z__namespace.object({
     asof: dateField(tool2, "asof").optional().describe("Optional as-of date for the screen."),
-    format: referenceFormat(tool2).describe("JSON output shape. Usually omit."),
     group: nonEmptyString2(tool2, "group", options.maxStringChars, "<BEQS_GROUP>").optional().describe("Bloomberg BEQS group when required by the screen."),
     kwargs: primitiveMap(tool2, "kwargs").describe(
       "Advanced BEQS request kwargs as flat string/number/boolean values only."
@@ -1741,7 +2150,9 @@ function createYasSchema(options) {
       options.maxSecurities,
       options.maxStringChars,
       '["/isin/<ISIN> <MARKET_SECTOR>"]'
-    ).describe("Fully qualified fixed-income Bloomberg securities supplied by the user."),
+    ).describe(
+      "Fixed-income securities exactly as the user supplied them: '<TICKER> <MARKET_SECTOR>' or identifier syntax such as '/isin/<ISIN> <MARKET_SECTOR>'. Never invent or guess tickers."
+    ),
     yieldType: z__namespace.number().int().optional().describe("Optional YAS yield type."),
     yieldVal: z__namespace.number().optional().describe("Optional YAS yield value input.")
   });
@@ -1754,8 +2165,10 @@ function createPreferredsSchema(options) {
       "equityTicker",
       options.maxStringChars,
       "<ISSUER_TICKER> <MARKET_SECTOR>"
-    ).describe("One fully qualified issuer equity ticker supplied by the user."),
-    fields: stringArray2(tool2, "fields", options.maxFields, options.maxStringChars, '["<FIELD>"]').optional().describe("Optional fields to include in the preferreds recipe result.")
+    ).describe(
+      "The issuer's common equity ticker as '<TICKER> <MARKET_SECTOR>', never a preferred ('Pfd') ticker and never a guessed one. Resolve a supplied ISIN/CUSIP with xbbg_resolve_isins first."
+    ),
+    fields: z__namespace.array(nonEmptyString2(tool2, "fields", options.maxStringChars, '["<FIELD>"]')).max(options.maxFields, `${tool2}: fields can contain at most ${options.maxFields} values`).transform((fields) => fields.length === 0 ? void 0 : fields).optional().describe("Optional fields to include in the preferreds recipe result.")
   });
 }
 function createCorporateBondsSchema(options) {
@@ -1769,7 +2182,9 @@ function createCorporateBondsSchema(options) {
       "ticker",
       options.maxStringChars,
       "<ISSUER_TICKER> <MARKET_SECTOR>"
-    ).describe("One fully qualified issuer/company ticker supplied by the user.")
+    ).describe(
+      "The issuer/company equity ticker as '<TICKER> <MARKET_SECTOR>' supplied by the user. Resolve a supplied ISIN/CUSIP with xbbg_resolve_isins first; never guess tickers."
+    )
   });
 }
 function createIndexMembersSchema(options) {
@@ -1782,7 +2197,9 @@ function createIndexMembersSchema(options) {
       "index",
       options.maxStringChars,
       "<INDEX_TICKER> <MARKET_SECTOR>"
-    ).describe("One fully qualified Bloomberg index ticker supplied by the user.")
+    ).describe(
+      "One Bloomberg index ticker as '<INDEX_TICKER> <MARKET_SECTOR>' supplied by the user; never guess index tickers."
+    )
   });
 }
 function createResolveIsinsSchema(options) {
@@ -1817,7 +2234,9 @@ function createEtfHoldingsSchema(options) {
       "etfTicker",
       options.maxStringChars,
       "<ETF_TICKER> <MARKET_SECTOR>"
-    ).describe("One fully qualified Bloomberg ETF ticker supplied by the user."),
+    ).describe(
+      "One Bloomberg ETF ticker as '<ETF_TICKER> <MARKET_SECTOR>' supplied by the user. Resolve a supplied ISIN/CUSIP with xbbg_resolve_isins first; never guess tickers."
+    ),
     fields: stringArray2(tool2, "fields", options.maxFields, options.maxStringChars, '["<FIELD>"]').optional().describe("Optional fields to include in the ETF holdings recipe result.")
   });
 }
@@ -1826,7 +2245,7 @@ function snapshotControlFields(tool2, options) {
     allFields: z__namespace.boolean().optional().describe("Request all Bloomberg fields when supported."),
     conflate: z__namespace.boolean().optional().describe("Enable Bloomberg conflated streaming when supported."),
     drain: z__namespace.boolean().optional().describe(
-      "Pass drain=true to unsubscribe. Defaults to false; collected output remains bounded."
+      "Flush buffered backlog while closing the subscription. The subscription always closes; collected output stays bounded either way. Defaults to false."
     ),
     flushThreshold: z__namespace.number().int().positive().optional().describe("Optional stream flush threshold."),
     maxUpdates: z__namespace.number().int(`${tool2}: maxUpdates must be a positive integer.`).positive(`${tool2}: maxUpdates must be greater than zero.`).max(
@@ -1861,7 +2280,9 @@ function createStreamSnapshotSchema(options) {
       options.maxSecurities,
       options.maxStringChars,
       '["<TICKER> <MARKET_SECTOR>"]'
-    ).describe("Fully qualified Bloomberg securities supplied by the user to observe."),
+    ).describe(
+      "Securities to observe, exactly as the user supplied them: '<TICKER> <MARKET_SECTOR>', '/isin/<ISIN>', or '/cusip/<CUSIP>'. Never invent or guess tickers."
+    ),
     ...snapshotControlFields(tool2, options)
   });
 }
@@ -1874,7 +2295,9 @@ function createMktbarSnapshotSchema(options) {
       "ticker",
       options.maxStringChars,
       "<TICKER> <MARKET_SECTOR>"
-    ).describe("One fully qualified Bloomberg security supplied by the user to observe."),
+    ).describe(
+      "One security to observe, exactly as the user supplied it: '<TICKER> <MARKET_SECTOR>', '/isin/<ISIN>', or '/cusip/<CUSIP>'. Never invent or guess tickers."
+    ),
     ...snapshotControlFields(tool2, options)
   });
 }
@@ -1887,7 +2310,9 @@ function createDepthSnapshotSchema(options) {
       "ticker",
       options.maxStringChars,
       "<TICKER> <MARKET_SECTOR>"
-    ).describe("One fully qualified Bloomberg security supplied by the user to observe."),
+    ).describe(
+      "One security to observe, exactly as the user supplied it: '<TICKER> <MARKET_SECTOR>', '/isin/<ISIN>', or '/cusip/<CUSIP>'. Never invent or guess tickers."
+    ),
     ...snapshotControlFields(tool2, options)
   });
 }
@@ -1897,17 +2322,24 @@ function resultString2(resolver, name, value) {
   return createToolResult(name, value, resolver.options.maxRows, resolver.options.maxStringChars);
 }
 var STREAM_TIMEOUT = /* @__PURE__ */ Symbol("stream_timeout");
+var STREAM_ABORTED = /* @__PURE__ */ Symbol("stream_aborted");
+function abortError(signal) {
+  const reason = signal?.reason;
+  return reason instanceof Error ? reason : new Error("Tool call aborted");
+}
 function streamOptions(input) {
   return {
     allFields: input.allFields,
     conflate: input.conflate,
-    fields: input.fields,
     flushThreshold: input.flushThreshold,
     options: input.options,
     overflowPolicy: input.overflowPolicy,
     streamCapacity: input.streamCapacity
   };
 }
+function singleTickerStreamOptions(input) {
+  return { ...streamOptions(input), fields: input.fields };
+}
 function isRecord(value) {
   return typeof value === "object" && value !== null;
 }
@@ -1963,42 +2395,55 @@ function normalizeStreamUpdate(value) {
   const rows = rowsFromArrowTable(value);
   return rows === void 0 ? jsonCompatible(value) : rows.map(jsonCompatible);
 }
-async function nextWithinTimeout(iterator, deadlineMs) {
+async function nextWithinTimeout(iterator, deadlineMs, signal) {
+  if (signal?.aborted === true) {
+    return STREAM_ABORTED;
+  }
   const remainingMs = deadlineMs - Date.now();
   if (remainingMs <= 0) {
     return STREAM_TIMEOUT;
   }
   const nextPromise = iterator.next();
   let timer;
-  const timeoutPromise = new Promise((resolve) => {
-    timer = setTimeout(() => resolve(STREAM_TIMEOUT), remainingMs);
-  });
-  const result = await Promise.race([nextPromise, timeoutPromise]);
+  let onAbort;
+  const racers = [
+    nextPromise,
+    new Promise((resolve) => {
+      timer = setTimeout(() => resolve(STREAM_TIMEOUT), remainingMs);
+    })
+  ];
+  if (signal !== void 0) {
+    racers.push(
+      new Promise((resolve) => {
+        onAbort = () => resolve(STREAM_ABORTED);
+        signal.addEventListener("abort", onAbort, { once: true });
+      })
+    );
+  }
+  const result = await Promise.race(racers);
   if (timer !== void 0) {
     clearTimeout(timer);
   }
-  if (result === STREAM_TIMEOUT) {
+  if (signal !== void 0 && onAbort !== void 0) {
+    signal.removeEventListener("abort", onAbort);
+  }
+  if (result === STREAM_TIMEOUT || result === STREAM_ABORTED) {
     void nextPromise.catch(() => void 0);
   }
   return result;
 }
-async function unsubscribeSnapshot(subscription, drain, priorError) {
-  try {
-    await subscription.unsubscribe(drain);
-  } catch (error) {
-    if (priorError === void 0) {
-      throw error;
-    }
-  }
-}
-async function collectSnapshot(subscription, input) {
+async function collectSnapshot(subscription, input, signal) {
   const updates = [];
   const deadlineMs = Date.now() + input.timeoutMs;
   let reason = "max_updates";
+  let failed = false;
   let caught;
   try {
     while (updates.length < input.maxUpdates) {
-      const next = await nextWithinTimeout(subscription, deadlineMs);
+      const next = await nextWithinTimeout(subscription, deadlineMs, signal);
+      if (next === STREAM_ABORTED) {
+        throw abortError(signal);
+      }
       if (next === STREAM_TIMEOUT) {
         reason = "timeout";
         break;
@@ -2009,26 +2454,34 @@ async function collectSnapshot(subscription, input) {
       }
       updates.push(normalizeStreamUpdate(next.value));
     }
-    return {
-      maxUpdates: input.maxUpdates,
-      reason,
-      timeoutMs: input.timeoutMs,
-      updateCount: updates.length,
-      updates
-    };
   } catch (error) {
+    failed = true;
     caught = error;
-    throw error;
-  } finally {
-    await unsubscribeSnapshot(subscription, input.drain === true, caught);
   }
+  const drain = input.drain === true && signal?.aborted !== true;
+  let unsubscribeError;
+  try {
+    await subscription.unsubscribe(drain);
+  } catch (error) {
+    if (!failed) {
+      unsubscribeError = error instanceof Error ? error.message : String(error);
+    }
+  }
+  if (failed) {
+    throw caught;
+  }
+  return {
+    maxUpdates: input.maxUpdates,
+    reason,
+    timeoutMs: input.timeoutMs,
+    updateCount: updates.length,
+    updates,
+    ...unsubscribeError === void 0 ? {} : { unsubscribeError }
+  };
 }
 function validationSetting(resolver, value) {
   return value ?? resolver.options.validateFields;
 }
-function enabledTool(resolver, name, creator) {
-  return isToolDisabled(resolver.options, name) ? [] : [creator(resolver)];
-}
 function bdpWithResolver(resolver) {
   const name = "xbbg_bdp";
   return createBloombergStructuredTool(
@@ -2092,7 +2545,6 @@ function bdsWithResolver(resolver) {
         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)
@@ -2182,7 +2634,6 @@ function bqlWithResolver(resolver) {
         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);
@@ -2206,7 +2657,6 @@ function bsrchWithResolver(resolver) {
         const engine = await resolver.getEngine();
         const result = await engine.bsrch(input.searchSpec, {
           backend: "json",
-          format: input.format,
           kwargs: input.kwargs,
           overrides: input.overrides
         });
@@ -2258,7 +2708,6 @@ function bfldsWithResolver(resolver) {
         const result = await engine.bflds({
           backend: "json",
           fields: input.fields,
-          format: input.format,
           kwargs: input.kwargs,
           searchSpec: input.searchSpec
         });
@@ -2284,7 +2733,6 @@ function beqsWithResolver(resolver) {
         const result = await engine.beqs(input.screen, {
           asof: input.asof,
           backend: "json",
-          format: input.format,
           group: input.group,
           kwargs: input.kwargs,
           overrides: input.overrides,
@@ -2469,11 +2917,13 @@ function etfHoldingsWithResolver(resolver) {
 function streamSnapshotWithResolver(resolver) {
   const name = "xbbg_stream_snapshot";
   return createBloombergStructuredTool(
-    async (input) => {
+    async (input, config) => {
+      const signal = config?.signal;
       try {
         const engine = await resolver.getEngine();
+        signal?.throwIfAborted();
         const subscription = await engine.stream(input.tickers, input.fields, streamOptions(input));
-        const result = await collectSnapshot(subscription, input);
+        const result = await collectSnapshot(subscription, input, signal);
         return resultString2(resolver, name, result);
       } catch (error) {
         throwWithToolContext(name, error);
@@ -2490,11 +2940,13 @@ function streamSnapshotWithResolver(resolver) {
 function mktbarSnapshotWithResolver(resolver) {
   const name = "xbbg_mktbar_snapshot";
   return createBloombergStructuredTool(
-    async (input) => {
+    async (input, config) => {
+      const signal = config?.signal;
       try {
         const engine = await resolver.getEngine();
-        const subscription = await engine.mktbar(input.ticker, streamOptions(input));
-        const result = await collectSnapshot(subscription, input);
+        signal?.throwIfAborted();
+        const subscription = await engine.mktbar(input.ticker, singleTickerStreamOptions(input));
+        const result = await collectSnapshot(subscription, input, signal);
         return resultString2(resolver, name, result);
       } catch (error) {
         throwWithToolContext(name, error);
@@ -2511,11 +2963,13 @@ function mktbarSnapshotWithResolver(resolver) {
 function depthSnapshotWithResolver(resolver) {
   const name = "xbbg_depth_snapshot";
   return createBloombergStructuredTool(
-    async (input) => {
+    async (input, config) => {
+      const signal = config?.signal;
       try {
         const engine = await resolver.getEngine();
-        const subscription = await engine.depth(input.ticker, streamOptions(input));
-        const result = await collectSnapshot(subscription, input);
+        signal?.throwIfAborted();
+        const subscription = await engine.depth(input.ticker, singleTickerStreamOptions(input));
+        const result = await collectSnapshot(subscription, input, signal);
         return resultString2(resolver, name, result);
       } catch (error) {
         throwWithToolContext(name, error);
@@ -2589,29 +3043,32 @@ function createMktbarSnapshotTool(options = {}) {
 function createDepthSnapshotTool(options = {}) {
   return depthSnapshotWithResolver(createCoreResolver(options));
 }
+var CORE_TOOL_DEFINITIONS = Object.freeze([
+  { create: bdpWithResolver, name: "xbbg_bdp" },
+  { create: bdhWithResolver, name: "xbbg_bdh" },
+  { create: bdsWithResolver, name: "xbbg_bds" },
+  { create: bdibWithResolver, name: "xbbg_bdib" },
+  { create: bdtickWithResolver, name: "xbbg_bdtick" },
+  { create: bqlWithResolver, name: "xbbg_bql" },
+  { create: bsrchWithResolver, name: "xbbg_bsrch" },
+  { create: bqrWithResolver, name: "xbbg_bqr" },
+  { create: bfldsWithResolver, name: "xbbg_bflds" },
+  { create: beqsWithResolver, name: "xbbg_beqs" },
+  { create: yasWithResolver, name: "xbbg_yas" },
+  { create: preferredsWithResolver, name: "xbbg_preferreds" },
+  { create: corporateBondsWithResolver, name: "xbbg_corporate_bonds" },
+  { create: indexMembersWithResolver, name: "xbbg_index_members" },
+  { create: resolveIsinsWithResolver, name: "xbbg_resolve_isins" },
+  { create: issuerIsinsWithResolver, name: "xbbg_issuer_isins" },
+  { create: etfHoldingsWithResolver, name: "xbbg_etf_holdings" },
+  { create: streamSnapshotWithResolver, name: "xbbg_stream_snapshot" },
+  { create: mktbarSnapshotWithResolver, name: "xbbg_mktbar_snapshot" },
+  { create: depthSnapshotWithResolver, name: "xbbg_depth_snapshot" }
+]);
 function createBloombergToolsForResolver(resolver) {
-  return [
-    ...enabledTool(resolver, "xbbg_bdp", bdpWithResolver),
-    ...enabledTool(resolver, "xbbg_bdh", bdhWithResolver),
-    ...enabledTool(resolver, "xbbg_bds", bdsWithResolver),
-    ...enabledTool(resolver, "xbbg_bdib", bdibWithResolver),
-    ...enabledTool(resolver, "xbbg_bdtick", bdtickWithResolver),
-    ...enabledTool(resolver, "xbbg_bql", bqlWithResolver),
-    ...enabledTool(resolver, "xbbg_bsrch", bsrchWithResolver),
-    ...enabledTool(resolver, "xbbg_bqr", bqrWithResolver),
-    ...enabledTool(resolver, "xbbg_bflds", bfldsWithResolver),
-    ...enabledTool(resolver, "xbbg_beqs", beqsWithResolver),
-    ...enabledTool(resolver, "xbbg_yas", yasWithResolver),
-    ...enabledTool(resolver, "xbbg_preferreds", preferredsWithResolver),
-    ...enabledTool(resolver, "xbbg_corporate_bonds", corporateBondsWithResolver),
-    ...enabledTool(resolver, "xbbg_index_members", indexMembersWithResolver),
-    ...enabledTool(resolver, "xbbg_resolve_isins", resolveIsinsWithResolver),
-    ...enabledTool(resolver, "xbbg_issuer_isins", issuerIsinsWithResolver),
-    ...enabledTool(resolver, "xbbg_etf_holdings", etfHoldingsWithResolver),
-    ...enabledTool(resolver, "xbbg_stream_snapshot", streamSnapshotWithResolver),
-    ...enabledTool(resolver, "xbbg_mktbar_snapshot", mktbarSnapshotWithResolver),
-    ...enabledTool(resolver, "xbbg_depth_snapshot", depthSnapshotWithResolver)
-  ];
+  return CORE_TOOL_DEFINITIONS.filter(
+    (definition) => !isToolDisabled(resolver.options, definition.name)
+  ).map((definition) => definition.create(resolver));
 }
 function createBloombergTools(options = {}) {
   return createBloombergToolsForResolver(createCoreResolver(options));
@@ -2629,6 +3086,7 @@ function createAllBloombergTools(options = {}) {
 exports.BLOOMBERG_EXT_TOOL_NAMES = BLOOMBERG_EXT_TOOL_NAMES;
 exports.BLOOMBERG_TOOL_INSTRUCTIONS = BLOOMBERG_TOOL_INSTRUCTIONS;
 exports.BLOOMBERG_TOOL_NAMES = BLOOMBERG_TOOL_NAMES;
+exports.DEFAULT_ENGINE_REQUEST_TIMEOUT_MS = DEFAULT_ENGINE_REQUEST_TIMEOUT_MS;
 exports.createAllBloombergTools = createAllBloombergTools;
 exports.createBdhTool = createBdhTool;
 exports.createBdibTool = createBdibTool;
@@ -2648,6 +3106,7 @@ exports.createEtfHoldingsTool = createEtfHoldingsTool;
 exports.createExtBqlBuilderTool = createExtBqlBuilderTool;
 exports.createExtCalculateTool = createExtCalculateTool;
 exports.createExtCdxTool = createExtCdxTool;
+exports.createExtChartSpecTool = createExtChartSpecTool;
 exports.createExtColumnsTool = createExtColumnsTool;
 exports.createExtConstantsTool = createExtConstantsTool;
 exports.createExtCurrencyTool = createExtCurrencyTool;
@@ -2663,5 +3122,6 @@ exports.createResolveIsinsTool = createResolveIsinsTool;
 exports.createStreamSnapshotTool = createStreamSnapshotTool;
 exports.createYasTool = createYasTool;
 exports.getBloombergToolInstructions = getBloombergToolInstructions;
+exports.toolParameterJsonSchema = toolParameterJsonSchema;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map