@assistant-ui/react 0.11.58 → 0.12.0

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;
+};

package/src/types/scopes/threadListItem.ts

@@ -0,0 +1,44 @@
+import type { ThreadListItemRuntime } from "../../legacy-runtime/runtime";
+import type { ThreadListItemStatus } from "../../legacy-runtime/runtime/ThreadListItemRuntime";
+
+export type ThreadListItemState = {
+  readonly id: string;
+  readonly remoteId: string | undefined;
+  readonly externalId: string | undefined;
+  readonly title?: string | undefined;
+  readonly status: ThreadListItemStatus;
+};
+
+export type ThreadListItemMethods = {
+  getState(): ThreadListItemState;
+  switchTo(): void;
+  rename(newTitle: string): void;
+  archive(): void;
+  unarchive(): void;
+  delete(): void;
+  generateTitle(): void;
+  initialize(): Promise<{ remoteId: string; externalId: string | undefined }>;
+  detach(): void;
+  /** @internal */
+  __internal_getRuntime?(): ThreadListItemRuntime;
+};
+
+export type ThreadListItemMeta = {
+  source: "threads";
+  query:
+    | { type: "main" }
+    | { type: "id"; id: string }
+    | { type: "index"; index: number; archived?: boolean };
+};
+
+export type ThreadListItemEvents = {
+  "threadListItem.switchedTo": { threadId: string };
+  "threadListItem.switchedAway": { threadId: string };
+};
+
+export type ThreadListItemClientSchema = {
+  state: ThreadListItemState;
+  methods: ThreadListItemMethods;
+  meta: ThreadListItemMeta;
+  events: ThreadListItemEvents;
+};

package/src/{client/types/ThreadList.ts → types/scopes/threads.ts}

@@ -1,25 +1,22 @@
-import {
-  ThreadListItemClientState,
-  ThreadListItemClientApi,
-} from "./ThreadListItem";
-import { ThreadClientApi, ThreadClientState } from "./Thread";
 import type { AssistantRuntime } from "../../legacy-runtime/runtime/AssistantRuntime";
+import type {
+  ThreadListItemMethods,
+  ThreadListItemState,
+} from "./threadListItem";
+import type { ThreadMethods, ThreadState } from "./thread";
 
-export type ThreadListClientState = {
+export type ThreadsState = {
   readonly mainThreadId: string;
   readonly newThreadId: string | null;
   readonly isLoading: boolean;
   readonly threadIds: readonly string[];
   readonly archivedThreadIds: readonly string[];
-
-  readonly threadItems: readonly ThreadListItemClientState[];
-
-  readonly main: ThreadClientState;
+  readonly threadItems: readonly ThreadListItemState[];
+  readonly main: ThreadState;
 };
 
-export type ThreadListClientApi = {
-  getState(): ThreadListClientState;
-
+export type ThreadsMethods = {
+  getState(): ThreadsState;
   switchToThread(threadId: string): void;
   switchToNewThread(): void;
   item(
@@ -27,10 +24,13 @@ export type ThreadListClientApi = {
       | "main"
       | { id: string }
       | { index: number; archived?: boolean },
-  ): ThreadListItemClientApi;
-
-  thread(selector: "main"): ThreadClientApi;
-
+  ): ThreadListItemMethods;
+  thread(selector: "main"): ThreadMethods;
   /** @internal */
   __internal_getAssistantRuntime?(): AssistantRuntime;
 };
+
+export type ThreadsClientSchema = {
+  state: ThreadsState;
+  methods: ThreadsMethods;
+};

package/src/types/scopes/tools.ts

@@ -0,0 +1,19 @@
+import type { ToolCallMessagePartComponent } from "../MessagePartComponentTypes";
+import type { Unsubscribe } from "../Unsubscribe";
+
+export type ToolsState = {
+  tools: Record<string, ToolCallMessagePartComponent[]>;
+};
+
+export type ToolsMethods = {
+  getState(): ToolsState;
+  setToolUI(
+    toolName: string,
+    render: ToolCallMessagePartComponent,
+  ): Unsubscribe;
+};
+
+export type ToolsClientSchema = {
+  state: ToolsState;
+  methods: ToolsMethods;
+};

package/src/types/store-augmentation.ts

@@ -0,0 +1,25 @@
+import "@assistant-ui/store";
+
+import type { ThreadsClientSchema } from "./scopes/threads";
+import type { ThreadListItemClientSchema } from "./scopes/threadListItem";
+import type { ThreadClientSchema } from "./scopes/thread";
+import type { MessageClientSchema } from "./scopes/message";
+import type { PartClientSchema } from "./scopes/part";
+import type { ComposerClientSchema } from "./scopes/composer";
+import type { AttachmentClientSchema } from "./scopes/attachment";
+import type { ToolsClientSchema } from "./scopes/tools";
+import type { ModelContextClientSchema } from "./scopes/modelContext";
+
+declare module "@assistant-ui/store" {
+  interface ClientRegistry {
+    threads: ThreadsClientSchema;
+    threadListItem: ThreadListItemClientSchema;
+    thread: ThreadClientSchema;
+    message: MessageClientSchema;
+    part: PartClientSchema;
+    composer: ComposerClientSchema;
+    attachment: AttachmentClientSchema;
+    tools: ToolsClientSchema;
+    modelContext: ModelContextClientSchema;
+  }
+}

package/src/utils/smooth/SmoothContext.tsx

@@ -15,7 +15,7 @@ import {
   MessagePartStatus,
   ToolCallMessagePartStatus,
 } from "../../types/AssistantTypes";
-import { useAssistantApi } from "../../context";
+import { useAui } from "@assistant-ui/store";
 import { createContextStoreHook } from "../../context/react/utils/createContextStoreHook";
 
 type SmoothContextValue = {
@@ -35,10 +35,10 @@ const makeSmoothContext = (
 
 export const SmoothContextProvider: FC<PropsWithChildren> = ({ children }) => {
   const outer = useSmoothContext({ optional: true });
-  const api = useAssistantApi();
+  const aui = useAui();
 
   const [context] = useState(() =>
-    makeSmoothContext(api.part().getState().status),
+    makeSmoothContext(aui.part().getState().status),
   );
 
   // do not wrap if there is an outer SmoothContextProvider

package/src/utils/smooth/useSmooth.tsx

@@ -1,7 +1,7 @@
 "use client";
 
 import { useEffect, useMemo, useRef, useState } from "react";
-import { useAssistantState } from "../../context";
+import { useAuiState } from "@assistant-ui/store";
 import {
   MessagePartStatus,
   ReasoningMessagePart,
@@ -75,7 +75,7 @@ export const useSmooth = (
   smooth: boolean = false,
 ): MessagePartState & (TextMessagePart | ReasoningMessagePart) => {
   const { text } = state;
-  const id = useAssistantState(({ message }) => message.id);
+  const id = useAuiState(({ message }) => message.id);
 
   const idRef = useRef(id);
   const [displayedText, setDisplayedText] = useState(text);

package/src/utils/useToolArgsFieldStatus.tsx

@@ -1,10 +1,10 @@
 import { getPartialJsonObjectFieldState } from "assistant-stream/utils";
-import { useAssistantState } from "../context";
+import { useAuiState } from "@assistant-ui/store";
 
 const COMPLETE_STATUS = { type: "complete" };
 
 export const useToolArgsFieldStatus = (fieldPath: (string | number)[]) => {
-  return useAssistantState(({ part }) => {
+  return useAuiState(({ part }) => {
     if (part.type !== "tool-call")
       throw new Error(
         "useToolArgsFieldStatus can only be used inside tool-call message parts",

package/dist/client/AssistantClient.d.ts

@@ -1,21 +0,0 @@
-import { ResourceElement } from "@assistant-ui/tap";
-import { ThreadListClientApi, ThreadListClientState } from "./types/ThreadList.js";
-import { AssistantApi } from "../context/react/AssistantApiContext.js";
-import { ToolsApi, ToolsState } from "./types/Tools.js";
-import { ModelContextApi, ModelContextState } from "./types/ModelContext.js";
-export type AssistantClientProps = {
-    threads: ResourceElement<{
-        state: ThreadListClientState;
-        api: ThreadListClientApi;
-    }>;
-    modelContext?: ResourceElement<{
-        state: ModelContextState;
-        api: ModelContextApi;
-    }>;
-    tools?: ResourceElement<{
-        state: ToolsState;
-        api: ToolsApi;
-    }> | undefined;
-};
-export declare const useAssistantClient: (props: AssistantClientProps) => AssistantApi;
-//# sourceMappingURL=AssistantClient.d.ts.map

package/dist/client/AssistantClient.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"AssistantClient.d.ts","sourceRoot":"","sources":["../../src/client/AssistantClient.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,eAAe,EAEhB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,8BAA2B;AAYhF,OAAO,EACL,YAAY,EAIb,gDAA6C;AAG9C,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,yBAAsB;AACrD,OAAO,EAAE,eAAe,EAAE,iBAAiB,EAAE,gCAA6B;AA4H1E,MAAM,MAAM,oBAAoB,GAAG;IACjC,OAAO,EAAE,eAAe,CAAC;QACvB,KAAK,EAAE,qBAAqB,CAAC;QAC7B,GAAG,EAAE,mBAAmB,CAAC;KAC1B,CAAC,CAAC;IACH,YAAY,CAAC,EAAE,eAAe,CAAC;QAC7B,KAAK,EAAE,iBAAiB,CAAC;QACzB,GAAG,EAAE,eAAe,CAAC;KACtB,CAAC,CAAC;IACH,KAAK,CAAC,EACF,eAAe,CAAC;QACd,KAAK,EAAE,UAAU,CAAC;QAClB,GAAG,EAAE,QAAQ,CAAC;KACf,CAAC,GACF,SAAS,CAAC;CACf,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAI,OAAO,oBAAoB,iBAK7D,CAAC"}