opencode-ext-connector 0.3.3 → 0.5.0

package/dist/opencode/ollama-production.d.ts

@@ -1,4 +1,11 @@
 import { type OllamaCatalogState } from "../providers/ollama/catalog-state.js";
+import { type OllamaEndpoints } from "../providers/ollama/endpoints.js";
 import { type OllamaRuntime } from "../providers/ollama/runtime.js";
+export type ProductionOllamaBundle = {
+    readonly endpoints: OllamaEndpoints;
+    readonly catalog: OllamaCatalogState;
+    readonly runtime: OllamaRuntime;
+};
+export declare function getProductionOllamaBundle(input?: unknown): ProductionOllamaBundle;
 export declare const productionOllamaCatalog: OllamaCatalogState;
 export declare const productionOllamaRuntime: OllamaRuntime;

package/dist/opencode/ollama-production.js

@@ -1,10 +1,22 @@
 import { createOllamaCatalogState, } from "../providers/ollama/catalog-state.js";
+import { parseOllamaEndpoints } from "../providers/ollama/endpoints.js";
 import { productionOllamaFetch } from "../providers/ollama/http.js";
 import { createOllamaRuntime } from "../providers/ollama/runtime.js";
-export const productionOllamaCatalog = createOllamaCatalogState({
-    fetch: productionOllamaFetch,
-});
-export const productionOllamaRuntime = createOllamaRuntime({
-    catalog: productionOllamaCatalog,
-    fetch: productionOllamaFetch,
-});
+const bundles = new Map();
+export function getProductionOllamaBundle(input) {
+    const endpoints = parseOllamaEndpoints(input);
+    const existing = bundles.get(endpoints.baseURL);
+    if (existing !== undefined)
+        return existing;
+    const catalog = createOllamaCatalogState({ fetch: productionOllamaFetch });
+    const bundle = Object.freeze({
+        endpoints,
+        catalog,
+        runtime: createOllamaRuntime({ endpoints, catalog, fetch: productionOllamaFetch }),
+    });
+    bundles.set(endpoints.baseURL, bundle);
+    return bundle;
+}
+const defaultBundle = getProductionOllamaBundle();
+export const productionOllamaCatalog = defaultBundle.catalog;
+export const productionOllamaRuntime = defaultBundle.runtime;

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/process/production-supervisor.d.ts

@@ -0,0 +1,20 @@
+import type { ProcessCommand, ProcessExit, ProcessSupervisor } from "../core/process.js";
+export type ProcessSpawnOptions = {
+    readonly shell: false;
+    readonly stdio: "ignore";
+    readonly windowsHide: true;
+};
+export interface SpawnedChild {
+    readonly exitCode: number | null;
+    readonly signalCode: string | null;
+    onSpawn(listener: () => void): () => void;
+    onError(listener: (error: Error) => void): () => void;
+    onExit(listener: (exit: ProcessExit) => void): () => void;
+    kill(signal: "SIGTERM" | "SIGKILL"): boolean;
+}
+export type ProcessSpawn = (command: ProcessCommand, options: ProcessSpawnOptions) => SpawnedChild;
+export type ProductionProcessSupervisorOptions = {
+    readonly spawn?: ProcessSpawn;
+    readonly terminationGraceMs?: number;
+};
+export declare function createProductionProcessSupervisor(options?: ProductionProcessSupervisorOptions): ProcessSupervisor;

package/dist/process/production-supervisor.js

@@ -0,0 +1,171 @@
+import { spawn } from "node:child_process";
+import { OperationCancelledError, ProcessSupervisorError, ResourceDisposedError, } from "../core/errors.js";
+import { createAsyncDisposable } from "../core/lifecycle.js";
+const spawnOptions = {
+    shell: false,
+    stdio: "ignore",
+    windowsHide: true,
+};
+function spawnNodeChild(command, options) {
+    const child = spawn(command.executable, [...command.arguments], {
+        cwd: command.cwd ?? undefined,
+        shell: options.shell,
+        stdio: options.stdio,
+        windowsHide: options.windowsHide,
+    });
+    return {
+        get exitCode() {
+            return child.exitCode;
+        },
+        get signalCode() {
+            return child.signalCode;
+        },
+        onSpawn: (listener) => {
+            child.once("spawn", listener);
+            return () => child.removeListener("spawn", listener);
+        },
+        onError: (listener) => {
+            child.once("error", listener);
+            return () => child.removeListener("error", listener);
+        },
+        onExit: (listener) => {
+            const onExit = (code, signal) => {
+                listener(code === null ? { kind: "signal", signal: signal ?? "unknown" } : { kind: "code", code });
+            };
+            child.once("exit", onExit);
+            return () => child.removeListener("exit", onExit);
+        },
+        kill: (signal) => child.kill(signal),
+    };
+}
+function processFailure(operation, cause) {
+    return new ProcessSupervisorError({ operation, retryable: true, cause });
+}
+class ProductionSupervisedProcess {
+    completion;
+    spawned;
+    disposal;
+    constructor(child, terminationGraceMs) {
+        this.spawned = new Promise((resolve, reject) => {
+            const removeSpawn = child.onSpawn(() => {
+                removeError();
+                resolve();
+            });
+            const removeError = child.onError((error) => {
+                removeSpawn();
+                reject(processFailure("spawn", error));
+            });
+        });
+        this.completion = new Promise((resolve, reject) => {
+            const removeExit = child.onExit((exit) => {
+                removeError();
+                resolve(exit);
+            });
+            const removeError = child.onError((error) => {
+                removeExit();
+                reject(processFailure("wait", error));
+            });
+        });
+        this.disposal = createAsyncDisposable(async () => {
+            if (child.exitCode !== null || child.signalCode !== null)
+                return;
+            child.kill("SIGTERM");
+            let timer;
+            await Promise.race([
+                this.completion,
+                new Promise((resolve) => {
+                    timer = setTimeout(resolve, terminationGraceMs);
+                    timer.unref();
+                }),
+            ]);
+            if (timer !== undefined)
+                clearTimeout(timer);
+            if (child.exitCode === null && child.signalCode === null) {
+                if (!child.kill("SIGKILL"))
+                    throw processFailure("terminate", null);
+                await this.completion;
+            }
+        });
+    }
+    ready(signal) {
+        return this.raceCancellation(this.spawned, signal, "start-process");
+    }
+    wait(signal) {
+        return this.raceCancellation(this.completion, signal, "wait-process");
+    }
+    terminate() {
+        return this.disposal.dispose();
+    }
+    dispose() {
+        return this.disposal.dispose();
+    }
+    [Symbol.asyncDispose]() {
+        return this.disposal.dispose();
+    }
+    raceCancellation(operation, signal, name) {
+        if (signal.aborted)
+            return Promise.reject(new OperationCancelledError(name));
+        const deferred = Promise.withResolvers();
+        const onAbort = () => deferred.reject(new OperationCancelledError(name));
+        signal.addEventListener("abort", onAbort, { once: true });
+        operation.then((value) => {
+            signal.removeEventListener("abort", onAbort);
+            deferred.resolve(value);
+        }, (error) => {
+            signal.removeEventListener("abort", onAbort);
+            deferred.reject(error);
+        });
+        return deferred.promise;
+    }
+}
+export function createProductionProcessSupervisor(options = {}) {
+    const spawnProcess = options.spawn ?? spawnNodeChild;
+    const terminationGraceMs = options.terminationGraceMs ?? 1_000;
+    const active = new Set();
+    const disposalController = new AbortController();
+    let disposalStarted = false;
+    const disposal = createAsyncDisposable(async () => {
+        disposalStarted = true;
+        disposalController.abort();
+        await Promise.all([...active].map((process) => process.terminate()));
+    });
+    const start = async (command, signal) => {
+        if (signal.aborted)
+            throw new OperationCancelledError("start-process");
+        if (disposalStarted)
+            throw new ResourceDisposedError("process-supervisor");
+        let child;
+        try {
+            child = spawnProcess(command, spawnOptions);
+        }
+        catch (error) {
+            throw processFailure("spawn", error);
+        }
+        const process = new ProductionSupervisedProcess(child, terminationGraceMs);
+        active.add(process);
+        try {
+            await process.ready(AbortSignal.any([signal, disposalController.signal]));
+            if (disposalStarted) {
+                await process.terminate();
+                throw new ResourceDisposedError("process-supervisor");
+            }
+            return process;
+        }
+        catch (error) {
+            active.delete(process);
+            if (error instanceof OperationCancelledError)
+                await process.terminate();
+            if (disposalStarted)
+                throw new ResourceDisposedError("process-supervisor");
+            throw error;
+        }
+        finally {
+            void process.wait(new AbortController().signal).then(() => active.delete(process), () => active.delete(process));
+        }
+    };
+    return {
+        start,
+        dispose: disposal.dispose,
+        [Symbol.asyncDispose]: disposal[Symbol.asyncDispose],
+    };
+}

package/dist/providers/claude/credential-authority-scheduler.d.ts

@@ -0,0 +1,23 @@
+import type { Clock } from "../../core/clock.js";
+import { type AsyncDisposableHandle } from "../../core/lifecycle.js";
+import type { ConnectorLogger } from "../../core/logger.js";
+import type { ProcessSupervisor } from "../../core/process.js";
+import type { ClaudeCredentials } from "./credentials.js";
+export type ClaudeCredentialReader = (env: Readonly<Record<string, string | undefined>>, signal: AbortSignal) => Promise<ClaudeCredentials | null>;
+export type ClaudeCredentialAuthorityEnvironment = Readonly<Record<string, string | undefined>> & {
+    readonly HOME?: string;
+    readonly XDG_STATE_HOME?: string;
+};
+export type ClaudeCredentialAuthoritySchedulerOptions = {
+    readonly enabled: boolean;
+    readonly platform?: string;
+    readonly clock: Clock;
+    readonly leadMs: number;
+    readonly retryMs: number;
+    readonly env: ClaudeCredentialAuthorityEnvironment;
+    readonly processSupervisor: ProcessSupervisor;
+    readonly logger: ConnectorLogger;
+    readonly readCredentials?: ClaudeCredentialReader;
+    readonly ensureStateDirectory?: (path: string) => Promise<void>;
+};
+export declare function createClaudeCredentialAuthorityScheduler(options: ClaudeCredentialAuthoritySchedulerOptions): AsyncDisposableHandle;

package/dist/providers/claude/credential-authority-scheduler.js

@@ -0,0 +1,181 @@
+import { mkdir } from "node:fs/promises";
+import { isAbsolute, join } from "node:path";
+import { InvalidArgumentError, OperationCancelledError, ProcessSupervisorError, } from "../../core/errors.js";
+import { createAsyncDisposable } from "../../core/lifecycle.js";
+import { readClaudeCredentials } from "./auth.js";
+const AUTHORITY_DIRECTORY = "claude-credential-authority";
+const LOCK_FILE = "authority.lock";
+const LOCK_CONFLICT_EXIT_CODE = 75;
+const MAXIMUM_DELAY_MS = 2_147_483_647;
+const AUTHORITY_PROMPT = "Reply OK without using tools.";
+function authorityStateDirectory(env) {
+    const configuredState = env.XDG_STATE_HOME;
+    if (configuredState !== undefined && configuredState.length > 0 && isAbsolute(configuredState)) {
+        return join(configuredState, "opencode-ext-connector", AUTHORITY_DIRECTORY);
+    }
+    const home = env.HOME;
+    if (home === undefined || home.length === 0 || !isAbsolute(home))
+        return null;
+    return join(home, ".local", "state", "opencode-ext-connector", AUTHORITY_DIRECTORY);
+}
+async function createStateDirectory(path) {
+    await mkdir(path, { recursive: true, mode: 0o700 });
+}
+function assertNeverProcessExit(exit) {
+    throw new InvalidArgumentError("processExit", exit);
+}
+export function createClaudeCredentialAuthorityScheduler(options) {
+    if (!Number.isSafeInteger(options.leadMs) || options.leadMs < 0) {
+        throw new InvalidArgumentError("leadMs");
+    }
+    if (!Number.isSafeInteger(options.retryMs) || options.retryMs <= 0) {
+        throw new InvalidArgumentError("retryMs");
+    }
+    if (!options.enabled || (options.platform ?? process.platform) !== "linux") {
+        return createAsyncDisposable(() => undefined);
+    }
+    const controller = new AbortController();
+    const readCredentials = options.readCredentials ?? readClaudeCredentials;
+    const ensureStateDirectory = options.ensureStateDirectory ?? createStateDirectory;
+    const stateDirectory = authorityStateDirectory(options.env);
+    let scheduled;
+    let activeProcess;
+    let activeEvaluation;
+    let disposalStarted = false;
+    const arm = (delayMs) => {
+        if (disposalStarted)
+            return;
+        scheduled?.cancel();
+        scheduled = options.clock.schedule(Math.min(MAXIMUM_DELAY_MS, Math.max(0, Math.trunc(delayMs))), () => {
+            scheduled = undefined;
+            startEvaluation(true);
+        });
+    };
+    const runAuthority = async () => {
+        if (stateDirectory === null)
+            return null;
+        await ensureStateDirectory(stateDirectory);
+        const process = await options.processSupervisor.start({
+            executable: "flock",
+            arguments: [
+                "--exclusive",
+                "--nonblock",
+                "--conflict-exit-code",
+                String(LOCK_CONFLICT_EXIT_CODE),
+                "--no-fork",
+                "--",
+                join(stateDirectory, LOCK_FILE),
+                "claude",
+                "--restricted",
+                "-p",
+                AUTHORITY_PROMPT,
+                "--permission-prompts",
+                "none",
+                "--max-turns",
+                "1",
+                "--output-format",
+                "json",
+            ],
+            cwd: stateDirectory,
+        }, controller.signal);
+        activeProcess = process;
+        try {
+            return await process.wait(controller.signal);
+        }
+        finally {
+            activeProcess = undefined;
+            await process.dispose();
+        }
+    };
+    const evaluate = async (canInvoke) => {
+        const credentials = await readCredentials(options.env, controller.signal);
+        if (disposalStarted)
+            return;
+        const expiresAtMs = credentials?.expiresAtMs ?? null;
+        if (expiresAtMs === null) {
+            arm(options.retryMs);
+            return;
+        }
+        const untilLeadMs = expiresAtMs - options.leadMs - options.clock.nowMs();
+        if (untilLeadMs > 0) {
+            arm(untilLeadMs);
+            return;
+        }
+        if (!canInvoke) {
+            arm(options.retryMs);
+            return;
+        }
+        const exit = await runAuthority();
+        if (disposalStarted)
+            return;
+        if (exit === null) {
+            options.logger.log("warn", "claude.credential-authority.state-unavailable", {});
+            arm(options.retryMs);
+            return;
+        }
+        switch (exit.kind) {
+            case "signal":
+                options.logger.log("warn", "claude.credential-authority.signal-exit", {
+                    signal: exit.signal,
+                });
+                arm(options.retryMs);
+                return;
+            case "code":
+                if (exit.code === LOCK_CONFLICT_EXIT_CODE) {
+                    arm(options.retryMs);
+                    return;
+                }
+                if (exit.code !== 0) {
+                    options.logger.log("warn", "claude.credential-authority.nonzero-exit", {
+                        exitCode: exit.code,
+                    });
+                    arm(options.retryMs);
+                    return;
+                }
+                await evaluate(false);
+                return;
+            default:
+                return assertNeverProcessExit(exit);
+        }
+    };
+    const startEvaluation = (canInvoke) => {
+        if (disposalStarted || activeEvaluation !== undefined)
+            return;
+        const operation = evaluate(canInvoke).catch((error) => {
+            if (error instanceof OperationCancelledError && disposalStarted)
+                return;
+            if (error instanceof ProcessSupervisorError) {
+                options.logger.log("warn", "claude.credential-authority.process-failed", {});
+                arm(options.retryMs);
+                return;
+            }
+            if (error instanceof Error) {
+                options.logger.log("warn", "claude.credential-authority.evaluation-failed", {});
+                arm(options.retryMs);
+                return;
+            }
+            throw error;
+        });
+        activeEvaluation = operation;
+        void operation.then(() => {
+            if (activeEvaluation === operation)
+                activeEvaluation = undefined;
+        }, () => {
+            if (activeEvaluation === operation)
+                activeEvaluation = undefined;
+        });
+    };
+    const disposal = createAsyncDisposable(async () => {
+        disposalStarted = true;
+        scheduled?.cancel();
+        scheduled = undefined;
+        controller.abort();
+        await activeProcess?.terminate();
+        await activeEvaluation;
+    });
+    startEvaluation(true);
+    return {
+        dispose: disposal.dispose,
+        [Symbol.asyncDispose]: disposal[Symbol.asyncDispose],
+    };
+}