@assistant-ui/react 0.12.10 → 0.12.11

package/src/tests/LocalThreadRuntimeCore.test.ts

@@ -0,0 +1,321 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { LocalThreadRuntimeCore } from "../legacy-runtime/runtime-cores/local/LocalThreadRuntimeCore";
+import type { ChatModelAdapter } from "../legacy-runtime/runtime-cores/local/ChatModelAdapter";
+import type { LocalRuntimeOptionsBase } from "../legacy-runtime/runtime-cores/local/LocalRuntimeOptions";
+import type { ModelContextProvider } from "@assistant-ui/core";
+import type { AppendMessage } from "@assistant-ui/core";
+
+const createMockContextProvider = (): ModelContextProvider => ({
+  getModelContext: () => ({}),
+});
+
+const createOptions = (
+  adapter: ChatModelAdapter,
+  overrides: Partial<LocalRuntimeOptionsBase> = {},
+): LocalRuntimeOptionsBase => ({
+  adapters: { chatModel: adapter },
+  ...overrides,
+});
+
+const createUserAppendMessage = (
+  text: string,
+  overrides: Partial<AppendMessage> = {},
+): AppendMessage => ({
+  role: "user",
+  content: [{ type: "text", text }],
+  attachments: [],
+  metadata: { custom: {} },
+  parentId: null,
+  sourceId: null,
+  runConfig: undefined,
+  createdAt: new Date(),
+  ...overrides,
+});
+
+describe("LocalThreadRuntimeCore", () => {
+  let contextProvider: ModelContextProvider;
+
+  beforeEach(() => {
+    contextProvider = createMockContextProvider();
+  });
+
+  it("appends a user message and runs the chat model", async () => {
+    const adapter: ChatModelAdapter = {
+      run: vi.fn().mockResolvedValue({
+        content: [{ type: "text", text: "Hello!" }],
+        status: { type: "complete", reason: "stop" },
+      }),
+    };
+    const core = new LocalThreadRuntimeCore(
+      contextProvider,
+      createOptions(adapter),
+    );
+
+    await core.append(createUserAppendMessage("Hi"));
+
+    const messages = core.messages;
+    expect(messages).toHaveLength(2);
+    expect(messages[0]!.role).toBe("user");
+    expect(messages[1]!.role).toBe("assistant");
+    expect(messages[1]!.content).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ type: "text", text: "Hello!" }),
+      ]),
+    );
+    expect(messages[1]!.status).toEqual({ type: "complete", reason: "stop" });
+    expect(adapter.run).toHaveBeenCalledOnce();
+  });
+
+  it("streams assistant response via async generator", async () => {
+    const adapter: ChatModelAdapter = {
+      run: vi.fn().mockImplementation(async function* () {
+        yield {
+          content: [{ type: "text" as const, text: "Hel" }],
+        };
+        yield {
+          content: [{ type: "text" as const, text: "Hello world" }],
+          status: { type: "complete" as const, reason: "stop" as const },
+        };
+      }),
+    };
+    const core = new LocalThreadRuntimeCore(
+      contextProvider,
+      createOptions(adapter),
+    );
+
+    await core.append(createUserAppendMessage("Stream test"));
+
+    const messages = core.messages;
+    expect(messages).toHaveLength(2);
+    const assistant = messages[1]!;
+    expect(assistant.role).toBe("assistant");
+    expect(assistant.content).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ type: "text", text: "Hello world" }),
+      ]),
+    );
+    expect(assistant.status).toEqual({ type: "complete", reason: "stop" });
+  });
+
+  it("cancels a running response", async () => {
+    const adapter: ChatModelAdapter = {
+      run: vi.fn().mockImplementation(async function* ({ abortSignal }) {
+        yield {
+          content: [{ type: "text" as const, text: "partial" }],
+        };
+        // Wait until the abort signal fires
+        await new Promise<void>((_resolve, reject) => {
+          if (abortSignal.aborted) {
+            reject(abortSignal.reason);
+            return;
+          }
+          abortSignal.addEventListener(
+            "abort",
+            () => reject(abortSignal.reason),
+            { once: true },
+          );
+        });
+      }),
+    };
+    const core = new LocalThreadRuntimeCore(
+      contextProvider,
+      createOptions(adapter),
+    );
+
+    // Start append but don't await (it will hang until cancelled)
+    const appendPromise = core.append(createUserAppendMessage("Cancel me"));
+
+    // Give the generator time to yield first chunk
+    await new Promise((r) => setTimeout(r, 50));
+
+    core.cancelRun();
+    await appendPromise;
+
+    const messages = core.messages;
+    expect(messages).toHaveLength(2);
+    const assistant = messages[1]!;
+    expect(assistant.status).toBeDefined();
+    expect(assistant.status!.type).toBe("incomplete");
+    if (assistant.status!.type === "incomplete") {
+      expect(assistant.status!.reason).toBe("cancelled");
+    }
+  });
+
+  it("handles adapter errors gracefully", async () => {
+    const adapter: ChatModelAdapter = {
+      run: vi.fn().mockRejectedValue(new Error("Model unavailable")),
+    };
+    const core = new LocalThreadRuntimeCore(
+      contextProvider,
+      createOptions(adapter),
+    );
+
+    await expect(
+      core.append(createUserAppendMessage("Error test")),
+    ).rejects.toThrow("Model unavailable");
+
+    const messages = core.messages;
+    expect(messages).toHaveLength(2);
+    const assistant = messages[1]!;
+    expect(assistant.status).toBeDefined();
+    expect(assistant.status!.type).toBe("incomplete");
+    if (assistant.status!.type === "incomplete") {
+      expect(assistant.status!.reason).toBe("error");
+      expect(assistant.status!.error).toBe("Model unavailable");
+    }
+  });
+
+  it("continues tool execution loop", async () => {
+    let callCount = 0;
+    const adapter: ChatModelAdapter = {
+      run: vi.fn().mockImplementation(() => {
+        callCount++;
+        if (callCount === 1) {
+          return Promise.resolve({
+            content: [
+              {
+                type: "tool-call",
+                toolCallId: "tc1",
+                toolName: "myTool",
+                args: { input: "test" },
+                argsText: '{"input":"test"}',
+              },
+            ],
+            status: { type: "requires-action", reason: "tool-calls" },
+          });
+        }
+        return Promise.resolve({
+          content: [{ type: "text", text: "Done with tool" }],
+          status: { type: "complete", reason: "stop" },
+        });
+      }),
+    };
+    const core = new LocalThreadRuntimeCore(
+      contextProvider,
+      createOptions(adapter),
+    );
+
+    await core.append(createUserAppendMessage("Use a tool"));
+
+    // The assistant message should have a tool-call with no result yet
+    // and status requires-action. Now add the tool result.
+    const assistantMsg = core.messages[1]!;
+    expect(assistantMsg.role).toBe("assistant");
+
+    core.addToolResult({
+      messageId: assistantMsg.id,
+      toolName: "myTool",
+      toolCallId: "tc1",
+      result: "tool output",
+      isError: false,
+    });
+
+    // Wait for the second roundtrip to complete
+    await new Promise((r) => setTimeout(r, 100));
+
+    expect(adapter.run).toHaveBeenCalledTimes(2);
+
+    const finalMessages = core.messages;
+    const finalAssistant = finalMessages[1]!;
+    // Content should include both the tool-call from round 1 and text from round 2
+    expect(finalAssistant.content.some((c) => c.type === "tool-call")).toBe(
+      true,
+    );
+    expect(
+      finalAssistant.content.some(
+        (c) => c.type === "text" && c.text === "Done with tool",
+      ),
+    ).toBe(true);
+  });
+
+  it("stops at maxSteps", async () => {
+    const adapter: ChatModelAdapter = {
+      run: vi.fn().mockResolvedValue({
+        content: [
+          {
+            type: "tool-call",
+            toolCallId: "tc1",
+            toolName: "myTool",
+            args: {},
+            argsText: "{}",
+          },
+        ],
+        status: { type: "requires-action", reason: "tool-calls" },
+        metadata: {
+          steps: [{ usage: { promptTokens: 10, completionTokens: 5 } }],
+        },
+      }),
+    };
+    const core = new LocalThreadRuntimeCore(
+      contextProvider,
+      createOptions(adapter, { maxSteps: 1 }),
+    );
+
+    await core.append(createUserAppendMessage("Tool call"));
+
+    // Add tool result - this should NOT trigger another roundtrip because maxSteps=1
+    const assistantMsg = core.messages[1]!;
+    core.addToolResult({
+      messageId: assistantMsg.id,
+      toolName: "myTool",
+      toolCallId: "tc1",
+      result: "result",
+      isError: false,
+    });
+
+    // Wait a bit to ensure no additional roundtrip happened
+    await new Promise((r) => setTimeout(r, 100));
+
+    // Should have been called only once (the initial run)
+    expect(adapter.run).toHaveBeenCalledTimes(1);
+
+    const finalAssistant = core.messages[1]!;
+    expect(finalAssistant.status).toBeDefined();
+    expect(finalAssistant.status!.type).toBe("incomplete");
+    if (finalAssistant.status!.type === "incomplete") {
+      expect(finalAssistant.status!.reason).toBe("tool-calls");
+    }
+  });
+
+  it("capabilities update from options", () => {
+    const adapter: ChatModelAdapter = {
+      run: vi.fn().mockResolvedValue({ content: [] }),
+    };
+    const core = new LocalThreadRuntimeCore(
+      contextProvider,
+      createOptions(adapter),
+    );
+
+    // Default capabilities
+    expect(core.capabilities.speech).toBe(false);
+    expect(core.capabilities.dictation).toBe(false);
+    expect(core.capabilities.attachments).toBe(false);
+    expect(core.capabilities.feedback).toBe(false);
+
+    // Update with adapters
+    core.__internal_setOptions({
+      adapters: {
+        chatModel: adapter,
+        speech: {} as any,
+        dictation: {} as any,
+        attachments: {} as any,
+        feedback: {} as any,
+      },
+    });
+
+    expect(core.capabilities.speech).toBe(true);
+    expect(core.capabilities.dictation).toBe(true);
+    expect(core.capabilities.attachments).toBe(true);
+    expect(core.capabilities.feedback).toBe(true);
+
+    // Update back to no adapters
+    core.__internal_setOptions({
+      adapters: { chatModel: adapter },
+    });
+
+    expect(core.capabilities.speech).toBe(false);
+    expect(core.capabilities.dictation).toBe(false);
+    expect(core.capabilities.attachments).toBe(false);
+    expect(core.capabilities.feedback).toBe(false);
+  });
+});

package/src/tests/external-message-converter.test.ts

@@ -1,7 +1,7 @@
 import { describe, it, expect } from "vitest";
 import { convertExternalMessages } from "../legacy-runtime/runtime-cores/external-store/external-message-converter";
 import type { useExternalMessageConverter } from "../legacy-runtime/runtime-cores/external-store/external-message-converter";
-import { isErrorMessageId } from "../utils/idUtils";
+import { isErrorMessageId } from "@assistant-ui/core/internal";
 
 describe("convertExternalMessages", () => {
   describe("reasoning part merging", () => {

package/src/tests/shouldContinue.test.ts

@@ -0,0 +1,89 @@
+import type { ThreadAssistantMessage } from "@assistant-ui/core";
+import { describe, expect, it } from "vitest";
+import { shouldContinue } from "../legacy-runtime/runtime-cores/local/shouldContinue";
+
+const makeMessage = (
+  overrides: Partial<ThreadAssistantMessage>,
+): ThreadAssistantMessage => ({
+  id: "msg-1",
+  role: "assistant",
+  createdAt: new Date(),
+  content: [],
+  status: { type: "complete", reason: "stop" },
+  metadata: {
+    unstable_state: null,
+    unstable_annotations: [],
+    unstable_data: [],
+    steps: [],
+    custom: {},
+  },
+  ...overrides,
+});
+
+const toolCall = (toolName: string, result?: unknown) => ({
+  type: "tool-call" as const,
+  toolCallId: `call-${toolName}`,
+  toolName,
+  args: {},
+  argsText: "{}",
+  ...(result !== undefined ? { result } : {}),
+});
+
+describe("shouldContinue", () => {
+  it("returns false when status is not requires-action", () => {
+    const msg = makeMessage({
+      status: { type: "complete", reason: "stop" },
+    });
+    expect(shouldContinue(msg, undefined)).toBe(false);
+  });
+
+  it("returns false when reason is not tool-calls", () => {
+    const msg = makeMessage({
+      status: { type: "requires-action", reason: "interrupt" },
+    });
+    expect(shouldContinue(msg, undefined)).toBe(false);
+  });
+
+  it("returns true when all tool calls have results (no humanToolNames)", () => {
+    const msg = makeMessage({
+      status: { type: "requires-action", reason: "tool-calls" },
+      content: [toolCall("search", "found it"), toolCall("calculate", 42)],
+    });
+    expect(shouldContinue(msg, undefined)).toBe(true);
+  });
+
+  it("returns false when some tool calls have no result (no humanToolNames)", () => {
+    const msg = makeMessage({
+      status: { type: "requires-action", reason: "tool-calls" },
+      content: [toolCall("search", "found it"), toolCall("calculate")],
+    });
+    expect(shouldContinue(msg, undefined)).toBe(false);
+  });
+
+  it("returns true when unresolved tool call is not a human tool", () => {
+    const msg = makeMessage({
+      status: { type: "requires-action", reason: "tool-calls" },
+      content: [toolCall("auto-tool")],
+    });
+    expect(shouldContinue(msg, ["human-approval"])).toBe(true);
+  });
+
+  it("returns false when unresolved tool call IS a human tool", () => {
+    const msg = makeMessage({
+      status: { type: "requires-action", reason: "tool-calls" },
+      content: [toolCall("human-approval")],
+    });
+    expect(shouldContinue(msg, ["human-approval"])).toBe(false);
+  });
+
+  it("returns true for non-tool-call content parts", () => {
+    const msg = makeMessage({
+      status: { type: "requires-action", reason: "tool-calls" },
+      content: [
+        { type: "text", text: "Hello" } as any,
+        toolCall("search", "done"),
+      ],
+    });
+    expect(shouldContinue(msg, undefined)).toBe(true);
+  });
+});

package/src/types/{MessagePartComponentTypes.tsx → MessagePartComponentTypes.ts}

@@ -1,6 +1,7 @@
 import type { ComponentType, PropsWithChildren } from "react";
 import type {
   MessagePartStatus,
+  DataMessagePart,
   FileMessagePart,
   ImageMessagePart,
   ReasoningMessagePart,
@@ -8,8 +9,8 @@ import type {
   TextMessagePart,
   ToolCallMessagePart,
   Unstable_AudioMessagePart,
-} from "./AssistantTypes";
-import { MessagePartState } from "../legacy-runtime/runtime/MessagePartRuntime";
+} from "@assistant-ui/core";
+import type { MessagePartState } from "@assistant-ui/core";
 import { ToolResponse } from "assistant-stream";
 
 export type EmptyMessagePartProps = {
@@ -44,6 +45,12 @@ export type Unstable_AudioMessagePartProps = MessagePartState &
 export type Unstable_AudioMessagePartComponent =
   ComponentType<Unstable_AudioMessagePartProps>;
 
+export type DataMessagePartProps<T = any> = MessagePartState &
+  DataMessagePart<T>;
+export type DataMessagePartComponent<T = any> = ComponentType<
+  DataMessagePartProps<T>
+>;
+
 export type ToolCallMessagePartProps<
   TArgs = any,
   TResult = unknown,

package/src/types/index.ts

@@ -1,11 +1,9 @@
+// Re-export core types from @assistant-ui/core
 export type {
   Attachment,
   PendingAttachment,
   CompleteAttachment,
   AttachmentStatus,
-} from "./AttachmentTypes";
-
-export type {
   AppendMessage,
   TextMessagePart,
   ReasoningMessagePart,
@@ -18,15 +16,18 @@ export type {
   MessageStatus,
   MessagePartStatus,
   ToolCallMessagePartStatus,
-  // thread message types
+  MessageTiming,
   ThreadUserMessagePart,
   ThreadAssistantMessagePart,
   ThreadSystemMessage,
   ThreadAssistantMessage,
   ThreadUserMessage,
   ThreadMessage,
-} from "./AssistantTypes";
+  Unsubscribe,
+  QuoteInfo,
+} from "@assistant-ui/core";
 
+// React-specific component types (stay in react)
 export type {
   EmptyMessagePartComponent,
   EmptyMessagePartProps,
@@ -42,6 +43,8 @@ export type {
   FileMessagePartProps,
   Unstable_AudioMessagePartComponent,
   Unstable_AudioMessagePartProps,
+  DataMessagePartComponent,
+  DataMessagePartProps,
   ToolCallMessagePartComponent,
   ToolCallMessagePartProps,
   ReasoningGroupProps,
@@ -49,8 +52,4 @@ export type {
 } from "./MessagePartComponentTypes";
 
 // Thread list item types
-export type { ThreadListItemStatus } from "../legacy-runtime/runtime/ThreadListItemRuntime";
-
-export type { Unsubscribe } from "./Unsubscribe";
-
-export type { QuoteInfo } from "./QuoteTypes";
+export type { ThreadListItemStatus } from "@assistant-ui/core";

package/src/types/scopes/dataRenderers.ts

@@ -0,0 +1,15 @@
+import type { DataMessagePartComponent } from "../MessagePartComponentTypes";
+import type { Unsubscribe } from "@assistant-ui/core";
+
+export type DataRenderersState = {
+  renderers: Record<string, DataMessagePartComponent[]>;
+};
+
+export type DataRenderersMethods = {
+  getState(): DataRenderersState;
+  setDataUI(name: string, render: DataMessagePartComponent): Unsubscribe;
+};
+
+export type DataRenderersClientSchema = {
+  methods: DataRenderersMethods;
+};

package/src/types/scopes/index.ts

@@ -1,69 +1,57 @@
+// Re-export 11 scope types from core
 export type {
   ThreadsState,
   ThreadsMethods,
   ThreadsClientSchema,
-} from "./threads";
-export type {
   ThreadListItemState,
   ThreadListItemMethods,
   ThreadListItemMeta,
   ThreadListItemEvents,
   ThreadListItemClientSchema,
-} from "./threadListItem";
-export type {
   ThreadState,
   ThreadMethods,
   ThreadMeta,
   ThreadEvents,
   ThreadClientSchema,
-} from "./thread";
-export type {
   MessageState,
   MessageMethods,
   MessageMeta,
   MessageClientSchema,
-} from "./message";
-export type {
   PartState,
   PartMethods,
   PartMeta,
   PartClientSchema,
-} from "./part";
-export type {
   ComposerState,
   ComposerMethods,
   ComposerMeta,
   ComposerEvents,
   ComposerClientSchema,
-} from "./composer";
-export type {
   AttachmentState,
   AttachmentMethods,
   AttachmentMeta,
   AttachmentClientSchema,
-} from "./attachment";
-export type { ToolsState, ToolsMethods, ToolsClientSchema } from "./tools";
-export type {
   SuggestionsState,
   SuggestionsMethods,
   SuggestionsClientSchema,
   Suggestion,
-} from "./suggestions";
-export type {
   SuggestionState,
   SuggestionMethods,
   SuggestionMeta,
   SuggestionClientSchema,
-} from "./suggestion";
-export type {
   ModelContextState,
   ModelContextMethods,
   ModelContextClientSchema,
-} from "./modelContext";
-export type {
   ChainOfThoughtState,
   ChainOfThoughtMethods,
   ChainOfThoughtMeta,
   ChainOfThoughtClientSchema,
   ChainOfThoughtPart,
-} from "./chainOfThought";
+} from "@assistant-ui/core/store";
+
+// Local scope types (React-specific)
+export type { ToolsState, ToolsMethods, ToolsClientSchema } from "./tools";
+export type {
+  DataRenderersState,
+  DataRenderersMethods,
+  DataRenderersClientSchema,
+} from "./dataRenderers";

package/src/types/scopes/tools.ts

@@ -1,5 +1,5 @@
 import type { ToolCallMessagePartComponent } from "../MessagePartComponentTypes";
-import type { Unsubscribe } from "../Unsubscribe";
+import type { Unsubscribe } from "@assistant-ui/core";
 
 export type ToolsState = {
   tools: Record<string, ToolCallMessagePartComponent[]>;
@@ -14,6 +14,5 @@ export type ToolsMethods = {
 };
 
 export type ToolsClientSchema = {
-  state: ToolsState;
   methods: ToolsMethods;
 };

package/src/types/store-augmentation.ts

@@ -1,31 +1,11 @@
-import "@assistant-ui/store";
+import "@assistant-ui/core/store";
 
-import type { ThreadsClientSchema } from "./scopes/threads";
-import type { ThreadListItemClientSchema } from "./scopes/threadListItem";
-import type { ThreadClientSchema } from "./scopes/thread";
-import type { MessageClientSchema } from "./scopes/message";
-import type { PartClientSchema } from "./scopes/part";
-import type { ComposerClientSchema } from "./scopes/composer";
-import type { AttachmentClientSchema } from "./scopes/attachment";
 import type { ToolsClientSchema } from "./scopes/tools";
-import type { ModelContextClientSchema } from "./scopes/modelContext";
-import type { SuggestionsClientSchema } from "./scopes/suggestions";
-import type { SuggestionClientSchema } from "./scopes/suggestion";
-import type { ChainOfThoughtClientSchema } from "./scopes/chainOfThought";
+import type { DataRenderersClientSchema } from "./scopes/dataRenderers";
 
-declare module "@assistant-ui/store" {
-  interface ClientRegistry {
-    threads: ThreadsClientSchema;
-    threadListItem: ThreadListItemClientSchema;
-    thread: ThreadClientSchema;
-    message: MessageClientSchema;
-    part: PartClientSchema;
-    composer: ComposerClientSchema;
-    attachment: AttachmentClientSchema;
+declare module "@assistant-ui/core/store" {
+  interface ScopeRegistry {
     tools: ToolsClientSchema;
-    modelContext: ModelContextClientSchema;
-    suggestions: SuggestionsClientSchema;
-    suggestion: SuggestionClientSchema;
-    chainOfThought: ChainOfThoughtClientSchema;
+    dataRenderers: DataRenderersClientSchema;
   }
 }

package/src/utils/smooth/SmoothContext.tsx

@@ -11,10 +11,10 @@ import {
 } from "react";
 import { ReadonlyStore } from "../../context/ReadonlyStore";
 import { create, UseBoundStore } from "zustand";
-import {
+import type {
   MessagePartStatus,
   ToolCallMessagePartStatus,
-} from "../../types/AssistantTypes";
+} from "@assistant-ui/core";
 import { useAui } from "@assistant-ui/store";
 import { createContextStoreHook } from "../../context/react/utils/createContextStoreHook";