@assistant-ui/core 0.3.20 → 0.3.21

package/src/runtime/api/message-runtime.test.ts

@@ -7,7 +7,7 @@ import type {
 import type { ThreadRuntimeCoreBinding } from "./thread-runtime";
 import {
   MessageRuntimeImpl,
-  type MessageState,
+  type MessageRuntimeState,
   type MessageStateBinding,
 } from "./message-runtime";
 import { toMessagePartStatus } from "../../utils/normalizePartStatus";
@@ -28,7 +28,7 @@ const attachment: CompleteAttachment = {
   status: { type: "complete" },
 };
 
-const message: MessageState = {
+const message: MessageRuntimeState = {
   id: "message-1",
   role: "assistant",
   createdAt: new Date(0),
@@ -226,6 +226,116 @@ describe("toMessagePartStatus", () => {
     });
   });
 
+  it.each([
+    ["approval", { approval: { id: "approval-1" } }],
+    [
+      "interrupt",
+      { interrupt: { type: "human" as const, payload: { question: "?" } } },
+    ],
+  ] as const)(
+    "keeps a tool call with a pending %s actionable beside its result",
+    (_label, action) => {
+      const message = createAssistantMessage(
+        [
+          {
+            type: "tool-call",
+            toolCallId: "call-1",
+            toolName: "weather",
+            args: {},
+            argsText: "{}",
+            result: "partial output",
+            ...action,
+          },
+        ],
+        { type: "requires-action", reason: "interrupt" },
+      );
+
+      expect(toMessagePartStatus(message, 0, message.content[0]!)).toEqual({
+        type: "requires-action",
+        reason: "interrupt",
+      });
+    },
+  );
+
+  it.each([
+    ["a decision", { approved: true }],
+    ["a rejection", { approved: false }],
+    ["a resolution", { resolution: "cancelled" as const }],
+  ])(
+    "treats a tool call whose approval carries %s as complete",
+    (_label, settled) => {
+      const message = createAssistantMessage(
+        [
+          {
+            type: "tool-call",
+            toolCallId: "call-1",
+            toolName: "weather",
+            args: {},
+            argsText: "{}",
+            result: "sunny",
+            approval: { id: "approval-1", ...settled },
+          },
+        ],
+        { type: "requires-action", reason: "interrupt" },
+      );
+
+      expect(toMessagePartStatus(message, 0, message.content[0]!)).toEqual({
+        type: "complete",
+      });
+    },
+  );
+
+  it.each([
+    ["running", { type: "running" as const }],
+    [
+      "cancelled",
+      { type: "incomplete" as const, reason: "cancelled" as const },
+    ],
+  ])(
+    "keeps a tool call with a preliminary result on the %s message status",
+    (_label, status) => {
+      const message = createAssistantMessage(
+        [
+          {
+            type: "tool-call",
+            toolCallId: "call-1",
+            toolName: "bash",
+            args: {},
+            argsText: "{}",
+            result: "partial output",
+            isPreliminary: true,
+          },
+        ],
+        status,
+      );
+
+      expect(toMessagePartStatus(message, 0, message.content[0]!)).toEqual(
+        status,
+      );
+    },
+  );
+
+  it("settles a tool call whose result is no longer preliminary", () => {
+    const message = createAssistantMessage(
+      [
+        {
+          type: "tool-call",
+          toolCallId: "call-1",
+          toolName: "bash",
+          args: {},
+          argsText: "{}",
+          result: "final output",
+          isPreliminary: false,
+        },
+      ],
+      { type: "running" },
+    );
+
+    expect(toMessagePartStatus(message, 0, message.content[0]!)).toEqual({
+      type: "complete",
+    });
+  });
+
   it("normalizes supplied upstream statuses", () => {
     const upstreamComplete = {
       type: "text",

package/src/runtime/api/message-runtime.ts

@@ -12,7 +12,7 @@ import {
 } from "../../subscribable/subscribable";
 import {
   type AttachmentRuntime,
-  type AttachmentState,
+  type AttachmentRuntimeState,
   MessageAttachmentRuntimeImpl,
 } from "./attachment-runtime";
 import {
@@ -29,7 +29,7 @@ import type { ThreadRuntimeCoreBinding } from "./thread-runtime";
 import type { MessageStateBinding } from "./bindings";
 
 const getMessagePartState = (
-  message: MessageState,
+  message: MessageRuntimeState,
   partIndex: number,
 ): MessagePartState | SKIP_UPDATE => {
   const part = message.content[partIndex];
@@ -46,7 +46,7 @@ const getMessagePartState = (
   });
 };
 
-export type MessageState = ThreadMessage & {
+export type MessageRuntimeState = ThreadMessage & {
   readonly parentId: string | null;
   /** The position of this message in the thread (0 for first message) */
   readonly index: number;
@@ -61,6 +61,11 @@ export type MessageState = ThreadMessage & {
   readonly speech: SpeechState | undefined;
 };
 
+/**
+ * @deprecated Use `MessageRuntimeState`. From `@assistant-ui/react` 0.16, `MessageState` names the message state read through `useAuiState`.
+ */
+export type MessageState = MessageRuntimeState;
+
 export type { MessageStateBinding } from "./bindings";
 
 type ReloadConfig = {
@@ -72,7 +77,7 @@ export type MessageRuntime = {
 
   readonly composer: EditComposerRuntime;
 
-  getState(): MessageState;
+  getState(): MessageRuntimeState;
   delete(): void | Promise<void>;
   reload(config?: ReloadConfig): void;
   /**
@@ -313,7 +318,7 @@ export class MessageRuntimeImpl implements MessageRuntime {
           return {
             ...attachment,
             source: "message",
-          } satisfies AttachmentState & { source: "message" };
+          } satisfies AttachmentRuntimeState & { source: "message" };
         },
         subscribe: (callback) => this._core.subscribe(callback),
       }),

package/src/runtime/api/thread-list-item-runtime.ts

@@ -25,10 +25,10 @@ export type ThreadListItemEventCallback<E extends ThreadListItemEventType> = (
   payload: ThreadListItemEventPayload[E],
 ) => void;
 
-import type { ThreadListItemState } from "./bindings";
+import type { ThreadListItemRuntimeState } from "./bindings";
 import type { ThreadListItemStatus } from "../interfaces/thread-list-runtime-core";
 
-export type { ThreadListItemState, ThreadListItemStatus };
+export type { ThreadListItemRuntimeState, ThreadListItemStatus };
 
 export type ThreadListItemGenerateTitleOptions = {
   /** Marks a generation started by the automatic title trigger. */
@@ -37,7 +37,7 @@ export type ThreadListItemGenerateTitleOptions = {
 
 export type ThreadListItemRuntime = {
   readonly path: ThreadListItemRuntimePath;
-  getState(): ThreadListItemState;
+  getState(): ThreadListItemRuntimeState;
 
   initialize(): Promise<{ remoteId: string; externalId: string | undefined }>;
   generateTitle(options?: ThreadListItemGenerateTitleOptions): Promise<void>;
@@ -62,7 +62,7 @@ export type ThreadListItemRuntime = {
 };
 
 export type ThreadListItemStateBinding = SubscribableWithState<
-  ThreadListItemState,
+  ThreadListItemRuntimeState,
   ThreadListItemRuntimePath
 >;
 
@@ -98,7 +98,7 @@ export class ThreadListItemRuntimeImpl implements ThreadListItemRuntime {
     this.detach = this.detach.bind(this);
   }
 
-  public getState(): ThreadListItemState {
+  public getState(): ThreadListItemRuntimeState {
     return this._core.getState();
   }
 

package/src/runtime/api/thread-list-runtime.ts

@@ -14,7 +14,7 @@ import type {
 import {
   type ThreadListItemRuntime,
   ThreadListItemRuntimeImpl,
-  type ThreadListItemState,
+  type ThreadListItemRuntimeState,
   type ThreadListItemStateBinding,
 } from "./thread-list-item-runtime";
 import {
@@ -40,7 +40,7 @@ export type ThreadListState = {
   readonly threadItems: Readonly<
     Record<
       string,
-      Omit<ThreadListItemState, "isMain" | "threadId" | "isRunning">
+      Omit<ThreadListItemRuntimeState, "isMain" | "threadId" | "isRunning">
     >
   >;
 };
@@ -110,7 +110,7 @@ const getThreadListState = (
 const getThreadListItemState = (
   threadList: ThreadListRuntimeCore,
   threadId: string | undefined,
-): ThreadListItemState | SKIP_UPDATE => {
+): ThreadListItemRuntimeState | SKIP_UPDATE => {
   if (threadId === undefined) return SKIP_UPDATE;
 
   const threadData = threadList.getItemById(threadId);

package/src/runtime/api/thread-runtime.test.ts

@@ -1,7 +1,10 @@
 import { describe, expect, it, vi } from "vitest";
+import { z } from "zod";
 import { LocalRuntimeCore } from "../../runtimes/local/local-runtime-core";
 import { ExternalStoreRuntimeCore } from "../../runtimes/external-store/external-store-runtime-core";
 import { ReadonlyThreadRuntimeCore } from "../../runtimes/readonly/ReadonlyThreadRuntimeCore";
+import { EMPTY_THREAD_CORE } from "../../runtimes/remote-thread-list/empty-thread-core";
+import type { ThreadRuntimeCore } from "../interfaces/thread-runtime-core";
 import { AssistantRuntimeImpl } from "./assistant-runtime";
 import {
   ThreadRuntimeImpl,
@@ -134,3 +137,59 @@ describe("ThreadRuntime state subscriptions", () => {
     expect(itemSubscriptions).toBe(2);
   });
 });
+
+describe("ThreadRuntime model context", () => {
+  it("notifies modelContextUpdate subscribers when the bound core is replaced", () => {
+    const attached = new ExternalStoreRuntimeCore({
+      messages: [],
+      onNew: async () => {},
+    });
+    attached.registerModelContextProvider({
+      getModelContext: () => ({
+        tools: { search_docs: { parameters: z.object({}) } },
+      }),
+    });
+
+    let core: ThreadRuntimeCore = EMPTY_THREAD_CORE;
+    let notifyBinding!: () => void;
+    const path = {
+      ref: "test.thread",
+      threadSelector: { type: "main" as const },
+    };
+    const runtime = new ThreadRuntimeImpl(
+      {
+        path,
+        getState: () => core,
+        subscribe: (callback) => {
+          notifyBinding = callback;
+          return () => {};
+        },
+        outerSubscribe: () => () => {},
+      } satisfies ThreadRuntimeCoreBinding,
+      {
+        path,
+        getState: () => ({
+          id: "test",
+          remoteId: undefined,
+          externalId: undefined,
+          isMain: true,
+          isRunning: false,
+          status: "regular",
+          title: undefined,
+        }),
+        subscribe: () => () => {},
+      } satisfies ThreadListItemRuntimeBinding,
+    );
+
+    const reads: string[][] = [];
+    runtime.unstable_on("modelContextUpdate", () => {
+      reads.push(Object.keys(runtime.getModelContext().tools ?? {}));
+    });
+    expect(runtime.getModelContext().tools).toBeUndefined();
+
+    core = attached.threads.getMainThreadRuntimeCore();
+    notifyBinding();
+
+    expect(reads).toEqual([["search_docs"]]);
+  });
+});

package/src/runtime/api/thread-runtime.ts

@@ -14,7 +14,7 @@ import type { ThreadMessageLike } from "../utils/thread-message-like";
 import {
   type MessageRuntime,
   MessageRuntimeImpl,
-  type MessageState,
+  type MessageRuntimeState,
 } from "./message-runtime";
 import { NestedSubscriptionSubject } from "../../subscribable/subscribable";
 import {
@@ -32,7 +32,7 @@ import type {
   ThreadListItemRuntimePath,
   ThreadRuntimePath,
 } from "./paths";
-import type { ThreadListItemState } from "./bindings";
+import type { ThreadListItemRuntimeState } from "./bindings";
 import type { AppendMessage, ThreadMessage } from "../../types/message";
 import type { Unsubscribe } from "../../types/unsubscribe";
 import { isMessageNotSentError } from "../../types/error";
@@ -134,11 +134,11 @@ export type ThreadRuntimeCoreBinding = SubscribableWithState<
 };
 
 export type ThreadListItemRuntimeBinding = SubscribableWithState<
-  ThreadListItemState,
+  ThreadListItemRuntimeState,
   ThreadListItemRuntimePath
 >;
 
-export type ThreadState = {
+export type ThreadRuntimeState = {
   /**
    * The thread ID.
    * @deprecated This field is deprecated and will be removed in 0.12.0. Use `useThreadListItem().id` instead.
@@ -150,7 +150,7 @@ export type ThreadState = {
    *
    * @deprecated Use `useThreadListItem()` instead. This field is deprecated and will be removed in 0.12.0.
    */
-  readonly metadata: ThreadListItemState;
+  readonly metadata: ThreadListItemRuntimeState;
 
   /**
    * Whether the thread is disabled. Disabled threads cannot receive new messages.
@@ -202,6 +202,11 @@ export type ThreadState = {
   readonly voice: VoiceSessionState | undefined;
 };
 
+/**
+ * @deprecated Use `ThreadRuntimeState`. From `@assistant-ui/react` 0.16, `ThreadState` names the thread state read through `useAuiState`.
+ */
+export type ThreadState = ThreadRuntimeState;
+
 /**
  * The canonical `isRunning` derivation. A runtime that tracks run state itself
  * reports it directly; the rest fall back to the trailing assistant message.
@@ -218,8 +223,8 @@ export const getThreadRuntimeCoreIsRunning = (
 
 export const getThreadState = (
   runtime: ThreadRuntimeCore,
-  threadListItemState: ThreadListItemState,
-): ThreadState => {
+  threadListItemState: ThreadListItemRuntimeState,
+): ThreadRuntimeState => {
   return Object.freeze({
     threadId: threadListItemState.id,
     metadata: threadListItemState,
@@ -250,7 +255,7 @@ export type ThreadRuntime = {
   /**
    * Gets a snapshot of the thread state.
    */
-  getState(): ThreadState;
+  getState(): ThreadRuntimeState;
 
   /**
    * Append a new message to the thread.
@@ -352,10 +357,10 @@ export class ThreadRuntimeImpl implements ThreadRuntime {
   }
 
   private readonly _threadBinding: ThreadRuntimeCoreBinding & {
-    getStateState(): ThreadState;
+    getStateState(): ThreadRuntimeState;
   };
   private readonly _stateBinding: ShallowMemoizeSubject<
-    ThreadState,
+    ThreadRuntimeState,
     ThreadRuntimePath
   >;
 
@@ -593,7 +598,7 @@ export class ThreadRuntimeImpl implements ThreadRuntime {
 
             speech:
               speechState?.messageId === message.id ? speechState : undefined,
-          } satisfies MessageState;
+          } satisfies MessageRuntimeState;
         },
         subscribe: (callback) => this._threadBinding.subscribe(callback),
       }),
@@ -615,6 +620,11 @@ export class ThreadRuntimeImpl implements ThreadRuntime {
       subject = new EventSubscriptionSubject<ThreadRuntimeEventType>({
         event,
         binding: this._threadBinding,
+        // The main thread binding starts on a placeholder core whose model
+        // context is empty and swaps to the real one once it attaches, so a
+        // subscriber that read the context before that would keep the
+        // placeholder's forever.
+        notifyOnRebind: event === "modelContextUpdate",
       });
       this._eventSubscriptionSubjects.set(event, subject);
     }