@anuma/sdk 6.39.1 → 6.39.2

package/dist/expo/index.cjs

@@ -24607,6 +24607,7 @@ function useChat(options) {
     apiType: defaultApiType = "auto",
     smoothing,
     preProcessors,
+    hooks,
     piiRedaction,
     onPiiRedacted,
     resumable = false,
@@ -24860,6 +24861,7 @@ function useChat(options) {
           onToolCallArgumentsDelta,
           onStepFinish,
           preProcessors,
+          hooks,
           piiRedaction: requestPiiRedaction ?? resolvedPiiRedaction,
           onPiiRedacted
         });
@@ -24899,6 +24901,7 @@ function useChat(options) {
       defaultApiType,
       smoothing,
       preProcessors,
+      hooks,
       resolvedPiiRedaction,
       onPiiRedacted,
       resumable,
@@ -25869,6 +25872,7 @@ function useChatStorage(options) {
     embeddingModel = DEFAULT_API_EMBEDDING_MODEL,
     minContentLength = DEFAULT_MIN_CONTENT_LENGTH,
     preProcessors,
+    hooks,
     smoothing,
     resumable = false,
     onCancelResult,
@@ -26328,6 +26332,7 @@ function useChatStorage(options) {
     onError,
     apiType,
     preProcessors,
+    hooks,
     smoothing,
     resumable,
     onCancelResult,

package/dist/expo/index.d.mts

@@ -2002,6 +2002,127 @@ declare function createStreamingDeAnonymizer(redactor: PiiRedactor, emit: (chunk
     flush: () => 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.
  *
@@ -2196,6 +2317,8 @@ type BaseSendMessageArgs = ResponsesApiOptions & {
 type BaseUseChatOptions = {
     getToken?: () => Promise<string | null>;
     baseUrl?: string;
+    /** Run lifecycle hooks for telemetry and tracing, for example from `createMetricsHooks` */
+    hooks?: RunHooks | RunHooks[];
     /**
      * Callback function to be called when a new data chunk is received.
      */
@@ -7135,6 +7258,8 @@ interface CreateConversationOptions {
  * @inline
  */
 interface BaseUseChatStorageOptions {
+    /** Run lifecycle hooks for telemetry and tracing, for example from `createMetricsHooks` */
+    hooks?: RunHooks | RunHooks[];
     /** WatermelonDB database instance for storing conversations and messages */
     database: Database;
     /** Route memory reads, writes, recall and the memory tools through this store instead of the database's vault; folders are unsupported. With `piiRedaction` on, build the store with `embeddingOptions.maskInput` (e.g. `(text) => redactor.maskText(text)` with any `PiiRedactor`) or its memory calls throw. */

package/dist/expo/index.d.ts

@@ -2002,6 +2002,127 @@ declare function createStreamingDeAnonymizer(redactor: PiiRedactor, emit: (chunk
     flush: () => 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.
  *
@@ -2196,6 +2317,8 @@ type BaseSendMessageArgs = ResponsesApiOptions & {
 type BaseUseChatOptions = {
     getToken?: () => Promise<string | null>;
     baseUrl?: string;
+    /** Run lifecycle hooks for telemetry and tracing, for example from `createMetricsHooks` */
+    hooks?: RunHooks | RunHooks[];
     /**
      * Callback function to be called when a new data chunk is received.
      */
@@ -7135,6 +7258,8 @@ interface CreateConversationOptions {
  * @inline
  */
 interface BaseUseChatStorageOptions {
+    /** Run lifecycle hooks for telemetry and tracing, for example from `createMetricsHooks` */
+    hooks?: RunHooks | RunHooks[];
     /** WatermelonDB database instance for storing conversations and messages */
     database: Database;
     /** Route memory reads, writes, recall and the memory tools through this store instead of the database's vault; folders are unsupported. With `piiRedaction` on, build the store with `embeddingOptions.maskInput` (e.g. `(text) => redactor.maskText(text)` with any `PiiRedactor`) or its memory calls throw. */

package/dist/expo/index.mjs

@@ -22960,6 +22960,7 @@ function useChat(options) {
     apiType: defaultApiType = "auto",
     smoothing,
     preProcessors,
+    hooks,
     piiRedaction,
     onPiiRedacted,
     resumable = false,
@@ -23213,6 +23214,7 @@ function useChat(options) {
           onToolCallArgumentsDelta,
           onStepFinish,
           preProcessors,
+          hooks,
           piiRedaction: requestPiiRedaction ?? resolvedPiiRedaction,
           onPiiRedacted
         });
@@ -23252,6 +23254,7 @@ function useChat(options) {
       defaultApiType,
       smoothing,
       preProcessors,
+      hooks,
       resolvedPiiRedaction,
       onPiiRedacted,
       resumable,
@@ -24212,6 +24215,7 @@ function useChatStorage(options) {
     embeddingModel = DEFAULT_API_EMBEDDING_MODEL,
     minContentLength = DEFAULT_MIN_CONTENT_LENGTH,
     preProcessors,
+    hooks,
     smoothing,
     resumable = false,
     onCancelResult,
@@ -24671,6 +24675,7 @@ function useChatStorage(options) {
     onError,
     apiType,
     preProcessors,
+    hooks,
     smoothing,
     resumable,
     onCancelResult,

package/dist/react/index.cjs

@@ -32345,6 +32345,7 @@ function useChat(options) {
     apiType: defaultApiType = "auto",
     smoothing,
     preProcessors,
+    hooks,
     piiRedaction,
     onPiiRedacted
   } = options || {};
@@ -32516,6 +32517,7 @@ function useChat(options) {
           onToolCallArgumentsDelta,
           onStepFinish,
           preProcessors,
+          hooks,
           piiRedaction: requestPiiRedaction ?? resolvedPiiRedaction,
           onPiiRedacted
         });
@@ -32553,6 +32555,7 @@ function useChat(options) {
       defaultApiType,
       smoothing,
       preProcessors,
+      hooks,
       resolvedPiiRedaction,
       onPiiRedacted
     ]
@@ -33767,6 +33770,7 @@ function useChatStorage(options) {
     minContentLength = DEFAULT_MIN_CONTENT_LENGTH,
     mcpR2Domain = MCP_R2_DOMAIN,
     preProcessors,
+    hooks,
     smoothing,
     piiRedaction,
     onPiiRedacted,
@@ -34341,6 +34345,7 @@ function useChatStorage(options) {
     onStreamMeta,
     apiType,
     preProcessors,
+    hooks,
     smoothing,
     piiRedaction: resolvedPiiRedaction,
     onPiiRedacted

package/dist/react/index.d.mts

@@ -2706,6 +2706,127 @@ declare class PiiRedactor {
     clear(): 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.
  *
@@ -2900,6 +3021,8 @@ type BaseSendMessageArgs = ResponsesApiOptions & {
 type BaseUseChatOptions = {
     getToken?: () => Promise<string | null>;
     baseUrl?: string;
+    /** Run lifecycle hooks for telemetry and tracing, for example from `createMetricsHooks` */
+    hooks?: RunHooks | RunHooks[];
     /**
      * Callback function to be called when a new data chunk is received.
      */
@@ -8691,6 +8814,8 @@ interface CreateConversationOptions {
  * @inline
  */
 interface BaseUseChatStorageOptions {
+    /** Run lifecycle hooks for telemetry and tracing, for example from `createMetricsHooks` */
+    hooks?: RunHooks | RunHooks[];
     /** WatermelonDB database instance for storing conversations and messages */
     database: Database;
     /** Route memory reads, writes, recall and the memory tools through this store instead of the database's vault; folders are unsupported. With `piiRedaction` on, build the store with `embeddingOptions.maskInput` (e.g. `(text) => redactor.maskText(text)` with any `PiiRedactor`) or its memory calls throw. */

package/dist/react/index.d.ts

@@ -2706,6 +2706,127 @@ declare class PiiRedactor {
     clear(): 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.
  *
@@ -2900,6 +3021,8 @@ type BaseSendMessageArgs = ResponsesApiOptions & {
 type BaseUseChatOptions = {
     getToken?: () => Promise<string | null>;
     baseUrl?: string;
+    /** Run lifecycle hooks for telemetry and tracing, for example from `createMetricsHooks` */
+    hooks?: RunHooks | RunHooks[];
     /**
      * Callback function to be called when a new data chunk is received.
      */
@@ -8691,6 +8814,8 @@ interface CreateConversationOptions {
  * @inline
  */
 interface BaseUseChatStorageOptions {
+    /** Run lifecycle hooks for telemetry and tracing, for example from `createMetricsHooks` */
+    hooks?: RunHooks | RunHooks[];
     /** WatermelonDB database instance for storing conversations and messages */
     database: Database;
     /** Route memory reads, writes, recall and the memory tools through this store instead of the database's vault; folders are unsupported. With `piiRedaction` on, build the store with `embeddingOptions.maskInput` (e.g. `(text) => redactor.maskText(text)` with any `PiiRedactor`) or its memory calls throw. */

package/dist/react/index.mjs

@@ -30435,6 +30435,7 @@ function useChat(options) {
     apiType: defaultApiType = "auto",
     smoothing,
     preProcessors,
+    hooks,
     piiRedaction,
     onPiiRedacted
   } = options || {};
@@ -30606,6 +30607,7 @@ function useChat(options) {
           onToolCallArgumentsDelta,
           onStepFinish,
           preProcessors,
+          hooks,
           piiRedaction: requestPiiRedaction ?? resolvedPiiRedaction,
           onPiiRedacted
         });
@@ -30643,6 +30645,7 @@ function useChat(options) {
       defaultApiType,
       smoothing,
       preProcessors,
+      hooks,
       resolvedPiiRedaction,
       onPiiRedacted
     ]
@@ -31847,6 +31850,7 @@ function useChatStorage(options) {
     minContentLength = DEFAULT_MIN_CONTENT_LENGTH,
     mcpR2Domain = MCP_R2_DOMAIN,
     preProcessors,
+    hooks,
     smoothing,
     piiRedaction,
     onPiiRedacted,
@@ -32421,6 +32425,7 @@ function useChatStorage(options) {
     onStreamMeta,
     apiType,
     preProcessors,
+    hooks,
     smoothing,
     piiRedaction: resolvedPiiRedaction,
     onPiiRedacted

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anuma/sdk",
-  "version": "6.39.1",
+  "version": "6.39.2",
   "description": "",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",