cursor-opencode-provider 0.2.9 → 0.3.0

package/dist/opencode2/types.d.ts

@@ -0,0 +1,316 @@
+/**
+ * Local structural types for the OpenCode 2.0 beta plugin API.
+ *
+ * Why not import from `@opencode-ai/plugin`?
+ *   • The 2.0 types live on the `@next` dist-tag (`0.0.0-next-*`), which cannot
+ *     coexist with this package's existing `@opencode-ai/plugin@^1.17.13`
+ *     dependency under the same module specifier.
+ *   • 2.0 is beta and its schema churns; a hand-maintained subset of only what
+ *     we touch is more stable than pinning a moving target.
+ *
+ * These mirror `@opencode-ai/plugin@next` `dist/promise/*.d.ts` as of
+ * `0.0.0-next-16281`. `test/opencode2-conformance.test-d.ts` asserts our
+ * default export still satisfies the real 2.0 `Plugin` interface.
+ *
+ * Effect `Schema` brands (Provider.ID, Model.ID, …) are modelled as plain
+ * `string`; brands are compile-time only and erase at runtime.
+ */
+export type Registration = {
+    readonly dispose: () => Promise<void>;
+};
+export type Hooks<Spec> = <Name extends keyof Spec>(name: Name, callback: (input: Spec[Name]) => Promise<void> | void) => Promise<Registration>;
+export type Transform<Input> = (callback: (input: Input) => void) => Promise<Registration>;
+export type ProviderInfo = {
+    id: string;
+    name: string;
+    /** `"aisdk:<pkg>"` selects the AI SDK path; a bare specifier selects native. */
+    package: string;
+    integrationID?: string;
+    disabled?: boolean;
+    settings?: Record<string, any>;
+    headers?: Record<string, string>;
+    body?: Record<string, any>;
+};
+export type ModelVariantInfo = {
+    id: string;
+    settings?: Record<string, any>;
+    headers?: Record<string, string>;
+    body?: Record<string, any>;
+};
+export type ModelInfo2 = {
+    id: string;
+    /** Wire id sent to the provider. Lets one Cursor model back several entries. */
+    modelID: string;
+    providerID: string;
+    name: string;
+    family?: string;
+    capabilities: {
+        tools: boolean;
+        input: readonly string[];
+        output: readonly string[];
+    };
+    variants: readonly ModelVariantInfo[];
+    time: {
+        released: number;
+    };
+    cost: readonly unknown[];
+    status: "alpha" | "beta" | "deprecated" | "active";
+    enabled: boolean;
+    limit: {
+        context: number;
+        input?: number;
+        output: number;
+    };
+    settings?: Record<string, any>;
+    headers?: Record<string, string>;
+    body?: Record<string, any>;
+    package?: string;
+};
+export type CredentialOAuth = {
+    type: "oauth";
+    methodID: string;
+    refresh: string;
+    access: string;
+    expires: number;
+    metadata?: Record<string, unknown>;
+};
+export type CredentialKey = {
+    type: "key";
+    key: string;
+    metadata?: Record<string, unknown>;
+};
+export type CredentialValue = CredentialOAuth | CredentialKey;
+export type ConnectionInfo = {
+    type: "credential";
+    id: string;
+    label: string;
+} | {
+    type: "env";
+    name: string;
+};
+/**
+ * Read accessors we never call are intentionally loose (`any`). Modelling the
+ * host's Effect-schema records exactly would make the conformance guard churn on
+ * unrelated upstream edits without protecting anything we depend on. The
+ * `update` signatures — the ones we actually build the catalog with — stay precise.
+ */
+export type CatalogDraft = {
+    readonly provider: {
+        list(): readonly any[];
+        get(providerID: string): any;
+        /** Upsert: creates the provider when absent. */
+        update(providerID: string, update: (provider: ProviderInfo) => void): void;
+        remove(providerID: string): void;
+    };
+    readonly model: {
+        get(providerID: string, modelID: string): any;
+        /** Upsert: creates provider and/or model when absent. */
+        update(providerID: string, modelID: string, update: (model: ModelInfo2) => void): void;
+        remove(providerID: string, modelID: string): void;
+        readonly default: {
+            get(): {
+                providerID: string;
+                modelID: string;
+            } | undefined;
+            set(providerID: string, modelID: string): void;
+        };
+    };
+};
+export type CatalogDomain = {
+    readonly transform: Transform<CatalogDraft>;
+    readonly reload: () => Promise<void>;
+};
+export type IntegrationTextPrompt = {
+    type: "text";
+    key: string;
+    message: string;
+    placeholder?: string;
+};
+export type IntegrationOAuthMethod = {
+    id: string;
+    type: "oauth";
+    label: string;
+    prompts?: IntegrationTextPrompt[];
+};
+export type IntegrationKeyMethod = {
+    type: "key";
+    label?: string;
+};
+export type IntegrationEnvMethod = {
+    type: "env";
+    names: string[];
+};
+export type IntegrationMethod = IntegrationOAuthMethod | IntegrationKeyMethod | IntegrationEnvMethod;
+export type IntegrationOAuthAuthorization = {
+    readonly url: string;
+    readonly instructions: string;
+    readonly expiresAt?: number;
+} & ({
+    readonly mode: "auto";
+    readonly callback: Promise<CredentialOAuth>;
+} | {
+    readonly mode: "code";
+    readonly callback: (code: string) => Promise<CredentialOAuth>;
+});
+export type IntegrationOAuthMethodRegistration = {
+    readonly integrationID: string;
+    readonly method: IntegrationOAuthMethod;
+    readonly authorize: (inputs: Record<string, string>) => Promise<IntegrationOAuthAuthorization>;
+    readonly refresh?: (credential: CredentialOAuth) => Promise<CredentialOAuth>;
+    readonly label?: (credential: CredentialOAuth) => string | undefined;
+};
+export type IntegrationMethodRegistration = IntegrationOAuthMethodRegistration | {
+    readonly integrationID: string;
+    readonly method: IntegrationKeyMethod;
+} | {
+    readonly integrationID: string;
+    readonly method: IntegrationEnvMethod;
+};
+export type IntegrationRef = {
+    id: string;
+    name: string;
+};
+export type IntegrationDraft = {
+    list(): readonly any[];
+    get(id: string): any;
+    update(id: string, update: (integration: IntegrationRef) => void): void;
+    remove(id: string): void;
+    readonly method: {
+        list(integrationID: string): readonly any[];
+        update(input: IntegrationMethodRegistration): void;
+        remove(integrationID: string, method: any): void;
+    };
+};
+export type IntegrationDomain = {
+    readonly transform: Transform<IntegrationDraft>;
+    readonly reload: () => Promise<void>;
+    readonly connection: {
+        readonly active: (integrationID: string) => Promise<ConnectionInfo | undefined>;
+        readonly resolve: (connection: ConnectionInfo) => Promise<CredentialValue | undefined>;
+    };
+};
+export type AISDKHooks = {
+    sdk: {
+        readonly model: ModelInfo2;
+        readonly package: string;
+        readonly options: Record<string, any>;
+        sdk?: any;
+    };
+    language: {
+        readonly model: ModelInfo2;
+        readonly sdk: any;
+        readonly options: Record<string, any>;
+        language?: unknown;
+    };
+};
+export type AISDKDomain = {
+    readonly hook: Hooks<AISDKHooks>;
+};
+export type ToolDefinition = {
+    readonly name: string;
+    readonly description: string;
+    readonly input: unknown;
+    readonly output?: unknown;
+    readonly execute: (input: any, context: any) => Promise<any>;
+};
+export type ToolDraft = {
+    add(tool: ToolDefinition): void;
+};
+export type ToolHookBase = {
+    readonly tool: string;
+    readonly sessionID: string;
+    readonly agent: string;
+    readonly messageID: string;
+    readonly callID: string;
+};
+export type ToolHooks = {
+    readonly "execute.before": ToolHookBase & {
+        input: unknown;
+    };
+    readonly "execute.after": ToolHookBase & {
+        readonly input: unknown;
+    } & ({
+        readonly status: "completed";
+        result: any;
+    } | {
+        readonly status: "error";
+        error: any;
+    });
+};
+export type ToolDomain = {
+    readonly transform: Transform<ToolDraft>;
+    readonly hook: Hooks<ToolHooks>;
+};
+export type SessionContext = {
+    readonly sessionID: string;
+    readonly agent: string;
+    readonly model: {
+        providerID: string;
+        id: string;
+        variant?: string;
+    };
+    system: Array<any>;
+    messages: Array<any>;
+    tools: Record<string, {
+        description: string;
+        input: unknown;
+    }>;
+};
+export type SessionHooks = {
+    readonly context: SessionContext;
+};
+/** Only the `location.directory` field we actually read; the rest of the real `SessionInfo` is loose. */
+export type SessionInfo = {
+    readonly id: string;
+    readonly location: {
+        readonly directory: string;
+    };
+};
+export type SessionDomain = {
+    readonly hook: Hooks<SessionHooks>;
+    readonly get: (input: {
+        sessionID: string;
+    }) => Promise<SessionInfo>;
+};
+export type WebSearchDefinition = {
+    readonly id: string;
+    readonly name: string;
+    readonly execute: (input: any, context: {
+        readonly signal: AbortSignal;
+    }) => Promise<readonly any[]>;
+};
+export type WebSearchDraft = {
+    add(definition: WebSearchDefinition): void;
+    readonly default: {
+        get(): string | undefined;
+        set(providerID: string): void;
+    };
+};
+export type WebSearchDomain = {
+    readonly transform: Transform<WebSearchDraft>;
+    readonly reload: () => Promise<void>;
+};
+export type EventDomain = {
+    readonly subscribe: (...args: any[]) => any;
+};
+export type App = {
+    readonly name: string;
+    readonly version: string;
+    readonly channel: string;
+};
+export type PluginContext = {
+    readonly app: App;
+    readonly options: Readonly<Record<string, any>>;
+    readonly aisdk: AISDKDomain;
+    readonly catalog: CatalogDomain;
+    readonly event: EventDomain;
+    readonly integration: IntegrationDomain;
+    readonly session: SessionDomain;
+    readonly tool: ToolDomain;
+    readonly websearch: WebSearchDomain;
+};
+export type Cleanup = () => Promise<void> | void;
+export type Plugin2 = {
+    readonly id: string;
+    readonly setup: (context: PluginContext) => Promise<Cleanup | void> | Cleanup | void;
+};

package/dist/opencode2/types.js

@@ -0,0 +1,18 @@
+/**
+ * Local structural types for the OpenCode 2.0 beta plugin API.
+ *
+ * Why not import from `@opencode-ai/plugin`?
+ *   • The 2.0 types live on the `@next` dist-tag (`0.0.0-next-*`), which cannot
+ *     coexist with this package's existing `@opencode-ai/plugin@^1.17.13`
+ *     dependency under the same module specifier.
+ *   • 2.0 is beta and its schema churns; a hand-maintained subset of only what
+ *     we touch is more stable than pinning a moving target.
+ *
+ * These mirror `@opencode-ai/plugin@next` `dist/promise/*.d.ts` as of
+ * `0.0.0-next-16281`. `test/opencode2-conformance.test-d.ts` asserts our
+ * default export still satisfies the real 2.0 `Plugin` interface.
+ *
+ * Effect `Schema` brands (Provider.ID, Model.ID, …) are modelled as plain
+ * `string`; brands are compile-time only and erase at runtime.
+ */
+export {};

package/dist/plugin-core.d.ts

@@ -0,0 +1,27 @@
+import { createCursorLanguageModel } from "./language-model.js";
+import type { CreateCursorOptions } from "./index.js";
+/**
+ * Runtime-agnostic pieces shared by every plugin surface:
+ *   • classic Hooks plugin      (`plugin.ts`)
+ *   • OpenCode 1.18 v2 plugin   (`plugin-v2.ts`)
+ *   • OpenCode 2.0 beta plugin  (`plugin-opencode2.ts`)
+ *
+ * Nothing here may import a host plugin API — the 1.18 and 2.0 APIs are
+ * source-incompatible, so anything host-shaped belongs in the entrypoint.
+ */
+/** Minimal AI SDK provider surface OpenCode expects from an `aisdk` package. */
+export type CursorSdk = {
+    languageModel(modelId: string): ReturnType<typeof createCursorLanguageModel>;
+};
+export declare function createSdk(options: CreateCursorOptions): CursorSdk;
+/**
+ * Whether an OpenCode `aisdk` package string refers to this provider.
+ *
+ * Matches on the provider id first (the common case once the catalog entry is
+ * ours), then on the package specifier so a bare `cursor-opencode-provider`,
+ * an `aisdk:`-prefixed form, or a resolved `dist/index.js` file URL all hit.
+ */
+export declare function isCursorPackage(pkg: string, providerID: string): boolean;
+/** API base for auth, model discovery, and GetServerConfig. */
+export declare function cursorApiBaseURL(): string;
+export declare function cursorGetServerConfigTelemetryEnabled(): boolean;

package/dist/plugin-core.js

@@ -0,0 +1,31 @@
+import { CURSOR_API_HOST, CURSOR_PROVIDER_ID } from "./shared.js";
+import { createCursorLanguageModel } from "./language-model.js";
+export function createSdk(options) {
+    const providerId = options.name || CURSOR_PROVIDER_ID;
+    return {
+        languageModel(modelId) {
+            return createCursorLanguageModel(modelId, providerId, options);
+        },
+    };
+}
+/**
+ * Whether an OpenCode `aisdk` package string refers to this provider.
+ *
+ * Matches on the provider id first (the common case once the catalog entry is
+ * ours), then on the package specifier so a bare `cursor-opencode-provider`,
+ * an `aisdk:`-prefixed form, or a resolved `dist/index.js` file URL all hit.
+ */
+export function isCursorPackage(pkg, providerID) {
+    if (providerID === CURSOR_PROVIDER_ID)
+        return true;
+    return (pkg.includes("cursor-opencode-provider") ||
+        /cursor-opencode-provider[/\\]dist[/\\]index\.js/.test(pkg));
+}
+/** API base for auth, model discovery, and GetServerConfig. */
+export function cursorApiBaseURL() {
+    return process.env.CURSOR_API_BASE_URL ?? `https://${CURSOR_API_HOST}`;
+}
+export function cursorGetServerConfigTelemetryEnabled() {
+    return (process.env.CURSOR_GET_SERVER_CONFIG_TELEMETRY === "1" ||
+        process.env.CURSOR_GET_SERVER_CONFIG_TELEMETRY === "true");
+}

package/dist/plugin-opencode2.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin2 } from "./opencode2/types.js";
+declare const plugin: Plugin2;
+export default plugin;

package/dist/plugin-opencode2.js

@@ -0,0 +1,293 @@
+import { CURSOR_PROVIDER_ID } from "./shared.js";
+import { createSdk, cursorApiBaseURL, cursorGetServerConfigTelemetryEnabled, isCursorPackage } from "./plugin-core.js";
+import { adoptCompatHostCacheDir, opencodeGlobalCacheDir } from "./context/paths.js";
+import { discoverModels, isCacheFresh, readCache } from "./models.js";
+import { resolveAgentUrl } from "./agent-url.js";
+import { sessionActivity } from "./activity.js";
+import { fetchOpenCodeWebSearchText } from "./web-tools.js";
+import { captureCursorShellResult, cursorShellOriginalCommand, prepareCursorShellArgs, releaseCursorShellEnv, sanitizeRegisteredCursorShellOutput, } from "./shell-timeout.js";
+import { applyCursorModels, applyCursorProvider } from "./opencode2/catalog.js";
+import { applyCursorIntegration, resolveCursorAccessToken } from "./opencode2/integration.js";
+import { markCompactionSession } from "./compaction-marker.js";
+import { markSessionDirectory } from "./session-directory.js";
+/**
+ * OpenCode 2.0 beta plugin.
+ *
+ * Separate from `plugin-v2.ts` on purpose: the OpenCode 1.18 `/v2/promise` API
+ * and the 2.0 API are source-incompatible (hook signatures, OAuth value type,
+ * provider schema), so they cannot share an entrypoint. Shared behavior lives in
+ * `plugin-core.ts`, `model-config.ts`, and `opencode2/*`.
+ *
+ * Load with:  { "plugins": ["cursor-opencode-provider/plugin/opencode2"] }
+ */
+async function loadModels(cacheDir, accessToken) {
+    const cached = await readCache(cacheDir);
+    if (cached?.models.length && isCacheFresh(cached))
+        return cached.models;
+    if (accessToken) {
+        try {
+            return await discoverModels(accessToken, cacheDir, { baseURL: cursorApiBaseURL() });
+        }
+        catch {
+            // Fall through to stale-on-failure below.
+        }
+    }
+    // Preserve offline / stale-cache behavior rather than emptying the picker.
+    return cached?.models ?? [];
+}
+const plugin = {
+    id: "cursor.provider",
+    setup: async (ctx) => {
+        // Prefer OCP HostProfile.cacheDir when present; else XDG host heuristic.
+        await adoptCompatHostCacheDir();
+        const cacheDir = opencodeGlobalCacheDir();
+        const registrations = [];
+        const track = async (p) => {
+            registrations.push(await p);
+        };
+        let models = [];
+        // ── Credentials ──────────────────────────────────────────────────────────
+        await track(ctx.integration.transform(applyCursorIntegration));
+        let cachedToken;
+        let tokenInflight;
+        /**
+         * Cache only a *successful* resolution.
+         *
+         * On a fresh install `setup()` runs before the user has connected, so the
+         * first attempt necessarily returns nothing. Memoizing that would pin the
+         * plugin to "no credentials" for the whole process and models would never
+         * load, even after a successful /connect.
+         */
+        const accessToken = async () => {
+            if (cachedToken)
+                return cachedToken;
+            tokenInflight ??= resolveCursorAccessToken(ctx.integration).finally(() => {
+                tokenInflight = undefined;
+            });
+            const token = await tokenInflight;
+            if (token)
+                cachedToken = token;
+            return token;
+        };
+        // ── Catalog ──────────────────────────────────────────────────────────────
+        // Runs now with whatever models we have (likely none) and is replayed by the
+        // host on every `catalog.reload()`, so the async fill below just re-triggers it.
+        await track(ctx.catalog.transform((draft) => {
+            applyCursorProvider(draft);
+            applyCursorModels(draft, models);
+        }));
+        // ── AI SDK wiring ────────────────────────────────────────────────────────
+        await track(ctx.aisdk.hook("sdk", async (event) => {
+            if (event.sdk)
+                return;
+            if (!isCursorPackage(event.package, event.model.providerID))
+                return;
+            const token = await accessToken();
+            event.sdk = createSdk({
+                name: event.model.providerID || CURSOR_PROVIDER_ID,
+                ...(token ? { accessToken: token } : {}),
+                // Static fallback only. This hook fires once per model/package, not
+                // per session, and 2.0 runs one daemon across many projects — the
+                // real per-request directory comes from the session.context hook
+                // below via `getSessionDirectory`, which `language-model.ts` prefers.
+                workspaceRoot: process.cwd(),
+                cacheDir,
+                ...event.options,
+            });
+        }));
+        await track(ctx.aisdk.hook("language", (event) => {
+            if (event.language)
+                return;
+            if (event.model.providerID !== CURSOR_PROVIDER_ID)
+                return;
+            if (typeof event.sdk?.languageModel !== "function")
+                return;
+            // `modelID` is the Cursor wire id; `id` may be a synthetic long-context entry.
+            event.language = event.sdk.languageModel(event.model.modelID || event.model.id);
+        }));
+        // ── Web search ───────────────────────────────────────────────────────────
+        // Registered as a tool, matching the classic plugin. 2.0 also has a
+        // first-class `websearch` domain, but its Result shape is structured
+        // ({url, title?, content?}) while the Exa backend here returns an opaque
+        // text blob — mapping one to the other would mean guessing Exa's payload
+        // shape, so the tool form stays until that can be verified against a live
+        // response.
+        await track(ctx.tool.transform((draft) => {
+            draft.add({
+                name: "custom_websearch",
+                description: "Search the web for current information using OpenCode's web search backend.",
+                input: {
+                    type: "object",
+                    properties: {
+                        query: { type: "string", description: "Web search query" },
+                        numResults: { type: "integer", minimum: 1, maximum: 20 },
+                        livecrawl: { type: "string", enum: ["fallback", "preferred"] },
+                        type: { type: "string", enum: ["auto", "fast", "deep"] },
+                        contextMaxCharacters: { type: "integer", exclusiveMinimum: 0 },
+                    },
+                    required: ["query"],
+                    additionalProperties: false,
+                },
+                execute: async (input, context) => {
+                    const output = await fetchOpenCodeWebSearchText(input, context?.abort);
+                    return {
+                        title: `Exa Web Search: ${input.query}`,
+                        output,
+                        metadata: { provider: "exa" },
+                    };
+                },
+            });
+        }));
+        // ── Shell timeout wrapper ────────────────────────────────────────────────
+        await track(ctx.tool.hook("execute.before", (event) => {
+            if (event.tool !== "bash")
+                return;
+            // No `shell.env` in 2.0 → always use the wrapper-file command form.
+            prepareCursorShellArgs(event.callID, event.input, {
+                preferWrapperCommand: true,
+            });
+        }));
+        await track(ctx.tool.hook("execute.after", (event) => {
+            if (event.tool !== "bash")
+                return;
+            try {
+                if (event.status !== "completed")
+                    return;
+                const result = event.result;
+                result.title = cursorShellOriginalCommand(event.callID) ?? result.title;
+                result.output = captureCursorShellResult(event.callID, result.output, result.metadata);
+                if (result.metadata && typeof result.metadata === "object") {
+                    const metadata = result.metadata;
+                    if (typeof metadata.output === "string") {
+                        metadata.output = sanitizeRegisteredCursorShellOutput(event.callID, metadata.output);
+                    }
+                }
+            }
+            finally {
+                releaseCursorShellEnv(event.callID);
+            }
+        }));
+        // ── Compaction marker + session directory ───────────────────────────────
+        // 2.0 removed `chat.params`, and `session.hook("context")` exposes no
+        // provider-options channel — only `system`/`messages`/`tools` are mutable.
+        // But it does name the owning agent and the session id, and the provider
+        // already derives the same session id from request headers, so record
+        // both facts here and let doStream read them back via
+        // `isCompactionSession` / `getSessionDirectory`.
+        await track(ctx.session.hook("context", async (event) => {
+            markCompactionSession(event.sessionID, event.agent === "compaction");
+            try {
+                const info = await ctx.session.get({ sessionID: event.sessionID });
+                markSessionDirectory(event.sessionID, info.location?.directory);
+            }
+            catch {
+                // Best effort — falls back to the static workspaceRoot above.
+            }
+        }));
+        // ── Model discovery ──────────────────────────────────────────────────────
+        // Idempotent and cheap once satisfied, so it is safe to call from anywhere
+        // that might mark the moment credentials became available.
+        let modelsLoaded = false;
+        let ensureInflight;
+        const ensureModels = () => {
+            if (modelsLoaded)
+                return Promise.resolve();
+            ensureInflight ??= (async () => {
+                try {
+                    const token = await accessToken();
+                    const discovered = await loadModels(cacheDir, token);
+                    if (!discovered.length)
+                        return;
+                    models = discovered;
+                    modelsLoaded = true;
+                    // Replays the catalog transform above, this time with models.
+                    await ctx.catalog.reload().catch(() => { });
+                    if (token) {
+                        // Resolve the region-specific Run origin so the first turn doesn't
+                        // pay for GetServerConfig. Best effort: startSession surfaces real
+                        // failures.
+                        await resolveAgentUrl(token, {
+                            apiBaseURL: cursorApiBaseURL(),
+                            telemetryEnabled: cursorGetServerConfigTelemetryEnabled(),
+                        }).catch(() => { });
+                    }
+                }
+                finally {
+                    ensureInflight = undefined;
+                }
+            })();
+            return ensureInflight;
+        };
+        // On a fresh install the user connects *after* startup, and the host has no
+        // "connection established" hook we can key on. Poll briefly so models show
+        // up within seconds of /connect instead of requiring a restart. The window
+        // is bounded; after it, any session/message event still triggers a retry.
+        const RETRY_INTERVAL_MS = 3_000;
+        const RETRY_WINDOW_MS = 300_000;
+        const startedAt = Date.now();
+        const retry = setInterval(() => {
+            if (modelsLoaded || Date.now() - startedAt > RETRY_WINDOW_MS) {
+                clearInterval(retry);
+                return;
+            }
+            void ensureModels();
+        }, RETRY_INTERVAL_MS);
+        retry.unref?.();
+        void ensureModels();
+        // ── Session activity ─────────────────────────────────────────────────────
+        // Doubles as a retry trigger: any host activity after the polling window has
+        // closed still gets one more chance to pick up newly-added credentials.
+        const unsubscribe = subscribeSessionActivity(ctx, ensureModels);
+        return async () => {
+            clearInterval(retry);
+            unsubscribe?.();
+            for (const registration of registrations.reverse()) {
+                await registration.dispose().catch(() => { });
+            }
+        };
+    },
+};
+/** Feed OpenCode session/message events into the shared activity tracker. */
+function subscribeSessionActivity(ctx, onEvent) {
+    try {
+        const stream = ctx.event.subscribe();
+        if (!stream || typeof stream[Symbol.asyncIterator] !== "function")
+            return undefined;
+        let stopped = false;
+        void (async () => {
+            for await (const event of stream) {
+                if (stopped)
+                    break;
+                applySessionActivity(event);
+                onEvent?.();
+            }
+        })().catch(() => { });
+        return () => {
+            stopped = true;
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+function applySessionActivity(event) {
+    switch (event?.type) {
+        case "session.created":
+            sessionActivity.linkSession(event.properties.info.id, event.properties.info.parentID);
+            sessionActivity.recordActivity(event.properties.info.id);
+            break;
+        case "session.updated":
+            sessionActivity.linkSession(event.properties.info.id, event.properties.info.parentID);
+            break;
+        case "session.deleted":
+            sessionActivity.removeSession(event.properties.info.id);
+            break;
+        case "message.updated":
+            sessionActivity.recordActivity(event.properties.info.sessionID);
+            break;
+        case "message.part.updated":
+            sessionActivity.recordActivity(event.properties.part.sessionID);
+            break;
+    }
+}
+export default plugin;