@opencode-ai/plugin 0.0.0-dev-19025 → 0.0.0-dev-202609031800

package/dist/promise/adapter.js

@@ -1,424 +0,0 @@
-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();
-class ReturnedRpcError extends Error {
-    type;
-    data;
-    constructor(type, message, data) {
-        super(message);
-        this.type = type;
-        this.data = data;
-    }
-}
-const makeStreams = Effect.fn("Plugin.Event.makeStreams")(function* () {
-    const context = yield* Effect.context();
-    const subscriptions = new Set();
-    // Async iterators own separate scopes, so close them when the plugin unloads.
-    yield* Effect.addFinalizer(() => Effect.promise(() => Promise.all(Array.from(subscriptions, (close) => close()))));
-    return ((stream, options) => ({
-        [Symbol.asyncIterator]() {
-            const iterator = Stream.toAsyncIterableWith(stream, context)[Symbol.asyncIterator]();
-            const close = () => {
-                subscriptions.delete(close);
-                options?.signal?.removeEventListener("abort", abort);
-                return iterator.return?.() ?? Promise.resolve({ done: true, value: undefined });
-            };
-            const abort = () => {
-                void close();
-            };
-            subscriptions.add(close);
-            options?.signal?.addEventListener("abort", abort, { once: true });
-            if (options?.signal?.aborted)
-                abort();
-            return {
-                next: () => iterator.next().then((result) => (result.done ? close().then(() => result) : result), (error) => close().then(() => Promise.reject(error))),
-                return: close,
-            };
-        },
-    }));
-});
-const rpcFromEffect = Effect.fn("Plugin.Rpc.fromEffect")(function* (host, streams) {
-    const context = yield* Effect.context();
-    const run = Effect.runPromiseWith(context);
-    const client = (definition) => {
-        const local = host(definition);
-        const subscribe = (name, options) => streams(local.events.subscribe(name), options);
-        return Object.assign(Object.fromEntries(Object.keys(definition.methods).map((name) => [
-            name,
-            (input, options) => {
-                // SAFETY: The local client was built from this definition, so every declared key is an Effect method.
-                // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
-                const method = local[name];
-                return run(method(input), { signal: options?.signal });
-            },
-        ])), {
-            events: {
-                subscribe,
-                on: (name, handler, options) => {
-                    const controller = new AbortController();
-                    const signal = options?.signal ? AbortSignal.any([controller.signal, options.signal]) : controller.signal;
-                    void (async () => {
-                        for await (const event of subscribe(name, { signal }))
-                            await handler(event);
-                    })().catch((error) => run(Effect.logError(error)));
-                    return () => controller.abort();
-                },
-            },
-        });
-    };
-    const register = (definition, handlers) => run(host.register(definition, 
-    // SAFETY: Each entry preserves its definition key; Core restores that method's erased schema and error types.
-    // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
-    Object.fromEntries(Object.entries(handlers).map(([name, handler]) => [
-        name,
-        (input, context) => Effect.tryPromise({
-            try: (signal) => {
-                // SAFETY: Promise RPC handlers return Promise values before this adapter erases their concrete types.
-                // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
-                return Reflect.apply(handler, undefined, [
-                    input,
-                    {
-                        signal,
-                        error: (type, message, data) => new ReturnedRpcError(type, message, data),
-                    },
-                ]);
-            },
-            catch: (error) => hostRpcError(context, error),
-        }).pipe(Effect.flatMap((result) => result instanceof ReturnedRpcError
-            ? Effect.fail(hostRpcError(context, result))
-            : Effect.succeed(result))),
-    ])))).then((registration) => ({
-        dispose: () => run(registration.dispose),
-        events: { emit: (...args) => run(registration.events.emit(...args)) },
-    }));
-    // SAFETY: Client and register implement RpcDomain from the same portable definitions and schema adapters.
-    // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
-    return Object.assign(client, { register });
-});
-function hostRpcError(context, error) {
-    if (!(error instanceof ReturnedRpcError))
-        return error;
-    return context.error(error.type, error.message, error.data);
-}
-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
- * Core plugin runtime 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,
-        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 ExperimentalEndpoints = ClientApi.groups["server.experimental"].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();
-            const streams = yield* makeStreams();
-            // 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((editor) => {
-                callback(editor);
-            }));
-            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((editor) => callback({
-                        add: (definition) => editor.add({
-                            ...definition,
-                            execute: (input) => Effect.tryPromise({ try: () => definition.execute(input), catch: (cause) => cause }),
-                        }),
-                    }))),
-                    reload: () => run(host.command.reload()),
-                },
-                event: {
-                    subscribe: (options) => streams(host.event.subscribe().pipe(Stream.mapEffect((event) => Schema.encodeUnknownEffect(OpenCodeEvent)(event)), Stream.map((event) => event)), options),
-                },
-                experimental: {
-                    terminal: {
-                        read: adaptApiMethod(ExperimentalEndpoints["persistentPty.read"], host.experimental.terminal.read),
-                    },
-                },
-                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((editor) => callback({
-                        list: editor.list,
-                        get: editor.get,
-                        update: editor.update,
-                        remove: editor.remove,
-                        method: {
-                            list: editor.method.list,
-                            update: (input) => {
-                                if (!("authorize" in input))
-                                    return editor.method.update(input);
-                                const refresh = input.refresh;
-                                editor.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: editor.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()),
-                },
-                rpc: yield* rpcFromEffect(host.rpc, streams),
-                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((editor) => callback({
-                        list: () => editor.list().map((tool) => ({ ...tool, execute: promiseExecutor(tool.execute) })),
-                        get: (id) => {
-                            const tool = editor.get(id);
-                            return tool ? { ...tool, execute: promiseExecutor(tool.execute) } : undefined;
-                        },
-                        namespace: editor.namespace,
-                        add: (tool) => editor.add({
-                            ...tool,
-                            execute: (input, context) => executePromiseTool(tool, input, context),
-                        }),
-                        update: (id, update) => editor.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: editor.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),
-                    base: adaptApiMethod(VcsEndpoints["vcs.base"], host.vcs.base),
-                    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((editor) => {
-                        callback({
-                            add: (definition) => {
-                                const base = definition.base?.bind(definition);
-                                editor.add({
-                                    id: definition.id,
-                                    name: definition.name,
-                                    info: (input) => attempt((signal) => definition.info(input, { signal })),
-                                    base: base ? (input) => attempt((signal) => base(input, { signal })) : undefined,
-                                    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: editor.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((editor) => {
-                        callback({
-                            add: (definition) => editor.add({
-                                id: definition.id,
-                                name: definition.name,
-                                execute: (input) => attempt((signal) => definition.execute(input, { signal })),
-                            }),
-                            default: editor.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

@@ -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 AgentEditor {
-    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<AgentEditor>;
-    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 CatalogEditor {
-    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<CatalogEditor>;
-    readonly reload: () => Promise<void>;
-}

package/dist/promise/command.d.ts

@@ -1,22 +0,0 @@
-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 CommandEditor {
-    add(definition: CommandDefinition): void;
-}
-export interface CommandDomain extends Pick<CommandApi, "list"> {
-    readonly transform: Transform<CommandEditor>;
-    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,18 +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 { Location } from "@opencode-ai/schema/location";
-export { Mcp } from "@opencode-ai/schema/mcp";
-export { Model } from "@opencode-ai/schema/model";
-export { PersistentPty } from "@opencode-ai/schema/persistent-pty";
-export { Provider } from "@opencode-ai/schema/provider";
-export { Reference } from "@opencode-ai/schema/reference";
-export { Rpc } from "@opencode-ai/schema/rpc";
-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

@@ -1,16 +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 { Location } from "@opencode-ai/schema/location";
-export { Mcp } from "@opencode-ai/schema/mcp";
-export { Model } from "@opencode-ai/schema/model";
-export { PersistentPty } from "@opencode-ai/schema/persistent-pty";
-export { Provider } from "@opencode-ai/schema/provider";
-export { Reference } from "@opencode-ai/schema/reference";
-export { Rpc } from "@opencode-ai/schema/rpc";
-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

@@ -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 IntegrationEditor {
-    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<IntegrationEditor>;
-    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 MCPEditor {
-    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<MCPEditor>;
-    readonly reload: () => Promise<void>;
-}