gloomberb 0.7.2 → 0.7.4

package/src/ui/context-menu.tsx

@@ -127,7 +127,7 @@ function selectedTextMenuItems(text: string, registry: PluginRegistry | null, co
       contextMenuDivider("selected-text:ticker-divider"),
       {
         id: "selected-text:open-ticker",
-        label: "Open as Ticker",
+        label: "Open Ticker Detail",
         onSelect: () => registry?.navigateTicker(symbol),
       },
       {
@@ -224,13 +224,13 @@ export function tickerContextMenuItems({
   const items: ContextMenuItem[] = [
     {
       id: "ticker:open",
-      label: `Open ${symbol}`,
+      label: `Open ${symbol} Detail`,
       onSelect: () => (openTicker ? openTicker(symbol) : registry?.navigateTicker(symbol)),
     },
     {
       id: "ticker:pin-floating",
-      label: `Pin ${symbol} in Floating Detail`,
-      onSelect: () => registry?.pinTicker(symbol, { floating: true, paneType: "ticker-detail" }),
+      label: `Open ${symbol} in New Floating Detail`,
+      onSelect: () => registry?.pinTicker(symbol, { floating: true, paneType: "ticker-detail", forceNewPane: true }),
     },
     {
       id: "ticker:copy-symbol",

package/src/utils/api-client.test.ts

@@ -210,6 +210,126 @@ describe("apiClient auth cookies", () => {
 
     unsubscribe();
   });
+
+  test("opens an anonymous market websocket and sends quote priority hints", () => {
+    const sent: unknown[] = [];
+    const sockets: Array<{
+      url: string;
+      readyState: number;
+      onopen: ((event: unknown) => void) | null;
+      close: () => void;
+    }> = [];
+
+    class FakeWebSocket {
+      static OPEN = 1;
+      readyState = 1;
+      onopen: ((event: unknown) => void) | null = null;
+      onmessage: ((event: { data: string }) => void) | null = null;
+      onclose: ((event: unknown) => void) | null = null;
+      onerror: ((event: unknown) => void) | null = null;
+
+      constructor(readonly url: string) {
+        sockets.push(this);
+      }
+
+      send(payload: string): void {
+        sent.push(JSON.parse(payload));
+      }
+
+      close(): void {
+        this.readyState = 3;
+      }
+    }
+
+    globalThis.WebSocket = FakeWebSocket as any;
+
+    const unsubscribe = apiClient.subscribeQuotes([{
+      symbol: "AAPL",
+      exchange: "NASDAQ",
+      surface: "portfolio",
+      visible: true,
+      selected: true,
+      weight: 100,
+    }], () => {});
+    sockets[0]!.onopen?.({});
+
+    expect(sockets).toHaveLength(1);
+    expect(sockets[0]!.url).toBe("wss://api.gloom.sh/cloud/ws");
+    expect(sent).toContainEqual({
+      type: "market.subscribe",
+      symbols: [{
+        symbol: "AAPL",
+        exchange: "NASDAQ",
+        surface: "portfolio",
+        visible: true,
+        selected: true,
+        weight: 100,
+      }],
+    });
+
+    unsubscribe();
+  });
+
+  test("keeps an anonymous market websocket open after auth rejection", () => {
+    const seenPrices: number[] = [];
+    let closeCalls = 0;
+    const sockets: Array<{
+      readyState: number;
+      onopen: ((event: unknown) => void) | null;
+      onmessage: ((event: { data: string }) => void) | null;
+      close: () => void;
+    }> = [];
+
+    class FakeWebSocket {
+      static OPEN = 1;
+      readyState = 1;
+      onopen: ((event: unknown) => void) | null = null;
+      onmessage: ((event: { data: string }) => void) | null = null;
+      onclose: ((event: unknown) => void) | null = null;
+      onerror: ((event: unknown) => void) | null = null;
+
+      constructor(readonly _url: string) {
+        sockets.push(this);
+      }
+
+      send(): void {}
+
+      close(): void {
+        closeCalls += 1;
+        this.readyState = 3;
+      }
+    }
+
+    globalThis.WebSocket = FakeWebSocket as any;
+
+    const unsubscribe = apiClient.subscribeQuotes([{ symbol: "AAPL" }], (_target, quote) => {
+      seenPrices.push(quote.price);
+    });
+    sockets[0]!.onopen?.({});
+    sockets[0]!.onmessage?.({ data: JSON.stringify({ type: "auth.unverified" }) });
+    sockets[0]!.onmessage?.({
+      data: JSON.stringify({
+        type: "market.quote",
+        symbol: "AAPL",
+        exchange: "",
+        quote: {
+          symbol: "AAPL",
+          price: 123,
+          currency: "USD",
+          change: 0,
+          changePercent: 0,
+          lastUpdated: 1,
+          providerId: "gloomberb-cloud",
+          dataSource: "live",
+        },
+      }),
+    });
+
+    expect(closeCalls).toBe(0);
+    expect(seenPrices).toEqual([123]);
+
+    unsubscribe();
+  });
 });
 
 describe("apiClient chat timestamps", () => {
@@ -282,6 +402,134 @@ describe("apiClient chat timestamps", () => {
     expect(seenCreatedAts).toEqual(["2026-04-08T07:28:27.625Z"]);
     channel.close();
   });
+
+  test("fetches chat state and normalizes pending notification timestamps", async () => {
+    let requestedUrl = "";
+    globalThis.fetch = mockFetch(async (input: Request | string | URL) => {
+      requestedUrl = String(input);
+      return createResponse({
+        channels: [{ id: "everyone", name: "everyone", created_at: "2026-04-08T07:00:00.000Z" }],
+        onlineCount: 2,
+        channelStates: [{
+          channelId: "everyone",
+          notificationsEnabled: true,
+          lastReadMessageId: "m1",
+          unreadCount: 1,
+        }],
+        notifications: [{
+          id: "n1",
+          type: "reply",
+          channelId: "everyone",
+          messageId: "m2",
+          createdAt: "2026-04-08 07:30:00.000",
+          message: {
+            id: "m2",
+            channelId: "everyone",
+            content: "reply",
+            replyToId: "m1",
+            createdAt: "2026-04-08 07:29:00.000",
+            user: { id: "u2", username: "bob", displayName: "Bob" },
+            replyTo: { content: "parent", user: { id: "u1", username: "vince" } },
+          },
+        }],
+      });
+    });
+
+    const state = await apiClient.getChatState();
+
+    expect(new URL(requestedUrl).pathname).toBe("/chat/state");
+    expect(state.onlineCount).toBe(2);
+    expect(state.notifications[0]?.createdAt).toBe("2026-04-08T07:30:00.000Z");
+    expect(state.notifications[0]?.message.createdAt).toBe("2026-04-08T07:29:00.000Z");
+  });
+
+  test("updates chat channel state and marks notifications delivered", async () => {
+    const requests: Array<{ path: string; method: string; body: unknown }> = [];
+    const responses = [
+      createResponse({
+        channelId: "everyone",
+        notificationsEnabled: true,
+        lastReadMessageId: "m2",
+        unreadCount: 0,
+      }),
+      createResponse({ delivered: 2 }),
+      createResponse({ onlineCount: 4 }),
+    ];
+    globalThis.fetch = mockFetch(async (input: Request | string | URL, init?: RequestInit) => {
+      requests.push({
+        path: new URL(String(input)).pathname,
+        method: init?.method ?? "GET",
+        body: init?.body ? JSON.parse(String(init.body)) : null,
+      });
+      return responses.shift() as Response;
+    });
+
+    await apiClient.updateChatChannelState("everyone", {
+      notificationsEnabled: true,
+      readThroughMessageId: "m2",
+    });
+    await apiClient.markChatNotificationsDelivered(["n1", "n2"]);
+    const presence = await apiClient.getChatPresence();
+
+    expect(requests).toEqual([
+      {
+        path: "/chat/channels/everyone/state",
+        method: "PATCH",
+        body: { notificationsEnabled: true, readThroughMessageId: "m2" },
+      },
+      {
+        path: "/chat/notifications/delivered",
+        method: "POST",
+        body: { notificationIds: ["n1", "n2"] },
+      },
+      {
+        path: "/chat/presence",
+        method: "GET",
+        body: null,
+      },
+    ]);
+    expect(presence).toEqual({ onlineCount: 4 });
+  });
+
+  test("emits websocket chat presence and notification events", async () => {
+    const seenPresence: number[] = [];
+    const seenNotifications: string[] = [];
+    const unsubscribePresence = apiClient.subscribeChatPresence((onlineCount) => {
+      seenPresence.push(onlineCount);
+    });
+    const unsubscribeNotifications = apiClient.subscribeChatNotifications((notification) => {
+      seenNotifications.push(`${notification.id}:${notification.message.createdAt}`);
+    });
+
+    await (apiClient as any).handleSocketMessage(JSON.stringify({
+      type: "chat.presence",
+      onlineCount: 5,
+    }));
+    await (apiClient as any).handleSocketMessage(JSON.stringify({
+      type: "chat.notification",
+      data: {
+        id: "n1",
+        type: "reply",
+        channelId: "everyone",
+        messageId: "m2",
+        createdAt: "2026-04-08 07:30:00.000",
+        message: {
+          id: "m2",
+          channelId: "everyone",
+          content: "reply",
+          replyToId: "m1",
+          createdAt: "2026-04-08 07:29:00.000",
+          user: { id: "u2", username: "bob", displayName: "Bob" },
+          replyTo: { content: "parent", user: { id: "u1", username: "vince" } },
+        },
+      },
+    }));
+
+    expect(seenPresence).toEqual([5]);
+    expect(seenNotifications).toEqual(["n1:2026-04-08T07:29:00.000Z"]);
+    unsubscribePresence();
+    unsubscribeNotifications();
+  });
 });
 
 describe("apiClient cloud news", () => {

package/src/utils/api-client.ts

@@ -5,6 +5,7 @@ import type {
   Fundamentals,
   HolderData,
   HolderRecord,
+  OptionsChain,
   PricePoint,
   Quote,
   TickerFinancials,
@@ -48,7 +49,7 @@ export interface ChatMessage {
   replyToId: string | null;
   createdAt: string;
   user: { id: string; username: string; displayName: string };
-  replyTo?: { content: string; user: { username: string } } | null;
+  replyTo?: { content: string; user: { id?: string; username: string } } | null;
   clientStatus?: "sending" | "failed";
   clientError?: string | null;
 }
@@ -59,6 +60,29 @@ export interface ChatChannel {
   created_at: string;
 }
 
+export interface ChatChannelState {
+  channelId: string;
+  notificationsEnabled: boolean;
+  lastReadMessageId: string | null;
+  unreadCount: number;
+}
+
+export interface ChatNotification {
+  id: string;
+  type: "reply" | "mention" | "channel";
+  channelId: string;
+  messageId: string;
+  createdAt: string;
+  message: ChatMessage;
+}
+
+export interface ChatStateResponse {
+  channels: ChatChannel[];
+  onlineCount: number;
+  channelStates: ChatChannelState[];
+  notifications: ChatNotification[];
+}
+
 export interface AuthUser {
   id: string;
   name: string;
@@ -77,6 +101,10 @@ export interface CloudQuotePayload extends Quote {
   dataSource: "live" | "delayed";
 }
 
+export interface CloudOptionsChainPayload extends OptionsChain {
+  providerId: "gloomberb-cloud";
+}
+
 export interface CloudCompanyProfile extends CompanyProfile {}
 
 export interface CloudFundamentals extends Fundamentals {}
@@ -294,10 +322,19 @@ export interface CloudMarketResponse<T> {
   reasonCode?: string;
   asOf?: string;
   staleAt?: string;
+  stale?: boolean;
+  currency?: string;
   providerMeta?: {
+    provider?: string;
     upstream?: string;
+    status?: CloudMarketStatus;
+    reasonCode?: string;
     normalizedSymbol?: string;
     normalizedExchange?: string;
+    stale?: boolean;
+    fallbackReason?: string;
+    requestedResolution?: string;
+    servedResolution?: string;
     latencyMs?: number;
     range?: string;
     granularity?: string;
@@ -333,6 +370,10 @@ export interface CloudVerificationResponse {
 export interface QuoteStreamTarget {
   symbol: string;
   exchange?: string;
+  surface?: "portfolio" | "watchlist" | "detail" | "monitor" | "inline" | "screener" | "unknown";
+  visible?: boolean;
+  selected?: boolean;
+  weight?: number;
 }
 
 function marketKey(symbol: string, exchange?: string): string {
@@ -352,6 +393,21 @@ function normalizeChatMessages(messages: ChatMessage[]): ChatMessage[] {
   return messages.map((message) => normalizeChatMessage(message));
 }
 
+function normalizeChatNotification(notification: ChatNotification): ChatNotification {
+  return {
+    ...notification,
+    createdAt: normalizeTimestamp(notification.createdAt),
+    message: normalizeChatMessage(notification.message),
+  };
+}
+
+function normalizeChatState(response: ChatStateResponse): ChatStateResponse {
+  return {
+    ...response,
+    notifications: response.notifications.map(normalizeChatNotification),
+  };
+}
+
 function normalizeTweet(tweet: CloudTweetPayload): CloudTweetPayload {
   return {
     ...tweet,
@@ -370,6 +426,8 @@ function normalizeTweetSearchResponse(response: CloudTweetSearchResponse): Cloud
 }
 
 type ChannelListener = (message: ChatMessage) => void;
+type ChatNotificationListener = (notification: ChatNotification) => void;
+type ChatPresenceListener = (onlineCount: number) => void;
 type QuoteListener = (target: QuoteStreamTarget, quote: CloudQuotePayload) => void;
 type SessionCookieName = (typeof SESSION_COOKIE_NAMES)[number];
 
@@ -408,6 +466,8 @@ class GloomApiClient {
   private reconnectDelayMs = 1000;
 
   private readonly channelListeners = new Map<string, Set<ChannelListener>>();
+  private readonly chatNotificationListeners = new Set<ChatNotificationListener>();
+  private readonly chatPresenceListeners = new Set<ChatPresenceListener>();
   private readonly quoteListeners = new Map<string, Set<QuoteListener>>();
   private readonly quoteTargets = new Map<string, QuoteStreamTarget>();
   private readonly pendingQuoteSubscribes = new Map<string, QuoteStreamTarget>();
@@ -560,18 +620,20 @@ class GloomApiClient {
   }
 
   private shouldKeepSocketOpen(): boolean {
+    if (this.quoteTargets.size > 0) return true;
     return !!this.getSocketAuthToken()
       && !!this.currentUser?.emailVerified
-      && (this.channelListeners.size > 0 || this.quoteTargets.size > 0);
+      && this.channelListeners.size > 0;
   }
 
   private ensureSocket(): void {
     if (!this.shouldKeepSocketOpen() || this.ws || this.reconnectTimer) return;
 
     const socketToken = this.getSocketAuthToken();
-    if (!socketToken) return;
     const usingWebSocketToken = !!this.websocketToken;
-    const url = `${this.getWebSocketBaseUrl()}/cloud/ws?token=${encodeURIComponent(socketToken)}`;
+    const url = socketToken
+      ? `${this.getWebSocketBaseUrl()}/cloud/ws?token=${encodeURIComponent(socketToken)}`
+      : `${this.getWebSocketBaseUrl()}/cloud/ws`;
     cloudApiLog.info("open websocket", {
       hasToken: !!socketToken,
       tokenSource: usingWebSocketToken ? "websocket" : "session",
@@ -650,7 +712,12 @@ class GloomApiClient {
     if (this.ws?.readyState !== WebSocket.OPEN) return;
     if (payload && typeof payload === "object" && "type" in (payload as Record<string, unknown>)) {
       const type = (payload as Record<string, unknown>).type;
-      if (type === "market.subscribe" || type === "market.unsubscribe" || type === "chat.subscribe") {
+      if (
+        type === "market.subscribe"
+        || type === "market.unsubscribe"
+        || type === "chat.subscribe"
+        || type === "chat.unsubscribe"
+      ) {
         cloudApiLog.info("send websocket message", payload);
       }
     }
@@ -667,10 +734,7 @@ class GloomApiClient {
     if (this.quoteTargets.size > 0) {
       this.sendSocketMessage({
         type: "market.subscribe",
-        symbols: [...this.quoteTargets.values()].map((target) => ({
-          symbol: target.symbol,
-          exchange: target.exchange ?? "",
-        })),
+        symbols: [...this.quoteTargets.values()].map((target) => this.serializeQuoteStreamTarget(target)),
       });
     }
   }
@@ -714,23 +778,28 @@ class GloomApiClient {
     if (subscribes.length > 0) {
       this.sendSocketMessage({
         type: "market.subscribe",
-        symbols: subscribes.map((target) => ({
-          symbol: target.symbol,
-          exchange: target.exchange ?? "",
-        })),
+        symbols: subscribes.map((target) => this.serializeQuoteStreamTarget(target)),
       });
     }
     if (unsubscribes.length > 0) {
       this.sendSocketMessage({
         type: "market.unsubscribe",
-        symbols: unsubscribes.map((target) => ({
-          symbol: target.symbol,
-          exchange: target.exchange ?? "",
-        })),
+        symbols: unsubscribes.map((target) => this.serializeQuoteStreamTarget(target)),
       });
     }
   }
 
+  private serializeQuoteStreamTarget(target: QuoteStreamTarget): QuoteStreamTarget {
+    return {
+      symbol: target.symbol,
+      exchange: target.exchange ?? "",
+      ...(target.surface ? { surface: target.surface } : {}),
+      ...(target.visible ? { visible: true } : {}),
+      ...(target.selected ? { selected: true } : {}),
+      ...(Number.isFinite(target.weight) ? { weight: target.weight } : {}),
+    };
+  }
+
   private async handleSocketMessage(raw: string): Promise<void> {
     let parsed: any;
     try {
@@ -761,6 +830,9 @@ class GloomApiClient {
       if (this.currentUser) {
         this.currentUser = { ...this.currentUser, emailVerified: false };
       }
+      if (this.quoteTargets.size > 0) {
+        return;
+      }
       this.teardownSocket();
       return;
     }
@@ -773,6 +845,21 @@ class GloomApiClient {
       return;
     }
 
+    if (parsed?.type === "chat.notification" && parsed.data) {
+      const notification = normalizeChatNotification(parsed.data as ChatNotification);
+      for (const listener of this.chatNotificationListeners) {
+        listener(notification);
+      }
+      return;
+    }
+
+    if (parsed?.type === "chat.presence" && typeof parsed.onlineCount === "number") {
+      for (const listener of this.chatPresenceListeners) {
+        listener(parsed.onlineCount);
+      }
+      return;
+    }
+
     if (parsed?.type === "market.quote" && parsed.quote && typeof parsed.symbol === "string") {
       const key = marketKey(parsed.symbol, parsed.exchange);
       const target = this.quoteTargets.get(key) ?? {
@@ -853,6 +940,32 @@ class GloomApiClient {
     return this.request<ChatChannel[]>("/chat/channels");
   }
 
+  async getChatPresence(): Promise<{ onlineCount: number }> {
+    return this.request<{ onlineCount: number }>("/chat/presence");
+  }
+
+  async getChatState(): Promise<ChatStateResponse> {
+    const state = await this.request<ChatStateResponse>("/chat/state");
+    return normalizeChatState(state);
+  }
+
+  async updateChatChannelState(
+    channelId: string,
+    body: { notificationsEnabled?: boolean; readThroughMessageId?: string },
+  ): Promise<ChatChannelState> {
+    return this.request<ChatChannelState>(`/chat/channels/${channelId}/state`, {
+      method: "PATCH",
+      body: JSON.stringify(body),
+    });
+  }
+
+  async markChatNotificationsDelivered(notificationIds: string[]): Promise<{ delivered: number }> {
+    return this.request<{ delivered: number }>("/chat/notifications/delivered", {
+      method: "POST",
+      body: JSON.stringify({ notificationIds }),
+    });
+  }
+
   async getMessages(
     channelId: string,
     opts?: { after?: string; before?: string; limit?: number },
@@ -866,10 +979,10 @@ class GloomApiClient {
     return normalizeChatMessages(messages);
   }
 
-  async sendMessage(channelId: string, content: string, replyToId?: string): Promise<ChatMessage> {
+  async sendMessage(channelId: string, content: string, replyToId?: string, clientMessageId?: string): Promise<ChatMessage> {
     const message = await this.request<ChatMessage>(`/chat/channels/${channelId}/messages`, {
       method: "POST",
-      body: JSON.stringify({ content, replyToId }),
+      body: JSON.stringify({ content, replyToId, clientMessageId }),
     });
     return normalizeChatMessage(message);
   }
@@ -878,7 +991,7 @@ class GloomApiClient {
     channelId: string,
     onMessage: (msg: ChatMessage) => void,
     onError?: (err: string) => void,
-  ): { send: (content: string, replyToId?: string) => Promise<ChatMessage>; close: () => void } {
+  ): { send: (content: string, replyToId?: string, clientMessageId?: string) => Promise<ChatMessage>; close: () => void } {
     if (!channelId) {
       return {
         send: async () => {
@@ -898,9 +1011,9 @@ class GloomApiClient {
     }
 
     return {
-      send: async (content: string, replyToId?: string) => {
+      send: async (content: string, replyToId?: string, clientMessageId?: string) => {
         try {
-          const message = await this.sendMessage(channelId, content, replyToId);
+          const message = await this.sendMessage(channelId, content, replyToId, clientMessageId);
           onMessage(message);
           return message;
         } catch (error) {
@@ -914,6 +1027,7 @@ class GloomApiClient {
         current.delete(onMessage);
         if (current.size === 0) {
           this.channelListeners.delete(channelId);
+          this.sendSocketMessage({ type: "chat.unsubscribe", channelId });
         }
         if (!this.shouldKeepSocketOpen()) {
           this.teardownSocket();
@@ -922,6 +1036,20 @@ class GloomApiClient {
     };
   }
 
+  subscribeChatNotifications(listener: ChatNotificationListener): () => void {
+    this.chatNotificationListeners.add(listener);
+    return () => {
+      this.chatNotificationListeners.delete(listener);
+    };
+  }
+
+  subscribeChatPresence(listener: ChatPresenceListener): () => void {
+    this.chatPresenceListeners.add(listener);
+    return () => {
+      this.chatPresenceListeners.delete(listener);
+    };
+  }
+
   subscribeQuotes(
     targets: QuoteStreamTarget[],
     onQuote: (target: QuoteStreamTarget, quote: CloudQuotePayload) => void,
@@ -933,17 +1061,27 @@ class GloomApiClient {
           const normalized = {
             symbol: normalizeSymbol(target.symbol),
             exchange: canonicalExchange(target.exchange),
+            surface: target.surface,
+            visible: target.visible,
+            selected: target.selected,
+            weight: target.weight,
           } satisfies QuoteStreamTarget;
           return [marketKey(normalized.symbol, normalized.exchange), normalized] as const;
         }),
     ).values()];
 
     const newSubscriptions: QuoteStreamTarget[] = [];
+    const updatedSubscriptions: QuoteStreamTarget[] = [];
     for (const target of uniqueTargets) {
       const key = marketKey(target.symbol, target.exchange);
       const listeners = this.quoteListeners.get(key) ?? new Set<QuoteListener>();
       if (listeners.size === 0) {
         newSubscriptions.push(target);
+      } else {
+        const existing = this.quoteTargets.get(key);
+        if (JSON.stringify(this.serializeQuoteStreamTarget(existing ?? target)) !== JSON.stringify(this.serializeQuoteStreamTarget(target))) {
+          updatedSubscriptions.push(target);
+        }
       }
       listeners.add(onQuote);
       this.quoteListeners.set(key, listeners);
@@ -951,12 +1089,13 @@ class GloomApiClient {
     }
 
     this.ensureSocket();
-    if (newSubscriptions.length > 0) {
+    const subscriptionsToSend = [...newSubscriptions, ...updatedSubscriptions];
+    if (subscriptionsToSend.length > 0) {
       cloudApiLog.info("register quote listeners", {
-        count: newSubscriptions.length,
-        symbols: newSubscriptions.map((target) => marketKey(target.symbol, target.exchange)),
+        count: subscriptionsToSend.length,
+        symbols: subscriptionsToSend.map((target) => marketKey(target.symbol, target.exchange)),
       });
-      this.queueQuoteSubscribes(newSubscriptions);
+      this.queueQuoteSubscribes(subscriptionsToSend);
     }
 
     return () => {
@@ -997,6 +1136,8 @@ class GloomApiClient {
       channelTargets: this.channelListeners.size,
     });
     this.channelListeners.clear();
+    this.chatNotificationListeners.clear();
+    this.chatPresenceListeners.clear();
     this.quoteListeners.clear();
     this.quoteTargets.clear();
     this.pendingQuoteSubscribes.clear();
@@ -1034,6 +1175,17 @@ class GloomApiClient {
     });
   }
 
+  async getCloudOptionsChain(
+    symbol: string,
+    exchange?: string,
+    expirationDate?: number,
+  ): Promise<CloudMarketResponse<CloudOptionsChainPayload>> {
+    const params = new URLSearchParams({ symbol });
+    if (exchange) params.set("exchange", exchange);
+    if (expirationDate != null) params.set("expirationDate", String(expirationDate));
+    return this.request<CloudMarketResponse<CloudOptionsChainPayload>>(`/market/options?${params.toString()}`);
+  }
+
   async getCloudProfile(symbol: string, exchange?: string): Promise<CloudMarketResponse<CloudCompanyProfile>> {
     const params = new URLSearchParams({ symbol });
     if (exchange) params.set("exchange", exchange);