Skip to content

armgit / eve

Public Imported from GitHub
0

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.md
new file mode 100644
index 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.mdx
index 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.ts
index 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.maxAttempts
diff --git a/packages/eve/src/client/session.test.ts b/packages/eve/src/client/session.test.ts
index 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.ts
index 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.ts
index 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.ts
index 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>) => {