@herbertgao/pi-extensions 2026.9.9 → 2026.9.11

package/node_modules/pi-multi-account/cursor/index.ts

@@ -0,0 +1,572 @@
+/**
+ * Cursor Provider Extension for pi
+ *
+ * Provides access to Cursor models (Claude, GPT, Gemini, etc.) via:
+ * 1. Browser-based PKCE OAuth login to Cursor
+ * 2. Local proxy translating OpenAI format → Cursor gRPC protocol
+ *
+ * Usage:
+ *   /login cursor    — authenticate via browser
+ *   /model           — select any Cursor model
+ *
+ * Based on https://github.com/ephraimduncan/opencode-cursor by Ephraim Duncan.
+ */
+
+import rawFallbackModels from "./cursor-models-raw.json" with { type: "json" };
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { cursorPayloadStream } from "../provider-payload-stream.ts";
+import { cursorModelDisplayName } from "../cursor-model-name.ts";
+import type { OAuthCredentials, OAuthLoginCallbacks } from "@earendil-works/pi-ai";
+import { appendFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join as pathJoin } from "node:path";
+import {
+  generateCursorAuthParams,
+  getTokenExpiry,
+  pollCursorAuth,
+  refreshCursorToken,
+} from "./auth.ts";
+import { cleanupSessionState, getCursorModels, resetConversationForSession, startProxy, type CursorModel } from "./proxy.ts";
+import { registerSessionLifecycleHooks } from "./session-lifecycle.ts";
+
+// ── Cost estimation ──
+
+interface ModelCost {
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+}
+
+let extensionDebugLogFilePath: string | undefined;
+
+function isExtensionDebugEnabled(): boolean {
+  const raw = process.env.PI_CURSOR_PROVIDER_DEBUG?.trim().toLowerCase();
+  return !!raw && raw !== "0" && raw !== "false" && raw !== "off";
+}
+
+function getExtensionDebugLogFilePath(): string {
+  if (extensionDebugLogFilePath) return extensionDebugLogFilePath;
+  const configured = process.env.PI_CURSOR_PROVIDER_EXTENSION_DEBUG_FILE?.trim();
+  if (configured) {
+    extensionDebugLogFilePath = configured;
+    return extensionDebugLogFilePath;
+  }
+  const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+  extensionDebugLogFilePath = pathJoin(tmpdir(), `pi-cursor-provider-extension-debug-${stamp}-${process.pid}.log`);
+  return extensionDebugLogFilePath;
+}
+
+function truncateDebugValue(value: string, max = 240): string {
+  return value.length > max ? `${value.slice(0, max)}…<truncated ${value.length - max} chars>` : value;
+}
+
+function summarizeContent(content: unknown): unknown {
+  if (typeof content === "string") return truncateDebugValue(content);
+  if (!Array.isArray(content)) return content;
+  return content.map((block) => {
+    if (!block || typeof block !== "object") return block;
+    const typed = block as Record<string, unknown>;
+    switch (typed.type) {
+      case "text":
+        return { type: "text", text: truncateDebugValue(String(typed.text ?? "")) };
+      case "thinking":
+        return { type: "thinking", thinking: truncateDebugValue(String(typed.thinking ?? "")) };
+      case "toolCall":
+        return {
+          type: "toolCall",
+          id: typed.id,
+          name: typed.name,
+          arguments: typed.arguments,
+        };
+      case "image":
+        return { type: "image", mimeType: typed.mimeType, data: `<redacted base64 ${String(typed.data ?? "").length} chars>` };
+      default:
+        return typed;
+    }
+  });
+}
+
+function summarizeMessage(message: unknown): unknown {
+  if (!message || typeof message !== "object") return message;
+  const typed = message as Record<string, unknown>;
+  return {
+    role: typed.role,
+    stopReason: typed.stopReason,
+    toolCallId: typed.toolCallId,
+    toolName: typed.toolName,
+    isError: typed.isError,
+    errorMessage: typed.errorMessage,
+    content: summarizeContent(typed.content),
+  };
+}
+
+function summarizeBranchTail(ctx: { sessionManager?: { getBranch?: () => unknown[]; getLeafId?: () => string; getSessionId?: () => string } }, limit = 6): unknown {
+  try {
+    const branch = ctx.sessionManager?.getBranch?.();
+    if (!Array.isArray(branch)) return undefined;
+    return {
+      sessionId: ctx.sessionManager?.getSessionId?.(),
+      leafId: ctx.sessionManager?.getLeafId?.(),
+      size: branch.length,
+      tail: branch.slice(-limit).map((entry) => {
+        if (!entry || typeof entry !== "object") return entry;
+        const typed = entry as Record<string, unknown>;
+        return {
+          type: typed.type,
+          id: typed.id,
+          parentId: typed.parentId,
+          customType: typed.customType,
+          message: summarizeMessage(typed.message),
+        };
+      }),
+    };
+  } catch (error) {
+    return { error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+function summarizeProviderPayload(payload: unknown): unknown {
+  if (!payload || typeof payload !== "object") return payload;
+  const typed = payload as Record<string, unknown>;
+  const messages = Array.isArray(typed.messages) ? typed.messages.map((message) => summarizeMessage(message)).slice(-8) : undefined;
+  return {
+    model: typed.model,
+    stream: typed.stream,
+    pi_session_id: typed.pi_session_id,
+    messageCount: Array.isArray(typed.messages) ? typed.messages.length : undefined,
+    messages,
+    toolCount: Array.isArray(typed.tools) ? typed.tools.length : undefined,
+  };
+}
+
+function debugExtensionLog(event: string, data?: Record<string, unknown>): void {
+  if (!isExtensionDebugEnabled()) return;
+  const payload = JSON.stringify({
+    ts: new Date().toISOString(),
+    pid: process.pid,
+    scope: "extension",
+    event,
+    ...data,
+  });
+  appendFileSync(getExtensionDebugLogFilePath(), `${payload}\n`, "utf8");
+}
+
+const MODEL_COST_TABLE: Record<string, ModelCost> = {
+  "claude-4-sonnet":         { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+  "claude-4.5-haiku":        { input: 1, output: 5, cacheRead: 0.1, cacheWrite: 1.25 },
+  "claude-4.5-opus":         { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 },
+  "claude-4.5-sonnet":       { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+  "claude-4.6-opus":         { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 },
+  "claude-4.6-sonnet":       { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+  "composer-1":              { input: 1.25, output: 10, cacheRead: 0.125, cacheWrite: 0 },
+  "composer-1.5":            { input: 3.5, output: 17.5, cacheRead: 0.35, cacheWrite: 0 },
+  "composer-2":              { input: 0.5, output: 2.5, cacheRead: 0.2, cacheWrite: 0 },
+  "gemini-2.5-flash":        { input: 0.3, output: 2.5, cacheRead: 0.03, cacheWrite: 0 },
+  "gemini-3-flash":          { input: 0.5, output: 3, cacheRead: 0.05, cacheWrite: 0 },
+  "gemini-3-pro":            { input: 2, output: 12, cacheRead: 0.2, cacheWrite: 0 },
+  "gemini-3.1-pro":          { input: 2, output: 12, cacheRead: 0.2, cacheWrite: 0 },
+  "gpt-5":                   { input: 1.25, output: 10, cacheRead: 0.125, cacheWrite: 0 },
+  "gpt-5-mini":              { input: 0.25, output: 2, cacheRead: 0.025, cacheWrite: 0 },
+  "gpt-5.2":                 { input: 1.75, output: 14, cacheRead: 0.175, cacheWrite: 0 },
+  "gpt-5.2-codex":           { input: 1.75, output: 14, cacheRead: 0.175, cacheWrite: 0 },
+  "gpt-5.3-codex":           { input: 1.75, output: 14, cacheRead: 0.175, cacheWrite: 0 },
+  "gpt-5.4":                 { input: 2.5, output: 15, cacheRead: 0.25, cacheWrite: 0 },
+  "gpt-5.4-mini":            { input: 0.75, output: 4.5, cacheRead: 0.075, cacheWrite: 0 },
+  "grok-4.20":               { input: 2, output: 6, cacheRead: 0.2, cacheWrite: 0 },
+  "kimi-k2.5":               { input: 0.6, output: 3, cacheRead: 0.1, cacheWrite: 0 },
+};
+
+const MODEL_COST_PATTERNS: Array<{ match: (id: string) => boolean; cost: ModelCost }> = [
+  { match: (id) => /claude.*opus.*fast/i.test(id),   cost: { input: 30, output: 150, cacheRead: 3, cacheWrite: 37.5 } },
+  { match: (id) => /claude.*opus/i.test(id),         cost: MODEL_COST_TABLE["claude-4.6-opus"]! },
+  { match: (id) => /claude.*haiku/i.test(id),        cost: MODEL_COST_TABLE["claude-4.5-haiku"]! },
+  { match: (id) => /claude.*sonnet/i.test(id),       cost: MODEL_COST_TABLE["claude-4.6-sonnet"]! },
+  { match: (id) => /composer/i.test(id),             cost: MODEL_COST_TABLE["composer-1"]! },
+  { match: (id) => /gpt-5\.4.*mini/i.test(id),      cost: MODEL_COST_TABLE["gpt-5.4-mini"]! },
+  { match: (id) => /gpt-5\.4/i.test(id),            cost: MODEL_COST_TABLE["gpt-5.4"]! },
+  { match: (id) => /gpt-5\.3/i.test(id),            cost: MODEL_COST_TABLE["gpt-5.3-codex"]! },
+  { match: (id) => /gpt-5\.2/i.test(id),            cost: MODEL_COST_TABLE["gpt-5.2"]! },
+  { match: (id) => /gpt-5.*mini/i.test(id),          cost: MODEL_COST_TABLE["gpt-5-mini"]! },
+  { match: (id) => /gpt-5/i.test(id),                cost: MODEL_COST_TABLE["gpt-5"]! },
+  { match: (id) => /gemini.*3\.1/i.test(id),        cost: MODEL_COST_TABLE["gemini-3.1-pro"]! },
+  { match: (id) => /gemini.*flash/i.test(id),        cost: MODEL_COST_TABLE["gemini-2.5-flash"]! },
+  { match: (id) => /gemini/i.test(id),               cost: MODEL_COST_TABLE["gemini-3-pro"]! },
+  { match: (id) => /grok/i.test(id),                 cost: MODEL_COST_TABLE["grok-4.20"]! },
+  { match: (id) => /kimi/i.test(id),                 cost: MODEL_COST_TABLE["kimi-k2.5"]! },
+];
+
+const DEFAULT_COST: ModelCost = { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 0 };
+
+function estimateModelCost(modelId: string): ModelCost {
+  const normalized = modelId.toLowerCase();
+  const exact = MODEL_COST_TABLE[normalized];
+  if (exact) return exact;
+  const stripped = normalized.replace(/-(high|medium|low|preview|thinking|spark-preview|fast)$/g, "");
+  const strippedMatch = MODEL_COST_TABLE[stripped];
+  if (strippedMatch) return strippedMatch;
+  return MODEL_COST_PATTERNS.find((p) => p.match(normalized))?.cost ?? DEFAULT_COST;
+}
+
+
+// ── Effort-level dedup ──
+
+const EFFORT_LEVELS = new Set(["low", "medium", "high", "xhigh", "max", "none"]);
+
+interface ParsedModelId {
+  base: string;       // model ID with effort stripped
+  effort: string;     // effort level, or "" if no effort suffix
+  fast: boolean;      // has -fast suffix
+  thinking: boolean;  // has -thinking suffix
+}
+
+export function parseModelId(id: string): ParsedModelId {
+  let remaining = id;
+  let fast = false;
+  let thinking = false;
+
+  if (remaining.endsWith("-fast")) {
+    fast = true;
+    remaining = remaining.slice(0, -5);
+  }
+  if (remaining.endsWith("-thinking")) {
+    thinking = true;
+    remaining = remaining.slice(0, -9);
+  }
+
+  const lastDash = remaining.lastIndexOf("-");
+  if (lastDash >= 0) {
+    const suffix = remaining.slice(lastDash + 1);
+    if (EFFORT_LEVELS.has(suffix)) {
+      return { base: remaining.slice(0, lastDash), effort: suffix, fast, thinking };
+    }
+  }
+
+  return { base: remaining, effort: "", fast, thinking };
+}
+
+interface ProcessedModel extends CursorModel {
+  supportsEffort: boolean;
+  effortMap?: Record<string, string>;
+}
+
+export function supportsReasoningModelId(id: string): boolean {
+  const { base, effort, thinking } = parseModelId(id);
+  if (effort || thinking) return true;
+  if (base === "default") return true;
+  // Cursor namespaces some families with a "cursor-" prefix (cursor-grok-4.6-high, …).
+  // Matching the raw base against the family list misclassified every such model as
+  // non-reasoning — and Pi clamps thinking to "off" for non-reasoning models, which also
+  // meant no effort ever reached the proxy.
+  const family = base.replace(/^cursor-/i, "");
+  return /^(claude|composer|gemini|gpt|grok|kimi)(-|$)/i.test(family);
+}
+
+/**
+ * Ordered effort levels from lowest to highest.
+ * "" = default (no effort suffix in model ID).
+ */
+const EFFORT_ORDER = ["none", "low", "", "medium", "high", "xhigh", "max"] as const;
+
+/**
+ * Build a reasoning-effort map from the set of available effort suffixes.
+ * For each pi effort level (minimal/low/medium/high/xhigh), picks the closest
+ * available cursor effort, falling back to the lowest available.
+ */
+export function buildEffortMap(efforts: Set<string>): Record<string, string> {
+  const sorted = EFFORT_ORDER.filter(e => efforts.has(e));
+  if (sorted.length === 0) return {};
+  const lowest = sorted[0]!;
+
+  const pick = (...targets: string[]) => {
+    for (const t of targets) if (efforts.has(t)) return t;
+    return lowest;
+  };
+
+  return {
+    minimal: pick("none", "low", ""),
+    low:     pick("low", "none", ""),
+    medium:  pick("medium", "", "low"),
+    high:    pick("high", "medium", ""),
+    xhigh:   pick("max", "xhigh", "high"),
+  };
+}
+
+/** Dedup raw models: collapse effort variants into one entry with supportsReasoningEffort. */
+export function processModels(raw: CursorModel[]): ProcessedModel[] {
+  // Group by (base, fast, thinking)
+  const groups = new Map<string, {
+    base: string; fast: boolean; thinking: boolean;
+    efforts: Map<string, CursorModel>;
+  }>();
+
+  for (const model of raw) {
+    const p = parseModelId(model.id);
+    const key = `${p.base}|${p.fast}|${p.thinking}`;
+    let g = groups.get(key);
+    if (!g) {
+      g = { base: p.base, fast: p.fast, thinking: p.thinking, efforts: new Map() };
+      groups.set(key, g);
+    }
+    g.efforts.set(p.effort, model);
+  }
+
+  const result: ProcessedModel[] = [];
+
+  for (const g of groups.values()) {
+    // Dedup when there are multiple effort variants, OR a single variant
+    // whose effort is non-empty (e.g. claude-4.5-opus-high — strip the
+    // mandatory effort suffix so the model appears as claude-4.5-opus
+    // with effort mapping).
+    const hasOnlyEffortVariants = g.efforts.size === 1 && !g.efforts.has("");
+    if (g.efforts.size >= 2 || hasOnlyEffortVariants) {
+      // Pick representative: prefer "medium" or default ("") for name/metadata
+      const rep = g.efforts.get("medium") ?? g.efforts.get("") ?? [...g.efforts.values()][0]!;
+
+      // Build deduped model ID: base + thinking/fast suffix (no effort)
+      let id = g.base;
+      if (g.thinking) id += "-thinking";
+      if (g.fast) id += "-fast";
+
+      const effortMap = buildEffortMap(new Set(g.efforts.keys()));
+      const named = g.efforts.get("") ?? g.efforts.get("high") ?? rep;
+
+      result.push({
+        ...rep,
+        id,
+        name: cursorModelDisplayName(named.name),
+        supportsEffort: true,
+        effortMap,
+      });
+    } else {
+      // Keep single entries as-is (base model without effort variants)
+      for (const model of g.efforts.values()) {
+        result.push({ ...model, supportsEffort: false });
+      }
+    }
+  }
+
+  return result.sort((a, b) => a.id.localeCompare(b.id));
+}
+
+export function modelConfig(m: ProcessedModel) {
+  const thinkingLevelMap =
+    m.supportsEffort && m.effortMap
+      ? { off: null, ...m.effortMap }
+      : undefined;
+  return {
+    id: m.id,
+    name: cursorModelDisplayName(m.name),
+    reasoning: supportsReasoningModelId(m.id),
+    input: ["text"] as ("text" | "image")[],
+    cost: estimateModelCost(m.id),
+    contextWindow: m.contextWindow,
+    maxTokens: m.maxTokens,
+    ...(thinkingLevelMap ? { thinkingLevelMap } : {}),
+    compat: {
+      supportsDeveloperRole: false,
+      supportsReasoningEffort: m.supportsEffort,
+      ...(m.supportsEffort && m.effortMap && {
+        reasoningEffortMap: m.effortMap,
+      }),
+      maxTokensField: "max_tokens" as const,
+    },
+  };
+}
+
+
+export const FALLBACK_MODELS: CursorModel[] = (rawFallbackModels as CursorModel[]).map((model) => ({
+  ...model,
+  reasoning: supportsReasoningModelId(model.id),
+}));
+
+// ── Extension ──
+
+export function registerSessionLifecycleCleanup(pi: ExtensionAPI) {
+  registerSessionLifecycleHooks(pi, {
+    cleanupSessionState,
+    resetConversationForSession,
+    debug: debugExtensionLog,
+  });
+}
+
+function registerExtensionDebugHooks(pi: ExtensionAPI) {
+  if (!isExtensionDebugEnabled()) return;
+
+  pi.on("message_start", async (event, ctx) => {
+    if (ctx.model?.provider !== "cursor") return;
+    debugExtensionLog("message.start", {
+      sessionId: ctx.sessionManager.getSessionId(),
+      leafId: ctx.sessionManager.getLeafId?.(),
+      model: ctx.model?.id,
+      message: summarizeMessage((event as { message?: unknown }).message),
+    });
+  });
+
+  pi.on("message_update", async (event, ctx) => {
+    if (ctx.model?.provider !== "cursor") return;
+    const typedEvent = event as { message?: unknown; assistantMessageEvent?: Record<string, unknown> };
+    debugExtensionLog("message.update", {
+      sessionId: ctx.sessionManager.getSessionId(),
+      leafId: ctx.sessionManager.getLeafId?.(),
+      model: ctx.model?.id,
+      assistantMessageEvent: typedEvent.assistantMessageEvent
+        ? {
+            type: typedEvent.assistantMessageEvent.type,
+            delta: truncateDebugValue(String((typedEvent.assistantMessageEvent as Record<string, unknown>).delta ?? (typedEvent.assistantMessageEvent as Record<string, unknown>).content ?? "")),
+          }
+        : undefined,
+      message: summarizeMessage(typedEvent.message),
+    });
+  });
+
+  pi.on("message_end", async (event, ctx) => {
+    if (ctx.model?.provider !== "cursor") return;
+    debugExtensionLog("message.end", {
+      sessionId: ctx.sessionManager.getSessionId(),
+      leafId: ctx.sessionManager.getLeafId?.(),
+      model: ctx.model?.id,
+      message: summarizeMessage((event as { message?: unknown }).message),
+      branch: summarizeBranchTail(ctx),
+    });
+  });
+
+  pi.on("context", async (event, ctx) => {
+    if (ctx.model?.provider !== "cursor") return;
+    const typedEvent = event as { messages?: unknown[] };
+    debugExtensionLog("context", {
+      sessionId: ctx.sessionManager.getSessionId(),
+      leafId: ctx.sessionManager.getLeafId?.(),
+      model: ctx.model?.id,
+      messageCount: Array.isArray(typedEvent.messages) ? typedEvent.messages.length : undefined,
+      messages: Array.isArray(typedEvent.messages)
+        ? typedEvent.messages.slice(-8).map((message) => summarizeMessage(message))
+        : undefined,
+      branch: summarizeBranchTail(ctx),
+    });
+  });
+
+  pi.on("turn_end", async (event, ctx) => {
+    if (ctx.model?.provider !== "cursor") return;
+    const typedEvent = event as { turnIndex?: number; message?: unknown; toolResults?: unknown[] };
+    debugExtensionLog("turn.end", {
+      sessionId: ctx.sessionManager.getSessionId(),
+      leafId: ctx.sessionManager.getLeafId?.(),
+      model: ctx.model?.id,
+      turnIndex: typedEvent.turnIndex,
+      message: summarizeMessage(typedEvent.message),
+      toolResults: Array.isArray(typedEvent.toolResults)
+        ? typedEvent.toolResults.map((message) => summarizeMessage(message))
+        : undefined,
+      branch: summarizeBranchTail(ctx),
+    });
+  });
+
+  debugExtensionLog("extension.debug_hooks_registered", { logFile: getExtensionDebugLogFilePath() });
+}
+
+export default async function (pi: ExtensionAPI) {
+  // Current access token, updated by login/refresh/getApiKey
+  let currentToken = "";
+
+  // Start proxy eagerly — it just binds a port, no auth needed until a request arrives.
+  // The getAccessToken callback reads currentToken at request time.
+  const proxyReady = startProxy(async () => {
+    if (!currentToken) throw new Error("Not logged in to Cursor. Run /login cursor");
+    return currentToken;
+  });
+
+  const skipDedup = !!process.env.PI_CURSOR_RAW_MODELS;
+
+  registerSessionLifecycleCleanup(pi);
+  registerExtensionDebugHooks(pi);
+  debugExtensionLog("extension.start", {
+    debugLogFile: isExtensionDebugEnabled() ? getExtensionDebugLogFilePath() : undefined,
+  });
+
+  pi.on("before_provider_request", (event, ctx) => {
+    const payload = event.payload as Record<string, unknown> | undefined;
+    if (payload && ctx.model?.provider === "cursor") {
+      payload.pi_session_id = ctx.sessionManager.getSessionId();
+      debugExtensionLog("before_provider_request", {
+        sessionId: ctx.sessionManager.getSessionId(),
+        leafId: ctx.sessionManager.getLeafId?.(),
+        model: ctx.model?.id,
+        payload: summarizeProviderPayload(payload),
+        branch: summarizeBranchTail(ctx),
+      });
+    }
+    return payload;
+  });
+
+  // Await proxy so models are registered before pi proceeds with model resolution.
+  const port = await proxyReady;
+  register(pi, port, FALLBACK_MODELS);
+
+  function register(pi: ExtensionAPI, port: number, rawModels: CursorModel[]) {
+    const baseUrl = `http://127.0.0.1:${port}/v1`;
+    const processed = skipDedup
+      ? rawModels.map(m => ({ ...m, supportsEffort: false } as ProcessedModel))
+      : processModels(rawModels);
+
+    pi.registerProvider("cursor", {
+      baseUrl,
+      api: "openai-completions",
+      streamSimple: cursorPayloadStream,
+      models: processed.map(modelConfig),
+      oauth: {
+        name: "Cursor",
+
+        async login(callbacks: OAuthLoginCallbacks): Promise<OAuthCredentials> {
+          const { verifier, uuid, loginUrl } = await generateCursorAuthParams();
+          callbacks.onAuth({ url: loginUrl });
+          const { accessToken, refreshToken } = await pollCursorAuth(uuid, verifier);
+          currentToken = accessToken;
+
+          // Discover real models and re-register
+          const realPort = await proxyReady;
+          try {
+            const discovered = await getCursorModels(accessToken);
+            if (discovered.length > 0) register(pi, realPort, discovered);
+          } catch {
+            // catalog discovery is best-effort; FALLBACK_MODELS are already registered
+          }
+
+          return {
+            refresh: refreshToken,
+            access: accessToken,
+            expires: getTokenExpiry(accessToken),
+          };
+        },
+
+        async refreshToken(credentials: OAuthCredentials): Promise<OAuthCredentials> {
+          const refreshed = await refreshCursorToken(credentials.refresh);
+          currentToken = refreshed.access;
+
+          // Discover real models on refresh too
+          const realPort = await proxyReady;
+          try {
+            const discovered = await getCursorModels(refreshed.access);
+            if (discovered.length > 0) register(pi, realPort, discovered);
+          } catch {
+            // catalog discovery is best-effort; FALLBACK_MODELS are already registered
+          }
+
+          return refreshed;
+        },
+
+        getApiKey(credentials: OAuthCredentials): string {
+          currentToken = credentials.access;
+          return "cursor-proxy";
+        },
+      },
+    });
+  }
+
+
+}
+
+/** Drop controller-owned Cursor state after a credentialless task request. */
+export function cleanupControllerSession(sessionId: string): void {
+  cleanupSessionState(sessionId);
+}