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

import * as Deferred from "effect/Deferred";
import * as Effect from "effect/Effect";
import * as Exit from "effect/Exit";
import * as Fiber from "effect/Fiber";
import * as Layer from "effect/Layer";
import * as Queue from "effect/Queue";
import * as Ref from "effect/Ref";
import * as Schema from "effect/Schema";
import * as Scope from "effect/Scope";

import { assert, it } from "@effect/vitest";

import * as AcpAgent from "./agent.ts";
import * as AcpSchema from "./_generated/schema.gen.ts";
import type * as AcpProtocol from "./protocol.ts";
import {
  encodeJsonl,
  jsonRpcNotification,
  jsonRpcRequest,
  jsonRpcResponse,
} from "./_internal/shared.ts";
import { makeInMemoryStdio } from "./_internal/stdio.ts";

const RequestPermissionRequest = jsonRpcRequest(
  "session/request_permission",
  AcpSchema.RequestPermissionRequest,
);
const InitializeRequest = jsonRpcRequest("initialize", AcpSchema.InitializeRequest);
const InitializeResponse = jsonRpcResponse(AcpSchema.InitializeResponse);
const RequestPermissionResponse = jsonRpcResponse(AcpSchema.RequestPermissionResponse);
const SessionCancelNotification = jsonRpcNotification(
  "session/cancel",
  AcpSchema.CancelSessionNotification,
);
const ExtPingNotification = jsonRpcNotification("x/ping", Schema.Struct({ count: Schema.Number }));
const ExtRequest = jsonRpcRequest("x/test", Schema.Struct({ hello: Schema.String }));
const ExtResponse = jsonRpcResponse(Schema.Struct({ ok: Schema.Boolean }));
const DieResponse = Schema.Struct({
  id: Schema.Number,
  error: Schema.TaggedStruct("Cause", { data: Schema.Tuple([Schema.TaggedStruct("Die", {})]) }),
});
const decodeRequestPermissionRequest = Schema.decodeEffect(
  Schema.fromJsonString(RequestPermissionRequest),
);
const decodeInitializeResponse = Schema.decodeEffect(Schema.fromJsonString(InitializeResponse));
const decodeExtResponse = Schema.decodeEffect(Schema.fromJsonString(ExtResponse));

it.effect("effect-acp agent handles core agent requests and outbound client requests", () =>
  Effect.gen(function* () {
    const { stdio, input, output } = yield* makeInMemoryStdio();
    const cancelNotifications = yield* Ref.make<Array<string>>([]);
    const extNotifications = yield* Ref.make<Array<number>>([]);
    const requestContexts = yield* Ref.make<Array<AcpProtocol.AcpRequestContext>>([]);
    const cancelReceived = yield* Deferred.make<void>();
    const extReceived = yield* Deferred.make<void>();
    const scope = yield* Scope.make();
    const context = yield* Layer.buildWithScope(AcpAgent.layer(stdio), scope);

    yield* Effect.gen(function* () {
      const agent = yield* AcpAgent.AcpAgent;

      yield* agent.handleInitialize((_request, requestContext) =>
        Ref.update(requestContexts, (current) => [...current, requestContext]).pipe(
          Effect.as({
            protocolVersion: 2,
            capabilities: {},
            info: {
              name: "mock-agent",
              version: "0.0.0",
            },
          }),
        ),
      );
      yield* agent.handleExtRequest(
        "x/test",
        Schema.Struct({ hello: Schema.String }),
        (_payload, requestContext) =>
          Ref.update(requestContexts, (current) => [...current, requestContext]).pipe(
            Effect.as({ ok: true }),
          ),
      );
      yield* agent.handleCancel((notification) =>
        Ref.update(cancelNotifications, (current) => [...current, notification.sessionId]).pipe(
          Effect.andThen(Deferred.succeed(cancelReceived, undefined)),
        ),
      );
      yield* agent.handleExtNotification(
        "x/ping",
        Schema.Struct({ count: Schema.Number }),
        (payload) =>
          Ref.update(extNotifications, (current) => [...current, payload.count]).pipe(
            Effect.andThen(Deferred.succeed(extReceived, undefined)),
          ),
      );

      const permissionFiber = yield* agent.client
        .requestPermission({
          sessionId: "session-1",
          title: "Allow mock action",
          subject: {
            type: "tool_call",
            toolCall: {
              toolCallId: "tool-1",
              title: "Allow mock action",
            },
          },
          options: [{ optionId: "allow", name: "Allow", kind: "allow_once" }],
        })
        .pipe(Effect.forkScoped);

      const permissionRequest = yield* decodeRequestPermissionRequest(yield* Queue.take(output));
      assert.equal(permissionRequest.jsonrpc, "2.0");
      assert.equal(permissionRequest.method, "session/request_permission");
      assert.deepEqual(permissionRequest.params, {
        sessionId: "session-1",
        title: "Allow mock action",
        subject: {
          type: "tool_call",
          toolCall: {
            toolCallId: "tool-1",
            title: "Allow mock action",
          },
        },
        options: [{ optionId: "allow", name: "Allow", kind: "allow_once" }],
      });
      assert.deepEqual(permissionRequest.headers, []);

      yield* Queue.offer(
        input,
        yield* encodeJsonl(RequestPermissionResponse, {
          jsonrpc: "2.0",
          id: permissionRequest.id,
          result: {
            outcome: {
              outcome: "selected",
              optionId: "allow",
            },
          },
        }),
      );

      const permission = yield* Fiber.join(permissionFiber);
      assert.equal(permission.outcome.outcome, "selected");

      yield* Queue.offer(
        input,
        yield* encodeJsonl(InitializeRequest, {
          jsonrpc: "2.0",
          id: 2,
          method: "initialize",
          params: {
            protocolVersion: 2,
            capabilities: {},
            info: {
              name: "effect-acp-test",
              version: "0.0.0",
            },
          },
          headers: [],
        }),
      );

      const initResponse = yield* decodeInitializeResponse(yield* Queue.take(output));
      assert.deepEqual(initResponse, {
        jsonrpc: "2.0",
        id: 2,
        result: {
          protocolVersion: 2,
          capabilities: {},
          info: {
            name: "mock-agent",
            version: "0.0.0",
          },
        },
      });

      yield* Queue.offer(
        input,
        yield* encodeJsonl(ExtRequest, {
          jsonrpc: "2.0",
          id: "extension-3",
          method: "x/test",
          params: { hello: "world" },
          headers: [],
        }),
      );
      const extResponse = yield* decodeExtResponse(yield* Queue.take(output));
      assert.deepEqual(extResponse, {
        jsonrpc: "2.0",
        id: "extension-3",
        result: { ok: true },
      });
      assert.deepEqual(yield* Ref.get(requestContexts), [
        { requestId: "$t3:jsonrpc:number:2", method: "initialize" },
        { requestId: "extension-3", method: "x/test" },
      ]);

      yield* Queue.offer(
        input,
        yield* encodeJsonl(SessionCancelNotification, {
          jsonrpc: "2.0",
          method: "session/cancel",
          params: {
            sessionId: "session-1",
          },
        }),
      );
      yield* Queue.offer(
        input,
        yield* encodeJsonl(ExtPingNotification, {
          jsonrpc: "2.0",
          method: "x/ping",
          params: { count: 2 },
        }),
      );

      yield* Deferred.await(cancelReceived);
      yield* Deferred.await(extReceived);
      assert.deepEqual(yield* Ref.get(cancelNotifications), ["session-1"]);
      assert.deepEqual(yield* Ref.get(extNotifications), [2]);
    }).pipe(Effect.provide(context), Effect.ensuring(Scope.close(scope, Exit.void)));
  }),
);

it.effect("effect-acp agent keeps RPC ids within int32 and apart from extension ids", () =>
  Effect.gen(function* () {
    const { stdio, input, output } = yield* makeInMemoryStdio();
    const scope = yield* Scope.make();
    const context = yield* Layer.buildWithScope(AcpAgent.layer(stdio), scope);

    yield* Effect.gen(function* () {
      const agent = yield* AcpAgent.AcpAgent;

      const permissionFiber = yield* agent.client
        .requestPermission({
          sessionId: "session-1",
          title: "Allow mock action",
          subject: {
            type: "tool_call",
            toolCall: {
              toolCallId: "tool-1",
              title: "Allow mock action",
            },
          },
          options: [{ optionId: "allow", name: "Allow", kind: "allow_once" }],
        })
        .pipe(Effect.forkScoped);
      const extFiber = yield* agent.client
        .extRequest("x/test", { hello: "world" })
        .pipe(Effect.forkScoped);

      const firstOutbound = yield* Queue.take(output);
      const secondOutbound = yield* Queue.take(output);

      const decodedPermission = Schema.decodeEffect(
        Schema.fromJsonString(RequestPermissionRequest),
      );
      const decodedExt = Schema.decodeEffect(Schema.fromJsonString(ExtRequest));
      const firstIsPermission = yield* decodedPermission(firstOutbound).pipe(Effect.isSuccess);

      const permissionRequest = firstIsPermission
        ? yield* decodedPermission(firstOutbound)
        : yield* decodedPermission(secondOutbound);
      const extRequest = firstIsPermission
        ? yield* decodedExt(secondOutbound)
        : yield* decodedExt(firstOutbound);

      assert.notEqual(permissionRequest.id, extRequest.id);
      // Keep locally generated ids compatible with SDKs that decode signed int32.
      assert.typeOf(permissionRequest.id, "number");
      assert.equal(permissionRequest.id, 2 ** 30);
      assert.isAtMost(Number(permissionRequest.id), 2 ** 31 - 1);
      assert.equal(extRequest.id, 1);

      yield* Queue.offer(
        input,
        yield* encodeJsonl(RequestPermissionResponse, {
          jsonrpc: "2.0",
          id: permissionRequest.id,
          result: {
            outcome: {
              outcome: "selected",
              optionId: "allow",
            },
          },
        }),
      );
      yield* Queue.offer(
        input,
        yield* encodeJsonl(ExtResponse, {
          jsonrpc: "2.0",
          id: extRequest.id,
          result: { ok: true },
        }),
      );

      const permission = yield* Fiber.join(permissionFiber);
      assert.equal(permission.outcome.outcome, "selected");
      assert.deepEqual(yield* Fiber.join(extFiber), { ok: true });

      const nextPermissionFiber = yield* agent.client
        .requestPermission(permissionRequest.params)
        .pipe(Effect.forkScoped);
      const nextPermissionRequest = yield* decodedPermission(yield* Queue.take(output));
      assert.equal(nextPermissionRequest.id, 2 ** 30 + 1);
      yield* Queue.offer(
        input,
        yield* encodeJsonl(RequestPermissionResponse, {
          jsonrpc: "2.0",
          id: nextPermissionRequest.id,
          result: { outcome: { outcome: "cancelled" } },
        }),
      );
      assert.equal((yield* Fiber.join(nextPermissionFiber)).outcome.outcome, "cancelled");
    }).pipe(Effect.provide(context), Effect.ensuring(Scope.close(scope, Exit.void)));
  }),
);

it.effect.each([0, 2 ** 30, 2 ** 32])(
  "effect-acp agent answers incoming id %s independently of outbound ids",
  (requestId) =>
    Effect.gen(function* () {
      const { stdio, input, output } = yield* makeInMemoryStdio();
      const agent = yield* AcpAgent.make(stdio);
      const contexts = yield* Ref.make<Array<AcpProtocol.AcpRequestContext>>([]);
      yield* agent.handleInitialize((_request, context) =>
        Ref.update(contexts, (current) => [...current, context]).pipe(
          Effect.as({
            protocolVersion: 2,
            capabilities: {},
            info: { name: "mock-agent", version: "0.0.0" },
          }),
        ),
      );

      // Opposite directions may reuse an id even while a request is pending.
      const outboundFiber = yield* agent.client
        .requestPermission({
          sessionId: "session-1",
          title: "Allow mock action",
          subject: {
            type: "tool_call",
            toolCall: { toolCallId: "tool-1", title: "Allow mock action" },
          },
          options: [{ optionId: "allow", name: "Allow", kind: "allow_once" }],
        })
        .pipe(Effect.forkScoped);
      const outbound = yield* decodeRequestPermissionRequest(yield* Queue.take(output));

      yield* Queue.offer(
        input,
        yield* encodeJsonl(InitializeRequest, {
          jsonrpc: "2.0",
          id: requestId,
          method: "initialize",
          params: {
            protocolVersion: 2,
            capabilities: {},
            info: { name: "test-client", version: "0.0.0" },
          },
          headers: [],
        }),
      );
      assert.deepEqual(yield* decodeInitializeResponse(yield* Queue.take(output)), {
        jsonrpc: "2.0",
        id: requestId,
        result: {
          protocolVersion: 2,
          capabilities: {},
          info: { name: "mock-agent", version: "0.0.0" },
        },
      });
      assert.deepEqual(yield* Ref.get(contexts), [
        { requestId: `$t3:jsonrpc:number:${requestId}`, method: "initialize" },
      ]);

      yield* Queue.offer(
        input,
        yield* encodeJsonl(RequestPermissionResponse, {
          jsonrpc: "2.0",
          id: outbound.id,
          result: { outcome: { outcome: "cancelled" } },
        }),
      );
      assert.equal((yield* Fiber.join(outboundFiber)).outcome.outcome, "cancelled");
    }),
);

it.effect("effect-acp agent answers a request whose handler dies with an error for it", () =>
  Effect.gen(function* () {
    const { stdio, input, output } = yield* makeInMemoryStdio();
    const scope = yield* Scope.make();
    const context = yield* Layer.buildWithScope(AcpAgent.layer(stdio), scope);
    const agent = yield* Effect.service(AcpAgent.AcpAgent).pipe(Effect.provide(context));
    yield* agent.handleInitialize(() => Effect.die(new Error("handler bug")));

    yield* Queue.offer(
      input,
      yield* encodeJsonl(InitializeRequest, {
        jsonrpc: "2.0",
        id: 7,
        method: "initialize",
        params: {
          protocolVersion: 2,
          capabilities: {},
          info: { name: "effect-acp-test", version: "0.0.0" },
        },
        headers: [],
      }),
    );
    const response = yield* Queue.take(output).pipe(
      Effect.flatMap(Schema.decodeEffect(Schema.fromJsonString(DieResponse))),
    );
    assert.equal(response.id, 7);
    yield* Scope.close(scope, Exit.void);
  }),
);