@opencode/plugin 0.0.0-reserved → 2.0.1

package/dist/app.d.ts

@@ -0,0 +1,5 @@
+export interface App {
+    readonly name: string;
+    readonly version: string;
+    readonly channel: string;
+}

package/dist/effect/agent.d.ts

@@ -0,0 +1,15 @@
+import type { AgentApi } from "@opencode/client/effect/api";
+import type { Agent } from "@opencode/schema/agent";
+import type { Effect, Types } from "effect";
+import type { Transform } from "./registration.js";
+export interface AgentEditor {
+    list(): readonly Types.DeepMutable<Agent.Info>[];
+    get(id: string): Types.DeepMutable<Agent.Info> | undefined;
+    default(id: string | undefined): void;
+    update(id: string, update: (agent: Types.DeepMutable<Agent.Info>) => void): void;
+    remove(id: string): void;
+}
+export interface AgentDomain extends AgentApi<unknown> {
+    readonly transform: Transform<AgentEditor>;
+    readonly reload: () => Effect.Effect<void>;
+}

package/dist/effect/aisdk.d.ts

@@ -0,0 +1,20 @@
+import type { LanguageModelV3 } from "@ai-sdk/provider";
+import type { Model } from "@opencode/schema/model";
+import type { ModelHooks } from "./registration.js";
+export interface AISDKHooks {
+    sdk: {
+        readonly model: Model.Info;
+        readonly package: string;
+        readonly options: Record<string, any>;
+        sdk?: any;
+    };
+    language: {
+        readonly model: Model.Info;
+        readonly sdk: any;
+        readonly options: Record<string, any>;
+        language?: LanguageModelV3;
+    };
+}
+export interface AISDKDomain {
+    readonly hook: ModelHooks<AISDKHooks>;
+}

package/dist/effect/catalog.d.ts

@@ -0,0 +1,33 @@
+import type { CatalogApi } from "@opencode/client/effect/api";
+import { Model } from "@opencode/schema/model";
+import { Provider } from "@opencode/schema/provider";
+import type { Effect, Types } from "effect";
+import type { Transform } from "./registration.js";
+export interface CatalogProviderRecord {
+    readonly provider: Types.DeepMutable<Provider.Info>;
+    readonly models: ReadonlyMap<string, Types.DeepMutable<Model.Info>>;
+}
+export interface CatalogEditor {
+    readonly provider: {
+        list(): readonly CatalogProviderRecord[];
+        get(providerID: string): CatalogProviderRecord | undefined;
+        update(providerID: string, update: (provider: Types.DeepMutable<Provider.Info>) => void): void;
+        remove(providerID: string): void;
+    };
+    readonly model: {
+        get(providerID: string, modelID: string): Types.DeepMutable<Model.Info> | undefined;
+        update(providerID: string, modelID: string, update: (model: Types.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<unknown> {
+    readonly transform: Transform<CatalogEditor>;
+    readonly reload: () => Effect.Effect<void>;
+}

package/dist/effect/catalog.js

@@ -0,0 +1,2 @@
+import { Model } from "@opencode/schema/model";
+import { Provider } from "@opencode/schema/provider";

package/dist/effect/command.d.ts

@@ -0,0 +1,23 @@
+import type { CommandApi } from "@opencode/client/effect/api";
+import type { PromptInput } from "@opencode/schema/prompt-input";
+import type { Session } from "@opencode/schema/session";
+import type { SessionInbox } from "@opencode/schema/session-inbox";
+import type { Effect } from "effect";
+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) => Effect.Effect<void, unknown>;
+}
+export interface CommandEditor {
+    add(definition: CommandDefinition): void;
+}
+export interface CommandDomain extends Pick<CommandApi<unknown>, "list"> {
+    readonly transform: Transform<CommandEditor>;
+    readonly reload: () => Effect.Effect<void>;
+}

package/dist/effect/event.d.ts

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

package/dist/effect/index.d.ts

@@ -0,0 +1,18 @@
+export * as Plugin from "./plugin.js";
+export type { StorageEntry, StorageScanOptions, StorageScanResult } from "../storage.js";
+export { Agent } from "@opencode/schema/agent";
+export { Command } from "@opencode/schema/command";
+export { Connection } from "@opencode/schema/connection";
+export { Credential } from "@opencode/schema/credential";
+export { Integration } from "@opencode/schema/integration";
+export { Location } from "@opencode/schema/location";
+export { Mcp } from "@opencode/schema/mcp";
+export { Model } from "@opencode/schema/model";
+export { PersistentPty } from "@opencode/schema/persistent-pty";
+export { Provider } from "@opencode/schema/provider";
+export { Reference } from "@opencode/schema/reference";
+export { Rpc } from "@opencode/schema/rpc";
+export { Skill } from "@opencode/schema/skill";
+export { Vcs } from "@opencode/schema/vcs";
+export { WebSearch } from "@opencode/schema/websearch";
+export { Worktree } from "@opencode/schema/worktree";

package/dist/effect/index.js

@@ -0,0 +1,17 @@
+export * as Plugin from "./plugin.js";
+export { Agent } from "@opencode/schema/agent";
+export { Command } from "@opencode/schema/command";
+export { Connection } from "@opencode/schema/connection";
+export { Credential } from "@opencode/schema/credential";
+export { Integration } from "@opencode/schema/integration";
+export { Location } from "@opencode/schema/location";
+export { Mcp } from "@opencode/schema/mcp";
+export { Model } from "@opencode/schema/model";
+export { PersistentPty } from "@opencode/schema/persistent-pty";
+export { Provider } from "@opencode/schema/provider";
+export { Reference } from "@opencode/schema/reference";
+export { Rpc } from "@opencode/schema/rpc";
+export { Skill } from "@opencode/schema/skill";
+export { Vcs } from "@opencode/schema/vcs";
+export { WebSearch } from "@opencode/schema/websearch";
+export { Worktree } from "@opencode/schema/worktree";

package/dist/effect/integration.d.ts

@@ -0,0 +1,80 @@
+import type { ConnectionInfo } from "@opencode/client";
+import type { IntegrationApi } from "@opencode/client/effect/api";
+import { Credential } from "@opencode/schema/credential";
+import { Form } from "@opencode/schema/form";
+import type { Effect, Scope } from "effect";
+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: Effect.Effect<Credential.OAuth, unknown>;
+} | {
+    readonly mode: "code";
+    readonly callback: (code: string) => Effect.Effect<Credential.OAuth, unknown>;
+});
+export type IntegrationOAuthMethodRegistration = {
+    readonly integrationID: string;
+    readonly method: IntegrationOAuthMethod;
+    readonly authorize: (answer: Form.Answer) => Effect.Effect<IntegrationOAuthAuthorization, unknown, Scope.Scope>;
+    readonly refresh?: (credential: Credential.OAuth) => Effect.Effect<Credential.OAuth, unknown>;
+    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<unknown>, "wellknown"> {
+    readonly transform: Transform<IntegrationEditor>;
+    readonly reload: () => Effect.Effect<void>;
+    readonly connection: {
+        readonly active: (integrationID: string) => Effect.Effect<ConnectionInfo | undefined>;
+        readonly resolve: (connection: ConnectionInfo) => Effect.Effect<Credential.Value | undefined, unknown>;
+    };
+}
+export {};

package/dist/effect/integration.js

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

package/dist/effect/mcp.d.ts

@@ -0,0 +1,15 @@
+import type { McpApi } from "@opencode/client/effect/api";
+import type { Mcp } from "@opencode/schema/mcp";
+import type { Effect, Types } from "effect";
+import type { Transform } from "./registration.js";
+export interface MCPEditor {
+    list(): readonly [string, Types.DeepMutable<Mcp.ServerConfig>][];
+    get(name: string): Types.DeepMutable<Mcp.ServerConfig> | undefined;
+    set(name: string, config: Mcp.ServerConfig): void;
+    update(name: string, update: (config: Types.DeepMutable<Mcp.ServerConfig>) => void): void;
+    remove(name: string): void;
+}
+export interface MCPDomain extends Pick<McpApi<unknown>, "list"> {
+    readonly transform: Transform<MCPEditor>;
+    readonly reload: () => Effect.Effect<void>;
+}

package/dist/effect/permission.d.ts

@@ -0,0 +1,21 @@
+import type { PermissionApi } from "@opencode/client/effect/api";
+import type { Agent } from "@opencode/schema/agent";
+import type { Permission } from "@opencode/schema/permission";
+import type { Session } from "@opencode/schema/session";
+import type { Hooks } from "./registration.js";
+export interface PermissionEvaluation {
+    readonly sessionID: Session.ID;
+    readonly agent?: Agent.ID;
+    readonly action: string;
+    readonly resources: ReadonlyArray<string>;
+    readonly metadata?: Record<string, unknown>;
+    readonly source?: Permission.Source;
+    effect: Permission.Effect;
+    message?: string;
+}
+export interface PermissionHooks {
+    readonly evaluate: PermissionEvaluation;
+}
+export type PermissionDomain = Pick<PermissionApi<unknown>, "list" | "get" | "reply" | "rules"> & {
+    readonly hook: Hooks<PermissionHooks>;
+};

package/dist/effect/plugin.d.ts

@@ -0,0 +1,56 @@
+import type { ExperimentalApi, GenerateApi, PluginApi } from "@opencode/client/effect/api";
+import type { Location } from "@opencode/schema/location";
+import type { Effect, Scope } from "effect";
+import type { PluginOptions } from "../options.js";
+import type { App } from "../app.js";
+import type { AgentDomain } from "./agent.js";
+import type { AISDKDomain } from "./aisdk.js";
+import type { CatalogDomain } from "./catalog.js";
+import type { CommandDomain } from "./command.js";
+import type { EventDomain } from "./event.js";
+import type { IntegrationDomain } from "./integration.js";
+import type { MCPDomain } from "./mcp.js";
+import type { PermissionDomain } from "./permission.js";
+import type { ReferenceDomain } from "./reference.js";
+import type { RpcDomain } from "./rpc.js";
+import type { SessionDomain } from "./session.js";
+import type { ShellDomain } from "./shell.js";
+import type { SkillDomain } from "./skill.js";
+import type { StorageDomain } from "./storage.js";
+import type { ToolDomain } from "./tool.js";
+import type { VcsDomain } from "./vcs.js";
+import type { WebSearchDomain } from "./websearch.js";
+import type { WorktreeDomain } from "./worktree.js";
+export interface Context {
+    readonly app: App;
+    readonly location: Location.Info;
+    readonly options: PluginOptions;
+    readonly agent: AgentDomain;
+    readonly aisdk: AISDKDomain;
+    readonly catalog: CatalogDomain;
+    readonly command: CommandDomain;
+    readonly event: EventDomain;
+    readonly experimental: {
+        readonly terminal: Pick<ExperimentalApi<unknown>["persistentPty"], "read">;
+    };
+    readonly integration: IntegrationDomain;
+    readonly mcp: MCPDomain;
+    readonly generate: GenerateApi<unknown>;
+    readonly permission: PermissionDomain;
+    readonly plugin: Pick<PluginApi<unknown>, "list">;
+    readonly reference: ReferenceDomain;
+    readonly rpc: RpcDomain;
+    readonly session: SessionDomain;
+    readonly shell: ShellDomain;
+    readonly skill: SkillDomain;
+    readonly storage: StorageDomain;
+    readonly tool: ToolDomain;
+    readonly vcs: VcsDomain;
+    readonly websearch: WebSearchDomain;
+    readonly worktree: WorktreeDomain;
+}
+export interface Plugin<R = Scope.Scope> {
+    readonly id: string;
+    readonly effect: (context: Context) => Effect.Effect<void, never, R>;
+}
+export declare function define<R = Scope.Scope>(plugin: Plugin<R>): Plugin<R>;

package/dist/effect/plugin.js

@@ -0,0 +1,3 @@
+export function define(plugin) {
+    return plugin;
+}

package/dist/effect/reference.d.ts

@@ -0,0 +1,14 @@
+import type { ReferenceGitSource, ReferenceLocalSource } from "@opencode/client";
+import type { ReferenceApi } from "@opencode/client/effect/api";
+import type { Effect } from "effect";
+import type { Transform } from "./registration.js";
+export interface ReferenceEditor {
+    add(name: string, source: ReferenceLocalSource | ReferenceGitSource): void;
+    remove(name: string): void;
+    list(): readonly (readonly [string, ReferenceLocalSource | ReferenceGitSource])[];
+    get(name: string): ReferenceLocalSource | ReferenceGitSource | undefined;
+}
+export interface ReferenceDomain extends ReferenceApi<unknown> {
+    readonly transform: Transform<ReferenceEditor>;
+    readonly reload: () => Effect.Effect<void>;
+}

package/dist/effect/registration.d.ts

@@ -0,0 +1,13 @@
+import type { Effect, Scope } from "effect";
+export interface Registration {
+    readonly dispose: Effect.Effect<void>;
+}
+export interface ModelHookOptions {
+    /** Limits the hook to one provider. Unscoped hooks apply to every provider. */
+    readonly providerID?: string;
+}
+export type Hooks<Spec, Failures extends Record<keyof Spec, unknown> = Record<keyof Spec, never>> = <Name extends keyof Spec>(name: Name, callback: (input: Spec[Name]) => Effect.Effect<void, Failures[Name]>) => Effect.Effect<Registration, never, Scope.Scope>;
+export type ModelHooks<Spec, Failures extends Record<keyof Spec, unknown> = Record<keyof Spec, never>> = <Name extends keyof Spec>(name: Name, callback: (input: Spec[Name]) => Effect.Effect<void, Failures[Name]>, options?: Spec[Name] extends {
+    readonly model: unknown;
+} ? ModelHookOptions : never) => Effect.Effect<Registration, never, Scope.Scope>;
+export type Transform<Input> = (callback: (input: Input) => void) => Effect.Effect<Registration, never, Scope.Scope>;

package/dist/effect/rpc.d.ts

@@ -0,0 +1,19 @@
+import type { RpcApi } from "@opencode/client/effect/api";
+export type { RpcClient } from "@opencode/client/effect/api";
+import type { Rpc } from "@opencode/schema/rpc";
+import type { Effect, Scope } from "effect";
+import type { Registration } from "./registration.js";
+export interface RpcCallContext<M extends Rpc.Method> {
+    readonly error: Rpc.ErrorFactory<M>;
+}
+export type RpcHandlers<D extends Rpc.Definition> = {
+    readonly [Name in keyof D["methods"]]: (input: Rpc.Output<D["methods"][Name]["input"]>, context: RpcCallContext<D["methods"][Name]>) => Effect.Effect<Rpc.HandlerOutput<D["methods"][Name]["output"]>, Rpc.HandlerError<D["methods"][Name]>>;
+};
+export interface RpcRegistration<D extends Rpc.Definition> extends Registration {
+    readonly events: {
+        readonly emit: (...args: Rpc.EventInput<D>) => Effect.Effect<void, unknown>;
+    };
+}
+export interface RpcDomain extends RpcApi<Rpc.SystemError, never, unknown> {
+    readonly register: <const D extends Rpc.Definition>(definition: D, handlers: RpcHandlers<NoInfer<D>>) => Effect.Effect<RpcRegistration<D>, unknown, Scope.Scope>;
+}

package/dist/effect/session.d.ts

@@ -0,0 +1,107 @@
+import type { SessionApi } from "@opencode/client/effect/api";
+import type { GenerationOptionsFields, Message, SystemPart } from "@opencode/ai";
+import type { Agent } from "@opencode/schema/agent";
+import type { Model } from "@opencode/schema/model";
+import type { PromptInput } from "@opencode/schema/prompt-input";
+import type { Session } from "@opencode/schema/session";
+import type { SessionInbox } from "@opencode/schema/session-inbox";
+import type { SessionError } from "@opencode/schema/session-error";
+import type { SessionMessage } from "@opencode/schema/session-message";
+import type { TokenUsage } from "@opencode/schema/token-usage";
+import type { JsonSchema, Types } from "effect";
+import type { ModelHooks } from "./registration.js";
+export interface SessionPrompt {
+    readonly sessionID: Session.ID;
+    readonly messageID: SessionMessage.ID;
+    prompt: Types.DeepMutable<PromptInput.Prompt>;
+    metadata?: Record<string, unknown>;
+    delivery: SessionInbox.Delivery;
+}
+/** Request overrides. Typed keys are generation settings; any other key is a provider option. */
+export type SessionRequestOptions = Types.DeepMutable<GenerationOptionsFields> & Record<string, unknown>;
+export interface SessionRequest {
+    readonly sessionID: Session.ID;
+    readonly model: Model.Ref;
+    system: Array<SystemPart>;
+    messages: Array<Message>;
+    options: SessionRequestOptions;
+}
+export interface SessionContext extends SessionRequest {
+    readonly agent: Agent.ID;
+    tools: Record<string, {
+        description: string;
+        input: JsonSchema.JsonSchema;
+    }>;
+}
+export interface SessionCompactionResult {
+    summary: string;
+    providerState?: SessionMessage.ProviderState;
+    metadata?: Record<string, unknown>;
+    tokens?: TokenUsage.Info;
+}
+export interface SessionCompaction extends SessionContext {
+    /** Set to use this compaction and skip the model request. */
+    result?: SessionCompactionResult;
+}
+export interface SessionGenerate extends SessionContext {
+}
+export interface SessionTitle extends SessionRequest {
+    /** Set to use this title and skip the model request. */
+    result?: string;
+}
+/**
+ * Why a Session request is being made. Auxiliary requests share the Session's
+ * hook identity but need to be told apart from the agent loop.
+ */
+export type SessionRequestKind = "primary" | "compaction" | "title" | "generate";
+export interface SessionModelRequest {
+    readonly sessionID: Session.ID;
+    readonly agent: Agent.ID;
+    readonly model: Model.Ref;
+    readonly kind: SessionRequestKind;
+    baseURL?: string;
+    headers: Record<string, string>;
+}
+export interface SessionHttpRequest {
+    readonly sessionID: Session.ID;
+    readonly agent: Agent.ID;
+    readonly model: Model.Ref;
+    readonly kind: SessionRequestKind;
+    request: Request;
+}
+export interface SessionHttpResponse {
+    readonly sessionID: Session.ID;
+    readonly agent: Agent.ID;
+    readonly model: Model.Ref;
+    readonly kind: SessionRequestKind;
+    readonly request: Request;
+    response: Response;
+}
+export type SessionRetryDecision = {
+    retry: false;
+} | {
+    retry: true;
+    delay: number;
+};
+export interface SessionRetry {
+    readonly sessionID: Session.ID;
+    readonly agent: Agent.ID;
+    readonly model: Model.Ref;
+    readonly error: SessionError.Error;
+    readonly attempt: number;
+    decision: SessionRetryDecision;
+}
+export interface SessionHooks {
+    readonly prompt: SessionPrompt;
+    readonly context: SessionContext;
+    readonly compaction: SessionCompaction;
+    readonly generate: SessionGenerate;
+    readonly title: SessionTitle;
+    readonly "model.request": SessionModelRequest;
+    readonly "http.request": SessionHttpRequest;
+    readonly "http.response": SessionHttpResponse;
+    readonly retry: SessionRetry;
+}
+export type SessionDomain = Pick<SessionApi<unknown>, "create" | "get" | "switchAgent" | "switchModel" | "prompt" | "generate" | "command" | "synthetic" | "interrupt" | "rename" | "move" | "wait" | "context"> & {
+    readonly hook: ModelHooks<SessionHooks>;
+};

package/dist/effect/shell.d.ts

@@ -0,0 +1,14 @@
+import type { Hooks } from "./registration.js";
+export interface ShellCreateBefore {
+    command: string;
+    cwd: string;
+    timeout: number;
+    shell: string;
+    env: Record<string, string | undefined>;
+}
+export interface ShellHooks {
+    readonly "create.before": ShellCreateBefore;
+}
+export interface ShellDomain {
+    readonly hook: Hooks<ShellHooks>;
+}

package/dist/effect/skill.d.ts

@@ -0,0 +1,15 @@
+import type { SkillApi } from "@opencode/client/effect/api";
+import { Skill } from "@opencode/schema/skill";
+import type { Effect, Types } from "effect";
+import type { Transform } from "./registration.js";
+export interface SkillEditor {
+    list(): readonly Types.DeepMutable<Skill.Info>[];
+    get(id: string): Types.DeepMutable<Skill.Info> | undefined;
+    add(skill: Skill.Info): void;
+    update(id: string, update: (skill: Types.DeepMutable<Skill.Info>) => void): void;
+    remove(id: string): void;
+}
+export interface SkillDomain extends SkillApi<unknown> {
+    readonly transform: Transform<SkillEditor>;
+    readonly reload: () => Effect.Effect<void>;
+}

package/dist/effect/skill.js

@@ -0,0 +1 @@
+import { Skill } from "@opencode/schema/skill";

package/dist/effect/storage.d.ts

@@ -0,0 +1,8 @@
+import type { Effect, Schema } from "effect";
+import type { StorageScanOptions, StorageScanResult } from "../storage.js";
+export interface StorageDomain {
+    readonly get: (key: string) => Effect.Effect<Schema.Json | undefined>;
+    readonly set: (key: string, value: Schema.Json) => Effect.Effect<void>;
+    readonly remove: (key: string) => Effect.Effect<void>;
+    readonly scan: (options: StorageScanOptions) => Effect.Effect<StorageScanResult>;
+}

package/dist/effect/tool.d.ts

@@ -0,0 +1,52 @@
+import { Tool } from "@opencode/schema/tool";
+import type { Agent } from "@opencode/schema/agent";
+import type { Session } from "@opencode/schema/session";
+import type { SessionMessage } from "@opencode/schema/session-message";
+import type { Effect, Types } from "effect";
+import type { Hooks, Transform } from "./registration.js";
+export interface ToolEditor {
+    list(): readonly (Tool.Info & {
+        readonly id: string;
+    })[];
+    get(id: string): (Tool.Info & {
+        readonly id: string;
+    }) | undefined;
+    namespace(namespace: Tool.Namespace): void;
+    add<Input extends Tool.ValueSchema<any>, Output extends Tool.ValueSchema<any> | undefined>(tool: Tool.Info<Input, Output>): void;
+    /** Updates an existing tool; missing IDs are ignored. */
+    update(id: string, update: (tool: Types.Mutable<Tool.Info>) => void): void;
+    remove(id: string): void;
+}
+export interface ToolHooks {
+    readonly "execute.before": {
+        tool: string;
+        readonly sessionID: Session.ID;
+        readonly agent: Agent.ID;
+        readonly messageID: SessionMessage.ID;
+        readonly id: Tool.CallID;
+        input: unknown;
+    };
+    readonly "execute.after": {
+        readonly tool: string;
+        readonly sessionID: Session.ID;
+        readonly agent: Agent.ID;
+        readonly messageID: SessionMessage.ID;
+        readonly id: Tool.CallID;
+        readonly input: unknown;
+    } & ({
+        readonly status: "completed";
+        result: Tool.Result;
+    } | {
+        readonly status: "error";
+        error: Tool.Error;
+    });
+}
+export interface ToolFailures extends Record<keyof ToolHooks, unknown> {
+    readonly "execute.before": Tool.Error;
+    readonly "execute.after": never;
+}
+export interface ToolDomain {
+    readonly transform: Transform<ToolEditor>;
+    readonly reload: () => Effect.Effect<void>;
+    readonly hook: Hooks<ToolHooks, ToolFailures>;
+}

package/dist/effect/tool.js

@@ -0,0 +1 @@
+import { Tool } from "@opencode/schema/tool";