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

package/src/AdkSessionAdapter.test.ts

@@ -62,6 +62,30 @@ describe("createAdkSessionAdapter - list", () => {
     expect(result.threads).toHaveLength(0);
   });
 
+  it("rejects a successful response that is not a session array", async () => {
+    mockFetch.mockResolvedValueOnce(
+      new Response(JSON.stringify({}), { status: 200 }),
+    );
+
+    const { adapter } = createAdkSessionAdapter(baseOptions);
+
+    await expect(adapter.list()).rejects.toThrow(
+      "Invalid ADK session list response: expected an array of sessions.",
+    );
+  });
+
+  it("rejects session list entries without a valid id", async () => {
+    mockFetch.mockResolvedValueOnce(
+      new Response(JSON.stringify([{ id: "s1" }, {}]), { status: 200 }),
+    );
+
+    const { adapter } = createAdkSessionAdapter(baseOptions);
+
+    await expect(adapter.list()).rejects.toThrow(
+      'Invalid ADK session list response: session at index 1 must have a non-empty string "id".',
+    );
+  });
+
   it("throws when response is not ok", async () => {
     mockFetch.mockResolvedValueOnce(
       new Response("Server error", { status: 500 }),
@@ -139,6 +163,18 @@ describe("createAdkSessionAdapter - initialize", () => {
       "Failed to create session: 403",
     );
   });
+
+  it("rejects a successful response without a session id", async () => {
+    mockFetch.mockResolvedValueOnce(
+      new Response(JSON.stringify({}), { status: 200 }),
+    );
+
+    const { adapter } = createAdkSessionAdapter(baseOptions);
+
+    await expect(adapter.initialize("thread-1")).rejects.toThrow(
+      'Invalid ADK session create response: expected an object with a non-empty string "id".',
+    );
+  });
 });
 
 // ── adapter.delete() ──
@@ -210,10 +246,14 @@ describe("createAdkSessionAdapter - no-op methods", () => {
 // ── adapter.generateTitle ──
 
 describe("createAdkSessionAdapter - generateTitle", () => {
-  it("returns an empty ReadableStream", async () => {
+  it("closes its title stream when title generation is unsupported", async () => {
     const { adapter } = createAdkSessionAdapter(baseOptions);
-    const result = await adapter.generateTitle("s1", []);
-    expect(result).toBeInstanceOf(ReadableStream);
+    const stream = await adapter.generateTitle("s1", []);
+
+    await expect(stream.getReader().read()).resolves.toEqual({
+      done: true,
+      value: undefined,
+    });
   });
 });
 
@@ -246,6 +286,18 @@ describe("createAdkSessionAdapter - fetch", () => {
       "Session not found: 404",
     );
   });
+
+  it("rejects a successful response without a session id", async () => {
+    mockFetch.mockResolvedValueOnce(
+      new Response(JSON.stringify({}), { status: 200 }),
+    );
+
+    const { adapter } = createAdkSessionAdapter(baseOptions);
+
+    await expect(adapter.fetch("s1")).rejects.toThrow(
+      'Invalid ADK session fetch response: expected an object with a non-empty string "id".',
+    );
+  });
 });
 
 // ── load() ──
@@ -301,6 +353,30 @@ describe("createAdkSessionAdapter - load", () => {
     expect(result.messages).toEqual([]);
   });
 
+  it("rejects a successful response without a session id", async () => {
+    mockFetch.mockResolvedValueOnce(
+      new Response(JSON.stringify({}), { status: 200 }),
+    );
+
+    const { load } = createAdkSessionAdapter(baseOptions);
+
+    await expect(load("s1")).rejects.toThrow(
+      'Invalid ADK session load response: expected an object with a non-empty string "id".',
+    );
+  });
+
+  it("rejects a session with a malformed events field", async () => {
+    mockFetch.mockResolvedValueOnce(
+      new Response(JSON.stringify({ id: "s1", events: {} }), { status: 200 }),
+    );
+
+    const { load } = createAdkSessionAdapter(baseOptions);
+
+    await expect(load("s1")).rejects.toThrow(
+      'Invalid ADK session load response: expected "events" to be an array when present.',
+    );
+  });
+
   it("throws when session fetch fails", async () => {
     mockFetch.mockResolvedValueOnce(
       new Response("Server error", { status: 500 }),
@@ -339,9 +415,153 @@ describe("createAdkSessionAdapter - load", () => {
   });
 });
 
-// ── URL encoding ──
+describe("createAdkSessionAdapter - artifacts", () => {
+  it("lists names from current and legacy artifact responses", async () => {
+    mockFetch.mockResolvedValueOnce(
+      new Response(JSON.stringify(["report.pdf", { filename: "chart.png" }]), {
+        status: 200,
+      }),
+    );
+
+    const { artifacts } = createAdkSessionAdapter(baseOptions);
+
+    await expect(artifacts.list("s1")).resolves.toEqual([
+      "report.pdf",
+      "chart.png",
+    ]);
+    expect(mockFetch.mock.calls[0]![0]).toBe(`${expectedBaseUrl}/s1/artifacts`);
+  });
+
+  it("rejects an artifact list that is not an array", async () => {
+    mockFetch.mockResolvedValueOnce(
+      new Response(JSON.stringify({}), { status: 200 }),
+    );
+
+    const { artifacts } = createAdkSessionAdapter(baseOptions);
+
+    await expect(artifacts.list("s1")).rejects.toThrow(
+      "Invalid ADK artifact list response: expected an array of artifact names.",
+    );
+  });
+
+  it("rejects malformed artifact list entries", async () => {
+    mockFetch.mockResolvedValueOnce(
+      new Response(JSON.stringify(["report.pdf", {}]), { status: 200 }),
+    );
+
+    const { artifacts } = createAdkSessionAdapter(baseOptions);
+
+    await expect(artifacts.list("s1")).rejects.toThrow(
+      'Invalid ADK artifact list response: artifact at index 1 must be a non-empty string or an object with a non-empty string "filename".',
+    );
+  });
+
+  it.each([
+    ["text", { text: "artifact contents" }],
+    [
+      "inline data",
+      { inlineData: { mimeType: "image/png", data: "aGVsbG8=" } },
+    ],
+  ])("loads valid %s artifacts", async (_label, artifact) => {
+    mockFetch.mockResolvedValueOnce(
+      new Response(JSON.stringify(artifact), { status: 200 }),
+    );
+
+    const { artifacts } = createAdkSessionAdapter(baseOptions);
+
+    await expect(artifacts.load("s1", "report.pdf")).resolves.toEqual(artifact);
+  });
+
+  it("rejects an artifact without supported content", async () => {
+    mockFetch.mockResolvedValueOnce(
+      new Response(JSON.stringify({}), { status: 200 }),
+    );
+
+    const { artifacts } = createAdkSessionAdapter(baseOptions);
+
+    await expect(artifacts.load("s1", "report.pdf")).rejects.toThrow(
+      'Invalid ADK artifact load response: expected an object containing "text" or "inlineData".',
+    );
+  });
+
+  it.each([
+    [
+      "text",
+      { text: 42 },
+      'Invalid ADK artifact load response: "text" must be a string when present.',
+    ],
+    [
+      "inline data",
+      { inlineData: { mimeType: "image/png" } },
+      'Invalid ADK artifact load response: "inlineData" must contain string "mimeType" and "data" fields.',
+    ],
+  ])("rejects malformed %s artifact content", async (_label, value, error) => {
+    mockFetch.mockResolvedValueOnce(
+      new Response(JSON.stringify(value), { status: 200 }),
+    );
+
+    const { artifacts } = createAdkSessionAdapter(baseOptions);
+
+    await expect(artifacts.load("s1", "report.pdf")).rejects.toThrow(error);
+  });
+
+  it("lists artifact versions", async () => {
+    mockFetch.mockResolvedValueOnce(
+      new Response(JSON.stringify([0, 1, 2]), { status: 200 }),
+    );
+
+    const { artifacts } = createAdkSessionAdapter(baseOptions);
+
+    await expect(artifacts.listVersions("s1", "report.pdf")).resolves.toEqual([
+      0, 1, 2,
+    ]);
+  });
+
+  it("rejects an artifact version list that is not an array", async () => {
+    mockFetch.mockResolvedValueOnce(
+      new Response(JSON.stringify({}), { status: 200 }),
+    );
+
+    const { artifacts } = createAdkSessionAdapter(baseOptions);
+
+    await expect(artifacts.listVersions("s1", "report.pdf")).rejects.toThrow(
+      "Invalid ADK artifact versions response: expected an array of version numbers.",
+    );
+  });
+
+  it("rejects malformed artifact version entries", async () => {
+    mockFetch.mockResolvedValueOnce(
+      new Response(JSON.stringify([0, "1"]), { status: 200 }),
+    );
+
+    const { artifacts } = createAdkSessionAdapter(baseOptions);
+
+    await expect(artifacts.listVersions("s1", "report.pdf")).rejects.toThrow(
+      "Invalid ADK artifact versions response: version at index 1 must be a non-negative integer.",
+    );
+  });
+});
+
+// ── URL construction ──
+
+describe("createAdkSessionAdapter - URL construction", () => {
+  it.each(["http://localhost:8000/", "http://localhost:8000//"])(
+    "normalizes trailing slashes in apiUrl: %s",
+    async (apiUrl) => {
+      mockFetch.mockResolvedValueOnce(
+        new Response(JSON.stringify([]), { status: 200 }),
+      );
+
+      const { adapter } = createAdkSessionAdapter({
+        ...baseOptions,
+        apiUrl,
+      });
+      await adapter.list();
+
+      expect(mockFetch.mock.calls[0]![0]).toBe(expectedBaseUrl);
+    },
+  );
 
-describe("createAdkSessionAdapter - URL encoding", () => {
   it("encodes special characters in appName and userId", async () => {
     mockFetch.mockResolvedValueOnce(
       new Response(JSON.stringify([]), { status: 200 }),

package/src/AdkSessionAdapter.ts

@@ -7,6 +7,7 @@ import type {
 } from "@assistant-ui/core";
 import { AdkEventAccumulator } from "./AdkEventAccumulator";
 import type { AdkEvent, AdkMessage } from "./types";
+import { trimTrailingSlashes } from "./trimTrailingSlashes";
 
 export type AdkSessionAdapterOptions = {
   /**
@@ -56,6 +57,130 @@ type AdkSessionAdapterResult = {
   };
 };
 
+type AdkSessionResponse = {
+  id: string;
+  events?: unknown;
+};
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === "object" && value !== null && !Array.isArray(value);
+
+const isAdkSessionResponse = (value: unknown): value is AdkSessionResponse => {
+  if (!isRecord(value)) return false;
+
+  const id = value.id;
+  return typeof id === "string" && id.length > 0;
+};
+
+const parseAdkSessionResponse = (
+  value: unknown,
+  operation: "create" | "fetch" | "load",
+): AdkSessionResponse => {
+  if (!isAdkSessionResponse(value)) {
+    throw new Error(
+      `Invalid ADK session ${operation} response: expected an object with a non-empty string "id".`,
+    );
+  }
+  return value;
+};
+
+const parseAdkSessionListResponse = (value: unknown): AdkSessionResponse[] => {
+  if (!Array.isArray(value)) {
+    throw new Error(
+      "Invalid ADK session list response: expected an array of sessions.",
+    );
+  }
+
+  return value.map((session, index) => {
+    if (!isAdkSessionResponse(session)) {
+      throw new Error(
+        `Invalid ADK session list response: session at index ${index} must have a non-empty string "id".`,
+      );
+    }
+    return session;
+  });
+};
+
+const parseAdkArtifactListResponse = (value: unknown): string[] => {
+  if (!Array.isArray(value)) {
+    throw new Error(
+      "Invalid ADK artifact list response: expected an array of artifact names.",
+    );
+  }
+
+  return value.map((artifact, index) => {
+    if (typeof artifact === "string" && artifact.length > 0) {
+      return artifact;
+    }
+
+    if (isRecord(artifact)) {
+      const filename = artifact.filename;
+      if (typeof filename === "string" && filename.length > 0) {
+        return filename;
+      }
+    }
+
+    throw new Error(
+      `Invalid ADK artifact list response: artifact at index ${index} must be a non-empty string or an object with a non-empty string "filename".`,
+    );
+  });
+};
+
+const parseAdkArtifactResponse = (value: unknown): AdkArtifactData => {
+  if (!isRecord(value)) {
+    throw new Error(
+      'Invalid ADK artifact load response: expected an object containing "text" or "inlineData".',
+    );
+  }
+
+  const { text, inlineData } = value;
+  if (text === undefined && inlineData === undefined) {
+    throw new Error(
+      'Invalid ADK artifact load response: expected an object containing "text" or "inlineData".',
+    );
+  }
+
+  if (text !== undefined && typeof text !== "string") {
+    throw new Error(
+      'Invalid ADK artifact load response: "text" must be a string when present.',
+    );
+  }
+
+  if (
+    inlineData !== undefined &&
+    (!isRecord(inlineData) ||
+      typeof inlineData.mimeType !== "string" ||
+      typeof inlineData.data !== "string")
+  ) {
+    throw new Error(
+      'Invalid ADK artifact load response: "inlineData" must contain string "mimeType" and "data" fields.',
+    );
+  }
+
+  return value as AdkArtifactData;
+};
+
+const parseAdkArtifactVersionsResponse = (value: unknown): number[] => {
+  if (!Array.isArray(value)) {
+    throw new Error(
+      "Invalid ADK artifact versions response: expected an array of version numbers.",
+    );
+  }
+
+  return value.map((version, index) => {
+    if (
+      typeof version !== "number" ||
+      !Number.isInteger(version) ||
+      version < 0
+    ) {
+      throw new Error(
+        `Invalid ADK artifact versions response: version at index ${index} must be a non-negative integer.`,
+      );
+    }
+    return version;
+  });
+};
+
 /**
  * Creates a `RemoteThreadListAdapter` backed by ADK's session REST API,
  * plus a `load` function that reconstructs messages from session events.
@@ -79,7 +204,8 @@ export function createAdkSessionAdapter(
   options: AdkSessionAdapterOptions,
 ): AdkSessionAdapterResult {
   const { apiUrl, appName, userId } = options;
-  const baseUrl = `${apiUrl}/apps/${encodeURIComponent(appName)}/users/${encodeURIComponent(userId)}/sessions`;
+  const normalizedApiUrl = trimTrailingSlashes(apiUrl);
+  const baseUrl = `${normalizedApiUrl}/apps/${encodeURIComponent(appName)}/users/${encodeURIComponent(userId)}/sessions`;
 
   const getHeaders = async (): Promise<Record<string, string>> => {
     if (!options.headers) return {};
@@ -94,12 +220,7 @@ export function createAdkSessionAdapter(
       if (!res.ok) {
         throw new Error(`Failed to list sessions: ${res.status}`);
       }
-      const data = (await res.json()) as Array<{
-        id: string;
-        app_name?: string;
-        user_id?: string;
-        last_update_time?: number;
-      }>;
+      const data = parseAdkSessionListResponse(await res.json());
 
       const threads: RemoteThreadMetadata[] = data.map((session) => ({
         status: "regular" as const,
@@ -123,7 +244,7 @@ export function createAdkSessionAdapter(
       if (!res.ok) {
         throw new Error(`Failed to create session: ${res.status}`);
       }
-      const session = (await res.json()) as { id: string };
+      const session = parseAdkSessionResponse(await res.json(), "create");
       return { remoteId: session.id, externalId: session.id };
     },
 
@@ -152,7 +273,13 @@ export function createAdkSessionAdapter(
 
     generateTitle(): Promise<AssistantStream> {
       // Title generation not supported without assistant-cloud
-      return Promise.resolve(new ReadableStream<AssistantStreamChunk>());
+      return Promise.resolve(
+        new ReadableStream<AssistantStreamChunk>({
+          start(controller) {
+            controller.close();
+          },
+        }),
+      );
     },
 
     async fetch(threadId: string): Promise<RemoteThreadMetadata> {
@@ -163,7 +290,7 @@ export function createAdkSessionAdapter(
       if (!res.ok) {
         throw new Error(`Session not found: ${res.status}`);
       }
-      const session = (await res.json()) as { id: string };
+      const session = parseAdkSessionResponse(await res.json(), "fetch");
       return {
         status: "regular",
         remoteId: session.id,
@@ -183,18 +310,23 @@ export function createAdkSessionAdapter(
     if (!res.ok) {
       throw new Error(`Failed to load session: ${res.status}`);
     }
-    const session = (await res.json()) as {
-      id: string;
-      events?: AdkEvent[];
-    };
+    const session = parseAdkSessionResponse(await res.json(), "load");
+
+    if (session.events !== undefined && !Array.isArray(session.events)) {
+      throw new Error(
+        'Invalid ADK session load response: expected "events" to be an array when present.',
+      );
+    }
+
+    const events = session.events as AdkEvent[] | undefined;
 
-    if (!session.events?.length) {
+    if (!events?.length) {
       return { messages: [] };
     }
 
     const accumulator = new AdkEventAccumulator();
     let messages: AdkMessage[] = [];
-    for (const event of session.events) {
+    for (const event of events) {
       messages = accumulator.processEvent(event);
     }
     return { messages };
@@ -208,8 +340,7 @@ export function createAdkSessionAdapter(
       const headers = await getHeaders();
       const res = await fetch(artifactBaseUrl(sessionId), { headers });
       if (!res.ok) throw new Error(`Failed to list artifacts: ${res.status}`);
-      const data = (await res.json()) as Array<{ filename: string }>;
-      return data.map((a) => a.filename);
+      return parseAdkArtifactListResponse(await res.json());
     },
 
     async load(sessionId, artifactName, version?) {
@@ -218,7 +349,7 @@ export function createAdkSessionAdapter(
       if (version != null) url += `/versions/${version}`;
       const res = await fetch(url, { headers });
       if (!res.ok) throw new Error(`Failed to load artifact: ${res.status}`);
-      return (await res.json()) as AdkArtifactData;
+      return parseAdkArtifactResponse(await res.json());
     },
 
     async listVersions(sessionId, artifactName) {
@@ -228,7 +359,7 @@ export function createAdkSessionAdapter(
       if (!res.ok) {
         throw new Error(`Failed to list artifact versions: ${res.status}`);
       }
-      return (await res.json()) as number[];
+      return parseAdkArtifactVersionsResponse(await res.json());
     },
 
     async delete(sessionId, artifactName) {

package/src/server/parseAdkRequest.test.ts

@@ -85,12 +85,14 @@ describe("parseAdkRequest", () => {
       method: "POST",
       body: "not json",
     });
-    await expect(parseAdkRequest(req)).rejects.toThrow();
+    await expect(parseAdkRequest(req)).rejects.toThrow(
+      'Invalid JSON in Google ADK proxy request body. Expected a JSON object like {"message":"Hello"} or {"type":"tool-result",...}.',
+    );
   });
 
   it("throws on non-object body", async () => {
     await expect(parseAdkRequest(makeRequest([1, 2, 3]))).rejects.toThrow(
-      "Request body must be a JSON object",
+      "Google ADK proxy request body must be a JSON object",
     );
   });
 });

package/src/server/parseAdkRequest.ts

@@ -46,11 +46,13 @@ export const parseAdkRequest = async (
   try {
     body = (await request.json()) as Record<string, unknown>;
   } catch {
-    throw new Error("Invalid JSON in request body");
+    throw new Error(
+      'Invalid JSON in Google ADK proxy request body. Expected a JSON object like {"message":"Hello"} or {"type":"tool-result",...}.',
+    );
   }
 
   if (!body || typeof body !== "object" || Array.isArray(body)) {
-    throw new Error("Request body must be a JSON object");
+    throw new Error("Google ADK proxy request body must be a JSON object");
   }
 
   const config: AdkSendMessageConfig = {};

package/src/trimTrailingSlashes.ts

@@ -0,0 +1,5 @@
+export const trimTrailingSlashes = (value: string) => {
+  let end = value.length;
+  while (end > 0 && value[end - 1] === "/") end -= 1;
+  return value.slice(0, end);
+};