Function createMcpRequestHandler

apps/local/src/mcp.ts:125–299

(
  input: ExecutorMcpServerConfig | LocalMcpRequestHandlerConfig,
)

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

export const createMcpRequestHandler = (
  input: ExecutorMcpServerConfig | 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 approvals = makeInProcessBrowserApprovalStore();
  const defaultEngine = engineFromConfig(handlerConfig.defaultConfig);

  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);
  };

  return {
    handleRequest: async (request) => {
      const resource = resourceFromRequest(request);
      if (!resource) return jsonError(404, -32001, "MCP resource not found");
      const sessionId = request.headers.get("mcp-session-id");

      if (sessionId) {
        const transport = transports.get(sessionId);
        if (!transport) return jsonError(404, -32001, "Session not found");
        const sessionResource = resources.get(sessionId);
        if (!sessionResource || mcpResourceKey(sessionResource) !== mcpResourceKey(resource)) {
          return jsonError(403, -32003, "Session belongs to a different MCP resource");
        }
        return transport.handleRequest(request);