feat: experimental codemode (#34677)

packages/opencode/src/mcp/index.ts

@@ -159,6 +159,12 @@ export interface Interface {
   readonly clients: () => Effect.Effect<Record<string, MCPClient>>
   readonly instructions: () => Effect.Effect<ServerInstructions[]>
   readonly tools: () => Effect.Effect<Record<string, Tool>>
+  /**
+   * Raw MCP tool definitions keyed identically to {@link tools} (`toolName(client, name)`).
+   * Unlike {@link tools}, these retain the original `inputSchema`/`outputSchema`, which code
+   * mode uses to render tool signatures (including return types) to the model.
+   */
+  readonly defs: () => Effect.Effect<Record<string, MCPToolDef>>
   readonly prompts: () => Effect.Effect<Record<string, PromptInfo & { client: string }>>
   readonly resources: (clientName?: string) => Effect.Effect<Record<string, ResourceInfo & { client: string }>>
   readonly resourceTemplates: (
@@ -680,6 +686,18 @@ const layer = Layer.effect(
       return result
     })
 
+    const defs = Effect.fn("MCP.defs")(function* () {
+      const result: Record<string, MCPToolDef> = {}
+      const s = yield* InstanceState.get(state)
+      for (const [clientName, listed] of Object.entries(s.defs)) {
+        if (s.status[clientName]?.status !== "connected") continue
+        for (const mcpTool of listed) {
+          result[McpCatalog.toolName(clientName, mcpTool.name)] = mcpTool
+        }
+      }
+      return result
+    })
+
     function collectFromConnected<T extends { name: string }>(
       s: State,
       listFn: (c: Client, timeout?: number) => Promise<T[]>,
@@ -982,6 +1000,7 @@ const layer = Layer.effect(
       clients,
       instructions,
       tools,
+      defs,
       prompts,
       resources,
       resourceTemplates,

packages/opencode/src/mcp/invoke.ts

@@ -0,0 +1,65 @@
+import type { ToolExecutionOptions } from "ai"
+import { Effect } from "effect"
+import type { Plugin } from "@/plugin"
+import type { Tool } from "@/tool/tool"
+
+/**
+ * The shared middle of every raw MCP tool invocation: plugin `tool.execute.before`
+ * hook → permission ask → dispatch through the ai-sdk tool's execute inside the
+ * `Tool.execute` tracing span → plugin `tool.execute.after` hook. Used by both the
+ * legacy per-tool registration in `SessionTools.resolve` and code-mode child calls,
+ * so MCP tools execute identically on either path.
+ *
+ * Returns the RAW result the ai-sdk execute resolved with — callers own their
+ * shaping edge (model-facing text/attachment shaping + truncation on the legacy
+ * path, `toSandboxResult` for code-mode child calls). The after hook fires here
+ * with that same raw result, which is exactly what the legacy loop always passed
+ * (the raw MCP result, not the shaped `{title, output, metadata}`), so the hook
+ * payload cannot drift between callers.
+ *
+ * `callID` is the hook/span identity — an opaque string nothing parses. Legacy
+ * passes the ai-sdk `toolCallId`; code-mode child calls pass a synthetic
+ * `${parentCallID}/${n}`. `options.toolCallId` is what the ai-sdk execute sees and
+ * stays each caller's existing value. Failure semantics belong to the caller: hook
+ * failures, permission denials, and tool failures all propagate — the legacy path
+ * lets them fail the tool call as before; code mode converts them into catchable
+ * in-program tool errors at its edge.
+ */
+export const invoke = Effect.fn("McpInvoke.invoke")(function* <R>(input: {
+  plugin: Plugin.Interface
+  key: string
+  execute: (args: any, options: ToolExecutionOptions) => R | PromiseLike<R>
+  args: any
+  callID: string
+  options: ToolExecutionOptions
+  sessionID: string
+  messageID: string
+  ask: Tool.Context["ask"]
+}) {
+  yield* input.plugin.trigger(
+    "tool.execute.before",
+    { tool: input.key, sessionID: input.sessionID, callID: input.callID },
+    { args: input.args },
+  )
+  const result: R = yield* Effect.gen(function* () {
+    yield* input.ask({ permission: input.key, metadata: {}, patterns: ["*"], always: ["*"] })
+    return yield* Effect.promise(() => Promise.resolve(input.execute(input.args, input.options)))
+  }).pipe(
+    Effect.withSpan("Tool.execute", {
+      attributes: {
+        "tool.name": input.key,
+        "tool.call_id": input.callID,
+        "session.id": input.sessionID,
+        "message.id": input.messageID,
+      },
+    }),
+  )
+  yield* input.plugin.trigger(
+    "tool.execute.after",
+    { tool: input.key, sessionID: input.sessionID, callID: input.callID, args: input.args },
+    result,
+  )
+  return result
+})
+
+export * as McpInvoke from "./invoke"