gloomberb 0.12.0 → 0.13.1

package/src/plugins/builtin/cloud/askg/protocol.test.ts

@@ -0,0 +1,189 @@
+import { describe, expect, test } from "bun:test";
+import type { HeadlessPaneDefinition } from "../../../../types/headless";
+import { marketValuationHeadless } from "../../market-valuation/headless";
+import {
+  ASKG_PROTOCOL_VERSION,
+  TOOL_NAME_PATTERN,
+  type ASKGSessionStartRequest,
+  type ASKGSessionStartResponse,
+  type ASKGSseEvent,
+  type ToolManifest,
+  type ToolResultPayload,
+} from "./protocol";
+
+function jsonRoundTrip<T>(value: T): T {
+  return JSON.parse(JSON.stringify(value)) as T;
+}
+
+function projectHeadlessDefinition(
+  definition: HeadlessPaneDefinition,
+): ToolManifest {
+  const options = definition.options.map(({ settingKey: _settingKey, pluginState: _pluginState, ...option }) => option);
+  const columns = definition.columns?.map(({ format: _format, ...column }) => column);
+  return {
+    name: "market.valuation",
+    source: "headless",
+    title: "Market valuation",
+    description: "Compare whole-market valuation ratios with their history.",
+    writeTier: "read",
+    shape: definition.shape,
+    argument: definition.argument,
+    options,
+    ...(columns ? { columns } : {}),
+    confirm: "never",
+    timeoutMs: 30_000,
+  };
+}
+
+describe("ASKG protocol", () => {
+  test("round-trips session negotiation, a manifest, every event, and a tool result", () => {
+    const manifest: ToolManifest = {
+      name: "layout.place_pane",
+      source: "remote-op",
+      title: "Place pane",
+      description: "Move a pane to a layout region.",
+      writeTier: "ui-write",
+      inputSchema: {
+        type: "object",
+        properties: {
+          paneId: { type: "string" },
+          region: { type: "string", enum: ["left", "right", "floating"] },
+        },
+        required: ["paneId", "region"],
+        additionalProperties: false,
+      },
+      confirm: "never",
+      timeoutMs: 10_000,
+    };
+    const sessionRequest: ASKGSessionStartRequest = {
+      protocolVersion: ASKG_PROTOCOL_VERSION,
+      client: { kind: "tui", version: "0.8.0" },
+      context: {
+        query: "Compare NVDA valuation",
+        symbol: "NVDA",
+        paneId: "ticker:main",
+        layout: { id: "layout-1" },
+      },
+      tools: [manifest],
+      manifestHash: "sha256:manifest-1",
+    };
+    const sessionResponse: ASKGSessionStartResponse = {
+      protocolVersion: ASKG_PROTOCOL_VERSION,
+      sessionId: "session-1",
+      manifestHash: sessionRequest.manifestHash,
+      serverTools: [],
+      acceptedTools: [manifest.name],
+      rejectedTools: [{ name: "invalid.tool", reason: "Unknown source" }],
+      limits: {
+        requestsPerMinute: 20,
+        turnsPerDay: 300,
+        turnsRemainingToday: 299,
+        maxToolCallsPerTurn: 25,
+        turnWallClockMs: 90_000,
+        clientToolTimeoutMs: 10_000,
+      },
+      tier: "pro",
+      model: "gpt-5.6-luna",
+      promptVersion: "2026-09-04",
+      expiresAt: "2026-09-04T21:30:00.000Z",
+    };
+    const events: ASKGSseEvent[] = [
+      {
+        type: "session",
+        seq: 1,
+        sessionId: "session-1",
+        turnId: "turn-1",
+        model: "gpt-5.6-luna",
+        promptVersion: "2026-09-04",
+      },
+      { type: "text-delta", seq: 2, turnId: "turn-1", delta: "NVDA" },
+      {
+        type: "tool-call",
+        seq: 3,
+        turnId: "turn-1",
+        toolCallId: "call-1",
+        name: manifest.name,
+        args: { paneId: "chart:main", region: "right" },
+        writeTier: "ui-write",
+        requiresConfirmation: false,
+        preview: { paneId: "chart:main", region: "right", dryRun: true },
+        timeoutMs: 10_000,
+        expiresAt: "2026-09-04T21:00:10.000Z",
+      },
+      {
+        type: "tool-executed",
+        seq: 4,
+        turnId: "turn-1",
+        toolCallId: "call-server-1",
+        name: "market.quote",
+        source: "server",
+        status: "ok",
+        summary: {
+          rowCount: 1,
+          elapsedMs: 24,
+          truncated: false,
+          note: "Fresh quote",
+          sample: { symbol: "NVDA", price: 180 },
+        },
+      },
+      { type: "tool-result-ack", seq: 5, turnId: "turn-1", toolCallId: "call-1" },
+      {
+        type: "error",
+        seq: 6,
+        turnId: "turn-1",
+        code: "rate_limited",
+        message: "Try again shortly.",
+        retryable: true,
+        retryAfterMs: 1_000,
+      },
+      {
+        type: "usage",
+        seq: 7,
+        turnId: "turn-1",
+        inputTokens: 120,
+        outputTokens: 30,
+        totalTokens: 150,
+        estimated: false,
+      },
+      { type: "done", seq: 8, turnId: "turn-1", reason: "complete" },
+    ];
+    const result: ToolResultPayload = {
+      turnId: "turn-1",
+      toolCallId: "call-1",
+      status: "ok",
+      result: { moved: true },
+      rowCount: 1,
+      truncated: false,
+      elapsedMs: 12,
+      rev: "rev-2",
+      undoToken: "undo-1",
+    };
+
+    expect(new RegExp(TOOL_NAME_PATTERN).test(manifest.name)).toBe(true);
+    expect(jsonRoundTrip(manifest)).toEqual(manifest);
+    expect(jsonRoundTrip(sessionRequest)).toEqual(sessionRequest);
+    expect(jsonRoundTrip(sessionResponse)).toEqual(sessionResponse);
+    expect(events.map(jsonRoundTrip)).toEqual(events);
+    expect(jsonRoundTrip(result)).toEqual(result);
+  });
+
+  test("projects a migrated headless definition without executable fields", () => {
+    const manifest = projectHeadlessDefinition(marketValuationHeadless);
+    const serialized = JSON.stringify(manifest);
+
+    expect(new RegExp(TOOL_NAME_PATTERN).test(manifest.name)).toBe(true);
+    expect(manifest).toMatchObject({
+      source: "headless",
+      writeTier: "read",
+      shape: marketValuationHeadless.shape,
+      argument: marketValuationHeadless.argument,
+      confirm: "never",
+    });
+    expect(manifest.options).toHaveLength(marketValuationHeadless.options.length);
+    expect(serialized).not.toContain("load");
+    expect(serialized).not.toContain("settingKey");
+    expect(serialized).not.toContain("pluginState");
+    expect(serialized).not.toContain("format");
+    expect(jsonRoundTrip(manifest)).toEqual(manifest);
+  });
+});

package/src/plugins/builtin/cloud/askg/protocol.ts

@@ -0,0 +1,274 @@
+// Wire declarations are mirrored in gloomberb-platform/server/src/services/askg/types.ts.
+import type {
+  HeadlessPaneArgumentDef,
+  HeadlessPaneColumn,
+  HeadlessPaneOptionDef,
+  HeadlessPaneOptionValue,
+  HeadlessPaneShape,
+} from "../../../../types/headless";
+import type {
+  RemoteJsonSchema,
+  RemoteJsonSchemaType,
+  RemoteWriteTier,
+} from "../../../../remote/types";
+
+/** Major version of the ASKG client and server wire contract. */
+export const ASKG_PROTOCOL_VERSION = 1;
+
+/** Maximum accepted JSON-encoded client tool result size. */
+export const MAX_TOOL_RESULT_BYTES = 262_144;
+
+/** Source form for valid tool names advertised to ASKG. */
+export const TOOL_NAME_PATTERN = "^[a-z][a-z0-9_.]{2,48}$";
+
+/** JSON value accepted on the ASKG wire. */
+export type JsonValue =
+  | string
+  | number
+  | boolean
+  | null
+  | JsonValue[]
+  | { [key: string]: JsonValue };
+
+/** Safety tier applied before a client tool is executed. */
+export type WriteTier = RemoteWriteTier;
+
+/** Runtime that opened an ASKG session. */
+export type ASKGClientKind = "tui" | "desktop" | "web";
+
+/** Origin of an advertised client tool. */
+export type ToolManifestSource = "headless" | "remote-op";
+
+/** Headless result shapes supported by the tool timeline. */
+export type ToolManifestShape = HeadlessPaneShape;
+
+/** Headless argument kinds understood by the manifest compiler. */
+export type ToolManifestArgumentKind = HeadlessPaneArgumentDef["kind"];
+
+/** Serializable headless argument declaration. */
+export type ToolManifestArgument = HeadlessPaneArgumentDef;
+
+/** Values accepted by a headless enum option. */
+export type ToolManifestOptionValue = HeadlessPaneOptionValue;
+
+/** Headless option types understood by the manifest compiler. */
+export type ToolManifestOptionType = HeadlessPaneOptionDef["type"];
+
+/** Serializable headless option declaration. */
+export type ToolManifestOption = Omit<HeadlessPaneOptionDef, "settingKey" | "pluginState">;
+
+/** Serializable headless column declaration. */
+export type ToolManifestColumn = Omit<HeadlessPaneColumn, "format">;
+
+/** JSON Schema primitive types accepted for remote operation inputs. */
+export type ToolInputSchemaType = RemoteJsonSchemaType;
+
+/** JSON Schema accepted by a remote operation tool. */
+export type ToolInputSchema = RemoteJsonSchema;
+
+/** Client or server tool metadata negotiated when a session starts. */
+export interface ToolManifest {
+  /** Lowercase stable identifier matching TOOL_NAME_PATTERN. */
+  name: string;
+  source: ToolManifestSource;
+  title: string;
+  description: string;
+  writeTier: WriteTier;
+  shape?: ToolManifestShape;
+  argument?: ToolManifestArgument;
+  options?: ToolManifestOption[];
+  columns?: ToolManifestColumn[];
+  inputSchema?: ToolInputSchema;
+  confirm: "never" | "always";
+  timeoutMs: number;
+}
+
+/** Client identity included in a session negotiation. */
+export interface ASKGClientDescriptor {
+  kind: ASKGClientKind;
+  version: string;
+}
+
+/** Terminal context supplied to the model at session start. */
+export interface ASKGSessionContext {
+  query?: string;
+  symbol?: string;
+  paneId?: string;
+  layout?: JsonValue;
+}
+
+/** Request used to negotiate tools and limits for an ASKG session. */
+export interface ASKGSessionStartRequest {
+  protocolVersion: typeof ASKG_PROTOCOL_VERSION;
+  client: ASKGClientDescriptor;
+  context: ASKGSessionContext;
+  tools: ToolManifest[];
+  manifestHash: string;
+}
+
+/** Per-user and per-turn limits returned by the platform. */
+export interface ASKGLimits {
+  requestsPerMinute: number;
+  turnsPerDay: number;
+  turnsRemainingToday: number;
+  maxToolCallsPerTurn: number;
+  turnWallClockMs: number;
+  clientToolTimeoutMs: number;
+}
+
+/** Client tool rejected during session negotiation. */
+export interface ASKGRejectedTool {
+  name: string;
+  reason: string;
+}
+
+/** Successful ASKG session negotiation response. */
+export interface ASKGSessionStartResponse {
+  protocolVersion: typeof ASKG_PROTOCOL_VERSION;
+  sessionId: string;
+  manifestHash: string;
+  serverTools: ToolManifest[];
+  acceptedTools: string[];
+  rejectedTools: ASKGRejectedTool[];
+  limits: ASKGLimits;
+  tier: string;
+  model: string;
+  promptVersion: string;
+  expiresAt: string;
+}
+
+/** Shared fields carried by every turn stream event. */
+export interface ASKGEventBase {
+  seq: number;
+}
+
+/** Announces the session and turn attached to this stream. */
+export interface ASKGSessionEvent extends ASKGEventBase {
+  type: "session";
+  sessionId: string;
+  turnId: string;
+  model: string;
+  promptVersion: string;
+}
+
+/** Appends model text to the visible answer. */
+export interface ASKGTextDeltaEvent extends ASKGEventBase {
+  type: "text-delta";
+  turnId: string;
+  delta: string;
+}
+
+/** Delegates one negotiated tool call to the client. */
+export interface ASKGToolCallEvent extends ASKGEventBase {
+  type: "tool-call";
+  turnId: string;
+  toolCallId: string;
+  name: string;
+  args: Record<string, JsonValue>;
+  writeTier: WriteTier;
+  requiresConfirmation: boolean;
+  preview: JsonValue;
+  timeoutMs: number;
+  expiresAt: string;
+}
+
+/** Compact result information suitable for the tool timeline. */
+export interface ToolExecutionSummary {
+  rowCount?: number;
+  elapsedMs: number;
+  truncated: boolean;
+  note?: string;
+  sample?: JsonValue;
+}
+
+/** Status returned by either a server or client tool execution. */
+export type ToolResultStatus =
+  | "ok"
+  | "error"
+  | "denied"
+  | "timeout"
+  | "partial"
+  | "cancelled";
+
+/** Reports a completed server tool or an accepted client execution. */
+export interface ASKGToolExecutedEvent extends ASKGEventBase {
+  type: "tool-executed";
+  turnId: string;
+  toolCallId: string;
+  name: string;
+  source: ToolManifestSource | "server";
+  status: ToolResultStatus;
+  summary: ToolExecutionSummary;
+}
+
+/** Confirms that one client tool result was accepted by the turn loop. */
+export interface ASKGToolResultAckEvent extends ASKGEventBase {
+  type: "tool-result-ack";
+  turnId: string;
+  toolCallId: string;
+}
+
+/** Stable error codes that clients can handle without parsing text. */
+export type ASKGErrorCode =
+  | "rate_limited"
+  | "daily_turn_cap"
+  | "tool_budget_exhausted"
+  | "turn_timeout"
+  | "model_usage_limit"
+  | "model_unavailable"
+  | "internal";
+
+/** Reports a recoverable or terminal session or turn failure. */
+export interface ASKGErrorEvent extends ASKGEventBase {
+  type: "error";
+  turnId?: string;
+  code: ASKGErrorCode;
+  message: string;
+  retryable: boolean;
+  retryAfterMs?: number;
+}
+
+/** Token accounting emitted when the model provider supplies it. */
+export interface ASKGUsageEvent extends ASKGEventBase {
+  type: "usage";
+  turnId: string;
+  inputTokens?: number;
+  outputTokens?: number;
+  totalTokens?: number;
+  estimated: boolean;
+}
+
+/** Reason a turn stream stopped. */
+export type ASKGDoneReason = "complete" | "cancelled" | "error" | "timeout";
+
+/** Terminates a turn stream. */
+export interface ASKGDoneEvent extends ASKGEventBase {
+  type: "done";
+  turnId: string;
+  reason: ASKGDoneReason;
+}
+
+/** Event payloads emitted over the ASKG turn SSE stream. */
+export type ASKGSseEvent =
+  | ASKGSessionEvent
+  | ASKGTextDeltaEvent
+  | ASKGToolCallEvent
+  | ASKGToolExecutedEvent
+  | ASKGToolResultAckEvent
+  | ASKGErrorEvent
+  | ASKGUsageEvent
+  | ASKGDoneEvent;
+
+/** Client result posted for one delegated tool call. */
+export interface ToolResultPayload {
+  turnId: string;
+  toolCallId: string;
+  status: ToolResultStatus;
+  result?: JsonValue;
+  rowCount?: number;
+  truncated: boolean;
+  elapsedMs: number;
+  note?: string;
+  rev?: string;
+  undoToken?: string;
+}

package/src/plugins/builtin/cloud/auth-dialog.tsx

@@ -12,6 +12,7 @@ import { useAppLanguage } from "../../../i18n/react";
 import { useDialog, type PromptContext } from "../../../ui/dialog";
 import { AuthForm, authFormTitle } from "./auth-form";
 import type { AccountMode } from "./auth-model";
+import { CloudVerificationPanel } from "./verification-panel";
 
 export function AuthDialog({
   initialMode,
@@ -20,13 +21,18 @@ export function AuthDialog({
 }: PromptContext<AuthUser | undefined> & { initialMode: AccountMode }) {
   useAppLanguage();
   const [mode, setMode] = useState<AccountMode>(initialMode);
+  const [verifyingUser, setVerifyingUser] = useState<AuthUser | null>(null);
+
+  if (verifyingUser) return <DialogFrame title={`Confirm ${verifyingUser.email}`}>
+    <CloudVerificationPanel onVerified={resolve} onContinueFree={() => resolve(verifyingUser)} />
+  </DialogFrame>;
 
   return (
     <DialogFrame title={authFormTitle(mode)}>
       <AuthForm
         initialMode={initialMode}
         onModeChange={setMode}
-        onSignedIn={resolve}
+        onSignedIn={(user) => user.emailVerified ? resolve(user) : setVerifyingUser(user)}
         onEscape={dismiss}
       />
     </DialogFrame>

package/src/plugins/builtin/cloud/device-signin-dialog.tsx

@@ -8,9 +8,10 @@ import { useEffect, useMemo, useRef, useState } from "react";
 import type { AuthUser } from "../../../api-client";
 import { t, tf } from "../../../i18n";
 import { useAppLanguage } from "../../../i18n/react";
-import { useViewport } from "../../../react/input";
+import { useShortcut, useViewport } from "../../../react/input";
 import { colors } from "../../../theme/colors";
-import { Box, Text, TextAttributes, useUiHost } from "../../../ui";
+import { Box, Text, TextAttributes, useUiHost, useRendererHost } from "../../../ui";
+import { Button } from "../../../components/ui/button";
 import { renderAsciiText } from "../../../ui/ascii-font";
 import { useDialog, useDialogKeyboard, type PromptContext } from "../../../ui/dialog";
 import { renderQrLines, renderQrSvgDataUri } from "../../../ui/qr";
@@ -55,6 +56,7 @@ export function DeviceSignInPanel({
   height: number;
 }) {
   useAppLanguage();
+  const renderer = useRendererHost();
   const desktop = useUiHost().kind === "desktop-web";
   // Cell lines still drive layout on desktop: they give the code its row/column
   // footprint, but the pixels come from the SVG below.
@@ -67,14 +69,25 @@ export function DeviceSignInPanel({
     [desktop, snapshot.verificationUri],
   );
   const status = deviceSignInStatus(snapshot);
+  useShortcut((event) => {
+    if (!isPlainKey(event, "b") || !snapshot.verificationUri) return;
+    event.preventDefault(); event.stopPropagation();
+    void renderer.openExternal(snapshot.verificationUri).catch(() => {});
+  }, { scope: "device-signin:browser", phase: "before" });
 
-  // Minimal QR layout: the code grid, one code row, and the status row.
-  const showQr = qrLines.length > 0 && height >= qrLines.length + 2;
-  const spacious = showQr && height >= qrLines.length + 8;
-  const showUrl = !!snapshot.verificationUri && (!showQr || height >= qrLines.length + 4);
+  // Reserve the browser button before fitting the QR, code, and status.
+  const contentHeight = height - (snapshot.verificationUri ? 2 : 0);
+  const showQr = qrLines.length > 0 && contentHeight >= qrLines.length + 2;
+  const spacious = showQr && contentHeight >= qrLines.length + 8;
+  const showUrl = !!snapshot.verificationUri && (!showQr || contentHeight >= qrLines.length + 4);
 
   return (
     <Box flexDirection="column" alignItems="center">
+      {snapshot.verificationUri && <Box height={2}>
+        <Button label="Continue in browser" shortcut="b" variant="primary" onPress={() => {
+          void renderer.openExternal(snapshot.verificationUri!).catch(() => {});
+        }} />
+      </Box>}
       {showQr && (qrImage
         ? (
           <Box
@@ -128,7 +141,7 @@ export function DeviceSignInPanel({
           {spacious && <Box height={1} />}
           <Box height={1}>
             <Text fg={colors.textMuted}>
-              {tf("No app? {url}", { url: snapshot.verificationUri ?? "" })}
+              {snapshot.verificationUri ?? ""}
             </Text>
           </Box>
         </>
@@ -184,7 +197,7 @@ export function DeviceSignInDialog({ resolve, dismiss }: PromptContext<AuthUser
     <Box flexDirection="column" alignItems="center">
       <Box height={1}>
         <Text fg={colors.textBright} attributes={TextAttributes.BOLD}>
-          {t("Scan with the Gloom app to sign in")}
+          {t("Sign in through your browser or scan the code")}
         </Text>
       </Box>
       <Box height={1} />

package/src/plugins/builtin/cloud/verification-panel.tsx

@@ -0,0 +1,56 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+import { apiClient, type AuthUser } from "../../../api-client";
+import { Button } from "../../../components/ui/button";
+import { useShortcut } from "../../../react/input";
+import { Box, Text } from "../../../ui";
+import { colors } from "../../../theme/colors";
+
+/** Shared continuation after email signup in the terminal and browser. */
+export function CloudVerificationPanel({ onVerified, onContinueFree }: {
+  onVerified: (user: AuthUser) => void;
+  onContinueFree: () => void;
+}) {
+  const [status, setStatus] = useState("Check your inbox and spam folder. This page continues automatically.");
+  const [sending, setSending] = useState(false);
+  const [cooldown, setCooldown] = useState(false);
+  const completed = useRef(false);
+  const callback = useRef(onVerified);
+  callback.current = onVerified;
+  const check = useCallback(async () => {
+    try {
+      const user = await apiClient.getSession();
+      if (user?.emailVerified && !completed.current) {
+        completed.current = true;
+        callback.current(user);
+      }
+    } catch { setStatus("Connection interrupted. Check again when you're online."); }
+  }, []);
+  useEffect(() => {
+    void check();
+    const timer = setInterval(() => { void check(); }, 5000);
+    return () => clearInterval(timer);
+  }, [check]);
+  useEffect(() => {
+    if (!cooldown) return;
+    const timer = setTimeout(() => setCooldown(false), 60_000);
+    return () => clearTimeout(timer);
+  }, [cooldown]);
+  useShortcut((event) => {
+    if (event.name !== "enter" && event.name !== "return") return;
+    event.preventDefault(); event.stopPropagation(); void check();
+  }, { scope: "cloud-email-verification" });
+  return <Box flexDirection="column" gap={1}>
+    <Text fg={colors.textDim} wrapText>{status}</Text>
+    <Box flexDirection="row" gap={1}>
+      <Button label="I've confirmed" variant="primary" onPress={() => { void check(); }} />
+      <Button label={cooldown ? "Email sent" : "Resend email"} disabled={sending || cooldown} onPress={() => {
+        setSending(true);
+        void apiClient.sendVerification().then(() => {
+          setCooldown(true); setStatus("Confirmation link sent. Check your inbox and spam folder.");
+        }).catch((error) => setStatus(error instanceof Error ? error.message : "Couldn't send email. Try again."))
+          .finally(() => setSending(false));
+      }} />
+    </Box>
+    <Button label="Keep using the terminal" variant="ghost" onPress={onContinueFree} />
+  </Box>;
+}

package/src/plugins/builtin/credit-conditions/client.ts

@@ -19,7 +19,7 @@ export interface CreditConditionsLoadResult {
 
 const HISTORY_LIMIT = 45;
 
-type CreditSeriesLoader = (
+export type CreditSeriesLoader = (
   seriesId: CreditSeriesId,
   options: { limit: number; sortOrder: "desc" },
 ) => Promise<CloudFredSeriesPayload>;

package/src/plugins/builtin/credit-conditions/headless.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, test } from "bun:test";
+import type { HeadlessPaneContext, HeadlessPaneLoadArgs } from "../../../types/plugin";
+import { createCreditConditionsHeadless } from "./headless";
+
+const args: HeadlessPaneLoadArgs = { rawArgument: "", argument: null, symbols: [], options: {} };
+
+describe("credit conditions headless model", () => {
+  test("returns normalized spread rows and partial errors", async () => {
+    const headless = createCreditConditionsHeadless({
+      load: async () => ({
+        rows: [{
+          seriesId: "BAMLC0A0CM",
+          label: "US IG",
+          title: "US Corporate Option-Adjusted Spread",
+          units: "Percent",
+          frequency: "Daily",
+          oasBp: 82.4,
+          dailyChangeBp: 1.2,
+          date: "2026-09-03",
+          stale: false,
+        }],
+        stale: false,
+        errors: ["one series unavailable"],
+      }),
+    });
+    const result = await headless.load(args, {} as HeadlessPaneContext);
+
+    expect(result.rows).toEqual([expect.objectContaining({ label: "US IG", oasBp: 82.4 })]);
+    expect(result.errors).toEqual(["one series unavailable"]);
+  });
+});