Revert the outbound MCP SDK v2 migration (#1697)

* Revert the outbound MCP SDK v2 migration * Drop the v2 MCP packages from the lockfile

Rhys Sullivan committed 2 months ago

Commit a5800a11 parent 54cde5e91 files · +5838 −10032Browse files

Showing the changes to packages/core/api/src/server (2 of 91 files). Show all

Unified · Split

2 files

packages/core/api/src/server/executor-app.ts +14 −33
packages/core/api/src/server/mcp-build.ts +31 −49

packages/core/api/src/server/executor-app.ts+14−33

 //                               + that stack + plugin tuple + failure strategy) (auth + per-request executor)
 //   3. the protected (plugin) API = makeProtectedApiLayer(plugins, { errorCapture,
 //                               router: prefixed(mountPrefix) }) wrapped by (2)
-//   4. the MCP serving envelope = McpServingRoutes + the auth/session/modern
+//   4. the MCP serving envelope = McpServingRoutes + the 2-3 seams (auth/sessions
-//                               builder/reporter seams                             (the seams)
+//                               /reporter), double-provided like the host did      (the seams)
 //   5. the account API = makeAccountApiLayer(accountMiddleware, { router })
 //   6. each extensions.route (Better Auth handler, Swagger, marketing, /autumn)
 //   7. provideMerge(boot) (+ optional requestScoped) -> the AppLayer
   McpErrorReporterNoop,
   type McpAuthProvider,
   type McpErrorReporter,
-  type McpModernServerBuilder,
   type McpSessionStore,
 } from "@executor-js/host-mcp";
  * identity fallback sets `RMcpAuth = IdentityProvider` (self-host) and one whose
  * MCP plane is a separate credential surface leaves it `never` (cloud).
  */
-interface McpProviderBase<RMcpAuth> {
+export interface McpProviders<RMcpAuth = never> {
   /** Resolve a request to an MCP `AuthOutcome` + declare the discovery routes. */
   readonly auth: Layer.Layer<McpAuthProvider, never, RMcpAuth>;
+  /**
+   * Owns the entire serving-session lifecycle (in-process Map vs DO). Optional:
+   * a host that serves `/mcp` transport outside this envelope (the Cloudflare
+   * Agent bridge) omits it, and only the discovery routes are mounted.
+   */
+  readonly sessions?: Layer.Layer<McpSessionStore>;
   /** Forward an orchestration defect to the host's capture; default no-op. */
   readonly reporter?: Layer.Layer<McpErrorReporter>;
 }
-/** MCP providers either serve discovery alone or provide both protocol eras. */
-export type McpProviders<RMcpAuth = never> = McpProviderBase<RMcpAuth> &
-  (
-    | {
-        /**
-         * Owns the legacy serving-session lifecycle (in-process Map vs DO).
-         */
-        readonly sessions: Layer.Layer<McpSessionStore>;
-        /** Builds one stateless MCP server for each modern request. */
-        readonly modern: Layer.Layer<McpModernServerBuilder>;
-      }
-    | {
-        /** Omitted when another platform surface serves `/mcp` transport. */
-        readonly sessions?: undefined;
-        /** Discovery-only providers do not construct modern servers here. */
-        readonly modern?: undefined;
-      }
-  );
 /**
  * The provider seams common to BOTH execution models (scoped + fixed): identity,
  * the optional account API, the optional MCP envelope, and error capture. The
     : pluginApiLive;
   // ---- (4) the MCP serving envelope (optional) --------------------------
-  // The serving providers, by design (mirrors makeSelfHostMcp):
+  // The two providers, by design (mirrors makeSelfHostMcp):
   //   - `Layer.provide(mcpAuth)` satisfies the `HttpRouter.use` callback's
   //     build-time `McpAuthProvider` requirement (it registers a GET per
   //     provider-declared discovery path).
   //   - `HttpRouter.provideRequest(McpSeams)` clears the route handlers'
-  //     per-request `Requires` markers (auth + both eras + reporter) so the
+  //     per-request `Requires` markers (auth + session store + reporter) so the
   //     /mcp routes carry no leftover requirements when merged into the router.
   // The auth seam may require the neutral `IdentityProvider` (`RMcpAuth =
   // IdentityProvider` for self-host, whose MCP auth genuinely reads the fallback;
 };
 /**
- * Compose the MCP serving routes over the auth/legacy/modern/reporter seams. The auth
+ * Compose the MCP serving routes over the auth/sessions/reporter seams. The auth
  * seam may require the neutral `IdentityProvider` (`RMcpAuth`); the facade provides
  * the complete identity seam ONCE (memoized) and shares it across the build-time
  * `Layer.provide` AND the per-request `HttpRouter.provideRequest`, so a single
   // No session store: the host serves `/mcp` transport elsewhere (the Cloudflare
   // Agent bridge), so mount only the auth-declared discovery routes. The discovery
   // handlers are captured from the auth seam at build, so no per-request seams.
-  if (mcp.sessions === undefined) {
+  if (!mcp.sessions) {
     return McpDiscoveryRoutes.pipe(Layer.provide(mcpAuthLive));
   }
-  const mcpSeams = Layer.mergeAll(
+  const mcpSeams = Layer.mergeAll(mcpAuthLive, mcp.sessions, mcp.reporter ?? McpErrorReporterNoop);
-    mcpAuthLive,
-    mcp.sessions,
-    mcp.modern,
-    mcp.reporter ?? McpErrorReporterNoop,
-  );
   return McpServingRoutes.pipe(HttpRouter.provideRequest(mcpSeams), Layer.provide(mcpAuthLive));
 };

packages/core/api/src/server/mcp-build.ts+31−49

 import { Effect, Layer } from "effect";
-import {
+import { McpErrorReporter, type Principal } from "@executor-js/host-mcp";
-  McpErrorReporter,
-  type McpModernServerBuilder,
-  type McpModernServerBuildOptions,
-  type Principal,
-} from "@executor-js/host-mcp";
 import {
   McpEngineBuildError,
-  type McpBuildServer as McpSessionBuildServer,
+  type McpBuildServer,
-  type McpBuildServerOptions as McpSessionBuildOptions,
+  type McpBuildServerOptions,
 } from "@executor-js/host-mcp/in-memory-session-store";
-import { buildMcpServer } from "@executor-js/host-mcp/tool-server";
+import { createExecutorMcpServer } from "@executor-js/host-mcp/tool-server";
 import {
   artifactUrlFor,
   type ArtifactSmokeRenderResult,
 // ---------------------------------------------------------------------------
 // Shared in-process MCP host helpers.
 //
-// Neutral hosts build both sessionful legacy-wire connections and stateless
+// Every host that serves MCP from one isolate (self-host, the Cloudflare QuickJS
-// modern requests from the same assembly over a scoped execution stack.
+// host) builds its per-session McpServer the same way — assemble the scoped
+// engine via `makeExecutionStack`, wrap it with `createExecutorMcpServer` — and
+// reports orchestration defects through the same console `ErrorCapture` seam.
+// These two factories are the single home for that logic; a host supplies ONLY
+// its fully-provided execution-stack layer and its `ErrorCapture` layer. The
+// cross-isolate variant (cloud's Durable Object store) is the exception that
+// builds its engine inside the DO.
 // ---------------------------------------------------------------------------
 /** The five execution-stack seams a host fully provides (no residual). */
   DbProvider | PluginsProvider | HostConfig | CodeExecutorProvider | EngineDecorator
 >;
-type McpSessionBuildEffect = ReturnType<McpSessionBuildServer>;
-type McpModernBuildEffect = ReturnType<McpModernServerBuilder["Service"]["build"]>;
-/** A single build seam accepted by both the session store and modern envelope. */
-export interface McpBuildServer {
-  /** Build a connection-lifetime server and retain its engine for session-owned approvals. */
-  (principal: Principal, options: McpSessionBuildOptions): McpSessionBuildEffect;
-  /** Build a stateless server for one modern request. */
-  (principal: Principal, options: McpModernServerBuildOptions): McpModernBuildEffect;
-}
 /**
- * Build the unified MCP server factory over a host's execution stack.
+ * Build the per-session MCP server factory over a host's execution stack:
- * Session callers receive the server plus its approval-owning engine; modern
+ * `makeExecutionStack` → engine → `createExecutorMcpServer`. Hosts differ only
- * request callers receive the server directly.
+ * in the injected stack layer (libSQL vs D1, etc.).
  */
-export const makeMcpBuildServer = (
+export const makeMcpBuildServer =
-  executionStack: McpExecutionStackLayer,
+  (executionStack: McpExecutionStackLayer, hostOptions?: McpBuildHostOptions): McpBuildServer =>
-  hostOptions?: McpBuildHostOptions,
+  (principal: Principal, options?: McpBuildServerOptions) =>
-): McpBuildServer => {
+    Effect.gen(function* () {
-  function build(principal: Principal, options: McpSessionBuildOptions): McpSessionBuildEffect;
-  function build(principal: Principal, options: McpModernServerBuildOptions): McpModernBuildEffect;
-  function build(
-    principal: Principal,
-    options: McpSessionBuildOptions | McpModernServerBuildOptions,
-  ): Effect.Effect<
-    Effect.Success<McpSessionBuildEffect> | Effect.Success<McpModernBuildEffect>,
-    Effect.Error<McpSessionBuildEffect> | Effect.Error<McpModernBuildEffect>
-  > {
-    const { resource, ...serverOptions } = options;
-    return Effect.gen(function* () {
       const { engine, executor } = yield* makeExecutionStack(
         principal.accountId,
         principal.organizationId,
         principal.organizationName,
-        { mcpResource: resource },
+        { mcpResource: options?.resource },
       ).pipe(Effect.withSpan("mcp.execution_stack.build"));
       // Read inside the provided boundary: `webBaseUrl` is a host seam, and
-      // hosts that cannot know their public URL at boot leave it unset.
+      // hosts that can't know their public URL at boot leave it unset — in
+      // which case artifacts still persist but carry no deep link.
       const hostConfig = yield* HostConfig;
       return { engine, executor, webBaseUrl: hostConfig.webBaseUrl };
     }).pipe(
+      // Pin browser-handoff URLs to the principal's org slug when present;
+      // absent slug leaves the service unprovided and the URL stays bare.
       principal.organizationSlug !== undefined
         ? Effect.provideService(RequestOrgSlug, { slug: principal.organizationSlug })
         : (effect) => effect,
       Effect.provide(executionStack),
       Effect.mapError((cause) => new McpEngineBuildError({ cause })),
       Effect.flatMap(({ engine, executor, webBaseUrl }) =>
-        buildMcpServer({
+        createExecutorMcpServer({
           engine,
           artifacts: executor.artifacts,
           connections: executor.connections,
             ? { smokeRenderArtifact: hostOptions.smokeRenderArtifact }
             : {}),
           ...(hostOptions?.onArtifactUsage ? { onArtifactUsage: hostOptions.onArtifactUsage } : {}),
+          // Same org pinning as `RequestOrgSlug` above: self-host serves its
+          // console under `/<org-slug>` (`default` when unconfigured), so the
+          // deep link carries the principal's slug rather than relying on the
+          // browser's active org to canonicalize a bare path after landing.
           ...(webBaseUrl
             ? { artifactUrl: artifactUrlFor(webBaseUrl, principal.organizationSlug) }
             : {}),
-          ...serverOptions,
+          ...(options ?? {}),
         }).pipe(
           Effect.withSpan("mcp.server.create"),
-          Effect.map((mcpServer) => ("sessionful" in options ? { mcpServer, engine } : mcpServer)),
+          Effect.map((mcpServer) => ({ mcpServer, engine })),
         ),
       ),
     );
-  }
-  return build;
-};
 /** Per-host (not per-session) MCP wiring. Kept separate from
  *  `McpBuildServerOptions`, which the session store fills in per request. */