@assistant-ui/core 0.3.5 → 0.3.7

package/src/react/runtimes/RemoteThreadListThreadListRuntimeCore.tsx

@@ -14,14 +14,29 @@ import {
   normalizeCursor,
   updateStatusReducer,
 } from "../../runtimes/remote-thread-list/remote-thread-state";
-import type { RemoteThreadListOptions } from "../../runtimes/remote-thread-list/types";
+import type {
+  RemoteThreadListOptions,
+  RemoteThreadListProviderComponent,
+} from "../../runtimes/remote-thread-list/types";
 import { RemoteThreadListHookInstanceManager } from "./RemoteThreadListHookInstanceManager";
-import { type FC, Fragment, useEffect, useId } from "react";
+import {
+  type ComponentType,
+  type FC,
+  Fragment,
+  type PropsWithChildren,
+  useEffect,
+  useId,
+} from "react";
 import { create } from "zustand";
 import { AssistantMessageStream } from "assistant-stream";
 import type { ModelContextProvider } from "../../model-context/types";
 import { RuntimeAdapterProvider } from "./RuntimeAdapterProvider";
 
+const asProviderComponent = (
+  provider: RemoteThreadListProviderComponent | undefined,
+): ComponentType<PropsWithChildren> =>
+  (provider ?? Fragment) as ComponentType<PropsWithChildren>;
+
 const threadNotFoundError = (threadIdOrRemoteId: string, action: string) =>
   new Error(`Thread "${threadIdOrRemoteId}" not found while ${action}.`);
 
@@ -189,7 +204,7 @@ export class RemoteThreadListThreadListRuntimeCore
       this._notifySubscribers(),
     );
     this.useProvider = create(() => ({
-      Provider: options.adapter.unstable_Provider ?? Fragment,
+      Provider: asProviderComponent(options.adapter.unstable_Provider),
     }));
     this.__internal_setOptions(options);
     this.switchToNewThread();
@@ -210,7 +225,7 @@ export class RemoteThreadListThreadListRuntimeCore
 
     this._options = options;
 
-    const Provider = options.adapter.unstable_Provider ?? Fragment;
+    const Provider = asProviderComponent(options.adapter.unstable_Provider);
     if (Provider !== this.useProvider.getState().Provider) {
       this.useProvider.setState({ Provider }, true);
     }

package/src/react/runtimes/createRuntimeExtras.test.ts

@@ -1,6 +1,10 @@
 import { describe, it, expect } from "vitest";
 import type { AssistantClient } from "@assistant-ui/store";
-import { createRuntimeExtras } from "./createRuntimeExtras";
+import {
+  createRuntimeExtras,
+  unstable_createRuntimeExtrasFromBrand,
+} from "./createRuntimeExtras";
+import { createRuntimeExtrasBrand } from "../../runtime/utils/runtime-extras-brand";
 
 type Extras = { value: number; greet: () => string };
 
@@ -55,4 +59,13 @@ describe("createRuntimeExtras", () => {
 
     expect(() => channel.get(clientWith(undefined))).toThrow("useTestRuntime");
   });
+
+  it("reads extras provided through a standalone brand instance", () => {
+    const brand = createRuntimeExtrasBrand<Extras>("useTestRuntime");
+    const channel = unstable_createRuntimeExtrasFromBrand(brand);
+    const branded = brand.provide({ value: 7, greet: () => "hi" });
+
+    expect(channel.is(branded)).toBe(true);
+    expect(channel.get(clientWith(branded)).value).toBe(7);
+  });
 });

package/src/react/runtimes/createRuntimeExtras.ts

@@ -2,6 +2,10 @@
 
 import { useAuiState } from "@assistant-ui/store";
 import type { AssistantClient } from "@assistant-ui/store";
+import {
+  createRuntimeExtrasBrand,
+  type RuntimeExtrasBrand,
+} from "../../runtime/utils/runtime-extras-brand";
 
 /** @deprecated Internal API for external-store adapter authors. Not part of the public API; may change or be removed without notice. */
 export type RuntimeExtras<T extends object> = {
@@ -17,33 +21,10 @@ export type RuntimeExtras<T extends object> = {
 };
 
 /** @deprecated Internal API for external-store adapter authors. Not part of the public API; may change or be removed without notice. */
-export const createRuntimeExtras = <T extends object>(
-  runtimeName: string,
+export const unstable_createRuntimeExtrasFromBrand = <T extends object>(
+  brand: RuntimeExtrasBrand<T>,
 ): RuntimeExtras<T> => {
-  const brand = Symbol(`${runtimeName} extras`);
-
-  const is = (extras: unknown): extras is T =>
-    typeof extras === "object" && extras !== null && brand in extras;
-
-  const assert = (extras: unknown): T => {
-    if (!is(extras))
-      throw new Error(
-        `The current thread is not backed by the ${runtimeName} runtime.`,
-      );
-    return extras;
-  };
-
-  const provide = (value: T): T => {
-    Object.defineProperty(value, brand, {
-      value: true,
-      enumerable: false,
-      configurable: true,
-    });
-    return value;
-  };
-
-  const tryGet = (extras: unknown): T | undefined =>
-    is(extras) ? extras : undefined;
+  const { provide, is, tryGet, assert } = brand;
 
   const get = (client: AssistantClient): T =>
     assert(client.thread.getState().extras);
@@ -66,3 +47,11 @@ export const createRuntimeExtras = <T extends object>(
 
   return { provide, is, tryGet, get, use: use as RuntimeExtras<T>["use"] };
 };
+
+/** @deprecated Internal API for external-store adapter authors. Not part of the public API; may change or be removed without notice. */
+export const createRuntimeExtras = <T extends object>(
+  runtimeName: string,
+): RuntimeExtras<T> =>
+  unstable_createRuntimeExtrasFromBrand(
+    createRuntimeExtrasBrand<T>(runtimeName),
+  );

package/src/react/runtimes/useLocalRuntime.ts

@@ -84,6 +84,8 @@ export const splitLocalRuntimeOptions = <T extends LocalRuntimeOptions>(
     adapters,
     unstable_humanToolNames,
     unstable_enableMessageQueue,
+    unstable_queueClearOnRewind,
+    unstable_queueClearOnCancel,
     ...rest
   } = options;
 
@@ -95,6 +97,8 @@ export const splitLocalRuntimeOptions = <T extends LocalRuntimeOptions>(
       adapters,
       unstable_humanToolNames,
       unstable_enableMessageQueue,
+      unstable_queueClearOnRewind,
+      unstable_queueClearOnCancel,
     },
     otherOptions: rest,
   };

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

@@ -4,6 +4,7 @@ import type { QuoteInfo } from "../../types/quote";
 import type { Unsubscribe } from "../../types/unsubscribe";
 import type { RunConfig } from "../../types/message";
 import type { QueueItemState } from "../../store/scopes/queue-item";
+import type { QueuePlacement } from "../queue/external-thread-queue-adapter";
 import {
   LazyMemoizeSubject,
   EventSubscriptionSubject,
@@ -200,9 +201,12 @@ export type ComposerRuntime = {
    */
   cancel(): void;
 
-  /** Promote a queued message so it processes next. */
+  /** @deprecated Use `moveQueueItem(queueItemId, { lane: "steer", insertAfter: null })` instead. Removal after 2026-11-05. */
   steerQueueItem(queueItemId: string): void;
 
+  /** Move a queued message between lanes or within a lane. */
+  moveQueueItem(queueItemId: string, placement: QueuePlacement): void;
+
   /** Remove a queued message. */
   removeQueueItem(queueItemId: string): void;
 
@@ -268,6 +272,7 @@ export abstract class ComposerRuntimeImpl implements ComposerRuntime {
     this.send = this.send.bind(this);
     this.cancel = this.cancel.bind(this);
     this.steerQueueItem = this.steerQueueItem.bind(this);
+    this.moveQueueItem = this.moveQueueItem.bind(this);
     this.removeQueueItem = this.removeQueueItem.bind(this);
     this.setRole = this.setRole.bind(this);
     this.getAttachmentByIndex = this.getAttachmentByIndex.bind(this);
@@ -322,9 +327,13 @@ export abstract class ComposerRuntimeImpl implements ComposerRuntime {
   }
 
   public steerQueueItem(queueItemId: string) {
+    this.moveQueueItem(queueItemId, { lane: "steer", insertAfter: null });
+  }
+
+  public moveQueueItem(queueItemId: string, placement: QueuePlacement) {
     const core = this._core.getState();
     if (!core) throw new Error("Composer is not available");
-    core.steerQueueItem(queueItemId);
+    core.moveQueueItem(queueItemId, placement);
   }
 
   public removeQueueItem(queueItemId: string) {

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

@@ -173,6 +173,31 @@ describe("toMessagePartStatus", () => {
     });
   });
 
+  it.each([
+    ["false", false],
+    ["zero", 0],
+    ["an empty string", ""],
+    ["null", null],
+  ])("treats %s tool results as complete", (_label, result) => {
+    const message = createAssistantMessage(
+      [
+        {
+          type: "tool-call",
+          toolCallId: "call-1",
+          toolName: "weather",
+          args: {},
+          argsText: "{}",
+          result,
+        },
+      ],
+      { 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

@@ -44,7 +44,7 @@ export const toMessagePartStatus = (
   if (message.role !== "assistant") return COMPLETE_STATUS;
 
   if (part.type === "tool-call") {
-    if (!part.result) {
+    if (part.result === undefined) {
       return message.status as ToolCallMessagePartStatus;
     } else {
       return COMPLETE_STATUS;

package/src/runtime/base/base-composer-runtime-core.ts

@@ -24,6 +24,7 @@ import type {
   SendOptions,
 } from "../interfaces/composer-runtime-core";
 import type { DictationAdapter } from "../../adapters/speech";
+import type { QueuePlacement } from "../queue/external-thread-queue-adapter";
 import {
   EMPTY_QUEUE_ITEMS,
   type QueueItemState,
@@ -301,7 +302,10 @@ export abstract class BaseComposerRuntimeCore
     return EMPTY_QUEUE_ITEMS;
   }
 
-  public steerQueueItem(_queueItemId: string): void {}
+  public moveQueueItem(
+    _queueItemId: string,
+    _placement: QueuePlacement,
+  ): void {}
   public removeQueueItem(_queueItemId: string): void {}
 
   protected abstract handleSend(

package/src/runtime/base/default-thread-composer-runtime-core.ts

@@ -6,6 +6,7 @@ import type {
   ThreadComposerRuntimeCore,
 } from "../interfaces/composer-runtime-core";
 import type { ThreadRuntimeCore } from "../interfaces/thread-runtime-core";
+import type { QueuePlacement } from "../queue/external-thread-queue-adapter";
 import {
   EMPTY_QUEUE_ITEMS,
   type QueueItemState,
@@ -26,12 +27,35 @@ export class DefaultThreadComposerRuntimeCore
     return !this.isEmpty && !this.runtime.isSendDisabled && !this._isSending;
   }
 
+  private _queueCache:
+    | {
+        steer: readonly QueueItemState[];
+        queue: readonly QueueItemState[];
+        flat: readonly QueueItemState[];
+      }
+    | undefined;
+
   public override get queue(): readonly QueueItemState[] {
-    return this.runtime.getQueueItems?.() ?? EMPTY_QUEUE_ITEMS;
+    const steer = this.runtime.getSteerQueueItems?.() ?? EMPTY_QUEUE_ITEMS;
+    const queue = this.runtime.getQueueItems?.() ?? EMPTY_QUEUE_ITEMS;
+    const cache = this._queueCache;
+    if (cache && cache.steer === steer && cache.queue === queue)
+      return cache.flat;
+    const flat =
+      steer.length === 0
+        ? queue
+        : queue.length === 0
+          ? steer
+          : [...steer, ...queue];
+    this._queueCache = { steer, queue, flat };
+    return flat;
   }
 
-  public override steerQueueItem(queueItemId: string): void {
-    this.runtime.steerQueueItem?.(queueItemId);
+  public override moveQueueItem(
+    queueItemId: string,
+    placement: QueuePlacement,
+  ): void {
+    this.runtime.moveQueueItem?.(queueItemId, placement);
   }
 
   public override removeQueueItem(queueItemId: string): void {

package/src/runtime/interfaces/composer-runtime-core.ts

@@ -5,6 +5,7 @@ import type { Unsubscribe } from "../../types/unsubscribe";
 import type { RunConfig } from "../../types/message";
 import type { DictationAdapter } from "../../adapters/speech";
 import type { QueueItemState } from "../../store/scopes/queue-item";
+import type { QueuePlacement } from "../queue/external-thread-queue-adapter";
 
 export type AttachmentAddErrorReason =
   | "no-adapter"
@@ -82,7 +83,7 @@ export type ComposerRuntimeCore = Readonly<{
   cancel: () => void;
 
   queue: readonly QueueItemState[];
-  steerQueueItem: (queueItemId: string) => void;
+  moveQueueItem: (queueItemId: string, placement: QueuePlacement) => void;
   removeQueueItem: (queueItemId: string) => void;
 
   dictation: DictationState | undefined;

package/src/runtime/interfaces/thread-runtime-core.ts

@@ -17,6 +17,7 @@ import type {
   ThreadComposerRuntimeCore,
 } from "./composer-runtime-core";
 import type { QueueItemState } from "../../store/scopes/queue-item";
+import type { QueuePlacement } from "../queue/external-thread-queue-adapter";
 
 export type RuntimeCapabilities = {
   readonly switchToBranch: boolean;
@@ -177,7 +178,8 @@ export type ThreadRuntimeCore = Readonly<{
   beginEdit: (messageId: string) => void;
 
   getQueueItems?: () => readonly QueueItemState[];
-  steerQueueItem?: (queueItemId: string) => void;
+  getSteerQueueItems?: () => readonly QueueItemState[];
+  moveQueueItem?: (queueItemId: string, placement: QueuePlacement) => void;
   removeQueueItem?: (queueItemId: string) => void;
 
   speech: SpeechState | undefined;

package/src/runtime/queue/external-thread-queue-adapter.ts

@@ -1,14 +1,30 @@
 import type { AppendMessage } from "../../types/message";
 import type { QueueItemState } from "../../store/scopes/queue-item";
 
+export type QueuePlacement = {
+  readonly lane?: "queue" | "steer";
+  readonly insertAfter?: string | null;
+  readonly insertBefore?: string | null;
+};
+
 /**
  * The queue surface a runtime exposes so the composer can stay usable during a
  * run and render the pending messages.
  */
 export type ExternalThreadQueueAdapter = {
   items: readonly QueueItemState[];
-  enqueue: (message: AppendMessage, options: { steer: boolean }) => void;
-  steer: (queueItemId: string) => void;
+  steerItems: readonly QueueItemState[];
+  /** Send a message into the queue lane, processed in order. */
+  enqueue: (message: AppendMessage) => void;
+  /** Send a message into the steer lane, processed next. */
+  steer: (message: AppendMessage) => void;
+  /**
+   * Move a queued message between lanes or within a lane. An unanchored move
+   * into the steer lane mid-run interrupts — cancels the live run and
+   * dispatches the item — when the runtime supports cancellation; a move with
+   * `insertAfter`/`insertBefore` only places the item and never interrupts.
+   */
+  move: (queueItemId: string, placement: QueuePlacement) => void;
+  edit: (queueItemId: string, message: AppendMessage) => void;
   remove: (queueItemId: string) => void;
-  clear: (reason: "edit" | "reload" | "cancel-run") => void;
 };