opencode-ext-connector 0.3.2 → 0.4.0

package/dist/opencode/provider-entry.d.ts

@@ -19,6 +19,7 @@ export type ProviderEntry = {
     readonly integrationId: string;
     readonly integrationMethod: IntegrationEnvMethod;
     readonly fallbackModelIds?: readonly string[];
+    readonly providerOptions?: Readonly<Record<string, unknown>>;
     readonly createAdapter: (deps: ProviderEntryDeps) => ProviderAdapter;
     readonly createAuthHook: (deps: ProviderEntryDeps) => AuthHook;
     readonly isConnected: (deps: ProviderEntryDeps) => Promise<boolean>;

package/dist/opencode/providers.d.ts

@@ -1,5 +1,6 @@
 import type { ClaudeCredentials } from "../providers/claude/credentials.js";
 import type { OllamaCatalogState } from "../providers/ollama/catalog-state.js";
+import type { OllamaEndpoints } from "../providers/ollama/endpoints.js";
 import { type OllamaFetch } from "../providers/ollama/http.js";
 import type { ProviderEntry } from "./provider-entry.js";
 export type ProviderConnectionActive = (integrationId: string) => Promise<boolean>;
@@ -9,6 +10,7 @@ export type ProviderRegistryOptions = {
     readonly ollama?: {
         readonly fetch: OllamaFetch;
         readonly catalog: OllamaCatalogState;
+        readonly endpoints?: OllamaEndpoints;
     };
 };
 export declare function selectConfiguredProviders(entries: readonly ProviderEntry[], providerIds: readonly string[]): readonly ProviderEntry[];

package/dist/opencode/providers.js

@@ -11,7 +11,7 @@ import { listCursorUsableModels } from "../providers/cursor/models.js";
 import { createOllamaAdapter } from "../providers/ollama/adapter.js";
 import { productionOllamaFetch } from "../providers/ollama/http.js";
 import { probeLocalOllama } from "./ollama-probe.js";
-import { productionOllamaCatalog } from "./ollama-production.js";
+import { getProductionOllamaBundle } from "./ollama-production.js";
 import { createAnthropicCliAuth } from "./v1-anthropic-auth.js";
 import { createCommandCodeSessionAuth, createCursorSessionAuth, createOllamaSessionAuth, } from "./v1-session-auth.js";
 async function readCommandCodeToken(deps, signal) {
@@ -43,9 +43,15 @@ export async function selectActiveProviders(entries, isActive) {
 }
 export function createProviderRegistry(options = {}) {
     const writeClaudeCredentials = options.writeClaudeCredentials;
-    const ollama = options.ollama ?? {
+    const productionOllama = getProductionOllamaBundle();
+    const configuredOllama = options.ollama ?? {
         fetch: productionOllamaFetch,
-        catalog: productionOllamaCatalog,
+        catalog: productionOllama.catalog,
+        endpoints: productionOllama.endpoints,
+    };
+    const ollama = {
+        ...configuredOllama,
+        endpoints: configuredOllama.endpoints ?? productionOllama.endpoints,
     };
     return [
         {
@@ -128,12 +134,13 @@ export function createProviderRegistry(options = {}) {
             displayName: "Ollama",
             integrationId: "ollama",
             integrationMethod: { type: "env", names: ["OLLAMA_EXT_CONNECTOR_ENABLED"] },
+            providerOptions: Object.freeze({ ollamaBaseURL: ollama.endpoints.baseURL }),
             createAdapter: () => createOllamaAdapter(ollama),
-            createAuthHook: () => createOllamaSessionAuth(ollama.fetch),
+            createAuthHook: () => createOllamaSessionAuth(ollama.fetch, ollama.endpoints),
             isConnected: async (deps) => {
                 if ((await deps.authStore.matchAuth("ollama")) === null)
                     return false;
-                return probeLocalOllama(ollama.fetch);
+                return probeLocalOllama(ollama.fetch, ollama.endpoints);
             },
         },
     ];

package/dist/opencode/v1-catalog.js

@@ -36,7 +36,12 @@ export function createV1CatalogProjector(options) {
         }
         const provider = attachedConfig.provider ?? {};
         Object.defineProperty(provider, entry.id, {
-            value: { npm, name: entry.displayName, models },
+            value: {
+                npm,
+                name: entry.displayName,
+                models,
+                ...(entry.providerOptions === undefined ? {} : { options: entry.providerOptions }),
+            },
             enumerable: true,
             configurable: true,
             writable: true,

package/dist/opencode/v1-language.js

@@ -4,7 +4,7 @@ import { createClaudeTokenReader } from "../providers/claude/auth.js";
 import { readCursorAccessToken } from "../providers/cursor/auth.js";
 import { createCursorDirectRuntime } from "../providers/cursor/direct-runtime.js";
 import { createConnectorLanguage } from "./language-factory.js";
-import { productionOllamaRuntime } from "./ollama-production.js";
+import { getProductionOllamaBundle } from "./ollama-production.js";
 const clock = {
     nowMs: () => Date.now(),
     schedule: (delayMs, callback) => {
@@ -47,12 +47,15 @@ function apiKeyFromOptions(options) {
 }
 export function languageForV1Provider(providerID, modelId, options) {
     const commandCodeApiKey = apiKeyFromOptions(options);
+    const ollamaRuntime = providerID === "ollama"
+        ? getProductionOllamaBundle(options["ollamaBaseURL"]).runtime
+        : undefined;
     const createLanguage = createConnectorLanguage({
         env,
         transport,
         readClaudeToken,
         cursorRuntime,
-        ollamaRuntime: productionOllamaRuntime,
+        ...(ollamaRuntime === undefined ? {} : { ollamaRuntime }),
         ...(commandCodeApiKey === undefined ? {} : { commandCodeApiKey }),
     });
     const model = createLanguage(providerID, modelId);

package/dist/opencode/v1-session-auth.d.ts

@@ -1,5 +1,6 @@
 import type { AuthHook } from "@opencode-ai/plugin";
+import { type OllamaEndpoints } from "../providers/ollama/endpoints.js";
 import { type OllamaFetch } from "../providers/ollama/http.js";
 export declare function createCursorSessionAuth(env: Readonly<Record<string, string | undefined>>): AuthHook;
 export declare function createCommandCodeSessionAuth(env: Readonly<Record<string, string | undefined>>): AuthHook;
-export declare function createOllamaSessionAuth(fetch?: OllamaFetch): AuthHook;
+export declare function createOllamaSessionAuth(fetch?: OllamaFetch, endpoints?: OllamaEndpoints): AuthHook;

package/dist/opencode/v1-session-auth.js

@@ -1,12 +1,13 @@
 import { readCommandCodeAccessToken } from "../providers/command-code/auth.js";
 import { readCursorAccessToken } from "../providers/cursor/auth.js";
+import { parseOllamaEndpoints } from "../providers/ollama/endpoints.js";
 import { productionOllamaFetch } from "../providers/ollama/http.js";
 import { probeLocalOllama } from "./ollama-probe.js";
 const CURSOR_SESSION_MARKER = "cli-session:cursor";
 const COMMAND_CODE_SESSION_MARKER = "cli-session:command-code";
 const OLLAMA_SESSION_MARKER = "cli-session:ollama";
-const OLLAMA_AVAILABLE_INSTRUCTIONS = "The connector will reuse the running local Ollama daemon. Cloud access remains managed by `ollama signin`; this plugin does not run sign-in.";
-const OLLAMA_UNAVAILABLE_INSTRUCTIONS = "Start the local Ollama daemon, then retry.";
+const OLLAMA_AVAILABLE_INSTRUCTIONS = "The connector will reuse the running configured Ollama daemon. Cloud access remains managed by `ollama signin`; this plugin does not run sign-in.";
+const OLLAMA_UNAVAILABLE_INSTRUCTIONS = "Start the configured Ollama daemon, then retry.";
 function sessionMethod(options) {
     return {
         type: "oauth",
@@ -68,22 +69,22 @@ export function createCommandCodeSessionAuth(env) {
         ],
     };
 }
-export function createOllamaSessionAuth(fetch = productionOllamaFetch) {
+export function createOllamaSessionAuth(fetch = productionOllamaFetch, endpoints = parseOllamaEndpoints(undefined)) {
     return {
         provider: "ollama",
         methods: [
             {
                 type: "oauth",
-                label: "Ollama local daemon",
+                label: "Ollama daemon",
                 authorize: async () => {
-                    const available = await probeLocalOllama(fetch);
+                    const available = await probeLocalOllama(fetch, endpoints);
                     return {
                         url: "",
                         instructions: available
                             ? OLLAMA_AVAILABLE_INSTRUCTIONS
                             : OLLAMA_UNAVAILABLE_INSTRUCTIONS,
                         method: "auto",
-                        callback: async () => (await probeLocalOllama(fetch))
+                        callback: async () => (await probeLocalOllama(fetch, endpoints))
                             ? {
                                 type: "success",
                                 provider: "ollama",

package/dist/providers/command-code/language-model.js

@@ -2,32 +2,32 @@
 // Licensed under MIT. See THIRD_PARTY_NOTICES.md.
 import { AdapterError, OperationCancelledError } from "../../core/errors.js";
 import { parseProviderId } from "../../core/ids.js";
-import { openHttpBody } from "../../http/read-body.js";
 import { createCommandCodeVersionResolver } from "./cli-version.js";
 import { emitCommandCodeChunks } from "./emit-stream.js";
 import { commandCodeMissingBodyError } from "./errors.js";
+import { openCommandCodeGeneration } from "./open-generation.js";
 import { buildBody, buildHeaders, } from "./request.js";
-import { commandCodeHttpError, createCommandCodeRequestLifecycle, readCommandCodeErrorBody, } from "./request-lifecycle.js";
+import { createCommandCodeRequestLifecycle } from "./request-lifecycle.js";
 import { createCommandCodeSessionId } from "./session.js";
-function buildRequestOptions(options, call, token, cliVersion) {
-    const bodyOptions = {
-        modelId: options.modelId,
-        call,
-        sessionId: options.sessionId,
-    };
+function buildRequestOptions(options) {
+    const { runtime, call, token, cliVersion, bodySnapshot } = options;
     const headerOptions = {
         token,
         cliVersion,
-        sessionId: options.sessionId,
+        sessionId: runtime.sessionId,
     };
+    const headers = {};
+    for (const source of [buildHeaders(headerOptions), runtime.headers ?? {}, call.headers ?? {}]) {
+        for (const [name, value] of Object.entries(source)) {
+            if (value !== undefined) {
+                headers[name.toLowerCase()] = value;
+            }
+        }
+    }
     return {
-        url: `${(options.baseURL ?? "https://api.commandcode.ai").replace(/\/+$/, "")}/alpha/generate`,
-        headers: {
-            ...buildHeaders(headerOptions),
-            ...options.headers,
-            ...Object.fromEntries(Object.entries(call.headers ?? {}).filter((entry) => entry[1] !== undefined)),
-        },
-        body: new TextEncoder().encode(JSON.stringify(buildBody(bodyOptions))),
+        url: `${(runtime.baseURL ?? "https://api.commandcode.ai").replace(/\/+$/, "")}/alpha/generate`,
+        headers,
+        body: new Uint8Array(bodySnapshot),
     };
 }
 function createUsage() {
@@ -66,34 +66,41 @@ async function streamCommandCode(options, call) {
             providerId: parseProviderId("command-code"),
         });
     }
-    const requestOptions = buildRequestOptions(options, call, token, cliVersion);
-    let opened;
+    const bodyOptions = {
+        modelId: options.modelId,
+        call,
+        sessionId: options.sessionId,
+    };
+    const bodySnapshot = new TextEncoder().encode(JSON.stringify(buildBody(bodyOptions)));
+    let generation;
     try {
-        opened = await openHttpBody(options.transport, {
-            method: "POST",
-            url: requestOptions.url,
-            headers: requestOptions.headers,
-            body: requestOptions.body,
-        }, lifecycle.signal);
+        generation = await openCommandCodeGeneration({
+            transport: options.transport,
+            lifecycle,
+            initialToken: token,
+            readAccessToken: options.readAccessToken,
+            createRequest: (accessToken) => {
+                const request = buildRequestOptions({
+                    runtime: options,
+                    call,
+                    token: accessToken,
+                    cliVersion,
+                    bodySnapshot,
+                });
+                return {
+                    method: "POST",
+                    url: request.url,
+                    headers: request.headers,
+                    body: request.body,
+                };
+            },
+        });
     }
     catch (error) {
         lifecycle.dispose();
         throw error;
     }
-    if (opened.status < 200 || opened.status >= 300) {
-        let errorBody;
-        try {
-            errorBody = await readCommandCodeErrorBody(opened.chunks);
-        }
-        catch (error) {
-            lifecycle.abort();
-            throw error;
-        }
-        finally {
-            lifecycle.dispose();
-        }
-        throw commandCodeHttpError(opened.status, errorBody);
-    }
+    const { opened, request } = generation;
     if (!opened.bodyPresent) {
         lifecycle.dispose();
         throw commandCodeMissingBodyError(opened.status);
@@ -124,7 +131,7 @@ async function streamCommandCode(options, call) {
     });
     return {
         stream,
-        request: { body: new TextDecoder().decode(requestOptions.body) },
+        request: { body: request.body === null ? undefined : new TextDecoder().decode(request.body) },
         response: { headers: opened.headers },
     };
 }

package/dist/providers/command-code/open-generation.d.ts

@@ -0,0 +1,16 @@
+import type { HttpRequest, HttpTransport } from "../../core/http.js";
+import { type HttpBodyStream } from "../../http/read-body.js";
+import type { CommandCodeRequestLifecycle } from "./request-lifecycle.js";
+type OpenGenerationOptions = {
+    readonly transport: HttpTransport;
+    readonly lifecycle: CommandCodeRequestLifecycle;
+    readonly initialToken: string;
+    readonly readAccessToken: (signal: AbortSignal) => Promise<string | null>;
+    readonly createRequest: (token: string) => HttpRequest;
+};
+export type OpenedCommandCodeGeneration = {
+    readonly opened: HttpBodyStream;
+    readonly request: HttpRequest;
+};
+export declare function openCommandCodeGeneration(options: OpenGenerationOptions): Promise<OpenedCommandCodeGeneration>;
+export {};

package/dist/providers/command-code/open-generation.js

@@ -0,0 +1,45 @@
+// Derived from brent-weatherall/opencode-commandcode-provider src/model.ts.
+// Licensed under MIT. See THIRD_PARTY_NOTICES.md.
+import { OperationCancelledError } from "../../core/errors.js";
+import { openHttpBody } from "../../http/read-body.js";
+import { commandCodeHttpError, readCommandCodeErrorBody } from "./request-lifecycle.js";
+async function openAttempt(options, request) {
+    const opened = await openHttpBody(options.transport, request, options.lifecycle.signal);
+    return { opened, request };
+}
+async function responseError(opened, lifecycle) {
+    try {
+        const body = await readCommandCodeErrorBody(opened.chunks);
+        return commandCodeHttpError(opened.status, body);
+    }
+    catch (error) {
+        lifecycle.abort();
+        throw error;
+    }
+}
+function successful(opened) {
+    return opened.status >= 200 && opened.status < 300;
+}
+export async function openCommandCodeGeneration(options) {
+    const firstRequest = options.createRequest(options.initialToken);
+    const first = await openAttempt(options, firstRequest);
+    if (successful(first.opened))
+        return first;
+    const firstError = await responseError(first.opened, options.lifecycle);
+    if (first.opened.status !== 401)
+        throw firstError;
+    const reloadedToken = await options.readAccessToken(options.lifecycle.signal);
+    if (options.lifecycle.signal.aborted) {
+        throw new OperationCancelledError("command-code-stream");
+    }
+    if (reloadedToken === null)
+        throw firstError;
+    const candidateRequest = options.createRequest(reloadedToken);
+    if (candidateRequest.headers["authorization"] === firstRequest.headers["authorization"]) {
+        throw firstError;
+    }
+    const second = await openAttempt(options, candidateRequest);
+    if (successful(second.opened))
+        return second;
+    throw await responseError(second.opened, options.lifecycle);
+}

package/dist/providers/cursor/credential-retry.d.ts

@@ -0,0 +1,14 @@
+import type { CursorReplayState } from "./recovery.js";
+export declare function isCursorCredentialRetryEligible(input: {
+    readonly error: unknown;
+    readonly replay: CursorReplayState;
+    readonly retryUsed: boolean;
+}): boolean;
+export type CursorCredentialRetry = {
+    readonly currentToken: () => string;
+    readonly reload: (error: unknown, replay: CursorReplayState, signal: AbortSignal) => Promise<boolean>;
+};
+export declare function createCursorCredentialRetry(options: {
+    readonly initialToken: string;
+    readonly reloadAccessToken: (signal: AbortSignal) => Promise<string | null>;
+}): CursorCredentialRetry;

package/dist/providers/cursor/credential-retry.js

@@ -0,0 +1,26 @@
+import { CursorDirectStreamError } from "./direct-stream.js";
+export function isCursorCredentialRetryEligible(input) {
+    return (!input.retryUsed &&
+        input.error instanceof CursorDirectStreamError &&
+        input.error.bridgeCode === "http-401" &&
+        input.replay.outputEpoch === 0 &&
+        input.replay.checkpointEpoch === null &&
+        !input.replay.toolBoundary);
+}
+export function createCursorCredentialRetry(options) {
+    let currentToken = options.initialToken;
+    let retryUsed = false;
+    return {
+        currentToken: () => currentToken,
+        reload: async (error, replay, signal) => {
+            if (!isCursorCredentialRetryEligible({ error, replay, retryUsed }))
+                return false;
+            retryUsed = true;
+            const reloadedToken = await options.reloadAccessToken(signal);
+            if (reloadedToken === null || reloadedToken === currentToken)
+                return false;
+            currentToken = reloadedToken;
+            return true;
+        },
+    };
+}

package/dist/providers/cursor/direct-run-failure.d.ts

@@ -0,0 +1,8 @@
+import type { CursorDirectSetupCleanup } from "./direct-run-types.js";
+import type { CursorRunSession } from "./run-session.js";
+import type { CursorStreamAdapter } from "./stream-adapter.js";
+export declare function retireCursorSessionForRetry(session: CursorRunSession, cause: unknown): Promise<void>;
+export declare function failCursorDirectRun(logical: {
+    readonly adapter: CursorStreamAdapter;
+    readonly cleanup: CursorDirectSetupCleanup;
+}, session: CursorRunSession | null, error: unknown): Promise<void>;

package/dist/providers/cursor/direct-run-failure.js

@@ -0,0 +1,26 @@
+export async function retireCursorSessionForRetry(session, cause) {
+    try {
+        const retireForRetry = session.retireForRetry;
+        if (retireForRetry === undefined)
+            throw new TypeError("retry retirement is unavailable");
+        await retireForRetry();
+    }
+    catch (retirementError) {
+        throw new AggregateError([cause, retirementError], "Cursor retry retirement failed");
+    }
+}
+export async function failCursorDirectRun(logical, session, error) {
+    try {
+        if (session === null) {
+            logical.cleanup.invalidateCheckpoint();
+            logical.cleanup.invalidateSession();
+        }
+        else
+            await session.abort();
+    }
+    catch (cleanupError) {
+        logical.adapter.fail(new AggregateError([error, cleanupError], "Cursor recovery cleanup failed"));
+        return;
+    }
+    logical.adapter.fail(error);
+}

package/dist/providers/cursor/direct-run-types.d.ts

@@ -25,6 +25,7 @@ export type CursorDirectRunOptions = {
     readonly createSetupCleanup?: (resources: CursorDirectSetupCleanupResources) => CursorDirectSetupCleanup;
     readonly idleTimeoutMs: number;
     readonly modelId: string;
+    readonly reloadAccessToken: (signal: AbortSignal) => Promise<string | null>;
     readonly registry: CursorRunSessionRegistry;
     readonly signal: AbortSignal;
     readonly token: string;

package/dist/providers/cursor/direct-run.js

@@ -3,6 +3,8 @@ import { parseModelId } from "../../core/ids.js";
 import { createCursorBlobStore } from "./blob-store.js";
 import { createCursorCheckpointStore } from "./checkpoint-store.js";
 import { encodeConnectFrame } from "./connect-frame.js";
+import { createCursorCredentialRetry } from "./credential-retry.js";
+import { failCursorDirectRun, retireCursorSessionForRetry } from "./direct-run-failure.js";
 import { consumeCursorDirectAttempt, isCursorRetryableStreamError } from "./direct-stream.js";
 import { cursorMcpDefinitions } from "./exec-reply.js";
 import { cursorPromptText } from "./prompt.js";
@@ -76,13 +78,13 @@ function buildRequest(options, logical, mode) {
             },
     });
 }
-async function openAttempt(options, logical, mode) {
-    const request = buildRequest(options, logical, mode);
+async function openAttempt(options, logical, attempt) {
+    const request = buildRequest(options, logical, attempt.mode);
     let stream = null;
     try {
         stream = await options.bridge.open({
             id: options.createId(),
-            accessToken: options.token,
+            accessToken: attempt.token,
             path: CURSOR_RUN_PATH,
             headers: { "content-type": "application/connect+proto", "connect-protocol-version": "1" },
             signal: options.signal,
@@ -123,27 +125,19 @@ async function openAttempt(options, logical, mode) {
         throw error;
     }
 }
-async function failRun(logical, session, error) {
-    try {
-        if (session === null) {
-            logical.cleanup.invalidateCheckpoint();
-            logical.cleanup.invalidateSession();
-        }
-        else
-            await session.abort();
-    }
-    catch (cleanupError) {
-        logical.adapter.fail(new AggregateError([error, cleanupError], "Cursor recovery cleanup failed"));
-        return;
-    }
-    logical.adapter.fail(error);
-}
 export async function startCursorDirectRun(options) {
     const logical = createLogicalRun(options);
     const planner = createCursorRecoveryPlanner();
+    const credential = createCursorCredentialRetry({
+        initialToken: options.token,
+        reloadAccessToken: options.reloadAccessToken,
+    });
     let session;
     try {
-        session = await openAttempt(options, logical, "initial");
+        session = await openAttempt(options, logical, {
+            mode: "initial",
+            token: credential.currentToken(),
+        });
     }
     catch (error) {
         logical.cleanup.releaseOwnership();
@@ -177,7 +171,25 @@ export async function startCursorDirectRun(options) {
                 const idle = watchdog.expired();
                 watchdog.dispose();
                 if (options.signal.aborted) {
-                    await failRun(logical, session, new OperationCancelledError("cursor-direct-stream"));
+                    await failCursorDirectRun(logical, session, new OperationCancelledError("cursor-direct-stream"));
+                    return;
+                }
+                try {
+                    const changed = await credential.reload(error, logical.adapter.replayState(), options.signal);
+                    if (options.signal.aborted)
+                        throw new OperationCancelledError("cursor-direct-stream");
+                    if (changed) {
+                        await retireCursorSessionForRetry(session, error);
+                        session = null;
+                        session = await openAttempt(options, logical, {
+                            mode: "initial",
+                            token: credential.currentToken(),
+                        });
+                        continue;
+                    }
+                }
+                catch (retryError) {
+                    await failCursorDirectRun(logical, session, retryError);
                     return;
                 }
                 const decision = planner.next({
@@ -190,20 +202,21 @@ export async function startCursorDirectRun(options) {
                         planner.requireRetry(decision, error);
                     }
                     catch (recoveryError) {
-                        await failRun(logical, session, recoveryError);
+                        await failCursorDirectRun(logical, session, recoveryError);
                     }
                     return;
                 }
                 try {
-                    const retireForRetry = session.retireForRetry;
-                    if (retireForRetry === undefined)
-                        throw new TypeError("retry retirement is unavailable");
-                    await retireForRetry();
+                    await retireCursorSessionForRetry(session, error);
+                    session = null;
                     logical.adapter.suspendForRetry();
-                    session = await openAttempt(options, logical, decision.mode);
+                    session = await openAttempt(options, logical, {
+                        mode: decision.mode,
+                        token: credential.currentToken(),
+                    });
                 }
                 catch (retryError) {
-                    await failRun(logical, session, retryError);
+                    await failCursorDirectRun(logical, session, retryError);
                     return;
                 }
             }

package/dist/providers/cursor/direct-runtime.js

@@ -41,7 +41,9 @@ export function createCursorDirectRuntime(options) {
         return bridgeClient;
     };
     const doStream = async (call, modelId) => {
-        const signal = call.abortSignal ?? new AbortController().signal;
+        const signal = call.abortSignal === undefined
+            ? lifecycle.signal
+            : AbortSignal.any([lifecycle.signal, call.abortSignal]);
         if (signal.aborted)
             throw new OperationCancelledError("cursor-direct-stream");
         const resultCallIds = [];
@@ -59,46 +61,31 @@ export function createCursorDirectRuntime(options) {
             await existing.writeContinuations(continuations, signal);
             return { stream: await consumeCursorDirectSession({ session: existing, signal, registry }) };
         }
-        const setup = new AbortController();
-        const cancel = () => {
-            if (!setup.signal.aborted) {
-                setup.abort(new OperationCancelledError("cursor-direct-stream"));
-            }
-        };
-        lifecycle.signal.addEventListener("abort", cancel, { once: true });
-        call.abortSignal?.addEventListener("abort", cancel, { once: true });
-        if (lifecycle.signal.aborted || signal.aborted)
-            cancel();
-        try {
-            const token = await options.readAccessToken(setup.signal);
-            if (setup.signal.aborted)
-                throw new OperationCancelledError("cursor-direct-stream");
-            if (token === null)
-                throw cursorFailure("cursor-auth-unavailable");
-            return await startCursorDirectRun({
-                bridge: await bridge(),
-                call,
-                clock: options.clock,
-                createId,
-                idleTimeoutMs: options.idleTimeoutMs ?? 60_000,
-                modelId,
-                registry,
-                signal,
-                token,
-                tools: toolsFromCall(call),
-                ttlMs: options.ttlMs ?? 300_000,
-                ...(options.createSetupCleanup === undefined
-                    ? {}
-                    : { createSetupCleanup: options.createSetupCleanup }),
-            });
-        }
-        finally {
-            lifecycle.signal.removeEventListener("abort", cancel);
-            call.abortSignal?.removeEventListener("abort", cancel);
-        }
+        const token = await options.readAccessToken(signal);
+        if (signal.aborted)
+            throw new OperationCancelledError("cursor-direct-stream");
+        if (token === null)
+            throw cursorFailure("cursor-auth-unavailable");
+        return await startCursorDirectRun({
+            bridge: await bridge(),
+            call,
+            clock: options.clock,
+            createId,
+            idleTimeoutMs: options.idleTimeoutMs ?? 60_000,
+            modelId,
+            reloadAccessToken: options.readAccessToken,
+            registry,
+            signal,
+            token,
+            tools: toolsFromCall(call),
+            ttlMs: options.ttlMs ?? 300_000,
+            ...(options.createSetupCleanup === undefined
+                ? {}
+                : { createSetupCleanup: options.createSetupCleanup }),
+        });
     };
     const disposal = createAsyncDisposable(async () => {
-        lifecycle.abort();
+        lifecycle.abort(new OperationCancelledError("cursor-direct-stream"));
         await settleCursorCleanup([
             registry.dispose,
             async () => {

package/dist/providers/cursor/run-session.js

@@ -150,12 +150,12 @@ export function createCursorRunSessionRegistry(_options) {
             retireForRetry: async () => {
                 if (resources.dispatcher.parkedCalls.size > 0 || reserved.size > 0)
                     throw new CursorRunSessionError("retry-boundary");
-                retired = true;
                 cancelTimer();
                 sessions.delete(identity.sessionId);
                 removeOwnership(identity.sessionId);
                 resources.dispatcher.parkedCalls.clear();
                 await settleCursorCleanup([resources.stream.abort, resources.ownership.release]);
+                retired = true;
             },
             dispose: disposal.dispose,
         };