refactor(plugin): move tool implementation to plugin (#34665)

bun.lock

@@ -680,7 +680,9 @@
       "version": "1.17.11",
       "dependencies": {
         "@ai-sdk/provider": "3.0.8",
+        "@opencode-ai/llm": "workspace:*",
         "@opencode-ai/protocol": "workspace:*",
+        "@opencode-ai/schema": "workspace:*",
         "@opencode-ai/sdk": "workspace:*",
         "effect": "catalog:",
         "zod": "catalog:",
@@ -744,6 +746,7 @@
       "dependencies": {
         "@opencode-ai/client": "workspace:*",
         "@opencode-ai/core": "workspace:*",
+        "@opencode-ai/plugin": "workspace:*",
         "@opencode-ai/server": "workspace:*",
         "effect": "catalog:",
       },

packages/core/src/plugin/host.ts

@@ -16,7 +16,6 @@ import { ProviderV2 } from "../provider"
 import { Reference } from "../reference"
 import { AbsolutePath, type DeepMutable } from "../schema"
 import { SkillV2 } from "../skill"
-import { Tool } from "../tool/tool"
 import { Tools } from "../tool/tools"
 import { WorkspaceV2 } from "../workspace"
 
@@ -247,7 +246,7 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: PluginV2.Int
         ),
     },
     tool: {
-      register: (input) => tools.register(input as Readonly<Record<string, Tool.AnyTool>>),
+      register: (input) => tools.register(input),
     },
     session: {
       create: (input) =>

packages/core/src/tool/tool.ts

@@ -1,214 +1,2 @@
-export * as Tool from "./tool"
-
-import { ToolDefinition, ToolFailure, ToolOutput, type ToolCall } from "@opencode-ai/llm"
-import { Effect, JsonSchema, Schema } from "effect"
-import type { AgentV2 } from "../agent"
-import type { SessionMessage } from "../session/message"
-import type { SessionSchema } from "../session/schema"
-
-export interface Context {
-  readonly sessionID: SessionSchema.ID
-  readonly agent: AgentV2.ID
-  readonly assistantMessageID: SessionMessage.ID
-  readonly toolCallID: string
-}
-
-export type SchemaType<A> = Schema.Codec<A, any, never, never>
-
-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>
-export const Failure = ToolFailure
-export type Failure = ToolFailure
-
-export class RegistrationError extends Schema.TaggedErrorClass<RegistrationError>()("Tool.RegistrationError", {
-  name: Schema.String,
-  message: Schema.String,
-}) {}
-
-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>, ToolFailure>
-  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, ToolFailure>
-}
-
-type Runtime = {
-  readonly permission?: string
-  readonly definition: (name: string) => ToolDefinition
-  readonly settle: (call: ToolCall, context: Context) => Effect.Effect<ToolOutput, ToolFailure>
-}
-
-const runtimes = new WeakMap<AnyTool, Runtime>()
-
-export function make<
-  Input extends SchemaType<any>,
-  Output extends SchemaType<any>,
-  Structured extends SchemaType<any> = Output,
->(config: Config<Input, Output, Structured>): Definition<Input, Structured>
-export function make(config: DynamicConfig): AnyTool
-export function make(config: Config<any, any, any> | DynamicConfig): AnyTool {
-  if ("jsonSchema" in config) return makeDynamic(config)
-  return makeTyped(config)
-}
-
-function makeTyped<
-  Input extends SchemaType<any>,
-  Output extends SchemaType<any>,
-  Structured extends SchemaType<any> = Output,
->(config: Config<Input, Output, Structured>): Definition<Input, Structured> {
-  const tool = Object.freeze({}) as Definition<Input, Structured>
-  const definitions = new Map<string, ToolDefinition>()
-  runtimes.set(tool, {
-    definition: (name) => {
-      const cached = definitions.get(name)
-      if (cached) return cached
-      const definition = new ToolDefinition({
-        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 ToolFailure({ 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 ToolFailure({
-                      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" as const, text: output }] : []),
-            })),
-          ),
-        ),
-      ),
-  })
-  return tool
-}
-
-function makeDynamic(config: DynamicConfig): AnyTool {
-  const tool = Object.freeze({}) as AnyTool
-  const definitions = new Map<string, ToolDefinition>()
-  runtimes.set(tool, {
-    definition: (name) => {
-      const cached = definitions.get(name)
-      if (cached) return cached
-      const definition = new ToolDefinition({
-        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: Content) {
-  if (part.type === "text") return { type: "text" as const, text: part.text }
-  return { type: "file" as const, uri: `data:${part.mime};base64,${part.data}`, mime: part.mime, name: part.name }
-}
-
-export const validateName = (name: string) =>
-  /^[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: Readonly<Record<string, AnyTool>>) =>
-  Object.entries(tools).map(([name, tool]) => [name.replace(/[^a-zA-Z0-9_-]/g, "_"), tool] as const)
-
-export const withPermission = <Input extends SchemaType<any>, Output extends SchemaType<any>>(
-  tool: Definition<Input, Output>,
-  permission: string,
-) => {
-  const decorated = Object.freeze({}) as Definition<Input, Output>
-  runtimes.set(decorated, { ...runtimeOf(tool), permission })
-  return decorated
-}
-
-export const permission = (tool: AnyTool, name: string) => runtimeOf(tool).permission ?? name
-export const definition = (name: string, tool: AnyTool) => runtimeOf(tool).definition(name)
-export const settle = (tool: AnyTool, call: ToolCall, context: Context) => runtimeOf(tool).settle(call, context)
-
-function runtimeOf(tool: AnyTool) {
-  const runtime = runtimes.get(tool)
-  if (!runtime) throw new TypeError("Invalid Core Tool value")
-  return runtime
-}
-
-function toJsonSchema(schema: Schema.Top): JsonSchema.JsonSchema {
-  const document = Schema.toJsonSchemaDocument(schema)
-  if (Object.keys(document.definitions).length === 0) return document.schema
-  return { ...document.schema, $defs: document.definitions }
-}
+export * as Tool from "@opencode-ai/plugin/v2/effect/tool"
+export * from "@opencode-ai/plugin/v2/effect/tool"

packages/plugin/package.json

@@ -15,6 +15,7 @@
     "./v2/effect": "./src/v2/effect/index.ts",
     "./v2/effect/integration": "./src/v2/effect/integration.ts",
     "./v2/effect/plugin": "./src/v2/effect/plugin.ts",
+    "./v2/effect/tool": "./src/v2/effect/tool.ts",
     "./v2/promise": "./src/v2/promise/index.ts"
   },
   "files": [
@@ -22,7 +23,9 @@
   ],
   "dependencies": {
     "@ai-sdk/provider": "3.0.8",
+    "@opencode-ai/llm": "workspace:*",
     "@opencode-ai/protocol": "workspace:*",
+    "@opencode-ai/schema": "workspace:*",
     "@opencode-ai/sdk": "workspace:*",
     "effect": "catalog:",
     "zod": "catalog:"

packages/plugin/src/v2/effect/index.ts

@@ -1,5 +1,6 @@
 export type { PluginContext } from "./context.js"
 export { define } from "./plugin.js"
 export type { Plugin } from "./plugin.js"
+export * as Tool from "./tool.js"
 export type { ToolDomain } from "./tool.js"
 export type { SessionDomain } from "./runtime.js"

packages/plugin/src/v2/effect/tool.ts

@@ -1,5 +1,218 @@
-import type { Effect, Scope } from "effect"
+export * as Tool from "./tool.js"
+
+import { ToolDefinition, ToolFailure, ToolOutput, type ToolCall } from "@opencode-ai/llm"
+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, type Scope } from "effect"
+
+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>
+
+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>
+export const Failure = ToolFailure
+export type Failure = ToolFailure
+
+export class RegistrationError extends Schema.TaggedErrorClass<RegistrationError>()("Tool.RegistrationError", {
+  name: Schema.String,
+  message: Schema.String,
+}) {}
+
+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>, ToolFailure>
+  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, ToolFailure>
+}
+
+type Runtime = {
+  readonly permission?: string
+  readonly definition: (name: string) => ToolDefinition
+  readonly settle: (call: ToolCall, context: Context) => Effect.Effect<ToolOutput, ToolFailure>
+}
+
+const runtimes = new WeakMap<AnyTool, Runtime>()
+
+export function make<
+  Input extends SchemaType<any>,
+  Output extends SchemaType<any>,
+  Structured extends SchemaType<any> = Output,
+>(config: Config<Input, Output, Structured>): Definition<Input, Structured>
+export function make(config: DynamicConfig): AnyTool
+export function make(config: Config<any, any, any> | DynamicConfig): AnyTool {
+  if ("jsonSchema" in config) return makeDynamic(config)
+  return makeTyped(config)
+}
+
+function makeTyped<
+  Input extends SchemaType<any>,
+  Output extends SchemaType<any>,
+  Structured extends SchemaType<any> = Output,
+>(config: Config<Input, Output, Structured>): Definition<Input, Structured> {
+  const tool = Object.freeze({}) as Definition<Input, Structured>
+  const definitions = new Map<string, ToolDefinition>()
+  runtimes.set(tool, {
+    definition: (name) => {
+      const cached = definitions.get(name)
+      if (cached) return cached
+      const definition = new ToolDefinition({
+        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 ToolFailure({ 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 ToolFailure({
+                      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" as const, text: output }] : []),
+            })),
+          ),
+        ),
+      ),
+  })
+  return tool
+}
+
+function makeDynamic(config: DynamicConfig): AnyTool {
+  const tool = Object.freeze({}) as AnyTool
+  const definitions = new Map<string, ToolDefinition>()
+  runtimes.set(tool, {
+    definition: (name) => {
+      const cached = definitions.get(name)
+      if (cached) return cached
+      const definition = new ToolDefinition({
+        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: Content) {
+  if (part.type === "text") return { type: "text" as const, text: part.text }
+  return { type: "file" as const, uri: `data:${part.mime};base64,${part.data}`, mime: part.mime, name: part.name }
+}
+
+export const validateName = (name: string) =>
+  /^[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: Readonly<Record<string, AnyTool>>) =>
+  Object.entries(tools).map(([name, tool]) => [name.replace(/[^a-zA-Z0-9_-]/g, "_"), tool] as const)
+
+export const withPermission = <Input extends SchemaType<any>, Output extends SchemaType<any>>(
+  tool: Definition<Input, Output>,
+  permission: string,
+) => {
+  const decorated = Object.freeze({}) as Definition<Input, Output>
+  runtimes.set(decorated, { ...runtimeOf(tool), permission })
+  return decorated
+}
+
+export const permission = (tool: AnyTool, name: string) => runtimeOf(tool).permission ?? name
+export const definition = (name: string, tool: AnyTool) => runtimeOf(tool).definition(name)
+export const settle = (tool: AnyTool, call: ToolCall, context: Context) => runtimeOf(tool).settle(call, context)
+
+function runtimeOf(tool: AnyTool) {
+  const runtime = runtimes.get(tool)
+  if (!runtime) throw new TypeError("Invalid Tool value")
+  return runtime
+}
+
+function toJsonSchema(schema: Schema.Top): JsonSchema.JsonSchema {
+  const document = Schema.toJsonSchemaDocument(schema)
+  if (Object.keys(document.definitions).length === 0) return document.schema
+  return { ...document.schema, $defs: document.definitions }
+}
 
 export interface ToolDomain {
-  readonly register: (tools: Readonly<Record<string, unknown>>) => Effect.Effect<void, unknown, Scope.Scope>
+  readonly register: (tools: Readonly<Record<string, AnyTool>>) => Effect.Effect<void, RegistrationError, Scope.Scope>
 }

packages/plugin/tsconfig.json

@@ -5,7 +5,8 @@
     "rootDir": "src",
     "outDir": "dist",
     "declaration": true,
-    "lib": ["es2022", "dom", "dom.iterable"]
+    "lib": ["ESNext", "DOM", "DOM.Iterable"],
+    "noUncheckedIndexedAccess": false
   },
   "include": ["src"]
 }

packages/sdk-next/package.json

@@ -14,6 +14,7 @@
   "dependencies": {
     "@opencode-ai/client": "workspace:*",
     "@opencode-ai/core": "workspace:*",
+    "@opencode-ai/plugin": "workspace:*",
     "@opencode-ai/server": "workspace:*",
     "effect": "catalog:"
   },

packages/sdk-next/src/tool.ts

@@ -1,2 +1,2 @@
-export { Failure, RegistrationError, make } from "@opencode-ai/core/tool/tool"
-export type { AnyTool, Content, Context, Definition } from "@opencode-ai/core/tool/tool"
+export { Failure, RegistrationError, make } from "@opencode-ai/plugin/v2/effect/tool"
+export type { AnyTool, Content, Context, Definition } from "@opencode-ai/plugin/v2/effect/tool"