@vidit19sharma/opencode-cursor-auth 0.1.0 → 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,32 @@
+# Changelog
+
+All notable changes to this project are documented here. The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
+
+## 0.2.0 — 2026-10-16
+
+### Added
+
+- Model variants: every variant Cursor publishes (reasoning effort, fast, 1M context) is a selectable id, e.g. `cursor/gpt-5.5-low-fast`, `cursor/claude-opus-5-5-1m-max`. Ids are the base id plus non-default param values and map back to Cursor `ModelSelection` params; unknown ids still pass through to Cursor's own 400.
+- Model context limits: each model gets `limit.context` from Cursor's `context` parameter (default 200k) and `limit.output` 32k. Without a limit opencode 1.19 sets context to 0 and silently disables auto-compaction and the context indicator.
+- SDK key check on `/chat/completions` (60s cache, skipped for pasted/env keys): a missing or expired key returns 401 telling the user to run `opencode auth login`; one-time stderr warning within 7 days of expiry.
+- Concurrency cap: a FIFO semaphore limits concurrently active Cursor runs (default 4, `OPENCODE_CURSOR_MAX_ACTIVE` to override). Extra requests queue; tool-result continuations never take a slot.
+- Retry: `Agent.create` / `Agent.resume` / `send` are attempted up to 3 times with jittered backoff on 429, 5xx, and network errors; never after the first byte.
+- Usage reports cache-read tokens (`prompt_tokens_details.cached_tokens`) and reasoning tokens (`completion_tokens_details.reasoning_tokens`).
+
+### Changed
+
+- Models cache bumped to v3 `{name, context, params}`; older cache files are refetched once. Catalog code moved to `src/models.ts`.
+- The reply is opened only on content deltas (text/thinking), so run errors before any content become real JSON error responses instead of a 200 stream with an error frame.
+
+### Fixed
+
+- Real HTTP error statuses: failures before the first byte return a JSON error with a real status (400 bad model/argument, 401 auth, 403 blocked, 429 rate limit, 502 otherwise); mid-stream failures emit an OpenAI error frame and close without `[DONE]`.
+- Admin-blocked models: "Model Blocked" / `permission_denied` map to 403 `permission_error` and are never retried. A 403 marks the model and its variants blocked in the models cache; they are hidden from the model list until the next 24h catalog refresh and still resolve if used explicitly.
+- Abort propagation: the request AbortSignal and stream `cancel()` cancel the Cursor run, close the agent, and release registries (no more zombie runs burning usage).
+- agentId race: the held run is registered before `send()`, so a tool call firing immediately can never miss its continuation lookup.
+- Session resume is scoped by opencode session id (via the `chat.headers` hook), so byte-identical histories from different sessions (parallel sub-agents) never resume each other's Cursor agent. Unscoped callers and existing disk entries hash exactly as before.
+- Per-session temp workspaces are removed once no session, disk, or held entry references them.
+
+## 0.1.0 — 2026-10-15
+
+- Initial release: in-process Cursor SDK bridge, auth, tool loop, session resume, AGENTS.md system prompt, dynamic model list.

package/README.md

@@ -10,9 +10,14 @@ The plugin bridges opencode's OpenAI-style chat requests to the official [`@curs
 - **In-process bridge** — no local HTTP proxy, no port to collide on, no extra daemon
 - **Full tool loop** — opencode's native tools (read, edit, bash, MCP, …) work end-to-end via a held-run bridge: one Cursor run spans the whole tool exchange
 - **Thinking blocks** — Cursor reasoning streams into opencode as proper thinking blocks (`reasoning_content`)
-- **Session resume** — conversations map to native Cursor agents (`Agent.resume`), in-memory and persisted to disk for 7 days, so multi-turn chats don't replay history
+- **Session resume** — conversations map to native Cursor agents (`Agent.resume`), in-memory and persisted to disk for 7 days, scoped per opencode session so parallel sub-agents never share an agent
 - **System prompts** — delivered via `AGENTS.md` in a per-session workspace (the `--system-prompt` flag is server-gated by Cursor)
-- **Dynamic model list** — fetched live from `Cursor.models.list()`, cached 24h
+- **Dynamic model list with variants** — fetched live from `Cursor.models.list()`, cached 24h; every reasoning-effort / fast / 1M-context variant is its own model id
+- **Context limits** — each model publishes its Cursor context window, so opencode's auto-compaction and context indicator work
+- **Real error statuses** — 400 / 401 / 403 / 429 / 502 instead of a 200 stream carrying an error
+- **Cancellation** — Esc or a sub-agent timeout cancels the Cursor run and closes the agent
+- **Concurrency cap and retry** — at most 4 Cursor runs at once (configurable); transient failures retried before the first byte
+- **Usage** — prompt, completion, cached-read, and reasoning tokens reported to opencode
 - **Zero cost display** — models are marked cost-free since you're on subscription billing
 
 ## Requirements
@@ -46,6 +51,8 @@ Pick **Cursor**, then either:
 
 Alternatively set `CURSOR_API_KEY` in your environment.
 
+When the browser-login key is used, the plugin checks it before each request (cached 60s): a missing or expired key returns a 401 telling you to run `opencode auth login`, and a one-time warning is printed to stderr within 7 days of expiry. The check is skipped for pasted keys and `CURSOR_API_KEY`.
+
 ## Use
 
 ```sh
@@ -56,6 +63,35 @@ opencode run -m cursor/auto "hello"
 
 Or pick any `cursor/*` model from the opencode model selector.
 
+## Models
+
+```sh
+opencode models | grep cursor/
+```
+
+- **Base ids** (`cursor/gpt-5.5`) send no parameters, so Cursor applies its own defaults. Cursor's `default` model is exposed as `cursor/auto`.
+- **Variant ids** are the base id plus every non-default parameter value, in Cursor's parameter order. Boolean parameters use the parameter name. Examples: `cursor/gpt-5.5-low`, `cursor/gpt-5.5-high-fast`, `cursor/gpt-5.5-1m-extra-high`, `cursor/claude-opus-5-5-1m-max`.
+- The full catalog is currently about 485 ids from 47 models.
+- **Limits**: `limit.context` is the variant's context value, else the model's first listed context value, else 200k. `limit.output` is a fixed 32k accounting reserve (Cursor publishes no output cap and the bridge sends no `max_tokens`). Limits you set yourself in opencode config are kept.
+- **Unknown ids** are passed through to Cursor, which answers with its own 400.
+- **Blocked models**: Cursor's catalog has no per-account entitlement info. If Cursor rejects a model as "Model Blocked" (e.g. a team admin disabled it), the request fails with 403 `permission_error` carrying Cursor's message, and that model and all its variants are hidden from the list. Using a hidden id explicitly still sends it to Cursor. Blocked flags persist across catalog refreshes; delete `~/.cache/opencode-cursor-auth/models.json` to re-check.
+- **Offline / logged out**: the stale cache is used if present, otherwise only `cursor/auto`.
+
+The catalog is cached at `~/.cache/opencode-cursor-auth/models.json`; delete it to force a refresh.
+
+## Configuration
+
+| Setting | Default | Purpose |
+| --- | --- | --- |
+| `OPENCODE_CURSOR_MAX_ACTIVE` | `4` | Max Cursor runs active at once; extra requests queue FIFO |
+| `CURSOR_API_KEY` | unset | Use this key instead of the stored SDK key |
+
+| Path | Contents |
+| --- | --- |
+| `~/.cursor/sdk/auth.json` | 90-day SDK key from browser login (written by `@cursor/sdk`) |
+| `~/.cache/opencode-cursor-auth/models.json` | Model catalog, 24h TTL, blocked-model flags |
+| `~/.cache/opencode-cursor-auth/sessions.json` | Conversation → Cursor agent map, 7-day TTL |
+
 ## How it works
 
 ```
@@ -65,25 +101,43 @@ opencode ──(OpenAI chat JSON)──> plugin fetch() ──> @cursor/sdk Agen
 
 - opencode calls the provider's `fetch` — the plugin intercepts it in-process; `http://cursor.local/v1` is a dummy URL that never resolves.
 - Each opencode tool is registered as a Cursor **custom tool** whose `execute()` parks a promise, emits an OpenAI `tool_calls` chunk, and resumes the *same* Cursor run when opencode sends the tool result back.
-- Conversation prefixes are hashed → mapped to Cursor agent IDs, so follow-up turns use `Agent.resume` instead of replaying history. The map persists at `~/.cache/opencode-cursor-auth/sessions.json`.
-- System messages are written to `AGENTS.md` in a per-session temp workspace and loaded via Cursor's project rules (`settingSources: ["project"]`).
+- Conversation prefixes, plus the opencode session id (sent via the `chat.headers` hook), are hashed → mapped to Cursor agent IDs, so follow-up turns use `Agent.resume` instead of replaying history. The map persists at `~/.cache/opencode-cursor-auth/sessions.json`.
+- System messages are written to `AGENTS.md` in a per-session temp workspace and loaded via Cursor's project rules (`settingSources: ["project"]`). Workspaces are removed once no session references them.
+- Variant ids are mapped back to Cursor `ModelSelection` params (`{ id, params }`).
+- New turns take a slot from a FIFO semaphore (`OPENCODE_CURSOR_MAX_ACTIVE`); tool-result continuations reuse their run's slot. `Agent.create` / `Agent.resume` / `send` are attempted up to 3 times with jittered exponential backoff on 429, 5xx, and network errors, never after the first byte.
+- The HTTP reply opens on the first text or thinking delta, so failures before any content become real HTTP errors.
+- The request's abort signal and stream cancel cancel the Cursor run, close the agent, and release its slot.
+
+### Errors
+
+| Status | When |
+| --- | --- |
+| 400 | Unknown model or bad argument (Cursor's message); also an expired tool-call continuation |
+| 401 | SDK key missing/expired, or Cursor rejects the key |
+| 403 | Model blocked for your account (`permission_error`) |
+| 429 | Cursor rate limit |
+| 502 | Anything else |
+
+These are JSON error responses when the failure happens before the first byte; mid-stream failures emit an SSE `error` frame and close the stream without `[DONE]`.
 
 ## Development
 
 ```sh
 bun install
 bun run build        # tsc → dist/
-bun run test         # end-to-end bridge tests (requires Cursor login)
+bun run test         # end-to-end bridge tests (requires Cursor login, uses real Cursor usage)
 bun run spike        # raw @cursor/sdk validation
 ```
 
-The test suite exercises: plain streaming, a full tool loop on one held run, in-memory session resume, AGENTS.md system-prompt delivery, and disk-persisted resume.
+The test suite runs 13 scenarios: plain streaming, a full tool loop on one held run, in-memory and disk-persisted session resume, AGENTS.md system-prompt delivery, mid-stream abort, error statuses, session scoping, context limits and key checks, model variants, the concurrency cap, retry semantics, and blocked models.
 
 ## Known limitations
 
-- `systemPrompt` as a true harness replacement is feature-gated server-side by Cursor; system text is applied as a project rule (merged under Cursor's harness prompt).
+- `systemPrompt` as a true harness replacement is feature-gated server-side by Cursor; system text is applied via `AGENTS.md` as a project rule (merged under Cursor's harness prompt).
 - The SDK spawns a `cursor-agent` worker per turn (~1–2 s startup on resume).
-- Usage/rate limits are whatever your Cursor plan enforces — the plugin adds none.
+- The model list is Cursor's full catalog (~485 ids). It has no entitlement info, so models your plan or team blocks only disappear after the first 403.
+- A run parked waiting for a tool result keeps its slot. Cursor-model sessions that spawn Cursor-model sub-agents nested deeper than `OPENCODE_CURSOR_MAX_ACTIVE` will stall; raise the limit if you fan out.
+- Usage/rate limits are whatever your Cursor plan enforces — the plugin adds none beyond the concurrency cap.
 
 ## License
 

package/dist/bridge.d.ts

@@ -28,6 +28,18 @@ type OaBody = {
     tools?: OaTool[];
     stream?: boolean;
 };
+export declare function isTransient(err: unknown): boolean;
+export declare function withRetry<T>(fn: () => Promise<T>, signal?: AbortSignal, baseDelayMs?: number, retryable?: typeof isTransient): Promise<T>;
+export declare function _setMaxActive(n: number): void;
+export declare function errorResponse(err: unknown, status?: number): Response;
 export declare function _resetForTest(): void;
-export declare function handleChatCompletion(body: OaBody, apiKey?: string): Promise<Response>;
+export declare function _stats(): {
+    held: number;
+    sessions: number;
+    disk: number;
+    agentIds: string[];
+    active: number;
+    waiting: number;
+};
+export declare function handleChatCompletion(body: OaBody, apiKey?: string, signal?: AbortSignal, scope?: string): Promise<Response>;
 export {};

package/dist/bridge.js

@@ -8,12 +8,13 @@
  * next HTTP request (role:"tool" messages) resolves the parked promises and
  * the SAME run continues — one metered Cursor run per opencode tool loop.
  */
-import { Agent } from "@cursor/sdk";
+import { Agent, AuthenticationError, ConfigurationError, NetworkError, RateLimitError } from "@cursor/sdk";
 import { createHash, randomUUID } from "node:crypto";
 import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { mkdtemp, readFile, writeFile } from "node:fs/promises";
 import { homedir, tmpdir } from "node:os";
 import { join } from "node:path";
+import { markBlocked, resolveModel } from "./models.js";
 // @cursor/sdk's internal logger writes "HH:MM:SS.mmm INFO ..." lines via
 // console.log unconditionally (no config/env to silence it, verified against
 // the esm bundle). Filter exactly those lines, pass everything else through.
@@ -31,6 +32,111 @@ function textOf(content) {
         return "";
     return content.map((p) => p.text ?? "").join("");
 }
+function statusFor(err) {
+    const e = (typeof err === "object" && err !== null ? err : {});
+    const msg = String(e.message ?? err ?? "");
+    const code = typeof e.code === "string" ? e.code : "";
+    if (err instanceof AuthenticationError || e.status === 401 || code === "unauthenticated" || /invalid user api key/i.test(msg))
+        return 401;
+    if (err instanceof RateLimitError || e.status === 429 || code === "resource_exhausted" || /rate limit/i.test(msg))
+        return 429;
+    if (code === "permission_denied" || /model blocked|permission denied|forbidden/i.test(msg))
+        return 403;
+    if (err instanceof ConfigurationError || code === "invalid_argument" || code === "not_found" || /cannot use this model|unknown model/i.test(msg))
+        return 400;
+    return 502;
+}
+const ERROR_TYPE = {
+    400: "invalid_request_error",
+    401: "authentication_error",
+    403: "permission_error",
+    429: "rate_limit_error",
+};
+function errorBody(err, status = statusFor(err)) {
+    const e = (typeof err === "object" && err !== null ? err : {});
+    return {
+        error: {
+            message: String(e.message ?? err ?? "unknown error"),
+            type: ERROR_TYPE[status] ?? "api_error",
+            ...(typeof e.code === "string" ? { code: e.code } : {}),
+        },
+    };
+}
+const abortError = () => new DOMException("aborted", "AbortError");
+export function isTransient(err) {
+    const e = (typeof err === "object" && err !== null ? err : {});
+    if (e.name === "AbortError")
+        return false;
+    const status = statusFor(err);
+    if (status === 429)
+        return true;
+    if (status === 400 || status === 401 || status === 403 || e.status === 404)
+        return false;
+    if (err instanceof NetworkError || (typeof e.status === "number" && e.status >= 500))
+        return true;
+    return /unavailable|deadline_exceeded|ECONNRESET|ETIMEDOUT|fetch failed/i.test(`${e.code ?? ""} ${e.message ?? ""}`);
+}
+export async function withRetry(fn, signal, baseDelayMs = 1000, retryable = isTransient) {
+    for (let attempt = 0;; attempt++) {
+        if (signal?.aborted)
+            throw abortError();
+        try {
+            return await fn();
+        }
+        catch (err) {
+            if (attempt >= 2 || signal?.aborted || !retryable(err))
+                throw err;
+            const delay = Math.min(baseDelayMs * 2 ** attempt * (0.75 + Math.random() * 0.5), 30_000);
+            await new Promise((r) => {
+                const t = setTimeout(r, delay);
+                signal?.addEventListener("abort", () => (clearTimeout(t), r(undefined)), { once: true });
+            });
+        }
+    }
+}
+// ponytail: global semaphore, slot held across parked tool loops; per-session fairness if it ever matters
+let maxActive = Number(process.env.OPENCODE_CURSOR_MAX_ACTIVE) || 4;
+let active = 0;
+const waiters = [];
+function pump() {
+    while (active < maxActive && waiters.length) {
+        active++;
+        waiters.shift()();
+    }
+}
+function acquireSlot(signal) {
+    if (signal?.aborted)
+        return Promise.reject(abortError());
+    if (active < maxActive && !waiters.length) {
+        active++;
+        return Promise.resolve();
+    }
+    return new Promise((resolve, reject) => {
+        const onAbort = () => {
+            const i = waiters.indexOf(go);
+            if (i >= 0)
+                waiters.splice(i, 1);
+            reject(abortError());
+        };
+        const go = () => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve();
+        };
+        signal?.addEventListener("abort", onAbort, { once: true });
+        waiters.push(go);
+    });
+}
+function releaseSlot() {
+    active--;
+    pump();
+}
+export function _setMaxActive(n) {
+    maxActive = n;
+    pump();
+}
+export function errorResponse(err, status = statusFor(err)) {
+    return Response.json(errorBody(err, status), { status });
+}
 function chunk(id, model, delta, finish, usage) {
     return {
         id,
@@ -41,7 +147,7 @@ function chunk(id, model, delta, finish, usage) {
         ...(usage ? { usage } : {}),
     };
 }
-function sseResponse(model) {
+function sseResponse(model, onCancel) {
     const id = `chatcmpl-${randomUUID()}`;
     const enc = new TextEncoder();
     let controller;
@@ -53,19 +159,31 @@ function sseResponse(model) {
         },
         cancel() {
             closed = true;
+            onCancel();
         },
     });
+    function frame(payload) {
+        if (closed)
+            return;
+        controller.enqueue(enc.encode(`data: ${JSON.stringify(payload)}\n\n`));
+    }
     function send(delta, finish = null, usage) {
+        frame(chunk(id, model, delta, finish, usage));
+    }
+    function close() {
         if (closed)
             return;
-        controller.enqueue(enc.encode(`data: ${JSON.stringify(chunk(id, model, delta, finish, usage))}\n\n`));
+        closed = true;
+        try {
+            controller.close();
+        }
+        catch { }
     }
     function end() {
         if (closed)
             return;
         controller.enqueue(enc.encode("data: [DONE]\n\n"));
-        controller.close();
-        closed = true;
+        close();
     }
     const sink = {
         text: (t) => send({ content: t }),
@@ -83,10 +201,10 @@ function sseResponse(model) {
             end();
         },
         fail: (err) => {
-            send({ content: `\n\n[cursor error] ${err instanceof Error ? err.message : String(err)}` });
-            send({}, "stop");
-            end();
+            frame(errorBody(err));
+            close();
         },
+        close,
     };
     return {
         response: new Response(stream, {
@@ -96,13 +214,11 @@ function sseResponse(model) {
         sink,
     };
 }
-function jsonCollector(model) {
+function jsonCollector(model, resolve) {
     const id = `chatcmpl-${randomUUID()}`;
     let content = "";
     let calls = [];
-    let resolve;
-    const promise = new Promise((r) => (resolve = r));
-    const sink = {
+    return {
         text: (t) => (content += t),
         reasoning: () => { },
         toolCalls: (c) => (calls = calls.concat(c)),
@@ -132,9 +248,18 @@ function jsonCollector(model) {
             ],
             usage: usage ?? { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
         })),
-        fail: (err) => resolve(Response.json({ error: { message: err instanceof Error ? err.message : String(err), type: "cursor_error" } }, { status: 500 })),
+        fail: (err) => resolve(errorResponse(err)),
+        close: () => { },
     };
-    return { promise, sink };
+}
+function deferred() {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+    });
+    return { promise, resolve, reject };
 }
 const BATCH_SETTLE_MS = 300;
 const TOOL_RESULT_TIMEOUT_MS = 10 * 60 * 1000;
@@ -144,13 +269,33 @@ const DISK_SESSION_TTL_MS = 7 * 24 * 60 * 60 * 1000;
 const MAX_SESSIONS = 8;
 const SESSION_STORE_DIR = join(homedir(), ".cache", "opencode-cursor-auth");
 const SESSION_STORE_PATH = join(SESSION_STORE_DIR, "sessions.json");
+const TMP_CWD_PREFIX = join(tmpdir(), "opencode-cursor-");
 const sessions = new Map();
 const heldByAgent = new Map();
 const agentByToolCallId = new Map();
 let diskSessions = new Map();
 let sessionsLoaded = false;
-function hashMessages(messages) {
+// ponytail: no orphan sweep, other opencode instances may own those dirs
+function releaseCwd(cwd) {
+    if (!cwd.startsWith(TMP_CWD_PREFIX))
+        return;
+    for (const v of sessions.values())
+        if (v.cwd === cwd)
+            return;
+    for (const v of diskSessions.values())
+        if (v.cwd === cwd)
+            return;
+    for (const h of heldByAgent.values())
+        if (h.cwd === cwd)
+            return;
+    rmSync(cwd, { recursive: true, force: true });
+}
+// scope (opencode session id) is folded in so identical histories from
+// different sessions (e.g. parallel sub-agents) never share a Cursor agent
+function hashMessages(messages, scope) {
     const norm = messages.map((m) => [m.role, textOf(m.content), m.tool_call_id ?? "", JSON.stringify(m.tool_calls ?? null)]);
+    if (scope)
+        norm.unshift(["scope", scope]);
     return createHash("sha256").update(JSON.stringify(norm)).digest("hex");
 }
 function collectDiskEntries() {
@@ -176,6 +321,9 @@ async function loadSessions() {
             if (now - v.lastUsedAt <= DISK_SESSION_TTL_MS)
                 diskSessions.set(k, v);
         }
+        for (const v of Object.values(raw.entries))
+            if (now - v.lastUsedAt > DISK_SESSION_TTL_MS)
+                releaseCwd(v.cwd);
     }
     catch { }
 }
@@ -185,9 +333,17 @@ function saveSessions() {
 }
 function sweepSessions(save = true) {
     const now = Date.now();
+    const evicted = [];
+    for (const [k, v] of diskSessions)
+        if (now - v.lastUsedAt > DISK_SESSION_TTL_MS) {
+            diskSessions.delete(k);
+            evicted.push(v.cwd);
+        }
     for (const [k, v] of sessions)
-        if (now - v.lastUsedAt > SESSION_TTL_MS)
+        if (now - v.lastUsedAt > SESSION_TTL_MS) {
             sessions.delete(k);
+            evicted.push(v.cwd);
+        }
     while (sessions.size > MAX_SESSIONS) {
         let oldestKey = "";
         let oldest = Infinity;
@@ -196,8 +352,11 @@ function sweepSessions(save = true) {
                 oldest = v.lastUsedAt;
                 oldestKey = k;
             }
+        evicted.push(sessions.get(oldestKey).cwd);
         sessions.delete(oldestKey);
     }
+    for (const cwd of evicted)
+        releaseCwd(cwd);
     if (save)
         saveSessions();
 }
@@ -214,15 +373,18 @@ function rememberSession(held, toolCalls) {
             ? { tool_calls: toolCalls.map((c) => ({ id: c.id, function: { name: c.name, arguments: c.argumentsJson } })) }
             : {}),
     };
-    const key = hashMessages(held.messages.concat(assistant));
+    const key = hashMessages(held.messages.concat(assistant), held.scope);
     const entry = {
         agentId: held.agent.agentId,
         cwd: held.cwd,
         lastUsedAt: Date.now(),
     };
+    const displaced = sessions.get(key) ?? diskSessions.get(key);
     sessions.set(key, entry);
     diskSessions.set(key, entry);
     sweepSessions();
+    if (displaced && displaced.cwd !== entry.cwd)
+        releaseCwd(displaced.cwd);
 }
 async function syncAgentsMd(cwd, messages) {
     mkdirSync(cwd, { recursive: true });
@@ -242,7 +404,12 @@ function mapUsage(u) {
         return undefined;
     const prompt = u.inputTokens ?? 0;
     const completion = u.outputTokens ?? 0;
-    return { prompt_tokens: prompt, completion_tokens: completion, total_tokens: prompt + completion };
+    const usage = { prompt_tokens: prompt, completion_tokens: completion, total_tokens: prompt + completion };
+    if (u.cacheReadTokens)
+        usage.prompt_tokens_details = { cached_tokens: u.cacheReadTokens };
+    if (u.reasoningTokens)
+        usage.completion_tokens_details = { reasoning_tokens: u.reasoningTokens };
+    return usage;
 }
 // deltas arriving between tool flush and the continuation request get buffered
 function emit(held, kind, t) {
@@ -251,73 +418,124 @@ function emit(held, kind, t) {
     else
         held.buffer.push({ kind, t });
 }
+function openReply(held) {
+    if (held.opened)
+        return;
+    held.opened = true;
+    if (held.response)
+        held.reply.resolve(held.response);
+}
 function attachSink(held, sink) {
     held.sink = sink;
+    if (held.buffer.length)
+        openReply(held);
     for (const b of held.buffer)
         (b.kind === "text" ? sink.text : sink.reasoning)(b.t);
     held.buffer = [];
 }
-function teardownHeld(agentId, held) {
+function attachSignal(held, signal) {
+    held.detachSignal?.();
+    held.detachSignal = null;
+    if (!signal)
+        return;
+    const onAbort = () => abortHeld(held);
+    signal.addEventListener("abort", onAbort, { once: true });
+    held.detachSignal = () => signal.removeEventListener("abort", onAbort);
+}
+function closeAgent(held) {
+    try {
+        held.agent.close();
+    }
+    catch { }
+}
+function teardownHeld(held) {
     held.done = true;
+    if (held.slot) {
+        held.slot = false;
+        releaseSlot();
+    }
+    held.detachSignal?.();
+    held.detachSignal = null;
     if (held.flushTimer)
         clearTimeout(held.flushTimer);
     if (held.idleTimer)
         clearTimeout(held.idleTimer);
     for (const id of held.parked.keys())
         agentByToolCallId.delete(id);
-    heldByAgent.delete(agentId);
+    heldByAgent.delete(held.agent.agentId);
+}
+function failHeld(held, err) {
+    teardownHeld(held);
+    if (statusFor(err) === 403)
+        markBlocked(held.model);
+    if (held.response && !held.opened) {
+        held.opened = true;
+        held.reply.resolve(errorResponse(err));
+        held.sink?.close();
+    }
+    else {
+        held.sink?.fail(err);
+    }
+    closeAgent(held);
+    releaseCwd(held.cwd);
+}
+function abortHeld(held) {
+    if (held.done)
+        return;
+    teardownHeld(held);
+    held.run?.cancel().catch(() => { });
+    closeAgent(held);
+    held.sink?.close();
+    held.reply.reject(new DOMException("aborted", "AbortError"));
+    releaseCwd(held.cwd);
 }
 /** Model requested tools: emit tool_calls, end this HTTP segment, park the run. */
-function flushToolCalls(agentId, held) {
+function flushToolCalls(held) {
     held.flushTimer = null;
     if (held.done || !held.pendingCalls.length)
         return;
     const calls = held.pendingCalls;
     held.pendingCalls = [];
     for (const c of calls)
-        agentByToolCallId.set(c.id, agentId);
+        agentByToolCallId.set(c.id, held.agent.agentId);
     const sink = held.sink;
     held.sink = null;
+    // the parked run outlives this HTTP segment, so its abort signal must not
+    // reach it; the continuation request attaches its own
+    held.detachSignal?.();
+    held.detachSignal = null;
+    openReply(held);
     sink?.toolCalls(calls);
     sink?.finish("tool_calls");
     rememberSession(held, calls);
-    held.idleTimer = setTimeout(() => {
-        teardownHeld(agentId, held);
-        held.run.cancel().catch(() => { });
-        try {
-            held.agent.close();
-        }
-        catch { }
-    }, TOOL_RESULT_TIMEOUT_MS);
+    held.idleTimer = setTimeout(() => abortHeld(held), TOOL_RESULT_TIMEOUT_MS);
     held.idleTimer.unref?.();
 }
-async function wireRunCompletion(agentId, held) {
-    if (held.wired)
+async function wireRunCompletion(held) {
+    if (held.wired || !held.run)
         return;
     held.wired = true;
+    let result;
     try {
-        const result = await held.run.wait();
-        if (held.done)
-            return;
-        const usage = mapUsage(result.usage) ?? held.usage;
-        teardownHeld(agentId, held);
-        rememberSession(held, []);
-        held.sink?.finish("stop", usage);
-        try {
-            held.agent.close();
-        }
-        catch { }
+        result = await held.run.wait();
     }
     catch (err) {
-        if (held.done)
-            return;
-        teardownHeld(agentId, held);
-        held.sink?.fail(err);
-        try {
-            held.agent.close();
-        }
-        catch { }
+        if (!held.done)
+            failHeld(held, err);
+        return;
     }
+    if (held.done)
+        return;
+    if (result.status === "cancelled")
+        return abortHeld(held);
+    if (result.status === "error")
+        return failHeld(held, result.error ?? new Error("cursor run failed"));
+    const usage = mapUsage(result.usage) ?? held.usage;
+    teardownHeld(held);
+    rememberSession(held, []);
+    openReply(held);
+    held.sink?.finish("stop", usage);
+    closeAgent(held);
 }
 export function _resetForTest() {
     sessions.clear();
@@ -326,79 +544,106 @@ export function _resetForTest() {
     agentByToolCallId.clear();
     sessionsLoaded = false;
 }
-export async function handleChatCompletion(body, apiKey) {
+export function _stats() {
+    return {
+        held: heldByAgent.size,
+        sessions: sessions.size,
+        disk: diskSessions.size,
+        agentIds: [...sessions.values()].map((v) => v.agentId).sort(),
+        active,
+        waiting: waiters.length,
+    };
+}
+export async function handleChatCompletion(body, apiKey, signal, scope) {
+    if (signal?.aborted)
+        throw new DOMException("aborted", "AbortError");
     await loadSessions();
     const streaming = body.stream !== false;
-    const sse = streaming ? sseResponse(body.model) : undefined;
-    const collected = streaming ? undefined : jsonCollector(body.model);
-    const sink = (sse?.sink ?? collected?.sink);
-    const reply = () => sse?.response ?? collected.promise;
+    const reply = deferred();
+    let held;
+    const sse = streaming ? sseResponse(body.model, () => held && abortHeld(held)) : undefined;
+    const sink = sse?.sink ?? jsonCollector(body.model, reply.resolve);
     // continuation: trailing tool results for a parked run
     const lastMsg = body.messages[body.messages.length - 1];
-    if (lastMsg?.role === "tool" && lastMsg.tool_call_id && agentByToolCallId.has(lastMsg.tool_call_id)) {
+    if (lastMsg?.role === "tool" && lastMsg.tool_call_id) {
         const agentId = agentByToolCallId.get(lastMsg.tool_call_id);
-        const held = heldByAgent.get(agentId);
-        if (held && !held.done) {
-            if (held.idleTimer)
-                clearTimeout(held.idleTimer);
-            held.messages = body.messages;
-            held.textAcc = "";
-            attachSink(held, sink);
-            for (const m of body.messages) {
-                if (m.role !== "tool" || !m.tool_call_id)
-                    continue;
-                const resolve = held.parked.get(m.tool_call_id);
-                if (resolve) {
-                    held.parked.delete(m.tool_call_id);
-                    agentByToolCallId.delete(m.tool_call_id);
-                    resolve(textOf(m.content));
-                }
+        held = agentId ? heldByAgent.get(agentId) : undefined;
+        if (!held || held.done) {
+            return Response.json({ error: { message: "cursor run for this tool call expired — please retry", type: "invalid_request_error", code: "tool_call_expired" } }, { status: 400 });
+        }
+        if (held.idleTimer)
+            clearTimeout(held.idleTimer);
+        held.messages = body.messages;
+        held.textAcc = "";
+        held.reply = reply;
+        held.response = sse?.response ?? null;
+        held.opened = false;
+        attachSignal(held, signal);
+        attachSink(held, sink);
+        for (const m of body.messages) {
+            if (m.role !== "tool" || !m.tool_call_id)
+                continue;
+            const resolve = held.parked.get(m.tool_call_id);
+            if (resolve) {
+                held.parked.delete(m.tool_call_id);
+                agentByToolCallId.delete(m.tool_call_id);
+                resolve(textOf(m.content));
             }
-            return reply();
         }
-        sink.fail(new Error("cursor run for this tool call expired — please retry"));
-        return reply();
+        return reply.promise;
     }
     // new turn: reuse the agent whose last-seen conversation matches our prefix
     const prefix = body.messages.slice(0, -1);
-    const key = hashMessages(prefix);
+    const key = hashMessages(prefix, scope);
+    await acquireSlot(signal);
     const entry = sessions.get(key) ?? diskSessions.get(key);
     let agent;
     let cwd;
     let newSuffix = body.messages;
+    const agentOptions = (cwd) => ({
+        model: resolveModel(body.model) ?? { id: body.model },
+        tools: ["mcp"],
+        ...(apiKey ? { apiKey } : {}),
+        local: { cwd, settingSources: ["project"], enableAgentRetries: true },
+    });
     if (entry) {
         sessions.delete(key);
+        diskSessions.delete(key);
         cwd = entry.cwd;
-        agent = await Agent.resume(entry.agentId, {
-            model: { id: body.model },
-            tools: ["mcp"],
-            ...(apiKey ? { apiKey } : {}),
-            local: { cwd, settingSources: ["project"], enableAgentRetries: true },
-        }).catch(() => {
-            sessions.delete(key);
-            diskSessions.delete(key);
+        agent = await withRetry(() => Agent.resume(entry.agentId, agentOptions(cwd)), signal).catch(() => {
             saveSessions();
+            releaseCwd(entry.cwd);
             return undefined;
         });
         if (agent)
             newSuffix = body.messages.slice(-1);
     }
     if (!agent) {
-        cwd = await mkdtemp(join(tmpdir(), "opencode-cursor-"));
-        agent = await Agent.create({
-            model: { id: body.model },
-            tools: ["mcp"],
-            ...(apiKey ? { apiKey } : {}),
-            local: { cwd, settingSources: ["project"], enableAgentRetries: true },
-        });
+        cwd = await mkdtemp(TMP_CWD_PREFIX);
+        try {
+            agent = await withRetry(() => Agent.create(agentOptions(cwd)), signal);
+        }
+        catch (err) {
+            releaseSlot();
+            releaseCwd(cwd);
+            if (signal?.aborted)
+                throw abortError();
+            return errorResponse(err);
+        }
     }
-    const held = {
+    held = {
         agent,
         cwd: cwd,
-        run: undefined,
+        model: body.model,
+        run: null,
         messages: body.messages,
+        scope,
         textAcc: "",
         sink: null,
+        reply,
+        response: sse?.response ?? null,
+        opened: false,
+        detachSignal: null,
         buffer: [],
         pendingCalls: [],
         parked: new Map(),
@@ -406,9 +651,12 @@ export async function handleChatCompletion(body, apiKey) {
         idleTimer: null,
         wired: false,
         done: false,
+        slot: true,
     };
+    const self = held;
+    heldByAgent.set(agent.agentId, held);
+    attachSignal(held, signal);
     attachSink(held, sink);
-    const agentIdRef = { id: "" };
     const customTools = {};
     for (const t of body.tools ?? []) {
         customTools[t.function.name] = {
@@ -416,11 +664,11 @@ export async function handleChatCompletion(body, apiKey) {
             inputSchema: t.function.parameters ?? { type: "object", properties: {} },
             execute: (args, ctx) => {
                 const id = (ctx.toolCallId ?? `call_${randomUUID()}`).replace(/\s+/g, "_");
-                held.pendingCalls.push({ id, name: t.function.name, argumentsJson: JSON.stringify(args ?? {}) });
-                if (held.flushTimer)
-                    clearTimeout(held.flushTimer);
-                held.flushTimer = setTimeout(() => flushToolCalls(agentIdRef.id, held), BATCH_SETTLE_MS);
-                return new Promise((resolve) => held.parked.set(id, resolve));
+                self.pendingCalls.push({ id, name: t.function.name, argumentsJson: JSON.stringify(args ?? {}) });
+                if (self.flushTimer)
+                    clearTimeout(self.flushTimer);
+                self.flushTimer = setTimeout(() => flushToolCalls(self), BATCH_SETTLE_MS);
+                return new Promise((resolve) => self.parked.set(id, resolve));
             },
         };
     }
@@ -430,29 +678,40 @@ export async function handleChatCompletion(body, apiKey) {
         .map((m) => (m.role === "user" ? textOf(m.content) : `${m.role.toUpperCase()}: ${textOf(m.content)}`))
         .filter(Boolean)
         .join("\n\n") || "(empty message)";
+    let run;
     try {
-        held.run = await held.agent.send(prompt, {
+        run = await withRetry(() => agent.send(prompt, {
             onDelta: ({ update }) => {
+                if (self.done)
+                    return;
                 if (update.type === "text-delta" && update.text) {
-                    held.textAcc += update.text;
-                    emit(held, "text", update.text);
+                    openReply(self);
+                    self.textAcc += update.text;
+                    emit(self, "text", update.text);
                 }
                 else if (update.type === "thinking-delta" && update.text) {
-                    emit(held, "reasoning", update.text);
+                    openReply(self);
+                    emit(self, "reasoning", update.text);
                 }
                 else if (update.type === "turn-ended") {
-                    held.usage = mapUsage(update.usage);
+                    self.usage = mapUsage(update.usage);
                 }
             },
             local: { customTools: customTools },
-        });
+        }), signal, 1000, (err) => !self.opened && !self.done && isTransient(err));
     }
     catch (err) {
-        sink.fail(err);
-        return reply();
+        if (!self.done)
+            failHeld(self, err);
+        return reply.promise;
+    }
+    if (self.done) {
+        run.cancel().catch(() => { });
+        return reply.promise;
     }
-    agentIdRef.id = held.run.agentId;
-    heldByAgent.set(held.run.agentId, held);
-    void wireRunCompletion(held.run.agentId, held);
-    return reply();
+    if (run.agentId !== agent.agentId)
+        console.error(`[opencode-cursor-auth] run.agentId ${run.agentId} != agent.agentId ${agent.agentId}`);
+    self.run = run;
+    void wireRunCompletion(self);
+    return reply.promise;
 }

package/dist/index.d.ts

@@ -1,3 +1,6 @@
 import type { Plugin } from "@opencode-ai/plugin";
+import { type SdkAuthStatus } from "@cursor/sdk";
+export { parseContext } from "./models.js";
+export declare function keyProblem(status: SdkAuthStatus, nowMs: number): string | undefined;
 export declare const CursorAuthPlugin: Plugin;
 export default CursorAuthPlugin;

package/dist/index.js

@@ -1,41 +1,39 @@
 import { Cursor } from "@cursor/sdk";
-import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { handleChatCompletion } from "./bridge.js";
+import { errorResponse, handleChatCompletion } from "./bridge.js";
+import { currentModels } from "./models.js";
+export { parseContext } from "./models.js";
 const BASE_URL = "http://cursor.local/v1";
-const CACHE_DIR = join(homedir(), ".cache", "opencode-cursor-auth");
-const MODELS_CACHE_PATH = join(CACHE_DIR, "models.json");
-const MODELS_CACHE_TTL_MS = 24 * 60 * 60 * 1000;
-function loadCachedModels() {
-    try {
-        const raw = JSON.parse(readFileSync(MODELS_CACHE_PATH, "utf8"));
-        if (raw?.version === 1 && raw.models && Object.keys(raw.models).length > 0)
-            return raw;
-    }
-    catch {
-        // no cache yet, or unreadable — fall back
-    }
+// Cursor publishes no output limit and the bridge never passes max_tokens to Cursor, so output is only an accounting reserve for opencode.
+const DEFAULT_CONTEXT = 200_000;
+const DEFAULT_OUTPUT = 32_000;
+export function keyProblem(status, nowMs) {
+    if (status.status !== "logged-in")
+        return "Cursor SDK key missing — run `opencode auth login` and pick Cursor";
+    if (typeof status.apiKeyExpiresAtMs === "number" && status.apiKeyExpiresAtMs <= nowMs)
+        return `Cursor SDK key expired on ${new Date(status.apiKeyExpiresAtMs).toISOString()} — run \`opencode auth login\` and pick Cursor`;
     return undefined;
 }
-// Live model list from Cursor, cached 24h to keep opencode startup fast.
-// Offline/logged-out: stale cache if present, else just "auto" (Cursor's universal alias).
-async function currentModels() {
-    const cached = loadCachedModels();
-    if (cached && Date.now() - cached.fetchedAt <= MODELS_CACHE_TTL_MS)
-        return cached.models;
-    try {
-        const list = await Cursor.models.list();
-        const models = {};
-        for (const m of list)
-            models[m.id === "default" ? "auto" : m.id] = m.displayName ?? m.id;
-        mkdirSync(CACHE_DIR, { recursive: true });
-        writeFileSync(MODELS_CACHE_PATH, JSON.stringify({ version: 1, fetchedAt: Date.now(), models }));
-        return models;
+const KEY_CHECK_TTL_MS = 60_000;
+const EXPIRY_WARN_MS = 7 * 24 * 60 * 60 * 1000;
+let keyStatus;
+let warnedExpiry = false;
+async function checkKey() {
+    if (pastedApiKey || process.env.CURSOR_API_KEY)
+        return undefined;
+    const now = Date.now();
+    if (!keyStatus || now - keyStatus.at > KEY_CHECK_TTL_MS) {
+        keyStatus = { at: now, value: Cursor.auth.status().catch(() => undefined) };
     }
-    catch {
-        return cached?.models ?? { auto: "Auto" };
+    const status = await keyStatus.value;
+    if (!status)
+        return undefined;
+    const exp = status.status === "logged-in" ? status.apiKeyExpiresAtMs : undefined;
+    if (!warnedExpiry && typeof exp === "number" && exp > now && exp - now <= EXPIRY_WARN_MS) {
+        warnedExpiry = true;
+        const days = Math.ceil((exp - now) / (24 * 60 * 60 * 1000));
+        console.error(`[opencode-cursor-auth] Cursor SDK key expires in ${days} days — run \`opencode auth login\` to renew`);
     }
+    return keyProblem(status, now);
 }
 async function bodyText(input, init) {
     const b = init?.body;
@@ -51,8 +49,15 @@ let pastedApiKey;
 async function cursorFetch(input, init) {
     const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
     if (url.includes("/chat/completions")) {
+        const problem = await checkKey();
+        if (problem)
+            return errorResponse(problem, 401);
         const body = JSON.parse(await bodyText(input, init));
-        return handleChatCompletion(body, pastedApiKey);
+        const signal = init?.signal ?? (input instanceof Request ? input.signal : undefined);
+        const scope = new Headers(init?.headers).get("x-opencode-session") ??
+            (input instanceof Request ? input.headers.get("x-opencode-session") : null) ??
+            undefined;
+        return handleChatCompletion(body, pastedApiKey, signal, scope);
     }
     if (url.includes("/models")) {
         return Response.json({
@@ -71,12 +76,17 @@ export const CursorAuthPlugin = async () => {
             cursor.name ??= "Cursor";
             cursor.options = { ...cursor.options, baseURL: BASE_URL };
             cursor.models ??= {};
-            for (const [id, displayName] of Object.entries(await currentModels())) {
-                cursor.models[id] ??= { name: displayName };
+            for (const [id, { name, context }] of Object.entries(await currentModels())) {
+                cursor.models[id] ??= { name };
                 const model = cursor.models[id];
                 model.cost = { input: 0, output: 0, cache_read: 0, cache_write: 0 };
+                model.limit ??= { context: context ?? DEFAULT_CONTEXT, output: DEFAULT_OUTPUT };
             }
         },
+        "chat.headers": async (input, output) => {
+            if (input.model.providerID === "cursor")
+                output.headers["x-opencode-session"] = input.sessionID;
+        },
         auth: {
             provider: "cursor",
             loader: async (getAuth) => {

package/dist/models.d.ts

@@ -0,0 +1,13 @@
+import { type ModelListItem, type ModelParameterValue, type ModelSelection } from "@cursor/sdk";
+export type ModelInfo = {
+    name: string;
+    context?: number;
+    base?: string;
+    params?: ModelParameterValue[];
+    blocked?: true;
+};
+export declare function parseContext(m: ModelListItem): number | undefined;
+export declare function buildCatalog(list: ModelListItem[]): Record<string, ModelInfo>;
+export declare function currentModels(): Promise<Record<string, ModelInfo>>;
+export declare function resolveModel(opencodeId: string): ModelSelection | undefined;
+export declare function markBlocked(opencodeId: string): void;

package/dist/models.js

@@ -0,0 +1,115 @@
+import { Cursor } from "@cursor/sdk";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const CACHE_DIR = join(homedir(), ".cache", "opencode-cursor-auth");
+const MODELS_CACHE_PATH = join(CACHE_DIR, "models.json");
+const MODELS_CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+let catalog = {};
+let fetchedAt = 0;
+function saveCatalog() {
+    mkdirSync(CACHE_DIR, { recursive: true });
+    writeFileSync(MODELS_CACHE_PATH, JSON.stringify({ version: 3, fetchedAt, models: catalog }));
+}
+function contextValue(raw) {
+    const match = raw?.trim().match(/^(\d+)([km]?)$/i);
+    if (!match)
+        return undefined;
+    const unit = match[2].toLowerCase();
+    return Number(match[1]) * (unit === "k" ? 1_000 : unit === "m" ? 1_000_000 : 1);
+}
+export function parseContext(m) {
+    return contextValue(m.parameters?.find((p) => p.id === "context")?.values[0]?.value);
+}
+export function buildCatalog(list) {
+    const models = {};
+    const rename = (id) => (id === "default" ? "auto" : id);
+    for (const m of list) {
+        const context = parseContext(m);
+        models[rename(m.id)] = { name: m.displayName ?? m.id, ...(context ? { context } : {}) };
+    }
+    for (const m of list) {
+        const base = rename(m.id);
+        for (const v of m.variants ?? []) {
+            // id = base + non-default param values (first listed value is the default); "true" flags use the param id, e.g. gpt-5.5-low-fast
+            const parts = v.params
+                .filter((p) => m.parameters?.find((d) => d.id === p.id)?.values[0]?.value !== p.value)
+                .map((p) => (p.value === "true" ? p.id : p.value));
+            const id = [base, ...parts].join("-");
+            if (models[id])
+                continue;
+            const context = contextValue(v.params.find((p) => p.id === "context")?.value) ?? models[base].context;
+            const label = v.displayName && v.displayName !== m.displayName ? v.displayName : parts.join(" ");
+            models[id] = { name: `${models[base].name} (${label})`, ...(context ? { context } : {}), base, params: v.params };
+        }
+    }
+    return models;
+}
+function loadCachedModels() {
+    try {
+        const raw = JSON.parse(readFileSync(MODELS_CACHE_PATH, "utf8"));
+        if (raw?.version === 3 && raw.models && Object.keys(raw.models).length > 0)
+            return raw;
+    }
+    catch {
+        // no cache yet, or unreadable — fall back
+    }
+    return undefined;
+}
+// Live model list from Cursor, cached 24h to keep opencode startup fast.
+// Offline/logged-out: stale cache if present, else just "auto" (Cursor's universal alias).
+// Models Cursor has rejected with "Model Blocked" for this account are hidden
+// until the cache file is deleted (the catalog itself carries no entitlement info).
+export async function currentModels() {
+    const cached = loadCachedModels();
+    if (cached && Date.now() - cached.fetchedAt <= MODELS_CACHE_TTL_MS) {
+        catalog = cached.models;
+        fetchedAt = cached.fetchedAt;
+    }
+    else {
+        try {
+            catalog = buildCatalog(await Cursor.models.list());
+            for (const [id, m] of Object.entries(cached?.models ?? {}))
+                if (m.blocked && catalog[id])
+                    catalog[id].blocked = true;
+            fetchedAt = Date.now();
+            saveCatalog();
+        }
+        catch {
+            catalog = cached?.models ?? { auto: { name: "Auto" } };
+            fetchedAt = cached?.fetchedAt ?? 0;
+        }
+    }
+    return Object.fromEntries(Object.entries(catalog).filter(([, m]) => !m.blocked));
+}
+function loadCatalog() {
+    if (Object.keys(catalog).length)
+        return;
+    const cached = loadCachedModels();
+    catalog = cached?.models ?? {};
+    fetchedAt = cached?.fetchedAt ?? 0;
+}
+export function resolveModel(opencodeId) {
+    loadCatalog();
+    const m = catalog[opencodeId];
+    if (!m)
+        return undefined;
+    return m.base && m.params ? { id: m.base, params: m.params } : { id: opencodeId };
+}
+export function markBlocked(opencodeId) {
+    loadCatalog();
+    const base = catalog[opencodeId]?.base ?? opencodeId;
+    let changed = false;
+    for (const [id, m] of Object.entries(catalog)) {
+        if ((id === base || m.base === base) && !m.blocked)
+            m.blocked = changed = true;
+    }
+    if (changed) {
+        try {
+            saveCatalog();
+        }
+        catch {
+            // cache dir unwritable — the in-memory flag still hides it for this process
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vidit19sharma/opencode-cursor-auth",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "OpenCode plugin that uses your Cursor subscription via the official @cursor/sdk \u2014 no proxy server, no separate login.",
   "type": "module",
   "main": "dist/index.js",
@@ -8,6 +8,7 @@
   "files": [
     "dist",
     "README.md",
+    "CHANGELOG.md",
     "LICENSE"
   ],
   "author": "Vidit Sharma <vidit19sharma@gmail.com> (https://github.com/vidit19sharma)",