@cursor/july 0.1.25 → 0.1.27

package/src/internal/session-engine.interrupt.test.ts

@@ -1,577 +0,0 @@
-import { mkdtemp, readdir, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { z } from "zod";
-import { httpChannel } from "../channels.js";
-import { defineTool } from "../tools.js";
-import type {
-  AgentProject,
-  AuthContext,
-  DiscoveredTool,
-  RunnerTurnRequest,
-  ToolDefinition,
-  TurnOutcome,
-} from "../types.js";
-import { toolInputJsonSchema } from "./json-schema.js";
-import type { AgentRunner, RunnerPrewarmRequest } from "./sdk-runner.js";
-import { SessionAuthError, SessionEngine } from "./session-engine.js";
-
-function discovered(name: string, definition: ToolDefinition): DiscoveredTool {
-  return {
-    name,
-    description: definition.description,
-    execution: definition.execution ?? "server",
-    needsApproval: definition.needsApproval !== undefined,
-    inputSchema: toolInputJsonSchema(definition.inputSchema),
-    definition,
-  };
-}
-
-function testProject(
-  rootDir: string,
-  options: {
-    cwd?: string;
-    workspaceDir?: string;
-    sandbox?: boolean;
-    tools?: DiscoveredTool[];
-  } = {}
-): AgentProject {
-  return {
-    rootDir,
-    agentDir: join(rootDir, "agent"),
-    name: "interrupt-test",
-    agent: {
-      name: "interrupt-test",
-      runtime: "local",
-      instructions: "Test agent.",
-      ...(options.cwd === undefined &&
-      options.workspaceDir === undefined &&
-      options.sandbox === undefined
-        ? {}
-        : {
-            local: {
-              cwd: options.cwd,
-              workspaceDir: options.workspaceDir,
-              sandbox: options.sandbox,
-            },
-          }),
-      tools: options.tools ?? [],
-      skills: [],
-      connections: [],
-      subagents: [],
-      seedFiles: [],
-    },
-    httpChannel: httpChannel(),
-    channels: [],
-    schedules: [],
-    hooks: [],
-    abs: [],
-    diagnostics: [],
-  };
-}
-
-const cleanups: Array<() => Promise<void>> = [];
-
-afterEach(async () => {
-  while (cleanups.length > 0) {
-    await cleanups.pop()?.();
-  }
-});
-
-describe("SessionEngine follow-up interrupts the running turn", () => {
-  it("cancels the in-flight turn and runs the follow-up", async () => {
-    const stateRoot = await mkdtemp(join(tmpdir(), "agent-serve-interrupt-"));
-    cleanups.push(() => rm(stateRoot, { recursive: true, force: true }));
-
-    const seen: Array<{ prompt: string; forced: boolean }> = [];
-    let firstAborted = false;
-    const runner: AgentRunner = {
-      runTurn: async (request: RunnerTurnRequest): Promise<TurnOutcome> => {
-        seen.push({
-          prompt: request.prompt,
-          forced: request.forceExpireActiveRun === true,
-        });
-        // First turns carry the framework session-context block before the
-        // channel message.
-        if (request.prompt.endsWith("first")) {
-          // Block until the follow-up preempts this turn (mirrors the SDK
-          // wiring the runner's abort signal to run.cancel()).
-          await new Promise<void>((resolve) => {
-            if (request.signal?.aborted === true) {
-              resolve();
-              return;
-            }
-            request.signal?.addEventListener("abort", () => resolve(), {
-              once: true,
-            });
-          });
-          firstAborted = true;
-          return { status: "cancelled" };
-        }
-        return { status: "finished", result: "second-done" };
-      },
-    };
-
-    const engine = new SessionEngine({
-      project: testProject(stateRoot),
-      stateRoot,
-      runner,
-    });
-    cleanups.push(() => engine.close());
-
-    // Turn one blocks inside runTurn awaiting its abort signal.
-    const session = await engine.send("http", "first", { auth: null });
-    // A follow-up on the same session must interrupt turn one and run.
-    const follow = await engine.send("http", "second", {
-      auth: null,
-      continuationToken: session.continuationToken ?? undefined,
-    });
-    const outcome = await follow.waitForCompletion();
-
-    expect(firstAborted).toBe(true);
-    expect(outcome.status).toBe("finished");
-    expect(outcome.result).toBe("second-done");
-    expect(seen[0]?.prompt).toMatch(/^<agentkit_context>\n/);
-    expect(seen[0]?.prompt.endsWith("\n\nfirst")).toBe(true);
-    expect(seen[1]?.prompt).toBe("second");
-    // The first turn creates the agent; the follow-up force-expires any run
-    // still marked active so it is never blocked by the preempted one.
-    expect(seen[0]?.forced).toBe(false);
-    expect(seen[1]?.forced).toBe(true);
-
-    const events = await engine.listEvents(session.id, 0);
-    const failed = events.find((event) => event.type === "turn.failed");
-    expect((failed?.data as { message?: string } | undefined)?.message).toBe(
-      "turn interrupted"
-    );
-    expect(events.some((event) => event.type === "turn.completed")).toBe(true);
-  });
-
-  it("interrupt() cancels the in-flight turn without a follow-up", async () => {
-    const stateRoot = await mkdtemp(join(tmpdir(), "agent-serve-stop-"));
-    cleanups.push(() => rm(stateRoot, { recursive: true, force: true }));
-
-    const runner: AgentRunner = {
-      runTurn: async (request: RunnerTurnRequest): Promise<TurnOutcome> => {
-        await new Promise<void>((resolve) => {
-          if (request.signal?.aborted === true) {
-            resolve();
-            return;
-          }
-          request.signal?.addEventListener("abort", () => resolve(), {
-            once: true,
-          });
-        });
-        return { status: "cancelled" };
-      },
-    };
-
-    const engine = new SessionEngine({
-      project: testProject(stateRoot),
-      stateRoot,
-      runner,
-    });
-    cleanups.push(() => engine.close());
-
-    const session = await engine.send("http", "running", { auth: null });
-    expect(await engine.interrupt(session.id)).toBe(true);
-    const outcome = await session.waitForCompletion();
-    expect(outcome.status).toBe("cancelled");
-    expect(await engine.interrupt(session.id)).toBe(false);
-
-    const events = await engine.listEvents(session.id, 0);
-    const failed = events.find((event) => event.type === "turn.failed");
-    expect((failed?.data as { message?: string } | undefined)?.message).toBe(
-      "turn interrupted"
-    );
-  });
-});
-
-describe("SessionEngine agent cwd", () => {
-  it("uses <agent.local.cwd>/<sessionId> as the harness cwd", async () => {
-    const stateRoot = await mkdtemp(join(tmpdir(), "agent-serve-cwd-state-"));
-    const harnessRoot = await mkdtemp(join(tmpdir(), "agent-serve-cwd-"));
-    cleanups.push(() => rm(stateRoot, { recursive: true, force: true }));
-    cleanups.push(() => rm(harnessRoot, { recursive: true, force: true }));
-
-    const seen: string[] = [];
-    const runner: AgentRunner = {
-      runTurn: async (request: RunnerTurnRequest): Promise<TurnOutcome> => {
-        seen.push(request.workspaceDir);
-        return { status: "finished", result: "ok" };
-      },
-    };
-
-    const engine = new SessionEngine({
-      project: testProject(stateRoot, { cwd: harnessRoot }),
-      stateRoot,
-      runner,
-    });
-    cleanups.push(() => engine.close());
-
-    const session = await engine.send("http", "hi", { auth: null });
-    await session.waitForCompletion();
-    expect(seen).toEqual([join(harnessRoot, session.id)]);
-  });
-
-  it("passes agent.local.sandbox through to the runner", async () => {
-    const stateRoot = await mkdtemp(join(tmpdir(), "agent-serve-sandbox-"));
-    cleanups.push(() => rm(stateRoot, { recursive: true, force: true }));
-
-    const seen: (boolean | undefined)[] = [];
-    const runner: AgentRunner = {
-      runTurn: async (request: RunnerTurnRequest): Promise<TurnOutcome> => {
-        seen.push(request.sandbox);
-        return { status: "finished", result: "ok" };
-      },
-    };
-
-    const engine = new SessionEngine({
-      project: testProject(stateRoot, { sandbox: true }),
-      stateRoot,
-      runner,
-    });
-    cleanups.push(() => engine.close());
-
-    const session = await engine.send("http", "hi", { auth: null });
-    await session.waitForCompletion();
-    expect(seen).toEqual([true]);
-  });
-
-  it("lets SendMessageOptions.workspaceDir override agent cwd", async () => {
-    const stateRoot = await mkdtemp(join(tmpdir(), "agent-serve-cwd-ov-"));
-    const harnessRoot = await mkdtemp(join(tmpdir(), "agent-serve-cwd-base-"));
-    const override = await mkdtemp(join(tmpdir(), "agent-serve-cwd-override-"));
-    cleanups.push(() => rm(stateRoot, { recursive: true, force: true }));
-    cleanups.push(() => rm(harnessRoot, { recursive: true, force: true }));
-    cleanups.push(() => rm(override, { recursive: true, force: true }));
-
-    const seen: string[] = [];
-    const runner: AgentRunner = {
-      runTurn: async (request: RunnerTurnRequest): Promise<TurnOutcome> => {
-        seen.push(request.workspaceDir);
-        return { status: "finished", result: "ok" };
-      },
-    };
-
-    const engine = new SessionEngine({
-      project: testProject(stateRoot, { cwd: harnessRoot }),
-      stateRoot,
-      runner,
-    });
-    cleanups.push(() => engine.close());
-
-    const session = await engine.send("http", "hi", {
-      auth: null,
-      workspaceDir: override,
-    });
-    await session.waitForCompletion();
-    expect(seen).toEqual([override]);
-  });
-});
-
-describe("SessionEngine shared harness workspace", () => {
-  async function runSessions(
-    options: { workspaceDir?: string; cwd?: string },
-    count: number
-  ): Promise<{ stateRoot: string; seen: string[]; prompts: string[] }> {
-    const stateRoot = await mkdtemp(join(tmpdir(), "agent-serve-shared-"));
-    cleanups.push(() => rm(stateRoot, { recursive: true, force: true }));
-
-    const seen: string[] = [];
-    const prompts: string[] = [];
-    const runner: AgentRunner = {
-      runTurn: async (request: RunnerTurnRequest): Promise<TurnOutcome> => {
-        seen.push(request.workspaceDir);
-        prompts.push(request.prompt);
-        return { status: "finished", result: "ok" };
-      },
-    };
-
-    const engine = new SessionEngine({
-      project: testProject(stateRoot, options),
-      stateRoot,
-      runner,
-    });
-    cleanups.push(() => engine.close());
-
-    for (let i = 0; i < count; i++) {
-      const session = await engine.send("http", `hi ${i}`, { auth: null });
-      await session.waitForCompletion();
-    }
-    return { stateRoot, seen, prompts };
-  }
-
-  it("gives every session the same harness cwd", async () => {
-    const shared = await mkdtemp(join(tmpdir(), "agent-serve-checkout-"));
-    cleanups.push(() => rm(shared, { recursive: true, force: true }));
-
-    const { seen } = await runSessions({ workspaceDir: shared }, 3);
-
-    // One cwd across sessions is the whole point: the SDK keys its local
-    // executor on it, so a stable path resolves rules and skills once.
-    expect(seen).toEqual([shared, shared, shared]);
-  });
-
-  it("takes precedence over cwd but yields to a per-send workspaceDir", async () => {
-    const shared = await mkdtemp(join(tmpdir(), "agent-serve-checkout-pri-"));
-    const perSend = await mkdtemp(join(tmpdir(), "agent-serve-checkout-send-"));
-    const cwd = await mkdtemp(join(tmpdir(), "agent-serve-checkout-cwd-"));
-    cleanups.push(() => rm(shared, { recursive: true, force: true }));
-    cleanups.push(() => rm(perSend, { recursive: true, force: true }));
-    cleanups.push(() => rm(cwd, { recursive: true, force: true }));
-
-    const stateRoot = await mkdtemp(join(tmpdir(), "agent-serve-shared-pri-"));
-    cleanups.push(() => rm(stateRoot, { recursive: true, force: true }));
-
-    const seen: string[] = [];
-    const runner: AgentRunner = {
-      runTurn: async (request: RunnerTurnRequest): Promise<TurnOutcome> => {
-        seen.push(request.workspaceDir);
-        return { status: "finished", result: "ok" };
-      },
-    };
-    const engine = new SessionEngine({
-      project: testProject(stateRoot, { cwd, workspaceDir: shared }),
-      stateRoot,
-      runner,
-    });
-    cleanups.push(() => engine.close());
-
-    await (await engine.send("http", "a", { auth: null })).waitForCompletion();
-    await (
-      await engine.send("http", "b", { auth: null, workspaceDir: perSend })
-    ).waitForCompletion();
-
-    expect(seen).toEqual([shared, perSend]);
-  });
-
-  it("warms the shared workspace with the same inputs a turn will use", async () => {
-    const shared = await mkdtemp(join(tmpdir(), "agent-serve-checkout-warm-"));
-    const stateRoot = await mkdtemp(join(tmpdir(), "agent-serve-warm-state-"));
-    cleanups.push(() => rm(shared, { recursive: true, force: true }));
-    cleanups.push(() => rm(stateRoot, { recursive: true, force: true }));
-
-    let warmed: RunnerPrewarmRequest | undefined;
-    let turn: RunnerTurnRequest | undefined;
-    const runner: AgentRunner = {
-      prewarm: async (request) => {
-        warmed = request;
-        return { warmed: true };
-      },
-      runTurn: async (request: RunnerTurnRequest): Promise<TurnOutcome> => {
-        turn = request;
-        return { status: "finished", result: "ok" };
-      },
-    };
-
-    const engine = new SessionEngine({
-      project: testProject(stateRoot, { workspaceDir: shared }),
-      stateRoot,
-      runner,
-    });
-    cleanups.push(() => engine.close());
-
-    await engine.prewarmSharedWorkspace();
-    await (await engine.send("http", "hi", { auth: null })).waitForCompletion();
-
-    // Warming a workspace the turn will not land on is silent waste, so every
-    // field the executor is keyed on has to agree.
-    expect(warmed).toBeDefined();
-    expect(turn).toBeDefined();
-    expect(warmed?.workspaceDir).toBe(turn?.workspaceDir);
-    expect(warmed?.runnerStateDir).toBe(turn?.runnerStateDir);
-    expect(warmed?.sandbox).toBe(turn?.sandbox);
-    expect(warmed?.mcpServers).toEqual(turn?.mcpServers);
-    expect(warmed?.subagents).toEqual(turn?.subagents);
-    expect(warmed?.model).toEqual(turn?.model);
-  });
-
-  it("does not warm when each session gets its own cwd", async () => {
-    const cwd = await mkdtemp(join(tmpdir(), "agent-serve-nowarm-"));
-    const stateRoot = await mkdtemp(join(tmpdir(), "agent-serve-nowarm-st-"));
-    cleanups.push(() => rm(cwd, { recursive: true, force: true }));
-    cleanups.push(() => rm(stateRoot, { recursive: true, force: true }));
-
-    const prewarm = vi.fn(async () => ({ warmed: true }) as const);
-    const engine = new SessionEngine({
-      project: testProject(stateRoot, { cwd }),
-      stateRoot,
-      runner: {
-        prewarm,
-        runTurn: async (): Promise<TurnOutcome> => ({ status: "finished" }),
-      },
-    });
-    cleanups.push(() => engine.close());
-
-    await engine.prewarmSharedWorkspace();
-
-    expect(prewarm).not.toHaveBeenCalled();
-  });
-
-  it("says so instead of claiming success when the runner cannot warm", async () => {
-    const shared = await mkdtemp(join(tmpdir(), "agent-serve-cold-"));
-    const stateRoot = await mkdtemp(join(tmpdir(), "agent-serve-cold-st-"));
-    cleanups.push(() => rm(shared, { recursive: true, force: true }));
-    cleanups.push(() => rm(stateRoot, { recursive: true, force: true }));
-
-    // What an older @cursor/sdk produces: the call resolves, nothing warms.
-    const lines: string[] = [];
-    const engine = new SessionEngine({
-      project: testProject(stateRoot, { workspaceDir: shared }),
-      stateRoot,
-      logger: (line) => lines.push(line),
-      runner: {
-        prewarm: async () => ({ warmed: false, reason: "sdk too old" }),
-        runTurn: async (): Promise<TurnOutcome> => ({ status: "finished" }),
-      },
-    });
-    cleanups.push(() => engine.close());
-
-    await engine.prewarmSharedWorkspace();
-
-    // An operator reading "warmed" over a cold workspace is worse than no log.
-    expect(lines).toContainEqual(
-      `[agentkit] did not warm ${shared}: sdk too old`
-    );
-    expect(lines.some((line) => line.includes("] warmed "))).toBe(false);
-  });
-
-  it("keeps agent scaffold out of the shared directory and inlines it instead", async () => {
-    const shared = await mkdtemp(join(tmpdir(), "agent-serve-checkout-safe-"));
-    cleanups.push(() => rm(shared, { recursive: true, force: true }));
-
-    const { prompts } = await runSessions({ workspaceDir: shared }, 1);
-
-    // Writing AGENTS.md into a borrowed checkout would dirty the user's tree.
-    expect(await readdir(shared)).toEqual([]);
-    expect(prompts[0]).toContain("Test agent.");
-  });
-});
-
-describe("ToolContext.send auth default", () => {
-  it("passes the calling session principal when auth is omitted", async () => {
-    const stateRoot = await mkdtemp(join(tmpdir(), "agent-serve-tool-auth-"));
-    cleanups.push(() => rm(stateRoot, { recursive: true, force: true }));
-
-    const owner: AuthContext = {
-      authenticator: "local-dev",
-      principalId: "loopback",
-      principalType: "runtime",
-    };
-
-    const handoff = defineTool({
-      description: "Resume a drive session.",
-      inputSchema: z.object({ token: z.string() }),
-      async execute({ token }, ctx) {
-        const session = await ctx.send("drive", "from-tool", {
-          continuationToken: token,
-        });
-        return { sessionId: session.id };
-      },
-    });
-
-    const runner: AgentRunner = {
-      runTurn: async (): Promise<TurnOutcome> => ({
-        status: "finished",
-        result: "ok",
-      }),
-    };
-
-    const engine = new SessionEngine({
-      project: testProject(stateRoot, {
-        tools: [discovered("handoff", handoff)],
-      }),
-      stateRoot,
-      runner,
-    });
-    cleanups.push(() => engine.close());
-
-    const drive = await engine.send("drive", "seed", {
-      auth: owner,
-      continuationToken: "sticky-pr",
-    });
-    await drive.waitForCompletion();
-
-    const chat = await engine.send("http", "chat", { auth: owner });
-    await chat.waitForCompletion();
-
-    const outcome = await engine.callTool(
-      "handoff",
-      { token: "sticky-pr" },
-      { auth: owner, sessionId: chat.id }
-    );
-    expect(outcome.isError).toBe(false);
-  });
-
-  it("rejects when the sticky session belongs to another principal", async () => {
-    const stateRoot = await mkdtemp(join(tmpdir(), "agent-serve-tool-auth2-"));
-    cleanups.push(() => rm(stateRoot, { recursive: true, force: true }));
-
-    const owner: AuthContext = {
-      authenticator: "local-dev",
-      principalId: "owner",
-      principalType: "runtime",
-    };
-    const other: AuthContext = {
-      authenticator: "local-dev",
-      principalId: "other",
-      principalType: "runtime",
-    };
-
-    const handoff = defineTool({
-      description: "Resume a drive session.",
-      inputSchema: z.object({ token: z.string() }),
-      async execute({ token }, ctx) {
-        try {
-          await ctx.send("drive", "from-tool", {
-            continuationToken: token,
-          });
-          return { ok: true };
-        } catch (error) {
-          return {
-            ok: false,
-            error: error instanceof Error ? error.name : String(error),
-          };
-        }
-      },
-    });
-
-    const runner: AgentRunner = {
-      runTurn: async (): Promise<TurnOutcome> => ({
-        status: "finished",
-        result: "ok",
-      }),
-    };
-
-    const engine = new SessionEngine({
-      project: testProject(stateRoot, {
-        tools: [discovered("handoff", handoff)],
-      }),
-      stateRoot,
-      runner,
-    });
-    cleanups.push(() => engine.close());
-
-    const drive = await engine.send("drive", "seed", {
-      auth: owner,
-      continuationToken: "sticky-pr",
-    });
-    await drive.waitForCompletion();
-
-    const chat = await engine.send("http", "chat", { auth: other });
-    await chat.waitForCompletion();
-
-    const outcome = await engine.callTool(
-      "handoff",
-      { token: "sticky-pr" },
-      { auth: other, sessionId: chat.id }
-    );
-    expect(outcome.isError).toBe(false);
-    expect(outcome.result).toEqual({
-      ok: false,
-      error: SessionAuthError.name,
-    });
-  });
-});