sailfork / t3code-github / packages/ provider-cursor/ src/ server/ adapter.test.ts

import * as NodeServices from "@effect/platform-node/NodeServices";
import { assert, describe, it } from "@effect/vitest";
import type { InteractionUpdate } from "@cursor/sdk";
import { toolOutputImages } from "@t3tools/shared/toolOutput";
import {
  EnvironmentId,
  MessageId,
  NodeId,
  ProjectId,
  ProviderInstanceId,
  ProviderSessionId,
  RunAttemptId,
  RunId,
  ThreadId,
} from "@t3tools/contracts";
import * as DateTime from "effect/DateTime";
import * as Effect from "effect/Effect";
import * as FileSystem from "effect/FileSystem";
import * as Layer from "effect/Layer";
import * as Option from "effect/Option";
import * as Path from "effect/Path";
import * as Stream from "effect/Stream";

import * as TestProviderHost from "@t3tools/provider-testing/TestProviderHost";
import * as IdAllocator from "@t3tools/provider-core/server/IdAllocator";
import * as McpProviderSessions from "@t3tools/provider-core/server/McpProviderSessions";
import * as ProviderAdapter from "@t3tools/provider-core/server/ProviderAdapter";
import { makeProviderFailure } from "@t3tools/provider-core/server/failure";
import {
  cursorMcpServers,
  cursorRuntimeAgentPolicy,
  makeCursorAgentOptions,
  makeCursorAdapterV2,
  nestedToolCallFromEnvelope,
} from "./adapter.ts";
import * as CursorAgentSdk from "./CursorAgentSdk.ts";
import { loadCursorSdk } from "./sdk.ts";

const { ConfigurationError } = loadCursorSdk();

describe("CursorAdapterV2", () => {
  it.effect.each([
    { status: "finished", model: undefined, lateModel: undefined },
    { status: "cancelled", model: "claude-opus-4-6", lateModel: undefined },
    { status: "error", model: "custom-fable", lateModel: undefined },
    { status: "finished", model: undefined, lateModel: "gpt-6-sol" },
    { status: "finished", model: "gpt-6-sol", lateModel: null },
  ] as const)(
    "projects Cursor tasks and unfinished tools: $status, late model $lateModel",
    ({ status, model, lateModel }) =>
      Effect.gen(function* () {
        const fileSystem = yield* FileSystem.FileSystem;
        const workspace = yield* fileSystem.makeTempDirectoryScoped({
          prefix: "cursor-v2-lifecycle-",
        });
        const instanceId = ProviderInstanceId.make("cursor");
        const threadId = ThreadId.make("cursor-lifecycle-thread");
        const mcpSessions = yield* McpProviderSessions.McpProviderSessions;
        yield* mcpSessions.set({
          environmentId: EnvironmentId.make("cursor-lifecycle-environment"),
          threadId,
          providerSessionId: "cursor-lifecycle-session",
          providerInstanceId: instanceId,
          endpoint: "http://127.0.0.1:43123/mcp",
          authorizationHeader: "Bearer synthetic-cursor-token",
          browserToolsAvailable: true,
        });
        let sentWithMcpOverride = true;
        const modelSelection = { instanceId, model: "composer-2.5" };
        const runtimePolicy = ProviderAdapter.ProviderAdapterV2RuntimePolicy.make({
          runtimeMode: "full-access",
          interactionMode: "default",
          cwd: workspace,
        });
        const adapter = yield* makeCursorAdapterV2({
          instanceId,
          environment: { HOME: workspace },
        }).pipe(
          Effect.provideService(CursorAgentSdk.CursorAgentSdkRunner, {
            assertComplete: Effect.void,
            open: () =>
              Effect.succeed({
                agentId: "native-cursor-lifecycle",
                listMessages: Effect.succeed([]),
                close: Effect.void,
                send: (input) =>
                  Effect.gen(function* () {
                    sentWithMcpOverride = Object.hasOwn(input.options ?? {}, "mcpServers");
                    // Recorded tasks stream partial args before start, then end without completion; live runs cannot force this.
                    const taskToolCall = {
                      type: "task" as const,
                      args: {
                        description: "Review",
                        prompt: "Review the code.",
                        subagentType: { kind: "unspecified" },
                        ...(model === undefined ? {} : { model }),
                        agentId: "cursor-task-agent",
                        mode: "unspecified" as const,
                      },
                    };
                    const updates =
                      lateModel !== undefined
                        ? (["tool-call-started", "tool-call-completed"] as const)
                        : (["partial-tool-call", "tool-call-started"] as const);
                    for (const type of updates) {
                      yield* input.onDelta!({
                        type,
                        modelCallId: "model-call",
                        callId: "task-call",
                        toolCall: {
                          ...taskToolCall,
                          args: {
                            ...taskToolCall.args,
                            ...(type === "tool-call-completed"
                              ? { model: lateModel ?? undefined }
                              : {}),
                          },
                        },
                      });
                    }
                    const readUpdates: ReadonlyArray<InteractionUpdate> = [
                      {
                        type: "tool-call-started",
                        modelCallId: "native-model-call",
                        callId: "read-secret",
                        toolCall: { type: "read", args: { path: "secret.txt" } },
                      },
                      ...(["tool-call-started", "tool-call-completed"] as const).map((type) => ({
                        type,
                        modelCallId: "native-model-call",
                        callId: "read-open",
                        toolCall: {
                          type: "read" as const,
                          args: { path: "open.txt" },
                          ...(type === "tool-call-completed"
                            ? {
                                result: {
                                  status: "success" as const,
                                  value: { fileSize: 3, content: "ok\n", totalLines: 1 },
                                },
                              }
                            : {}),
                        },
                      })),
                    ];
                    for (const update of readUpdates) {
                      yield* input.onDelta!(update);
                    }
                    return {
                      agentId: "native-cursor-lifecycle",
                      runId: "native-cursor-run",
                      wait: Effect.succeed({
                        id: "native-cursor-run",
                        requestId: "native-request",
                        status,
                        model: { id: "composer-2.5" },
                        durationMs: 1,
                      }),
                      cancel: Effect.void,
                    };
                  }).pipe(Effect.orDie),
              }),
          }),
          Effect.provide(TestProviderHost.layer({ cwd: workspace })),
        );
        const runtime = yield* adapter.openSession({
          threadId,
          providerSessionId: ProviderSessionId.make("cursor-lifecycle-session"),
          modelSelection,
          runtimePolicy,
        });
        const providerThread = yield* runtime.ensureThread({
          threadId,
          modelSelection,
          runtimePolicy,
        });
        const now = yield* DateTime.now;
        yield* runtime.startTurn({
          threadId,
          providerThread,
          modelSelection,
          runtimePolicy,
          runId: RunId.make("cursor-lifecycle-run"),
          runOrdinal: 1,
          providerTurnOrdinal: 1,
          attemptId: RunAttemptId.make("cursor-lifecycle-attempt"),
          rootNodeId: NodeId.make("cursor-lifecycle-root"),
          appThread: {
            id: threadId,
            projectId: ProjectId.make("cursor-lifecycle-project"),
            createdBy: "user",
            creationSource: "web",
            title: "Cursor lifecycle",
            providerInstanceId: instanceId,
            modelSelection,
            runtimeMode: "full-access",
            interactionMode: "default",
            branch: null,
            worktreePath: null,
            activeProviderThreadId: providerThread.id,
            lineage: { parentThreadId: null, relationshipToParent: null, rootThreadId: threadId },
            forkedFrom: null,
            createdAt: now,
            updatedAt: now,
            archivedAt: null,
            settledOverride: null,
            settledAt: null,
            lastVisitedAt: null,
            deletedAt: null,
          },
          message: {
            messageId: MessageId.make("cursor-lifecycle-message"),
            createdBy: "user",
            creationSource: "web",
            text: "Review the code.",
            attachments: [],
          },
        });
        const events = yield* runtime.events.pipe(
          Stream.takeUntil((event) => event.type === "turn.terminal"),
          Stream.runCollect,
        );
        assert.isTrue(sentWithMcpOverride);
        const rows = events.filter((event) => event.type === "subagent.updated");
        assert.equal(rows[0]?.subagent.status, "running");
        assert.equal(rows[0]?.subagent.model, model ?? null);
        assert.equal(rows.at(-1)?.subagent.model, lateModel ?? model ?? null);
        assert.equal(
          rows.at(-1)?.subagent.status,
          lateModel !== undefined
            ? "completed"
            : status === "finished"
              ? "idle"
              : status === "cancelled"
                ? "cancelled"
                : "failed",
        );
        assert.isNotNull(rows.at(-1)?.subagent.completedAt);
        const unfinished =
          status === "finished" ? "interrupted" : status === "error" ? "failed" : "cancelled";
        const finalReads = new Map<string, { status: string; output: unknown; done: boolean }>();
        for (const event of events) {
          if (
            event.type === "turn_item.updated" &&
            event.turnItem.type === "dynamic_tool" &&
            event.turnItem.toolName === "Read"
          ) {
            finalReads.set(String(event.turnItem.title), {
              status: event.turnItem.status,
              output: event.turnItem.output,
              done: event.turnItem.completedAt !== null,
            });
          }
        }
        const finalNodes = new Map<string, string>();
        for (const event of events) {
          if (event.type === "node.updated" && event.node.kind === "tool_call") {
            finalNodes.set(String(event.node.nativeItemRef?.nativeId), event.node.status);
          }
        }
        assert.deepEqual(Object.fromEntries(finalReads), {
          "Read secret.txt": { status: unfinished, output: undefined, done: true },
          "Read open.txt": {
            status: "completed",
            output: { fileSize: 3, content: "ok\n", totalLines: 1 },
            done: true,
          },
        });
        assert.deepEqual(Object.fromEntries(finalNodes), {
          "read-secret": unfinished,
          "read-open": "completed",
        });
      }).pipe(
        Effect.scoped,
        Effect.provide(
          Layer.mergeAll(NodeServices.layer, IdAllocator.layer, McpProviderSessions.layer),
        ),
      ),
  );

  it.effect.each([
    {
      reason: "the SDK's detailed plan usage limit code",
      wait: Effect.succeed({
        id: "native-cursor-run",
        status: "error" as const,
        error: { message: "You've hit your usage limit", code: "PRO_USER_USAGE_LIMIT" },
      }),
      failure: { class: "usage_limit", message: "You've hit your usage limit" },
    },
    {
      reason: "the error Cursor's run ended with",
      wait: Effect.succeed({
        id: "native-cursor-run",
        requestId: "native-request",
        status: "error" as const,
        error: {
          message: "Model Blocked Please ask your admin to enable access to Claude Fable 5.",
        },
        model: { id: "claude-fable-5" },
        durationMs: 1,
      }),
      failure: {
        class: "provider_error",
        message: "Model Blocked Please ask your admin to enable access to Claude Fable 5.",
      },
    },
    {
      reason: "the SDK rate limit that broke the run",
      wait: Effect.fail(
        new CursorAgentSdk.CursorAgentSdkRunnerError({
          method: "run.wait",
          cause: Object.assign(new Error("Too many requests"), {
            code: "resource_exhausted",
            status: 429,
          }),
        }),
      ),
      failure: {
        class: "usage_limit",
        message:
          "Cursor Agent SDK run.wait failed: Too many requests (resource_exhausted, HTTP 429)",
      },
    },
    {
      reason: "a transport dump sent after earlier commentary",
      updates: [
        { type: "text-delta", text: "Checking the build first." },
        { type: "step-completed", stepId: 1, stepDurationMs: 1 },
        { type: "text-delta", text: "Error: RetriableError: WritableIterable is closed" },
      ] satisfies ReadonlyArray<InteractionUpdate>,
      wait: Effect.succeed({
        id: "native-cursor-run",
        requestId: "native-request",
        status: "finished" as const,
        model: { id: "claude-fable-5" },
        durationMs: 1,
      }),
      failure: { class: "transport_error", message: "Provider turn failed." },
    },
    {
      reason: "no failure when Cursor's resume after the turn ended made no progress",
      // Cursor's SDK resumed from an older checkpoint after the answer was
      // delivered, regenerated the closing, then gave up on the run.
      updates: [
        { type: "text-delta", text: "The answer." },
        { type: "turn-ended" },
        { type: "text-delta", text: "A regenerated closing." },
        { type: "turn-ended" },
      ] satisfies ReadonlyArray<InteractionUpdate>,
      wait: Effect.succeed({
        id: "native-cursor-run",
        requestId: "native-request",
        status: "error" as const,
        error: { message: "Agent turn stopped after repeated resume attempts made no progress" },
        model: { id: "claude-fable-5" },
        durationMs: 1,
      }),
      failure: null,
    },
    {
      reason: "the error a continuation after the turn ended stopped with",
      updates: [
        { type: "text-delta", text: "The answer." },
        { type: "turn-ended" },
        { type: "text-delta", text: "Following up on the stop hook." },
      ] satisfies ReadonlyArray<InteractionUpdate>,
      wait: Effect.succeed({
        id: "native-cursor-run",
        requestId: "native-request",
        status: "error" as const,
        error: { message: "Agent turn stopped after repeated resume attempts made no progress" },
        model: { id: "claude-fable-5" },
        durationMs: 1,
      }),
      failure: {
        class: "provider_error",
        message: "Agent turn stopped after repeated resume attempts made no progress",
      },
    },
    {
      reason: "no answer from a resume after the turn ended that made no progress",
      updates: [{ type: "turn-ended" }] satisfies ReadonlyArray<InteractionUpdate>,
      wait: Effect.succeed({
        id: "native-cursor-run",
        requestId: "native-request",
        status: "error" as const,
        error: { message: "Agent turn stopped after repeated resume attempts made no progress" },
        result: "A regenerated closing.",
        model: { id: "claude-fable-5" },
        durationMs: 1,
      }),
      failure: null,
      answers: [],
    },
  ])("ends the turn with $reason", ({ updates = [], wait, failure, answers }) =>
    Effect.gen(function* () {
      const fileSystem = yield* FileSystem.FileSystem;
      const workspace = yield* fileSystem.makeTempDirectoryScoped({ prefix: "cursor-v2-failure-" });
      const instanceId = ProviderInstanceId.make("cursor");
      const threadId = ThreadId.make("cursor-failure-thread");
      const modelSelection = { instanceId, model: "claude-fable-5" };
      const runtimePolicy = ProviderAdapter.ProviderAdapterV2RuntimePolicy.make({
        runtimeMode: "full-access",
        interactionMode: "default",
        cwd: workspace,
      });
      const adapter = yield* makeCursorAdapterV2({
        instanceId,
        environment: { HOME: workspace },
      }).pipe(
        Effect.provideService(CursorAgentSdk.CursorAgentSdkRunner, {
          assertComplete: Effect.void,
          open: () =>
            Effect.succeed({
              agentId: "native-cursor-failure",
              listMessages: Effect.succeed([]),
              close: Effect.void,
              send: (input) =>
                Effect.gen(function* () {
                  for (const update of updates) {
                    yield* input.onDelta!(update).pipe(Effect.orDie);
                  }
                  return {
                    agentId: "native-cursor-failure",
                    runId: "native-cursor-run",
                    wait,
                    cancel: Effect.void,
                  };
                }),
            }),
        }),
        Effect.provide(TestProviderHost.layer({ cwd: workspace })),
      );
      const runtime = yield* adapter.openSession({
        threadId,
        providerSessionId: ProviderSessionId.make("cursor-failure-session"),
        modelSelection,
        runtimePolicy,
      });
      const providerThread = yield* runtime.ensureThread({
        threadId,
        modelSelection,
        runtimePolicy,
      });
      const now = yield* DateTime.now;
      yield* runtime.startTurn({
        threadId,
        providerThread,
        modelSelection,
        runtimePolicy,
        runId: RunId.make("cursor-failure-run"),
        runOrdinal: 1,
        providerTurnOrdinal: 1,
        attemptId: RunAttemptId.make("cursor-failure-attempt"),
        rootNodeId: NodeId.make("cursor-failure-root"),
        appThread: {
          id: threadId,
          projectId: ProjectId.make("cursor-failure-project"),
          createdBy: "user",
          creationSource: "web",
          title: "Cursor failure",
          providerInstanceId: instanceId,
          modelSelection,
          runtimeMode: "full-access",
          interactionMode: "default",
          branch: null,
          worktreePath: null,
          activeProviderThreadId: providerThread.id,
          lineage: { parentThreadId: null, relationshipToParent: null, rootThreadId: threadId },
          forkedFrom: null,
          createdAt: now,
          updatedAt: now,
          archivedAt: null,
          settledOverride: null,
          settledAt: null,
          lastVisitedAt: null,
          deletedAt: null,
        },
        message: {
          messageId: MessageId.make("cursor-failure-message"),
          createdBy: "user",
          creationSource: "web",
          text: "hi",
          attachments: [],
        },
      });
      const events = yield* runtime.events.pipe(
        Stream.takeUntil((event) => event.type === "turn.terminal"),
        Stream.runCollect,
      );
      const terminal = events.find((event) => event.type === "turn.terminal");
      assert.equal(terminal?.status, failure === null ? "completed" : "failed");
      assert.equal(terminal?.failure?.class, failure?.class);
      assert.equal(terminal?.failure?.message, failure?.message);
      if (answers !== undefined) {
        assert.deepEqual(
          events.flatMap((event) =>
            event.type === "message.updated" && event.message.role === "assistant"
              ? [event.message.text]
              : [],
          ),
          answers,
        );
      }
    }).pipe(
      Effect.scoped,
      Effect.provide(
        Layer.mergeAll(NodeServices.layer, IdAllocator.layer, McpProviderSessions.layer),
      ),
    ),
  );

  it.effect("fails standalone SDK transport diagnostics and compacts with SDK summarize", () =>
    Effect.gen(function* () {
      const fileSystem = yield* FileSystem.FileSystem;
      const workspace = yield* fileSystem.makeTempDirectoryScoped({ prefix: "cursor-v2-errors-" });
      const summarizeRequests: Array<boolean> = [];
      let sendCalls = 0;
      const instanceId = ProviderInstanceId.make("cursor");
      const threadId = ThreadId.make("cursor-transport-error-thread");
      const modelSelection = { instanceId, model: "composer-2.5" };
      const runtimePolicy = ProviderAdapter.ProviderAdapterV2RuntimePolicy.make({
        runtimeMode: "full-access",
        interactionMode: "default",
        cwd: workspace,
      });
      const adapter = yield* makeCursorAdapterV2({
        instanceId,
        environment: { HOME: workspace },
      }).pipe(
        Effect.provideService(CursorAgentSdk.CursorAgentSdkRunner, {
          assertComplete: Effect.void,
          open: () =>
            Effect.succeed({
              agentId: "native-cursor-error",
              listMessages: Effect.succeed([]),
              close: Effect.void,
              send: (input) =>
                Effect.sync(() => {
                  sendCalls += 1;
                  summarizeRequests.push(input.summarize === true);
                  const runId = `native-cursor-run-${sendCalls}`;
                  return {
                    agentId: "native-cursor-error",
                    runId,
                    wait: Effect.succeed({
                      id: runId,
                      requestId: `native-request-${sendCalls}`,
                      status: "finished" as const,
                      model: { id: "composer-2.5" },
                      durationMs: 1,
                      result:
                        sendCalls === 1
                          ? "Error: RetriableError: WritableIterable is closed"
                          : "Summary of the conversation so far",
                    }),
                    cancel: Effect.void,
                  };
                }),
            }),
        }),
        Effect.provide(TestProviderHost.layer({ cwd: workspace })),
      );
      const runtime = yield* adapter.openSession({
        threadId,
        providerSessionId: ProviderSessionId.make("cursor-error-session"),
        modelSelection,
        runtimePolicy,
      });
      const providerThread = yield* runtime.ensureThread({
        threadId,
        modelSelection,
        runtimePolicy,
      });
      const now = yield* DateTime.now;
      const appThread = {
        id: threadId,
        projectId: ProjectId.make("cursor-error-project"),
        createdBy: "user" as const,
        creationSource: "web" as const,
        title: "Cursor transport failure",
        providerInstanceId: instanceId,
        modelSelection,
        runtimeMode: "full-access" as const,
        interactionMode: "default" as const,
        branch: null,
        worktreePath: null,
        activeProviderThreadId: providerThread.id,
        lineage: { parentThreadId: null, relationshipToParent: null, rootThreadId: threadId },
        forkedFrom: null,
        createdAt: now,
        updatedAt: now,
        archivedAt: null,
        settledOverride: null,
        settledAt: null,
        lastVisitedAt: null,
        deletedAt: null,
      };
      yield* runtime.startTurn({
        threadId,
        providerThread,
        modelSelection,
        runtimePolicy,
        runId: RunId.make("cursor-error-run"),
        runOrdinal: 1,
        providerTurnOrdinal: 1,
        attemptId: RunAttemptId.make("cursor-error-attempt"),
        rootNodeId: NodeId.make("cursor-error-root"),
        appThread,
        message: {
          messageId: MessageId.make("cursor-error-message"),
          createdBy: "user",
          creationSource: "web",
          text: "continue",
          attachments: [],
        },
      });
      const first = yield* runtime.events.pipe(
        Stream.filter((event) => event.type === "turn.terminal"),
        Stream.runHead,
      );
      assert.isTrue(Option.isSome(first));
      if (Option.isSome(first)) {
        assert.equal(first.value.status, "failed");
        assert.equal(first.value.failure?.class, "transport_error");
      }

      assert.isDefined(runtime.compactThread);
      yield* runtime.compactThread!({
        threadId,
        providerThread,
        modelSelection,
        runtimePolicy,
        runId: RunId.make("cursor-compact-run"),
        runOrdinal: 2,
        providerTurnOrdinal: 2,
        attemptId: RunAttemptId.make("cursor-compact-attempt"),
        rootNodeId: NodeId.make("cursor-compact-root"),
        appThread,
        message: {
          messageId: MessageId.make("cursor-compact-message"),
          createdBy: "user",
          creationSource: "web",
          text: "ignored by compactThread",
          attachments: [],
        },
      });
      const compactionEvents = yield* runtime.events.pipe(
        Stream.takeUntil((event) => event.type === "turn.terminal"),
        Stream.runCollect,
      );
      assert.deepEqual(summarizeRequests, [false, true]);
      assert.notInclude(JSON.stringify(compactionEvents), "Summary of the conversation so far");
    }).pipe(
      Effect.scoped,
      Effect.provide(
        Layer.mergeAll(NodeServices.layer, IdAllocator.layer, McpProviderSessions.layer),
      ),
    ),
  );

  it.effect("sends T3 instructions to each Cursor conversation that lacks them", () =>
    Effect.gen(function* () {
      const fileSystem = yield* FileSystem.FileSystem;
      const workspace = yield* fileSystem.makeTempDirectoryScoped({ prefix: "cursor-v2-device-" });
      const sentMessages: Array<string> = [];
      const instanceId = ProviderInstanceId.make("cursor");
      const threadId = ThreadId.make("cursor-device-thread");
      const mcpSessions = yield* McpProviderSessions.McpProviderSessions;
      const setDeviceAccess = (device: boolean) =>
        mcpSessions.set({
          environmentId: EnvironmentId.make("cursor-device-environment"),
          threadId,
          providerSessionId: "cursor-device-session",
          providerInstanceId: instanceId,
          endpoint: "http://127.0.0.1:43123/mcp",
          authorizationHeader: "Bearer synthetic-cursor-token",
          browserToolsAvailable: true,
          capabilities: new Set(device ? ["device"] : []),
        });
      const modelSelection = { instanceId, model: "composer-2.5" };
      const runtimePolicy = ProviderAdapter.ProviderAdapterV2RuntimePolicy.make({
        runtimeMode: "full-access",
        interactionMode: "default",
        cwd: workspace,
      });
      const adapter = yield* makeCursorAdapterV2({
        instanceId,
        environment: { HOME: workspace },
      }).pipe(
        Effect.provideService(CursorAgentSdk.CursorAgentSdkRunner, {
          assertComplete: Effect.void,
          open: () =>
            Effect.succeed({
              agentId: "native-cursor-device",
              listMessages: Effect.succeed([]),
              close: Effect.void,
              send: (input) =>
                Effect.sync(() => {
                  sentMessages.push(
                    typeof input.message === "string" ? input.message : input.message.text,
                  );
                  const runId = `native-cursor-run-${sentMessages.length}`;
                  return {
                    agentId: "native-cursor-device",
                    runId,
                    wait: Effect.succeed({
                      id: runId,
                      requestId: `native-request-${sentMessages.length}`,
                      status: "finished" as const,
                      model: { id: "composer-2.5" },
                      durationMs: 1,
                    }),
                    cancel: Effect.void,
                  };
                }),
            }),
        }),
        Effect.provide(TestProviderHost.layer({ cwd: workspace })),
      );
      const runtime = yield* adapter.openSession({
        threadId,
        providerSessionId: ProviderSessionId.make("cursor-device-session"),
        modelSelection,
        runtimePolicy,
      });
      const providerThread = yield* runtime.ensureThread({
        threadId,
        modelSelection,
        runtimePolicy,
      });
      const now = yield* DateTime.now;
      const appThread = {
        id: threadId,
        projectId: ProjectId.make("cursor-device-project"),
        createdBy: "user" as const,
        creationSource: "web" as const,
        title: "Cursor devices",
        providerInstanceId: instanceId,
        modelSelection,
        runtimeMode: "full-access" as const,
        interactionMode: "default" as const,
        branch: null,
        worktreePath: null,
        activeProviderThreadId: providerThread.id,
        lineage: { parentThreadId: null, relationshipToParent: null, rootThreadId: threadId },
        forkedFrom: null,
        createdAt: now,
        updatedAt: now,
        archivedAt: null,
        settledOverride: null,
        settledAt: null,
        lastVisitedAt: null,
        deletedAt: null,
      };
      // Starts at run 5: a conversation from before device instructions existed, now resumed.
      let runOrdinal = 4;
      const send = Effect.fnUntraced(function* (compact = false) {
        runOrdinal += 1;
        const turnInput = {
          threadId,
          providerThread,
          modelSelection,
          runtimePolicy,
          runId: RunId.make(`cursor-device-run-${runOrdinal}`),
          runOrdinal,
          providerTurnOrdinal: runOrdinal,
          attemptId: RunAttemptId.make(`cursor-device-attempt-${runOrdinal}`),
          rootNodeId: NodeId.make(`cursor-device-root-${runOrdinal}`),
          appThread,
          message: {
            messageId: MessageId.make(`cursor-device-message-${runOrdinal}`),
            createdBy: "user" as const,
            creationSource: "web" as const,
            text: "Open the app.",
            attachments: [],
          },
        };
        yield* compact ? runtime.compactThread!(turnInput) : runtime.startTurn(turnInput);
        yield* runtime.events.pipe(
          Stream.filter((event) => event.type === "turn.terminal"),
          Stream.runHead,
        );
        const sent = sentMessages.at(-1)!;
        return {
          orchestration: sent.includes("## T3 Code orchestration"),
          devices: sent.includes("## T3 Code devices"),
        };
      });
      const told = (orchestration: boolean, devices: boolean) => ({ orchestration, devices });

      yield* setDeviceAccess(true);
      assert.deepEqual(yield* send(), told(false, true));
      assert.deepEqual(yield* send(), told(false, false));
      yield* send(true);
      assert.deepEqual(
        yield* send(),
        told(true, true),
        "compaction drops what the conversation was told",
      );
      yield* setDeviceAccess(false);
      assert.deepEqual(yield* send(), told(false, false));
      yield* setDeviceAccess(true);
      assert.deepEqual(yield* send(), told(false, true), "device access turned on later");
      assert.deepEqual(yield* send(), told(false, false));
    }).pipe(
      Effect.scoped,
      Effect.provide(
        Layer.mergeAll(NodeServices.layer, IdAllocator.layer, McpProviderSessions.layer),
      ),
    ),
  );

  it.effect("projects Cursor directory trees and lint diagnostics as file search results", () =>
    Effect.gen(function* () {
      const fileSystem = yield* FileSystem.FileSystem;
      const path = yield* Path.Path;
      const workspace = yield* fileSystem.makeTempDirectoryScoped({ prefix: "cursor-v2-search-" });
      const instanceId = ProviderInstanceId.make("cursor");
      const threadId = ThreadId.make("cursor-search-thread");
      const modelSelection = { instanceId, model: "composer-2.5" };
      const runtimePolicy = ProviderAdapter.ProviderAdapterV2RuntimePolicy.make({
        runtimeMode: "full-access",
        interactionMode: "default",
        cwd: workspace,
      });
      const emptyLsNode = {
        childrenDirs: [],
        childrenFiles: [],
        childrenWereProcessed: true,
        fullSubtreeExtensionCounts: {},
        numFiles: 0,
      };
      const updates: ReadonlyArray<InteractionUpdate> = [
        ...(["tool-call-started", "tool-call-completed"] as const).map((type) => ({
          type,
          modelCallId: "native-model-call",
          callId: "mcp-weather",
          toolCall: {
            type: "mcp" as const,
            args: {
              providerIdentifier: "weather",
              toolName: "get_weather",
              args: { city: "Berlin" },
            },
            ...(type === "tool-call-completed"
              ? {
                  result: {
                    status: "success" as const,
                    value: {
                      content: [
                        { text: { text: "Preview complete" } },
                        { image: { data: "iVBORw0KGgo=", mimeType: "image/png" } },
                      ],
                      isError: false,
                    },
                  },
                }
              : {}),
          },
        })),
        {
          type: "tool-call-completed",
          modelCallId: "native-model-call",
          callId: "read-file",
          toolCall: {
            type: "read",
            args: { path: "src/env.ts" },
            result: {
              status: "success",
              value: { fileSize: 12, content: "---\nfile body", totalLines: 2 },
            },
          },
        },
        {
          type: "tool-call-completed",
          modelCallId: "native-model-call",
          callId: "ls-nested",
          toolCall: {
            type: "ls",
            args: { path: workspace },
            result: {
              status: "success",
              value: {
                directoryTreeRoot: {
                  ...emptyLsNode,
                  absPath: workspace,
                  childrenFiles: [{ name: "README.md" }],
                  childrenDirs: [
                    {
                      ...emptyLsNode,
                      absPath: path.join(workspace, "src"),
                      childrenFiles: [{ name: "index.ts" }],
                      childrenDirs: [
                        {
                          ...emptyLsNode,
                          absPath: path.join(workspace, "src", "nested"),
                          childrenFiles: [{ name: "util.ts" }],
                        },
                      ],
                    },
                  ],
                },
              },
            },
          },
        },
        {
          type: "tool-call-completed",
          modelCallId: "native-model-call",
          callId: "ls-empty",
          toolCall: {
            type: "ls",
            args: { path: path.join(workspace, "empty") },
            result: {
              status: "success",
              value: {
                directoryTreeRoot: { ...emptyLsNode, absPath: path.join(workspace, "empty") },
              },
            },
          },
        },
        {
          type: "tool-call-completed",
          modelCallId: "native-model-call",
          callId: "ls-failed",
          toolCall: {
            type: "ls",
            args: { path: path.join(workspace, "missing") },
            result: { status: "error", error: "ENOENT" },
          },
        },
        {
          type: "tool-call-completed",
          modelCallId: "native-model-call",
          callId: "grep-failed",
          toolCall: {
            type: "grep",
            args: { pattern: "TODO", path: "src" },
            result: { status: "error", error: "search failed" },
          },
        },
        {
          type: "tool-call-completed",
          modelCallId: "native-model-call",
          callId: "grep-counts",
          toolCall: {
            type: "grep",
            args: { pattern: "TODO", outputMode: "count" },
            result: {
              status: "success",
              value: {
                workspaceResults: {
                  [workspace]: {
                    type: "count",
                    output: {
                      counts: [
                        { file: "src/a.ts", count: 1 },
                        { file: "src/b.ts", count: 3 },
                      ],
                      total: 4,
                    },
                  },
                },
              },
            },
          },
        },
        {
          type: "tool-call-completed",
          modelCallId: "native-model-call",
          callId: "glob-failed",
          toolCall: {
            type: "glob",
            args: { globPattern: "*.ts" },
            result: { status: "error", error: "search failed" },
          },
        },
        {
          type: "tool-call-completed",
          modelCallId: "native-model-call",
          callId: "lints",
          toolCall: {
            type: "readLints",
            args: { paths: ["src/a.ts", "src/b.ts"] },
            result: {
              status: "success",
              value: {
                totalFiles: 2,
                totalDiagnostics: 3,
                fileDiagnostics: [
                  {
                    path: "src/a.ts",
                    diagnosticsCount: 2,
                    diagnostics: [
                      {
                        message: "Unused variable",
                        code: "TS6133",
                        source: "ts",
                        severity: "warning",
                        range: { start: { line: 0, character: 4 } },
                      },
                      {
                        message: "Cannot find name",
                        code: "TS2304",
                        source: "ts",
                        severity: "error",
                        range: { start: { line: 11 } },
                      },
                    ],
                  },
                  {
                    path: "src/b.ts",
                    diagnosticsCount: 1,
                    diagnostics: [
                      {
                        message: "File-level diagnostic",
                        code: "TS0",
                        source: "ts",
                        severity: "information",
                      },
                    ],
                  },
                ],
              },
            },
          },
        },
        {
          type: "tool-call-completed",
          modelCallId: "native-model-call",
          callId: "lints-empty",
          toolCall: {
            type: "readLints",
            args: { paths: ["src/clean.ts"] },
            result: {
              status: "success",
              value: {
                totalFiles: 1,
                totalDiagnostics: 0,
                fileDiagnostics: [{ path: "src/clean.ts", diagnosticsCount: 0, diagnostics: [] }],
              },
            },
          },
        },
        {
          type: "tool-call-completed",
          modelCallId: "native-model-call",
          callId: "lints-failed",
          toolCall: {
            type: "readLints",
            args: { paths: ["src/a.ts"] },
            result: { status: "error", error: "lint failed" },
          },
        },
      ];
      const adapter = yield* makeCursorAdapterV2({
        instanceId,
        environment: { HOME: workspace },
      }).pipe(
        Effect.provideService(CursorAgentSdk.CursorAgentSdkRunner, {
          assertComplete: Effect.void,
          open: () =>
            Effect.succeed({
              agentId: "native-cursor-search",
              listMessages: Effect.succeed([]),
              close: Effect.void,
              send: (input) =>
                Effect.gen(function* () {
                  for (const update of updates) {
                    if (input.onDelta !== undefined) {
                      yield* input.onDelta(update).pipe(Effect.orDie);
                    }
                  }
                  return {
                    agentId: "native-cursor-search",
                    runId: "native-cursor-run",
                    wait: Effect.succeed({
                      id: "native-cursor-run",
                      requestId: "native-request",
                      status: "finished" as const,
                      model: { id: "composer-2.5" },
                      durationMs: 1,
                    }),
                    cancel: Effect.void,
                  };
                }),
            }),
        }),
        Effect.provide(TestProviderHost.layer({ cwd: workspace })),
      );
      const runtime = yield* adapter.openSession({
        threadId,
        providerSessionId: ProviderSessionId.make("cursor-search-session"),
        modelSelection,
        runtimePolicy,
      });
      const providerThread = yield* runtime.ensureThread({
        threadId,
        modelSelection,
        runtimePolicy,
      });
      const now = yield* DateTime.now;
      yield* runtime.startTurn({
        threadId,
        providerThread,
        modelSelection,
        runtimePolicy,
        runId: RunId.make("cursor-search-run"),
        runOrdinal: 1,
        providerTurnOrdinal: 1,
        attemptId: RunAttemptId.make("cursor-search-attempt"),
        rootNodeId: NodeId.make("cursor-search-root"),
        appThread: {
          id: threadId,
          projectId: ProjectId.make("cursor-search-project"),
          createdBy: "user",
          creationSource: "web",
          title: "Cursor search results",
          providerInstanceId: instanceId,
          modelSelection,
          runtimeMode: "full-access",
          interactionMode: "default",
          branch: null,
          worktreePath: null,
          activeProviderThreadId: providerThread.id,
          lineage: { parentThreadId: null, relationshipToParent: null, rootThreadId: threadId },
          forkedFrom: null,
          createdAt: now,
          updatedAt: now,
          archivedAt: null,
          settledOverride: null,
          settledAt: null,
          lastVisitedAt: null,
          deletedAt: null,
        },
        message: {
          messageId: MessageId.make("cursor-search-message"),
          createdBy: "user",
          creationSource: "web",
          text: "inspect the workspace",
          attachments: [],
        },
      });
      const events = yield* runtime.events.pipe(
        Stream.takeUntil((event) => event.type === "turn.terminal"),
        Stream.runCollect,
      );
      const mcpItems = events.flatMap((event) =>
        event.type === "turn_item.updated" &&
        event.turnItem.type === "dynamic_tool" &&
        event.turnItem.toolName === "mcp__weather__get_weather"
          ? [event.turnItem]
          : [],
      );
      assert.deepEqual(
        mcpItems.map((item) => item.status),
        ["running", "completed"],
      );
      for (const item of mcpItems) {
        assert.equal(item.title, "get weather");
        assert.deepEqual(item.toolSource, {
          key: "mcp:weather",
          name: "weather",
          kind: "integration",
        });
        assert.deepEqual(item.input, { city: "Berlin" });
      }
      assert.deepEqual(toolOutputImages(mcpItems.at(-1)?.output), [
        { mimeType: "image/png", data: "iVBORw0KGgo=" },
      ]);
      const fileSearchItems = events.flatMap((event) =>
        event.type === "turn_item.updated" &&
        event.turnItem.type === "file_search" &&
        event.turnItem.status !== "running"
          ? [event.turnItem]
          : [],
      );
      const readItems = events.flatMap((event) =>
        event.type === "turn_item.updated" &&
        event.turnItem.type === "dynamic_tool" &&
        event.turnItem.toolName === "Read" &&
        event.turnItem.status === "completed"
          ? [event.turnItem]
          : [],
      );
      assert.deepEqual(
        readItems.map((item) => ({ title: item.title, input: item.input })),
        [{ title: "Read src/env.ts", input: { path: "src/env.ts" } }],
      );
      assert.deepEqual(
        fileSearchItems.map((item) => ({
          pattern: item.pattern,
          status: item.status,
          results: item.results,
        })),
        [
          {
            pattern: workspace,
            status: "completed",
            results: [
              { fileName: path.join(workspace, "README.md") },
              { fileName: path.join(workspace, "src", "index.ts") },
              { fileName: path.join(workspace, "src", "nested", "util.ts") },
            ],
          },
          {
            pattern: path.join(workspace, "empty"),
            status: "completed",
            results: undefined,
          },
          {
            pattern: path.join(workspace, "missing"),
            status: "failed",
            results: [{ fileName: path.join(workspace, "missing"), preview: "ENOENT" }],
          },
          {
            pattern: "TODO",
            status: "failed",
            results: [{ fileName: "src", preview: "search failed" }],
          },
          {
            pattern: "TODO",
            status: "completed",
            results: [
              { fileName: "src/a.ts", preview: "1 match" },
              { fileName: "src/b.ts", preview: "3 matches" },
            ],
          },
          {
            pattern: "*.ts",
            status: "failed",
            results: [{ fileName: ".", preview: "search failed" }],
          },
          {
            pattern: "src/a.ts, src/b.ts",
            status: "completed",
            results: [
              { fileName: "src/a.ts", line: 1, column: 5, preview: "Unused variable" },
              { fileName: "src/a.ts", line: 12, preview: "Cannot find name" },
              { fileName: "src/b.ts", preview: "File-level diagnostic" },
            ],
          },
          {
            pattern: "src/clean.ts",
            status: "completed",
            results: undefined,
          },
          {
            pattern: "src/a.ts",
            status: "failed",
            results: [{ fileName: "src/a.ts", preview: "lint failed" }],
          },
        ],
      );
    }).pipe(
      Effect.scoped,
      Effect.provide(
        Layer.mergeAll(NodeServices.layer, IdAllocator.layer, McpProviderSessions.layer),
      ),
    ),
  );

  it.effect("projects subagent directory trees Cursor serialized without empty lists", () =>
    Effect.gen(function* () {
      const fileSystem = yield* FileSystem.FileSystem;
      const path = yield* Path.Path;
      const workspace = yield* fileSystem.makeTempDirectoryScoped({ prefix: "cursor-v2-task-ls-" });
      const instanceId = ProviderInstanceId.make("cursor");
      const threadId = ThreadId.make("cursor-task-ls-thread");
      const modelSelection = { instanceId, model: "composer-2.5" };
      const runtimePolicy = ProviderAdapter.ProviderAdapterV2RuntimePolicy.make({
        runtimeMode: "full-access",
        interactionMode: "default",
        cwd: workspace,
      });
      // The SDK serializes subagent steps with protobuf toJson(), which omits empty repeated fields.
      const conversationSteps = [
        {
          toolCall: {
            toolCallId: "tool:ls",
            lsToolCall: {
              args: { path: workspace },
              result: {
                success: {
                  directoryTreeRoot: {
                    absPath: workspace,
                    childrenWereProcessed: true,
                    childrenDirs: [
                      {
                        absPath: path.join(workspace, "src"),
                        childrenFiles: [{ name: "index.ts" }],
                        childrenWereProcessed: true,
                        numFiles: 1,
                      },
                    ],
                  },
                },
              },
            },
          },
        },
        {
          toolCall: {
            toolCallId: "tool:lints",
            readLintsToolCall: { args: {}, result: { success: {} } },
          },
        },
        {
          toolCall: {
            toolCallId: "tool:lints-clean-file",
            readLintsToolCall: {
              args: {},
              result: { success: { fileDiagnostics: [{ path: "src/clean.ts" }] } },
            },
          },
        },
        {
          toolCall: {
            toolCallId: "tool:mcp",
            mcpToolCall: {
              args: { providerIdentifier: "docs", toolName: "lookup", args: { query: "ls" } },
              result: { success: {} },
            },
          },
        },
      ];
      const adapter = yield* makeCursorAdapterV2({
        instanceId,
        environment: { HOME: workspace },
      }).pipe(
        Effect.provideService(CursorAgentSdk.CursorAgentSdkRunner, {
          assertComplete: Effect.void,
          open: () =>
            Effect.succeed({
              agentId: "native-cursor-task-ls",
              listMessages: Effect.succeed([]),
              close: Effect.void,
              send: (input) =>
                Effect.gen(function* () {
                  const args = {
                    description: "Explore",
                    prompt: "List the workspace.",
                    subagentType: { kind: "unspecified" as const },
                    agentId: "cursor-task-agent",
                    mode: "unspecified" as const,
                  };
                  yield* input.onDelta!({
                    type: "tool-call-started",
                    modelCallId: "model-call",
                    callId: "task-call",
                    toolCall: { type: "task", args },
                  });
                  yield* input.onDelta!({
                    type: "tool-call-completed",
                    modelCallId: "model-call",
                    callId: "task-call",
                    toolCall: {
                      type: "task",
                      args,
                      result: {
                        status: "success",
                        value: {
                          conversationSteps,
                          isBackground: false,
                          backgroundReason: "unspecified",
                        },
                      },
                    },
                  });
                  return {
                    agentId: "native-cursor-task-ls",
                    runId: "native-cursor-run",
                    wait: Effect.succeed({
                      id: "native-cursor-run",
                      requestId: "native-request",
                      status: "finished" as const,
                      model: { id: "composer-2.5" },
                      durationMs: 1,
                    }),
                    cancel: Effect.void,
                  };
                }).pipe(Effect.orDie),
            }),
        }),
        Effect.provide(TestProviderHost.layer({ cwd: workspace })),
      );
      const runtime = yield* adapter.openSession({
        threadId,
        providerSessionId: ProviderSessionId.make("cursor-task-ls-session"),
        modelSelection,
        runtimePolicy,
      });
      const providerThread = yield* runtime.ensureThread({
        threadId,
        modelSelection,
        runtimePolicy,
      });
      const now = yield* DateTime.now;
      yield* runtime.startTurn({
        threadId,
        providerThread,
        modelSelection,
        runtimePolicy,
        runId: RunId.make("cursor-task-ls-run"),
        runOrdinal: 1,
        providerTurnOrdinal: 1,
        attemptId: RunAttemptId.make("cursor-task-ls-attempt"),
        rootNodeId: NodeId.make("cursor-task-ls-root"),
        appThread: {
          id: threadId,
          projectId: ProjectId.make("cursor-task-ls-project"),
          createdBy: "user",
          creationSource: "web",
          title: "Cursor subagent ls",
          providerInstanceId: instanceId,
          modelSelection,
          runtimeMode: "full-access",
          interactionMode: "default",
          branch: null,
          worktreePath: null,
          activeProviderThreadId: providerThread.id,
          lineage: { parentThreadId: null, relationshipToParent: null, rootThreadId: threadId },
          forkedFrom: null,
          createdAt: now,
          updatedAt: now,
          archivedAt: null,
          settledOverride: null,
          settledAt: null,
          lastVisitedAt: null,
          deletedAt: null,
        },
        message: {
          messageId: MessageId.make("cursor-task-ls-message"),
          createdBy: "user",
          creationSource: "web",
          text: "List the workspace with a subagent.",
          attachments: [],
        },
      });
      const events = yield* runtime.events.pipe(
        Stream.takeUntil((event) => event.type === "turn.terminal"),
        Stream.runCollect,
      );
      const terminal = events.find((event) => event.type === "turn.terminal");
      assert.equal(terminal?.status, "completed");
      const childThreadId = events.findLast((event) => event.type === "subagent.updated")?.subagent
        .childThreadId;
      assert.isDefined(childThreadId);
      assert.deepEqual(
        events.flatMap((event): ReadonlyArray<unknown> => {
          if (event.type !== "turn_item.updated" || event.turnItem.threadId !== childThreadId) {
            return [];
          }
          const item = event.turnItem;
          return item.type === "file_search"
            ? [{ status: item.status, pattern: item.pattern, results: item.results ?? [] }]
            : item.type === "dynamic_tool"
              ? [{ status: item.status, toolName: item.toolName, output: item.output }]
              : [];
        }),
        [
          {
            status: "completed",
            pattern: workspace,
            results: [{ fileName: path.join(workspace, "src", "index.ts") }],
          },
          { status: "completed", pattern: "", results: [] },
          { status: "completed", pattern: "", results: [] },
          {
            status: "completed",
            toolName: "mcp__docs__lookup",
            output: { content: [], isError: false },
          },
        ],
      );
    }).pipe(
      Effect.scoped,
      Effect.provide(
        Layer.mergeAll(NodeServices.layer, IdAllocator.layer, McpProviderSessions.layer),
      ),
    ),
  );

  it.effect("names a custom model Cursor's account catalog rejects", () =>
    Effect.gen(function* () {
      const fileSystem = yield* FileSystem.FileSystem;
      const workspace = yield* fileSystem.makeTempDirectoryScoped({ prefix: "cursor-v2-model-" });
      const instanceId = ProviderInstanceId.make("cursor");
      const threadId = ThreadId.make("cursor-custom-model-thread");
      const catalogModel = { instanceId, model: "composer-2.5" };
      const customModel = { instanceId, model: "deepseek/deepseek-v4.1-flash" };
      const runtimePolicy = ProviderAdapter.ProviderAdapterV2RuntimePolicy.make({
        runtimeMode: "full-access",
        interactionMode: "default",
        cwd: workspace,
      });
      // The SDK checks every create, resume, and send model against the account catalog.
      const checkModel = (method: string, model: { readonly id: string } | undefined) =>
        model === undefined || model.id === "composer-2.5"
          ? Effect.void
          : Effect.fail(
              new CursorAgentSdk.CursorAgentSdkRunnerError({
                method,
                cause: new ConfigurationError(
                  `Cannot use this model: ${model.id}. Available models: default, composer-2.5. Use Cursor.models.list() to discover valid selections.`,
                  { isRetryable: false },
                ),
              }),
            );
      const adapter = yield* makeCursorAdapterV2({
        instanceId,
        environment: { HOME: workspace },
      }).pipe(
        Effect.provideService(CursorAgentSdk.CursorAgentSdkRunner, {
          assertComplete: Effect.void,
          open: (input) =>
            checkModel(`agent.${input.operation}`, input.options.model).pipe(
              Effect.as({
                agentId: "native-cursor-custom-model",
                listMessages: Effect.succeed([]),
                close: Effect.void,
                send: (sendInput) =>
                  checkModel("run.start", sendInput.options?.model).pipe(
                    Effect.andThen(Effect.die("unexpected Cursor run")),
                  ),
              }),
            ),
        }),
        Effect.provide(TestProviderHost.layer({ cwd: workspace })),
      );
      const runtime = yield* adapter.openSession({
        threadId,
        providerSessionId: ProviderSessionId.make("cursor-custom-model-session"),
        modelSelection: catalogModel,
        runtimePolicy,
      });
      const expected =
        'Cursor cannot run the model "deepseek/deepseek-v4.1-flash". Cursor only runs models from your Cursor account. Choose one of those, or use OpenCode for OpenRouter and other API-key models.';

      const createFailure = yield* runtime
        .ensureThread({ threadId, modelSelection: customModel, runtimePolicy })
        .pipe(Effect.flip);
      assert.equal(makeProviderFailure({ cause: createFailure }).message, expected);

      const providerThread = yield* runtime.ensureThread({
        threadId,
        modelSelection: catalogModel,
        runtimePolicy,
      });
      const now = yield* DateTime.now;
      const sendFailure = yield* runtime
        .startTurn({
          threadId,
          providerThread,
          modelSelection: customModel,
          runtimePolicy,
          runId: RunId.make("cursor-custom-model-run"),
          runOrdinal: 1,
          providerTurnOrdinal: 1,
          attemptId: RunAttemptId.make("cursor-custom-model-attempt"),
          rootNodeId: NodeId.make("cursor-custom-model-root"),
          appThread: {
            id: threadId,
            projectId: ProjectId.make("cursor-custom-model-project"),
            createdBy: "user",
            creationSource: "web",
            title: "Cursor custom model",
            providerInstanceId: instanceId,
            modelSelection: customModel,
            runtimeMode: "full-access",
            interactionMode: "default",
            branch: null,
            worktreePath: null,
            activeProviderThreadId: providerThread.id,
            lineage: { parentThreadId: null, relationshipToParent: null, rootThreadId: threadId },
            forkedFrom: null,
            createdAt: now,
            updatedAt: now,
            archivedAt: null,
            settledOverride: null,
            settledAt: null,
            lastVisitedAt: null,
            deletedAt: null,
          },
          message: {
            messageId: MessageId.make("cursor-custom-model-message"),
            createdBy: "user",
            creationSource: "web",
            text: "Hello.",
            attachments: [],
          },
        })
        .pipe(Effect.flip);
      assert.equal(makeProviderFailure({ cause: sendFailure }).message, expected);
    }).pipe(
      Effect.scoped,
      Effect.provide(
        Layer.mergeAll(NodeServices.layer, IdAllocator.layer, McpProviderSessions.layer),
      ),
    ),
  );

  it("maps runtime modes to the SDK sandbox and auto-review controls", () => {
    const base = {
      interactionMode: "default" as const,
      cwd: "/tmp/cursor-adapter",
    };
    assert.deepEqual(
      cursorRuntimeAgentPolicy(
        {
          ...base,
          runtimeMode: "full-access",
        },
        "linux",
      ),
      {
        autoReview: false,
        sandboxEnabled: false,
      },
    );
    assert.deepEqual(
      cursorRuntimeAgentPolicy(
        {
          ...base,
          runtimeMode: "auto-accept-edits",
        },
        "linux",
      ),
      {
        autoReview: false,
        sandboxEnabled: true,
      },
    );
    assert.deepEqual(
      cursorRuntimeAgentPolicy(
        {
          ...base,
          runtimeMode: "auto",
        },
        "linux",
      ),
      {
        autoReview: true,
        sandboxEnabled: true,
      },
    );
    assert.deepEqual(
      cursorRuntimeAgentPolicy(
        {
          ...base,
          runtimeMode: "approval-required",
        },
        "linux",
      ),
      {
        autoReview: true,
        sandboxEnabled: true,
      },
    );
    assert.deepEqual(
      cursorRuntimeAgentPolicy(
        {
          ...base,
          runtimeMode: "full-access",
          approvalPolicy: "never",
          sandboxPolicy: { type: "readOnly" },
        },
        "linux",
      ),
      {
        autoReview: false,
        sandboxEnabled: true,
      },
    );
    assert.deepEqual(
      cursorRuntimeAgentPolicy(
        {
          ...base,
          runtimeMode: "approval-required",
          approvalPolicy: "never",
          sandboxPolicy: { type: "dangerFullAccess" },
        },
        "linux",
      ),
      {
        autoReview: false,
        sandboxEnabled: false,
      },
    );
    assert.deepEqual(
      cursorRuntimeAgentPolicy(
        {
          ...base,
          runtimeMode: "auto-accept-edits",
        },
        "win32",
      ),
      {
        autoReview: false,
        sandboxEnabled: true,
      },
    );
    assert.deepEqual(
      cursorRuntimeAgentPolicy(
        {
          ...base,
          runtimeMode: "auto",
          approvalPolicy: "never",
        },
        "win32",
      ),
      {
        autoReview: false,
        sandboxEnabled: true,
      },
    );
    // Auto-review can gate Windows execution without the unsupported SDK sandbox.
    assert.deepEqual(
      cursorRuntimeAgentPolicy(
        {
          ...base,
          runtimeMode: "auto",
        },
        "win32",
      ),
      {
        autoReview: true,
        sandboxEnabled: false,
      },
    );
    assert.deepEqual(
      cursorRuntimeAgentPolicy(
        {
          ...base,
          runtimeMode: "auto",
          sandboxPolicy: { type: "workspaceWrite" },
        },
        "win32",
      ),
      {
        autoReview: true,
        sandboxEnabled: true,
      },
    );
  });

  it("injects thread-scoped MCP credentials without logging them", () => {
    const threadId = ThreadId.make("thread-cursor-mcp");
    const mcpSession = {
      environmentId: EnvironmentId.make("environment-cursor-mcp"),
      threadId,
      providerSessionId: "mcp-session-cursor",
      providerInstanceId: ProviderInstanceId.make("cursor"),
      endpoint: "http://127.0.0.1:43123/mcp",
      authorizationHeader: "Bearer secret-cursor-mcp-token",
      browserToolsAvailable: true,
    };

    assert.deepEqual(cursorMcpServers(mcpSession), {
      "t3-code": {
        type: "http",
        url: "http://127.0.0.1:43123/mcp",
        headers: {
          Authorization: "Bearer secret-cursor-mcp-token",
        },
      },
    });

    const options = makeCursorAgentOptions({
      apiKey: "secret-cursor-api-key",
      modelSelection: {
        instanceId: ProviderInstanceId.make("cursor"),
        model: "composer-2.5",
      },
      runtimePolicy: {
        runtimeMode: "full-access",
        interactionMode: "default",
        cwd: "/workspace",
      },
      threadId,
      mcpSession,
      platform: "linux",
    });
    assert.deepEqual(options.mcpServers, cursorMcpServers(mcpSession));

    const logged = JSON.stringify(CursorAgentSdk.loggedCursorAgentOptions(options));
    assert.notInclude(logged, "secret-cursor-api-key");
    assert.notInclude(logged, "secret-cursor-mcp-token");
  });

  it("recognizes direct and SDK-wrapped abort failures as cancellation", () => {
    assert.isTrue(CursorAgentSdk.isCursorCancellationError({ name: "AbortError" }));
    assert.isTrue(
      CursorAgentSdk.isCursorCancellationError({
        name: "ConnectError",
        cause: {
          name: "ConnectError",
          cause: { name: "AbortError" },
        },
      }),
    );
    assert.isFalse(CursorAgentSdk.isCursorCancellationError(new Error("request failed")));
    assert.isFalse(CursorAgentSdk.isCursorCancellationError(null));
  });

  it("preserves failed nested read calls when Cursor omits their path", () => {
    assert.deepEqual(
      nestedToolCallFromEnvelope({
        toolCallId: "tool:failed-read",
        readToolCall: {
          args: {},
          result: { error: "File path was not provided." },
        },
      }),
      {
        callId: "tool:failed-read",
        toolCall: {
          type: "read",
          args: { path: "<unknown path>" },
          result: {
            status: "error",
            error: "File path was not provided.",
          },
        },
      },
    );
  });
});