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

import { describe, expect, it } from "@effect/vitest";
import * as Effect from "effect/Effect";
import * as Schema from "effect/Schema";
import * as RpcClientError from "effect/rpc/RpcClientError";

import { callRpc } from "./_internal/shared.ts";
import * as AcpError from "./errors.ts";

const decodeNestedNumberPayload = Schema.decodeUnknownEffect(
  Schema.Struct({ profile: Schema.Struct({ token: Schema.Number }) }),
);
const encodeUnknownJson = Schema.encodeSync(Schema.fromJsonString(Schema.Unknown));

describe("effect-acp errors", () => {
  it.effect("retains RPC method and cause without deriving the message from the cause", () => {
    const rootCause = new Error("connection details that must not become the public message");
    const failure = new RpcClientError.RpcClientError({
      reason: new RpcClientError.RpcClientDefect({
        message: rootCause.message,
        cause: rootCause,
      }),
    });

    return Effect.gen(function* () {
      const error = yield* callRpc("session/new", Effect.fail(failure)).pipe(Effect.flip);

      expect(error).toMatchObject({
        _tag: "AcpTransportError",
        operation: "call-rpc",
        method: "session/new",
        cause: failure,
      });
      expect(error.message).toBe("ACP transport operation call-rpc failed for method session/new.");
      expect(error.message).not.toContain(rootCause.message);
    });
  });

  it.effect("preserves typed ACP failures carried by the RPC protocol", () => {
    const original = new AcpError.AcpTransportError({
      detail: "Sign in to the agent.",
      cause: undefined,
    });
    const failure = new RpcClientError.RpcClientError({
      reason: new RpcClientError.RpcClientDefect({
        message: "ACP protocol terminated.",
        cause: original,
      }),
    });

    return Effect.gen(function* () {
      const error = yield* callRpc("initialize", Effect.fail(failure)).pipe(Effect.flip);
      expect(error).toBe(original);
    });
  });

  it("includes the authored detail but not the cause in the transport message", () => {
    const cause = new Error("connection refused at a private endpoint");
    const error = new AcpError.AcpTransportError({
      detail: "ACP replay did not consume all frames",
      cause,
    });

    expect(error.message).toBe(
      "ACP transport operation failed: ACP replay did not consume all frames.",
    );
    expect(error.cause).toBe(cause);
  });

  it("preserves structured extension handler failures behind stable request errors", () => {
    const cause = new AcpError.AcpTransportError({
      operation: "read-input-stream",
      cause: new Error("private transport diagnostics"),
    });
    const error = AcpError.AcpRequestError.fromExtensionHandlerError(cause, "x/test");

    expect(error).toMatchObject({
      code: -32603,
      method: "x/test",
      operation: "handle-extension-request",
      cause,
    });
    expect(error.message).toBe("ACP extension request handler failed for method 'x/test'");
    expect(error.message).not.toContain(cause.message);
  });

  it.effect("keeps invalid extension payload values only in the exact schema cause", () =>
    Effect.gen(function* () {
      const secret = "acp-schema-payload-secret";
      const cause = yield* decodeNestedNumberPayload({ profile: { token: secret } }).pipe(
        Effect.flip,
      );
      const error = AcpError.AcpRequestError.invalidExtensionPayload("x/private", cause);
      const { cause: directCause, ...directDiagnostics } = error;

      expect(directCause).toBe(cause);
      expect(error).toMatchObject({
        method: "x/private",
        operation: "decode-extension-request-payload",
        maximumPathDepth: 2,
      });
      expect(error.issueCount).toBeGreaterThan(0);
      expect(error.issueKinds).toContain("Pointer");
      expect(error.message).toBe("Invalid payload for ACP extension method 'x/private'.");
      expect(error.message).not.toContain(secret);
      expect(encodeUnknownJson(directDiagnostics)).not.toContain(secret);
      expect(encodeUnknownJson(error.toProtocolError())).not.toContain(secret);

      const protocolError = AcpError.AcpProtocolParseError.fromSchemaError(
        "decode-notification-payload",
        "x/private",
        cause,
      );
      const { cause: protocolCause, ...protocolDiagnostics } = protocolError;
      expect(protocolCause).toBe(cause);
      expect(protocolError).toMatchObject({
        method: "x/private",
        operation: "decode-notification-payload",
        maximumPathDepth: 2,
      });
      expect(protocolError.message).not.toContain(secret);
      expect(encodeUnknownJson(protocolDiagnostics)).not.toContain(secret);
      expect("detail" in protocolError).toBe(false);
    }),
  );

  it.effect("summarizes schema issues by path without payload values", () =>
    Effect.gen(function* () {
      const secret = "acp-summary-secret";
      const decodeStruct = Schema.decodeUnknownEffect(
        Schema.Struct({
          update: Schema.Struct({ used: Schema.Number, size: Schema.Number }),
          env: Schema.Record(Schema.String, Schema.Number),
        }),
      );

      const cause = yield* decodeStruct(
        { update: { size: secret }, env: { [`${secret} key`]: secret } },
        { errors: "all" },
      ).pipe(Effect.flip);
      const error = AcpError.AcpProtocolParseError.fromSchemaError(
        "decode-notification-payload",
        "session/update",
        cause,
      );

      expect(error.issueSummary).toBe(
        "update.used missing, update.size wrong type, env.* wrong type",
      );
      expect(error.message).toBe(
        "ACP protocol operation 'decode-notification-payload' failed for method 'session/update': update.used missing, update.size wrong type, env.* wrong type.",
      );
      expect(error.message).not.toContain(secret);
    }),
  );
});