@tanstack/ai-client 0.31.1 → 0.32.1

package/src/chat-client.ts

@@ -14,6 +14,7 @@ import {
   ByokMissingError,
   ByokUnresolvedProviderError,
 } from '@tanstack/ai/byok'
+import { byokFallbackProviderId } from './byok/client'
 import {
   prepareResolvedByokHeaders,
   resolveByokProviderId,
@@ -39,6 +40,7 @@ import type {
 } from '@tanstack/ai/client'
 import type { ByokClient } from './byok'
 import type {
+  ChatHydrateOptions,
   ChatHydrationResult,
   ConnectionAdapter,
   SubscribeConnectionAdapter,
@@ -330,6 +332,9 @@ const REJOIN_REBUILD_TRIGGERS = new Set<string>([
   'MESSAGES_SNAPSHOT',
 ])
 
+// Cap parent-chain walks so a cyclic replayed parentRunId cannot loop.
+const MAX_RUN_LINEAGE_DEPTH = 64
+
 export class ChatClient<
   TTools extends ReadonlyArray<AnyClientTool> = any,
   TContext = unknown,
@@ -352,6 +357,9 @@ export class ChatClient<
   // run, so approvals/client-tool results can be sent back. Cleared when the
   // run terminates. This is STATE (interrupt) resume, not delivery/cursor.
   private lastResume: ChatResumeState | null = null
+  // Replay can deliver a parent pause after a descendant already finished.
+  private readonly runParents = new Map<string, string>()
+  private readonly supersededInterruptRunIds = new Set<string>()
   // The in-flight run id already handed to `resumeInFlightRun`, so a persisted
   // run is rejoined at most once even when both the sync read and the async
   // hydrate surface the same resume pointer.
@@ -456,6 +464,16 @@ export class ChatClient<
   /** Constructor inputs `attach()` needs on every re-attach, not just the first. */
   private readonly rejoinRunId: string | null | undefined
   private readonly cachesMessages: boolean
+  /**
+   * Newest-window size from `history.pageSize`. Only set when
+   * `persistence === true`.
+   */
+  private readonly historyPageSize: number | undefined
+  private hasOlderMessages = false
+  private olderMessagesCursor: string | undefined
+  private readonly knownServerMessageIds = new Set<string>()
+  private loadOlderMessagesInFlight = false
+  private historyGeneration = 0
   private devtoolsMounted = false
 
   private readonly callbacksRef: {
@@ -511,6 +529,7 @@ export class ChatClient<
         )
       }
       cachesMessages = false
+      this.historyPageSize = options.history?.pageSize
     } else if (options.persistence) {
       // A storage adapter: keep the combined record (transcript + resume pointer)
       // in the browser. Persistence keys on `threadId` (the conversation
@@ -526,6 +545,9 @@ export class ChatClient<
         (messages) => this.processor.setMessages(messages),
         (snapshot) => this.applyPersistedResume(snapshot),
       )
+      this.historyPageSize = undefined
+    } else {
+      this.historyPageSize = undefined
     }
     // Both `body` (deprecated) and `forwardedProps` populate the AG-UI
     // `RunAgentInput.forwardedProps` wire field. They are stored
@@ -1038,13 +1060,18 @@ export class ChatClient<
     if (!hydrate) return
     if (this.isLoading || this.abortController) return
     if (this.disposed) return
+    const pageSize = this.historyPageSize
+    const hydrateOptions: ChatHydrateOptions | undefined =
+      pageSize === undefined ? undefined : { limit: pageSize }
     void (async () => {
       let result: ChatHydrationResult
+      const generation = this.historyGeneration
       try {
-        result = await hydrate(this.threadId)
+        result = await hydrate(this.threadId, hydrateOptions)
       } catch {
         return
       }
+      if (generation !== this.historyGeneration) return
       // NO VIEW IS WATCHING ANY MORE (it unmounted while this fetch was in
       // flight). Applying anything now is pointless, and one thing is actively
       // harmful: the branch below calls `maybeRejoinInFlight`, which opens a TAIL.
@@ -1057,8 +1084,11 @@ export class ChatClient<
       if (this.disposed || !this.tailing) return
       // A send may have started while the fetch was in flight — don't stomp it.
       if (this.isLoading || this.abortController) return
+      this.applyHydrationPage(result.page)
       if (result.messages.length > 0) {
-        this.processor.setMessages(normalizeMessagesDates(result.messages))
+        const windowMessages = normalizeMessagesDates(result.messages)
+        this.processor.setMessages(windowMessages)
+        this.rememberServerMessageIds(windowMessages)
       }
       if (result.interrupts && result.interrupts.pending.length > 0) {
         // Pending interrupt = the thread is paused awaiting a human decision, so
@@ -1134,14 +1164,30 @@ export class ChatClient<
   ): void {
     if (chunk.type === 'RUN_STARTED') {
       const chunkRunId = getChunkRunId(chunk) ?? chunk.runId
+      const parentRunId =
+        'parentRunId' in chunk && typeof chunk.parentRunId === 'string'
+          ? chunk.parentRunId
+          : undefined
+      if (parentRunId) {
+        this.runParents.set(chunkRunId, parentRunId)
+        if (this.supersededInterruptRunIds.has(chunkRunId)) {
+          this.markLineageAnswered(parentRunId)
+        }
+      }
       this.activeResumeThreadId =
         'threadId' in chunk && typeof chunk.threadId === 'string'
           ? chunk.threadId
           : this.activeResumeThreadId
       this.activeResumeRunId = chunkRunId
-      this.activeRunIds.add(chunkRunId)
-      this.clearedStreamTracker.onRunStarted(chunkRunId)
-      this.setSessionGenerating(true)
+      // Late RUN_STARTED for a run that already finished is replay, not a live
+      // turn. A new send can reuse a finished run id while isLoading is true.
+      const isAnsweredReplayStart =
+        this.supersededInterruptRunIds.has(chunkRunId) && !this.isLoading
+      if (!isAnsweredReplayStart) {
+        this.activeRunIds.add(chunkRunId)
+        this.clearedStreamTracker.onRunStarted(chunkRunId)
+        this.setSessionGenerating(true)
+      }
       // Persist a live-run resume snapshot so a full page reload can rejoin this
       // in-flight run via joinRun. Only a persistor writes it, and a persistor
       // exists only in client-authoritative mode; server-authoritative reconnect
@@ -1149,12 +1195,25 @@ export class ChatClient<
       // client-cached run pointer (which goes stale the moment a turn spans a
       // second run) is ever written. Interrupt/terminal handling overwrites or
       // clears it in observeInterruptState.
-      if (this.persistor && this.connection.joinRun && !this.lastResume) {
+      if (
+        this.persistor &&
+        this.connection.joinRun &&
+        !this.lastResume &&
+        !isAnsweredReplayStart
+      ) {
         this.persistResumeSnapshot({
           threadId: this.activeResumeThreadId ?? this.threadId,
           runId: chunkRunId,
         })
       }
+      if (
+        this.lastResume &&
+        this.supersededInterruptRunIds.has(this.lastResume.runId)
+      ) {
+        this.lastResume = null
+        this.persistor?.persistResumeSnapshot(null)
+        this.interruptManager.reset()
+      }
       return
     }
 
@@ -1199,11 +1258,29 @@ export class ChatClient<
         ? chunk.threadId
         : this.activeResumeThreadId
 
+    // Record answered lineage before hydrating a pause. Intermediate
+    // tool_calls RUN_FINISHED is a mid-turn handoff, not an answered pause.
+    if (
+      runId &&
+      !isIntermediateToolTurn(chunk) &&
+      (chunk.type === 'RUN_ERROR' ||
+        (chunk.type === 'RUN_FINISHED' && chunk.outcome?.type !== 'interrupt'))
+    ) {
+      this.markLineageAnswered(runId)
+    }
+
     if (chunk.type === 'RUN_FINISHED' && chunk.outcome?.type === 'interrupt') {
       // Track the REQUEST run id (what the client sent) so a resume targets the
       // same run even when provider events carry their own run id.
       const interruptedRunId =
         this.currentRunId ?? runId ?? this.activeResumeRunId ?? ''
+      // Replay re-emits a pause that a continuation already answered.
+      if (
+        interruptedRunId &&
+        this.supersededInterruptRunIds.has(interruptedRunId)
+      ) {
+        return
+      }
       this.lastResume = {
         threadId: threadId ?? this.threadId,
         runId: interruptedRunId,
@@ -1248,13 +1325,20 @@ export class ChatClient<
       chunk.type === 'RUN_FINISHED' &&
       chunk.outcome?.type !== 'interrupt',
     )
+    // Replay can deliver a parent pause after a descendant already finished,
+    // and this terminal's run id may not match lastResume.
+    const isLineageDescendantTerminal = Boolean(
+      this.lastResume &&
+      this.supersededInterruptRunIds.has(this.lastResume.runId),
+    )
     if (
       isRunlessSessionError ||
       isTrackedRunTerminal ||
       isCurrentRunTerminal ||
       isActiveStreamRunTerminal ||
       isCurrentStreamTerminal ||
-      isActiveInterruptSubmissionTerminal
+      isActiveInterruptSubmissionTerminal ||
+      isLineageDescendantTerminal
     ) {
       this.lastResume = null
       // Run settled without an interrupt: drop the durable resume snapshot so a
@@ -1266,6 +1350,18 @@ export class ChatClient<
     this.notifyResumeStateChange('live')
   }
 
+  /** Walk parentRunId links and mark this run plus its ancestors as answered. */
+  private markLineageAnswered(runId: string): void {
+    let current: string | undefined = runId
+    let hops = 0
+    while (current !== undefined && hops < MAX_RUN_LINEAGE_DEPTH) {
+      if (this.supersededInterruptRunIds.has(current)) return
+      this.supersededInterruptRunIds.add(current)
+      current = this.runParents.get(current)
+      hops++
+    }
+  }
+
   /**
    * The interrupt-resume state for the active/interrupted run (its run/thread
    * ids), or null when there is nothing to resume. Apps can persist this to
@@ -2262,7 +2358,7 @@ export class ChatClient<
 
     try {
       // Get UIMessages with parts (preserves approval state and client tool results)
-      const messages = this.processor.getMessages()
+      const messages = this.messagesForSend(this.processor.getMessages())
       const clientTools = new Map(this.clientToolsRef.current)
       const runtimeContext = this.context
 
@@ -2327,6 +2423,7 @@ export class ChatClient<
         const provider = resolveByokProviderId(
           this.byokProvider,
           mergedBody.provider,
+          byokFallbackProviderId(this.byok),
         )
         byokHeaders = await prepareResolvedByokHeaders(this.byok, provider)
       }
@@ -2484,6 +2581,7 @@ export class ChatClient<
         await this.drainPostStreamActions()
 
         if (streamCompletedSuccessfully) {
+          this.rememberProcessorMessageIds()
           if (this.status !== 'ready') {
             // Terminal run, but onStreamEnd never fired: the processor had
             // no assistant message to emit it for (e.g. a bare
@@ -2614,6 +2712,7 @@ export class ChatClient<
     // remove the stored conversation outright.
     this.persistor?.beginClear()
     this.processor.clearMessages()
+    this.resetHistoryPaging()
     this.discardPendingSends()
     this.persistor?.remove()
     this.lastResume = null
@@ -2875,6 +2974,108 @@ export class ChatClient<
     return this.processor.getMessages() as Array<UIMessage<TTools>>
   }
 
+  /**
+   * True when the last hydrate or older-page response said more messages exist.
+   */
+  getHasOlderMessages() {
+    return this.hasOlderMessages
+  }
+
+  /**
+   * Fetch the next older window and put it in front of the painted messages.
+   *
+   * No-op when there is no older page, no cursor, or a page load is already
+   * running. A network failure rejects and leaves the painted messages as they
+   * are; {@link getHasOlderMessages} stays true.
+   */
+  async loadOlderMessages() {
+    const hydrate = this.connection.hydrate
+    if (hydrate === undefined) return
+    if (this.disposed) return
+    if (!this.hasOlderMessages) return
+    const cursor = this.olderMessagesCursor
+    if (cursor === undefined) return
+    if (this.loadOlderMessagesInFlight) return
+
+    const hydrateOptions: ChatHydrateOptions = { before: cursor }
+    if (this.historyPageSize !== undefined) {
+      hydrateOptions.limit = this.historyPageSize
+    }
+
+    this.loadOlderMessagesInFlight = true
+    const generation = this.historyGeneration
+    try {
+      const result = await hydrate(this.threadId, hydrateOptions)
+      if (this.disposed) return
+      if (generation !== this.historyGeneration) return
+      const olderMessages = normalizeMessagesDates(result.messages)
+      if (olderMessages.length === 0) {
+        throw new Error('Older page was empty')
+      }
+      this.applyHydrationPage(result.page)
+      this.processor.prependMessages(olderMessages)
+      this.rememberServerMessageIds(olderMessages)
+    } finally {
+      this.loadOlderMessagesInFlight = false
+    }
+  }
+
+  private resetHistoryPaging() {
+    this.hasOlderMessages = false
+    this.olderMessagesCursor = undefined
+    this.knownServerMessageIds.clear()
+    this.historyGeneration++
+  }
+
+  private applyHydrationPage(page: ChatHydrationResult['page']) {
+    if (page?.truncated === true) {
+      this.hasOlderMessages = true
+      this.olderMessagesCursor = page.cursor
+      return
+    }
+    this.hasOlderMessages = false
+    this.olderMessagesCursor = undefined
+  }
+
+  private rememberServerMessageIds(messages: Array<UIMessage>) {
+    const ids = messages.map((message) => message.id)
+    for (const id of ids) {
+      this.knownServerMessageIds.add(id)
+    }
+  }
+
+  private rememberProcessorMessageIds() {
+    if (this.historyPageSize === undefined) return
+    this.rememberServerMessageIds(this.processor.getMessages())
+  }
+
+  private messagesForSend(messages: Array<UIMessage>) {
+    if (this.historyPageSize === undefined) {
+      return messages
+    }
+    const unknownMessages: Array<UIMessage> = []
+    for (const message of messages) {
+      const isKnown = this.knownServerMessageIds.has(message.id)
+      if (isKnown) {
+        continue
+      }
+      unknownMessages.push(message)
+    }
+    if (unknownMessages.length > 0) {
+      return unknownMessages
+    }
+    // No new ids: reload has already dropped the old assistant, so this is
+    // `[lastUser]`. Resume/continue still has the assistant, so the cutoff is
+    // that assistant and the stored tool-call stays.
+    const lastUserIndex = messages.findLastIndex(
+      (message) => message.role === 'user',
+    )
+    if (lastUserIndex === -1) {
+      return []
+    }
+    return messages.slice(lastUserIndex)
+  }
+
   /**
    * True when an interrupt (or another direct send) claimed the client during
    * a drain. Read via a method so cross-await mutations are not constant-folded

package/src/connection-adapters.ts

@@ -531,12 +531,48 @@ function errorFromXhrStatus(xhr: XMLHttpRequest): Error {
   return new Error(`XHR error! status: ${xhr.status} ${xhr.statusText}`)
 }
 
+function chatHydrationSearchParams(
+  threadId: string,
+  options?: ChatHydrateOptions,
+): Record<string, string> {
+  const values: Record<string, string> = { threadId }
+  if (options?.limit !== undefined) {
+    values.limit = String(options.limit)
+  }
+  if (options?.before !== undefined) {
+    values.before = options.before
+  }
+  return values
+}
+
+function readChatHydrationPage(
+  value: unknown,
+): { truncated: false } | { truncated: true; cursor: string } {
+  if (value === null || typeof value !== 'object') {
+    return { truncated: false }
+  }
+  if (!('truncated' in value) || value.truncated !== true) {
+    return { truncated: false }
+  }
+  if (
+    !('cursor' in value) ||
+    typeof value.cursor !== 'string' ||
+    value.cursor === ''
+  ) {
+    return { truncated: false }
+  }
+  return { truncated: true, cursor: value.cursor }
+}
+
 /**
  * GET the hydration endpoint for a thread and parse its JSON `{ messages,
  * activeRun }` body. This is the transport-agnostic reconnect probe: keyed on
  * the STABLE thread id, it returns the stored transcript and — if a run is still
  * generating — a cursor the caller tails via `joinRun`. Shared by every fetch/
  * XHR adapter so the client never has to know which transport is in use.
+ *
+ * Pass `limit` / `before` to page. Old servers that omit `page` are treated as
+ * a full list (`truncated: false`).
  */
 async function fetchThreadHydration(
   fetchClient: typeof globalThis.fetch,
@@ -544,12 +580,16 @@ async function fetchThreadHydration(
   headers: Record<string, string>,
   credentials: RequestCredentials,
   threadId: string,
+  options?: ChatHydrateOptions,
 ): Promise<ChatHydrationResult> {
-  const response = await fetchClient(withSearchParams(url, { threadId }), {
-    method: 'GET',
-    headers: { Accept: 'application/json', ...headers },
-    credentials,
-  })
+  const response = await fetchClient(
+    withSearchParams(url, chatHydrationSearchParams(threadId, options)),
+    {
+      method: 'GET',
+      headers: { Accept: 'application/json', ...headers },
+      credentials,
+    },
+  )
   await assertResponseOk(response)
   const data = (await response.json()) as {
     messages?: Array<UIMessage>
@@ -558,6 +598,7 @@ async function fetchThreadHydration(
       runId?: unknown
       pending?: unknown
     } | null
+    page?: unknown
   }
   const activeRun =
     data.activeRun && typeof data.activeRun.runId === 'string'
@@ -579,6 +620,7 @@ async function fetchThreadHydration(
       : [],
     activeRun,
     interrupts,
+    page: readChatHydrationPage(data.page),
   }
 }
 
@@ -881,7 +923,10 @@ export interface ConnectConnectionAdapter {
    * `fetchServerSentEvents` / `fetchHttpStream`, and on `stream()` /
    * `rpcStream()` when supplied via {@link StreamConnectionHandlers}.
    */
-  hydrate?: (threadId: string) => Promise<ChatHydrationResult>
+  hydrate?: (
+    threadId: string,
+    options?: ChatHydrateOptions,
+  ) => Promise<ChatHydrationResult>
 }
 
 /**
@@ -911,11 +956,23 @@ export interface GenerationHydrationResult {
   activeRun: { runId: string } | null
 }
 
+/**
+ * Optional paging for a chat hydrate GET.
+ * Omit both fields to load the full thread.
+ */
+export interface ChatHydrateOptions {
+  limit?: number
+  before?: string
+}
+
 /**
  * Server-resolved hydration for a thread. `messages` is the stored transcript;
  * `activeRun` is a cursor to a run still generating for the thread (or `null`).
  * Keyed on the STABLE thread id — the client never handles a run id, so a turn
  * that spans several runs (interrupt/tool continuations) reconnects correctly.
+ *
+ * `page` is additive. Old servers omit it; treat that as a full list
+ * (`truncated: false`).
  */
 export interface ChatHydrationResult {
   messages: Array<UIMessage>
@@ -929,6 +986,11 @@ export interface ChatHydrationResult {
     runId: string
     pending: Array<ChatPendingInterrupt>
   } | null
+  /**
+   * Whether this window is a slice of a longer thread.
+   * `cursor` is set when `truncated` is true and is sent back as `before`.
+   */
+  page?: { truncated: false } | { truncated: true; cursor: string }
 }
 
 /**
@@ -952,7 +1014,10 @@ export interface ResumableConnectConnectionAdapter extends ConnectConnectionAdap
    * JSON GET (`?threadId`), so it is transport-agnostic regardless of how the
    * delivery stream is served.
    */
-  hydrate?: (threadId: string) => Promise<ChatHydrationResult>
+  hydrate?: (
+    threadId: string,
+    options?: ChatHydrateOptions,
+  ) => Promise<ChatHydrationResult>
 }
 
 export interface SubscribeConnectionAdapter {
@@ -984,7 +1049,10 @@ export interface SubscribeConnectionAdapter {
    * cursor). Present only when the underlying connection supports it. The client
    * calls it on mount to re-hydrate without any app-side loader or prop.
    */
-  hydrate?: (threadId: string) => Promise<ChatHydrationResult>
+  hydrate?: (
+    threadId: string,
+    options?: ChatHydrateOptions,
+  ) => Promise<ChatHydrationResult>
 }
 
 /**
@@ -1209,7 +1277,10 @@ export function normalizeConnectionAdapter(
       // (no non-null assertion). Present only when the connection supports it.
       const hydrate = (connection as ResumableConnectConnectionAdapter).hydrate
       return typeof hydrate === 'function'
-        ? { hydrate: (threadId: string) => hydrate(threadId) }
+        ? {
+            hydrate: (threadId: string, options?: ChatHydrateOptions) =>
+              hydrate(threadId, options),
+          }
         : {}
     })(),
   }
@@ -1423,7 +1494,7 @@ export function fetchServerSentEvents(
         resolvedOptions.reconnect,
       )
     },
-    async hydrate(threadId) {
+    async hydrate(threadId, hydrateOptions) {
       const resolvedUrl = typeof url === 'function' ? url() : url
       const resolvedOptions =
         typeof options === 'function' ? await options() : options
@@ -1433,6 +1504,7 @@ export function fetchServerSentEvents(
         mergeHeaders(resolvedOptions.headers),
         resolvedOptions.credentials || 'same-origin',
         threadId,
+        hydrateOptions,
       )
     },
     async hydrateGeneration(threadId) {
@@ -1579,7 +1651,7 @@ export function fetchHttpStream(
         resolvedOptions.reconnect,
       )
     },
-    async hydrate(threadId) {
+    async hydrate(threadId, hydrateOptions) {
       const resolvedUrl = typeof url === 'function' ? url() : url
       const resolvedOptions =
         typeof options === 'function' ? await options() : options
@@ -1589,6 +1661,7 @@ export function fetchHttpStream(
         mergeHeaders(resolvedOptions.headers),
         resolvedOptions.credentials || 'same-origin',
         threadId,
+        hydrateOptions,
       )
     },
     async hydrateGeneration(threadId) {
@@ -1917,7 +1990,7 @@ export function xhrServerSentEvents(
         resolvedOptions.reconnect,
       )
     },
-    async hydrate(threadId) {
+    async hydrate(threadId, hydrateOptions) {
       const resolvedUrl = typeof url === 'function' ? url() : url
       const resolvedOptions = await resolveXhrConnectionOptions(options)
       // Hydration is a non-streaming JSON GET, so fetch is fine even for the
@@ -1928,6 +2001,7 @@ export function xhrServerSentEvents(
         mergeHeaders(resolvedOptions.headers),
         resolvedOptions.withCredentials ? 'include' : 'same-origin',
         threadId,
+        hydrateOptions,
       )
     },
     async hydrateGeneration(threadId) {
@@ -2000,7 +2074,7 @@ export function xhrHttpStream(
         resolvedOptions.reconnect,
       )
     },
-    async hydrate(threadId) {
+    async hydrate(threadId, hydrateOptions) {
       const resolvedUrl = typeof url === 'function' ? url() : url
       const resolvedOptions = await resolveXhrConnectionOptions(options)
       // Hydration is a non-streaming JSON GET, so fetch is fine even for the
@@ -2011,6 +2085,7 @@ export function xhrHttpStream(
         mergeHeaders(resolvedOptions.headers),
         resolvedOptions.withCredentials ? 'include' : 'same-origin',
         threadId,
+        hydrateOptions,
       )
     },
     async hydrateGeneration(threadId) {
@@ -2451,7 +2526,10 @@ export interface StreamConnectionHandlers {
    * Server-driven chat hydration for `persistence: true`: the stored
    * transcript for `threadId` plus a cursor to an in-flight run.
    */
-  hydrate?: (threadId: string) => Promise<ChatHydrationResult>
+  hydrate?: (
+    threadId: string,
+    options?: ChatHydrateOptions,
+  ) => Promise<ChatHydrationResult>
   /**
    * Server-driven generation hydration for `persistence: true`: the last
    * generation's resume snapshot for `threadId` plus a cursor to a run still

package/src/generation-client.ts

@@ -1,4 +1,5 @@
 import { ByokBlockedError, ByokMissingError } from '@tanstack/ai/byok'
+import { byokFallbackProviderId } from './byok/client'
 import {
   prepareResolvedByokHeaders,
   resolveByokProviderId,
@@ -280,6 +281,7 @@ export class GenerationClient<
         const provider = resolveByokProviderId(
           this.byokProvider,
           this.body.provider,
+          byokFallbackProviderId(this.byok),
         )
         headers = await prepareResolvedByokHeaders(this.byok, provider)
       }

package/src/types.ts

@@ -751,14 +751,23 @@ export type ChatPersistenceOptions<
   | {
       persistence: true
       threadId: string
+      /**
+       * Newest-window size for server hydrate. Only with `persistence: true`.
+       * Without this, hydrate still loads the full thread.
+       */
+      history?: {
+        pageSize: number
+      }
     }
   | {
       persistence: ChatClientPersistence<TTools>
       threadId: string
+      history?: never
     }
   | {
       persistence?: false | undefined
       threadId?: string
+      history?: never
     }
 
 type IsUnknown<T> = unknown extends T

package/src/video-generation-client.ts

@@ -1,4 +1,5 @@
 import { ByokBlockedError, ByokMissingError } from '@tanstack/ai/byok'
+import { byokFallbackProviderId } from './byok/client'
 import {
   prepareResolvedByokHeaders,
   resolveByokProviderId,
@@ -273,6 +274,7 @@ export class VideoGenerationClient<TOutput = VideoGenerateResult> {
         const provider = resolveByokProviderId(
           this.byokProvider,
           this.body.provider,
+          byokFallbackProviderId(this.byok),
         )
         headers = await prepareResolvedByokHeaders(this.byok, provider)
       }