@superxd-studio/adptr 0.5.0

package/source/reusable/assistant-ui/index.tsx

@@ -0,0 +1,266 @@
+import { useMemo, type ReactNode } from "react";
+import {
+  AssistantRuntimeProvider,
+  useLocalRuntime,
+  useAui,
+  useAuiState,
+  type ChatModelAdapter,
+} from "@assistant-ui/react";
+import {
+  ChatInterrupted,
+  type ChatActions,
+  type ChatAdapter,
+  type ChatSnapshot,
+  parseChatFile,
+} from "../core/index.js";
+
+/** Optional bridge. assistant-ui alone owns state; there is no mirrored controller. */
+type Projection = { snapshot: ChatSnapshot; actions: ChatActions };
+export function AssistantChat({
+  adapter,
+  children,
+}: {
+  adapter: ChatAdapter;
+  children: (chat: Projection) => ReactNode;
+}) {
+  const bridge = useMemo<ChatModelAdapter>(
+    () => ({
+      async *run({ messages, abortSignal }) {
+        let text = "";
+        let metadata: Readonly<Record<string, unknown>> = {};
+        try {
+          for await (const event of adapter.run(
+            {
+              requestId: globalThis.crypto.randomUUID(),
+              messages: messages.map((message) => ({
+                id: message.id,
+                role: message.role === "user" ? "user" : "assistant",
+                text: message.content
+                  .filter((part) => part.type === "text")
+                  .map((part) => part.text)
+                  .join(""),
+                metadata: message.metadata.custom,
+                files: Array.isArray(message.metadata.custom.superxdFiles)
+                  ? message.metadata.custom.superxdFiles.map(parseChatFile)
+                  : undefined,
+              })),
+            },
+            abortSignal,
+          )) {
+            if (event.type === "error") throw new Error("Response failed");
+            if (event.type === "finish") return;
+            if (event.type === "metadata") metadata = event.metadata;
+            else text = event.type === "replace-text" ? event.text : text + event.text;
+            if (text.length > 100_000) throw new Error("Response too large");
+            yield { content: [{ type: "text", text }], metadata: { custom: { ...metadata } } };
+          }
+          if (!abortSignal.aborted) throw new Error("Response interrupted");
+        } catch (error) {
+          if (error instanceof ChatInterrupted)
+            throw new Error("Response interrupted", { cause: error });
+          throw error;
+        }
+      },
+    }),
+    [adapter],
+  );
+  const runtime = useLocalRuntime(bridge);
+  return (
+    <AssistantRuntimeProvider runtime={runtime}>
+      <Bridge adapter={adapter}>{children}</Bridge>
+    </AssistantRuntimeProvider>
+  );
+}
+
+function Bridge({
+  adapter,
+  children,
+}: {
+  adapter: ChatAdapter;
+  children: (chat: Projection) => ReactNode;
+}) {
+  const aui = useAui();
+  const thread = aui.thread;
+  const state = useAuiState((s) => s.thread);
+  const last = state.messages.at(-1);
+  const interrupted =
+    last?.role === "assistant" &&
+    last.status.type === "incomplete" &&
+    typeof last.status.error === "object" &&
+    last.status.error !== null &&
+    "message" in last.status.error &&
+    last.status.error.message === "Response interrupted";
+  const status: ChatSnapshot["status"] = state.isRunning
+    ? last?.content.some((part) => part.type === "text" && part.text)
+      ? "streaming"
+      : "waiting"
+    : last?.role === "assistant"
+      ? last.status.type === "incomplete"
+        ? last.status.reason === "cancelled"
+          ? "cancelled"
+          : interrupted
+            ? "interrupted"
+            : "error"
+        : "complete"
+      : "idle";
+  return children({
+    snapshot: {
+      status,
+      capabilities: adapter.capabilities,
+      branches: Object.fromEntries(
+        state.messages.flatMap((message) => {
+          const branch = thread.message({ id: message.id }).getState();
+          return branch.branchCount > 1
+            ? [[message.id, { index: branch.branchNumber - 1, count: branch.branchCount }]]
+            : [];
+        }),
+      ),
+      messages: state.messages.map((message) => ({
+        id: message.id,
+        role: message.role === "user" ? "user" : "assistant",
+        text: message.content
+          .filter((part) => part.type === "text")
+          .map((part) => part.text)
+          .join(""),
+        metadata: message.metadata.custom,
+        files: Array.isArray(message.metadata.custom.superxdFiles)
+          ? message.metadata.custom.superxdFiles.map(parseChatFile)
+          : undefined,
+      })),
+    },
+    actions: {
+      send(text, files = []) {
+        if (
+          thread.getState().isRunning ||
+          thread.getState().messages.length >= 98 ||
+          !adapter.capabilities.send ||
+          (!text.trim() && !files.length) ||
+          (files.length > 0 && !adapter.capabilities.attachments) ||
+          files.length > 4 ||
+          text.length > 20_000
+        )
+          return false;
+        let validated;
+        try {
+          validated = files.map(parseChatFile);
+        } catch {
+          return false;
+        }
+        if (!validated.length) thread.append(text);
+        else
+          thread.append({
+            role: "user",
+            content: [
+              ...(text ? [{ type: "text" as const, text }] : []),
+              ...validated.map((file) => ({
+                type: "file" as const,
+                data: file.url,
+                mimeType: file.mediaType,
+                filename: file.name,
+                sourceType: "url" as const,
+              })),
+            ],
+            metadata: { custom: { superxdFiles: validated } },
+          });
+        return true;
+      },
+      cancel() {
+        if (adapter.capabilities.cancel) thread.cancelRun();
+      },
+      retry() {
+        if (
+          thread.getState().isRunning ||
+          !adapter.capabilities.retry ||
+          !["error", "interrupted", "cancelled"].includes(status)
+        )
+          return false;
+        const parent = [...state.messages].reverse().find((message) => message.role === "user");
+        if (!parent) return false;
+        thread.startRun({ parentId: parent.id });
+        return true;
+      },
+      edit(messageId, text) {
+        if (
+          thread.getState().isRunning ||
+          !thread.getState().messages.some((message) => message.id === messageId)
+        )
+          return false;
+        const source = thread.message({ id: messageId }).getState();
+        const files = Array.isArray(source.metadata.custom.superxdFiles)
+          ? source.metadata.custom.superxdFiles.map(parseChatFile)
+          : [];
+        const previous = source.content
+          .filter((part) => part.type === "text")
+          .map((part) => part.text)
+          .join("");
+        if (
+          thread.getState().isRunning ||
+          !adapter.capabilities.send ||
+          !adapter.capabilities.edit ||
+          source.role !== "user" ||
+          !state.messages.some((message) => message.id === messageId) ||
+          text.length > 20_000 ||
+          (!text.trim() && !files.length) ||
+          text === previous ||
+          source.branchCount >= 20
+        )
+          return false;
+        thread.append({
+          role: "user",
+          parentId: source.parentId,
+          sourceId: source.id,
+          content: [
+            ...(text ? [{ type: "text" as const, text }] : []),
+            ...files.map((file) => ({
+              type: "file" as const,
+              data: file.url,
+              mimeType: file.mediaType,
+              filename: file.name,
+              sourceType: "url" as const,
+            })),
+          ],
+          metadata: { custom: { ...source.metadata.custom, superxdFiles: files } },
+        });
+        return true;
+      },
+      regenerate(messageId) {
+        if (
+          thread.getState().isRunning ||
+          !thread.getState().messages.some((message) => message.id === messageId)
+        )
+          return false;
+        const source = thread.message({ id: messageId }).getState();
+        if (
+          thread.getState().isRunning ||
+          !adapter.capabilities.send ||
+          !adapter.capabilities.regenerate ||
+          source.role !== "assistant" ||
+          source.branchCount >= 20 ||
+          !state.messages.some((message) => message.id === messageId)
+        )
+          return false;
+        thread.message({ id: messageId }).reload();
+        return true;
+      },
+      selectBranch(messageId, direction) {
+        if (
+          thread.getState().isRunning ||
+          !thread.getState().messages.some((message) => message.id === messageId)
+        )
+          return false;
+        const source = thread.message({ id: messageId }).getState();
+        if (
+          thread.getState().isRunning ||
+          !adapter.capabilities.branches ||
+          !state.messages.some((message) => message.id === messageId) ||
+          (direction === "previous"
+            ? source.branchNumber <= 1
+            : source.branchNumber >= source.branchCount)
+        )
+          return false;
+        thread.message({ id: messageId }).switchToBranch({ position: direction });
+        return true;
+      },
+    },
+  });
+}

package/source/reusable/core/attachments.ts

@@ -0,0 +1,163 @@
+import { parseChatFile, type ChatFile } from "./index.js";
+
+export interface UploadSource<Data> {
+  readonly id?: string;
+  readonly name: string;
+  readonly mediaType: string;
+  readonly size: number;
+  readonly data: Data;
+}
+export interface UploadAdapter<Data> {
+  upload(source: UploadSource<Data>, signal: AbortSignal): Promise<ChatFile>;
+  /** Release a removed draft file. Transferred transcript references must stay valid. */
+  release?(file: ChatFile): Promise<void>;
+}
+export interface UploadPolicy {
+  readonly maxFiles: number;
+  readonly maxBytes: number;
+  readonly mediaTypes: readonly string[];
+}
+export type AttachmentIssue = "type" | "size" | "count" | "failed";
+export interface AttachmentItem {
+  readonly id: string;
+  readonly name: string;
+  readonly mediaType: string;
+  readonly size: number;
+  readonly status: "uploading" | "ready" | "error" | "cancelled" | "rejected";
+  readonly file?: ChatFile;
+  readonly issue?: AttachmentIssue;
+}
+export interface AttachmentSnapshot {
+  readonly items: readonly AttachmentItem[];
+  readonly issue?: AttachmentIssue;
+}
+/** Upload state is separate from transcript state; no browser assumptions or second chat owner. */
+export class AttachmentController<Data> {
+  private snapshot: AttachmentSnapshot = { items: [] };
+  private readonly listeners = new Set<() => void>();
+  private readonly sources = new Map<string, UploadSource<Data>>();
+  private readonly active = new Map<string, AbortController>();
+  constructor(
+    private readonly adapter: UploadAdapter<Data>,
+    readonly policy: UploadPolicy,
+    private readonly id: () => string,
+  ) {}
+  getSnapshot = (): AttachmentSnapshot => this.snapshot;
+  subscribe = (listener: () => void) => {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  };
+  private publish(items: readonly AttachmentItem[], issue?: AttachmentIssue) {
+    this.snapshot = { items, ...(issue ? { issue } : {}) };
+    for (const listener of this.listeners) listener();
+  }
+  add = (inputs: readonly UploadSource<Data>[]): void => {
+    let countIssue: AttachmentIssue | undefined;
+    for (const source of inputs) {
+      if (this.snapshot.items.length >= this.policy.maxFiles) {
+        countIssue = "count";
+        continue;
+      }
+      const id = this.id();
+      const issue = !this.policy.mediaTypes.includes(source.mediaType)
+        ? "type"
+        : !Number.isSafeInteger(source.size) ||
+            source.size < 1 ||
+            source.size > this.policy.maxBytes
+          ? "size"
+          : undefined;
+      const identified = { ...source, id };
+      this.sources.set(id, identified);
+      const item: AttachmentItem = {
+        id,
+        name: source.name,
+        mediaType: source.mediaType,
+        size: source.size,
+        status: issue ? "rejected" : "uploading",
+        ...(issue ? { issue } : {}),
+      };
+      this.publish([...this.snapshot.items, item]);
+      if (!issue) this.begin(id, identified);
+    }
+    if (countIssue) this.publish(this.snapshot.items, countIssue);
+  };
+  cancel = (id: string): void => {
+    if (!this.active.has(id)) return;
+    this.active.get(id)?.abort();
+    this.active.delete(id);
+    this.publish(
+      this.snapshot.items.map((item) => (item.id === id ? { ...item, status: "cancelled" } : item)),
+    );
+  };
+  remove = (id: string): void => {
+    const item = this.snapshot.items.find((item) => item.id === id);
+    this.active.get(id)?.abort();
+    this.active.delete(id);
+    this.sources.delete(id);
+    if (item?.file) void this.adapter.release?.(item.file).catch(() => {});
+    this.publish(this.snapshot.items.filter((item) => item.id !== id));
+  };
+  retry = (id: string): void => {
+    const item = this.snapshot.items.find((item) => item.id === id);
+    const source = this.sources.get(id);
+    if (!source || !item || !["error", "cancelled"].includes(item.status)) return;
+    this.publish(
+      this.snapshot.items.map((item) =>
+        item.id === id ? { ...item, status: "uploading", issue: undefined } : item,
+      ),
+    );
+    this.begin(id, source);
+  };
+  /** Call only after send accepts: files now belong to the transcript, not the draft. */
+  transfer = (): void => {
+    const ready = this.snapshot.items.filter((item) => item.status === "ready");
+    for (const item of ready) this.sources.delete(item.id);
+    this.publish(this.snapshot.items.filter((item) => item.status !== "ready"));
+  };
+  dispose = (): void => {
+    for (const controller of this.active.values()) controller.abort();
+    this.active.clear();
+    for (const item of this.snapshot.items)
+      if (item.file) void this.adapter.release?.(item.file).catch(() => {});
+    this.sources.clear();
+    this.snapshot = { items: [] };
+    this.listeners.clear();
+  };
+  private begin(id: string, source: UploadSource<Data>) {
+    const controller = new AbortController();
+    this.active.set(id, controller);
+    void Promise.resolve()
+      .then(() => {
+        if (controller.signal.aborted) throw new Error("Upload cancelled before start");
+        return this.adapter.upload(source, controller.signal);
+      })
+      .then((value) => {
+        const file = parseChatFile(value);
+        if (
+          file.name !== source.name ||
+          file.mediaType !== source.mediaType ||
+          file.size !== source.size
+        )
+          throw new Error("Upload reference mismatch");
+        if (this.active.get(id) !== controller || controller.signal.aborted) {
+          void this.adapter.release?.(file).catch(() => {});
+          return;
+        }
+        this.active.delete(id);
+        this.publish(
+          this.snapshot.items.map((item) =>
+            item.id === id ? { ...item, status: "ready", file } : item,
+          ),
+        );
+      })
+      .catch(() => {
+        if (this.active.get(id) !== controller) return;
+        this.active.delete(id);
+        this.publish(
+          this.snapshot.items.map((item) =>
+            item.id === id ? { ...item, status: "error", issue: "failed" } : item,
+          ),
+        );
+      });
+  }
+}