feat(sdk): restore session runtime operations (#33777)

packages/sdk-next/src/opencode.ts

@@ -2,43 +2,37 @@ import { OpenCode } from "@opencode-ai/client/effect"
 import { PermissionSaved } from "@opencode-ai/core/permission/saved"
 import { ApplicationTools } from "@opencode-ai/core/tool/application-tools"
 import { createEmbeddedRoutes } from "@opencode-ai/server/routes"
-import { Cause, Context, Effect, Layer } from "effect"
-import {
-  HttpClient,
-  HttpRouter,
-  HttpServer,
-  HttpServerError,
-  HttpServerRequest,
-  HttpServerResponse,
-} from "effect/unstable/http"
+import { Context, Effect, Layer, Scope } from "effect"
+import { FetchHttpClient, HttpRouter, HttpServer } from "effect/unstable/http"
 
 export const create = Effect.fn("OpenCode.create")(function* () {
-  const applicationTools = ApplicationTools.layer
-  const { handler, permissions, tools } = yield* Effect.all({
-    // Reusing this Layer value lets registration and every Location share one memoized host-level registry.
-    handler: HttpRouter.toHttpEffect(
-      createEmbeddedRoutes().pipe(Layer.provide(applicationTools), Layer.provide(HttpServer.layerServices)),
-    ),
-    permissions: PermissionSaved.Service,
-    tools: ApplicationTools.Service,
-  }).pipe(Effect.provide(Layer.merge(applicationTools, PermissionSaved.defaultLayer)))
-  const httpClient = HttpClient.make(
-    Effect.fnUntraced(function* (request) {
-      const response = yield* handler.pipe(
-        Effect.provideService(HttpServerRequest.HttpServerRequest, HttpServerRequest.fromClientRequest(request)),
-        Effect.provideService(ApplicationTools.Service, tools),
-        Effect.provideService(PermissionSaved.Service, permissions),
-        Effect.catchCause((cause) =>
-          Cause.hasInterruptsOnly(cause)
-            ? Effect.interrupt
-            : HttpServerError.causeResponse(cause).pipe(Effect.map(([response]) => response)),
-        ),
-      )
-      return HttpServerResponse.toClientResponse(response, { request })
-    }, Effect.scoped),
+  const scope = yield* Scope.Scope
+  const memoMap = yield* Layer.makeMemoMap
+  const context = yield* Layer.buildWithMemoMap(
+    Layer.merge(ApplicationTools.layer, PermissionSaved.defaultLayer),
+    memoMap,
+    scope,
   )
+  const tools = Context.get(context, ApplicationTools.Service)
+  const permissions = Context.get(context, PermissionSaved.Service)
+  const web = yield* Effect.acquireRelease(
+    Effect.sync(() =>
+      HttpRouter.toWebHandler(
+        createEmbeddedRoutes().pipe(
+          HttpRouter.provideRequest(Layer.succeed(PermissionSaved.Service, permissions)),
+          Layer.provide(HttpServer.layerServices),
+        ),
+        { disableLogger: true, memoMap },
+      ),
+    ),
+    (web) => Effect.promise(web.dispose),
+  )
+  const fetch = Object.assign((input: RequestInfo | URL, init?: RequestInit) => web.handler(new Request(input, init)), {
+    preconnect: () => undefined,
+  }) satisfies typeof globalThis.fetch
   const client = yield* OpenCode.make({ baseUrl: "http://opencode.local" }).pipe(
-    Effect.provideService(HttpClient.HttpClient, httpClient),
+    Effect.provide(FetchHttpClient.layer),
+    Effect.provideService(FetchHttpClient.Fetch, fetch),
   )
   return {
     ...client,