@anuma/sdk 10.9.0 → 11.0.0

package/dist/expo/index.d.mts

@@ -1668,34 +1668,126 @@ declare function buildAttachedFilesText(fileContext: string): string;
  */
 declare function attachFileContextToLastUserMessage(messages: LlmapiMessage[], fileContext: string): LlmapiMessage[];
 
-/**
- * What became of a restaurant booking or cancellation in one turn, read from
- * the server's own tool result rather than from the model's reply.
- */
-type ReservationReceipt = {
-    kind: "booking" | "cancel";
+type LlmTokenUsage = {
+    inputTokens?: number;
+    outputTokens?: number;
+};
+type ModelCallStartEvent = {
+    runId: string;
+    stepIndex: number;
+    model: string;
+    messages: Array<LlmapiMessage>;
+    tools: Array<LlmapiChatCompletionTool>;
+    requestBody: Record<string, unknown>;
+};
+type ModelCallEndEvent = {
+    runId: string;
+    stepIndex: number;
+    content: string;
+    toolCalls: Array<{
+        id: string;
+        name: string;
+        arguments: string;
+    }>;
+    usage?: LlmTokenUsage;
+    finishReason?: string;
+    error?: string;
+};
+type ToolUseStartEvent = {
+    runId: string;
+    stepIndex: number;
+    toolCallId: string;
+    name: string;
+    rawArguments: string;
+    parsedArguments?: Record<string, unknown>;
+};
+type ToolUseEndEvent = {
+    runId: string;
+    stepIndex: number;
+    toolCallId: string;
+    name: string;
+    result?: unknown;
+    error?: string;
+    errorType?: "parse" | "timeout" | "execution" | "cancelled";
+};
+type RunStartEvent = {
+    runId: string;
+    model: string;
+    messages: Array<LlmapiMessage>;
+    tools: Array<LlmapiChatCompletionTool>;
+};
+type RunEndEvent = {
+    runId: string;
+    finalContent: string;
+    /** Number of LLM rounds executed. */
+    totalSteps: number;
+};
+type RunErrorEvent = {
+    runId: string;
+    error: string;
     /**
-     * `made`: the provider confirmed it. `not_made`: it did not happen.
-     * `already_done`: an earlier call in the conversation had already done it.
-     * `unknown`: the call reached the provider and its outcome is not known.
+     * Only `"model"` today. Tool failures surface on {@link RunHooks.afterToolUse}
+     * with `errorType`, not on `onRunError`, so a tool stage isn't needed yet.
+     * Left as a union to leave room for `"validation"` or `"tool"` later
+     * without a breaking change.
      */
-    status: "made" | "not_made" | "already_done" | "unknown";
-    venueName: string;
-    /** As the call sent it, e.g. `2026-10-23`. */
-    day: string;
-    /** As the call sent it, e.g. `9:00 PM`. */
-    time: string;
-    partySize?: number;
-    reservationId?: string;
-    /** Resy page where the user can see the reservation. */
-    resyUrl?: string;
-    /** The restaurant's own cancellation terms, when the booking result carries them. */
-    feeSummary?: string;
-    /** The provider's stated reason, when it did not happen. */
-    reason?: string;
+    stage: "model";
+    /**
+     * The underlying `Error` when one is available. `RunErrorEvent` predates
+     * this field, so `error` (a string message) is kept for backwards
+     * compatibility; new consumers should prefer `errorObject` when present
+     * for stack traces and `cause`.
+     */
+    errorObject?: Error;
+};
+type RunHooks = {
+    /**
+     * Fires once per `runToolLoop` invocation, before any pre-processor or
+     * model call. The `messages` payload is the raw caller-supplied
+     * conversation — pre-processors that enrich it (e.g. web search context)
+     * run afterwards, so `beforeModelCall.messages` reflects the
+     * post-enrichment state.
+     */
+    onRunStart?: (e: RunStartEvent) => Promise<void> | void;
+    /**
+     * Fires exactly once per run on clean completion. Mutually exclusive
+     * with `onRunError` — a run that completes fires `onRunEnd`; a run that
+     * errors or is aborted fires `onRunError`. Consumers can rely on
+     * exactly one terminal hook per `onRunStart`.
+     */
+    onRunEnd?: (e: RunEndEvent) => Promise<void> | void;
+    /**
+     * Fires exactly once per run when the loop errors or is aborted.
+     * `stage` is `"model"` for stream/provider errors and for aborts;
+     * tool execution failures surface as structured `{ error, errorType }`
+     * results on `afterToolUse` rather than firing `onRunError`.
+     * Mutually exclusive with `onRunEnd`.
+     */
+    onRunError?: (e: RunErrorEvent) => Promise<void> | void;
+    beforeModelCall?: (e: ModelCallStartEvent) => Promise<void> | void;
+    afterModelCall?: (e: ModelCallEndEvent) => Promise<void> | void;
+    /**
+     * Fires before each tool the model invoked — including server-side
+     * tools that have no client executor. Today this is observe-only.
+     * TODO(follow-up PR): allow returning { args?, abort?: { reason } } to
+     * mutate arguments or short-circuit the tool call.
+     *
+     * Pairing with {@link afterToolUse} is asymmetric: server-side tools
+     * routed via `onToolCall` get `beforeToolUse` but no `afterToolUse`,
+     * because they don't execute in-process. Tools blocked by a failed
+     * dependency or a dependency cycle DO get `afterToolUse` with
+     * `errorType: "execution"` — consumers tallying matched pairs should
+     * filter on executor-backed tools to avoid spurious imbalances.
+     */
+    beforeToolUse?: (e: ToolUseStartEvent) => Promise<void> | void;
+    /**
+     * Fires after each executor-backed tool finishes (success or failure)
+     * and after each dependency-blocked tool is skipped (`errorType:
+     * "execution"`). Does NOT fire for server-side tools routed via
+     * `onToolCall`. See {@link beforeToolUse} for the pairing contract.
+     */
+    afterToolUse?: (e: ToolUseEndEvent) => Promise<void> | void;
 };
-/** One receipt per kind for the turn's booking and cancel calls, holding the last attempt's outcome unless an earlier one was `made` or `unknown`. */
-declare function extractReservationReceipts(toolCallEvents?: LlmapiToolCallEvent[]): ReservationReceipt[];
 
 /**
  * PII detection patterns for structured data types.
@@ -2051,166 +2143,232 @@ declare function createStreamingDeAnonymizer(redactor: PiiRedactor, emit: (chunk
     flush: () => void;
 };
 
-type LlmTokenUsage = {
-    inputTokens?: number;
-    outputTokens?: number;
+/**
+ * Configuration for stream output smoothing.
+ *
+ * Controls the adaptive speed ramp that meters out streaming text
+ * at a consistent pace regardless of how fast the model produces tokens.
+ */
+type StreamSmoothingConfig = {
+    /** Whether smoothing is enabled. Default: true */
+    enabled: boolean;
+    /** Minimum chars/sec at the start of streaming. Default: 60 */
+    minSpeed?: number;
+    /** Maximum chars/sec after ramp completes. Default: 600 */
+    maxSpeed?: number;
+    /** Duration in ms to ramp from minSpeed to maxSpeed. Default: 4000 */
+    rampDuration?: number;
 };
-type ModelCallStartEvent = {
-    runId: string;
-    stepIndex: number;
-    model: string;
-    messages: Array<LlmapiMessage>;
-    tools: Array<LlmapiChatCompletionTool>;
-    requestBody: Record<string, unknown>;
+
+/**
+ * Server tool call event emitted during streaming
+ */
+type ServerToolCallEvent = {
+    /** Tool name (e.g., "BraveSearchMCP_brave_web_search") */
+    name: string;
+    /** Status: "started" when tool begins, "completed" when done */
+    status: "started" | "completed";
+    /** Arguments passed to the tool (JSON string) */
+    arguments?: string;
 };
-type ModelCallEndEvent = {
-    runId: string;
+/**
+ * Result from processing a streaming chunk
+ */
+/** Event emitted when tool call arguments are being streamed. */
+type ToolCallArgumentsDeltaEvent = {
+    toolCallId: string;
+    toolName: string;
+    argumentsDelta: string;
+    accumulatedArguments: string;
+};
+type ToolExecutionErrorType = "parse" | "timeout" | "execution" | "cancelled";
+
+/** A tool result from an auto-executed tool. */
+type AutoExecutedToolResult = {
+    name: string;
+    result: unknown;
+};
+/** Information emitted after each tool execution round completes. */
+type StepFinishEvent = {
+    /** 1-based index of this tool round. */
     stepIndex: number;
+    /** Text content the model produced in this round (may be empty if the model only called tools). */
     content: string;
+    /** Tool calls the model made in this round. */
     toolCalls: Array<{
-        id: string;
         name: string;
         arguments: string;
     }>;
-    usage?: LlmTokenUsage;
+    /** Results from auto-executed tools in this round. */
+    toolResults: Array<{
+        name: string;
+        result: unknown;
+        error?: string;
+        errorType?: ToolExecutionErrorType;
+    }>;
+    /** Token usage for this round, if available. */
+    usage: {
+        inputTokens?: number;
+        outputTokens?: number;
+    };
+    /**
+     * The round's own finish reason, as the provider sent it — `"length"` means
+     * this round hit the output ceiling.
+     *
+     * Per-round, not per-turn: a round can truncate and the loop still recover on
+     * the next one, which is why the loop does not treat it as an error on its
+     * own (see the truncation guard below). Without it a consumer watching steps
+     * cannot tell a round that said everything it meant to from one that was cut
+     * off mid-argument — they differ only in this field (#805).
+     *
+     * Absent when the provider sent no finish reason. Note that no step event
+     * fires for the round that *ends* a turn, so use {@link RunTerminalState} on
+     * the result for the final round.
+     */
     finishReason?: string;
-    error?: string;
-};
-type ToolUseStartEvent = {
-    runId: string;
-    stepIndex: number;
-    toolCallId: string;
-    name: string;
-    rawArguments: string;
-    parsedArguments?: Record<string, unknown>;
-};
-type ToolUseEndEvent = {
-    runId: string;
-    stepIndex: number;
-    toolCallId: string;
-    name: string;
-    result?: unknown;
-    error?: string;
-    errorType?: "parse" | "timeout" | "execution" | "cancelled";
 };
-type RunStartEvent = {
-    runId: string;
-    model: string;
-    messages: Array<LlmapiMessage>;
-    tools: Array<LlmapiChatCompletionTool>;
-};
-type RunEndEvent = {
-    runId: string;
-    finalContent: string;
-    /** Number of LLM rounds executed. */
-    totalSteps: number;
+/**
+ * Terminal state of the LAST model response in the turn, normalized to the
+ * completions vocabulary (`"stop"` | `"length"` | `"tool_calls"` | provider-
+ * specific values). `undefined` when the stream carried no finish reason at all.
+ *
+ * Exposed because neither response shape reliably carries it out to a caller.
+ * The Responses shape now carries `status` / `incomplete_details` — added in
+ * `clientCompat` and emitted by `buildFinalResponse` — but only in the
+ * Responses vocabulary, so a caller reading it has to translate
+ * `incomplete_details.reason === "max_output_tokens"` itself. Completions
+ * exposes `choices[0].finish_reason`, but omits `tool_calls` entirely when
+ * there are none, so a caller sniffing the response cannot tell "no tool calls"
+ * from "field absent". This field answers both questions in one vocabulary,
+ * for either transport.
+ *
+ * The loop already knows both, unambiguously and identically for either API.
+ * Reporting them here means callers and test harnesses stop reverse-engineering
+ * them from a response shape that cannot answer. See anuma-ai/sdk#805.
+ */
+type RunTerminalState = {
+    /** Normalized finish reason of the final response. `"length"` means the output
+     *  ceiling cut it off; anything else means the model stopped on its own. */
+    finishReason?: string;
+    /** Tool calls the final response carried. `0` is meaningful — combined with
+     *  empty content it identifies a turn that ended having produced nothing. */
+    finalToolCallCount: number;
 };
-type RunErrorEvent = {
-    runId: string;
+type RunToolLoopResult = {
+    data: ApiResponse;
+    error: null;
+    /** Checksum of tools used to generate this response */
+    toolsChecksum?: string;
+    /** Results from tools that were auto-executed by the SDK */
+    autoExecutedToolResults?: AutoExecutedToolResult[];
+    /** Terminal state of the final model response. See {@link RunTerminalState}. */
+    terminalState?: RunTerminalState;
+} | {
+    data: ApiResponse | null;
     error: string;
+    /** HTTP status code from the SSE connection, if available */
+    statusCode?: number;
+    /** Checksum of tools used to generate this response */
+    toolsChecksum?: string;
+    /** True when the loop exited via detachSignal. `error` is "Request detached". */
+    detached?: true;
+    /** Non-null only when `resumable` was true AND an inference id was captured before detach. */
+    resume?: StreamResumeHandle | null;
+    /** True when the connection failed rather than the generation: the portal may still be generating. */
+    connectionLost?: true;
     /**
-     * Only `"model"` today. Tool failures surface on {@link RunHooks.afterToolUse}
-     * with `errorType`, not on `onRunError`, so a tool stage isn't needed yet.
-     * Left as a union to leave room for `"validation"` or `"tool"` later
-     * without a breaking change.
-     */
-    stage: "model";
-    /**
-     * The underlying `Error` when one is available. `RunErrorEvent` predates
-     * this field, so `error` (a string message) is kept for backwards
-     * compatibility; new consumers should prefer `errorObject` when present
-     * for stack traces and `cause`.
-     */
-    errorObject?: Error;
-};
-type RunHooks = {
-    /**
-     * Fires once per `runToolLoop` invocation, before any pre-processor or
-     * model call. The `messages` payload is the raw caller-supplied
-     * conversation — pre-processors that enrich it (e.g. web search context)
-     * run afterwards, so `beforeModelCall.messages` reflects the
-     * post-enrichment state.
-     */
-    onRunStart?: (e: RunStartEvent) => Promise<void> | void;
-    /**
-     * Fires exactly once per run on clean completion. Mutually exclusive
-     * with `onRunError` — a run that completes fires `onRunEnd`; a run that
-     * errors or is aborted fires `onRunError`. Consumers can rely on
-     * exactly one terminal hook per `onRunStart`.
-     */
-    onRunEnd?: (e: RunEndEvent) => Promise<void> | void;
-    /**
-     * Fires exactly once per run when the loop errors or is aborted.
-     * `stage` is `"model"` for stream/provider errors and for aborts;
-     * tool execution failures surface as structured `{ error, errorType }`
-     * results on `afterToolUse` rather than firing `onRunError`.
-     * Mutually exclusive with `onRunEnd`.
-     */
-    onRunError?: (e: RunErrorEvent) => Promise<void> | void;
-    beforeModelCall?: (e: ModelCallStartEvent) => Promise<void> | void;
-    afterModelCall?: (e: ModelCallEndEvent) => Promise<void> | void;
-    /**
-     * Fires before each tool the model invoked — including server-side
-     * tools that have no client executor. Today this is observe-only.
-     * TODO(follow-up PR): allow returning { args?, abort?: { reason } } to
-     * mutate arguments or short-circuit the tool call.
+     * Terminal state of the final model response, when the failure is one the
+     * loop diagnosed FROM that response — today, the truncated-to-nothing
+     * error. See {@link RunTerminalState}.
      *
-     * Pairing with {@link afterToolUse} is asymmetric: server-side tools
-     * routed via `onToolCall` get `beforeToolUse` but no `afterToolUse`,
-     * because they don't execute in-process. Tools blocked by a failed
-     * dependency or a dependency cycle DO get `afterToolUse` with
-     * `errorType: "execution"` — consumers tallying matched pairs should
-     * filter on executor-backed tools to avoid spurious imbalances.
-     */
-    beforeToolUse?: (e: ToolUseStartEvent) => Promise<void> | void;
-    /**
-     * Fires after each executor-backed tool finishes (success or failure)
-     * and after each dependency-blocked tool is skipped (`errorType:
-     * "execution"`). Does NOT fire for server-side tools routed via
-     * `onToolCall`. See {@link beforeToolUse} for the pairing contract.
+     * Absent on failures that never got a terminal response to read (transport
+     * errors, detach, an SSE failure mid-stream), which is why it stays
+     * optional here. Present on the truncation error specifically because that
+     * is where it is most diagnostic: a caller can branch on
+     * `finishReason === "length"` instead of matching the error string.
      */
-    afterToolUse?: (e: ToolUseEndEvent) => Promise<void> | void;
+    terminalState?: RunTerminalState;
 };
-
+/** Capability header: tells the portal this client can resume a detached stream. Pinned with zeta-chain/ai-portal#1139. */
+declare const STREAM_RESUMABLE_HEADER = "X-Stream-Resumable";
+/** Response header carrying the per-request stream id, issued by the portal pre-stream. */
+declare const INFERENCE_ID_HEADER = "X-Inference-ID";
 /**
- * Configuration for stream output smoothing.
- *
- * Controls the adaptive speed ramp that meters out streaming text
- * at a consistent pace regardless of how fast the model produces tokens.
+ * Everything resumeStream() needs to replay a detached stream.
+ * @public
  */
-type StreamSmoothingConfig = {
-    /** Whether smoothing is enabled. Default: true */
-    enabled: boolean;
-    /** Minimum chars/sec at the start of streaming. Default: 60 */
-    minSpeed?: number;
-    /** Maximum chars/sec after ramp completes. Default: 600 */
-    maxSpeed?: number;
-    /** Duration in ms to ramp from minSpeed to maxSpeed. Default: 4000 */
-    rampDuration?: number;
+type StreamResumeHandle = {
+    inferenceId: string;
+    /** The reply id the storage hook writes this turn's answer under, when it chose one. */
+    assistantMessageId?: string;
+    /** The RESOLVED api type (never "auto") — resolveApiType() already ran inside runToolLoop. */
+    apiType: Exclude<ApiType, "auto">;
+    model?: string;
+    conversationId?: string;
 };
-
 /**
- * Server tool call event emitted during streaming
+ * Payload for RunToolLoopOptions.onStreamMeta.
+ * @public
  */
-type ServerToolCallEvent = {
-    /** Tool name (e.g., "BraveSearchMCP_brave_web_search") */
-    name: string;
-    /** Status: "started" when tool begins, "completed" when done */
-    status: "started" | "completed";
-    /** Arguments passed to the tool (JSON string) */
-    arguments?: string;
+type StreamMetaEvent = {
+    inferenceId: string;
+    /** 0 = initial request, 1+ = continuation round (same numbering as RequestEvent.round). */
+    round: number;
+};
+/** Options passed to a streaming transport function. */
+type StreamingTransportOptions = {
+    baseUrl: string;
+    endpoint: string;
+    /** @default "POST" */
+    method?: "GET" | "POST";
+    /** Request body. Optional — GET resume requests have no body. */
+    body?: Record<string, unknown>;
+    token?: string;
+    headers?: Record<string, string>;
+    signal?: AbortSignal;
+    onSseError?: (error: unknown) => void;
+    /** Fires once per request when response headers arrive with X-Inference-ID (2xx only). */
+    onStreamMeta?: (meta: {
+        inferenceId: string;
+    }) => void;
+    /**
+     * Fires when the transport receives bytes, including SSE keep-alive comments.
+     * Consumers can use this callback to reset the idle timeout.
+     * The fetch and XHR transports emit it.
+     * Custom transports can omit it if they cannot report byte activity.
+     */
+    onActivity?: () => void;
+};
+/** Result returned by a streaming transport function. */
+type StreamingTransportResult = {
+    stream: AsyncIterable<unknown>;
 };
 /**
- * Result from processing a streaming chunk
+ * A pluggable transport function for streaming SSE requests.
+ * The default uses `fetch` + `ReadableStream`. React Native environments
+ * can supply an XHR-based transport instead.
+ *
+ * ### Abort contract
+ *
+ * When `options.signal` aborts **mid-stream**, the returned async iterable
+ * MUST surface an `AbortError` (an `Error` whose `name === "AbortError"`)
+ * to its consumer — either by throwing from the iterator, or by causing
+ * the underlying `read()` to reject. It MUST NOT terminate the iterable
+ * with an orderly `done` in that case.
+ *
+ * `runToolLoop` relies on this to distinguish two scenarios that are
+ * otherwise indistinguishable from outside the transport:
+ * 1. The server closed the connection cleanly and every byte was
+ *    delivered → iterable returns `done`, result is success.
+ * 2. The caller aborted the request mid-stream → iterable throws
+ *    `AbortError`, result is `{ data: <partial>, error: "Request aborted" }`.
+ *
+ * Transports that swallow mid-stream aborts and yield `done` instead
+ * will cause a partial response to be reported as a successful
+ * completion. The built-in `xhrTransport` and the default fetch-based
+ * transport both honor this contract.
  */
-/** Event emitted when tool call arguments are being streamed. */
-type ToolCallArgumentsDeltaEvent = {
-    toolCallId: string;
-    toolName: string;
-    argumentsDelta: string;
-    accumulatedArguments: string;
-};
-type ToolExecutionErrorType = "parse" | "timeout" | "execution" | "cancelled";
+type StreamingTransport = (options: StreamingTransportOptions) => StreamingTransportResult;
 
 /**
  * Tool executor function type
@@ -2496,580 +2654,9 @@ type ApiType = "auto" | "responses" | "completions";
  */
 type ApiResponse = LlmapiResponseResponse | LlmapiChatCompletionResponse;
 
-/** A tool result from an auto-executed tool. */
-type AutoExecutedToolResult = {
-    name: string;
-    result: unknown;
-};
-/** Information emitted after each tool execution round completes. */
-type StepFinishEvent = {
-    /** 1-based index of this tool round. */
-    stepIndex: number;
-    /** Text content the model produced in this round (may be empty if the model only called tools). */
-    content: string;
-    /** Tool calls the model made in this round. */
-    toolCalls: Array<{
-        name: string;
-        arguments: string;
-    }>;
-    /** Results from auto-executed tools in this round. */
-    toolResults: Array<{
-        name: string;
-        result: unknown;
-        error?: string;
-        errorType?: ToolExecutionErrorType;
-    }>;
-    /** Token usage for this round, if available. */
-    usage: {
-        inputTokens?: number;
-        outputTokens?: number;
-    };
-    /**
-     * The round's own finish reason, as the provider sent it — `"length"` means
-     * this round hit the output ceiling.
-     *
-     * Per-round, not per-turn: a round can truncate and the loop still recover on
-     * the next one, which is why the loop does not treat it as an error on its
-     * own (see the truncation guard below). Without it a consumer watching steps
-     * cannot tell a round that said everything it meant to from one that was cut
-     * off mid-argument — they differ only in this field (#805).
-     *
-     * Absent when the provider sent no finish reason. Note that no step event
-     * fires for the round that *ends* a turn, so use {@link RunTerminalState} on
-     * the result for the final round.
-     */
-    finishReason?: string;
-};
-/**
- * Terminal state of the LAST model response in the turn, normalized to the
- * completions vocabulary (`"stop"` | `"length"` | `"tool_calls"` | provider-
- * specific values). `undefined` when the stream carried no finish reason at all.
- *
- * Exposed because neither response shape reliably carries it out to a caller.
- * The Responses shape now carries `status` / `incomplete_details` — added in
- * `clientCompat` and emitted by `buildFinalResponse` — but only in the
- * Responses vocabulary, so a caller reading it has to translate
- * `incomplete_details.reason === "max_output_tokens"` itself. Completions
- * exposes `choices[0].finish_reason`, but omits `tool_calls` entirely when
- * there are none, so a caller sniffing the response cannot tell "no tool calls"
- * from "field absent". This field answers both questions in one vocabulary,
- * for either transport.
- *
- * The loop already knows both, unambiguously and identically for either API.
- * Reporting them here means callers and test harnesses stop reverse-engineering
- * them from a response shape that cannot answer. See anuma-ai/sdk#805.
- */
-type RunTerminalState = {
-    /** Normalized finish reason of the final response. `"length"` means the output
-     *  ceiling cut it off; anything else means the model stopped on its own. */
-    finishReason?: string;
-    /** Tool calls the final response carried. `0` is meaningful — combined with
-     *  empty content it identifies a turn that ended having produced nothing. */
-    finalToolCallCount: number;
-};
-type RunToolLoopResult = {
-    data: ApiResponse;
-    error: null;
-    /** Checksum of tools used to generate this response */
-    toolsChecksum?: string;
-    /** Results from tools that were auto-executed by the SDK */
-    autoExecutedToolResults?: AutoExecutedToolResult[];
-    /** Terminal state of the final model response. See {@link RunTerminalState}. */
-    terminalState?: RunTerminalState;
-} | {
-    data: ApiResponse | null;
-    error: string;
-    /** HTTP status code from the SSE connection, if available */
-    statusCode?: number;
-    /** Checksum of tools used to generate this response */
-    toolsChecksum?: string;
-    /** True when the loop exited via detachSignal. `error` is "Request detached". */
-    detached?: true;
-    /** Non-null only when `resumable` was true AND an inference id was captured before detach. */
-    resume?: StreamResumeHandle | null;
-    /** True when the connection failed rather than the generation: the portal may still be generating. */
-    connectionLost?: true;
-    /**
-     * Terminal state of the final model response, when the failure is one the
-     * loop diagnosed FROM that response — today, the truncated-to-nothing
-     * error. See {@link RunTerminalState}.
-     *
-     * Absent on failures that never got a terminal response to read (transport
-     * errors, detach, an SSE failure mid-stream), which is why it stays
-     * optional here. Present on the truncation error specifically because that
-     * is where it is most diagnostic: a caller can branch on
-     * `finishReason === "length"` instead of matching the error string.
-     */
-    terminalState?: RunTerminalState;
-};
-/** Capability header: tells the portal this client can resume a detached stream. Pinned with zeta-chain/ai-portal#1139. */
-declare const STREAM_RESUMABLE_HEADER = "X-Stream-Resumable";
-/** Response header carrying the per-request stream id, issued by the portal pre-stream. */
-declare const INFERENCE_ID_HEADER = "X-Inference-ID";
-/**
- * Everything resumeStream() needs to replay a detached stream.
- * @public
- */
-type StreamResumeHandle = {
-    inferenceId: string;
-    /** The RESOLVED api type (never "auto") — resolveApiType() already ran inside runToolLoop. */
-    apiType: Exclude<ApiType, "auto">;
-    model?: string;
-    conversationId?: string;
-};
-/**
- * Payload for RunToolLoopOptions.onStreamMeta.
- * @public
- */
-type StreamMetaEvent = {
-    inferenceId: string;
-    /** 0 = initial request, 1+ = continuation round (same numbering as RequestEvent.round). */
-    round: number;
-};
-/** Options passed to a streaming transport function. */
-type StreamingTransportOptions = {
-    baseUrl: string;
-    endpoint: string;
-    /** @default "POST" */
-    method?: "GET" | "POST";
-    /** Request body. Optional — GET resume requests have no body. */
-    body?: Record<string, unknown>;
-    token?: string;
-    headers?: Record<string, string>;
-    signal?: AbortSignal;
-    onSseError?: (error: unknown) => void;
-    /** Fires once per request when response headers arrive with X-Inference-ID (2xx only). */
-    onStreamMeta?: (meta: {
-        inferenceId: string;
-    }) => void;
-    /**
-     * Fires when the transport receives bytes, including SSE keep-alive comments.
-     * Consumers can use this callback to reset the idle timeout.
-     * The fetch and XHR transports emit it.
-     * Custom transports can omit it if they cannot report byte activity.
-     */
-    onActivity?: () => void;
-};
-/** Result returned by a streaming transport function. */
-type StreamingTransportResult = {
-    stream: AsyncIterable<unknown>;
-};
-/**
- * A pluggable transport function for streaming SSE requests.
- * The default uses `fetch` + `ReadableStream`. React Native environments
- * can supply an XHR-based transport instead.
- *
- * ### Abort contract
- *
- * When `options.signal` aborts **mid-stream**, the returned async iterable
- * MUST surface an `AbortError` (an `Error` whose `name === "AbortError"`)
- * to its consumer — either by throwing from the iterator, or by causing
- * the underlying `read()` to reject. It MUST NOT terminate the iterable
- * with an orderly `done` in that case.
- *
- * `runToolLoop` relies on this to distinguish two scenarios that are
- * otherwise indistinguishable from outside the transport:
- * 1. The server closed the connection cleanly and every byte was
- *    delivered → iterable returns `done`, result is success.
- * 2. The caller aborted the request mid-stream → iterable throws
- *    `AbortError`, result is `{ data: <partial>, error: "Request aborted" }`.
- *
- * Transports that swallow mid-stream aborts and yield `done` instead
- * will cause a partial response to be reported as a successful
- * completion. The built-in `xhrTransport` and the default fetch-based
- * transport both honor this contract.
- */
-type StreamingTransport = (options: StreamingTransportOptions) => StreamingTransportResult;
-
-/**
- * Build the replay path for a detached stream. The portal serves the buffered
- * stream from seq 0 on a GET to this path — no `starting_after`, no `id:`
- * cursor, no request body. Replay always starts from the first buffered byte
- * and the client rebuilds its own view with a fresh accumulator; partial
- * client state is never sent back to the server.
- *
- * Exported so client repos can mock the endpoint in E2E without string drift.
- */
-declare function streamReplayPath(inferenceId: string): string;
-/**
- * Build the cancel path for a detached stream. A POST here tells the portal to
- * stop generating into the buffer and release it — the billing-safe teardown
- * for "the user pressed stop after we'd already detached".
- *
- * Exported so client repos can mock the endpoint in E2E without string drift.
- */
-declare function streamCancelPath(inferenceId: string): string;
-/**
- * Thrown when the portal answers `410 Gone` to a replay GET: the buffered
- * stream is gone — expired (10-min sliding TTL), absent, not owned by the
- * caller, or already cancelled. There is nothing to replay; the answer is
- * permanently lost and the caller should fall back to a fresh send rather than
- * retry. A `stop()`-then-resume race lands here and finalizes as stopped, which
- * is correct.
- *
- * `resumeStream` throws this (it does not return it) and fires neither
- * `onFinish` nor `onError` — there is no body to deliver.
- * @public
- */
-declare class StreamExpiredError extends Error {
-    readonly name = "StreamExpiredError";
-    readonly inferenceId: string;
-    constructor(inferenceId: string, message?: string);
-}
-/**
- * Options for {@link resumeStream}.
- * @public
- */
-interface ResumeStreamOptions {
-    /** The handle captured from a detached `runToolLoop` result. */
-    handle: StreamResumeHandle;
-    /**
-     * Fresh bearer token. The CALLER fetches it at resume time — a multi-minute
-     * background gap expires the bearer, so a token captured when the original
-     * stream started must never be reused (see `useChat.resumeStream`).
-     */
-    token: string;
-    /** Base URL for the portal. @default the SDK's configured BASE_URL. */
-    baseUrl?: string;
-    /**
-     * Streaming transport. Defaults to the GET-capable fetch transport; Expo
-     * passes `xhrTransport` (RN can't stream `fetch` bodies).
-     */
-    transport?: StreamingTransport;
-    /** Aborts the replay; the partial is returned as an interrupted result. */
-    signal?: AbortSignal;
-    /** Adaptive output smoothing for the replayed content. @default true */
-    smoothing?: StreamSmoothingConfig | boolean;
-    /**
-     * Client-side watchdog for a dead live-tail. @default 120_000ms.
-     *
-     * Deliberately NOT ~30s: the portal tolerates >100s reasoning silences (no
-     * `data:` frames on the replay connection during them) and its own liveness
-     * rule (heartbeat stale >90s => SSE error + `[DONE]`) is the authoritative
-     * guard. This client timer is a backstop for a half-open TCP connection and
-     * must sit ABOVE the server's 90s rule so the server error always wins when
-     * the portal is reachable. Set to 0 / Infinity to disable.
-     */
-    idleTimeoutMs?: number;
-    /** Content text deltas as they replay (always from seq 0 — reset accumulated text first). */
-    onData?: (chunk: string) => void;
-    /** Thinking/reasoning deltas as they replay. */
-    onThinking?: (chunk: string) => void;
-    /** Restores the placeholders this redactor assigned when the original request was sent. */
-    piiRedactor?: PiiRedactor;
-    /** Called once on a clean completion. Never called for 410 nor interrupted terminals. */
-    onFinish?: (response: ApiResponse) => void;
-    /** Called on a transient/unexpected failure. Never called for 410 (throws) nor interrupted terminals. */
-    onError?: (error: Error) => void;
-}
-/**
- * Result of {@link resumeStream}. A `410 Gone` is the only outcome that throws
- * ({@link StreamExpiredError}); every other terminal is returned.
- *
- * - clean completion → `{ data, error: null, interrupted: false, empty }`
- * - in-stream error / tool-request terminal / idle timeout → `{ data, error,
- *   interrupted: true }` (finalize as a stopped/partial message)
- * - transient transport/HTTP failure (401, 5xx, network) → `{ data, error,
- *   interrupted: false, statusCode? }` (retryable — keep the handle)
- *
- * `empty` is true when the clean terminal delivered ZERO content/thinking
- * deltas — a `[DONE]`-only replay. That is never a real completion (a
- * completed generation always buffered at least one content frame); it means
- * the buffered frames were lost server-side (evicted/trimmed) while the
- * terminal survived. Consumers must NOT persist `data` (an empty response)
- * over content they already hold — keep the detached partial instead. On the
- * empty terminal `onFinish` is NOT fired (there is no completion to deliver);
- * the flag is optional so existing constructors of the clean arm stay valid.
- * @public
- */
-type ResumeStreamResult = {
-    data: ApiResponse;
-    error: null;
-    interrupted: false;
-    empty?: boolean;
-} | {
-    data: ApiResponse | null;
-    error: string;
-    interrupted: boolean;
-    statusCode?: number;
-};
-/**
- * Replay a detached stream from the portal's buffer.
- *
- * This is the reconnect primitive: after `runToolLoop` returns the detached
- * variant with a {@link StreamResumeHandle}, `resumeStream` issues a GET to the
- * portal's replay endpoint and rebuilds the response from seq 0 using a FRESH
- * accumulator and FRESH smoothers. Nothing from the original (detached) run is
- * reused — the completions strategy's reasoning-tag parser is stateful, so
- * replaying into reused state would double-count; replay-from-0 into fresh
- * state is the correctness mechanism, not just a simplification.
- *
- * Contract highlights:
- * - **No `starting_after`, no `id:` cursor, no body.** The GET carries the
- *   inference id in the path only; replay is always whole-stream. (The server
- *   reserves `starting_after` but does NOT honor it — sending it would silently
- *   duplicate content.)
- * - **410 → throws {@link StreamExpiredError}.** No `onFinish`/`onError`.
- * - **In-stream error / tool-request terminal → `interrupted: true`.** Flushes
- *   both smoothers and returns the partial; no throw, no `onError`, no `onFinish`.
- * - **token resolved by the caller at resume time** so a refresh during the
- *   detach window is honored.
- *
- * @public
- */
-declare function resumeStream(options: ResumeStreamOptions): Promise<ResumeStreamResult>;
-
-interface StockPriceClassification {
-    /** Whether the prompt likely asks for stock/ETF/FX quote data. */
-    needsStockPrice: boolean;
-    /** Cosine similarity to the "needs stock price" centroid. */
-    stockPriceScore: number;
-    /** Cosine similarity to the "no stock price" centroid. */
-    noStockPriceScore: number;
-}
-interface StockPriceClassifierOptions extends EmbeddingOptions {
-    /**
-     * Score margin: the stock-price score must exceed the no-stock-price
-     * score by at least this amount to classify as "needs stock price data".
-     * @default 0.02
-     */
-    margin?: number;
-}
-/**
- * Classify whether a prompt needs stock/ETF/index/FX price data.
- *
- * Domain: traditional financial instruments (equities, indices, ETFs, FX).
- * Crypto is handled by `classifyCryptoPrice`. Ambiguous prompts
- * (e.g. *"gold price"*) may fire both — that's expected; the caller can
- * inject both sets of results.
- */
-declare function classifyStockPrice(prompt: string, options: StockPriceClassifierOptions): Promise<StockPriceClassification>;
-/**
- * Batch-classify multiple prompts. Embeds all prompts in one batch
- * call for efficiency.
- */
-declare function classifyStockPriceBatch(prompts: string[], options: StockPriceClassifierOptions): Promise<StockPriceClassification[]>;
-interface StockPricePreProcessorOptions {
-    /**
-     * Called with the caller's stock-quote provider when the classifier
-     * decides the prompt is asking for stock/ETF/FX data. Return either a
-     * plain string (wrapped by the SDK in a default user message) or a
-     * fully-formed `LlmapiMessage[]` (full control over role/shape). Omit
-     * to run in observer mode — classification still fires but nothing is
-     * injected.
-     *
-     * The `signal` argument is forwarded from the tool loop so long-running
-     * provider requests can be aborted when the caller aborts.
-     */
-    fetchStockPriceData?: (prompt: string, options: {
-        signal?: AbortSignal;
-    }) => Promise<string | LlmapiMessage[]>;
-    /**
-     * Score margin: `stockPriceScore` must exceed `noStockPriceScore` by at
-     * least this amount to classify as "needs stock price data".
-     * @default 0.02
-     */
-    margin?: number;
-    /** Observe the classification without injecting anything. */
-    onClassification?: (result: StockPriceClassification) => void;
-}
-/**
- * Build a pre-processor that runs stock-price classification on the shared
- * embedding provided by `runToolLoop`, and — if the classifier decides the
- * prompt is asking for quotes — invokes the caller-supplied
- * `fetchStockPriceData` and injects the result into the conversation.
- *
- * Domain: stocks, ETFs, indices, FX. For crypto use
- * `createCryptoPricePreProcessor`. The SDK does not run the lookup itself;
- * the caller wires up whichever provider they want (Twelve Data, Alpha
- * Vantage, Finnhub, etc.).
- */
-declare function createStockPricePreProcessor(options?: StockPricePreProcessorOptions): PromptPreProcessor;
-
-/**
- * Value of the `origin` column on a row the SDK synthesised for a turn's tool results (v44, #866).
- *
- * `satisfies MessageOrigin` so this constant and the column's union cannot drift apart silently.
- */
-declare const TOOL_RESULT_ORIGIN = "tool_result";
-
-interface WeatherClassification {
-    /** Whether the prompt likely asks for weather data. */
-    needsWeather: boolean;
-    /** Cosine similarity to the "needs weather" centroid. */
-    weatherScore: number;
-    /** Cosine similarity to the "no weather" centroid. */
-    noWeatherScore: number;
-}
-interface WeatherClassifierOptions extends EmbeddingOptions {
-    /**
-     * Score margin: the weather score must exceed the no-weather score by at
-     * least this amount to classify as "needs weather data".
-     * @default 0.02
-     */
-    margin?: number;
-}
-/**
- * Classify whether a prompt needs weather data.
- *
- * Covers forecasts, temperature, precipitation, wind, humidity, UV, AQI,
- * marine, flood, climate — anything OpenMeteo-shaped.
- */
-declare function classifyWeather(prompt: string, options: WeatherClassifierOptions): Promise<WeatherClassification>;
-/**
- * Batch-classify multiple prompts. Embeds all prompts in one batch
- * call for efficiency.
- */
-declare function classifyWeatherBatch(prompts: string[], options: WeatherClassifierOptions): Promise<WeatherClassification[]>;
-interface WeatherPreProcessorOptions {
-    /**
-     * Called with the caller's weather provider when the classifier decides
-     * the prompt is asking for weather. Return either a plain string
-     * (wrapped by the SDK in a default user message) or a fully-formed
-     * `LlmapiMessage[]` (full control over role/shape). Omit to run in
-     * observer mode — classification still fires but nothing is injected.
-     *
-     * The `signal` argument is forwarded from the tool loop so long-running
-     * provider requests can be aborted when the caller aborts.
-     */
-    fetchWeatherData?: (prompt: string, options: {
-        signal?: AbortSignal;
-    }) => Promise<string | LlmapiMessage[]>;
-    /**
-     * Score margin: `weatherScore` must exceed `noWeatherScore` by at least
-     * this amount to classify as "needs weather data".
-     * @default 0.02
-     */
-    margin?: number;
-    /** Observe the classification without injecting anything. */
-    onClassification?: (result: WeatherClassification) => void;
-}
-/**
- * Build a pre-processor that runs weather classification on the shared
- * embedding provided by `runToolLoop`, and — if the classifier decides
- * the prompt is asking for weather — invokes the caller-supplied
- * `fetchWeatherData` and injects the result into the conversation.
- *
- * The SDK does not run the weather lookup itself; the caller wires up
- * whichever provider they want (OpenMeteo, AccuWeather, weather.gov, etc.).
- */
-declare function createWeatherPreProcessor(options?: WeatherPreProcessorOptions): PromptPreProcessor;
-
-interface WebSearchClassification {
-    /** Whether the prompt likely needs a web search. */
-    needsWebSearch: boolean;
-    /** Cosine similarity to the "needs search" centroid. */
-    searchScore: number;
-    /** Cosine similarity to the "no search" centroid. */
-    noSearchScore: number;
-}
-interface WebSearchClassifierOptions extends EmbeddingOptions {
-    /**
-     * Score margin: the search score must exceed the no-search score
-     * by at least this amount to classify as "needs web search".
-     * @default 0.02
-     */
-    margin?: number;
-}
-/**
- * Classify whether a prompt needs a web search.
- *
- * Embeds the prompt and compares it against the pre-computed
- * search and no-search centroid vectors.
- */
-declare function classifyWebSearch(prompt: string, options: WebSearchClassifierOptions): Promise<WebSearchClassification>;
-/**
- * Batch-classify multiple prompts. Embeds all prompts in one batch
- * call for efficiency.
- */
-declare function classifyWebSearchBatch(prompts: string[], options: WebSearchClassifierOptions): Promise<WebSearchClassification[]>;
-interface WebSearchPreProcessorOptions {
-    /**
-     * Called with the caller's search provider when the classifier decides
-     * a web search is needed. Return either a plain string (the SDK will
-     * wrap it in a default user message) or a fully-formed message array
-     * (full control over role/shape). Omit to run in observer mode —
-     * classification still fires but no messages are injected.
-     *
-     * The `signal` argument is forwarded from the tool loop so long-running
-     * search requests can be aborted when the caller aborts.
-     */
-    fetchSearchResults?: (prompt: string, options: {
-        signal?: AbortSignal;
-    }) => Promise<string | LlmapiMessage[]>;
-    /**
-     * Score margin: `searchScore` must exceed `noSearchScore` by at least
-     * this amount to classify as "needs web search".
-     * @default 0.02
-     */
-    margin?: number;
-    /** Observe the classification without injecting anything. */
-    onClassification?: (result: WebSearchClassification) => void;
-}
-/**
- * Build a pre-processor that runs web-search classification on the
- * shared embedding provided by `runToolLoop`, and — if the classifier
- * decides a search is warranted — invokes the caller-supplied
- * `fetchSearchResults` and injects the result into the conversation.
- *
- * @example Basic usage with a search provider
- * ```ts
- * import { runToolLoop, createWebSearchPreProcessor } from "@anuma/sdk/server";
- *
- * const webSearch = createWebSearchPreProcessor({
- *   fetchSearchResults: async (prompt, { signal }) => {
- *     const res = await mySearchProvider.query(prompt, { signal });
- *     return res.results.map((r) => `- ${r.title}: ${r.snippet}`).join("\n");
- *   },
- * });
- *
- * await runToolLoop({
- *   messages,
- *   model,
- *   token,
- *   preProcessors: [webSearch],
- * });
- * ```
- *
- * @example Observer mode — only log classification, inject nothing
- * ```ts
- * const observer = createWebSearchPreProcessor({
- *   onClassification: ({ needsWebSearch, searchScore, noSearchScore }) => {
- *     metrics.record({ needsWebSearch, searchScore, noSearchScore });
- *   },
- * });
- * ```
- *
- * @example Full control — return a custom message shape
- * ```ts
- * const webSearch = createWebSearchPreProcessor({
- *   fetchSearchResults: async (prompt, { signal }) => {
- *     const results = await mySearchProvider.query(prompt, { signal });
- *     return [
- *       {
- *         role: "system",
- *         content: [{ type: "text", text: `Search results for "${prompt}":\n${formatResults(results)}` }],
- *       },
- *     ];
- *   },
- * });
- * ```
- */
-declare function createWebSearchPreProcessor(options?: WebSearchPreProcessorOptions): PromptPreProcessor;
-
-/**
- * XHR-based streaming transport for React Native environments.
- *
- * React Native's `fetch` doesn't support `response.body` streaming,
- * so this transport uses `XMLHttpRequest` with `onprogress` to stream
- * SSE events. It exposes the same `{ stream: AsyncIterable }` interface
- * as the default fetch-based transport.
- */
-declare const xhrTransport: StreamingTransport;
-
-type ChatRecordKind = "conversation" | "message" | "summary" | "project" | "memory_links" | "setting";
-type ChatJson = null | boolean | number | string | ChatJson[] | {
-    [key: string]: ChatJson;
+type ChatRecordKind = "conversation" | "message" | "summary" | "project" | "memory_links" | "setting";
+type ChatJson = null | boolean | number | string | ChatJson[] | {
+    [key: string]: ChatJson;
 };
 /** Whole-record JSON data is encrypted on the device, including all text, vectors and tool events. */
 interface ChatRecord {
@@ -4542,7 +4129,7 @@ interface ChatStorageAdapter {
     createMessage(options: CreateMessageOptions): Promise<StoredMessage>;
     updateMessageEmbedding(uniqueId: string, vector: number[], embeddingModel: string): Promise<StoredMessage | null>;
     updateMessageChunks(uniqueId: string, chunks: MessageChunk[], embeddingModel: string): Promise<StoredMessage | null>;
-    updateMessageError(uniqueId: string, error: string): Promise<StoredMessage | null>;
+    updateMessageError(uniqueId: string, error: string | null): Promise<StoredMessage | null>;
     updateMessageFeedback(uniqueId: string, feedback: MessageFeedback): Promise<StoredMessage | null>;
     /**
      * Replace a message's attached media ids (`fileIds`). Used to attach a
@@ -8289,160 +7876,656 @@ interface BaseSendMessageWithStorageArgs {
      * Controls randomness in the response (0.0 to 2.0).
      * Lower values make output more deterministic, higher values more creative.
      */
-    temperature?: number;
+    temperature?: number;
+    /**
+     * Maximum number of tokens to generate in the response.
+     * Use this to limit response length and control costs.
+     */
+    maxOutputTokens?: number;
+    /**
+     * Client-side tools with optional executors.
+     * These tools run in the browser/app and can have JavaScript executor functions.
+     */
+    clientTools?: LlmapiChatCompletionTool[];
+    /**
+     * Server-side tools to include from /api/v1/tools.
+     * - undefined: Include all server-side tools (default)
+     * - string[]: Include only tools with these names
+     * - []: Include no server-side tools
+     * - function: Dynamic filter that receives prompt embedding(s) and all tools,
+     *   returns tool names to include. Useful for semantic tool matching.
+     *
+     * @example
+     * // Include only specific server tools
+     * serverTools: ["anuma_create_image", "perplexity_search"]
+     *
+     * // Disable server tools for this request
+     * serverTools: []
+     *
+     * // Semantic tool matching based on prompt
+     * serverTools: (embeddings, tools) => {
+     *   const matches = findMatchingTools(embeddings, tools, { limit: 5 });
+     *   return matches.map(m => m.tool.name);
+     * }
+     */
+    serverTools?: ServerToolsFilter;
+    /**
+     * Dynamic filter for client-side tools based on prompt embeddings.
+     * Receives the prompt embedding(s) (or null for short messages) and all client tools,
+     * returns tool names to include. Tools not in the returned list are excluded from the request.
+     *
+     * @example
+     * clientToolsFilter: (embeddings, tools) => {
+     *   if (!embeddings) return []; // Short message — no client tools
+     *   const matches = findMatchingTools(embeddings, pseudoServerTools);
+     *   return matches.map(m => m.tool.name);
+     * }
+     */
+    clientToolsFilter?: ClientToolsFilterFn;
+    /**
+     * Controls which tool the model should use:
+     * - "auto": Model decides whether to use a tool (default)
+     * - "any": Model must use one of the provided tools
+     * - "none": Model cannot use any tools
+     * - "required": Model must use a tool
+     * - Specific tool name: Model must use that specific tool
+     */
+    toolChoice?: string;
+    /**
+     * Maximum number of tool execution rounds before forcing the model to respond with text.
+     * After this many rounds, `toolChoice` is set to `"none"` on the next continuation,
+     * so the model produces a text answer using whatever tool results it has gathered.
+     * @default 3
+     */
+    maxToolRounds?: number;
+    /**
+     * Reasoning configuration for o-series and other reasoning models.
+     * Controls reasoning effort level and whether to include reasoning summary.
+     */
+    reasoning?: LlmapiResponseReasoning;
+    /**
+     * Extended thinking configuration for Anthropic models (Claude).
+     * Enables the model to think through complex problems step by step
+     * before generating the final response.
+     */
+    thinking?: LlmapiThinkingOptions;
+    /** User-selected image generation model for server-side enforcement. */
+    imageModel?: string;
+    /**
+     * Per-request callback for thinking/reasoning chunks.
+     * Called with delta chunks as the model "thinks" through a problem.
+     * Use this to display thinking progress in the UI.
+     */
+    onThinking?: (chunk: string) => void;
+    /** Parent message ID for branching (edit/regenerate). Sets on the user message. */
+    parentMessageId?: string;
+    /**
+     * Pre-generated unique ID for the assistant response message.
+     * When provided, the persisted assistant message will use this ID instead of
+     * an auto-generated one. This lets the consumer show an in-flight streaming
+     * placeholder under the same React key, avoiding an unmount/remount flash
+     * when streaming completes and the message is loaded from the database.
+     */
+    assistantUniqueId?: string;
+}
+interface BaseSendMessageSuccessResult {
+    data: ApiResponse;
+    error: null;
+    userMessage: StoredMessage;
+    assistantMessage: StoredMessage;
+    /** Results from tools the SDK auto-executed this turn (e.g. display tools). */
+    autoExecutedToolResults?: {
+        name: string;
+        result: unknown;
+    }[];
+    /**
+     * The synthetic `[Tool Execution Results]` row those results were persisted as.
+     *
+     * Returned so a caller can key its transient overlay on the id the SDK actually wrote instead of
+     * deriving one and hoping the two agree — that guesswork is what mobile's per-card persist
+     * workarounds existed to do (#5519). Absent when the turn executed no tools, or when the row write
+     * failed (non-fatal: the assistant reply is already stored).
+     */
+    toolResultsMessage?: StoredMessage;
+}
+interface BaseSendMessageSkippedResult {
+    data: ApiResponse;
+    error: null;
+    userMessage?: undefined;
+    assistantMessage?: undefined;
+    autoExecutedToolResults?: {
+        name: string;
+        result: unknown;
+    }[];
+    /** Indicates this was a skipStorage request - no messages were persisted */
+    skipped: true;
+}
+interface BaseSendMessageErrorResult {
+    data: null;
+    error: string;
+    userMessage?: StoredMessage;
+    assistantMessage?: undefined;
+}
+type BaseSendMessageWithStorageResult = BaseSendMessageSuccessResult | BaseSendMessageSkippedResult | BaseSendMessageErrorResult;
+interface BaseUseChatStorageResult {
+    isLoading: boolean;
+    stop: () => void;
+    conversationId: string | null;
+    setConversationId: (id: string | null) => void;
+    createConversation: (options?: CreateConversationOptions) => Promise<StoredConversation>;
+    getConversation: (id: string) => Promise<StoredConversation | null>;
+    getConversations: () => Promise<StoredConversation[]>;
+    updateConversationTitle: (id: string, title: string) => Promise<boolean>;
+    updateConversationPinned: (id: string, pinned: boolean) => Promise<boolean>;
+    deleteConversation: (id: string) => Promise<boolean>;
+    getMessages: (conversationId: string) => Promise<StoredMessage[]>;
+    /**
+     * Paginated display read: the newest `limit` messages (optionally below
+     * `beforeMessageId`), ascending, with embedding columns skipped.
+     */
+    getMessagesPage: (conversationId: string, options: GetMessagesPageOptions) => Promise<StoredMessage[]>;
+    /** Whole-thread branch-tree skeleton — no field decryption. */
+    getMessageSkeletons: (conversationId: string) => Promise<MessageSkeleton[]>;
+    /** Total message count for a conversation. */
+    getMessageCount: (conversationId: string) => Promise<number>;
+}
+declare function generateConversationId(): string;
+
+/**
+ * A finished background answer, as portal sealed it into the vault inbox.
+ * @public
+ */
+type InboxPlaintext = {
+    v: 1;
+    inference_id: string;
+    conversation_id: string;
+    parent_message_id: string | null;
+    assistant_message_id?: string | null;
+    api_type: "responses" | "completions";
+    model: string;
+    status: "completed" | "tool_request";
+    pending_tool: string | null;
+    response: ApiResponse;
+    finished_at: string;
+};
+/**
+ * One sealed item in the vault inbox.
+ * @public
+ */
+type InboxItem = {
+    id: string;
+    sealed: string;
+    created_at: string;
+};
+/**
+ * The account's vault inbox and the public key portal seals answers to.
+ * @public
+ */
+interface VaultInbox {
+    putPublicKey(publicKey: string): Promise<void>;
+    list(): Promise<InboxItem[]>;
+    remove(id: string): Promise<void>;
+}
+/**
+ * The vault inbox client, under the same `/api/private-chats` routes as the chat store.
+ * @public
+ */
+declare function createVaultInbox(options: {
+    baseUrl: string;
+    getToken: () => Promise<string | null>;
+    fetch?: typeof globalThis.fetch;
+    timeoutMs?: number;
+}): VaultInbox;
+/** The 65-byte uncompressed P-256 point, base64url, as vault stores it. */
+declare function exportInboxPublicKey(publicKey: CryptoKey): Promise<string>;
+/** Decrypt a sealed inbox item with the account's ECDH key pair. */
+declare function openInboxItem(item: Pick<InboxItem, "id" | "sealed">, keyPair: CryptoKeyPair): Promise<InboxPlaintext>;
+/**
+ * Outcome of delivering one vault inbox item.
+ * @public
+ */
+type InboxDeliveryResult = {
+    id: string;
+    conversationId: string | null;
+    status: "stored" | "delivered" | "elsewhere" | "unreadable" | "retry";
+    assistantMessage: StoredMessage | null;
+    error?: string;
+};
+
+/**
+ * What became of a restaurant booking or cancellation in one turn, read from
+ * the server's own tool result rather than from the model's reply.
+ */
+type ReservationReceipt = {
+    kind: "booking" | "cancel";
+    /**
+     * `made`: the provider confirmed it. `not_made`: it did not happen.
+     * `already_done`: an earlier call in the conversation had already done it.
+     * `unknown`: the call reached the provider and its outcome is not known.
+     */
+    status: "made" | "not_made" | "already_done" | "unknown";
+    venueName: string;
+    /** As the call sent it, e.g. `2026-10-23`. */
+    day: string;
+    /** As the call sent it, e.g. `9:00 PM`. */
+    time: string;
+    partySize?: number;
+    reservationId?: string;
+    /** Resy page where the user can see the reservation. */
+    resyUrl?: string;
+    /** The restaurant's own cancellation terms, when the booking result carries them. */
+    feeSummary?: string;
+    /** The provider's stated reason, when it did not happen. */
+    reason?: string;
+};
+/** One receipt per kind for the turn's booking and cancel calls, holding the last attempt's outcome unless an earlier one was `made` or `unknown`. */
+declare function extractReservationReceipts(toolCallEvents?: LlmapiToolCallEvent[]): ReservationReceipt[];
+
+/**
+ * Build the replay path for a detached stream. The portal serves the buffered
+ * stream from seq 0 on a GET to this path — no `starting_after`, no `id:`
+ * cursor, no request body. Replay always starts from the first buffered byte
+ * and the client rebuilds its own view with a fresh accumulator; partial
+ * client state is never sent back to the server.
+ *
+ * Exported so client repos can mock the endpoint in E2E without string drift.
+ */
+declare function streamReplayPath(inferenceId: string): string;
+/**
+ * Build the cancel path for a detached stream. A POST here tells the portal to
+ * stop generating into the buffer and release it — the billing-safe teardown
+ * for "the user pressed stop after we'd already detached".
+ *
+ * Exported so client repos can mock the endpoint in E2E without string drift.
+ */
+declare function streamCancelPath(inferenceId: string): string;
+/**
+ * A generation still running on the portal for the caller.
+ * @public
+ */
+type ActiveStream = {
+    inferenceId: string;
+    assistantMessageId: string | null;
+    conversationId: string | null;
+    parentMessageId: string | null;
+    apiType: "responses" | "completions";
+    model?: string;
+    startedAt: string;
+};
+/** List the caller's generations still running on the portal. */
+declare function listActiveStreams(options: {
+    token: string;
+    baseUrl?: string;
+    conversationId?: string;
+    fetch?: typeof globalThis.fetch;
+}): Promise<ActiveStream[]>;
+/**
+ * Thrown when the portal answers `410 Gone` to a replay GET: the buffered
+ * stream is gone — expired (10-min sliding TTL), absent, not owned by the
+ * caller, or already cancelled. There is nothing to replay; the answer is
+ * permanently lost and the caller should fall back to a fresh send rather than
+ * retry. A `stop()`-then-resume race lands here and finalizes as stopped, which
+ * is correct.
+ *
+ * `resumeStream` throws this (it does not return it) and fires neither
+ * `onFinish` nor `onError` — there is no body to deliver.
+ * @public
+ */
+declare class StreamExpiredError extends Error {
+    readonly name = "StreamExpiredError";
+    readonly inferenceId: string;
+    constructor(inferenceId: string, message?: string);
+}
+/**
+ * Options for {@link resumeStream}.
+ * @public
+ */
+interface ResumeStreamOptions {
+    /** The handle captured from a detached `runToolLoop` result. */
+    handle: StreamResumeHandle;
     /**
-     * Maximum number of tokens to generate in the response.
-     * Use this to limit response length and control costs.
+     * Fresh bearer token. The CALLER fetches it at resume time — a multi-minute
+     * background gap expires the bearer, so a token captured when the original
+     * stream started must never be reused (see `useChat.resumeStream`).
      */
-    maxOutputTokens?: number;
+    token: string;
+    /** Base URL for the portal. @default the SDK's configured BASE_URL. */
+    baseUrl?: string;
     /**
-     * Client-side tools with optional executors.
-     * These tools run in the browser/app and can have JavaScript executor functions.
+     * Streaming transport. Defaults to the GET-capable fetch transport; Expo
+     * passes `xhrTransport` (RN can't stream `fetch` bodies).
      */
-    clientTools?: LlmapiChatCompletionTool[];
+    transport?: StreamingTransport;
+    /** Aborts the replay; the partial is returned as an interrupted result. */
+    signal?: AbortSignal;
+    /** Adaptive output smoothing for the replayed content. @default true */
+    smoothing?: StreamSmoothingConfig | boolean;
     /**
-     * Server-side tools to include from /api/v1/tools.
-     * - undefined: Include all server-side tools (default)
-     * - string[]: Include only tools with these names
-     * - []: Include no server-side tools
-     * - function: Dynamic filter that receives prompt embedding(s) and all tools,
-     *   returns tool names to include. Useful for semantic tool matching.
-     *
-     * @example
-     * // Include only specific server tools
-     * serverTools: ["anuma_create_image", "perplexity_search"]
-     *
-     * // Disable server tools for this request
-     * serverTools: []
+     * Client-side watchdog for a dead live-tail. @default 120_000ms.
      *
-     * // Semantic tool matching based on prompt
-     * serverTools: (embeddings, tools) => {
-     *   const matches = findMatchingTools(embeddings, tools, { limit: 5 });
-     *   return matches.map(m => m.tool.name);
-     * }
+     * Deliberately NOT ~30s: the portal tolerates >100s reasoning silences (no
+     * `data:` frames on the replay connection during them) and its own liveness
+     * rule (heartbeat stale >90s => SSE error + `[DONE]`) is the authoritative
+     * guard. This client timer is a backstop for a half-open TCP connection and
+     * must sit ABOVE the server's 90s rule so the server error always wins when
+     * the portal is reachable. Set to 0 / Infinity to disable.
      */
-    serverTools?: ServerToolsFilter;
+    idleTimeoutMs?: number;
+    /** Content text deltas as they replay (always from seq 0 — reset accumulated text first). */
+    onData?: (chunk: string) => void;
+    /** Thinking/reasoning deltas as they replay. */
+    onThinking?: (chunk: string) => void;
+    /** Restores the placeholders this redactor assigned when the original request was sent. */
+    piiRedactor?: PiiRedactor;
+    /** Called once on a clean completion. Never called for 410 nor interrupted terminals. */
+    onFinish?: (response: ApiResponse) => void;
+    /** Called on a transient/unexpected failure. Never called for 410 (throws) nor interrupted terminals. */
+    onError?: (error: Error) => void;
+}
+/**
+ * Result of {@link resumeStream}. A `410 Gone` is the only outcome that throws
+ * ({@link StreamExpiredError}); every other terminal is returned.
+ *
+ * - clean completion → `{ data, error: null, interrupted: false, empty }`
+ * - in-stream error / tool-request terminal / idle timeout → `{ data, error,
+ *   interrupted: true }` (finalize as a stopped/partial message)
+ * - transient transport/HTTP failure (401, 5xx, network) → `{ data, error,
+ *   interrupted: false, statusCode? }` (retryable — keep the handle)
+ *
+ * `empty` is true when the clean terminal delivered ZERO content/thinking
+ * deltas — a `[DONE]`-only replay. That is never a real completion (a
+ * completed generation always buffered at least one content frame); it means
+ * the buffered frames were lost server-side (evicted/trimmed) while the
+ * terminal survived. Consumers must NOT persist `data` (an empty response)
+ * over content they already hold — keep the detached partial instead. On the
+ * empty terminal `onFinish` is NOT fired (there is no completion to deliver);
+ * the flag is optional so existing constructors of the clean arm stay valid.
+ * @public
+ */
+type ResumeStreamResult = {
+    data: ApiResponse;
+    error: null;
+    interrupted: false;
+    empty?: boolean;
+} | {
+    data: ApiResponse | null;
+    error: string;
+    interrupted: boolean;
+    statusCode?: number;
+};
+/**
+ * Replay a detached stream from the portal's buffer.
+ *
+ * This is the reconnect primitive: after `runToolLoop` returns the detached
+ * variant with a {@link StreamResumeHandle}, `resumeStream` issues a GET to the
+ * portal's replay endpoint and rebuilds the response from seq 0 using a FRESH
+ * accumulator and FRESH smoothers. Nothing from the original (detached) run is
+ * reused — the completions strategy's reasoning-tag parser is stateful, so
+ * replaying into reused state would double-count; replay-from-0 into fresh
+ * state is the correctness mechanism, not just a simplification.
+ *
+ * Contract highlights:
+ * - **No `starting_after`, no `id:` cursor, no body.** The GET carries the
+ *   inference id in the path only; replay is always whole-stream. (The server
+ *   reserves `starting_after` but does NOT honor it — sending it would silently
+ *   duplicate content.)
+ * - **410 → throws {@link StreamExpiredError}.** No `onFinish`/`onError`.
+ * - **In-stream error / tool-request terminal → `interrupted: true`.** Flushes
+ *   both smoothers and returns the partial; no throw, no `onError`, no `onFinish`.
+ * - **token resolved by the caller at resume time** so a refresh during the
+ *   detach window is honored.
+ *
+ * @public
+ */
+declare function resumeStream(options: ResumeStreamOptions): Promise<ResumeStreamResult>;
+
+interface StockPriceClassification {
+    /** Whether the prompt likely asks for stock/ETF/FX quote data. */
+    needsStockPrice: boolean;
+    /** Cosine similarity to the "needs stock price" centroid. */
+    stockPriceScore: number;
+    /** Cosine similarity to the "no stock price" centroid. */
+    noStockPriceScore: number;
+}
+interface StockPriceClassifierOptions extends EmbeddingOptions {
     /**
-     * Dynamic filter for client-side tools based on prompt embeddings.
-     * Receives the prompt embedding(s) (or null for short messages) and all client tools,
-     * returns tool names to include. Tools not in the returned list are excluded from the request.
-     *
-     * @example
-     * clientToolsFilter: (embeddings, tools) => {
-     *   if (!embeddings) return []; // Short message — no client tools
-     *   const matches = findMatchingTools(embeddings, pseudoServerTools);
-     *   return matches.map(m => m.tool.name);
-     * }
+     * Score margin: the stock-price score must exceed the no-stock-price
+     * score by at least this amount to classify as "needs stock price data".
+     * @default 0.02
      */
-    clientToolsFilter?: ClientToolsFilterFn;
+    margin?: number;
+}
+/**
+ * Classify whether a prompt needs stock/ETF/index/FX price data.
+ *
+ * Domain: traditional financial instruments (equities, indices, ETFs, FX).
+ * Crypto is handled by `classifyCryptoPrice`. Ambiguous prompts
+ * (e.g. *"gold price"*) may fire both — that's expected; the caller can
+ * inject both sets of results.
+ */
+declare function classifyStockPrice(prompt: string, options: StockPriceClassifierOptions): Promise<StockPriceClassification>;
+/**
+ * Batch-classify multiple prompts. Embeds all prompts in one batch
+ * call for efficiency.
+ */
+declare function classifyStockPriceBatch(prompts: string[], options: StockPriceClassifierOptions): Promise<StockPriceClassification[]>;
+interface StockPricePreProcessorOptions {
     /**
-     * Controls which tool the model should use:
-     * - "auto": Model decides whether to use a tool (default)
-     * - "any": Model must use one of the provided tools
-     * - "none": Model cannot use any tools
-     * - "required": Model must use a tool
-     * - Specific tool name: Model must use that specific tool
+     * Called with the caller's stock-quote provider when the classifier
+     * decides the prompt is asking for stock/ETF/FX data. Return either a
+     * plain string (wrapped by the SDK in a default user message) or a
+     * fully-formed `LlmapiMessage[]` (full control over role/shape). Omit
+     * to run in observer mode — classification still fires but nothing is
+     * injected.
+     *
+     * The `signal` argument is forwarded from the tool loop so long-running
+     * provider requests can be aborted when the caller aborts.
      */
-    toolChoice?: string;
+    fetchStockPriceData?: (prompt: string, options: {
+        signal?: AbortSignal;
+    }) => Promise<string | LlmapiMessage[]>;
     /**
-     * Maximum number of tool execution rounds before forcing the model to respond with text.
-     * After this many rounds, `toolChoice` is set to `"none"` on the next continuation,
-     * so the model produces a text answer using whatever tool results it has gathered.
-     * @default 3
+     * Score margin: `stockPriceScore` must exceed `noStockPriceScore` by at
+     * least this amount to classify as "needs stock price data".
+     * @default 0.02
      */
-    maxToolRounds?: number;
+    margin?: number;
+    /** Observe the classification without injecting anything. */
+    onClassification?: (result: StockPriceClassification) => void;
+}
+/**
+ * Build a pre-processor that runs stock-price classification on the shared
+ * embedding provided by `runToolLoop`, and — if the classifier decides the
+ * prompt is asking for quotes — invokes the caller-supplied
+ * `fetchStockPriceData` and injects the result into the conversation.
+ *
+ * Domain: stocks, ETFs, indices, FX. For crypto use
+ * `createCryptoPricePreProcessor`. The SDK does not run the lookup itself;
+ * the caller wires up whichever provider they want (Twelve Data, Alpha
+ * Vantage, Finnhub, etc.).
+ */
+declare function createStockPricePreProcessor(options?: StockPricePreProcessorOptions): PromptPreProcessor;
+
+/**
+ * Value of the `origin` column on a row the SDK synthesised for a turn's tool results (v44, #866).
+ *
+ * `satisfies MessageOrigin` so this constant and the column's union cannot drift apart silently.
+ */
+declare const TOOL_RESULT_ORIGIN = "tool_result";
+
+interface WeatherClassification {
+    /** Whether the prompt likely asks for weather data. */
+    needsWeather: boolean;
+    /** Cosine similarity to the "needs weather" centroid. */
+    weatherScore: number;
+    /** Cosine similarity to the "no weather" centroid. */
+    noWeatherScore: number;
+}
+interface WeatherClassifierOptions extends EmbeddingOptions {
     /**
-     * Reasoning configuration for o-series and other reasoning models.
-     * Controls reasoning effort level and whether to include reasoning summary.
+     * Score margin: the weather score must exceed the no-weather score by at
+     * least this amount to classify as "needs weather data".
+     * @default 0.02
      */
-    reasoning?: LlmapiResponseReasoning;
+    margin?: number;
+}
+/**
+ * Classify whether a prompt needs weather data.
+ *
+ * Covers forecasts, temperature, precipitation, wind, humidity, UV, AQI,
+ * marine, flood, climate — anything OpenMeteo-shaped.
+ */
+declare function classifyWeather(prompt: string, options: WeatherClassifierOptions): Promise<WeatherClassification>;
+/**
+ * Batch-classify multiple prompts. Embeds all prompts in one batch
+ * call for efficiency.
+ */
+declare function classifyWeatherBatch(prompts: string[], options: WeatherClassifierOptions): Promise<WeatherClassification[]>;
+interface WeatherPreProcessorOptions {
     /**
-     * Extended thinking configuration for Anthropic models (Claude).
-     * Enables the model to think through complex problems step by step
-     * before generating the final response.
+     * Called with the caller's weather provider when the classifier decides
+     * the prompt is asking for weather. Return either a plain string
+     * (wrapped by the SDK in a default user message) or a fully-formed
+     * `LlmapiMessage[]` (full control over role/shape). Omit to run in
+     * observer mode — classification still fires but nothing is injected.
+     *
+     * The `signal` argument is forwarded from the tool loop so long-running
+     * provider requests can be aborted when the caller aborts.
      */
-    thinking?: LlmapiThinkingOptions;
-    /** User-selected image generation model for server-side enforcement. */
-    imageModel?: string;
+    fetchWeatherData?: (prompt: string, options: {
+        signal?: AbortSignal;
+    }) => Promise<string | LlmapiMessage[]>;
     /**
-     * Per-request callback for thinking/reasoning chunks.
-     * Called with delta chunks as the model "thinks" through a problem.
-     * Use this to display thinking progress in the UI.
+     * Score margin: `weatherScore` must exceed `noWeatherScore` by at least
+     * this amount to classify as "needs weather data".
+     * @default 0.02
      */
-    onThinking?: (chunk: string) => void;
-    /** Parent message ID for branching (edit/regenerate). Sets on the user message. */
-    parentMessageId?: string;
+    margin?: number;
+    /** Observe the classification without injecting anything. */
+    onClassification?: (result: WeatherClassification) => void;
+}
+/**
+ * Build a pre-processor that runs weather classification on the shared
+ * embedding provided by `runToolLoop`, and — if the classifier decides
+ * the prompt is asking for weather — invokes the caller-supplied
+ * `fetchWeatherData` and injects the result into the conversation.
+ *
+ * The SDK does not run the weather lookup itself; the caller wires up
+ * whichever provider they want (OpenMeteo, AccuWeather, weather.gov, etc.).
+ */
+declare function createWeatherPreProcessor(options?: WeatherPreProcessorOptions): PromptPreProcessor;
+
+interface WebSearchClassification {
+    /** Whether the prompt likely needs a web search. */
+    needsWebSearch: boolean;
+    /** Cosine similarity to the "needs search" centroid. */
+    searchScore: number;
+    /** Cosine similarity to the "no search" centroid. */
+    noSearchScore: number;
+}
+interface WebSearchClassifierOptions extends EmbeddingOptions {
     /**
-     * Pre-generated unique ID for the assistant response message.
-     * When provided, the persisted assistant message will use this ID instead of
-     * an auto-generated one. This lets the consumer show an in-flight streaming
-     * placeholder under the same React key, avoiding an unmount/remount flash
-     * when streaming completes and the message is loaded from the database.
+     * Score margin: the search score must exceed the no-search score
+     * by at least this amount to classify as "needs web search".
+     * @default 0.02
      */
-    assistantUniqueId?: string;
+    margin?: number;
 }
-interface BaseSendMessageSuccessResult {
-    data: ApiResponse;
-    error: null;
-    userMessage: StoredMessage;
-    assistantMessage: StoredMessage;
-    /** Results from tools the SDK auto-executed this turn (e.g. display tools). */
-    autoExecutedToolResults?: {
-        name: string;
-        result: unknown;
-    }[];
+/**
+ * Classify whether a prompt needs a web search.
+ *
+ * Embeds the prompt and compares it against the pre-computed
+ * search and no-search centroid vectors.
+ */
+declare function classifyWebSearch(prompt: string, options: WebSearchClassifierOptions): Promise<WebSearchClassification>;
+/**
+ * Batch-classify multiple prompts. Embeds all prompts in one batch
+ * call for efficiency.
+ */
+declare function classifyWebSearchBatch(prompts: string[], options: WebSearchClassifierOptions): Promise<WebSearchClassification[]>;
+interface WebSearchPreProcessorOptions {
     /**
-     * The synthetic `[Tool Execution Results]` row those results were persisted as.
+     * Called with the caller's search provider when the classifier decides
+     * a web search is needed. Return either a plain string (the SDK will
+     * wrap it in a default user message) or a fully-formed message array
+     * (full control over role/shape). Omit to run in observer mode —
+     * classification still fires but no messages are injected.
      *
-     * Returned so a caller can key its transient overlay on the id the SDK actually wrote instead of
-     * deriving one and hoping the two agree — that guesswork is what mobile's per-card persist
-     * workarounds existed to do (#5519). Absent when the turn executed no tools, or when the row write
-     * failed (non-fatal: the assistant reply is already stored).
+     * The `signal` argument is forwarded from the tool loop so long-running
+     * search requests can be aborted when the caller aborts.
      */
-    toolResultsMessage?: StoredMessage;
-}
-interface BaseSendMessageSkippedResult {
-    data: ApiResponse;
-    error: null;
-    userMessage?: undefined;
-    assistantMessage?: undefined;
-    autoExecutedToolResults?: {
-        name: string;
-        result: unknown;
-    }[];
-    /** Indicates this was a skipStorage request - no messages were persisted */
-    skipped: true;
-}
-interface BaseSendMessageErrorResult {
-    data: null;
-    error: string;
-    userMessage?: StoredMessage;
-    assistantMessage?: undefined;
-}
-type BaseSendMessageWithStorageResult = BaseSendMessageSuccessResult | BaseSendMessageSkippedResult | BaseSendMessageErrorResult;
-interface BaseUseChatStorageResult {
-    isLoading: boolean;
-    stop: () => void;
-    conversationId: string | null;
-    setConversationId: (id: string | null) => void;
-    createConversation: (options?: CreateConversationOptions) => Promise<StoredConversation>;
-    getConversation: (id: string) => Promise<StoredConversation | null>;
-    getConversations: () => Promise<StoredConversation[]>;
-    updateConversationTitle: (id: string, title: string) => Promise<boolean>;
-    updateConversationPinned: (id: string, pinned: boolean) => Promise<boolean>;
-    deleteConversation: (id: string) => Promise<boolean>;
-    getMessages: (conversationId: string) => Promise<StoredMessage[]>;
+    fetchSearchResults?: (prompt: string, options: {
+        signal?: AbortSignal;
+    }) => Promise<string | LlmapiMessage[]>;
     /**
-     * Paginated display read: the newest `limit` messages (optionally below
-     * `beforeMessageId`), ascending, with embedding columns skipped.
+     * Score margin: `searchScore` must exceed `noSearchScore` by at least
+     * this amount to classify as "needs web search".
+     * @default 0.02
      */
-    getMessagesPage: (conversationId: string, options: GetMessagesPageOptions) => Promise<StoredMessage[]>;
-    /** Whole-thread branch-tree skeleton — no field decryption. */
-    getMessageSkeletons: (conversationId: string) => Promise<MessageSkeleton[]>;
-    /** Total message count for a conversation. */
-    getMessageCount: (conversationId: string) => Promise<number>;
+    margin?: number;
+    /** Observe the classification without injecting anything. */
+    onClassification?: (result: WebSearchClassification) => void;
 }
-declare function generateConversationId(): string;
+/**
+ * Build a pre-processor that runs web-search classification on the
+ * shared embedding provided by `runToolLoop`, and — if the classifier
+ * decides a search is warranted — invokes the caller-supplied
+ * `fetchSearchResults` and injects the result into the conversation.
+ *
+ * @example Basic usage with a search provider
+ * ```ts
+ * import { runToolLoop, createWebSearchPreProcessor } from "@anuma/sdk/server";
+ *
+ * const webSearch = createWebSearchPreProcessor({
+ *   fetchSearchResults: async (prompt, { signal }) => {
+ *     const res = await mySearchProvider.query(prompt, { signal });
+ *     return res.results.map((r) => `- ${r.title}: ${r.snippet}`).join("\n");
+ *   },
+ * });
+ *
+ * await runToolLoop({
+ *   messages,
+ *   model,
+ *   token,
+ *   preProcessors: [webSearch],
+ * });
+ * ```
+ *
+ * @example Observer mode — only log classification, inject nothing
+ * ```ts
+ * const observer = createWebSearchPreProcessor({
+ *   onClassification: ({ needsWebSearch, searchScore, noSearchScore }) => {
+ *     metrics.record({ needsWebSearch, searchScore, noSearchScore });
+ *   },
+ * });
+ * ```
+ *
+ * @example Full control — return a custom message shape
+ * ```ts
+ * const webSearch = createWebSearchPreProcessor({
+ *   fetchSearchResults: async (prompt, { signal }) => {
+ *     const results = await mySearchProvider.query(prompt, { signal });
+ *     return [
+ *       {
+ *         role: "system",
+ *         content: [{ type: "text", text: `Search results for "${prompt}":\n${formatResults(results)}` }],
+ *       },
+ *     ];
+ *   },
+ * });
+ * ```
+ */
+declare function createWebSearchPreProcessor(options?: WebSearchPreProcessorOptions): PromptPreProcessor;
+
+/**
+ * XHR-based streaming transport for React Native environments.
+ *
+ * React Native's `fetch` doesn't support `response.body` streaming,
+ * so this transport uses `XMLHttpRequest` with `onprogress` to stream
+ * SSE events. It exposes the same `{ stream: AsyncIterable }` interface
+ * as the default fetch-based transport.
+ */
+declare const xhrTransport: StreamingTransport;
 
 /** Returns `value` as an {@link AnumaTurn} when it is one, otherwise `undefined`. */
 declare function readAnumaTurn(value: unknown): AnumaTurn | undefined;
@@ -8530,13 +8613,14 @@ declare function saveSetting(store: ChatStore, section: string, data: {
 }, signal?: AbortSignal): Promise<Setting>;
 
 /**
- * AES-GCM keys derived from one wallet signature over `SIGN_MESSAGE`.
+ * AES-GCM keys and the topic HMAC key derived from one wallet signature over `SIGN_MESSAGE`.
  * @public
  */
 interface MemoryKeyRing {
     keyId: string;
     v3: CryptoKey;
     v2: CryptoKey;
+    topicHash: CryptoKey;
 }
 /**
  * Thrown when no supplied key decrypts a field.
@@ -8546,17 +8630,18 @@ declare class MemoryKeyError extends Error {
     constructor(message: string);
 }
 /**
- * Derive the v3 and legacy v2 memory keys from a hex wallet signature.
+ * Derive the v3 and legacy v2 memory keys and the topic HMAC key from a hex wallet signature.
  * @public
  */
 declare function deriveMemoryKeyRing(signatureHex: string): Promise<MemoryKeyRing>;
 /**
- * Encrypt and decrypt callbacks for `createRemoteMemoryPersistence` under the canonical key.
+ * Encrypt, decrypt and topic-hash callbacks for `createRemoteMemoryPersistence` under the canonical key.
  * @public
  */
 declare function memoryCipher(canonical: MemoryKeyRing): {
     encrypt: (plaintext: string) => Promise<string>;
     decrypt: (ciphertext: string) => Promise<string>;
+    hashTopic: (normalized: string) => Promise<string>;
 };
 /**
  * Re-encrypt a local field under the canonical key.
@@ -10332,7 +10417,7 @@ interface RemoteMemoryWorkPersistence {
     releaseWork(kind: RemoteMemoryWorkKind, token: string): Promise<void>;
 }
 
-/** The nearby private-memory row. Content and kind_value are plaintext ONLY on the device. */
+/** The nearby private-memory row. Content, kind_value and topic names are plaintext ONLY on the device. */
 interface RemoteMemoryRow {
     memory_id: string;
     content: string;
@@ -10453,8 +10538,10 @@ interface RemoteMemoryPersistenceOptions {
     keyId: string;
     encrypt: (plaintext: string) => Promise<string>;
     decrypt: (ciphertext: string) => Promise<string>;
+    /** Keyed hash of a normalized topic name, as provided by `memoryCipher`. */
+    hashTopic: (normalized: string) => Promise<string>;
     fetch?: typeof globalThis.fetch;
-    /** Cancellation for the initial account/key check. Individual operations take their own signal. */
+    /** Cancellation for the initial account/key check and the background topic upgrade. Individual operations take their own signal. */
     signal?: AbortSignal;
     timeoutMs?: number;
 }
@@ -11915,11 +12002,7 @@ interface UseChatOptions extends BaseUseChatOptions {
      */
     apiType?: ApiType;
     /**
-     * Opt into resumable streaming. When `true`, every `sendMessage` request
-     * sends `X-Stream-Resumable: 1` so the portal keeps generating into its
-     * buffer after a client disconnect, and `detach()` can hand back a
-     * {@link StreamResumeHandle} for {@link resumeStream}. Off by default — no
-     * header is sent and `detach()` always resolves to `null`.
+     * Keep each generation running on the portal after a disconnect, so `detach()` or a dropped connection resolves the send as detached with a {@link StreamResumeHandle} for {@link resumeStream}.
      * @default false
      */
     resumable?: boolean;
@@ -11954,6 +12037,8 @@ interface UseChatOptions extends BaseUseChatOptions {
 }
 type UseChatResult = BaseUseChatResult & {
     sendMessage: (args: SendMessageArgs) => Promise<SendMessageResult>;
+    /** The caller's generations still running on the portal, optionally for one conversation. */
+    getActiveStreams: (conversationId?: string) => Promise<ActiveStream[]>;
     /**
      * Tear down the in-flight request as a DETACH rather than a stop: the portal
      * keeps generating server-side and `sendMessage` resolves with the detached
@@ -12127,7 +12212,10 @@ interface UseChatStorageOptions extends BaseUseChatStorageOptions {
         apiType: "responses" | "completions";
         model?: string;
         round?: number;
+        assistantMessageId?: string;
     }) => void;
+    /** The vault inbox that receives answers finished while no client was attached. */
+    inbox?: VaultInbox;
     /**
      * Observability hook fired once per send with the tools actually selected for
      * the turn (after server + client filtering). Never throws into the send path.
@@ -12269,6 +12357,12 @@ interface UseChatStorageResult extends BaseUseChatStorageResult {
     resumeStream: (handleOverride?: StreamResumeHandle, opts?: {
         headless?: boolean;
     }) => Promise<ResumeStreamWithStorageResult>;
+    /** The caller's generations still running on the portal, optionally for one conversation. */
+    getActiveStreams: (conversationId?: string) => Promise<ActiveStream[]>;
+    /** Show a running generation from its first frame; nothing is stored. */
+    watchStream: (stream: ActiveStream) => Promise<ResumeStreamResult>;
+    /** Register the inbox public key, then store and remove every answer portal sealed into the inbox. */
+    deliverInbox: () => Promise<InboxDeliveryResult[]>;
     /**
      * Create a memory engine tool for LLM to search past conversations.
      * The tool is pre-configured with the hook's storage context and auth.
@@ -12370,4 +12464,4 @@ interface UseChatStorageResult extends BaseUseChatStorageResult {
  */
 declare function useChatStorage(options: UseChatStorageOptions): UseChatStorageResult;
 
-export { ANUMA_CONVERSATION_ID, type AnumaTurn, type AnumaTurnOrigin, type AutoExtractMessage, type AutoExtractor, type Budget, CHUNKS_DISCARDED_ORIGIN, type CachedChunkVectors, type CachedServerTools, type ChatAccount, type ChatAccountState, type ChatAttachment, type ChatAttachments, type ChatBackend, type ChatBackendFactory, type ChatBackendSigner, type ChatCacheStorage, type ChatChanges, type ChatChunkSearchOptions, Conversation as ChatConversation, type ChatImport, type ChatJson, type ChatListOptions, Message as ChatMessage, type ChatMigrationOptions, type ChatMigrationProgress, type ChatMigrationResult, type ChatMigrationSkip, type ChatOutboxLocks, type ChatOutboxStorage, type ChatPage, type ChatPresignedUrl, type ChatRecord, type ChatRecordKind, type ChatRef, type ChatRevision, type ChatRole, type ChatSearchHit, type ChatSearchOptions, type ChatSnapshot, type ChatStore, ChatStoreError, type ChatWrite, type ChunkSearchStats, type ChunkVectorCache, type ChunkingOptions, type ConsolidationAction, type ConsolidationFallbackReason, type ConversationMemoryInput, ConversationMemory as ConversationMemoryModel, type ConversationMemoryOperationsContext, type CreateAutoExtractorOptions, type CreateConversationOptions, type CreateDecaySweeperOptions, type CreateMessageOptions, type CreateSelectPaymentWalletToolOptions, type CreateVaultFolderOptions, type CreateVaultMemoryOptions, type CreateWalletPaymentToolOptions, type CryptoPriceClassification, type CryptoPricePreProcessorOptions, DEFAULT_CACHE_EXPIRATION_MS, DEFAULT_CHUNK_CACHE_SIZE, DEFAULT_CHUNK_OVERLAP, DEFAULT_CHUNK_SIZE, DEFAULT_DECAY_POLICY, DEFAULT_MAX_CLASSIFIER_CALLS_PER_SWEEP, DEFAULT_MIN_CHUNK_SIZE, DEFAULT_PROFILE_FACETS, DEFAULT_PROFILE_FACT_TYPE_WEIGHTS, DEFAULT_PROFILE_PROOF_ALPHA, DEFAULT_PROFILE_TREND_MULTIPLIERS, DEFAULT_VAULT_CACHE_SIZE, DatabaseManager, type DatabaseManagerLogger, type DatabaseManagerOptions, type DecayCandidateRaw, type DecayClassifier, type DecayInput, type DecayPolicy, type DecaySweepResult, type DecaySweeper, type DecayVerdict, type DurableAutoExtractorOptions, ENTITY_FANOUT, type EmbeddedWalletSignerFn, type EmbeddingRepairOptions, type EmbeddingRepairResult, EncryptionKeyMissingError, type ExtractFactsOptions, type ExtractOutcome, type ExtractedCandidate, type ExtractedEntity, type ExtractionCursorStore, type ExtractionFunnel, type ExtractionMessageSource, type ExtractionSourceMessage, type ExtractionSourceStatus, type ExtractionTimings, type FactType, type FileMetadata, type FileProcessingReason, type FileProcessingStatus, type FlushResult, type GetConversationsPageOptions, type GetMessagesPageOptions, type GraphTraversalOptions, HARD_DELETE_WINDOW_MS, INFERENCE_ID_HEADER, type InjectionClassifierOptions, type InjectionReason, type LazyStoredConversation, type LlmDecayClassifierOptions, type LlmNeighborRefinerOptions, type LocalMemoryStoreOptions, type LocalMessageAttachment, type Logger, LoggerProvider, type LoggerProviderProps, MAX_HOPS, MEDIUM_TTL_MS, MEMORY_KINDS, MEMORY_LEVELS, type ManualFactType, type MemoriesNeedingTopicExtraction, type MemoryContextItem, type MemoryContextLane, type MemoryContextOptions, type MemoryContextResult, type MemoryCounts, type MemoryCreate, type MemoryDecay, type MemoryDecaySweeperOptions, type EmbeddingOptions as MemoryEngineEmbeddingOptions, type MemoryEngineResult, type MemoryEngineSearchOptions, type MemoryExtractedEvent, MemoryKeyError, type MemoryKeyRing, type MemoryKind, type MemoryLevel, MemoryLevelError, type MemoryListOptions, type MemoryMaintenance, type MemoryMigrationOptions, type MemoryMigrationProgress, type MemoryMigrationResult, type MemoryMigrationSkip, type MemoryQuarantinedEvent, type MemoryRecallOptions, type MemoryRetainOptions, type MemoryStore, type MemorySubscribeOptions, type MemoryToVerify, type MemoryTopic, type MemoryTopicBacklog, type MemoryTopicMaintenance, type MemoryUpdate, type MemoryVaultSearchOptions, type MemoryVaultToolOptions, type MemoryVerification, type MessageAttachmentMigrationOptions, type MessageAttachmentMigrationResult, type MessageRedactionResult, type MessageSkeleton, NEVER_TTL_MS, NODE_BUDGET, NOTION_OAUTH_CONFIG, type NeighborRefiner, type NotionAuthUrlParams, type NotionClientRegistration, type NotionExchangeCodeParams, type NotionMcpCaller, type NotionOAuthEndpoints, type NotionPKCEChallenge, type NotionRefreshTokenParams, type NotionTokenResponse, type NowSource, type ObservationTrend, type ObservationTrendInput, PAST_EVENT_GRACE_MS, PII_PATTERNS, PROFILE_DOC_VERSION, type PaymentWallet, type PhotoIngestResult, type PhotoMediaRef, type PiiCategory, type PiiMatch, type PiiPattern, PiiRedactor, type PiiRedactorOptions, type PlatformStorage, type PortalLlmAuth, type PortalLlmFailure, type PortalLlmFailureReason, type ProfileConfigFingerprint, type ProfileDoc, type ProfileFacet, type ProfileFacetKey, type ProfileSalienceInput, type ProfileSection, type PromptPreProcessor, type PromptPreProcessorContext, type PublishedPhotoMemory, type QuantizedEmbedding, type QuarantinedMemoryInfo, QueueManager, type QueueStatus, RECALL_MAX_LIMIT, RECALL_TOOL_NAME, type RankableVaultMemory, type RankedMemory, type RankedProfileCandidate, type RecallContext, type RecallDegradation, type RecallDiagnostics, type RecallEmptyReason, type RecallOptions, type RecallResult, type RecallTelemetryCallbacks, type RecallToolCallbacks, type RecallToolOptions, type RecallTruncation, type RecencyOptions, type RedactionResult, type ReflectOptions, type ReflectResult, type RemoteChatStoreOptions, type RemoteMemoryCandidateOptions, type RemoteMemoryDecodeFailure, RemoteMemoryError, type RemoteMemoryListOptions, type RemoteMemoryMetadataPage, type RemoteMemoryMetadataRecord, type RemoteMemoryPage, RemoteMemoryPartialCreateError, type RemoteMemoryPersistence, type RemoteMemoryPersistenceOptions, type RemoteMemoryPipeline, type RemoteMemoryPipelineOptions, type RemoteMemoryQueryOptions, type RemoteMemoryQueryPage, type RemoteMemoryReadFilters, type RemoteMemoryRecord, type RemoteMemoryRow, type RemoteMemoryStoreOptions, type RemoteMemoryTopic, type RemoteMemoryWorkKind, type RemoteMemoryWorkLease, type RemoteMemoryWorkPersistence, type RemoteTopicPersistence, type RequestEncryptionKeyOptions, RerankerUnavailableError, type ReservationReceipt, type ResumeStreamOptions, type ResumeStreamResult, type ResumeStreamWithStorageResult, type RetainAction, type RetainContext, type RetainOptions, type RetainResult, type RetainSource, SDK_SCHEMA_VERSION, SELECT_PAYMENT_WALLET_TOOL_NAME, SHORT_TTL_MS, STREAM_RESUMABLE_HEADER, type ScoreBreakdown, type ScoreProfileSalienceOptions, type ScreenResult, type ScreenedCandidate, type SearchSource, type SelectPaymentWalletResult, type SendMessageWithStorageArgs, type SendMessageWithStorageDetachedResult, type SendMessageWithStorageResult, type ServerToolsOptions, type ServerToolsResponse, type Setting, type SignMessageFn, type StockPriceClassification, type StockPricePreProcessorOptions, type ChatCompletionUsage as StoredChatCompletionUsage, type StoredConversation, type StoredConversationMemory, type StoredMessage, type StoredMessageWithSimilarity, type StoredTopic, type StoredVaultFolder, VaultFolder as StoredVaultFolderModel, type StoredVaultMemory, VaultMemory as StoredVaultMemoryModel, StreamExpiredError, type StreamMetaEvent, type StreamResumeHandle, type StreamSmoothingConfig, type SynthesizeProfileOptions, TOOL_RESULT_ORIGIN, TOPICS_EXTRACTION_VERSION, TOPIC_EXTRACTION_BATCH_SIZE, TOPIC_SALIENCE_WEIGHTS, TREND_RECENT_WINDOW_DAYS, TREND_STALE_WINDOW_DAYS, type TextChunk, type TopicExtractOptions, type TopicExtractionBatchDiagnostics, type TopicExtractionInput, type TopicExtractionRunResult, type TopicSalience, type TopicSkipReason, type TurnCompleteEvent, type TurnSkippedEvent, type UncheckedReason, type UnverifiableReason, type UpdateVaultFolderOptions, type UpdateVaultMemoryOptions, type UseChatStorageOptions, type UseChatStorageResult, type UseCreditsOptions, type UseCreditsResult, type UseModelsOptions, type UseModelsResult, VAULT_SIZE_HOP_CAP, type VaultAttachmentCache, type VaultAttachmentJournal, type VaultAttachmentOwner, type VaultAttachmentRef, type VaultAttachmentUploadOptions, type VaultAttachments, type VaultAttachmentsOptions, type VaultChatActivity, type VaultChatBackend, type VaultChatBackendOptions, type VaultChatEvent, type VaultEmbeddingCache, type VaultEmbeddingExpectation, type VaultFolderOperationsContext, type VaultMemoryKind, type VaultMemoryOperationsContext, type VaultMemoryProjection, type VaultMemoryVisibility, type VaultMemoryWriter, type VaultSaveOperation, type VaultSearchResult, type VaultWriteAction, type VaultWriteInput, type VaultWriteOutcome, type VerificationSources, type VerifyMemoriesForPublishOptions, WALLET_PAYMENT_TOOL_NAME, type WalletPaymentOutcome, type WalletPaymentPassenger, type WalletPaymentRequest, type WalletPaymentResult, WalletPoller, type WeatherClassification, type WeatherPreProcessorOptions, type WebSearchClassification, type WebSearchPreProcessorOptions, type WriteFailureReason, addConversationMemoriesOp, anumaLastReadSortKey, anumaTurnContent, archiveVaultMemoryOp, assembleMemoryContext, attachFileContextToLastUserMessage, backfillMemoryTopicsOp, buildAttachedFilesText, buildNotionAuthUrl, capHopsForDensity, chatStorageMigrations, chatStorageSchema, chunkAndEmbedAllMessages, chunkAndEmbedMessage, chunkText, classifyCryptoPrice, classifyCryptoPriceBatch, classifyDecay, classifyInjectionCandidates, classifyObservationTrend, classifyStockPrice, classifyStockPriceBatch, classifyWeather, classifyWeatherBatch, classifyWebSearch, classifyWebSearchBatch, clearAllEncryptionKeys, clearAllEncryptionState, clearConversationMemoriesOp, clearEncryptionKey, clearLazyTitleCache, clearModelsCache, clearServerToolsCache, consoleLogger, conversationMemoryToStored, cosineInt8, countUnreadAnumaTurns, createAutoExtractor, createChunkVectorCache, createCryptoPricePreProcessor, createDecaySweeper, createDurableAutoExtractor, createLlmDecayClassifier, createLlmNeighborRefiner, createLocalMemoryStore, createMemoryEngineTool, createMemoryVaultSearchTool, createMemoryVaultTool, createMessageSourceResolver, createNotionProxyTools, createNotionTools, createPlatformCursorStore, createRecallTool, createRemoteChatStore, createRemoteMemoryPersistence, createRemoteMemoryPipeline, createRemoteMemoryStore, createSelectPaymentWalletTool, createStockPricePreProcessor, createStreamingDeAnonymizer, createVaultAttachments, createVaultChatBackend, createVaultEmbeddingCache, createVaultFolderOp, createVaultMemoriesBatchOp, createVaultMemoryOp, createWalletPaymentTool, createWeatherPreProcessor, createWebSearchPreProcessor, decodeChunkVector, decryptConversationTitle, decryptMessageEmbeddingFields, deleteAllVaultMemoriesForUserOp, deleteMessageOp, deleteVaultFolderOp, deleteVaultMemoryOp, dequantizeEmbedding, deriveKeyFromSignatureBytes, deriveMemoryKeyRing, discoverNotionOAuthEndpoints, eagerEmbedContent, embedAllMessages, embedMessage, encodeChunkVector, encryptToolCallEventsOp, ensureAnumaConversation, ensureDefaultFoldersOp, exchangeNotionCode, extractAndLinkEntitiesForMemoriesOp, extractAndRetain, extractEntitiesForMemories, extractFacts, extractReservationReceipts, formatFileProcessingNotes, generateConversationId, generateEmbedding, generateEmbeddings, generateNotionPKCE, getAllVaultFoldersOp, getAllVaultMemoriesOp, getAllVaultMemoryContentsOp, getCachedServerTools, getConversationMemoriesOp, getConversationsByProjectLazyOp, getConversationsLazyOp, getConversationsPageOp, getDecayCandidatesRawOp, getLogger, getMemoriesNeedingTopicExtractionOp, getServerTools, getUnfiledVaultMemoriesOp, getVaultFolderMemoryCountOp, getVaultMemoriesByIdsOp, getVaultMemoryOp, getVaultRankingProjectionsOp, hardDeleteDecayedOp, hasEncryptionKey, ingestPublishedPhotoMemoriesOp, injectionSignatureCatalog, isAttachedFilesText, isDegradedTopicSkip, isEncrypted, isPiiRedactor, isRerankerAvailable, loadSettings, localChatBackend, markAnumaRead, maskScopedEmbeddingCache, maxVaultAttachmentBytes, memoryCipher, migrateChatsToRemote, migrateMemoriesToRemote, migrateMessageAttachments, moveMemoriesToFolderOp, noopLogger, onKeyAvailable, parseMedia, preEmbedVaultMemories, primaryTopic, quantizeEmbedding, queueManager, rankProfileCandidates, readAnumaTurn, recall, reencryptMemoryField, reflect, refreshEncryptionKeyIfMatches, refreshNotionAccessToken, registerNotionClient, relinkMemoryTopicsOp, requestEncryptionKey, resolvePiiRedactor, restoreVaultMemoryOp, resumeStream, retain, saveSetting, scoreProfileSalience, screenCandidatesForInjection, sdkMigrations, sdkModelClasses, sdkSchema, sealLegacyMessageEmbeddingsOp, searchVaultMemories, seedEncryptionKeys, setLogger, setMemoryVisibilityOp, shouldChunkMessage, shouldRecallMemory, stampTopicsExtractedAtOp, streamCancelPath, streamReplayPath, stripLegacyChunkTextOp, summarizeObservationTrends, supersedeVaultMemoryOp, synthesizeProfile, topicWeight, traverseGraphLane, ttlForType, updateVaultFolderContextOp, updateVaultFolderOp, updateVaultMemoryEmbeddingOp, updateVaultMemoryOp, upsertMessageOp, useChat, useChatStorage, useCredits, useEncryption, useModels, vaultAttachmentRefs, vaultChatBackend, verifyMemoriesForPublish, xhrTransport };
+export { ANUMA_CONVERSATION_ID, type ActiveStream, type AnumaTurn, type AnumaTurnOrigin, type AutoExtractMessage, type AutoExtractor, type Budget, CHUNKS_DISCARDED_ORIGIN, type CachedChunkVectors, type CachedServerTools, type ChatAccount, type ChatAccountState, type ChatAttachment, type ChatAttachments, type ChatBackend, type ChatBackendFactory, type ChatBackendSigner, type ChatCacheStorage, type ChatChanges, type ChatChunkSearchOptions, Conversation as ChatConversation, type ChatImport, type ChatJson, type ChatListOptions, Message as ChatMessage, type ChatMigrationOptions, type ChatMigrationProgress, type ChatMigrationResult, type ChatMigrationSkip, type ChatOutboxLocks, type ChatOutboxStorage, type ChatPage, type ChatPresignedUrl, type ChatRecord, type ChatRecordKind, type ChatRef, type ChatRevision, type ChatRole, type ChatSearchHit, type ChatSearchOptions, type ChatSnapshot, type ChatStore, ChatStoreError, type ChatWrite, type ChunkSearchStats, type ChunkVectorCache, type ChunkingOptions, type ConsolidationAction, type ConsolidationFallbackReason, type ConversationMemoryInput, ConversationMemory as ConversationMemoryModel, type ConversationMemoryOperationsContext, type CreateAutoExtractorOptions, type CreateConversationOptions, type CreateDecaySweeperOptions, type CreateMessageOptions, type CreateSelectPaymentWalletToolOptions, type CreateVaultFolderOptions, type CreateVaultMemoryOptions, type CreateWalletPaymentToolOptions, type CryptoPriceClassification, type CryptoPricePreProcessorOptions, DEFAULT_CACHE_EXPIRATION_MS, DEFAULT_CHUNK_CACHE_SIZE, DEFAULT_CHUNK_OVERLAP, DEFAULT_CHUNK_SIZE, DEFAULT_DECAY_POLICY, DEFAULT_MAX_CLASSIFIER_CALLS_PER_SWEEP, DEFAULT_MIN_CHUNK_SIZE, DEFAULT_PROFILE_FACETS, DEFAULT_PROFILE_FACT_TYPE_WEIGHTS, DEFAULT_PROFILE_PROOF_ALPHA, DEFAULT_PROFILE_TREND_MULTIPLIERS, DEFAULT_VAULT_CACHE_SIZE, DatabaseManager, type DatabaseManagerLogger, type DatabaseManagerOptions, type DecayCandidateRaw, type DecayClassifier, type DecayInput, type DecayPolicy, type DecaySweepResult, type DecaySweeper, type DecayVerdict, type DurableAutoExtractorOptions, ENTITY_FANOUT, type EmbeddedWalletSignerFn, type EmbeddingRepairOptions, type EmbeddingRepairResult, EncryptionKeyMissingError, type ExtractFactsOptions, type ExtractOutcome, type ExtractedCandidate, type ExtractedEntity, type ExtractionCursorStore, type ExtractionFunnel, type ExtractionMessageSource, type ExtractionSourceMessage, type ExtractionSourceStatus, type ExtractionTimings, type FactType, type FileMetadata, type FileProcessingReason, type FileProcessingStatus, type FlushResult, type GetConversationsPageOptions, type GetMessagesPageOptions, type GraphTraversalOptions, HARD_DELETE_WINDOW_MS, INFERENCE_ID_HEADER, type InboxDeliveryResult, type InboxItem, type InboxPlaintext, type InjectionClassifierOptions, type InjectionReason, type LazyStoredConversation, type LlmDecayClassifierOptions, type LlmNeighborRefinerOptions, type LocalMemoryStoreOptions, type LocalMessageAttachment, type Logger, LoggerProvider, type LoggerProviderProps, MAX_HOPS, MEDIUM_TTL_MS, MEMORY_KINDS, MEMORY_LEVELS, type ManualFactType, type MemoriesNeedingTopicExtraction, type MemoryContextItem, type MemoryContextLane, type MemoryContextOptions, type MemoryContextResult, type MemoryCounts, type MemoryCreate, type MemoryDecay, type MemoryDecaySweeperOptions, type EmbeddingOptions as MemoryEngineEmbeddingOptions, type MemoryEngineResult, type MemoryEngineSearchOptions, type MemoryExtractedEvent, MemoryKeyError, type MemoryKeyRing, type MemoryKind, type MemoryLevel, MemoryLevelError, type MemoryListOptions, type MemoryMaintenance, type MemoryMigrationOptions, type MemoryMigrationProgress, type MemoryMigrationResult, type MemoryMigrationSkip, type MemoryQuarantinedEvent, type MemoryRecallOptions, type MemoryRetainOptions, type MemoryStore, type MemorySubscribeOptions, type MemoryToVerify, type MemoryTopic, type MemoryTopicBacklog, type MemoryTopicMaintenance, type MemoryUpdate, type MemoryVaultSearchOptions, type MemoryVaultToolOptions, type MemoryVerification, type MessageAttachmentMigrationOptions, type MessageAttachmentMigrationResult, type MessageRedactionResult, type MessageSkeleton, NEVER_TTL_MS, NODE_BUDGET, NOTION_OAUTH_CONFIG, type NeighborRefiner, type NotionAuthUrlParams, type NotionClientRegistration, type NotionExchangeCodeParams, type NotionMcpCaller, type NotionOAuthEndpoints, type NotionPKCEChallenge, type NotionRefreshTokenParams, type NotionTokenResponse, type NowSource, type ObservationTrend, type ObservationTrendInput, PAST_EVENT_GRACE_MS, PII_PATTERNS, PROFILE_DOC_VERSION, type PaymentWallet, type PhotoIngestResult, type PhotoMediaRef, type PiiCategory, type PiiMatch, type PiiPattern, PiiRedactor, type PiiRedactorOptions, type PlatformStorage, type PortalLlmAuth, type PortalLlmFailure, type PortalLlmFailureReason, type ProfileConfigFingerprint, type ProfileDoc, type ProfileFacet, type ProfileFacetKey, type ProfileSalienceInput, type ProfileSection, type PromptPreProcessor, type PromptPreProcessorContext, type PublishedPhotoMemory, type QuantizedEmbedding, type QuarantinedMemoryInfo, QueueManager, type QueueStatus, RECALL_MAX_LIMIT, RECALL_TOOL_NAME, type RankableVaultMemory, type RankedMemory, type RankedProfileCandidate, type RecallContext, type RecallDegradation, type RecallDiagnostics, type RecallEmptyReason, type RecallOptions, type RecallResult, type RecallTelemetryCallbacks, type RecallToolCallbacks, type RecallToolOptions, type RecallTruncation, type RecencyOptions, type RedactionResult, type ReflectOptions, type ReflectResult, type RemoteChatStoreOptions, type RemoteMemoryCandidateOptions, type RemoteMemoryDecodeFailure, RemoteMemoryError, type RemoteMemoryListOptions, type RemoteMemoryMetadataPage, type RemoteMemoryMetadataRecord, type RemoteMemoryPage, RemoteMemoryPartialCreateError, type RemoteMemoryPersistence, type RemoteMemoryPersistenceOptions, type RemoteMemoryPipeline, type RemoteMemoryPipelineOptions, type RemoteMemoryQueryOptions, type RemoteMemoryQueryPage, type RemoteMemoryReadFilters, type RemoteMemoryRecord, type RemoteMemoryRow, type RemoteMemoryStoreOptions, type RemoteMemoryTopic, type RemoteMemoryWorkKind, type RemoteMemoryWorkLease, type RemoteMemoryWorkPersistence, type RemoteTopicPersistence, type RequestEncryptionKeyOptions, RerankerUnavailableError, type ReservationReceipt, type ResumeStreamOptions, type ResumeStreamResult, type ResumeStreamWithStorageResult, type RetainAction, type RetainContext, type RetainOptions, type RetainResult, type RetainSource, SDK_SCHEMA_VERSION, SELECT_PAYMENT_WALLET_TOOL_NAME, SHORT_TTL_MS, STREAM_RESUMABLE_HEADER, type ScoreBreakdown, type ScoreProfileSalienceOptions, type ScreenResult, type ScreenedCandidate, type SearchSource, type SelectPaymentWalletResult, type SendMessageWithStorageArgs, type SendMessageWithStorageDetachedResult, type SendMessageWithStorageResult, type ServerToolsOptions, type ServerToolsResponse, type Setting, type SignMessageFn, type StockPriceClassification, type StockPricePreProcessorOptions, type ChatCompletionUsage as StoredChatCompletionUsage, type StoredConversation, type StoredConversationMemory, type StoredMessage, type StoredMessageWithSimilarity, type StoredTopic, type StoredVaultFolder, VaultFolder as StoredVaultFolderModel, type StoredVaultMemory, VaultMemory as StoredVaultMemoryModel, StreamExpiredError, type StreamMetaEvent, type StreamResumeHandle, type StreamSmoothingConfig, type SynthesizeProfileOptions, TOOL_RESULT_ORIGIN, TOPICS_EXTRACTION_VERSION, TOPIC_EXTRACTION_BATCH_SIZE, TOPIC_SALIENCE_WEIGHTS, TREND_RECENT_WINDOW_DAYS, TREND_STALE_WINDOW_DAYS, type TextChunk, type TopicExtractOptions, type TopicExtractionBatchDiagnostics, type TopicExtractionInput, type TopicExtractionRunResult, type TopicSalience, type TopicSkipReason, type TurnCompleteEvent, type TurnSkippedEvent, type UncheckedReason, type UnverifiableReason, type UpdateVaultFolderOptions, type UpdateVaultMemoryOptions, type UseChatStorageOptions, type UseChatStorageResult, type UseCreditsOptions, type UseCreditsResult, type UseModelsOptions, type UseModelsResult, VAULT_SIZE_HOP_CAP, type VaultAttachmentCache, type VaultAttachmentJournal, type VaultAttachmentOwner, type VaultAttachmentRef, type VaultAttachmentUploadOptions, type VaultAttachments, type VaultAttachmentsOptions, type VaultChatActivity, type VaultChatBackend, type VaultChatBackendOptions, type VaultChatEvent, type VaultEmbeddingCache, type VaultEmbeddingExpectation, type VaultFolderOperationsContext, type VaultInbox, type VaultMemoryKind, type VaultMemoryOperationsContext, type VaultMemoryProjection, type VaultMemoryVisibility, type VaultMemoryWriter, type VaultSaveOperation, type VaultSearchResult, type VaultWriteAction, type VaultWriteInput, type VaultWriteOutcome, type VerificationSources, type VerifyMemoriesForPublishOptions, WALLET_PAYMENT_TOOL_NAME, type WalletPaymentOutcome, type WalletPaymentPassenger, type WalletPaymentRequest, type WalletPaymentResult, WalletPoller, type WeatherClassification, type WeatherPreProcessorOptions, type WebSearchClassification, type WebSearchPreProcessorOptions, type WriteFailureReason, addConversationMemoriesOp, anumaLastReadSortKey, anumaTurnContent, archiveVaultMemoryOp, assembleMemoryContext, attachFileContextToLastUserMessage, backfillMemoryTopicsOp, buildAttachedFilesText, buildNotionAuthUrl, capHopsForDensity, chatStorageMigrations, chatStorageSchema, chunkAndEmbedAllMessages, chunkAndEmbedMessage, chunkText, classifyCryptoPrice, classifyCryptoPriceBatch, classifyDecay, classifyInjectionCandidates, classifyObservationTrend, classifyStockPrice, classifyStockPriceBatch, classifyWeather, classifyWeatherBatch, classifyWebSearch, classifyWebSearchBatch, clearAllEncryptionKeys, clearAllEncryptionState, clearConversationMemoriesOp, clearEncryptionKey, clearLazyTitleCache, clearModelsCache, clearServerToolsCache, consoleLogger, conversationMemoryToStored, cosineInt8, countUnreadAnumaTurns, createAutoExtractor, createChunkVectorCache, createCryptoPricePreProcessor, createDecaySweeper, createDurableAutoExtractor, createLlmDecayClassifier, createLlmNeighborRefiner, createLocalMemoryStore, createMemoryEngineTool, createMemoryVaultSearchTool, createMemoryVaultTool, createMessageSourceResolver, createNotionProxyTools, createNotionTools, createPlatformCursorStore, createRecallTool, createRemoteChatStore, createRemoteMemoryPersistence, createRemoteMemoryPipeline, createRemoteMemoryStore, createSelectPaymentWalletTool, createStockPricePreProcessor, createStreamingDeAnonymizer, createVaultAttachments, createVaultChatBackend, createVaultEmbeddingCache, createVaultFolderOp, createVaultInbox, createVaultMemoriesBatchOp, createVaultMemoryOp, createWalletPaymentTool, createWeatherPreProcessor, createWebSearchPreProcessor, decodeChunkVector, decryptConversationTitle, decryptMessageEmbeddingFields, deleteAllVaultMemoriesForUserOp, deleteMessageOp, deleteVaultFolderOp, deleteVaultMemoryOp, dequantizeEmbedding, deriveKeyFromSignatureBytes, deriveMemoryKeyRing, discoverNotionOAuthEndpoints, eagerEmbedContent, embedAllMessages, embedMessage, encodeChunkVector, encryptToolCallEventsOp, ensureAnumaConversation, ensureDefaultFoldersOp, exchangeNotionCode, exportInboxPublicKey, extractAndLinkEntitiesForMemoriesOp, extractAndRetain, extractEntitiesForMemories, extractFacts, extractReservationReceipts, formatFileProcessingNotes, generateConversationId, generateEmbedding, generateEmbeddings, generateNotionPKCE, getAllVaultFoldersOp, getAllVaultMemoriesOp, getAllVaultMemoryContentsOp, getCachedServerTools, getConversationMemoriesOp, getConversationsByProjectLazyOp, getConversationsLazyOp, getConversationsPageOp, getDecayCandidatesRawOp, getLogger, getMemoriesNeedingTopicExtractionOp, getServerTools, getUnfiledVaultMemoriesOp, getVaultFolderMemoryCountOp, getVaultMemoriesByIdsOp, getVaultMemoryOp, getVaultRankingProjectionsOp, hardDeleteDecayedOp, hasEncryptionKey, ingestPublishedPhotoMemoriesOp, injectionSignatureCatalog, isAttachedFilesText, isDegradedTopicSkip, isEncrypted, isPiiRedactor, isRerankerAvailable, listActiveStreams, loadSettings, localChatBackend, markAnumaRead, maskScopedEmbeddingCache, maxVaultAttachmentBytes, memoryCipher, migrateChatsToRemote, migrateMemoriesToRemote, migrateMessageAttachments, moveMemoriesToFolderOp, noopLogger, onKeyAvailable, openInboxItem, parseMedia, preEmbedVaultMemories, primaryTopic, quantizeEmbedding, queueManager, rankProfileCandidates, readAnumaTurn, recall, reencryptMemoryField, reflect, refreshEncryptionKeyIfMatches, refreshNotionAccessToken, registerNotionClient, relinkMemoryTopicsOp, requestEncryptionKey, resolvePiiRedactor, restoreVaultMemoryOp, resumeStream, retain, saveSetting, scoreProfileSalience, screenCandidatesForInjection, sdkMigrations, sdkModelClasses, sdkSchema, sealLegacyMessageEmbeddingsOp, searchVaultMemories, seedEncryptionKeys, setLogger, setMemoryVisibilityOp, shouldChunkMessage, shouldRecallMemory, stampTopicsExtractedAtOp, streamCancelPath, streamReplayPath, stripLegacyChunkTextOp, summarizeObservationTrends, supersedeVaultMemoryOp, synthesizeProfile, topicWeight, traverseGraphLane, ttlForType, updateVaultFolderContextOp, updateVaultFolderOp, updateVaultMemoryEmbeddingOp, updateVaultMemoryOp, upsertMessageOp, useChat, useChatStorage, useCredits, useEncryption, useModels, vaultAttachmentRefs, vaultChatBackend, verifyMemoriesForPublish, xhrTransport };