sailfork / t3code-github / packages/ effect-acp/ src/ agent.ts

import * as Context from "effect/Context";
import * as Effect from "effect/Effect";
import * as ErrorReporter from "effect/ErrorReporter";
import * as Layer from "effect/Layer";
import * as Schema from "effect/Schema";
import * as Scope from "effect/Scope";
import * as Stream from "effect/Stream";
import * as Stdio from "effect/Stdio";
import * as RpcClient from "effect/rpc/RpcClient";
import * as RpcMessage from "effect/rpc/RpcMessage";
import * as RpcServer from "effect/rpc/RpcServer";

import * as AcpSchema from "./schema.ts";
import { AGENT_METHODS, CLIENT_METHODS } from "./_generated/meta.gen.ts";
import * as AcpError from "./errors.ts";
import * as AcpProtocol from "./protocol.ts";
import * as AcpRpcs from "./rpc.ts";
import {
  callRpc,
  decodeExtNotificationRegistration,
  decodeExtRequestRegistration,
  isolateNotificationHandler,
  runHandler,
} from "./_internal/shared.ts";

export interface AcpAgentOptions {
  readonly logIncoming?: boolean;
  readonly logOutgoing?: boolean;
  readonly logger?: (event: AcpProtocol.AcpProtocolLogEvent) => Effect.Effect<void, never>;
}

export type AcpRequestHandler<Request, Response> = AcpProtocol.AcpRequestHandler<Request, Response>;

export class AcpAgent extends Context.Service<
  AcpAgent,
  {
    readonly raw: {
      readonly notifications: Stream.Stream<AcpProtocol.AcpIncomingNotification>;
      readonly request: (
        method: string,
        payload: unknown,
      ) => Effect.Effect<unknown, AcpError.AcpError>;
      readonly notify: (method: string, payload: unknown) => Effect.Effect<void, AcpError.AcpError>;
    };
    readonly client: {
      readonly requestPermission: (
        payload: AcpSchema.RequestPermissionRequest,
      ) => Effect.Effect<AcpSchema.RequestPermissionResponse, AcpError.AcpError>;
      readonly elicit: (
        payload: AcpSchema.CreateElicitationRequest,
      ) => Effect.Effect<AcpSchema.CreateElicitationResponse, AcpError.AcpError>;
      readonly sessionUpdate: (
        payload: AcpSchema.SessionNotification,
      ) => Effect.Effect<void, AcpError.AcpError>;
      readonly elicitationComplete: (
        payload: AcpSchema.CompleteElicitationNotification,
      ) => Effect.Effect<void, AcpError.AcpError>;
      readonly connectMcp: (
        payload: AcpSchema.ConnectMcpRequest,
      ) => Effect.Effect<AcpSchema.ConnectMcpResponse, AcpError.AcpError>;
      readonly messageMcp: (
        payload: AcpSchema.MessageMcpRequest,
      ) => Effect.Effect<AcpSchema.MessageMcpResponse, AcpError.AcpError>;
      readonly disconnectMcp: (
        payload: AcpSchema.DisconnectMcpRequest,
      ) => Effect.Effect<AcpSchema.DisconnectMcpResponse, AcpError.AcpError>;
      readonly notifyMcp: (
        payload: AcpSchema.MessageMcpNotification,
      ) => Effect.Effect<void, AcpError.AcpError>;
      readonly extRequest: (
        method: string,
        payload: unknown,
      ) => Effect.Effect<unknown, AcpError.AcpError>;
      readonly extNotification: (
        method: string,
        payload: unknown,
      ) => Effect.Effect<void, AcpError.AcpError>;
    };
    readonly handleInitialize: (
      handler: AcpRequestHandler<AcpSchema.InitializeRequest, AcpSchema.InitializeResponse>,
    ) => Effect.Effect<void>;
    readonly handleAuthenticate: (
      handler: AcpRequestHandler<AcpSchema.AuthenticateRequest, AcpSchema.AuthenticateResponse>,
    ) => Effect.Effect<void>;
    readonly handleLogout: (
      handler: AcpRequestHandler<AcpSchema.LogoutRequest, AcpSchema.LogoutResponse>,
    ) => Effect.Effect<void>;
    readonly handleCreateSession: (
      handler: AcpRequestHandler<AcpSchema.NewSessionRequest, AcpSchema.NewSessionResponse>,
    ) => Effect.Effect<void>;
    readonly handleLoadSession: (
      handler: AcpRequestHandler<AcpSchema.LoadSessionRequest, AcpSchema.LoadSessionResponse>,
    ) => Effect.Effect<void>;
    readonly handleListSessions: (
      handler: AcpRequestHandler<AcpSchema.ListSessionsRequest, AcpSchema.ListSessionsResponse>,
    ) => Effect.Effect<void>;
    readonly handleForkSession: (
      handler: AcpRequestHandler<AcpSchema.ForkSessionRequest, AcpSchema.ForkSessionResponse>,
    ) => Effect.Effect<void>;
    readonly handleResumeSession: (
      handler: AcpRequestHandler<AcpSchema.ResumeSessionRequest, AcpSchema.ResumeSessionResponse>,
    ) => Effect.Effect<void>;
    readonly handleCloseSession: (
      handler: AcpRequestHandler<AcpSchema.CloseSessionRequest, AcpSchema.CloseSessionResponse>,
    ) => Effect.Effect<void>;
    readonly handleDeleteSession: (
      handler: AcpRequestHandler<AcpSchema.DeleteSessionRequest, AcpSchema.DeleteSessionResponse>,
    ) => Effect.Effect<void>;
    readonly handleListProviders: (
      handler: AcpRequestHandler<AcpSchema.ListProvidersRequest, AcpSchema.ListProvidersResponse>,
    ) => Effect.Effect<void>;
    readonly handleSetProvider: (
      handler: AcpRequestHandler<AcpSchema.SetProviderRequest, AcpSchema.SetProviderResponse>,
    ) => Effect.Effect<void>;
    readonly handleDisableProvider: (
      handler: AcpRequestHandler<
        AcpSchema.DisableProviderRequest,
        AcpSchema.DisableProviderResponse
      >,
    ) => Effect.Effect<void>;
    readonly handleSetSessionConfigOption: (
      handler: AcpRequestHandler<
        AcpSchema.SetSessionConfigOptionRequest,
        AcpSchema.SetSessionConfigOptionResponse
      >,
    ) => Effect.Effect<void>;
    readonly handlePrompt: (
      handler: AcpRequestHandler<AcpSchema.PromptRequest, AcpSchema.PromptResponse>,
    ) => Effect.Effect<void>;
    readonly handleCancel: (
      handler: (
        notification: AcpSchema.CancelNotification,
      ) => Effect.Effect<void, AcpError.AcpError>,
    ) => Effect.Effect<void>;
    readonly handleUnknownExtRequest: (
      handler: (
        method: string,
        params: unknown,
        context: AcpProtocol.AcpRequestContext,
      ) => Effect.Effect<unknown, AcpError.AcpError>,
    ) => Effect.Effect<void>;
    readonly handleUnknownExtNotification: (
      handler: (method: string, params: unknown) => Effect.Effect<void, AcpError.AcpError>,
    ) => Effect.Effect<void>;
    readonly handleExtRequest: <A, I>(
      method: string,
      payload: Schema.Codec<A, I>,
      handler: AcpRequestHandler<A, unknown>,
    ) => Effect.Effect<void>;
    readonly handleExtNotification: <A, I>(
      method: string,
      payload: Schema.Codec<A, I>,
      handler: (payload: A) => Effect.Effect<void, AcpError.AcpError>,
    ) => Effect.Effect<void>;
  }
>()("effect-acp/agent/AcpAgent") {}

interface AcpCoreAgentRequestHandlers {
  initialize?: AcpRequestHandler<AcpSchema.InitializeRequest, AcpSchema.InitializeResponse>;
  authenticate?: AcpRequestHandler<AcpSchema.AuthenticateRequest, AcpSchema.AuthenticateResponse>;
  logout?: AcpRequestHandler<AcpSchema.LogoutRequest, AcpSchema.LogoutResponse>;
  createSession?: AcpRequestHandler<AcpSchema.NewSessionRequest, AcpSchema.NewSessionResponse>;
  loadSession?: AcpRequestHandler<AcpSchema.LoadSessionRequest, AcpSchema.LoadSessionResponse>;
  listSessions?: AcpRequestHandler<AcpSchema.ListSessionsRequest, AcpSchema.ListSessionsResponse>;
  forkSession?: AcpRequestHandler<AcpSchema.ForkSessionRequest, AcpSchema.ForkSessionResponse>;
  resumeSession?: AcpRequestHandler<
    AcpSchema.ResumeSessionRequest,
    AcpSchema.ResumeSessionResponse
  >;
  closeSession?: AcpRequestHandler<AcpSchema.CloseSessionRequest, AcpSchema.CloseSessionResponse>;
  deleteSession?: AcpRequestHandler<
    AcpSchema.DeleteSessionRequest,
    AcpSchema.DeleteSessionResponse
  >;
  listProviders?: AcpRequestHandler<
    AcpSchema.ListProvidersRequest,
    AcpSchema.ListProvidersResponse
  >;
  setProvider?: AcpRequestHandler<AcpSchema.SetProviderRequest, AcpSchema.SetProviderResponse>;
  disableProvider?: AcpRequestHandler<
    AcpSchema.DisableProviderRequest,
    AcpSchema.DisableProviderResponse
  >;
  setSessionConfigOption?: AcpRequestHandler<
    AcpSchema.SetSessionConfigOptionRequest,
    AcpSchema.SetSessionConfigOptionResponse
  >;
  prompt?: AcpRequestHandler<AcpSchema.PromptRequest, AcpSchema.PromptResponse>;
}

const decodeCancelNotification = Schema.decodeUnknownEffect(AcpSchema.CancelNotification);

/** @public */
export const make = Effect.fn("effect-acp/AcpAgent.make")(function* (
  stdio: Stdio.Stdio,
  options: AcpAgentOptions = {},
): Effect.fn.Return<AcpAgent["Service"], never, Scope.Scope> {
  const coreHandlers: AcpCoreAgentRequestHandlers = {};
  const cancelHandlers: Array<
    (notification: AcpSchema.CancelNotification) => Effect.Effect<void, AcpError.AcpError>
  > = [];
  const extRequestHandlers = new Map<string, AcpRequestHandler<unknown, unknown>>();
  const extNotificationHandlers = new Map<
    string,
    (params: unknown) => Effect.Effect<void, AcpError.AcpError>
  >();
  let unknownExtRequestHandler:
    | ((
        method: string,
        params: unknown,
        context: AcpProtocol.AcpRequestContext,
      ) => Effect.Effect<unknown, AcpError.AcpError>)
    | undefined;
  let unknownExtNotificationHandler:
    | ((method: string, params: unknown) => Effect.Effect<void, AcpError.AcpError>)
    | undefined;

  const transport = yield* AcpProtocol.makeAcpPatchedProtocol({
    stdio,
    serverRequestMethods: new Set(AcpRpcs.AgentRpcs.requests.keys()),
    ...(options.logIncoming !== undefined ? { logIncoming: options.logIncoming } : {}),
    ...(options.logOutgoing !== undefined ? { logOutgoing: options.logOutgoing } : {}),
    ...(options.logger ? { logger: options.logger } : {}),
    onNotification: (notification) => {
      if (
        notification._tag === "ExtNotification" &&
        notification.method === AGENT_METHODS.session_cancel
      ) {
        return decodeCancelNotification(notification.params).pipe(
          Effect.mapError((error) =>
            AcpError.AcpProtocolParseError.fromSchemaError(
              "decode-notification-payload",
              AGENT_METHODS.session_cancel,
              error,
            ),
          ),
          Effect.flatMap((decoded) =>
            Effect.forEach(
              cancelHandlers,
              (handler) => isolateNotificationHandler(handler(decoded)),
              { discard: true },
            ),
          ),
        );
      }

      if (notification._tag !== "ExtNotification") {
        return Effect.void;
      }

      const handler = extNotificationHandlers.get(notification.method);
      if (handler) {
        return handler(notification.params);
      }
      return unknownExtNotificationHandler
        ? unknownExtNotificationHandler(notification.method, notification.params)
        : Effect.void;
    },
    onExtRequest: (method, params, context) => {
      const handler = extRequestHandlers.get(method);
      if (handler) {
        return handler(params, context);
      }
      return unknownExtRequestHandler
        ? unknownExtRequestHandler(method, params, context)
        : Effect.fail(AcpError.AcpRequestError.methodNotFound(method));
    },
  });

  const requestContext = (
    requestId: RpcMessage.RequestId,
    method: string,
  ): AcpProtocol.AcpRequestContext => ({
    requestId: AcpProtocol.acpRequestIdentity(requestId),
    method,
  });

  const layerAgentHandler = AcpRpcs.AgentRpcs.toLayer(
    AcpRpcs.AgentRpcs.of({
      [AGENT_METHODS.initialize]: (payload, { requestId }) =>
        runHandler(
          coreHandlers.initialize,
          payload,
          AGENT_METHODS.initialize,
          requestContext(requestId, AGENT_METHODS.initialize),
        ),
      [AGENT_METHODS.auth_login]: (payload, { requestId }) =>
        runHandler(
          coreHandlers.authenticate,
          payload,
          AGENT_METHODS.auth_login,
          requestContext(requestId, AGENT_METHODS.auth_login),
        ),
      [AGENT_METHODS.auth_logout]: (payload, { requestId }) =>
        runHandler(
          coreHandlers.logout,
          payload,
          AGENT_METHODS.auth_logout,
          requestContext(requestId, AGENT_METHODS.auth_logout),
        ),
      [AGENT_METHODS.session_new]: (payload, { requestId }) =>
        runHandler(
          coreHandlers.createSession,
          payload,
          AGENT_METHODS.session_new,
          requestContext(requestId, AGENT_METHODS.session_new),
        ),
      [AGENT_METHODS.session_list]: (payload, { requestId }) =>
        runHandler(
          coreHandlers.listSessions,
          payload,
          AGENT_METHODS.session_list,
          requestContext(requestId, AGENT_METHODS.session_list),
        ),
      [AGENT_METHODS.session_fork]: (payload, { requestId }) =>
        runHandler(
          coreHandlers.forkSession,
          payload,
          AGENT_METHODS.session_fork,
          requestContext(requestId, AGENT_METHODS.session_fork),
        ),
      [AGENT_METHODS.session_resume]: (payload, { requestId }) =>
        runHandler(
          payload.replayFrom?.type === "start"
            ? (coreHandlers.loadSession ?? coreHandlers.resumeSession)
            : (coreHandlers.resumeSession ?? coreHandlers.loadSession),
          payload,
          AGENT_METHODS.session_resume,
          requestContext(requestId, AGENT_METHODS.session_resume),
        ),
      [AGENT_METHODS.session_close]: (payload, { requestId }) =>
        runHandler(
          coreHandlers.closeSession,
          payload,
          AGENT_METHODS.session_close,
          requestContext(requestId, AGENT_METHODS.session_close),
        ),
      [AGENT_METHODS.session_delete]: (payload, { requestId }) =>
        runHandler(
          coreHandlers.deleteSession,
          payload,
          AGENT_METHODS.session_delete,
          requestContext(requestId, AGENT_METHODS.session_delete),
        ),
      [AGENT_METHODS.providers_list]: (payload, { requestId }) =>
        runHandler(
          coreHandlers.listProviders,
          payload,
          AGENT_METHODS.providers_list,
          requestContext(requestId, AGENT_METHODS.providers_list),
        ),
      [AGENT_METHODS.providers_set]: (payload, { requestId }) =>
        runHandler(
          coreHandlers.setProvider,
          payload,
          AGENT_METHODS.providers_set,
          requestContext(requestId, AGENT_METHODS.providers_set),
        ),
      [AGENT_METHODS.providers_disable]: (payload, { requestId }) =>
        runHandler(
          coreHandlers.disableProvider,
          payload,
          AGENT_METHODS.providers_disable,
          requestContext(requestId, AGENT_METHODS.providers_disable),
        ),
      [AGENT_METHODS.session_set_config_option]: (payload, { requestId }) =>
        runHandler(
          coreHandlers.setSessionConfigOption,
          payload,
          AGENT_METHODS.session_set_config_option,
          requestContext(requestId, AGENT_METHODS.session_set_config_option),
        ),
      [AGENT_METHODS.session_prompt]: (payload, { requestId }) =>
        runHandler(
          coreHandlers.prompt,
          payload,
          AGENT_METHODS.session_prompt,
          requestContext(requestId, AGENT_METHODS.session_prompt),
        ),
    }),
  );

  yield* RpcServer.make(AcpRpcs.AgentRpcs, { disableFatalDefects: true }).pipe(
    Effect.provideService(ErrorReporter.CurrentErrorReporters, new Set()),
    Effect.provideService(RpcServer.Protocol, transport.serverProtocol),
    Effect.provide(layerAgentHandler),
    Effect.forkScoped,
  );

  let nextRpcRequestId = AcpProtocol.RPC_REQUEST_ID_START;
  const rpc = yield* RpcClient.make(AcpRpcs.ClientRpcs, {
    generateRequestId: () => RpcMessage.RequestId(nextRpcRequestId++),
  }).pipe(Effect.provideService(RpcClient.Protocol, transport.clientProtocol));

  return AcpAgent.of({
    raw: {
      notifications: transport.incoming,
      request: transport.request,
      notify: transport.notify,
    },
    client: {
      requestPermission: (payload) =>
        callRpc(
          CLIENT_METHODS.session_request_permission,
          rpc[CLIENT_METHODS.session_request_permission](payload),
        ),
      elicit: (payload) =>
        callRpc(CLIENT_METHODS.elicitation_create, rpc[CLIENT_METHODS.elicitation_create](payload)),
      sessionUpdate: (payload) => transport.notify(CLIENT_METHODS.session_update, payload),
      elicitationComplete: (payload) =>
        transport.notify(CLIENT_METHODS.elicitation_complete, payload),
      connectMcp: (payload) =>
        callRpc(CLIENT_METHODS.mcp_connect, rpc[CLIENT_METHODS.mcp_connect](payload)),
      messageMcp: (payload) =>
        callRpc(CLIENT_METHODS.mcp_message, rpc[CLIENT_METHODS.mcp_message](payload)),
      disconnectMcp: (payload) =>
        callRpc(CLIENT_METHODS.mcp_disconnect, rpc[CLIENT_METHODS.mcp_disconnect](payload)),
      notifyMcp: (payload) => transport.notify(CLIENT_METHODS.mcp_message, payload),
      extRequest: transport.request,
      extNotification: transport.notify,
    },
    handleInitialize: Effect.fn("AcpAgent.handleInitialize")(function (handler) {
      return Effect.suspend(() => {
        coreHandlers.initialize = handler;
        return Effect.void;
      });
    }),
    handleAuthenticate: Effect.fn("AcpAgent.handleAuthenticate")(function (handler) {
      return Effect.suspend(() => {
        coreHandlers.authenticate = handler;
        return Effect.void;
      });
    }),
    handleLogout: Effect.fn("AcpAgent.handleLogout")(function (handler) {
      return Effect.suspend(() => {
        coreHandlers.logout = handler;
        return Effect.void;
      });
    }),
    handleCreateSession: Effect.fn("AcpAgent.handleCreateSession")(function (handler) {
      return Effect.suspend(() => {
        coreHandlers.createSession = handler;
        return Effect.void;
      });
    }),
    handleLoadSession: Effect.fn("AcpAgent.handleLoadSession")(function (handler) {
      return Effect.suspend(() => {
        coreHandlers.loadSession = handler;
        return Effect.void;
      });
    }),
    handleListSessions: Effect.fn("AcpAgent.handleListSessions")(function (handler) {
      return Effect.suspend(() => {
        coreHandlers.listSessions = handler;
        return Effect.void;
      });
    }),
    handleForkSession: Effect.fn("AcpAgent.handleForkSession")(function (handler) {
      return Effect.suspend(() => {
        coreHandlers.forkSession = handler;
        return Effect.void;
      });
    }),
    handleResumeSession: Effect.fn("AcpAgent.handleResumeSession")(function (handler) {
      return Effect.suspend(() => {
        coreHandlers.resumeSession = handler;
        return Effect.void;
      });
    }),
    handleCloseSession: Effect.fn("AcpAgent.handleCloseSession")(function (handler) {
      return Effect.suspend(() => {
        coreHandlers.closeSession = handler;
        return Effect.void;
      });
    }),
    handleDeleteSession: Effect.fn("AcpAgent.handleDeleteSession")(function (handler) {
      return Effect.suspend(() => {
        coreHandlers.deleteSession = handler;
        return Effect.void;
      });
    }),
    handleListProviders: Effect.fn("AcpAgent.handleListProviders")(function (handler) {
      return Effect.suspend(() => {
        coreHandlers.listProviders = handler;
        return Effect.void;
      });
    }),
    handleSetProvider: Effect.fn("AcpAgent.handleSetProvider")(function (handler) {
      return Effect.suspend(() => {
        coreHandlers.setProvider = handler;
        return Effect.void;
      });
    }),
    handleDisableProvider: Effect.fn("AcpAgent.handleDisableProvider")(function (handler) {
      return Effect.suspend(() => {
        coreHandlers.disableProvider = handler;
        return Effect.void;
      });
    }),
    handleSetSessionConfigOption: Effect.fn("AcpAgent.handleSetSessionConfigOption")(
      function (handler) {
        return Effect.suspend(() => {
          coreHandlers.setSessionConfigOption = handler;
          return Effect.void;
        });
      },
    ),
    handlePrompt: Effect.fn("AcpAgent.handlePrompt")(function (handler) {
      return Effect.suspend(() => {
        coreHandlers.prompt = handler;
        return Effect.void;
      });
    }),
    handleCancel: Effect.fn("AcpAgent.handleCancel")(function (handler) {
      return Effect.suspend(() => {
        cancelHandlers.push(handler);
        return Effect.void;
      });
    }),
    handleUnknownExtRequest: Effect.fn("AcpAgent.handleUnknownExtRequest")(function (handler) {
      return Effect.suspend(() => {
        unknownExtRequestHandler = handler;
        return Effect.void;
      });
    }),
    handleUnknownExtNotification: Effect.fn("AcpAgent.handleUnknownExtNotification")(
      function (handler) {
        return Effect.suspend(() => {
          unknownExtNotificationHandler = handler;
          return Effect.void;
        });
      },
    ),
    handleExtRequest: Effect.fn("AcpAgent.handleExtRequest")(function (method, payload, handler) {
      return Effect.suspend(() => {
        extRequestHandlers.set(method, decodeExtRequestRegistration(method, payload, handler));
        return Effect.void;
      });
    }),
    handleExtNotification: Effect.fn("AcpAgent.handleExtNotification")(
      function (method, payload, handler) {
        return Effect.suspend(() => {
          extNotificationHandlers.set(
            method,
            decodeExtNotificationRegistration(method, payload, handler),
          );
          return Effect.void;
        });
      },
    ),
  });
});

export const layer = (stdio: Stdio.Stdio, options: AcpAgentOptions = {}): Layer.Layer<AcpAgent> =>
  Layer.effect(AcpAgent, make(stdio, options));

export const layerStdio = (
  options: AcpAgentOptions = {},
): Layer.Layer<AcpAgent, never, Stdio.Stdio> =>
  Layer.effect(
    AcpAgent,
    Effect.flatMap(Effect.service(Stdio.Stdio), (stdio) => make(stdio, options)),
  );