fix(eve): cancellation - align accepted response contract

Signed-off-by: Andrew Barba <barba@hey.com>

Author: AndrewBarba

.changeset/eve-channel-cancel-turn-route.md

@@ -2,4 +2,4 @@
 "eve": patch
 ---
 
-Added `POST /eve/v1/session/:sessionId/cancel` to the eve HTTP channel for requesting cancellation of an in-flight turn. The optional `{ turnId }` body limits the request to the turn the caller observed; the response reports `"cancelling"` when a cancellation hook accepts it or the benign `"no_active_turn"` when no resumable target exists.
+Added `POST /eve/v1/session/:sessionId/cancel` to the eve HTTP channel for requesting cancellation of an in-flight turn. The optional `{ turnId }` body limits the request to the turn the caller observed; the response reports `"accepted"` when a cancellation hook accepts it or the benign `"no_active_turn"` when no resumable target exists.

docs/channels/eve.mdx

@@ -49,10 +49,10 @@ Cancel a session's in-flight turn with an empty body, or scope the cancel to the
 
 ```bash
 curl -X POST https://<deployment>/eve/v1/session/ses_01h.../cancel
-# {"ok":true,"sessionId":"ses_01h...","status":"cancelling"}
+# {"ok":true,"sessionId":"ses_01h...","status":"accepted"}
 ```
 
-Cancellation is asynchronous: `"cancelling"` means a cancellation hook accepted the request. Confirm the effective outcome on the stream as `turn.cancelled` followed by `session.waiting` — never as a failure. Active local and remote subagents are cancelled recursively before the parent settles; their own streams carry their cancellation boundaries, and cancelled work does not emit `subagent.completed` on the parent. Content emitted before the cancel stays on the event stream, while durable model history keeps only content that had already settled. The session accepts the next message normally. When there is no resumable cancellation target (including an unknown session, a settled turn, or a duplicate cancel), the route responds with `"no_active_turn"` — also a success, so a stop button can fire and forget. A `turnId` naming any other turn is accepted and consumed as a no-op, so a guarded cancel racing a turn boundary cannot stop a turn the caller never saw.
+Cancellation is asynchronous: `"accepted"` means a cancellation hook accepted the request. Confirm the effective outcome on the stream as `turn.cancelled` followed by `session.waiting` — never as a failure. Active local and remote subagents are cancelled recursively before the parent settles; their own streams carry their cancellation boundaries, and cancelled work does not emit `subagent.completed` on the parent. Content emitted before the cancel stays on the event stream, while durable model history keeps only content that had already settled. The session accepts the next message normally. When there is no resumable cancellation target (including an unknown session, a settled turn, or a duplicate cancel), the route responds with `"no_active_turn"` — also a success, so a stop button can fire and forget. A `turnId` naming any other turn is accepted and consumed as a no-op, so a guarded cancel racing a turn boundary cannot stop a turn the caller never saw.
 
 See [Sessions, runs & streaming](../concepts/sessions-runs-and-streaming) for the full request and stream flow, including the complete event set.
 

docs/concepts/sessions-runs-and-streaming.md

@@ -95,10 +95,10 @@ POST to the session's cancel endpoint to stop the turn that is currently running
 
 ```bash
 curl -X POST http://127.0.0.1:3000/eve/v1/session/<sessionId>/cancel
-# {"ok":true,"sessionId":"<sessionId>","status":"cancelling"}
+# {"ok":true,"sessionId":"<sessionId>","status":"accepted"}
 ```
 
-`"cancelling"` means a cancellation hook accepted the request. Confirm cancellation on the stream as `turn.cancelled` followed by `session.waiting`; the session then accepts the next message normally. If the turn is waiting on active local or remote subagents, eve also requests cancellation of every adopted child, recursively, before settling the parent. Each child reports its own cancellation boundary on its child-session stream; the parent does not emit `subagent.completed` for cancelled work. `"no_active_turn"` means no resumable cancellation target exists, including an unknown session or an already-settled turn. Both statuses are success, so clients can fire and forget. See the [eve channel](../channels/eve) for the full route contract.
+`"accepted"` means a cancellation hook accepted the request. Confirm cancellation on the stream as `turn.cancelled` followed by `session.waiting`; the session then accepts the next message normally. If the turn is waiting on active local or remote subagents, eve also requests cancellation of every adopted child, recursively, before settling the parent. Each child reports its own cancellation boundary on its child-session stream; the parent does not emit `subagent.completed` for cancelled work. `"no_active_turn"` means no resumable cancellation target exists, including an unknown session or an already-settled turn. Both statuses are success, so clients can fire and forget. See the [eve channel](../channels/eve) for the full route contract.
 
 ## Reconnect and rewind
 

docs/evals/cases.mdx

@@ -103,7 +103,7 @@ export default defineEval({
 
 - `t.send(input)` sends a turn and waits for it to settle. It accepts the same input as `ClientSession.send()` (a string or a structured message) and resolves to a turn carrying `.message` and `.expectOk()`.
 - `t.start(input)` starts a turn but returns as soon as the server accepts it. The returned live turn exposes `.sessionId`, `.waitForEvent(...)`, `.cancel()`, and `.result()` for coordinating with work that is still running.
-- `t.cancel()` requests cooperative cancellation of the primary session's active turn. Both `cancelling` and `no_active_turn` are successful outcomes.
+- `t.cancel()` requests cooperative cancellation of the primary session's active turn. Both `accepted` and `no_active_turn` are successful outcomes.
 - `t.sendFile(text, path, mediaType?)` attaches a local file as a data URL.
 - `t.requireInputRequest(filter?)` records a gate, requires exactly one pending request, and returns it. Filters match tool name, action input, prompt, display, and option ids.
 - `t.respond(...responses)` answers specific pending input requests and sends them as the next turn.

docs/guides/client/streaming.mdx

@@ -5,7 +5,7 @@ description: "Consume eve client stream events live, reconnect by event index, a
 
 Every `ClientSession.send()` call posts the turn, then reads the session's NDJSON (newline-delimited JSON) event stream. `MessageResponse` gives you two ways to consume that stream, aggregating it with `result()` or iterating it live.
 
-Once `send()` is accepted, the session exposes its assigned `sessionId` and can request cooperative cancellation with `session.cancel()`, even while the response stream is still running. The result status is `cancelling` when the active turn accepted the signal or `no_active_turn` when it already settled:
+Once `send()` is accepted, the session exposes its assigned `sessionId` and can request cooperative cancellation with `session.cancel()`, even while the response stream is still running. The result status is `accepted` when the active turn accepted the signal or `no_active_turn` when it already settled:
 
 ```ts
 const session = client.session();

e2e/fixtures/agent-cancellation/evals/cancellation/cancel-subagent.eval.ts

@@ -25,7 +25,7 @@ export default defineEval({
     await t.require(
       cancelled,
       satisfies(
-        (value: typeof cancelled) => value.status === "cancelling",
+        (value: typeof cancelled) => value.status === "accepted",
         "parent cancel request is accepted",
       ),
     );

e2e/fixtures/agent-cancellation/evals/cancellation/cancel-turn.eval.ts

@@ -31,8 +31,8 @@ export default defineEval({
       cancelled,
       satisfies(
         (value: typeof cancelled) =>
-          value.sessionId === live.sessionId && value.status === "cancelling",
-        "cancel request is accepted with status 'cancelling'",
+          value.sessionId === live.sessionId && value.status === "accepted",
+        "cancel request is accepted with status 'accepted'",
       ),
     );
 
@@ -50,7 +50,7 @@ export default defineEval({
     followUp.notEvent("session.failed");
     followUp.messageIncludes(/CANCELLATION-FOLLOW-UP-OK/i);
 
-    let lateStatus: "cancelling" | "no_active_turn" | undefined;
+    let lateStatus: "accepted" | "no_active_turn" | undefined;
     for (let attempt = 0; attempt < 30; attempt += 1) {
       lateStatus = (await t.cancel()).status;
       if (lateStatus === "no_active_turn") break;

packages/eve/src/channel/types.ts

@@ -1,6 +1,7 @@
 import type { UserContent } from "ai";
 
 import type { HandleMessageStreamEvent } from "#protocol/message.js";
+import type { CancelTurnStatus } from "#protocol/cancel-turn.js";
 import type { RunMode } from "#shared/run-mode.js";
 import type { RuntimeActionResult } from "#runtime/actions/types.js";
 import type { InputRequest, InputResponse } from "#runtime/input/types.js";
@@ -27,7 +28,7 @@ export interface CancelTurnInput {
 
 /** Result of requesting turn cancellation. Both statuses are successful. */
 export interface CancelTurnResult {
-  readonly status: "cancelling" | "no_active_turn";
+  readonly status: CancelTurnStatus;
 }
 
 // ---------------------------------------------------------------------------

packages/eve/src/client/session.test.ts

@@ -66,7 +66,7 @@ describe("ClientSession", () => {
       });
       if (new URL(url).pathname.endsWith("/cancel")) {
         return Response.json(
-          { ok: true, sessionId: "session_1", status: "cancelling" },
+          { ok: true, sessionId: "session_1", status: "accepted" },
           { status: 202 },
         );
       }
@@ -88,7 +88,7 @@ describe("ClientSession", () => {
 
     expect(turn.sessionId).toBe("session_1");
     expect(session.state.sessionId).toBe("session_1");
-    expect(cancelled).toEqual({ sessionId: "session_1", status: "cancelling" });
+    expect(cancelled).toEqual({ sessionId: "session_1", status: "accepted" });
     expect(requests).toHaveLength(2);
     expect(new URL(requests[1]!.url).pathname).toBe("/eve/v1/session/session_1/cancel");
     expect(requests[1]!.method).toBe("POST");
@@ -99,6 +99,18 @@ describe("ClientSession", () => {
     await expect(createSession().cancel()).rejects.toThrow("Session has no session ID");
   });
 
+  it("rejects a cancel response for a different session", async () => {
+    vi.spyOn(globalThis, "fetch").mockResolvedValue(
+      Response.json(
+        { ok: true, sessionId: "another-session", status: "accepted" },
+        { status: 202 },
+      ),
+    );
+    const session = createSession({ sessionId: "session_1", streamIndex: 0 });
+
+    await expect(session.cancel()).rejects.toThrow("Cancel route returned an invalid response");
+  });
+
   it("serializes clientContext when sending a create-session message", async () => {
     const fetchMock = vi.spyOn(globalThis, "fetch").mockResolvedValueOnce(createAcceptedResponse());
     const session = createSession();

packages/eve/src/client/session.ts

@@ -1,5 +1,6 @@
 import type { HandleMessageStreamEvent } from "#protocol/message.js";
 import { EVE_SESSION_ID_HEADER, isCurrentTurnBoundaryEvent } from "#protocol/message.js";
+import { CancelTurnResponseSchema } from "#protocol/cancel-turn.js";
 import {
   EVE_CREATE_SESSION_ROUTE_PATH,
   createEveCancelTurnRoutePath,
@@ -91,7 +92,7 @@ export class ClientSession {
   /**
    * Requests cooperative cancellation of this session's active turn.
    *
-   * Both `cancelling` and `no_active_turn` are successful outcomes. The latter
+   * Both `accepted` and `no_active_turn` are successful outcomes. The latter
    * means the active turn settled before the request arrived or the session is
    * already parked. Credentials are resolved immediately before the request.
    *
@@ -123,12 +124,12 @@ export class ClientSession {
       throw new Error(`Cancel route returned invalid JSON (${response.status}).`);
     }
 
-    const status = readCancelStatus(payload);
-    if (status === undefined) {
+    const result = CancelTurnResponseSchema.safeParse(payload);
+    if (!result.success || result.data.sessionId !== sessionId) {
       throw new Error(`Cancel route returned an invalid response (${response.status}).`);
     }
 
-    return { sessionId, status };
+    return { sessionId: result.data.sessionId, status: result.data.status };
   }
 
   /**
@@ -427,12 +428,6 @@ function createHandleMessageBody(input: {
   return body;
 }
 
-function readCancelStatus(value: unknown): CancelSessionResult["status"] | undefined {
-  if (typeof value !== "object" || value === null) return undefined;
-  const status = (value as { readonly status?: unknown }).status;
-  return status === "cancelling" || status === "no_active_turn" ? status : undefined;
-}
-
 function withRedirectPolicy(init: RequestInit, redirect?: ClientRedirectPolicy): RequestInit {
   return redirect === undefined ? init : { ...init, redirect };
 }