cursor-opencode-provider 0.6.8 → 0.7.0

package/dist/opencode2/types.d.ts

@@ -1,16 +1,14 @@
 /**
- * Local structural types for the OpenCode 2.0 beta plugin API.
+ * Runtime duck-type boundary for the OpenCode 2.0 plugin — not host conformance.
  *
- * 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.
+ * Only the methods and fields this plugin calls or publishes. Extra host
+ * fields are ignored at runtime. Do not import `@opencode/plugin`: it is not a
+ * standalone types surface we can pin next to `@opencode-ai/plugin`, and a host
+ * dependency would force a plugin bump on every OpenCode release.
  *
- * These mirror `@opencode-ai/plugin@next` `dist/promise/*.d.ts` as of
- * `0.0.0-next-17155`. `test/opencode2-conformance.types.ts` asserts our
- * default export still satisfies the real 2.0 `Plugin` interface.
+ * Compile-time checks that our *calls and payloads* still fit the fuller host
+ * editor live in `test/opencode2-conformance.types.ts` against
+ * `test/opencode2-host-contract.ts`.
  *
  * Effect `Schema` brands (Provider.ID, Model.ID, …) are modelled as plain
  * `string`; brands are compile-time only and erase at runtime.
@@ -25,17 +23,12 @@ export type ProviderInfo = {
     name: string;
     /** `"aisdk:<pkg>"` selects the AI SDK path; a bare specifier selects native. */
     package: string;
+    activation: "auto" | "enabled" | "disabled";
     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;
@@ -43,7 +36,6 @@ export type ModelInfo2 = {
     modelID: string;
     providerID: string;
     name: string;
-    family?: string;
     capabilities: {
         tools: boolean;
         input: readonly string[];
@@ -66,7 +58,7 @@ export type ModelInfo2 = {
             write: number;
         };
     }[];
-    status: "alpha" | "beta" | "deprecated" | "active";
+    status: "active";
     enabled: boolean;
     limit: {
         context: number;
@@ -74,9 +66,6 @@ export type ModelInfo2 = {
         output: number;
     };
     settings?: Record<string, any>;
-    headers?: Record<string, string>;
-    body?: Record<string, any>;
-    package?: string;
 };
 export type CredentialOAuth = {
     type: "oauth";
@@ -101,35 +90,18 @@ export type ConnectionInfo = {
     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.
+ * Inventory writer this plugin uses (`editor.add` only).
+ * The host editor is a superset; unused methods are not part of this boundary.
  */
-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>;
+export type ProviderEditor = {
+    add(input: {
+        info: ProviderInfo;
+        models: readonly ModelInfo2[];
+        sourceConnection?: ConnectionInfo;
+    }): void;
+};
+export type ProviderDomain = {
+    readonly transform: Transform<ProviderEditor>;
     readonly reload: () => Promise<void>;
 };
 export type IntegrationTextPrompt = {
@@ -142,6 +114,7 @@ export type IntegrationOAuthMethod = {
     id: string;
     type: "oauth";
     label: string;
+    form?: unknown;
     prompts?: IntegrationTextPrompt[];
 };
 export type IntegrationKeyMethod = {
@@ -167,7 +140,7 @@ export type IntegrationOAuthAuthorization = {
 export type IntegrationOAuthMethodRegistration = {
     readonly integrationID: string;
     readonly method: IntegrationOAuthMethod;
-    readonly authorize: (inputs: Record<string, string>) => Promise<IntegrationOAuthAuthorization>;
+    readonly authorize: (answer: any) => Promise<IntegrationOAuthAuthorization>;
     readonly refresh?: (credential: CredentialOAuth) => Promise<CredentialOAuth>;
     readonly label?: (credential: CredentialOAuth) => string | undefined;
 };
@@ -183,14 +156,9 @@ export type IntegrationRef = {
     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 = {
@@ -201,15 +169,21 @@ export type IntegrationDomain = {
         readonly resolve: (connection: ConnectionInfo) => Promise<CredentialValue | undefined>;
     };
 };
+/** Fields this plugin reads from the host model object. */
+export type HostModelRef = {
+    readonly id: string;
+    readonly modelID: string;
+    readonly providerID: string;
+};
 export type AISDKHooks = {
     sdk: {
-        readonly model: ModelInfo2;
+        readonly model: HostModelRef;
         readonly package: string;
         readonly options: Record<string, any>;
         sdk?: any;
     };
     language: {
-        readonly model: ModelInfo2;
+        readonly model: HostModelRef;
         readonly sdk: any;
         readonly options: Record<string, any>;
         language?: unknown;
@@ -218,15 +192,37 @@ export type AISDKHooks = {
 export type AISDKDomain = {
     readonly hook: Hooks<AISDKHooks>;
 };
+export type ToolOptions = {
+    readonly namespace?: string;
+    readonly permission?: string;
+    readonly codemode?: boolean;
+    readonly pinned?: boolean;
+};
+/** Public OpenCode 2 tool context. It deliberately has no permission `ask`. */
+export type ToolExecutionContext = {
+    readonly sessionID: string;
+    readonly agent: string;
+    readonly messageID: string;
+    readonly id: string;
+    readonly progress: (update: Record<string, unknown>) => Promise<void>;
+};
 export type ToolDefinition = {
     readonly name: string;
     readonly description: string;
     readonly input: unknown;
     readonly output?: unknown;
-    readonly execute: (input: any, context: any) => Promise<any>;
+    readonly options?: ToolOptions;
+    readonly execute: (input: any, context: ToolExecutionContext) => Promise<any>;
 };
 export type ToolDraft = {
     add(tool: ToolDefinition): void;
+    /** Host ToolEditor.get — used to skip registering tools the host already owns. */
+    get?(id: string): (ToolDefinition & {
+        readonly id?: string;
+    }) | undefined;
+    list?(): readonly (ToolDefinition & {
+        readonly id: string;
+    })[];
 };
 export type ToolHookBaseFields = {
     readonly tool: string;
@@ -257,6 +253,7 @@ export type ToolHooks = {
 };
 export type ToolDomain = {
     readonly transform: Transform<ToolDraft>;
+    readonly reload: () => Promise<void>;
     readonly hook: Hooks<ToolHooks>;
 };
 export type SessionContext = {
@@ -273,11 +270,38 @@ export type SessionContext = {
         description: string;
         input: unknown;
     }>;
+    /** Mutable generation / provider options. OpenCode 2.0 SessionRequest.options. */
+    options?: Record<string, unknown>;
+};
+export type SessionCompactionResult = {
+    summary: string;
+    providerState?: unknown;
+    metadata?: Record<string, unknown>;
+    tokens?: unknown;
+};
+export type SessionCompaction = SessionContext & {
+    result?: SessionCompactionResult;
+};
+export type SessionGenerate = SessionContext;
+export type SessionTitle = {
+    readonly sessionID: string;
+    readonly model: {
+        providerID: string;
+        id: string;
+        variant?: string;
+    };
+    system: Array<any>;
+    messages: Array<any>;
+    options?: Record<string, unknown>;
+    result?: string;
 };
 export type SessionHooks = {
     readonly context: SessionContext;
+    readonly compaction: SessionCompaction;
+    readonly generate: SessionGenerate;
+    readonly title: SessionTitle;
 };
-/** Only the `location.directory` field we actually read; the rest of the real `SessionInfo` is loose. */
+/** Only the `location.directory` field we actually read. */
 export type SessionInfo = {
     readonly id: string;
     readonly location: {
@@ -289,43 +313,74 @@ export type SessionDomain = {
     readonly get: (input: {
         sessionID: string;
     }) => Promise<SessionInfo>;
+    readonly switchAgent?: (input: {
+        sessionID: string;
+        agent: string;
+    }) => Promise<void>;
+    readonly synthetic?: (input: {
+        sessionID: string;
+        text: string;
+        description?: string;
+        metadata?: Record<string, unknown>;
+        delivery?: "steer" | "queue";
+        resume?: boolean;
+    }) => Promise<unknown>;
+    readonly prompt?: (input: {
+        sessionID: string;
+        text: string;
+    }) => Promise<unknown>;
 };
-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 EventDomain = {
+    readonly subscribe: (...args: any[]) => any;
+};
+export type ShellCreateBefore = {
+    command: string;
+    cwd: string;
+    timeout: number;
+    shell: string;
+    env: Record<string, string | undefined>;
+};
+export type ShellDomain = {
+    readonly hook: Hooks<{
+        readonly "create.before": ShellCreateBefore;
+    }>;
+};
+export type WebSearchResult = {
+    url: string;
+    title?: string;
+    content?: string;
+    time: {
+        published?: number;
     };
 };
+export type WebSearchEditor = {
+    add(definition: {
+        readonly id: string;
+        readonly name: string;
+        readonly execute: (input: {
+            query: string;
+        }, context: {
+            readonly signal: AbortSignal;
+        }) => Promise<readonly WebSearchResult[]>;
+    }): void;
+};
 export type WebSearchDomain = {
-    readonly transform: Transform<WebSearchDraft>;
+    readonly transform: Transform<WebSearchEditor>;
     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 PluginLocation = {
+    readonly directory: 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 provider: ProviderDomain;
     readonly session: SessionDomain;
     readonly tool: ToolDomain;
-    readonly websearch: WebSearchDomain;
+    readonly location?: PluginLocation;
+    readonly shell?: ShellDomain;
+    readonly websearch?: WebSearchDomain;
 };
 export type Cleanup = () => Promise<void> | void;
 export type Plugin2 = {

package/dist/opencode2/types.js

@@ -1,16 +1,14 @@
 /**
- * Local structural types for the OpenCode 2.0 beta plugin API.
+ * Runtime duck-type boundary for the OpenCode 2.0 plugin — not host conformance.
  *
- * 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.
+ * Only the methods and fields this plugin calls or publishes. Extra host
+ * fields are ignored at runtime. Do not import `@opencode/plugin`: it is not a
+ * standalone types surface we can pin next to `@opencode-ai/plugin`, and a host
+ * dependency would force a plugin bump on every OpenCode release.
  *
- * These mirror `@opencode-ai/plugin@next` `dist/promise/*.d.ts` as of
- * `0.0.0-next-17155`. `test/opencode2-conformance.types.ts` asserts our
- * default export still satisfies the real 2.0 `Plugin` interface.
+ * Compile-time checks that our *calls and payloads* still fit the fuller host
+ * editor live in `test/opencode2-conformance.types.ts` against
+ * `test/opencode2-host-contract.ts`.
  *
  * Effect `Schema` brands (Provider.ID, Model.ID, …) are modelled as plain
  * `string`; brands are compile-time only and erase at runtime.

package/dist/plan-execution-kickoff.d.ts

@@ -37,6 +37,8 @@ export declare function setPlanExecutionKickoff(fn: PlanExecutionKickoffFn | und
 export declare function hasPlanExecutionKickoff(): boolean;
 /** Record the approved plan; execution is flushed after the stream settles. */
 export declare function queuePlanExecutionKickoff(input: PlanExecutionKickoffInput): boolean;
+/** Drop any approval state owned by a deleted host session. */
+export declare function cancelPlanExecutionKickoff(sessionID: string | undefined): void;
 /**
  * Run one pending kickoff only after the owning Cursor Run reached a terminal,
  * idle state. Returns true only after successful host handoff.

package/dist/plan-execution-kickoff.js

@@ -53,9 +53,14 @@ export function planPathFromUri(planUri) {
 let kickoff;
 const pending = new Map();
 const warnings = new Map();
+const MAX_PENDING_PLAN_KICKOFFS = 256;
 /** Install (or clear) the host kickoff. */
 export function setPlanExecutionKickoff(fn) {
     kickoff = fn;
+    if (!fn) {
+        pending.clear();
+        warnings.clear();
+    }
 }
 export function hasPlanExecutionKickoff() {
     return kickoff !== undefined;
@@ -77,10 +82,25 @@ export function queuePlanExecutionKickoff(input) {
         attempts: 0,
     });
     warnings.delete(sessionID);
+    while (pending.size > MAX_PENDING_PLAN_KICKOFFS) {
+        const oldest = pending.keys().next().value;
+        if (!oldest)
+            break;
+        pending.delete(oldest);
+        warnings.delete(oldest);
+    }
     trace(`plan-execution-kickoff: pending sessionID=${sessionID} ` +
         `cursorSessionID=${input.cursorSessionID ?? ""} planPath=${planPath}`);
     return true;
 }
+/** Drop any approval state owned by a deleted host session. */
+export function cancelPlanExecutionKickoff(sessionID) {
+    const key = sessionID?.trim();
+    if (!key)
+        return;
+    pending.delete(key);
+    warnings.delete(key);
+}
 /**
  * Run one pending kickoff only after the owning Cursor Run reached a terminal,
  * idle state. Returns true only after successful host handoff.
@@ -100,7 +120,11 @@ export async function flushPlanExecutionKickoff(sessionID, options = {}) {
     if (state.cursorSessionID
         && options.cursorSessionID
         && state.cursorSessionID !== options.cursorSessionID) {
-        trace(`plan-execution-kickoff: skipped stale Run sessionID=${key} ` +
+        // The owning Run was superseded before the handoff could happen. Applying
+        // it from a later Run would execute a stale approval in the wrong turn.
+        pending.delete(key);
+        warnings.delete(key);
+        trace(`plan-execution-kickoff: discarded stale Run sessionID=${key} ` +
             `owner=${state.cursorSessionID} terminal=${options.cursorSessionID}`);
         return false;
     }

package/dist/plugin-opencode2.d.ts

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