@assistant-ui/core 0.3.19 → 0.3.21

package/dist/runtime/interfaces/thread-list-runtime-core.d.ts

@@ -1,74 +1,71 @@
-import { Unsubscribe } from "../../types/unsubscribe.js";
-import { ThreadRuntimeCore, ThreadRuntimeEventType } from "./thread-runtime-core.js";
-//#region src/runtime/interfaces/thread-list-runtime-core.d.ts
-type ThreadListItemStatus = "archived" | "regular" | "new" | "deleted";
-type ThreadListItemCoreState = {
-  readonly id: string;
-  readonly remoteId: string | undefined;
-  readonly externalId: string | undefined;
-  readonly status: ThreadListItemStatus;
-  readonly title?: string | undefined;
-  readonly lastMessageAt?: Date | undefined;
-  readonly custom?: Record<string, unknown> | undefined;
-  readonly runtime?: ThreadRuntimeCore | undefined;
+import type { Unsubscribe } from "../../types/unsubscribe.js";
+import type { ThreadRuntimeCore, ThreadRuntimeEventType } from "./thread-runtime-core.js";
+export type ThreadListItemStatus = "archived" | "regular" | "new" | "deleted";
+export type ThreadListItemCoreState = {
+    readonly id: string;
+    readonly remoteId: string | undefined;
+    readonly externalId: string | undefined;
+    readonly status: ThreadListItemStatus;
+    readonly title?: string | undefined;
+    readonly lastMessageAt?: Date | undefined;
+    readonly custom?: Record<string, unknown> | undefined;
+    readonly runtime?: ThreadRuntimeCore | undefined;
 };
-type ThreadListRuntimeEvent = {
-  readonly threadId: string;
-  readonly type: ThreadRuntimeEventType;
+export type ThreadListRuntimeEvent = {
+    readonly threadId: string;
+    readonly type: ThreadRuntimeEventType;
 };
-type ThreadListRuntimeCore = {
-  readonly isLoading: boolean;
-  readonly loadError?: unknown;
-  readonly isLoadingMore?: boolean;
-  readonly hasMore?: boolean;
-  mainThreadId: string;
-  newThreadId: string | undefined;
-  threadIds: readonly string[];
-  archivedThreadIds: readonly string[];
-  readonly threadItems: Readonly<Record<string, ThreadListItemCoreState>>;
-  getMainThreadRuntimeCore(): ThreadRuntimeCore;
-  getThreadRuntimeCore(threadId: string): ThreadRuntimeCore;
-  /**
-   * Whether the thread currently has a run in progress, including a run on a
-   * thread that is not the main one. Implemented by thread lists that keep
-   * runtimes alive for non-main threads, and they notify their subscribers
-   * whenever the answer changes. A thread list that mounts only the main thread
-   * leaves this undefined: its other threads have no runtime and so cannot be
-   * running, and the main thread's run state is read from its runtime directly.
-   */
-  unstable_isThreadRunning?(threadId: string): boolean;
-  /**
-   * Lifecycle events from every thread this list keeps alive, including
-   * threads that are not the main one. Implemented by thread lists that keep
-   * runtimes alive for non-main threads. A thread list that mounts only the
-   * main thread leaves this undefined: its other threads have no runtime and so
-   * emit nothing, and the main thread's runtime is observed directly.
-   */
-  unstable_subscribeThreadEvents?(callback: (event: ThreadListRuntimeEvent) => void): Unsubscribe;
-  getItemById(threadId: string): ThreadListItemCoreState | undefined;
-  switchToThread(threadId: string, options?: {
-    unarchive?: boolean;
-  }): Promise<void>;
-  switchToNewThread(): Promise<void>;
-  getLoadThreadsPromise(): Promise<void>;
-  reload?(): Promise<void>;
-  reloadMainThread?(): Promise<void>;
-  loadMore?(): Promise<void>;
-  detach(threadId: string): Promise<void>;
-  rename(threadId: string, newTitle: string): Promise<void>;
-  updateCustom?(threadId: string, custom: Record<string, unknown> | undefined): Promise<void>;
-  archive(threadId: string): Promise<void>;
-  unarchive(threadId: string): Promise<void>;
-  delete(threadId: string): Promise<void>;
-  initialize(threadId: string): Promise<{
-    remoteId: string;
-    externalId: string | undefined;
-  }>;
-  generateTitle(threadId: string, options?: {
-    automatic?: boolean;
-  }): Promise<void>;
-  subscribe(callback: () => void): Unsubscribe;
+export type ThreadListRuntimeCore = {
+    readonly isLoading: boolean;
+    readonly loadError?: unknown;
+    readonly isLoadingMore?: boolean;
+    readonly hasMore?: boolean;
+    mainThreadId: string;
+    newThreadId: string | undefined;
+    threadIds: readonly string[];
+    archivedThreadIds: readonly string[];
+    readonly threadItems: Readonly<Record<string, ThreadListItemCoreState>>;
+    getMainThreadRuntimeCore(): ThreadRuntimeCore;
+    getThreadRuntimeCore(threadId: string): ThreadRuntimeCore;
+    /**
+     * Whether the thread currently has a run in progress, including a run on a
+     * thread that is not the main one. Implemented by thread lists that keep
+     * runtimes alive for non-main threads, and they notify their subscribers
+     * whenever the answer changes. A thread list that mounts only the main thread
+     * leaves this undefined: its other threads have no runtime and so cannot be
+     * running, and the main thread's run state is read from its runtime directly.
+     */
+    unstable_isThreadRunning?(threadId: string): boolean;
+    /**
+     * Lifecycle events from every thread this list keeps alive, including
+     * threads that are not the main one. Implemented by thread lists that keep
+     * runtimes alive for non-main threads. A thread list that mounts only the
+     * main thread leaves this undefined: its other threads have no runtime and so
+     * emit nothing, and the main thread's runtime is observed directly.
+     */
+    unstable_subscribeThreadEvents?(callback: (event: ThreadListRuntimeEvent) => void): Unsubscribe;
+    getItemById(threadId: string): ThreadListItemCoreState | undefined;
+    switchToThread(threadId: string, options?: {
+        unarchive?: boolean;
+    }): Promise<void>;
+    switchToNewThread(): Promise<void>;
+    getLoadThreadsPromise(): Promise<void>;
+    reload?(): Promise<void>;
+    reloadMainThread?(): Promise<void>;
+    loadMore?(): Promise<void>;
+    detach(threadId: string): Promise<void>;
+    rename(threadId: string, newTitle: string): Promise<void>;
+    updateCustom?(threadId: string, custom: Record<string, unknown> | undefined): Promise<void>;
+    archive(threadId: string): Promise<void>;
+    unarchive(threadId: string): Promise<void>;
+    delete(threadId: string): Promise<void>;
+    initialize(threadId: string): Promise<{
+        remoteId: string;
+        externalId: string | undefined;
+    }>;
+    generateTitle(threadId: string, options?: {
+        automatic?: boolean;
+    }): Promise<void>;
+    subscribe(callback: () => void): Unsubscribe;
 };
-//#endregion
-export { ThreadListItemCoreState, ThreadListItemStatus, ThreadListRuntimeCore, ThreadListRuntimeEvent };
 //# sourceMappingURL=thread-list-runtime-core.d.ts.map

package/dist/runtime/interfaces/thread-list-runtime-core.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"thread-list-runtime-core.d.ts","names":[],"sources":["../../../src/runtime/interfaces/thread-list-runtime-core.ts"],"mappings":";;;KAMY;KAEA;WACD;WACA;WACA;WAEA,QAAQ;WACR;WACA,gBAAgB;WAChB,SAAS;WAET,UAAU;;KAGT;WACD;WACA,MAAM;;KAGL;WACD;WACA;WACA;WACA;EACT;EACA;EAEA;EACA;WAES,aAAa,SAAS,eAAe;EAE9C,4BAA4B;EAC5B,qBAAqB,mBAAmB;;;;;;;;;EAUxC,0BAA0B;;;;;;;;EAS1B,gCACE,WAAW,OAAO,kCACjB;EAEH,YAAY,mBAAmB;EAE/B,eACE,kBACA;IAAY;MACX;EACH,qBAAqB;EAErB,yBAAyB;EACzB,WAAW;EACX,qBAAqB;EACrB,aAAa;EAEb,OAAO,mBAAmB;EAC1B,OAAO,kBAAkB,mBAAmB;EAC5C,cACE,kBACA,QAAQ,sCACP;EACH,QAAQ,mBAAmB;EAC3B,UAAU,mBAAmB;EAC7B,OAAO,mBAAmB;EAE1B,WACE,mBACC;IAAU;IAAkB;;EAC/B,cACE,kBACA;IAAY;MACX;EAEH,UAAU,uBAAuB"}
+{"version":3,"file":"thread-list-runtime-core.d.ts","sourceRoot":"","sources":["../../../src/runtime/interfaces/thread-list-runtime-core.ts"],"names":[],"mappings":"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"}

package/dist/runtime/interfaces/thread-runtime-core.d.ts

@@ -1,225 +1,239 @@
-import { AppendMessage, RunConfig, ThreadMessage } from "../../types/message.js";
-import { Unsubscribe } from "../../types/unsubscribe.js";
-import { SpeechSynthesisAdapter } from "../../adapters/speech.js";
-import { RealtimeVoiceAdapter } from "../../adapters/voice.js";
-import { ModelContext } from "../../model-context/types.js";
-import { ChatModelRunOptions, ChatModelRunResult } from "../utils/chat-model-adapter.js";
-import { ThreadMessageLike } from "../utils/thread-message-like.js";
-import { ExportedMessageRepository } from "../utils/message-repository.js";
-import { QueueItemState } from "../queue/queue-item.js";
-import { QueuePlacement } from "../queue/external-thread-queue-adapter.js";
-import { EditComposerRuntimeCore, ThreadComposerRuntimeCore } from "./composer-runtime-core.js";
-import { ToolModelContentPart } from "assistant-stream";
-import { ReadonlyJSONValue } from "assistant-stream/utils";
-//#region src/runtime/interfaces/thread-runtime-core.d.ts
-type RuntimeCapabilities = {
-  readonly switchToBranch: boolean;
-  readonly switchBranchDuringRun: boolean;
-  readonly edit: boolean;
-  readonly reload: boolean;
-  /** Whether the runtime can refetch this thread's remote state in place. */
-  readonly refetchThread: boolean;
-  readonly delete: boolean;
-  readonly cancel: boolean;
-  readonly unstable_copy: boolean;
-  readonly speech: boolean;
-  readonly dictation: boolean;
-  readonly voice: boolean;
-  readonly attachments: boolean;
-  readonly feedback: boolean;
-  readonly queue: boolean;
+import type { ToolModelContentPart } from "assistant-stream";
+import type { ReadonlyJSONValue } from "assistant-stream/utils";
+import type { ModelContext } from "../../model-context/types.js";
+import type { Unsubscribe } from "../../types/unsubscribe.js";
+import type { AppendMessage, ThreadMessage, Unstable_ToolInteraction } from "../../types/message.js";
+import type { RunConfig } from "../../types/message.js";
+import type { SpeechSynthesisAdapter } from "../../adapters/speech.js";
+import type { RealtimeVoiceAdapter } from "../../adapters/voice.js";
+import type { ChatModelRunOptions, ChatModelRunResult } from "../utils/chat-model-adapter.js";
+import type { ExportedMessageRepository } from "../utils/message-repository.js";
+import type { ThreadMessageLike } from "../utils/thread-message-like.js";
+import type { EditComposerRuntimeCore, ThreadComposerRuntimeCore } from "./composer-runtime-core.js";
+import type { QueueItemState } from "../queue/queue-item.js";
+import type { QueuePlacement } from "../queue/external-thread-queue-adapter.js";
+export type RuntimeCapabilities = {
+    readonly switchToBranch: boolean;
+    readonly switchBranchDuringRun: boolean;
+    readonly edit: boolean;
+    readonly reload: boolean;
+    /** Whether the runtime can refetch this thread's remote state in place. */
+    readonly refetchThread: boolean;
+    readonly delete: boolean;
+    readonly cancel: boolean;
+    readonly unstable_copy: boolean;
+    readonly speech: boolean;
+    readonly dictation: boolean;
+    readonly voice: boolean;
+    readonly attachments: boolean;
+    readonly feedback: boolean;
+    readonly queue: boolean;
 };
-type AddToolResultOptions = {
-  messageId: string;
-  toolName: string;
-  toolCallId: string;
-  result: ReadonlyJSONValue;
-  isError: boolean;
-  artifact?: ReadonlyJSONValue | undefined;
-  /**
-   * Optional model-content payload produced by the tool. Populated when a
-   * client-side `execute()` or `streamCall` returns a `ToolResponse` with
-   * `modelContent`. Forwarded through `adapter.onAddToolResult` so the
-   * adapter can include it when sending the result back to its backend.
-   */
-  modelContent?: readonly ToolModelContentPart[] | undefined;
-};
-type ResumeToolCallOptions = {
-  toolCallId: string;
-  payload: unknown;
+export type AddToolResultOptions = {
+    messageId: string;
+    toolName: string;
+    toolCallId: string;
+    result: ReadonlyJSONValue;
+    isError: boolean;
+    artifact?: ReadonlyJSONValue | undefined;
+    /**
+     * Optional model-content payload produced by the tool. Populated when a
+     * client-side `execute()` or `streamCall` returns a `ToolResponse` with
+     * `modelContent`. Forwarded through `adapter.onAddToolResult` so the
+     * adapter can include it when sending the result back to its backend.
+     */
+    modelContent?: readonly ToolModelContentPart[] | undefined;
 };
-type RespondToToolApprovalOptions = {
-  approvalId: string;
-  approved: boolean;
-  /** The approval option that produced this decision, when the request carried options. */
-  optionId?: string;
-  /** The free-form answer, when the request asked for one. */
-  text?: string;
-  reason?: string;
+export type ResumeToolCallOptions = {
+    toolCallId: string;
+    payload: unknown;
 };
-type SubmitFeedbackOptions = {
-  messageId: string;
-  type: "negative" | "positive";
+export type Unstable_RecordToolInteractionOptions = {
+    messageId: string;
+    toolCallId: string;
+    interaction: Unstable_ToolInteraction;
 };
-type ThreadSuggestion = {
-  /** Display heading for the suggestion. Falls back to the prompt when absent. */
-  title?: string;
-  /** Secondary display text shown alongside the title. */
-  label?: string;
-  /** The message text sent when the suggestion is selected. */
-  prompt: string;
+export type RespondToToolApprovalOptions = {
+    approvalId: string;
+    approved: boolean;
+    /** The approval option that produced this decision, when the request carried options. */
+    optionId?: string;
+    /** The free-form answer, when the request asked for one. */
+    text?: string;
+    reason?: string;
 };
-type SpeechState = {
-  readonly messageId: string;
-  readonly status: SpeechSynthesisAdapter.Status;
+export type SubmitFeedbackOptions = {
+    messageId: string;
+    type: "negative" | "positive";
+    comment?: string;
 };
-type VoiceSessionState = {
-  readonly status: RealtimeVoiceAdapter.Status;
-  readonly isMuted: boolean;
-  readonly mode: RealtimeVoiceAdapter.Mode;
+export type ThreadSuggestion = {
+    /** Display heading for the suggestion. Falls back to the prompt when absent. */
+    title?: string;
+    /** Secondary display text shown alongside the title. */
+    label?: string;
+    /** The message text sent when the suggestion is selected. */
+    prompt: string;
 };
-type SubmittedFeedback = {
-  readonly type: "negative" | "positive";
+export type SpeechState = {
+    readonly messageId: string;
+    readonly status: SpeechSynthesisAdapter.Status;
 };
-type ThreadRuntimeEventPayload = {
-  toolApprovalAnswered: {
-    messageId: string;
-    toolCallId: string;
-    toolName: string;
-    approved: boolean;
-  };
-  /**
-   * @deprecated State-derivable. Observe `state.isRunning` flipping to `true`
-   * via `subscribe` + `getState` instead. Note: this event fires at the
-   * transition point and may run before the next subscriber notification.
-   * Kept for backward compatibility.
-   */
-  runStart: Record<string, never>;
-  /**
-   * @deprecated State-derivable. Observe `state.isRunning` flipping to `false`
-   * via `subscribe` + `getState` instead. Note: this event fires at the
-   * transition point and may run before the next subscriber notification.
-   * Kept for backward compatibility.
-   */
-  runEnd: Record<string, never>;
-  /**
-   * @deprecated State-derivable. Observe `state.messages` becoming non-empty
-   * via a regular `subscribe` callback instead. This event fires once at the
-   * initialization transition; subscribers that attach afterwards receive a
-   * one-off replay (on a microtask), by which point the thread already has
-   * messages, so handler-visible state differs between live and replayed
-   * delivery. Kept for backward compatibility.
-   */
-  initialize: Record<string, never>;
-  /**
-   * Truly transient. The model context lives in a provider, not in thread
-   * state, so this event has no state-derivable equivalent.
-   */
-  modelContextUpdate: Record<string, never>;
+export type VoiceSessionState = {
+    readonly status: RealtimeVoiceAdapter.Status;
+    readonly isMuted: boolean;
+    readonly mode: RealtimeVoiceAdapter.Mode;
+    /**
+     * Whether the running session takes typed text. While true, `append` routes a plain text user message into the session and the thread composer can send.
+     */
+    readonly canSendText: boolean;
 };
-type ThreadRuntimeEventType = keyof ThreadRuntimeEventPayload;
-type ThreadRuntimeEventCallback<E extends ThreadRuntimeEventType> = (payload: ThreadRuntimeEventPayload[E]) => void;
-type StartRunConfig = {
-  parentId: string | null;
-  sourceId: string | null;
-  runConfig: RunConfig;
+export type SubmittedFeedback = {
+    readonly type: "negative" | "positive";
+    readonly comment?: string;
 };
-type ResumeRunConfig = StartRunConfig & {
-  stream?: (options: ChatModelRunOptions) => AsyncGenerator<ChatModelRunResult, void, unknown>;
+export type ThreadRuntimeEventPayload = {
+    toolApprovalAnswered: {
+        messageId: string;
+        toolCallId: string;
+        toolName: string;
+        approved: boolean;
+    };
+    /**
+     * @deprecated State-derivable. Observe `state.isRunning` flipping to `true`
+     * via `subscribe` + `getState` instead. Note: this event fires at the
+     * transition point and may run before the next subscriber notification.
+     * Kept for backward compatibility.
+     */
+    runStart: Record<string, never>;
+    /**
+     * @deprecated State-derivable. Observe `state.isRunning` flipping to `false`
+     * via `subscribe` + `getState` instead. Note: this event fires at the
+     * transition point and may run before the next subscriber notification.
+     * Kept for backward compatibility.
+     */
+    runEnd: Record<string, never>;
+    /**
+     * @deprecated State-derivable. Observe `state.messages` becoming non-empty
+     * via a regular `subscribe` callback instead. This event fires once at the
+     * initialization transition; subscribers that attach afterwards receive a
+     * one-off replay (on a microtask), by which point the thread already has
+     * messages, so handler-visible state differs between live and replayed
+     * delivery. Kept for backward compatibility.
+     */
+    initialize: Record<string, never>;
+    /**
+     * Truly transient. The model context lives in a provider, not in thread
+     * state, so this event has no state-derivable equivalent.
+     */
+    modelContextUpdate: Record<string, never>;
 };
-type ThreadRuntimeCore = Readonly<{
-  getMessageById: (messageId: string) => {
+export type ThreadRuntimeEventType = keyof ThreadRuntimeEventPayload;
+export type ThreadRuntimeEventCallback<E extends ThreadRuntimeEventType> = (payload: ThreadRuntimeEventPayload[E]) => void;
+export type StartRunConfig = {
     parentId: string | null;
-    message: ThreadMessage;
-    index: number;
-  } | undefined;
-  getBranches: (messageId: string) => readonly string[];
-  switchToBranch: (branchId: string) => void;
-  append: (message: AppendMessage) => void;
-  deleteMessage: (messageId: string) => void | Promise<void>;
-  startRun: (config: StartRunConfig) => void;
-  resumeRun: (config: ResumeRunConfig) => void;
-  cancelRun: () => void;
-  unstable_notifySessionReset: () => void;
-  addToolResult: (options: AddToolResultOptions) => void;
-  resumeToolCall: (options: ResumeToolCallOptions) => void;
-  /**
-   * Records a decision on a tool approval gate. Resolves once the runtime has
-   * accepted the response and rejects when it could not be recorded, so a
-   * caller can leave the gate retryable rather than spending it. A capability
-   * or state precondition still throws synchronously; a failure to record
-   * arrives as a rejection, including one an adapter raises synchronously.
-   *
-   * Acceptance is as far as the runtime can see the response: one that records
-   * the decision locally settles on the record, while one that answers by
-   * resuming a run settles on the resume. A failure of the work the decision
-   * unblocks is reported through the runtime's own error channel, not here.
-   */
-  respondToToolApproval: (options: RespondToToolApprovalOptions) => Promise<void>;
-  speak: (messageId: string) => void;
-  stopSpeaking: () => void;
-  connectVoice: () => void;
-  disconnectVoice: () => void;
-  muteVoice: () => void;
-  unmuteVoice: () => void;
-  submitFeedback: (feedback: SubmitFeedbackOptions) => void;
-  getModelContext: () => ModelContext;
-  composer: ThreadComposerRuntimeCore;
-  getEditComposer: (messageId: string) => EditComposerRuntimeCore | undefined;
-  beginEdit: (messageId: string) => void;
-  getQueueItems?: () => readonly QueueItemState[];
-  getSteerQueueItems?: () => readonly QueueItemState[];
-  moveQueueItem?: (queueItemId: string, placement: QueuePlacement) => void;
-  removeQueueItem?: (queueItemId: string) => void;
-  speech: SpeechState | undefined;
-  voice: VoiceSessionState | undefined;
-  capabilities: Readonly<RuntimeCapabilities>;
-  isDisabled: boolean;
-  /**
-   * Whether sending from this thread's composer is disabled. Surfaces the
-   * `isSendDisabled` flag from external-store adapters; internal runtimes
-   * default to `false`. Composer state derives `canSend` from this.
-   */
-  isSendDisabled: boolean;
-  isLoading: boolean;
-  /**
-   * Optional explicit thread-level running flag. When provided, takes
-   * precedence over the last-message-status heuristic. When omitted, falls
-   * back to the legacy behavior. External-store runtimes surface this via
-   * `ExternalStoreAdapter.isRunning`.
-   */
-  isRunning?: boolean | undefined;
-  messages: readonly ThreadMessage[];
-  state: ReadonlyJSONValue;
-  suggestions: readonly ThreadSuggestion[];
-  extras: unknown;
-  subscribe: (callback: () => void) => Unsubscribe;
-  getVoiceVolume: () => number;
-  subscribeVoiceVolume: (callback: () => void) => Unsubscribe;
-  import(repository: ExportedMessageRepository): void;
-  export(): ExportedMessageRepository;
-  exportExternalState(): any;
-  importExternalState(state: any): void;
-  reset(initialMessages?: readonly ThreadMessageLike[]): void;
-  /**
-   * Re-fetches this thread's state from its backing store, in place: no
-   * runtime-hook remount, so runtime identity and composer drafts survive.
-   * Presence signals the capability to `threads.reloadMainThread()`, which
-   * calls this and propagates its rejection. It does not touch a run in
-   * progress first, because stopping one is `cancelRun`, whose contract is
-   * that the user abandoned a send: it returns the trailing user message to
-   * the composer. An implementation is therefore responsible for whatever
-   * coordination a concurrent run needs. Runtimes without remote state leave
-   * it undefined.
-   */
-  unstable_refetchThread?: (() => Promise<void>) | undefined;
-  /**
-   * @deprecated This API is still under active development and might change without notice.
-   * For state-derivable transitions, prefer `subscribe` + `getState`. This channel is the
-   * escape hatch for transient occurrences not represented in state.
-   */
-  unstable_on<E extends ThreadRuntimeEventType>(event: E, callback: ThreadRuntimeEventCallback<E>): Unsubscribe;
+    sourceId: string | null;
+    runConfig: RunConfig;
+};
+export type ResumeRunConfig = StartRunConfig & {
+    stream?: (options: ChatModelRunOptions) => AsyncGenerator<ChatModelRunResult, void, unknown>;
+};
+export type ThreadRuntimeCore = Readonly<{
+    getMessageById: (messageId: string) => {
+        parentId: string | null;
+        message: ThreadMessage;
+        index: number;
+    } | undefined;
+    getBranches: (messageId: string) => readonly string[];
+    switchToBranch: (branchId: string) => void;
+    append: (message: AppendMessage) => void;
+    deleteMessage: (messageId: string) => void | Promise<void>;
+    startRun: (config: StartRunConfig) => void;
+    resumeRun: (config: ResumeRunConfig) => void;
+    cancelRun: () => void;
+    unstable_notifySessionReset: () => void;
+    addToolResult: (options: AddToolResultOptions) => void;
+    resumeToolCall: (options: ResumeToolCallOptions) => void;
+    /**
+     * Records a decision on a tool approval gate. Resolves once the runtime has
+     * accepted the response and rejects when it could not be recorded, so a
+     * caller can leave the gate retryable rather than spending it. A capability
+     * or state precondition still throws synchronously; a failure to record
+     * arrives as a rejection, including one an adapter raises synchronously.
+     *
+     * Acceptance is as far as the runtime can see the response: one that records
+     * the decision locally settles on the record, while one that answers by
+     * resuming a run settles on the resume. A failure of the work the decision
+     * unblocks is reported through the runtime's own error channel, not here.
+     */
+    respondToToolApproval: (options: RespondToToolApprovalOptions) => Promise<void>;
+    /**
+     * Appends a validated interaction to a tool call part and persists it where
+     * the runtime persists messages. Rejects when the runtime cannot record it.
+     */
+    unstable_recordToolInteraction?: (options: Unstable_RecordToolInteractionOptions) => Promise<void>;
+    speak: (messageId: string) => void;
+    stopSpeaking: () => void;
+    connectVoice: () => void;
+    disconnectVoice: () => void;
+    muteVoice: () => void;
+    unmuteVoice: () => void;
+    submitFeedback: (feedback: SubmitFeedbackOptions) => void;
+    getModelContext: () => ModelContext;
+    composer: ThreadComposerRuntimeCore;
+    getEditComposer: (messageId: string) => EditComposerRuntimeCore | undefined;
+    beginEdit: (messageId: string) => void;
+    getQueueItems?: () => readonly QueueItemState[];
+    getSteerQueueItems?: () => readonly QueueItemState[];
+    moveQueueItem?: (queueItemId: string, placement: QueuePlacement) => void;
+    removeQueueItem?: (queueItemId: string) => void;
+    speech: SpeechState | undefined;
+    voice: VoiceSessionState | undefined;
+    capabilities: Readonly<RuntimeCapabilities>;
+    isDisabled: boolean;
+    /**
+     * Whether sending from this thread's composer is disabled. Surfaces the
+     * `isSendDisabled` flag from external-store adapters; internal runtimes
+     * default to `false`. Composer state derives `canSend` from this.
+     */
+    isSendDisabled: boolean;
+    isLoading: boolean;
+    /**
+     * Optional explicit thread-level running flag. When provided, takes
+     * precedence over the last-message-status heuristic. When omitted, falls
+     * back to the legacy behavior. External-store runtimes surface this via
+     * `ExternalStoreAdapter.isRunning`.
+     */
+    isRunning?: boolean | undefined;
+    messages: readonly ThreadMessage[];
+    state: ReadonlyJSONValue;
+    suggestions: readonly ThreadSuggestion[];
+    extras: unknown;
+    subscribe: (callback: () => void) => Unsubscribe;
+    getVoiceVolume: () => number;
+    subscribeVoiceVolume: (callback: () => void) => Unsubscribe;
+    import(repository: ExportedMessageRepository): void;
+    export(): ExportedMessageRepository;
+    exportExternalState(): any;
+    importExternalState(state: any): void;
+    reset(initialMessages?: readonly ThreadMessageLike[]): void;
+    /**
+     * Re-fetches this thread's state from its backing store, in place: no
+     * runtime-hook remount, so runtime identity and composer drafts survive.
+     * Presence signals the capability to `threads.reloadMainThread()`, which
+     * calls this and propagates its rejection. It does not touch a run in
+     * progress first, because stopping one is `cancelRun`, whose contract is
+     * that the user abandoned a send: it returns the trailing user message to
+     * the composer. An implementation is therefore responsible for whatever
+     * coordination a concurrent run needs. Runtimes without remote state leave
+     * it undefined.
+     */
+    unstable_refetchThread?: (() => Promise<void>) | undefined;
+    /**
+     * @deprecated This API is still under active development and might change without notice.
+     * For state-derivable transitions, prefer `subscribe` + `getState`. This channel is the
+     * escape hatch for transient occurrences not represented in state.
+     */
+    unstable_on<E extends ThreadRuntimeEventType>(event: E, callback: ThreadRuntimeEventCallback<E>): Unsubscribe;
 }>;
-//#endregion
-export { AddToolResultOptions, RespondToToolApprovalOptions, ResumeRunConfig, ResumeToolCallOptions, RuntimeCapabilities, SpeechState, StartRunConfig, SubmitFeedbackOptions, SubmittedFeedback, ThreadRuntimeCore, ThreadRuntimeEventCallback, ThreadRuntimeEventPayload, ThreadRuntimeEventType, ThreadSuggestion, VoiceSessionState };
 //# sourceMappingURL=thread-runtime-core.d.ts.map