gloomberb 0.15.7 → 0.16.0

package/src/api-client/exposure.ts

@@ -0,0 +1,202 @@
+type EvidenceTier = "structured" | "primary" | "secondary" | "imported";
+
+export type ExposureRange = { low: number; high: number }
+export type ExposureBasis =
+  | "revenue"
+  | "cost"
+  | "purchases"
+  | "receivables"
+  | "operating_income"
+  | "interest_expense"
+  | "debt"
+type ExposureShockKind =
+  | "country"
+  | "commodity"
+  | "rate"
+  | "fx"
+  | "tariff"
+  | "supplier"
+  | "customer"
+/** Percentages are percentage points. Weights alone are fractions of NAV. */
+interface ExposureShock {
+  id: string
+  kind: ExposureShockKind
+  /** ISO country/currency code, commodity, or exact entity id/ticker/name. */
+  target: string
+  changePct?: number
+  changeBps?: number
+  /** Optional product restriction, e.g. a country export ban on semiconductors. */
+  products?: string[]
+  /** An explicit user assumption, never represented as a sourced disclosure. */
+  transmission?: {
+    basis: ExposureBasis
+    exposurePct: ExposureRange
+    /** Change in the denominator per unit change in the shock. */
+    factor: ExposureRange
+    direction?: 1 | -1
+  }
+}
+export interface ExposureScenario {
+  id?: string
+  label: string
+  shocks: ExposureShock[]
+}
+export interface ExposureHolding {
+  symbol: string
+  /** Signed fraction of NAV; 0.25 = 25%, -0.1 = 10% short. */
+  weight: number
+}
+export interface ExposureRequest {
+  holdings: ExposureHolding[]
+  scenario: ExposureScenario
+  depth?: number
+  /** Cash weight in NAV fractions, never used to renormalize holding weights. */
+  cashWeight?: number
+}
+export interface ExposureEvidence {
+  id: string
+  source: string
+  tier: EvidenceTier | "profile" | "user"
+  url: string | null
+  quote: string | null
+  asOf: string | null
+  period: string | null
+  units: string
+  currency: string | null
+  confidence: number | null
+  /** Corrections must supersede explicitly; adapters return the current revision. */
+  revision?: string | null
+}
+export interface ExposureExtensionObservation {
+  id: string
+  label: string
+  kind: "kpi" | "credit" | "guidance"
+  value: number | null
+  units: string
+  evidence: ExposureEvidence[]
+  currency?: string | null
+  period?: string | null
+  asOf?: string | null
+  basis?: string
+  dimensions?: Record<string, string>
+  qualifier?: string
+  range?: { low: number | null; high: number | null }
+  valueText?: string
+  status?: string
+  notes?: string[]
+  sensitivity?: {
+    kind: ExposureShockKind
+    target: string
+    basis: ExposureBasis
+    period: string
+    exposurePct: ExposureRange
+    factor: ExposureRange
+    direction: 1 | -1
+  } | null
+}
+interface ExposurePathHop {
+  from: { id: string; name: string; symbol: string | null; country: string | null }
+  to: { id: string; name: string; symbol: string | null; country: string | null }
+  evidence: ExposureEvidence[]
+  pct: number | null
+  basis: ExposureBasis | null
+  denominatorEntityId: string | null
+}
+export interface ExposureComponent {
+  id: string
+  shockId: string
+  label: string
+  channel: "geography" | "product" | "supplier" | "customer" | "profile" | "assumption" | "extension"
+  order: number
+  basis: ExposureBasis | null
+  period: string | null
+  classification: "disclosed" | "estimated" | "unknown"
+  exposurePct: ExposureRange | null
+  /** Estimated operating-denominator change; never a stock-return forecast. */
+  impactPct: ExposureRange | null
+  proportionalEstimatePct?: number | null
+  evidence: ExposureEvidence[]
+  path: ExposurePathHop[]
+  unknowns: string[]
+  /** Used only internally for validated disjoint revenue partitions. */
+  partition?: string | null
+}
+interface ExposureMeasure {
+  shockId: string
+  basis: ExposureBasis
+  period: string
+  exposurePct: ExposureRange
+  impactPct: ExposureRange | null
+  classification: "disclosed" | "estimated"
+  componentIds: string[]
+  /** True when an unquantified matching relationship prevents a complete bound. */
+  incomplete: boolean
+}
+interface ExposureHoldingResult {
+  symbol: string
+  name: string | null
+  weight: number
+  status: "quantified" | "partial" | "unknown"
+  measures: ExposureMeasure[]
+  components: ExposureComponent[]
+  extensions: ExposureExtensionObservation[]
+  unknowns: string[]
+  coverage: {
+    revenueRows: number
+    graphNodes: number
+    graphLinks: number
+    matchedPaths: number
+    quantifiedComponents: number
+    unknownComponents: number
+    graphComplete: boolean
+    oldestEvidenceAt: string | null
+    latestEvidenceAt: string | null
+  }
+}
+interface ExposurePortfolioMeasure {
+  shockId: string
+  basis: ExposureBasis
+  period: string
+  /** Holding-weighted operating exposure, in NAV-weighted percentage points. */
+  signedExposurePct: ExposureRange
+  grossExposurePct: ExposureRange
+  impactPct: ExposureRange | null
+  coveredGrossWeight: number
+  unknownGrossWeight: number
+  symbols: string[]
+}
+interface ExposureConcentration {
+  kind: "country" | "supplier" | "customer"
+  key: string
+  label: string
+  basis: ExposureBasis | null
+  period: string | null
+  grossExposurePct: ExposureRange | null
+  signedExposurePct: ExposureRange | null
+  grossHoldingWeight: number
+  symbols: string[]
+  evidence: ExposureEvidence[]
+  incomplete: boolean
+}
+export interface ExposurePayload {
+  version: 1
+  scenario: ExposureScenario
+  evaluatedAt: string
+  access: "full" | "preview"
+  depth: number
+  requestedHoldings: number
+  lockedHoldings: number
+  holdings: ExposureHoldingResult[]
+  portfolio: {
+    grossWeight: number
+    netWeight: number
+    cashWeight: number | null
+    /** 1 - net holding weights - explicit cash, financing/residual if not zero. */
+    residualWeight: number
+    measures: ExposurePortfolioMeasure[]
+    concentrations: ExposureConcentration[]
+    unknownGrossWeight: number
+  }
+  unknowns: string[]
+  methodology: string[]
+}

package/src/api-client/gpu.ts

@@ -0,0 +1,93 @@
+export type GpuBasis = "list" | "spot" | "ask" | "reserved" | "index" | "reference";
+
+type GpuProvenance = "archive" | "official-history" | "live" | "reference";
+interface GpuAccess { tier: "pro" | "preview"; preview: boolean; locked: boolean }
+
+export interface GpuObservation {
+  source: string;
+  skuKey: string;
+  provider: string;
+  providerClass: "hyperscaler" | "neocloud" | "marketplace" | "aggregate";
+  region: string;
+  gpuModel: string;
+  gpuCount: number;
+  formFactor: string | null;
+  memoryGb: number | null;
+  basis: GpuBasis;
+  pricePerGpuHr: number;
+  priceNodeHr: number | null;
+  currency: "USD";
+  availability: string | null;
+  observedAt: string;
+  effectiveAt: string | null;
+  provenance?: GpuProvenance;
+  provenanceLabel?: string;
+  evidenceUrl?: string | null;
+  sourceUrl?: string | null;
+  stats?: {
+    n: number; min: number; max: number;
+    p25?: number; p75?: number;
+    constituents?: string[];
+    rawMedian?: number;
+    chainFactor?: number;
+    constituentPrices?: Record<string, number>;
+  };
+}
+
+export interface GpuBoardRow extends GpuObservation {
+  id: string;
+  label: string;
+  sourceLabel: string;
+  change1d: number | null;
+  change7d: number | null;
+  change30d: number | null;
+  stale: boolean;
+  lastError: string | null;
+}
+
+export interface GpuBoardPayload {
+  access?: GpuAccess;
+  generatedAt: string;
+  status: "available" | "partial" | "unavailable";
+  asOf: string | null;
+  stale: boolean;
+  gaps: string[];
+  rows: GpuBoardRow[];
+}
+
+export interface GpuHistoryPayload {
+  access?: GpuAccess;
+  generatedAt: string;
+  points: GpuObservation[];
+  /** Provider effective dates are separate from observations collected by Gloom. */
+  effectivePoints: GpuObservation[];
+}
+
+export interface GpuEvent {
+  id: string;
+  origin?: "published" | "observed";
+  kind: "price" | "membership" | "availability";
+  provenance?: GpuProvenance;
+  provenanceLabel?: string;
+  evidenceUrl?: string | null;
+  sourceUrl?: string | null;
+  oldAvailability?: string | null;
+  newAvailability?: string | null;
+  source: string;
+  skuKey: string;
+  provider: string;
+  gpuModel: string;
+  formFactor: string | null;
+  memoryGb: number | null;
+  basis: GpuBasis;
+  observedAt: string;
+  effectiveAt: string | null;
+  oldPrice: number;
+  newPrice: number;
+  changePct: number;
+  oldMembers: string[] | null;
+  newMembers: string[] | null;
+}
+
+export interface GpuEventsPayload { access?: GpuAccess; generatedAt: string; events: GpuEvent[] }
+export interface GpuHistoryQuery { gpuModel?: string; basis?: GpuBasis; seriesId?: string; from?: string; to?: string; limit?: number }

package/src/api-client/hiring.ts

@@ -0,0 +1,110 @@
+/** HIRING is an observed requisition series, not headcount or job creation. */
+interface HiringCompany {
+  entityId: string
+  symbol: string
+  name: string
+  sector: string | null
+  mappingConfidence: number
+  mappingSourceUrl: string | null
+}
+
+interface HiringPosting {
+  id: string
+  title: string
+  url: string | null
+  location: string | null
+  country: string | null
+  remote: boolean | null
+  jobFunction: string | null
+  seniority: string | null
+  tags: string[]
+  classifiedBy: string | null
+  evergreen: boolean | null
+}
+
+interface HiringBucket {
+  id: string
+  label: string
+  count: number
+  share: number
+}
+
+interface HiringPoint {
+  week: string
+  observedAt: string
+  openCount: number
+  added: number | null
+  removed: number | null
+  netChange: number | null
+  changePct: number | null
+  remoteShare: number | null
+  remoteKnown: number | null
+  evergreenCount: number
+  sourceCount: number
+  completeness: "complete" | "partial" | "unknown"
+  confidence: number
+  kind: "observed" | "legacy_daily" | "mixed"
+}
+
+interface HiringSignal {
+  type: "surge" | "freeze" | "new_location"
+  label: string
+  value: number
+  asOf: string
+  confidence: number
+  location: string | null
+  evidenceUrls: string[]
+}
+
+interface HiringEvidence extends HiringPosting {
+  sourceTicker: string
+  sourceUrl: string | null
+  observedAt: string
+  snapshotId: string
+  revision: number
+  confidence: number
+}
+
+export interface HiringSummary extends HiringCompany {
+  latest: HiringPoint | null
+  historyWeeks: number
+  zScore: number | null
+  signal: "surge" | "freeze" | null
+  status: "ok" | "collecting" | "stale" | "uncovered"
+}
+
+export interface HiringPayload extends HiringSummary {
+  generatedAt: string
+  requestedSymbol?: string
+  proRequired: true
+  preview: boolean
+  locked: { history: number; evidence: number; peers: number; signals: number; mix: number }
+  series: HiringPoint[]
+  functions: HiringBucket[]
+  seniority: HiringBucket[]
+  countries: HiringBucket[]
+  locations: HiringBucket[]
+  signals: HiringSignal[]
+  peers: HiringSummary[]
+  evidence: HiringEvidence[]
+  coverage: {
+    sourceTickers: string[]
+    sourceUrls: string[]
+    firstObservedAt: string | null
+    lastObservedAt: string | null
+    knownCountryShare: number | null
+    classifiedShare: number | null
+    remoteKnownShare: number | null
+    comparability: string
+  }
+}
+
+export interface HiringBoard {
+  generatedAt: string
+  requestedSymbol?: string
+  proRequired: true
+  preview: boolean
+  total: number
+  locked: number
+  companies: HiringSummary[]
+}

package/src/api-client/index.ts

@@ -38,7 +38,8 @@ import type {
   PersistedAuthUser
 } from "./types";
 
-export { setCloudApiFetchTransport } from "./request";
+export { setCloudApiFetchTransport, setCloudApiUploadTransport } from "./request";
+export type { ChatAttachmentUpload } from "./chat";
 export { NoteConflictError } from "./notes";
 export { ThesisConflictError, ThesisGoalpostError } from "./theses";
 export { TeamRevisionConflictError } from "./views";
@@ -89,6 +90,8 @@ interface PendingSessionRequest {
 
 class GloomApiClient {
   private currentUser: AuthUser | null = null;
+  /** Local identity of a verified user/credential pair, never serialized. */
+  private verifiedSessionIdentity: object | null = null;
   private sessionChecked = false;
   /** Last few session transitions, content-free, for app://auth. */
   private authTrace: Array<{ at: number; event: string; token: boolean; user: string }> = [];
@@ -116,6 +119,8 @@ class GloomApiClient {
     markCurrentUserUnverified: () => {
       if (this.currentUser) {
         this.currentUser = { ...this.currentUser, emailVerified: false };
+        this.verifiedSessionIdentity = null;
+        this.emitCurrentUserChange();
       }
     },
     updateCurrentUserFromSocket: (user) => {
@@ -127,6 +132,7 @@ class GloomApiClient {
   });
   private readonly chat: CloudChatApi = new CloudChatApi({
     request: (path, options) => this.request(path, options),
+    upload: (path, body, options) => this.transport.upload(path, body, options),
     socket: this.socket,
   });
   private readonly teams: CloudTeamsApi = new CloudTeamsApi({
@@ -156,16 +162,22 @@ class GloomApiClient {
 
   setCookieSessionMode(enabled: boolean): void {
     this.sessionChecked = false;
+    this.verifiedSessionIdentity = null;
     this.transport.setCookieSessionMode(enabled);
+    this.emitCurrentUserChange();
   }
 
   setSessionToken(token: string | null): void {
     const changed = this.transport.getSessionToken() !== token;
     this.sessionChecked = false;
     this.transport.setSessionToken(token);
+    if (changed) this.verifiedSessionIdentity = null;
     this.traceAuth(changed ? "setSessionToken:changed" : "setSessionToken:same");
     if (!token) {
       this.currentUser = null;
+      this.verifiedSessionIdentity = null;
+    }
+    if (changed || !token) {
       this.emitCurrentUserChange();
     }
     this.socket.syncAuthState({ reconnect: changed });
@@ -190,7 +202,7 @@ class GloomApiClient {
     return !!this.transport.getSessionToken() || !!this.currentUser;
   }
 
-  /** Notifies when the signed-in user changes, including plan and trial entitlement. */
+  /** Notifies when the user or credential changes, including plan and trial entitlement. */
   subscribeCurrentUser(listener: () => void): () => void {
     this.currentUserListeners.add(listener);
     return () => {
@@ -206,6 +218,11 @@ class GloomApiClient {
     return this.transport.hasSessionCredential() && !!this.currentUser?.emailVerified;
   }
 
+  /** Null while a replacement credential still awaits its matching user. */
+  getVerifiedSessionIdentity(): object | null {
+    return this.isVerified() ? this.verifiedSessionIdentity : null;
+  }
+
   /**
    * What this client currently believes about its session, with no secrets.
    * Exposed over remote control so a "shows my username but not my
@@ -259,6 +276,7 @@ class GloomApiClient {
     const changed = this.socketEntitlementKey(this.currentUser) !== this.socketEntitlementKey(user);
     this.traceAuth("setCurrentUser", user);
     this.currentUser = user;
+    this.verifiedSessionIdentity = this.isVerified() ? {} : null;
     this.socket.syncAuthState({ reconnect: changed });
     this.emitCurrentUserChange();
   }
@@ -360,7 +378,8 @@ class GloomApiClient {
     event: import("./research-activity").ResearchActivity; eventId: string;
     surface: "web" | "desktop" | "tui" | "cli"; anonymousId?: string;
     attribution?: Record<string, string>; feature?: import("./research-activity").ResearchFeature;
-    tab?: string; desks?: readonly string[];
+    tab?: string; desks?: readonly string[]; placement?: string; teaser_kind?: "summary" | "sample" | "none";
+    cta?: "login" | "signup";
   }): Promise<void> {
     await this.request("/activity/research", { method: "POST", body: JSON.stringify(payload) });
   }
@@ -399,6 +418,20 @@ class GloomApiClient {
     return this.request<{ url: string }>("/stripe/portal", { method: "POST", body: JSON.stringify({}) });
   }
 
+  /**
+   * Asks which arm of an app experiment this account or web visitor is in, at the
+   * moment it would show. The API counts the answer as the exposure.
+   */
+  async recordExperimentExposure(payload: {
+    eventId: string; surface: "web" | "desktop" | "tui" | "cli"; anonymousId?: string;
+    attribution?: Record<string, string>; experiment: string; variant?: string;
+  }, signal?: AbortSignal): Promise<import("./web-experiments").ExperimentAnswer> {
+    return this.request("/activity/research", {
+      method: "POST",
+      body: JSON.stringify({ event: "experiment_exposed", ...payload }),
+      ...(signal ? { signal } : {}),
+    });
+  }
   getAccountProfile = this.auth.getAccountProfile.bind(this.auth);
   getCloudPricing = this.auth.getCloudPricing.bind(this.auth);
   getCloudAccountPlan = this.auth.getCloudAccountPlan.bind(this.auth);
@@ -603,6 +636,9 @@ class GloomApiClient {
   openGroupChannel = this.chat.openGroupChannel.bind(this.chat);
   getMessages = this.chat.getMessages.bind(this.chat);
   sendMessage = this.chat.sendMessage.bind(this.chat);
+  uploadChatAttachment = this.chat.uploadAttachment.bind(this.chat);
+  chatAttachmentsSupported = this.chat.attachmentsSupported.bind(this.chat);
+  subscribeChatAttachmentSupport = this.chat.subscribeAttachmentSupport.bind(this.chat);
   editMessage = this.chat.editMessage.bind(this.chat);
   connectChannel = this.chat.connectChannel.bind(this.chat);
   subscribeChatNotifications = this.chat.subscribeNotifications.bind(this.chat);
@@ -639,6 +675,7 @@ class GloomApiClient {
   listFeedback = this.feedback.listFeedback.bind(this.feedback);
   reportCrashErrors = this.telemetry.reportCrashErrors.bind(this.telemetry);
   reportUsageCounts = this.telemetry.reportUsageCounts.bind(this.telemetry);
+  reportAttentionCounts = this.telemetry.reportAttentionCounts.bind(this.telemetry);
   deleteCloudNote = this.notes.deleteNote.bind(this.notes);
   listTheses = this.theses.listTheses.bind(this.theses);
   getThesis = this.theses.getThesis.bind(this.theses);
@@ -705,12 +742,18 @@ class GloomApiClient {
   getCloudEstimateRevisions = this.data.getCloudEstimateRevisions.bind(this.data);
   getCloudMoneyMarkets = this.data.getCloudMoneyMarkets.bind(this.data);
   equityScreener = this.data.equityScreener.bind(this.data);
+  getCloudThemes = this.data.getCloudThemes.bind(this.data);
+  getCloudThemeMembers = this.data.getCloudThemeMembers.bind(this.data);
   impliedVolatility = this.data.impliedVolatility.bind(this.data);
   optionsPositioning = this.data.optionsPositioning.bind(this.data);
   getCloudDebtMaturities = this.data.getCloudDebtMaturities.bind(this.data);
   getCloudRevenueBreakdown = this.data.getCloudRevenueBreakdown.bind(this.data);
   getCloudMnaDeals = this.data.getCloudMnaDeals.bind(this.data);
   getCloudMnaDeal = this.data.getCloudMnaDeal.bind(this.data);
+  getPublicDistressFilings = this.data.getPublicDistressFilings.bind(this.data);
+  getPublicGoingConcern = this.data.getPublicGoingConcern.bind(this.data);
+  getPublicDistressDesignations = this.data.getPublicDistressDesignations.bind(this.data);
+  getPublicInsolvencyNotices = this.data.getPublicInsolvencyNotices.bind(this.data);
   getCloudIpoCalendar = this.data.getCloudIpoCalendar.bind(this.data);
   getCloudShortVolume = this.data.getCloudShortVolume.bind(this.data);
   getCloudSocialMentions = this.data.getCloudSocialMentions.bind(this.data);
@@ -721,6 +764,38 @@ class GloomApiClient {
   getCloudShiller = this.data.getCloudShiller.bind(this.data);
   getCloudCotBoard = this.data.getCloudCotBoard.bind(this.data);
   getCloudCotContract = this.data.getCloudCotContract.bind(this.data);
+  creditDocuments = this.data.creditDocuments.bind(this.data);
+  getCloudHiring = this.data.getCloudHiring.bind(this.data);
+  getCloudAppRankHistory = this.data.getCloudAppRankHistory.bind(this.data);
+  getCloudAppAttention = this.data.getCloudAppAttention.bind(this.data);
+  getCloudCatalystChanges = this.data.getCloudCatalystChanges.bind(this.data);
+  getCloudCatalysts = this.data.getCloudCatalysts.bind(this.data);
+  getCloudCatalystEvent = this.data.getCloudCatalystEvent.bind(this.data);
+  getCloudCatalystStatus = this.data.getCloudCatalystStatus.bind(this.data);
+  getCloudCompanyKpis = this.data.getCloudCompanyKpis.bind(this.data);
+  getCloudCompanyGuidance = this.data.getCloudCompanyGuidance.bind(this.data);
+  getCloudPerpsBoard = this.data.getCloudPerpsBoard.bind(this.data);
+  getCloudPerpsHistory = this.data.getCloudPerpsHistory.bind(this.data);
+  getCloudPerpsRankings = this.data.getCloudPerpsRankings.bind(this.data);
+  getCloudPerpsCompare = this.data.getCloudPerpsCompare.bind(this.data);
+  getCloudPerpsEquity = this.data.getCloudPerpsEquity.bind(this.data);
+  getCloudPerpsMarket = this.data.getCloudPerpsMarket.bind(this.data);
+  analyzeCloudExposure = this.data.analyzeCloudExposure.bind(this.data);
+  getCloudExposureScenarios = this.data.getCloudExposureScenarios.bind(this.data);
+  getCloudSupplyGraph = this.data.getCloudSupplyGraph.bind(this.data);
+  getCloudSupplyPaths = this.data.getCloudSupplyPaths.bind(this.data);
+  getCloudSupplyChain = this.data.getCloudSupplyChain.bind(this.data);
+  getCloudAwards = this.data.getCloudAwards.bind(this.data);
+  getCloudAward = this.data.getCloudAward.bind(this.data);
+  getCloudDoeBoard = this.data.getCloudDoeBoard.bind(this.data);
+  getCloudAttention = this.data.getCloudAttention.bind(this.data);
+  getCloudPowerBoard = this.data.getCloudPowerBoard.bind(this.data);
+  getCloudPowerHistory = this.data.getCloudPowerHistory.bind(this.data);
+  getCloudPowerProject = this.data.getCloudPowerProject.bind(this.data);
+  getCloudGpuBoard = this.data.getCloudGpuBoard.bind(this.data);
+  getCloudGpuHistory = this.data.getCloudGpuHistory.bind(this.data);
+  getCloudGpuEvents = this.data.getCloudGpuEvents.bind(this.data);
+  getCloudCpiBoard = this.data.getCloudCpiBoard.bind(this.data);
   getCloudTape = this.data.getCloudTape.bind(this.data);
   getCloudYieldCurve = this.data.getCloudYieldCurve.bind(this.data);
   getCloudCurve = this.data.getCloudCurve.bind(this.data);

package/src/api-client/normalizers.ts

@@ -1,4 +1,5 @@
 import type {
+  ChatAttachment,
   ChatChannel,
   ChatMessage,
   ChatNotification,
@@ -50,14 +51,43 @@ export function normalizeSearchResponse(
   return { ...response, hits: hits.map(normalizeSearchHit) };
 }
 
+function finiteNumber(value: unknown): number {
+  const number = typeof value === "number" ? value : Number(value);
+  return Number.isFinite(number) && number > 0 ? number : 0;
+}
+
+/** The images a message can show: entries without an id or a link are dropped. */
+export function normalizeChatAttachments(value: unknown): ChatAttachment[] {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((entry): ChatAttachment[] => {
+    if (!entry || typeof entry !== "object") return [];
+    const raw = entry as Record<string, unknown>;
+    if (typeof raw.id !== "string" || !raw.id || typeof raw.url !== "string" || !raw.url) return [];
+    return [{
+      id: raw.id,
+      mime: typeof raw.mime === "string" ? raw.mime : "",
+      width: finiteNumber(raw.width),
+      height: finiteNumber(raw.height),
+      size: finiteNumber(raw.size),
+      url: raw.url,
+    }];
+  });
+}
+
 export function normalizeChatMessage(message: ChatMessage): ChatMessage {
-  return {
+  const normalized: ChatMessage = {
     ...message,
+    content: typeof message.content === "string" ? message.content : "",
     createdAt: normalizeTimestamp(message.createdAt),
     ...(message.editedAt
       ? { editedAt: normalizeTimestamp(message.editedAt) }
       : {}),
   };
+  if ("attachments" in message) normalized.attachments = normalizeChatAttachments(message.attachments);
+  if (message.attachmentReview !== "pending" && message.attachmentReview !== "failed") {
+    delete normalized.attachmentReview;
+  }
+  return normalized;
 }
 
 export function normalizeChatMessages(messages: ChatMessage[]): ChatMessage[] {

package/src/api-client/paths.ts

@@ -13,6 +13,8 @@ export type CloudHistoryParams = {
   endDate?: string;
   rangeKey?: string;
   historyRecovery?: HistoryRetention;
+  /** Ask for pre-market and after-hours bars too. */
+  session?: "extended";
 };
 
 export type CloudFredSeriesParams = {
@@ -172,6 +174,7 @@ export function cloudHistoryPath(
   if (params.endDate) search.set("endDate", params.endDate);
   if (params.rangeKey) search.set("rangeKey", params.rangeKey);
   if (params.historyRecovery) search.set("historyRecovery", JSON.stringify(params.historyRecovery));
+  if (params.session) search.set("session", params.session);
   return appendQuery("/market/history", search);
 }