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

package/dist/promise/adapter.js

@@ -0,0 +1,313 @@
+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,
+        vcs: plugin.vcs,
+        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 GenerateEndpoints = ClientApi.groups["server.generate"].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 PermissionEndpoints = ClientApi.groups["server.permission"].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 VcsEndpoints = ClientApi.groups["server.vcs"].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 promiseExecutor = (execute) => (input, context) => run(execute(input, {
+                ...context,
+                progress: (update) => Effect.promise(() => context.progress(update)),
+            }));
+            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,
+                location: host.location,
+                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))),
+                },
+                generate: {
+                    text: adaptApiMethod(GenerateEndpoints["generate.text"], host.generate.text),
+                },
+                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),
+                    transform: transform(host.mcp),
+                    reload: () => run(host.mcp.reload()),
+                },
+                permission: {
+                    hook: (name, callback) => register(host.permission.hook(name, (event) => Effect.promise(() => Promise.resolve(callback(event))))),
+                    list: adaptApiMethod(PermissionEndpoints["session.permission.list"], host.permission.list),
+                    get: adaptApiMethod(PermissionEndpoints["session.permission.get"], host.permission.get),
+                    reply: adaptApiMethod(PermissionEndpoints["session.permission.reply"], host.permission.reply),
+                },
+                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: {
+                    reload: () => run(host.tool.reload()),
+                    transform: (callback) => register(host.tool.transform((draft) => callback({
+                        list: () => draft.list().map((tool) => ({ ...tool, execute: promiseExecutor(tool.execute) })),
+                        get: (id) => {
+                            const tool = draft.get(id);
+                            return tool ? { ...tool, execute: promiseExecutor(tool.execute) } : undefined;
+                        },
+                        add: (tool) => draft.add({
+                            ...tool,
+                            execute: (input, context) => executePromiseTool(tool, input, context),
+                        }),
+                        update: (id, update) => draft.update(id, (tool) => {
+                            const value = {
+                                ...tool,
+                                execute: promiseExecutor(tool.execute),
+                            };
+                            update(value);
+                            Object.assign(tool, value, {
+                                output: value.output,
+                                options: value.options,
+                                execute: (input, context) => executePromiseTool(value, input, context),
+                            });
+                        }),
+                        remove: draft.remove,
+                    }))),
+                    hook: (name, callback) => register(host.tool.hook(name, (event) => Effect.promise(() => Promise.resolve(callback(event))))),
+                },
+                vcs: {
+                    get: adaptApiMethod(VcsEndpoints["vcs.get"], host.vcs.get),
+                    branches: adaptApiMethod(VcsEndpoints["vcs.branches"], host.vcs.branches),
+                    status: adaptApiMethod(VcsEndpoints["vcs.status"], host.vcs.status),
+                    diff: adaptApiMethod(VcsEndpoints["vcs.diff"], host.vcs.diff),
+                    reload: () => run(host.vcs.reload()),
+                    transform: (callback) => register(host.vcs.transform((draft) => {
+                        callback({
+                            add: (definition) => draft.add({
+                                id: definition.id,
+                                name: definition.name,
+                                info: (input) => attempt((signal) => definition.info(input, { signal })),
+                                branches: (input) => attempt((signal) => definition.branches(input, { signal })),
+                                status: (input) => attempt((signal) => definition.status(input, { signal })),
+                                diff: (input) => attempt((signal) => definition.diff(input, { signal })),
+                            }),
+                            default: draft.default,
+                        });
+                    })),
+                },
+                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),
+                    move: adaptApiMethod(SessionEndpoints["session.move"], host.session.move),
+                    wait: adaptApiMethod(SessionEndpoints["session.wait"], host.session.wait),
+                    context: adaptApiMethod(SessionEndpoints["session.context"], host.session.context),
+                },
+                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,16 @@
+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 { 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/promise/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/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 Pick<McpApi, "list"> {
+    readonly transform: Transform<MCPDraft>;
+    readonly reload: () => Promise<void>;
+}

package/dist/promise/permission.d.ts

@@ -0,0 +1,21 @@
+import type { PermissionApi } from "@opencode-ai/client/promise/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, "list" | "get" | "reply"> & {
+    readonly hook: Hooks<PermissionHooks>;
+};

package/dist/promise/plugin.d.ts

@@ -0,0 +1,52 @@
+import type { GenerateApi, PluginApi } from "@opencode-ai/client/promise/api";
+import type { Location } from "@opencode-ai/schema/location";
+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;
+    readonly permission: PermissionDomain;
+    readonly plugin: PluginApi;
+    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 type Cleanup = () => Promise<void> | void;
+export interface Plugin {
+    readonly id: string;
+    readonly tui?: boolean;
+    readonly vcs?: VcsDiscovery;
+    readonly setup: (context: Context) => Promise<Cleanup | void> | Cleanup | void;
+}
+export declare function define(plugin: Plugin): Plugin;