@assistant-ui/react-google-adk 0.0.16 → 0.0.18

package/src/AdkClient.test.ts

@@ -34,6 +34,28 @@ const sseBody = (text: string): ReadableStream<Uint8Array> => {
   });
 };
 
+const sseResponse = (
+  body: BodyInit | null,
+  contentType: string | null = "text/event-stream",
+): Response =>
+  new Response(body, {
+    status: 200,
+    ...(contentType === null
+      ? {}
+      : { headers: { "Content-Type": contentType } }),
+  });
+
+const nextWithTimeout = async <T>(
+  promise: Promise<IteratorResult<T>>,
+): Promise<IteratorResult<T> | "timeout"> => {
+  return Promise.race([
+    promise,
+    new Promise<"timeout">((resolve) => {
+      setTimeout(() => resolve("timeout"), 100);
+    }),
+  ]);
+};
+
 const mockFetch =
   vi.fn<(input: RequestInfo | URL, init?: RequestInit) => Promise<Response>>();
 
@@ -46,7 +68,7 @@ beforeEach(() => {
 
 describe("createAdkStream - proxy mode", () => {
   it("POSTs to the api URL directly", async () => {
-    mockFetch.mockResolvedValueOnce(new Response(sseBody(""), { status: 200 }));
+    mockFetch.mockResolvedValueOnce(sseResponse(sseBody("")));
 
     const stream = createAdkStream({ api: "/api/adk" });
     const messages: AdkMessage[] = [
@@ -67,7 +89,7 @@ describe("createAdkStream - proxy mode", () => {
   });
 
   it("sends runConfig and checkpointId in proxy body", async () => {
-    mockFetch.mockResolvedValueOnce(new Response(sseBody(""), { status: 200 }));
+    mockFetch.mockResolvedValueOnce(sseResponse(sseBody("")));
 
     const stream = createAdkStream({ api: "/api/adk" });
     const gen = await stream(
@@ -84,7 +106,7 @@ describe("createAdkStream - proxy mode", () => {
   });
 
   it("sends a tool-result body when message type is tool", async () => {
-    mockFetch.mockResolvedValueOnce(new Response(sseBody(""), { status: 200 }));
+    mockFetch.mockResolvedValueOnce(sseResponse(sseBody("")));
 
     const stream = createAdkStream({ api: "/api/adk" });
     const messages: AdkMessage[] = [
@@ -111,7 +133,7 @@ describe("createAdkStream - proxy mode", () => {
   });
 
   it("sends parts when message has multimodal content", async () => {
-    mockFetch.mockResolvedValueOnce(new Response(sseBody(""), { status: 200 }));
+    mockFetch.mockResolvedValueOnce(sseResponse(sseBody("")));
 
     const stream = createAdkStream({ api: "/api/adk" });
     const messages: AdkMessage[] = [
@@ -138,7 +160,7 @@ describe("createAdkStream - proxy mode", () => {
   });
 
   it("sends file parts as inlineData in proxy mode", async () => {
-    mockFetch.mockResolvedValueOnce(new Response(sseBody(""), { status: 200 }));
+    mockFetch.mockResolvedValueOnce(sseResponse(sseBody("")));
 
     const stream = createAdkStream({ api: "/api/adk" });
     const messages: AdkMessage[] = [
@@ -169,7 +191,7 @@ describe("createAdkStream - proxy mode", () => {
   });
 
   it("sends parts array when multiple messages are provided", async () => {
-    mockFetch.mockResolvedValueOnce(new Response(sseBody(""), { status: 200 }));
+    mockFetch.mockResolvedValueOnce(sseResponse(sseBody("")));
 
     const stream = createAdkStream({ api: "/api/adk" });
     const messages: AdkMessage[] = [
@@ -194,7 +216,7 @@ describe("createAdkStream - proxy mode", () => {
   });
 
   it("marks isError=true when tool status is error", async () => {
-    mockFetch.mockResolvedValueOnce(new Response(sseBody(""), { status: 200 }));
+    mockFetch.mockResolvedValueOnce(sseResponse(sseBody("")));
 
     const stream = createAdkStream({ api: "/api/adk" });
     const messages: AdkMessage[] = [
@@ -220,8 +242,35 @@ describe("createAdkStream - proxy mode", () => {
 // ── Direct mode ──
 
 describe("createAdkStream - direct mode", () => {
+  it("rejects direct mode with an empty appName", () => {
+    expect(() =>
+      createAdkStream({
+        api: "http://localhost:8000",
+        appName: "",
+        userId: "user-1",
+      }),
+    ).toThrow('createAdkStream direct mode requires a non-empty "appName".');
+    expect(mockFetch).not.toHaveBeenCalled();
+  });
+
+  it.each([
+    ["missing", undefined],
+    ["empty", ""],
+  ])("rejects direct mode with a %s userId", (_label, userId) => {
+    expect(() =>
+      createAdkStream({
+        api: "http://localhost:8000",
+        appName: "my-app",
+        userId,
+      }),
+    ).toThrow(
+      'createAdkStream direct mode requires "userId" when "appName" is provided.',
+    );
+    expect(mockFetch).not.toHaveBeenCalled();
+  });
+
   it("POSTs to /run_sse with ADK-native body", async () => {
-    mockFetch.mockResolvedValueOnce(new Response(sseBody(""), { status: 200 }));
+    mockFetch.mockResolvedValueOnce(sseResponse(sseBody("")));
 
     const stream = createAdkStream({
       api: "http://localhost:8000",
@@ -250,11 +299,33 @@ describe("createAdkStream - direct mode", () => {
     });
   });
 
+  it.each(["http://localhost:8000/", "http://localhost:8000//"])(
+    "normalizes trailing slashes in the api URL: %s",
+    async (api) => {
+      mockFetch.mockResolvedValueOnce(sseResponse(sseBody("")));
+
+      const stream = createAdkStream({
+        api,
+        appName: "my-app",
+        userId: "user-1",
+      });
+      const gen = await stream(
+        [{ id: "m1", type: "human", content: "Hello" }],
+        makeConfig(),
+      );
+      for await (const _ of gen) {
+        /* noop */
+      }
+
+      expect(mockFetch.mock.calls[0]![0]).toBe("http://localhost:8000/run_sse");
+    },
+  );
+
   it("calls config.initialize() to get the sessionId", async () => {
     const initialize = vi
       .fn()
       .mockResolvedValue({ remoteId: "r1", externalId: "s-42" });
-    mockFetch.mockResolvedValueOnce(new Response(sseBody(""), { status: 200 }));
+    mockFetch.mockResolvedValueOnce(sseResponse(sseBody("")));
 
     const stream = createAdkStream({
       api: "http://localhost:8000",
@@ -275,7 +346,7 @@ describe("createAdkStream - direct mode", () => {
   });
 
   it("converts tool messages to functionResponse parts", async () => {
-    mockFetch.mockResolvedValueOnce(new Response(sseBody(""), { status: 200 }));
+    mockFetch.mockResolvedValueOnce(sseResponse(sseBody("")));
 
     const stream = createAdkStream({
       api: "http://localhost:8000",
@@ -307,7 +378,7 @@ describe("createAdkStream - direct mode", () => {
   });
 
   it("falls back to raw string when tool content is not valid JSON", async () => {
-    mockFetch.mockResolvedValueOnce(new Response(sseBody(""), { status: 200 }));
+    mockFetch.mockResolvedValueOnce(sseResponse(sseBody("")));
 
     const stream = createAdkStream({
       api: "http://localhost:8000",
@@ -333,7 +404,7 @@ describe("createAdkStream - direct mode", () => {
   });
 
   it("sends empty text part when no messages provided", async () => {
-    mockFetch.mockResolvedValueOnce(new Response(sseBody(""), { status: 200 }));
+    mockFetch.mockResolvedValueOnce(sseResponse(sseBody("")));
 
     const stream = createAdkStream({
       api: "http://localhost:8000",
@@ -359,9 +430,7 @@ describe("createAdkStream - SSE parsing", () => {
       { id: "e2", content: { parts: [{ text: "world" }] } },
     ];
     const text = events.map((e) => `data: ${JSON.stringify(e)}\n\n`).join("");
-    mockFetch.mockResolvedValueOnce(
-      new Response(sseBody(text), { status: 200 }),
-    );
+    mockFetch.mockResolvedValueOnce(sseResponse(sseBody(text)));
 
     const stream = createAdkStream({ api: "/api/adk" });
     const gen = await stream(
@@ -378,11 +447,47 @@ describe("createAdkStream - SSE parsing", () => {
     expect(collected[1]!.id).toBe("e2");
   });
 
+  it("accepts parameterized event-stream content types", async () => {
+    const event: AdkEvent = { id: "e1" };
+    mockFetch.mockResolvedValueOnce(
+      sseResponse(
+        sseBody(`data: ${JSON.stringify(event)}\n\n`),
+        "Text/Event-Stream; charset=utf-8",
+      ),
+    );
+
+    const stream = createAdkStream({ api: "/api/adk" });
+    const gen = await stream(
+      [{ id: "m1", type: "human", content: "Hi" }],
+      makeConfig(),
+    );
+    const collected: AdkEvent[] = [];
+    for await (const value of gen) collected.push(value);
+
+    expect(collected).toEqual([event]);
+  });
+
   it("skips :ok SSE comments", async () => {
     const text = `:ok\n\ndata: ${JSON.stringify({ id: "e1" })}\n\n`;
-    mockFetch.mockResolvedValueOnce(
-      new Response(sseBody(text), { status: 200 }),
+    mockFetch.mockResolvedValueOnce(sseResponse(sseBody(text)));
+
+    const stream = createAdkStream({ api: "/api/adk" });
+    const gen = await stream(
+      [{ id: "m1", type: "human", content: "Hi" }],
+      makeConfig(),
     );
+    const collected: AdkEvent[] = [];
+    for await (const evt of gen) {
+      collected.push(evt);
+    }
+
+    expect(collected).toHaveLength(1);
+    expect(collected[0]!.id).toBe("e1");
+  });
+
+  it("parses data fields without a space after the colon", async () => {
+    const text = `data:${JSON.stringify({ id: "e1" })}\n\n`;
+    mockFetch.mockResolvedValueOnce(sseResponse(sseBody(text)));
 
     const stream = createAdkStream({ api: "/api/adk" });
     const gen = await stream(
@@ -398,6 +503,56 @@ describe("createAdkStream - SSE parsing", () => {
     expect(collected[0]!.id).toBe("e1");
   });
 
+  it("parses CR-delimited SSE events", async () => {
+    const events: AdkEvent[] = [{ id: "e1" }, { id: "e2" }];
+    const text = events.map((e) => `data: ${JSON.stringify(e)}\r\r`).join("");
+    mockFetch.mockResolvedValueOnce(sseResponse(sseBody(text)));
+
+    const stream = createAdkStream({ api: "/api/adk" });
+    const gen = await stream(
+      [{ id: "m1", type: "human", content: "Hi" }],
+      makeConfig(),
+    );
+    const collected: AdkEvent[] = [];
+    for await (const evt of gen) {
+      collected.push(evt);
+    }
+
+    expect(collected).toHaveLength(2);
+    expect(collected[0]!.id).toBe("e1");
+    expect(collected[1]!.id).toBe("e2");
+  });
+
+  it("emits CRLF-delimited SSE events before the response closes", async () => {
+    const encoder = new TextEncoder();
+    let controller!: ReadableStreamDefaultController<Uint8Array>;
+    const body = new ReadableStream<Uint8Array>({
+      start(nextController) {
+        controller = nextController;
+      },
+    });
+    mockFetch.mockResolvedValueOnce(sseResponse(body));
+
+    const stream = createAdkStream({ api: "/api/adk" });
+    const gen = await stream(
+      [{ id: "m1", type: "human", content: "Hi" }],
+      makeConfig(),
+    );
+
+    const first = gen.next();
+    controller.enqueue(
+      encoder.encode(`data: ${JSON.stringify({ id: "e1" })}\r`),
+    );
+    controller.enqueue(encoder.encode("\n\r\n"));
+
+    await expect(nextWithTimeout(first)).resolves.toMatchObject({
+      done: false,
+      value: { id: "e1" },
+    });
+
+    controller.close();
+  });
+
   it("handles partial chunks that split across reads", async () => {
     const event = { id: "e1", content: { parts: [{ text: "split" }] } };
     const fullText = `data: ${JSON.stringify(event)}\n\n`;
@@ -413,7 +568,34 @@ describe("createAdkStream - SSE parsing", () => {
         controller.close();
       },
     });
-    mockFetch.mockResolvedValueOnce(new Response(body, { status: 200 }));
+    mockFetch.mockResolvedValueOnce(sseResponse(body));
+
+    const stream = createAdkStream({ api: "/api/adk" });
+    const gen = await stream(
+      [{ id: "m1", type: "human", content: "Hi" }],
+      makeConfig(),
+    );
+    const collected: AdkEvent[] = [];
+    for await (const evt of gen) {
+      collected.push(evt);
+    }
+
+    expect(collected).toHaveLength(1);
+    expect(collected[0]!.id).toBe("e1");
+  });
+
+  it("parses CR-delimited events split across chunks", async () => {
+    const encoder = new TextEncoder();
+    const body = new ReadableStream<Uint8Array>({
+      start(controller) {
+        controller.enqueue(
+          encoder.encode(`data: ${JSON.stringify({ id: "e1" })}\r`),
+        );
+        controller.enqueue(encoder.encode("\r"));
+        controller.close();
+      },
+    });
+    mockFetch.mockResolvedValueOnce(sseResponse(body));
 
     const stream = createAdkStream({ api: "/api/adk" });
     const gen = await stream(
@@ -433,9 +615,7 @@ describe("createAdkStream - SSE parsing", () => {
     // No trailing \n\n
     const event = { id: "e1" };
     const text = `data: ${JSON.stringify(event)}\n`;
-    mockFetch.mockResolvedValueOnce(
-      new Response(sseBody(text), { status: 200 }),
-    );
+    mockFetch.mockResolvedValueOnce(sseResponse(sseBody(text)));
 
     const stream = createAdkStream({ api: "/api/adk" });
     const gen = await stream(
@@ -471,13 +651,57 @@ describe("createAdkStream - error handling", () => {
       }
     }).rejects.toThrow("ADK request failed: 404 Not Found");
   });
+
+  it("rejects successful HTML responses and cancels their body", async () => {
+    const cancelBody = vi.fn();
+    const body = new ReadableStream<Uint8Array>({
+      start(controller) {
+        controller.enqueue(new TextEncoder().encode("<html>Sign in</html>"));
+      },
+      cancel: cancelBody,
+    });
+    mockFetch.mockResolvedValueOnce(
+      sseResponse(body, "text/html; charset=utf-8"),
+    );
+
+    const stream = createAdkStream({ api: "/api/adk" });
+    await expect(async () => {
+      const gen = await stream(
+        [{ id: "m1", type: "human", content: "Hi" }],
+        makeConfig(),
+      );
+      for await (const _ of gen) {
+        /* noop */
+      }
+    }).rejects.toThrow(
+      'Expected ADK stream response Content-Type "text/event-stream", received "text/html; charset=utf-8"',
+    );
+    expect(cancelBody).toHaveBeenCalledOnce();
+  });
+
+  it("rejects successful responses without a content type", async () => {
+    mockFetch.mockResolvedValueOnce(sseResponse(sseBody(""), null));
+
+    const stream = createAdkStream({ api: "/api/adk" });
+    await expect(async () => {
+      const gen = await stream(
+        [{ id: "m1", type: "human", content: "Hi" }],
+        makeConfig(),
+      );
+      for await (const _ of gen) {
+        /* noop */
+      }
+    }).rejects.toThrow(
+      'Expected ADK stream response Content-Type "text/event-stream", received no Content-Type header',
+    );
+  });
 });
 
 // ── Headers ──
 
 describe("createAdkStream - headers", () => {
   it("sends static headers", async () => {
-    mockFetch.mockResolvedValueOnce(new Response(sseBody(""), { status: 200 }));
+    mockFetch.mockResolvedValueOnce(sseResponse(sseBody("")));
 
     const stream = createAdkStream({
       api: "/api/adk",
@@ -500,7 +724,7 @@ describe("createAdkStream - headers", () => {
   });
 
   it("resolves dynamic headers from a function", async () => {
-    mockFetch.mockResolvedValueOnce(new Response(sseBody(""), { status: 200 }));
+    mockFetch.mockResolvedValueOnce(sseResponse(sseBody("")));
 
     const stream = createAdkStream({
       api: "/api/adk",
@@ -522,7 +746,7 @@ describe("createAdkStream - headers", () => {
   });
 
   it("resolves async dynamic headers", async () => {
-    mockFetch.mockResolvedValueOnce(new Response(sseBody(""), { status: 200 }));
+    mockFetch.mockResolvedValueOnce(sseResponse(sseBody("")));
 
     const stream = createAdkStream({
       api: "/api/adk",
@@ -544,7 +768,7 @@ describe("createAdkStream - headers", () => {
   });
 
   it("sends no extra headers when headers option is undefined", async () => {
-    mockFetch.mockResolvedValueOnce(new Response(sseBody(""), { status: 200 }));
+    mockFetch.mockResolvedValueOnce(sseResponse(sseBody("")));
 
     const stream = createAdkStream({ api: "/api/adk" });
     const gen = await stream(
@@ -567,7 +791,7 @@ describe("createAdkStream - headers", () => {
 
 describe("createAdkStream - AbortSignal", () => {
   it("forwards the AbortSignal to fetch", async () => {
-    mockFetch.mockResolvedValueOnce(new Response(sseBody(""), { status: 200 }));
+    mockFetch.mockResolvedValueOnce(sseResponse(sseBody("")));
 
     const controller = new AbortController();
     const stream = createAdkStream({ api: "/api/adk" });
@@ -587,7 +811,7 @@ describe("createAdkStream - AbortSignal", () => {
 
 describe("createAdkStream - content conversion", () => {
   it("converts reasoning content parts to thought parts in direct mode", async () => {
-    mockFetch.mockResolvedValueOnce(new Response(sseBody(""), { status: 200 }));
+    mockFetch.mockResolvedValueOnce(sseResponse(sseBody("")));
 
     const stream = createAdkStream({
       api: "http://localhost:8000",
@@ -614,7 +838,7 @@ describe("createAdkStream - content conversion", () => {
   });
 
   it("converts image_url content parts to fileData in direct mode", async () => {
-    mockFetch.mockResolvedValueOnce(new Response(sseBody(""), { status: 200 }));
+    mockFetch.mockResolvedValueOnce(sseResponse(sseBody("")));
 
     const stream = createAdkStream({
       api: "http://localhost:8000",
@@ -640,7 +864,7 @@ describe("createAdkStream - content conversion", () => {
   });
 
   it("converts file content parts to inlineData in direct mode", async () => {
-    mockFetch.mockResolvedValueOnce(new Response(sseBody(""), { status: 200 }));
+    mockFetch.mockResolvedValueOnce(sseResponse(sseBody("")));
 
     const stream = createAdkStream({
       api: "http://localhost:8000",
@@ -673,7 +897,7 @@ describe("createAdkStream - content conversion", () => {
   });
 
   it("converts file_url content parts to fileData with mimeType in direct mode", async () => {
-    mockFetch.mockResolvedValueOnce(new Response(sseBody(""), { status: 200 }));
+    mockFetch.mockResolvedValueOnce(sseResponse(sseBody("")));
 
     const stream = createAdkStream({
       api: "http://localhost:8000",
@@ -708,7 +932,7 @@ describe("createAdkStream - content conversion", () => {
   });
 
   it("converts code content parts to executableCode", async () => {
-    mockFetch.mockResolvedValueOnce(new Response(sseBody(""), { status: 200 }));
+    mockFetch.mockResolvedValueOnce(sseResponse(sseBody("")));
 
     const stream = createAdkStream({
       api: "http://localhost:8000",
@@ -734,7 +958,7 @@ describe("createAdkStream - content conversion", () => {
   });
 
   it("converts code_result content parts to codeExecutionResult", async () => {
-    mockFetch.mockResolvedValueOnce(new Response(sseBody(""), { status: 200 }));
+    mockFetch.mockResolvedValueOnce(sseResponse(sseBody("")));
 
     const stream = createAdkStream({
       api: "http://localhost:8000",

package/src/AdkClient.ts

@@ -1,4 +1,6 @@
+import { SSEEventDecoder } from "assistant-stream/utils";
 import { contentToParts } from "./contentToParts";
+import { trimTrailingSlashes } from "./trimTrailingSlashes";
 import type {
   AdkEvent,
   AdkEventPart,
@@ -58,7 +60,18 @@ export type CreateAdkStreamOptions = {
 export function createAdkStream(
   options: CreateAdkStreamOptions,
 ): AdkStreamCallback {
+  if (options.appName === "") {
+    throw new Error(
+      'createAdkStream direct mode requires a non-empty "appName".',
+    );
+  }
+
   const isDirect = options.appName != null;
+  if (isDirect && (options.userId == null || options.userId === "")) {
+    throw new Error(
+      'createAdkStream direct mode requires "userId" when "appName" is provided.',
+    );
+  }
 
   return async function* (messages, config) {
     const headers = await resolveHeaders(options.headers);
@@ -68,7 +81,7 @@ export function createAdkStream(
 
     if (isDirect) {
       // Direct mode: POST to ADK server's /run_sse
-      url = `${options.api}/run_sse`;
+      url = `${trimTrailingSlashes(options.api)}/run_sse`;
       const { externalId } = await config.initialize();
       body = {
         appName: options.appName,
@@ -97,12 +110,27 @@ export function createAdkStream(
       );
     }
 
+    validateEventStreamContentType(response);
     yield* parseSSEResponse(response);
   };
 }
 
 // ── Internal helpers ──
 
+function validateEventStreamContentType(response: Response): void {
+  const contentType = response.headers.get("Content-Type");
+  const mediaType = contentType?.split(";", 1)[0]?.trim().toLowerCase();
+  if (mediaType !== "text/event-stream") {
+    const received = contentType
+      ? `"${contentType}"`
+      : "no Content-Type header";
+    void response.body?.cancel().catch(() => undefined);
+    throw new Error(
+      `Expected ADK stream response Content-Type "text/event-stream", received ${received}`,
+    );
+  }
+}
+
 async function resolveHeaders(
   headers:
     | Record<string, string>
@@ -213,34 +241,27 @@ function messagesToProxyBody(
 async function* parseSSEResponse(response: Response): AsyncGenerator<AdkEvent> {
   const reader = response.body!.getReader();
   const decoder = new TextDecoder();
-  let buffer = "";
+  const sseDecoder = new SSEEventDecoder({ trailing: "dispatch" });
 
   try {
     while (true) {
       const { done, value } = await reader.read();
-      if (done) break;
-
-      buffer += decoder.decode(value, { stream: true });
-      const parts = buffer.split("\n\n");
-      buffer = parts.pop() ?? "";
-
-      for (const part of parts) {
-        for (const line of part.split("\n")) {
-          if (line.startsWith("data: ")) {
-            yield JSON.parse(line.slice(6)) as AdkEvent;
-          }
+      if (done) {
+        for (const event of sseDecoder.push(decoder.decode())) {
+          yield JSON.parse(event.data) as AdkEvent;
         }
+        break;
       }
-    }
 
-    // Handle remaining buffer
-    if (buffer.trim()) {
-      for (const line of buffer.split("\n")) {
-        if (line.startsWith("data: ")) {
-          yield JSON.parse(line.slice(6)) as AdkEvent;
-        }
+      for (const event of sseDecoder.push(
+        decoder.decode(value, { stream: true }),
+      )) {
+        yield JSON.parse(event.data) as AdkEvent;
       }
     }
+
+    const trailing = sseDecoder.flush();
+    if (trailing !== null) yield JSON.parse(trailing.data) as AdkEvent;
   } finally {
     reader.releaseLock();
   }