@assistant-ui/react 0.11.57 → 0.12.0

package/src/primitives/threadList/ThreadListNew.tsx

@@ -7,7 +7,7 @@ import {
 import { forwardRef } from "react";
 import { Primitive } from "@radix-ui/react-primitive";
 import { composeEventHandlers } from "@radix-ui/primitive";
-import { useAssistantState, useAssistantApi } from "../../context";
+import { useAuiState, useAui } from "@assistant-ui/store";
 
 export namespace ThreadListPrimitiveNew {
   export type Element = ActionButtonElement;
@@ -18,11 +18,11 @@ export const ThreadListPrimitiveNew = forwardRef<
   ThreadListPrimitiveNew.Element,
   ThreadListPrimitiveNew.Props
 >(({ onClick, disabled, ...props }, forwardedRef) => {
-  const isMain = useAssistantState(
+  const isMain = useAuiState(
     ({ threads }) => threads.newThreadId === threads.mainThreadId,
   );
 
-  const api = useAssistantApi();
+  const aui = useAui();
 
   return (
     <Primitive.button
@@ -32,7 +32,7 @@ export const ThreadListPrimitiveNew = forwardRef<
       ref={forwardedRef}
       disabled={disabled}
       onClick={composeEventHandlers(onClick, () => {
-        api.threads().switchToNewThread();
+        aui.threads().switchToNewThread();
       })}
     />
   );

package/src/primitives/threadListItem/ThreadListItemArchive.ts

@@ -5,14 +5,14 @@ import {
   ActionButtonProps,
   createActionButton,
 } from "../../utils/createActionButton";
-import { useAssistantApi } from "../../context";
+import { useAui } from "@assistant-ui/store";
 import { useCallback } from "react";
 
 const useThreadListItemArchive = () => {
-  const api = useAssistantApi();
+  const aui = useAui();
   return useCallback(() => {
-    api.threadListItem().archive();
-  }, [api]);
+    aui.threadListItem().archive();
+  }, [aui]);
 };
 
 export namespace ThreadListItemPrimitiveArchive {

package/src/primitives/threadListItem/ThreadListItemDelete.ts

@@ -5,14 +5,14 @@ import {
   ActionButtonProps,
   createActionButton,
 } from "../../utils/createActionButton";
-import { useAssistantApi } from "../../context";
+import { useAui } from "@assistant-ui/store";
 import { useCallback } from "react";
 
 const useThreadListItemDelete = () => {
-  const api = useAssistantApi();
+  const aui = useAui();
   return useCallback(() => {
-    api.threadListItem().delete();
-  }, [api]);
+    aui.threadListItem().delete();
+  }, [aui]);
 };
 
 export namespace ThreadListItemPrimitiveDelete {

package/src/primitives/threadListItem/ThreadListItemRoot.tsx

@@ -2,7 +2,7 @@
 
 import { Primitive } from "@radix-ui/react-primitive";
 import { type ComponentRef, forwardRef, ComponentPropsWithoutRef } from "react";
-import { useAssistantState } from "../../context";
+import { useAuiState } from "@assistant-ui/store";
 
 type PrimitiveDivProps = ComponentPropsWithoutRef<typeof Primitive.div>;
 
@@ -15,7 +15,7 @@ export const ThreadListItemPrimitiveRoot = forwardRef<
   ThreadListItemPrimitiveRoot.Element,
   ThreadListItemPrimitiveRoot.Props
 >((props, ref) => {
-  const isMain = useAssistantState(
+  const isMain = useAuiState(
     ({ threads, threadListItem }) => threads.mainThreadId === threadListItem.id,
   );
 

package/src/primitives/threadListItem/ThreadListItemTitle.tsx

@@ -1,7 +1,7 @@
 "use client";
 
 import type { FC, ReactNode } from "react";
-import { useAssistantState } from "../../context";
+import { useAuiState } from "@assistant-ui/store";
 
 export namespace ThreadListItemPrimitiveTitle {
   export type Props = {
@@ -12,7 +12,7 @@ export namespace ThreadListItemPrimitiveTitle {
 export const ThreadListItemPrimitiveTitle: FC<
   ThreadListItemPrimitiveTitle.Props
 > = ({ fallback }) => {
-  const title = useAssistantState(({ threadListItem }) => threadListItem.title);
+  const title = useAuiState(({ threadListItem }) => threadListItem.title);
   return <>{title || fallback}</>;
 };
 

package/src/primitives/threadListItem/ThreadListItemTrigger.ts

@@ -5,14 +5,14 @@ import {
   ActionButtonProps,
   createActionButton,
 } from "../../utils/createActionButton";
-import { useAssistantApi } from "../../context";
+import { useAui } from "@assistant-ui/store";
 import { useCallback } from "react";
 
 const useThreadListItemTrigger = () => {
-  const api = useAssistantApi();
+  const aui = useAui();
   return useCallback(() => {
-    api.threadListItem().switchTo();
-  }, [api]);
+    aui.threadListItem().switchTo();
+  }, [aui]);
 };
 
 export namespace ThreadListItemPrimitiveTrigger {

package/src/primitives/threadListItem/ThreadListItemUnarchive.ts

@@ -5,14 +5,14 @@ import {
   ActionButtonProps,
   createActionButton,
 } from "../../utils/createActionButton";
-import { useAssistantApi } from "../../context";
+import { useAui } from "@assistant-ui/store";
 import { useCallback } from "react";
 
 const useThreadListItemUnarchive = () => {
-  const api = useAssistantApi();
+  const aui = useAui();
   return useCallback(() => {
-    api.threadListItem().unarchive();
-  }, [api]);
+    aui.threadListItem().unarchive();
+  }, [aui]);
 };
 
 export namespace ThreadListItemPrimitiveUnarchive {

package/src/types/index.ts

@@ -52,11 +52,3 @@ export type {
 export type { ThreadListItemStatus } from "../legacy-runtime/runtime/ThreadListItemRuntime";
 
 export type { Unsubscribe } from "./Unsubscribe";
-
-export type {
-  AssistantEventScope,
-  AssistantEventSelector,
-  AssistantEvent,
-  AssistantEventMap,
-  AssistantEventCallback,
-} from "./EventTypes";

package/src/types/scopes/attachment.ts

@@ -0,0 +1,22 @@
+import type { Attachment } from "../AttachmentTypes";
+import type { AttachmentRuntime } from "../../legacy-runtime/runtime";
+
+export type AttachmentState = Attachment;
+
+export type AttachmentMethods = {
+  getState(): AttachmentState;
+  remove(): Promise<void>;
+  /** @internal */
+  __internal_getRuntime?(): AttachmentRuntime;
+};
+
+export type AttachmentMeta = {
+  source: "message" | "composer";
+  query: { type: "index"; index: number } | { type: "id"; id: string };
+};
+
+export type AttachmentClientSchema = {
+  state: AttachmentState;
+  methods: AttachmentMethods;
+  meta: AttachmentMeta;
+};

package/src/{client/types/Composer.ts → types/scopes/composer.ts}

@@ -1,10 +1,10 @@
+import type { Attachment } from "../AttachmentTypes";
+import type { MessageRole, RunConfig } from "../AssistantTypes";
 import type { ComposerRuntime } from "../../legacy-runtime/runtime";
-import type { DictationState } from "../../legacy-runtime/runtime-cores/core/ComposerRuntimeCore";
-import type { Attachment } from "../../types";
-import type { MessageRole, RunConfig } from "../../types/AssistantTypes";
-import type { AttachmentClientApi } from "./Attachment";
+import type { AttachmentMethods } from "./attachment";
+import { DictationState } from "../../legacy-runtime/runtime-cores";
 
-export type ComposerClientState = {
+export type ComposerState = {
   readonly text: string;
   readonly role: MessageRole;
   readonly attachments: readonly Attachment[];
@@ -14,6 +14,7 @@ export type ComposerClientState = {
   readonly attachmentAccept: string;
   readonly isEmpty: boolean;
   readonly type: "thread" | "edit";
+
   /**
    * The current state of dictation.
    * Undefined when dictation is not active.
@@ -21,15 +22,14 @@ export type ComposerClientState = {
   readonly dictation: DictationState | undefined;
 };
 
-export type ComposerClientApi = {
-  getState(): ComposerClientState;
-
+export type ComposerMethods = {
+  getState(): ComposerState;
   setText(text: string): void;
   setRole(role: MessageRole): void;
   setRunConfig(runConfig: RunConfig): void;
   addAttachment(file: File): Promise<void>;
   clearAttachments(): Promise<void>;
-  attachment(selector: { index: number } | { id: string }): AttachmentClientApi;
+  attachment(selector: { index: number } | { id: string }): AttachmentMethods;
   reset(): Promise<void>;
   send(): void;
   cancel(): void;
@@ -49,3 +49,20 @@ export type ComposerClientApi = {
   /** @internal */
   __internal_getRuntime?(): ComposerRuntime;
 };
+
+export type ComposerMeta = {
+  source: "thread" | "message";
+  query: Record<string, never>;
+};
+
+export type ComposerEvents = {
+  "composer.send": { threadId: string; messageId?: string };
+  "composer.attachmentAdd": { threadId: string; messageId?: string };
+};
+
+export type ComposerClientSchema = {
+  state: ComposerState;
+  methods: ComposerMethods;
+  meta: ComposerMeta;
+  events: ComposerEvents;
+};

package/src/types/scopes/index.ts

@@ -0,0 +1,50 @@
+export type {
+  ThreadsState,
+  ThreadsMethods,
+  ThreadsClientSchema,
+} from "./threads";
+export type {
+  ThreadListItemState,
+  ThreadListItemMethods,
+  ThreadListItemMeta,
+  ThreadListItemEvents,
+  ThreadListItemClientSchema,
+} from "./threadListItem";
+export type {
+  ThreadState,
+  ThreadMethods,
+  ThreadMeta,
+  ThreadEvents,
+  ThreadClientSchema,
+} from "./thread";
+export type {
+  MessageState,
+  MessageMethods,
+  MessageMeta,
+  MessageClientSchema,
+} from "./message";
+export type {
+  PartState,
+  PartMethods,
+  PartMeta,
+  PartClientSchema,
+} from "./part";
+export type {
+  ComposerState,
+  ComposerMethods,
+  ComposerMeta,
+  ComposerEvents,
+  ComposerClientSchema,
+} from "./composer";
+export type {
+  AttachmentState,
+  AttachmentMethods,
+  AttachmentMeta,
+  AttachmentClientSchema,
+} from "./attachment";
+export type { ToolsState, ToolsMethods, ToolsClientSchema } from "./tools";
+export type {
+  ModelContextState,
+  ModelContextMethods,
+  ModelContextClientSchema,
+} from "./modelContext";

package/src/{client/types/Message.ts → types/scopes/message.ts}

@@ -1,23 +1,21 @@
-import { ComposerClientState, ComposerClientApi } from "./Composer";
-import { MessagePartClientApi, MessagePartClientState } from "./Part";
-import { MessageRuntime } from "../../legacy-runtime/runtime";
-import {
+import type { ThreadMessage } from "../AssistantTypes";
+import type {
   SpeechState,
   SubmittedFeedback,
 } from "../../legacy-runtime/runtime-cores/core/ThreadRuntimeCore";
-import { ThreadMessage } from "../../types";
-import { RunConfig } from "../../types/AssistantTypes";
-import { AttachmentClientApi } from "./Attachment";
+import type { RunConfig } from "../AssistantTypes";
+import type { MessageRuntime } from "../../legacy-runtime/runtime";
+import type { ComposerMethods, ComposerState } from "./composer";
+import type { PartMethods, PartState } from "./part";
+import type { AttachmentMethods } from "./attachment";
 
-export type MessageClientState = ThreadMessage & {
+export type MessageState = ThreadMessage & {
   readonly parentId: string | null;
   readonly isLast: boolean;
-
   readonly branchNumber: number;
   readonly branchCount: number;
-
   /**
-   * @deprecated The `speech` property is deprecated and will be removed in a future version.
+   * @deprecated This API is still under active development and might change without notice.
    *
    * To enable text-to-speech, provide a `SpeechSynthesisAdapter` to the runtime.
    *
@@ -31,40 +29,28 @@ export type MessageClientState = ThreadMessage & {
    *     speech: new WebSpeechSynthesisAdapter(),
    *   },
    * });
-   * ```
    */
   readonly speech: SpeechState | undefined;
-  /**
-   * @deprecated Use `message.metadata.submittedFeedback` instead. This will be removed in 0.12.0.
-   */
+  /** @deprecated Use `message.metadata.submittedFeedback` instead. This will be removed in 0.12.0. */
   readonly submittedFeedback: SubmittedFeedback | undefined;
-
-  readonly composer: ComposerClientState;
-  readonly parts: readonly MessagePartClientState[];
-
+  readonly composer: ComposerState;
+  readonly parts: readonly PartState[];
   readonly isCopied: boolean;
   readonly isHovering: boolean;
-
   /** The position of this message in the thread (0 for first message) */
   readonly index: number;
 };
 
-export type MessageClientApi = {
+export type MessageMethods = {
   /**
    * Get the current state of the message.
    */
-  getState(): MessageClientState;
-
-  readonly composer: ComposerClientApi;
-
+  getState(): MessageState;
+  composer: ComposerMethods;
   reload(config?: { runConfig?: RunConfig }): void;
-  /**
-   * @deprecated The `speak()` method is deprecated. Use the `ActionBarPrimitive.Speak` component instead.
-   */
+  /** @deprecated This API is still under active development and might change without notice. */
   speak(): void;
-  /**
-   * @deprecated The `stopSpeaking()` method is deprecated. Use the `ActionBarPrimitive.StopSpeaking` component instead.
-   */
+  /** @deprecated This API is still under active development and might change without notice. */
   stopSpeaking(): void;
   submitFeedback(feedback: { type: "positive" | "negative" }): void;
   switchToBranch(options: {
@@ -72,15 +58,21 @@ export type MessageClientApi = {
     branchId?: string;
   }): void;
   getCopyText(): string;
-
-  part: (
-    selector: { index: number } | { toolCallId: string },
-  ) => MessagePartClientApi;
-  attachment(selector: { index: number } | { id: string }): AttachmentClientApi;
-
+  part(selector: { index: number } | { toolCallId: string }): PartMethods;
+  attachment(selector: { index: number } | { id: string }): AttachmentMethods;
   setIsCopied(value: boolean): void;
   setIsHovering(value: boolean): void;
-
   /** @internal */
   __internal_getRuntime?(): MessageRuntime;
 };
+
+export type MessageMeta = {
+  source: "thread";
+  query: { type: "id"; id: string } | { type: "index"; index: number };
+};
+
+export type MessageClientSchema = {
+  state: MessageState;
+  methods: MessageMethods;
+  meta: MessageMeta;
+};

package/src/types/scopes/modelContext.ts

@@ -0,0 +1,14 @@
+import type { Unsubscribe } from "../Unsubscribe";
+import type { ModelContextProvider } from "../../model-context/ModelContextTypes";
+
+export type ModelContextState = Record<string, never>;
+
+export type ModelContextMethods = ModelContextProvider & {
+  getState(): ModelContextState;
+  register: (provider: ModelContextProvider) => Unsubscribe;
+};
+
+export type ModelContextClientSchema = {
+  state: ModelContextState;
+  methods: ModelContextMethods;
+};

package/src/{client/types/Part.ts → types/scopes/part.ts}

@@ -1,37 +1,44 @@
-import { ToolResponse } from "assistant-stream";
-import { MessagePartRuntime } from "../../legacy-runtime/runtime";
-import {
+import type { ToolResponse } from "assistant-stream";
+import type { MessagePartRuntime } from "../../legacy-runtime/runtime";
+import type {
   ThreadUserMessagePart,
   ThreadAssistantMessagePart,
   MessagePartStatus,
   ToolCallMessagePartStatus,
-} from "../../types";
+} from "../AssistantTypes";
 
-export type MessagePartClientState = (
-  | ThreadUserMessagePart
-  | ThreadAssistantMessagePart
-) & {
+export type PartState = (ThreadUserMessagePart | ThreadAssistantMessagePart) & {
   readonly status: MessagePartStatus | ToolCallMessagePartStatus;
 };
 
-export type MessagePartClientApi = {
+export type PartMethods = {
   /**
    * Get the current state of the message part.
    */
-  getState(): MessagePartClientState;
-
+  getState(): PartState;
   /**
    * Add tool result to a tool call message part that has no tool result yet.
    * This is useful when you are collecting a tool result via user input ("human tool calls").
    */
-  addToolResult(result: any | ToolResponse<any>): void;
-
+  addToolResult(result: unknown | ToolResponse<unknown>): void;
   /**
    * Resume a tool call that is waiting for human input with a payload.
    * This is useful when a tool has requested human input and is waiting for a response.
    */
   resumeToolCall(payload: unknown): void;
-
   /** @internal */
   __internal_getRuntime?(): MessagePartRuntime;
 };
+
+export type PartMeta = {
+  source: "message";
+  query:
+    | { type: "index"; index: number }
+    | { type: "toolCallId"; toolCallId: string };
+};
+
+export type PartClientSchema = {
+  state: PartState;
+  methods: PartMethods;
+  meta: PartMeta;
+};

package/src/{client/types/Thread.ts → types/scopes/thread.ts}

@@ -1,90 +1,75 @@
-import { ReadonlyJSONValue } from "assistant-stream/utils";
-import { ComposerClientState, ComposerClientApi } from "./Composer";
-import { MessageClientApi, MessageClientState } from "./Message";
-import {
-  CreateAppendMessage,
-  CreateStartRunConfig,
-  ThreadRuntime,
-} from "../../legacy-runtime/runtime";
-import {
+import type { ReadonlyJSONValue } from "assistant-stream/utils";
+import type {
+  RuntimeCapabilities,
+  SpeechState,
+} from "../../legacy-runtime/runtime-cores/core/ThreadRuntimeCore";
+import type {
   ThreadSuggestion,
   ExportedMessageRepository,
   ThreadMessageLike,
 } from "../../legacy-runtime/runtime-cores";
-import {
-  RuntimeCapabilities,
-  SpeechState,
-} from "../../legacy-runtime/runtime-cores/core/ThreadRuntimeCore";
-import { CreateResumeRunConfig } from "../../legacy-runtime/runtime/ThreadRuntime";
-import { ModelContext } from "../../model-context";
+import type {
+  CreateAppendMessage,
+  CreateStartRunConfig,
+  ThreadRuntime,
+} from "../../legacy-runtime/runtime";
+import type { CreateResumeRunConfig } from "../../legacy-runtime/runtime/ThreadRuntime";
+import type { ModelContext } from "../../model-context";
+import type { MessageMethods, MessageState } from "./message";
+import type { ComposerMethods, ComposerState } from "./composer";
 
-export type ThreadClientState = {
+export type ThreadState = {
   /**
    * Whether the thread is empty. A thread is considered empty when it has no messages and is not loading.
    */
   readonly isEmpty: boolean;
-
   /**
    * Whether the thread is disabled. Disabled threads cannot receive new messages.
    */
   readonly isDisabled: boolean;
-
   /**
    * Whether the thread is loading its history.
    */
   readonly isLoading: boolean;
-
   /**
    * Whether the thread is running. A thread is considered running when there is an active stream connection to the backend.
    */
   readonly isRunning: boolean;
-
   /**
    * The capabilities of the thread, such as whether the thread supports editing, branch switching, etc.
    */
   readonly capabilities: RuntimeCapabilities;
-
   /**
    * The messages in the currently selected branch of the thread.
    */
-  readonly messages: readonly MessageClientState[];
-
+  readonly messages: readonly MessageState[];
   /**
    * The thread state.
-   *
    * @deprecated This feature is experimental
    */
   readonly state: ReadonlyJSONValue;
-
   /**
    * Follow up message suggestions to show the user.
    */
   readonly suggestions: readonly ThreadSuggestion[];
-
   /**
    * Custom extra information provided by the runtime.
    */
   readonly extras: unknown;
-
-  /**
-   * @deprecated This API is still under active development and might change without notice.
-   */
+  /** @deprecated This API is still under active development and might change without notice. */
   readonly speech: SpeechState | undefined;
-
-  readonly composer: ComposerClientState;
+  readonly composer: ComposerState;
 };
 
-export type ThreadClientApi = {
+export type ThreadMethods = {
   /**
    * Get the current state of the thread.
    */
-  getState(): ThreadClientState;
-
+  getState(): ThreadState;
   /**
    * The thread composer runtime.
    */
-  readonly composer: ComposerClientApi;
-
+  composer: ComposerMethods;
   /**
    * Append a new message to the thread.
    *
@@ -102,49 +87,55 @@ export type ThreadClientApi = {
    * ```
    */
   append(message: CreateAppendMessage): void;
-
   /**
    * Start a new run with the given configuration.
    * @param config The configuration for starting the run
    */
   startRun(config: CreateStartRunConfig): void;
-
   /**
    * Resume a run with the given configuration.
    * @param config The configuration for resuming the run
-   **/
+   */
   unstable_resumeRun(config: CreateResumeRunConfig): void;
-
   cancelRun(): void;
   getModelContext(): ModelContext;
-
   export(): ExportedMessageRepository;
   import(repository: ExportedMessageRepository): void;
-
   /**
    * Reset the thread with optional initial messages.
-   *
    * @param initialMessages - Optional array of initial messages to populate the thread
    */
   reset(initialMessages?: readonly ThreadMessageLike[]): void;
-
-  message(selector: { id: string } | { index: number }): MessageClientApi;
-
-  /**
-   * @deprecated This API is still under active development and might change without notice.
-   */
+  message(selector: { id: string } | { index: number }): MessageMethods;
+  /** @deprecated This API is still under active development and might change without notice. */
   stopSpeaking(): void;
-
   /**
    * Start the voice session for the thread. Establishes any necessary media connections.
    */
   startVoice(): Promise<void>;
-
   /**
    * Stop the currently active voice session.
    */
   stopVoice(): Promise<void>;
-
   /** @internal */
   __internal_getRuntime?(): ThreadRuntime;
 };
+
+export type ThreadMeta = {
+  source: "threads";
+  query: { type: "main" };
+};
+
+export type ThreadEvents = {
+  "thread.runStart": { threadId: string };
+  "thread.runEnd": { threadId: string };
+  "thread.initialize": { threadId: string };
+  "thread.modelContextUpdate": { threadId: string };
+};
+
+export type ThreadClientSchema = {
+  state: ThreadState;
+  methods: ThreadMethods;
+  meta: ThreadMeta;
+  events: ThreadEvents;
+};