@assistant-ui/core 0.1.17 → 0.2.2

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[];