pi-provider-cursor-ask 0.1.0

package/src/stream/types.ts

@@ -0,0 +1,330 @@
+/**
+ * Shared type surface for the Cursor stream runtime.
+ *
+ * These types are pure structure with no runtime behaviour, so every stream
+ * module can depend on this file without creating import cycles. Anything that
+ * used to be declared twice (native-core + recovery) now lives here once.
+ */
+import type { Api, AssistantMessage, Model, SimpleStreamOptions } from "@earendil-works/pi-ai";
+import type { BridgeHandle } from "../client/bridge.js";
+import type { CursorModelParameter } from "../client/cursor-wire.js";
+import type { McpToolDefinition } from "../proto/agent_pb.js";
+import type { CursorNativeModelRouting } from "./model-routing.js";
+
+// ── OpenAI-shaped request surface ──
+//
+// Pi hands the provider an OpenAI-style context. These types describe that
+// intermediate shape before it is translated into Cursor's protobuf request.
+
+export interface OpenAIToolCall {
+  id: string;
+  type: "function";
+  function: { name: string; arguments: string };
+}
+
+export interface ContentPart {
+  type: string;
+  text?: string;
+  data?: string;
+  mimeType?: string;
+  image_url?: { url?: string };
+}
+
+export interface OpenAIMessage {
+  role: "system" | "user" | "assistant" | "tool";
+  content: string | null | ContentPart[];
+  tool_call_id?: string;
+  tool_calls?: OpenAIToolCall[];
+  /** Propagated from Pi toolResult.isError into Cursor MCP results. */
+  is_error?: boolean;
+  /**
+   * Set on a historical assistant message whose turn did not run to completion
+   * (aborted, errored, truncated). Replayed into the turn as a trailing
+   * assistant step — see `interruptedAssistantNotice()` in ./pi-adapter.ts.
+   */
+  interrupted_notice?: string;
+  /** Replayed thinking from a prior assistant turn; see ./pi-adapter.ts. */
+  thinking?: string;
+}
+
+export interface OpenAIToolDef {
+  type: "function";
+  function: {
+    name: string;
+    description?: string;
+    parameters?: Record<string, unknown>;
+  };
+}
+
+export interface CursorToolResultImagePayload {
+  toolCallId: string;
+  images: Array<{ data: string; mimeType: string }>;
+}
+
+export interface ChatCompletionRequest {
+  model: string;
+  messages: OpenAIMessage[];
+  stream?: boolean;
+  temperature?: number;
+  max_tokens?: number;
+  max_completion_tokens?: number;
+  tools?: OpenAIToolDef[];
+  tool_choice?: unknown;
+  reasoning_effort?: string;
+  user?: string;
+  pi_session_id?: string;
+  cursor_model_id?: string;
+  cursor_model_parameters?: CursorModelParameter[];
+  cursor_tool_result_images?: CursorToolResultImagePayload[];
+  cursor_requires_max_mode?: boolean;
+  cursor_model_max_mode?: boolean;
+}
+
+// ── Parsed conversation history ──
+
+export interface ParsedImageContent {
+  data: Uint8Array;
+  mimeType: string;
+}
+
+export interface ParsedToolResult {
+  content: string;
+  isError: boolean;
+  images?: ParsedImageContent[];
+}
+
+export interface ParsedAssistantTextStep {
+  kind: "assistantText";
+  text: string;
+}
+
+export interface ParsedThinkingStep {
+  kind: "thinking";
+  text: string;
+}
+
+export interface ParsedToolCallStep {
+  kind: "toolCall";
+  toolCallId: string;
+  toolName: string;
+  arguments: Record<string, unknown>;
+  result?: ParsedToolResult;
+}
+
+export type ParsedTurnStep = ParsedAssistantTextStep | ParsedThinkingStep | ParsedToolCallStep;
+
+export interface ParsedTurn {
+  userText: string;
+  steps: ParsedTurnStep[];
+  userImages?: ParsedImageContent[];
+}
+
+export interface ToolResultInfo {
+  toolCallId: string;
+  content: string;
+  images?: ParsedImageContent[];
+  isError?: boolean;
+}
+
+export interface ParsedMessages {
+  systemPrompt: string;
+  userText: string;
+  userImages: ParsedImageContent[];
+  turns: ParsedTurn[];
+  toolResults: ToolResultInfo[];
+  inFlightTurn?: ParsedTurn;
+}
+
+// ── Wire request payloads ──
+
+export interface CursorRequestPayload {
+  contextCheckpoint?: Uint8Array | null;
+  requestBytes: Uint8Array;
+  requestBody: Uint8Array;
+  blobStore: Map<string, Uint8Array>;
+  mcpTools: McpToolDefinition[];
+}
+
+export interface CursorRequestDebugSummary {
+  systemPrompt: string;
+  selectedImages: Array<{ byteLength: number; mimeType: string }>;
+}
+
+// ── Session / bridge state ──
+
+export interface PendingExec {
+  execId: string;
+  execMsgId: number;
+  toolCallId: string;
+  toolName: string;
+  decodedArgs: string;
+}
+
+/**
+ * Latest upstream checkpoint for a bridge, held by reference so it survives a tool pause.
+ *
+ * Each resume re-enters the stream writer with fresh locals, but the bridge — and the frames
+ * still arriving on it — outlive that boundary. A checkpoint delivered during a pause would be
+ * stranded in the previous round's closure without a shared cell.
+ */
+export interface CheckpointRef {
+  current: Uint8Array | null;
+  /** Last positive observation survives placeholder checkpoints and local tool pauses. */
+  contextTokens?: number;
+  /** One upstream Run's receipt survives Pi's local tool-response boundaries. */
+  usage?: CursorRunUsage;
+}
+
+/**
+ * Pi's view of the turn in flight, as opposed to the wire history sent upstream.
+ * Behaviour lives in ./client-transcript.ts.
+ */
+export type ClientTranscript =
+  | { kind: "live"; completedTurns: ParsedTurn[] }
+  | { kind: "recovered"; completedTurns: ParsedTurn[]; inFlightTurn: ParsedTurn };
+
+export interface ActiveBridge {
+  bridge: BridgeHandle;
+  heartbeatTimer: ReturnType<typeof setInterval>;
+  toolTimeoutTimer?: ReturnType<typeof setTimeout>;
+  blobStore: Map<string, Uint8Array>;
+  mcpTools: McpToolDefinition[];
+  pendingExecs: PendingExec[];
+  currentTurn: ParsedTurn;
+  checkpointRef: CheckpointRef;
+  state: StreamState;
+  /** Fingerprint of the completed turns this bridge was parked on; guards against key collisions. */
+  historyFingerprint: string;
+  /** Pi's completed-turn history when the wire current turn is synthetic after recovery. */
+  clientTranscript?: ClientTranscript;
+}
+
+export interface StoredConversation {
+  conversationId: string;
+  checkpoint: Uint8Array | null;
+  checkpointSource?: "upstream" | "absent";
+  checkpointTurnCount?: number;
+  checkpointHistoryFingerprint?: string;
+  midPausePendingToolCalls?: Array<{ toolCallId: string; toolName: string }>;
+  midPauseTurnCount?: number;
+  midPauseHistoryFingerprint?: string;
+  midPauseRecordedAtMs?: number;
+  /** In-memory receipts received after their Pi writer closed; claim on the next same-model reply. */
+  unreportedUsage?: CursorRunUsage[];
+  /** Hash of the system prompt last published to Cursor for this conversation. */
+  systemPromptHash?: string;
+  sessionScoped: boolean;
+  sessionId?: string;
+  blobStore: Map<string, Uint8Array>;
+  lastAccessMs: number;
+}
+
+/** Per-turn raw billed fields from `turnEnded`; `input` includes cache read and write. */
+export interface CursorBilledUsage {
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+}
+
+export interface CursorRunUsage {
+  modelId?: string;
+  rates?: Model<Api>["cost"];
+  billedUsage?: CursorBilledUsage;
+  missingFields?: Array<keyof CursorBilledUsage>;
+  reported?: boolean;
+  boundaryLogged?: boolean;
+}
+
+export interface StreamState {
+  toolCallIndex: number;
+  pendingExecs: PendingExec[];
+  outputTokens: number;
+  /** Latest checkpoint `usedTokens`: a context snapshot, not turnEnded's cumulative bill. */
+  totalTokens: number;
+  /** Set once Cursor reported `turnEnded`; a connection close after it is a completed turn. */
+  turnEnded: boolean;
+  billedUsage?: CursorBilledUsage;
+  runUsage?: CursorRunUsage;
+}
+
+// ── Native streamSimple runtime ──
+
+export interface CursorNativeStreamConfig {
+  /**
+   * Declared as a property rather than a method: the runtime passes this
+   * reference on to the idle-retry path, so it must not depend on `this`.
+   */
+  getAccessToken: (options?: { forceRefresh?: boolean }) => Promise<string>;
+  getNoReasoningEffortByModelId?(): Map<string, string>;
+  getRawModelRoutingByModelId?(): Map<string, Record<string, CursorNativeModelRouting>>;
+}
+
+export type CursorNativeStreamOptions = SimpleStreamOptions & {
+  toolChoice?: unknown;
+};
+
+export type NativeBlockKind = "text" | "thinking";
+
+export interface NativeStreamWriter {
+  output: AssistantMessage;
+  closed: boolean;
+  start(): void;
+  contextSnapshot?(tokens: number, checkpoint?: Uint8Array): void;
+  contextMode?(
+    mode: "history" | "checkpoint" | "live",
+    tokens?: number,
+    checkpoint?: Uint8Array,
+  ): void;
+  carryUsage?(usage: CursorRunUsage): void;
+  text(delta: string): void;
+  thinking(delta: string): void;
+  toolCall(exec: PendingExec): void;
+  done(reason: "stop" | "length" | "toolUse", state?: StreamState): void;
+  error(message: string, reason: "error" | "aborted", state?: StreamState): void;
+}
+
+export interface IdleRestartContext {
+  /** True when text/thinking was already pushed to the Pi writer. */
+  emittedUserVisibleContent: boolean;
+  latestCheckpoint: Uint8Array | null;
+  blobStore: Map<string, Uint8Array>;
+  completedTurns: ParsedTurn[];
+  currentTurn: ParsedTurn;
+}
+
+export interface StreamIdleRetryController {
+  currentAttempt: number;
+  maxRetries: number;
+  recoverBeforeRetry?: boolean;
+  restart(nextAttempt: number, context: IdleRestartContext): boolean;
+}
+
+export interface NativeStreamAttemptInput {
+  contextCheckpoint?: Uint8Array | null;
+  accessToken: string;
+  requestBytes: Uint8Array;
+  blobStore: Map<string, Uint8Array>;
+  mcpTools: McpToolDefinition[];
+  model: Model<Api>;
+  modelId: string;
+  bridgeKey: string;
+  convKey: string;
+  completedTurns: ParsedTurn[];
+  currentTurn: ParsedTurn;
+  /** Pi's transcript when `completedTurns`/`currentTurn` are a recovered wire view. */
+  clientTranscript?: ClientTranscript;
+  writer: NativeStreamWriter;
+  options?: CursorNativeStreamOptions;
+  requestId?: string;
+  maxIdleRetries?: number;
+  streamIdleTimeoutMs?: number;
+  getAccessToken?: (options?: { forceRefresh?: boolean }) => Promise<string>;
+  /** When true, idle timeout tries recovery/rebuild before a blind restart. */
+  recoverBeforeRetry?: boolean;
+  /** Required for checkpoint-based continuation after transport loss. */
+  systemPrompt?: string;
+  conversationId?: string;
+  maxMode?: boolean;
+  cursorModelParameters?: CursorModelParameter[];
+}

package/src/types/enums.ts

@@ -0,0 +1,103 @@
+/**
+ * Domain enums for the Cursor Ask provider.
+ *
+ * Strongly-typed TypeScript enums for provider constants, credentials,
+ * reasoning levels, transport states, and drift signals.
+ */
+
+import { CURSOR_ASK_IDENTITY } from "../identity.js";
+
+/** Credential origin in the resolution cascade. */
+export enum CredentialSource {
+  Env = "env",
+  CliKeychain = "cli_keychain",
+  CliKeychainRefresh = "cli_keychain_refresh",
+  IdeVscdb = "ide_vscdb",
+  IdeVscdbRefresh = "ide_vscdb_refresh",
+  PiOAuth = "pi_oauth",
+  PiOAuthRefresh = "pi_oauth_refresh",
+  None = "none",
+}
+
+export type CredentialSourceType = `${CredentialSource}`;
+
+/** Policy for system credential harvesting (Keychain, state.vscdb, WSL). */
+export enum SystemCredentialPolicy {
+  Allow = "allow",
+  Deny = "deny",
+}
+
+export type SystemCredentialPolicyType = `${SystemCredentialPolicy}`;
+
+/** Reasoning effort levels recognized by Pi AI. */
+export enum ThinkingLevel {
+  Off = "off",
+  Minimal = "minimal",
+  Low = "low",
+  Medium = "medium",
+  High = "high",
+  XHigh = "xhigh",
+  Max = "max",
+}
+
+export type PiThinkingLevel = `${ThinkingLevel}`;
+
+/** Stream output block types for native streaming. */
+export enum StreamBlockKind {
+  Text = "text",
+  Thinking = "thinking",
+}
+
+export type NativeBlockKind = `${StreamBlockKind}`;
+
+/** Recovery decisions when encountering bridge death or tool continuation. */
+export enum RecoveryKind {
+  ActiveBridge = "active_bridge",
+  RebuildFullHistory = "rebuild_full_history",
+  Skip = "skip",
+  Error = "error",
+}
+
+export type RecoveryDecisionKind = `${RecoveryKind}`;
+
+/** Wire protocol drift signal categories. */
+export enum DriftKind {
+  ServerMessage = "server_message",
+  InteractionUpdate = "interaction_update",
+  KvMessage = "kv_message",
+  InteractionQuery = "interaction_query",
+  ExecMessage = "exec_message",
+  UnknownFields = "unknown_fields",
+}
+
+export type DriftKindType = `${DriftKind}`;
+
+/** Classified bridge exit and transport failure types. */
+export enum TransportFailureKind {
+  ConnectTimeout = "connect_timeout",
+  SocketTimeout = "socket_timeout",
+  ConnectionReset = "connection_reset",
+  Goaway = "goaway",
+  BridgeCrash = "bridge_crash",
+  UpstreamSilence = "upstream_silence",
+  Authentication = "authentication",
+  RateLimit = "rate_limit",
+  ProtocolDrift = "protocol_drift",
+  InvalidRequest = "invalid_request",
+  Unknown = "unknown",
+}
+
+export type TransportFailureKindType = `${TransportFailureKind}`;
+
+/** Connect RPC framing flags. */
+export enum ConnectFlag {
+  None = 0,
+  EndStream = 0b00000010,
+}
+
+/** Provider identifier and API source constants. */
+export const ProviderConstant = {
+  ProviderId: CURSOR_ASK_IDENTITY.providerId,
+  NativeApi: CURSOR_ASK_IDENTITY.nativeApi,
+  Source: CURSOR_ASK_IDENTITY.apiSource,
+} as const;

package/src/types/index.ts

@@ -0,0 +1,4 @@
+/**
+ * Central type definitions and domain enums.
+ */
+export * from "./enums.js";

package/src/usage.ts

@@ -0,0 +1,262 @@
+import { cursorEnv, isRecord } from "./utils/util.js";
+
+export interface CursorUsageSummary {
+  billingCycleStart?: string;
+  billingCycleEnd?: string;
+  membershipType?: string;
+  limitType?: string;
+  isUnlimited?: boolean;
+  individualUsage?: {
+    plan?: UsageBucket;
+    onDemand?: UsageBucket;
+  };
+  teamUsage?: {
+    onDemand?: UsageBucket;
+  };
+}
+
+function toIsoStringOrUndefined(value: unknown): string | undefined {
+  if (typeof value !== "string") return undefined;
+  const ms = Number(value);
+  return Number.isFinite(ms) ? new Date(ms).toISOString() : undefined;
+}
+
+interface UsageBucket {
+  enabled?: boolean;
+  used?: number | null;
+  limit?: number | null;
+  remaining?: number | null;
+  breakdown?: {
+    included?: number | null;
+    bonus?: number | null;
+    total?: number | null;
+  };
+  totalPercentUsed?: number | null;
+  autoPercentUsed?: number | null;
+  apiPercentUsed?: number | null;
+}
+
+const USAGE_SUMMARY_URL = "https://cursor.com/api/usage-summary";
+
+function asNumberOrNull(value: unknown): number | null | undefined {
+  return typeof value === "number" && Number.isFinite(value)
+    ? value
+    : value === null
+      ? null
+      : undefined;
+}
+
+function parseBucket(value: unknown): UsageBucket | undefined {
+  if (!isRecord(value)) return undefined;
+  const breakdown = isRecord(value.breakdown)
+    ? {
+        included: asNumberOrNull(value.breakdown.included),
+        bonus: asNumberOrNull(value.breakdown.bonus),
+        total: asNumberOrNull(value.breakdown.total),
+      }
+    : undefined;
+  return {
+    enabled: typeof value.enabled === "boolean" ? value.enabled : undefined,
+    used: asNumberOrNull(value.used),
+    limit: asNumberOrNull(value.limit),
+    remaining: asNumberOrNull(value.remaining),
+    breakdown,
+    totalPercentUsed: asNumberOrNull(value.totalPercentUsed),
+    autoPercentUsed: asNumberOrNull(value.autoPercentUsed),
+    apiPercentUsed: asNumberOrNull(value.apiPercentUsed),
+  };
+}
+
+export function parseCursorUsageSummary(value: unknown): CursorUsageSummary {
+  if (!isRecord(value)) throw new Error("Cursor usage endpoint returned an invalid response");
+  return {
+    billingCycleStart:
+      typeof value.billingCycleStart === "string" ? value.billingCycleStart : undefined,
+    billingCycleEnd: typeof value.billingCycleEnd === "string" ? value.billingCycleEnd : undefined,
+    membershipType: typeof value.membershipType === "string" ? value.membershipType : undefined,
+    limitType: typeof value.limitType === "string" ? value.limitType : undefined,
+    isUnlimited: typeof value.isUnlimited === "boolean" ? value.isUnlimited : undefined,
+    individualUsage: isRecord(value.individualUsage)
+      ? {
+          plan: parseBucket(value.individualUsage.plan),
+          onDemand: parseBucket(value.individualUsage.onDemand),
+        }
+      : undefined,
+    teamUsage: isRecord(value.teamUsage)
+      ? { onDemand: parseBucket(value.teamUsage.onDemand) }
+      : undefined,
+  };
+}
+
+export function parseConnectPeriodUsage(value: unknown): CursorUsageSummary {
+  if (!isRecord(value))
+    throw new Error("Cursor period usage endpoint returned an invalid response");
+
+  const billingCycleStart = toIsoStringOrUndefined(value.billingCycleStart);
+  const billingCycleEnd = toIsoStringOrUndefined(value.billingCycleEnd);
+
+  const planUsage = isRecord(value.planUsage) ? value.planUsage : undefined;
+  const spendLimitUsage = isRecord(value.spendLimitUsage) ? value.spendLimitUsage : undefined;
+
+  const limitType =
+    typeof spendLimitUsage?.limitType === "string" ? spendLimitUsage.limitType : undefined;
+  const totalPercentUsed = asNumberOrNull(planUsage?.totalPercentUsed);
+  const autoPercentUsed = asNumberOrNull(planUsage?.autoPercentUsed);
+  const apiPercentUsed = asNumberOrNull(planUsage?.apiPercentUsed);
+  const includedSpend = asNumberOrNull(planUsage?.includedSpend);
+  const limit = asNumberOrNull(planUsage?.limit);
+
+  // Infer membership type from limitType or displayMessage or fallback to Pro
+  let membershipType = "Pro";
+  if (limitType === "user") membershipType = "Pro";
+  else if (limitType === "team") membershipType = "Team";
+  else if (typeof value.membershipType === "string") membershipType = value.membershipType;
+
+  return {
+    billingCycleStart,
+    billingCycleEnd,
+    membershipType,
+    limitType,
+    individualUsage: {
+      plan: {
+        enabled: true,
+        used: includedSpend,
+        limit,
+        remaining:
+          limit !== null &&
+          limit !== undefined &&
+          includedSpend !== null &&
+          includedSpend !== undefined
+            ? Math.max(0, limit - includedSpend)
+            : undefined,
+        totalPercentUsed,
+        autoPercentUsed,
+        apiPercentUsed,
+      },
+    },
+  };
+}
+
+export async function getCursorUsageSummary(
+  getAccessToken?: () => Promise<string>,
+  sessionToken = cursorEnv("USAGE_SESSION_TOKEN"),
+): Promise<CursorUsageSummary> {
+  if (getAccessToken) {
+    try {
+      const accessToken = await getAccessToken();
+      if (accessToken) {
+        const response = await fetch(
+          "https://api2.cursor.sh/aiserver.v1.DashboardService/GetCurrentPeriodUsage",
+          {
+            method: "POST",
+            headers: {
+              Authorization: `Bearer ${accessToken}`,
+              "Content-Type": "application/json",
+            },
+            body: "{}",
+            signal: AbortSignal.timeout(10_000),
+          },
+        );
+        if (response.ok) {
+          return parseConnectPeriodUsage(await response.json());
+        }
+      }
+    } catch {
+      // Connect usage call failed; fall back to session token
+    }
+  }
+
+  if (sessionToken) {
+    const response = await fetch(USAGE_SUMMARY_URL, {
+      headers: { Cookie: `WorkosCursorSessionToken=${sessionToken}` },
+      signal: AbortSignal.timeout(10_000),
+    });
+    if (response.ok) {
+      return parseCursorUsageSummary(await response.json());
+    }
+  }
+
+  throw new Error(
+    "Not logged in to Cursor. Please log in with Cursor CLI ('cursor' / 'agent'), run /login cursor, or set CURSOR_USAGE_SESSION_TOKEN to check usage.",
+  );
+}
+
+function formatDollars(cents: number | null | undefined): string {
+  return cents === null || cents === undefined ? "unlimited" : `$${(cents / 100).toFixed(2)}`;
+}
+
+function renderProgressBar(pct: number, width = 20): string {
+  const clamped = Math.max(0, Math.min(100, pct));
+  const filled = Math.round((clamped / 100) * width);
+  const empty = width - filled;
+  return "█".repeat(filled) + "░".repeat(empty);
+}
+
+function formatResetDate(dateStr: string | undefined): string {
+  if (!dateStr) return "";
+  const d = new Date(dateStr);
+  if (Number.isNaN(d.valueOf())) return "";
+  const day = d.getDate();
+  const month = d.toLocaleString("en-US", { month: "short" });
+  return `Resets ${day} ${month}`;
+}
+
+function formatPctLabel(pct: number | null | undefined): string {
+  if (pct === null || pct === undefined) return "0% used";
+  return `${Math.round(pct)}% used`;
+}
+
+function capitalize(str: string): string {
+  if (!str) return "Pro";
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+export function formatCursorUsage(summary: CursorUsageSummary): string {
+  const plan = summary.individualUsage?.plan;
+  const onDemand = summary.individualUsage?.onDemand;
+  const resetStr = formatResetDate(summary.billingCycleEnd);
+
+  const planName = capitalize(summary.membershipType || "Pro");
+  const headerLeft = `Usage • ${planName}`;
+  const totalWidth = 60;
+  const headerRight = resetStr
+    ? resetStr.padStart(Math.max(1, totalWidth - headerLeft.length))
+    : "";
+
+  const lines = [
+    `${headerLeft}${headerRight}`,
+    "Monthly plan and on-demand usage",
+    "",
+    "Category        Current          Usage",
+  ];
+
+  const totalPct = plan?.totalPercentUsed ?? 0;
+  lines.push(
+    `Included        ${formatPctLabel(totalPct).padEnd(16)}${renderProgressBar(totalPct)}`,
+  );
+
+  if (plan?.autoPercentUsed !== undefined && plan.autoPercentUsed !== null) {
+    lines.push(
+      `  Auto          ${formatPctLabel(plan.autoPercentUsed).padEnd(16)}${renderProgressBar(plan.autoPercentUsed)}`,
+    );
+  }
+
+  if (plan?.apiPercentUsed !== undefined && plan.apiPercentUsed !== null) {
+    lines.push(
+      `  API           ${formatPctLabel(plan.apiPercentUsed).padEnd(16)}${renderProgressBar(plan.apiPercentUsed)}`,
+    );
+  }
+
+  const isOnDemandActive = Boolean(onDemand?.enabled && (onDemand.used ?? 0) > 0);
+  lines.push(`On-Demand       ${isOnDemandActive ? formatDollars(onDemand?.used) : "Disabled"}`);
+  lines.push("-".repeat(totalWidth));
+  lines.push(
+    isOnDemandActive
+      ? `On-demand spend: ${formatDollars(onDemand?.used)}`
+      : "On-demand usage is off",
+  );
+  lines.push("");
+  lines.push("View in dashboard: cursor.com/dashboard?tab=usage");
+
+  return lines.join("\n");
+}