@assistant-ui/core 0.2.0 → 0.2.3

package/src/react/types/MessagePartComponentTypes.ts

@@ -57,10 +57,21 @@ export type ToolCallMessagePartProps<
   TResult = unknown,
 > = MessagePartState &
   ToolCallMessagePart<TArgs, TResult> & {
+    /**
+     * Sets the result for this tool-call message part.
+     *
+     * Use when the renderer, rather than a tool `execute` function, is the
+     * source of the result.
+     */
     addResult: (result: TResult | ToolResponse<TResult>) => void;
+    /**
+     * Supplies the payload requested by `context.human(...)` and resumes the
+     * paused frontend tool execution.
+     */
     resume: (payload: unknown) => void;
   };
 
+/** Component used to render a tool-call message part. */
 export type ToolCallMessagePartComponent<
   TArgs = any,
   TResult = any,

package/src/react/types/scopes/tools.ts

@@ -1,8 +1,13 @@
 import type { ToolCallMessagePartComponent } from "../MessagePartComponentTypes";
 import type { Unsubscribe } from "../../..";
 
+export type McpAppResourceOutput = {
+  readonly render: ToolCallMessagePartComponent;
+};
+
 export type ToolsState = {
   tools: Record<string, ToolCallMessagePartComponent[]>;
+  mcpApp?: McpAppResourceOutput | undefined;
 };
 
 export type ToolsMethods = {

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

@@ -41,6 +41,7 @@ export type {
 
 type BaseComposerState = {
   readonly canCancel: boolean;
+  readonly canSend: boolean;
   readonly isEditing: boolean;
   readonly isEmpty: boolean;
 
@@ -86,6 +87,7 @@ const getThreadComposerState = (
 
     isEditing: runtime?.isEditing ?? false,
     canCancel: runtime?.canCancel ?? false,
+    canSend: runtime?.canSend ?? false,
     isEmpty: runtime?.isEmpty ?? true,
 
     attachments: runtime?.attachments ?? EMPTY_ARRAY,
@@ -108,6 +110,7 @@ const getEditComposerState = (
 
     isEditing: runtime?.isEditing ?? false,
     canCancel: runtime?.canCancel ?? false,
+    canSend: runtime?.canSend ?? false,
     isEmpty: runtime?.isEmpty ?? true,
 
     text: runtime?.text ?? "",

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

@@ -52,6 +52,7 @@ export abstract class BaseComposerRuntimeCore
   }
 
   public abstract get canCancel(): boolean;
+  public abstract get canSend(): boolean;
 
   public get isEmpty() {
     return !this.text.trim() && !this.attachments.length;
@@ -157,7 +158,7 @@ export abstract class BaseComposerRuntimeCore
   }
 
   public async send(options?: SendOptions) {
-    if (this.isEmpty) return;
+    if (!this.canSend) return;
 
     if (this._dictationSession) {
       this._dictationSession.cancel();

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

@@ -48,6 +48,7 @@ export abstract class BaseThreadRuntimeCore implements ThreadRuntimeCore {
   protected readonly repository = new MessageRepository();
   public abstract get adapters(): BaseThreadAdapters | undefined;
   public abstract get isDisabled(): boolean;
+  public abstract get isSendDisabled(): boolean;
   public abstract get isLoading(): boolean;
   public abstract get suggestions(): readonly ThreadSuggestion[];
   public abstract get extras(): unknown;

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

@@ -13,6 +13,10 @@ export class DefaultEditComposerRuntimeCore extends BaseComposerRuntimeCore {
     return true;
   }
 
+  public get canSend() {
+    return !this.isEmpty;
+  }
+
   protected getAttachmentAdapter() {
     return this.runtime.adapters?.attachments;
   }

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

@@ -17,6 +17,10 @@ export class DefaultThreadComposerRuntimeCore
     return this._canCancel;
   }
 
+  public get canSend() {
+    return !this.isEmpty && !this.runtime.isSendDisabled;
+  }
+
   protected getAttachmentAdapter() {
     return this.runtime.adapters?.attachments;
   }
@@ -40,11 +44,18 @@ export class DefaultThreadComposerRuntimeCore
   }
 
   public connect() {
+    let lastIsSendDisabled = this.runtime.isSendDisabled;
     return this.runtime.subscribe(() => {
+      let changed = false;
       if (this.canCancel !== this.runtime.capabilities.cancel) {
         this._canCancel = this.runtime.capabilities.cancel;
-        this._notifySubscribers();
+        changed = true;
+      }
+      if (lastIsSendDisabled !== this.runtime.isSendDisabled) {
+        lastIsSendDisabled = this.runtime.isSendDisabled;
+        changed = true;
       }
+      if (changed) this._notifySubscribers();
     });
   }
 

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

@@ -51,6 +51,7 @@ export type ComposerRuntimeCore = Readonly<{
   isEditing: boolean;
 
   canCancel: boolean;
+  canSend: boolean;
   isEmpty: boolean;
 
   attachments: readonly Attachment[];

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

@@ -158,6 +158,12 @@ export type ThreadRuntimeCore = Readonly<{
 
   capabilities: Readonly<RuntimeCapabilities>;
   isDisabled: boolean;
+  /**
+   * Whether sending from this thread's composer is disabled. Surfaces the
+   * `isSendDisabled` flag from external-store adapters; internal runtimes
+   * default to `false`. Composer state derives `canSend` from this.
+   */
+  isSendDisabled: boolean;
   isLoading: boolean;
   /**
    * Optional explicit thread-level running flag. When provided, takes

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

@@ -53,6 +53,7 @@ export class ExternalStoreThreadRuntimeCore
   implements ThreadRuntimeCore
 {
   private _assistantOptimisticId: string | null = null;
+  private _lastSyncedMessageIds = new Set<string>();
 
   private _capabilities: RuntimeCapabilities = {
     switchToBranch: false,
@@ -75,6 +76,7 @@ export class ExternalStoreThreadRuntimeCore
 
   private _messages!: readonly ThreadMessage[];
   public isDisabled!: boolean;
+  public isSendDisabled!: boolean;
   public get isLoading() {
     return this._store.isLoading ?? false;
   }
@@ -122,6 +124,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;
@@ -168,6 +171,7 @@ export class ExternalStoreThreadRuntimeCore
       // Clear and import the message repository
       this.repository.clear();
       this._assistantOptimisticId = null;
+      this._lastSyncedMessageIds = new Set();
       this.repository.import(store.messageRepository);
 
       messages = this.repository.getMessages();
@@ -220,6 +224,12 @@ export class ExternalStoreThreadRuntimeCore
             return newMessage;
           });
 
+      const nextIds = new Set(messages.map((m) => m.id));
+      for (const prevId of this._lastSyncedMessageIds) {
+        if (!nextIds.has(prevId)) this.repository.deleteMessage(prevId);
+      }
+      this._lastSyncedMessageIds = nextIds;
+
       for (let i = 0; i < messages.length; i++) {
         const message = messages[i]!;
         const parent = messages[i - 1];
@@ -334,6 +344,7 @@ export class ExternalStoreThreadRuntimeCore
       previousMessage.id === messages.at(-1)?.id // ensure the previous message is a leaf node
     ) {
       this.repository.deleteMessage(previousMessage.id);
+      this._lastSyncedMessageIds.delete(previousMessage.id);
       if (!this.composer.text.trim()) {
         this.composer.setText(getThreadMessageText(previousMessage));
       }
@@ -362,6 +373,7 @@ export class ExternalStoreThreadRuntimeCore
   }
 
   public override reset(initialMessages?: readonly ThreadMessageLike[]) {
+    this._lastSyncedMessageIds = new Set();
     const repo = new MessageRepository();
     repo.import(ExportedMessageRepository.fromArray(initialMessages ?? []));
     this.updateMessages(repo.getMessages());
@@ -369,6 +381,7 @@ export class ExternalStoreThreadRuntimeCore
 
   public override import(data: ExportedMessageRepository) {
     this._assistantOptimisticId = null;
+    this._lastSyncedMessageIds = new Set();
 
     super.import(data);
 

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/model-context-client.test.ts

@@ -0,0 +1,108 @@
+import { describe, it, expect } from "vitest";
+import { createResourceRoot } from "@assistant-ui/tap";
+import type { Tool } from "assistant-stream";
+import { ModelContext } from "./model-context-client";
+import type {
+  ModelContext as ModelContextValue,
+  ModelContextProvider,
+} from "../../model-context/types";
+
+const tick = () => new Promise<void>((resolve) => setTimeout(resolve, 0));
+
+const provider = (ctx: ModelContextValue): ModelContextProvider => ({
+  getModelContext: () => ctx,
+});
+
+const stubTool = (): Tool<any, any> =>
+  ({ description: "", parameters: {} as any }) as unknown as Tool<any, any>;
+
+const render = () => {
+  const root = createResourceRoot();
+  const sub = root.render(ModelContext());
+  return { sub, unmount: () => root.unmount() };
+};
+
+describe("ModelContext", () => {
+  it("starts with undefined modelName and an empty toolNames array", () => {
+    const { sub, unmount } = render();
+    try {
+      const state = sub.getValue().getState();
+      expect(state.modelName).toBeUndefined();
+      expect(state.toolNames).toEqual([]);
+    } finally {
+      unmount();
+    }
+  });
+
+  it("reflects modelName from a registered provider", async () => {
+    const { sub, unmount } = render();
+    try {
+      sub.getValue().register(provider({ config: { modelName: "gpt-4" } }));
+      await tick();
+
+      expect(sub.getValue().getState().modelName).toBe("gpt-4");
+    } finally {
+      unmount();
+    }
+  });
+
+  it("reflects tool names from a registered provider", async () => {
+    const { sub, unmount } = render();
+    try {
+      sub
+        .getValue()
+        .register(provider({ tools: { foo: stubTool(), bar: stubTool() } }));
+      await tick();
+
+      expect(sub.getValue().getState().toolNames).toEqual(["bar", "foo"]);
+    } finally {
+      unmount();
+    }
+  });
+
+  it("keeps the same state reference when an extra provider does not change the merged values", async () => {
+    const { sub, unmount } = render();
+    try {
+      sub.getValue().register(provider({ config: { modelName: "gpt-4" } }));
+      await tick();
+      const before = sub.getValue().getState();
+
+      sub.getValue().register(provider({ config: { modelName: "gpt-4" } }));
+      await tick();
+      const after = sub.getValue().getState();
+
+      expect(after).toBe(before);
+    } finally {
+      unmount();
+    }
+  });
+
+  it("clears modelName when the last contributing provider unsubscribes", async () => {
+    const { sub, unmount } = render();
+    try {
+      const unsubscribe = sub
+        .getValue()
+        .register(provider({ config: { modelName: "gpt-4" } }));
+      await tick();
+      expect(sub.getValue().getState().modelName).toBe("gpt-4");
+
+      unsubscribe();
+      await tick();
+      expect(sub.getValue().getState().modelName).toBeUndefined();
+      expect(sub.getValue().getState().toolNames).toEqual([]);
+    } finally {
+      unmount();
+    }
+  });
+
+  it("reflects modelName synchronously after register without awaiting", () => {
+    const { sub, unmount } = render();
+    try {
+      sub.getValue().register(provider({ config: { modelName: "gpt-4" } }));
+
+      expect(sub.getValue().getState().modelName).toBe("gpt-4");
+    } finally {
+      unmount();
+    }
+  });
+});

package/src/store/clients/model-context-client.ts

@@ -1,18 +1,48 @@
-import { resource, tapMemo, tapState } from "@assistant-ui/tap";
+import { resource, tapEffect, tapMemo, tapState } from "@assistant-ui/tap";
 import type { ClientOutput } from "@assistant-ui/store";
 import { CompositeContextProvider } from "../../utils/composite-context-provider";
 import type { ModelContextState } from "../scopes/model-context";
 
-const version = 1;
+const EMPTY_TOOL_NAMES: readonly string[] = [];
+
+const INITIAL_STATE: ModelContextState = {
+  modelName: undefined,
+  toolNames: EMPTY_TOOL_NAMES,
+};
+
+const toolNamesEqual = (a: readonly string[], b: readonly string[]): boolean =>
+  a === b || (a.length === b.length && a.every((v, i) => v === b[i]));
+
+const deriveState = (
+  composite: CompositeContextProvider,
+  prev: ModelContextState,
+): ModelContextState => {
+  const ctx = composite.getModelContext();
+  const modelName = ctx.config?.modelName;
+  const keys = ctx.tools ? Object.keys(ctx.tools).sort() : EMPTY_TOOL_NAMES;
+  const toolNames = keys.length ? keys : EMPTY_TOOL_NAMES;
+
+  if (modelName === prev.modelName && toolNamesEqual(toolNames, prev.toolNames))
+    return prev;
+
+  return { modelName, toolNames };
+};
 
 export const ModelContext = resource((): ClientOutput<"modelContext"> => {
-  const [state] = tapState<ModelContextState>(
-    () => ({ version: version + 1 }) as unknown as ModelContextState,
-  );
   const composite = tapMemo(() => new CompositeContextProvider(), []);
+  const [state, setState] = tapState<ModelContextState>(() =>
+    deriveState(composite, INITIAL_STATE),
+  );
+
+  tapEffect(() => {
+    setState((prev) => deriveState(composite, prev));
+    return composite.subscribe(() => {
+      setState((prev) => deriveState(composite, prev));
+    });
+  }, [composite]);
 
   return {
-    getState: () => state,
+    getState: () => deriveState(composite, state),
     getModelContext: () => composite.getModelContext(),
     subscribe: (callback) => composite.subscribe(callback),
     register: (provider) => composite.registerModelContextProvider(provider),

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/store/scopes/model-context.ts

@@ -1,7 +1,10 @@
 import type { Unsubscribe } from "../../types/unsubscribe";
 import type { ModelContextProvider } from "../../model-context/types";
 
-export type ModelContextState = Record<string, never>;
+export type ModelContextState = {
+  readonly modelName?: string | undefined;
+  readonly toolNames: readonly string[];
+};
 
 export type ModelContextMethods = ModelContextProvider & {
   getState(): ModelContextState;

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,
+          },
+        },
+      },
+    ]);
+  });
+});