cursor-opencode-provider 0.1.2 → 0.1.4

package/README.md

@@ -2,10 +2,16 @@
 
 Use [Cursor](https://cursor.com) subscription models from [OpenCode](https://opencode.ai) by speaking Cursor's Connect-RPC agent protocol.
 
-This project is a custom **AI SDK provider** (`LanguageModelV3`) plus an **OpenCode plugin** that handles authentication and model discovery. Instead of calling a generic chat-completions API, it encodes and decodes Cursor's protobuf agent protocol over HTTP/2 to `agentn.global.api5.cursor.sh`.
+This project is a custom **AI SDK provider** (`LanguageModelV3`) plus an **OpenCode plugin** that handles authentication and model discovery. Instead of calling a generic chat-completions API, it encodes and decodes Cursor's protobuf agent protocol over HTTP/2 to Cursor's agent backend.
 
 > **Status:** Usable end-to-end in OpenCode (auth, models, streaming, tools). See [Known limitations](#known-limitations).
 
+## Demo
+
+OpenCode driving a Cursor-routed Grok model through this provider:
+
+![OpenCode running a Grok model via cursor-opencode-provider](https://raw.githubusercontent.com/oakimov/cursor-opencode-provider/main/assets/opencode-grok.png)
+
 ## Features
 
 - **OpenCode integration** — registers a `cursor` provider with auth hooks and cached model list
@@ -41,7 +47,7 @@ Add the package name to OpenCode config. OpenCode installs npm plugins with Bun
 }
 ```
 
-Pin a version if you want: `"cursor-opencode-provider@0.1.2"`.
+Pin a version if you want: `"cursor-opencode-provider@0.1.4"`.
 
 ### From a local clone
 
@@ -69,7 +75,7 @@ Point config at the built files with absolute `file://` URLs:
 
 ## OpenCode setup
 
-If the `cursor` provider block is omitted, the classic plugin auto-registers it on startup (as **Cursor Integration**) using this package's entry. Model entries are filled from the local cache after you authenticate.
+If the `cursor` provider block is omitted, the classic plugin auto-registers it on startup (as **Cursor Integration**) using this package's entry. Model entries come from the local cache, which is filled after auth and again on startup when the cache is empty but credentials remain.
 
 For OpenCode builds that use the Effect/Promise **v2** plugin API (`plugins` field), also load:
 
@@ -96,7 +102,15 @@ Choose the **cursor** provider, then one of:
 | **Cursor account (browser login)** | PKCE OAuth — opens cursor.com to sign in |
 | **API key** | Paste a key from [cursor.com/settings](https://cursor.com/settings) (`sk-...`) |
 
-After login, the plugin fetches your available models and writes them to `cursor-models.json` (OpenCode config directory, or `CURSOR_CONFIG_DIR` if set).
+After login, the plugin fetches your available models and writes them to `~/.cache/opencode/cursor-models.json` (or `$XDG_CACHE_HOME/opencode/` when set). On later startups, if that cache is missing or empty but Cursor auth is still present, the plugin fetches again during config load.
+
+### Paths (XDG)
+
+| Kind | Default | Override |
+|------|---------|----------|
+| Model / version **cache** | `~/.cache/opencode/` | `$XDG_CACHE_HOME/opencode/` |
+| OpenCode **auth** (`auth.json`) | `~/.local/share/opencode/` | `$XDG_DATA_HOME/opencode/` |
+| OpenCode **config** (AGENTS, skills, …) | `~/.config/opencode/` | (config dir helper; not the model cache) |
 
 ### Select a model
 
@@ -114,25 +128,30 @@ import { createCursor } from "cursor-opencode-provider"
 const cursor = createCursor({
   name: "cursor",
   accessToken: process.env.CURSOR_ACCESS_TOKEN,
+  // apiBaseURL: "https://api2.cursor.sh",
+  // agentBaseURL: "https://agentn.us.api5.cursor.sh", // explicit Run host override
+  // telemetryEnabled: true, // opt in to GetServerConfig telemetry
 })
 
 const model = cursor.languageModel("composer-2.5")
 // model implements AI SDK LanguageModelV3 (doStream / doGenerate)
 ```
 
-Pass either `accessToken` (JWT from OAuth or key exchange) or `apiKey` (raw `sk-...` key). Optional: `baseURL`, `headers`.
+Pass either `accessToken` (JWT from OAuth or key exchange) or `apiKey` (raw `sk-...` key). Optional: `apiBaseURL`, `agentBaseURL`, `headers`, `telemetryEnabled`. The older `baseURL` option is still accepted as a legacy alias for `agentBaseURL`.
 
 ## Environment variables
 
 | Variable | Description |
 |----------|-------------|
-| `CURSOR_CONFIG_DIR` | Override directory for `cursor-models.json` cache (defaults to the OpenCode directory passed into the plugin) |
 | `CURSOR_WEBSITE_URL` | Override OAuth login base URL (default `https://cursor.com`) |
-| `CURSOR_API_BASE_URL` | Override API base for auth and model discovery (default `https://api2.cursor.sh`) |
+| `CURSOR_API_BASE_URL` | Override API base for auth, model discovery, and `GetServerConfig` agent URL resolution (default `https://api2.cursor.sh`) |
+| `CURSOR_GET_SERVER_CONFIG_TELEMETRY` | Set to `1` or `true` to opt the `GetServerConfig` lookup into telemetry in OpenCode/plugin usage |
 | `CURSOR_PROVIDER_DEBUG` | Set to `1` or `true` to enable wire-level debug logging |
 | `CURSOR_PROVIDER_DEBUG_FILE` | Debug log path (default `/tmp/cursor-provider-debug.log`) |
+| `XDG_CACHE_HOME` | When set, model/version caches go under `$XDG_CACHE_HOME/opencode/` instead of `~/.cache/opencode/` |
+| `XDG_DATA_HOME` | When set, OpenCode `auth.json` is read from `$XDG_DATA_HOME/opencode/` instead of `~/.local/share/opencode/` |
 
-`createCursor({ baseURL })` also overrides the agent Run host (default `https://agentn.global.api5.cursor.sh`).
+`createCursor({ agentBaseURL })` overrides the agent Run host. When unset, the provider resolves the host from Cursor's `GetServerConfig` API (`agentUrlConfig.agentnUrl`, region-specific — e.g. `agentn.us.api5.cursor.sh`, `agent-gcpp-uswest.api5.cursor.sh`) once per process and holds it in memory (never written to disk), so a held-open Run stream is never repointed mid-session. Explicit agent overrides and GetServerConfig results are validated as HTTPS `*.cursor.sh` hosts (Cursor's agent hostnames vary and may change); non-`cursor.sh` hosts are rejected. The lookup sends `{ "telem_enabled": false }` by default; set `telemetryEnabled: true` in provider config, or `CURSOR_GET_SERVER_CONFIG_TELEMETRY=1` for OpenCode/plugin usage, to opt in. If the lookup fails or does not return a valid Cursor agent host, the model call fails clearly instead of falling back to `agentn.global.api5.cursor.sh`.
 
 ## Development
 
@@ -152,7 +171,7 @@ OpenCode
         └── createCursor() → LanguageModelV3
               ├── session.ts  held-open Run stream + exec bridge
               ├── protocol/   protobuf messages, framing, tools, thinking
-              └── transport/  Connect-RPC over HTTP/2 to agentn.global.api5.cursor.sh
+              └── transport/  Connect-RPC over HTTP/2 to Cursor's agent backend
 ```
 
 | Module | Role |
@@ -164,6 +183,7 @@ OpenCode
 | `src/session.ts` | Held-open agent Run session and pending exec correlation |
 | `src/auth.ts` | PKCE OAuth, API key exchange, JWT refresh |
 | `src/models.ts` | `AvailableModels` fetch and `cursor-models.json` cache |
+| `src/agent-url.ts` | `GetServerConfig` fetch + in-process memo (region-specific Run host) |
 | `src/transport/connect.ts` | HTTP/2 bidi stream and unary RPC calls |
 | `src/protocol/` | Protobuf encode/decode, checksum/device ids, tool-call mapping |
 
@@ -181,11 +201,12 @@ OpenCode
 
 | Problem | What to try |
 |---------|-------------|
-| No Cursor models in the picker | Run `opencode auth login`, choose **cursor**, then restart OpenCode so the plugin reloads `cursor-models.json`. Confirm `provider.cursor.npm` is the package name (or a built `file://…/dist/index.js`). |
+| No Cursor models in the picker | Confirm Cursor auth (`opencode auth login` → **cursor**). Restart OpenCode — if auth is present and the cache is empty, models are fetched on startup. Confirm `provider.cursor.npm` is the package name (or a built `file://…/dist/index.js`). |
 | Auth / 401 errors mid-session | Re-login. OAuth and exchanged API-key JWTs refresh automatically when near expiry; a revoked refresh token needs a fresh login. |
 | “Too many connections from different devices” | Device IDs are derived from stable OS identifiers (same approach as the Cursor CLI). Avoid running multiple clients that invent different machine fingerprints for the same account. |
-| Empty or stale model list | Delete `cursor-models.json` under the OpenCode config dir (or the dir set by `CURSOR_CONFIG_DIR`) and re-auth / restart so models are fetched again. Cache TTL is 24h; a failed background refresh keeps serving the previous cache. |
-| Stream hangs or HTTP/2 errors | Abort the turn and retry. The agent Run uses a bidirectional HTTP/2 stream to `agentn.global.api5.cursor.sh`; a dropped connection leaves the in-flight session unusable. |
+| Empty or stale model list | Delete `~/.cache/opencode/cursor-models.json` (or under `$XDG_CACHE_HOME/opencode/`) and restart OpenCode. Existing Cursor auth is enough to refill the cache; re-login only if auth itself is broken. Cache TTL is 24h; a failed background refresh keeps serving the previous cache. |
+| Stream hangs or HTTP/2 errors | Abort the turn and retry. The agent Run uses a bidirectional HTTP/2 stream; a dropped connection leaves the in-flight session unusable. |
+| No response / silent 200 + close | The provider resolves the Run host from `GetServerConfig` (`agentUrlConfig.agentnUrl`). The URL is resolved once per process and not cached on disk. If resolution fails, the model call reports the endpoint-resolution error instead of falling back to `agentn.global.api5.cursor.sh`, which some accounts reject silently ("This region is not yet available for your team"). Set `CURSOR_PROVIDER_DEBUG=1` to confirm the resolved host in the debug log. |
 | Need wire-level logs | Set `CURSOR_PROVIDER_DEBUG=1` (optional `CURSOR_PROVIDER_DEBUG_FILE`, default `/tmp/cursor-provider-debug.log`) and reproduce the issue. |
 
 ## Known limitations

package/dist/agent-url.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Resolve the Run stream origin for this account via the `GetServerConfig`
+ * Connect RPC. Memoized for the process lifetime.
+ *
+ *   - already resolved → return the memo (no fetch)
+ *   - otherwise → fetch `agentUrlConfig.agentnUrl` (then `agentUrl`), memoize, return
+ *   - fetch fails / no valid `agentUrlConfig` → throw (no global-host fallback)
+ *
+ * Concurrent callers share a single in-flight fetch.
+ */
+export declare function resolveAgentUrl(token: string, options?: {
+    apiBaseURL?: string;
+    baseURL?: string;
+    telemetryEnabled?: boolean;
+}): Promise<string>;
+/** Reset the in-process memo. Tests only. */
+export declare function resetAgentUrlCache(): void;

package/dist/agent-url.js

@@ -0,0 +1,74 @@
+import { createHash } from "node:crypto";
+import { fetchAgentUrl, trace } from "./transport/connect.js";
+import { CURSOR_API_HOST } from "./shared.js";
+const DEFAULT_API_BASE = `https://${CURSOR_API_HOST}`;
+// In-process memo of the region-specific Run stream origin (agentnUrl). Resolved
+// once per process — the auth loader warms it, and the first startSession reuses
+// it — and held for the process lifetime. Region routing is near-static, and
+// re-resolving mid-session would break a held-open bidi Run stream anyway.
+//
+// Unlike the models/version caches this is NOT persisted to disk. A wrong agent
+// host is fatal and silent (HTTP 200 + immediate close, "This region is not
+// available for your team"), so persisting it would risk pinning the process —
+// or the next process — to a stale region or the legacy global host that some
+// accounts reject. Resolving fresh per process is cheap (one unary RPC on the
+// API host) and self-heals after a Cursor-side region migration on restart.
+//
+function normalizeApiBaseURL(baseURL) {
+    if (!baseURL)
+        return DEFAULT_API_BASE;
+    return new URL(baseURL).origin;
+}
+function resolveCacheKey(token, options) {
+    const tokenHash = createHash("sha256").update(token).digest("hex").slice(0, 16);
+    return `${tokenHash}|${normalizeApiBaseURL(options.apiBaseURL ?? options.baseURL)}|telem:${options.telemetryEnabled === true}`;
+}
+const _resolved = new Map();
+// In-flight fetches share the same key as resolved URLs so concurrent callers dedup per account.
+const _inflight = new Map();
+/**
+ * Resolve the Run stream origin for this account via the `GetServerConfig`
+ * Connect RPC. Memoized for the process lifetime.
+ *
+ *   - already resolved → return the memo (no fetch)
+ *   - otherwise → fetch `agentUrlConfig.agentnUrl` (then `agentUrl`), memoize, return
+ *   - fetch fails / no valid `agentUrlConfig` → throw (no global-host fallback)
+ *
+ * Concurrent callers share a single in-flight fetch.
+ */
+export async function resolveAgentUrl(token, options = {}) {
+    const cacheKey = resolveCacheKey(token, options);
+    const memo = _resolved.get(cacheKey);
+    if (memo) {
+        trace(`agent-url: reuse in-process memo → ${memo}`);
+        return memo;
+    }
+    const inflight = _inflight.get(cacheKey);
+    if (inflight) {
+        trace("agent-url: awaiting in-flight GetServerConfig");
+        return inflight;
+    }
+    const promise = (async () => {
+        try {
+            const url = await fetchAgentUrl(token, options);
+            _resolved.set(cacheKey, url);
+            trace(`agent-url: resolved via GetServerConfig → ${url}`);
+            return url;
+        }
+        catch (err) {
+            const reason = err instanceof Error ? err.message : String(err);
+            trace(`agent-url: GetServerConfig failed (${reason}); no fallback agent host will be used`);
+            throw err;
+        }
+        finally {
+            _inflight.delete(cacheKey);
+        }
+    })();
+    _inflight.set(cacheKey, promise);
+    return promise;
+}
+/** Reset the in-process memo. Tests only. */
+export function resetAgentUrlCache() {
+    _resolved.clear();
+    _inflight.clear();
+}

package/dist/context/auth-store.d.ts

@@ -0,0 +1,21 @@
+/** Mirrors OpenCode / SDK OAuth + API auth used for Cursor. `wellknown` is not wired yet. */
+export type StoredAuth = {
+    type: "oauth";
+    access: string;
+    refresh: string;
+    expires: number;
+    accountId?: string;
+    enterpriseUrl?: string;
+} | {
+    type: "api";
+    key: string;
+    metadata?: Record<string, string>;
+};
+/**
+ * Read a provider's credentials from OpenCode's `auth.json` (XDG data dir).
+ *
+ * Honors `OPENCODE_AUTH_CONTENT` when set — same injection hook OpenCode core
+ * uses in tests / embedded runs (not an SDK export).
+ */
+export declare function readStoredAuth(providerId: string): Promise<StoredAuth | undefined>;
+export declare function asStoredAuth(value: unknown): StoredAuth | undefined;

package/dist/context/auth-store.js

@@ -0,0 +1,64 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { opencodeGlobalDataDir } from "./paths.js";
+function debugEnabled() {
+    return process.env.CURSOR_PROVIDER_DEBUG === "1" || process.env.CURSOR_PROVIDER_DEBUG === "true";
+}
+function debugAuthStore(message) {
+    if (!debugEnabled())
+        return;
+    console.debug(`[cursor-opencode-provider] auth-store: ${message}`);
+}
+/**
+ * Read a provider's credentials from OpenCode's `auth.json` (XDG data dir).
+ *
+ * Honors `OPENCODE_AUTH_CONTENT` when set — same injection hook OpenCode core
+ * uses in tests / embedded runs (not an SDK export).
+ */
+export async function readStoredAuth(providerId) {
+    if (process.env.OPENCODE_AUTH_CONTENT) {
+        try {
+            const data = JSON.parse(process.env.OPENCODE_AUTH_CONTENT);
+            return asStoredAuth(data[providerId]);
+        }
+        catch {
+            debugAuthStore("OPENCODE_AUTH_CONTENT is not valid JSON");
+            return undefined;
+        }
+    }
+    const filePath = path.join(opencodeGlobalDataDir(), "auth.json");
+    try {
+        const raw = await readFile(filePath, "utf-8");
+        try {
+            const data = JSON.parse(raw);
+            return asStoredAuth(data[providerId]);
+        }
+        catch {
+            debugAuthStore("auth.json is not valid JSON");
+            return undefined;
+        }
+    }
+    catch (err) {
+        const code = err?.code;
+        if (code !== "ENOENT") {
+            debugAuthStore(`failed to read auth.json (${code ?? "unknown"})`);
+        }
+        return undefined;
+    }
+}
+export function asStoredAuth(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const v = value;
+    if (v.type === "oauth" &&
+        typeof v.access === "string" &&
+        typeof v.refresh === "string" &&
+        typeof v.expires === "number") {
+        return value;
+    }
+    if (v.type === "api" && typeof v.key === "string") {
+        return value;
+    }
+    // wellknown is intentionally rejected until resolveAccessToken supports it
+    return undefined;
+}

package/dist/context/index.d.ts

@@ -1,2 +1,2 @@
 export { buildRequestContext, type BuildRequestContextInput } from "./build.js";
-export { opencodeGlobalConfigDir } from "./paths.js";
+export { opencodeGlobalCacheDir, opencodeGlobalConfigDir, opencodeGlobalDataDir } from "./paths.js";

package/dist/context/index.js

@@ -1,2 +1,2 @@
 export { buildRequestContext } from "./build.js";
-export { opencodeGlobalConfigDir } from "./paths.js";
+export { opencodeGlobalCacheDir, opencodeGlobalConfigDir, opencodeGlobalDataDir } from "./paths.js";

package/dist/context/paths.d.ts

@@ -1,3 +1,14 @@
 /** OpenCode global config dir (`~/.config/opencode`). */
 export declare function opencodeGlobalConfigDir(): string;
+/**
+ * OpenCode global cache dir (`~/.cache/opencode`).
+ * Uses `$XDG_CACHE_HOME/opencode` when set, otherwise `$HOME/.cache/opencode`.
+ */
+export declare function opencodeGlobalCacheDir(): string;
+/**
+ * OpenCode global data dir (`~/.local/share/opencode`).
+ * Uses `$XDG_DATA_HOME/opencode` when set, otherwise `$HOME/.local/share/opencode`.
+ * Auth credentials live here in `auth.json`.
+ */
+export declare function opencodeGlobalDataDir(): string;
 export declare function resolveHomeRelative(p: string): string;

package/dist/context/paths.js

@@ -1,8 +1,32 @@
 import { homedir } from "node:os";
 import path from "node:path";
+function resolveHome() {
+    return process.env.HOME || process.env.USERPROFILE || homedir();
+}
 /** OpenCode global config dir (`~/.config/opencode`). */
 export function opencodeGlobalConfigDir() {
-    return path.join(homedir(), ".config", "opencode");
+    return path.join(resolveHome(), ".config", "opencode");
+}
+/**
+ * OpenCode global cache dir (`~/.cache/opencode`).
+ * Uses `$XDG_CACHE_HOME/opencode` when set, otherwise `$HOME/.cache/opencode`.
+ */
+export function opencodeGlobalCacheDir() {
+    if (process.env.XDG_CACHE_HOME) {
+        return path.join(process.env.XDG_CACHE_HOME, "opencode");
+    }
+    return path.join(resolveHome(), ".cache", "opencode");
+}
+/**
+ * OpenCode global data dir (`~/.local/share/opencode`).
+ * Uses `$XDG_DATA_HOME/opencode` when set, otherwise `$HOME/.local/share/opencode`.
+ * Auth credentials live here in `auth.json`.
+ */
+export function opencodeGlobalDataDir() {
+    if (process.env.XDG_DATA_HOME) {
+        return path.join(process.env.XDG_DATA_HOME, "opencode");
+    }
+    return path.join(resolveHome(), ".local", "share", "opencode");
 }
 export function resolveHomeRelative(p) {
     if (p.startsWith("~/"))

package/dist/index.d.ts

@@ -3,8 +3,15 @@ export type CreateCursorOptions = {
     name: string;
     accessToken?: string;
     apiKey?: string;
+    /** API base for auth, model discovery, and GetServerConfig. */
+    apiBaseURL?: string;
+    /** Explicit Cursor agent Run host override. */
+    agentBaseURL?: string;
+    /** @deprecated Use agentBaseURL. Kept as the legacy agent Run host override. */
     baseURL?: string;
     headers?: Record<string, string>;
+    /** Opt in to telemetry on the GetServerConfig endpoint lookup. Defaults to false. */
+    telemetryEnabled?: boolean;
     /** OpenCode project / worktree directory for request_context collectors. */
     workspaceRoot?: string;
 };

package/dist/language-model.js

@@ -1,7 +1,6 @@
-import path from "node:path";
 import fs from "node:fs";
 import { createHash } from "node:crypto";
-import { bidiRunStream, trace } from "./transport/connect.js";
+import { bidiRunStream, normalizeAgentRunOrigin, trace } from "./transport/connect.js";
 import { buildRunRequest, buildHeartbeat } from "./protocol/request.js";
 import { decodeFramePayload } from "./protocol/framing.js";
 import { decodeMessage } from "./protocol/messages.js";
@@ -12,10 +11,13 @@ import { conversationBlobCount } from "./protocol/blob-store.js";
 import { sessionManager } from "./session.js";
 import { readCache, cacheFilePath, resolveVariantParameters } from "./models.js";
 import { buildRequestContext } from "./context/build.js";
+import { opencodeGlobalCacheDir } from "./context/paths.js";
+import { resolveAgentUrl } from "./agent-url.js";
+import { CURSOR_API_HOST } from "./shared.js";
 let _availableModels;
 // mtime of the cache file the last time we loaded it. Compared on each call
 // so discoverModels' background refresh is picked up without a process restart.
-let _availableModelsMtimeMs = 0;
+let _availableModelsMtimeMs = -1;
 export function createCursorLanguageModel(modelId, providerId, options) {
     return {
         specificationVersion: "v3",
@@ -49,7 +51,7 @@ async function doStreamImpl(modelId, options, callOptions) {
     const token = await resolveBearerToken({
         accessToken: options.accessToken,
         apiKey: options.apiKey,
-        baseUrl: options.baseURL,
+        baseUrl: resolveApiBaseURL(options),
     });
     const prompt = callOptions.prompt;
     // ── Continuation vs fresh turn ──
@@ -171,6 +173,14 @@ async function startSession(modelId, token, callOptions, options) {
     const systemPrompt = extractSystemPrompt(prompt);
     const tools = extractTools(callOptions);
     await loadAvailableModels();
+    // Resolve the region-specific Run stream origin once per process (memoized
+    // in agent-url.ts). Explicit agent host overrides skip GetServerConfig but
+    // still go through the Cursor agent-host allowlist.
+    const agentBaseUrl = resolveExplicitAgentBaseURL(options) ??
+        (await resolveAgentUrl(token, {
+            apiBaseURL: resolveApiBaseURL(options),
+            telemetryEnabled: resolveTelemetryEnabled(options),
+        }));
     const providerOptions = callOptions.providerOptions?.cursor;
     const reasoningEffort = providerOptions?.reasoningEffort;
     const maxMode = !!(providerOptions?.maxMode ?? false);
@@ -180,7 +190,7 @@ async function startSession(modelId, token, callOptions, options) {
     // that signal when a turn ends with tool-calls; the Cursor stream must stay
     // open until we write the exec results on the next doStream.
     const stream = await bidiRunStream(token, {
-        baseURL: options.baseURL,
+        baseURL: agentBaseUrl,
         headers: options.headers,
     });
     // Build the tool descriptors once — advertised in AgentRunRequest #4 mcp_tools
@@ -301,11 +311,9 @@ export function findContinuationSession(toolResults) {
     return undefined;
 }
 async function loadAvailableModels() {
-    const configDir = resolveModelCacheDir();
-    if (!configDir)
-        return;
+    const cacheDir = opencodeGlobalCacheDir();
     try {
-        const filePath = cacheFilePath(configDir);
+        const filePath = cacheFilePath(cacheDir);
         let mtime = 0;
         try {
             const stat = await fs.promises.stat(filePath);
@@ -316,23 +324,31 @@ async function loadAvailableModels() {
         }
         // Re-read when the file changed (discoverModels background refresh).
         if (mtime !== _availableModelsMtimeMs) {
-            const cached = await readCache(configDir);
+            const cached = await readCache(cacheDir);
             _availableModels = cached?.models;
             _availableModelsMtimeMs = mtime;
         }
     }
     catch { /* ignore */ }
 }
-/** Same directory the plugin writes to (CURSOR_CONFIG_DIR, else OpenCode config). */
-function resolveModelCacheDir() {
-    if (process.env.CURSOR_CONFIG_DIR)
-        return process.env.CURSOR_CONFIG_DIR;
-    const home = process.env.HOME || process.env.USERPROFILE;
-    if (!home)
+function resolveApiBaseURL(options) {
+    return options.apiBaseURL ?? process.env.CURSOR_API_BASE_URL ?? `https://${CURSOR_API_HOST}`;
+}
+function resolveTelemetryEnabled(options) {
+    return options.telemetryEnabled ?? isTruthyEnv(process.env.CURSOR_GET_SERVER_CONFIG_TELEMETRY);
+}
+function resolveExplicitAgentBaseURL(options) {
+    const raw = options.agentBaseURL ?? options.baseURL;
+    if (!raw)
         return undefined;
-    return process.env.XDG_CONFIG_HOME
-        ? path.join(process.env.XDG_CONFIG_HOME, "opencode")
-        : path.join(home, ".config", "opencode");
+    const normalized = normalizeAgentRunOrigin(raw);
+    if (!normalized) {
+        throw new Error("Invalid Cursor agent base URL override: expected https://*.cursor.sh");
+    }
+    return normalized;
+}
+function isTruthyEnv(value) {
+    return value === "1" || value === "true";
 }
 /**
  * Read the held-open stream, emitting stream parts, until the turn boundary:

package/dist/models.d.ts

@@ -24,9 +24,9 @@ export type ModelCache = {
     fetchedAt: number;
 };
 export declare function isCacheFresh(cache: ModelCache, ttlMs?: number): boolean;
-export declare function cacheFilePath(configDir: string): string;
-export declare function readCache(configDir: string): Promise<ModelCache | null>;
-export declare function writeCache(configDir: string, cache: ModelCache): Promise<void>;
+export declare function cacheFilePath(cacheDir: string): string;
+export declare function readCache(cacheDir: string): Promise<ModelCache | null>;
+export declare function writeCache(cacheDir: string, cache: ModelCache): Promise<void>;
 export declare function mapAvailableModelsResponse(raw: Record<string, unknown>): ModelInfo[];
 /**
  * Resolve the parameter values to send in `requested_model.parameters` for a
@@ -43,7 +43,7 @@ export declare function fetchModels(token: string, options?: {
     baseURL?: string;
     headers?: Record<string, string>;
 }): Promise<ModelInfo[]>;
-export declare function discoverModels(token: string, configDir: string, options?: {
+export declare function discoverModels(token: string, cacheDir: string, options?: {
     baseURL?: string;
     headers?: Record<string, string>;
 }): Promise<ModelInfo[]>;

package/dist/models.js

@@ -8,11 +8,11 @@ import path from "node:path";
 export function isCacheFresh(cache, ttlMs = MODEL_CACHE_TTL_MS) {
     return Date.now() - cache.fetchedAt < ttlMs;
 }
-export function cacheFilePath(configDir) {
-    return path.join(configDir, MODEL_CACHE_FILE);
+export function cacheFilePath(cacheDir) {
+    return path.join(cacheDir, MODEL_CACHE_FILE);
 }
-export async function readCache(configDir) {
-    const filePath = cacheFilePath(configDir);
+export async function readCache(cacheDir) {
+    const filePath = cacheFilePath(cacheDir);
     try {
         if (!existsSync(filePath))
             return null;
@@ -23,8 +23,8 @@ export async function readCache(configDir) {
         return null;
     }
 }
-export async function writeCache(configDir, cache) {
-    const filePath = cacheFilePath(configDir);
+export async function writeCache(cacheDir, cache) {
+    const filePath = cacheFilePath(cacheDir);
     await mkdir(path.dirname(filePath), { recursive: true });
     await writeFile(filePath, JSON.stringify(cache, null, 2), "utf-8");
 }
@@ -104,13 +104,13 @@ export async function fetchModels(token, options = {}) {
     const raw = await unaryAvailableModels(token, options);
     return mapAvailableModelsResponse(raw);
 }
-export async function discoverModels(token, configDir, options = {}) {
-    const cached = await readCache(configDir);
+export async function discoverModels(token, cacheDir, options = {}) {
+    const cached = await readCache(cacheDir);
     // Cache is fresh → return it; refresh in background
     if (cached && isCacheFresh(cached)) {
         // Background refresh (fire and forget)
         fetchModels(token, options)
-            .then((models) => writeCache(configDir, { models, fetchedAt: Date.now() }))
+            .then((models) => writeCache(cacheDir, { models, fetchedAt: Date.now() }))
             .catch(() => {
             /* background refresh failure is non-fatal */
         });
@@ -121,7 +121,7 @@ export async function discoverModels(token, configDir, options = {}) {
         try {
             const models = await fetchModels(token, options);
             const newCache = { models, fetchedAt: Date.now() };
-            await writeCache(configDir, newCache);
+            await writeCache(cacheDir, newCache);
             return models;
         }
         catch {
@@ -131,6 +131,6 @@ export async function discoverModels(token, configDir, options = {}) {
     // No cache → must fetch
     const models = await fetchModels(token, options);
     const newCache = { models, fetchedAt: Date.now() };
-    await writeCache(configDir, newCache);
+    await writeCache(cacheDir, newCache);
     return models;
 }

package/dist/plugin.d.ts

@@ -1,2 +1,15 @@
 import type { Hooks, PluginInput } from "@opencode-ai/plugin";
+import { type ModelInfo } from "./models.js";
+/**
+ * Display names shared by both a thinking and a non-thinking model. A thinking
+ * model with such a name needs a "Thinking" tag to disambiguate it from its
+ * non-thinking twin (Cursor's Claude/Fable/Sonnet families). Models whose names
+ * are already unique — including Cursor's GPT family, where the reasoning tier
+ * ("None"/"Low"/"High"…) is baked into the name — are excluded, so they aren't
+ * tagged redundantly.
+ */
+export declare function thinkingSuffixBaseNames(models: ModelInfo[]): Set<string>;
+export declare function modelInfoToConfig(mi: ModelInfo, options?: {
+    thinkingSuffix?: boolean;
+}): Record<string, any>;
 export declare function CursorPlugin(input: PluginInput): Promise<Hooks>;

package/dist/plugin.js

@@ -1,13 +1,37 @@
 import { CURSOR_PROVIDER_ID, CURSOR_WEBSITE_HOST, CURSOR_API_HOST } from "./shared.js";
 import { pollForTokens, exchangeApiKey, refreshAccessToken, isExpiringSoon, generatePkceParams, generatePkceChallenge, buildLoginUrl, decodeJwtPayload } from "./auth.js";
-import { readCache, discoverModels } from "./models.js";
+import { readCache, discoverModels, isCacheFresh } from "./models.js";
+import { opencodeGlobalCacheDir } from "./context/paths.js";
+import { readStoredAuth } from "./context/auth-store.js";
+import { resolveAgentUrl } from "./agent-url.js";
 const MODULE_URL = new URL("./index.js", import.meta.url).href;
+/**
+ * Strip characters that break rendering in the OpenCode Desktop webview from a
+ * model or variant display name: HTML/markup chars (`< > & " ' \``), parentheses,
+ * Tabs/newlines collapse to single spaces; dots and unicode letters are preserved so names
+ * stay readable. Fixes https://github.com/oakimov/cursor-opencode-provider/issues/2.
+ */
+function safeLabel(value) {
+    return (value
+        .replace(/[()<>&"'`]/g, "")
+        .replace(/\s+/g, " ")
+        .trim() || "default");
+}
+function baseName(mi) {
+    return safeLabel(mi.displayName ?? mi.id);
+}
 function modelInfoVariants(mi) {
     if (mi.variants.length === 0)
         return undefined;
     const entries = {};
+    const usedKeys = new Set();
     for (const v of mi.variants) {
-        const key = v.displayName || v.key || "default";
+        const base = safeLabel(v.displayName || v.key || "default");
+        let key = base;
+        let suffix = 2;
+        while (usedKeys.has(key))
+            key = `${base}--${suffix++}`;
+        usedKeys.add(key);
         const params = {};
         for (const p of v.parameterValues) {
             params[p.id] = p.value;
@@ -16,9 +40,37 @@ function modelInfoVariants(mi) {
     }
     return entries;
 }
-function modelInfoToConfig(mi) {
+/**
+ * Display names shared by both a thinking and a non-thinking model. A thinking
+ * model with such a name needs a "Thinking" tag to disambiguate it from its
+ * non-thinking twin (Cursor's Claude/Fable/Sonnet families). Models whose names
+ * are already unique — including Cursor's GPT family, where the reasoning tier
+ * ("None"/"Low"/"High"…) is baked into the name — are excluded, so they aren't
+ * tagged redundantly.
+ */
+export function thinkingSuffixBaseNames(models) {
+    const flags = new Map();
+    for (const m of models) {
+        const base = baseName(m);
+        const entry = flags.get(base) ?? { hasThinking: false, hasNonThinking: false };
+        if (m.supportsThinking)
+            entry.hasThinking = true;
+        else
+            entry.hasNonThinking = true;
+        flags.set(base, entry);
+    }
+    const ambiguous = new Set();
+    for (const [base, f] of flags)
+        if (f.hasThinking && f.hasNonThinking)
+            ambiguous.add(base);
+    return ambiguous;
+}
+export function modelInfoToConfig(mi, options = {}) {
+    let name = baseName(mi);
+    if (options.thinkingSuffix)
+        name += " Thinking";
     const config = {
-        name: mi.displayName ?? mi.id,
+        name,
         reasoning: mi.supportsThinking ?? false,
         tool_call: mi.supportsAgent ?? true,
         temperature: false,
@@ -32,17 +84,139 @@ function modelInfoToConfig(mi) {
         config.variants = variants;
     return config;
 }
+function modelsToConfig(models) {
+    const ambiguous = thinkingSuffixBaseNames(models);
+    const out = {};
+    for (const m of models) {
+        out[m.id] = modelInfoToConfig(m, {
+            thinkingSuffix: !!m.supportsThinking && ambiguous.has(baseName(m)),
+        });
+    }
+    return out;
+}
+function cursorApiBaseURL() {
+    return process.env.CURSOR_API_BASE_URL ?? `https://${CURSOR_API_HOST}`;
+}
+function cursorGetServerConfigTelemetryEnabled() {
+    return (process.env.CURSOR_GET_SERVER_CONFIG_TELEMETRY === "1" ||
+        process.env.CURSOR_GET_SERVER_CONFIG_TELEMETRY === "true");
+}
 export async function CursorPlugin(input) {
-    const configDir = process.env.CURSOR_CONFIG_DIR || input.directory;
+    const cacheDir = opencodeGlobalCacheDir();
+    const apiBaseURL = cursorApiBaseURL();
+    // Last access token successfully resolved in this plugin instance. Config's
+    // loadModels can only read OpenCode's durable store (auth.json /
+    // OPENCODE_AUTH_CONTENT); auth.loader gets live credentials via getAuth().
+    // Those usually match, but after a refresh where persistAuthBestEffort fails,
+    // getAuth() may still see the old credentials while we already hold a usable
+    // token here — keep it so the loader can still discover models.
+    let sessionAccessToken;
+    async function persistAuth(body) {
+        await input.client.auth.set({
+            path: { id: CURSOR_PROVIDER_ID },
+            body,
+        });
+    }
+    /** Persist refreshed credentials without failing the caller that already holds a live token. */
+    async function persistAuthBestEffort(body) {
+        try {
+            await persistAuth(body);
+        }
+        catch {
+            // ignore — token is still usable for this process
+        }
+    }
+    /**
+     * Durable credentials OpenCode stores on disk (same file getAuth() reads in
+     * the normal path). Used from `config`, which has no getAuth() callback.
+     */
+    async function authFromStore() {
+        return readStoredAuth(CURSOR_PROVIDER_ID);
+    }
+    /**
+     * Prefer OpenCode's live getAuth(); fall back to the durable store so loader
+     * and config share the same underlying credentials when possible.
+     */
+    async function authForLoader(getAuth) {
+        return (await getAuth()) ?? (await authFromStore());
+    }
+    async function resolveAccessToken(auth) {
+        if (auth.type === "api") {
+            let accessToken = auth.key;
+            const refreshToken = auth.metadata?.refreshToken;
+            // API-key exchange returns a short-lived JWT stored as `key`. Refresh
+            // it the same way as OAuth when it is expiring / already expired.
+            if (refreshToken && isExpiringSoon(auth.key)) {
+                try {
+                    const newTokens = await refreshAccessToken(refreshToken, apiBaseURL);
+                    accessToken = newTokens.accessToken;
+                    await persistAuthBestEffort({
+                        type: "api",
+                        key: newTokens.accessToken,
+                        metadata: {
+                            ...auth.metadata,
+                            refreshToken: newTokens.refreshToken,
+                        },
+                    });
+                }
+                catch {
+                    // refresh failed — keep the existing key; the next call may still work
+                }
+            }
+            if (accessToken)
+                sessionAccessToken = accessToken;
+            return accessToken;
+        }
+        if (auth.type === "oauth") {
+            if (!isExpiringSoon(auth.access)) {
+                sessionAccessToken = auth.access;
+                return auth.access;
+            }
+            if (!auth.refresh)
+                return undefined;
+            try {
+                const newTokens = await refreshAccessToken(auth.refresh, apiBaseURL);
+                // Preserve optional OAuth fields (v2 Auth / plugin may carry these).
+                const extras = auth;
+                // Use the new token even if persisting back to OpenCode fails.
+                await persistAuthBestEffort({
+                    type: "oauth",
+                    access: newTokens.accessToken,
+                    refresh: newTokens.refreshToken,
+                    expires: decodeExpFromJwt(newTokens.accessToken),
+                    ...(extras.accountId !== undefined ? { accountId: extras.accountId } : {}),
+                    ...(extras.enterpriseUrl !== undefined ? { enterpriseUrl: extras.enterpriseUrl } : {}),
+                });
+                sessionAccessToken = newTokens.accessToken;
+                return newTokens.accessToken;
+            }
+            catch {
+                return undefined;
+            }
+        }
+        return undefined;
+    }
     async function loadModels() {
-        const cached = await readCache(configDir);
-        if (!cached || cached.models.length === 0)
+        const cached = await readCache(cacheDir);
+        if (!cached || cached.models.length === 0) {
+            // Config runs before auth.loader and has no getAuth(); read the durable
+            // store (normally the same source getAuth() uses).
+            const auth = await authFromStore();
+            if (auth) {
+                const accessToken = await resolveAccessToken(auth);
+                if (accessToken) {
+                    try {
+                        const models = await discoverModels(accessToken, cacheDir, { baseURL: apiBaseURL });
+                        return modelsToConfig(models);
+                    }
+                    catch {
+                        // discovery failed — leave the list empty
+                    }
+                }
+            }
             return {};
-        const models = {};
-        for (const m of cached.models) {
-            models[m.id] = modelInfoToConfig(m);
         }
-        return models;
+        return modelsToConfig(cached.models);
     }
     return {
         async config(cfg) {
@@ -115,7 +289,7 @@ export async function CursorPlugin(input) {
                         if (!apiKey)
                             return { type: "failed" };
                         try {
-                            const result = await exchangeApiKey(apiKey);
+                            const result = await exchangeApiKey(apiKey, apiBaseURL);
                             return {
                                 type: "success",
                                 key: result.accessToken,
@@ -130,60 +304,27 @@ export async function CursorPlugin(input) {
                 },
             ],
             async loader(getAuth) {
-                const auth = await getAuth();
-                if (!auth)
-                    return {};
-                let accessToken;
-                if (auth.type === "api") {
-                    accessToken = auth.key;
-                    const refreshToken = auth.metadata?.refreshToken;
-                    // API-key exchange returns a short-lived JWT stored as `key`. Refresh
-                    // it the same way as OAuth when it is expiring / already expired.
-                    if (refreshToken && isExpiringSoon(auth.key)) {
-                        try {
-                            const newTokens = await refreshAccessToken(refreshToken);
-                            await input.client.auth.set({
-                                path: { id: CURSOR_PROVIDER_ID },
-                                body: {
-                                    type: "api",
-                                    key: newTokens.accessToken,
-                                    metadata: { refreshToken: newTokens.refreshToken },
-                                },
-                            });
-                            accessToken = newTokens.accessToken;
-                        }
-                        catch {
-                            // refresh failed — keep the existing key; the next call may still work
-                        }
-                    }
-                }
-                else if (auth.type === "oauth") {
-                    if (!isExpiringSoon(auth.access)) {
-                        accessToken = auth.access;
-                    }
-                    else if (auth.refresh) {
-                        try {
-                            const newTokens = await refreshAccessToken(auth.refresh);
-                            await input.client.auth.set({
-                                path: { id: CURSOR_PROVIDER_ID },
-                                body: {
-                                    type: "oauth",
-                                    access: newTokens.accessToken,
-                                    refresh: newTokens.refreshToken,
-                                    expires: decodeExpFromJwt(newTokens.accessToken),
-                                },
-                            });
-                            accessToken = newTokens.accessToken;
-                        }
-                        catch {
-                            // refresh failed
-                        }
-                    }
-                }
+                const auth = await authForLoader(getAuth);
+                // Prefer credentials from getAuth/store; if refresh already succeeded in
+                // loadModels but persist failed, fall back to the in-memory session token.
+                const accessToken = (auth ? await resolveAccessToken(auth) : undefined) ?? sessionAccessToken;
                 if (accessToken) {
-                    // Use discoverModels so we respect TTL / serve-stale semantics and
-                    // write through the same cache path language-model reads.
-                    discoverModels(accessToken, configDir).catch(() => { });
+                    // Skip when config already filled a fresh cache (avoids a second
+                    // AvailableModels round-trip + background refresh on cold start).
+                    const cached = await readCache(cacheDir);
+                    if (!cached || cached.models.length === 0 || !isCacheFresh(cached)) {
+                        // Await so an empty/missing cache is written before the loader returns
+                        // (fire-and-forget often loses the race on short-lived CLI commands).
+                        await discoverModels(accessToken, cacheDir, { baseURL: apiBaseURL }).catch(() => { });
+                    }
+                    // Resolve the region-specific Run stream origin so the first turn
+                    // does not spend time on GetServerConfig. Best-effort: a failure is
+                    // surfaced by startSession, which can fail the actual model call with
+                    // a clear endpoint-resolution error instead of using global fallback.
+                    await resolveAgentUrl(accessToken, {
+                        apiBaseURL,
+                        telemetryEnabled: cursorGetServerConfigTelemetryEnabled(),
+                    }).catch(() => { });
                 }
                 return {
                     ...(accessToken ? { accessToken } : {}),

package/dist/protocol/client-version.js

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { FALLBACK_CLIENT_VERSION, MODEL_CACHE_TTL_MS, VERSION_CACHE_FILE, } from "../shared.js";
+import { opencodeGlobalCacheDir } from "../context/paths.js";
 const INSTALL_URL = "https://cursor.com/install";
 const REMOTE_TIMEOUT_MS = 5_000;
 const BUILD_RE = /^\d{4}\.\d{2}\.\d{2}-[0-9A-Za-z][0-9A-Za-z.-]*$/;
@@ -69,24 +70,11 @@ export function extractVersionFromInstaller(script) {
     const match = script.match(/downloads\.cursor\.com\/lab\/([^/"'\s]+)\//);
     return match && BUILD_RE.test(match[1]) ? match[1] : undefined;
 }
-function resolveCacheDir() {
-    if (process.env.CURSOR_CONFIG_DIR)
-        return process.env.CURSOR_CONFIG_DIR;
-    const home = process.env.HOME || process.env.USERPROFILE;
-    if (!home)
-        return undefined;
-    return process.env.XDG_CONFIG_HOME
-        ? path.join(process.env.XDG_CONFIG_HOME, "opencode")
-        : path.join(home, ".config", "opencode");
-}
 function versionCachePath() {
-    const dir = resolveCacheDir();
-    return dir ? path.join(dir, VERSION_CACHE_FILE) : undefined;
+    return path.join(opencodeGlobalCacheDir(), VERSION_CACHE_FILE);
 }
 function readVersionCache() {
     const file = versionCachePath();
-    if (!file)
-        return undefined;
     try {
         const value = JSON.parse(fs.readFileSync(file, "utf8"));
         if (!isClientVersion(value.version) ||
@@ -102,8 +90,6 @@ function readVersionCache() {
 }
 function writeVersionCache(cache) {
     const file = versionCachePath();
-    if (!file)
-        return;
     try {
         fs.mkdirSync(path.dirname(file), { recursive: true });
         fs.writeFileSync(file, JSON.stringify(cache, null, 2));

package/dist/shared.d.ts

@@ -1,4 +1,3 @@
-export declare const CURSOR_AGENT_HOST = "agentn.global.api5.cursor.sh";
 export declare const CURSOR_API_HOST = "api2.cursor.sh";
 export declare const CURSOR_WEBSITE_HOST = "cursor.com";
 export declare const FALLBACK_CLIENT_VERSION = "cli-2026.07.09-a3815c0";
@@ -6,6 +5,7 @@ export declare const CURSOR_PROVIDER_ID = "cursor";
 export declare const TOKEN_EXPIRY_THRESHOLD_S = 300;
 export declare const RUN_PATH = "/agent.v1.AgentService/Run";
 export declare const AVAILABLE_MODELS_PATH = "/aiserver.v1.AiService/AvailableModels";
+export declare const SERVER_CONFIG_PATH = "/aiserver.v1.ServerConfigService/GetServerConfig";
 export declare const MODEL_CACHE_FILE = "cursor-models.json";
 export declare const MODEL_CACHE_TTL_MS = 86400000;
 export declare const VERSION_CACHE_FILE = "cursor-client-version.json";

package/dist/shared.js

@@ -1,4 +1,3 @@
-export const CURSOR_AGENT_HOST = "agentn.global.api5.cursor.sh";
 export const CURSOR_API_HOST = "api2.cursor.sh";
 export const CURSOR_WEBSITE_HOST = "cursor.com";
 export const FALLBACK_CLIENT_VERSION = "cli-2026.07.09-a3815c0";
@@ -6,6 +5,7 @@ export const CURSOR_PROVIDER_ID = "cursor";
 export const TOKEN_EXPIRY_THRESHOLD_S = 300;
 export const RUN_PATH = "/agent.v1.AgentService/Run";
 export const AVAILABLE_MODELS_PATH = "/aiserver.v1.AiService/AvailableModels";
+export const SERVER_CONFIG_PATH = "/aiserver.v1.ServerConfigService/GetServerConfig";
 export const MODEL_CACHE_FILE = "cursor-models.json";
 export const MODEL_CACHE_TTL_MS = 86_400_000;
 export const VERSION_CACHE_FILE = "cursor-client-version.json";

package/dist/transport/connect.d.ts

@@ -1,9 +1,35 @@
 export declare function trace(msg: string): void;
 export declare function buildBaseHeaders(token: string, clientVersion: string, extra?: Record<string, string>): Record<string, string>;
 export declare function unaryAvailableModels(token: string, options?: {
+    apiBaseURL?: string;
     baseURL?: string;
     headers?: Record<string, string>;
 }): Promise<Record<string, unknown>>;
+/**
+ * Cursor Run stream hosts from GetServerConfig / agentBaseURL.
+ * Any HTTPS subdomain of cursor.sh is accepted — hostnames vary
+ * (agentn.*, agent.*, agent-gcpp-*, api5 / api5lat, …) and may change.
+ */
+export declare function isAllowedAgentHost(hostname: string): boolean;
+/**
+ * Normalize a GetServerConfig agent URL to an https origin.
+ * Returns null for missing, malformed, non-https, or non-*.cursor.sh hosts.
+ */
+export declare function normalizeAgentRunOrigin(raw: string | undefined): string | null;
+/**
+ * Fetch the Cursor server config (a Connect unary RPC on the API host) and
+ * return the `agentUrlConfig.agentnUrl` field — the region-specific Run stream
+ * origin the server routes this account/team to (e.g. `agentn.us.api5.cursor.sh`).
+ *
+ * Region-routed accounts can be silently rejected by the wrong regional host, so
+ * this lookup fails closed instead of substituting any host on error. Any
+ * authoritative `*.cursor.sh` origin from GetServerConfig is accepted.
+ */
+export declare function fetchAgentUrl(token: string, options?: {
+    apiBaseURL?: string;
+    baseURL?: string;
+    telemetryEnabled?: boolean;
+}): Promise<string>;
 export type BidiStream = {
     write(msg: Uint8Array): void;
     end(): void;
@@ -14,10 +40,10 @@ export type BidiStream = {
     destroy(): void;
 };
 /** Resolve the HTTP/2 connect origin for a Run stream (exported for tests). */
-export declare function resolveAgentOrigin(baseURL?: string): string;
-export declare function bidiRunStream(token: string, options?: {
+export declare function resolveAgentOrigin(baseURL: string): string;
+export declare function bidiRunStream(token: string, options: {
     signal?: AbortSignal;
-    baseURL?: string;
+    baseURL: string;
     headers?: Record<string, string>;
 }): Promise<BidiStream>;
 export declare function makeRequestId(): string;

package/dist/transport/connect.js

@@ -1,4 +1,4 @@
-import { CURSOR_API_HOST, CURSOR_AGENT_HOST, CONNECT_PROTOCOL_VERSION } from "../shared.js";
+import { CURSOR_API_HOST, CONNECT_PROTOCOL_VERSION, SERVER_CONFIG_PATH } from "../shared.js";
 import { encodeFrame, streamFrames } from "../protocol/framing.js";
 import { createCursorChecksumHeader } from "../protocol/checksum.js";
 import { getDeviceIds } from "../protocol/device-id.js";
@@ -6,7 +6,9 @@ import { resolveClientVersion } from "../protocol/client-version.js";
 import http2 from "node:http2";
 import fs from "node:fs";
 const API_BASE = `https://${CURSOR_API_HOST}`;
-const AGENT = CURSOR_AGENT_HOST;
+function resolveApiBaseURL(options) {
+    return new URL(options.apiBaseURL ?? options.baseURL ?? API_BASE).origin;
+}
 // Wire-level diagnostics. Opt in with CURSOR_PROVIDER_DEBUG=1 (or "true").
 // Writes to CURSOR_PROVIDER_DEBUG_FILE (default /tmp/cursor-provider-debug.log).
 // Truncated once per process. Captures h2 response status, parsed frames, and
@@ -43,7 +45,7 @@ export function buildBaseHeaders(token, clientVersion, extra) {
 }
 // ── Unary (AvailableModels) ──
 export async function unaryAvailableModels(token, options = {}) {
-    const base = options.baseURL ?? API_BASE;
+    const base = resolveApiBaseURL(options);
     const url = `${base}/aiserver.v1.AiService/AvailableModels`;
     const clientVersion = await resolveClientVersion();
     const headers = buildBaseHeaders(token, clientVersion, options.headers);
@@ -62,6 +64,82 @@ export async function unaryAvailableModels(token, options = {}) {
     }
     return (await res.json());
 }
+// ── Unary (GetServerConfig) ──
+/**
+ * Cursor Run stream hosts from GetServerConfig / agentBaseURL.
+ * Any HTTPS subdomain of cursor.sh is accepted — hostnames vary
+ * (agentn.*, agent.*, agent-gcpp-*, api5 / api5lat, …) and may change.
+ */
+export function isAllowedAgentHost(hostname) {
+    return /^([a-z0-9-]+\.)+cursor\.sh$/i.test(hostname);
+}
+/**
+ * Normalize a GetServerConfig agent URL to an https origin.
+ * Returns null for missing, malformed, non-https, or non-*.cursor.sh hosts.
+ */
+export function normalizeAgentRunOrigin(raw) {
+    if (raw === undefined || raw === null)
+        return null;
+    const trimmed = String(raw).trim();
+    if (!trimmed)
+        return null;
+    try {
+        const withScheme = /^https?:\/\//i.test(trimmed) ? trimmed : `https://${trimmed}`;
+        const parsed = new URL(withScheme);
+        if (parsed.protocol !== "https:")
+            return null;
+        if (parsed.username || parsed.password)
+            return null;
+        if (!isAllowedAgentHost(parsed.hostname))
+            return null;
+        return parsed.origin;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Fetch the Cursor server config (a Connect unary RPC on the API host) and
+ * return the `agentUrlConfig.agentnUrl` field — the region-specific Run stream
+ * origin the server routes this account/team to (e.g. `agentn.us.api5.cursor.sh`).
+ *
+ * Region-routed accounts can be silently rejected by the wrong regional host, so
+ * this lookup fails closed instead of substituting any host on error. Any
+ * authoritative `*.cursor.sh` origin from GetServerConfig is accepted.
+ */
+export async function fetchAgentUrl(token, options = {}) {
+    const base = resolveApiBaseURL(options);
+    const url = `${base}${SERVER_CONFIG_PATH}`;
+    const clientVersion = await resolveClientVersion();
+    // Match Cursor CLI: GetServerConfig uses base headers only — session headers belong on Run.
+    const headers = buildBaseHeaders(token, clientVersion);
+    trace(`GetServerConfig POST ${url}`);
+    const res = await fetch(url, {
+        method: "POST",
+        headers: {
+            ...headers,
+            "content-type": "application/json",
+            accept: "application/json",
+        },
+        body: JSON.stringify({ telem_enabled: options.telemetryEnabled ?? false }),
+    });
+    if (!res.ok) {
+        const text = await res.text().catch(() => "");
+        throw new Error(`GetServerConfig failed: ${res.status} ${res.statusText}${text ? ` - ${text.slice(0, 200)}` : ""}`);
+    }
+    const body = (await res.json());
+    const cfg = body.agentUrlConfig;
+    const raw = cfg?.agentnUrl || cfg?.agentUrl;
+    const normalized = normalizeAgentRunOrigin(raw);
+    trace(`GetServerConfig reply: agentnUrl=${cfg?.agentnUrl ?? "<missing>"} ` +
+        `agentUrl=${cfg?.agentUrl ?? "<missing>"} → ${normalized ?? "<invalid>"}`);
+    if (!normalized) {
+        throw new Error(raw
+            ? "GetServerConfig returned an invalid Cursor agent URL"
+            : "GetServerConfig response missing agentUrlConfig.agentnUrl");
+    }
+    return normalized;
+}
 // Cache http2 sessions keyed by origin so a custom baseURL never reuses a
 // connection opened to the default agent host — and vice versa.
 const _http2Sessions = new Map();
@@ -73,8 +151,11 @@ const _http2Connecting = new Map();
 const CONNECT_TIMEOUT_MS = 15_000;
 /** Resolve the HTTP/2 connect origin for a Run stream (exported for tests). */
 export function resolveAgentOrigin(baseURL) {
-    // baseURL may be https://host or https://host:port — http2.connect accepts both.
-    return (baseURL ? new URL(baseURL) : new URL(`https://${AGENT}`)).origin;
+    const origin = normalizeAgentRunOrigin(baseURL);
+    if (!origin) {
+        throw new Error("Cursor Run stream requires an allowlisted Cursor agent base URL");
+    }
+    return origin;
 }
 function dropSession(origin, session) {
     if (_http2Sessions.get(origin) === session)
@@ -133,7 +214,7 @@ function getSession(baseURL) {
     _http2Connecting.set(origin, promise);
     return promise;
 }
-export async function bidiRunStream(token, options = {}) {
+export async function bidiRunStream(token, options) {
     const [session, clientVersion] = await Promise.all([
         getSession(options.baseURL),
         resolveClientVersion(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cursor-opencode-provider",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Use Cursor subscription models from OpenCode via Cursor's Connect-RPC agent protocol",
   "type": "module",
   "license": "MIT",