@assistant-ui/core 0.3.20 → 0.3.21

package/dist/runtime/utils/tool-call-tree.d.ts

@@ -1,9 +1,8 @@
-import { ThreadAssistantMessagePart, ThreadMessage, ToolCallMessagePart } from "../../types/message.js";
-//#region src/runtime/utils/tool-call-tree.d.ts
+import type { ThreadAssistantMessagePart, ThreadMessage, ToolCallMessagePart } from "../../types/message.js";
 export type ToolCallTreeEntry = {
-  readonly part: ToolCallMessagePart;
-  /** Id of the message whose content directly holds `part`. */
-  readonly messageId: string;
+    readonly part: ToolCallMessagePart;
+    /** Id of the message whose content directly holds `part`. */
+    readonly messageId: string;
 };
 /**
  * Walk every tool-call part reachable from `messages`. A tool call projects a
@@ -31,8 +30,7 @@ export declare function iterateToolCallParts(content: readonly ThreadAssistantMe
  * whether anything moved.
  */
 export declare function mapToolCallPartsDeep(content: readonly ThreadAssistantMessagePart[], fn: (part: ToolCallMessagePart) => ToolCallMessagePart): {
-  content: readonly ThreadAssistantMessagePart[];
-  changed: boolean;
+    content: readonly ThreadAssistantMessagePart[];
+    changed: boolean;
 };
-//#endregion
 //# sourceMappingURL=tool-call-tree.d.ts.map

package/dist/runtime/utils/tool-call-tree.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool-call-tree.d.ts","names":[],"sources":["../../../src/runtime/utils/tool-call-tree.ts"],"mappings":";;YAOY;WACD,MAAM;;WAEN;;;;;;;;;;;;;;;wBAgBM,iBACf,mBAAmB,kBAClB,UAAU;;;;;wBAiBI,qBACf,kBAAkB,+BACjB,UAAU;;;;;;;wBAkBG,qBACd,kBAAkB,8BAClB,KAAK,MAAM,wBAAwB;EAChC,kBAAkB;EAA8B"}
+{"version":3,"file":"tool-call-tree.d.ts","sourceRoot":"","sources":["../../../src/runtime/utils/tool-call-tree.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,0BAA0B,EAC1B,aAAa,EACb,mBAAmB,EACpB,+BAA4B;AAE7B,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,CAAC,IAAI,EAAE,mBAAmB,CAAC;IACnC,6DAA6D;IAC7D,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,wBAAiB,gBAAgB,CAC/B,QAAQ,EAAE,SAAS,aAAa,EAAE,GACjC,SAAS,CAAC,iBAAiB,CAAC,CAW9B;AAED;;;GAGG;AACH,wBAAiB,oBAAoB,CACnC,OAAO,EAAE,SAAS,0BAA0B,EAAE,GAC7C,SAAS,CAAC,mBAAmB,CAAC,CAUhC;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,SAAS,0BAA0B,EAAE,EAC9C,EAAE,EAAE,CAAC,IAAI,EAAE,mBAAmB,KAAK,mBAAmB,GACrD;IAAE,OAAO,EAAE,SAAS,0BAA0B,EAAE,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,CA4BtE"}

package/dist/runtime/utils/tool-interactions.d.ts

@@ -0,0 +1,10 @@
+import type { Unstable_ToolInteraction, Unstable_ToolInteractionInput, Unstable_ToolInteractionLog } from "../../types/message.js";
+export declare const TOOL_INTERACTION_LIMITS: {
+    readonly entries: 32;
+    readonly payloadLength: 16384;
+    readonly logLength: 65536;
+};
+export declare function createToolInteraction(input: Unstable_ToolInteractionInput, occurredAt?: number): Unstable_ToolInteraction;
+export declare function appendToolInteraction(log: Unstable_ToolInteractionLog | undefined, interaction: Unstable_ToolInteraction): Unstable_ToolInteractionLog;
+export declare function readToolInteractionLog(value: unknown): Unstable_ToolInteractionLog | undefined;
+//# sourceMappingURL=tool-interactions.d.ts.map

package/dist/runtime/utils/tool-interactions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-interactions.d.ts","sourceRoot":"","sources":["../../../src/runtime/utils/tool-interactions.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,wBAAwB,EACxB,6BAA6B,EAC7B,2BAA2B,EAC5B,+BAA4B;AAE7B,eAAO,MAAM,uBAAuB;;;;CAI1B,CAAC;AA8CX,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,6BAA6B,EACpC,UAAU,GAAE,MAAmB,GAC9B,wBAAwB,CAkB1B;AAED,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,2BAA2B,GAAG,SAAS,EAC5C,WAAW,EAAE,wBAAwB,GACpC,2BAA2B,CAY7B;AAoBD,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,OAAO,GACb,2BAA2B,GAAG,SAAS,CA0BzC"}

package/dist/runtime/utils/tool-interactions.js

@@ -0,0 +1,92 @@
+//#region src/runtime/utils/tool-interactions.ts
+const TOOL_INTERACTION_LIMITS = {
+	entries: 32,
+	payloadLength: 16384,
+	logLength: 65536
+};
+const MAX_DEPTH = 64;
+const isPlainObject = (value) => {
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+};
+const isPlainJSON = (value, ancestors, depth) => {
+	if (value === null) return true;
+	switch (typeof value) {
+		case "string":
+		case "boolean": return true;
+		case "number": return Number.isFinite(value);
+		case "object": break;
+		default: return false;
+	}
+	if (depth > MAX_DEPTH || ancestors.has(value)) return false;
+	ancestors.add(value);
+	const valid = Array.isArray(value) ? value.every((item) => isPlainJSON(item, ancestors, depth + 1)) : isPlainObject(value) && Object.values(value).every((item) => isPlainJSON(item, ancestors, depth + 1));
+	ancestors.delete(value);
+	return valid;
+};
+const isJSONObjectValue = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isInteractionType = (value) => value === "action" || value === "human-response";
+function createToolInteraction(input, occurredAt = Date.now()) {
+	const { type, payload } = input;
+	if (!isInteractionType(type)) throw new Error(`Unknown tool interaction type: ${String(type)}`);
+	if (!isPlainJSON(payload, /* @__PURE__ */ new Set(), 0)) throw new Error("A tool interaction payload must be plain JSON.");
+	if (type === "action" && !isJSONObjectValue(payload)) throw new Error("An action interaction payload must be a JSON object.");
+	const serialized = JSON.stringify(payload);
+	if (serialized.length > TOOL_INTERACTION_LIMITS.payloadLength) throw new Error(`A tool interaction payload is limited to ${TOOL_INTERACTION_LIMITS.payloadLength} characters of JSON.`);
+	return {
+		type,
+		occurredAt,
+		payload: JSON.parse(serialized)
+	};
+}
+function appendToolInteraction(log, interaction) {
+	const entries = [...log?.entries ?? [], interaction];
+	let omitted = log?.omitted ?? 0;
+	while (entries.length > 1 && (entries.length > TOOL_INTERACTION_LIMITS.entries || JSON.stringify(entries).length > TOOL_INTERACTION_LIMITS.logLength)) {
+		entries.shift();
+		omitted += 1;
+	}
+	return omitted > 0 ? {
+		entries,
+		omitted
+	} : { entries };
+}
+const readInteraction = (value) => {
+	if (!isJSONObjectValue(value)) return void 0;
+	const { type, occurredAt, payload } = value;
+	if (!isInteractionType(type)) return void 0;
+	if (typeof occurredAt !== "number" || !Number.isFinite(occurredAt)) return;
+	if (!isPlainJSON(payload, /* @__PURE__ */ new Set(), 0)) return void 0;
+	if (type === "action") return isJSONObjectValue(payload) ? {
+		type,
+		occurredAt,
+		payload
+	} : void 0;
+	return {
+		type,
+		occurredAt,
+		payload
+	};
+};
+function readToolInteractionLog(value) {
+	if (!isJSONObjectValue(value)) return void 0;
+	const { entries, omitted } = value;
+	const readable = Array.isArray(entries) ? entries.flatMap((entry) => {
+		const interaction = readInteraction(entry);
+		return interaction ? [interaction] : [];
+	}) : [];
+	let omittedEntries = typeof omitted === "number" && Number.isInteger(omitted) && omitted > 0 ? omitted : 0;
+	while (readable.length > 1 && (readable.length > TOOL_INTERACTION_LIMITS.entries || JSON.stringify(readable).length > TOOL_INTERACTION_LIMITS.logLength)) {
+		readable.shift();
+		omittedEntries += 1;
+	}
+	if (readable.length === 0 && omittedEntries === 0) return void 0;
+	return omittedEntries > 0 ? {
+		entries: readable,
+		omitted: omittedEntries
+	} : { entries: readable };
+}
+//#endregion
+export { TOOL_INTERACTION_LIMITS, appendToolInteraction, createToolInteraction, readToolInteractionLog };
+
+//# sourceMappingURL=tool-interactions.js.map

package/dist/runtime/utils/tool-interactions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-interactions.js","names":["ReadonlyJSONObject","ReadonlyJSONValue","Unstable_ToolInteraction","Unstable_ToolInteractionInput","Unstable_ToolInteractionLog","TOOL_INTERACTION_LIMITS","entries","payloadLength","logLength","const","MAX_DEPTH","isPlainObject","value","prototype","Object","getPrototypeOf","isPlainJSON","ancestors","Set","depth","Number","isFinite","has","add","valid","Array","isArray","every","item","values","delete","isJSONObjectValue","isInteractionType","createToolInteraction","input","occurredAt","Date","now","type","payload","Error","String","serialized","JSON","stringify","length","parse","appendToolInteraction","log","interaction","omitted","shift","readInteraction","undefined","Record","readToolInteractionLog","readable","flatMap","entry","omittedCount","isInteger","omittedEntries"],"sources":["../../../src/runtime/utils/tool-interactions.ts"],"sourcesContent":["import type {\n  ReadonlyJSONObject,\n  ReadonlyJSONValue,\n} from \"assistant-stream/utils\";\nimport type {\n  Unstable_ToolInteraction,\n  Unstable_ToolInteractionInput,\n  Unstable_ToolInteractionLog,\n} from \"../../types/message\";\n\nexport const TOOL_INTERACTION_LIMITS = {\n  entries: 32,\n  payloadLength: 16_384,\n  logLength: 65_536,\n} as const;\n\nconst MAX_DEPTH = 64;\n\nconst isPlainObject = (value: object): boolean => {\n  const prototype = Object.getPrototypeOf(value);\n  return prototype === Object.prototype || prototype === null;\n};\n\nconst isPlainJSON = (\n  value: unknown,\n  ancestors: Set<object>,\n  depth: number,\n): value is ReadonlyJSONValue => {\n  if (value === null) return true;\n  switch (typeof value) {\n    case \"string\":\n    case \"boolean\":\n      return true;\n    case \"number\":\n      return Number.isFinite(value);\n    case \"object\":\n      break;\n    default:\n      return false;\n  }\n  if (depth > MAX_DEPTH || ancestors.has(value)) return false;\n  ancestors.add(value);\n  const valid = Array.isArray(value)\n    ? value.every((item) => isPlainJSON(item, ancestors, depth + 1))\n    : isPlainObject(value) &&\n      Object.values(value).every((item) =>\n        isPlainJSON(item, ancestors, depth + 1),\n      );\n  ancestors.delete(value);\n  return valid;\n};\n\nconst isJSONObjectValue = (value: unknown) =>\n  typeof value === \"object\" && value !== null && !Array.isArray(value);\n\nconst isInteractionType = (\n  value: unknown,\n): value is Unstable_ToolInteraction[\"type\"] =>\n  value === \"action\" || value === \"human-response\";\n\nexport function createToolInteraction(\n  input: Unstable_ToolInteractionInput,\n  occurredAt: number = Date.now(),\n): Unstable_ToolInteraction {\n  const { type, payload } = input;\n  if (!isInteractionType(type)) {\n    throw new Error(`Unknown tool interaction type: ${String(type)}`);\n  }\n  if (!isPlainJSON(payload, new Set(), 0)) {\n    throw new Error(\"A tool interaction payload must be plain JSON.\");\n  }\n  if (type === \"action\" && !isJSONObjectValue(payload)) {\n    throw new Error(\"An action interaction payload must be a JSON object.\");\n  }\n  const serialized = JSON.stringify(payload);\n  if (serialized.length > TOOL_INTERACTION_LIMITS.payloadLength) {\n    throw new Error(\n      `A tool interaction payload is limited to ${TOOL_INTERACTION_LIMITS.payloadLength} characters of JSON.`,\n    );\n  }\n  return { type, occurredAt, payload: JSON.parse(serialized) };\n}\n\nexport function appendToolInteraction(\n  log: Unstable_ToolInteractionLog | undefined,\n  interaction: Unstable_ToolInteraction,\n): Unstable_ToolInteractionLog {\n  const entries = [...(log?.entries ?? []), interaction];\n  let omitted = log?.omitted ?? 0;\n  while (\n    entries.length > 1 &&\n    (entries.length > TOOL_INTERACTION_LIMITS.entries ||\n      JSON.stringify(entries).length > TOOL_INTERACTION_LIMITS.logLength)\n  ) {\n    entries.shift();\n    omitted += 1;\n  }\n  return omitted > 0 ? { entries, omitted } : { entries };\n}\n\nconst readInteraction = (\n  value: unknown,\n): Unstable_ToolInteraction | undefined => {\n  if (!isJSONObjectValue(value)) return undefined;\n  const { type, occurredAt, payload } = value as Record<string, unknown>;\n  if (!isInteractionType(type)) return undefined;\n  if (typeof occurredAt !== \"number\" || !Number.isFinite(occurredAt)) {\n    return undefined;\n  }\n  if (!isPlainJSON(payload, new Set(), 0)) return undefined;\n  if (type === \"action\") {\n    return isJSONObjectValue(payload)\n      ? { type, occurredAt, payload: payload as ReadonlyJSONObject }\n      : undefined;\n  }\n  return { type, occurredAt, payload };\n};\n\nexport function readToolInteractionLog(\n  value: unknown,\n): Unstable_ToolInteractionLog | undefined {\n  if (!isJSONObjectValue(value)) return undefined;\n  const { entries, omitted } = value as Record<string, unknown>;\n  const readable = Array.isArray(entries)\n    ? entries.flatMap((entry) => {\n        const interaction = readInteraction(entry);\n        return interaction ? [interaction] : [];\n      })\n    : [];\n  const omittedCount =\n    typeof omitted === \"number\" && Number.isInteger(omitted) && omitted > 0\n      ? omitted\n      : 0;\n  let omittedEntries = omittedCount;\n  while (\n    readable.length > 1 &&\n    (readable.length > TOOL_INTERACTION_LIMITS.entries ||\n      JSON.stringify(readable).length > TOOL_INTERACTION_LIMITS.logLength)\n  ) {\n    readable.shift();\n    omittedEntries += 1;\n  }\n  if (readable.length === 0 && omittedEntries === 0) return undefined;\n  return omittedEntries > 0\n    ? { entries: readable, omitted: omittedEntries }\n    : { entries: readable };\n}\n"],"mappings":"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"}

package/dist/runtimes/assistant-transport/utils.d.ts

@@ -1,4 +1,2 @@
-//#region src/runtimes/assistant-transport/utils.d.ts
 export declare function createRequestHeaders(headersValue: Record<string, string> | Headers | (() => Promise<Record<string, string> | Headers>)): Promise<Headers>;
-//#endregion
 //# sourceMappingURL=utils.d.ts.map

package/dist/runtimes/assistant-transport/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","names":[],"sources":["../../../src/runtimes/assistant-transport/utils.ts"],"mappings":";wBAAsB,qBACpB,cACI,yBACA,iBACO,QAAQ,yBAAyB,YAC3C,QAAQ"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/runtimes/assistant-transport/utils.ts"],"names":[],"mappings":"AAAA,wBAAsB,oBAAoB,CACxC,YAAY,EACR,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GACtB,OAAO,GACP,CAAC,MAAM,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,GACpD,OAAO,CAAC,OAAO,CAAC,CAOlB"}

package/dist/runtimes/external-store/external-store-adapter.d.ts

@@ -1,217 +1,234 @@
-import { AppendMessage, ThreadMessage, ToolCallMessagePart } from "../../types/message.js";
-import { AttachmentAdapter } from "../../adapters/attachment.js";
-import { FeedbackAdapter } from "../../adapters/feedback.js";
-import { DictationAdapter, SpeechSynthesisAdapter } from "../../adapters/speech.js";
-import { RealtimeVoiceAdapter } from "../../adapters/voice.js";
-import { ThreadMessageLike } from "../../runtime/utils/thread-message-like.js";
-import { ExportedMessageRepository, MessageRepository } from "../../runtime/utils/message-repository.js";
-import { ExternalThreadQueueAdapter } from "../../runtime/queue/external-thread-queue-adapter.js";
-import { AddToolResultOptions, RespondToToolApprovalOptions, ResumeRunConfig, StartRunConfig, ThreadSuggestion } from "../../runtime/interfaces/thread-runtime-core.js";
-import { ToolExecutionStatus } from "../tool-invocations/ToolInvocationTracker.js";
-import { ReadonlyJSONValue } from "assistant-stream/utils";
-//#region src/runtimes/external-store/external-store-adapter.d.ts
+import type { AppendMessage, ThreadMessage, ToolCallMessagePart } from "../../types/message.js";
+import type { ThreadMessageLike } from "../../runtime/utils/thread-message-like.js";
+import type { AttachmentAdapter } from "../../adapters/attachment.js";
+import type { SpeechSynthesisAdapter, DictationAdapter } from "../../adapters/speech.js";
+import type { RealtimeVoiceAdapter } from "../../adapters/voice.js";
+import type { FeedbackAdapter } from "../../adapters/feedback.js";
+import type { AddToolResultOptions, RespondToToolApprovalOptions, Unstable_RecordToolInteractionOptions, StartRunConfig, ResumeRunConfig, ThreadSuggestion } from "../../runtime/interfaces/thread-runtime-core.js";
+import type { ExportedMessageRepository, MessageRepository } from "../../runtime/utils/message-repository.js";
+import type { ReadonlyJSONValue } from "assistant-stream/utils";
+import type { ToolExecutionStatus } from "../tool-invocations/ToolInvocationTracker.js";
+import type { ExternalThreadQueueAdapter } from "../../runtime/queue/external-thread-queue-adapter.js";
 export type ExternalStoreThreadData<TState extends "regular" | "archived"> = {
-  status: TState;
-  id: string;
-  remoteId?: string | undefined;
-  externalId?: string | undefined;
-  title?: string | undefined;
-  custom?: Record<string, unknown> | undefined;
+    status: TState;
+    id: string;
+    remoteId?: string | undefined;
+    externalId?: string | undefined;
+    title?: string | undefined;
+    custom?: Record<string, unknown> | undefined;
 };
 export type ExternalStoreThreadListAdapter = {
-  /**
-   * @deprecated This API is still under active development and might change without notice.
-   */
-  threadId?: string | undefined;
-  isLoading?: boolean | undefined;
-  threads?: readonly ExternalStoreThreadData<"regular">[] | undefined;
-  archivedThreads?: readonly ExternalStoreThreadData<"archived">[] | undefined;
-  /**
-   * @deprecated This API is still under active development and might change without notice.
-   */
-  onSwitchToNewThread?: (() => Promise<void> | void) | undefined;
-  /**
-   * @deprecated This API is still under active development and might change without notice.
-   */
-  onSwitchToThread?: ((threadId: string) => Promise<void> | void) | undefined;
-  onRename?: (threadId: string, newTitle: string) => (Promise<void> | void) | undefined;
-  onUpdateCustom?: ((threadId: string, custom: Record<string, unknown> | undefined) => Promise<void> | void) | undefined;
-  onArchive?: ((threadId: string) => Promise<void> | void) | undefined;
-  onUnarchive?: ((threadId: string) => Promise<void> | void) | undefined;
-  onDelete?: ((threadId: string) => Promise<void> | void) | undefined;
+    /**
+     * @deprecated This API is still under active development and might change without notice.
+     */
+    threadId?: string | undefined;
+    isLoading?: boolean | undefined;
+    threads?: readonly ExternalStoreThreadData<"regular">[] | undefined;
+    archivedThreads?: readonly ExternalStoreThreadData<"archived">[] | undefined;
+    /**
+     * @deprecated This API is still under active development and might change without notice.
+     */
+    onSwitchToNewThread?: (() => Promise<void> | void) | undefined;
+    /**
+     * @deprecated This API is still under active development and might change without notice.
+     */
+    onSwitchToThread?: ((threadId: string) => Promise<void> | void) | undefined;
+    onRename?: (threadId: string, newTitle: string) => (Promise<void> | void) | undefined;
+    onUpdateCustom?: ((threadId: string, custom: Record<string, unknown> | undefined) => Promise<void> | void) | undefined;
+    onArchive?: ((threadId: string) => Promise<void> | void) | undefined;
+    onUnarchive?: ((threadId: string) => Promise<void> | void) | undefined;
+    onDelete?: ((threadId: string) => Promise<void> | void) | undefined;
 };
 export type ExternalStoreMessageConverter<T> = (message: T, idx: number) => ThreadMessageLike;
 /**
  * @deprecated This API is still under active development and might change without notice.
  */
 export type ExternalStoreBranchChange = {
-  headId: string | null;
-  visibleMessageIds: readonly string[];
+    headId: string | null;
+    visibleMessageIds: readonly string[];
 };
 type ExternalStoreMessageConverterAdapter<T> = {
-  convertMessage: ExternalStoreMessageConverter<T>;
+    convertMessage: ExternalStoreMessageConverter<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
-   * running state even after the last assistant message has completed (for
-   * example while non-message stream chunks like suggestions or metadata
-   * updates are still arriving). When omitted, `thread.isRunning` falls back
-   * to the last-message-status heuristic.
-   */
-  isRunning?: boolean | undefined;
-  isLoading?: boolean | undefined;
-  messages?: readonly T[];
-  messageRepository?: ExportedMessageRepository;
-  /**
-   * An externally owned message repository instance. When provided, the
-   * thread runtime adopts it as its branch store and swaps to it atomically
-   * whenever a different instance is passed, so hosts that route multiple
-   * conversations through one runtime keep each conversation's history and
-   * branches isolated in its own instance. Omit it to keep the runtime's own
-   * repository.
-   */
-  unstable_messageRepositoryInstance?: MessageRepository | undefined;
-  suggestions?: readonly ThreadSuggestion[] | undefined;
-  state?: ReadonlyJSONValue | undefined;
-  extras?: unknown;
-  /**
-   * Applies a message list the runtime rewrote, and is what tells the runtime
-   * a removal it makes will survive the next snapshot. Without it, cancelling a
-   * run leaves a trailing user message in the thread and the composer
-   * untouched; an adapter that removes that message itself owns handing it
-   * back, because the runtime cannot see a removal it did not make.
-   */
-  setMessages?: ((messages: readonly T[]) => void) | undefined;
-  /**
-   * Called with each finalized voice transcript message. The host appends it to its own messages under the same id, which is how the runtime knows the host carries it. A host that does not implement this callback keeps transcripts for the session only.
-   */
-  onVoiceTranscript?: ((message: ThreadMessage) => void) | undefined;
-  /**
-   * Fires when the user explicitly switches branches via the runtime's
-   * `switchToBranch` action (e.g. a BranchPicker click). It does not fire on
-   * adapter resync, `append`, edit/regenerate, content-only updates, or while
-   * the thread is running. Consecutive switches that resolve to the same
-   * canonical head are de-duped.
-   *
-   * `headId` is the canonical (persisted) head of the now-visible branch —
-   * optimistic/transient ids are never surfaced. `visibleMessageIds` lists the
-   * visible path in order.
-   *
-   * This complements `setMessages` rather than replacing it: switching still
-   * requires `setMessages`, and this callback does not on its own enable branch
-   * switching.
-   *
-   * @deprecated This API is still under active development and might change without notice.
-   */
-  unstable_onBranchChange?: ((event: ExternalStoreBranchChange) => void) | undefined;
-  onImport?: ((messages: readonly ThreadMessage[]) => void) | undefined;
-  onExportExternalState?: (() => any) | undefined;
-  onLoadExternalState?: ((state: any) => void) | undefined;
-  onNew: (message: AppendMessage) => Promise<void>;
-  /** Opt in to message queuing. Typically produced by `createMessageQueue`. */
-  queue?: ExternalThreadQueueAdapter | undefined;
-  onEdit?: ((message: AppendMessage) => Promise<void>) | undefined;
-  onDelete?: ((messageId: string) => Promise<void> | void) | undefined;
-  onReload?: ((parentId: string | null, config: StartRunConfig) => Promise<void>) | undefined;
-  onResume?: ((config: ResumeRunConfig) => Promise<void>) | undefined;
-  onCancel?: (() => Promise<void>) | undefined;
-  /**
-   * Re-fetches the thread's state from the backing store, in place; a
-   * rejection reaches the `threads.reloadMainThread()` caller. Unrelated to
-   * `onReload`, which re-generates an assistant message.
-   *
-   * The caller does not stop a run in progress first, so an adapter that can
-   * stream owns whatever coordination one needs.
-   */
-  onRefetchThread?: (() => Promise<void>) | undefined;
-  onAddToolResult?: ((options: AddToolResultOptions) => Promise<void> | void) | undefined;
-  onResumeToolCall?: ((options: {
-    toolCallId: string;
-    payload: unknown;
-  }) => void) | undefined;
-  onRespondToToolApproval?: ((options: RespondToToolApprovalOptions) => Promise<void> | void) | undefined;
-  convertMessage?: ExternalStoreMessageConverter<T> | undefined;
-  adapters?: {
-    attachments?: AttachmentAdapter | undefined;
-    speech?: SpeechSynthesisAdapter | undefined;
-    dictation?: DictationAdapter | undefined;
-    voice?: RealtimeVoiceAdapter | undefined;
-    feedback?: FeedbackAdapter | undefined;
     /**
+     * The runtime writes its messages to the thread list's history adapter
+     * itself, so `useExternalStoreRuntime` does not copy them.
+     */
+    unstable_persistsHistory?: boolean | undefined;
+    /**
+     * 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
+     * running state even after the last assistant message has completed (for
+     * example while non-message stream chunks like suggestions or metadata
+     * updates are still arriving). When omitted, `thread.isRunning` falls back
+     * to the last-message-status heuristic.
+     */
+    isRunning?: boolean | undefined;
+    isLoading?: boolean | undefined;
+    messages?: readonly T[];
+    messageRepository?: ExportedMessageRepository;
+    /**
+     * An externally owned message repository instance. When provided, the
+     * thread runtime adopts it as its branch store and swaps to it atomically
+     * whenever a different instance is passed, so hosts that route multiple
+     * conversations through one runtime keep each conversation's history and
+     * branches isolated in its own instance. Omit it to keep the runtime's own
+     * repository.
+     */
+    unstable_messageRepositoryInstance?: MessageRepository | undefined;
+    suggestions?: readonly ThreadSuggestion[] | undefined;
+    state?: ReadonlyJSONValue | undefined;
+    extras?: unknown;
+    /**
+     * Applies a message list the runtime rewrote, and is what tells the runtime
+     * a removal it makes will survive the next snapshot. Without it, cancelling a
+     * run leaves a trailing user message in the thread and the composer
+     * untouched; an adapter that removes that message itself owns handing it
+     * back, because the runtime cannot see a removal it did not make.
+     */
+    setMessages?: ((messages: readonly T[]) => void) | undefined;
+    /**
+     * Called with each message a voice session adds to the thread: every finalized transcript, and every text message typed into a session that takes typed text (it carries no `metadata.modality`). The host appends it to its own messages under the same id, which is how the runtime knows the host carries it. A message that finalizes while `isLoading` is true is delivered once loading ends, to the callback on the adapter current at that moment, and is not delivered at all when the conversation changed while it waited. A host that routes conversations through one runtime is recognized by its `unstable_messageRepositoryInstance`; one that swaps only its `messages` cannot be told apart from a load finishing. A host that does not implement this callback keeps these messages for the session only.
+     */
+    onVoiceTranscript?: ((message: ThreadMessage) => void) | undefined;
+    /**
+     * Fires when the user explicitly switches branches via the runtime's
+     * `switchToBranch` action (e.g. a BranchPicker click). It does not fire on
+     * adapter resync, `append`, edit/regenerate, content-only updates, or while
+     * the thread is running. Consecutive switches that resolve to the same
+     * canonical head are de-duped.
+     *
+     * `headId` is the canonical (persisted) head of the now-visible branch —
+     * optimistic/transient ids are never surfaced. `visibleMessageIds` lists the
+     * visible path in order.
+     *
+     * This complements `setMessages` rather than replacing it: switching still
+     * requires `setMessages`, and this callback does not on its own enable branch
+     * switching.
+     *
      * @deprecated This API is still under active development and might change without notice.
      */
-    threadList?: ExternalStoreThreadListAdapter | undefined;
-  } | undefined;
-  unstable_capabilities?: {
-    copy?: boolean | undefined;
-  } | undefined;
-  /**
-   * Opt in to the built-in client-side tool-invocations pipeline
-   * (`streamCall` / `execute` / tool-status tracking) for this thread.
-   *
-   * Defaults to `false` — the runtime does *not* drive client-side tool
-   * callbacks on its own. Set to `true` to have the runtime construct a
-   * `ToolInvocationTracker` and feed every snapshot through it, so tool
-   * callbacks fire automatically for tool-call parts in `messages`.
-   *
-   * Opt-in by default because most external-store runtimes either run
-   * tools entirely server-side, or already wire their own client-side
-   * dispatch path. Enabling the embedded tracker on top of an existing
-   * dispatch path would cause tool callbacks to run twice.
-   *
-   * When enabled, client-side tool results (from `execute()` returning,
-   * or from `streamCall` resolving) flow back through
-   * `adapter.onAddToolResult` like any other tool result, with
-   * `modelContent` populated when present.
-   */
-  unstable_enableToolInvocations?: boolean | undefined;
-  /**
-   * Decides whether a tool call's result is produced on the client. Only
-   * consulted when `unstable_enableToolInvocations` is `true`.
-   *
-   * A provider that runs tools itself answers its own calls, and its result
-   * arrives one or more snapshots after the call's arguments complete. In
-   * that window the call is complete and result-less, so a registered tool
-   * of the same name would otherwise execute locally and produce a result
-   * the provider never asked for. An adapter that can tell the two apart
-   * supplies this predicate; it is read once per tool call, when the call is
-   * first observed live.
-   *
-   * The predicate is also what licenses running a frontend tool while the
-   * provider's run is still open. Without it, ownership is unknown until the
-   * run ends, so a registered tool executes only once the run's outcome is
-   * known and cannot fire on a call the provider was about to answer or gate.
-   */
-  unstable_isClientToolCall?: ((toolCall: ToolCallMessagePart) => boolean) | undefined;
-  /**
-   * Receives the current per-tool-call execution status map whenever it
-   * changes. Only invoked when `unstable_enableToolInvocations` is `true`
-   * — the runtime maintains the map via the embedded tracker.
-   *
-   * Wire this into local React state and feed it into the converter's
-   * `metadata.toolStatuses` so the UI can render `executing` spinners
-   * and human-input prompts.
-   */
-  setToolStatuses?: ((statuses: Record<string, ToolExecutionStatus>) => void) | undefined;
+    unstable_onBranchChange?: ((event: ExternalStoreBranchChange) => void) | undefined;
+    onImport?: ((messages: readonly ThreadMessage[]) => void) | undefined;
+    onExportExternalState?: (() => any) | undefined;
+    onLoadExternalState?: ((state: any) => void) | undefined;
+    onNew: (message: AppendMessage) => Promise<void>;
+    /** Opt in to message queuing. Typically produced by `createMessageQueue`. */
+    queue?: ExternalThreadQueueAdapter | undefined;
+    onEdit?: ((message: AppendMessage) => Promise<void>) | undefined;
+    /**
+     * Removes a message from the host's store. The runtime drops the message
+     * from its branches when `messages` stops carrying the id, and reads a
+     * `messages` update that still carries it after every call for it has
+     * settled as a declined delete. A host that accepts the delete therefore
+     * publishes the removal before the returned promise settles.
+     */
+    onDelete?: ((messageId: string) => Promise<void> | void) | undefined;
+    onReload?: ((parentId: string | null, config: StartRunConfig) => Promise<void>) | undefined;
+    onResume?: ((config: ResumeRunConfig) => Promise<void>) | undefined;
+    onCancel?: (() => Promise<void>) | undefined;
+    /**
+     * Re-fetches the thread's state from the backing store, in place; a
+     * rejection reaches the `threads.reloadMainThread()` caller. Unrelated to
+     * `onReload`, which re-generates an assistant message.
+     *
+     * The caller does not stop a run in progress first, so an adapter that can
+     * stream owns whatever coordination one needs.
+     */
+    onRefetchThread?: (() => Promise<void>) | undefined;
+    onAddToolResult?: ((options: AddToolResultOptions) => Promise<void> | void) | undefined;
+    onResumeToolCall?: ((options: {
+        toolCallId: string;
+        payload: unknown;
+    }) => void) | undefined;
+    onRespondToToolApproval?: ((options: RespondToToolApprovalOptions) => Promise<void> | void) | undefined;
+    /**
+     * Stores a user interaction on a tool call part of a message this store
+     * owns and exposes it on that part's `unstable_interactions`. Without it,
+     * recording an interaction rejects and nothing is kept.
+     */
+    unstable_onRecordToolInteraction?: ((options: Unstable_RecordToolInteractionOptions) => Promise<void> | void) | undefined;
+    convertMessage?: ExternalStoreMessageConverter<T> | undefined;
+    adapters?: {
+        attachments?: AttachmentAdapter | undefined;
+        speech?: SpeechSynthesisAdapter | undefined;
+        dictation?: DictationAdapter | undefined;
+        voice?: RealtimeVoiceAdapter | undefined;
+        feedback?: FeedbackAdapter | undefined;
+        /**
+         * @deprecated This API is still under active development and might change without notice.
+         */
+        threadList?: ExternalStoreThreadListAdapter | undefined;
+    } | undefined;
+    unstable_capabilities?: {
+        copy?: boolean | undefined;
+    } | undefined;
+    /**
+     * Opt in to the built-in client-side tool-invocations pipeline
+     * (`streamCall` / `execute` / tool-status tracking) for this thread.
+     *
+     * Defaults to `false` — the runtime does *not* drive client-side tool
+     * callbacks on its own. Set to `true` to have the runtime construct a
+     * `ToolInvocationTracker` and feed every snapshot through it, so tool
+     * callbacks fire automatically for tool-call parts in `messages`.
+     *
+     * Opt-in by default because most external-store runtimes either run
+     * tools entirely server-side, or already wire their own client-side
+     * dispatch path. Enabling the embedded tracker on top of an existing
+     * dispatch path would cause tool callbacks to run twice.
+     *
+     * When enabled, client-side tool results (from `execute()` returning,
+     * or from `streamCall` resolving) flow back through
+     * `adapter.onAddToolResult` like any other tool result, with
+     * `modelContent` populated when present.
+     */
+    unstable_enableToolInvocations?: boolean | undefined;
+    /**
+     * Decides whether a tool call's result is produced on the client. Only
+     * consulted when `unstable_enableToolInvocations` is `true`.
+     *
+     * A provider that runs tools itself answers its own calls, and its result
+     * arrives one or more snapshots after the call's arguments complete. In
+     * that window the call is complete and result-less, so a registered tool
+     * of the same name would otherwise execute locally and produce a result
+     * the provider never asked for. An adapter that can tell the two apart
+     * supplies this predicate; it is read once per tool call, when the call is
+     * first observed live.
+     *
+     * The predicate is also what licenses running a frontend tool while the
+     * provider's run is still open. Without it, ownership is unknown until the
+     * run ends, so a registered tool executes only once the run's outcome is
+     * known and cannot fire on a call the provider was about to answer or gate.
+     */
+    unstable_isClientToolCall?: ((toolCall: ToolCallMessagePart) => boolean) | undefined;
+    /**
+     * Receives the current per-tool-call execution status map whenever it
+     * changes. Only invoked when `unstable_enableToolInvocations` is `true`
+     * — the runtime maintains the map via the embedded tracker.
+     *
+     * Wire this into local React state and feed it into the converter's
+     * `metadata.toolStatuses` so the UI can render `executing` spinners
+     * and human-input prompts.
+     */
+    setToolStatuses?: ((statuses: Record<string, ToolExecutionStatus>) => void) | undefined;
 };
 export type ExternalStoreAdapter<T = ThreadMessage> = ExternalStoreAdapterBase<T> & (T extends ThreadMessage ? object : ExternalStoreMessageConverterAdapter<T>);
-//#endregion
+export {};
 //# sourceMappingURL=external-store-adapter.d.ts.map