feat(core): attach global native tools (#30832)

packages/core/test/application-tools.test.ts

@@ -0,0 +1,184 @@
+import { describe, expect } from "bun:test"
+import { Tool } from "@opencode-ai/core/public"
+import { ApplicationTools } from "@opencode-ai/core/tool/application-tools"
+import { PermissionV2 } from "@opencode-ai/core/permission"
+import { SessionV2 } from "@opencode-ai/core/session"
+import { ToolRegistry } from "@opencode-ai/core/tool/registry"
+import { Effect, Exit, Layer, Schema, Scope } from "effect"
+import { testEffect } from "./lib/effect"
+
+const permission = Layer.mock(PermissionV2.Service, {
+  assert: () => Effect.void,
+})
+const applications = ApplicationTools.layer
+const registry = ToolRegistry.layer.pipe(Layer.provide(permission), Layer.provide(applications))
+const it = testEffect(Layer.mergeAll(applications, registry))
+
+const sessionID = SessionV2.ID.make("ses_application_tool")
+const contextual = (contexts: Tool.Context[]) =>
+  Tool.make({
+    description: "Read application context",
+    parameters: Schema.Struct({ query: Schema.String }),
+    success: Schema.Struct({ answer: Schema.String }),
+    execute: ({ query }, context) =>
+      Effect.sync(() => {
+        contexts.push(context)
+        return { answer: query.toUpperCase() }
+      }),
+    toModelOutput: ({ output }) => [
+      { type: "text", text: output.answer },
+      { type: "file", data: "aGVsbG8=", mime: "image/png", name: "result.png" },
+    ],
+  })
+
+describe("ApplicationTools", () => {
+  it.effect("advertises and executes a scoped application tool with Session context", () =>
+    Effect.gen(function* () {
+      const applications = yield* ApplicationTools.Service
+      const registry = yield* ToolRegistry.Service
+      const contexts: Tool.Context[] = []
+
+      yield* applications.attach({ application_context: contextual(contexts) })
+
+      expect(yield* registry.definitions()).toMatchObject([
+        { name: "application_context", description: "Read application context" },
+      ])
+      expect(
+        yield* registry.settle({
+          sessionID,
+          call: { type: "tool-call", id: "call-context", name: "application_context", input: { query: "hello" } },
+        }),
+      ).toEqual({
+        result: {
+          type: "content",
+          value: [
+            { type: "text", text: "HELLO" },
+            { type: "media", mediaType: "image/png", data: "aGVsbG8=", filename: "result.png" },
+          ],
+        },
+        output: {
+          structured: { answer: "HELLO" },
+          content: [
+            { type: "text", text: "HELLO" },
+            { type: "file", source: { type: "data", data: "aGVsbG8=" }, mime: "image/png", name: "result.png" },
+          ],
+        },
+      })
+      expect(contexts).toEqual([{ sessionID, id: "call-context", name: "application_context" }])
+    }),
+  )
+
+  it.effect("removes an application tool when its attachment scope closes", () =>
+    Effect.gen(function* () {
+      const applications = yield* ApplicationTools.Service
+      const registry = yield* ToolRegistry.Service
+      const scope = yield* Scope.make()
+
+      yield* applications.attach({ temporary: contextual([]) }).pipe(Scope.provide(scope))
+      expect((yield* registry.definitions()).map((tool) => tool.name)).toEqual(["temporary"])
+
+      yield* Scope.close(scope, Exit.void)
+      expect(yield* registry.definitions()).toEqual([])
+    }),
+  )
+
+  it.effect("removes a tool before settling a call produced from an earlier definition", () =>
+    Effect.gen(function* () {
+      const applications = yield* ApplicationTools.Service
+      const registry = yield* ToolRegistry.Service
+      const attachmentScope = yield* Scope.make()
+      yield* applications.attach({ contextual: contextual([]) }).pipe(Scope.provide(attachmentScope))
+      expect((yield* registry.definitions()).map((tool) => tool.name)).toEqual(["contextual"])
+
+      yield* Scope.close(attachmentScope, Exit.void)
+      expect(
+        yield* registry.settle({
+          sessionID,
+          call: { type: "tool-call", id: "call-removed", name: "contextual", input: { query: "hello" } },
+        }),
+      ).toEqual({ result: { type: "error", value: "Unknown tool: contextual" } })
+    }),
+  )
+
+  it.effect("does not leak an attachment into an already closed scope", () =>
+    Effect.gen(function* () {
+      const applications = yield* ApplicationTools.Service
+      const registry = yield* ToolRegistry.Service
+      const scope = yield* Scope.make()
+      yield* Scope.close(scope, Exit.void)
+
+      yield* applications.attach({ closed: contextual([]) }).pipe(Scope.provide(scope))
+
+      expect(yield* registry.definitions()).toEqual([])
+    }),
+  )
+
+  it.effect("captures the attached record before later State rebuilds", () =>
+    Effect.gen(function* () {
+      const applications = yield* ApplicationTools.Service
+      const registry = yield* ToolRegistry.Service
+      const attached = { stable: contextual([]) }
+      yield* applications.attach(attached)
+      Object.assign(attached, { late: contextual([]) })
+
+      yield* Effect.scoped(applications.attach({ temporary: contextual([]) }))
+
+      expect((yield* registry.definitions()).map((tool) => tool.name)).toEqual(["stable"])
+    }),
+  )
+
+  it.effect("settles with the current same-name application tool and restores earlier attachments", () =>
+    Effect.gen(function* () {
+      const applications = yield* ApplicationTools.Service
+      const registry = yield* ToolRegistry.Service
+      const firstContexts: Tool.Context[] = []
+      const secondContexts: Tool.Context[] = []
+      const scope = yield* Scope.make()
+      yield* applications.attach({ contextual: contextual(firstContexts) })
+      expect((yield* registry.definitions()).map((tool) => tool.name)).toEqual(["contextual"])
+      yield* applications.attach({ contextual: contextual(secondContexts) }).pipe(Scope.provide(scope))
+
+      yield* registry.settle({
+        sessionID,
+        call: { type: "tool-call", id: "call-second", name: "contextual", input: { query: "second" } },
+      })
+      yield* Scope.close(scope, Exit.void)
+      yield* registry.settle({
+        sessionID,
+        call: { type: "tool-call", id: "call-first", name: "contextual", input: { query: "first" } },
+      })
+
+      expect(secondContexts).toEqual([{ sessionID, id: "call-second", name: "contextual" }])
+      expect(firstContexts).toEqual([{ sessionID, id: "call-first", name: "contextual" }])
+    }),
+  )
+
+  it.effect("keeps the Location tool when an application tool has the same name", () =>
+    Effect.gen(function* () {
+      const applications = yield* ApplicationTools.Service
+      const registry = yield* ToolRegistry.Service
+      const transform = yield* registry.transform()
+      const locationContexts: Tool.Context[] = []
+      const applicationContexts: Tool.Context[] = []
+      const location = contextual(locationContexts)
+      yield* transform((editor) =>
+        editor.set("shared", {
+          tool: location.definition,
+          execute: ({ parameters, sessionID, call }) =>
+            location.execute(parameters, { sessionID, id: call.id, name: call.name }),
+        }),
+      )
+      yield* applications.attach({ shared: contextual(applicationContexts) })
+
+      expect((yield* registry.definitions()).map((definition) => definition.name)).toEqual(["shared"])
+      expect(
+        yield* registry.settle({
+          sessionID,
+          call: { type: "tool-call", id: "call-shared", name: "shared", input: { query: "location" } },
+        }),
+      ).toMatchObject({ result: { type: "content" } })
+      expect(locationContexts).toEqual([{ sessionID, id: "call-shared", name: "shared" }])
+      expect(applicationContexts).toEqual([])
+    }),
+  )
+})

packages/core/test/location-layer.test.ts

@@ -1,7 +1,8 @@
 import fs from "fs/promises"
 import path from "path"
 import { describe, expect } from "bun:test"
-import { Effect, Layer } from "effect"
+import { Effect, Layer, Schema } from "effect"
+import { Tool } from "@opencode-ai/core/public"
 import { Catalog } from "@opencode-ai/core/catalog"
 import { LocationServiceMap } from "@opencode-ai/core/location-layer"
 import { PluginBoot } from "@opencode-ai/core/plugin/boot"
@@ -18,19 +19,24 @@ import { Npm } from "../src/npm"
 import { Project } from "../src/project"
 import { ProjectReference } from "../src/project-reference"
 import { LocationSearch } from "../src/location-search"
-import { ToolRegistry } from "../src/tool-registry"
+import { ToolRegistry } from "../src/tool/registry"
+import { ApplicationTools } from "../src/tool/application-tools"
 
+const applicationTools = ApplicationTools.layer
 const it = testEffect(
-  LocationServiceMap.layer.pipe(
-    Layer.provide(
-      Layer.mergeAll(
-        Project.defaultLayer,
-        EventV2.defaultLayer,
-        Auth.defaultLayer,
-        Npm.defaultLayer,
-        ModelsDev.defaultLayer,
-        FSUtil.defaultLayer,
-        Global.defaultLayer,
+  Layer.merge(
+    applicationTools,
+    LocationServiceMap.layer.pipe(
+      Layer.provide(
+        Layer.mergeAll(
+          Project.defaultLayer,
+          EventV2.defaultLayer,
+          Auth.defaultLayer,
+          Npm.defaultLayer,
+          ModelsDev.defaultLayer,
+          FSUtil.defaultLayer,
+          Global.defaultLayer,
+        ),
       ),
     ),
   ),
@@ -44,6 +50,14 @@ describe("LocationServiceMap", () => {
     ).pipe(
       Effect.flatMap(([blocked, allowed]) =>
         Effect.gen(function* () {
+          yield* (yield* ApplicationTools.Service).attach({
+            application_context: Tool.make({
+              description: "Read application context",
+              parameters: Schema.Struct({}),
+              success: Schema.Struct({ ok: Schema.Boolean }),
+              execute: () => Effect.succeed({ ok: true }),
+            }),
+          })
           yield* Effect.promise(() =>
             fs.writeFile(
               path.join(blocked.path, "opencode.json"),
@@ -70,6 +84,7 @@ describe("LocationServiceMap", () => {
           const blockedState = yield* update(blocked.path)
           expect(blockedState.providers.some((provider) => provider.id === ProviderV2.ID.make("test"))).toBe(false)
           expect(blockedState.tools.map((tool) => tool.name).sort()).toEqual([
+            "application_context",
             "apply_patch",
             "bash",
             "edit",
@@ -86,6 +101,7 @@ describe("LocationServiceMap", () => {
           const allowedState = yield* update(allowed.path)
           expect(allowedState.providers.some((provider) => provider.id === ProviderV2.ID.make("test"))).toBe(true)
           expect(allowedState.tools.map((tool) => tool.name).sort()).toEqual([
+            "application_context",
             "apply_patch",
             "bash",
             "edit",

packages/core/test/public-opencode.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect } from "bun:test"
-import { Effect } from "effect"
-import { OpenCode, Session } from "@opencode-ai/core/public"
+import { Effect, Schema } from "effect"
+import { OpenCode, Session, Tool } from "@opencode-ai/core/public"
 import { testEffect } from "./lib/effect"
 
 const it = testEffect(OpenCode.layer)
@@ -10,6 +10,8 @@ describe("public native OpenCode API", () => {
     Effect.gen(function* () {
       const opencode = yield* OpenCode.Service
 
+      expect(Object.keys(opencode).sort()).toEqual(["sessions", "tools"])
+
       expect(Object.keys(opencode.sessions).sort()).toEqual([
         "context",
         "create",
@@ -23,6 +25,14 @@ describe("public native OpenCode API", () => {
       expect(Session.ID.create()).toStartWith("ses_")
       expect(Session.MessageID.create()).toStartWith("msg_")
       expect(yield* opencode.sessions.list()).toBeArray()
+      yield* opencode.tools.attach({
+        public_tool: Tool.make({
+          description: "Public tool",
+          parameters: Schema.Struct({}),
+          success: Schema.Struct({ ok: Schema.Boolean }),
+          execute: () => Effect.succeed({ ok: true }),
+        }),
+      })
     }),
   )
 })

packages/core/test/session-runner-recorded.test.ts

@@ -16,7 +16,7 @@ import { SessionExecution } from "@opencode-ai/core/session/execution"
 import { SessionRunCoordinator } from "@opencode-ai/core/session/run-coordinator"
 import * as SessionRunnerLLM from "@opencode-ai/core/session/runner/llm"
 import { SessionRunnerModel } from "@opencode-ai/core/session/runner/model"
-import { ToolRegistry } from "@opencode-ai/core/tool-registry"
+import { ToolRegistry } from "@opencode-ai/core/tool/registry"
 import { SessionTable } from "@opencode-ai/core/session/sql"
 import { SessionStore } from "@opencode-ai/core/session/store"
 import { describe, expect } from "bun:test"
@@ -46,7 +46,7 @@ const permission = Layer.succeed(
     list: () => Effect.die("unused"),
   }),
 )
-const registry = ToolRegistry.layer.pipe(Layer.provide(permission))
+const registry = ToolRegistry.defaultLayer.pipe(Layer.provide(permission))
 const model = OpenAIChat.route
   .with({
     endpoint: { baseURL: "https://api.openai.com/v1" },

packages/core/test/session-runner-tool-registry.test.ts

@@ -2,7 +2,7 @@ import { describe, expect } from "bun:test"
 import { Tool, ToolFailure } from "@opencode-ai/llm"
 import { PermissionV2 } from "@opencode-ai/core/permission"
 import { SessionV2 } from "@opencode-ai/core/session"
-import { ToolRegistry } from "@opencode-ai/core/tool-registry"
+import { ToolRegistry } from "@opencode-ai/core/tool/registry"
 import { Effect, Exit, Layer, Schema, Scope } from "effect"
 import { testEffect } from "./lib/effect"
 
@@ -24,7 +24,7 @@ const permission = Layer.succeed(
     list: () => Effect.die("unused"),
   }),
 )
-const registry = ToolRegistry.layer.pipe(Layer.provide(permission))
+const registry = ToolRegistry.defaultLayer.pipe(Layer.provide(permission))
 const it = testEffect(Layer.mergeAll(permission, registry))
 
 const echo = Tool.make({

packages/core/test/session-runner.test.ts

@@ -29,7 +29,9 @@ import { SessionRunCoordinator } from "@opencode-ai/core/session/run-coordinator
 import { SessionRunner } from "@opencode-ai/core/session/runner"
 import * as SessionRunnerLLM from "@opencode-ai/core/session/runner/llm"
 import { SessionRunnerModel } from "@opencode-ai/core/session/runner/model"
-import { ToolRegistry } from "@opencode-ai/core/tool-registry"
+import { ToolRegistry } from "@opencode-ai/core/tool/registry"
+import { ApplicationTools } from "@opencode-ai/core/tool/application-tools"
+import { NativeTool } from "@opencode-ai/core/tool/native"
 import { SessionInputTable, SessionMessageTable, SessionTable } from "@opencode-ai/core/session/sql"
 import { SessionStore } from "@opencode-ai/core/session/store"
 import { ModelV2 } from "@opencode-ai/core/model"
@@ -93,7 +95,8 @@ const permission = Layer.succeed(
     list: () => Effect.die("unused"),
   }),
 )
-const registry = ToolRegistry.layer.pipe(Layer.provide(permission))
+const applications = ApplicationTools.layer
+const registry = ToolRegistry.layer.pipe(Layer.provide(permission), Layer.provide(applications))
 const echo = Layer.effectDiscard(
   ToolRegistry.Service.use((registry) =>
     registry.contribute((editor) => {
@@ -163,6 +166,7 @@ const it = testEffect(
     store,
     client,
     permission,
+    applications,
     registry,
     echo,
     models,
@@ -414,6 +418,55 @@ const verifyPartialFlushOnInterruption = (kind: FragmentKind) =>
   })
 
 describe("SessionRunnerLLM", () => {
+  it.effect("advertises and executes a globally attached application tool", () =>
+    Effect.gen(function* () {
+      yield* setup
+      const applicationTools = yield* ApplicationTools.Service
+      const session = yield* SessionV2.Service
+      const contexts: NativeTool.Context[] = []
+      yield* applicationTools.attach({
+        application_context: NativeTool.make({
+          description: "Read application context",
+          parameters: Schema.Struct({ query: Schema.String }),
+          success: Schema.Struct({ answer: Schema.String }),
+          execute: ({ query }, context) =>
+            Effect.sync(() => {
+              contexts.push(context)
+              return { answer: query.toUpperCase() }
+            }),
+        }),
+      })
+      yield* session.prompt({ sessionID, prompt: new Prompt({ text: "Use application context" }), resume: false })
+      responses = [
+        [
+          LLMEvent.stepStart({ index: 0 }),
+          LLMEvent.toolCall({ id: "call-application", name: "application_context", input: { query: "hello" } }),
+          LLMEvent.stepFinish({ index: 0, reason: "tool-calls" }),
+          LLMEvent.finish({ reason: "tool-calls" }),
+        ],
+        [],
+      ]
+
+      yield* session.resume(sessionID)
+
+      expect(requests[0]?.tools.map((tool) => tool.name)).toContain("application_context")
+      expect(contexts).toEqual([{ sessionID, id: "call-application", name: "application_context" }])
+      expect(yield* session.context(sessionID)).toMatchObject([
+        { type: "user", text: "Use application context" },
+        {
+          type: "assistant",
+          content: [
+            {
+              type: "tool",
+              id: "call-application",
+              state: { status: "completed", structured: { answer: "HELLO" } },
+            },
+          ],
+        },
+      ])
+    }),
+  )
+
   it.effect("starts a real runner turn after default prompt recording", () =>
     Effect.gen(function* () {
       yield* setup

packages/core/test/tool-apply-patch.test.ts

@@ -9,7 +9,7 @@ import { LocationMutation } from "@opencode-ai/core/location-mutation"
 import { PermissionV2 } from "@opencode-ai/core/permission"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { SessionV2 } from "@opencode-ai/core/session"
-import { ToolRegistry } from "@opencode-ai/core/tool-registry"
+import { ToolRegistry } from "@opencode-ai/core/tool/registry"
 import { ApplyPatchTool } from "@opencode-ai/core/tool/apply-patch"
 import { location } from "./fixture/location"
 import { tmpdir } from "./fixture/tmpdir"
@@ -86,7 +86,7 @@ const withTool = <A, E, R>(directory: string, body: (registry: ToolRegistry.Inte
   )
   const planning = LocationMutation.layer.pipe(Layer.provide(filesystem), Layer.provide(activeLocation))
   const commits = FileMutation.layer.pipe(Layer.provide(filesystem), Layer.provide(planning))
-  const registry = ToolRegistry.layer.pipe(Layer.provide(permission))
+  const registry = ToolRegistry.defaultLayer.pipe(Layer.provide(permission))
   const patch = ApplyPatchTool.layer.pipe(
     Layer.provide(registry),
     Layer.provide(planning),

packages/core/test/tool-bash.test.ts

@@ -14,7 +14,7 @@ import { AbsolutePath } from "@opencode-ai/core/schema"
 import { SessionV2 } from "@opencode-ai/core/session"
 import { BashTool } from "@opencode-ai/core/tool/bash"
 import { ToolOutputStore } from "@opencode-ai/core/tool-output-store"
-import { ToolRegistry } from "@opencode-ai/core/tool-registry"
+import { ToolRegistry } from "@opencode-ai/core/tool/registry"
 import { location } from "./fixture/location"
 import { tmpdir } from "./fixture/tmpdir"
 import { testEffect } from "./lib/effect"
@@ -113,7 +113,7 @@ const withTool = <A, E, R>(
     Location.Service.of(location({ directory: AbsolutePath.make(directory) })),
   )
   const mutation = LocationMutation.layer.pipe(Layer.provide(filesystem), Layer.provide(activeLocation))
-  const registry = ToolRegistry.layer.pipe(Layer.provide(permission))
+  const registry = ToolRegistry.defaultLayer.pipe(Layer.provide(permission))
   const bash = BashTool.layer.pipe(
     Layer.provide(registry),
     Layer.provide(permission),

packages/core/test/tool-edit.test.ts

@@ -10,7 +10,7 @@ import { LocationMutation } from "@opencode-ai/core/location-mutation"
 import { PermissionV2 } from "@opencode-ai/core/permission"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { SessionV2 } from "@opencode-ai/core/session"
-import { ToolRegistry } from "@opencode-ai/core/tool-registry"
+import { ToolRegistry } from "@opencode-ai/core/tool/registry"
 import { EditTool } from "@opencode-ai/core/tool/edit"
 import { location } from "./fixture/location"
 import { tmpdir } from "./fixture/tmpdir"
@@ -79,7 +79,7 @@ const withTool = <A, E, R>(directory: string, body: (registry: ToolRegistry.Inte
   )
   const planning = LocationMutation.layer.pipe(Layer.provide(filesystem), Layer.provide(activeLocation))
   const commits = FileMutation.layer.pipe(Layer.provide(filesystem), Layer.provide(planning))
-  const registry = ToolRegistry.layer.pipe(Layer.provide(permission))
+  const registry = ToolRegistry.defaultLayer.pipe(Layer.provide(permission))
   const edit = EditTool.layer.pipe(
     Layer.provide(registry),
     Layer.provide(planning),

packages/core/test/tool-glob.test.ts

@@ -6,7 +6,7 @@ import { PermissionV2 } from "@opencode-ai/core/permission"
 import { RelativePath } from "@opencode-ai/core/schema"
 import { SessionV2 } from "@opencode-ai/core/session"
 import { GlobTool } from "@opencode-ai/core/tool/glob"
-import { ToolRegistry } from "@opencode-ai/core/tool-registry"
+import { ToolRegistry } from "@opencode-ai/core/tool/registry"
 import { testEffect } from "./lib/effect"
 
 const sessionID = SessionV2.ID.make("ses_glob_tool_test")
@@ -81,7 +81,7 @@ const search = Layer.succeed(
   }),
 )
 
-const registry = ToolRegistry.layer.pipe(Layer.provide(permission))
+const registry = ToolRegistry.defaultLayer.pipe(Layer.provide(permission))
 const glob = GlobTool.layer.pipe(
   Layer.provide(registry),
   Layer.provide(permission),

packages/core/test/tool-grep.test.ts

@@ -14,7 +14,7 @@ import { Ripgrep } from "@opencode-ai/core/ripgrep"
 import { AbsolutePath, RelativePath } from "@opencode-ai/core/schema"
 import { SessionV2 } from "@opencode-ai/core/session"
 import { GrepTool } from "@opencode-ai/core/tool/grep"
-import { ToolRegistry } from "@opencode-ai/core/tool-registry"
+import { ToolRegistry } from "@opencode-ai/core/tool/registry"
 import { location } from "./fixture/location"
 import { tmpdir } from "./fixture/tmpdir"
 import { it as runtimeIt } from "./lib/effect"
@@ -86,7 +86,7 @@ const permission = Layer.succeed(
     list: () => Effect.die("unused"),
   }),
 )
-const registry = ToolRegistry.layer.pipe(Layer.provide(permission))
+const registry = ToolRegistry.defaultLayer.pipe(Layer.provide(permission))
 const grep = GrepTool.layer.pipe(
   Layer.provide(registry),
   Layer.provide(filesystem),
@@ -140,7 +140,7 @@ function provideLive(directory: string, projectReferences = references({})) {
     Layer.provide(FSUtil.defaultLayer),
     Layer.provide(dependencies),
   )
-  const registry = ToolRegistry.layer.pipe(Layer.provide(permission))
+  const registry = ToolRegistry.defaultLayer.pipe(Layer.provide(permission))
   const grep = GrepTool.layer.pipe(
     Layer.provide(registry),
     Layer.provide(filesystem),

packages/core/test/tool-question.test.ts

@@ -3,7 +3,7 @@ import { Effect, Exit, Fiber, Layer } from "effect"
 import { PermissionV2 } from "@opencode-ai/core/permission"
 import { QuestionV2 } from "@opencode-ai/core/question"
 import { SessionV2 } from "@opencode-ai/core/session"
-import { ToolRegistry } from "@opencode-ai/core/tool-registry"
+import { ToolRegistry } from "@opencode-ai/core/tool/registry"
 import { QuestionTool } from "@opencode-ai/core/tool/question"
 import { testEffect } from "./lib/effect"
 
@@ -23,7 +23,7 @@ const permission = Layer.succeed(
     list: () => Effect.die("unused"),
   }),
 )
-const registry = ToolRegistry.layer.pipe(Layer.provide(permission))
+const registry = ToolRegistry.defaultLayer.pipe(Layer.provide(permission))
 const question = Layer.succeed(
   QuestionV2.Service,
   QuestionV2.Service.of({

packages/core/test/tool-read.test.ts

@@ -3,7 +3,7 @@ import { Effect, Layer } from "effect"
 import { FileSystem } from "@opencode-ai/core/filesystem"
 import { PermissionV2 } from "@opencode-ai/core/permission"
 import { SessionV2 } from "@opencode-ai/core/session"
-import { ToolRegistry } from "@opencode-ai/core/tool-registry"
+import { ToolRegistry } from "@opencode-ai/core/tool/registry"
 import { ReadTool } from "@opencode-ai/core/tool/read"
 import { ToolOutputStore } from "@opencode-ai/core/tool-output-store"
 import { RelativePath } from "@opencode-ai/core/schema"
@@ -127,7 +127,7 @@ const permission = Layer.succeed(
     list: () => Effect.die("unused"),
   }),
 )
-const registry = ToolRegistry.layer.pipe(Layer.provide(permission))
+const registry = ToolRegistry.defaultLayer.pipe(Layer.provide(permission))
 const resources = Layer.succeed(
   ToolOutputStore.Service,
   ToolOutputStore.Service.of({

packages/core/test/tool-skill.test.ts

@@ -10,7 +10,7 @@ import { SessionV2 } from "@opencode-ai/core/session"
 import { SkillV2 } from "@opencode-ai/core/skill"
 import { SkillTool } from "@opencode-ai/core/tool/skill"
 import { ToolOutputStore } from "@opencode-ai/core/tool-output-store"
-import { ToolRegistry } from "@opencode-ai/core/tool-registry"
+import { ToolRegistry } from "@opencode-ai/core/tool/registry"
 import { tmpdir } from "./fixture/tmpdir"
 import { it } from "./lib/effect"
 
@@ -72,7 +72,7 @@ describe("SkillTool", () => {
               forAgent: () => Effect.die("unused"),
             }),
           )
-          const registry = ToolRegistry.layer.pipe(Layer.provide(permission))
+          const registry = ToolRegistry.defaultLayer.pipe(Layer.provide(permission))
           const resources = Layer.succeed(
             ToolOutputStore.Service,
             ToolOutputStore.Service.of({

packages/core/test/tool-todowrite.test.ts

@@ -10,7 +10,7 @@ import { SessionV2 } from "@opencode-ai/core/session"
 import { SessionTable } from "@opencode-ai/core/session/sql"
 import { SessionTodo } from "@opencode-ai/core/session/todo"
 import { TodoWriteTool } from "@opencode-ai/core/tool/todowrite"
-import { ToolRegistry } from "@opencode-ai/core/tool-registry"
+import { ToolRegistry } from "@opencode-ai/core/tool/registry"
 import { testEffect } from "./lib/effect"
 
 const sessionID = SessionV2.ID.make("ses_todowrite_tool_test")
@@ -34,7 +34,7 @@ const permission = Layer.succeed(
 const database = Database.layerFromPath(":memory:")
 const events = EventV2.layer.pipe(Layer.provide(database))
 const todos = SessionTodo.layer.pipe(Layer.provide(database), Layer.provide(events))
-const registry = ToolRegistry.layer.pipe(Layer.provide(permission))
+const registry = ToolRegistry.defaultLayer.pipe(Layer.provide(permission))
 const tool = TodoWriteTool.layer.pipe(Layer.provide(registry), Layer.provide(todos))
 const it = testEffect(Layer.mergeAll(database, events, todos, permission, registry, tool))
 

packages/core/test/tool-webfetch.test.ts

@@ -5,7 +5,7 @@ import { FetchHttpClient, HttpClient, HttpClientRequest, HttpClientResponse } fr
 import { PermissionV2 } from "@opencode-ai/core/permission"
 import { SessionV2 } from "@opencode-ai/core/session"
 import { ToolOutputStore } from "@opencode-ai/core/tool-output-store"
-import { ToolRegistry } from "@opencode-ai/core/tool-registry"
+import { ToolRegistry } from "@opencode-ai/core/tool/registry"
 import { WebFetchTool } from "@opencode-ai/core/tool/webfetch"
 import { testEffect } from "./lib/effect"
 
@@ -48,7 +48,7 @@ const resources = Layer.succeed(
     cleanup: () => Effect.die("unused"),
   }),
 )
-const registry = ToolRegistry.layer.pipe(Layer.provide(permission))
+const registry = ToolRegistry.defaultLayer.pipe(Layer.provide(permission))
 const webfetch = WebFetchTool.layer.pipe(Layer.provide(registry), Layer.provide(http), Layer.provide(resources))
 const it = testEffect(Layer.mergeAll(registry, permission, http, resources, webfetch))
 const fetchWebfetch = WebFetchTool.layer.pipe(

packages/core/test/tool-websearch.test.ts

@@ -3,7 +3,7 @@ import { Effect, Layer, Schema } from "effect"
 import { HttpClient, HttpClientResponse } from "effect/unstable/http"
 import { PermissionV2 } from "@opencode-ai/core/permission"
 import { SessionV2 } from "@opencode-ai/core/session"
-import { ToolRegistry } from "@opencode-ai/core/tool-registry"
+import { ToolRegistry } from "@opencode-ai/core/tool/registry"
 import { WebSearchTool } from "@opencode-ai/core/tool/websearch"
 import { ToolOutputStore } from "@opencode-ai/core/tool-output-store"
 import { testEffect } from "./lib/effect"
@@ -96,7 +96,7 @@ const permission = Layer.succeed(
     list: () => Effect.die("unused"),
   }),
 )
-const registry = ToolRegistry.layer.pipe(Layer.provide(permission))
+const registry = ToolRegistry.defaultLayer.pipe(Layer.provide(permission))
 const websearchConfig = Layer.succeed(
   WebSearchTool.ConfigService,
   WebSearchTool.ConfigService.of({

packages/core/test/tool-write.test.ts

@@ -10,7 +10,7 @@ import { LocationMutation } from "@opencode-ai/core/location-mutation"
 import { PermissionV2 } from "@opencode-ai/core/permission"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { SessionV2 } from "@opencode-ai/core/session"
-import { ToolRegistry } from "@opencode-ai/core/tool-registry"
+import { ToolRegistry } from "@opencode-ai/core/tool/registry"
 import { WriteTool } from "@opencode-ai/core/tool/write"
 import { location } from "./fixture/location"
 import { tmpdir } from "./fixture/tmpdir"
@@ -67,7 +67,7 @@ const withTool = <A, E, R>(directory: string, body: (registry: ToolRegistry.Inte
   )
   const planning = LocationMutation.layer.pipe(Layer.provide(filesystem), Layer.provide(activeLocation))
   const commits = FileMutation.layer.pipe(Layer.provide(filesystem), Layer.provide(planning))
-  const registry = ToolRegistry.layer.pipe(Layer.provide(permission))
+  const registry = ToolRegistry.defaultLayer.pipe(Layer.provide(permission))
   const write = WriteTool.layer.pipe(Layer.provide(registry), Layer.provide(planning), Layer.provide(commits))
   return Effect.gen(function* () {
     return yield* body(yield* ToolRegistry.Service)