@assistant-ui/react 0.15.13 → 0.15.15

package/src/client/InMemoryThreadList.ts

@@ -1,241 +0,0 @@
-import { useState, useMemo } from "react";
-import { resource, withKey, type ResourceElement } from "@assistant-ui/tap";
-import {
-  type ClientOutput,
-  useClientLookup,
-  Derived,
-  attachTransformScopes,
-  useClientResource,
-} from "@assistant-ui/store";
-
-import { ModelContext, Suggestions } from "@assistant-ui/core/store";
-import { Tools, DataRenderers } from "@assistant-ui/core/react";
-
-const RESOLVED_PROMISE = Promise.resolve();
-
-export type InMemoryThreadListProps = {
-  thread: (threadId: string) => ResourceElement<ClientOutput<"thread">>;
-  onSwitchToThread?: (threadId: string) => void;
-  onSwitchToNewThread?: () => void;
-};
-
-type ThreadData = {
-  id: string;
-  title?: string;
-  status: "regular" | "archived";
-  custom?: Record<string, unknown> | undefined;
-};
-
-// ThreadListItem Client
-const useThreadListItemClient = (props: {
-  data: ThreadData;
-  isRunning: boolean;
-  onSwitchTo: () => void;
-  onRename: (title: string) => void;
-  onUpdateCustom: (custom: Record<string, unknown> | undefined) => void;
-  onArchive: () => void;
-  onUnarchive: () => void;
-  onDelete: () => void;
-}): ClientOutput<"threadListItem"> => {
-  const {
-    data,
-    isRunning,
-    onSwitchTo,
-    onRename,
-    onUpdateCustom,
-    onArchive,
-    onUnarchive,
-    onDelete,
-  } = props;
-  const state = useMemo(
-    () => ({
-      id: data.id,
-      remoteId: undefined,
-      externalId: undefined,
-      title: data.title,
-      status: data.status,
-      custom: data.custom,
-      isRunning,
-    }),
-    [data.id, data.title, data.status, data.custom, isRunning],
-  );
-
-  return {
-    getState: () => state,
-    switchTo: onSwitchTo,
-    rename: onRename,
-    updateCustom: onUpdateCustom,
-    archive: onArchive,
-    unarchive: onUnarchive,
-    delete: onDelete,
-    generateTitle: () => {},
-    initialize: async () => ({ remoteId: data.id, externalId: undefined }),
-    detach: () => {},
-  };
-};
-
-const ThreadListItemClient = resource(useThreadListItemClient);
-
-// InMemoryThreadList Client
-const useInMemoryThreadList = (
-  props: InMemoryThreadListProps,
-): ClientOutput<"threads"> => {
-  const {
-    thread: threadFactory,
-    onSwitchToThread,
-    onSwitchToNewThread,
-  } = props;
-
-  const [mainThreadId, setMainThreadId] = useState("main");
-  const [threads, setThreads] = useState<readonly ThreadData[]>(() => [
-    { id: "main", title: "Main Thread", status: "regular" },
-  ]);
-
-  const handleSwitchToThread = (threadId: string) => {
-    setMainThreadId(threadId);
-    onSwitchToThread?.(threadId);
-  };
-
-  const handleRename = (threadId: string, title: string) => {
-    setThreads((prev) =>
-      prev.map((t) => (t.id === threadId ? { ...t, title } : t)),
-    );
-  };
-
-  const handleArchive = (threadId: string) => {
-    setThreads((prev) =>
-      prev.map((t) =>
-        t.id === threadId ? { ...t, status: "archived" as const } : t,
-      ),
-    );
-  };
-
-  const handleUnarchive = (threadId: string) => {
-    setThreads((prev) =>
-      prev.map((t) =>
-        t.id === threadId ? { ...t, status: "regular" as const } : t,
-      ),
-    );
-  };
-
-  const handleUpdateCustom = (
-    threadId: string,
-    custom: Record<string, unknown> | undefined,
-  ) => {
-    setThreads((prev) =>
-      prev.map((t) => (t.id === threadId ? { ...t, custom } : t)),
-    );
-  };
-
-  const handleDelete = (threadId: string) => {
-    setThreads((prev) => prev.filter((t) => t.id !== threadId));
-    setMainThreadId((prev) =>
-      prev === threadId
-        ? threads.find((t) => t.id !== threadId)?.id || "main"
-        : prev,
-    );
-  };
-
-  const handleSwitchToNewThread = () => {
-    const newId = `thread-${Date.now()}`;
-    setThreads((prev) => [
-      ...prev,
-      { id: newId, title: "New Thread", status: "regular" },
-    ]);
-    setMainThreadId(newId);
-    onSwitchToNewThread?.();
-  };
-
-  // Only the main thread is mounted, so it is the only thread that can run.
-  const mainThreadClient = useClientResource(threadFactory(mainThreadId));
-
-  const threadListItems = useClientLookup(
-    threads.map((t) =>
-      withKey(
-        t.id,
-        ThreadListItemClient({
-          data: t,
-          isRunning: t.id === mainThreadId && mainThreadClient.state.isRunning,
-          onSwitchTo: () => handleSwitchToThread(t.id),
-          onRename: (title) => handleRename(t.id, title),
-          onUpdateCustom: (custom) => handleUpdateCustom(t.id, custom),
-          onArchive: () => handleArchive(t.id),
-          onUnarchive: () => handleUnarchive(t.id),
-          onDelete: () => handleDelete(t.id),
-        }),
-      ),
-    ),
-  );
-
-  const state = useMemo(() => {
-    const regularThreads = threads.filter((t) => t.status === "regular");
-    const archivedThreads = threads.filter((t) => t.status === "archived");
-
-    return {
-      mainThreadId,
-      newThreadId: null,
-      isLoading: false,
-      isLoadingMore: false,
-      hasMore: false,
-      threadIds: regularThreads.map((t) => t.id),
-      archivedThreadIds: archivedThreads.map((t) => t.id),
-      threadItems: threadListItems.state,
-      main: mainThreadClient.state,
-    };
-  }, [mainThreadId, threads, threadListItems.state, mainThreadClient.state]);
-
-  return {
-    getState: () => state,
-    switchToThread: handleSwitchToThread,
-    switchToNewThread: handleSwitchToNewThread,
-    getLoadThreadsPromise: () => RESOLVED_PROMISE,
-    reload: () => RESOLVED_PROMISE,
-    reloadMainThread: () => RESOLVED_PROMISE,
-    loadMore: () => RESOLVED_PROMISE,
-    item: (selector) => {
-      if (selector === "main") {
-        const index = threads.findIndex((t) => t.id === mainThreadId);
-        return threadListItems.get({ index: index === -1 ? 0 : index });
-      }
-      if ("id" in selector) {
-        const index = threads.findIndex((t) => t.id === selector.id);
-        return threadListItems.get({ index });
-      }
-      return threadListItems.get(selector);
-    },
-    thread: () => mainThreadClient.methods,
-  };
-};
-
-export const InMemoryThreadList = resource(useInMemoryThreadList);
-
-attachTransformScopes(useInMemoryThreadList, (scopes, parent) => {
-  scopes.thread ??= Derived({
-    source: "threads",
-    query: { type: "main" },
-    get: (aui) => aui.threads.thread("main"),
-  });
-  scopes.threadListItem ??= Derived({
-    source: "threads",
-    query: { type: "main" },
-    get: (aui) => aui.threads.item("main"),
-  });
-  scopes.composer ??= Derived({
-    source: "thread",
-    query: {},
-    get: (aui) => aui.threads.thread("main").composer(),
-  });
-
-  if (!scopes.modelContext && parent.modelContext.source === null) {
-    scopes.modelContext = ModelContext();
-  }
-  if (!scopes.tools && parent.tools.source === null) {
-    scopes.tools = Tools({});
-  }
-  if (!scopes.dataRenderers && parent.dataRenderers.source === null) {
-    scopes.dataRenderers = DataRenderers();
-  }
-  if (!scopes.suggestions && parent.suggestions.source === null) {
-    scopes.suggestions = Suggestions();
-  }
-});

package/src/legacy-runtime/cloud/auiV0.ts

@@ -1,331 +0,0 @@
-import type {
-  CompleteAttachment,
-  MessageStatus,
-  SourceProviderMetadata,
-  ThreadMessage,
-  ToolApprovalOption,
-} from "@assistant-ui/core";
-import { fromThreadMessageLike } from "../runtime-cores/external-store/ThreadMessageLike";
-import type { CloudMessage } from "assistant-cloud";
-import { isJSONValue } from "@assistant-ui/core/internal";
-import type {
-  ReadonlyJSONObject,
-  ReadonlyJSONValue,
-} from "assistant-stream/utils";
-import type { ExportedMessageRepositoryItem } from "../runtime-cores/utils/MessageRepository";
-
-type AuiV0ToolApproval = {
-  readonly id: string;
-  readonly approved?: boolean;
-  readonly reason?: string;
-  readonly isAutomatic?: boolean;
-  readonly options?: readonly ToolApprovalOption[];
-  readonly optionId?: string;
-  readonly resolution?: "cancelled" | "expired";
-};
-
-type AuiV0MessagePart =
-  | {
-      readonly type: "text";
-      readonly text: string;
-    }
-  | {
-      readonly type: "reasoning";
-      readonly text: string;
-      readonly unstable_summary?: string;
-    }
-  | {
-      readonly type: "source";
-      readonly sourceType: "url";
-      readonly id: string;
-      readonly url: string;
-      readonly title?: string;
-      readonly providerMetadata?: SourceProviderMetadata;
-    }
-  | {
-      readonly type: "source";
-      readonly sourceType: "document";
-      readonly id: string;
-      readonly title: string;
-      readonly mediaType: string;
-      readonly filename?: string;
-      readonly providerMetadata?: SourceProviderMetadata;
-    }
-  | {
-      readonly type: "tool-call";
-      readonly toolCallId: string;
-      readonly toolName: string;
-      readonly args: ReadonlyJSONObject;
-      readonly result?: ReadonlyJSONValue;
-      readonly isError?: true;
-      readonly approval?: AuiV0ToolApproval;
-    }
-  | {
-      readonly type: "tool-call";
-      readonly toolCallId: string;
-      readonly toolName: string;
-      readonly argsText: string;
-      readonly result?: ReadonlyJSONValue;
-      readonly isError?: true;
-      readonly approval?: AuiV0ToolApproval;
-    }
-  | {
-      readonly type: "image";
-      readonly image: string;
-    }
-  | {
-      readonly type: "file";
-      readonly data: string;
-      readonly mimeType: string;
-      readonly filename?: string;
-      readonly sourceType?: "url" | "id";
-    };
-
-type AuiV0AttachmentPart =
-  | {
-      readonly type: "text";
-      readonly text: string;
-    }
-  | {
-      readonly type: "image";
-      readonly image: string;
-      readonly filename?: string;
-    }
-  | {
-      readonly type: "file";
-      readonly data: string;
-      readonly mimeType: string;
-      readonly filename?: string;
-      readonly sourceType?: "url" | "id";
-    }
-  | {
-      readonly type: "audio";
-      readonly audio: {
-        readonly data: string;
-        readonly format: "mp3" | "wav";
-      };
-    }
-  | {
-      readonly type: "data";
-      readonly name: string;
-      readonly data: ReadonlyJSONValue;
-    };
-
-type AuiV0Attachment = {
-  readonly id: string;
-  readonly type: CompleteAttachment["type"];
-  readonly name: string;
-  readonly contentType?: string;
-  readonly status: CompleteAttachment["status"];
-  readonly content: readonly AuiV0AttachmentPart[];
-};
-
-type AuiV0Message = {
-  readonly role: "assistant" | "user" | "system";
-  readonly status?: MessageStatus;
-  readonly content: readonly AuiV0MessagePart[];
-  readonly attachments?: readonly AuiV0Attachment[];
-  readonly metadata: {
-    readonly unstable_state?: ReadonlyJSONValue;
-    readonly unstable_annotations: readonly ReadonlyJSONValue[];
-    readonly unstable_data: readonly ReadonlyJSONValue[];
-    readonly steps: readonly {
-      readonly usage?: {
-        readonly inputTokens: number;
-        readonly outputTokens: number;
-      };
-    }[];
-    readonly custom: ReadonlyJSONObject;
-  };
-};
-
-const encodeAttachmentPart = (
-  part: CompleteAttachment["content"][number],
-): AuiV0AttachmentPart => {
-  const type = part.type;
-  switch (type) {
-    case "text":
-      return { type: "text", text: part.text };
-
-    case "image":
-      return {
-        type: "image",
-        image: part.image,
-        ...(part.filename != null ? { filename: part.filename } : undefined),
-      };
-
-    case "file":
-      return {
-        type: "file",
-        data: part.data,
-        mimeType: part.mimeType,
-        ...(part.filename != null ? { filename: part.filename } : undefined),
-        ...(part.sourceType != null
-          ? { sourceType: part.sourceType }
-          : undefined),
-      };
-
-    case "audio":
-      return {
-        type: "audio",
-        audio: { data: part.audio.data, format: part.audio.format },
-      };
-
-    case "data": {
-      if (!isJSONValue(part.data)) {
-        console.warn(`attachment data is not JSON! ${JSON.stringify(part)}`);
-      }
-      return {
-        type: "data",
-        name: part.name,
-        data: part.data as ReadonlyJSONValue,
-      };
-    }
-
-    default: {
-      const unhandledType: never = type;
-      throw new Error(
-        `Attachment part type not supported by aui/v0: ${unhandledType}`,
-      );
-    }
-  }
-};
-
-const encodeAttachments = (
-  message: ThreadMessage,
-): readonly AuiV0Attachment[] | undefined => {
-  if (message.role !== "user" || message.attachments.length === 0) {
-    return undefined;
-  }
-
-  return message.attachments.map(
-    ({ id, type, name, contentType, status, content }) => ({
-      id,
-      type,
-      name,
-      status,
-      ...(contentType != null ? { contentType } : undefined),
-      content: content.map(encodeAttachmentPart),
-    }),
-  );
-};
-
-export function auiV0Encode(message: ThreadMessage): AuiV0Message {
-  // info: ID and createdAt are ignored (we use the server value instead)
-  const status: MessageStatus | undefined =
-    message.status?.type === "running"
-      ? { type: "incomplete", reason: "cancelled" }
-      : message.status;
-  const attachments = encodeAttachments(message);
-
-  return {
-    role: message.role,
-    content: message.content.map((part) => {
-      const type = part.type;
-      switch (type) {
-        case "text":
-          return { type: "text", text: part.text };
-
-        case "reasoning":
-          return {
-            type: "reasoning",
-            text: part.text,
-            ...(part.unstable_summary !== undefined
-              ? { unstable_summary: part.unstable_summary }
-              : undefined),
-          };
-
-        case "source":
-          if (part.sourceType === "url") {
-            return {
-              type: "source",
-              sourceType: "url",
-              id: part.id,
-              url: part.url,
-              ...(part.title != null ? { title: part.title } : undefined),
-              ...(part.providerMetadata != null
-                ? { providerMetadata: part.providerMetadata }
-                : undefined),
-            };
-          }
-
-          return {
-            type: "source",
-            sourceType: "document",
-            id: part.id,
-            title: part.title,
-            mediaType: part.mediaType,
-            ...(part.filename != null
-              ? { filename: part.filename }
-              : undefined),
-            ...(part.providerMetadata != null
-              ? { providerMetadata: part.providerMetadata }
-              : undefined),
-          };
-
-        case "tool-call": {
-          if (part.result !== undefined && !isJSONValue(part.result)) {
-            console.warn(
-              `tool-call result is not JSON! ${JSON.stringify(part)}`,
-            );
-          }
-          return {
-            type: "tool-call",
-            toolCallId: part.toolCallId,
-            toolName: part.toolName,
-            ...(JSON.stringify(part.args) === part.argsText
-              ? { args: part.args }
-              : { argsText: part.argsText }),
-            ...(part.result !== undefined
-              ? { result: part.result as ReadonlyJSONValue }
-              : undefined),
-            ...(part.isError ? { isError: true } : undefined),
-            ...(part.approval ? { approval: part.approval } : undefined),
-          };
-        }
-
-        case "image":
-          return { type: "image", image: part.image };
-
-        case "file":
-          return {
-            type: "file",
-            data: part.data,
-            mimeType: part.mimeType,
-            ...(part.filename ? { filename: part.filename } : undefined),
-            ...(part.sourceType ? { sourceType: part.sourceType } : undefined),
-          };
-
-        default: {
-          const unhandledType: "audio" | "data" | "generative-ui" = type;
-          throw new Error(
-            `Message part type not supported by aui/v0: ${unhandledType}`,
-          );
-        }
-      }
-    }),
-    metadata: message.metadata as AuiV0Message["metadata"],
-    ...(status ? { status } : undefined),
-    ...(attachments ? { attachments } : undefined),
-  };
-}
-
-export function auiV0Decode(
-  cloudMessage: CloudMessage & { format: "aui/v0" },
-): ExportedMessageRepositoryItem {
-  const payload = cloudMessage.content as unknown as AuiV0Message;
-  const message = fromThreadMessageLike(
-    {
-      id: cloudMessage.id,
-      createdAt: cloudMessage.created_at,
-      ...payload,
-    },
-    cloudMessage.id,
-    { type: "complete", reason: "unknown" },
-  );
-
-  return {
-    parentId: cloudMessage.parent_id,
-    message,
-  };
-}

package/src/legacy-runtime/cloud/useCloudThreadListRuntime.ts

@@ -1,31 +0,0 @@
-"use client";
-
-import type { AssistantCloud } from "assistant-cloud";
-import type { AssistantRuntime } from "@assistant-ui/core";
-import { useRemoteThreadListRuntime } from "../runtime-cores/remote-thread-list/useRemoteThreadListRuntime";
-import { useCloudThreadListAdapter } from "../runtime-cores/remote-thread-list/adapter/cloud";
-
-type ThreadData = {
-  externalId: string;
-};
-
-type CloudThreadListAdapter = {
-  cloud: AssistantCloud;
-
-  runtimeHook: () => AssistantRuntime;
-
-  create?(): Promise<ThreadData>;
-  delete?(threadId: string): Promise<void>;
-};
-
-export function useCloudThreadListRuntime({
-  runtimeHook,
-  ...adapterOptions
-}: CloudThreadListAdapter) {
-  const adapter = useCloudThreadListAdapter(adapterOptions);
-  return useRemoteThreadListRuntime({
-    runtimeHook,
-    adapter,
-    allowNesting: true,
-  });
-}

package/src/legacy-runtime/runtime-cores/assistant-transport/commandQueue.ts

@@ -1,68 +0,0 @@
-import { useState, useCallback, useRef, useEffect } from "react";
-import type {
-  AssistantTransportCommand,
-  CommandQueueState,
-  QueuedCommand,
-} from "./types";
-
-export const createInitialQueueState = (): CommandQueueState => ({
-  queued: [],
-  inTransit: [],
-});
-
-export const useCommandQueue = (opts: { onQueue: () => void }) => {
-  const onQueueRef = useRef(opts.onQueue);
-  useEffect(() => {
-    onQueueRef.current = opts.onQueue;
-  });
-
-  const [, rerender] = useState(0);
-  const queueStateRef = useRef<CommandQueueState>(createInitialQueueState());
-
-  const enqueue = (
-    command: AssistantTransportCommand,
-    options?: { schedule?: boolean },
-  ) => {
-    queueStateRef.current = {
-      queued: [...queueStateRef.current.queued, command],
-      inTransit: queueStateRef.current.inTransit,
-    };
-    rerender((prev) => prev + 1);
-
-    if (options?.schedule !== false) onQueueRef.current();
-  };
-
-  const flush = (): QueuedCommand[] => {
-    if (queueStateRef.current.queued.length === 0) return [];
-
-    const queued = queueStateRef.current.queued;
-    queueStateRef.current = {
-      queued: [],
-      inTransit: [...queueStateRef.current.inTransit, ...queued],
-    };
-    rerender((prev) => prev + 1);
-
-    return queued;
-  };
-
-  const markDelivered = () => {
-    queueStateRef.current = { ...queueStateRef.current, inTransit: [] };
-    rerender((prev) => prev + 1);
-  };
-
-  const reset = useCallback(() => {
-    queueStateRef.current = createInitialQueueState();
-    rerender((prev) => prev + 1);
-  }, []);
-
-  return {
-    // live getter — callbacks firing between renders must not see a stale snapshot
-    get state() {
-      return queueStateRef.current;
-    },
-    enqueue,
-    flush,
-    markDelivered,
-    reset,
-  };
-};