@assistant-ui/core 0.3.19 → 0.3.21

package/src/tests/external-thread-feedback.test.tsx

@@ -78,11 +78,19 @@ describe("ExternalThread feedback", () => {
     expect(withAdapter().thread.getState().capabilities.feedback).toBe(true);
   });
 
-  it("throws on submitFeedback when no adapter is configured", () => {
+  it("marks assistant feedback locally without an adapter", async () => {
     const { aui } = renderThreadWithProps({});
-    expect(() =>
-      aui().thread.message({ id: "a1" }).submitFeedback({ type: "positive" }),
-    ).toThrow("Feedback adapter not configured");
+
+    await act(async () => {
+      aui().thread.message({ id: "a1" }).submitFeedback({ type: "positive" });
+    });
+
+    await waitFor(() => {
+      expect(
+        aui().thread.message({ id: "a1" }).getState().metadata
+          .submittedFeedback,
+      ).toEqual({ type: "positive" });
+    });
   });
 
   it("submits feedback to the adapter and marks the assistant message", async () => {
@@ -90,23 +98,28 @@ describe("ExternalThread feedback", () => {
     const { aui } = renderThreadWithProps({ feedbackAdapter: adapter });
 
     await act(async () => {
-      aui().thread.message({ id: "a1" }).submitFeedback({ type: "positive" });
+      aui()
+        .thread.message({ id: "a1" })
+        .submitFeedback({ type: "positive", comment: "Helpful summary" });
     });
 
     expect(submit).toHaveBeenCalledTimes(1);
     expect(submit).toHaveBeenCalledWith({
       message: MESSAGES[1],
       type: "positive",
+      comment: "Helpful summary",
     });
     await waitFor(() => {
       expect(
         aui().thread.message({ id: "a1" }).getState().metadata
           .submittedFeedback,
-      ).toEqual({ type: "positive" });
+      ).toEqual({ type: "positive", comment: "Helpful summary" });
     });
 
     await act(async () => {
-      aui().thread.message({ id: "a1" }).submitFeedback({ type: "negative" });
+      aui()
+        .thread.message({ id: "a1" })
+        .submitFeedback({ type: "negative", comment: "   " });
     });
 
     expect(submit).toHaveBeenLastCalledWith({

package/src/tests/external-thread-isLast.test.tsx

@@ -0,0 +1,69 @@
+// @vitest-environment jsdom
+
+import { render } from "@testing-library/react";
+import type { FC } from "react";
+import { describe, it, expect } from "vitest";
+import { useAui, AuiProvider } from "@assistant-ui/store";
+import {
+  ExternalThread,
+  type ExternalThreadProps,
+} from "../store/clients/external-thread";
+
+const renderThread = (props: ExternalThreadProps) => {
+  const captured: { aui?: ReturnType<typeof useAui> } = {};
+  const Capture: FC = () => {
+    captured.aui = useAui();
+    return null;
+  };
+  const App: FC<{ threadProps: ExternalThreadProps }> = ({ threadProps }) => {
+    const aui = useAui({ thread: ExternalThread(threadProps) });
+    return (
+      <AuiProvider value={aui}>
+        <Capture />
+      </AuiProvider>
+    );
+  };
+  const utils = render(<App threadProps={props} />);
+  return {
+    aui: () => captured.aui!,
+    rerender: (next: ExternalThreadProps) =>
+      utils.rerender(<App threadProps={next} />),
+  };
+};
+
+const userMessage = (id: string) =>
+  ({
+    id,
+    role: "user",
+    content: [{ type: "text", text: "hi" }],
+    createdAt: new Date(0),
+    metadata: { custom: {} },
+  }) as unknown as ExternalThreadProps["messages"][number];
+
+describe("ExternalThread isLast", () => {
+  const messages = [userMessage("m1"), userMessage("m2")];
+
+  it("agrees between the thread's message list and the message client", () => {
+    const t = renderThread({ messages });
+
+    expect(
+      t
+        .aui()
+        .thread.getState()
+        .messages.map((m) => m.isLast),
+    ).toEqual([false, true]);
+
+    expect(t.aui().thread.message({ index: 0 }).getState().isLast).toBe(false);
+    expect(t.aui().thread.message({ index: 1 }).getState().isLast).toBe(true);
+    expect(t.aui().thread.message({ id: "m2" }).getState().isLast).toBe(true);
+  });
+
+  it("moves to the new message when the thread grows", () => {
+    const t = renderThread({ messages });
+
+    t.rerender({ messages: [...messages, userMessage("m3")] });
+
+    expect(t.aui().thread.message({ id: "m2" }).getState().isLast).toBe(false);
+    expect(t.aui().thread.message({ id: "m3" }).getState().isLast).toBe(true);
+  });
+});

package/src/tests/external-thread-parity.test.tsx

@@ -254,7 +254,7 @@ describe("ExternalThread unset optional callbacks", () => {
     expect(() => part().resumeToolCall(undefined)).toThrow(
       "Runtime does not support resuming tool calls (onResumeToolCall is not set).",
     );
-    expect(() => aui().thread.resumeRun()).toThrow(
+    expect(() => aui().thread.resumeRun({ parentId: null })).toThrow(
       "Runtime does not support resuming runs (onResume is not set).",
     );
     expect(() => aui().thread.importExternalState({})).toThrow(

package/src/tests/get-thread-state-isRunning.test.ts

@@ -2,9 +2,9 @@ import { describe, expect, it } from "vitest";
 import { getThreadState } from "../runtime/api/thread-runtime";
 import type { ThreadRuntimeCore } from "../runtime/interfaces/thread-runtime-core";
 import type { ThreadMessage } from "../types/message";
-import type { ThreadListItemState } from "../runtime/api/thread-list-item-runtime";
+import type { ThreadListItemRuntimeState } from "../runtime/api/thread-list-item-runtime";
 
-const listItem = { id: "t1" } as unknown as ThreadListItemState;
+const listItem = { id: "t1" } as unknown as ThreadListItemRuntimeState;
 
 const baseRuntime = (
   overrides: Partial<ThreadRuntimeCore>,

package/src/tests/message-queue.test.ts

@@ -1,5 +1,8 @@
 import { describe, it, expect, vi } from "vitest";
-import { createMessageQueue } from "../runtime/queue/message-queue";
+import {
+  createMessageQueue,
+  type MessageQueueDriver,
+} from "../runtime/queue/message-queue";
 import type { AppendMessage } from "../types/message";
 
 const msg = (text: string, extra?: Partial<AppendMessage>): AppendMessage => ({
@@ -35,6 +38,32 @@ describe("createMessageQueue", () => {
     expect(adapter.items).toHaveLength(0);
   });
 
+  it("does not advance a held queue when a run settles", () => {
+    const run = vi.fn();
+    const { adapter, hold, notifyIdle } = createMessageQueue({ run });
+
+    adapter.enqueue(msg("first"));
+    adapter.enqueue(msg("second"));
+    hold();
+    notifyIdle();
+
+    expect(run).toHaveBeenCalledOnce();
+    expect(prompts(adapter.items)).toEqual(["second"]);
+  });
+
+  it("advances a held queue once when released", () => {
+    const run = vi.fn();
+    const { adapter, hold, release } = createMessageQueue({ run });
+
+    hold();
+    adapter.enqueue(msg("first"));
+    release();
+    release();
+
+    expect(run).toHaveBeenCalledOnce();
+    expect(adapter.items).toHaveLength(0);
+  });
+
   it("drains FIFO across multiple queued messages", () => {
     const order: string[] = [];
     const run = vi.fn((m: AppendMessage) =>
@@ -438,7 +467,7 @@ describe("createMessageQueue", () => {
   describe("synchronous dispatch failures", () => {
     it("restores a message when the driver throws", () => {
       const error = new Error("dispatch failed");
-      const run = vi.fn(() => {
+      const run = vi.fn<MessageQueueDriver["run"]>(() => {
         throw error;
       });
       const { adapter } = createMessageQueue({ run });
@@ -446,7 +475,7 @@ describe("createMessageQueue", () => {
       expect(() => adapter.enqueue(msg("first"))).toThrow(error);
       expect(prompts(adapter.items)).toEqual(["first"]);
 
-      run.mockImplementation(() => undefined);
+      run.mockImplementation(() => {});
       adapter.enqueue(msg("second"));
 
       expect(run).toHaveBeenCalledTimes(2);
@@ -490,7 +519,10 @@ describe("createMessageQueue", () => {
       const error = new Error("transform failed");
       const run = vi.fn();
       const { adapter } = createMessageQueue({ run });
-      adapter.__internal_setDispatchTransform(() => {
+      const setDispatchTransform = adapter.__internal_setDispatchTransform;
+      if (setDispatchTransform === undefined)
+        throw new Error("expected dispatch transform support");
+      setDispatchTransform(() => {
         throw error;
       });
 
@@ -498,7 +530,7 @@ describe("createMessageQueue", () => {
       expect(run).not.toHaveBeenCalled();
       expect(prompts(adapter.items)).toEqual(["first"]);
 
-      adapter.__internal_setDispatchTransform((message) => message);
+      setDispatchTransform((message) => message);
       adapter.enqueue(msg("second"));
 
       expect(run).toHaveBeenCalledWith(
@@ -511,7 +543,7 @@ describe("createMessageQueue", () => {
     it("restores a steer when cancellation throws", () => {
       const error = new Error("cancel failed");
       const run = vi.fn();
-      const cancel = vi.fn(() => {
+      const cancel = vi.fn<NonNullable<MessageQueueDriver["cancel"]>>(() => {
         throw error;
       });
       const { adapter, notifyIdle } = createMessageQueue({ run, cancel });
@@ -523,7 +555,7 @@ describe("createMessageQueue", () => {
       notifyIdle();
       expect(run).toHaveBeenCalledOnce();
 
-      cancel.mockImplementation(() => undefined);
+      cancel.mockImplementation(() => {});
       adapter.enqueue(msg("later"));
       expect(run).toHaveBeenLastCalledWith(
         expect.objectContaining({
@@ -541,7 +573,10 @@ describe("createMessageQueue", () => {
       const { adapter, notifyIdle } = createMessageQueue({ run, cancel });
 
       adapter.enqueue(msg("active"));
-      adapter.__internal_setDispatchTransform(() => {
+      const setDispatchTransform = adapter.__internal_setDispatchTransform;
+      if (setDispatchTransform === undefined)
+        throw new Error("expected dispatch transform support");
+      setDispatchTransform(() => {
         throw error;
       });
 
@@ -550,7 +585,7 @@ describe("createMessageQueue", () => {
       expect(prompts(adapter.steerItems)).toEqual(["urgent"]);
 
       notifyIdle();
-      adapter.__internal_setDispatchTransform((message) => message);
+      setDispatchTransform((message) => message);
       adapter.enqueue(msg("later"));
 
       expect(run).toHaveBeenLastCalledWith(
@@ -880,7 +915,7 @@ describe("createMessageQueue", () => {
     subscribe(laterSubscriber);
 
     try {
-      expect(() => adapter.enqueue(msg("a"), { steer: false })).not.toThrow();
+      expect(() => adapter.enqueue(msg("a"))).not.toThrow();
       expect(run).toHaveBeenCalledTimes(1);
       expect(adapter.items).toHaveLength(0);
       expect(laterSubscriber).toHaveBeenCalledTimes(2);

package/src/tests/remote-thread-list-adapter-switch.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it, vi } from "vitest";
+import { describe, expect, it, onTestFinished, vi } from "vitest";
 import {
   createCore,
   deferred,
@@ -248,6 +248,50 @@ describe("RemoteThreadList adapter changes", () => {
     expect(stopped).not.toContain(core.mainThreadId);
   });
 
+  it("keeps stopping the threads missing from the replacement list when one stop throws", async () => {
+    const adapterA = makeAdapter({
+      list: async () => ({
+        threads: [thread("thread-a"), thread("thread-c")],
+      }),
+    });
+    const adapterB = makeAdapter({
+      list: async () => ({ threads: [thread("thread-b")] }),
+    });
+    const core = createCore(adapterA);
+    const stopped: string[] = [];
+    const error = new Error("cleanup failed");
+    const hookManager = (
+      core as unknown as {
+        _hookManager: { stopThreadRuntime: (id: string) => void };
+      }
+    )._hookManager;
+    const originalStop = hookManager.stopThreadRuntime.bind(hookManager);
+    hookManager.stopThreadRuntime = (id: string) => {
+      stopped.push(id);
+      originalStop(id);
+      if (stopped.length === 1) throw error;
+    };
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => {});
+    onTestFinished(() => consoleError.mockRestore());
+
+    await core.getLoadThreadsPromise();
+    core.__internal_setOptions({
+      adapter: adapterB,
+      runtimeHook: () => ({}) as never,
+    });
+    await core.getLoadThreadsPromise();
+
+    expect(stopped).toEqual(expect.arrayContaining(["thread-a", "thread-c"]));
+    expect(core.getItemById("thread-a")).toBeUndefined();
+    expect(core.getItemById("thread-b")).toBeDefined();
+    expect(consoleError).toHaveBeenCalledWith(
+      "[assistant-ui] Thread runtime cleanup threw while stopping a thread",
+      error,
+    );
+  });
+
   it("does not reject when a controlled thread is missing from the replacement adapter", async () => {
     const adapterA = makeAdapter({
       list: async () => ({ threads: [thread("thread-a")] }),

package/src/tests/thread-switch-events.test.tsx

@@ -15,13 +15,14 @@ import {
 } from "../runtime/api/assistant-runtime";
 import { ExternalStoreRuntimeCore } from "../runtimes/external-store/external-store-runtime-core";
 import type { ExternalStoreAdapter } from "../runtimes/external-store/external-store-adapter";
+import type { ThreadMessage } from "../types/message";
 
 type DemoMessage = { id: string; role: "user" | "assistant"; text: string };
 
 const EMPTY_MESSAGES: readonly never[] = [];
 
 const useTestThreadRuntime = () =>
-  useExternalStoreRuntime({
+  useExternalStoreRuntime<ThreadMessage>({
     messages: EMPTY_MESSAGES,
     isRunning: false,
     onNew: async () => {},
@@ -129,7 +130,10 @@ describe("thread switch events", () => {
 
   it("delivers threads.selectionChanged with the new and previous thread ids", async () => {
     const runtime = createRuntime();
-    const selectionChanged = vi.fn();
+    const selectionChanged =
+      vi.fn<
+        (payload: { threadId: string; previousThreadId: string }) => void
+      >();
     const auiOn = vi.fn();
     let aui!: ReturnType<typeof useAui>;
     const Consumer = () => {
@@ -208,7 +212,10 @@ describe("thread switch events", () => {
 
   it("emits when a deep-linked initial thread resolves after mount", async () => {
     const adapter = makeAdapter();
-    const selectionChanged = vi.fn();
+    const selectionChanged =
+      vi.fn<
+        (payload: { threadId: string; previousThreadId: string }) => void
+      >();
     const Listener = () => {
       useAuiEvent("threads.selectionChanged", selectionChanged);
       return null;
@@ -228,10 +235,7 @@ describe("thread switch events", () => {
     render(<Harness />);
 
     await waitFor(() => expect(selectionChanged).toHaveBeenCalledTimes(1));
-    const payload = selectionChanged.mock.calls[0]![0] as {
-      threadId: string;
-      previousThreadId: string;
-    };
+    const payload = selectionChanged.mock.calls[0]![0];
     expect(payload.threadId).toBe("thread-a");
     expect(payload.previousThreadId).toMatch(/^__LOCALID_/);
   });

package/src/tests/useRemoteThreadListRuntime-controlled.test.tsx

@@ -7,6 +7,7 @@ import { AssistantRuntimeProvider } from "../react/AssistantRuntimeProvider";
 import { useExternalStoreRuntime } from "../react/runtimes/useExternalStoreRuntime";
 import { useRemoteThreadListRuntime } from "../react/runtimes/useRemoteThreadListRuntime";
 import type { AssistantRuntime } from "../runtime/api/assistant-runtime";
+import type { ThreadMessage } from "../types/message";
 import type {
   RemoteThreadListAdapter,
   RemoteThreadMetadata,
@@ -23,7 +24,7 @@ const makeThreadMetadata = (remoteId: string): RemoteThreadMetadata => ({
 });
 
 const useTestThreadRuntime = () =>
-  useExternalStoreRuntime({
+  useExternalStoreRuntime<ThreadMessage>({
     messages: EMPTY_MESSAGES,
     isRunning: false,
     onNew: async () => {},

package/src/types/message.test.ts

@@ -0,0 +1,19 @@
+import { expectTypeOf, it } from "vitest";
+import type { ThreadMessageLike } from "../runtime/utils/thread-message-like";
+import type {
+  AppendMessage,
+  ThreadAssistantMessage,
+  ThreadMessage,
+  ThreadSystemMessage,
+  ThreadUserMessage,
+} from "./message";
+
+it("keeps every role variant assignable to ThreadMessage", () => {
+  expectTypeOf<ThreadUserMessage>().toExtend<ThreadMessage>();
+  expectTypeOf<ThreadSystemMessage>().toExtend<ThreadMessage>();
+  expectTypeOf<ThreadAssistantMessage>().toExtend<ThreadMessage>();
+});
+
+it("keeps AppendMessage assignable to ThreadMessageLike", () => {
+  expectTypeOf<AppendMessage>().toExtend<ThreadMessageLike>();
+});

package/src/types/message.ts

@@ -104,12 +104,14 @@ export type DataMessagePart<T = any> = {
  */
 export type GenerativeUINode =
   | string
+  | number
+  | readonly GenerativeUINode[]
   | {
       /** Allowlisted component name (resolved against the consumer registry). */
       readonly component: string;
       /** Props passed to the resolved component (must be JSON-serializable). */
       readonly props?: Record<string, unknown>;
-      /** Optional children — strings render as text, objects recurse. */
+      /** Optional child nodes — strings and numbers render as text; nested arrays and objects recurse. */
       readonly children?: readonly GenerativeUINode[];
       /** Optional stable key for React reconciliation. */
       readonly key?: string;
@@ -227,6 +229,38 @@ export type ToolApprovalResponse =
       readonly reason?: string;
     };
 
+/** One thing a user did in a tool call's rendered UI, stored with the call. */
+export type Unstable_ToolInteraction =
+  | {
+      /** A generative UI action the user fired, with the user's input under `$input`. */
+      readonly type: "action";
+      /** When the user acted, in epoch milliseconds. */
+      readonly occurredAt: number;
+      readonly payload: ReadonlyJSONObject;
+    }
+  | {
+      /** The answer the user gave to the tool's request for human input. */
+      readonly type: "human-response";
+      /** When the user answered, in epoch milliseconds. */
+      readonly occurredAt: number;
+      readonly payload: ReadonlyJSONValue;
+    };
+
+/**
+ * The interactions recorded on a tool call, oldest first. `omitted` counts
+ * earlier entries dropped to keep the log within its size limit.
+ */
+export type Unstable_ToolInteractionLog = {
+  readonly entries: readonly Unstable_ToolInteraction[];
+  readonly omitted?: number;
+};
+
+/** An interaction to record; the runtime validates the payload and stamps the time. */
+export type Unstable_ToolInteractionInput = {
+  readonly type: Unstable_ToolInteraction["type"];
+  readonly payload: unknown;
+};
+
 export type ToolCallMessagePart<
   TArgs = ReadonlyJSONObject,
   TResult = unknown,
@@ -243,10 +277,12 @@ export type ToolCallMessagePart<
    * `useToolArgsStatus` to detect which fields are still arriving.
    */
   readonly args: TArgs;
-  /** Result returned by the tool, if it has completed. */
+  /** Result returned by the tool. Final once it has completed; an interim value while `isPreliminary` is set. */
   readonly result?: TResult | undefined;
   /** Whether the result represents a tool execution error. */
   readonly isError?: boolean | undefined;
+  /** Whether `result` is an interim value from a tool that is still running, so the call is not settled yet. */
+  readonly isPreliminary?: boolean | undefined;
   /** Raw JSON argument text streamed by the model. */
   readonly argsText: string;
   /** UI-only artifact associated with the tool result. */
@@ -274,6 +310,12 @@ export type ToolCallMessagePart<
     readonly display?: ToolApprovalDisplay;
     /** Whether a free-form answer is accepted alongside the options. */
     readonly allowFreeform?: boolean;
+    /**
+     * Whether the request accepts a dismissal: `approved: false` with no
+     * answer. A decision is always refusable; a question is only when its host
+     * records a dismissal, so a renderer offers one only when this is set.
+     */
+    readonly dismissible?: boolean;
     readonly approved?: boolean;
     readonly reason?: string;
     readonly isAutomatic?: boolean;
@@ -293,6 +335,11 @@ export type ToolCallMessagePart<
    * conversation.
    */
   readonly messages?: readonly ThreadMessage[];
+  /**
+   * What the user did in this call's rendered UI, recorded so a stored
+   * conversation shows the answer beside the question.
+   */
+  readonly unstable_interactions?: Unstable_ToolInteractionLog;
 };
 
 export type ThreadUserMessagePart =
@@ -454,7 +501,10 @@ export type ThreadAssistantMessage = MessageCommonProps & {
     readonly unstable_annotations: readonly ReadonlyJSONValue[];
     readonly unstable_data: readonly ReadonlyJSONValue[];
     readonly steps: readonly ThreadStep[];
-    readonly submittedFeedback?: { readonly type: "positive" | "negative" };
+    readonly submittedFeedback?: {
+      readonly type: "positive" | "negative";
+      readonly comment?: string;
+    };
     readonly timing?: MessageTiming;
     /**
      * Marks a client-side optimistic placeholder. Such messages are evicted
@@ -470,14 +520,19 @@ export type ThreadAssistantMessage = MessageCommonProps & {
 type BaseThreadMessage = {
   readonly status?: ThreadAssistantMessage["status"];
   readonly metadata: {
-    readonly unstable_state?: ReadonlyJSONValue;
-    readonly unstable_annotations?: readonly ReadonlyJSONValue[];
-    readonly unstable_data?: readonly ReadonlyJSONValue[];
-    readonly steps?: readonly ThreadStep[];
-    readonly submittedFeedback?: { readonly type: "positive" | "negative" };
-    readonly timing?: MessageTiming;
+    readonly unstable_state?: ReadonlyJSONValue | undefined;
+    readonly unstable_annotations?: readonly ReadonlyJSONValue[] | undefined;
+    readonly unstable_data?: readonly ReadonlyJSONValue[] | undefined;
+    readonly steps?: readonly ThreadStep[] | undefined;
+    readonly submittedFeedback?:
+      | {
+          readonly type: "positive" | "negative";
+          readonly comment?: string;
+        }
+      | undefined;
+    readonly timing?: MessageTiming | undefined;
     readonly isOptimistic?: boolean;
-    readonly modality?: MessageModality;
+    readonly modality?: MessageModality | undefined;
     readonly custom: Record<string, unknown>;
   };
   readonly attachments?: ThreadUserMessage["attachments"];

package/src/utils/normalizePartStatus.ts

@@ -4,6 +4,7 @@ import type {
   ThreadAssistantMessagePart,
   ThreadMessage,
   ThreadUserMessagePart,
+  ToolCallMessagePart,
   ToolCallMessagePartStatus,
 } from "../types/message";
 
@@ -56,6 +57,14 @@ export const normalizePartStatus = (
   return INCOMPLETE_STATUSES[normalizedReason];
 };
 
+export const hasPendingToolAction = (
+  part: Pick<ToolCallMessagePart, "approval" | "interrupt">,
+): boolean =>
+  part.interrupt != null ||
+  (part.approval != null &&
+    part.approval.approved === undefined &&
+    part.approval.resolution === undefined);
+
 export const toMessagePartStatus = (
   message: ThreadMessage,
   partIndex: number,
@@ -64,7 +73,11 @@ export const toMessagePartStatus = (
   if (message.role !== "assistant") return COMPLETE_STATUS;
 
   if (part.type === "tool-call") {
-    if (part.result === undefined) {
+    if (
+      part.result === undefined ||
+      part.isPreliminary ||
+      hasPendingToolAction(part)
+    ) {
       return message.status;
     } else {
       return COMPLETE_STATUS;

package/dist/tests/remote-thread-list-test-helpers.d.ts

@@ -1,16 +0,0 @@
-import { ModelContextProvider } from "../model-context/types.js";
-import { RemoteThreadListAdapter } from "../runtimes/remote-thread-list/types.js";
-import { RemoteThreadListThreadListRuntimeCore } from "../react/runtimes/RemoteThreadListThreadListRuntimeCore.js";
-//#region src/tests/remote-thread-list-test-helpers.d.ts
-declare function deferred<T>(): {
-  promise: Promise<T>;
-  resolve: (value: T) => void;
-  reject: (reason?: unknown) => void;
-};
-declare const contextProvider: ModelContextProvider;
-declare function setStartThreadRuntime(core: RemoteThreadListThreadListRuntimeCore, startThreadRuntime: (id: string) => Promise<unknown>): void;
-declare function makeAdapter(overrides?: Partial<RemoteThreadListAdapter>): RemoteThreadListAdapter;
-declare function createCore(adapter: RemoteThreadListAdapter, threadId?: string, onThreadIdChange?: (threadId: string | undefined) => void): RemoteThreadListThreadListRuntimeCore;
-//#endregion
-export { contextProvider, createCore, deferred, makeAdapter, setStartThreadRuntime };
-//# sourceMappingURL=remote-thread-list-test-helpers.d.ts.map

package/dist/tests/remote-thread-list-test-helpers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"remote-thread-list-test-helpers.d.ts","names":[],"sources":["../../src/tests/remote-thread-list-test-helpers.ts"],"mappings":";;;;iBAKgB,SAAS;;EACD,UAAA,OAAA;EACC,SAAA;;cAQZ,iBAAiB;iBAKd,sBACd,MAAM,uCACN,qBAAqB,eAAe;iBAWtB,YACd,YAAW,QAAQ,2BAClB;iBA6Ba,WACd,SAAS,yBACT,mBACA,oBAAoB,wCACnB"}

package/dist/tests/remote-thread-list-test-helpers.js

@@ -1,59 +0,0 @@
-import { RemoteThreadListThreadListRuntimeCore } from "../react/runtimes/RemoteThreadListThreadListRuntimeCore.js";
-import { vi } from "vitest";
-//#region src/tests/remote-thread-list-test-helpers.ts
-function deferred() {
-	let resolve;
-	let reject;
-	return {
-		promise: new Promise((res, rej) => {
-			resolve = res;
-			reject = rej;
-		}),
-		resolve,
-		reject
-	};
-}
-const contextProvider = {
-	getModelContext: () => ({}),
-	subscribe: () => () => {}
-};
-function setStartThreadRuntime(core, startThreadRuntime) {
-	core._hookManager.startThreadRuntime = startThreadRuntime;
-}
-function makeAdapter(overrides = {}) {
-	return {
-		list: vi.fn(async () => ({ threads: [] })),
-		initialize: vi.fn(async (threadId) => ({
-			remoteId: threadId,
-			externalId: threadId
-		})),
-		rename: vi.fn(async () => {}),
-		archive: vi.fn(async () => {}),
-		unarchive: vi.fn(async () => {}),
-		delete: vi.fn(async () => {}),
-		generateTitle: vi.fn(async () => new ReadableStream({ start(c) {
-			c.close();
-		} })),
-		fetch: vi.fn(async (id) => ({
-			status: "regular",
-			remoteId: id,
-			externalId: id,
-			title: "Test"
-		})),
-		...overrides
-	};
-}
-function createCore(adapter, threadId, onThreadIdChange) {
-	const core = new RemoteThreadListThreadListRuntimeCore({
-		adapter,
-		runtimeHook: () => ({}),
-		threadId,
-		onThreadIdChange
-	}, contextProvider);
-	setStartThreadRuntime(core, async () => ({}));
-	return core;
-}
-//#endregion
-export { contextProvider, createCore, deferred, makeAdapter, setStartThreadRuntime };
-
-//# sourceMappingURL=remote-thread-list-test-helpers.js.map