refactor(tool): convert webfetch tool to defineEffect with HttpClient

Author: kitlangton

packages/opencode/src/tool/lsp.ts

@@ -1,4 +1,5 @@
 import z from "zod"
+import { Effect } from "effect"
 import { Tool } from "./tool"
 import path from "path"
 import { LSP } from "../lsp"
@@ -20,78 +21,93 @@ const operations = [
   "outgoingCalls",
 ] as const
 
-export const LspTool = Tool.define("lsp", {
-  description: DESCRIPTION,
-  parameters: z.object({
-    operation: z.enum(operations).describe("The LSP operation to perform"),
-    filePath: z.string().describe("The absolute or relative path to the file"),
-    line: z.number().int().min(1).describe("The line number (1-based, as shown in editors)"),
-    character: z.number().int().min(1).describe("The character offset (1-based, as shown in editors)"),
-  }),
-  execute: async (args, ctx) => {
-    const file = path.isAbsolute(args.filePath) ? args.filePath : path.join(Instance.directory, args.filePath)
-    await assertExternalDirectory(ctx, file)
+const parameters = z.object({
+  operation: z.enum(operations).describe("The LSP operation to perform"),
+  filePath: z.string().describe("The absolute or relative path to the file"),
+  line: z.number().int().min(1).describe("The line number (1-based, as shown in editors)"),
+  character: z.number().int().min(1).describe("The character offset (1-based, as shown in editors)"),
+})
 
-    await ctx.ask({
-      permission: "lsp",
-      patterns: ["*"],
-      always: ["*"],
-      metadata: {},
-    })
-    const uri = pathToFileURL(file).href
-    const position = {
-      file,
-      line: args.line - 1,
-      character: args.character - 1,
-    }
+export const LspTool = Tool.defineEffect(
+  "lsp",
+  Effect.gen(function* () {
+    const lsp = yield* LSP.Service
 
-    const relPath = path.relative(Instance.worktree, file)
-    const title = `${args.operation} ${relPath}:${args.line}:${args.character}`
+    const run = Effect.fn("LspTool.execute")(function* (args: z.infer<typeof parameters>, ctx: Tool.Context) {
+      const file = path.isAbsolute(args.filePath) ? args.filePath : path.join(Instance.directory, args.filePath)
+      yield* Effect.promise(() => assertExternalDirectory(ctx, file))
 
-    const exists = await Filesystem.exists(file)
-    if (!exists) {
-      throw new Error(`File not found: ${file}`)
-    }
+      yield* Effect.promise(() =>
+        ctx.ask({
+          permission: "lsp",
+          patterns: ["*"],
+          always: ["*"],
+          metadata: {},
+        }),
+      )
+      const uri = pathToFileURL(file).href
+      const position = {
+        file,
+        line: args.line - 1,
+        character: args.character - 1,
+      }
 
-    const available = await LSP.hasClients(file)
-    if (!available) {
-      throw new Error("No LSP server available for this file type.")
-    }
+      const rel = path.relative(Instance.worktree, file)
+      const title = `${args.operation} ${rel}:${args.line}:${args.character}`
 
-    await LSP.touchFile(file, true)
+      const exists = yield* Effect.promise(() => Filesystem.exists(file))
+      if (!exists) {
+        return yield* Effect.fail(new Error(`File not found: ${file}`))
+      }
 
-    const result: unknown[] = await (async () => {
-      switch (args.operation) {
-        case "goToDefinition":
-          return LSP.definition(position)
-        case "findReferences":
-          return LSP.references(position)
-        case "hover":
-          return LSP.hover(position)
-        case "documentSymbol":
-          return LSP.documentSymbol(uri)
-        case "workspaceSymbol":
-          return LSP.workspaceSymbol("")
-        case "goToImplementation":
-          return LSP.implementation(position)
-        case "prepareCallHierarchy":
-          return LSP.prepareCallHierarchy(position)
-        case "incomingCalls":
-          return LSP.incomingCalls(position)
-        case "outgoingCalls":
-          return LSP.outgoingCalls(position)
+      const available = yield* lsp.hasClients(file)
+      if (!available) {
+        return yield* Effect.fail(new Error("No LSP server available for this file type."))
       }
-    })()
 
-    const output = (() => {
-      if (result.length === 0) return `No results found for ${args.operation}`
-      return JSON.stringify(result, null, 2)
-    })()
+      yield* lsp.touchFile(file, true)
+
+      const result: unknown[] = yield* (() => {
+        switch (args.operation) {
+          case "goToDefinition":
+            return lsp.definition(position)
+          case "findReferences":
+            return lsp.references(position)
+          case "hover":
+            return lsp.hover(position)
+          case "documentSymbol":
+            return lsp.documentSymbol(uri)
+          case "workspaceSymbol":
+            return lsp.workspaceSymbol("")
+          case "goToImplementation":
+            return lsp.implementation(position)
+          case "prepareCallHierarchy":
+            return lsp.prepareCallHierarchy(position)
+          case "incomingCalls":
+            return lsp.incomingCalls(position)
+          case "outgoingCalls":
+            return lsp.outgoingCalls(position)
+        }
+      })()
+
+      const output = (() => {
+        if (result.length === 0) return `No results found for ${args.operation}`
+        return JSON.stringify(result, null, 2)
+      })()
+
+      return {
+        title,
+        metadata: { result },
+        output,
+      }
+    })
 
     return {
-      title,
-      metadata: { result },
-      output,
+      description: DESCRIPTION,
+      parameters,
+      async execute(args: z.infer<typeof parameters>, ctx) {
+        return Effect.runPromise(run(args, ctx).pipe(Effect.orDie))
+      },
     }
-  },
-})
+  }),
+)

packages/opencode/src/tool/registry.ts

@@ -28,6 +28,7 @@ import { Glob } from "../util/glob"
 import path from "path"
 import { pathToFileURL } from "url"
 import { Effect, Layer, ServiceMap } from "effect"
+import { FetchHttpClient, HttpClient } from "effect/unstable/http"
 import { InstanceState } from "@/effect/instance-state"
 import { makeRuntime } from "@/effect/run-service"
 import { Env } from "../env"
@@ -80,6 +81,7 @@ export namespace ToolRegistry {
     | FileTime.Service
     | Instruction.Service
     | AppFileSystem.Service
+    | HttpClient.HttpClient
   > = Layer.effect(
     Service,
     Effect.gen(function* () {
@@ -92,6 +94,8 @@ export namespace ToolRegistry {
       const read = yield* ReadTool
       const question = yield* QuestionTool
       const todo = yield* TodoWriteTool
+      const lsptool = yield* LspTool
+      const webfetch = yield* WebFetchTool
 
       const state = yield* InstanceState.make<State>(
         Effect.fn("ToolRegistry.state")(function* (ctx) {
@@ -157,14 +161,14 @@ export namespace ToolRegistry {
             edit: Tool.init(EditTool),
             write: Tool.init(WriteTool),
             task: Tool.init(task),
-            fetch: Tool.init(WebFetchTool),
+            fetch: Tool.init(webfetch),
             todo: Tool.init(todo),
             search: Tool.init(WebSearchTool),
             code: Tool.init(CodeSearchTool),
             skill: Tool.init(SkillTool),
             patch: Tool.init(ApplyPatchTool),
             question: Tool.init(question),
-            lsp: Tool.init(LspTool),
+            lsp: Tool.init(lsptool),
             plan: Tool.init(PlanExitTool),
           })
 
@@ -301,6 +305,7 @@ export namespace ToolRegistry {
       Layer.provide(FileTime.defaultLayer),
       Layer.provide(Instruction.defaultLayer),
       Layer.provide(AppFileSystem.defaultLayer),
+      Layer.provide(FetchHttpClient.layer),
     ),
   )