@assistant-ui/react-ink 0.0.1

package/src/context/providers/RuntimeAdapterProvider.tsx

@@ -0,0 +1,42 @@
+import { createContext, FC, ReactNode, useContext } from "react";
+import type {
+  ThreadHistoryAdapter,
+  AttachmentAdapter,
+  ModelContextProvider,
+} from "@assistant-ui/core";
+
+export type RuntimeAdapters = {
+  modelContext?: ModelContextProvider | undefined;
+  history?: ThreadHistoryAdapter | undefined;
+  attachments?: AttachmentAdapter | undefined;
+};
+
+const RuntimeAdaptersContext = createContext<RuntimeAdapters | null>(null);
+
+export namespace RuntimeAdapterProvider {
+  export type Props = {
+    adapters: RuntimeAdapters;
+    children: ReactNode;
+  };
+}
+
+export const RuntimeAdapterProvider: FC<RuntimeAdapterProvider.Props> = ({
+  adapters,
+  children,
+}) => {
+  const context = useContext(RuntimeAdaptersContext);
+  return (
+    <RuntimeAdaptersContext.Provider
+      value={{
+        ...context,
+        ...adapters,
+      }}
+    >
+      {children}
+    </RuntimeAdaptersContext.Provider>
+  );
+};
+
+export const useRuntimeAdapters = () => {
+  return useContext(RuntimeAdaptersContext);
+};

package/src/context/providers/ThreadListItemRuntimeProvider.tsx

@@ -0,0 +1 @@
+export { ThreadListItemRuntimeProvider } from "@assistant-ui/core/react";

package/src/index.ts

@@ -0,0 +1,157 @@
+import "@assistant-ui/core/react"; // store-augmentation side-effect (tools, dataRenderers scopes)
+
+// Re-export core types
+export type {
+  // Message types
+  ThreadMessage,
+  ThreadUserMessage,
+  ThreadAssistantMessage,
+  ThreadSystemMessage,
+  MessageStatus,
+  MessageRole,
+  ThreadMessageLike,
+  AppendMessage,
+  RunConfig,
+  // Message parts
+  TextMessagePart,
+  ReasoningMessagePart,
+  SourceMessagePart,
+  ToolCallMessagePart,
+  ImageMessagePart,
+  FileMessagePart,
+  DataMessagePart,
+  Unstable_AudioMessagePart,
+  ThreadUserMessagePart,
+  ThreadAssistantMessagePart,
+  // Runtime types
+  AssistantRuntime,
+  ThreadRuntime,
+  MessageRuntime,
+  ThreadComposerRuntime,
+  EditComposerRuntime,
+  ComposerRuntime,
+  ThreadListRuntime,
+  ThreadListItemRuntime,
+  // Runtime core types
+  ChatModelAdapter,
+  ChatModelRunOptions,
+  ChatModelRunResult,
+  RuntimeCapabilities,
+  // Attachment types
+  Attachment,
+  PendingAttachment,
+  CreateAttachment,
+  AttachmentRuntime,
+  // Adapter types
+  AttachmentAdapter,
+  ThreadHistoryAdapter,
+  FeedbackAdapter,
+  SuggestionAdapter,
+  // Other
+  Unsubscribe,
+} from "@assistant-ui/core";
+
+// Re-export core remote thread list types
+export type {
+  RemoteThreadListAdapter,
+  RemoteThreadListOptions,
+} from "@assistant-ui/core";
+export { InMemoryThreadListAdapter } from "@assistant-ui/core";
+
+// Attachment adapter implementations
+export {
+  SimpleImageAttachmentAdapter,
+  SimpleTextAttachmentAdapter,
+  CompositeAttachmentAdapter,
+} from "@assistant-ui/core";
+
+// Re-export store scope state types
+export type {
+  ThreadState,
+  ThreadsState,
+  MessageState,
+  ComposerState,
+  AttachmentState,
+  ThreadListItemState,
+} from "@assistant-ui/core/store";
+
+// Store hooks and components
+export {
+  useAui,
+  useAuiState,
+  useAuiEvent,
+  AuiProvider,
+  AuiIf,
+  type AssistantClient,
+  type AssistantState,
+  type AssistantEventScope,
+  type AssistantEventSelector,
+  type AssistantEventName,
+  type AssistantEventPayload,
+  type AssistantEventCallback,
+} from "@assistant-ui/store";
+
+// Context providers and hooks
+export { AssistantProvider, useAssistantRuntime } from "./context";
+
+// Primitive hooks
+export {
+  useThreadMessages,
+  useThreadIsRunning,
+  useThreadIsEmpty,
+  useComposerSend,
+  useComposerCancel,
+  useMessageReload,
+  useMessageBranching,
+  useActionBarCopy,
+  type UseActionBarCopyOptions,
+  useActionBarEdit,
+  useActionBarReload,
+  useActionBarFeedbackPositive,
+  useActionBarFeedbackNegative,
+  useEditComposerSend,
+  useEditComposerCancel,
+  useComposerAddAttachment,
+} from "./primitive-hooks";
+
+// Runtime
+export {
+  useLocalRuntime,
+  type LocalRuntimeOptions,
+  useRemoteThreadListRuntime,
+} from "./runtimes";
+
+// Primitives
+export * from "./primitives/thread";
+export * from "./primitives/composer";
+export * from "./primitives/message";
+export * from "./primitives/threadList";
+export * from "./primitives/actionBar";
+export * from "./primitives/branchPicker";
+export * from "./primitives/attachment";
+export * from "./primitives/threadListItem";
+export * from "./primitives/chainOfThought";
+export * from "./primitives/suggestion";
+
+// Re-export shared providers from core/react
+export {
+  ThreadListItemByIndexProvider,
+  ChainOfThoughtByIndicesProvider,
+  MessageByIndexProvider,
+  PartByIndexProvider,
+  TextMessagePartProvider,
+  ChainOfThoughtPartByIndexProvider,
+  SuggestionByIndexProvider,
+} from "@assistant-ui/core/react";
+
+// Model context, tools & clients
+export * from "./model-context";
+export * from "./client";
+export * from "./types";
+
+// Adapters
+export {
+  type TitleGenerationAdapter,
+  createSimpleTitleAdapter,
+  createLocalStorageAdapter,
+} from "./adapters";

package/src/internal.ts

@@ -0,0 +1,22 @@
+// Re-export from @assistant-ui/core
+export type {
+  ThreadRuntimeCore,
+  ThreadListRuntimeCore,
+} from "@assistant-ui/core";
+
+// Re-export from @assistant-ui/core/internal
+export {
+  DefaultThreadComposerRuntimeCore,
+  CompositeContextProvider,
+  MessageRepository,
+  BaseAssistantRuntimeCore,
+  generateId,
+  AssistantRuntimeImpl,
+  ThreadRuntimeImpl,
+  fromThreadMessageLike,
+  getAutoStatus,
+} from "@assistant-ui/core/internal";
+export type {
+  ThreadRuntimeCoreBinding,
+  ThreadListItemRuntimeBinding,
+} from "@assistant-ui/core/internal";

package/src/model-context/index.ts

@@ -0,0 +1,44 @@
+// Re-export shared from core/react
+export {
+  makeAssistantTool,
+  type AssistantTool,
+  makeAssistantToolUI,
+  type AssistantToolUI,
+  makeAssistantDataUI,
+  type AssistantDataUI,
+  useAssistantTool,
+  type AssistantToolProps,
+  useAssistantToolUI,
+  type AssistantToolUIProps,
+  useAssistantDataUI,
+  type AssistantDataUIProps,
+  useAssistantInstructions,
+  useInlineRender,
+  type Toolkit,
+  type ToolDefinition,
+  Tools,
+  DataRenderers,
+} from "@assistant-ui/core/react";
+
+// Core pass-through (unchanged)
+export type {
+  ModelContext,
+  ModelContextProvider,
+  LanguageModelConfig,
+  LanguageModelV1CallSettings,
+} from "@assistant-ui/core";
+
+export { mergeModelContexts } from "@assistant-ui/core";
+
+export type { Tool } from "assistant-stream";
+
+export { tool } from "@assistant-ui/core";
+
+export { Suggestions, type SuggestionConfig } from "@assistant-ui/core/store";
+
+export { ModelContextRegistry } from "@assistant-ui/core";
+export type {
+  ModelContextRegistryToolHandle,
+  ModelContextRegistryInstructionHandle,
+  ModelContextRegistryProviderHandle,
+} from "@assistant-ui/core";

package/src/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 { useEditComposerSend } from "./useEditComposerSend";
+export { useEditComposerCancel } from "./useEditComposerCancel";
+export { useComposerAddAttachment } from "./useComposerAddAttachment";

package/src/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/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/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/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/primitive-hooks/useComposerAddAttachment.ts

@@ -0,0 +1,16 @@
+import { useCallback } from "react";
+import { useAui } from "@assistant-ui/store";
+import type { CreateAttachment } from "@assistant-ui/core";
+
+export const useComposerAddAttachment = () => {
+  const aui = useAui();
+
+  const addAttachment = useCallback(
+    (file: File | CreateAttachment) => {
+      return aui.composer().addAttachment(file);
+    },
+    [aui],
+  );
+
+  return { addAttachment };
+};

package/src/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 canCancel = useAuiState((s) => s.thread.isRunning);
+
+  const cancel = useCallback(() => {
+    aui.threads().thread("main").cancelRun();
+  }, [aui]);
+
+  return { cancel, canCancel };
+};

package/src/primitive-hooks/useComposerSend.ts

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

package/src/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/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/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/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/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/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/primitive-hooks/useThreadMessages.ts

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

package/src/primitives/actionBar/ActionBarCopy.tsx

@@ -0,0 +1,34 @@
+import type { ReactNode } from "react";
+import {
+  useActionBarCopy,
+  type UseActionBarCopyOptions,
+} from "../../primitive-hooks/useActionBarCopy";
+import { Pressable, type PressableProps } from "../internal/Pressable";
+
+export type ActionBarCopyProps = Omit<PressableProps, "onPress" | "children"> &
+  UseActionBarCopyOptions & {
+    children: ReactNode | ((props: { isCopied: boolean }) => ReactNode);
+  };
+
+export const ActionBarCopy = ({
+  children,
+  disabled: disabledProp,
+  copiedDuration,
+  copyToClipboard,
+  ...pressableProps
+}: ActionBarCopyProps) => {
+  const { copy, disabled, isCopied } = useActionBarCopy({
+    copiedDuration,
+    copyToClipboard,
+  });
+
+  return (
+    <Pressable
+      onPress={copy}
+      disabled={disabledProp ?? disabled}
+      {...pressableProps}
+    >
+      {typeof children === "function" ? children({ isCopied }) : children}
+    </Pressable>
+  );
+};

package/src/primitives/actionBar/ActionBarEdit.tsx

@@ -0,0 +1,25 @@
+import type { ReactNode } from "react";
+import { useActionBarEdit } from "../../primitive-hooks/useActionBarEdit";
+import { Pressable, type PressableProps } from "../internal/Pressable";
+
+export type ActionBarEditProps = Omit<PressableProps, "onPress"> & {
+  children: ReactNode;
+};
+
+export const ActionBarEdit = ({
+  children,
+  disabled: disabledProp,
+  ...pressableProps
+}: ActionBarEditProps) => {
+  const { edit, disabled } = useActionBarEdit();
+
+  return (
+    <Pressable
+      onPress={edit}
+      disabled={disabledProp ?? disabled}
+      {...pressableProps}
+    >
+      {children}
+    </Pressable>
+  );
+};

package/src/primitives/actionBar/ActionBarFeedbackNegative.tsx

@@ -0,0 +1,23 @@
+import type { ReactNode } from "react";
+import { useActionBarFeedbackNegative } from "../../primitive-hooks/useActionBarFeedback";
+import { Pressable, type PressableProps } from "../internal/Pressable";
+
+export type ActionBarFeedbackNegativeProps = Omit<
+  PressableProps,
+  "onPress" | "children"
+> & {
+  children: ReactNode | ((props: { isSubmitted: boolean }) => ReactNode);
+};
+
+export const ActionBarFeedbackNegative = ({
+  children,
+  ...pressableProps
+}: ActionBarFeedbackNegativeProps) => {
+  const { submit, isSubmitted } = useActionBarFeedbackNegative();
+
+  return (
+    <Pressable onPress={submit} {...pressableProps}>
+      {typeof children === "function" ? children({ isSubmitted }) : children}
+    </Pressable>
+  );
+};

package/src/primitives/actionBar/ActionBarFeedbackPositive.tsx

@@ -0,0 +1,23 @@
+import type { ReactNode } from "react";
+import { useActionBarFeedbackPositive } from "../../primitive-hooks/useActionBarFeedback";
+import { Pressable, type PressableProps } from "../internal/Pressable";
+
+export type ActionBarFeedbackPositiveProps = Omit<
+  PressableProps,
+  "onPress" | "children"
+> & {
+  children: ReactNode | ((props: { isSubmitted: boolean }) => ReactNode);
+};
+
+export const ActionBarFeedbackPositive = ({
+  children,
+  ...pressableProps
+}: ActionBarFeedbackPositiveProps) => {
+  const { submit, isSubmitted } = useActionBarFeedbackPositive();
+
+  return (
+    <Pressable onPress={submit} {...pressableProps}>
+      {typeof children === "function" ? children({ isSubmitted }) : children}
+    </Pressable>
+  );
+};

package/src/primitives/actionBar/ActionBarReload.tsx

@@ -0,0 +1,25 @@
+import type { ReactNode } from "react";
+import { useActionBarReload } from "../../primitive-hooks/useActionBarReload";
+import { Pressable, type PressableProps } from "../internal/Pressable";
+
+export type ActionBarReloadProps = Omit<PressableProps, "onPress"> & {
+  children: ReactNode;
+};
+
+export const ActionBarReload = ({
+  children,
+  disabled: disabledProp,
+  ...pressableProps
+}: ActionBarReloadProps) => {
+  const { reload, disabled } = useActionBarReload();
+
+  return (
+    <Pressable
+      onPress={reload}
+      disabled={disabledProp ?? disabled}
+      {...pressableProps}
+    >
+      {children}
+    </Pressable>
+  );
+};

package/src/primitives/actionBar/index.ts

@@ -0,0 +1,11 @@
+export { ActionBarCopy, type ActionBarCopyProps } from "./ActionBarCopy";
+export { ActionBarEdit, type ActionBarEditProps } from "./ActionBarEdit";
+export { ActionBarReload, type ActionBarReloadProps } from "./ActionBarReload";
+export {
+  ActionBarFeedbackPositive,
+  type ActionBarFeedbackPositiveProps,
+} from "./ActionBarFeedbackPositive";
+export {
+  ActionBarFeedbackNegative,
+  type ActionBarFeedbackNegativeProps,
+} from "./ActionBarFeedbackNegative";