feat(plugin): support plugin-provided tools (#34619)

packages/core/src/plugin/host.ts

@@ -8,12 +8,17 @@ import { Catalog } from "../catalog"
 import { CommandV2 } from "../command"
 import { Credential } from "../credential"
 import { Integration } from "../integration"
+import { Location } from "../location"
 import { ModelV2 } from "../model"
 import { PluginV2 } from "../plugin"
+import { PluginRuntime } from "./runtime"
 import { ProviderV2 } from "../provider"
 import { Reference } from "../reference"
-import type { DeepMutable } from "../schema"
+import { AbsolutePath, type DeepMutable } from "../schema"
 import { SkillV2 } from "../skill"
+import { Tool } from "../tool/tool"
+import { Tools } from "../tool/tools"
+import { WorkspaceV2 } from "../workspace"
 
 const mutable = <T>(value: T) => value as DeepMutable<T>
 
@@ -23,12 +28,38 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: PluginV2.Int
   const catalog = yield* Catalog.Service
   const commands = yield* CommandV2.Service
   const integration = yield* Integration.Service
+  const location = yield* Location.Service
   const reference = yield* Reference.Service
   const skill = yield* SkillV2.Service
+  const tools = yield* Tools.Service
+  const runtime = yield* PluginRuntime.Service
+  const locationInfo = () =>
+    new Location.Info({
+      directory: location.directory,
+      workspaceID: location.workspaceID,
+      project: location.project,
+    })
+  const locationRef = (input?: Parameters<Interface["agent"]["list"]>[0]) =>
+    input?.location === undefined
+      ? undefined
+      : Location.Ref.make({
+          directory: AbsolutePath.make(input.location.directory ?? location.directory),
+          workspaceID:
+            input.location.workspace === undefined
+              ? location.workspaceID
+              : WorkspaceV2.ID.make(input.location.workspace),
+        })
+  const isCurrentLocation = (ref: Location.Ref) =>
+    ref.directory === location.directory && ref.workspaceID === location.workspaceID
 
   return {
     options: {},
     agent: {
+      list: (input) => {
+        const ref = locationRef(input)
+        if (ref && !isCurrentLocation(ref)) return runtime.location.agent.list(ref)
+        return agents.list().pipe(Effect.map((data) => ({ location: locationInfo(), data })))
+      },
       reload: agents.reload,
       transform: (callback) =>
         agents.transform((draft) =>
@@ -215,5 +246,21 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: PluginV2.Int
           }),
         ),
     },
+    tool: {
+      register: (input) => tools.register(input as Readonly<Record<string, Tool.AnyTool>>),
+    },
+    session: {
+      create: (input) =>
+        runtime.session.create({
+          id: input?.id,
+          agent: input?.agent,
+          model: input?.model,
+          location:
+            input?.location ?? Location.Ref.make({ directory: location.directory, workspaceID: location.workspaceID }),
+        }),
+      get: (input) => runtime.session.get(input.sessionID),
+      prompt: runtime.session.prompt,
+      interrupt: (input) => runtime.session.interrupt(input.sessionID),
+    },
   } satisfies Interface
 })

packages/core/src/plugin/internal.ts

@@ -20,12 +20,18 @@ import { FSUtil } from "../fs-util"
 import { Global } from "../global"
 import { Integration } from "../integration"
 import { Location } from "../location"
+import { LocationMutation } from "../location-mutation"
 import { ModelsDev } from "../models-dev"
 import { Npm } from "../npm"
 import { PluginV2 } from "../plugin"
+import { PluginRuntime } from "../plugin/runtime"
+import { PermissionV2 } from "../permission"
 import { Reference } from "../reference"
+import { Shell } from "../shell"
 import { SkillV2 } from "../skill"
 import { State } from "../state"
+import { ToolRegistry } from "../tool/registry"
+import { Tools } from "../tool/tools"
 import { FetchHttpClient, HttpClient } from "effect/unstable/http"
 import { AgentPlugin } from "./agent"
 import { CommandPlugin } from "./command"
@@ -34,6 +40,8 @@ import { ProviderPlugins } from "./provider"
 import { SdkPlugins } from "./sdk"
 import { SkillPlugin } from "./skill"
 import { VariantPlugin } from "./variant"
+import { ShellTool } from "../tool/shell"
+import { SubagentTool } from "../tool/subagent"
 
 export type Requirements =
   | AgentV2.Service
@@ -47,10 +55,15 @@ export type Requirements =
   | HttpClient.HttpClient
   | Integration.Service
   | Location.Service
+  | LocationMutation.Service
   | ModelsDev.Service
   | Npm.Service
+  | PermissionV2.Service
+  | PluginRuntime.Service
   | Reference.Service
+  | Shell.Service
   | SkillV2.Service
+  | Tools.Service
 
 export interface Plugin<R = never> {
   readonly id: string
@@ -78,8 +91,13 @@ const layer = Layer.effectDiscard(
     const filesystem = yield* FileSystem.Service
     const global = yield* Global.Service
     const http = yield* HttpClient.HttpClient
+    const mutation = yield* LocationMutation.Service
+    const permission = yield* PermissionV2.Service
     const skill = yield* SkillV2.Service
     const reference = yield* Reference.Service
+    const shell = yield* Shell.Service
+    const tools = yield* Tools.Service
+    const runtime = yield* PluginRuntime.Service
     const add = <R>(input: Plugin<R>) => {
       const loaded = {
         id: input.id,
@@ -100,8 +118,13 @@ const layer = Layer.effectDiscard(
               Effect.provideService(FileSystem.Service, filesystem),
               Effect.provideService(Global.Service, global),
               Effect.provideService(HttpClient.HttpClient, http),
+              Effect.provideService(LocationMutation.Service, mutation),
+              Effect.provideService(PermissionV2.Service, permission),
               Effect.provideService(SkillV2.Service, skill),
               Effect.provideService(Reference.Service, reference),
+              Effect.provideService(Shell.Service, shell),
+              Effect.provideService(Tools.Service, tools),
+              Effect.provideService(PluginRuntime.Service, runtime),
             ),
       }
       return plugin.add(PluginV2.ID.make(loaded.id), loaded.effect)
@@ -115,6 +138,8 @@ const layer = Layer.effectDiscard(
         yield* add(SkillPlugin.Plugin)
         yield* add(ModelsDevPlugin)
         yield* add(ConfigExternalPlugin.Plugin)
+        yield* add(ShellTool.Plugin)
+        yield* add(SubagentTool.Plugin)
         yield* add(ConfigAgentPlugin.Plugin)
         yield* add(ConfigCommandPlugin.Plugin)
         yield* add(ConfigSkillPlugin.Plugin)
@@ -146,6 +171,7 @@ export const node = makeLocationNode({
     AgentV2.node,
     Config.node,
     Location.node,
+    LocationMutation.node,
     ModelsDev.node,
     Npm.node,
     EventV2.node,
@@ -153,8 +179,12 @@ export const node = makeLocationNode({
     FileSystem.node,
     Global.node,
     httpClient,
+    PermissionV2.node,
     SkillV2.node,
     Reference.node,
+    Shell.node,
+    ToolRegistry.toolsNode,
+    PluginRuntime.node,
     SdkPlugins.node,
   ],
 })

packages/core/src/plugin/runtime.ts

@@ -0,0 +1,117 @@
+export * as PluginRuntime from "./runtime"
+
+import { Context, Effect, Layer } from "effect"
+import { AgentV2 } from "../agent"
+import { makeGlobalNode } from "../effect/app-node"
+import { Job } from "../job"
+import { Location } from "../location"
+import { LocationServiceMap } from "../location-service-map"
+import { SessionV2 } from "../session"
+
+export interface Interface {
+  readonly session: Pick<
+    SessionV2.Interface,
+    "get" | "create" | "messages" | "prompt" | "resume" | "interrupt" | "synthetic"
+  >
+  readonly job: Pick<Job.Interface, "start" | "wait" | "block" | "background" | "cancel">
+  readonly location: {
+    readonly agent: {
+      readonly list: (
+        ref: Location.Ref,
+      ) => Effect.Effect<{ readonly location: Location.Info; readonly data: AgentV2.Info[] }>
+    }
+  }
+}
+
+export class Service extends Context.Service<Service, Interface>()("@opencode/PluginRuntime") {}
+
+export interface Cell {
+  runtime?: Interface
+}
+
+export const makeCell = (): Cell => ({})
+
+const unavailable = <A, E, R>() => Effect.die("Plugin runtime is unavailable") as Effect.Effect<A, E, R>
+const require = <A, E, R>(cell: Cell, f: (runtime: Interface) => Effect.Effect<A, E, R>) =>
+  Effect.suspend(() => {
+    const runtime = cell.runtime
+    if (runtime === undefined) return unavailable<A, E, R>()
+    return f(runtime)
+  })
+
+const defaultCell = makeCell()
+
+export const layerWithCell = (cell: Cell) =>
+  Layer.succeed(
+    Service,
+    Service.of({
+      session: {
+        get: (sessionID) => require(cell, (runtime) => runtime.session.get(sessionID)),
+        create: (input) => require(cell, (runtime) => runtime.session.create(input)),
+        messages: (input) => require(cell, (runtime) => runtime.session.messages(input)),
+        prompt: (input) => require(cell, (runtime) => runtime.session.prompt(input)),
+        resume: (sessionID) => require(cell, (runtime) => runtime.session.resume(sessionID)),
+        interrupt: (sessionID) => require(cell, (runtime) => runtime.session.interrupt(sessionID)),
+        synthetic: (input) => require(cell, (runtime) => runtime.session.synthetic(input)),
+      },
+      job: {
+        start: (input) => require(cell, (runtime) => runtime.job.start(input)),
+        wait: (input) => require(cell, (runtime) => runtime.job.wait(input)),
+        block: (input) => require(cell, (runtime) => runtime.job.block(input)),
+        background: (id) => require(cell, (runtime) => runtime.job.background(id)),
+        cancel: (id) => require(cell, (runtime) => runtime.job.cancel(id)),
+      },
+      location: {
+        agent: {
+          list: (ref) => require(cell, (runtime) => runtime.location.agent.list(ref)),
+        },
+      },
+    }),
+  )
+
+export const providerLayerWithCell = (cell: Cell) =>
+  Layer.effectDiscard(
+    Effect.gen(function* () {
+      const sessions = yield* SessionV2.Service
+      const jobs = yield* Job.Service
+      const locations = yield* LocationServiceMap.Service
+      const runtime = {
+        session: sessions,
+        job: jobs,
+        location: {
+          agent: {
+            list: (ref) =>
+              Effect.gen(function* () {
+                const location = yield* Location.Service
+                const agents = yield* AgentV2.Service
+                return {
+                  location: new Location.Info({
+                    directory: location.directory,
+                    workspaceID: location.workspaceID,
+                    project: location.project,
+                  }),
+                  data: yield* agents.list(),
+                }
+              }).pipe(Effect.provide(locations.get(ref))),
+          },
+        },
+      } satisfies Interface
+      cell.runtime = runtime
+      yield* Effect.addFinalizer(() =>
+        Effect.sync(() => {
+          if (cell.runtime === runtime) cell.runtime = undefined
+        }),
+      )
+    }),
+  )
+
+export const layer = layerWithCell(defaultCell)
+export const providerLayer = providerLayerWithCell(defaultCell)
+
+export const node = makeGlobalNode({ service: Service, layer, deps: [] })
+
+export const providerNode = makeGlobalNode({
+  name: "plugin-runtime-provider",
+  layer: providerLayer,
+  deps: [node, SessionV2.node, Job.node, LocationServiceMap.node],
+})

packages/core/src/plugin/sdk.ts

@@ -4,6 +4,14 @@ import type { Plugin } from "@opencode-ai/plugin/v2/effect"
 import { Context, Effect, Layer } from "effect"
 import { makeGlobalNode } from "../effect/app-node"
 
+export interface Store {
+  readonly plugins: Map<string, Plugin>
+}
+
+export const makeStore = (): Store => ({ plugins: new Map() })
+
+const defaultStore = makeStore()
+
 /**
  * Holds the plugins an embedder (the `@opencode-ai/sdk-next` host) contributes,
  * so `PluginInternal` can add them on every Location boot through the ordinary
@@ -12,9 +20,10 @@ import { makeGlobalNode } from "../effect/app-node"
  * applies to Locations booted afterward, matching config-plugin timing;
  * embedders register at startup before creating Sessions.
  *
- * State lives in this global-node service (like `ApplicationTools`) rather than
- * module scope, so the list belongs to one embedded instance and is disposed
- * with it instead of leaking across `OpenCode.create` calls.
+ * The store is shared explicitly between the SDK construction graph and the
+ * embedded route graph because `LocationServiceMap` builds Location layers lazily
+ * in a nested graph. Each embedded SDK creates its own store, so instances do not
+ * see each other's contributions.
  */
 export interface Interface {
   readonly register: (plugin: Plugin) => Effect.Effect<void>
@@ -23,15 +32,25 @@ export interface Interface {
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/SdkPlugins") {}
 
-export const layer = Layer.effect(
-  Service,
-  Effect.sync(() => {
-    const plugins: Plugin[] = []
-    return Service.of({
-      register: (plugin) => Effect.sync(() => void plugins.push(plugin)),
-      all: () => plugins,
-    })
-  }),
-)
+export const layerWithStore = (store: Store) =>
+  Layer.effect(
+    Service,
+    Effect.gen(function* () {
+      yield* Effect.addFinalizer(() =>
+        Effect.sync(() => {
+          store.plugins.clear()
+        }),
+      )
+      return Service.of({
+        register: (plugin) =>
+          Effect.sync(() => {
+            store.plugins.set(plugin.id, plugin)
+          }),
+        all: () => [...store.plugins.values()],
+      })
+    }),
+  )
+
+export const layer = layerWithStore(defaultStore)
 
 export const node = makeGlobalNode({ service: Service, layer, deps: [] })