@assistant-ui/core 0.1.3 → 0.1.5

package/src/react/primitive-hooks/index.ts

@@ -0,0 +1,20 @@
+export { useThreadMessages } from "./useThreadMessages";
+export { useThreadIsRunning } from "./useThreadIsRunning";
+export { useThreadIsEmpty } from "./useThreadIsEmpty";
+export { useComposerSend } from "./useComposerSend";
+export { useComposerCancel } from "./useComposerCancel";
+export { useMessageReload } from "./useMessageReload";
+export { useMessageBranching } from "./useMessageBranching";
+export {
+  useActionBarCopy,
+  type UseActionBarCopyOptions,
+} from "./useActionBarCopy";
+export { useActionBarEdit } from "./useActionBarEdit";
+export { useActionBarReload } from "./useActionBarReload";
+export {
+  useActionBarFeedbackPositive,
+  useActionBarFeedbackNegative,
+} from "./useActionBarFeedback";
+export { useComposerAddAttachment } from "./useComposerAddAttachment";
+export { useEditComposerCancel } from "./useEditComposerCancel";
+export { useEditComposerSend } from "./useEditComposerSend";

package/src/react/primitive-hooks/useActionBarCopy.ts

@@ -0,0 +1,38 @@
+import { useCallback } from "react";
+import { useAui, useAuiState } from "@assistant-ui/store";
+
+export type UseActionBarCopyOptions = {
+  copiedDuration?: number | undefined;
+  copyToClipboard?: ((text: string) => void | Promise<void>) | undefined;
+};
+
+export const useActionBarCopy = ({
+  copiedDuration = 3000,
+  copyToClipboard,
+}: UseActionBarCopyOptions = {}) => {
+  const aui = useAui();
+  const disabled = useAuiState((s) => {
+    return !(
+      (s.message.role !== "assistant" ||
+        s.message.status?.type !== "running") &&
+      s.message.parts.some((c) => c.type === "text" && c.text.length > 0)
+    );
+  });
+  const isCopied = useAuiState((s) => s.message.isCopied);
+  const isEditing = useAuiState((s) => s.composer.isEditing);
+  const composerValue = useAuiState((s) => s.composer.text);
+
+  const copy = useCallback(() => {
+    const valueToCopy = isEditing ? composerValue : aui.message().getCopyText();
+    if (!valueToCopy) return;
+
+    const write = copyToClipboard ?? (() => {});
+    const result = write(valueToCopy);
+    Promise.resolve(result).then(() => {
+      aui.message().setIsCopied(true);
+      setTimeout(() => aui.message().setIsCopied(false), copiedDuration);
+    });
+  }, [aui, isEditing, composerValue, copiedDuration, copyToClipboard]);
+
+  return { copy, disabled, isCopied };
+};

package/src/react/primitive-hooks/useActionBarEdit.ts

@@ -0,0 +1,13 @@
+import { useCallback } from "react";
+import { useAui, useAuiState } from "@assistant-ui/store";
+
+export const useActionBarEdit = () => {
+  const aui = useAui();
+  const disabled = useAuiState((s) => s.composer.isEditing);
+
+  const edit = useCallback(() => {
+    aui.composer().beginEdit();
+  }, [aui]);
+
+  return { edit, disabled };
+};

package/src/react/primitive-hooks/useActionBarFeedback.ts

@@ -0,0 +1,28 @@
+import { useCallback } from "react";
+import { useAui, useAuiState } from "@assistant-ui/store";
+
+export const useActionBarFeedbackPositive = () => {
+  const aui = useAui();
+  const isSubmitted = useAuiState(
+    (s) => s.message.metadata.submittedFeedback?.type === "positive",
+  );
+
+  const submit = useCallback(() => {
+    aui.message().submitFeedback({ type: "positive" });
+  }, [aui]);
+
+  return { submit, isSubmitted };
+};
+
+export const useActionBarFeedbackNegative = () => {
+  const aui = useAui();
+  const isSubmitted = useAuiState(
+    (s) => s.message.metadata.submittedFeedback?.type === "negative",
+  );
+
+  const submit = useCallback(() => {
+    aui.message().submitFeedback({ type: "negative" });
+  }, [aui]);
+
+  return { submit, isSubmitted };
+};

package/src/react/primitive-hooks/useActionBarReload.ts

@@ -0,0 +1,18 @@
+import { useCallback } from "react";
+import { useAui, useAuiState } from "@assistant-ui/store";
+
+export const useActionBarReload = () => {
+  const aui = useAui();
+  const disabled = useAuiState(
+    (s) =>
+      s.thread.isRunning ||
+      s.thread.isDisabled ||
+      s.message.role !== "assistant",
+  );
+
+  const reload = useCallback(() => {
+    aui.message().reload();
+  }, [aui]);
+
+  return { reload, disabled };
+};

package/src/react/primitive-hooks/useComposerAddAttachment.ts

@@ -0,0 +1,17 @@
+import { useCallback } from "react";
+import { useAui, useAuiState } from "@assistant-ui/store";
+import type { CreateAttachment } from "../../types/attachment";
+
+export const useComposerAddAttachment = () => {
+  const aui = useAui();
+  const disabled = useAuiState((s) => !s.composer.isEditing);
+
+  const addAttachment = useCallback(
+    (file: File | CreateAttachment) => {
+      return aui.composer().addAttachment(file);
+    },
+    [aui],
+  );
+
+  return { addAttachment, disabled };
+};

package/src/react/primitive-hooks/useComposerCancel.ts

@@ -0,0 +1,13 @@
+import { useCallback } from "react";
+import { useAui, useAuiState } from "@assistant-ui/store";
+
+export const useComposerCancel = () => {
+  const aui = useAui();
+  const disabled = useAuiState((s) => !s.composer.canCancel);
+
+  const cancel = useCallback(() => {
+    aui.composer().cancel();
+  }, [aui]);
+
+  return { cancel, disabled };
+};

package/src/react/primitive-hooks/useComposerSend.ts

@@ -0,0 +1,15 @@
+import { useCallback } from "react";
+import { useAui, useAuiState } from "@assistant-ui/store";
+
+export const useComposerSend = () => {
+  const aui = useAui();
+  const disabled = useAuiState(
+    (s) => s.thread.isRunning || !s.composer.isEditing || s.composer.isEmpty,
+  );
+
+  const send = useCallback(() => {
+    aui.composer().send();
+  }, [aui]);
+
+  return { send, disabled };
+};

package/src/react/primitive-hooks/useEditComposerCancel.ts

@@ -0,0 +1,12 @@
+import { useCallback } from "react";
+import { useAui } from "@assistant-ui/store";
+
+export const useEditComposerCancel = () => {
+  const aui = useAui();
+
+  const cancel = useCallback(() => {
+    aui.composer().cancel();
+  }, [aui]);
+
+  return { cancel };
+};

package/src/react/primitive-hooks/useEditComposerSend.ts

@@ -0,0 +1,13 @@
+import { useCallback } from "react";
+import { useAui, useAuiState } from "@assistant-ui/store";
+
+export const useEditComposerSend = () => {
+  const aui = useAui();
+  const disabled = useAuiState((s) => s.composer.isEmpty);
+
+  const send = useCallback(() => {
+    aui.composer().send();
+  }, [aui]);
+
+  return { send, disabled };
+};

package/src/react/primitive-hooks/useMessageBranching.ts

@@ -0,0 +1,18 @@
+import { useCallback } from "react";
+import { useAui, useAuiState } from "@assistant-ui/store";
+
+export const useMessageBranching = () => {
+  const aui = useAui();
+  const branchNumber = useAuiState((s) => s.message.branchNumber);
+  const branchCount = useAuiState((s) => s.message.branchCount);
+
+  const goToPrev = useCallback(() => {
+    aui.message().switchToBranch({ position: "previous" });
+  }, [aui]);
+
+  const goToNext = useCallback(() => {
+    aui.message().switchToBranch({ position: "next" });
+  }, [aui]);
+
+  return { branchNumber, branchCount, goToPrev, goToNext };
+};

package/src/react/primitive-hooks/useMessageReload.ts

@@ -0,0 +1,13 @@
+import { useCallback } from "react";
+import { useAui, useAuiState } from "@assistant-ui/store";
+
+export const useMessageReload = () => {
+  const aui = useAui();
+  const canReload = useAuiState((s) => s.message.role === "assistant");
+
+  const reload = useCallback(() => {
+    aui.message().reload();
+  }, [aui]);
+
+  return { reload, canReload };
+};

package/src/react/primitive-hooks/useThreadIsEmpty.ts

@@ -0,0 +1,5 @@
+import { useAuiState } from "@assistant-ui/store";
+
+export const useThreadIsEmpty = (): boolean => {
+  return useAuiState((s) => s.thread.isEmpty);
+};

package/src/react/primitive-hooks/useThreadIsRunning.ts

@@ -0,0 +1,5 @@
+import { useAuiState } from "@assistant-ui/store";
+
+export const useThreadIsRunning = (): boolean => {
+  return useAuiState((s) => s.thread.isRunning);
+};

package/src/react/primitive-hooks/useThreadMessages.ts

@@ -0,0 +1,6 @@
+import { useAuiState } from "@assistant-ui/store";
+import type { MessageState } from "../../store/scopes/message";
+
+export const useThreadMessages = (): readonly MessageState[] => {
+  return useAuiState((s) => s.thread.messages);
+};

package/src/react/runtimes/cloud/useCloudThreadListAdapter.tsx

@@ -26,7 +26,9 @@ type CloudThreadListAdapterOptions = {
   delete?: ((threadId: string) => Promise<void>) | undefined;
 };
 
-const baseUrl = process?.env?.["NEXT_PUBLIC_ASSISTANT_BASE_URL"];
+const baseUrl =
+  typeof process !== "undefined" &&
+  process?.env?.["NEXT_PUBLIC_ASSISTANT_BASE_URL"];
 const autoCloud = baseUrl
   ? new AssistantCloud({ baseUrl, anonymous: true })
   : undefined;

package/src/react/runtimes/index.ts

@@ -28,3 +28,9 @@ export {
   useAssistantCloudThreadHistoryAdapter,
   CloudFileAttachmentAdapter,
 } from "./cloud";
+
+export {
+  useLocalRuntime,
+  splitLocalRuntimeOptions,
+  type LocalRuntimeOptions,
+} from "./useLocalRuntime";

package/src/react/runtimes/useLocalRuntime.ts

@@ -0,0 +1,101 @@
+import { useEffect, useMemo, useRef, useState } from "react";
+import type {
+  AssistantRuntime,
+  ChatModelAdapter,
+  ThreadMessageLike,
+} from "../../index";
+import type { LocalRuntimeOptionsBase } from "../../runtimes/local/local-runtime-options";
+import { AssistantRuntimeImpl, LocalRuntimeCore } from "../../internal";
+import { useAuiState } from "@assistant-ui/store";
+import { useRemoteThreadListRuntime } from "./useRemoteThreadListRuntime";
+import { useCloudThreadListAdapter } from "./cloud";
+import { useRuntimeAdapters } from "./RuntimeAdapterProvider";
+import type { AssistantCloud } from "assistant-cloud";
+
+export type LocalRuntimeOptions = Omit<LocalRuntimeOptionsBase, "adapters"> & {
+  cloud?: AssistantCloud | undefined;
+  initialMessages?: readonly ThreadMessageLike[] | undefined;
+  adapters?: Omit<LocalRuntimeOptionsBase["adapters"], "chatModel"> | undefined;
+};
+
+const useLocalThreadRuntime = (
+  chatModel: ChatModelAdapter,
+  { initialMessages, ...options }: LocalRuntimeOptions,
+): AssistantRuntime => {
+  const { modelContext, ...threadListAdapters } = useRuntimeAdapters() ?? {};
+  const opt = {
+    ...options,
+    adapters: {
+      ...threadListAdapters,
+      ...options.adapters,
+      chatModel,
+    },
+  };
+
+  const [runtime] = useState(() => new LocalRuntimeCore(opt, initialMessages));
+
+  const threadIdRef = useRef<string | undefined>(undefined);
+  threadIdRef.current = useAuiState((s) => s.threadListItem.remoteId);
+
+  useEffect(() => {
+    runtime.threads
+      .getMainThreadRuntimeCore()
+      .__internal_setGetThreadId(() => threadIdRef.current);
+  }, [runtime]);
+
+  useEffect(() => {
+    return () => {
+      runtime.threads.getMainThreadRuntimeCore().detach();
+    };
+  }, [runtime]);
+
+  useEffect(() => {
+    runtime.threads.getMainThreadRuntimeCore().__internal_setOptions(opt);
+    runtime.threads.getMainThreadRuntimeCore().__internal_load();
+  });
+
+  useEffect(() => {
+    if (!modelContext) return undefined;
+    return runtime.registerModelContextProvider(modelContext);
+  }, [modelContext, runtime]);
+
+  return useMemo(() => new AssistantRuntimeImpl(runtime), [runtime]);
+};
+
+export const splitLocalRuntimeOptions = <T extends LocalRuntimeOptions>(
+  options: T,
+) => {
+  const {
+    cloud,
+    initialMessages,
+    maxSteps,
+    adapters,
+    unstable_humanToolNames,
+    ...rest
+  } = options;
+
+  return {
+    localRuntimeOptions: {
+      cloud,
+      initialMessages,
+      maxSteps,
+      adapters,
+      unstable_humanToolNames,
+    },
+    otherOptions: rest,
+  };
+};
+
+export const useLocalRuntime = (
+  chatModel: ChatModelAdapter,
+  { cloud, ...options }: LocalRuntimeOptions = {},
+): AssistantRuntime => {
+  const cloudAdapter = useCloudThreadListAdapter({ cloud });
+  return useRemoteThreadListRuntime({
+    runtimeHook: function RuntimeHook() {
+      return useLocalThreadRuntime(chatModel, options);
+    },
+    adapter: cloudAdapter,
+    allowNesting: true,
+  });
+};

package/src/tests/no-unsafe-process-env.test.ts

@@ -0,0 +1,58 @@
+import { describe, expect, it } from "vitest";
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import { resolve, relative, join } from "node:path";
+
+const SRC_DIR = resolve(__dirname, "..");
+
+function findFiles(dir: string, ext: string[]): string[] {
+  const results: string[] = [];
+  for (const entry of readdirSync(dir)) {
+    const full = join(dir, entry);
+    if (statSync(full).isDirectory()) {
+      results.push(...findFiles(full, ext));
+    } else if (ext.some((e) => full.endsWith(e))) {
+      results.push(full);
+    }
+  }
+  return results;
+}
+
+describe("no unsafe process.env access", () => {
+  it("all process.env access for non-NODE_ENV vars must have a typeof process guard", () => {
+    const files = findFiles(SRC_DIR, [".ts", ".tsx"]).filter(
+      (f) => !f.includes("/tests/") && !f.includes(".test."),
+    );
+
+    const violations: string[] = [];
+
+    for (const file of files) {
+      const content = readFileSync(file, "utf-8");
+
+      // Check if file has process.env access beyond NODE_ENV
+      // Match process.env, process?.env, process.env?, process?.env?
+      const hasNonNodeEnvProcessAccess =
+        /process\??\.env\??(?!\.NODE_ENV\b)/.test(
+          content.replace(/process\??\.env\??\.NODE_ENV/g, ""),
+        );
+
+      if (!hasNonNodeEnvProcessAccess) continue;
+
+      // File accesses process.env for non-NODE_ENV vars — must have typeof guard
+      const hasTypeofGuard = /typeof process\s*!==\s*["']undefined["']/.test(
+        content,
+      );
+
+      if (!hasTypeofGuard) {
+        violations.push(relative(SRC_DIR, file));
+      }
+    }
+
+    expect(
+      violations,
+      `These files access process.env (non-NODE_ENV) without a typeof process !== "undefined" guard.\n` +
+        `@assistant-ui/core lacks @types/node, so bare process.env access crashes in Vite and other bundlers.\n` +
+        `Add: typeof process !== "undefined" ? process.env?.["VAR_NAME"] : undefined\n\n` +
+        `Files:\n${violations.map((f) => `  - ${f}`).join("\n")}`,
+    ).toEqual([]);
+  });
+});