@assistant-ui/react-devtools 1.2.16 → 1.2.18

package/src/utils/serialization.test.ts

@@ -59,6 +59,85 @@ describe("sanitizeForMessage", () => {
   it("sanitizes invalid dates without throwing", () => {
     expect(sanitizeForMessage(new Date(Number.NaN))).toBe("Invalid Date");
   });
+
+  it("preserves readable properties when an enumerable getter throws", () => {
+    const value = { readable: "value" };
+    Object.defineProperty(value, "broken", {
+      enumerable: true,
+      get: () => {
+        throw new Error("getter failed");
+      },
+    });
+
+    expect(sanitizeForMessage(value)).toEqual({
+      readable: "value",
+      broken: "[Unserializable]",
+    });
+  });
+
+  it("handles proxies that reject key enumeration", () => {
+    const value = new Proxy(
+      {},
+      {
+        ownKeys: () => {
+          throw new Error("enumeration failed");
+        },
+      },
+    );
+
+    expect(sanitizeForMessage(value)).toBe("[Unserializable]");
+  });
+
+  it("preserves readable array entries when an indexed getter throws", () => {
+    const value = ["first", "second", "third"];
+    Object.defineProperty(value, 1, {
+      get: () => {
+        throw new Error("getter failed");
+      },
+    });
+
+    expect(sanitizeForMessage(value)).toEqual([
+      "first",
+      "[Unserializable]",
+      "third",
+    ]);
+  });
+
+  it("snapshots proxy array length before reading entries", () => {
+    let lengthReads = 0;
+    const value = new Proxy(["first", "second"], {
+      get: (target, property, receiver) => {
+        if (property === "length") return lengthReads++ === 0 ? 2 : 0;
+        return Reflect.get(target, property, receiver);
+      },
+    });
+
+    expect(sanitizeForMessage(value)).toEqual(["first", "second"]);
+  });
+
+  it("preserves map entries when a key cannot be converted to a string", () => {
+    const brokenKey = {
+      toString: () => {
+        throw new Error("key conversion failed");
+      },
+    };
+    const secondBrokenKey = {
+      toString: () => {
+        throw new Error("key conversion failed");
+      },
+    };
+    const value = new Map<unknown, unknown>([
+      [brokenKey, "broken key value"],
+      [secondBrokenKey, "second broken key value"],
+      ["readable", "readable value"],
+    ]);
+
+    expect(sanitizeForMessage(value)).toEqual({
+      "[Unserializable]": "broken key value",
+      "[Unserializable] (2)": "second broken key value",
+      readable: "readable value",
+    });
+  });
 });
 
 describe("redactSensitive", () => {
@@ -181,4 +260,31 @@ describe("serializeModelContext", () => {
   it("returns undefined when there is no context", () => {
     expect(serializeModelContext(undefined)).toBeUndefined();
   });
+
+  it("preserves readable fields when a model-context getter throws", () => {
+    const context = {
+      tools: {
+        search: { type: "frontend", description: "Search documents" },
+      },
+      config: { model: "test-model" },
+    };
+    Object.defineProperty(context, "system", {
+      enumerable: true,
+      get: () => {
+        throw new Error("system unavailable");
+      },
+    });
+
+    expect(serializeModelContext(context as never)).toEqual({
+      system: "[Unserializable]",
+      tools: [
+        {
+          name: "search",
+          type: "frontend",
+          description: "Search documents",
+        },
+      ],
+      config: { model: "test-model" },
+    });
+  });
 });

package/src/utils/serialization.ts

@@ -1,6 +1,7 @@
 import type { ModelContext } from "@assistant-ui/react";
 import type { SerializedModelContext } from "../types";
 import { normalizeToolList, type NormalizedTool } from "./toolNormalization";
+import { readProperty, UNSERIALIZABLE } from "./unserializable";
 
 export const sanitizeForMessage = (
   value: unknown,
@@ -21,48 +22,79 @@ export const sanitizeForMessage = (
   if (typeof value === "function") {
     return "[Function]";
   }
-  if (value instanceof Date) {
-    return Number.isNaN(value.getTime()) ? String(value) : value.toISOString();
-  }
-  if (value instanceof Map) {
-    if (seen.has(value)) return "[Circular]";
-    seen.add(value);
-    const result: Record<string, unknown> = {};
-    for (const [key, entry] of value.entries()) {
-      result[String(key)] = sanitizeForMessage(entry, seen);
-    }
-    seen.delete(value);
-    return result;
-  }
-  if (value instanceof Set) {
+  if (typeof value === "object") {
     if (seen.has(value)) return "[Circular]";
     seen.add(value);
-    const result = Array.from(value).map((entry) =>
-      sanitizeForMessage(entry, seen),
-    );
-    seen.delete(value);
-    return result;
-  }
-  if (Array.isArray(value)) {
-    if (seen.has(value as unknown as object)) return "[Circular]";
-    seen.add(value as unknown as object);
-    const result = value
-      .map((entry) => sanitizeForMessage(entry, seen))
-      .filter((item) => item !== undefined);
-    seen.delete(value as unknown as object);
-    return result;
-  }
-  if (typeof value === "object") {
-    if (seen.has(value as object)) return "[Circular]";
-    seen.add(value as object);
-    const result: Record<string, unknown> = {};
-    for (const [key, entry] of Object.entries(
-      value as Record<string, unknown>,
-    )) {
-      result[key] = sanitizeForMessage(entry, seen);
+    try {
+      if (value instanceof Date) {
+        return Number.isNaN(value.getTime())
+          ? String(value)
+          : value.toISOString();
+      }
+      if (value instanceof Map) {
+        const result: Record<string, unknown> = {};
+        const nextSuffixByKey = new Map<string, number>();
+        for (const [key, entry] of value.entries()) {
+          let serializedKey: string;
+          try {
+            serializedKey = String(key);
+          } catch {
+            serializedKey = UNSERIALIZABLE;
+          }
+
+          if (Object.hasOwn(result, serializedKey)) {
+            const baseKey = serializedKey;
+            let suffix = nextSuffixByKey.get(baseKey) ?? 2;
+            do {
+              serializedKey = `${baseKey} (${suffix})`;
+              suffix += 1;
+            } while (Object.hasOwn(result, serializedKey));
+            nextSuffixByKey.set(baseKey, suffix);
+          } else {
+            nextSuffixByKey.set(serializedKey, 2);
+          }
+
+          result[serializedKey] = sanitizeForMessage(entry, seen);
+        }
+        return result;
+      }
+      if (value instanceof Set) {
+        return Array.from(value).map((entry) =>
+          sanitizeForMessage(entry, seen),
+        );
+      }
+      if (Array.isArray(value)) {
+        const result: unknown[] = [];
+        const length = value.length;
+        for (let index = 0; index < length; index++) {
+          try {
+            if (!(index in value)) continue;
+            const item = sanitizeForMessage(value[index], seen);
+            if (item !== undefined) result.push(item);
+          } catch {
+            result.push(UNSERIALIZABLE);
+          }
+        }
+        return result;
+      }
+
+      const result: Record<string, unknown> = {};
+      for (const key of Object.keys(value)) {
+        try {
+          result[key] = sanitizeForMessage(
+            (value as Record<string, unknown>)[key],
+            seen,
+          );
+        } catch {
+          result[key] = UNSERIALIZABLE;
+        }
+      }
+      return result;
+    } catch {
+      return UNSERIALIZABLE;
+    } finally {
+      seen.delete(value);
     }
-    seen.delete(value as object);
-    return result;
   }
   return value;
 };
@@ -140,12 +172,12 @@ export const serializeModelContext = (
   const modelContext = context as Record<string, unknown>;
   const result: SerializedModelContext = {};
 
-  const systemValue = modelContext.system;
+  const systemValue = readProperty(modelContext, "system");
   if (typeof systemValue === "string" && systemValue.length > 0) {
     result.system = systemValue;
   }
 
-  const tools = normalizeToolList(modelContext.tools);
+  const tools = normalizeToolList(readProperty(modelContext, "tools"));
   if (tools.length > 0) {
     result.tools = tools.map((tool): NormalizedTool => {
       return {
@@ -167,8 +199,9 @@ export const serializeModelContext = (
     });
   }
 
-  if (modelContext.callSettings !== undefined) {
-    const callSettings = sanitizeAndRedact(modelContext.callSettings);
+  const callSettingsValue = readProperty(modelContext, "callSettings");
+  if (callSettingsValue !== undefined) {
+    const callSettings = sanitizeAndRedact(callSettingsValue);
     if (
       callSettings &&
       typeof callSettings === "object" &&
@@ -178,8 +211,9 @@ export const serializeModelContext = (
     }
   }
 
-  if (modelContext.config !== undefined) {
-    const config = sanitizeAndRedact(modelContext.config);
+  const configValue = readProperty(modelContext, "config");
+  if (configValue !== undefined) {
+    const config = sanitizeAndRedact(configValue);
     if (config && typeof config === "object" && !Array.isArray(config)) {
       result.config = config as Record<string, unknown>;
     }

package/src/utils/toolNormalization.test.ts

@@ -1,3 +1,4 @@
+import { z } from "zod";
 import { describe, expect, it } from "vitest";
 import { normalizeToolList } from "./toolNormalization";
 
@@ -64,8 +65,73 @@ describe("normalizeToolList", () => {
     expect(tools[1]?.disabled).toBe(true);
   });
 
+  it("preserves array entries around an unreadable slot", () => {
+    const tools = [
+      { name: "first", type: "frontend" },
+      { name: "hidden-one", type: "frontend" },
+      { name: "hidden-two", type: "frontend" },
+      { name: "last", type: "backend" },
+    ];
+    Object.defineProperty(tools, 1, {
+      get: () => {
+        throw new Error("tool unavailable");
+      },
+    });
+    Object.defineProperty(tools, 2, {
+      get: () => {
+        throw new Error("tool unavailable");
+      },
+    });
+
+    expect(normalizeToolList(tools)).toEqual([
+      { name: "first", type: "frontend" },
+      { name: "[Unserializable]" },
+      { name: "[Unserializable]" },
+      { name: "last", type: "backend" },
+    ]);
+  });
+
+  it("keeps Zod schemas that cannot be converted to JSON Schema", () => {
+    const parameters = z.object({ when: z.date() });
+
+    expect(normalizeToolList({ schedule: { parameters } })[0]?.parameters).toBe(
+      parameters,
+    );
+  });
+
   it("returns an empty list for non-objects", () => {
     expect(normalizeToolList(undefined)).toEqual([]);
     expect(normalizeToolList(null)).toEqual([]);
   });
+
+  it("preserves readable tool properties when another getter throws", () => {
+    const tool = { description: "Search documents" };
+    Object.defineProperty(tool, "type", {
+      enumerable: true,
+      get: () => {
+        throw new Error("type unavailable");
+      },
+    });
+
+    expect(normalizeToolList({ search: tool })).toEqual([
+      {
+        name: "search",
+        type: "[Unserializable]",
+        description: "Search documents",
+      },
+    ]);
+  });
+
+  it("represents a tool collection that rejects enumeration", () => {
+    const tools = new Proxy(
+      {},
+      {
+        ownKeys: () => {
+          throw new Error("enumeration unavailable");
+        },
+      },
+    );
+
+    expect(normalizeToolList(tools)).toEqual([{ name: "[Unserializable]" }]);
+  });
 });

package/src/utils/toolNormalization.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { readProperty, UNSERIALIZABLE } from "./unserializable";
 
 export type NormalizedTool = {
   name: string;
@@ -19,12 +20,12 @@ const isRecord = (value: unknown): value is Record<string, unknown> =>
   value !== null && typeof value === "object";
 
 const toJsonSchema = (value: unknown): unknown => {
-  if (value instanceof z.ZodType) {
-    try {
+  try {
+    if (value instanceof z.ZodType) {
       return z.toJSONSchema(value);
-    } catch {
-      return value;
     }
+  } catch {
+    return value;
   }
 
   return value;
@@ -36,64 +37,90 @@ const mapToNormalizedTool = (
 ): NormalizedTool => {
   const tool: NormalizedTool = { name };
 
-  if (typeof raw.type === "string") {
-    tool.type = raw.type as string;
+  const type = readProperty(raw, "type");
+  if (typeof type === "string") {
+    tool.type = type;
   }
 
-  if (typeof raw.description === "string") {
-    tool.description = raw.description as string;
+  const description = readProperty(raw, "description");
+  if (typeof description === "string") {
+    tool.description = description;
   }
 
-  if (typeof raw.disabled === "boolean") {
-    tool.disabled = raw.disabled as boolean;
+  const disabled = readProperty(raw, "disabled");
+  if (typeof disabled === "boolean") {
+    tool.disabled = disabled;
   }
 
-  if (typeof raw.display === "string") {
-    tool.display = raw.display as string;
+  const display = readProperty(raw, "display");
+  if (typeof display === "string") {
+    tool.display = display;
   }
 
-  if (typeof raw.providerId === "string") {
-    tool.providerId = raw.providerId as string;
+  const providerId = readProperty(raw, "providerId");
+  if (typeof providerId === "string") {
+    tool.providerId = providerId;
   }
 
-  if (typeof raw.supportsDeferredResults === "boolean") {
-    tool.supportsDeferredResults = raw.supportsDeferredResults as boolean;
+  const supportsDeferredResults = readProperty(raw, "supportsDeferredResults");
+  if (typeof supportsDeferredResults === "boolean") {
+    tool.supportsDeferredResults = supportsDeferredResults;
   }
 
-  if (raw.unstable_backendDefault !== undefined) {
-    tool.backendDefault = raw.unstable_backendDefault;
+  const backendDefault = readProperty(raw, "unstable_backendDefault");
+  if (backendDefault !== undefined) {
+    tool.backendDefault = backendDefault;
   }
 
-  if (raw.providerOptions !== undefined) {
-    tool.providerOptions = raw.providerOptions;
+  const providerOptions = readProperty(raw, "providerOptions");
+  if (providerOptions !== undefined) {
+    tool.providerOptions = providerOptions;
   }
 
-  if (raw.args !== undefined) {
-    tool.providerArgs = raw.args;
+  const providerArgs = readProperty(raw, "args");
+  if (providerArgs !== undefined) {
+    tool.providerArgs = providerArgs;
   }
 
-  if (raw.server !== undefined) {
-    tool.server = raw.server;
+  const server = readProperty(raw, "server");
+  if (server !== undefined) {
+    tool.server = server;
   }
 
-  if (Object.hasOwn(raw, "parameters")) {
-    tool.parameters = toJsonSchema(raw.parameters);
+  try {
+    if (Object.hasOwn(raw, "parameters")) {
+      tool.parameters = toJsonSchema(readProperty(raw, "parameters"));
+    }
+  } catch {
+    tool.parameters = UNSERIALIZABLE;
   }
 
   return tool;
 };
 
 export const normalizeToolList = (value: unknown): NormalizedTool[] => {
+  if (value === UNSERIALIZABLE) {
+    return [{ name: UNSERIALIZABLE }];
+  }
   if (!value || typeof value !== "object") {
     return [];
   }
 
   if (Array.isArray(value)) {
     const tools: NormalizedTool[] = [];
+    const length = readProperty(value, "length");
+    if (typeof length !== "number") return [{ name: UNSERIALIZABLE }];
 
-    for (const entry of value) {
-      if (!isRecord(entry) || typeof entry.name !== "string") continue;
-      tools.push(mapToNormalizedTool(entry.name as string, entry));
+    for (let index = 0; index < length; index++) {
+      const entry = readProperty(value, index);
+      if (entry === UNSERIALIZABLE) {
+        tools.push({ name: UNSERIALIZABLE });
+        continue;
+      }
+      if (!isRecord(entry)) continue;
+      const name = readProperty(entry, "name");
+      if (typeof name !== "string") continue;
+      tools.push(mapToNormalizedTool(name, entry));
     }
 
     return tools;
@@ -101,8 +128,15 @@ export const normalizeToolList = (value: unknown): NormalizedTool[] => {
 
   if (isRecord(value)) {
     const tools: NormalizedTool[] = [];
+    let names: string[];
+    try {
+      names = Object.keys(value);
+    } catch {
+      return [{ name: UNSERIALIZABLE }];
+    }
 
-    for (const [name, entry] of Object.entries(value)) {
+    for (const name of names) {
+      const entry = readProperty(value, name);
       if (!isRecord(entry)) {
         tools.push({ name });
         continue;

package/src/utils/unserializable.ts

@@ -0,0 +1,9 @@
+export const UNSERIALIZABLE = "[Unserializable]";
+
+export const readProperty = (value: object, key: PropertyKey): unknown => {
+  try {
+    return Reflect.get(value, key);
+  } catch {
+    return UNSERIALIZABLE;
+  }
+};

package/src/views/context/contextNodes.test.ts

@@ -28,4 +28,25 @@ describe("buildContextNav", () => {
       "ctx:toolUIs",
     ]);
   });
+
+  it("assigns unique navigation IDs to tools with the same display name", () => {
+    const groups = buildContextNav({
+      id: 1,
+      state: {},
+      logs: [],
+      modelContext: {
+        tools: [
+          { name: "[Unserializable]" },
+          { name: "[Unserializable]:2" },
+          { name: "[Unserializable]" },
+        ],
+      },
+    });
+
+    expect(flattenNav(groups).map((node) => node.id)).toEqual([
+      "ctx:tool:[Unserializable]",
+      "ctx:tool:[Unserializable]:2",
+      "ctx:tool:[Unserializable]:3",
+    ]);
+  });
 });

package/src/views/context/contextNodes.ts

@@ -28,9 +28,21 @@ export const buildContextNav = (data: ApiInfo): ContextNavGroup[] => {
     });
   }
 
+  const nextToolOccurrence = new Map<string, number>();
+  const toolNodeIds = new Set<string>();
   for (const tool of model?.tools ?? []) {
+    const baseId = `ctx:tool:${tool.name}` as const;
+    let occurrence = nextToolOccurrence.get(tool.name) ?? 1;
+    let id: `ctx:tool:${string}` =
+      occurrence === 1 ? baseId : `${baseId}:${occurrence}`;
+    while (toolNodeIds.has(id)) {
+      occurrence += 1;
+      id = `${baseId}:${occurrence}`;
+    }
+    nextToolOccurrence.set(tool.name, occurrence + 1);
+    toolNodeIds.add(id);
     modelNodes.push({
-      id: `ctx:tool:${tool.name}`,
+      id,
       kind: "tool",
       tool,
     });