@assistant-ui/react-google-adk 0.0.17 → 0.0.19

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() ──
@@ -188,20 +224,10 @@ describe("createAdkSessionAdapter - delete", () => {
 // ── adapter.rename / archive / unarchive ──
 
 describe("createAdkSessionAdapter - no-op methods", () => {
-  it("rename resolves without error", async () => {
+  it("rename/archive/unarchive resolve without hitting the network", async () => {
     const { adapter } = createAdkSessionAdapter(baseOptions);
     await expect(adapter.rename("s1", "New Title")).resolves.toBeUndefined();
-    expect(mockFetch).not.toHaveBeenCalled();
-  });
-
-  it("archive resolves without error", async () => {
-    const { adapter } = createAdkSessionAdapter(baseOptions);
     await expect(adapter.archive("s1")).resolves.toBeUndefined();
-    expect(mockFetch).not.toHaveBeenCalled();
-  });
-
-  it("unarchive resolves without error", async () => {
-    const { adapter } = createAdkSessionAdapter(baseOptions);
     await expect(adapter.unarchive("s1")).resolves.toBeUndefined();
     expect(mockFetch).not.toHaveBeenCalled();
   });
@@ -250,6 +276,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() ──
@@ -305,6 +343,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 }),
@@ -343,6 +405,133 @@ describe("createAdkSessionAdapter - load", () => {
   });
 });
 
+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", () => {

package/src/AdkSessionAdapter.ts

@@ -57,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.
@@ -96,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,
@@ -125,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 };
     },
 
@@ -171,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,
@@ -191,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 };
@@ -216,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?) {
@@ -226,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) {
@@ -236,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/useAdkMessages.ts

@@ -106,7 +106,7 @@ export const useAdkMessages = ({
           ...config,
           abortSignal: abortController.signal,
           initialize: async () => {
-            return await aui.threadListItem().initialize();
+            return await aui.threadListItem.initialize();
           },
         });
 

package/src/useAdkRuntime.ts

@@ -356,7 +356,7 @@ const useAdkRuntimeImpl = (options: UseAdkRuntimeOptions) => {
             setMessages(nextMessages);
             return;
           }
-          const externalId = aui.threadListItem().getState().externalId;
+          const externalId = aui.threadListItem.getState().externalId;
           const checkpointId = externalId
             ? await getCheckpointId(externalId, truncated)
             : null;
@@ -397,7 +397,7 @@ const useAdkRuntimeImpl = (options: UseAdkRuntimeOptions) => {
               parentId,
             );
             replaceMessages(truncated);
-            const externalId = aui.threadListItem().getState().externalId;
+            const externalId = aui.threadListItem.getState().externalId;
             const checkpointId = externalId
               ? await getCheckpointId(externalId, truncated)
               : null;
@@ -447,7 +447,7 @@ const useAdkRuntimeImpl = (options: UseAdkRuntimeOptions) => {
       const loadFn = loadRef.current;
       if (!loadFn) return;
 
-      const externalId = aui.threadListItem().getState().externalId;
+      const externalId = aui.threadListItem.getState().externalId;
       if (externalId == null) return;
 
       loadFn(externalId).then(
@@ -477,7 +477,7 @@ export const useAdkRuntime = ({
     cloud,
     create: async () => {
       if (create) return create();
-      if (aui.threadListItem.source) return aui.threadListItem().initialize();
+      if (aui.threadListItem.source) return aui.threadListItem.initialize();
       return { externalId: undefined };
     },
     delete: deleteFn,