@opencode-ai/core 0.0.0-next-17293

package/dist/types/models-dev.d.ts

@@ -0,0 +1,33 @@
+import { Context, Effect, Layer, Schema } from "effect";
+import { HttpClient } from "effect/unstable/http";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+import { Bus } from "./bus.js";
+import { Model } from "./model.js";
+import { Provider } from "./provider.js";
+import { KV } from "./kv.js";
+export declare const CatalogModelStatus: Schema.Literals<readonly ["alpha", "beta", "deprecated"]>;
+export type CatalogModelStatus = typeof CatalogModelStatus.Type;
+export type Snapshot = {
+    readonly info: Provider.Info;
+    readonly models: readonly Model.Info[];
+    readonly environment: readonly string[];
+};
+export { Event } from "@opencode-ai/schema/models-dev";
+export interface Interface {
+    readonly get: () => Effect.Effect<readonly Snapshot[]>;
+    readonly refresh: (force?: boolean) => Effect.Effect<void>;
+}
+export declare const Options: Schema.Struct<{
+    readonly url: Schema.optional<Schema.String>;
+    readonly file: Schema.optional<Schema.String>;
+    readonly fetch: Schema.optional<Schema.Boolean>;
+    readonly snapshot: Schema.optional<Schema.Boolean>;
+}>;
+export type Options = typeof Options.Type;
+declare const Service_base: Context.ServiceClass<Service, "@opencode/ModelsDev", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layer: (options?: Options) => Layer.Layer<Service, never, HttpClient.HttpClient | FSUtil.Service | Bus.Service | KV.Service>;
+export declare function configured(options?: Options): import("@opencode-ai/util/effect/layer-node").Node<Service, never, import("@opencode-ai/util/effect/layer-node").Tag<"global">>;
+export declare const node: import("@opencode-ai/util/effect/layer-node").Node<Service, never, import("@opencode-ai/util/effect/layer-node").Tag<"global">>;
+export * as ModelsDev from "./models-dev.js";

package/dist/types/oauth/page.d.ts

@@ -0,0 +1,15 @@
+export interface CallbackPageOptions {
+    /** Friendly integration name shown as a subtitle, e.g. "xAI", "Snowflake", "MCP". */
+    provider?: string;
+    /** Attempt to close the window shortly after success. Defaults to true. */
+    autoClose?: boolean;
+}
+export declare function success(options?: CallbackPageOptions): string;
+export declare function error(detail: string, options?: CallbackPageOptions): string;
+export interface BootstrapOptions {
+    /** Same-origin path the in-browser script POSTs the parsed callback to. */
+    tokenPath: string;
+    provider?: string;
+}
+export declare function bootstrap(options: BootstrapOptions): string;
+export * as OauthCallbackPage from "./page.js";

package/dist/types/permission/saved.d.ts

@@ -0,0 +1,40 @@
+export * as PermissionSaved from "./saved.js";
+import { Context, Effect, Schema } from "effect";
+export declare const ID: Schema.brand<Schema.String, "PermissionSaved.ID"> & {
+    create: () => string & import("effect/Brand").Brand<"PermissionSaved.ID">;
+};
+export type ID = typeof ID.Type;
+export declare const Info: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "PermissionSaved.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"PermissionSaved.ID">;
+    };
+    readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
+        global: string & import("effect/Brand").Brand<"Project.ID">;
+    };
+    readonly action: Schema.String;
+    readonly resource: Schema.String;
+}>;
+export type Info = typeof Info.Type;
+export declare const ListInput: Schema.Struct<{
+    readonly projectID: Schema.optional<Schema.brand<Schema.String, "Project.ID"> & {
+        global: string & import("effect/Brand").Brand<"Project.ID">;
+    }>;
+}>;
+export type ListInput = typeof ListInput.Type;
+export declare const AddInput: Schema.Struct<{
+    readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
+        global: string & import("effect/Brand").Brand<"Project.ID">;
+    };
+    readonly action: Schema.String;
+    readonly resources: Schema.$Array<Schema.String>;
+}>;
+export type AddInput = typeof AddInput.Type;
+export interface Interface {
+    readonly list: (input?: ListInput) => Effect.Effect<ReadonlyArray<Info>>;
+    readonly add: (input: AddInput) => Effect.Effect<void>;
+    readonly remove: (id: ID) => Effect.Effect<void>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/PermissionSaved", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const node: import("@opencode-ai/util/effect/layer-node").Node<Service, never, import("@opencode-ai/util/effect/layer-node").Tag<"global">>;

package/dist/types/permission/sql.d.ts

@@ -0,0 +1,103 @@
+export declare const PermissionTable: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "permission";
+    schema: undefined;
+    columns: {
+        time_created: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "permission";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        time_updated: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "permission";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "permission";
+            dataType: "string";
+            data: string & import("effect/Brand").Brand<"PermissionSaved.ID">;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        project_id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "permission";
+            dataType: "string";
+            data: string & import("effect/Brand").Brand<"Project.ID">;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        action: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "permission";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        resource: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "permission";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+    };
+    dialect: "sqlite";
+}>;

package/dist/types/permission.d.ts

@@ -0,0 +1,125 @@
+export * as Permission from "./permission.js";
+import { Context, Effect, Schema } from "effect";
+import { Permission } from "@opencode-ai/schema/permission";
+import { SessionErrors } from "./session/error.js";
+import { SessionSchema } from "./session/schema.js";
+declare const PermissionEffect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+export { PermissionEffect as Effect };
+export { Rule, Ruleset } from "@opencode-ai/schema/permission";
+export declare const ID: Schema.brand<Schema.String, "Permission.ID"> & {
+    create: (id?: string) => string & import("effect/Brand").Brand<"Permission.ID">;
+};
+export type ID = typeof ID.Type;
+export declare const Source: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"tool">;
+    readonly messageID: Schema.String;
+    readonly id: Schema.String;
+}>]>;
+export type Source = typeof Source.Type;
+export declare const Request: Schema.Struct<{
+    readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    };
+    readonly action: Schema.String;
+    readonly resources: Schema.$Array<Schema.String>;
+    readonly save: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+    readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+    readonly source: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"tool">;
+        readonly messageID: Schema.String;
+        readonly id: Schema.String;
+    }>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"tool">;
+        readonly messageID: Schema.String;
+        readonly id: Schema.String;
+    }>]>>, never, never>;
+    readonly id: Schema.brand<Schema.String, "Permission.ID"> & {
+        create: (id?: string) => string & import("effect/Brand").Brand<"Permission.ID">;
+    };
+}>;
+export type Request = typeof Request.Type;
+export declare const Reply: Schema.Literals<readonly ["once", "always", "reject"]>;
+export type Reply = typeof Reply.Type;
+export declare const AssertInput: Schema.Struct<{
+    readonly agent: Schema.optional<Schema.brand<Schema.String, "Agent.ID">>;
+    readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    };
+    readonly action: Schema.String;
+    readonly resources: Schema.$Array<Schema.String>;
+    readonly save: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+    readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+    readonly source: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"tool">;
+        readonly messageID: Schema.String;
+        readonly id: Schema.String;
+    }>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"tool">;
+        readonly messageID: Schema.String;
+        readonly id: Schema.String;
+    }>]>>, never, never>;
+    readonly id: Schema.optional<Schema.brand<Schema.String, "Permission.ID"> & {
+        create: (id?: string) => string & import("effect/Brand").Brand<"Permission.ID">;
+    }>;
+}>;
+export type AssertInput = typeof AssertInput.Type;
+export declare const ReplyInput: Schema.Struct<{
+    readonly requestID: Schema.brand<Schema.String, "Permission.ID"> & {
+        create: (id?: string) => string & import("effect/Brand").Brand<"Permission.ID">;
+    };
+    readonly reply: Schema.Literals<readonly ["once", "always", "reject"]>;
+    readonly message: Schema.optional<Schema.String>;
+}>;
+export type ReplyInput = typeof ReplyInput.Type;
+export declare const AskResult: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Permission.ID"> & {
+        create: (id?: string) => string & import("effect/Brand").Brand<"Permission.ID">;
+    };
+    readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+}>;
+export type AskResult = typeof AskResult.Type;
+export { Event } from "@opencode-ai/schema/permission";
+declare const DeclinedError_base: Schema.Class<DeclinedError, Schema.TaggedStruct<"Permission.DeclinedError", {}>, import("effect/Cause").YieldableError>;
+export declare class DeclinedError extends DeclinedError_base {
+}
+declare const CorrectedError_base: Schema.Class<CorrectedError, Schema.TaggedStruct<"Permission.CorrectedError", {
+    readonly feedback: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class CorrectedError extends CorrectedError_base {
+}
+declare const BlockedError_base: Schema.Class<BlockedError, Schema.TaggedStruct<"Permission.BlockedError", {
+    readonly rules: Schema.$Array<Schema.Struct<{
+        readonly action: Schema.String;
+        readonly resource: Schema.String;
+        readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+    }>>;
+    readonly permission: Schema.String;
+    readonly resources: Schema.$Array<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+export declare class BlockedError extends BlockedError_base {
+    get message(): string;
+}
+declare const NotFoundError_base: Schema.Class<NotFoundError, Schema.TaggedStruct<"Permission.NotFoundError", {
+    readonly requestID: Schema.brand<Schema.String, "Permission.ID"> & {
+        create: (id?: string) => string & import("effect/Brand").Brand<"Permission.ID">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class NotFoundError extends NotFoundError_base {
+}
+export type Error = BlockedError | CorrectedError;
+export declare function evaluate(action: string, resource: string, ...rulesets: Permission.Ruleset[]): Permission.Rule;
+export declare function merge(...rulesets: Permission.Ruleset[]): Permission.Ruleset;
+export interface Interface {
+    readonly ask: (input: AssertInput) => Effect.Effect<AskResult, SessionErrors.NotFoundError>;
+    readonly assert: (input: AssertInput) => Effect.Effect<void, Error | SessionErrors.NotFoundError>;
+    readonly reply: (input: ReplyInput) => Effect.Effect<void, NotFoundError>;
+    readonly get: (id: ID) => Effect.Effect<Request | undefined>;
+    readonly forSession: (sessionID: SessionSchema.ID) => Effect.Effect<ReadonlyArray<Request>>;
+    readonly list: () => Effect.Effect<ReadonlyArray<Request>>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/Permission", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const node: import("@opencode-ai/util/effect/layer-node").Node<Service, never, import("@opencode-ai/util/effect/layer-node").Tag<"location">>;

package/dist/types/plugin/agent.d.ts

@@ -0,0 +1,2 @@
+export * as AgentPlugin from "./agent.js";
+export declare const Plugin: import("@opencode-ai/plugin/effect/plugin").Plugin<import("effect/Scope").Scope>;

package/dist/types/plugin/command.d.ts

@@ -0,0 +1,3 @@
+export * as CommandPlugin from "./command.js";
+import { Location } from "../location.js";
+export declare const Plugin: import("@opencode-ai/plugin/effect/plugin").Plugin<import("effect/Scope").Scope | Location.Service>;

package/dist/types/plugin/hooks.d.ts

@@ -0,0 +1,31 @@
+export * as PluginHooks from "./hooks.js";
+import type { AISDKHooks } from "@opencode-ai/plugin/effect/aisdk";
+import type { SessionHooks } from "@opencode-ai/plugin/effect/session";
+import type { ShellHooks } from "@opencode-ai/plugin/effect/shell";
+import type { ToolFailures, ToolHooks } from "@opencode-ai/plugin/effect/tool";
+import { Context, Effect, Scope } from "effect";
+import { State } from "../state.js";
+export interface Domains {
+    readonly aisdk: AISDKHooks;
+    readonly session: SessionHooks;
+    readonly shell: ShellHooks;
+    readonly tool: ToolHooks;
+}
+type NoFailures<Spec> = {
+    readonly [Name in keyof Spec]: never;
+};
+interface Failures extends Record<keyof Domains, unknown> {
+    readonly aisdk: NoFailures<AISDKHooks>;
+    readonly session: NoFailures<SessionHooks>;
+    readonly shell: NoFailures<ShellHooks>;
+    readonly tool: ToolFailures;
+}
+type Callback<Event, Error> = (event: Event) => Effect.Effect<void, Error>;
+export interface Interface {
+    readonly register: <Domain extends keyof Domains, Name extends keyof Domains[Domain] & keyof Failures[Domain]>(domain: Domain, name: Name, callback: Callback<Domains[Domain][Name], Failures[Domain][Name]>) => Effect.Effect<State.Registration, never, Scope.Scope>;
+    readonly trigger: <Domain extends keyof Domains, Name extends keyof Domains[Domain] & keyof Failures[Domain]>(domain: Domain, name: Name, event: Domains[Domain][Name]) => Effect.Effect<Domains[Domain][Name], Failures[Domain][Name]>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/PluginHooks", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const node: import("@opencode-ai/util/effect/layer-node").Node<Service, never, import("@opencode-ai/util/effect/layer-node").Tag<"location">>;

package/dist/types/plugin/host.d.ts

@@ -0,0 +1,280 @@
+export * as PluginHost from "./host.js";
+import { EventManifest } from "@opencode-ai/schema/event-manifest";
+import { App } from "../app.js";
+import { Effect, Stream } from "effect";
+import { Agent } from "../agent.js";
+import { AISDK } from "../aisdk.js";
+import { Catalog } from "../catalog.js";
+import { Command } from "../command.js";
+import { Bus } from "../bus.js";
+import { Integration } from "../integration.js";
+import { Location } from "../location.js";
+import { Model } from "../model.js";
+import { PluginRuntime } from "./runtime.js";
+import { Reference } from "../reference.js";
+import { Skill } from "../skill.js";
+import { Tool } from "../tool.js";
+import { WebSearch } from "../websearch.js";
+import { PluginHooks } from "./hooks.js";
+export declare const make: (plugin: import("../plugin.js").Interface) => Effect.Effect<{
+    app: App.Info;
+    options: {};
+    agent: {
+        get: (input: import("@opencode-ai/client/effect/api").Endpoint3_1Input) => Effect.Effect<{
+            data: import("@opencode-ai/schema/agent").Info;
+            location: Location.Info;
+        }, Error, never>;
+        list: (input: import("@opencode-ai/client/effect/api").Endpoint3_0Input | undefined) => Effect.Effect<{
+            readonly location: Location.Info;
+            readonly data: Agent.Info[];
+        }, never, never>;
+        reload: import("../state.js").Reload;
+        transform: (callback: (input: import("@opencode-ai/plugin/effect/agent").AgentDraft) => void) => Effect.Effect<import("../state.js").Registration, never, import("effect/Scope").Scope>;
+    };
+    aisdk: {
+        hook: <Name extends keyof import("@opencode-ai/plugin/effect/aisdk").AISDKHooks>(name: Name, callback: (input: import("@opencode-ai/plugin/effect/aisdk").AISDKHooks[Name]) => Effect.Effect<void, Record<keyof import("@opencode-ai/plugin/effect/aisdk").AISDKHooks, never>[Name], never>) => Effect.Effect<import("../state.js").Registration, never, import("effect/Scope").Scope>;
+    };
+    catalog: {
+        provider: {
+            list: () => Effect.Effect<{
+                location: Location.Info;
+                data: import("@opencode-ai/schema/provider").Info[];
+            }, never, never>;
+            get: (input: import("@opencode-ai/client/effect/api").Endpoint9_1Input) => Effect.Effect<{
+                location: Location.Info;
+                data: import("@opencode-ai/schema/provider").Info;
+            }, Error, never>;
+        };
+        model: {
+            list: () => Effect.Effect<{
+                location: Location.Info;
+                data: import("@opencode-ai/schema/model").Info[];
+            }, never, never>;
+            default: () => Effect.Effect<{
+                location: Location.Info;
+                data: import("@opencode-ai/schema/model").Info | undefined;
+            }, never, never>;
+        };
+        reload: import("../state.js").Reload;
+        transform: (callback: (input: import("@opencode-ai/plugin/effect/catalog").CatalogDraft) => void) => Effect.Effect<import("../state.js").Registration, never, import("effect/Scope").Scope>;
+    };
+    command: {
+        list: () => Effect.Effect<{
+            location: Location.Info;
+            data: import("@opencode-ai/schema/command").Info[];
+        }, never, never>;
+        reload: import("../state.js").Reload;
+        transform: (callback: (input: import("@opencode-ai/plugin/effect/command").CommandDraft) => void) => Effect.Effect<import("../state.js").Registration, never, import("effect/Scope").Scope>;
+    };
+    event: {
+        subscribe: () => Stream.Stream<EventManifest.ServerEvent, never, never>;
+    };
+    integration: {
+        list: () => Effect.Effect<{
+            location: Location.Info;
+            data: import("@opencode-ai/schema/integration").Info[];
+        }, never, never>;
+        get: (input: import("@opencode-ai/client/effect/api").Endpoint10_1Input) => Effect.Effect<{
+            location: Location.Info;
+            data: import("@opencode-ai/schema/integration").Info | undefined;
+        }, never, never>;
+        connect: {
+            key: (input: import("@opencode-ai/client/effect/api").Endpoint10_3Input) => Effect.Effect<void, Integration.AuthorizationError, never>;
+        };
+        oauth: {
+            connect: (input: import("@opencode-ai/client/effect/api").Endpoint10_4Input) => Effect.Effect<{
+                location: Location.Info;
+                data: import("@opencode-ai/schema/integration").Attempt;
+            }, Integration.AuthorizationError, never>;
+            status: (input: import("@opencode-ai/client/effect/api").Endpoint10_5Input) => Effect.Effect<{
+                location: Location.Info;
+                data: {
+                    readonly status: "pending";
+                    readonly time: {
+                        readonly created: number;
+                        readonly expires: number;
+                    };
+                } | {
+                    readonly status: "complete";
+                    readonly time: {
+                        readonly created: number;
+                        readonly expires: number;
+                    };
+                } | {
+                    readonly status: "failed";
+                    readonly message: string;
+                    readonly time: {
+                        readonly created: number;
+                        readonly expires: number;
+                    };
+                } | {
+                    readonly status: "expired";
+                    readonly time: {
+                        readonly created: number;
+                        readonly expires: number;
+                    };
+                };
+            }, never, never>;
+            complete: (input: import("@opencode-ai/client/effect/api").Endpoint10_6Input) => Effect.Effect<void, Integration.CodeRequiredError | Integration.AuthorizationError, never>;
+            cancel: (input: import("@opencode-ai/client/effect/api").Endpoint10_7Input) => Effect.Effect<void, never, never>;
+        };
+        command: {
+            connect: (input: import("@opencode-ai/client/effect/api").Endpoint10_8Input) => Effect.Effect<{
+                location: Location.Info;
+                data: import("@opencode-ai/schema/integration").CommandAttempt;
+            }, Integration.AuthorizationError, never>;
+            status: (input: import("@opencode-ai/client/effect/api").Endpoint10_9Input) => Effect.Effect<{
+                location: Location.Info;
+                data: {
+                    readonly status: "pending";
+                    readonly time: {
+                        readonly created: number;
+                        readonly expires: number;
+                    };
+                    readonly message?: string | undefined;
+                } | {
+                    readonly status: "complete";
+                    readonly time: {
+                        readonly created: number;
+                        readonly expires: number;
+                    };
+                } | {
+                    readonly status: "failed";
+                    readonly message: string;
+                    readonly time: {
+                        readonly created: number;
+                        readonly expires: number;
+                    };
+                } | {
+                    readonly status: "expired";
+                    readonly time: {
+                        readonly created: number;
+                        readonly expires: number;
+                    };
+                };
+            }, never, never>;
+            cancel: (input: import("@opencode-ai/client/effect/api").Endpoint10_10Input) => Effect.Effect<void, never, never>;
+        };
+        reload: import("../state.js").Reload;
+        connection: {
+            active: (id: string) => Effect.Effect<{
+                readonly type: "credential";
+                readonly id: string & import("effect/Brand").Brand<"Credential.ID">;
+                readonly label: string;
+            } | {
+                readonly type: "env";
+                readonly name: string;
+            } | undefined, never, never>;
+            resolve: (connection: import("@opencode-ai/client").ConnectionInfo) => Effect.Effect<{
+                readonly type: "oauth";
+                readonly methodID: string & import("effect/Brand").Brand<"Integration.MethodID">;
+                readonly refresh: string;
+                readonly access: string;
+                readonly expires: number;
+                readonly metadata?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+            } | {
+                readonly type: "key";
+                readonly key: string;
+                readonly metadata?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+                readonly configuration?: {
+                    readonly [x: string]: string | number | boolean | readonly string[];
+                } | undefined;
+            } | undefined, Integration.AuthorizationError, never>;
+        };
+        transform: (callback: (input: import("@opencode-ai/plugin/effect/integration").IntegrationDraft) => void) => Effect.Effect<import("../state.js").Registration, never, import("effect/Scope").Scope>;
+    };
+    plugin: {
+        list: () => Effect.Effect<{
+            location: Location.Info;
+            data: import("@opencode-ai/schema/plugin").Info[];
+        }, never, never>;
+    };
+    reference: {
+        list: () => Effect.Effect<{
+            location: Location.Info;
+            data: import("@opencode-ai/schema/reference").Info[];
+        }, never, never>;
+        reload: import("../state.js").Reload;
+        transform: (callback: (input: import("@opencode-ai/plugin/effect/reference").ReferenceDraft) => void) => Effect.Effect<import("../state.js").Registration, never, import("effect/Scope").Scope>;
+    };
+    skill: {
+        list: () => Effect.Effect<{
+            location: Location.Info;
+            data: import("@opencode-ai/schema/skill").Info[];
+        }, never, never>;
+        reload: import("../state.js").Reload;
+        transform: (callback: (input: import("@opencode-ai/plugin/effect/skill").SkillDraft) => void) => Effect.Effect<import("../state.js").Registration, never, import("effect/Scope").Scope>;
+    };
+    shell: {
+        hook: <Name extends "create.before">(name: Name, callback: (input: import("@opencode-ai/plugin/effect/shell").ShellHooks[Name]) => Effect.Effect<void, Record<"create.before", never>[Name], never>) => Effect.Effect<import("../state.js").Registration, never, import("effect/Scope").Scope>;
+    };
+    tool: {
+        transform: (callback: (input: import("@opencode-ai/plugin/effect/tool").ToolDraft) => void) => Effect.Effect<{
+            dispose: Effect.Effect<void, never, never>;
+        }, never, import("effect/Scope").Scope>;
+        hook: <Name extends keyof import("@opencode-ai/plugin/effect/tool").ToolHooks>(name: Name, callback: (input: import("@opencode-ai/plugin/effect/tool").ToolHooks[Name]) => Effect.Effect<void, import("@opencode-ai/plugin/effect/tool").ToolFailures[Name], never>) => Effect.Effect<import("../state.js").Registration, never, import("effect/Scope").Scope>;
+    };
+    websearch: {
+        providers: () => Effect.Effect<{
+            location: Location.Info;
+            data: readonly import("@opencode-ai/schema/websearch").Provider[];
+        }, never, never>;
+        query: (input: import("@opencode-ai/client/effect/api").Endpoint28_1Input) => Effect.Effect<{
+            location: Location.Info;
+            data: import("@opencode-ai/schema/websearch").Response;
+        }, WebSearch.Error, never>;
+        reload: import("../state.js").Reload;
+        transform: (callback: (input: import("@opencode-ai/plugin/effect/websearch").WebSearchDraft) => void) => Effect.Effect<import("../state.js").Registration, never, import("effect/Scope").Scope>;
+    };
+    session: {
+        hook: <Name extends keyof import("@opencode-ai/plugin/effect/session").SessionHooks>(name: Name, callback: (input: import("@opencode-ai/plugin/effect/session").SessionHooks[Name]) => Effect.Effect<void, Record<keyof import("@opencode-ai/plugin/effect/session").SessionHooks, never>[Name], never>) => Effect.Effect<import("../state.js").Registration, never, import("effect/Scope").Scope>;
+        create: (input: import("@opencode-ai/client/effect/api").Endpoint5_1Input | undefined) => Effect.Effect<import("@opencode-ai/schema/session").Info, import("../session.js").NotFoundError, never>;
+        get: (input: import("@opencode-ai/client/effect/api").Endpoint5_5Input) => Effect.Effect<import("@opencode-ai/schema/session").Info, import("../session.js").NotFoundError, never>;
+        prompt: (input: {
+            id?: import("@opencode-ai/schema/session-message").ID;
+            sessionID: import("../session.js").ID;
+            text: string;
+            files?: import("@opencode-ai/schema/prompt-input").Prompt["files"];
+            agents?: import("@opencode-ai/schema/prompt-input").Prompt["agents"];
+            skills?: import("@opencode-ai/schema/prompt-input").Prompt["skills"];
+            metadata?: Record<string, unknown>;
+            delivery?: import("@opencode-ai/schema/session-pending").Delivery;
+            resume?: boolean;
+        }) => Effect.Effect<import("@opencode-ai/schema/session-pending").User, import("../session.js").NotFoundError | import("../session.js").PromptConflictError | import("../session.js").AttachmentError | import("../session.js").SkillNotFoundError>;
+        generate: (input: import("@opencode-ai/client/effect/api").Endpoint5_30Input) => Effect.Effect<{
+            text: string;
+        }, import("../session.js").NotFoundError | import("../session/generate.js").Error, never>;
+        command: (input: {
+            id?: import("@opencode-ai/schema/session-message").ID;
+            sessionID: import("../session.js").ID;
+            command: string;
+            arguments?: string;
+            agent?: Agent.ID;
+            model?: Model.Ref;
+            files?: import("@opencode-ai/schema/prompt-input").Prompt["files"];
+            agents?: import("@opencode-ai/schema/prompt-input").Prompt["agents"];
+            skills?: import("@opencode-ai/schema/prompt-input").Prompt["skills"];
+            delivery?: import("@opencode-ai/schema/session-pending").Delivery;
+            resume?: boolean;
+        }) => Effect.Effect<import("@opencode-ai/schema/session-pending").User, import("../session.js").NotFoundError | import("../session.js").PromptConflictError | import("../session.js").AttachmentError | import("../session.js").SkillNotFoundError | Command.NotFoundError | Command.EvaluationError>;
+        rename: (input: {
+            sessionID: import("../session.js").ID;
+            title: string;
+        }) => Effect.Effect<void, import("../session.js").NotFoundError>;
+        synthetic: (input: {
+            id?: import("@opencode-ai/schema/session-message").ID;
+            sessionID: import("../session.js").ID;
+            text: string;
+            description?: string;
+            metadata?: Record<string, unknown>;
+            delivery?: import("@opencode-ai/schema/session-pending").Delivery;
+            resume?: boolean;
+        }) => Effect.Effect<import("@opencode-ai/schema/session-pending").Synthetic, import("../session.js").NotFoundError | import("../session.js").SyntheticConflictError>;
+        interrupt: (input: import("@opencode-ai/client/effect/api").Endpoint5_32Input) => Effect.Effect<void, never, never>;
+        wait: (input: import("@opencode-ai/client/effect/api").Endpoint5_18Input) => Effect.Effect<void, import("../session.js").NotFoundError, never>;
+    };
+}, never, Location.Service | Bus.Service | Agent.Service | AISDK.Service | Integration.Service | Catalog.Service | Command.Service | Reference.Service | WebSearch.Service | PluginRuntime.Service | Skill.Service | PluginHooks.Service | Tool.Service>;