@assistant-ui/core 0.3.19 → 0.3.21

package/dist/runtimes/remote-thread-list/types.d.ts

@@ -1,131 +1,129 @@
-import { ThreadMessage } from "../../types/message.js";
-import { AttachmentAdapter } from "../../adapters/attachment.js";
-import { FeedbackAdapter } from "../../adapters/feedback.js";
-import { ModelContextProvider } from "../../model-context/types.js";
-import { ThreadHistoryAdapter } from "../../adapters/thread-history.js";
-import { AssistantRuntime } from "../../runtime/api/assistant-runtime.js";
-import { AssistantStream } from "assistant-stream";
-//#region src/runtimes/remote-thread-list/types.d.ts
+import type { ThreadMessage } from "../../types/message.js";
+import type { AssistantRuntime } from "../../runtime/api/assistant-runtime.js";
+import type { AssistantStream } from "assistant-stream";
+import type { ThreadHistoryAdapter } from "../../adapters/thread-history.js";
+import type { AttachmentAdapter } from "../../adapters/attachment.js";
+import type { FeedbackAdapter } from "../../adapters/feedback.js";
+import type { ModelContextProvider } from "../../model-context/types.js";
 type RemoteThreadListProviderProps = {
-  children?: any;
+    children?: any;
 };
-type RemoteThreadListProviderComponent = ((props: RemoteThreadListProviderProps) => any) | (new (props: RemoteThreadListProviderProps) => any);
-type RemoteThreadInitializeResponse = {
-  remoteId: string;
-  externalId?: string | undefined;
+export type RemoteThreadListProviderComponent = ((props: RemoteThreadListProviderProps) => any) | (new (props: RemoteThreadListProviderProps) => any);
+export type RemoteThreadInitializeResponse = {
+    remoteId: string;
+    externalId?: string | undefined;
 };
-type RemoteThreadMetadata = {
-  readonly status: "regular" | "archived";
-  readonly remoteId: string;
-  readonly externalId?: string | undefined;
-  readonly title?: string | undefined;
-  readonly lastMessageAt?: Date | undefined;
-  readonly custom?: Record<string, unknown> | undefined;
+export type RemoteThreadMetadata = {
+    readonly status: "regular" | "archived";
+    readonly remoteId: string;
+    readonly externalId?: string | undefined;
+    readonly title?: string | undefined;
+    readonly lastMessageAt?: Date | undefined;
+    readonly custom?: Record<string, unknown> | undefined;
 };
-type RemoteThreadListResponse = {
-  threads: RemoteThreadMetadata[];
-  nextCursor?: string | undefined;
+export type RemoteThreadListResponse = {
+    threads: RemoteThreadMetadata[];
+    nextCursor?: string | undefined;
 };
-type RemoteThreadListPageOptions = {
-  after?: string | undefined;
+export type RemoteThreadListPageOptions = {
+    after?: string | undefined;
 };
-type RuntimeAdapters = {
-  modelContext?: ModelContextProvider | undefined;
-  history?: ThreadHistoryAdapter | undefined;
-  attachments?: AttachmentAdapter | undefined;
-  feedback?: FeedbackAdapter | undefined;
+export type RuntimeAdapters = {
+    modelContext?: ModelContextProvider | undefined;
+    history?: ThreadHistoryAdapter | undefined;
+    attachments?: AttachmentAdapter | undefined;
+    feedback?: FeedbackAdapter | undefined;
 };
-type RemoteThreadListAdapter = {
-  list(params?: RemoteThreadListPageOptions): Promise<RemoteThreadListResponse>;
-  rename(remoteId: string, newTitle: string): Promise<void>;
-  updateCustom?(remoteId: string, custom: Record<string, unknown> | undefined): Promise<void>;
-  archive(remoteId: string): Promise<void>;
-  unarchive(remoteId: string): Promise<void>;
-  delete(remoteId: string): Promise<void>;
-  initialize(threadId: string): Promise<RemoteThreadInitializeResponse>;
-  /**
-   * Generates a title for the thread and streams it back.
-   *
-   * When the generation persists the title itself, the returned stream must
-   * not complete before that write has landed. Concurrent generations are
-   * ordered by stream completion, and a run whose write outlives its stream
-   * can overwrite a newer title.
-   */
-  generateTitle(remoteId: string, unstable_messages: readonly ThreadMessage[]): Promise<AssistantStream>;
-  fetch(threadId: string): Promise<RemoteThreadMetadata>;
-  /**
-   * Optional React component wrapped around each active thread. Use it to
-   * inject per-thread context such as a history or attachments adapter (see
-   * `useCloudThreadListAdapter` for the canonical shape).
-   *
-   * `useRemoteThreadListRuntime` renders this component when present. If it
-   * is omitted, that host synthesizes a `RuntimeAdapterProvider` from
-   * `unstable_useAdapters`. The `RemoteThreadList` store entry ignores it;
-   * expose `unstable_useAdapters` for that host.
-   *
-   * The Provider must render `children` on its first commit; deferring them
-   * behind a loading state, a Suspense boundary, or a `useEffect`-gated render
-   * is unsupported and leaves thread context unavailable to downstream
-   * consumers. Load data inside an always-mounted child instead.
-   */
-  unstable_Provider?: RemoteThreadListProviderComponent | undefined;
-  /**
-   * Hook the `RemoteThreadList` store entry calls once per mounted thread
-   * body (the main-thread slot by default; every started thread with
-   * `backgroundThreads`), then provides to the `thread` factory. This is not
-   * mounted per listed thread. `useRemoteThreadListRuntime` also calls it
-   * when `unstable_Provider` is omitted. Resolve `threadListItem` lazily on
-   * each adapter call; do not capture it at hook mount. The hook must keep a
-   * stable hook count across adapter swaps; a different count throws.
-   * Memoize the returned object.
-   *
-   * Per-thread history also requires the `thread` factory to be keyed by
-   * thread id (`withKey(id, thread(...))`). History loaders such as
-   * `useExternalHistory` run once per mount; an unkeyed factory keeps one
-   * instance across switches and the next thread's messages never load.
-   */
-  unstable_useAdapters?: (() => RuntimeAdapters | null | undefined) | undefined;
+export type RemoteThreadListAdapter = {
+    list(params?: RemoteThreadListPageOptions): Promise<RemoteThreadListResponse>;
+    rename(remoteId: string, newTitle: string): Promise<void>;
+    updateCustom?(remoteId: string, custom: Record<string, unknown> | undefined): Promise<void>;
+    archive(remoteId: string): Promise<void>;
+    unarchive(remoteId: string): Promise<void>;
+    delete(remoteId: string): Promise<void>;
+    initialize(threadId: string): Promise<RemoteThreadInitializeResponse>;
+    /**
+     * Generates a title for the thread and streams it back.
+     *
+     * When the generation persists the title itself, the returned stream must
+     * not complete before that write has landed. Concurrent generations are
+     * ordered by stream completion, and a run whose write outlives its stream
+     * can overwrite a newer title.
+     */
+    generateTitle(remoteId: string, unstable_messages: readonly ThreadMessage[]): Promise<AssistantStream>;
+    fetch(threadId: string): Promise<RemoteThreadMetadata>;
+    /**
+     * Optional React component wrapped around each active thread. Use it to
+     * inject per-thread context such as a history or attachments adapter (see
+     * `useCloudThreadListAdapter` for the canonical shape).
+     *
+     * `useRemoteThreadListRuntime` renders this component when present. If it
+     * is omitted, that host synthesizes a `RuntimeAdapterProvider` from
+     * `unstable_useAdapters`. The `RemoteThreadList` store entry ignores it;
+     * expose `unstable_useAdapters` for that host.
+     *
+     * The Provider must render `children` on its first commit; deferring them
+     * behind a loading state, a Suspense boundary, or a `useEffect`-gated render
+     * is unsupported and leaves thread context unavailable to downstream
+     * consumers. Load data inside an always-mounted child instead.
+     */
+    unstable_Provider?: RemoteThreadListProviderComponent | undefined;
+    /**
+     * Hook the `RemoteThreadList` store entry calls once per mounted thread
+     * body (the main-thread slot by default; every started thread with
+     * `backgroundThreads`), then provides to the `thread` factory. This is not
+     * mounted per listed thread. `useRemoteThreadListRuntime` also calls it
+     * when `unstable_Provider` is omitted. Resolve `threadListItem` lazily on
+     * each adapter call; do not capture it at hook mount. The hook must keep a
+     * stable hook count across adapter swaps; a different count throws.
+     * Memoize the returned object.
+     *
+     * Per-thread history also requires the `thread` factory to be keyed by
+     * thread id (`withKey(id, thread(...))`). History loaders such as
+     * `useExternalHistory` run once per mount; an unkeyed factory keeps one
+     * instance across switches and the next thread's messages never load.
+     */
+    unstable_useAdapters?: (() => RuntimeAdapters | null | undefined) | undefined;
 };
-type RemoteThreadListOptions = {
-  runtimeHook: () => AssistantRuntime;
-  /**
-   * The adapter reference should remain stable across renders. Replacing it reloads the list and drops cached threads that are not in the replacement page. In-flight mutations from the previous adapter are cancelled.
-   */
-  adapter: RemoteThreadListAdapter;
-  /**
-   * When provided, the runtime starts on this thread instead of creating a
-   * new empty thread. Useful for URL-based routing (e.g. `/chat/[threadId]`)
-   * where the initial thread is known at mount time.
-   *
-   * @deprecated Use `threadId` instead, which also reacts to subsequent changes.
-   */
-  initialThreadId?: string | undefined;
-  /**
-   * The current thread ID to display. When this value changes, the runtime
-   * automatically switches to the specified thread. Set to `undefined` to
-   * switch to a new thread.
-   */
-  threadId?: string | undefined;
-  /**
-   * Called whenever the runtime changes the active thread's canonical (remote)
-   * ID, so the value can be treated as a managed/controlled variable (e.g.
-   * synced to a URL query param). Changes initiated by the controlled
-   * `threadId` option are not echoed back. Together these options form the
-   * controlled pattern: `threadId` in, `onThreadIdChange` out.
-   *
-   * Only the settled remote ID is emitted: while a freshly created thread is
-   * still optimistic (no remote ID yet) the value is `undefined`, and the real
-   * ID is emitted once the thread is initialized. The transient local ID is
-   * never surfaced.
-   */
-  onThreadIdChange?: ((threadId: string | undefined) => void) | undefined;
-  /**
-   * When true, if this runtime is used inside another RemoteThreadListRuntime,
-   * it becomes a no-op and simply calls the runtimeHook directly.
-   * This allows wrapping runtimes that internally use RemoteThreadListRuntime.
-   */
-  allowNesting?: boolean | undefined;
+export type RemoteThreadListOptions = {
+    runtimeHook: () => AssistantRuntime;
+    /**
+     * The adapter reference should remain stable across renders. Replacing it reloads the list and drops cached threads that are not in the replacement page. In-flight mutations from the previous adapter are cancelled.
+     */
+    adapter: RemoteThreadListAdapter;
+    /**
+     * When provided, the runtime starts on this thread instead of creating a
+     * new empty thread. Useful for URL-based routing (e.g. `/chat/[threadId]`)
+     * where the initial thread is known at mount time.
+     *
+     * @deprecated Use `threadId` instead, which also reacts to subsequent changes.
+     */
+    initialThreadId?: string | undefined;
+    /**
+     * The current thread ID to display. When this value changes, the runtime
+     * automatically switches to the specified thread. Set to `undefined` to
+     * switch to a new thread.
+     */
+    threadId?: string | undefined;
+    /**
+     * Called whenever the runtime changes the active thread's canonical (remote)
+     * ID, so the value can be treated as a managed/controlled variable (e.g.
+     * synced to a URL query param). Changes initiated by the controlled
+     * `threadId` option are not echoed back. Together these options form the
+     * controlled pattern: `threadId` in, `onThreadIdChange` out.
+     *
+     * Only the settled remote ID is emitted: while a freshly created thread is
+     * still optimistic (no remote ID yet) the value is `undefined`, and the real
+     * ID is emitted once the thread is initialized. The transient local ID is
+     * never surfaced.
+     */
+    onThreadIdChange?: ((threadId: string | undefined) => void) | undefined;
+    /**
+     * When true, if this runtime is used inside another RemoteThreadListRuntime,
+     * it becomes a no-op and simply calls the runtimeHook directly.
+     * This allows wrapping runtimes that internally use RemoteThreadListRuntime.
+     */
+    allowNesting?: boolean | undefined;
 };
-//#endregion
-export { RemoteThreadInitializeResponse, RemoteThreadListAdapter, RemoteThreadListOptions, RemoteThreadListPageOptions, RemoteThreadListProviderComponent, RemoteThreadListResponse, RemoteThreadMetadata, RuntimeAdapters };
+export {};
 //# sourceMappingURL=types.d.ts.map

package/dist/runtimes/remote-thread-list/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/runtimes/remote-thread-list/types.ts"],"mappings":";;;;;;;;KASK;EAAkC;;KAE3B,sCACN,OAAO,+CACH,OAAO;KAGL;EACV;EACA;;KAGU;WACD;WACA;WACA;WACA;WACA,gBAAgB;WAChB,SAAS;;KAGR;EACV,SAAS;EACT;;KAGU;EACV;;KAGU;EACV,eAAe;EACf,UAAU;EACV,cAAc;EACd,WAAW;;KAGD;EACV,KAAK,SAAS,8BAA8B,QAAQ;EAEpD,OAAO,kBAAkB,mBAAmB;EAC5C,cACE,kBACA,QAAQ,sCACP;EACH,QAAQ,mBAAmB;EAC3B,UAAU,mBAAmB;EAC7B,OAAO,mBAAmB;EAC1B,WAAW,mBAAmB,QAAQ;;;;;;;;;EAStC,cACE,kBACA,4BAA4B,kBAC3B,QAAQ;EACX,MAAM,mBAAmB,QAAQ;;;;;;;;;;;;;;;;EAiBjC,oBAAoB;;;;;;;;;;;;;;;;EAiBpB,8BAA8B;;KAGpB;EACV,mBAAmB;;;;EAKnB,SAAS;;;;;;;;EAST;;;;;;EAOA;;;;;;;;;;;;;EAcA,qBAAqB;;;;;;EAOrB"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/runtimes/remote-thread-list/types.ts"],"names":[],"mappings":"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"}

package/dist/runtimes/tool-invocations/ToolInvocationTracker.d.ts

@@ -1,27 +1,26 @@
-import { ThreadMessage, ToolCallMessagePart } from "../../types/message.js";
-import { Tool, ToolModelContentPart } from "assistant-stream";
-import { ReadonlyJSONValue } from "assistant-stream/utils";
-//#region src/runtimes/tool-invocations/ToolInvocationTracker.d.ts
+import { type Tool, type ToolModelContentPart } from "assistant-stream";
+import { type ReadonlyJSONValue } from "assistant-stream/utils";
+import type { ThreadMessage, ToolCallMessagePart } from "../../types/message.js";
 /**
  * Streaming execution state for a frontend tool.
  */
-type ToolExecutionStatus = {
-  type: "executing";
+export type ToolExecutionStatus = {
+    type: "executing";
 } | {
-  type: "interrupt";
-  payload: {
-    type: "human";
-    payload: unknown;
-  };
+    type: "interrupt";
+    payload: {
+        type: "human";
+        payload: unknown;
+    };
 };
-type AddToolResultCommand = {
-  readonly type: "add-tool-result";
-  readonly toolCallId: string;
-  readonly toolName: string;
-  readonly result: ReadonlyJSONValue;
-  readonly isError: boolean;
-  readonly artifact?: ReadonlyJSONValue;
-  readonly modelContent?: readonly ToolModelContentPart[];
+export type AddToolResultCommand = {
+    readonly type: "add-tool-result";
+    readonly toolCallId: string;
+    readonly toolName: string;
+    readonly result: ReadonlyJSONValue;
+    readonly isError: boolean;
+    readonly artifact?: ReadonlyJSONValue;
+    readonly modelContent?: readonly ToolModelContentPart[];
 };
 /**
  * Plain-class port of the former `useToolInvocations` React hook. Owns the
@@ -45,141 +44,140 @@ type AddToolResultCommand = {
  *
  * @deprecated Internal — for framework bindings; not a public API. May change without notice.
  */
-declare class ToolInvocationTracker {
-  private readonly _getTools;
-  private readonly _callbacks;
-  private readonly _isClientToolCall;
-  private readonly _entries;
-  private readonly _humanInput;
-  private readonly _executing;
-  /**
-   * Tool calls whose turn ended before they reached the executor. Held here
-   * rather than on the entry because an entry is rebuilt whenever a snapshot
-   * re-creates the call, and this is the one reason to skip that no later
-   * snapshot carries.
-   */
-  private readonly _discardedToolCallIds;
-  private readonly _settledResolvers;
-  private _statuses;
-  private _ac;
-  private _pendingRestore;
-  /** Cached last snapshot, used to skip processing on identical re-renders. */
-  private _lastSnapshot;
-  private _isRunning;
-  private _controller;
-  /**
-   * Set when the assistant-stream pipeline has died (errored out via
-   * `.pipeTo(...).catch(...)`). The next `setState` re-initializes the
-   * pipeline and demotes each active entry that reached the executor to
-   * restored, so it survives the restart without re-firing `streamCall`.
-   * A restart is an execution boundary like `reset()`: an entry that had
-   * not reached it starts over and fires once there (F.4). Capped at a
-   * single auto-restart per session — repeated failures keep the tracker
-   * dead with a more visible error.
-   */
-  private _pipelineDead;
-  private _pipelineRestartUsed;
-  constructor(getTools: () => Record<string, Tool> | undefined, callbacks: ToolInvocationTracker.Callbacks, isClientToolCall?: (toolCall: ToolCallMessagePart) => boolean | undefined);
-  /**
-   * Build the assistant-stream pipeline. Called once from the constructor
-   * and at most once again if `_pipelineDead` is set (see F.4 in
-   * EDGE_CASES.md).
-   */
-  private _initPipeline;
-  /**
-   * Feed the next observed snapshot into the tracker. Called from the host
-   * runtime whenever its message list / running state changes.
-   */
-  setState(snapshot: ToolInvocationTracker.Snapshot): void;
-  /**
-   * Reset the tracker so the next observed snapshot is treated as historical.
-   * Clears entries and aborts any in-flight executions. Used by callers like
-   * `importExternalState` to mark a freshly loaded state as restored.
-   */
-  reset(): void;
-  /**
-   * Abort any in-flight `execute()` invocations. Resolves once all of them
-   * have settled (or immediately if none are running).
-   *
-   * `discardPending` additionally kills the calls that never reached the
-   * executor, for a caller ending the turn rather than interrupting it. The
-   * signal cannot reach those: they are waiting on the run to settle (A.10),
-   * and the settled snapshot arrives after this installs a fresh controller.
-   */
-  abort(options?: {
-    discardPending?: boolean;
-  }): Promise<void>;
-  /**
-   * Resolve a pending human-input request for the given tool call. Returns
-   * `true` if a pending request was resumed, `false` if the tracker has no
-   * outstanding request for that id (the caller should fall back to its own
-   * dispatch path).
-   */
-  resume(toolCallId: string, payload: unknown): boolean;
-  /**
-   * Returns the current tool execution status map. The returned `Map` is
-   * the tracker's internal store — do not mutate it. Treat the reference
-   * as a snapshot that may be replaced wholesale on the next status
-   * transition.
-   */
-  getStatuses(): ReadonlyMap<string, ToolExecutionStatus>;
-  private _getWrappedTools;
-  private _captureExecution;
-  private _onHumanInput;
-  private _onExecutionStart;
-  private _onExecutionEnd;
-  private _handleResultChunk;
-  private _invokeOnResult;
-  private _invokeOnStatusesChange;
-  private _setStatus;
-  private _deleteStatus;
-  private _warnProviderOwnedSkip;
-  /**
-   * Closing the args stream hands the call to the client executor, so it may
-   * only happen once the provider can no longer speak about that call. The run
-   * ending is the only universal signal for that; an adapter that reports the
-   * call as client-owned has said it earlier, per call.
-   */
-  private _shouldCloseArgsStream;
-  private _startActiveEntry;
-  /**
-   * Demote every active entry back to the restored phase. Used by the
-   * pipeline-restart path so that, after a fresh pipeline is built, the
-   * next observed snapshot does not re-fire `streamCall` for tool calls
-   * that already fired pre-death. Args / hasResult tracking is preserved
-   * so signature comparisons still work.
-   */
-  private _demoteEntriesToRestored;
-  private _processArgsText;
-  private _processMessages;
-}
-declare namespace ToolInvocationTracker {
-  type ExecutionStatus = ToolExecutionStatus;
-  type Snapshot = {
-    readonly messages: readonly ThreadMessage[];
-    /** Whether the producing runtime is currently streaming new output. */
-    readonly isRunning: boolean;
+export declare class ToolInvocationTracker {
+    private readonly _getTools;
+    private readonly _callbacks;
+    private readonly _isClientToolCall;
+    private readonly _entries;
+    private readonly _humanInput;
+    private readonly _executing;
+    /**
+     * Tool calls whose turn ended before they reached the executor. Held here
+     * rather than on the entry because an entry is rebuilt whenever a snapshot
+     * re-creates the call, and this is the one reason to skip that no later
+     * snapshot carries.
+     */
+    private readonly _discardedToolCallIds;
+    private readonly _settledResolvers;
+    private _statuses;
+    private _ac;
+    private _pendingRestore;
+    /** Cached last snapshot, used to skip processing on identical re-renders. */
+    private _lastSnapshot;
+    private _isRunning;
+    private _controller;
+    /**
+     * Set when the assistant-stream pipeline has died (errored out via
+     * `.pipeTo(...).catch(...)`). The next `setState` re-initializes the
+     * pipeline and demotes each active entry that reached the executor to
+     * restored, so it survives the restart without re-firing `streamCall`.
+     * A restart is an execution boundary like `reset()`: an entry that had
+     * not reached it starts over and fires once there (F.4). Capped at a
+     * single auto-restart per session — repeated failures keep the tracker
+     * dead with a more visible error.
+     */
+    private _pipelineDead;
+    private _pipelineRestartUsed;
+    constructor(getTools: () => Record<string, Tool> | undefined, callbacks: ToolInvocationTracker.Callbacks, isClientToolCall?: (toolCall: ToolCallMessagePart) => boolean | undefined);
+    /**
+     * Build the assistant-stream pipeline. Called once from the constructor
+     * and at most once again if `_pipelineDead` is set (see F.4 in
+     * EDGE_CASES.md).
+     */
+    private _initPipeline;
+    /**
+     * Feed the next observed snapshot into the tracker. Called from the host
+     * runtime whenever its message list / running state changes.
+     */
+    setState(snapshot: ToolInvocationTracker.Snapshot): void;
+    /**
+     * Reset the tracker so the next observed snapshot is treated as historical.
+     * Clears entries and aborts any in-flight executions. Used by callers like
+     * `importExternalState` to mark a freshly loaded state as restored.
+     */
+    reset(): void;
+    /**
+     * Abort any in-flight `execute()` invocations. Resolves once all of them
+     * have settled (or immediately if none are running).
+     *
+     * `discardPending` additionally kills the calls that never reached the
+     * executor, for a caller ending the turn rather than interrupting it. The
+     * signal cannot reach those: they are waiting on the run to settle (A.10),
+     * and the settled snapshot arrives after this installs a fresh controller.
+     */
+    abort(options?: {
+        discardPending?: boolean;
+    }): Promise<void>;
+    private _endHumanRequest;
+    /**
+     * Resolve a pending human-input request for the given tool call. Returns
+     * `true` if a pending request was resumed, `false` if the tracker has no
+     * outstanding request for that id (the caller should fall back to its own
+     * dispatch path).
+     */
+    resume(toolCallId: string, payload: unknown): boolean;
     /**
-     * Whether the producing runtime is still loading historical state.
-     * When `true`, every snapshot is treated as historical (no `streamCall` /
-     * `execute` fires). When `false`, processing resumes as live.
+     * Returns the current tool execution status map. The returned `Map` is
+     * the tracker's internal store — do not mutate it. Treat the reference
+     * as a snapshot that may be replaced wholesale on the next status
+     * transition.
      */
-    readonly isLoading?: boolean;
-  };
-  type Callbacks = {
+    getStatuses(): ReadonlyMap<string, ToolExecutionStatus>;
+    private _getWrappedTools;
+    private _captureExecution;
+    private _onHumanInput;
+    private _onExecutionStart;
+    private _onExecutionEnd;
+    private _handleResultChunk;
+    private _invokeOnResult;
+    private _invokeOnStatusesChange;
+    private _setStatus;
+    private _deleteStatus;
+    private _warnProviderOwnedSkip;
     /**
-     * Invoked when a client-side `execute()` returns a result and the runtime
-     * needs to feed it back into the conversation.
+     * Closing the args stream hands the call to the client executor, so it may
+     * only happen once the provider can no longer speak about that call. The run
+     * ending is the only universal signal for that; an adapter that reports the
+     * call as client-owned has said it earlier, per call.
      */
-    onResult: (command: AddToolResultCommand) => void;
+    private _shouldCloseArgsStream;
+    private _startActiveEntry;
     /**
-     * Invoked whenever the per-tool-call status map changes (executing /
-     * interrupt / cleared). The callback receives a fresh map; mutating the
-     * argument is not supported.
+     * Demote every active entry back to the restored phase. Used by the
+     * pipeline-restart path so that, after a fresh pipeline is built, the
+     * next observed snapshot does not re-fire `streamCall` for tool calls
+     * that already fired pre-death. Args / hasResult tracking is preserved
+     * so signature comparisons still work.
      */
-    onStatusesChange: (statuses: ReadonlyMap<string, ToolExecutionStatus>) => void;
-  };
+    private _demoteEntriesToRestored;
+    private _processArgsText;
+    private _processMessages;
+}
+export declare namespace ToolInvocationTracker {
+    type ExecutionStatus = ToolExecutionStatus;
+    type Snapshot = {
+        readonly messages: readonly ThreadMessage[];
+        /** Whether the producing runtime is currently streaming new output. */
+        readonly isRunning: boolean;
+        /**
+         * Whether the producing runtime is still loading historical state.
+         * When `true`, every snapshot is treated as historical (no `streamCall` /
+         * `execute` fires). When `false`, processing resumes as live.
+         */
+        readonly isLoading?: boolean;
+    };
+    type Callbacks = {
+        /**
+         * Invoked when a client-side `execute()` returns a result and the runtime
+         * needs to feed it back into the conversation.
+         */
+        onResult: (command: AddToolResultCommand) => void;
+        /**
+         * Invoked whenever the per-tool-call status map changes (executing /
+         * interrupt / cleared). The callback receives a fresh map; mutating the
+         * argument is not supported.
+         */
+        onStatusesChange: (statuses: ReadonlyMap<string, ToolExecutionStatus>) => void;
+    };
 }
-//#endregion
-export { AddToolResultCommand, ToolExecutionStatus, ToolInvocationTracker };
 //# sourceMappingURL=ToolInvocationTracker.d.ts.map

package/dist/runtimes/tool-invocations/ToolInvocationTracker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ToolInvocationTracker.d.ts","names":[],"sources":["../../../src/runtimes/tool-invocations/ToolInvocationTracker.ts"],"mappings":";;;;;;;KAwBY;EACN;;EAEA;EACA;IAAW;IAAe;;;KAGpB;WACD;WACA;WACA;WACA,QAAQ;WACR;WACA,WAAW;WACX,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;cA+EtB;mBACM;mBACA;mBACA;mBAIA;mBACA;mBAQA;;;;;;;mBAOA;mBACA;UAET;UAEA;UACA;;UAGA;UACA;UAEA;;;;;;;;;;;UAYA;UACA;EAGN,YAAA,gBAAgB,eAAe,mBAC/B,WAAW,sBAAsB,WACjC,oBAAoB,UAAU;;;;;;UAcxB;;;;;EAsDD,SAAS,UAAU,sBAAsB;;;;;;EAmEzC;;;;;;;;;;EA8BA,MAAM;IAAY;MAA6B;;;;;;;EA2C/C,OAAO,oBAAoB;;;;;;;EAoB3B,eAAe,oBAAoB;UAMlC;UA6CA;UAaA;UAmCA;UAcA;UA0BA;UAkCA;UAWA;UAaA;UAOA;UAUA;;;;;;;UAeA;UAcA;;;;;;;;UA8BA;UAqBA;UA0GA;;kBAuFO;OACH,kBAAkB;OAElB;aACD,mBAAmB;;aAEnB;;;;;;aAMA;;OAGC;;;;;IAKV,WAAW,SAAS;;;;;;IAMpB,mBACE,UAAU,oBAAoB"}
+{"version":3,"file":"ToolInvocationTracker.d.ts","sourceRoot":"","sources":["../../../src/runtimes/tool-invocations/ToolInvocationTracker.ts"],"names":[],"mappings":"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"}