@tanstack/ai 0.63.0 → 0.64.0

package/src/activities/generateVoice/index.ts

@@ -166,7 +166,7 @@ function createId(prefix: string): string {
  * if (!preview) throw new Error('No voice candidates returned')
  *
  * const speech = await generateSpeech({
- *   adapter: elevenlabsSpeech('eleven_v3'),
+ *   adapter: elevenlabsSpeech('eleven_v4'),
  *   text: 'Once upon a time...',
  *   voice: preview.voiceId,
  * })

package/src/activities/index.ts

@@ -209,9 +209,10 @@ export {
   type VideoAdapterConfig,
   type AnyVideoAdapter,
   type DurationOptions,
+  type VideoDurationSpell,
 } from './generateVideo/adapter'
 
-export { snapToDurationOption } from './generateVideo/snap'
+export { durationToSeconds, snapToDurationOption } from './generateVideo/snap'
 
 // ===========================
 // TTS Activity

package/src/adapter-internals.ts

@@ -59,3 +59,4 @@ export {
 } from './utilities/structured-output-events'
 export { tanstackMetadata } from './utilities/merge-metadata'
 export { isSpecTopLevelKey } from './utilities/spec-event-keys'
+export { REDACTED_THINKING_ID_PREFIX } from './utilities/reasoning-encrypted-value'

package/src/types.ts

@@ -381,7 +381,12 @@ export interface ModelMessage<
   name?: string
   toolCalls?: Array<ToolCall>
   toolCallId?: string
-  thinking?: Array<{ content: string; signature?: string }>
+  /**
+   * Signed thinking to send back to the provider. `redacted: true` marks a
+   * block the provider encrypted: `content` is empty and `signature` holds its
+   * opaque data. See `ThinkingPart.signature` for the planned rename.
+   */
+  thinking?: Array<{ content: string; signature?: string; redacted?: boolean }>
   /** Error reported by an AG-UI tool message. */
   error?: string
   /** Optional AG-UI message metadata. TanStack-owned fields live under `tanstack`. */
@@ -465,7 +470,20 @@ export interface ThinkingPart {
   type: 'thinking'
   content: string
   stepId?: string
+  /**
+   * The provider's opaque reasoning artefact, sent back unchanged: an
+   * Anthropic signature, Anthropic redacted data, or OpenAI encrypted content.
+   * TODO(#1581): rename to `encryptedValue` to match AG-UI's `ReasoningMessage`.
+   * Renaming breaks stored messages, so it needs a read shim for `signature`.
+   */
   signature?: string
+  /**
+   * The provider encrypted this thinking block (Anthropic `redacted_thinking`).
+   * `content` is empty, and `signature` holds the opaque data that goes back
+   * to the provider unchanged. On the AG-UI wire, the reasoning message id
+   * starts with `redacted_thinking-` instead.
+   */
+  redacted?: boolean
 }
 
 /**
@@ -1088,6 +1106,11 @@ export interface TextOptions<
    */
   systemPrompts?: Array<SystemPrompt>
   agentLoopStrategy?: AgentLoopStrategy
+  /**
+   * How the server tools of one model turn run. `'parallel'` (the default)
+   * starts them together, and `'sequential'` runs them one at a time.
+   */
+  toolExecution?: 'parallel' | 'sequential'
   /**
    * Optional configuration for lazy-tool discovery (tools marked `lazy: true`).
    * Tunes how much of each lazy tool's description appears in the discovery
@@ -2277,9 +2300,10 @@ export interface VideoGenerationOptions<
   /** Video size — format depends on the provider (e.g., "16:9", "1280x720") */
   size?: TSize
   /**
-   * Video duration in seconds. Adapters that declare a per-model duration
-   * map narrow this to the model's valid union; use
-   * `adapter.snapDuration(seconds)` to coerce raw seconds to a valid value.
+   * Video duration. Adapters that declare a per-model duration map narrow
+   * this to that model's union (a number, `"8"`, or `"8s"`). Use
+   * `adapter.snapDuration(input)` to coerce a raw value. `input` may be
+   * seconds, a `"6s"` template, or `"auto"` when the model lists it.
    */
   duration?: TDuration
   /** Model-specific options for video generation */

package/src/utilities/ag-ui-wire.ts

@@ -21,6 +21,7 @@ import type {
 import type { MetadataRecord } from './merge-metadata'
 import { tanstackMetadata } from './merge-metadata'
 import { isProviderExecutedToolCall } from './provider-executed'
+import { REDACTED_THINKING_ID_PREFIX } from './reasoning-encrypted-value'
 import { normalizeToolResult } from './tool-result'
 import { wireSubagentInfo, wireSubagentRunId } from './subagent-wire'
 import type { SubagentWireInfo } from './subagent-wire'
@@ -614,7 +615,10 @@ function collectToolCalls(
 }
 
 function deriveReasoningId(messageId: string, part: MessagePart): string {
-  return `${messageId}-reasoning-${(part as { id?: string }).id ?? hashContent((part as { content: string }).content)}`
+  const id = `${messageId}-reasoning-${(part as { id?: string }).id ?? hashContent((part as { content: string }).content)}`
+  return part.type === 'thinking' && part.redacted
+    ? `${REDACTED_THINKING_ID_PREFIX}${id}`
+    : id
 }
 
 function deriveToolMessageId(toolCallId: string): string {

package/src/utilities/merge-streams.ts

@@ -0,0 +1,34 @@
+/**
+ * Yield the items of several async streams as they arrive. If the reader
+ * stops early, every stream that is still open is closed, so its `finally`
+ * runs.
+ */
+export async function* mergeStreams<T>(streams: Array<AsyncIterable<T>>) {
+  const readers = streams.map((stream) => {
+    const iterator = stream[Symbol.asyncIterator]()
+    return {
+      iterator,
+      next: iterator.next(),
+    }
+  })
+
+  try {
+    while (readers.length > 0) {
+      const indexed = readers.map((reader, index) =>
+        reader.next.then((result) => ({ index, result, reader })),
+      )
+      const winner = await Promise.race(indexed)
+      if (winner.result.done) {
+        readers.splice(winner.index, 1)
+        continue
+      }
+      yield winner.result.value
+      winner.reader.next = winner.reader.iterator.next()
+    }
+  } finally {
+    // The reader stopped early. Close every stream so its finally runs.
+    for (const reader of readers) {
+      void reader.iterator.return?.().catch(() => {})
+    }
+  }
+}

package/src/utilities/reasoning-encrypted-value.ts

@@ -16,3 +16,15 @@ export function reasoningEncryptedValue(opts: {
     ...(opts.timestamp !== undefined ? { timestamp: opts.timestamp } : {}),
   }
 }
+
+/**
+ * Id prefix for the reasoning message of a redacted thinking block (Anthropic
+ * `redacted_thinking`). AG-UI's `encryptedValue` does not say what kind of
+ * bytes it holds (ag-ui-protocol/ag-ui#2884), so the id that `entityId` points
+ * to says it. AG-UI clients keep message ids, but they drop event metadata.
+ */
+export const REDACTED_THINKING_ID_PREFIX = 'redacted_thinking-'
+
+export function isRedactedThinkingId(id: unknown): boolean {
+  return typeof id === 'string' && id.startsWith(REDACTED_THINKING_ID_PREFIX)
+}