@assistant-ui/core 0.2.0 → 0.2.3

package/src/tests/composer-can-send.test.ts

@@ -0,0 +1,112 @@
+import { describe, expect, it, vi } from "vitest";
+import { DefaultThreadComposerRuntimeCore } from "../runtime/base/default-thread-composer-runtime-core";
+import { DefaultEditComposerRuntimeCore } from "../runtime/base/default-edit-composer-runtime-core";
+import type { ThreadRuntimeCore } from "../runtime/interfaces/thread-runtime-core";
+import type { ThreadMessage } from "../types/message";
+
+type ThreadRuntimeStub = Omit<ThreadRuntimeCore, "composer"> & {
+  notify: () => void;
+};
+
+const makeRuntimeStub = (
+  overrides: Partial<ThreadRuntimeCore> = {},
+): ThreadRuntimeStub => {
+  const subscribers = new Set<() => void>();
+  const stub = {
+    append: vi.fn(),
+    cancelRun: vi.fn(),
+    subscribe: (cb: () => void) => {
+      subscribers.add(cb);
+      return () => subscribers.delete(cb);
+    },
+    capabilities: { cancel: false },
+    messages: [],
+    isDisabled: false,
+    isSendDisabled: false,
+    isLoading: false,
+    composer: { runConfig: {} },
+    notify: () => {
+      for (const cb of subscribers) cb();
+    },
+    ...overrides,
+  } as unknown as ThreadRuntimeStub;
+  return stub;
+};
+
+const makeUserMessage = (text = "old"): ThreadMessage =>
+  ({
+    id: "msg-1",
+    role: "user",
+    createdAt: new Date(),
+    content: [{ type: "text", text }],
+    attachments: [],
+    metadata: { custom: {} },
+  }) as ThreadMessage;
+
+describe("DefaultThreadComposerRuntimeCore.canSend", () => {
+  it("is false when the composer is empty", () => {
+    const composer = new DefaultThreadComposerRuntimeCore(makeRuntimeStub());
+    expect(composer.canSend).toBe(false);
+  });
+
+  it("is true when in editing mode with non-empty text", () => {
+    const composer = new DefaultThreadComposerRuntimeCore(makeRuntimeStub());
+    composer.setText("hi");
+    expect(composer.canSend).toBe(true);
+  });
+
+  it("is false when the runtime reports isSendDisabled", () => {
+    const composer = new DefaultThreadComposerRuntimeCore(
+      makeRuntimeStub({ isSendDisabled: true }),
+    );
+    composer.setText("hi");
+    expect(composer.canSend).toBe(false);
+  });
+
+  it("notifies subscribers when isSendDisabled flips", () => {
+    const stub = makeRuntimeStub();
+    const composer = new DefaultThreadComposerRuntimeCore(stub);
+    composer.setText("hi");
+    const onChange = vi.fn();
+    composer.subscribe(onChange);
+
+    (stub as { isSendDisabled: boolean }).isSendDisabled = true;
+    stub.notify();
+    expect(onChange).toHaveBeenCalled();
+    expect(composer.canSend).toBe(false);
+  });
+});
+
+describe("BaseComposerRuntimeCore.send", () => {
+  it("is a no-op when canSend is false because of isSendDisabled", async () => {
+    const stub = makeRuntimeStub({ isSendDisabled: true });
+    const composer = new DefaultThreadComposerRuntimeCore(stub);
+    composer.setText("hi");
+
+    await composer.send();
+
+    expect(stub.append).not.toHaveBeenCalled();
+  });
+
+  it("dispatches when canSend is true", async () => {
+    const stub = makeRuntimeStub();
+    const composer = new DefaultThreadComposerRuntimeCore(stub);
+    composer.setText("hi");
+
+    await composer.send();
+
+    expect(stub.append).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe("DefaultEditComposerRuntimeCore.canSend", () => {
+  it("ignores runtime.isSendDisabled (thread-scoped flag does not block edits)", () => {
+    const stub = makeRuntimeStub({ isSendDisabled: true });
+    const composer = new DefaultEditComposerRuntimeCore(stub, () => {}, {
+      parentId: null,
+      message: makeUserMessage("seed"),
+    });
+
+    expect(composer.canSend).toBe(true);
+  });
+});

package/src/tests/external-store-thread-list-runtime-core.test.ts

@@ -146,6 +146,33 @@ describe("ExternalStoreThreadListRuntimeCore - __internal_setAdapter", () => {
     core.__internal_setAdapter(makeAdapter({ threadId: "thread-beta" }));
     expect(callback).toHaveBeenCalled();
   });
+
+  it("synthesizes mainThreadId entry after a switch to a threadId not in the threads list (regression: #3971)", () => {
+    const core = new ExternalStoreThreadListRuntimeCore(
+      makeAdapter({ threadId: "thread-alpha" }),
+      makeFactory(),
+    );
+    core.__internal_setAdapter(makeAdapter({ threadId: "thread-beta" }));
+    const item = core.getItemById("thread-beta");
+    expect(item).toBeDefined();
+    expect(item?.id).toBe("thread-beta");
+  });
+
+  it("does not retain stale synthesized entries across mainThreadId switches (regression: #3971)", () => {
+    const core = new ExternalStoreThreadListRuntimeCore(
+      makeAdapter({ threadId: "thread-alpha" }),
+      makeFactory(),
+    );
+    core.__internal_setAdapter(makeAdapter({ threadId: "thread-beta" }));
+    core.__internal_setAdapter(makeAdapter({ threadId: "thread-gamma" }));
+    expect(core.getItemById("thread-alpha")).toBeUndefined();
+    expect(core.getItemById("thread-beta")).toBeUndefined();
+    expect(core.getItemById("thread-gamma")).toBeDefined();
+    expect(Object.keys(core.threadItems).sort()).toEqual([
+      "DEFAULT_THREAD_ID",
+      "thread-gamma",
+    ]);
+  });
 });
 
 describe("ExternalStoreThreadListRuntimeCore - isMain via ThreadListRuntimeImpl", () => {
@@ -187,6 +214,13 @@ describe("ExternalStoreThreadListRuntimeCore - isMain via ThreadListRuntimeImpl"
     expect(state.mainThreadId).toBe("thread-alpha");
     expect(state.threadIds).toEqual(["thread-alpha", "thread-beta"]);
   });
+
+  it("does not throw when adapter.threadId has no matching threads entry (regression: #3971)", () => {
+    const impl = buildImpl({ threadId: "thread-alpha" });
+    expect(impl.mainItem.getState().id).toBe("thread-alpha");
+    expect(impl.mainItem.getState().isMain).toBe(true);
+    expect(impl.mainItem.getState().status).toBe("regular");
+  });
 });
 
 describe("ExternalStoreThreadListRuntimeCore - switchToThread", () => {

package/src/tests/external-store-thread-runtime-core.test.ts

@@ -150,3 +150,116 @@ describe("ExternalStoreThreadRuntimeCore - state reference stability", () => {
     expect(runtime.capabilities).toBe(capsBefore);
   });
 });
+
+describe("ExternalStoreThreadRuntimeCore - messages reconciliation", () => {
+  const user = { id: "u", role: "user" as const, content: [] };
+
+  it("drops ids that disappear between syncs (same length, swapped assistant id)", () => {
+    const a1 = { id: "a1", role: "assistant" as const, content: [] };
+    const a2 = { id: "a2", role: "assistant" as const, content: [] };
+
+    const runtime = new ExternalStoreThreadRuntimeCore(
+      mockContextProvider,
+      makeStore({ messages: [user, a1] }),
+    );
+
+    runtime.__internal_setAdapter(makeStore({ messages: [user, a2] }));
+
+    const exported = runtime.export();
+    expect(exported.messages.map((m) => m.message.id)).toEqual(["u", "a2"]);
+    const userChildren = exported.messages
+      .filter((m) => m.parentId === "u")
+      .map((m) => m.message.id);
+    expect(userChildren).toEqual(["a2"]);
+  });
+
+  it("keeps prior ids when they remain in the new sync", () => {
+    const a = { id: "a", role: "assistant" as const, content: [] };
+
+    const runtime = new ExternalStoreThreadRuntimeCore(
+      mockContextProvider,
+      makeStore({ messages: [user, a] }),
+    );
+
+    runtime.__internal_setAdapter(makeStore({ messages: [user, a] }));
+
+    expect(runtime.export().messages.map((m) => m.message.id)).toEqual([
+      "u",
+      "a",
+    ]);
+  });
+
+  it("removes trailing messages dropped from the new sync", () => {
+    const a = { id: "a", role: "assistant" as const, content: [] };
+    const u2 = { id: "u2", role: "user" as const, content: [] };
+
+    const runtime = new ExternalStoreThreadRuntimeCore(
+      mockContextProvider,
+      makeStore({ messages: [user, a, u2] }),
+    );
+
+    runtime.__internal_setAdapter(makeStore({ messages: [user, a] }));
+
+    expect(runtime.export().messages.map((m) => m.message.id)).toEqual([
+      "u",
+      "a",
+    ]);
+  });
+
+  it("does not crash on the next sync after cancelRun removes a leaf user", () => {
+    const userWithText = {
+      id: "u",
+      role: "user" as const,
+      content: [{ type: "text" as const, text: "hi" }],
+    };
+
+    const runtime = new ExternalStoreThreadRuntimeCore(
+      mockContextProvider,
+      makeStore({
+        messages: [userWithText],
+        onCancel: vi.fn(),
+        isRunning: true,
+      }),
+    );
+
+    runtime.cancelRun();
+
+    expect(() => {
+      runtime.__internal_setAdapter(makeStore({ messages: [] }));
+    }).not.toThrow();
+  });
+
+  it("drops phantom sibling when convertMessage swaps the assistant id", () => {
+    type Raw = { id: string; role: "user" | "assistant"; text: string };
+    const rawU: Raw = { id: "u", role: "user", text: "hi" };
+    const rawA1: Raw = { id: "client_id", role: "assistant", text: "" };
+    const rawA2: Raw = { id: "server_id", role: "assistant", text: "" };
+
+    const convertMessage = (m: Raw) => ({
+      id: m.id,
+      role: m.role,
+      content: [{ type: "text" as const, text: m.text }],
+    });
+
+    const runtime = new ExternalStoreThreadRuntimeCore(
+      mockContextProvider,
+      makeStore({
+        messages: [rawU, rawA1] as any,
+        convertMessage: convertMessage as any,
+      }),
+    );
+
+    runtime.__internal_setAdapter(
+      makeStore({
+        messages: [rawU, rawA2] as any,
+        convertMessage: convertMessage as any,
+      }),
+    );
+
+    const userChildren = runtime
+      .export()
+      .messages.filter((m) => m.parentId === "u")
+      .map((m) => m.message.id);
+    expect(userChildren).toEqual(["server_id"]);
+  });
+});

package/src/types/index.ts

@@ -2,12 +2,14 @@ export type {
   // Message parts
   TextMessagePart,
   ReasoningMessagePart,
+  SourceProviderMetadata,
   SourceMessagePart,
   ImageMessagePart,
   FileMessagePart,
   DataMessagePart,
   Unstable_AudioMessagePart,
   ToolCallMessagePart,
+  ToolModelContentPart,
   ThreadUserMessagePart,
   ThreadAssistantMessagePart,
   // Message status

package/src/types/message.ts

@@ -2,8 +2,11 @@ import type {
   ReadonlyJSONObject,
   ReadonlyJSONValue,
 } from "assistant-stream/utils";
+import type { ToolModelContentPart } from "assistant-stream";
 import type { CompleteAttachment } from "./attachment";
 
+export type { ToolModelContentPart };
+
 export type TextMessagePart = {
   readonly type: "text";
   readonly text: string;
@@ -16,15 +19,32 @@ export type ReasoningMessagePart = {
   readonly parentId?: string;
 };
 
-export type SourceMessagePart = {
-  readonly type: "source";
-  readonly sourceType: "url";
-  readonly id: string;
-  readonly url: string;
-  readonly title?: string;
-  readonly parentId?: string;
+export type SourceProviderMetadata = {
+  readonly [providerName: string]: ReadonlyJSONObject;
 };
 
+export type SourceMessagePart =
+  | {
+      readonly type: "source";
+      readonly sourceType: "url";
+      readonly id: string;
+      readonly url: string;
+      readonly title?: string;
+      readonly providerMetadata?: SourceProviderMetadata;
+      readonly parentId?: string;
+    }
+  | {
+      readonly type: "source";
+      readonly sourceType: "document";
+      readonly id: string;
+      readonly url?: undefined;
+      readonly title: string;
+      readonly mediaType: string;
+      readonly filename?: string;
+      readonly providerMetadata?: SourceProviderMetadata;
+      readonly parentId?: string;
+    };
+
 export type ImageMessagePart = {
   readonly type: "image";
   readonly image: string;
@@ -53,20 +73,57 @@ export type DataMessagePart<T = any> = {
   readonly data: T;
 };
 
+export type McpAppMetadata = {
+  readonly resourceUri: string;
+  readonly mimeType?: string;
+  readonly visibility?: readonly ("model" | "app")[];
+};
+
+export const MCP_APP_URI_SCHEME = "ui://";
+
+export const isMcpAppUri = (uri: string | undefined): boolean =>
+  !!uri?.startsWith(MCP_APP_URI_SCHEME);
+
+export type ToolCallMessagePartMcpMetadata = {
+  readonly app?: McpAppMetadata;
+};
+
 export type ToolCallMessagePart<
   TArgs = ReadonlyJSONObject,
   TResult = unknown,
 > = {
+  /** Identifies this part as a tool call. */
   readonly type: "tool-call";
+  /** Stable identifier for this invocation of the tool. */
   readonly toolCallId: string;
+  /** Name of the tool requested by the model. */
   readonly toolName: string;
+  /**
+   * Arguments supplied by the model. During streaming this is a partial parse:
+   * fields may be missing or incomplete. From a tool-call renderer, use
+   * `useToolArgsStatus` to detect which fields are still arriving.
+   */
   readonly args: TArgs;
+  /** Result returned by the tool, if it has completed. */
   readonly result?: TResult | undefined;
+  /** Whether the result represents a tool execution error. */
   readonly isError?: boolean | undefined;
+  /** Raw JSON argument text streamed by the model. */
   readonly argsText: string;
+  /** UI-only artifact associated with the tool result. */
   readonly artifact?: unknown;
+  /** MCP app metadata associated with this tool call, when present. */
+  readonly mcp?: ToolCallMessagePartMcpMetadata;
+  /** Content returned to the model for this tool result. */
+  readonly modelContent?: readonly ToolModelContentPart[] | undefined;
+  /** Human-input request that must be resolved before the run can continue. */
   readonly interrupt?: { type: "human"; payload: unknown };
+  /** Parent message-part ID when this part belongs to a nested structure. */
   readonly parentId?: string;
+  /**
+   * Nested thread messages produced by this tool call, for example a sub-agent
+   * conversation.
+   */
   readonly messages?: readonly ThreadMessage[];
 };
 
@@ -106,7 +163,9 @@ export type MessagePartStatus =
 
 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";
     }
   | MessagePartStatus;