@opencode-ai/core 0.0.0-beta-17498

package/dist/types/model.d.ts

@@ -0,0 +1,177 @@
+import { Model } from "@opencode-ai/schema/model";
+import { Provider } from "./provider.js";
+import type { DeepMutable } from "./schema.js";
+export declare const ID: import("effect/Schema").brand<import("effect/Schema").String, "Model.ID">;
+export type ID = typeof ID.Type;
+export declare const VariantID: import("effect/Schema").brand<import("effect/Schema").String, "Model.VariantID">;
+export type VariantID = typeof VariantID.Type;
+export declare const Family: import("effect/Schema").brand<import("effect/Schema").String, "Model.Family">;
+export type Family = Model.Family;
+export declare const ReasoningField: import("effect/Schema").Codec<Model.ReasoningField, Model.ReasoningField, never, never>;
+export type ReasoningField = Model.ReasoningField;
+export declare const Compatibility: import("effect/Schema").Struct<{
+    readonly reasoningField: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Codec<Model.ReasoningField, Model.ReasoningField, never, never>>>, import("effect/Schema").optionalKey<import("effect/Schema").Codec<Model.ReasoningField, Model.ReasoningField, never, never>>, never, never>;
+    readonly maxTokensField: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Literals<readonly ["max_completion_tokens", "max_tokens"]>>>, import("effect/Schema").optionalKey<import("effect/Schema").Literals<readonly ["max_completion_tokens", "max_tokens"]>>, never, never>;
+    readonly requireFinishReason: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Boolean>>, import("effect/Schema").optionalKey<import("effect/Schema").Boolean>, never, never>;
+}>;
+export type Compatibility = Model.Compatibility;
+export declare const Capabilities: import("effect/Schema").Struct<{
+    readonly tools: import("effect/Schema").Boolean;
+    readonly input: import("effect/Schema").$Array<import("effect/Schema").String>;
+    readonly output: import("effect/Schema").$Array<import("effect/Schema").String>;
+}>;
+export type Capabilities = Model.Capabilities;
+export declare const Cost: import("effect/Schema").Struct<{
+    readonly tier: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
+        readonly type: import("effect/Schema").tag<"context">;
+        readonly size: import("effect/Schema").Int;
+    }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+        readonly type: import("effect/Schema").tag<"context">;
+        readonly size: import("effect/Schema").Int;
+    }>>, never, never>;
+    readonly input: import("effect/Schema").brand<import("effect/Schema").Finite, "Money.USDPerMillionTokens"> & {
+        zero: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
+    };
+    readonly output: import("effect/Schema").brand<import("effect/Schema").Finite, "Money.USDPerMillionTokens"> & {
+        zero: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
+    };
+    readonly cache: import("effect/Schema").Struct<{
+        readonly read: import("effect/Schema").brand<import("effect/Schema").Finite, "Money.USDPerMillionTokens"> & {
+            zero: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
+        };
+        readonly write: import("effect/Schema").brand<import("effect/Schema").Finite, "Money.USDPerMillionTokens"> & {
+            zero: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
+        };
+    }>;
+}>;
+export declare const Ref: import("effect/Schema").Struct<{
+    readonly id: import("effect/Schema").brand<import("effect/Schema").String, "Model.ID">;
+    readonly providerID: import("effect/Schema").brand<import("effect/Schema").String, "Provider.ID"> & {
+        opencode: string & import("effect/Brand").Brand<"Provider.ID">;
+        anthropic: string & import("effect/Brand").Brand<"Provider.ID">;
+        openai: string & import("effect/Brand").Brand<"Provider.ID">;
+        google: string & import("effect/Brand").Brand<"Provider.ID">;
+        googleVertex: string & import("effect/Brand").Brand<"Provider.ID">;
+        githubCopilot: string & import("effect/Brand").Brand<"Provider.ID">;
+        amazonBedrock: string & import("effect/Brand").Brand<"Provider.ID">;
+        azure: string & import("effect/Brand").Brand<"Provider.ID">;
+        openrouter: string & import("effect/Brand").Brand<"Provider.ID">;
+        mistral: string & import("effect/Brand").Brand<"Provider.ID">;
+        gitlab: string & import("effect/Brand").Brand<"Provider.ID">;
+    };
+    readonly variant: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "Model.VariantID">>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "Model.VariantID">>, never, never>;
+}> & {
+    parse: (input: string) => {
+        readonly id: string & import("effect/Brand").Brand<"Model.ID">;
+        readonly providerID: string & import("effect/Brand").Brand<"Provider.ID">;
+        readonly variant?: (string & import("effect/Brand").Brand<"Model.VariantID">) | undefined;
+    };
+};
+export type Ref = typeof Ref.Type;
+export declare const Info: import("effect/Schema").Struct<{
+    readonly capabilities: import("effect/Schema").Struct<{
+        readonly tools: import("effect/Schema").Boolean;
+        readonly input: import("effect/Schema").$Array<import("effect/Schema").String>;
+        readonly output: import("effect/Schema").$Array<import("effect/Schema").String>;
+    }>;
+    readonly variants: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+        readonly settings: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Any>>>, import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Any>>, never, never>;
+        readonly headers: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").String>>>, import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").String>>, never, never>;
+        readonly body: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Any>>>, import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Any>>, never, never>;
+        readonly id: import("effect/Schema").brand<import("effect/Schema").String, "Model.VariantID">;
+    }>>;
+    readonly time: import("effect/Schema").Struct<{
+        readonly released: import("effect/Schema").Finite;
+    }>;
+    readonly cost: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+        readonly tier: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").tag<"context">;
+            readonly size: import("effect/Schema").Int;
+        }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").tag<"context">;
+            readonly size: import("effect/Schema").Int;
+        }>>, never, never>;
+        readonly input: import("effect/Schema").brand<import("effect/Schema").Finite, "Money.USDPerMillionTokens"> & {
+            zero: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
+        };
+        readonly output: import("effect/Schema").brand<import("effect/Schema").Finite, "Money.USDPerMillionTokens"> & {
+            zero: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
+        };
+        readonly cache: import("effect/Schema").Struct<{
+            readonly read: import("effect/Schema").brand<import("effect/Schema").Finite, "Money.USDPerMillionTokens"> & {
+                zero: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
+            };
+            readonly write: import("effect/Schema").brand<import("effect/Schema").Finite, "Money.USDPerMillionTokens"> & {
+                zero: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
+            };
+        }>;
+    }>>;
+    readonly status: import("effect/Schema").Literals<readonly ["alpha", "beta", "deprecated", "active"]>;
+    readonly enabled: import("effect/Schema").Boolean;
+    readonly limit: import("effect/Schema").Struct<{
+        readonly context: import("effect/Schema").Int;
+        readonly input: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Int>>, import("effect/Schema").optionalKey<import("effect/Schema").Int>, never, never>;
+        readonly output: import("effect/Schema").Int;
+    }>;
+    readonly settings: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Any>>>, import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Any>>, never, never>;
+    readonly headers: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").String>>>, import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").String>>, never, never>;
+    readonly body: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Any>>>, import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Any>>, never, never>;
+    readonly id: import("effect/Schema").brand<import("effect/Schema").String, "Model.ID">;
+    readonly modelID: import("effect/Schema").brand<import("effect/Schema").String, "Model.ID">;
+    readonly providerID: import("effect/Schema").brand<import("effect/Schema").String, "Provider.ID"> & {
+        opencode: string & import("effect/Brand").Brand<"Provider.ID">;
+        anthropic: string & import("effect/Brand").Brand<"Provider.ID">;
+        openai: string & import("effect/Brand").Brand<"Provider.ID">;
+        google: string & import("effect/Brand").Brand<"Provider.ID">;
+        googleVertex: string & import("effect/Brand").Brand<"Provider.ID">;
+        githubCopilot: string & import("effect/Brand").Brand<"Provider.ID">;
+        amazonBedrock: string & import("effect/Brand").Brand<"Provider.ID">;
+        azure: string & import("effect/Brand").Brand<"Provider.ID">;
+        openrouter: string & import("effect/Brand").Brand<"Provider.ID">;
+        mistral: string & import("effect/Brand").Brand<"Provider.ID">;
+        gitlab: string & import("effect/Brand").Brand<"Provider.ID">;
+    };
+    readonly family: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "Model.Family">>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "Model.Family">>, never, never>;
+    readonly name: import("effect/Schema").String;
+    readonly compatibility: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
+        readonly reasoningField: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Codec<Model.ReasoningField, Model.ReasoningField, never, never>>>, import("effect/Schema").optionalKey<import("effect/Schema").Codec<Model.ReasoningField, Model.ReasoningField, never, never>>, never, never>;
+        readonly maxTokensField: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Literals<readonly ["max_completion_tokens", "max_tokens"]>>>, import("effect/Schema").optionalKey<import("effect/Schema").Literals<readonly ["max_completion_tokens", "max_tokens"]>>, never, never>;
+        readonly requireFinishReason: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Boolean>>, import("effect/Schema").optionalKey<import("effect/Schema").Boolean>, never, never>;
+    }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+        readonly reasoningField: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Codec<Model.ReasoningField, Model.ReasoningField, never, never>>>, import("effect/Schema").optionalKey<import("effect/Schema").Codec<Model.ReasoningField, Model.ReasoningField, never, never>>, never, never>;
+        readonly maxTokensField: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Literals<readonly ["max_completion_tokens", "max_tokens"]>>>, import("effect/Schema").optionalKey<import("effect/Schema").Literals<readonly ["max_completion_tokens", "max_tokens"]>>, never, never>;
+        readonly requireFinishReason: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Boolean>>, import("effect/Schema").optionalKey<import("effect/Schema").Boolean>, never, never>;
+    }>>, never, never>;
+    readonly package: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").String>>, import("effect/Schema").optionalKey<import("effect/Schema").String>, never, never>;
+}> & {
+    default: (providerID: import("@opencode-ai/schema/provider").ID, id: Model.ID) => {
+        id: string & import("effect/Brand").Brand<"Model.ID">;
+        modelID: string & import("effect/Brand").Brand<"Model.ID">;
+        providerID: string & import("effect/Brand").Brand<"Provider.ID">;
+        name: string & import("effect/Brand").Brand<"Model.ID">;
+        capabilities: {
+            tools: true;
+            input: string[];
+            output: string[];
+        };
+        variants: never[];
+        time: {
+            released: number;
+        };
+        cost: never[];
+        status: "active";
+        enabled: true;
+        limit: {
+            context: number;
+            output: number;
+        };
+    };
+};
+export type Info = Model.Info;
+export type MutableInfo = DeepMutable<Info>;
+export declare function compatibility(input: unknown): Compatibility | undefined;
+export declare function parse(input: string): {
+    providerID: Provider.ID;
+    modelID: ID;
+};
+export * as Model from "./model.js";

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,131 @@
+export * as Permission from "./permission.js";
+import { Context, Effect, Schema } from "effect";
+import { Permission } from "@opencode-ai/schema/permission";
+import { Agent } from "./agent.js";
+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 allowsAll: (input: {
+        readonly sessionID: SessionSchema.ID;
+        readonly action: string;
+        readonly agent?: Agent.ID;
+    }) => Effect.Effect<boolean, SessionErrors.NotFoundError>;
+    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,32 @@
+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 has: <Domain extends keyof Domains>(domain: Domain, name: keyof Domains[Domain] & keyof Failures[Domain]) => Effect.Effect<boolean>;
+    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">>;