@opencode-ai/plugin 0.0.0-dev-202608272023 → 0.0.0-dev-18430

package/dist/app.d.ts

@@ -0,0 +1,5 @@
+export interface App {
+    readonly name: string;
+    readonly version: string;
+    readonly channel: string;
+}

package/dist/effect/agent.d.ts

@@ -0,0 +1,15 @@
+import type { AgentApi } from "@opencode-ai/client/effect/api";
+import type { Agent } from "@opencode-ai/schema/agent";
+import type { Effect, Types } from "effect";
+import type { Transform } from "./registration.js";
+export interface AgentDraft {
+    list(): readonly Types.DeepMutable<Agent.Info>[];
+    get(id: string): Types.DeepMutable<Agent.Info> | undefined;
+    default(id: string | undefined): void;
+    update(id: string, update: (agent: Types.DeepMutable<Agent.Info>) => void): void;
+    remove(id: string): void;
+}
+export interface AgentDomain extends AgentApi<unknown> {
+    readonly transform: Transform<AgentDraft>;
+    readonly reload: () => Effect.Effect<void>;
+}

package/dist/{v2/promise → effect}/aisdk.d.ts

@@ -1,17 +1,20 @@
 import type { LanguageModelV3 } from "@ai-sdk/provider";
-import type { ModelV2Info } from "@opencode-ai/sdk/v2/types";
-import type { Hooks } from "./registration.js";
-export type AISDKHooks = Hooks<{
+import type { Model } from "@opencode-ai/schema/model";
+import type { ModelHooks } from "./registration.js";
+export interface AISDKHooks {
     sdk: {
-        readonly model: ModelV2Info;
+        readonly model: Model.Info;
         readonly package: string;
         readonly options: Record<string, any>;
         sdk?: any;
     };
     language: {
-        readonly model: ModelV2Info;
+        readonly model: Model.Info;
         readonly sdk: any;
         readonly options: Record<string, any>;
         language?: LanguageModelV3;
     };
-}>;
+}
+export interface AISDKDomain {
+    readonly hook: ModelHooks<AISDKHooks>;
+}

package/dist/effect/catalog.d.ts

@@ -0,0 +1,33 @@
+import type { CatalogApi } from "@opencode-ai/client/effect/api";
+import { Model } from "@opencode-ai/schema/model";
+import { Provider } from "@opencode-ai/schema/provider";
+import type { Effect, Types } from "effect";
+import type { Transform } from "./registration.js";
+export interface CatalogProviderRecord {
+    readonly provider: Types.DeepMutable<Provider.Info>;
+    readonly models: ReadonlyMap<string, Types.DeepMutable<Model.Info>>;
+}
+export interface CatalogDraft {
+    readonly provider: {
+        list(): readonly CatalogProviderRecord[];
+        get(providerID: string): CatalogProviderRecord | undefined;
+        update(providerID: string, update: (provider: Types.DeepMutable<Provider.Info>) => void): void;
+        remove(providerID: string): void;
+    };
+    readonly model: {
+        get(providerID: string, modelID: string): Types.DeepMutable<Model.Info> | undefined;
+        update(providerID: string, modelID: string, update: (model: Types.DeepMutable<Model.Info>) => void): void;
+        remove(providerID: string, modelID: string): void;
+        readonly default: {
+            get(): {
+                providerID: string;
+                modelID: string;
+            } | undefined;
+            set(providerID: string, modelID: string): void;
+        };
+    };
+}
+export interface CatalogDomain extends CatalogApi<unknown> {
+    readonly transform: Transform<CatalogDraft>;
+    readonly reload: () => Effect.Effect<void>;
+}

package/dist/effect/catalog.js

@@ -0,0 +1,2 @@
+import { Model } from "@opencode-ai/schema/model";
+import { Provider } from "@opencode-ai/schema/provider";

package/dist/effect/command.d.ts

@@ -0,0 +1,23 @@
+import type { CommandApi } from "@opencode-ai/client/effect/api";
+import type { PromptInput } from "@opencode-ai/schema/prompt-input";
+import type { Session } from "@opencode-ai/schema/session";
+import type { SessionInbox } from "@opencode-ai/schema/session-inbox";
+import type { Effect } from "effect";
+import type { Transform } from "./registration.js";
+export interface CommandInvocation {
+    readonly sessionID: Session.ID;
+    readonly prompt: PromptInput.Prompt;
+    readonly delivery: SessionInbox.Delivery;
+}
+export interface CommandDefinition {
+    readonly name: string;
+    readonly description?: string;
+    readonly execute: (input: CommandInvocation) => Effect.Effect<void, unknown>;
+}
+export interface CommandDraft {
+    add(definition: CommandDefinition): void;
+}
+export interface CommandDomain extends Pick<CommandApi<unknown>, "list"> {
+    readonly transform: Transform<CommandDraft>;
+    readonly reload: () => Effect.Effect<void>;
+}

package/dist/effect/event.d.ts

@@ -0,0 +1,3 @@
+import type { EventApi } from "@opencode-ai/client/effect/api";
+export interface EventDomain extends Pick<EventApi<unknown>, "subscribe"> {
+}

package/dist/effect/index.d.ts

@@ -0,0 +1,15 @@
+export * as Plugin from "./plugin.js";
+export type { StorageEntry, StorageScanOptions, StorageScanResult } from "../storage.js";
+export { Agent } from "@opencode-ai/schema/agent";
+export { Command } from "@opencode-ai/schema/command";
+export { Connection } from "@opencode-ai/schema/connection";
+export { Credential } from "@opencode-ai/schema/credential";
+export { Integration } from "@opencode-ai/schema/integration";
+export { Location } from "@opencode-ai/schema/location";
+export { Mcp } from "@opencode-ai/schema/mcp";
+export { Model } from "@opencode-ai/schema/model";
+export { Provider } from "@opencode-ai/schema/provider";
+export { Reference } from "@opencode-ai/schema/reference";
+export { Skill } from "@opencode-ai/schema/skill";
+export { Vcs } from "@opencode-ai/schema/vcs";
+export { WebSearch } from "@opencode-ai/schema/websearch";

package/dist/effect/index.js

@@ -0,0 +1,14 @@
+export * as Plugin from "./plugin.js";
+export { Agent } from "@opencode-ai/schema/agent";
+export { Command } from "@opencode-ai/schema/command";
+export { Connection } from "@opencode-ai/schema/connection";
+export { Credential } from "@opencode-ai/schema/credential";
+export { Integration } from "@opencode-ai/schema/integration";
+export { Location } from "@opencode-ai/schema/location";
+export { Mcp } from "@opencode-ai/schema/mcp";
+export { Model } from "@opencode-ai/schema/model";
+export { Provider } from "@opencode-ai/schema/provider";
+export { Reference } from "@opencode-ai/schema/reference";
+export { Skill } from "@opencode-ai/schema/skill";
+export { Vcs } from "@opencode-ai/schema/vcs";
+export { WebSearch } from "@opencode-ai/schema/websearch";

package/dist/effect/integration.d.ts

@@ -0,0 +1,80 @@
+import type { ConnectionInfo } from "@opencode-ai/client";
+import type { IntegrationApi } from "@opencode-ai/client/effect/api";
+import { Credential } from "@opencode-ai/schema/credential";
+import { Form } from "@opencode-ai/schema/form";
+import type { Effect, Scope } from "effect";
+import type { Transform } from "./registration.js";
+type IntegrationRef = {
+    id: string;
+    name: string;
+};
+export interface IntegrationOAuthMethod {
+    readonly id: string;
+    readonly type: "oauth";
+    readonly label: string;
+    readonly form?: Form.Fields;
+}
+export interface IntegrationCommandMethod {
+    readonly id: string;
+    readonly type: "command";
+    readonly label: string;
+    readonly command: ReadonlyArray<string>;
+}
+export interface IntegrationKeyMethod {
+    readonly type: "key";
+    readonly label?: string;
+    readonly form?: Form.Fields;
+}
+export interface IntegrationEnvMethod {
+    readonly type: "env";
+    readonly names: ReadonlyArray<string>;
+}
+export type IntegrationMethod = IntegrationOAuthMethod | IntegrationCommandMethod | IntegrationKeyMethod | IntegrationEnvMethod;
+export type IntegrationOAuthAuthorization = {
+    readonly url: string;
+    readonly instructions: string;
+    readonly expiresAt?: number;
+} & ({
+    readonly mode: "auto";
+    readonly callback: Effect.Effect<Credential.OAuth, unknown>;
+} | {
+    readonly mode: "code";
+    readonly callback: (code: string) => Effect.Effect<Credential.OAuth, unknown>;
+});
+export type IntegrationOAuthMethodRegistration = {
+    readonly integrationID: string;
+    readonly method: IntegrationOAuthMethod;
+    readonly authorize: (answer: Form.Answer) => Effect.Effect<IntegrationOAuthAuthorization, unknown, Scope.Scope>;
+    readonly refresh?: (credential: Credential.OAuth) => Effect.Effect<Credential.OAuth, unknown>;
+    readonly label?: (credential: Credential.OAuth) => string | undefined;
+};
+export type IntegrationMethodRegistration = IntegrationOAuthMethodRegistration | {
+    readonly integrationID: string;
+    readonly method: IntegrationCommandMethod;
+} | {
+    readonly integrationID: string;
+    readonly method: IntegrationKeyMethod;
+} | {
+    readonly integrationID: string;
+    readonly method: IntegrationEnvMethod;
+};
+export interface IntegrationDraft {
+    list(): readonly IntegrationRef[];
+    get(id: string): IntegrationRef | undefined;
+    update(id: string, update: (integration: IntegrationRef) => void): void;
+    remove(id: string): void;
+    readonly method: {
+        list(integrationID: string): readonly IntegrationMethod[];
+        update(input: IntegrationMethodRegistration): void;
+        remove(integrationID: string, method: IntegrationMethod): void;
+    };
+}
+export interface IntegrationDomain extends Omit<IntegrationApi<unknown>, "wellknown"> {
+    readonly transform: Transform<IntegrationDraft>;
+    readonly reload: () => Effect.Effect<void>;
+    readonly connection: {
+        readonly active: (integrationID: string) => Effect.Effect<ConnectionInfo | undefined>;
+        readonly resolve: (connection: ConnectionInfo) => Effect.Effect<Credential.Value | undefined, unknown>;
+    };
+}
+export {};

package/dist/effect/integration.js

@@ -0,0 +1,2 @@
+import { Credential } from "@opencode-ai/schema/credential";
+import { Form } from "@opencode-ai/schema/form";

package/dist/effect/mcp.d.ts

@@ -0,0 +1,15 @@
+import type { McpApi } from "@opencode-ai/client/effect/api";
+import type { Mcp } from "@opencode-ai/schema/mcp";
+import type { Effect, Types } from "effect";
+import type { Transform } from "./registration.js";
+export interface MCPDraft {
+    list(): readonly [string, Types.DeepMutable<Mcp.ServerConfig>][];
+    get(name: string): Types.DeepMutable<Mcp.ServerConfig> | undefined;
+    set(name: string, config: Mcp.ServerConfig): void;
+    update(name: string, update: (config: Types.DeepMutable<Mcp.ServerConfig>) => void): void;
+    remove(name: string): void;
+}
+export interface MCPDomain extends Pick<McpApi<unknown>, "list"> {
+    readonly transform: Transform<MCPDraft>;
+    readonly reload: () => Effect.Effect<void>;
+}

package/dist/effect/permission.d.ts

@@ -0,0 +1,21 @@
+import type { PermissionApi } from "@opencode-ai/client/effect/api";
+import type { Agent } from "@opencode-ai/schema/agent";
+import type { Permission } from "@opencode-ai/schema/permission";
+import type { Session } from "@opencode-ai/schema/session";
+import type { Hooks } from "./registration.js";
+export interface PermissionEvaluation {
+    readonly sessionID: Session.ID;
+    readonly agent?: Agent.ID;
+    readonly action: string;
+    readonly resources: ReadonlyArray<string>;
+    readonly metadata?: Record<string, unknown>;
+    readonly source?: Permission.Source;
+    effect: Permission.Effect;
+    message?: string;
+}
+export interface PermissionHooks {
+    readonly evaluate: PermissionEvaluation;
+}
+export type PermissionDomain = Pick<PermissionApi<unknown>, "list" | "get" | "reply"> & {
+    readonly hook: Hooks<PermissionHooks>;
+};

package/dist/effect/plugin.d.ts

@@ -0,0 +1,52 @@
+import type { GenerateApi, PluginApi } from "@opencode-ai/client/effect/api";
+import type { Location } from "@opencode-ai/schema/location";
+import type { Effect, Scope } from "effect";
+import type { PluginOptions } from "../options.js";
+import type { VcsDiscovery } from "../vcs.js";
+import type { App } from "../app.js";
+import type { AgentDomain } from "./agent.js";
+import type { AISDKDomain } from "./aisdk.js";
+import type { CatalogDomain } from "./catalog.js";
+import type { CommandDomain } from "./command.js";
+import type { EventDomain } from "./event.js";
+import type { IntegrationDomain } from "./integration.js";
+import type { MCPDomain } from "./mcp.js";
+import type { PermissionDomain } from "./permission.js";
+import type { ReferenceDomain } from "./reference.js";
+import type { SessionDomain } from "./session.js";
+import type { ShellDomain } from "./shell.js";
+import type { SkillDomain } from "./skill.js";
+import type { StorageDomain } from "./storage.js";
+import type { ToolDomain } from "./tool.js";
+import type { VcsDomain } from "./vcs.js";
+import type { WebSearchDomain } from "./websearch.js";
+export interface Context {
+    readonly app: App;
+    readonly location: Location.Info;
+    readonly options: PluginOptions;
+    readonly agent: AgentDomain;
+    readonly aisdk: AISDKDomain;
+    readonly catalog: CatalogDomain;
+    readonly command: CommandDomain;
+    readonly event: EventDomain;
+    readonly integration: IntegrationDomain;
+    readonly mcp: MCPDomain;
+    readonly generate: GenerateApi<unknown>;
+    readonly permission: PermissionDomain;
+    readonly plugin: PluginApi<unknown>;
+    readonly reference: ReferenceDomain;
+    readonly session: SessionDomain;
+    readonly shell: ShellDomain;
+    readonly skill: SkillDomain;
+    readonly storage: StorageDomain;
+    readonly tool: ToolDomain;
+    readonly vcs: VcsDomain;
+    readonly websearch: WebSearchDomain;
+}
+export interface Plugin<R = Scope.Scope> {
+    readonly id: string;
+    readonly tui?: boolean;
+    readonly vcs?: VcsDiscovery;
+    readonly effect: (context: Context) => Effect.Effect<void, never, R>;
+}
+export declare function define<R = Scope.Scope>(plugin: Plugin<R>): Plugin<R>;

package/dist/effect/reference.d.ts

@@ -0,0 +1,13 @@
+import type { ReferenceGitSource, ReferenceLocalSource } from "@opencode-ai/client";
+import type { ReferenceApi } from "@opencode-ai/client/effect/api";
+import type { Effect } from "effect";
+import type { Transform } from "./registration.js";
+export interface ReferenceDraft {
+    add(name: string, source: ReferenceLocalSource | ReferenceGitSource): void;
+    remove(name: string): void;
+    list(): readonly (readonly [string, ReferenceLocalSource | ReferenceGitSource])[];
+}
+export interface ReferenceDomain extends ReferenceApi<unknown> {
+    readonly transform: Transform<ReferenceDraft>;
+    readonly reload: () => Effect.Effect<void>;
+}

package/dist/effect/registration.d.ts

@@ -0,0 +1,13 @@
+import type { Effect, Scope } from "effect";
+export interface Registration {
+    readonly dispose: Effect.Effect<void>;
+}
+export interface ModelHookOptions {
+    /** Limits the hook to one provider. Unscoped hooks apply to every provider. */
+    readonly providerID?: string;
+}
+export type Hooks<Spec, Failures extends Record<keyof Spec, unknown> = Record<keyof Spec, never>> = <Name extends keyof Spec>(name: Name, callback: (input: Spec[Name]) => Effect.Effect<void, Failures[Name]>) => Effect.Effect<Registration, never, Scope.Scope>;
+export type ModelHooks<Spec, Failures extends Record<keyof Spec, unknown> = Record<keyof Spec, never>> = <Name extends keyof Spec>(name: Name, callback: (input: Spec[Name]) => Effect.Effect<void, Failures[Name]>, options?: Spec[Name] extends {
+    readonly model: unknown;
+} ? ModelHookOptions : never) => Effect.Effect<Registration, never, Scope.Scope>;
+export type Transform<Input> = (callback: (input: Input) => void) => Effect.Effect<Registration, never, Scope.Scope>;

package/dist/effect/session.d.ts

@@ -0,0 +1,61 @@
+import type { SessionApi } from "@opencode-ai/client/effect/api";
+import type { GenerationOptionsFields, Message, SystemPart } from "@opencode-ai/ai";
+import type { Agent } from "@opencode-ai/schema/agent";
+import type { Model } from "@opencode-ai/schema/model";
+import type { PromptInput } from "@opencode-ai/schema/prompt-input";
+import type { Session } from "@opencode-ai/schema/session";
+import type { SessionInbox } from "@opencode-ai/schema/session-inbox";
+import type { SessionMessage } from "@opencode-ai/schema/session-message";
+import type { JsonSchema, Types } from "effect";
+import type { ModelHooks } from "./registration.js";
+export interface SessionPrompt {
+    readonly sessionID: Session.ID;
+    readonly messageID: SessionMessage.ID;
+    prompt: Types.DeepMutable<PromptInput.Prompt>;
+    metadata?: Record<string, unknown>;
+    delivery: SessionInbox.Delivery;
+}
+export interface SessionContext {
+    readonly sessionID: Session.ID;
+    readonly agent: Agent.ID;
+    readonly model: Model.Ref;
+    system: Array<SystemPart>;
+    messages: Array<Message>;
+    tools: Record<string, {
+        description: string;
+        input: JsonSchema.JsonSchema;
+    }>;
+    /** Request overrides; unset fields retain route and model defaults. */
+    generation: Types.DeepMutable<GenerationOptionsFields>;
+    providerOptions: Record<string, unknown>;
+}
+export interface SessionModelRequest {
+    readonly sessionID: Session.ID;
+    readonly agent: Agent.ID;
+    readonly model: Model.Ref;
+    baseURL?: string;
+    headers: Record<string, string>;
+}
+export interface SessionHttpRequest {
+    readonly sessionID: Session.ID;
+    readonly agent: Agent.ID;
+    readonly model: Model.Ref;
+    request: Request;
+}
+export interface SessionHttpResponse {
+    readonly sessionID: Session.ID;
+    readonly agent: Agent.ID;
+    readonly model: Model.Ref;
+    readonly request: Request;
+    response: Response;
+}
+export interface SessionHooks {
+    readonly prompt: SessionPrompt;
+    readonly context: SessionContext;
+    readonly "model.request": SessionModelRequest;
+    readonly "http.request": SessionHttpRequest;
+    readonly "http.response": SessionHttpResponse;
+}
+export type SessionDomain = Pick<SessionApi<unknown>, "create" | "get" | "switchAgent" | "switchModel" | "prompt" | "generate" | "command" | "synthetic" | "interrupt" | "rename" | "move" | "wait" | "context"> & {
+    readonly hook: ModelHooks<SessionHooks>;
+};

package/dist/effect/shell.d.ts

@@ -0,0 +1,14 @@
+import type { Hooks } from "./registration.js";
+export interface ShellCreateBefore {
+    command: string;
+    cwd: string;
+    timeout: number;
+    shell: string;
+    env: Record<string, string | undefined>;
+}
+export interface ShellHooks {
+    readonly "create.before": ShellCreateBefore;
+}
+export interface ShellDomain {
+    readonly hook: Hooks<ShellHooks>;
+}

package/dist/effect/skill.d.ts

@@ -0,0 +1,14 @@
+import type { SkillApi } from "@opencode-ai/client/effect/api";
+import { Skill } from "@opencode-ai/schema/skill";
+import type { Effect, Types } from "effect";
+import type { Transform } from "./registration.js";
+export interface SkillDraft {
+    list(): readonly Types.DeepMutable<Skill.Info>[];
+    add(skill: Skill.Info): void;
+    update(id: string, update: (skill: Types.DeepMutable<Skill.Info>) => void): void;
+    remove(id: string): void;
+}
+export interface SkillDomain extends SkillApi<unknown> {
+    readonly transform: Transform<SkillDraft>;
+    readonly reload: () => Effect.Effect<void>;
+}

package/dist/effect/skill.js

@@ -0,0 +1 @@
+import { Skill } from "@opencode-ai/schema/skill";

package/dist/effect/storage.d.ts

@@ -0,0 +1,8 @@
+import type { Effect, Schema } from "effect";
+import type { StorageScanOptions, StorageScanResult } from "../storage.js";
+export interface StorageDomain {
+    readonly get: (key: string) => Effect.Effect<Schema.Json | undefined>;
+    readonly set: (key: string, value: Schema.Json) => Effect.Effect<void>;
+    readonly remove: (key: string) => Effect.Effect<void>;
+    readonly scan: (options: StorageScanOptions) => Effect.Effect<StorageScanResult>;
+}

package/dist/effect/tool.d.ts

@@ -0,0 +1,51 @@
+import { Tool } from "@opencode-ai/schema/tool";
+import type { Agent } from "@opencode-ai/schema/agent";
+import type { Session } from "@opencode-ai/schema/session";
+import type { SessionMessage } from "@opencode-ai/schema/session-message";
+import type { Effect, Types } from "effect";
+import type { Hooks, Transform } from "./registration.js";
+export interface ToolDraft {
+    list(): readonly (Tool.Info & {
+        readonly id: string;
+    })[];
+    get(id: string): (Tool.Info & {
+        readonly id: string;
+    }) | undefined;
+    add<Input extends Tool.ValueSchema<any>, Output extends Tool.ValueSchema<any> | undefined>(tool: Tool.Info<Input, Output>): void;
+    /** Updates an existing tool; missing IDs are ignored. */
+    update(id: string, update: (tool: Types.Mutable<Tool.Info>) => void): void;
+    remove(id: string): void;
+}
+export interface ToolHooks {
+    readonly "execute.before": {
+        tool: string;
+        readonly sessionID: Session.ID;
+        readonly agent: Agent.ID;
+        readonly messageID: SessionMessage.ID;
+        readonly id: Tool.CallID;
+        input: unknown;
+    };
+    readonly "execute.after": {
+        readonly tool: string;
+        readonly sessionID: Session.ID;
+        readonly agent: Agent.ID;
+        readonly messageID: SessionMessage.ID;
+        readonly id: Tool.CallID;
+        readonly input: unknown;
+    } & ({
+        readonly status: "completed";
+        result: Tool.Result;
+    } | {
+        readonly status: "error";
+        error: Tool.Error;
+    });
+}
+export interface ToolFailures extends Record<keyof ToolHooks, unknown> {
+    readonly "execute.before": Tool.Error;
+    readonly "execute.after": never;
+}
+export interface ToolDomain {
+    readonly transform: Transform<ToolDraft>;
+    readonly reload: () => Effect.Effect<void>;
+    readonly hook: Hooks<ToolHooks, ToolFailures>;
+}

package/dist/effect/tool.js

@@ -0,0 +1 @@
+import { Tool } from "@opencode-ai/schema/tool";

package/dist/effect/vcs.d.ts

@@ -0,0 +1,39 @@
+import type { VcsApi } from "@opencode-ai/client/effect/api";
+import type { FileDiff } from "@opencode-ai/schema/file-diff";
+import type { Vcs } from "@opencode-ai/schema/vcs";
+import type { Effect } from "effect";
+import type { Transform } from "./registration.js";
+export interface VcsScope {
+    readonly directory: string;
+    readonly worktree: string;
+    readonly canonical: string;
+    readonly store?: string;
+}
+export interface VcsBranchesInput extends VcsScope {
+    readonly search?: string;
+    readonly limit?: number;
+}
+export interface VcsDiffInput extends VcsScope {
+    readonly mode: Vcs.Mode;
+    readonly context: number;
+    readonly maxOutputBytes: number;
+}
+export interface VcsDefinition {
+    readonly id: string;
+    readonly name: string;
+    readonly info: (input: VcsScope) => Effect.Effect<Vcs.Info, unknown>;
+    readonly branches: (input: VcsBranchesInput) => Effect.Effect<Vcs.BranchList, unknown>;
+    readonly status: (input: VcsScope) => Effect.Effect<readonly Vcs.FileStatus[], unknown>;
+    readonly diff: (input: VcsDiffInput) => Effect.Effect<readonly FileDiff.Info[], unknown>;
+}
+export interface VcsDomain extends VcsApi<unknown> {
+    readonly transform: Transform<VcsDraft>;
+    readonly reload: () => Effect.Effect<void>;
+}
+export interface VcsDraft {
+    add(definition: VcsDefinition): void;
+    readonly default: {
+        get(): string | undefined;
+        set(selection: string): void;
+    };
+}

package/dist/effect/websearch.d.ts

@@ -0,0 +1,20 @@
+import type { WebSearch } from "@opencode-ai/schema/websearch";
+import type { WebsearchApi } from "@opencode-ai/client/effect/api";
+import type { Effect } from "effect";
+import type { Transform } from "./registration.js";
+export interface WebSearchDefinition {
+    readonly id: string;
+    readonly name: string;
+    readonly execute: (input: WebSearch.ProviderInput) => Effect.Effect<readonly WebSearch.Result[], unknown>;
+}
+export interface WebSearchDomain extends WebsearchApi<unknown> {
+    readonly transform: Transform<WebSearchDraft>;
+    readonly reload: () => Effect.Effect<void>;
+}
+export interface WebSearchDraft {
+    add(definition: WebSearchDefinition): void;
+    readonly default: {
+        get(): string | false | undefined;
+        set(selection: string | false): void;
+    };
+}

package/dist/promise/adapter.d.ts

@@ -0,0 +1,12 @@
+import type { Scope } from "effect";
+import type { Plugin } from "./plugin.js";
+/**
+ * Adapts a Promise plugin into an Effect plugin so the existing Effect-only
+ * loader (`Plugin` / `PluginSupervisor`) can run it unchanged.
+ *
+ * Hook registrations created during the async `setup` attach to the plugin's
+ * scope, so unloading the plugin disposes them. The captured fiber context
+ * preserves boot-time batching, so Promise-plugin transforms still coalesce
+ * into one reload per domain.
+ */
+export declare function fromPromise(plugin: Plugin): import("../effect/plugin.js").Plugin<Scope.Scope>;