@opencode-ai/plugin 0.0.0-dev-17732 → 0.0.0-dev-202608201547

package/dist/effect/websearch.d.ts

@@ -1,20 +0,0 @@
-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

@@ -1,12 +0,0 @@
-import { 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>;

package/dist/promise/adapter.js

@@ -1,255 +0,0 @@
-import { Tool } from "@opencode-ai/schema/tool";
-import { Effect, Schema, SchemaAST, Scope, 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 scope = yield* Scope.Scope;
-            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)(Scope.provide(scope)(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: transform(host.command),
-                    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),
-                    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))))),
-                },
-            };
-            const cleanup = yield* Effect.promise(() => Promise.resolve(plugin.setup(context2)));
-            if (!cleanup)
-                return;
-            yield* Effect.addFinalizer(() => Effect.promise(() => Promise.resolve(cleanup())));
-        }),
-    });
-}
-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

@@ -1,15 +0,0 @@
-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/promise/catalog.d.ts

@@ -1,33 +0,0 @@
-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

@@ -1,13 +0,0 @@
-import type { CommandApi } from "@opencode-ai/client/promise/api";
-import type { CommandInfo } from "@opencode-ai/client";
-import type { Transform } from "./registration.js";
-export interface CommandDraft {
-    list(): readonly CommandInfo[];
-    get(name: string): CommandInfo | undefined;
-    update(name: string, update: (command: CommandInfo) => void): void;
-    remove(name: string): void;
-}
-export interface CommandDomain extends CommandApi {
-    readonly transform: Transform<CommandDraft>;
-    readonly reload: () => Promise<void>;
-}

package/dist/promise/event.d.ts

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

package/dist/promise/index.d.ts

@@ -1,14 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,79 +0,0 @@
-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

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

package/dist/promise/mcp.d.ts

@@ -1,15 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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/promise/registration.d.ts

@@ -1,10 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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" | "prompt" | "generate" | "command" | "synthetic" | "interrupt" | "rename" | "wait"> & {
-    readonly hook: ModelHooks<SessionHooks>;
-};

package/dist/promise/shell.d.ts

@@ -1,14 +0,0 @@
-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/promise/skill.d.ts

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