@assistant-ui/core 0.2.0 → 0.2.2

package/src/runtimes/external-store/external-store-adapter.ts

@@ -59,7 +59,22 @@ type ExternalStoreMessageConverterAdapter<T> = {
 };
 
 type ExternalStoreAdapterBase<T> = {
+  /**
+   * Whether the entire thread is disabled. When `true`, the composer's input
+   * is also disabled (the user cannot type, attach files, or submit). For a
+   * narrower gate that keeps the input usable but blocks only sending, use
+   * `isSendDisabled`.
+   */
   isDisabled?: boolean | undefined;
+  /**
+   * Whether sending new messages is currently disabled. When `true`, the
+   * thread composer's input remains usable but `send()` becomes a no-op
+   * and the thread composer's `canSend` is `false`. Use this to gate
+   * sending on external React state (e.g. while tool config is loading)
+   * without disabling the input itself the way `isDisabled` does. Edit
+   * composers (saving message edits) intentionally ignore this flag.
+   */
+  isSendDisabled?: boolean | undefined;
   /**
    * Whether the thread is running. When provided, this value flows directly
    * to `thread.isRunning`, letting the application keep the thread in a

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

@@ -78,14 +78,7 @@ export class ExternalStoreThreadListRuntimeCore
   }
 
   public getItemById(threadId: string) {
-    for (const thread of this.adapter.threads ?? []) {
-      if (thread.id === threadId) return thread as any;
-    }
-    for (const thread of this.adapter.archivedThreads ?? []) {
-      if (thread.id === threadId) return thread as any;
-    }
-    if (threadId === DEFAULT_THREAD_ID) return DEFAULT_THREAD;
-    return undefined;
+    return this._threadData[threadId];
   }
 
   public __internal_setAdapter(
@@ -115,7 +108,8 @@ export class ExternalStoreThreadListRuntimeCore
 
     if (
       previousThreads !== newThreads ||
-      previousArchivedThreads !== newArchivedThreads
+      previousArchivedThreads !== newArchivedThreads ||
+      previousThreadId !== newThreadId
     ) {
       this._threadData = {
         ...DEFAULT_THREAD_DATA,
@@ -159,6 +153,18 @@ export class ExternalStoreThreadListRuntimeCore
       this._mainThread = this.threadFactory();
     }
 
+    if (!this._threadData[this._mainThreadId]) {
+      this._threadData = {
+        ...this._threadData,
+        [this._mainThreadId]: {
+          id: this._mainThreadId,
+          remoteId: undefined,
+          externalId: undefined,
+          status: "regular",
+        },
+      };
+    }
+
     this._notifySubscribers();
   }
 

package/src/runtimes/external-store/external-store-thread-runtime-core.ts

@@ -75,6 +75,7 @@ export class ExternalStoreThreadRuntimeCore
 
   private _messages!: readonly ThreadMessage[];
   public isDisabled!: boolean;
+  public isSendDisabled!: boolean;
   public get isLoading() {
     return this._store.isLoading ?? false;
   }
@@ -122,6 +123,7 @@ export class ExternalStoreThreadRuntimeCore
 
     const isRunning = store.isRunning ?? false;
     this.isDisabled = store.isDisabled ?? false;
+    this.isSendDisabled = store.isSendDisabled ?? false;
 
     const oldStore = this._store as ExternalStoreAdapter<any> | undefined;
     this._store = store;

package/src/runtimes/local/local-thread-runtime-core.ts

@@ -54,6 +54,7 @@ export class LocalThreadRuntimeCore
   private abortController: AbortController | null = null;
 
   public readonly isDisabled = false;
+  public readonly isSendDisabled = false;
 
   private _isLoading = false;
   public get isLoading() {

package/src/runtimes/readonly/ReadonlyThreadRuntimeCore.ts

@@ -118,6 +118,7 @@ export class ReadonlyThreadRuntimeCore
 
     isEditing: false as const,
     canCancel: false,
+    canSend: false,
     isEmpty: true,
     text: "",
 
@@ -205,6 +206,7 @@ export class ReadonlyThreadRuntimeCore
   } as const;
 
   isDisabled = false;
+  isSendDisabled = false;
   isLoading = false;
 
   state = null;

package/src/runtimes/remote-thread-list/empty-thread-core.ts

@@ -98,6 +98,7 @@ export const EMPTY_THREAD_CORE: ThreadRuntimeCore = {
     isEditing: true,
 
     canCancel: false,
+    canSend: false,
     isEmpty: true,
 
     text: "",
@@ -186,6 +187,7 @@ export const EMPTY_THREAD_CORE: ThreadRuntimeCore = {
   },
 
   isDisabled: false,
+  isSendDisabled: false,
   isLoading: true,
 
   messages: [],

package/src/store/clients/no-op-composer-client.ts

@@ -14,6 +14,7 @@ export const NoOpComposerClient = resource(
         role: "user",
         runConfig: {},
         canCancel: false,
+        canSend: false,
         type: type,
         dictation: undefined,
         quote: undefined,

package/src/store/runtime-clients/composer-runtime-client.ts

@@ -103,6 +103,7 @@ export const ComposerClient = resource(
         runConfig: runtimeState.runConfig,
         isEditing: runtimeState.isEditing,
         canCancel: runtimeState.canCancel,
+        canSend: runtimeState.canSend,
         attachmentAccept: runtimeState.attachmentAccept,
         isEmpty: runtimeState.isEmpty,
         type: runtimeState.type ?? "thread",

package/src/store/scopes/composer.ts

@@ -26,6 +26,15 @@ export type ComposerState = {
   readonly runConfig: RunConfig;
   readonly isEditing: boolean;
   readonly canCancel: boolean;
+  /**
+   * Whether the composer is currently willing to send. `true` when the
+   * composer is in editing mode and has non-empty content; for thread
+   * composers also requires the thread's `isSendDisabled` flag to be unset.
+   * Edit composers (saving message edits) ignore `isSendDisabled` since it
+   * is a thread-scoped gate. Cross-thread gating (running, queue capability)
+   * is layered on top by `useComposerSend`.
+   */
+  readonly canSend: boolean;
   readonly attachmentAccept: string;
   readonly isEmpty: boolean;
   readonly type: "thread" | "edit";

package/src/tests/auiV0Encode.test.ts

@@ -0,0 +1,55 @@
+import { describe, expect, it } from "vitest";
+import { auiV0Encode } from "../react/runtimes/cloud/auiV0";
+
+describe("auiV0Encode", () => {
+  it("preserves document source parts in the core cloud encoder", () => {
+    const encoded = auiV0Encode({
+      id: "m1",
+      createdAt: new Date("2026-03-15T00:00:00.000Z"),
+      role: "assistant",
+      status: { type: "complete", reason: "stop" },
+      metadata: {
+        unstable_state: undefined,
+        unstable_annotations: [],
+        unstable_data: [],
+        steps: [],
+        custom: {},
+      },
+      content: [
+        {
+          type: "source",
+          sourceType: "document",
+          id: "doc_123",
+          title: "proposal.pdf",
+          mediaType: "application/pdf",
+          filename: "proposal.pdf",
+          providerMetadata: {
+            openai: {
+              type: "file_citation",
+              fileId: "file_123",
+              index: 0,
+            },
+          },
+        },
+      ],
+    });
+
+    expect(encoded.content).toEqual([
+      {
+        type: "source",
+        sourceType: "document",
+        id: "doc_123",
+        title: "proposal.pdf",
+        mediaType: "application/pdf",
+        filename: "proposal.pdf",
+        providerMetadata: {
+          openai: {
+            type: "file_citation",
+            fileId: "file_123",
+            index: 0,
+          },
+        },
+      },
+    ]);
+  });
+});

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/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,6 +73,21 @@ 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,
@@ -65,6 +100,8 @@ export type ToolCallMessagePart<
   readonly isError?: boolean | undefined;
   readonly argsText: string;
   readonly artifact?: unknown;
+  readonly mcp?: ToolCallMessagePartMcpMetadata;
+  readonly modelContent?: readonly ToolModelContentPart[] | undefined;
   readonly interrupt?: { type: "human"; payload: unknown };
   readonly parentId?: string;
   readonly messages?: readonly ThreadMessage[];