Skip to content

armgit / eve

Public Imported from GitHub
0

The Open Framework for Building Agents

fix(eve): cancel a turn resumed by an input answer (#4570)

roboeve[bot]caf61ffb9b99
diff --git a/.changeset/cancel-resumed-answer-turn.md b/.changeset/cancel-resumed-answer-turn.md
new file mode 100644
index 000000000..7caafad6a
--- /dev/null
+++ b/.changeset/cancel-resumed-answer-turn.md
@@ -0,0 +1,5 @@
+---
+"eve": patch
+---
+
+`cancel()` from `useEveAgent()` and `EveAgentStore` now stops a turn that an approval or other input answer resumed. Previously it sent no cancel request and the resumed turn ran to completion. `MessageResponse.cancel()` on a `ClientSession.respond()` response now targets that resumed turn too.
diff --git a/packages/eve/src/client/eve-agent-store.test.ts b/packages/eve/src/client/eve-agent-store.test.ts
index 0bbbafb76..d62ec6fed 100644
--- a/packages/eve/src/client/eve-agent-store.test.ts
+++ b/packages/eve/src/client/eve-agent-store.test.ts
@@ -21,6 +21,8 @@ import {
createSessionWaitingEvent,
createAgentStartedEvent,
createInputRequestedEvent,
+ createInputResolvedEvent,
+ createStepStartedEvent,
createTaskSettledEvent,
createTaskStartedEvent,
createTurnCompletedEvent,
@@ -2481,6 +2483,63 @@ describe("EveAgentStore cancellation", () => {
await expect(store.cancel()).resolves.toEqual({ status: "no_active_turn" });
});
+ it("cancels a turn resumed by an approval answer", async () => {
+ const events = stampTestEvents([
+ createTurnStartedEvent({ sequence: 0, turnId: "turn_1" }),
+ colorApprovalRequested("color-a"),
+ createTurnWaitingEvent({ on: "input", sequence: 1, turnId: "turn_1", usage: TEST_USAGE }),
+ createInputResolvedEvent({
+ resolutions: [
+ {
+ kind: "tool-approval",
+ outcome: "approved",
+ requestId: "color-a",
+ response: { optionId: "approve", requestId: "color-a" },
+ },
+ ],
+ sequence: 2,
+ stepIndex: 1,
+ turnId: "turn_1",
+ }),
+ createStepStartedEvent({ modelId: "mock", sequence: 3, stepIndex: 1, turnId: "turn_1" }),
+ createTurnCancelledEvent({ sequence: 4, turnId: "turn_1" }),
+ createSessionWaitingEvent(TEST_USAGE),
+ ] as UnstampedMessageStreamEvent[]);
+ const parked = events.slice(0, 3);
+ const resumed = events.slice(3);
+ const live = controlledStreamResponse();
+ const fetchMock = vi.spyOn(globalThis, "fetch").mockImplementation(async (url, init) => {
+ if (init?.method !== "POST") return live.response;
+ return String(url).endsWith("/cancel") ? acceptedCancellationResponse() : startedResponse();
+ });
+ const cancelRequests = () =>
+ fetchMock.mock.calls.filter(([url]) => String(url) === "/eve/v1/session/session_1/cancel");
+ const store = createStore({
+ initialEvents: parked,
+ initialSession: { sessionId: "session_1", streamIndex: parked.length },
+ reducer: defaultMessageReducer(),
+ });
+
+ const answering = store.send({
+ inputResponses: [{ optionId: "approve", requestId: "color-a" }],
+ });
+ await vi.waitFor(() => expect(fetchMock).toHaveBeenCalledTimes(2));
+ live.emit(resumed[0]!);
+ live.emit(resumed[1]!);
+ await vi.waitFor(() => expect(store.snapshot.status).toBe("streaming"));
+
+ const cancellation = store.cancel();
+ await vi.waitFor(() => expect(cancelRequests()).toHaveLength(1));
+ expect(JSON.parse(String(cancelRequests()[0]?.[1]?.body))).toEqual({ turnId: "turn_1" });
+
+ live.emit(resumed[2]!);
+ live.emit(resumed[3]!);
+ live.close();
+ await expect(cancellation).resolves.toEqual({ sessionId: "session_1", status: "accepted" });
+ await answering;
+ expect(store.snapshot.status).toBe("ready");
+ });
+
it("resolves a queued cancellation when reset wins before dispatch", async () => {
const fetchMock = vi.spyOn(globalThis, "fetch");
const store = createStore({ reducer: defaultMessageReducer() });
diff --git a/packages/eve/src/client/eve-agent-store.ts b/packages/eve/src/client/eve-agent-store.ts
index d50614f76..bf99a90cd 100644
--- a/packages/eve/src/client/eve-agent-store.ts
+++ b/packages/eve/src/client/eve-agent-store.ts
@@ -357,8 +357,8 @@ export class EveAgentStore<TData> {
/**
* Requests cooperative cancellation of the active durable turn.
*
- * If the server has not emitted `turn.started` yet, the request waits for
- * that turn ID. The event stream stays attached until the turn settles.
+ * If the stream has not identified the turn yet, the request waits for its
+ * turn ID. The event stream stays attached until the turn settles.
*/
cancel(): Promise<CancelSessionResult> {
const turn = this.#activeTurn;
diff --git a/packages/eve/src/client/message-response.test.ts b/packages/eve/src/client/message-response.test.ts
index 541f0c25d..7f3eadd35 100644
--- a/packages/eve/src/client/message-response.test.ts
+++ b/packages/eve/src/client/message-response.test.ts
@@ -3,6 +3,7 @@ import { describe, expect, it, vi } from "vitest";
import { MessageResponse } from "#client/message-response.js";
import { TEST_USAGE, stampTestEvents } from "#internal/testing/events.js";
import {
+ createInputResolvedEvent,
createSessionWaitingEvent,
createTurnStartedEvent,
type MessageStreamEvent,
@@ -23,6 +24,15 @@ function acceptedCancellation() {
return { sessionId: "session_1", status: "accepted" as const };
}
+function inputResolved(turnId: string): UnstampedMessageStreamEvent {
+ return createInputResolvedEvent({
+ resolutions: [{ kind: "tool-approval", outcome: "approved", requestId: "approval_1" }],
+ sequence: 0,
+ stepIndex: 0,
+ turnId,
+ });
+}
+
describe("MessageResponse cancellation", () => {
it("queues one guarded cancellation until this response identifies its turn", async () => {
const start = createDeferred<void>();
@@ -107,4 +117,33 @@ describe("MessageResponse cancellation", () => {
await consumed;
expect(cancelTurn).not.toHaveBeenCalled();
});
+
+ it.each([
+ { label: "an answer's resumed turn", events: [inputResolved("turn_1")], resumesTurn: true },
+ {
+ label: "a message's turn past an earlier turn's resolution",
+ events: [inputResolved("turn_0"), createTurnStartedEvent({ sequence: 0, turnId: "turn_1" })],
+ resumesTurn: false,
+ },
+ ])("targets $label", async ({ events, resumesTurn }) => {
+ const settle = createDeferred<void>();
+ const cancelTurn = vi.fn(async () => acceptedCancellation());
+ const response = new MessageResponse({
+ cancelTurn,
+ createStream: async function* () {
+ yield* stampTestEvents(events);
+ await settle.promise;
+ yield* stampTestEvents([createSessionWaitingEvent(TEST_USAGE)]);
+ },
+ resumesTurn,
+ sessionId: "session_1",
+ });
+
+ const consumed = consume(response);
+ await expect(response.cancel()).resolves.toEqual(acceptedCancellation());
+ expect(cancelTurn).toHaveBeenCalledExactlyOnceWith("turn_1");
+
+ settle.resolve();
+ await consumed;
+ });
});
diff --git a/packages/eve/src/client/message-response.ts b/packages/eve/src/client/message-response.ts
index 79ce526ac..ae421ccc2 100644
--- a/packages/eve/src/client/message-response.ts
+++ b/packages/eve/src/client/message-response.ts
@@ -12,6 +12,8 @@ interface MessageResponseInput {
source?: AsyncIterable<MessageStreamEvent>,
) => AsyncGenerator<MessageStreamEvent>;
readonly deliveryId?: string;
+ /** Answers resume a turn that started before their stream, so its `input.resolved` names it. */
+ readonly resumesTurn?: boolean;
readonly sessionId: string;
}
@@ -36,6 +38,7 @@ export class MessageResponse<TOutput = unknown> implements AsyncIterable<Message
#cancellation: Promise<CancelSessionResult> | undefined;
#consumed = false;
readonly #createStream: MessageResponseInput["createStream"];
+ readonly #resumesTurn: boolean;
#settled = false;
readonly #turnId = Promise.withResolvers<string | undefined>();
@@ -45,6 +48,7 @@ export class MessageResponse<TOutput = unknown> implements AsyncIterable<Message
this.sessionId = input.sessionId;
this[acceptedDeliveryId] = input.deliveryId;
this.#createStream = input.createStream;
+ this.#resumesTurn = input.resumesTurn ?? false;
}
/**
@@ -114,7 +118,10 @@ export class MessageResponse<TOutput = unknown> implements AsyncIterable<Message
): AsyncGenerator<MessageStreamEvent> {
try {
for await (const event of this.#createStream(source)) {
- if (event.type === "turn.started") {
+ if (
+ event.type === "turn.started" ||
+ (this.#resumesTurn && event.type === "input.resolved")
+ ) {
this.#turnId.resolve(event.data.turnId);
} else if (isCurrentTurnBoundaryEvent(event)) {
this.#settled = true;
diff --git a/packages/eve/src/client/session.ts b/packages/eve/src/client/session.ts
index f0b751929..061fdc5a1 100644
--- a/packages/eve/src/client/session.ts
+++ b/packages/eve/src/client/session.ts
@@ -238,6 +238,7 @@ export class ClientSession {
createStream: (source) =>
this.#createEventStream(initialStreamIndex, input, deliveryId, source),
deliveryId,
+ resumesTurn: input.inputResponses !== undefined,
sessionId: this.#state.sessionId,
});
}