@assistant-ui/core 0.3.14 → 0.3.16

package/src/tests/thread-message-like.test.ts

@@ -1,5 +1,9 @@
 import { describe, expect, it } from "vitest";
-import { fromThreadMessageLike } from "../runtime/utils/thread-message-like";
+import {
+  fromThreadMessageLike,
+  type ThreadMessageLike,
+} from "../runtime/utils/thread-message-like";
+import type { ToolCallMessagePartMcpMetadata } from "../types/message";
 
 const fallbackId = "test-id";
 const fallbackStatus = {
@@ -421,3 +425,37 @@ describe("fromThreadMessageLike provider metadata", () => {
     ]);
   });
 });
+
+describe("fromThreadMessageLike MCP app metadata", () => {
+  it("keeps mcp on tool-call parts", () => {
+    const mcp: ToolCallMessagePartMcpMetadata = {
+      app: { resourceUri: "ui://demo/card" },
+    };
+    const message: ThreadMessageLike = {
+      role: "assistant",
+      content: [
+        {
+          type: "tool-call",
+          toolCallId: "call-1",
+          toolName: "show_card",
+          args: {},
+          argsText: "{}",
+          mcp,
+        },
+      ],
+    };
+
+    const result = fromThreadMessageLike(message, fallbackId, fallbackStatus);
+
+    expect(result.content).toEqual([
+      {
+        type: "tool-call",
+        toolCallId: "call-1",
+        toolName: "show_card",
+        args: {},
+        argsText: "{}",
+        mcp,
+      },
+    ]);
+  });
+});

package/src/tests/useRemoteThreadListRuntime-controlled.test.tsx

@@ -173,6 +173,73 @@ describe("useRemoteThreadListRuntime controlled threadId", () => {
     expect(onThreadIdChange).not.toHaveBeenCalled();
   });
 
+  it("reports the reset when an adapter change makes the runtime uncontrolled", async () => {
+    const adapterA = makeAdapter();
+    const adapterB = makeAdapter();
+    const onThreadIdChange = vi.fn();
+    const runtimeRef: RuntimeRef = { current: null };
+
+    const { rerender } = render(
+      <ControlledRuntime
+        adapter={adapterA}
+        threadId="thread-a"
+        onThreadIdChange={onThreadIdChange}
+        runtimeRef={runtimeRef}
+      />,
+    );
+    await waitForRemoteThread(runtimeRef, "thread-a");
+    onThreadIdChange.mockClear();
+
+    rerender(
+      <ControlledRuntime
+        adapter={adapterB}
+        threadId={undefined}
+        onThreadIdChange={onThreadIdChange}
+        runtimeRef={runtimeRef}
+      />,
+    );
+
+    await waitFor(() => {
+      const state = runtimeRef.current!.threads.getState();
+      expect(state.mainThreadId).toBeDefined();
+      expect(runtimeRef.current!.threads.mainItem.getState().status).toBe(
+        "new",
+      );
+    });
+    expect(onThreadIdChange).not.toHaveBeenCalled();
+  });
+
+  it("does not echo a controlled target when the adapter changes", async () => {
+    const adapterA = makeAdapter();
+    const adapterB = makeAdapter();
+    const onThreadIdChange = vi.fn();
+    const runtimeRef: RuntimeRef = { current: null };
+
+    const { rerender } = render(
+      <ControlledRuntime
+        adapter={adapterA}
+        threadId="thread-a"
+        onThreadIdChange={onThreadIdChange}
+        runtimeRef={runtimeRef}
+      />,
+    );
+    await waitForRemoteThread(runtimeRef, "thread-a");
+    onThreadIdChange.mockClear();
+
+    rerender(
+      <ControlledRuntime
+        adapter={adapterB}
+        threadId="thread-b"
+        onThreadIdChange={onThreadIdChange}
+        runtimeRef={runtimeRef}
+      />,
+    );
+
+    await waitForRemoteThread(runtimeRef, "thread-b");
+    expect(adapterB.fetch).toHaveBeenCalledWith("thread-b");
+    expect(onThreadIdChange).not.toHaveBeenCalled();
+  });
+
   it("still emits runtime-initiated thread switches", async () => {
     const adapter = makeAdapter();
     const onThreadIdChange = vi.fn();

package/src/types/message.ts

@@ -168,9 +168,9 @@ export type ToolApprovalOption = {
   readonly id: string;
   /**
    * Decision class. Drives approved-resolution and default rendering.
-   * Open union: `_`-prefixed custom kinds are never auto-resolved and the
-   * default kit skips them; they must be answered with an explicit
-   * `approved` value (optionally alongside the `optionId`).
+   * Open union: `_`-prefixed custom kinds are never auto-resolved; they must
+   * be answered with an explicit `approved` value (optionally alongside the
+   * `optionId`), which is what the default kit sends when one is chosen.
    */
   readonly kind: ToolApprovalOptionKind | (string & {});
   /** Human label. Renderers supply defaults per kind when omitted. */
@@ -304,7 +304,12 @@ export type ToolCallMessagePartStatus =
       /** The tool call is waiting for UI or human input before continuing. */
       readonly type: "requires-action";
       /** Reason the tool call requires action. */
-      readonly reason: "interrupt";
+      readonly reason: "tool-calls" | "interrupt";
+    }
+  | {
+      readonly type: "incomplete";
+      readonly reason: "tool-calls";
+      readonly error?: ReadonlyJSONValue;
     }
   | MessagePartStatus;
 

package/src/utils/data-url.test.ts

@@ -1,5 +1,9 @@
 import { describe, it, expect } from "vitest";
-import { httpUrlPattern, parseDataUrl } from "./data-url";
+import {
+  httpUrlPattern,
+  parseDataUrl,
+  resolveFilePartSource,
+} from "./data-url";
 
 describe("parseDataUrl", () => {
   it("parses a base64 data URL", () => {
@@ -72,3 +76,50 @@ describe("httpUrlPattern", () => {
     },
   );
 });
+
+describe("resolveFilePartSource", () => {
+  it("uses an explicit url source type for opaque values", () => {
+    expect(
+      resolveFilePartSource({
+        data: "provider-file-id",
+        mimeType: "application/pdf",
+        sourceType: "url",
+      }),
+    ).toEqual({ kind: "url", url: "provider-file-id" });
+  });
+
+  it("uses http URLs as url sources", () => {
+    expect(
+      resolveFilePartSource({
+        data: "https://example.com/file.pdf",
+        mimeType: "application/pdf",
+      }),
+    ).toEqual({ kind: "url", url: "https://example.com/file.pdf" });
+  });
+
+  it("decodes data URLs and uses their media type", () => {
+    expect(
+      resolveFilePartSource({
+        data: "data:image/png;base64,aGVsbG8=",
+        mimeType: "application/octet-stream",
+      }),
+    ).toEqual({
+      kind: "data",
+      data: "aGVsbG8=",
+      mimeType: "image/png",
+    });
+  });
+
+  it("passes through opaque data with its declared media type", () => {
+    expect(
+      resolveFilePartSource({
+        data: "provider-file-id",
+        mimeType: "application/pdf",
+      }),
+    ).toEqual({
+      kind: "data",
+      data: "provider-file-id",
+      mimeType: "application/pdf",
+    });
+  });
+});

package/src/utils/data-url.ts

@@ -1,5 +1,9 @@
 export const httpUrlPattern = /^https?:\/\//i;
 
+export type FilePartSource =
+  | { kind: "url"; url: string }
+  | { kind: "data"; data: string; mimeType: string };
+
 export function parseDataUrl(
   value: string,
 ): { mimeType: string; data: string } | null {
@@ -8,6 +12,23 @@ export function parseDataUrl(
   return { mimeType: match[1]!.toLowerCase(), data: match[2]! };
 }
 
+export const resolveFilePartSource = (part: {
+  data: string;
+  mimeType: string;
+  sourceType?: string | undefined;
+}): FilePartSource => {
+  if (part.sourceType === "url" || httpUrlPattern.test(part.data)) {
+    return { kind: "url", url: part.data };
+  }
+
+  const parsed = parseDataUrl(part.data);
+  return {
+    kind: "data",
+    data: parsed?.data ?? part.data,
+    mimeType: parsed?.mimeType ?? part.mimeType,
+  };
+};
+
 /**
  * Whether a payload is something `new URL()` accepts. Adapters that place a
  * `FileMessagePart` payload into a url-typed wire field use this to decide

package/src/utils/invoke-user-callback.test.ts

@@ -0,0 +1,82 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { invokeUserCallback } from "./invoke-user-callback";
+
+describe("invokeUserCallback", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("invokes a callback synchronously with its arguments", () => {
+    const callback = vi.fn((left: number, right: number) => left + right);
+
+    expect(invokeUserCallback("test", "onSuccess", callback, 2, 3)).toBe(
+      undefined,
+    );
+    expect(callback).toHaveBeenCalledOnce();
+    expect(callback).toHaveBeenCalledWith(2, 3);
+  });
+
+  it("reports and swallows a synchronous throw", () => {
+    const error = new Error("sync failure");
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => {});
+
+    expect(() =>
+      invokeUserCallback("test", "onError", () => {
+        throw error;
+      }),
+    ).not.toThrow();
+    expect(consoleError).toHaveBeenCalledOnce();
+    expect(consoleError).toHaveBeenCalledWith(
+      "[test] onError callback threw an error",
+      error,
+    );
+  });
+
+  it("reports an asynchronous rejection and resolves", async () => {
+    const error = new Error("async failure");
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => {});
+
+    await expect(
+      invokeUserCallback("test", "onError", async () => {
+        throw error;
+      }),
+    ).resolves.toBeUndefined();
+    expect(consoleError).toHaveBeenCalledOnce();
+    expect(consoleError).toHaveBeenCalledWith(
+      "[test] onError callback threw an error",
+      error,
+    );
+  });
+
+  it("resolves only after an asynchronous callback settles", async () => {
+    let settleCallback: (() => void) | undefined;
+    const callbackPromise = new Promise<void>((resolve) => {
+      settleCallback = resolve;
+    });
+    let settled = false;
+
+    const result = invokeUserCallback(
+      "test",
+      "onFinish",
+      () => callbackPromise,
+    );
+    void result?.then(() => {
+      settled = true;
+    });
+
+    await Promise.resolve();
+    expect(settled).toBe(false);
+
+    settleCallback?.();
+    await result;
+    expect(settled).toBe(true);
+  });
+
+  it("does nothing when the callback is undefined", () => {
+    expect(invokeUserCallback("test", "onMissing", undefined)).toBeUndefined();
+  });
+});

package/src/utils/invoke-user-callback.ts

@@ -0,0 +1,31 @@
+export function invokeUserCallback<TArgs extends readonly unknown[]>(
+  tag: string,
+  name: string,
+  callback: ((...args: TArgs) => unknown) | undefined,
+  ...args: TArgs
+): void | Promise<void> {
+  if (!callback) return;
+
+  const reportError = (error: unknown) => {
+    try {
+      console.error(`[${tag}] ${name} callback threw an error`, error);
+    } catch {}
+  };
+
+  try {
+    const result = callback(...args);
+    if (
+      result !== null &&
+      (typeof result === "object" || typeof result === "function") &&
+      "then" in result &&
+      typeof result.then === "function"
+    ) {
+      return Promise.resolve(result).then(
+        () => undefined,
+        (error) => reportError(error),
+      );
+    }
+  } catch (error) {
+    reportError(error);
+  }
+}

package/src/utils/normalizePartStatus.ts

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

package/src/utils/silent-runtime-action.ts

@@ -0,0 +1,6 @@
+export const SILENT_RUNTIME_ACTION = Symbol.for(
+  "assistant-ui.silent-runtime-action",
+);
+
+export const isSilentRuntimeAction = (error: unknown): boolean =>
+  typeof error === "object" && error !== null && SILENT_RUNTIME_ACTION in error;

package/dist/store/scopes/queue-item.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"queue-item.js","names":["FileMessagePart","TextMessagePart","QueuePlacement","QueueItemState","id","prompt","parts","EMPTY_QUEUE_ITEMS","Object","freeze","QueueItemMethods","getState","steer","move","placement","remove","QueueItemMeta","source","query","type","index","QueueItemClientSchema","methods","meta"],"sources":["../../../src/store/scopes/queue-item.ts"],"sourcesContent":["import type { FileMessagePart, TextMessagePart } from \"../../types/message\";\nimport type { QueuePlacement } from \"../../runtime/queue/external-thread-queue-adapter\";\n\nexport type QueueItemState = {\n  readonly id: string;\n  /** @deprecated Derive from the text parts of `parts` instead. Removal after 2026-11-05. */\n  readonly prompt: string;\n  readonly parts: readonly (FileMessagePart | TextMessagePart)[];\n};\n\nexport const EMPTY_QUEUE_ITEMS: readonly QueueItemState[] = Object.freeze([]);\n\nexport type QueueItemMethods = {\n  getState(): QueueItemState;\n  /** @deprecated Use `move({ lane: \"steer\", insertAfter: null })` instead. Removal after 2026-11-05. */\n  steer(): void;\n  move(placement: QueuePlacement): void;\n  remove(): void;\n};\n\nexport type QueueItemMeta = {\n  source: \"composer\";\n  query: { type: \"index\"; index: number } | { type: \"id\"; id: string };\n};\n\nexport type QueueItemClientSchema = {\n  methods: QueueItemMethods;\n  meta: QueueItemMeta;\n};\n"],"mappings":";AAUA,MAAaO,oBAA+CC,OAAOC,OAAO,CAAA,CAAE"}