gloomberb 0.16.1 → 0.16.2

package/src/api-client/paths.ts

@@ -4,7 +4,9 @@ import type {
   CloudTweetQueryType,
 } from "./types";
 import { isUsListingExchange, normalizeSymbol, parsePublicTickerKey, publicTickerKey } from "../utils/exchanges";
+import { nonUsSecListingVenue } from "../utils/sec";
 import type { HistoryRetention } from "../sources/history-retention";
+import type { CloudBeneficialOwnersParams } from "./beneficial-owners";
 
 export type CloudHistoryParams = {
   interval?: string;
@@ -228,6 +230,10 @@ export function cloudCreditBoardPath(board: "cdx" | "sovr", params: { days?: num
 
 export type CloudSecFilingsParams = {
   ticker: string;
+  /** The listing's venue. Sent only for a venue outside the US, with `name`. */
+  exchange?: string;
+  /** The listing's company name, from its own quote. */
+  name?: string;
   limit?: number;
   offset?: number;
 };
@@ -343,13 +349,36 @@ export function cloudProxyStatementPath(ticker: string, year: number): string {
   return `/cloud/proxies/${encodeURIComponent(normalizeIssuerResearchTicker(ticker))}/${year}`;
 }
 
+/**
+ * A US listing, or a symbol with no venue, looks up its US ticker as before.
+ * A listing elsewhere sends its bare symbol with the venue and company name:
+ * its symbol can be another company's US ticker.
+ */
 export function cloudSecFilingsPath(params: CloudSecFilingsParams): string {
-  const search = new URLSearchParams({ ticker: normalizeIssuerResearchTicker(params.ticker) });
+  const venue = nonUsSecListingVenue(params.ticker, params.exchange);
+  const search = new URLSearchParams({
+    ticker: venue ? parsePublicTickerKey(params.ticker).symbol : normalizeIssuerResearchTicker(params.ticker),
+  });
   if (params.limit != null) search.set("limit", String(params.limit));
   if (params.offset != null) search.set("offset", String(params.offset));
+  if (venue) {
+    search.set("exchange", venue);
+    const name = params.name?.trim();
+    if (name) search.set("name", name);
+  }
   return appendQuery("/cloud/sec/filings", search);
 }
 
+/** Schedule 13D and 13G reports about the issuer behind `ticker`. */
+export function cloudSecBeneficialOwnersPath(params: CloudBeneficialOwnersParams): string {
+  const search = new URLSearchParams({ ticker: normalizeIssuerResearchTicker(params.ticker) });
+  if (params.form) search.set("form", params.form);
+  if (params.history) search.set("history", "1");
+  if (params.limit != null) search.set("limit", String(params.limit));
+  if (params.offset != null) search.set("offset", String(params.offset));
+  return appendQuery("/cloud/sec/beneficial-owners", search);
+}
+
 export function cloudSecFilingDocumentsPath(
   params: CloudSecFilingParams,
 ): string {

package/src/api-client/perps.ts

@@ -79,6 +79,28 @@ interface UnderlyingReference {
   sourceUrl: string
 }
 
+/**
+ * The venue's latest long/short account reading for one contract, in its own hourly bucket. Shares are
+ * fractions and may sum to less than one (flat accounts); OKX publishes only the ratio, so its shares are derived.
+ */
+export interface PerpLongShortRatio {
+  venue: string
+  /** Key of what is counted, such as `accounts_all`; `definitionText` says it in words. */
+  definition: string
+  definitionText: string
+  period: string
+  longShare: number
+  shortShare: number
+  ratio: number | null
+  derived: boolean
+  bucketAt: string
+  observedAt: string
+  /** The bucket is more than three hours old. */
+  stale: boolean
+}
+/** Why a row has no reading: the venue publishes none, collection is off, or nothing is stored yet. */
+type PerpLongShortReason = "unsupported" | "off" | "collecting"
+
 export interface PerpBoardRow extends PerpMarket {
   equityMatch?: { listing: PerpEquityListing; underlying: PerpEquityListing; basis: "listing" | "issuer" }
   stale: boolean
@@ -89,6 +111,19 @@ export interface PerpBoardRow extends PerpMarket {
   underlying: UnderlyingReference | null
   underlyingPremium: number | null
   closedMarketPremium: number | null
+  /** Absent from servers older than the long/short series: read as null. */
+  longShortRatio?: PerpLongShortRatio | null
+  longShortRatioReason?: PerpLongShortReason | null
+}
+
+export type PerpLongShortPoint = {
+  time: string
+  definition: string
+  longShare: number
+  shortShare: number
+  ratio: number | null
+  derived: boolean
+  observedAt: string
 }
 
 type PerpHistoryPoint = {
@@ -114,6 +149,8 @@ export interface PerpBoardPayload {
 export interface PerpEquityListing { symbol: string; exchange: string }
 export interface PerpHistoryPayload {
   status: string; marketId: string; rows: PerpHistoryPoint[]; funding: PerpFunding[]; candles: PerpCandle[];
+  /** Absent from servers older than the long/short series: read as empty. */
+  longShortRatio?: PerpLongShortPoint[];
   locked: boolean; access: "pro" | "preview"; asOf: string | null;
   from?: string; to?: string; resolution?: "minute" | "hour" | "day"; truncated?: boolean;
 }

package/src/api-client/request.ts

@@ -3,6 +3,7 @@ import { withDeadline } from "../utils/async-deadline";
 import {
   ApiRequestError,
   parseApiErrorCode,
+  parseApiErrorDetails,
   parseApiErrorMessage,
   parseRetryAfterMs,
   type RevisionConflictError,
@@ -391,6 +392,7 @@ export class CloudApiRequestTransport {
           res.status,
           parseRetryAfterMs(res.headers.get("Retry-After")),
           parseApiErrorCode(text),
+          parseApiErrorDetails(text),
         );
       }
 
@@ -404,8 +406,9 @@ export class CloudApiRequestTransport {
     };
     // Crash reports, usage counts and command-search reports are background
     // traffic: a rate-limited, timed-out or missing one must not show up as a
-    // Cloud outage in the connections pane.
-    if (path.startsWith("/telemetry/") || path === "/assist/searches") return request();
+    // Cloud outage in the connections pane. Nor must the map's probe for geo
+    // layers, which a server without them answers with 404.
+    if (path.startsWith("/telemetry/") || path === "/assist/searches" || path === "/cloud/geo/layers") return request();
     return this.connectionHealth.track(
       GLOOM_CLOUD_HTTP_CONNECTION_ID,
       operation,

package/src/api-client/types.ts

@@ -12,6 +12,8 @@ import type { SyncSettings, SyncSnapshot } from "../sync/types";
 
 export interface ChatUserSummary {
   id: string;
+  /** A person, a managed assistant (Gloombot), or a Discord user bridged into public channels. */
+  accountType?: "human" | "managed_llm" | "discord";
   username: string | null;
   displayName: string;
   bio?: string | null;

package/src/brokers/account-cache.ts

@@ -84,6 +84,30 @@ export function loadPersistedBrokerAccounts(
   })?.value.accounts ?? null;
 }
 
+/**
+ * The newest saved account snapshot of a profile, for readers without its
+ * adapter such as the CLI. Read only: without the adapter the current source
+ * key is unknown, so nothing is pruned.
+ */
+export function peekPersistedBrokerAccounts(
+  resources: Pick<AppResourceStorePort, "list">,
+  instance: BrokerInstanceConfig,
+): BrokerAccount[] | null {
+  const records = resources.list<PersistedBrokerAccountSnapshot>({
+    namespace: brokerAccountNamespace(instance),
+    kind: BROKER_ACCOUNT_SNAPSHOT_KIND,
+    entityKey: instance.id,
+  }, {
+    schemaVersion: BROKER_ACCOUNT_SNAPSHOT_SCHEMA_VERSION,
+    allowExpired: true,
+  });
+  const newest = records.reduce<(typeof records)[number] | null>(
+    (latest, record) => (!latest || record.fetchedAt > latest.fetchedAt ? record : latest),
+    null,
+  );
+  return newest?.value.accounts ?? null;
+}
+
 export function persistBrokerAccounts(
   resources: AppResourceStorePort,
   instance: BrokerInstanceConfig,

package/src/cli/commands/command-utils.ts

@@ -15,6 +15,14 @@ export function takeOption(args: string[], name: string): string | undefined {
   return value;
 }
 
+/** Removes a boolean flag (`--history`) from `args` and says whether it was there. */
+export function takeFlag(args: string[], name: string): boolean {
+  const index = args.indexOf(name);
+  if (index < 0) return false;
+  args.splice(index, 1);
+  return true;
+}
+
 export function parseJsonPayload(value: string | undefined, ctx: CliCommandContext): unknown {
   if (!value) return {};
   try {

package/src/cli/commands/crypto-hints.ts

@@ -0,0 +1,75 @@
+import { isCryptoInstrumentType } from "../../tickers/search/ranking";
+import type { Quote } from "../../types/financials";
+import { isCryptoPairSymbol } from "../../utils/crypto-pair";
+
+/** Where a crypto pair that will not load can still be read. `fn CRYP` takes no argument. */
+export const CRYPTO_BOARD_HINT = "Crypto prices may be briefly unavailable; the CRYP function (gloomberb fn CRYP) shows the crypto board.";
+
+// The coins whose bare ticker is most often typed for the coin itself. The label is how the note
+// names the coin and what a listing's name has to say before the note applies.
+const MAJOR_COINS = new Map([
+  ["BTC", "bitcoin"],
+  ["ETH", "ethereum"],
+  ["SOL", "solana"],
+  ["XRP", "XRP"],
+  ["DOGE", "dogecoin"],
+  ["ADA", "cardano"],
+  ["LTC", "litecoin"],
+  ["BCH", "bitcoin cash"],
+  ["AVAX", "avalanche"],
+  ["DOT", "polkadot"],
+  ["LINK", "chainlink"],
+  ["BNB", "BNB"],
+]);
+
+/**
+ * A bare coin ticker usually resolves to a listed fund, not the coin. The note applies only when
+ * the listing is not crypto and its own name says the coin (a "Bitcoin" trust), so a company that
+ * happens to share the letters (Interlink Electronics on LINK) is left alone.
+ */
+function notTheCoinNote(symbol: string, quote: Pick<Quote, "name" | "instrumentType"> | null | undefined): string | null {
+  const coin = MAJOR_COINS.get(symbol);
+  const type = quote?.instrumentType?.trim();
+  const name = quote?.name?.trim();
+  if (!coin || !name || !type || isCryptoInstrumentType(type)) return null;
+  if (!new RegExp(`\\b${coin}\\b`, "i").test(name)) return null;
+  return `${symbol} is ${name}, not ${coin}. For ${coin} use ${symbol}-USD.`;
+}
+
+interface QuoteNoteResult {
+  target: { symbol: string };
+  quote: Pick<Quote, "name" | "instrumentType"> | null;
+  error: string | null;
+}
+
+/** The router words a failure as "<reason> for <symbol>"; drop the symbol so equal reasons group. */
+function failureReason(message: string, symbol: string): string {
+  const line = (message.split("\n")[0] ?? "").trim().replace(/\.+$/, "");
+  const suffix = ` for ${symbol}`;
+  return line.toLowerCase().endsWith(suffix.toLowerCase()) ? line.slice(0, -suffix.length) : line;
+}
+
+/**
+ * Text-mode notes under a quote table: one line per distinct failure reason (with the crypto board
+ * pointer when a failed symbol is a crypto pair), then a line for each bare coin ticker that
+ * resolved to something else. `--exchange` names the listing on purpose, so it gets no coin note.
+ */
+export function quoteNotes(results: QuoteNoteResult[], options: { exchange?: string } = {}): string[] {
+  const failures = new Map<string, string[]>();
+  for (const result of results) {
+    if (!result.error || result.quote) continue;
+    const reason = failureReason(result.error, result.target.symbol);
+    const symbols = failures.get(reason) ?? [];
+    if (!symbols.includes(result.target.symbol)) failures.set(reason, [...symbols, result.target.symbol]);
+  }
+  const notes = [...failures].map(([reason, symbols]) => (
+    `${symbols.join(", ")}: ${reason}${symbols.some(isCryptoPairSymbol) ? `. ${CRYPTO_BOARD_HINT}` : ""}`
+  ));
+  if (!options.exchange) {
+    for (const result of results) {
+      const note = notTheCoinNote(result.target.symbol, result.quote);
+      if (note) notes.push(note);
+    }
+  }
+  return notes;
+}