@assistant-ui/react 0.11.0 → 0.11.2

package/src/runtimes/external-store/ThreadMessageLike.tsx

@@ -1,215 +0,0 @@
-import { parsePartialJsonObject } from "assistant-stream/utils";
-import { generateId } from "../../utils/idUtils";
-import {
-  MessageStatus,
-  TextMessagePart,
-  ImageMessagePart,
-  ThreadMessage,
-  ThreadAssistantMessagePart,
-  ThreadAssistantMessage,
-  ThreadUserMessagePart,
-  ThreadUserMessage,
-  ThreadSystemMessage,
-  CompleteAttachment,
-  FileMessagePart,
-  Unstable_AudioMessagePart,
-} from "../../types";
-import {
-  ReasoningMessagePart,
-  SourceMessagePart,
-  ThreadStep,
-} from "../../types/AssistantTypes";
-import { ReadonlyJSONObject, ReadonlyJSONValue } from "assistant-stream/utils";
-
-export type ThreadMessageLike = {
-  readonly role: "assistant" | "user" | "system";
-  readonly content:
-    | string
-    | readonly (
-        | TextMessagePart
-        | ReasoningMessagePart
-        | SourceMessagePart
-        | ImageMessagePart
-        | FileMessagePart
-        | Unstable_AudioMessagePart
-        | {
-            readonly type: "tool-call";
-            readonly toolCallId?: string;
-            readonly toolName: string;
-            readonly args?: ReadonlyJSONObject;
-            readonly argsText?: string;
-            readonly artifact?: any;
-            readonly result?: any | undefined;
-            readonly isError?: boolean | undefined;
-            readonly parentId?: string | undefined;
-          }
-      )[];
-  readonly id?: string | undefined;
-  readonly createdAt?: Date | undefined;
-  readonly status?: MessageStatus | undefined;
-  readonly attachments?: readonly CompleteAttachment[] | undefined;
-  readonly metadata?:
-    | {
-        readonly unstable_state?: ReadonlyJSONValue;
-        readonly unstable_annotations?:
-          | readonly ReadonlyJSONValue[]
-          | undefined;
-        readonly unstable_data?: readonly ReadonlyJSONValue[] | undefined;
-        readonly steps?: readonly ThreadStep[] | undefined;
-        readonly custom?: Record<string, unknown> | undefined;
-      }
-    | undefined;
-};
-
-export const fromThreadMessageLike = (
-  like: ThreadMessageLike,
-  fallbackId: string,
-  fallbackStatus: MessageStatus,
-): ThreadMessage => {
-  const { role, id, createdAt, attachments, status, metadata } = like;
-  const common = {
-    id: id ?? fallbackId,
-    createdAt: createdAt ?? new Date(),
-  };
-
-  const content =
-    typeof like.content === "string"
-      ? [{ type: "text" as const, text: like.content }]
-      : like.content;
-
-  const sanitizeImageContent = ({
-    image,
-    ...rest
-  }: ImageMessagePart): ImageMessagePart | null => {
-    const match = image.match(
-      /^data:image\/(png|jpeg|jpg|gif|webp);base64,(.*)$/,
-    );
-    if (match) {
-      return { ...rest, image };
-    }
-    console.warn(`Invalid image data format detected`);
-    return null;
-  };
-
-  if (role !== "user" && attachments?.length)
-    throw new Error("attachments are only supported for user messages");
-
-  if (role !== "assistant" && status)
-    throw new Error("status is only supported for assistant messages");
-
-  if (role !== "assistant" && metadata?.steps)
-    throw new Error("metadata.steps is only supported for assistant messages");
-
-  switch (role) {
-    case "assistant":
-      return {
-        ...common,
-        role,
-        content: content
-          .map((part): ThreadAssistantMessagePart | null => {
-            const type = part.type;
-            switch (type) {
-              case "text":
-              case "reasoning":
-                if (part.text.trim().length === 0) return null;
-                return part;
-
-              case "file":
-              case "source":
-                return part;
-
-              case "image":
-                return sanitizeImageContent(part);
-
-              case "tool-call": {
-                const { parentId, ...basePart } = part;
-                const commonProps = {
-                  ...basePart,
-                  toolCallId: part.toolCallId ?? "tool-" + generateId(),
-                  ...(parentId !== undefined && { parentId }),
-                };
-
-                if (part.args) {
-                  return {
-                    ...commonProps,
-                    args: part.args,
-                    argsText: JSON.stringify(part.args),
-                  };
-                }
-                return {
-                  ...commonProps,
-                  args:
-                    part.args ??
-                    parsePartialJsonObject(part.argsText ?? "") ??
-                    {},
-                  argsText: part.argsText ?? "",
-                };
-              }
-
-              default: {
-                const unhandledType: "audio" = type;
-                throw new Error(
-                  `Unsupported assistant message part type: ${unhandledType}`,
-                );
-              }
-            }
-          })
-          .filter((c) => !!c),
-        status: status ?? fallbackStatus,
-        metadata: {
-          unstable_state: metadata?.unstable_state ?? null,
-          unstable_annotations: metadata?.unstable_annotations ?? [],
-          unstable_data: metadata?.unstable_data ?? [],
-          custom: metadata?.custom ?? {},
-          steps: metadata?.steps ?? [],
-        },
-      } satisfies ThreadAssistantMessage;
-
-    case "user":
-      return {
-        ...common,
-        role,
-        content: content.map((part): ThreadUserMessagePart => {
-          const type = part.type;
-          switch (type) {
-            case "text":
-            case "image":
-            case "audio":
-            case "file":
-              return part;
-
-            default: {
-              const unhandledType: "tool-call" | "reasoning" | "source" = type;
-              throw new Error(
-                `Unsupported user message part type: ${unhandledType}`,
-              );
-            }
-          }
-        }),
-        attachments: attachments ?? [],
-        metadata: {
-          custom: metadata?.custom ?? {},
-        },
-      } satisfies ThreadUserMessage;
-
-    case "system":
-      if (content.length !== 1 || content[0]!.type !== "text")
-        throw new Error(
-          "System messages must have exactly one text message part.",
-        );
-
-      return {
-        ...common,
-        role,
-        content: content as [TextMessagePart],
-        metadata: {
-          custom: metadata?.custom ?? {},
-        },
-      } satisfies ThreadSystemMessage;
-
-    default: {
-      const unsupportedRole: never = role;
-      throw new Error(`Unknown message role: ${unsupportedRole}`);
-    }
-  }
-};

package/src/runtimes/external-store/auto-status.tsx

@@ -1,26 +0,0 @@
-import { MessageStatus } from "../../types";
-
-const AUTO_STATUS_RUNNING = Object.freeze({ type: "running" });
-const AUTO_STATUS_COMPLETE = Object.freeze({
-  type: "complete",
-  reason: "unknown",
-});
-
-const AUTO_STATUS_PENDING = Object.freeze({
-  type: "requires-action",
-  reason: "tool-calls",
-});
-
-export const isAutoStatus = (status: MessageStatus) =>
-  status === AUTO_STATUS_RUNNING || status === AUTO_STATUS_COMPLETE;
-
-export const getAutoStatus = (
-  isLast: boolean,
-  isRunning: boolean,
-  hasPendingToolCalls: boolean,
-) =>
-  isLast && isRunning
-    ? AUTO_STATUS_RUNNING
-    : hasPendingToolCalls
-      ? AUTO_STATUS_PENDING
-      : AUTO_STATUS_COMPLETE;

package/src/runtimes/external-store/createMessageConverter.tsx

@@ -1,70 +0,0 @@
-"use client";
-import { ThreadState } from "../../api";
-import { useAssistantApi, useAssistantState } from "../../context";
-import { ThreadMessage } from "../../types";
-import {
-  useExternalMessageConverter,
-  convertExternalMessages,
-} from "./external-message-converter";
-import { getExternalStoreMessages } from "./getExternalStoreMessage";
-
-export const createMessageConverter = <T extends object>(
-  callback: useExternalMessageConverter.Callback<T>,
-) => {
-  const result = {
-    useThreadMessages: ({
-      messages,
-      isRunning,
-      joinStrategy,
-    }: {
-      messages: T[];
-      isRunning: boolean;
-      joinStrategy?: "concat-content" | "none" | undefined;
-    }) => {
-      return useExternalMessageConverter<T>({
-        callback,
-        messages,
-        isRunning,
-        joinStrategy,
-      });
-    },
-    toThreadMessages: (messages: T[]) => {
-      return convertExternalMessages(messages, callback, false); // TODO figure out isRunning
-    },
-    toOriginalMessages: (
-      input: ThreadState | ThreadMessage | ThreadMessage["content"][number],
-    ) => {
-      const messages = getExternalStoreMessages(input);
-      if (messages.length === 0) throw new Error("No original messages found");
-      return messages;
-    },
-    toOriginalMessage: (
-      input: ThreadState | ThreadMessage | ThreadMessage["content"][number],
-    ) => {
-      const messages = result.toOriginalMessages(input);
-      return messages[0]!;
-    },
-    useOriginalMessage: () => {
-      const messageMessages = result.useOriginalMessages();
-      const first = messageMessages[0]!;
-      return first;
-    },
-    useOriginalMessages: () => {
-      const api = useAssistantApi();
-      const partMessages = useAssistantState((s) => {
-        if (api.part.source) return getExternalStoreMessages(s.part);
-        return undefined;
-      });
-
-      const messageMessages = useAssistantState<T[]>(({ message }) =>
-        getExternalStoreMessages(message),
-      );
-
-      const messages = partMessages ?? messageMessages;
-      if (messages.length === 0) throw new Error("No original messages found");
-      return messages;
-    },
-  };
-
-  return result;
-};

package/src/runtimes/external-store/external-message-converter.tsx

@@ -1,354 +0,0 @@
-"use client";
-
-import { useMemo } from "react";
-import { ThreadMessageConverter } from "./ThreadMessageConverter";
-import {
-  getExternalStoreMessages,
-  symbolInnerMessage,
-} from "./getExternalStoreMessage";
-import { fromThreadMessageLike, ThreadMessageLike } from "./ThreadMessageLike";
-import { getAutoStatus, isAutoStatus } from "./auto-status";
-import { ToolCallMessagePart } from "../../types";
-
-export namespace useExternalMessageConverter {
-  export type Message =
-    | (ThreadMessageLike & {
-        readonly convertConfig?: {
-          readonly joinStrategy?: "concat-content" | "none";
-        };
-      })
-    | {
-        role: "tool";
-        toolCallId: string;
-        toolName?: string | undefined;
-        result: any;
-        artifact?: any;
-        isError?: boolean;
-      };
-
-  export type Callback<T> = (message: T) => Message | Message[];
-}
-
-type CallbackResult<T> = {
-  input: T;
-  outputs: useExternalMessageConverter.Message[];
-};
-
-type ChunkResult<T> = {
-  inputs: T[];
-  outputs: useExternalMessageConverter.Message[];
-};
-
-type Mutable<T> = {
-  -readonly [P in keyof T]: T[P];
-};
-
-const joinExternalMessages = (
-  messages: readonly useExternalMessageConverter.Message[],
-): ThreadMessageLike => {
-  const assistantMessage: Mutable<Omit<ThreadMessageLike, "metadata">> & {
-    content: Exclude<ThreadMessageLike["content"][0], string>[];
-    metadata?: Mutable<ThreadMessageLike["metadata"]>;
-  } = {
-    role: "assistant",
-    content: [],
-  };
-  for (const output of messages) {
-    if (output.role === "tool") {
-      const toolCallIdx = assistantMessage.content.findIndex(
-        (c) => c.type === "tool-call" && c.toolCallId === output.toolCallId,
-      );
-      if (toolCallIdx !== -1) {
-        const toolCall = assistantMessage.content[
-          toolCallIdx
-        ]! as ToolCallMessagePart;
-        if (output.toolName) {
-          if (toolCall.toolName !== output.toolName)
-            throw new Error(
-              `Tool call name ${output.toolCallId} ${output.toolName} does not match existing tool call ${toolCall.toolName}`,
-            );
-        }
-        assistantMessage.content[toolCallIdx] = {
-          ...toolCall,
-          ...{
-            [symbolInnerMessage]: [
-              ...((toolCall as any)[symbolInnerMessage] ?? []),
-              output,
-            ],
-          },
-          result: output.result,
-          artifact: output.artifact,
-          isError: output.isError,
-        };
-      } else {
-        throw new Error(
-          `Tool call ${output.toolCallId} ${output.toolName} not found in assistant message`,
-        );
-      }
-    } else {
-      const role = output.role;
-      const content = (
-        typeof output.content === "string"
-          ? [{ type: "text" as const, text: output.content }]
-          : output.content
-      ).map((c) => ({
-        ...c,
-        ...{ [symbolInnerMessage]: [output] },
-      }));
-      switch (role) {
-        case "system":
-        case "user":
-          return {
-            ...output,
-            content,
-          };
-        case "assistant":
-          if (assistantMessage.content.length === 0) {
-            assistantMessage.id = output.id;
-            assistantMessage.createdAt ??= output.createdAt;
-            assistantMessage.status ??= output.status;
-
-            if (output.attachments) {
-              assistantMessage.attachments = [
-                ...(assistantMessage.attachments ?? []),
-                ...output.attachments,
-              ];
-            }
-
-            if (output.metadata) {
-              assistantMessage.metadata ??= {};
-              if (output.metadata.unstable_state) {
-                assistantMessage.metadata.unstable_state =
-                  output.metadata.unstable_state;
-              }
-              if (output.metadata.unstable_annotations) {
-                assistantMessage.metadata.unstable_annotations = [
-                  ...(assistantMessage.metadata.unstable_annotations ?? []),
-                  ...output.metadata.unstable_annotations,
-                ];
-              }
-              if (output.metadata.unstable_data) {
-                assistantMessage.metadata.unstable_data = [
-                  ...(assistantMessage.metadata.unstable_data ?? []),
-                  ...output.metadata.unstable_data,
-                ];
-              }
-              if (output.metadata.steps) {
-                assistantMessage.metadata.steps = [
-                  ...(assistantMessage.metadata.steps ?? []),
-                  ...output.metadata.steps,
-                ];
-              }
-              if (output.metadata.custom) {
-                assistantMessage.metadata.custom = {
-                  ...(assistantMessage.metadata.custom ?? {}),
-                  ...output.metadata.custom,
-                };
-              }
-            }
-            // TODO keep this in sync
-          }
-
-          assistantMessage.content.push(...content);
-          break;
-        default: {
-          const unsupportedRole: never = role;
-          throw new Error(`Unknown message role: ${unsupportedRole}`);
-        }
-      }
-    }
-  }
-  return assistantMessage;
-};
-
-const chunkExternalMessages = <T,>(
-  callbackResults: CallbackResult<T>[],
-  joinStrategy?: "concat-content" | "none",
-) => {
-  const results: ChunkResult<T>[] = [];
-  let isAssistant = false;
-  let pendingNone = false; // true if the previous assistant message had joinStrategy "none"
-  let inputs: T[] = [];
-  let outputs: useExternalMessageConverter.Message[] = [];
-
-  const flush = () => {
-    if (outputs.length) {
-      results.push({
-        inputs,
-        outputs,
-      });
-    }
-    inputs = [];
-    outputs = [];
-    isAssistant = false;
-    pendingNone = false;
-  };
-
-  for (const callbackResult of callbackResults) {
-    for (const output of callbackResult.outputs) {
-      if (
-        (pendingNone && output.role !== "tool") ||
-        !isAssistant ||
-        output.role === "user" ||
-        output.role === "system"
-      ) {
-        flush();
-      }
-      isAssistant = output.role === "assistant" || output.role === "tool";
-
-      if (inputs.at(-1) !== callbackResult.input) {
-        inputs.push(callbackResult.input);
-      }
-      outputs.push(output);
-
-      if (
-        output.role === "assistant" &&
-        (output.convertConfig?.joinStrategy === "none" ||
-          joinStrategy === "none")
-      ) {
-        pendingNone = true;
-      }
-    }
-  }
-  flush();
-  return results;
-};
-
-export const convertExternalMessages = <T extends WeakKey>(
-  messages: T[],
-  callback: useExternalMessageConverter.Callback<T>,
-  isRunning: boolean,
-) => {
-  const callbackResults: CallbackResult<T>[] = [];
-  for (const message of messages) {
-    const output = callback(message);
-    const outputs = Array.isArray(output) ? output : [output];
-    const result = { input: message, outputs };
-    callbackResults.push(result);
-  }
-
-  const chunks = chunkExternalMessages(callbackResults);
-
-  return chunks.map((message, idx) => {
-    const isLast = idx === chunks.length - 1;
-    const joined = joinExternalMessages(message.outputs);
-    const hasPendingToolCalls =
-      typeof joined.content === "object" &&
-      joined.content.some(
-        (c) => c.type === "tool-call" && c.result === undefined,
-      );
-    const autoStatus = getAutoStatus(isLast, isRunning, hasPendingToolCalls);
-    const newMessage = fromThreadMessageLike(
-      joined,
-      idx.toString(),
-      autoStatus,
-    );
-    (newMessage as any)[symbolInnerMessage] = message.inputs;
-    return newMessage;
-  });
-};
-
-export const useExternalMessageConverter = <T extends WeakKey>({
-  callback,
-  messages,
-  isRunning,
-  joinStrategy,
-}: {
-  callback: useExternalMessageConverter.Callback<T>;
-  messages: T[];
-  isRunning: boolean;
-  joinStrategy?: "concat-content" | "none" | undefined;
-}) => {
-  const state = useMemo(
-    () => ({
-      callback,
-      callbackCache: new WeakMap<T, CallbackResult<T>>(),
-      chunkCache: new WeakMap<
-        useExternalMessageConverter.Message,
-        ChunkResult<T>
-      >(),
-      converterCache: new ThreadMessageConverter(),
-    }),
-    [callback],
-  );
-
-  return useMemo(() => {
-    const callbackResults: CallbackResult<T>[] = [];
-    for (const message of messages) {
-      let result = state.callbackCache.get(message);
-      if (!result) {
-        const output = state.callback(message);
-        const outputs = Array.isArray(output) ? output : [output];
-        result = { input: message, outputs };
-        state.callbackCache.set(message, result);
-      }
-      callbackResults.push(result);
-    }
-
-    const chunks = chunkExternalMessages(callbackResults, joinStrategy).map(
-      (m) => {
-        const key = m.outputs[0];
-        if (!key) return m;
-
-        const cached = state.chunkCache.get(key);
-        if (cached && shallowArrayEqual(cached.outputs, m.outputs))
-          return cached;
-        state.chunkCache.set(key, m);
-        return m;
-      },
-    );
-
-    const threadMessages = state.converterCache.convertMessages(
-      chunks,
-      (cache, message, idx) => {
-        const isLast = idx === chunks.length - 1;
-
-        const joined = joinExternalMessages(message.outputs);
-        const hasPendingToolCalls =
-          typeof joined.content === "object" &&
-          joined.content.some(
-            (c) => c.type === "tool-call" && c.result === undefined,
-          );
-        const autoStatus = getAutoStatus(
-          isLast,
-          isRunning,
-          hasPendingToolCalls,
-        );
-
-        if (
-          cache &&
-          (cache.role !== "assistant" ||
-            !isAutoStatus(cache.status) ||
-            cache.status === autoStatus)
-        ) {
-          const inputs = getExternalStoreMessages<T>(cache);
-          if (shallowArrayEqual(inputs, message.inputs)) {
-            return cache;
-          }
-        }
-
-        const newMessage = fromThreadMessageLike(
-          joined,
-          idx.toString(),
-          autoStatus,
-        );
-        (newMessage as any)[symbolInnerMessage] = message.inputs;
-        return newMessage;
-      },
-    );
-
-    (threadMessages as unknown as { [symbolInnerMessage]: T[] })[
-      symbolInnerMessage
-    ] = messages;
-
-    return threadMessages;
-  }, [state, messages, isRunning, joinStrategy]);
-};
-
-const shallowArrayEqual = (a: unknown[], b: unknown[]) => {
-  if (a.length !== b.length) return false;
-  for (let i = 0; i < a.length; i++) {
-    if (a[i] !== b[i]) return false;
-  }
-  return true;
-};

package/src/runtimes/external-store/getExternalStoreMessage.tsx

@@ -1,37 +0,0 @@
-import { ThreadState } from "../../api";
-import { ThreadMessage } from "../../types";
-
-export const symbolInnerMessage = Symbol("innerMessage");
-const symbolInnerMessages = Symbol("innerMessages");
-
-type WithInnerMessages<T> = {
-  [symbolInnerMessage]?: T | T[];
-  [symbolInnerMessages]?: T[];
-};
-
-/**
- * @deprecated Use `getExternalStoreMessages` (plural) instead. This function will be removed in 0.8.0.
- */
-export const getExternalStoreMessage = <T,>(input: ThreadMessage) => {
-  const withInnerMessages = input as WithInnerMessages<T>;
-  return withInnerMessages[symbolInnerMessage];
-};
-
-const EMPTY_ARRAY: never[] = [];
-
-export const getExternalStoreMessages = <T,>(
-  input: ThreadState | ThreadMessage | ThreadMessage["content"][number],
-) => {
-  // TODO temp until 0.8.0 (migrate useExternalStoreRuntime to always set an array)
-
-  const container = (
-    "messages" in input ? input.messages : input
-  ) as WithInnerMessages<T>;
-  const value = container[symbolInnerMessages] || container[symbolInnerMessage];
-  if (!value) return EMPTY_ARRAY;
-  if (Array.isArray(value)) {
-    return value;
-  }
-  container[symbolInnerMessages] = [value];
-  return container[symbolInnerMessages];
-};