@opencode-ai/plugin 0.0.0-next-202606301613 → 0.0.0-next-15259

package/dist/example.d.ts

@@ -1,2 +1,2 @@
-import { Plugin } from "./index.js";
+import type { Plugin } from "./index.js";
 export declare const ExamplePlugin: Plugin;

package/dist/index.js

@@ -1 +1,2 @@
+import {} from "./tool.js";
 export * from "./tool.js";

package/dist/shell.js

@@ -1 +0,0 @@
-export {};

package/dist/tui.d.ts

@@ -1,4 +1,7 @@
-import type { AgentPart, OpencodeClient, V2Event, FilePart, LspStatus, McpStatus, Todo, Message, Part, Provider, PermissionRequest, QuestionRequest, Session, SessionStatus, TextPart, Config as SdkConfig } from "@opencode-ai/sdk/v2";
+import type { OpencodeClient, LspStatus, McpStatus, Message, Part, Provider, PermissionRequest, QuestionRequest, Session, SessionStatus, Config as SdkConfig } from "@opencode-ai/sdk/v2";
+import type { OpenCodeEvent } from "@opencode-ai/client/promise";
+import type { PromptInput } from "@opencode-ai/schema";
+import type { Types } from "effect";
 import type { CliRenderer, KeyEvent, RGBA, Renderable, SlotMode } from "@opentui/core";
 import type { Binding, Keymap } from "@opentui/keymap";
 import { type BindingConfig, type CreateBindingLookupOptions, type KeySequenceFormatPart, type SequenceBindingLike } from "@opentui/keymap/extras";
@@ -125,18 +128,16 @@ export type TuiDialogSelectProps<Value = unknown> = {
     skipFilter?: boolean;
     current?: Value;
 };
-export type TuiPromptInfo = {
-    input: string;
-    mode?: "normal" | "shell";
-    parts: (Omit<FilePart, "id" | "messageID" | "sessionID"> | Omit<AgentPart, "id" | "messageID" | "sessionID"> | (Omit<TextPart, "id" | "messageID" | "sessionID"> & {
-        source?: {
-            text: {
-                start: number;
-                end: number;
-                value: string;
-            };
+export type TuiPromptInfo = Types.DeepMutable<PromptInput.Prompt> & {
+    pasted: {
+        text: string;
+        source: {
+            start: number;
+            end: number;
+            text: string;
         };
-    }))[];
+    }[];
+    mode?: "normal" | "shell";
 };
 export type TuiPromptRef = {
     focused: boolean;
@@ -302,7 +303,6 @@ export type TuiState = {
         count: () => number;
         get: (sessionID: string) => Session | undefined;
         diff: (sessionID: string) => ReadonlyArray<TuiSidebarFileItem>;
-        todo: (sessionID: string) => ReadonlyArray<TuiSidebarTodoItem>;
         messages: (sessionID: string) => ReadonlyArray<Message>;
         status: (sessionID: string) => SessionStatus | undefined;
         permission: (sessionID: string) => ReadonlyArray<PermissionRequest>;
@@ -346,7 +346,6 @@ export type TuiSidebarMcpItem = {
     error?: string;
 };
 export type TuiSidebarLspItem = Pick<LspStatus, "id" | "root" | "status">;
-export type TuiSidebarTodoItem = Pick<Todo, "content" | "status">;
 export type TuiSidebarFileItem = {
     file: string;
     additions: number;
@@ -382,6 +381,7 @@ export type TuiHostSlotMap = {
     };
     sidebar_footer: {
         session_id: string;
+        directory: string;
     };
 };
 export type TuiSlotMap<Slots extends Record<string, object> = {}> = TuiHostSlotMap & Slots;
@@ -405,7 +405,7 @@ export type TuiSlots = {
     };
 };
 export type TuiEventBus = {
-    on: <Type extends V2Event["type"]>(type: Type, handler: (event: Extract<V2Event, {
+    on: <Type extends OpenCodeEvent["type"]>(type: Type, handler: (event: Extract<OpenCodeEvent, {
         type: Type;
     }>) => void) => () => void;
 };

package/dist/v2/effect/agent.d.ts

@@ -1,12 +1,15 @@
-import type { AgentV2Info } from "@opencode-ai/sdk/v2/types";
-import type { Hooks } from "./registration.js";
+import type { AgentApi } from "@opencode-ai/client/effect/api";
+import type { AgentInfo } from "@opencode-ai/sdk/v2/types";
+import type { Effect } from "effect";
+import type { Transform } from "./registration.js";
 export interface AgentDraft {
-    list(): readonly AgentV2Info[];
-    get(id: string): AgentV2Info | undefined;
+    list(): readonly AgentInfo[];
+    get(id: string): AgentInfo | undefined;
     default(id: string | undefined): void;
-    update(id: string, update: (agent: AgentV2Info) => void): void;
+    update(id: string, update: (agent: AgentInfo) => void): void;
     remove(id: string): void;
 }
-export type AgentHooks = Hooks<{
-    transform: AgentDraft;
-}>;
+export interface AgentDomain extends AgentApi<unknown> {
+    readonly transform: Transform<AgentDraft>;
+    readonly reload: () => Effect.Effect<void>;
+}

package/dist/v2/effect/agent.js

@@ -1 +0,0 @@
-export {};

package/dist/v2/effect/aisdk.d.ts

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

package/dist/v2/effect/aisdk.js

@@ -1 +0,0 @@
-export {};

package/dist/v2/effect/catalog.d.ts

@@ -1,8 +1,10 @@
-import type { ModelV2Info, ProviderV2Info } from "@opencode-ai/sdk/v2/types";
-import type { Hooks } from "./registration.js";
+import type { ModelInfo, ProviderV2Info } from "@opencode-ai/sdk/v2/types";
+import type { CatalogApi } from "@opencode-ai/client/effect/api";
+import type { Effect } from "effect";
+import type { Transform } from "./registration.js";
 export interface CatalogProviderRecord {
     readonly provider: ProviderV2Info;
-    readonly models: ReadonlyMap<string, ModelV2Info>;
+    readonly models: ReadonlyMap<string, ModelInfo>;
 }
 export interface CatalogDraft {
     readonly provider: {
@@ -12,8 +14,8 @@ export interface CatalogDraft {
         remove(providerID: string): void;
     };
     readonly model: {
-        get(providerID: string, modelID: string): ModelV2Info | undefined;
-        update(providerID: string, modelID: string, update: (model: ModelV2Info) => void): void;
+        get(providerID: string, modelID: string): ModelInfo | undefined;
+        update(providerID: string, modelID: string, update: (model: ModelInfo) => void): void;
         remove(providerID: string, modelID: string): void;
         readonly default: {
             get(): {
@@ -24,6 +26,7 @@ export interface CatalogDraft {
         };
     };
 }
-export type CatalogHooks = Hooks<{
-    transform: CatalogDraft;
-}>;
+export interface CatalogDomain extends CatalogApi<unknown> {
+    readonly transform: Transform<CatalogDraft>;
+    readonly reload: () => Effect.Effect<void>;
+}

package/dist/v2/effect/catalog.js

@@ -1 +0,0 @@
-export {};

package/dist/v2/effect/command.d.ts

@@ -1,11 +1,14 @@
-import type { CommandV2Info } from "@opencode-ai/sdk/v2/types";
-import type { Hooks } from "./registration.js";
+import type { CommandInfo } from "@opencode-ai/sdk/v2/types";
+import type { CommandApi } from "@opencode-ai/client/effect/api";
+import type { Effect } from "effect";
+import type { Transform } from "./registration.js";
 export interface CommandDraft {
-    list(): readonly CommandV2Info[];
-    get(name: string): CommandV2Info | undefined;
-    update(name: string, update: (command: CommandV2Info) => void): void;
+    list(): readonly CommandInfo[];
+    get(name: string): CommandInfo | undefined;
+    update(name: string, update: (command: CommandInfo) => void): void;
     remove(name: string): void;
 }
-export type CommandHooks = Hooks<{
-    transform: CommandDraft;
-}>;
+export interface CommandDomain extends CommandApi<unknown> {
+    readonly transform: Transform<CommandDraft>;
+    readonly reload: () => Effect.Effect<void>;
+}

package/dist/v2/effect/command.js

@@ -1 +0,0 @@
-export {};

package/dist/v2/effect/event.d.ts

@@ -1,8 +1,3 @@
-import type { Event as SDKEvent } from "@opencode-ai/sdk/v2/types";
-import type { Stream } from "effect";
-export type EventMap = {
-    [Item in SDKEvent as Item["type"]]: Item;
-};
-export interface Event {
-    subscribe<Type extends keyof EventMap>(type: Type): Stream.Stream<EventMap[Type]>;
+import type { EventApi } from "@opencode-ai/client/effect/api";
+export interface EventDomain extends Pick<EventApi<unknown>, "subscribe"> {
 }

package/dist/v2/effect/event.js

@@ -1 +0,0 @@
-export {};

package/dist/v2/effect/filesystem.js

@@ -1 +0,0 @@
-export {};

package/dist/v2/effect/index.d.ts

@@ -1,3 +1,10 @@
-export type { PluginContext } from "./context.js";
-export { define } from "./plugin.js";
-export type { Plugin } from "./plugin.js";
+export * as Plugin from "./plugin.js";
+export { Agent } from "@opencode-ai/schema/agent";
+export { Command } from "@opencode-ai/schema/command";
+export { Connection } from "@opencode-ai/schema/connection";
+export { Credential } from "@opencode-ai/schema/credential";
+export { Integration } from "@opencode-ai/schema/integration";
+export { Model } from "@opencode-ai/schema/model";
+export { Provider } from "@opencode-ai/schema/provider";
+export { Reference } from "@opencode-ai/schema/reference";
+export { Skill } from "@opencode-ai/schema/skill";

package/dist/v2/effect/index.js

@@ -1 +1,10 @@
-export { define } from "./plugin.js";
+export * as Plugin from "./plugin.js";
+export { Agent } from "@opencode-ai/schema/agent";
+export { Command } from "@opencode-ai/schema/command";
+export { Connection } from "@opencode-ai/schema/connection";
+export { Credential } from "@opencode-ai/schema/credential";
+export { Integration } from "@opencode-ai/schema/integration";
+export { Model } from "@opencode-ai/schema/model";
+export { Provider } from "@opencode-ai/schema/provider";
+export { Reference } from "@opencode-ai/schema/reference";
+export { Skill } from "@opencode-ai/schema/skill";

package/dist/v2/effect/integration.d.ts

@@ -1,6 +1,7 @@
 import type { ConnectionInfo, CredentialOAuth, CredentialValue, IntegrationEnvMethod, IntegrationInputs, IntegrationKeyMethod, IntegrationMethod, IntegrationOAuthMethod, IntegrationRef } from "@opencode-ai/sdk/v2/types";
+import type { IntegrationApi } from "@opencode-ai/client/effect/api";
 import type { Effect, Scope } from "effect";
-import type { Hooks } from "./registration.js";
+import type { Transform } from "./registration.js";
 export type IntegrationOAuthAuthorization = {
     readonly url: string;
     readonly instructions: string;
@@ -36,9 +37,9 @@ export interface IntegrationDraft {
         remove(integrationID: string, method: IntegrationMethod): void;
     };
 }
-export interface IntegrationHooks extends Hooks<{
-    transform: IntegrationDraft;
-}> {
+export interface IntegrationDomain extends IntegrationApi<unknown> {
+    readonly transform: Transform<IntegrationDraft>;
+    readonly reload: () => Effect.Effect<void>;
     readonly connection: {
         readonly active: (integrationID: string) => Effect.Effect<ConnectionInfo | undefined>;
         readonly resolve: (connection: ConnectionInfo) => Effect.Effect<CredentialValue | undefined, unknown>;

package/dist/v2/effect/integration.js

@@ -1 +0,0 @@
-export {};

package/dist/v2/effect/location.js

@@ -1 +0,0 @@
-export {};

package/dist/v2/effect/npm.js

@@ -1 +0,0 @@
-export {};

package/dist/v2/effect/path.js

@@ -1 +0,0 @@
-export {};

package/dist/v2/effect/plugin.d.ts

@@ -1,11 +1,32 @@
+import type { PluginApi } from "@opencode-ai/client/effect/api";
 import type { Effect, Scope } from "effect";
-import type { PluginContext } from "./context.js";
+import type { PluginOptions } from "../options.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 { ReferenceDomain } from "./reference.js";
+import type { SessionDomain } from "./session.js";
+import type { SkillDomain } from "./skill.js";
+import type { ToolDomain } from "./tool.js";
+export interface Context {
+    readonly options: PluginOptions;
+    readonly agent: AgentDomain;
+    readonly aisdk: AISDKDomain;
+    readonly catalog: CatalogDomain;
+    readonly command: CommandDomain;
+    readonly event: EventDomain;
+    readonly integration: IntegrationDomain;
+    readonly plugin: PluginApi<unknown>;
+    readonly reference: ReferenceDomain;
+    readonly session: SessionDomain;
+    readonly skill: SkillDomain;
+    readonly tool: ToolDomain;
+}
 export interface Plugin<R = Scope.Scope> {
     readonly id: string;
-    readonly effect: (context: PluginContext) => Effect.Effect<void, never, R>;
+    readonly effect: (context: Context) => Effect.Effect<void, never, R>;
 }
 export declare function define<R = Scope.Scope>(plugin: Plugin<R>): Plugin<R>;
-export interface PluginDomain {
-    readonly add: (plugin: Plugin) => Effect.Effect<void>;
-    readonly remove: (id: string) => Effect.Effect<void>;
-}

package/dist/v2/effect/reference.d.ts

@@ -1,10 +1,13 @@
 import type { ReferenceGitSource, ReferenceLocalSource } from "@opencode-ai/sdk/v2/types";
-import type { Hooks } from "./registration.js";
+import type { ReferenceApi } from "@opencode-ai/client/effect/api";
+import type { Effect } from "effect";
+import type { Transform } from "./registration.js";
 export interface ReferenceDraft {
     add(name: string, source: ReferenceLocalSource | ReferenceGitSource): void;
     remove(name: string): void;
     list(): readonly (readonly [string, ReferenceLocalSource | ReferenceGitSource])[];
 }
-export type ReferenceHooks = Hooks<{
-    transform: ReferenceDraft;
-}>;
+export interface ReferenceDomain extends ReferenceApi<unknown> {
+    readonly transform: Transform<ReferenceDraft>;
+    readonly reload: () => Effect.Effect<void>;
+}

package/dist/v2/effect/reference.js

@@ -1 +0,0 @@
-export {};

package/dist/v2/effect/registration.d.ts

@@ -2,9 +2,5 @@ import type { Effect, Scope } from "effect";
 export interface Registration {
     readonly dispose: Effect.Effect<void>;
 }
-export interface Reload {
-    readonly reload: () => Effect.Effect<void>;
-}
-export type Hooks<Spec> = {
-    readonly [Name in keyof Spec]: (callback: (input: Spec[Name]) => Effect.Effect<void> | void) => Effect.Effect<Registration, never, Scope.Scope>;
-};
+export type Hooks<Spec> = <Name extends keyof Spec>(name: Name, callback: (input: Spec[Name]) => Effect.Effect<void>) => Effect.Effect<Registration, never, Scope.Scope>;
+export type Transform<Input> = (callback: (input: Input) => void) => Effect.Effect<Registration, never, Scope.Scope>;

package/dist/v2/effect/registration.js

@@ -1 +0,0 @@
-export {};

package/dist/v2/effect/session.d.ts

@@ -0,0 +1,2 @@
+import type { SessionApi } from "@opencode-ai/client/effect/api";
+export type SessionDomain = Pick<SessionApi<unknown>, "create" | "get" | "prompt" | "command" | "interrupt">;

package/dist/v2/effect/skill.d.ts

@@ -1,9 +1,12 @@
-import type { SkillV2Source } from "@opencode-ai/sdk/v2/types";
-import type { Hooks } from "./registration.js";
+import type { SkillSource } from "@opencode-ai/sdk/v2/types";
+import type { SkillApi } from "@opencode-ai/client/effect/api";
+import type { Effect } from "effect";
+import type { Transform } from "./registration.js";
 export interface SkillDraft {
-    source(source: SkillV2Source): void;
-    list(): readonly SkillV2Source[];
+    source(source: SkillSource): void;
+    list(): readonly SkillSource[];
+}
+export interface SkillDomain extends SkillApi<unknown> {
+    readonly transform: Transform<SkillDraft>;
+    readonly reload: () => Effect.Effect<void>;
 }
-export type SkillHooks = Hooks<{
-    transform: SkillDraft;
-}>;

package/dist/v2/effect/skill.js

@@ -1 +0,0 @@
-export {};

package/dist/v2/effect/tool.d.ts

@@ -0,0 +1,148 @@
+export * as Tool from "./tool.js";
+import { Agent } from "@opencode-ai/schema/agent";
+import type { LLM } from "@opencode-ai/schema/llm";
+import { Session } from "@opencode-ai/schema/session";
+import { SessionMessage } from "@opencode-ai/schema/session-message";
+import { Effect, JsonSchema, Schema } from "effect";
+import type { Hooks, Transform } from "./registration.js";
+export interface Context {
+    readonly sessionID: Session.ID;
+    readonly agent: Agent.ID;
+    readonly assistantMessageID: SessionMessage.ID;
+    readonly toolCallID: string;
+}
+export type SchemaType<A> = Schema.Codec<A, any>;
+type ToolDefinition = {
+    readonly name: string;
+    readonly description: string;
+    readonly inputSchema: JsonSchema.JsonSchema;
+    readonly outputSchema?: JsonSchema.JsonSchema;
+};
+type ToolCall = {
+    readonly input: unknown;
+    readonly [key: string]: unknown;
+};
+type ToolResultValue = {
+    readonly type: "json";
+    readonly value: unknown;
+} | {
+    readonly type: "text";
+    readonly value: unknown;
+} | {
+    readonly type: "error";
+    readonly value: unknown;
+} | {
+    readonly type: "content";
+    readonly value: ReadonlyArray<LLM.ToolContent>;
+};
+type ToolOutput = {
+    readonly structured: unknown;
+    readonly content: ReadonlyArray<LLM.ToolContent>;
+};
+declare const TypeId: unique symbol;
+export interface Definition<Input extends SchemaType<any>, Output extends SchemaType<any>> {
+    readonly [TypeId]: {
+        readonly _Input: Input;
+        readonly _Output: Output;
+    };
+}
+export type AnyTool = Definition<any, any>;
+declare const Failure_base: Schema.Class<Failure, Schema.TaggedStruct<"LLM.ToolFailure", {
+    readonly message: Schema.String;
+    readonly error: Schema.optional<Schema.Defect>;
+    readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+}>, import("effect/Cause").YieldableError>;
+export declare class Failure extends Failure_base {
+}
+declare const RegistrationError_base: Schema.Class<RegistrationError, Schema.TaggedStruct<"Tool.RegistrationError", {
+    readonly name: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class RegistrationError extends RegistrationError_base {
+}
+export type Content = {
+    readonly type: "text";
+    readonly text: string;
+} | {
+    readonly type: "file";
+    readonly data: string;
+    readonly mime: string;
+    readonly name?: string;
+};
+type Config<Input extends SchemaType<any>, Output extends SchemaType<any>, Structured extends SchemaType<any> = Output> = {
+    readonly description: string;
+    readonly input: Input;
+    readonly output: Output;
+    readonly structured?: Structured;
+    readonly toStructuredOutput?: (input: {
+        readonly input: Schema.Schema.Type<Input>;
+        readonly output: Output["Encoded"];
+    }) => Schema.Schema.Type<Structured>;
+    readonly execute: (input: Schema.Schema.Type<Input>, context: Context) => Effect.Effect<Schema.Schema.Type<Output>, Failure>;
+    readonly toModelOutput?: (input: {
+        readonly input: Schema.Schema.Type<Input>;
+        readonly output: Output["Encoded"];
+    }) => ReadonlyArray<Content>;
+};
+export type DynamicOutput = {
+    readonly structured: unknown;
+    readonly content: ReadonlyArray<Content>;
+};
+/**
+ * Config for a tool whose input shape is a raw JSON Schema not known at compile
+ * time (MCP servers, plugin manifests). Input is passed through as `unknown`;
+ * `execute` returns the already-projected structured value and model content.
+ */
+type DynamicConfig = {
+    readonly description: string;
+    readonly jsonSchema: JsonSchema.JsonSchema;
+    readonly outputSchema?: JsonSchema.JsonSchema;
+    readonly execute: (input: unknown, context: Context) => Effect.Effect<DynamicOutput, Failure>;
+};
+export declare function make<Input extends SchemaType<any>, Output extends SchemaType<any>, Structured extends SchemaType<any> = Output>(config: Config<Input, Output, Structured>): Definition<Input, Structured>;
+export declare function make(config: DynamicConfig): AnyTool;
+export declare const validateName: (name: string) => Effect.Effect<void, never, never> | Effect.Effect<never, RegistrationError, never>;
+export declare const registrationEntries: (tools: Readonly<Record<string, AnyTool>>, group?: string) => {
+    key: string;
+    name: string;
+    group: string | undefined;
+    tool: AnyTool;
+}[];
+export declare const withPermission: <Input extends SchemaType<any>, Output extends SchemaType<any>>(tool: Definition<Input, Output>, permission: string) => Definition<Input, Output>;
+export declare const permission: (tool: AnyTool, name: string) => string;
+export declare const definition: (name: string, tool: AnyTool) => ToolDefinition;
+export declare const settle: (tool: AnyTool, call: ToolCall, context: Context) => Effect.Effect<ToolOutput, Failure, never>;
+export interface ToolExecuteBeforeEvent {
+    readonly tool: string;
+    readonly sessionID: Session.ID;
+    readonly agent: Agent.ID;
+    readonly assistantMessageID: SessionMessage.ID;
+    readonly toolCallID: string;
+    input: unknown;
+}
+export interface ToolExecuteAfterEvent {
+    readonly tool: string;
+    readonly sessionID: Session.ID;
+    readonly agent: Agent.ID;
+    readonly assistantMessageID: SessionMessage.ID;
+    readonly toolCallID: string;
+    readonly input: unknown;
+    result: ToolResultValue;
+    output?: ToolOutput;
+    outputPaths?: ReadonlyArray<string>;
+}
+export interface RegisterOptions {
+    readonly group?: string;
+    readonly deferred?: boolean;
+}
+export interface ToolDraft {
+    add(name: string, tool: AnyTool, options?: RegisterOptions): void;
+}
+export interface ToolHooks {
+    readonly "execute.before": ToolExecuteBeforeEvent;
+    readonly "execute.after": ToolExecuteAfterEvent;
+}
+export interface ToolDomain {
+    readonly transform: Transform<ToolDraft>;
+    readonly hook: Hooks<ToolHooks>;
+}

package/dist/v2/effect/tool.js

@@ -0,0 +1,114 @@
+export * as Tool from "./tool.js";
+import { Agent } from "@opencode-ai/schema/agent";
+import { Session } from "@opencode-ai/schema/session";
+import { SessionMessage } from "@opencode-ai/schema/session-message";
+import { Effect, JsonSchema, Schema } from "effect";
+export class Failure extends Schema.TaggedErrorClass()("LLM.ToolFailure", {
+    message: Schema.String,
+    error: Schema.optional(Schema.Defect()),
+    metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+}) {
+}
+export class RegistrationError extends Schema.TaggedErrorClass()("Tool.RegistrationError", {
+    name: Schema.String,
+    message: Schema.String,
+}) {
+}
+const runtimes = new WeakMap();
+export function make(config) {
+    if ("jsonSchema" in config)
+        return makeDynamic(config);
+    return makeTyped(config);
+}
+function makeTyped(config) {
+    const tool = Object.freeze({});
+    const definitions = new Map();
+    runtimes.set(tool, {
+        definition: (name) => {
+            const cached = definitions.get(name);
+            if (cached)
+                return cached;
+            const definition = {
+                name,
+                description: config.description,
+                inputSchema: toJsonSchema(config.input),
+                outputSchema: toJsonSchema(config.structured ?? config.output),
+            };
+            definitions.set(name, definition);
+            return definition;
+        },
+        settle: (call, context) => Schema.decodeUnknownEffect(config.input)(call.input).pipe(Effect.mapError((error) => new Failure({ message: `Invalid tool input: ${error.message}` })), Effect.flatMap((input) => config.execute(input, context).pipe(Effect.flatMap((output) => Schema.encodeEffect(config.output)(output).pipe(Effect.flatMap((output) => {
+            if (!config.structured || !config.toStructuredOutput)
+                return Effect.succeed({ output, structured: output });
+            return Schema.encodeEffect(config.structured)(config.toStructuredOutput({ input, output })).pipe(Effect.map((structured) => ({ output, structured })));
+        }), Effect.mapError((error) => new Failure({
+            message: `Tool returned an invalid value for its output schema: ${error.message}`,
+        })))), Effect.map(({ output, structured }) => ({
+            structured,
+            content: config.toModelOutput?.({ input, output }).map(toModelContent) ??
+                (typeof output === "string" ? [{ type: "text", text: output }] : []),
+        }))))),
+    });
+    return tool;
+}
+function makeDynamic(config) {
+    const tool = Object.freeze({});
+    const definitions = new Map();
+    runtimes.set(tool, {
+        definition: (name) => {
+            const cached = definitions.get(name);
+            if (cached)
+                return cached;
+            const definition = {
+                name,
+                description: config.description,
+                inputSchema: config.jsonSchema,
+                outputSchema: config.outputSchema,
+            };
+            definitions.set(name, definition);
+            return definition;
+        },
+        settle: (call, context) => config
+            .execute(call.input, context)
+            .pipe(Effect.map((output) => ({ structured: output.structured, content: output.content.map(toModelContent) }))),
+    });
+    return tool;
+}
+function toModelContent(part) {
+    if (part.type === "text")
+        return { type: "text", text: part.text };
+    return { type: "file", uri: `data:${part.mime};base64,${part.data}`, mime: part.mime, name: part.name };
+}
+export const validateName = (name) => /^[A-Za-z][A-Za-z0-9_-]{0,63}$/.test(name)
+    ? Effect.void
+    : Effect.fail(new RegistrationError({ name, message: `Invalid tool name: ${name}` }));
+export const registrationEntries = (tools, group) => Object.entries(tools).map(([name, tool]) => {
+    const normalized = name.replace(/[^a-zA-Z0-9_-]/g, "_");
+    const parent = group?.replace(/[^a-zA-Z0-9_-]/g, "_");
+    return {
+        key: parent === undefined ? normalized : `${parent}_${normalized}`,
+        name: normalized,
+        group: parent,
+        tool,
+    };
+});
+export const withPermission = (tool, permission) => {
+    const decorated = Object.freeze({});
+    runtimes.set(decorated, { ...runtimeOf(tool), permission });
+    return decorated;
+};
+export const permission = (tool, name) => runtimeOf(tool).permission ?? name;
+export const definition = (name, tool) => runtimeOf(tool).definition(name);
+export const settle = (tool, call, context) => runtimeOf(tool).settle(call, context);
+function runtimeOf(tool) {
+    const runtime = runtimes.get(tool);
+    if (!runtime)
+        throw new TypeError("Invalid Tool value");
+    return runtime;
+}
+function toJsonSchema(schema) {
+    const document = Schema.toJsonSchemaDocument(schema);
+    if (Object.keys(document.definitions).length === 0)
+        return document.schema;
+    return { ...document.schema, $defs: document.definitions };
+}

package/dist/v2/options.js

@@ -1 +0,0 @@
-export {};

package/dist/v2/promise/agent.d.ts

@@ -1,6 +1,8 @@
+import type { AgentApi } from "@opencode-ai/client/promise/api";
 import type { AgentDraft } from "../effect/agent.js";
-import type { Hooks } from "./registration.js";
+import type { Transform } from "./registration.js";
 export type { AgentDraft };
-export type AgentHooks = Hooks<{
-    transform: AgentDraft;
-}>;
+export interface AgentDomain extends AgentApi {
+    readonly transform: Transform<AgentDraft>;
+    readonly reload: () => Promise<void>;
+}

package/dist/v2/promise/agent.js

@@ -1 +0,0 @@
-export {};

package/dist/v2/promise/aisdk.d.ts

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

package/dist/v2/promise/aisdk.js

@@ -1 +0,0 @@
-export {};

package/dist/v2/promise/catalog.d.ts

@@ -1,6 +1,8 @@
+import type { CatalogApi } from "@opencode-ai/client/promise/api";
 import type { CatalogDraft, CatalogProviderRecord } from "../effect/catalog.js";
-import type { Hooks } from "./registration.js";
+import type { Transform } from "./registration.js";
 export type { CatalogDraft, CatalogProviderRecord };
-export type CatalogHooks = Hooks<{
-    transform: CatalogDraft;
-}>;
+export interface CatalogDomain extends CatalogApi {
+    readonly transform: Transform<CatalogDraft>;
+    readonly reload: () => Promise<void>;
+}

package/dist/v2/promise/catalog.js

@@ -1 +0,0 @@
-export {};

package/dist/v2/promise/command.d.ts

@@ -1,6 +1,8 @@
+import type { CommandApi } from "@opencode-ai/client/promise/api";
 import type { CommandDraft } from "../effect/command.js";
-import type { Hooks } from "./registration.js";
+import type { Transform } from "./registration.js";
 export type { CommandDraft };
-export type CommandHooks = Hooks<{
-    transform: CommandDraft;
-}>;
+export interface CommandDomain extends CommandApi {
+    readonly transform: Transform<CommandDraft>;
+    readonly reload: () => Promise<void>;
+}

package/dist/v2/promise/command.js

@@ -1 +0,0 @@
-export {};

package/dist/v2/promise/event.d.ts

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

package/dist/v2/promise/index.d.ts

@@ -1,12 +1,12 @@
-export type { PluginContext } from "./context.js";
 export type { PluginOptions } from "../options.js";
-export { define } from "./plugin.js";
-export type { Plugin, PluginDomain } from "./plugin.js";
-export type { Registration, Reload } from "./registration.js";
-export type { AgentDraft, AgentHooks } from "./agent.js";
-export type { AISDKHooks } from "./aisdk.js";
-export type { CatalogDraft, CatalogHooks, CatalogProviderRecord } from "./catalog.js";
-export type { CommandDraft, CommandHooks } from "./command.js";
-export type { IntegrationDraft, IntegrationHooks, IntegrationMethodRegistration } from "./integration.js";
-export type { ReferenceDraft, ReferenceHooks } from "./reference.js";
-export type { SkillDraft, SkillHooks } from "./skill.js";
+export * as Plugin from "./plugin.js";
+export { Tool } from "./tool.js";
+export { Agent } from "@opencode-ai/schema/agent";
+export { Command } from "@opencode-ai/schema/command";
+export { Connection } from "@opencode-ai/schema/connection";
+export { Credential } from "@opencode-ai/schema/credential";
+export { Integration } from "@opencode-ai/schema/integration";
+export { Model } from "@opencode-ai/schema/model";
+export { Provider } from "@opencode-ai/schema/provider";
+export { Reference } from "@opencode-ai/schema/reference";
+export { Skill } from "@opencode-ai/schema/skill";

package/dist/v2/promise/index.js

@@ -1 +1,11 @@
-export { define } from "./plugin.js";
+export * as Plugin from "./plugin.js";
+export { Tool } from "./tool.js";
+export { Agent } from "@opencode-ai/schema/agent";
+export { Command } from "@opencode-ai/schema/command";
+export { Connection } from "@opencode-ai/schema/connection";
+export { Credential } from "@opencode-ai/schema/credential";
+export { Integration } from "@opencode-ai/schema/integration";
+export { Model } from "@opencode-ai/schema/model";
+export { Provider } from "@opencode-ai/schema/provider";
+export { Reference } from "@opencode-ai/schema/reference";
+export { Skill } from "@opencode-ai/schema/skill";

package/dist/v2/promise/integration.d.ts

@@ -1,10 +1,11 @@
+import type { IntegrationApi } from "@opencode-ai/client/promise/api";
 import type { IntegrationDraft, IntegrationMethodRegistration } from "../effect/integration.js";
 import type { CredentialValue } from "@opencode-ai/sdk/v2/types";
-import type { Hooks } from "./registration.js";
+import type { Transform } from "./registration.js";
 export type { IntegrationDraft, IntegrationMethodRegistration };
-export interface IntegrationHooks extends Hooks<{
-    transform: IntegrationDraft;
-}> {
+export interface IntegrationDomain extends IntegrationApi {
+    readonly transform: Transform<IntegrationDraft>;
+    readonly reload: () => Promise<void>;
     readonly connection: {
         readonly active: (integrationID: string) => Promise<import("@opencode-ai/sdk/v2/types").ConnectionInfo | undefined>;
         readonly resolve: (connection: import("@opencode-ai/sdk/v2/types").ConnectionInfo) => Promise<CredentialValue | undefined>;

package/dist/v2/promise/integration.js

@@ -1 +0,0 @@
-export {};

package/dist/v2/promise/plugin.d.ts

@@ -1,10 +1,31 @@
-import type { PluginContext } from "./context.js";
+import type { PluginApi } from "@opencode-ai/client/promise/api";
+import type { PluginOptions } from "../options.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 { ReferenceDomain } from "./reference.js";
+import type { SessionDomain } from "./session.js";
+import type { SkillDomain } from "./skill.js";
+import type { ToolDomain } from "./tool.js";
+export interface Context {
+    readonly options: PluginOptions;
+    readonly agent: AgentDomain;
+    readonly aisdk: AISDKDomain;
+    readonly catalog: CatalogDomain;
+    readonly command: CommandDomain;
+    readonly event: EventDomain;
+    readonly integration: IntegrationDomain;
+    readonly plugin: PluginApi;
+    readonly reference: ReferenceDomain;
+    readonly session: SessionDomain;
+    readonly skill: SkillDomain;
+    readonly tool: ToolDomain;
+}
 export interface Plugin {
     readonly id: string;
-    readonly setup: (context: PluginContext) => Promise<void> | void;
+    readonly setup: (context: Context) => Promise<void> | void;
 }
 export declare function define(plugin: Plugin): Plugin;
-export interface PluginDomain {
-    readonly add: (plugin: Plugin) => Promise<void>;
-    readonly remove: (id: string) => Promise<void>;
-}

package/dist/v2/promise/reference.d.ts

@@ -1,6 +1,8 @@
+import type { ReferenceApi } from "@opencode-ai/client/promise/api";
 import type { ReferenceDraft } from "../effect/reference.js";
-import type { Hooks } from "./registration.js";
+import type { Transform } from "./registration.js";
 export type { ReferenceDraft };
-export type ReferenceHooks = Hooks<{
-    transform: ReferenceDraft;
-}>;
+export interface ReferenceDomain extends ReferenceApi {
+    readonly transform: Transform<ReferenceDraft>;
+    readonly reload: () => Promise<void>;
+}

package/dist/v2/promise/reference.js

@@ -1 +0,0 @@
-export {};

package/dist/v2/promise/registration.d.ts

@@ -1,9 +1,5 @@
 export interface Registration {
     readonly dispose: () => Promise<void>;
 }
-export interface Reload {
-    readonly reload: () => Promise<void>;
-}
-export type Hooks<Spec> = {
-    readonly [Name in keyof Spec]: (callback: (input: Spec[Name]) => Promise<void> | void) => Promise<Registration>;
-};
+export type Hooks<Spec> = <Name extends keyof Spec>(name: Name, callback: (input: Spec[Name]) => Promise<void> | void) => Promise<Registration>;
+export type Transform<Input> = (callback: (input: Input) => void) => Promise<Registration>;

package/dist/v2/promise/registration.js

@@ -1 +0,0 @@
-export {};

package/dist/v2/promise/session.d.ts

@@ -0,0 +1,2 @@
+import type { SessionApi } from "@opencode-ai/client/promise/api";
+export type SessionDomain = Pick<SessionApi, "create" | "get" | "prompt" | "command" | "interrupt">;

package/dist/v2/promise/skill.d.ts

@@ -1,6 +1,8 @@
+import type { SkillApi } from "@opencode-ai/client/promise/api";
 import type { SkillDraft } from "../effect/skill.js";
-import type { Hooks } from "./registration.js";
+import type { Transform } from "./registration.js";
 export type { SkillDraft };
-export type SkillHooks = Hooks<{
-    transform: SkillDraft;
-}>;
+export interface SkillDomain extends SkillApi {
+    readonly transform: Transform<SkillDraft>;
+    readonly reload: () => Promise<void>;
+}

package/dist/v2/promise/skill.js

@@ -1 +0,0 @@
-export {};

package/dist/v2/promise/tool.d.ts

@@ -0,0 +1,75 @@
+export * as Tool from "./tool.js";
+import { Tool } from "../effect/tool.js";
+import type { Agent } from "@opencode-ai/schema/agent";
+import type { Session } from "@opencode-ai/schema/session";
+import type { SessionMessage } from "@opencode-ai/schema/session-message";
+import { type JsonSchema, type Schema } from "effect";
+import type { Hooks, Transform } from "./registration.js";
+export type Context = Tool.Context;
+export type SchemaType<A> = Tool.SchemaType<A>;
+export type Definition<Input extends SchemaType<any>, Output extends SchemaType<any>> = Tool.Definition<Input, Output>;
+export type AnyTool = Tool.AnyTool;
+export declare const Failure: typeof Tool.Failure;
+export type Failure = Tool.Failure;
+export declare const RegistrationError: typeof Tool.RegistrationError;
+export type RegistrationError = Tool.RegistrationError;
+export type Content = Tool.Content;
+export type DynamicOutput = Tool.DynamicOutput;
+type Config<Input extends SchemaType<any>, Output extends SchemaType<any>, Structured extends SchemaType<any> = Output> = {
+    readonly description: string;
+    readonly input: Input;
+    readonly output: Output;
+    readonly structured?: Structured;
+    readonly toStructuredOutput?: (input: {
+        readonly input: Schema.Schema.Type<Input>;
+        readonly output: Output["Encoded"];
+    }) => Schema.Schema.Type<Structured>;
+    readonly execute: (input: Schema.Schema.Type<Input>, context: Context) => Promise<Schema.Schema.Type<Output>>;
+    readonly toModelOutput?: (input: {
+        readonly input: Schema.Schema.Type<Input>;
+        readonly output: Output["Encoded"];
+    }) => ReadonlyArray<Content>;
+};
+type DynamicConfig = {
+    readonly description: string;
+    readonly jsonSchema: JsonSchema.JsonSchema;
+    readonly outputSchema?: JsonSchema.JsonSchema;
+    readonly execute: (input: unknown, context: Context) => Promise<DynamicOutput>;
+};
+export declare function make<Input extends SchemaType<any>, Output extends SchemaType<any>, Structured extends SchemaType<any> = Output>(config: Config<Input, Output, Structured>): Definition<Input, Structured>;
+export declare function make(config: DynamicConfig): AnyTool;
+export declare const withPermission: <Input extends Tool.SchemaType<any>, Output extends Tool.SchemaType<any>>(tool: Tool.Definition<Input, Output>, permission: string) => Tool.Definition<Input, Output>;
+export interface ToolExecuteBeforeEvent {
+    readonly tool: string;
+    readonly sessionID: Session.ID;
+    readonly agent: Agent.ID;
+    readonly assistantMessageID: SessionMessage.ID;
+    readonly toolCallID: string;
+    input: unknown;
+}
+export interface ToolExecuteAfterEvent {
+    readonly tool: string;
+    readonly sessionID: Session.ID;
+    readonly agent: Agent.ID;
+    readonly assistantMessageID: SessionMessage.ID;
+    readonly toolCallID: string;
+    readonly input: unknown;
+    result: Tool.ToolExecuteAfterEvent["result"];
+    output?: Tool.ToolExecuteAfterEvent["output"];
+    outputPaths?: ReadonlyArray<string>;
+}
+export interface RegisterOptions {
+    readonly group?: string;
+    readonly deferred?: boolean;
+}
+export interface ToolDraft {
+    add(name: string, tool: AnyTool, options?: RegisterOptions): void;
+}
+export interface ToolHooks {
+    readonly "execute.before": ToolExecuteBeforeEvent;
+    readonly "execute.after": ToolExecuteAfterEvent;
+}
+export interface ToolDomain {
+    readonly transform: Transform<ToolDraft>;
+    readonly hook: Hooks<ToolHooks>;
+}

package/dist/v2/promise/tool.js

@@ -0,0 +1,17 @@
+export * as Tool from "./tool.js";
+import { Tool } from "../effect/tool.js";
+import { Effect } from "effect";
+export const Failure = Tool.Failure;
+export const RegistrationError = Tool.RegistrationError;
+export function make(config) {
+    if ("jsonSchema" in config)
+        return Tool.make({
+            ...config,
+            execute: (input, context) => Effect.promise(() => config.execute(input, context)),
+        });
+    return Tool.make({
+        ...config,
+        execute: (input, context) => Effect.promise(() => config.execute(input, context)),
+    });
+}
+export const withPermission = Tool.withPermission;

package/package.json

@@ -1,12 +1,13 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode-ai/plugin",
-  "version": "0.0.0-next-202606301613",
+  "version": "0.0.0-next-15259",
   "type": "module",
   "license": "MIT",
   "scripts": {
+    "test": "bun test --timeout 5000",
     "typecheck": "tsgo --noEmit",
-    "build": "tsc"
+    "build": "tsc -p tsconfig.build.json"
   },
   "exports": {
     ".": {
@@ -25,17 +26,17 @@
       "import": "./dist/v2/effect/index.js",
       "types": "./dist/v2/effect/index.d.ts"
     },
-    "./v2/effect/integration": {
-      "import": "./dist/v2/effect/integration.js",
-      "types": "./dist/v2/effect/integration.d.ts"
+    "./v2/effect/*": {
+      "import": "./dist/v2/effect/*.js",
+      "types": "./dist/v2/effect/*.d.ts"
     },
-    "./v2/effect/plugin": {
-      "import": "./dist/v2/effect/plugin.js",
-      "types": "./dist/v2/effect/plugin.d.ts"
-    },
-    "./v2/promise": {
+    "./v2": {
       "import": "./dist/v2/promise/index.js",
       "types": "./dist/v2/promise/index.d.ts"
+    },
+    "./v2/*": {
+      "import": "./dist/v2/promise/*.js",
+      "types": "./dist/v2/promise/*.d.ts"
     }
   },
   "files": [
@@ -43,14 +44,16 @@
   ],
   "dependencies": {
     "@ai-sdk/provider": "3.0.8",
-    "@opencode-ai/sdk": "0.0.0-next-202606301613",
+    "@opencode-ai/client": "0.0.0-next-15259",
+    "@opencode-ai/schema": "0.0.0-next-15259",
+    "@opencode-ai/sdk": "0.0.0-next-15259",
     "effect": "4.0.0-beta.83",
     "zod": "4.1.8"
   },
   "peerDependencies": {
-    "@opentui/core": ">=0.3.4",
-    "@opentui/keymap": ">=0.3.4",
-    "@opentui/solid": ">=0.3.4"
+    "@opentui/core": ">=0.4.3",
+    "@opentui/keymap": ">=0.4.3",
+    "@opentui/solid": ">=0.4.3"
   },
   "peerDependenciesMeta": {
     "@opentui/core": {
@@ -64,9 +67,10 @@
     }
   },
   "devDependencies": {
-    "@opentui/core": "0.3.4",
-    "@opentui/keymap": "0.3.4",
-    "@opentui/solid": "0.3.4",
+    "@opentui/core": "0.4.3",
+    "@opentui/keymap": "0.4.3",
+    "@opentui/solid": "0.4.3",
+    "@tsconfig/bun": "1.0.9",
     "@tsconfig/node22": "22.0.2",
     "@types/node": "24.12.2",
     "typescript": "5.8.2",

package/dist/v2/effect/context.d.ts

@@ -1,21 +0,0 @@
-import type { PluginOptions } from "../options.js";
-import type { AgentHooks } from "./agent.js";
-import type { AISDKHooks } from "./aisdk.js";
-import type { CatalogHooks } from "./catalog.js";
-import type { CommandHooks } from "./command.js";
-import type { IntegrationHooks } from "./integration.js";
-import type { PluginDomain } from "./plugin.js";
-import type { ReferenceHooks } from "./reference.js";
-import type { SkillHooks } from "./skill.js";
-import type { Reload } from "./registration.js";
-export interface PluginContext {
-    readonly options: PluginOptions;
-    readonly agent: AgentHooks & Reload;
-    readonly aisdk: AISDKHooks;
-    readonly catalog: CatalogHooks & Reload;
-    readonly command: CommandHooks & Reload;
-    readonly integration: IntegrationHooks & Reload;
-    readonly plugin: PluginDomain;
-    readonly reference: ReferenceHooks & Reload;
-    readonly skill: SkillHooks & Reload;
-}

package/dist/v2/effect/context.js

@@ -1 +0,0 @@
-export {};

package/dist/v2/promise/context.d.ts

@@ -1,21 +0,0 @@
-import type { PluginOptions } from "../options.js";
-import type { AgentHooks } from "./agent.js";
-import type { AISDKHooks } from "./aisdk.js";
-import type { CatalogHooks } from "./catalog.js";
-import type { CommandHooks } from "./command.js";
-import type { IntegrationHooks } from "./integration.js";
-import type { PluginDomain } from "./plugin.js";
-import type { ReferenceHooks } from "./reference.js";
-import type { SkillHooks } from "./skill.js";
-import type { Reload } from "./registration.js";
-export interface PluginContext {
-    readonly options: PluginOptions;
-    readonly agent: AgentHooks & Reload;
-    readonly aisdk: AISDKHooks;
-    readonly catalog: CatalogHooks & Reload;
-    readonly command: CommandHooks & Reload;
-    readonly integration: IntegrationHooks & Reload;
-    readonly plugin: PluginDomain;
-    readonly reference: ReferenceHooks & Reload;
-    readonly skill: SkillHooks & Reload;
-}

package/dist/v2/promise/context.js

@@ -1 +0,0 @@
-export {};