Function makeMcpSurface

e2e/src/surfaces/mcp.ts:296–451

(target: Target, runDir?: string)

};

export const makeMcpSurface = (target: Target, runDir?: string): McpSurface => ({
  url: target.mcpUrl,
  mintBearer: (email) => Effect.promise(() => mintBearerFlow(target, email)),
  session: (identity, options) => {
    const mcpUrl = options?.url ?? target.mcpUrl;
    if (runDir) installTraceparentFetch(mcpUrl, runDir);
    // mcporter caches OAuth tokens (and the DCR client) per server NAME, so a
    // constant name would let a later session reuse an earlier identity's token
    // — landing in the wrong org. A unique name per session keeps each
    // identity's OAuth isolated. The traceparent ledger keys off the URL, not
    // this name, so it is unaffected.
    const serverName = `${target.name}-${randomUUID().slice(0, 8)}`;
    // Per-connection settings ride the MCP endpoint query, the ecosystem
    // convention: `elicitation_mode` so a paused execution yields an approvalUrl
    // instead of letting the model resume inline, `artifacts=false` to opt the
    // session out of the artifact surface, and `search_tools=true` to opt into
    // the per-integration search tools. All are non-defaults, so a plain
    // session's URL carries no query at all.
    const sessionQuery = [
      ...(options?.elicitationMode ? [`elicitation_mode=${options.elicitationMode}`] : []),
      ...(options?.artifacts === false ? ["artifacts=false"] : []),
      ...(options?.searchTools === true ? ["search_tools=true"] : []),
    ].join("&");
    const sessionUrl = sessionQuery ? `${mcpUrl}?${sessionQuery}` : mcpUrl;

    if (target.name === "cloudflare") {
      let clientPromise: Promise<Client> | undefined;
      const client = () => {
        if (!clientPromise) {
          clientPromise = (async () => {
            const directClient = new Client(
              { name: serverName, version: "1.0.0" },
              { capabilities: {} },
            );
            const transport = new StreamableHTTPClientTransport(new URL(sessionUrl), {
              requestInit: { headers: identity.headers ?? {} },
            });
            await directClient.connect(transport);
            return directClient;
          })();
        }
        return clientPromise;
      };

      const listTools = () =>
        Effect.promise(async () => {
          const listed = await (await client()).listTools();
          return listed.tools.map((tool) => tool.name);
        });

      const call = (name: string, args: Record<string, unknown> = {}) =>
        Effect.promise(async (): Promise<McpCallResult> => {
          const raw = await (await client()).callTool({ name, arguments: args });
          const isError = Boolean((raw as { isError?: boolean })?.isError);
          return { raw, text: textOf(raw), ok: !isError };
        });

      return {