refactor(plugin): simplify promise tool declarations

packages/core/src/plugin/promise.ts

@@ -1,7 +1,9 @@
 export * as PluginPromise from "./promise"
 
 import { Plugin } from "@opencode-ai/plugin/v2/effect"
+import type { AnyTool, RegisterOptions } from "@opencode-ai/plugin/v2/tool"
 import { Effect, Scope, Stream } from "effect"
+import { Tool } from "../tool/tool"
 
 type HostRegistration = { readonly dispose: Effect.Effect<void> }
 type Registration = { readonly dispose: () => Promise<void> }
@@ -108,7 +110,15 @@ export function fromPromise(plugin: PromisePlugin) {
             reload: () => run(host.skill.reload()),
           },
           tool: {
-            transform: transform(host.tool),
+            transform: (callback) =>
+              register(
+                host.tool.transform((draft) =>
+                  callback({
+                    add: (name: string, tool: AnyTool, options?: RegisterOptions) =>
+                      draft.add(name, fromPromiseTool(tool), options),
+                  }),
+                ),
+              ),
             hook: (name, callback) =>
               register(host.tool.hook(name, (event) => Effect.promise(() => Promise.resolve(callback(event))))),
           },
@@ -125,3 +135,15 @@ export function fromPromise(plugin: PromisePlugin) {
       }),
   })
 }
+
+function fromPromiseTool(tool: AnyTool) {
+  if ("jsonSchema" in tool)
+    return Tool.make({
+      ...tool,
+      execute: (input, context) => Effect.promise(() => tool.execute(input, context)),
+    })
+  return Tool.make({
+    ...tool,
+    execute: (input, context) => Effect.promise(() => tool.execute(input, context)),
+  })
+}

packages/core/test/plugin/promise.test.ts

@@ -1,9 +1,12 @@
 import { describe, expect } from "bun:test"
-import { Effect } from "effect"
+import { Effect, Schema } from "effect"
 import { AgentV2 } from "@opencode-ai/core/agent"
 import { PluginV2 } from "@opencode-ai/core/plugin"
 import { PluginHost } from "@opencode-ai/core/plugin/host"
 import { PluginPromise } from "@opencode-ai/core/plugin/promise"
+import { SessionV2 } from "@opencode-ai/core/session"
+import { SessionMessage } from "@opencode-ai/core/session/message"
+import { ToolRegistry } from "@opencode-ai/core/tool/registry"
 import { Plugin } from "@opencode-ai/plugin/v2"
 import { testEffect } from "../lib/effect"
 import { PluginTestLayer } from "./fixture"
@@ -93,4 +96,38 @@ describe("fromPromise", () => {
       expect(yield* agents.get(AgentV2.ID.make("temp"))).toBeUndefined()
     }),
   )
+
+  it.effect("constructs plain Promise tool declarations in the host", () =>
+    Effect.gen(function* () {
+      const plugins = yield* PluginV2.Service
+      const registry = yield* ToolRegistry.Service
+      const host = yield* PluginHost.make(plugins)
+      const promisePlugin = Plugin.define({
+        id: "promise-tool",
+        setup: async (ctx) => {
+          await ctx.tool.transform((tools) => {
+            tools.add("hello", {
+              description: "Hello",
+              input: Schema.Struct({ name: Schema.String }),
+              output: Schema.String,
+              execute: async ({ name }) => `Hello, ${name}!`,
+            })
+          })
+        },
+      })
+
+      yield* PluginPromise.fromPromise(promisePlugin).effect(host)
+
+      const materialized = yield* registry.materialize()
+      expect(materialized.definitions).toContainEqual(expect.objectContaining({ name: "hello", description: "Hello" }))
+      expect(
+        yield* materialized.settle({
+          sessionID: SessionV2.ID.make("ses_promise_tool"),
+          agent: AgentV2.ID.make("build"),
+          assistantMessageID: SessionMessage.ID.make("msg_promise_tool"),
+          call: { type: "tool-call", id: "call_promise_tool", name: "hello", input: { name: "world" } },
+        }),
+      ).toMatchObject({ result: { type: "text", value: "Hello, world!" } })
+    }),
+  )
 })