diff --git a/packages/core/perf/location.ts b/packages/core/perf/location.ts
index f2c0f01092d..0606a947119 100644
--- a/packages/core/perf/location.ts
+++ b/packages/core/perf/location.ts
@@ -7,9 +7,9 @@ import { rmSync } from "fs"
import os from "os"
import path from "path"
import { Effect, Layer, Logger, ManagedRuntime, Scope } from "effect"
-import { FetchHttpClient } from "effect/http"
import { Global } from "@opencode/util/global"
import { LayerNode } from "@opencode/util/effect/layer-node"
+import { LayerNodePlatform } from "@opencode/util/effect/app-node-platform"
import { AppNodeBuilder } from "../src/effect/app-node-builder"
import { Bus } from "../src/bus"
import { Database } from "../src/database/database"
@@ -30,7 +30,12 @@ import { providerHost, host, integrationHost } from "../test/plugin/host"
const root = await fs.realpath(await fs.mkdtemp(path.join(os.tmpdir(), "opencode-location-bench-")))
process.on("exit", () => rmSync(root, { recursive: true, force: true }))
+const offline = Object.assign(() => Promise.reject(new Error("no network in the location benchmark")), {
+ preconnect: () => {},
+})
+
const replacements = [
+ LayerNodePlatform.httpFetch.replace(LayerNodePlatform.fetchLayer(offline)),
Global.node.replace(
Global.layerWith({
home: path.join(root, "home"),
@@ -55,12 +60,8 @@ const runtime = ManagedRuntime.make(
).pipe(Layer.provide(Logger.layer([]))),
)
-const offline = Object.assign(() => Promise.reject(new Error("no network in the location benchmark")), {
- preconnect: () => {},
-})
-
const run = (effect: Effect.Effect) =>
- runtime.runPromise(effect.pipe(Effect.provideService(FetchHttpClient.Fetch, offline)))
+ runtime.runPromise(effect)
// The variant's own checkout: a real project with its config, git and instructions.
const ref = Location.Ref.make({ directory: AbsolutePath.make(process.cwd()) })
diff --git a/packages/core/src/aisdk.ts b/packages/core/src/aisdk.ts
index eb3d2785fc9..f63cda0e2ce 100644
--- a/packages/core/src/aisdk.ts
+++ b/packages/core/src/aisdk.ts
@@ -1,6 +1,7 @@
export * as AISDK from "./aisdk.js"
import { makeLocationNode } from "@opencode/util/effect/app-node"
+import { httpFetch } from "@opencode/util/effect/app-node-platform"
import { APICallError } from "@ai-sdk/provider"
import type {
JSONSchema7,
@@ -35,7 +36,7 @@ import { Auth, Endpoint, ProviderShared, RequestExecutor, type AnyRoute, type Ht
import { isRecord } from "@opencode/util/record"
import { Cause, Context, Effect, Layer, Option, Schema, Scope, Stream, Struct } from "effect"
import { makeParser } from "effect/encoding/Sse"
-import { HttpClientRequest, HttpClientResponse } from "effect/http"
+import { FetchHttpClient, HttpClientRequest, HttpClientResponse } from "effect/http"
import { AsyncLocalStorage } from "node:async_hooks"
import type { ID, RuntimeInfo } from "./model.js"
import { Provider } from "./provider.js"
@@ -120,7 +121,8 @@ function wrapSSE(res: Response, ms: number, ctl: AbortController) {
})
}
-function prepareOptions(model: RuntimeInfo, pkg: string) {
+// `outbound` sends requests for providers whose settings name no `fetch` of their own.
+function prepareOptions(model: RuntimeInfo, pkg: string, outbound: Fetch) {
const projected = mapBodyToProviderOptions(model, pkg)
const settings = model.settings ?? {}
const options: Record = {
@@ -158,7 +160,7 @@ function prepareOptions(model: RuntimeInfo, pkg: string) {
}
}
- const send: Fetch = isFetch(customFetch) ? customFetch : fetch
+ const send: Fetch = isFetch(customFetch) ? customFetch : outbound
const middleware = httpMiddleware.getStore()
const res = await (
middleware
@@ -255,6 +257,7 @@ export class Service extends Context.Service()("@opencode/AI
export const locationLayer = Layer.effect(
Service,
Effect.gen(function* () {
+ const outbound = yield* FetchHttpClient.Fetch
let sdkHooks: ((event: SDKEvent) => Effect.Effect | void)[] = []
let languageHooks: ((event: LanguageEvent) => Effect.Effect | void)[] = []
const languages = new Map()
@@ -333,7 +336,7 @@ export const locationLayer = Layer.effect(
})
const packageName = Provider.packageName(model.package)
- const options = prepareOptions(model, packageName)
+ const options = prepareOptions(model, packageName, outbound)
const sdkKey = cacheKey({
providerID: model.providerID,
canonical: model.canonical,
@@ -1042,4 +1045,4 @@ function providerErrorMessage(error: APICallError) {
return error.message.trim() !== "" ? error.message : (message ?? (code === undefined ? prefix : `${prefix}: ${code}`))
}
-export const node = makeLocationNode({ service: Service, layer: locationLayer, deps: [] })
+export const node = makeLocationNode({ service: Service, layer: locationLayer, deps: [httpFetch] })
diff --git a/packages/core/src/mcp/connection.ts b/packages/core/src/mcp/connection.ts
index 90a44167691..bfbd9df7fea 100644
--- a/packages/core/src/mcp/connection.ts
+++ b/packages/core/src/mcp/connection.ts
@@ -3,6 +3,7 @@ export * as McpConnection from "./connection.js"
import type { OAuthClientProvider } from "@modelcontextprotocol/client"
import type { Mcp } from "@opencode/schema/mcp"
import { Cause, Effect, Exit, Scope } from "effect"
+import { FetchHttpClient } from "effect/http"
import { Environment } from "../environment/index.js"
import type { McpClient } from "./client.js"
@@ -39,6 +40,8 @@ export interface Input {
readonly elicitation: McpClient.ElicitationHandler
/** A stdio server is spawned on this execution plane. */
readonly environment: Environment.Interface
+ /** A remote server is reached with this fetch. */
+ readonly fetch: typeof globalThis.fetch
/** Each attempt's scope is forked from this one. */
readonly scope: Scope.Scope
/** Serializes lifecycle work. Callbacks and recovery take it; `start` and `stop` expect the caller to hold it. */
@@ -165,6 +168,7 @@ export function make(input: Input): Connection {
).pipe(
Effect.flatMap((client) => client.tools().pipe(Effect.map((tools) => ({ client, tools })))),
Effect.provideService(Environment.Service, input.environment),
+ Effect.provideService(FetchHttpClient.Fetch, input.fetch),
Scope.provide(scope),
input.handshake,
Effect.exit,
diff --git a/packages/core/src/mcp/index.ts b/packages/core/src/mcp/index.ts
index 43a4223c649..06599b167de 100644
--- a/packages/core/src/mcp/index.ts
+++ b/packages/core/src/mcp/index.ts
@@ -8,7 +8,9 @@ import type { Transport } from "@modelcontextprotocol/client"
import { createHash } from "node:crypto"
import { isDeepStrictEqual } from "node:util"
import { Clock, Context, Effect, Exit, FiberSet, Latch, Layer, Schema, Scope, Semaphore, Stream, Types } from "effect"
+import { FetchHttpClient } from "effect/http"
import { makeLocationNode } from "@opencode/util/effect/app-node"
+import { httpFetch } from "@opencode/util/effect/app-node-platform"
import { Credential } from "../credential.js"
import { Bus } from "../bus.js"
import { Environment } from "../environment/index.js"
@@ -189,6 +191,7 @@ export const layer = (options?: Options) =>
const forms = yield* Form.Service
const integration = yield* Integration.Service
const credentials = yield* Credential.Service
+ const fetch = yield* FetchHttpClient.Fetch
const root = yield* Effect.scope
const fork = yield* FiberSet.makeRuntime()
// Server scopes close in parallel on shutdown, so one slow server's stop grace does not delay
@@ -245,6 +248,7 @@ export const layer = (options?: Options) =>
const { McpOAuth } = yield* Effect.promise(() => import("./oauth.js"))
return yield* McpOAuth.authorize({ name, config: remote, integrationID, methodID }).pipe(
Effect.provideService(Credential.Service, credentials),
+ Effect.provideService(FetchHttpClient.Fetch, fetch),
)
}),
})
@@ -267,6 +271,7 @@ export const layer = (options?: Options) =>
const { McpOAuth } = yield* Effect.promise(() => import("./oauth.js"))
return yield* McpOAuth.connectProvider({ config: entry.config, integrationID: entry.integrationID }).pipe(
Effect.provideService(Credential.Service, credentials),
+ Effect.provideService(FetchHttpClient.Fetch, fetch),
)
})
@@ -357,6 +362,7 @@ export const layer = (options?: Options) =>
authProvider: Effect.suspend(() => connectProvider(entry)),
elicitation,
environment,
+ fetch,
scope: servers,
lock: locks.withLock(name),
handshake: (effect) => (config.type === "remote" ? endpointLoads.withLock(config.url)(effect) : effect),
@@ -856,7 +862,7 @@ export function configured(options?: Options) {
return makeLocationNode({
service: Service,
layer: layer(options),
- deps: [Location.node, Environment.node, Bus.node, Form.node, Integration.node, Credential.node],
+ deps: [Location.node, Environment.node, Bus.node, Form.node, Integration.node, Credential.node, httpFetch],
})
}
diff --git a/packages/core/src/mcp/oauth.ts b/packages/core/src/mcp/oauth.ts
index f28cc0f0f41..c2cac9717a2 100644
--- a/packages/core/src/mcp/oauth.ts
+++ b/packages/core/src/mcp/oauth.ts
@@ -17,10 +17,10 @@ import {
} from "@modelcontextprotocol/client"
import { OAuthMetadataSchema, OpenIdProviderDiscoveryMetadataSchema } from "@modelcontextprotocol/core"
import { Cause, Deferred, Effect } from "effect"
+import { FetchHttpClient } from "effect/http"
import type { ServerResponse } from "node:http"
import type { AddressInfo } from "node:net"
import { ConfigMCP } from "@opencode/schema/config/mcp"
-import { noTimeoutFetch } from "@opencode/util/no-timeout-fetch"
import { Credential } from "../credential.js"
import { OauthCallbackPage } from "../oauth/page.js"
import type { Integration } from "../integration.js"
@@ -40,24 +40,30 @@ const refreshKey = (url: string | URL, init: RequestInit | undefined) => {
// Bun's and Node's fetch types both apply here and the SDK's FetchLike wants Bun's Response, so the
// overload is picked by annotation and clone() is pinned to the type it was called on. A tool call
// can stay silent for minutes, so Bun's idle deadline is off; the MCP execution timeout still applies.
-const base: FetchLike = noTimeoutFetch
const share = (pending: ReturnType) => pending.then((response) => response.clone() as typeof response)
-const send: FetchLike = (url, init) => {
- const key = refreshKey(url, init)
- if (key === undefined) return base(url, init)
- const current = refreshes.get(key)
- if (current) return share(current)
- const pending = base(url, init).finally(() => {
- if (refreshes.get(key) === pending) refreshes.delete(key)
- })
- refreshes.set(key, pending)
- return share(pending)
-}
+// Requests use `FetchHttpClient.Fetch`, which an embedder can replace, rather than the global fetch.
+const sender = Effect.gen(function* () {
+ const fetch = yield* FetchHttpClient.Fetch
+ const base: FetchLike = (url, init) => fetch(url, { ...init, timeout: false } as BunFetchRequestInit)
+ const send: FetchLike = (url, init) => {
+ const key = refreshKey(url, init)
+ if (key === undefined) return base(url, init)
+ const current = refreshes.get(key)
+ if (current) return share(current)
+ const pending = base(url, init).finally(() => {
+ if (refreshes.get(key) === pending) refreshes.delete(key)
+ })
+ refreshes.set(key, pending)
+ return share(pending)
+ }
+ return send
+})
export const loggedFetch = (fields: { readonly server: string; readonly directory?: string }) =>
Effect.gen(function* () {
const run = Effect.runPromiseWith(yield* Effect.context())
+ const send = yield* sender
const request: FetchLike = (url, init) => {
const grant = init?.body instanceof URLSearchParams ? init.body.get("grant_type") : undefined
const operation = grant === "refresh_token" ? "refresh" : grant === "authorization_code" ? "exchange" : undefined
@@ -136,6 +142,7 @@ interface Store {
interface Options {
readonly config: typeof ConfigMCP.Remote.Type
readonly store: Store
+ readonly fetch: FetchLike
/** Absent on connect: the provider then refuses to register a client or redirect, ending in needs_auth. */
readonly redirect?: {
readonly url: string
@@ -160,7 +167,7 @@ const provider = (options: Options): OAuthClientProvider => {
return {
redirectUrl,
discoveryState: async () => {
- discovery ??= await configuredDiscovery({ config: options.config, fetchFn: send })
+ discovery ??= await configuredDiscovery({ config: options.config, fetchFn: options.fetch })
return discovery
},
saveDiscoveryState: (state) => {
@@ -203,7 +210,9 @@ const provider = (options: Options): OAuthClientProvider => {
redirectToAuthorization: (url) => {
if (!redirect) throw refuse("user authorization")
if (url.protocol !== "http:" && url.protocol !== "https:")
- throw new Error(`MCP server "${options.config.url}" returned a ${url.protocol} authorization URL; only http and https are supported`)
+ throw new Error(
+ `MCP server "${options.config.url}" returned a ${url.protocol} authorization URL; only http and https are supported`,
+ )
return redirect.open(url)
},
...(options.invalidate ? { invalidateCredentials: options.invalidate } : {}),
@@ -279,8 +288,9 @@ export const connectProvider = Effect.fnUntraced(function* (input: {
}) {
const credentials = yield* Credential.Service
const run = Effect.runPromiseWith(yield* Effect.context())
+ const fetch = yield* sender
const found = (yield* credentials.list(input.integrationID)).at(-1)
- if (!found || found.value.type !== "oauth") return provider({ config: input.config, store: memoryStore() })
+ if (!found || found.value.type !== "oauth") return provider({ config: input.config, store: memoryStore(), fetch })
const id = found.id
const methodID = found.value.methodID
const read = async () => {
@@ -291,6 +301,7 @@ export const connectProvider = Effect.fnUntraced(function* (input: {
let presented = found.value.refresh
return provider({
config: input.config,
+ fetch,
invalidate: async (scope) => {
if (scope === "verifier" || scope === "discovery") return
const oauth = await read()
@@ -389,7 +400,9 @@ export const authorize = (input: {
if (!value) return fail("Missing authorization code", "missing_code")
// The page waits for the token exchange so the browser never reports success for a rejected code.
if (
- !Effect.runSync(Deferred.succeed(code, { code: value, iss: url.searchParams.get("iss") ?? undefined, response }))
+ !Effect.runSync(
+ Deferred.succeed(code, { code: value, iss: url.searchParams.get("iss") ?? undefined, response }),
+ )
)
response.writeHead(409).end("OAuth callback already received")
})
@@ -450,6 +463,7 @@ export const authorize = (input: {
const oauthProvider = provider({
config: input.config,
store,
+ fetch: fetchFn,
clientMetadataUrl: cimd ? CLIENT_METADATA_URL : undefined,
discovery: { ...discovery, resourceMetadataUrl: resourceMetadataUrl?.toString() },
redirect: {
diff --git a/packages/core/src/plugin/internal.ts b/packages/core/src/plugin/internal.ts
index 074e239a940..8ebed690b10 100644
--- a/packages/core/src/plugin/internal.ts
+++ b/packages/core/src/plugin/internal.ts
@@ -4,10 +4,10 @@ import { LLMClient } from "@opencode/ai/effect"
import type { Plugin } from "@opencode/plugin/effect/plugin"
import { LayerNode } from "@opencode/util/effect/layer-node"
import type { Generation } from "./service.js"
-import { httpClient } from "@opencode/util/effect/app-node-platform"
+import { httpClient, httpFetch } from "@opencode/util/effect/app-node-platform"
import { AppProcess } from "@opencode/util/process"
import { Context, Effect, Scope } from "effect"
-import { HttpClient } from "effect/http"
+import { FetchHttpClient, HttpClient } from "effect/http"
import { Agent } from "../agent.js"
import { Artifact } from "../artifact.js"
import { Model } from "../model.js"
@@ -118,6 +118,7 @@ import { WellKnownPlugin } from "../wellknown/plugin.js"
const services = [
Agent.Service,
+ FetchHttpClient.Fetch,
Artifact.Service,
AppProcess.Service,
Provider.Service,
@@ -195,6 +196,7 @@ export const requirements = LayerNode.group([
FSUtil.node,
Global.node,
httpClient,
+ httpFetch,
Image.node,
InstructionDiscovery.node,
Integration.node,
diff --git a/packages/core/src/plugin/provider/github-copilot.ts b/packages/core/src/plugin/provider/github-copilot.ts
index 439a7399cec..7663c1ebae2 100644
--- a/packages/core/src/plugin/provider/github-copilot.ts
+++ b/packages/core/src/plugin/provider/github-copilot.ts
@@ -2,7 +2,7 @@ import type { IntegrationOAuthMethodRegistration } from "@opencode/plugin/effect
import type { SessionRequestKind, SessionTitle } from "@opencode/plugin/effect/session"
import { isRecord } from "@opencode/util/record"
import { Effect, Option, Schema } from "effect"
-import { HttpClient } from "effect/http"
+import { FetchHttpClient, HttpClient } from "effect/http"
import { IntegrationConnection } from "../../integration/connection.js"
import { Credential } from "../../credential.js"
import { CopilotModels } from "../../github-copilot/models.js"
@@ -166,6 +166,7 @@ export const GithubCopilotPlugin = define({
const providers = yield* Provider.Service
const cache = yield* SharedCache.Service
const http = yield* HttpClient.HttpClient
+ const outbound = yield* FetchHttpClient.Fetch
const discovered = yield* ProviderRefresh.start({
integrationID: "github-copilot",
initial: {} as {
@@ -293,7 +294,7 @@ export const GithubCopilotPlugin = define({
const model = utilityTitleModels.find((id) => loaded.models?.has(id))
if (!model) return
evt.result = yield* utilityTitle(
- { baseURL: loaded.baseURL, token: loaded.token, model, app: ctx.app },
+ { baseURL: loaded.baseURL, token: loaded.token, model, app: ctx.app, fetch: outbound },
evt,
).pipe(
Effect.tapError((cause) => Effect.logDebug("Copilot utility title failed", { model, cause })),
diff --git a/packages/core/test/aisdk.test.ts b/packages/core/test/aisdk.test.ts
index 6667f5b6e7f..657f6025cb6 100644
--- a/packages/core/test/aisdk.test.ts
+++ b/packages/core/test/aisdk.test.ts
@@ -26,6 +26,8 @@ import { compileRequest } from "@opencode/ai/testing"
import { expect } from "bun:test"
import { Effect, Layer } from "effect"
import { HttpClientRequest, HttpClientResponse } from "effect/http"
+import { AppNodeBuilder } from "@opencode/core/effect/app-node-builder"
+import { LayerNodePlatform } from "@opencode/util/effect/app-node-platform"
import { testEffect } from "./lib/effect"
const it = testEffect(AISDK.locationLayer)
@@ -566,11 +568,19 @@ it.effect("normalizes file data across AI SDK prompt parts", () =>
Message.user([
{ type: "media", media: Media.bytes(bytes, "image/png"), filename: "bytes.png" },
{ type: "media", media: Media.base64("AAAA", "image/png"), filename: "base64.png" },
- { type: "media", media: Media.fromDataUrl("data:image/png;charset=utf-8;base64,AQID"), filename: "inline.png" },
+ {
+ type: "media",
+ media: Media.fromDataUrl("data:image/png;charset=utf-8;base64,AQID"),
+ filename: "inline.png",
+ },
{ type: "media", media: Media.url("https://example.com/image.png", { mediaType: "image/png" }) },
{ type: "media", media: Media.base64("s3://bucket/image.png", "image/png") },
]),
- Message.assistant({ type: "media", media: Media.url("http://example.com/document.pdf", { mediaType: "application/pdf" }), filename: "document.pdf" }),
+ Message.assistant({
+ type: "media",
+ media: Media.url("http://example.com/document.pdf", { mediaType: "application/pdf" }),
+ filename: "document.pdf",
+ }),
Message.tool({
id: "call_1",
name: "screenshot",
@@ -713,6 +723,38 @@ const compatibleModel = Effect.fn(function* (customFetch: typeof fetch) {
)
})
+// Not `it`, whose AISDK layer is already built with the harness's fetch and would be reused here.
+testEffect(Layer.empty).effect("sends AI SDK requests through the embedder's fetch when the provider names none", () =>
+ Effect.gen(function* () {
+ const sent: string[] = []
+ const embedder = async (input: Request | string | URL) => {
+ sent.push(input instanceof Request ? input.url : String(input))
+ return new Response(chatChunk("embedded"), { headers: { "content-type": "text/event-stream" } })
+ }
+ const response = yield* Effect.gen(function* () {
+ const aisdk = yield* AISDK.Service
+ yield* aisdk.hook.sdk((event) => {
+ event.sdk = createOpenAICompatible({
+ ...event.options,
+ name: String(event.options.name),
+ baseURL: String(event.options.baseURL),
+ })
+ })
+ const resolved = yield* aisdk.model(
+ model("@ai-sdk/openai-compatible", { apiKey: "test", baseURL: "https://example.test/v1" }),
+ )
+ return yield* LLMClient.generate(ai.request({ model: resolved, prompt: "Hello" })).pipe(Effect.provide(client))
+ }).pipe(
+ Effect.provide(
+ AppNodeBuilder.build(AISDK.node, [LayerNodePlatform.httpFetch.replace(LayerNodePlatform.fetchLayer(embedder))]),
+ ),
+ )
+
+ expect(sent).toEqual(["https://example.test/v1/chat/completions"])
+ expect(response.text).toBe("embedded")
+ }),
+)
+
it.effect("routes AI SDK requests and responses through HTTP hook middleware", () =>
Effect.gen(function* () {
const sent: Array<{ url: string; headers: Headers; body: string }> = []
@@ -753,12 +795,7 @@ it.effect("routes AI SDK requests and responses through HTTP hook middleware", (
expect(sent[0]?.headers.get("x-hook")).toBe("applied")
expect(sent[0]?.headers.get("authorization")).toBe("Bearer test")
expect(JSON.parse(sent[0]?.body ?? "")).toMatchObject({ model: "api-model" })
- expect(seen).toEqual([
- "POST https://example.test/v1/chat/completions",
- sent[0]?.body,
- sent[0]?.body,
- "status 200",
- ])
+ expect(seen).toEqual(["POST https://example.test/v1/chat/completions", sent[0]?.body, sent[0]?.body, "status 200"])
expect(response.events.filter(LLMEvent.is.textDelta).map((event) => event.text)).toEqual(["rewritten"])
}),
)
diff --git a/packages/core/test/fixture/mcp-echo.ts b/packages/core/test/fixture/mcp-echo.ts
new file mode 100644
index 00000000000..c90bcb01b7b
--- /dev/null
+++ b/packages/core/test/fixture/mcp-echo.ts
@@ -0,0 +1,14 @@
+import { createMcpHandler, Server } from "@modelcontextprotocol/server"
+
+/** A web-standard MCP server with one `echo` tool, for tests that route MCP HTTP through their own fetch. */
+export const echoMcpHandler = () =>
+ createMcpHandler(() => {
+ const protocol = new Server({ name: "echo", version: "1.0.0" }, { capabilities: { tools: {} } })
+ protocol.setRequestHandler("tools/list", () =>
+ Promise.resolve({ tools: [{ name: "echo", inputSchema: { type: "object" as const, properties: {} } }] }),
+ )
+ protocol.setRequestHandler("tools/call", (request) =>
+ Promise.resolve({ content: [{ type: "text" as const, text: `called ${request.params.name}` }] }),
+ )
+ return protocol
+ })
diff --git a/packages/core/test/lib/effect.ts b/packages/core/test/lib/effect.ts
index 8d67db19f5e..371091a1ace 100644
--- a/packages/core/test/lib/effect.ts
+++ b/packages/core/test/lib/effect.ts
@@ -10,10 +10,10 @@ const body = (value: Body) => Effect.suspend(() => (typeof val
const loopback = new Set(["127.0.0.1", "localhost", "[::1]"])
// Core is env-free, so nothing tells the default node graph to stay offline;
-// a test that boots it would phone home through FetchHttpClient. Every
-// FetchHttpClient reads this reference at request time, so refusing here covers
-// each node that shares the default client, while an explicit HttpClient
-// replacement never reaches it. Callers such as ModelsDev swallow request
+// a test that boots it would phone home through FetchHttpClient. The default
+// client node captures this reference when the test builds its layer, so
+// refusing here covers each node that shares the default client, while an
+// explicit HttpClient or fetch replacement never reaches it. Callers such as ModelsDev swallow request
// failures, so the harness also records the attempt and fails the test itself.
export const refuseNetwork = (violations: string[]): typeof fetch =>
Object.assign(
diff --git a/packages/core/test/plugin/provider-github-copilot.test.ts b/packages/core/test/plugin/provider-github-copilot.test.ts
index 4fab9e53218..70b2b5c33cb 100644
--- a/packages/core/test/plugin/provider-github-copilot.test.ts
+++ b/packages/core/test/plugin/provider-github-copilot.test.ts
@@ -5,7 +5,7 @@ import { Session } from "@opencode/core/session"
import { Location } from "@opencode/core/location"
import { describe, expect, test } from "bun:test"
import { Effect } from "effect"
-import { HttpClient, HttpClientResponse } from "effect/http"
+import { FetchHttpClient, HttpClient, HttpClientResponse } from "effect/http"
import { TestClock } from "effect/testing"
import { Model } from "@opencode/core/model"
import { ModelResolver } from "@opencode/core/model-resolver"
@@ -348,6 +348,69 @@ describe("GithubCopilotPlugin", () => {
}),
)
+ it.effect("sends the utility title request through the host's fetch", () =>
+ Effect.gen(function* () {
+ const credentials = yield* Credential.Service
+ const providers = yield* Provider.Service
+ const hooks = yield* PluginHooks.Service
+ const http = HttpClient.make((request) =>
+ Effect.succeed(
+ HttpClientResponse.fromWeb(
+ request,
+ Response.json({
+ data: [
+ {
+ model_picker_enabled: true,
+ id: "gpt-4o-mini",
+ name: "GPT-4o mini",
+ version: "gpt-4o-mini",
+ capabilities: {
+ family: "gpt-4o-mini",
+ limits: { max_output_tokens: 1, max_prompt_tokens: 1 },
+ supports: { tool_calls: true },
+ },
+ },
+ ],
+ }),
+ ),
+ ),
+ )
+ const sent: string[] = []
+ const outbound = Object.assign(
+ async (input: Parameters[0]) => {
+ sent.push(String(input))
+ return Response.json({ choices: [{ message: { content: "Faster Python" } }] })
+ },
+ { preconnect: fetch.preconnect },
+ )
+ yield* providers.transform((draft) => {
+ draft.update(Provider.ID.githubCopilot, () => {})
+ })
+ yield* credentials.create({
+ integrationID: Integration.ID.make("github-copilot"),
+ value: Credential.OAuth.make({
+ type: "oauth",
+ methodID: Integration.MethodID.make("device"),
+ access: "token",
+ refresh: "token",
+ expires: 0,
+ }),
+ })
+ yield* addPlugin().pipe(
+ Effect.provideService(HttpClient.HttpClient, http),
+ Effect.provideService(FetchHttpClient.Fetch, outbound),
+ )
+ yield* drain
+
+ const event = yield* hooks.trigger("session", "title", {
+ ...titleRequest,
+ model: Model.Ref.make({ providerID: Provider.ID.githubCopilot, id: Model.ID.make("gpt-5") }),
+ })
+ expect(event.result).toBe("Faster Python")
+ expect(sent).toEqual(["https://api.githubcopilot.com/chat/completions"])
+ }),
+ )
+
it.live("fails the utility title on rate limits so the billable path can run", () =>
Effect.gen(function* () {
const error = yield* utilityTitle(
diff --git a/packages/server/src/options.ts b/packages/server/src/options.ts
index b5b9b8085a0..483406d8bfa 100644
--- a/packages/server/src/options.ts
+++ b/packages/server/src/options.ts
@@ -2,6 +2,7 @@ import { Database } from "@opencode/core/database/database"
import { ModelsDev } from "@opencode/core/models-dev"
import { PersistentPty } from "@opencode/core/persistent-pty"
import { Schema } from "effect"
+import type { LayerNodePlatform } from "@opencode/util/effect/app-node-platform"
export const ServerOptions = Schema.Struct({
app: Schema.optional(
@@ -24,6 +25,12 @@ export const ServerOptions = Schema.Struct({
}),
),
models: Schema.optional(ModelsDev.Options),
+ /**
+ * Replaces `globalThis.fetch` for OpenCode's own HTTP requests: OpenCode Console config, model requests, web fetch
+ * and search, well-known config, and remote MCP servers. Agent code in Code Mode keeps `globalThis.fetch`. For
+ * example, a Cloudflare Worker can route requests through a Service Binding.
+ */
+ fetch: Schema.optional(Schema.declare((input): input is LayerNodePlatform.Fetch => typeof input === "function")),
config: Schema.optional(
Schema.Struct({
directory: Schema.optional(Schema.String),
diff --git a/packages/server/src/routes.ts b/packages/server/src/routes.ts
index 0c065bc2b79..d3533569ba0 100644
--- a/packages/server/src/routes.ts
+++ b/packages/server/src/routes.ts
@@ -3,7 +3,7 @@ import { V1Migration } from "@opencode/core/database/v1-migration"
import { App } from "@opencode/core/app"
import { LayerNode } from "@opencode/util/effect/layer-node"
import { Node } from "@opencode/util/effect/app-node"
-import { httpClient } from "@opencode/util/effect/app-node-platform"
+import { fetchLayer, httpClient, httpFetch } from "@opencode/util/effect/app-node-platform"
import { AppNodeBuilder } from "@opencode/core/effect/app-node-builder"
import { Bus } from "@opencode/core/bus"
import { EventLogger } from "@opencode/core/event-logger"
@@ -127,6 +127,7 @@ function makeRoutes(
Bus.node.replace(Bus.configured({ persist: options.events?.persist })),
App.node.replace(App.configured(options.app)),
ModelsDev.node.replace(ModelsDev.configured(options.models)),
+ httpFetch.replace(fetchLayer(options.fetch)),
Watcher.node.replace(Watcher.configured({ enabled: options.fs?.filewatcher })),
FileWatch.node.replace(FileWatch.configured({ enabled: options.fs?.filewatcher })),
FileSystemSearch.node.replace(FileSystemSearch.configured({ fff: options.fs?.fff })),
diff --git a/packages/server/src/workerd.ts b/packages/server/src/workerd.ts
index db72fdb1ab2..258650a4be8 100644
--- a/packages/server/src/workerd.ts
+++ b/packages/server/src/workerd.ts
@@ -46,6 +46,8 @@ export interface Options {
readonly config?: { readonly content?: string }
/** models.dev catalog options; the bundled snapshot is the boot-time floor either way. */
readonly models?: ServerOptions["models"]
+ /** Replaces `globalThis.fetch` for OpenCode's own HTTP requests, e.g. to route them through a Service Binding. */
+ readonly fetch?: ServerOptions["fetch"]
}
/**
@@ -71,6 +73,7 @@ export function serverOptions(options: Options): ServerOptions {
events: { persist: true },
config: { content: options.config?.content },
models: options.models,
+ fetch: options.fetch,
}
}
diff --git a/packages/server/test/fetch-option.test.ts b/packages/server/test/fetch-option.test.ts
new file mode 100644
index 00000000000..03b07403699
--- /dev/null
+++ b/packages/server/test/fetch-option.test.ts
@@ -0,0 +1,104 @@
+import { expect } from "bun:test"
+import { Location } from "@opencode/core/location"
+import { LocationServiceMap } from "@opencode/core/location-service-map"
+import { Mcp } from "@opencode/core/mcp/index"
+import { Context, Effect, Layer } from "effect"
+import { HttpEffect, HttpRouter, HttpServer } from "effect/http"
+import { echoMcpHandler } from "../../core/test/fixture/mcp-echo"
+import { waitUntil } from "../../core/test/lib/eventually"
+import { tmpdirScoped } from "../../core/test/fixture/tmpdir"
+import { it } from "../../core/test/lib/effect"
+import { createRoutes } from "../src/routes"
+
+// `.invalid` never resolves, so only the embedder's fetch can answer these.
+const consoleServer = "https://console.invalid"
+const mcpServer = "https://mcp.invalid/mcp"
+
+it.live("sends Console config and remote MCP requests through the embedder's fetch", () =>
+ Effect.gen(function* () {
+ const tmp = yield* tmpdirScoped("opencode-fetch-option-")
+ const requested: string[] = []
+ const methods: string[] = []
+ const mcp = echoMcpHandler()
+ yield* Effect.addFinalizer(() => Effect.promise(() => mcp.close()))
+ const fetch = async (input: Request | string | URL, init?: RequestInit) => {
+ const request = new Request(input, init)
+ const url = new URL(request.url)
+ requested.push(`${url.origin}${url.pathname}`)
+ if (url.pathname === "/api/v2/config") return Response.json({})
+ if (`${url.origin}${url.pathname}` !== mcpServer) return new Response("Not found", { status: 404 })
+ const body: unknown = request.method === "POST" ? await request.clone().json() : undefined
+ if (typeof body === "object" && body !== null && "method" in body && typeof body.method === "string")
+ methods.push(body.method)
+ return mcp.fetch(request)
+ }
+ const context = yield* Layer.build(
+ createRoutes({
+ password: "secret",
+ database: { path: ":memory:" },
+ models: { fetch: false },
+ fs: { filewatcher: false },
+ fetch,
+ config: {
+ directory: tmp.path,
+ project: false,
+ content: JSON.stringify({ mcp: { servers: { gateway: { type: "remote", url: mcpServer, oauth: false } } } }),
+ },
+ }).pipe(Layer.provide(HttpServer.layerServices)),
+ )
+ const handler = Context.get(context, HttpRouter.HttpRouter)
+ .asHttpEffect()
+ .pipe(HttpEffect.toWebHandlerWith(context))
+ const request = (method: "GET" | "POST", route: string, body?: unknown) =>
+ Effect.promise(async (signal) => {
+ const url = new URL(route, "http://opencode.local")
+ url.searchParams.set("location[directory]", tmp.path)
+ const response = await handler(
+ new Request(url, {
+ method,
+ headers: {
+ authorization: `Basic ${btoa("opencode:secret")}`,
+ ...(body === undefined ? {} : { "content-type": "application/json" }),
+ },
+ body: body === undefined ? undefined : JSON.stringify(body),
+ signal,
+ }),
+ )
+ return response.status
+ })
+ const inLocation = (effect: Effect.Effect) =>
+ effect.pipe(
+ Effect.provide(
+ LocationServiceMap.Service.get(
+ LocationServiceMap.canonical(Location.Ref.make({ directory: tmp.path as Location.Ref["directory"] })),
+ ),
+ ),
+ Effect.provideContext(context),
+ )
+
+ expect(
+ yield* request("POST", "/api/credential", {
+ integrationID: "opencode",
+ value: { type: "key", key: "secret", metadata: { server: consoleServer } },
+ }),
+ ).toBe(200)
+ expect(yield* request("GET", "/api/provider")).toBe(200)
+ yield* waitUntil(Effect.sync(() => requested.includes(`${consoleServer}/api/v2/config`)))
+
+ yield* waitUntil(
+ inLocation(Mcp.Service.use((service) => service.tools())).pipe(
+ Effect.map((tools) => tools.some((tool) => tool.server === "gateway" && tool.name === "echo")),
+ ),
+ )
+ const result = yield* inLocation(
+ Mcp.Service.use((service) => service.callTool({ server: "gateway", name: "echo" })),
+ )
+ expect(result.content).toEqual([{ type: "text", text: "called echo" }])
+ expect(methods).toEqual(expect.arrayContaining(["initialize", "tools/list", "tools/call"]))
+
+ // A reconnect requested over the API starts the connection in the request's fiber rather than the MCP service's.
+ methods.length = 0
+ expect(yield* request("POST", "/api/experimental/mcp/gateway/connect")).toBe(204)
+ expect(methods).toContain("initialize")
+ }),
+)
diff --git a/packages/server/test/fetch.test.ts b/packages/server/test/fetch.test.ts
index 56f8a1dbf96..310e3effa09 100644
--- a/packages/server/test/fetch.test.ts
+++ b/packages/server/test/fetch.test.ts
@@ -166,6 +166,13 @@ function occupy(port: number, cancel = false) {
})
}
+// A server without its own config directory reads the developer's global config, whose remote MCP servers would
+// reach the network.
+const isolated = Effect.gen(function* () {
+ const config = yield* Effect.acquireDisposable(Effect.promise(() => tmpdir("opencode-openai-oauth-")))
+ return yield* ServerFetch.make({ ...options, config: { ...options.config, directory: config.path } })
+})
+
const connectOpenAI = (handler: Handler) =>
Effect.gen(function* () {
// Catalog endpoints no longer wait for plugin initialization.
@@ -426,7 +433,7 @@ it.live("returns 404 when a previously readable file is deleted", () =>
it.live("cancels a stale OpenAI OAuth callback server before falling back", () =>
Effect.gen(function* () {
const requests = yield* occupy(1455, true)
- const handler = yield* ServerFetch.make(options)
+ const handler = yield* isolated
const response = yield* connectOpenAI(handler)
expect(response.status).toBe(200)
@@ -439,7 +446,7 @@ it.live("cancels a stale OpenAI OAuth callback server before falling back", () =
it.live("falls back to port 1457 when OpenAI OAuth port 1455 remains busy", () =>
Effect.gen(function* () {
const requests = yield* occupy(1455)
- const handler = yield* ServerFetch.make(options)
+ const handler = yield* isolated
const response = yield* connectOpenAI(handler)
expect(response.status).toBe(200)
@@ -455,7 +462,7 @@ it.live(
Effect.gen(function* () {
yield* occupy(1455)
yield* occupy(1457)
- const handler = yield* ServerFetch.make(options)
+ const handler = yield* isolated
const response = yield* connectOpenAI(handler)
expect(response.status).toBe(400)
diff --git a/packages/server/test/media.test.ts b/packages/server/test/media.test.ts
index b51c50dbf64..c80ad230922 100644
--- a/packages/server/test/media.test.ts
+++ b/packages/server/test/media.test.ts
@@ -62,7 +62,12 @@ const serve = (database: string, mediaBlob: boolean) =>
ServerFetch.make({
app: { version: "test" },
database: { path: database },
- config: { project: false, content: JSON.stringify(mediaBlob ? { experimental: { media_blob: true } } : {}) },
+ // Its own global config directory, so the developer's global config can't add remote MCP servers.
+ config: {
+ directory: path.dirname(database),
+ project: false,
+ content: JSON.stringify(mediaBlob ? { experimental: { media_blob: true } } : {}),
+ },
models: { fetch: false },
fs: { filewatcher: false },
})
diff --git a/packages/server/test/options.test.ts b/packages/server/test/options.test.ts
index 1da08f031b9..844f47538a8 100644
--- a/packages/server/test/options.test.ts
+++ b/packages/server/test/options.test.ts
@@ -34,3 +34,9 @@ test("accepts an optional CORS allowlist", () => {
])
expect(Option.isNone(decode({ cors: "http://192.168.1.10:3001" }))).toBe(true)
})
+
+test("accepts an embedder fetch and rejects other values", () => {
+ const fetch = () => Promise.resolve(new Response())
+ expect(Option.getOrThrow(decode({ fetch })).fetch).toBe(fetch)
+ expect(Option.isNone(decode({ fetch: "https://example.com" }))).toBe(true)
+})
diff --git a/packages/util/src/effect/app-node-platform.ts b/packages/util/src/effect/app-node-platform.ts
index ee9e462039f..67836d5ec17 100644
--- a/packages/util/src/effect/app-node-platform.ts
+++ b/packages/util/src/effect/app-node-platform.ts
@@ -2,12 +2,39 @@
// ioredis, and node:sqlite, which runtimes such as workerd cannot load.
import * as NodeFileSystem from "@effect/platform-node/NodeFileSystem"
import * as NodePath from "@effect/platform-node/NodePath"
-import { FileSystem, Path } from "effect"
+import { Effect, FileSystem, Layer, Path } from "effect"
import { FetchHttpClient, HttpClient } from "effect/http"
import { makeGlobalNode } from "./app-node.js"
export const filesystem = makeGlobalNode({ service: FileSystem.FileSystem, layer: NodeFileSystem.layer, deps: [] })
export const path = makeGlobalNode({ service: Path.Path, layer: NodePath.layer, deps: [] })
-export const httpClient = makeGlobalNode({ service: HttpClient.HttpClient, layer: FetchHttpClient.layer, deps: [] })
+// `RequestInfo | URL`, spelled out because not every runtime declares `RequestInfo` globally.
+export type Fetch = (input: Request | string | URL, init?: RequestInit) => Promise
+/**
+ * The fetch behind `httpClient`, AI SDK providers and remote MCP servers: `fetch` when given, so an embedder can route requests through
+ * e.g. a Service Binding, otherwise the `FetchHttpClient.Fetch` in scope when the graph is built.
+ */
+export const fetchLayer = (fetch?: Fetch) =>
+ Layer.effect(
+ FetchHttpClient.Fetch,
+ Effect.gen(function* () {
+ // Bun's `typeof fetch` adds `preconnect`, which nothing here calls.
+ return fetch ? (fetch as typeof globalThis.fetch) : yield* FetchHttpClient.Fetch
+ }),
+ )
+export const httpFetch = makeGlobalNode({ service: FetchHttpClient.Fetch, layer: fetchLayer(), deps: [] })
+// Provided per request, so a caller's context can't swap `httpFetch` for another fetch.
+export const httpClient = makeGlobalNode({
+ service: HttpClient.HttpClient,
+ layer: Layer.effect(
+ HttpClient.HttpClient,
+ Effect.gen(function* () {
+ const fetch = yield* FetchHttpClient.Fetch
+ const client = yield* HttpClient.HttpClient.pipe(Effect.provide(FetchHttpClient.layer))
+ return HttpClient.transformResponse(client, Effect.provideService(FetchHttpClient.Fetch, fetch))
+ }),
+ ),
+ deps: [httpFetch],
+})
export * as LayerNodePlatform from "./app-node-platform.js"
diff --git a/services/www/src/docs/content/build/sdk/cloudflare.mdx b/services/www/src/docs/content/build/sdk/cloudflare.mdx
index 1088d235725..cf9dde15954 100644
--- a/services/www/src/docs/content/build/sdk/cloudflare.mdx
+++ b/services/www/src/docs/content/build/sdk/cloudflare.mdx
@@ -55,6 +55,22 @@ a Durable Object without running cleanup, so correctness does not depend on `clo
}
```
+## Route outbound requests
+
+Pass `fetch` to route OpenCode's outbound HTTP requests (OpenCode Console config, model requests, web fetch and
+search, well-known config, and remote MCP servers) through a custom handler such as a Service Binding. Agent code in
+Code Mode continues to use `globalThis.fetch`.
+
+```ts
+OpenCodeWorkerd.create({
+ storage: state.storage,
+ fetch: (input, init) => {
+ const request = new Request(input, init)
+ return new URL(request.url).hostname === "console.example.com" ? env.CONSOLE.fetch(request) : fetch(request)
+ },
+})
+```
+
## Customize
Customize your OpenCode instance by registering plugins bundled with your