@tanstack/ai 0.47.3 → 0.49.1

package/src/activities/chat/tools/tool-calls.ts

@@ -1,4 +1,6 @@
 import { normalizeToolResult } from '../../../utilities/tool-result'
+import { tanstackMetadata } from '../../../utilities/merge-metadata'
+import type { AdapterYieldChunk } from '../../../utilities/adapter-yield-chunk'
 import { isStandardSchema, parseWithStandardSchema } from './schema-converter'
 import type { ToolApprovalResolution } from '../../../interrupts'
 import type {
@@ -231,10 +233,8 @@ export class ToolCallManager<
    * Add a TOOL_CALL_START event to begin tracking a tool call (AG-UI)
    */
   addToolCallStartEvent(event: ToolCallStartEvent): void {
-    const index = event.index ?? this.toolCallsMap.size
-    const runtimeEvent = event as Partial<ToolCallStartEvent> &
-      Pick<ToolCallStartEvent, 'toolName'>
-    const name = runtimeEvent.toolCallName ?? runtimeEvent.toolName
+    const index = (event as AdapterYieldChunk).index ?? this.toolCallsMap.size
+    const name = event.toolCallName ?? event.toolName
     this.toolCallsMap.set(index, {
       id: event.toolCallId,
       type: 'function',
@@ -250,10 +250,14 @@ export class ToolCallManager<
    * Add a TOOL_CALL_ARGS event to accumulate arguments (AG-UI)
    */
   addToolCallArgsEvent(event: ToolCallArgsEvent): void {
-    // Find the tool call by ID
+    const extra = event as AdapterYieldChunk
     for (const [, toolCall] of this.toolCallsMap.entries()) {
       if (toolCall.id === event.toolCallId) {
-        toolCall.function.arguments += event.delta
+        if (typeof extra.args === 'string' && extra.args !== '') {
+          toolCall.function.arguments = extra.args
+        } else {
+          toolCall.function.arguments += event.delta
+        }
         break
       }
     }
@@ -264,16 +268,13 @@ export class ToolCallManager<
    * Called when TOOL_CALL_END is received
    */
   completeToolCall(event: ToolCallEndEvent): void {
-    for (const [, toolCall] of this.toolCallsMap.entries()) {
-      if (toolCall.id === event.toolCallId) {
-        if (event.input !== undefined) {
-          // Normalize null/non-object to {} (e.g. Anthropic empty tool_use blocks)
-          const normalized =
-            event.input && typeof event.input === 'object' ? event.input : {}
-          toolCall.function.arguments = JSON.stringify(normalized)
-        }
-        break
-      }
+    for (const toolCall of this.toolCallsMap.values()) {
+      if (toolCall.id !== event.toolCallId) continue
+      if (event.input === undefined) return
+      const normalized =
+        event.input && typeof event.input === 'object' ? event.input : {}
+      toolCall.function.arguments = JSON.stringify(normalized)
+      return
     }
   }
 
@@ -301,7 +302,7 @@ export class ToolCallManager<
   async *executeTools(
     finishEvent: RunFinishedEvent,
     ...contextArgs: ExecuteToolsContextArgs<TContext>
-  ): AsyncGenerator<ToolCallEndEvent, Array<ModelMessage>, void> {
+  ): AsyncGenerator<AdapterYieldChunk, Array<ModelMessage>, void> {
     const toolCallsArray = this.getToolCalls()
     const toolResults: Array<ModelMessage> = []
     const hasRuntimeContext = contextArgs.length > 0
@@ -313,9 +314,6 @@ export class ToolCallManager<
       let toolResultContent: string | Array<ContentPart>
       let toolResultState: ToolOutputState | undefined
       // Holds the parsed/validated execution output before serialization.
-      // Surfaced on the emitted `TOOL_CALL_END` event as `output` so
-      // consumers can read it typed (via `TypedStreamChunk` distribution
-      // over the tools array) without re-parsing `result`.
       // Stays `undefined` when the tool has no `execute` (client-only
       // tools) or when execution throws.
       let toolOutput: unknown
@@ -397,7 +395,10 @@ export class ToolCallManager<
         toolCallId: toolCall.id,
         toolCallName: toolCall.function.name,
         toolName: toolCall.function.name,
-        model: finishEvent.model,
+        model: (() => {
+          const model = tanstackMetadata(finishEvent)?.model
+          return typeof model === 'string' ? model : undefined
+        })(),
         timestamp: Date.now(),
         // Typed parsed output (undefined for failed exec / client-only tools).
         ...(toolOutput !== undefined ? { output: toolOutput } : {}),
@@ -433,7 +434,7 @@ export interface ToolResult {
   duration?: number
   /**
    * Parsed tool input (after JSON parse + optional Standard Schema validation).
-   * Surfaced on engine-emitted `TOOL_CALL_END` events for TypedStreamChunk consumers.
+   * Parsed tool input after JSON parse + optional Standard Schema validation.
    */
   input?: unknown
   /**

package/src/activities/generateVideo/index.ts

@@ -33,6 +33,8 @@ import type {
   GenerationMiddlewareContext,
 } from '../middleware/types'
 import type { VideoAdapter } from './adapter'
+import { normalizeStreamChunk } from '../../utilities/normalize-stream-chunk'
+import type { AdapterYieldChunk } from '../../utilities/adapter-yield-chunk'
 import type {
   MediaPrompt,
   MediaPromptFor,
@@ -728,13 +730,13 @@ async function* runStreamingVideoGeneration<
           timestamp: Date.now(),
         }
 
-        yield {
+        yield* normalizeStreamChunk({
           type: 'RUN_FINISHED',
           runId,
           threadId: wireThreadId,
           finishReason: 'stop',
           timestamp: Date.now(),
-        } as StreamChunk
+        } as AdapterYieldChunk)
         return
       }
 
@@ -768,15 +770,14 @@ async function* runStreamingVideoGeneration<
       code: payload.code,
       source: 'generateVideo',
     })
-    yield {
+    yield* normalizeStreamChunk({
       type: 'RUN_ERROR',
       runId,
       threadId: wireThreadId,
       message: payload.message,
-      code: payload.code,
-      error: payload,
+      ...(payload.code !== undefined ? { code: payload.code } : {}),
       timestamp: Date.now(),
-    } as StreamChunk
+    } as AdapterYieldChunk)
   } finally {
     abortControls.clear()
     if (!settled) {

package/src/activities/stream-generation-result.ts

@@ -7,6 +7,7 @@
 import { EventType } from '@ag-ui/core'
 import { toRunErrorPayload } from './error-payload'
 import type { StreamChunk } from '../types'
+import { normalizeStreamChunk } from '../utilities/normalize-stream-chunk'
 
 function createId(prefix: string): string {
   return `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`
@@ -74,31 +75,26 @@ export async function* streamGenerationResult<TResult>(
       timestamp: Date.now(),
     }
 
-    yield {
+    yield* normalizeStreamChunk({
       type: EventType.RUN_FINISHED,
       runId,
       threadId,
       finishReason: 'stop',
       timestamp: Date.now(),
-    }
+    })
   } catch (error: unknown) {
     const payload = toRunErrorPayload(error, 'Generation failed')
     // `code` is omitted entirely when undefined so the event matches the
-    // AG-UI `code?: string` shape under `exactOptionalPropertyTypes`. The
-    // deprecated nested `error` form preserves the same conditional
-    // structure for backward compatibility.
+    // AG-UI `code?: string` shape under `exactOptionalPropertyTypes`.
     const codeFields =
       payload.code !== undefined ? { code: payload.code } : undefined
-    yield {
+    yield* normalizeStreamChunk({
       type: EventType.RUN_ERROR,
+      runId,
+      threadId,
       message: payload.message,
       ...codeFields,
-      // Deprecated nested form for backward compatibility
-      error: {
-        message: payload.message,
-        ...codeFields,
-      },
       timestamp: Date.now(),
-    }
+    })
   }
 }

package/src/activities/summarize/chat-stream-summarize.ts

@@ -1,14 +1,58 @@
 import { EventType } from '@ag-ui/core'
 import { toRunErrorPayload } from '../error-payload'
 import { MAX_TOKENS_KEYS } from '../../utilities/sampling-keys'
+import { rebuildTokenUsage } from '../../utilities/ag-ui-usage'
+import type { AdapterYieldChunk } from '../../utilities/adapter-yield-chunk'
+import { tanstackMetadata } from '../../utilities/merge-metadata'
+import { normalizeStreamChunk } from '../../utilities/normalize-stream-chunk'
 import { BaseSummarizeAdapter } from './adapter'
 import type {
   StreamChunk,
   SummarizationOptions,
   SummarizationResult,
   TextOptions,
+  TokenUsage,
 } from '../../types'
 
+function consumeSpecSummarizeChunk(
+  chunk: StreamChunk,
+  state: { summary: string; model: string; usage: TokenUsage },
+): void {
+  if (chunk.type === EventType.TEXT_MESSAGE_CONTENT) {
+    if (chunk.delta) state.summary += chunk.delta
+    return
+  }
+
+  const tanstack = tanstackMetadata(chunk)
+  if (
+    (chunk.type === EventType.RUN_STARTED ||
+      chunk.type === EventType.RUN_FINISHED ||
+      chunk.type === EventType.TEXT_MESSAGE_START) &&
+    typeof tanstack?.model === 'string'
+  ) {
+    state.model = tanstack.model
+  }
+
+  if (chunk.type === EventType.RUN_FINISHED) {
+    const rebuilt = rebuildTokenUsage(chunk.usage, tanstack?.usage)
+    if (rebuilt) state.usage = rebuilt
+  }
+}
+
+function throwRunError(
+  chunk: Extract<StreamChunk, { type: 'RUN_ERROR' }>,
+): never {
+  const message =
+    typeof chunk.message === 'string' && chunk.message.length > 0
+      ? chunk.message
+      : 'Summarization failed'
+  const err = new Error(message)
+  if (typeof chunk.code === 'string') {
+    ;(err as Error & { code?: string }).code = chunk.code
+  }
+  throw err
+}
+
 /**
  * Minimal contract for a text adapter that supports `chatStream`. Lets
  * `ChatStreamSummarizeAdapter` work with any text adapter without coupling
@@ -21,7 +65,7 @@ import type {
  * `SummarizationOptions<TProviderOptions>` on the wrapper itself.
  */
 export interface ChatStreamCapable {
-  chatStream: (options: TextOptions<any>) => AsyncIterable<StreamChunk>
+  chatStream: (options: TextOptions<any>) => AsyncIterable<AdapterYieldChunk>
 }
 
 /**
@@ -201,10 +245,12 @@ export class ChatStreamSummarizeAdapter<
   ): Promise<SummarizationResult> {
     const systemPrompt = this.buildSummarizationPrompt(options)
 
-    let summary = ''
     const id = this.generateId()
-    let model = options.model
-    let usage = { promptTokens: 0, completionTokens: 0, totalTokens: 0 }
+    const state = {
+      summary: '',
+      model: options.model,
+      usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
+    }
 
     options.logger.request(
       `activity=summarize provider=${this.name} model=${options.model} text-length=${options.text.length} maxLength=${options.maxLength ?? 'unset'}`,
@@ -212,41 +258,15 @@ export class ChatStreamSummarizeAdapter<
     )
 
     try {
-      for await (const chunk of this.textAdapter.chatStream(
+      for await (const raw of this.textAdapter.chatStream(
         this.buildTextOptions(options, systemPrompt),
       )) {
-        if (chunk.type === 'TEXT_MESSAGE_CONTENT') {
-          if (chunk.content) {
-            summary = chunk.content
-          } else if (chunk.delta) {
-            // Append delta only when present — a content-less chunk with no
-            // delta would otherwise concat literal `'undefined'`.
-            summary += chunk.delta
-          }
-          model = chunk.model || model
-        }
-        if (chunk.type === 'RUN_FINISHED') {
-          if (chunk.usage) {
-            usage = chunk.usage
-          }
-        }
-        // Surface failures: the underlying chatStream emits RUN_ERROR instead
-        // of throwing, so without this branch summarize() would return an
-        // empty summary and pretend a failed run succeeded.
-        if (chunk.type === 'RUN_ERROR') {
-          const message =
-            (chunk.error && typeof chunk.error.message === 'string'
-              ? chunk.error.message
-              : null) ?? 'Summarization failed'
-          const code =
-            chunk.error && typeof chunk.error.code === 'string'
-              ? chunk.error.code
-              : undefined
-          const err = new Error(message)
-          if (code) {
-            ;(err as Error & { code?: string }).code = code
-          }
-          throw err
+        for (const chunk of normalizeStreamChunk(raw as AdapterYieldChunk)) {
+          // Surface failures: the underlying chatStream emits RUN_ERROR instead
+          // of throwing, so without this branch summarize() would return an
+          // empty summary and pretend a failed run succeeded.
+          if (chunk.type === EventType.RUN_ERROR) throwRunError(chunk)
+          consumeSpecSummarizeChunk(chunk, state)
         }
       }
     } catch (error: unknown) {
@@ -259,7 +279,12 @@ export class ChatStreamSummarizeAdapter<
       throw error
     }
 
-    return { id, model, summary, usage }
+    return {
+      id,
+      model: state.model,
+      summary: state.summary,
+      usage: state.usage,
+    }
   }
 
   override async *summarizeStream(
@@ -273,46 +298,45 @@ export class ChatStreamSummarizeAdapter<
     )
 
     const id = this.generateId()
-    let summary = ''
-    let model = options.model
-    let usage: SummarizationResult['usage'] = {
-      promptTokens: 0,
-      completionTokens: 0,
-      totalTokens: 0,
+    const state = {
+      summary: '',
+      model: options.model,
+      usage: {
+        promptTokens: 0,
+        completionTokens: 0,
+        totalTokens: 0,
+      } satisfies SummarizationResult['usage'],
     }
 
     try {
-      for await (const chunk of this.textAdapter.chatStream(
+      for await (const raw of this.textAdapter.chatStream(
         this.buildTextOptions(options, systemPrompt),
       )) {
-        // Accumulate the same way `summarize()` does so consumers see deltas
-        // AND the terminal `generation:result` event below carries the same
-        // final summary that non-streaming returns.
-        if (chunk.type === 'TEXT_MESSAGE_CONTENT') {
-          if (chunk.content) {
-            summary = chunk.content
-          } else if (chunk.delta) {
-            summary += chunk.delta
+        for (const chunk of normalizeStreamChunk(raw as AdapterYieldChunk)) {
+          // Accumulate the same way `summarize()` does so consumers see deltas
+          // AND the terminal `generation:result` event below carries the same
+          // final summary that non-streaming returns.
+          consumeSpecSummarizeChunk(chunk, state)
+
+          // Emit the GenerationClient-shaped result event just before the
+          // terminal RUN_FINISHED so subscribers (useSummarize) populate
+          // `result` before flipping `status` to success.
+          if (chunk.type === EventType.RUN_FINISHED) {
+            yield {
+              type: EventType.CUSTOM,
+              name: 'generation:result',
+              value: {
+                id,
+                model: state.model,
+                summary: state.summary,
+                usage: state.usage,
+              } satisfies SummarizationResult,
+              timestamp: Date.now(),
+            }
           }
-          if (chunk.model) model = chunk.model
-        }
 
-        // Emit the GenerationClient-shaped result event just before the
-        // terminal RUN_FINISHED so subscribers (useSummarize) populate
-        // `result` before flipping `status` to success.
-        if (chunk.type === 'RUN_FINISHED') {
-          if (chunk.usage) usage = chunk.usage
-          if (chunk.model) model = chunk.model
-          yield {
-            type: EventType.CUSTOM,
-            name: 'generation:result',
-            value: { id, model, summary, usage } satisfies SummarizationResult,
-            model,
-            timestamp: Date.now(),
-          }
+          yield chunk
         }
-
-        yield chunk
       }
     } catch (error: unknown) {
       options.logger.errors(`${this.name}.summarizeStream fatal`, {

package/src/adapter-internals.ts

@@ -57,3 +57,5 @@ export {
   structuredOutputCompleteChunk,
   structuredOutputStartChunk,
 } from './utilities/structured-output-events'
+export { tanstackMetadata } from './utilities/merge-metadata'
+export { isSpecTopLevelKey } from './utilities/spec-event-keys'

package/src/byok/define-provider.ts

@@ -0,0 +1,46 @@
+import { isProviderId } from './providers'
+
+/**
+ * A BYOK provider declared by an adapter. `id` is the `x-byok-<id>` slug and
+ * is required — `{ id?: string }` is not a {@link ByokProvider}.
+ */
+export interface ByokProvider<TId extends string = string> {
+  readonly id: TId
+  readonly label: string
+  /**
+   * Env var names the relay may read. Names only — never put `process.env`
+   * values here. This object is imported on the client.
+   */
+  readonly env?: ReadonlyArray<string>
+}
+
+/**
+ * Input for {@link defineByokProvider}. `id` cannot be optional: if `TId`
+ * includes `undefined`, `id` becomes `never` and the object is unassignable.
+ */
+export type ByokProviderInit<TId extends string> = {
+  readonly id: undefined extends TId ? never : TId
+  readonly label: string
+  readonly env?: string | ReadonlyArray<string>
+}
+
+function normalizeEnv(
+  env: string | ReadonlyArray<string> | undefined,
+): ReadonlyArray<string> | undefined {
+  if (env === undefined) return undefined
+  return typeof env === 'string' ? [env] : env
+}
+
+export function defineByokProvider<const TId extends string>(
+  provider: ByokProviderInit<TId>,
+): ByokProvider<TId> {
+  if (!isProviderId(provider.id)) {
+    throw new Error(`Invalid BYOK provider id: ${String(provider.id)}`)
+  }
+  const env = normalizeEnv(provider.env)
+  return {
+    id: provider.id,
+    label: provider.label,
+    ...(env ? { env } : {}),
+  }
+}

package/src/byok/errors.ts

@@ -0,0 +1,36 @@
+import type { ProviderId } from './providers'
+
+export class ByokMissingError extends Error {
+  readonly provider: ProviderId
+
+  constructor(provider: ProviderId) {
+    super(`Missing ${provider} API key`)
+    this.name = 'ByokMissingError'
+    this.provider = provider
+  }
+}
+
+export class ByokBlockedError extends Error {
+  readonly provider: ProviderId
+  readonly reason: 'missing' | 'locked'
+
+  constructor(provider: ProviderId, reason: 'missing' | 'locked') {
+    super(
+      reason === 'locked'
+        ? `${provider} key is locked`
+        : `Missing ${provider} API key`,
+    )
+    this.name = 'ByokBlockedError'
+    this.provider = provider
+    this.reason = reason
+  }
+}
+
+export class ByokUnresolvedProviderError extends Error {
+  constructor() {
+    super(
+      'BYOK is enabled but no provider slug was resolved. Pass byokProvider or forwardedProps.provider.',
+    )
+    this.name = 'ByokUnresolvedProviderError'
+  }
+}

package/src/byok/get-key.ts

@@ -0,0 +1,27 @@
+import { byokHeaderName, resolveProviderId } from './providers'
+import type { ByokProvider } from './define-provider'
+import type { ProviderId } from './providers'
+
+/**
+ * Read a key on the relay. Import from `@tanstack/ai/byok/server` so this
+ * `process.env` access is not in the client graph.
+ *
+ * The header wins. A {@link ByokProvider} then tries `provider.env` in order.
+ * A slug is header-only.
+ */
+export function getByokKey(
+  request: Request,
+  provider: ProviderId | ByokProvider,
+): string | null {
+  const value = request.headers.get(byokHeaderName(resolveProviderId(provider)))
+  if (typeof value === 'string') {
+    const trimmed = value.trim()
+    if (trimmed.length > 0) return trimmed
+  }
+  if (typeof provider === 'string') return null
+  for (const name of provider.env ?? []) {
+    const envValue = process.env[name]
+    if (typeof envValue === 'string' && envValue.length > 0) return envValue
+  }
+  return null
+}

package/src/byok/missing.ts

@@ -0,0 +1,43 @@
+import { isProviderId, resolveProviderId } from './providers'
+import type { ByokProvider } from './define-provider'
+import type { ProviderId } from './providers'
+
+export interface ByokMissingBody {
+  error: {
+    type: 'byok_missing'
+    provider: ProviderId
+    message: string
+  }
+}
+
+export function isByokMissingBody(value: unknown): value is ByokMissingBody {
+  if (typeof value !== 'object' || value === null) return false
+  if (!('error' in value)) return false
+  const error = value.error
+  if (typeof error !== 'object' || error === null) return false
+  if (!('type' in error) || error.type !== 'byok_missing') return false
+  if (!('provider' in error) || typeof error.provider !== 'string') {
+    return false
+  }
+  if (!isProviderId(error.provider)) return false
+  if (!('message' in error) || typeof error.message !== 'string') return false
+  return true
+}
+
+export function byokMissing(provider: ProviderId | ByokProvider): Response {
+  const id = resolveProviderId(provider)
+  if (!isProviderId(id)) {
+    throw new Error(`Invalid BYOK provider id: ${id}`)
+  }
+  const body: ByokMissingBody = {
+    error: {
+      type: 'byok_missing',
+      provider: id,
+      message: `Missing ${id} API key`,
+    },
+  }
+  return new Response(JSON.stringify(body), {
+    status: 401,
+    headers: { 'content-type': 'application/json' },
+  })
+}

package/src/byok/providers.ts

@@ -0,0 +1,27 @@
+/**
+ * Provider ids are open slugs, not a closed catalog. `@tanstack/ai` does not
+ * list adapters. Any matching string is a valid id and becomes `x-byok-<id>`.
+ */
+export type ProviderId = string
+
+/** `[a-z][a-z0-9-]{0,63}` — lowercase, no underscores, max 64 chars. */
+export const BYOK_PROVIDER_ID_PATTERN = /^[a-z][a-z0-9-]{0,63}$/
+
+export const BYOK_HEADER_PREFIX = 'x-byok-'
+
+export function isProviderId(value: unknown): value is ProviderId {
+  return typeof value === 'string' && BYOK_PROVIDER_ID_PATTERN.test(value)
+}
+
+export function resolveProviderId(
+  provider: string | { readonly id: string },
+): string {
+  return typeof provider === 'string' ? provider : provider.id
+}
+
+export function byokHeaderName(provider: string): string {
+  if (!isProviderId(provider)) {
+    throw new Error(`Invalid BYOK provider id: ${provider}`)
+  }
+  return `${BYOK_HEADER_PREFIX}${provider}`
+}

package/src/byok/scrub.ts

@@ -0,0 +1,16 @@
+export function maskKey(key: string): string {
+  if (key.length <= 4) return '••'
+  return key.slice(-4)
+}
+
+export function scrubSecrets(
+  input: string,
+  secrets: ReadonlyArray<string>,
+): string {
+  let next = input
+  for (const secret of secrets) {
+    if (secret.length === 0) continue
+    next = next.split(secret).join('[redacted]')
+  }
+  return next
+}

package/src/byok/server.ts

@@ -0,0 +1,3 @@
+export { getByokKey } from './get-key'
+export { byokMissing, isByokMissingBody } from './missing'
+export type { ByokMissingBody } from './missing'

package/src/byok.ts

@@ -0,0 +1,17 @@
+export {
+  BYOK_PROVIDER_ID_PATTERN,
+  BYOK_HEADER_PREFIX,
+  byokHeaderName,
+  isProviderId,
+} from './byok/providers'
+export type { ProviderId } from './byok/providers'
+export { defineByokProvider } from './byok/define-provider'
+export type { ByokProvider, ByokProviderInit } from './byok/define-provider'
+export { isByokMissingBody, byokMissing } from './byok/missing'
+export type { ByokMissingBody } from './byok/missing'
+export {
+  ByokMissingError,
+  ByokBlockedError,
+  ByokUnresolvedProviderError,
+} from './byok/errors'
+export { maskKey, scrubSecrets } from './byok/scrub'

package/src/client.ts

@@ -297,6 +297,17 @@ export type {
 } from './activities/chat/stream/index'
 
 export { uiMessagesToWire } from './utilities/ag-ui-wire'
+export {
+  mergeMetadata,
+  tanstackMetadata,
+  withTanstackMetadata,
+} from './utilities/merge-metadata'
+export { fromSpecTokenUsage, toSpecTokenUsage } from './utilities/ag-ui-usage'
+export type { SpecTokenUsage } from './utilities/ag-ui-usage'
+export { normalizeStreamChunk } from './utilities/normalize-stream-chunk'
+export { restoreInboundChunk } from './utilities/restore-inbound-chunk'
+export type { AdapterYieldChunk } from './utilities/adapter-yield-chunk'
+export { getChunkRunId, getChunkThreadId } from './utilities/chunk-ids'
 export type { WireMessage } from './utilities/ag-ui-wire'
 
 export type {
@@ -326,6 +337,8 @@ export type {
   StreamChunk,
   StructuredOutputPart,
   TextPart,
+  TanStackMessageMetadata,
+  TanStackRunMetadata,
   ThinkingPart,
   ToolCall,
   ToolCallPart,