@ulearning/ai-generative-frame 0.0.0-stage → 1.0.0-next.0

package/src/assistant-ui/snapshotSaver.ts

@@ -0,0 +1,116 @@
+const SAVE_DELAY_MS = 500;
+
+/** The snapshot as JSON only when it is plain JSON throughout, since `JSON.stringify` quietly turns `NaN`, `undefined`, and class instances into other values, which would compare equal to a different snapshot and restore something else. */
+const serialize = (snapshot: unknown): string | undefined => {
+  try {
+    return JSON.stringify(
+      snapshot,
+      function (this: Record<string, unknown>, key: string, value: unknown) {
+        const raw = this[key];
+        if (
+          raw === null ||
+          typeof raw === "string" ||
+          typeof raw === "boolean" ||
+          (typeof raw === "number" && Number.isFinite(raw))
+        )
+          return value;
+        if (
+          typeof raw === "object" &&
+          typeof (raw as { toJSON?: unknown }).toJSON !== "function"
+        ) {
+          const prototype = Object.getPrototypeOf(raw);
+          if (
+            Array.isArray(raw)
+              ? prototype === Array.prototype
+              : prototype === Object.prototype || prototype === null
+          )
+            return value;
+        }
+        throw new TypeError("Not plain JSON");
+      },
+    );
+  } catch {
+    return undefined;
+  }
+};
+
+export type SnapshotSaver<T> = {
+  /** Saves `read()` once changes settle, if it differs from the newest entry recorded. */
+  schedule(read: () => T): void;
+  /** Saves a change that is still waiting now rather than after the delay. */
+  flush(): void;
+};
+
+/**
+ * Saves snapshots of a tool call's UI state through `record`, 500 ms after the last change and when flushed, whenever the snapshot differs from the newest entry recorded; `initial` is that entry when saving starts. One record is in flight at a time, so entries land in the order they are sent, and a change made meanwhile is saved once it settles. When the current snapshot cannot be recorded, `record(null)` marks it, so the call starts fresh on its next mount rather than from an older snapshot; a marker that fails is sent again only after a newer snapshot is tried.
+ */
+export function createSnapshotSaver<T>(
+  initial: T,
+  record: (snapshot: T | null) => unknown,
+): SnapshotSaver<T> {
+  let recorded = JSON.stringify(initial);
+  let failed: string | undefined;
+  let markerFailed = false;
+  let busy = false;
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  let read: (() => T) | undefined;
+
+  const send = (snapshot: T | null, json: string, marker: boolean) => {
+    busy = true;
+    let result: Promise<unknown>;
+    try {
+      result = Promise.resolve(record(snapshot));
+    } catch (error) {
+      result = Promise.reject(error);
+    }
+    void result
+      .then(
+        () => {
+          recorded = json;
+          if (!marker) failed = undefined;
+        },
+        () => {
+          if (marker) markerFailed = true;
+          else failed = json;
+        },
+      )
+      .finally(() => {
+        busy = false;
+        if (timer === undefined) save();
+      });
+  };
+
+  const save = () => {
+    if (busy || !read) return;
+    let snapshot: T | undefined;
+    let json: string | undefined;
+    try {
+      snapshot = read();
+      json = serialize(snapshot);
+    } catch {}
+    if (json === recorded) return;
+    if (json !== undefined && json !== failed) {
+      markerFailed = false;
+      send(snapshot as T, json, false);
+      return;
+    }
+    if (recorded !== "null" && !markerFailed) send(null, "null", true);
+  };
+
+  return {
+    schedule(next) {
+      read = next;
+      clearTimeout(timer);
+      timer = setTimeout(() => {
+        timer = undefined;
+        save();
+      }, SAVE_DELAY_MS);
+    },
+    flush() {
+      if (timer === undefined) return;
+      clearTimeout(timer);
+      timer = undefined;
+      save();
+    },
+  };
+}

package/src/assistant-ui/tool-calls.ts

@@ -0,0 +1,115 @@
+type ToolCallLike = {
+  type: string;
+  toolName?: string;
+  toolCallId?: string;
+  args?: unknown;
+  argsText?: unknown;
+  result?: unknown;
+  isPreliminary?: unknown;
+};
+
+/** The part of a thread message the history readers need. */
+export type MessageLike = {
+  readonly content: string | readonly unknown[];
+  readonly status?: { readonly type: string };
+};
+
+/** A tool call as the history readers see it. */
+export type ToolCall = {
+  id: string;
+  name: string;
+  args: Record<string, unknown>;
+  argsText: string | undefined;
+  result: unknown;
+  /** Whether the arguments can no longer change, read as core reads a tool call's status: it has a final result, or its message is no longer running. */
+  settled: boolean;
+};
+
+export function* toolCalls(
+  messages: readonly MessageLike[],
+): Generator<ToolCall> {
+  for (const message of messages) {
+    if (typeof message.content === "string") continue;
+    const running = message.status?.type === "running";
+    for (const part of message.content) {
+      const call = part as ToolCallLike;
+      if (call?.type === "tool-call" && call.toolCallId && call.toolName) {
+        yield {
+          id: call.toolCallId,
+          name: call.toolName,
+          args: (call.args ?? {}) as Record<string, unknown>,
+          argsText:
+            typeof call.argsText === "string" ? call.argsText : undefined,
+          result: call.result,
+          settled:
+            (call.result !== undefined && call.isPreliminary !== true) ||
+            !running,
+        };
+      }
+    }
+  }
+}
+
+const STRING_TOKEN = /"(?:[^"\\]|\\.)*"/y;
+
+const decode = (token: string): unknown => {
+  try {
+    return JSON.parse(token);
+  } catch {
+    return undefined;
+  }
+};
+
+/** The top-level `title` of streamed arguments once its string has closed, whatever escaping it was written with. */
+const streamedTitle = (argsText: string): unknown => {
+  let depth = 0;
+  let key: unknown;
+  let inValue = false;
+  for (let i = 0; i < argsText.length; i++) {
+    const char = argsText[i];
+    if (char === '"') {
+      STRING_TOKEN.lastIndex = i;
+      const token = STRING_TOKEN.exec(argsText)?.[0];
+      if (token === undefined) return undefined;
+      if (depth === 1) {
+        if (!inValue) key = decode(token);
+        else if (key === "title") return decode(token);
+        else inValue = false;
+      }
+      i += token.length - 1;
+    } else if (char === "{" || char === "[") depth++;
+    else if (char === "}" || char === "]") depth--;
+    else if (depth === 1 && char === ":") inValue = true;
+    else if (depth === 1 && char === ",") inValue = false;
+  }
+  return undefined;
+};
+
+/** Whether streamed arguments hold this whole title, not a prefix of a longer one that is still arriving. */
+const holdsTitle = (argsText: string | undefined, title: string) =>
+  argsText === undefined || streamedTitle(argsText) === title;
+
+/** Whether a later call in the same message, with this call's whole title, takes over what this call shows, as `takesOver` decides. A call in a later message never does, since earlier messages are the conversation's history. */
+export function hasLaterToolCallInMessage(
+  messages: readonly MessageLike[],
+  toolCallId: string,
+  title: string,
+  takesOver: (call: ToolCall) => boolean,
+): boolean {
+  if (!title) return false;
+  for (const message of messages) {
+    let seen = false;
+    for (const call of toolCalls([message])) {
+      if (call.id === toolCallId) seen = true;
+      else if (
+        seen &&
+        call.args["title"] === title &&
+        holdsTitle(call.argsText, title) &&
+        takesOver(call)
+      )
+        return true;
+    }
+    if (seen) return false;
+  }
+  return false;
+}