cursor-opencode-provider 0.7.6 → 0.8.0

package/dist/context/paths.js

@@ -68,9 +68,18 @@ export function getHostCacheDirOverride() {
 export function resolveHostCacheDir(env = process.env) {
     return bridgeGlobalCacheDir() ?? openCodeGlobalCacheDir(env);
 }
-/** Native OpenCode global config dir. */
-export function opencodeGlobalConfigDir() {
-    return path.join(resolveHome(), ".config", "opencode");
+function xdgConfigHome(env = process.env) {
+    if (env.XDG_CONFIG_HOME && env.XDG_CONFIG_HOME.length > 0)
+        return env.XDG_CONFIG_HOME;
+    return path.join(resolveHome(env), ".config");
+}
+/**
+ * Native OpenCode global config dir: `$XDG_CONFIG_HOME/opencode`, otherwise
+ * `~/.config/opencode` — OpenCode's `Global.Path.config` (`xdg-basedir`
+ * `xdgConfig`, `packages/core/src/global.ts`), the same in 1.x and 2.0.
+ */
+export function opencodeGlobalConfigDir(env = process.env) {
+    return path.join(xdgConfigHome(env), "opencode");
 }
 /**
  * Host global cache dir for Cursor project metadata + model/version caches.
@@ -116,7 +125,7 @@ export function hostPlansDir(_workspaceRoot) {
     return path.join(hostGlobalDataDir(), "plans");
 }
 /**
- * Cursor-compatible path slug (`/Users/a/b` → `Users-a-b`).
+ * Cursor-compatible path slug (`/workspace/a/b` → `workspace-a-b`).
  * Used for per-workspace metadata under the host cache.
  */
 export function slugifyWorkspacePath(workspaceRoot) {
@@ -157,8 +166,3 @@ export function ensureOpencodeProjectDir(workspaceRoot) {
         `xdg_cache_home=${process.env.XDG_CACHE_HOME ?? "(unset)"}`);
     return dir;
 }
-export function resolveHomeRelative(p) {
-    if (p.startsWith("~/"))
-        return path.join(homedir(), p.slice(2));
-    return p;
-}

package/dist/context/rules.d.ts

@@ -1,7 +1,3 @@
-export type CollectedRule = {
-    fullPath: string;
-    content: string;
-};
 export type OpencodeJson = {
     instructions?: string[];
     permission?: unknown;
@@ -9,18 +5,10 @@ export type OpencodeJson = {
     plugins?: string[];
     mcp?: Record<string, unknown>;
 };
-export declare function findGitWorktree(start: string): Promise<string>;
 /** Same truthy rule as OpenCode's Flag.OPENCODE_DISABLE_PROJECT_CONFIG. */
 export declare function isProjectConfigDisabled(): boolean;
-/** Fetch a remote instruction with one deadline covering headers and body. */
-export declare function fetchRemoteInstruction(url: string, timeoutMs?: number): Promise<string | undefined>;
-export declare function loadMergedConfig(workspaceRoot: string): Promise<OpencodeJson>;
 /**
- * Collect OpenCode instruction files.
- * `preloadedConfig` reuses a merged config already loaded on this Run.
+ * Merged `opencode.json` / `opencode.jsonc` for MCP server ids, plugin lists,
+ * and interaction guidance. Instruction file bodies are not collected here.
  */
-export declare function collectRules(workspaceRoot: string, preloadedConfig?: OpencodeJson): Promise<{
-    rules: CollectedRule[];
-    config: OpencodeJson;
-    worktree: string;
-}>;
+export declare function loadMergedConfig(workspaceRoot: string): Promise<OpencodeJson>;

package/dist/context/rules.js

@@ -1,7 +1,6 @@
-import { readFile, readdir, stat } from "node:fs/promises";
-import { homedir } from "node:os";
+import { readFile, stat } from "node:fs/promises";
 import path from "node:path";
-import { opencodeConfigFileNames, opencodeGlobalConfigDirs, opencodeProjectConfigDirs, resolveHomeRelative } from "./paths.js";
+import { opencodeConfigFileNames, opencodeGlobalConfigDirs, opencodeProjectConfigDirs } from "./paths.js";
 async function exists(file) {
     try {
         await stat(file);
@@ -18,7 +17,10 @@ async function readJsonConfig(dir) {
             continue;
         try {
             const raw = await readFile(file, "utf-8");
-            const stripped = raw.replace(/\/\*[\s\S]*?\*\//g, "").replace(/^\s*\/\/.*$/gm, "");
+            // Match strings first so comment markers inside URLs/plugin specifiers
+            // survive. Remove comments before trailing commas (which may precede one).
+            const uncommented = raw.replace(/"(?:\\.|[^"\\])*"|\/\*[\s\S]*?\*\/|\/\/[^\r\n]*/g, token => token.startsWith('"') ? token : " ");
+            const stripped = uncommented.replace(/"(?:\\.|[^"\\])*"|,\s*(?=[}\]])/g, token => token.startsWith('"') ? token : "");
             return JSON.parse(stripped);
         }
         catch {
@@ -27,131 +29,11 @@ async function readJsonConfig(dir) {
     }
     return {};
 }
-export async function findGitWorktree(start) {
-    let dir = path.resolve(start);
-    for (;;) {
-        if (await exists(path.join(dir, ".git")))
-            return dir;
-        const parent = path.dirname(dir);
-        if (parent === dir)
-            return path.resolve(start);
-        dir = parent;
-    }
-}
-async function findUp(name, start, stop) {
-    let dir = path.resolve(start);
-    const root = path.resolve(stop);
-    for (;;) {
-        const candidate = path.join(dir, name);
-        if (await exists(candidate))
-            return candidate;
-        if (dir === root)
-            return undefined;
-        const parent = path.dirname(dir);
-        if (parent === dir)
-            return undefined;
-        dir = parent;
-    }
-}
-async function readRule(file) {
-    if (!(await exists(file)))
-        return undefined;
-    try {
-        const content = await readFile(file, "utf-8");
-        if (!content.trim())
-            return undefined;
-        return { fullPath: path.resolve(file), content };
-    }
-    catch {
-        return undefined;
-    }
-}
-function globToRegExp(glob) {
-    const norm = glob.replace(/\\/g, "/");
-    let re = "^";
-    for (let i = 0; i < norm.length; i++) {
-        const c = norm[i];
-        if (c === "*") {
-            if (norm[i + 1] === "*") {
-                re += ".*";
-                i++;
-                if (norm[i + 1] === "/")
-                    i++;
-            }
-            else {
-                re += "[^/]*";
-            }
-        }
-        else if (".$^+?()[]{}|".includes(c) || c === "\\") {
-            re += "\\" + c;
-        }
-        else {
-            re += c;
-        }
-    }
-    return new RegExp(re + "$");
-}
-async function expandGlob(pattern, workspaceRoot) {
-    const abs = path.isAbsolute(pattern) ? pattern : path.join(workspaceRoot, pattern);
-    if (!abs.includes("*"))
-        return (await exists(abs)) ? [abs] : [];
-    const out = [];
-    const base = abs.split("*")[0] || workspaceRoot;
-    const startDir = path.dirname(base.endsWith("/") ? base : base);
-    const regex = globToRegExp(abs);
-    async function walk(dir, depth) {
-        if (depth > 8)
-            return;
-        let entries;
-        try {
-            entries = await readdir(dir);
-        }
-        catch {
-            return;
-        }
-        entries.sort();
-        for (const name of entries) {
-            if (name === "node_modules" || name === ".git")
-                continue;
-            const full = path.join(dir, name);
-            let st;
-            try {
-                st = await stat(full);
-            }
-            catch {
-                continue;
-            }
-            if (st.isDirectory())
-                await walk(full, depth + 1);
-            else if (regex.test(full.replace(/\\/g, "/")))
-                out.push(full);
-        }
-    }
-    await walk(startDir, 0);
-    return out;
-}
 /** Same truthy rule as OpenCode's Flag.OPENCODE_DISABLE_PROJECT_CONFIG. */
 export function isProjectConfigDisabled() {
     const value = process.env.OPENCODE_DISABLE_PROJECT_CONFIG?.toLowerCase();
     return value === "true" || value === "1";
 }
-/** Fetch a remote instruction with one deadline covering headers and body. */
-export async function fetchRemoteInstruction(url, timeoutMs = 5000) {
-    const ctrl = new AbortController();
-    const timer = setTimeout(() => ctrl.abort(), Math.max(1, timeoutMs));
-    try {
-        const res = await fetch(url, { signal: ctrl.signal });
-        if (!res.ok)
-            return undefined;
-        return await res.text();
-    }
-    catch {
-        return undefined;
-    }
-    finally {
-        clearTimeout(timer);
-    }
-}
 function mergeConfig(base, overlay) {
     return {
         ...base,
@@ -163,6 +45,10 @@ function mergeConfig(base, overlay) {
         permission: overlay.permission ?? base.permission,
     };
 }
+/**
+ * Merged `opencode.json` / `opencode.jsonc` for MCP server ids, plugin lists,
+ * and interaction guidance. Instruction file bodies are not collected here.
+ */
 export async function loadMergedConfig(workspaceRoot) {
     const globalConfig = await readJsonConfig(opencodeGlobalConfigDirs()[0] ?? "");
     if (isProjectConfigDisabled())
@@ -176,65 +62,3 @@ export async function loadMergedConfig(workspaceRoot) {
     }
     return mergeConfig(globalConfig, projectConfig);
 }
-/**
- * Collect OpenCode instruction files.
- * `preloadedConfig` reuses a merged config already loaded on this Run.
- */
-export async function collectRules(workspaceRoot, preloadedConfig) {
-    const worktree = await findGitWorktree(workspaceRoot);
-    const rules = [];
-    const seen = new Set();
-    const config = preloadedConfig ?? await loadMergedConfig(workspaceRoot);
-    const add = async (file) => {
-        if (!file)
-            return;
-        const resolved = path.resolve(file);
-        if (seen.has(resolved))
-            return;
-        const rule = await readRule(resolved);
-        if (!rule)
-            return;
-        seen.add(resolved);
-        rules.push(rule);
-    };
-    // Match OpenCode: OPENCODE_DISABLE_PROJECT_CONFIG skips project AGENTS/CLAUDE/CONTEXT
-    // discovery and project opencode.json (see loadMergedConfig).
-    if (!isProjectConfigDisabled()) {
-        for (const name of ["AGENTS.md", "CLAUDE.md", "CONTEXT.md"]) {
-            const hit = await findUp(name, workspaceRoot, worktree);
-            if (hit) {
-                await add(hit);
-                break;
-            }
-        }
-    }
-    for (const globalDir of opencodeGlobalConfigDirs()) {
-        await add(path.join(globalDir, "AGENTS.md"));
-    }
-    await add(path.join(homedir(), ".claude", "CLAUDE.md"));
-    for (const raw of config.instructions ?? []) {
-        if (raw.startsWith("http://") || raw.startsWith("https://")) {
-            // HTTPS-only. Redirects (incl. to a local proxy) are intentional — do not
-            // disable follow-redirects or reject localhost/private/metadata hosts.
-            let remoteUrl;
-            try {
-                remoteUrl = new URL(raw);
-            }
-            catch {
-                continue;
-            }
-            if (remoteUrl.protocol !== "https:")
-                continue;
-            const content = await fetchRemoteInstruction(remoteUrl.href);
-            if (!content?.trim() || seen.has(raw))
-                continue;
-            seen.add(raw);
-            rules.push({ fullPath: raw, content });
-            continue;
-        }
-        const expanded = resolveHomeRelative(raw);
-        for (const m of await expandGlob(expanded, workspaceRoot))
-            await add(m);
-    }
-    return { rules, config, worktree };
-}

package/dist/debug.d.ts

@@ -1,5 +1,7 @@
 /** Soft cap for the debug log file; exceeded size triggers truncate + new header. */
 export declare const DEBUG_LOG_MAX_BYTES: number;
+/** Message of an unknown thrown value, for log lines and error text. */
+export declare function errorMessage(error: unknown): string;
 /** Whether `CURSOR_PROVIDER_DEBUG` is enabled for this process. */
 export declare function isDebugEnabled(): boolean;
 /** Resolve the debug log path (env override or per-uid tmpdir default). */

package/dist/debug.js

@@ -18,6 +18,10 @@ let _traceInitialized = false;
 let _debugFile;
 let _debugFileUsesManagedDirectory = false;
 let _announcedLogPath = false;
+/** Message of an unknown thrown value, for log lines and error text. */
+export function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
 /** Whether `CURSOR_PROVIDER_DEBUG` is enabled for this process. */
 export function isDebugEnabled() {
     return DEBUG_ENABLED;

package/dist/errors.d.ts

@@ -17,6 +17,12 @@ export declare class CursorProviderError extends Error {
     readonly origin: CursorErrorOrigin;
     readonly transient: boolean;
     replaySafe: boolean;
+    /**
+     * The Run failed because Cursor could not restore the resumed checkpoint
+     * (it requested blobs this client does not hold) before producing anything.
+     * Recovery must reseed a new conversation instead of resuming that checkpoint.
+     */
+    checkpointUnusable?: boolean;
     readonly statusCode?: number;
     readonly grpcStatus?: number | string;
     readonly rstCode?: number;
@@ -41,8 +47,15 @@ export declare class CursorProtocolError extends CursorProviderError {
 export declare class CursorAuthError extends CursorProviderError {
     constructor(message?: string, options?: Partial<CursorErrorDiagnostics> & {
         cause?: unknown;
+        replaySafe?: boolean;
     });
 }
+/**
+ * Cursor refused the request's credential (HTTP 401 / gRPC unauthenticated),
+ * as opposed to refusing the account an action (403 / permission_denied).
+ * Only this case is worth one renewed-token retry.
+ */
+export declare function isRejectedCredentialError(error: unknown): error is CursorAuthError;
 /**
  * OpenCode's SessionRetry treats several substrings in provider error messages
  * as always-retryable — notably bare "unavailable" and "exhausted", plus a

package/dist/errors.js

@@ -3,6 +3,12 @@ export class CursorProviderError extends Error {
     origin;
     transient;
     replaySafe;
+    /**
+     * The Run failed because Cursor could not restore the resumed checkpoint
+     * (it requested blobs this client does not hold) before producing anything.
+     * Recovery must reseed a new conversation instead of resuming that checkpoint.
+     */
+    checkpointUnusable;
     statusCode;
     grpcStatus;
     rstCode;
@@ -64,11 +70,27 @@ export class CursorAuthError extends CursorProviderError {
             ...options,
             origin: "auth",
             transient: false,
-            replaySafe: false,
+            replaySafe: options.replaySafe ?? false,
         });
         this.name = "CursorAuthError";
     }
 }
+function isUnauthenticatedStatus(status) {
+    if (status === undefined)
+        return false;
+    const normalized = String(status).toLowerCase().replaceAll("-", "_");
+    return normalized === "16" || normalized === "unauthenticated";
+}
+/**
+ * Cursor refused the request's credential (HTTP 401 / gRPC unauthenticated),
+ * as opposed to refusing the account an action (403 / permission_denied).
+ * Only this case is worth one renewed-token retry.
+ */
+export function isRejectedCredentialError(error) {
+    return error instanceof CursorAuthError && (error.statusCode === 401 ||
+        isUnauthenticatedStatus(error.grpcStatus) ||
+        isUnauthenticatedStatus(error.code));
+}
 /**
  * OpenCode's SessionRetry treats several substrings in provider error messages
  * as always-retryable — notably bare "unavailable" and "exhausted", plus a
@@ -141,7 +163,9 @@ export function isAuthGrpcStatus(status) {
 }
 export function cursorHttpError(operation, statusCode, diagnostics = {}) {
     if (statusCode === 401 || statusCode === 403) {
-        return new CursorAuthError(`Cursor authentication failed (HTTP ${statusCode}); reauthenticate with Cursor`, { ...diagnostics, statusCode });
+        // A rejected credential means the server did no work: replaying with a
+        // renewed token is safe unless the attempt already crossed a barrier.
+        return new CursorAuthError(`Cursor authentication failed (HTTP ${statusCode}); reauthenticate with Cursor`, { ...diagnostics, statusCode, replaySafe: statusCode === 401 });
     }
     return new CursorServerError(`${operation} HTTP ${statusCode}`, {
         ...diagnostics,
@@ -152,7 +176,7 @@ export function cursorHttpError(operation, statusCode, diagnostics = {}) {
 }
 export function cursorGrpcError(operation, grpcStatus, diagnostics = {}) {
     if (isAuthGrpcStatus(grpcStatus)) {
-        return new CursorAuthError(`Cursor authentication failed (gRPC ${grpcStatus}); reauthenticate with Cursor`, { ...diagnostics, grpcStatus });
+        return new CursorAuthError(`Cursor authentication failed (gRPC ${grpcStatus}); reauthenticate with Cursor`, { ...diagnostics, grpcStatus, replaySafe: isUnauthenticatedStatus(grpcStatus) });
     }
     return new CursorServerError(`${operation} gRPC status ${grpcStatus}`, {
         ...diagnostics,

package/dist/host-agent-mode.js

@@ -7,7 +7,7 @@
  * OpenCode 2.0 uses it to select its vendor-maintained `plan` / `build` agents;
  * OpenCode 1.x continues to use advertised `plan_enter` / `plan_exit` tools.
  */
-import { trace } from "./debug.js";
+import { errorMessage, trace } from "./debug.js";
 let switchHostAgent;
 const pending = new Map();
 const MAX_PENDING_HOST_AGENT_SWITCHES = 256;
@@ -82,7 +82,7 @@ export async function flushHostAgentModeSwitch(sessionID, options = {}) {
         // behavioral fallback until the native host switch succeeds.
         delete state.cursorSessionID;
         trace(`host-agent-mode: FAILED sessionID=${key} target=${state.targetModeID} ` +
-            `attempts=${state.attempts} err=${error instanceof Error ? error.message : String(error)}`);
+            `attempts=${state.attempts} err=${errorMessage(error)}`);
         return false;
     }
 }

package/dist/image-save.js

@@ -8,7 +8,7 @@
  */
 import fs from "node:fs";
 import path from "node:path";
-import { trace } from "./debug.js";
+import { errorMessage, trace } from "./debug.js";
 import { takePendingCursorImage } from "./image-staging.js";
 /**
  * Marks a refusal that must reach Cursor as `WriteResult.permission_denied`
@@ -150,7 +150,7 @@ export async function executeCursorImageSave(args, ctx) {
         });
     }
     catch (error) {
-        const reason = error instanceof Error ? error.message : String(error);
+        const reason = errorMessage(error);
         trace(`image save: permission refused path=${JSON.stringify(contained.path)} reason=${reason}`);
         throw new Error(`${IMAGE_PERMISSION_DENIED_PREFIX} ${reason}`);
     }
@@ -165,7 +165,7 @@ export async function executeCursorImageSave(args, ctx) {
     catch (error) {
         // Most often something already occupies a path component (EEXIST/ENOTDIR).
         // Say which path is blocked; the raw errno alone tells the model nothing.
-        const reason = error instanceof Error ? error.message : String(error);
+        const reason = errorMessage(error);
         trace(`image save: write failed path=${JSON.stringify(contained.path)} reason=${reason}`);
         throw new Error(`Could not save the generated image to ${contained.path}: ${reason}. `
             + `Check that ${directory} is a writable directory.`);

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 import { CursorPlugin } from "./plugin.js";
 import type { CursorContinuationOptions } from "./session.js";
 import type { HostToolDialect } from "./protocol/tools.js";
+import type { AccessTokenProvider } from "./auth-renewal.js";
 export type CursorRetryOptions = {
     /** Total attempts including the initial request. Default: 3. */
     maxAttempts?: number;
@@ -11,7 +12,16 @@ export type CursorRetryOptions = {
 };
 export type CreateCursorOptions = {
     name: string;
+    /**
+     * Current Cursor access token, asked for every time a Run opens. Takes
+     * precedence over `accessToken` and `apiKey`; hosts use it to renew the
+     * login without exposing a secret in serializable options. `forceRefresh`
+     * is set once after Cursor rejected the previous token.
+     */
+    getAccessToken?: AccessTokenProvider;
+    /** Access token sent as-is (no renewal). Used when `getAccessToken` is absent. */
     accessToken?: string;
+    /** Raw `crsr_` API key, exchanged and renewed. Used only when neither of the above is given. */
     apiKey?: string;
     /** API base for auth, model discovery, and GetServerConfig. */
     apiBaseURL?: string;

package/dist/language-model.d.ts

@@ -5,6 +5,7 @@ import { cursorContextUsageMetadata, type CursorContextUsageSource, type CursorC
 import { type ConversationBlobGraphStats } from "./protocol/blob-store.js";
 import { type CursorSession } from "./session.js";
 import { CursorProviderError } from "./errors.js";
+import { type ModelInfo } from "./models.js";
 import type { SeedHistoryMessage } from "./protocol/request.js";
 type PromptIdentity = {
     hostAgent?: string;
@@ -21,6 +22,13 @@ export declare const MAX_CHECKPOINT_BLOB_GRAPH_BYTES: number;
 export declare function checkpointBlobGraphRequiresRebase(_stats: ConversationBlobGraphStats, _maxBytes?: number): boolean;
 /** Warn-only concern for incomplete / oversized checkpoint graphs (no remint). */
 export declare function checkpointBlobGraphConcern(stats: ConversationBlobGraphStats, maxBytes?: number): "incomplete-checkpoint-graph" | "oversized-checkpoint-graph" | undefined;
+/**
+ * True when the raw frame holds exactly one control message: a KV request, a
+ * checkpoint update, or an interaction update that is only a heartbeat. Extra
+ * fields inside a KV request are tolerated (Cursor has sent them live); extra
+ * top-level fields are not.
+ */
+export declare function isSoleControlFrame(payload: Uint8Array): boolean;
 export type CursorRetryPolicy = {
     maxAttempts: number;
     baseDelayMs: number;
@@ -50,9 +58,17 @@ export declare function pumpWithRecovery(input: {
     recover: (recovery: CursorRunRecovery) => Promise<CursorSession>;
     onSession?: (session: CursorSession) => void;
     maxRecoveries?: number;
+    /**
+     * Set when the credential source can renew: called once per turn after
+     * Cursor rejects the token (401 / unauthenticated) before the attempt did
+     * anything, so the reopened Run uses a force-renewed token. This retry does
+     * not count against the transient-failure budget.
+     */
+    renewRejectedCredential?: () => void;
 }): Promise<CursorSession>;
 export type CursorRunRecovery = {
     kind: "rebase";
+    reason?: "checkpoint-unusable";
 } | {
     kind: "resume";
     conversationId: string;
@@ -145,18 +161,12 @@ type ExtractedToolResult = {
     output: string;
     error?: string;
 };
-/**
- * Tool results that form a live continuation: only the trailing run of `tool`
- * messages after the last non-tool message. Mid-prompt historical tool results
- * are ignored — they are conversation history, not replies for a held-open Run.
- */
 export declare function extractTrailingToolResults(prompt: LanguageModelV3CallOptions["prompt"]): ExtractedToolResult[];
 /** Detect a host-owned canonical plan review, excluding Cursor exec replies. */
 export declare function hasApprovedUncorrelatedPlanStageResult(prompt: LanguageModelV3CallOptions["prompt"]): boolean;
 /**
- * Checkpointed Runs do not resend the system prompt. Keep the workspace root
- * on the live user message, and require absolute `path` arguments when that is
- * the host's file-tool dialect.
+ * Keep the workspace root on a checkpointed turn's live user message too, and
+ * require absolute `path` arguments when that is the host's file-tool dialect.
  */
 export declare function groundCheckpointTurnText(userText: string, checkpoint: boolean, workspaceRoot: string, tools: readonly {
     name?: string;
@@ -196,6 +206,21 @@ export declare function extractPromptHistory(prompt: LanguageModelV3CallOptions[
     preserveTrailingUser?: boolean;
     toolResults?: "omit" | "all" | "trailing";
 }): SeedHistoryMessage[];
+/** Share of the target context a foreign-history rebase may fill before compaction. */
+export declare const FOREIGN_HISTORY_REBASE_CONTEXT_SHARE = 0.8;
+/**
+ * A foreign-history rebase replays the full host history. When that cannot fit,
+ * fail before opening a Run with an error hosts classify as context overflow
+ * (HTTP 413 + "prompt is too long"), so the host compacts and retries.
+ */
+export declare function assertForeignHistoryRebaseFits(input: {
+    modelInfo: ModelInfo | undefined;
+    cursorModelId: string;
+    maxMode: boolean;
+    history: SeedHistoryMessage[];
+    systemPrompt: string | undefined;
+    userText: string;
+}): void;
 /** OpenCode session id header, if present. */
 export declare function opencodeSessionKey(callOptions: LanguageModelV3CallOptions): string | undefined;
 /**
@@ -205,6 +230,14 @@ export declare function opencodeSessionKey(callOptions: LanguageModelV3CallOptio
  */
 export declare function resolveConversationId(callOptions: LanguageModelV3CallOptions): string;
 export { sessionIdToUuid } from "./protocol/conversation-bind.js";
+/**
+ * Grow the held Run's advertised + permitted catalog from this `doStream`
+ * call. Continuation skips `startSession`, so without this, exec #36 and
+ * permission keep the freeze from Run open. MCP server ids stay those of the
+ * Run's one merged-config load (`startSession`); a tool that connects later
+ * still gets its identity from that set.
+ */
+export declare function refreshHeldSessionToolCatalog(session: CursorSession, callOptions: LanguageModelV3CallOptions): Promise<void>;
 /** Exported for tests — AI SDK V3 span ends that must precede finish / tool-call. */
 export declare function spanEndParts(opts: {
     textStarted: boolean;