@anuma/sdk 10.9.0 → 10.10.0

package/dist/react/index.d.mts

@@ -1894,6 +1894,127 @@ declare function buildAttachedFilesText(fileContext: string): string;
  */
 declare function attachFileContextToLastUserMessage(messages: LlmapiMessage[], fileContext: string): LlmapiMessage[];
 
+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;
+    /**
+     * 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.
+     *
+     * 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;
+};
+
 /**
  * PII detection patterns for structured data types.
  *
@@ -2208,127 +2329,6 @@ declare class PiiRedactor {
     dispose(): void;
 }
 
-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;
-    /**
-     * 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.
-     *
-     * 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;
-};
-
 /**
  * Configuration for stream output smoothing.
  *
@@ -2367,8 +2367,6 @@ type ToolCallArgumentsDeltaEvent = {
     argumentsDelta: string;
     accumulatedArguments: string;
 };
-type ToolExecutionErrorType = "parse" | "timeout" | "execution" | "cancelled";
-
 /**
  * Error thrown when an upstream provider emits an in-stream error event.
  * Carries the provider's code (e.g. `"timeout"`) so callers can match
@@ -2379,6 +2377,7 @@ declare class ProviderStreamError extends Error {
     readonly code: string | undefined;
     constructor(message: string, code?: string);
 }
+type ToolExecutionErrorType = "parse" | "timeout" | "execution" | "cancelled";
 
 /** A tool result from an auto-executed tool. */
 type AutoExecutedToolResult = {
@@ -2434,6 +2433,8 @@ declare const INFERENCE_ID_HEADER = "X-Inference-ID";
  */
 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;
@@ -2787,481 +2788,6 @@ type ApiType = "auto" | "responses" | "completions";
  */
 type ApiResponse = LlmapiResponseResponse | LlmapiChatCompletionResponse;
 
-/**
- * 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>;
-
-/**
- * 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;
-    /**
-     * 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;
-
 type ChatRecordKind = "conversation" | "message" | "summary" | "project" | "memory_links" | "setting";
 type ChatJson = null | boolean | number | string | ChatJson[] | {
     [key: string]: ChatJson;
@@ -5073,7 +4599,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
@@ -9293,132 +8819,618 @@ interface BaseSendMessageWithStorageArgs {
      */
     thoughtProcess?: ActivityPhase[];
     /**
-     * Callback to get activity phases AFTER streaming completes.
-     * Use this instead of `thoughtProcess` when phases are added dynamically during streaming
-     * (e.g., via server tool call events like "Searching...", "Generating image...").
-     *
-     * If both `thoughtProcess` and `getThoughtProcess` are provided, `getThoughtProcess` takes precedence.
+     * Callback to get activity phases AFTER streaming completes.
+     * Use this instead of `thoughtProcess` when phases are added dynamically during streaming
+     * (e.g., via server tool call events like "Searching...", "Generating image...").
+     *
+     * If both `thoughtProcess` and `getThoughtProcess` are provided, `getThoughtProcess` takes precedence.
+     */
+    getThoughtProcess?: () => ActivityPhase[];
+    /**
+     * Controls randomness in the response (0.0 to 2.0).
+     * Lower values make output more deterministic, higher values more creative.
+     */
+    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 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.
      */
-    getThoughtProcess?: () => ActivityPhase[];
+    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;
     /**
-     * Controls randomness in the response (0.0 to 2.0).
-     * Lower values make output more deterministic, higher values more creative.
+     * 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`).
      */
-    temperature?: number;
+    token: string;
+    /** Base URL for the portal. @default the SDK's configured BASE_URL. */
+    baseUrl?: string;
     /**
-     * Maximum number of tokens to generate in the response.
-     * Use this to limit response length and control costs.
+     * Streaming transport. Defaults to the GET-capable fetch transport; Expo
+     * passes `xhrTransport` (RN can't stream `fetch` bodies).
      */
-    maxOutputTokens?: number;
+    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 tools with optional executors.
-     * These tools run in the browser/app and can have JavaScript executor functions.
+     * 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.
      */
-    clientTools?: LlmapiChatCompletionTool[];
+    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 {
     /**
-     * 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);
-     * }
+     * 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
      */
-    serverTools?: ServerToolsFilter;
+    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 {
     /**
-     * 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.
+     * 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.
      *
-     * @example
-     * clientToolsFilter: (embeddings, tools) => {
-     *   if (!embeddings) return []; // Short message — no client tools
-     *   const matches = findMatchingTools(embeddings, pseudoServerTools);
-     *   return matches.map(m => m.tool.name);
-     * }
+     * The `signal` argument is forwarded from the tool loop so long-running
+     * provider requests can be aborted when the caller aborts.
      */
-    clientToolsFilter?: ClientToolsFilterFn;
+    fetchStockPriceData?: (prompt: string, options: {
+        signal?: AbortSignal;
+    }) => Promise<string | LlmapiMessage[]>;
     /**
-     * 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
+     * Score margin: `stockPriceScore` must exceed `noStockPriceScore` by at
+     * least this amount to classify as "needs stock price data".
+     * @default 0.02
      */
-    toolChoice?: string;
+    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 {
     /**
-     * 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: the weather score must exceed the no-weather score by at
+     * least this amount to classify as "needs weather data".
+     * @default 0.02
      */
-    maxToolRounds?: number;
+    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 {
     /**
-     * Reasoning configuration for o-series and other reasoning models.
-     * Controls reasoning effort level and whether to include reasoning summary.
+     * 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.
      */
-    reasoning?: LlmapiResponseReasoning;
+    fetchWeatherData?: (prompt: string, options: {
+        signal?: AbortSignal;
+    }) => Promise<string | LlmapiMessage[]>;
     /**
-     * Extended thinking configuration for Anthropic models (Claude).
-     * Enables the model to think through complex problems step by step
-     * before generating the final response.
+     * Score margin: `weatherScore` must exceed `noWeatherScore` by at least
+     * this amount to classify as "needs weather data".
+     * @default 0.02
      */
-    thinking?: LlmapiThinkingOptions;
-    /** User-selected image generation model for server-side enforcement. */
-    imageModel?: 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 {
     /**
-     * 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: the search score must exceed the no-search score
+     * by at least this amount to classify as "needs web search".
+     * @default 0.02
      */
-    onThinking?: (chunk: string) => void;
-    /** Parent message ID for branching (edit/regenerate). Sets on the user message. */
-    parentMessageId?: string;
+    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 {
     /**
-     * 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.
+     * 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.
      */
-    assistantUniqueId?: string;
-}
-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;
 
 /** Returns `value` as an {@link AnumaTurn} when it is one, otherwise `undefined`. */
 declare function readAnumaTurn(value: unknown): AnumaTurn | undefined;
@@ -13819,7 +13831,7 @@ declare class WatermelonChatStorageAdapter implements ChatBackend {
     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>;
     updateMessageFileIds(uniqueId: string, fileIds: string[]): Promise<StoredMessage | null>;
     clearMessages(conversationId: string): Promise<void>;
@@ -15093,17 +15105,6 @@ type SendMessageWithStorageResult = {
     userMessage: StoredMessage;
     assistantMessage?: undefined;
 };
-/**
- * Outcome of delivering one vault inbox item with `deliverInbox`.
- * @public
- */
-type InboxDeliveryResult = {
-    id: string;
-    conversationId: string | null;
-    status: "stored" | "delivered" | "elsewhere" | "unreadable" | "retry";
-    assistantMessage: StoredMessage | null;
-    error?: string;
-};
 /**
  * Options for searching messages
  */