Function createMcpRequestHandler

apps/local/src/mcp.ts:135–375

(
  input: ExecutorMcpToolConfig | LocalMcpRequestHandlerConfig,
)

): LocalMcpRequestHandlerConfig => ("defaultConfig" in input ? input : { defaultConfig: input });

export const createMcpRequestHandler = (
  input: ExecutorMcpToolConfig | LocalMcpRequestHandlerConfig,
): McpRequestHandler => {
  const handlerConfig = normalizeHandlerConfig(input);
  const transports = new Map<string, WebStandardStreamableHTTPServerTransport>();
  const servers = new Map<string, McpServer>();
  const resources = new Map<string, McpResource>();
  const sessionEngines = new Map<string, AnyExecutionEngine>();
  const sessionClosers = new Map<string, () => Promise<void>>();
  const modernHandlers = new Map<string, McpHttpHandler>();
  const modernRequestBodies = new WeakMap<Request, unknown>();
  const approvals = makeInProcessBrowserApprovalStore();
  const defaultEngine = engineFromConfig(handlerConfig.defaultConfig);
  let requestStateSigningKey: Uint8Array | undefined;

  const signingKey = (): Uint8Array =>
    (requestStateSigningKey ??= crypto.getRandomValues(new Uint8Array(32)));

  const pausedDetail = (
    sessionId: string,
    executionId: string,
  ): Promise<ReturnType<typeof formatPausedExecution> | null> =>
    (sessionEngines.get(sessionId) ?? defaultEngine)
      ? Effect.runPromise(
          (sessionEngines.get(sessionId) ?? defaultEngine)!.getPausedExecution(executionId).pipe(
            Effect.map((paused) => (paused ? formatPausedExecution(paused) : null)),
            Effect.orElseSucceed(() => null),
          ),
        )
      : Promise.resolve(null);

  const configForResource = async (resource: McpResource): Promise<LocalMcpServerConfig> => {
    if (!handlerConfig.createConfigForResource) return { config: handlerConfig.defaultConfig };
    return handlerConfig.createConfigForResource(resource);
  };

  const dispose = async (id: string, opts: { transport?: boolean; server?: boolean } = {}) => {
    const t = transports.get(id);
    const s = servers.get(id);
    const close = sessionClosers.get(id);
    transports.delete(id);
    servers.delete(id);
    resources.delete(id);
    sessionEngines.delete(id);
    sessionClosers.delete(id);
    if (opts.transport) await ignoreClose(t ? () => t.close() : undefined);
    if (opts.server) await ignoreClose(s ? () => s.close() : undefined);
    await ignoreClose(close);
  };

  const modernHandlerFor = (resource: McpResource): McpHttpHandler => {
    const key = mcpResourceKey(resource);
    const cached = modernHandlers.get(key);
    if (cached) return cached;

    const handler = createMcpHandler(
      (context) => {
        const request = context.requestInfo;