sailfork / t3code-github / packages/ provider-acp/ src/ server/ mcpOverAcpBridge.ts

// @effect-diagnostics globalJsonInEffect:off
import * as Effect from "effect/Effect";
import * as Schema from "effect/Schema";
import * as Semaphore from "effect/Semaphore";
import * as Stream from "effect/Stream";
import type * as AcpSchema from "effect-acp/compat";

import { responsePayloads } from "@t3tools/shared/mcpResponsePayloads";

const MAX_CONNECTIONS = 16;
const MAX_MESSAGE_BYTES = 8 * 1024 * 1024;

interface JsonRpcEnvelope {
  readonly id?: unknown;
  readonly method?: unknown;
  readonly error?: unknown;
  readonly result?: unknown;
}

interface Connection {
  readonly mutex: Semaphore.Semaphore;
  sessionId: string | null;
  protocolVersion: string | null;
  nextRequestId: number;
}

export class AcpMcpOverAcpError extends Schema.TaggedError<AcpMcpOverAcpError>()(
  "AcpMcpOverAcpError",
  { message: Schema.String, cause: Schema.optional(Schema.Defect()) },
) {}

const isAcpMcpOverAcpError = Schema.is(AcpMcpOverAcpError);

const bridgeError = (cause: unknown): AcpMcpOverAcpError =>
  isAcpMcpOverAcpError(cause)
    ? cause
    : new AcpMcpOverAcpError({
        message: cause instanceof Error ? cause.message : String(cause),
        cause,
      });

const asEnvelope = (value: unknown): JsonRpcEnvelope | null =>
  typeof value === "object" && value !== null && !Array.isArray(value)
    ? (value as JsonRpcEnvelope)
    : null;

function protocolVersionOf(payload: unknown): string | null {
  const result = asEnvelope(payload)?.result;
  if (typeof result !== "object" || result === null || Array.isArray(result)) return null;
  const protocolVersion = (result as { readonly protocolVersion?: unknown }).protocolVersion;
  return typeof protocolVersion === "string" && protocolVersion.length > 0 ? protocolVersion : null;
}

function errorMessage(error: unknown): string {
  if (typeof error !== "object" || error === null || Array.isArray(error)) {
    return "The MCP server returned an error.";
  }
  const message = (error as { readonly message?: unknown }).message;
  return typeof message === "string" && message.length > 0
    ? message
    : "The MCP server returned an error.";
}

export interface AcpMcpOverAcpBridgeOptions {
  readonly endpoint: string;
  readonly authorization: string;
  readonly allocateConnectionId: Effect.Effect<string>;
  readonly fetchImplementation?: (url: string, init?: RequestInit) => Promise<Response>;
}

export interface AcpMcpOverAcpBridge {
  readonly connect: (
    request: AcpSchema.ConnectMcpRequest,
  ) => Effect.Effect<AcpSchema.ConnectMcpResponse, AcpMcpOverAcpError>;
  readonly message: (
    request: AcpSchema.MessageMcpRequest,
  ) => Effect.Effect<AcpSchema.MessageMcpResponse, AcpMcpOverAcpError>;
  readonly notification: (
    request: AcpSchema.MessageMcpNotification,
  ) => Effect.Effect<void, AcpMcpOverAcpError>;
  readonly disconnect: (
    request: AcpSchema.DisconnectMcpRequest,
  ) => Effect.Effect<AcpSchema.DisconnectMcpResponse, AcpMcpOverAcpError>;
  readonly dispose: Effect.Effect<void>;
}

export const makeAcpMcpOverAcpBridge = Effect.fn("AcpMcpOverAcpBridge.make")(function* (
  options: AcpMcpOverAcpBridgeOptions,
): Effect.fn.Return<AcpMcpOverAcpBridge> {
  const fetchImplementation = options.fetchImplementation ?? fetch;
  const connections = yield* Effect.sync(() => new Map<string, Connection>());

  const connectionFor = (connectionId: string): Effect.Effect<Connection, AcpMcpOverAcpError> =>
    Effect.suspend(() => {
      const connection = connections.get(connectionId);
      return connection === undefined
        ? Effect.fail(
            new AcpMcpOverAcpError({
              message: `Unknown MCP-over-ACP connection "${connectionId}".`,
            }),
          )
        : Effect.succeed(connection);
    });

  // Only initialization needs ordering; negotiated calls may wait independently.
  const untilNegotiated = <A, E>(connection: Connection, effect: Effect.Effect<A, E>) =>
    Effect.suspend(() =>
      connection.protocolVersion === null ? connection.mutex.withPermits(1)(effect) : effect,
    );

  const send = (
    connection: Connection,
    message: unknown,
  ): Effect.Effect<ReadonlyArray<unknown>, AcpMcpOverAcpError> =>
    untilNegotiated(
      connection,
      Effect.gen(function* () {
        const body = JSON.stringify(message);
        if (Buffer.byteLength(body) > MAX_MESSAGE_BYTES) {
          return yield* new AcpMcpOverAcpError({ message: "MCP-over-ACP message exceeds 8 MiB." });
        }
        const response = yield* Effect.tryPromise({
          try: (signal) =>
            fetchImplementation(options.endpoint, {
              method: "POST",
              signal,
              headers: {
                "content-type": "application/json",
                accept: "application/json, text/event-stream",
                authorization: options.authorization,
                ...(connection.sessionId === null
                  ? {}
                  : { "mcp-session-id": connection.sessionId }),
                ...(connection.protocolVersion === null
                  ? {}
                  : { "mcp-protocol-version": connection.protocolVersion }),
              },
              body,
            }),
          catch: bridgeError,
        });
        connection.sessionId = response.headers.get("mcp-session-id") ?? connection.sessionId;
        if (!response.ok) {
          yield* Effect.promise(
            () => response.body?.cancel().catch(() => undefined) ?? Promise.resolve(),
          );
          return yield* new AcpMcpOverAcpError({
            message: `T3 Code MCP endpoint responded with HTTP ${response.status}.`,
          });
        }
        const payloads = [...(yield* Stream.runCollect(responsePayloads(response, bridgeError)))];
        for (const payload of payloads) {
          connection.protocolVersion = protocolVersionOf(payload) ?? connection.protocolVersion;
        }
        return payloads;
      }).pipe(Effect.mapError(bridgeError)),
    );

  const disconnect = Effect.fn("mcpOverAcpBridge.disconnect")(function* (
    request: AcpSchema.DisconnectMcpRequest,
  ): Effect.fn.Return<AcpSchema.DisconnectMcpResponse, AcpMcpOverAcpError> {
    const connection = yield* connectionFor(request.connectionId);
    connections.delete(request.connectionId);
    const sessionId = connection.sessionId;
    if (sessionId !== null) {
      const response = yield* Effect.tryPromise({
        try: (signal) =>
          fetchImplementation(options.endpoint, {
            method: "DELETE",
            signal,
            headers: {
              authorization: options.authorization,
              "mcp-session-id": sessionId,
              ...(connection.protocolVersion === null
                ? {}
                : { "mcp-protocol-version": connection.protocolVersion }),
            },
          }),
        catch: bridgeError,
      });
      if (!response.ok && response.status !== 404) {
        return yield* new AcpMcpOverAcpError({
          message: `T3 Code MCP endpoint rejected disconnect with HTTP ${response.status}.`,
        });
      }
      yield* Effect.promise(
        () => response.body?.cancel().catch(() => undefined) ?? Promise.resolve(),
      );
    }
    return {};
  });

  return {
    connect: Effect.fn("mcpOverAcpBridge.connect")(function* (request) {
      if (request.serverId !== "t3-code") {
        return yield* new AcpMcpOverAcpError({
          message: `Unknown ACP MCP server "${request.serverId}".`,
        });
      }
      if (connections.size >= MAX_CONNECTIONS) {
        return yield* new AcpMcpOverAcpError({ message: "Too many MCP-over-ACP connections." });
      }
      const connectionId = yield* options.allocateConnectionId;
      connections.set(connectionId, {
        mutex: yield* Semaphore.make(1),
        sessionId: null,
        protocolVersion: null,
        nextRequestId: 0,
      });
      return { connectionId };
    }),
    message: Effect.fn("mcpOverAcpBridge.message")(function* (request) {
      const connection = yield* connectionFor(request.connectionId);
      const id = ++connection.nextRequestId;
      const payloads = yield* send(connection, {
        jsonrpc: "2.0",
        id,
        method: request.method,
        ...(request.params == null ? {} : { params: request.params }),
      });
      const response = payloads.find((payload) => asEnvelope(payload)?.id === id);
      const envelope = asEnvelope(response);
      if (envelope === null) {
        return yield* new AcpMcpOverAcpError({
          message: "MCP server did not return a matching response.",
        });
      }
      if (envelope.error !== undefined) {
        return yield* new AcpMcpOverAcpError({ message: errorMessage(envelope.error) });
      }
      return (envelope.result ?? null) as AcpSchema.MessageMcpResponse;
    }),
    notification: Effect.fn("mcpOverAcpBridge.notification")(function* (request) {
      const connection = yield* connectionFor(request.connectionId);
      yield* send(connection, {
        jsonrpc: "2.0",
        method: request.method,
        ...(request.params == null ? {} : { params: request.params }),
      });
    }),
    disconnect,
    dispose: Effect.suspend(() =>
      Effect.forEach(
        [...connections.keys()],
        (connectionId) => disconnect({ connectionId }).pipe(Effect.ignore),
        { discard: true },
      ),
    ),
  };
});