@opencode-ai/plugin 0.0.0-dev-202608250823 → 0.0.0-dev-18182

package/dist/promise/adapter.js

@@ -0,0 +1,258 @@
+import { Tool } from "@opencode-ai/schema/tool";
+import { Effect, Schema, SchemaAST, Stream } from "effect";
+import { HttpApiEndpoint, HttpApiSchema } from "effect/unstable/httpapi";
+import { define } from "../effect/plugin.js";
+const compiledEndpoints = new WeakMap();
+function compileEndpoint(endpoint) {
+    const cached = compiledEndpoints.get(endpoint);
+    if (cached)
+        return cached;
+    const payloadSchemas = Array.from(endpoint.payload.values()).flatMap(({ schemas }) => schemas);
+    const successSchemas = Array.from(endpoint.success);
+    if (payloadSchemas.length > 1 || successSchemas.length > 1) {
+        throw new Error(`Unsupported API schema cardinality: ${endpoint.identifier}`);
+    }
+    const inputs = [
+        endpoint.params,
+        endpoint.query === undefined ? undefined : Schema.toType(endpoint.query),
+        endpoint.headers,
+        ...payloadSchemas,
+    ].filter((schema) => schema !== undefined);
+    const success = (successSchemas[0] ?? HttpApiSchema.NoContent);
+    const noContent = HttpApiSchema.isNoContent(success.ast);
+    const type = Schema.toType(success).ast;
+    const data = SchemaAST.isObjects(success.ast)
+        ? success.ast.propertySignatures.find((property) => property.name === "data")
+        : undefined;
+    const output = !noContent &&
+        SchemaAST.isObjects(type) &&
+        type.indexSignatures.length === 0 &&
+        type.propertySignatures.length === 1 &&
+        type.propertySignatures[0]?.name === "data" &&
+        data !== undefined
+        ? Schema.make(data.type)
+        : success;
+    const compiled = {
+        decode: inputs.map((schema) => Schema.decodeUnknownEffect(schema)),
+        encode: Schema.encodeUnknownEffect(output),
+        noContent,
+    };
+    compiledEndpoints.set(endpoint, compiled);
+    return compiled;
+}
+/**
+ * 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 function fromPromise(plugin) {
+    return define({
+        id: plugin.id,
+        tui: plugin.tui,
+        effect: (host) => Effect.gen(function* () {
+            const [{ ClientApi }, { OpenCodeEvent }] = yield* Effect.promise(() => Promise.all([import("@opencode-ai/protocol/client"), import("@opencode-ai/protocol/groups/event")]));
+            const AgentEndpoints = ClientApi.groups["server.agent"].endpoints;
+            const CommandEndpoints = ClientApi.groups["server.command"].endpoints;
+            const IntegrationEndpoints = ClientApi.groups["server.integration"].endpoints;
+            const McpEndpoints = ClientApi.groups["server.mcp"].endpoints;
+            const ModelEndpoints = ClientApi.groups["server.model"].endpoints;
+            const PluginEndpoints = ClientApi.groups["server.plugin"].endpoints;
+            const ProviderEndpoints = ClientApi.groups["server.provider"].endpoints;
+            const ReferenceEndpoints = ClientApi.groups["server.reference"].endpoints;
+            const SessionEndpoints = ClientApi.groups["server.session"].endpoints;
+            const SkillEndpoints = ClientApi.groups["server.skill"].endpoints;
+            const WebSearchEndpoints = ClientApi.groups["server.websearch"].endpoints;
+            const context = yield* Effect.context();
+            // Run a hook registration on the plugin scope and resolve once it is registered.
+            const register = (effect) => Effect.runPromiseWith(context)(effect).then((registration) => ({
+                dispose: () => Effect.runPromiseWith(context)(registration.dispose),
+            }));
+            const run = (effect) => Effect.runPromiseWith(context)(effect);
+            const adaptApiMethod = (endpoint, method) => {
+                const compiled = compileEndpoint(endpoint);
+                return ((input) => Effect.gen(function* () {
+                    const decoded = yield* Effect.forEach(compiled.decode, (decode) => decode(input ?? {}));
+                    const result = yield* method(Object.assign({}, ...decoded));
+                    if (compiled.noContent)
+                        return undefined;
+                    return yield* compiled.encode(result);
+                }).pipe(Effect.runPromiseWith(context)));
+            };
+            const transform = (domain) => (callback) => register(domain.transform((draft) => {
+                callback(draft);
+            }));
+            const context2 = {
+                app: host.app,
+                options: host.options,
+                agent: {
+                    get: adaptApiMethod(AgentEndpoints["agent.get"], host.agent.get),
+                    list: adaptApiMethod(AgentEndpoints["agent.list"], host.agent.list),
+                    transform: transform(host.agent),
+                    reload: () => run(host.agent.reload()),
+                },
+                aisdk: {
+                    hook: (name, callback, options) => register(host.aisdk.hook(name, (event) => Effect.promise(() => Promise.resolve(callback(event))), options)),
+                },
+                catalog: {
+                    provider: {
+                        list: adaptApiMethod(ProviderEndpoints["provider.list"], host.catalog.provider.list),
+                        get: adaptApiMethod(ProviderEndpoints["provider.get"], host.catalog.provider.get),
+                    },
+                    model: {
+                        list: adaptApiMethod(ModelEndpoints["model.list"], host.catalog.model.list),
+                        default: adaptApiMethod(ModelEndpoints["model.default"], host.catalog.model.default),
+                    },
+                    transform: transform(host.catalog),
+                    reload: () => run(host.catalog.reload()),
+                },
+                command: {
+                    list: adaptApiMethod(CommandEndpoints["command.list"], host.command.list),
+                    transform: (callback) => register(host.command.transform((draft) => callback({
+                        add: (definition) => draft.add({
+                            ...definition,
+                            execute: (input) => Effect.tryPromise({ try: () => definition.execute(input), catch: (cause) => cause }),
+                        }),
+                    }))),
+                    reload: () => run(host.command.reload()),
+                },
+                event: {
+                    subscribe: () => Stream.toAsyncIterable(host.event.subscribe().pipe(Stream.mapEffect((event) => Schema.encodeUnknownEffect(OpenCodeEvent)(event)), Stream.map((event) => event))),
+                },
+                integration: {
+                    list: adaptApiMethod(IntegrationEndpoints["integration.list"], host.integration.list),
+                    get: adaptApiMethod(IntegrationEndpoints["integration.get"], host.integration.get),
+                    connect: {
+                        key: adaptApiMethod(IntegrationEndpoints["integration.connect.key"], host.integration.connect.key),
+                    },
+                    oauth: {
+                        connect: adaptApiMethod(IntegrationEndpoints["integration.oauth.connect"], host.integration.oauth.connect),
+                        status: adaptApiMethod(IntegrationEndpoints["integration.oauth.status"], host.integration.oauth.status),
+                        complete: adaptApiMethod(IntegrationEndpoints["integration.oauth.complete"], host.integration.oauth.complete),
+                        cancel: adaptApiMethod(IntegrationEndpoints["integration.oauth.cancel"], host.integration.oauth.cancel),
+                    },
+                    command: {
+                        connect: adaptApiMethod(IntegrationEndpoints["integration.command.connect"], host.integration.command.connect),
+                        status: adaptApiMethod(IntegrationEndpoints["integration.command.status"], host.integration.command.status),
+                        cancel: adaptApiMethod(IntegrationEndpoints["integration.command.cancel"], host.integration.command.cancel),
+                    },
+                    transform: (callback) => register(host.integration.transform((draft) => callback({
+                        list: draft.list,
+                        get: draft.get,
+                        update: draft.update,
+                        remove: draft.remove,
+                        method: {
+                            list: draft.method.list,
+                            update: (input) => {
+                                if (!("authorize" in input))
+                                    return draft.method.update(input);
+                                const refresh = input.refresh;
+                                draft.method.update({
+                                    ...input,
+                                    authorize: (answer) => Effect.promise(() => input.authorize(answer)).pipe(Effect.map((authorization) => authorization.mode === "auto"
+                                        ? {
+                                            ...authorization,
+                                            callback: Effect.promise(() => authorization.callback),
+                                        }
+                                        : {
+                                            ...authorization,
+                                            callback: (code) => Effect.promise(() => authorization.callback(code)),
+                                        })),
+                                    refresh: refresh === undefined
+                                        ? undefined
+                                        : (credential) => Effect.promise(() => refresh(credential)),
+                                });
+                            },
+                            remove: draft.method.remove,
+                        },
+                    }))),
+                    reload: () => run(host.integration.reload()),
+                    connection: {
+                        active: (id) => Effect.runPromiseWith(context)(host.integration.connection.active(id)),
+                        resolve: (connection) => Effect.runPromiseWith(context)(host.integration.connection.resolve(connection)),
+                    },
+                },
+                mcp: {
+                    list: adaptApiMethod(McpEndpoints["mcp.list"], host.mcp.list),
+                    add: adaptApiMethod(McpEndpoints["mcp.add"], host.mcp.add),
+                    remove: adaptApiMethod(McpEndpoints["mcp.remove"], host.mcp.remove),
+                    connect: adaptApiMethod(McpEndpoints["mcp.connect"], host.mcp.connect),
+                    disconnect: adaptApiMethod(McpEndpoints["mcp.disconnect"], host.mcp.disconnect),
+                    transform: transform(host.mcp),
+                    reload: () => run(host.mcp.reload()),
+                },
+                plugin: {
+                    list: adaptApiMethod(PluginEndpoints["plugin.list"], host.plugin.list),
+                },
+                reference: {
+                    list: adaptApiMethod(ReferenceEndpoints["reference.list"], host.reference.list),
+                    transform: transform(host.reference),
+                    reload: () => run(host.reference.reload()),
+                },
+                skill: {
+                    list: adaptApiMethod(SkillEndpoints["skill.list"], host.skill.list),
+                    transform: transform(host.skill),
+                    reload: () => run(host.skill.reload()),
+                },
+                storage: {
+                    get: (key) => run(host.storage.get(key)),
+                    set: (key, value) => run(host.storage.set(key, value)),
+                    remove: (key) => run(host.storage.remove(key)),
+                    scan: (options) => run(host.storage.scan(options)),
+                },
+                tool: {
+                    transform: (callback) => register(host.tool.transform((draft) => callback({
+                        add: (tool) => draft.add({
+                            ...tool,
+                            execute: (input, context) => executePromiseTool(tool, input, context),
+                        }),
+                    }))),
+                    hook: (name, callback) => register(host.tool.hook(name, (event) => Effect.promise(() => Promise.resolve(callback(event))))),
+                },
+                websearch: {
+                    providers: adaptApiMethod(WebSearchEndpoints["websearch.providers"], host.websearch.providers),
+                    query: adaptApiMethod(WebSearchEndpoints["websearch.query"], host.websearch.query),
+                    reload: () => run(host.websearch.reload()),
+                    transform: (callback) => register(host.websearch.transform((draft) => {
+                        callback({
+                            add: (definition) => draft.add({
+                                id: definition.id,
+                                name: definition.name,
+                                execute: (input) => attempt((signal) => definition.execute(input, { signal })),
+                            }),
+                            default: draft.default,
+                        });
+                    })),
+                },
+                session: {
+                    hook: (name, callback, options) => register(host.session.hook(name, (event) => Effect.promise(() => Promise.resolve(callback(event))), options)),
+                    create: adaptApiMethod(SessionEndpoints["session.create"], host.session.create),
+                    get: adaptApiMethod(SessionEndpoints["session.get"], host.session.get),
+                    switchAgent: adaptApiMethod(SessionEndpoints["session.switchAgent"], host.session.switchAgent),
+                    switchModel: adaptApiMethod(SessionEndpoints["session.switchModel"], host.session.switchModel),
+                    prompt: adaptApiMethod(SessionEndpoints["session.prompt"], host.session.prompt),
+                    generate: adaptApiMethod(SessionEndpoints["session.generate"], host.session.generate),
+                    command: adaptApiMethod(SessionEndpoints["session.command"], host.session.command),
+                    synthetic: adaptApiMethod(SessionEndpoints["session.synthetic"], host.session.synthetic),
+                    interrupt: adaptApiMethod(SessionEndpoints["session.interrupt"], host.session.interrupt),
+                    rename: adaptApiMethod(SessionEndpoints["session.rename"], host.session.rename),
+                    wait: adaptApiMethod(SessionEndpoints["session.wait"], host.session.wait),
+                },
+                shell: {
+                    hook: (name, callback) => register(host.shell.hook(name, (event) => Effect.promise(() => Promise.resolve(callback(event))))),
+                },
+            };
+            yield* Effect.acquireRelease(Effect.promise(() => Promise.resolve(plugin.setup(context2))), (cleanup) => (cleanup ? Effect.promise(() => Promise.resolve(cleanup())) : Effect.void));
+        }),
+    });
+}
+function attempt(evaluate) {
+    return Effect.tryPromise({ try: evaluate, catch: (cause) => cause });
+}
+const executePromiseTool = (tool, input, context) => Effect.promise(() => tool.execute(input, {
+    ...context,
+    progress: (update) => Effect.runPromise(context.progress(update)),
+}));

package/dist/promise/agent.d.ts

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

package/dist/{v2/effect → promise}/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/promise/catalog.d.ts

@@ -0,0 +1,33 @@
+import type { CatalogApi } from "@opencode-ai/client/promise/api";
+import type { Model } from "@opencode-ai/schema/model";
+import type { Provider } from "@opencode-ai/schema/provider";
+import type { Transform } from "./registration.js";
+import type { DeepMutable } from "./types.js";
+export interface CatalogProviderRecord {
+    readonly provider: DeepMutable<Provider.Info>;
+    readonly models: ReadonlyMap<string, DeepMutable<Model.Info>>;
+}
+export interface CatalogDraft {
+    readonly provider: {
+        list(): readonly CatalogProviderRecord[];
+        get(providerID: string): CatalogProviderRecord | undefined;
+        update(providerID: string, update: (provider: DeepMutable<Provider.Info>) => void): void;
+        remove(providerID: string): void;
+    };
+    readonly model: {
+        get(providerID: string, modelID: string): DeepMutable<Model.Info> | undefined;
+        update(providerID: string, modelID: string, update: (model: 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 {
+    readonly transform: Transform<CatalogDraft>;
+    readonly reload: () => Promise<void>;
+}

package/dist/promise/command.d.ts

@@ -0,0 +1,22 @@
+import type { CommandApi } from "@opencode-ai/client/promise/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 { 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) => Promise<void>;
+}
+export interface CommandDraft {
+    add(definition: CommandDefinition): void;
+}
+export interface CommandDomain extends Pick<CommandApi, "list"> {
+    readonly transform: Transform<CommandDraft>;
+    readonly reload: () => Promise<void>;
+}

package/dist/promise/event.d.ts

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

package/dist/promise/index.d.ts

@@ -0,0 +1,14 @@
+export type { PluginOptions } from "../options.js";
+export type { StorageEntry, StorageScanOptions, StorageScanResult } from "../storage.js";
+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 { 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 { WebSearch } from "@opencode-ai/schema/websearch";

package/dist/promise/index.js

@@ -0,0 +1,12 @@
+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 { 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 { WebSearch } from "@opencode-ai/schema/websearch";

package/dist/promise/integration.d.ts

@@ -0,0 +1,79 @@
+import type { ConnectionInfo } from "@opencode-ai/client";
+import type { IntegrationApi } from "@opencode-ai/client/promise/api";
+import { Credential } from "@opencode-ai/schema/credential";
+import { Form } from "@opencode-ai/schema/form";
+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: Promise<Credential.OAuth>;
+} | {
+    readonly mode: "code";
+    readonly callback: (code: string) => Promise<Credential.OAuth>;
+});
+export type IntegrationOAuthMethodRegistration = {
+    readonly integrationID: string;
+    readonly method: IntegrationOAuthMethod;
+    readonly authorize: (answer: Form.Answer) => Promise<IntegrationOAuthAuthorization>;
+    readonly refresh?: (credential: Credential.OAuth) => Promise<Credential.OAuth>;
+    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, "wellknown"> {
+    readonly transform: Transform<IntegrationDraft>;
+    readonly reload: () => Promise<void>;
+    readonly connection: {
+        readonly active: (integrationID: string) => Promise<ConnectionInfo | undefined>;
+        readonly resolve: (connection: ConnectionInfo) => Promise<Credential.Value | undefined>;
+    };
+}
+export {};

package/dist/promise/integration.js

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

package/dist/promise/mcp.d.ts

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

package/dist/promise/plugin.d.ts

@@ -0,0 +1,43 @@
+import type { PluginApi } from "@opencode-ai/client/promise/api";
+import type { PluginOptions } from "../options.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 { 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 { WebSearchDomain } from "./websearch.js";
+export interface Context {
+    readonly app: App;
+    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 plugin: PluginApi;
+    readonly reference: ReferenceDomain;
+    readonly session: SessionDomain;
+    readonly shell: ShellDomain;
+    readonly skill: SkillDomain;
+    readonly storage: StorageDomain;
+    readonly tool: ToolDomain;
+    readonly websearch: WebSearchDomain;
+}
+export type Cleanup = () => Promise<void> | void;
+export interface Plugin {
+    readonly id: string;
+    readonly tui?: boolean;
+    readonly setup: (context: Context) => Promise<Cleanup | void> | Cleanup | void;
+}
+export declare function define(plugin: Plugin): Plugin;

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

@@ -1,10 +1,12 @@
-import type { ReferenceGitSource, ReferenceLocalSource } from "@opencode-ai/sdk/v2/types";
-import type { Hooks } from "./registration.js";
+import type { ReferenceApi } from "@opencode-ai/client/promise/api";
+import type { ReferenceGitSource, ReferenceLocalSource } from "@opencode-ai/client";
+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 type ReferenceHooks = Hooks<{
-    transform: ReferenceDraft;
-}>;
+export interface ReferenceDomain extends ReferenceApi {
+    readonly transform: Transform<ReferenceDraft>;
+    readonly reload: () => Promise<void>;
+}

package/dist/promise/registration.d.ts

@@ -0,0 +1,10 @@
+export interface Registration {
+    readonly dispose: () => Promise<void>;
+}
+export interface ModelHookOptions {
+    /** Limits the hook to one provider. Unscoped hooks apply to every provider. */
+    readonly providerID?: string;
+}
+export type Hooks<Spec> = <Name extends keyof Spec>(name: Name, callback: (input: Spec[Name]) => Promise<void> | void) => Promise<Registration>;
+export type ModelHooks<Spec> = <Name extends keyof Spec>(name: Name, callback: (input: Spec[Name]) => Promise<void> | void, options?: ModelHookOptions) => Promise<Registration>;
+export type Transform<Input> = (callback: (input: Input) => void) => Promise<Registration>;

package/dist/promise/session.d.ts

@@ -0,0 +1,47 @@
+import type { SessionApi } from "@opencode-ai/client/promise/api";
+import type { Message, SystemPart } from "@opencode-ai/ai";
+import type { Agent } from "@opencode-ai/schema/agent";
+import type { Model } from "@opencode-ai/schema/model";
+import type { Session } from "@opencode-ai/schema/session";
+import type { JsonSchema } from "effect";
+import type { ModelHooks } from "./registration.js";
+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;
+    }>;
+}
+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 context: SessionContext;
+    readonly "model.request": SessionModelRequest;
+    readonly "http.request": SessionHttpRequest;
+    readonly "http.response": SessionHttpResponse;
+}
+export type SessionDomain = Pick<SessionApi, "create" | "get" | "switchAgent" | "switchModel" | "prompt" | "generate" | "command" | "synthetic" | "interrupt" | "rename" | "wait"> & {
+    readonly hook: ModelHooks<SessionHooks>;
+};

package/dist/promise/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>;
+}