refactor(tool): Tool.Def.execute returns Effect, rename defineEffect → define (#21961)

packages/opencode/src/tool/tool.ts

@@ -23,22 +23,21 @@ export namespace Tool {
     extra?: { [key: string]: any }
     messages: MessageV2.WithParts[]
     metadata(input: { title?: string; metadata?: M }): void
-    ask(input: Omit<Permission.Request, "id" | "sessionID" | "tool">): Promise<void>
+    ask(input: Omit<Permission.Request, "id" | "sessionID" | "tool">): Effect.Effect<void>
+  }
+
+  export interface ExecuteResult<M extends Metadata = Metadata> {
+    title: string
+    metadata: M
+    output: string
+    attachments?: Omit<MessageV2.FilePart, "id" | "sessionID" | "messageID">[]
   }
 
   export interface Def<Parameters extends z.ZodType = z.ZodType, M extends Metadata = Metadata> {
     id: string
     description: string
     parameters: Parameters
-    execute(
-      args: z.infer<Parameters>,
-      ctx: Context,
-    ): Promise<{
-      title: string
-      metadata: M
-      output: string
-      attachments?: Omit<MessageV2.FilePart, "id" | "sessionID" | "messageID">[]
-    }>
+    execute(args: z.infer<Parameters>, ctx: Context): Effect.Effect<ExecuteResult<M>>
     formatValidationError?(error: z.ZodError): string
   }
   export type DefWithoutID<Parameters extends z.ZodType = z.ZodType, M extends Metadata = Metadata> = Omit<
@@ -74,48 +73,41 @@ export namespace Tool {
     return async () => {
       const toolInfo = init instanceof Function ? await init() : { ...init }
       const execute = toolInfo.execute
-      toolInfo.execute = async (args, ctx) => {
-        try {
-          toolInfo.parameters.parse(args)
-        } catch (error) {
-          if (error instanceof z.ZodError && toolInfo.formatValidationError) {
-            throw new Error(toolInfo.formatValidationError(error), { cause: error })
+      toolInfo.execute = (args, ctx) =>
+        Effect.gen(function* () {
+          yield* Effect.try({
+            try: () => toolInfo.parameters.parse(args),
+            catch: (error) => {
+              if (error instanceof z.ZodError && toolInfo.formatValidationError) {
+                return new Error(toolInfo.formatValidationError(error), { cause: error })
+              }
+              return new Error(
+                `The ${id} tool was called with invalid arguments: ${error}.\nPlease rewrite the input so it satisfies the expected schema.`,
+                { cause: error },
+              )
+            },
+          })
+          const result = yield* execute(args, ctx)
+          if (result.metadata.truncated !== undefined) {
+            return result
           }
-          throw new Error(
-            `The ${id} tool was called with invalid arguments: ${error}.\nPlease rewrite the input so it satisfies the expected schema.`,
-            { cause: error },
-          )
-        }
-        const result = await execute(args, ctx)
-        if (result.metadata.truncated !== undefined) {
-          return result
-        }
-        const truncated = await Truncate.output(result.output, {}, await Agent.get(ctx.agent))
-        return {
-          ...result,
-          output: truncated.content,
-          metadata: {
-            ...result.metadata,
-            truncated: truncated.truncated,
-            ...(truncated.truncated && { outputPath: truncated.outputPath }),
-          },
-        }
-      }
+          const agent = yield* Effect.promise(() => Agent.get(ctx.agent))
+          const truncated = yield* Effect.promise(() => Truncate.output(result.output, {}, agent))
+          return {
+            ...result,
+            output: truncated.content,
+            metadata: {
+              ...result.metadata,
+              truncated: truncated.truncated,
+              ...(truncated.truncated && { outputPath: truncated.outputPath }),
+            },
+          }
+        }).pipe(Effect.orDie)
       return toolInfo
     }
   }
 
-  export function define<Parameters extends z.ZodType, Result extends Metadata, ID extends string = string>(
-    id: ID,
-    init: (() => Promise<DefWithoutID<Parameters, Result>>) | DefWithoutID<Parameters, Result>,
-  ): Info<Parameters, Result> & { id: ID } {
-    return {
-      id,
-      init: wrap(id, init),
-    }
-  }
-
-  export function defineEffect<Parameters extends z.ZodType, Result extends Metadata, R, ID extends string = string>(
+  export function define<Parameters extends z.ZodType, Result extends Metadata, R, ID extends string = string>(
     id: ID,
     init: Effect.Effect<(() => Promise<DefWithoutID<Parameters, Result>>) | DefWithoutID<Parameters, Result>, never, R>,
   ): Effect.Effect<Info<Parameters, Result>, never, R> & { id: ID } {