The Open Framework for Building Agents
fix(eve): keep active turn streams connected (#2081)
Allen Zhou60e87ef93eb0
diff --git a/.changeset/tidy-streams-resume.md b/.changeset/tidy-streams-resume.mdnew file mode 100644index 000000000..6ffda652c--- /dev/null+++ b/.changeset/tidy-streams-resume.md@@ -0,0 +1,5 @@+---+"eve": patch+---++Keep active client turns connected while they are paused for authorization so responses resume automatically after the callback completes.diff --git a/docs/guides/client/streaming.mdx b/docs/guides/client/streaming.mdxindex 836d13c02..9c2ba454e 100644--- a/docs/guides/client/streaming.mdx+++ b/docs/guides/client/streaming.mdx@@ -126,7 +126,7 @@ If you support refresh while an authorization prompt is pending, keep the sessio## Reconnection-HTTP connections can end before a run does. The client reconnects from the number of events already consumed, so long turns continue without replaying events. It stops at a turn boundary, when aborted, or when the stream can no longer make progress.+HTTP connections can end before a run does. The client reconnects from the number of events already consumed, so long turns continue without replaying events. By default, a turn response keeps reconnecting until it reaches a turn boundary or is aborted, including while the turn is paused for authorization. A manually opened `session.stream()` eventually stops after repeated empty streams when it can no longer make progress.If your consumer persists events, key on `event.meta.id`. It is stable across reconnects and rewinds, so an overlapping replay is safe to ingest twice. See [the event envelope](../../concepts/sessions-runs-and-streaming#the-event-envelope).diff --git a/packages/eve/src/client/open-stream.ts b/packages/eve/src/client/open-stream.tsindex b0d8007d5..a78c775e4 100644--- a/packages/eve/src/client/open-stream.ts+++ b/packages/eve/src/client/open-stream.ts@@ -76,6 +76,8 @@ function resolveStreamReconnectPolicy(*/interface FollowStreamInput {readonly host: string;+ /** Keep reconnecting after empty streams until the consumer aborts or stops iteration. */+ readonly keepAlive?: boolean;readonly streamReconnectPolicy?: StreamReconnectPolicy;readonly resolveHeaders: () => Promise<Headers>;readonly redirect?: ClientRedirectPolicy;@@ -177,6 +179,7 @@ export async function* followStreamIterable(}if (+ input.keepAlive !== true &&!deliveredEvent &&!initialConnection &&(idleReconnects += 1) >= idleRetryPolicy.maxAttemptsdiff --git a/packages/eve/src/client/session.test.ts b/packages/eve/src/client/session.test.tsindex 979fcce1d..2aa6fac5c 100644--- a/packages/eve/src/client/session.test.ts+++ b/packages/eve/src/client/session.test.ts@@ -800,6 +800,71 @@ describe("ClientSession", () => {]);});+ it("keeps following an active turn while authorization is pending", async () => {+ let streamRequest = 0;+ const fetchMock = vi.spyOn(globalThis, "fetch").mockImplementation(async (_request, init) => {+ if ((init?.method ?? "GET") === "POST") {+ return createAcceptedResponse();+ }++ streamRequest += 1;+ if (streamRequest === 1) {+ return createStreamResponse([{ type: "authorization.required", data: {} }]);+ }+ if (streamRequest <= 7) {+ return createStreamResponse([]);+ }+ return createStreamResponse([+ { type: "authorization.completed", data: {} },+ {+ type: "session.waiting",+ data: { continuationToken: "session-id", wait: "next-user-message" },+ },+ ]);+ });+ const session = createSession();++ vi.useFakeTimers();+ try {+ const eventTypes = await collectEventTypes(await session.send("first"));+ expect(eventTypes).toEqual([+ "authorization.required",+ "authorization.completed",+ "session.waiting",+ ]);+ } finally {+ vi.useRealTimers();+ }++ expect(fetchMock).toHaveBeenCalledTimes(9);+ expect(session.state.streamIndex).toBe(3);+ });++ it("honors an explicit idle reconnect limit for an active turn", async () => {+ const fetchMock = vi.spyOn(globalThis, "fetch").mockImplementation(async (_request, init) => {+ return (init?.method ?? "GET") === "POST"+ ? createAcceptedResponse()+ : createStreamResponse([]);+ });+ const session = createSession();++ vi.useFakeTimers();+ try {+ const eventTypes = await collectEventTypes(+ await session.send("first", {+ streamReconnectPolicy: {+ streamIdleReconnectPolicy: { baseDelayMs: 10, maxAttempts: 2 },+ },+ }),+ );+ expect(eventTypes).toEqual([]);+ } finally {+ vi.useRealTimers();+ }++ expect(fetchMock).toHaveBeenCalledTimes(4);+ });+it("preserves the session cursor when a turn stream is aborted mid-flight", async () => {const encoder = new TextEncoder();const abortController = new AbortController();diff --git a/packages/eve/src/client/session.ts b/packages/eve/src/client/session.tsindex 704c8ebaf..4a6bf9be0 100644--- a/packages/eve/src/client/session.ts+++ b/packages/eve/src/client/session.ts@@ -183,6 +183,7 @@ export class ClientSession {try {for await (const event of this.#readStream({headers: input.headers,+ keepAlive: shouldKeepActiveTurnAlive(input.streamReconnectPolicy),signal: input.signal,startIndex: initialStreamIndex,streamReconnectPolicy: input.streamReconnectPolicy,@@ -225,6 +226,7 @@ export class ClientSession {#readStream(input: {readonly follow?: boolean;readonly headers?: Readonly<Record<string, string>>;+ readonly keepAlive?: boolean;readonly signal?: AbortSignal;readonly startIndex: number;readonly streamReconnectPolicy?: StreamOptions["streamReconnectPolicy"];@@ -232,6 +234,7 @@ export class ClientSession {return followStreamIterable({follow: input.follow,host: this.#context.host,+ keepAlive: input.keepAlive,resolveHeaders: () => this.#context.resolveHeaders(input.headers),redirect: this.#context.redirect,sessionId: this.#state.sessionId,@@ -242,6 +245,14 @@ export class ClientSession {}}+function shouldKeepActiveTurnAlive(policy: StreamOptions["streamReconnectPolicy"]): boolean {+ if (policy && "reconnect" in policy) {+ return false;+ }++ return policy?.streamIdleReconnectPolicy?.maxAttempts === undefined;+}+async function postTurn(context: ClientSessionContext,path: string,diff --git a/packages/eve/src/react/use-eve-agent.test.ts b/packages/eve/src/react/use-eve-agent.test.tsindex 5212ac245..a57f8fc62 100644--- a/packages/eve/src/react/use-eve-agent.test.ts+++ b/packages/eve/src/react/use-eve-agent.test.ts@@ -142,6 +142,54 @@ describe("useEveAgent", () => {expect(seenHelpers.at(-1)).toBe(firstHelpers);});+ it("stops an active turn stream when the component unmounts", async () => {+ let streamSignal: AbortSignal | null | undefined;+ const fetchMock = vi.spyOn(globalThis, "fetch").mockImplementation(async (_request, init) => {+ if ((init?.method ?? "GET") === "POST") {+ return createStartedMessageResponse("session_1", "http:session_1");+ }++ streamSignal = init?.signal;+ return new Response(+ new ReadableStream<Uint8Array>({+ start(controller) {+ streamSignal?.addEventListener("abort", () => controller.error(createAbortError()));+ },+ }),+ );+ });++ let helpers: UseEveAgentHelpers<EveMessageData> | undefined;+ let root: ReturnType<typeof create> | undefined;++ function TestComponent() {+ helpers = useEveAgent();+ return null;+ }++ await act(async () => {+ root = create(createElement(TestComponent));+ });++ let sendPromise: Promise<void> | undefined;+ await act(async () => {+ sendPromise = helpers?.send("Hello");+ await vi.waitFor(() => expect(fetchMock).toHaveBeenCalledTimes(2));+ });++ expect(streamSignal?.aborted).toBe(false);++ await act(async () => {+ root?.unmount();+ });++ expect(streamSignal?.aborted).toBe(true);++ await act(async () => {+ await sendPromise;+ });+ });+it("sends a message and projects streamed events with the default reducer", async () => {const events = [createMessageReceivedEvent({diff --git a/packages/eve/src/react/use-eve-agent.ts b/packages/eve/src/react/use-eve-agent.tsindex bc0f7b092..2d7da1c3a 100644--- a/packages/eve/src/react/use-eve-agent.ts+++ b/packages/eve/src/react/use-eve-agent.ts@@ -1,4 +1,4 @@-import { useCallback, useMemo, useRef, useSyncExternalStore } from "react";+import { useCallback, useEffect, useMemo, useRef, useSyncExternalStore } from "react";import {EveAgentStore,@@ -168,6 +168,8 @@ export function useEveAgent<TData>(() => store.snapshot,);+ useEffect(() => () => store.stop(), [store]);+const reset = useCallback(() => store.reset(), [store]);const send = useCallback(<TOutput = unknown>(message: string | UserContent, options?: SendTurnOptions<TOutput>) => {