@tanstack/ai 0.59.0 → 0.63.0

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

@@ -1,7 +1,13 @@
 import { normalizeToolResult } from '../../../utilities/tool-result'
 import { tanstackMetadata } from '../../../utilities/merge-metadata'
+import { isProviderExecutedToolCall } from '../../../utilities/provider-executed'
 import type { AdapterYieldChunk } from '../../../utilities/adapter-yield-chunk'
-import { isStandardSchema, parseWithStandardSchema } from './schema-converter'
+import {
+  StandardSchemaValidationError,
+  isStandardSchema,
+  parseWithStandardSchema,
+  validateWithStandardSchema,
+} from './schema-converter'
 import type { ToolApprovalResolution } from '../../../interrupts'
 import type {
   AnyTool,
@@ -18,6 +24,8 @@ import type {
   ToolCallEndEvent,
   ToolCallStartEvent,
   ToolExecutionContext,
+  ToolInputResponse,
+  ToolResultOutcome,
   ToolOutputState,
 } from '../../../types'
 import type {
@@ -461,6 +469,8 @@ export interface ToolResult {
   toolName: string
   result: any
   state?: 'output-available' | 'output-error'
+  /** Set when the user or middleware cancelled or denied the tool call; state is output-error. */
+  outcome?: ToolResultOutcome
   /** Duration of tool execution in milliseconds (only for server-executed tools) */
   duration?: number
   /**
@@ -489,9 +499,38 @@ export interface ClientToolRequest {
   input: any
 }
 
+/** Form or sampling input that paused a server tool. */
+export interface McpInputRequest {
+  toolCallId: string
+  toolName: string
+  kind: 'form' | 'sampling'
+  request: unknown
+}
+
+interface McpInputRequiredThrow {
+  name: 'MCPInputRequiredError'
+  kind: 'form' | 'sampling'
+  request: unknown
+}
+
+function isMcpInputRequired(value: unknown): value is McpInputRequiredThrow {
+  if (typeof value !== 'object' || value === null) return false
+  if (!('name' in value) || value.name !== 'MCPInputRequiredError') {
+    return false
+  }
+  if (!('kind' in value)) return false
+  const kindIsFormOrSampling =
+    value.kind === 'form' || value.kind === 'sampling'
+  if (!kindIsFormOrSampling) return false
+  return 'request' in value
+}
+
 export interface ToolResumeExecutionState {
+  clientToolErrors?: ReadonlyMap<string, string>
   deniedToolResults?: ReadonlyMap<string, unknown>
   cancelledToolCallIds?: ReadonlySet<string>
+  /** Answers to `mcp_input` interrupts, by tool call id. */
+  inputResponses?: ReadonlyMap<string, ToolInputResponse>
 }
 
 function approvalResolution(
@@ -526,6 +565,8 @@ interface ExecuteToolCallsResult {
   needsApproval: Array<ApprovalRequest>
   /** Tools that need client-side execution */
   needsClientExecution: Array<ClientToolRequest>
+  /** Server tools that paused for MCP form or sampling input */
+  inputRequired: Array<McpInputRequest>
   /** Interrupts raised by subagents that run as tools */
   subagentInterrupts: Array<Interrupt>
 }
@@ -638,6 +679,7 @@ export async function* executeServerTool<TContext = unknown>(
   pendingEvents: Array<CustomEvent | StreamChunk>,
   results: Array<ToolResult>,
   middlewareHooks?: ToolExecutionMiddlewareHooks,
+  inputRequired?: Array<McpInputRequest>,
   subagentInterrupts?: Array<Interrupt>,
 ): AsyncGenerator<CustomEvent | StreamChunk, void, void> {
   const startTime = Date.now()
@@ -743,6 +785,18 @@ export async function* executeServerTool<TContext = unknown>(
       throw error
     }
 
+    // Same shape as MCPInputRequiredError. Pause instead of a tool error.
+    if (isMcpInputRequired(error)) {
+      if (!inputRequired) throw error
+      inputRequired.push({
+        toolCallId: toolCall.id,
+        toolName,
+        kind: error.kind,
+        request: error.request,
+      })
+      return
+    }
+
     const message = error instanceof Error ? error.message : 'Unknown error'
     results.push({
       toolCallId: toolCall.id,
@@ -767,17 +821,35 @@ export async function* executeServerTool<TContext = unknown>(
   }
 }
 
-function buildClientToolResult(
+async function buildClientToolResult(
   toolCallId: string,
   toolName: string,
   tool: AnyTool,
   rawResult: unknown,
   input?: unknown,
-): ToolResult {
+  errorText?: string,
+): Promise<ToolResult> {
+  if (errorText !== undefined) {
+    return {
+      toolCallId,
+      toolName,
+      result: { error: errorText },
+      input,
+      state: 'output-error',
+    }
+  }
+
   try {
     let result = rawResult
     if (tool.outputSchema && isStandardSchema(tool.outputSchema)) {
-      result = parseWithStandardSchema(tool.outputSchema, result)
+      const validation = await validateWithStandardSchema<unknown>(
+        tool.outputSchema,
+        result,
+      )
+      if (!validation.success) {
+        throw new StandardSchemaValidationError(validation.issues)
+      }
+      result = validation.data
     }
 
     const parsed =
@@ -834,6 +906,7 @@ export async function* executeToolCalls<TContext = unknown>(
   const results: Array<ToolResult> = []
   const needsApproval: Array<ApprovalRequest> = []
   const needsClientExecution: Array<ClientToolRequest> = []
+  const inputRequired: Array<McpInputRequest> = []
   const subagentInterrupts: Array<Interrupt> = []
 
   // Create tool lookup map
@@ -854,6 +927,11 @@ export async function* executeToolCalls<TContext = unknown>(
   })
 
   for (const toolCall of toolCalls) {
+    // Provider-executed tools (Anthropic web_search / web_fetch) already ran
+    // inside the provider response and carry their result on the call's
+    // metadata. They have no execute() and must not become client requests.
+    if (isProviderExecutedToolCall(toolCall)) continue
+
     const tool = toolMap.get(toolCall.function.name)
     const toolName = toolCall.function.name
 
@@ -885,6 +963,7 @@ export async function* executeToolCalls<TContext = unknown>(
         toolName,
         result: { error: 'Tool execution cancelled' },
         state: 'output-error',
+        outcome: 'cancelled',
       })
       continue
     }
@@ -936,10 +1015,12 @@ export async function* executeToolCalls<TContext = unknown>(
 
     // Create a ToolExecutionContext for this tool call with event emission
     const pendingEvents: Array<CustomEvent | StreamChunk> = []
+    const inputResponse = resumeState?.inputResponses?.get(toolCall.id)
     const context = {
       toolCallId: toolCall.id,
       context: userContext,
       abortSignal,
+      ...(inputResponse !== undefined ? { inputResponse } : {}),
       emitCustomEvent: (
         eventName: string,
         value: Record<string, any>,
@@ -974,14 +1055,16 @@ export async function* executeToolCalls<TContext = unknown>(
           if (approved) {
             input = editedApprovalArgs(resolution) ?? input
             // Approved - check if client has executed
-            if (clientResults.has(toolCall.id)) {
+            const clientError = resumeState?.clientToolErrors?.get(toolCall.id)
+            if (clientResults.has(toolCall.id) || clientError !== undefined) {
               results.push(
-                buildClientToolResult(
+                await buildClientToolResult(
                   toolCall.id,
                   toolName,
                   tool,
                   clientResults.get(toolCall.id),
                   input,
+                  clientError,
                 ),
               )
             } else {
@@ -1002,6 +1085,7 @@ export async function* executeToolCalls<TContext = unknown>(
                 deniedApprovalResult(resolution),
               input,
               state: 'output-error',
+              outcome: 'denied',
             })
           }
         } else {
@@ -1015,14 +1099,16 @@ export async function* executeToolCalls<TContext = unknown>(
         }
       } else {
         // No approval needed - check if client has executed
-        if (clientResults.has(toolCall.id)) {
+        const clientError = resumeState?.clientToolErrors?.get(toolCall.id)
+        if (clientResults.has(toolCall.id) || clientError !== undefined) {
           results.push(
-            buildClientToolResult(
+            await buildClientToolResult(
               toolCall.id,
               toolName,
               tool,
               clientResults.get(toolCall.id),
               input,
+              clientError,
             ),
           )
         } else {
@@ -1071,6 +1157,7 @@ export async function* executeToolCalls<TContext = unknown>(
             pendingEvents,
             results,
             middlewareHooks,
+            inputRequired,
             subagentInterrupts,
           )
         } else {
@@ -1083,6 +1170,7 @@ export async function* executeToolCalls<TContext = unknown>(
               deniedApprovalResult(resolution),
             input,
             state: 'output-error',
+            outcome: 'denied',
           })
         }
       } else {
@@ -1120,9 +1208,16 @@ export async function* executeToolCalls<TContext = unknown>(
       pendingEvents,
       results,
       middlewareHooks,
+      inputRequired,
       subagentInterrupts,
     )
   }
 
-  return { results, needsApproval, needsClientExecution, subagentInterrupts }
+  return {
+    results,
+    needsApproval,
+    needsClientExecution,
+    inputRequired,
+    subagentInterrupts,
+  }
 }

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

@@ -99,6 +99,7 @@ export interface ServerTool<
   outputSchema?: TOutput
   needsApproval?: TNeedsApproval
   approvalSchema?: TApprovalSchema
+  execution?: 'task'
 }
 
 /**
@@ -127,6 +128,7 @@ export interface ClientTool<
   outputSchema?: TOutput
   needsApproval?: TNeedsApproval
   approvalSchema?: TApprovalSchema
+  execution?: 'task'
   lazy?: boolean
   metadata?: Record<string, unknown>
   execute?: ToolExecuteFunction<TInput, TOutput, TContext>
@@ -158,6 +160,7 @@ export interface ToolDefinitionInstance<
   outputSchema: TOutput
   needsApproval?: TNeedsApproval
   approvalSchema: TApprovalSchema
+  execution?: 'task'
   readonly [toolApprovalCapability]?: {
     needsApproval: TNeedsApproval
     approvalSchema: TApprovalSchema
@@ -221,6 +224,7 @@ export type ToolDefinitionConfig<
   outputSchema?: TOutput
   lazy?: boolean
   metadata?: Record<string, unknown>
+  execution?: 'task'
 } & ApprovalConfig<TNeedsApproval, TApprovalSchema>
 
 /**
@@ -353,6 +357,7 @@ export function toolDefinition<
   const outputSchema = config.outputSchema as TOutput
   const approvalSchema = config.approvalSchema as TApprovalSchema
   const needsApproval = config.needsApproval as TNeedsApproval | undefined
+  const execution = config.execution
 
   const definition: ToolDefinition<
     TInput,
@@ -367,6 +372,7 @@ export function toolDefinition<
     outputSchema,
     approvalSchema,
     needsApproval,
+    execution,
     server<TContext = unknown>(
       execute: ToolExecuteFunction<TInput, TOutput, TContext>,
     ): ServerTool<
@@ -385,6 +391,7 @@ export function toolDefinition<
         outputSchema,
         approvalSchema,
         needsApproval,
+        execution,
         execute,
       }
     },
@@ -407,6 +414,7 @@ export function toolDefinition<
         outputSchema,
         approvalSchema,
         needsApproval,
+        execution,
         ...(execute !== undefined && { execute }),
       }
     },

package/src/activities/embed/adapter.ts

@@ -39,6 +39,12 @@ export interface EmbeddingAdapter<
   readonly kind: 'embedding'
   /** Adapter name identifier */
   readonly name: string
+  /**
+   * Declares that this adapter can consume `{ type: 'file' }` content
+   * sources (provider Files API references). `embed()` rejects file sources
+   * in preflight for adapters that don't declare this.
+   */
+  readonly supportsFileSources?: boolean
   /** The model this adapter is configured for */
   readonly model: TModel
 
@@ -85,6 +91,7 @@ export abstract class BaseEmbeddingAdapter<
 > {
   readonly kind = 'embedding' as const
   abstract readonly name: string
+  readonly supportsFileSources: boolean = false
   readonly model: TModel
 
   // Type-only property - never assigned at runtime

package/src/activities/embed/index.ts

@@ -15,6 +15,7 @@ import {
   runGenerationUsage,
 } from '../middleware/run'
 import { countEmbeddingInputModalities } from '../../utilities/embedding-input'
+import { assertPromptFileSourceSupport } from '../../utilities/content-source'
 import type { InternalLogger } from '../../logger/internal-logger'
 import type { DebugOption } from '../../logger/types'
 import type { GenerationMiddleware } from '../middleware/types'
@@ -190,6 +191,10 @@ export async function embed<
   TAdapter extends EmbeddingAdapter<string, any, any, any>,
 >(options: EmbedOptions<TAdapter>): Promise<EmbeddingResult> {
   const { adapter, middleware } = options
+  // Fail closed on `{ type: 'file' }` sources before middleware start. No
+  // embedding adapter consumes file handles today; this matches chat /
+  // generateImage / generateVideo.
+  assertPromptFileSourceSupport(adapter, options.input)
   const model = adapter.model
   const requestId = createId('embedding')
   const startTime = Date.now()

package/src/activities/evaluate/adapter.ts

@@ -131,6 +131,10 @@ export interface EvaluateAdapterResult {
   model: string
   answers: Record<string, WireAnswer>
   usage: TokenUsage
+  /** Provider response id, for example to look the request up later. */
+  id?: string
+  /** Upstream provider that served the request, when a router reports it. */
+  provider?: string
 }
 
 /**

package/src/activities/evaluate/index.ts

@@ -100,6 +100,10 @@ export interface EvaluateResultMeta {
   /** Resolved model id from the provider. */
   model: string
   usage: TokenUsage
+  /** Provider response id, when the adapter returns one. */
+  id?: string
+  /** Upstream provider that served the request, when the adapter returns one. */
+  provider?: string
 }
 
 /**
@@ -576,6 +580,8 @@ export async function decide<
     return withMeta(answers, {
       model: result.model,
       usage: result.usage,
+      ...(result.id !== undefined && { id: result.id }),
+      ...(result.provider !== undefined && { provider: result.provider }),
     })
   } catch (error) {
     const duration = Date.now() - startTime

package/src/activities/files/adapter.ts

@@ -0,0 +1,120 @@
+/**
+ * Files Adapter
+ *
+ * Base class and interface for the `files` activity — a provider's native Files
+ * API (upload a media asset once, reference it later by the returned handle
+ * instead of re-sending base64 or a public URL each request).
+ *
+ * Providers with a native surface expose a factory (`openaiFiles()`,
+ * `anthropicFiles()`, `geminiFiles()`, `falFiles()`). `upload` is required;
+ * `get`/`delete` are optional because not every provider has a lifecycle API
+ * (fal's storage is upload-only).
+ */
+
+import { base64ToArrayBuffer } from '@tanstack/ai-utils'
+
+/**
+ * Input to {@link FilesAdapter.upload}. Either a `Blob` (memory-efficient,
+ * preferred for large assets) or base64 `data` plus its `mimeType`.
+ */
+export type FileUploadInput =
+  | Blob
+  | {
+      /** Base64-encoded file bytes. */
+      data: string
+      /** MIME type of the bytes (e.g. `'image/png'`, `'application/pdf'`). */
+      mimeType: string
+      /** Optional filename hint sent to providers that accept one. */
+      filename?: string
+    }
+
+/**
+ * A provider-issued file handle returned by {@link FilesAdapter.upload} /
+ * {@link FilesAdapter.get}. Reference it in a message via a `{ type: 'file' }`
+ * content source — use `fileSourceFromHandle` to build one.
+ *
+ * `TProvider` carries the issuing provider's name as a literal (`'openai'`,
+ * `'gemini'`, ...) when the handle came from a concrete files adapter, so
+ * cross-provider lifecycle calls (`deleteFile` with a foreign handle) fail at
+ * compile time. It defaults to `string` so wire-deserialized handles still fit.
+ */
+export interface FileHandle<TProvider extends string = string> {
+  /**
+   * Provider handle used for lifecycle operations (`get`/`delete`): the
+   * OpenAI/Anthropic `file_id`, the Gemini file resource name (`files/...`), or
+   * the fal storage URL (fal itself has no lifecycle API — the URL doubles as
+   * the wire reference).
+   */
+  id: string
+  /** The provider that issued the handle (`'openai'`, `'gemini'`, ...). */
+  provider: TProvider
+  /**
+   * The handle's URL form when the provider exposes one (Gemini file URI, fal
+   * storage URL). For providers whose handle is an opaque id (OpenAI,
+   * Anthropic) this is `undefined`.
+   */
+  uri?: string
+  /** MIME type reported by the provider (or echoed from the upload input). */
+  mimeType?: string
+  /** File size in bytes when the provider reports it. */
+  sizeBytes?: number
+  /** Expiry as epoch milliseconds when the handle is scheduled to expire. */
+  expiresAt?: number
+  /** Original filename when the provider reports it. */
+  filename?: string
+}
+
+/**
+ * The `files` adapter contract. `upload` is required; `get`/`delete` are
+ * optional and present only when the provider has a lifecycle API.
+ *
+ * `TName` is the provider name literal (`'openai'`, `'gemini'`, ...); concrete
+ * adapters bind it so the handles they issue carry their provenance in the
+ * type system.
+ */
+export interface FilesAdapter<TName extends string = string> {
+  readonly kind: 'files'
+  readonly name: TName
+  upload: (input: FileUploadInput) => Promise<FileHandle<TName>>
+  get?: (id: string) => Promise<FileHandle<TName>>
+  delete?: (id: string) => Promise<void>
+}
+
+export type AnyFilesAdapter = FilesAdapter<string>
+
+/**
+ * Normalize a {@link FileUploadInput} to a `Blob` (plus best-effort MIME /
+ * filename) so provider adapters can hand it straight to their SDK. A `Blob`
+ * input passes through; base64 `{ data }` is decoded to bytes. Shared so
+ * provider files adapters don't each re-implement the decode.
+ */
+export function normalizeFileUploadInput(input: FileUploadInput): {
+  blob: Blob
+  mimeType?: string
+  filename?: string
+} {
+  if (input instanceof Blob) {
+    return { blob: input, mimeType: input.type || undefined }
+  }
+  const bytes = base64ToArrayBuffer(input.data)
+  return {
+    blob: new Blob([bytes], { type: input.mimeType }),
+    mimeType: input.mimeType,
+    filename: input.filename,
+  }
+}
+
+/**
+ * Abstract base for provider files adapters. Subclasses bind `TName` to their
+ * provider literal, set `name`, implement `upload`, and may add `get`/`delete`
+ * (declared on {@link FilesAdapter}, not here, since not every provider has a
+ * lifecycle API).
+ */
+export abstract class BaseFilesAdapter<
+  TName extends string = string,
+> implements FilesAdapter<TName> {
+  readonly kind = 'files' as const
+  abstract readonly name: TName
+
+  abstract upload(input: FileUploadInput): Promise<FileHandle<TName>>
+}

package/src/activities/files/index.ts

@@ -0,0 +1,113 @@
+/**
+ * Files Activity
+ *
+ * Dispatch functions for provider Files APIs. Each takes `{ adapter, ... }` and
+ * calls the adapter method directly (mirrors the other activity dispatchers).
+ * `get`/`delete` are optional on the adapter; the dispatchers throw a clear
+ * error when the selected provider has no lifecycle API.
+ */
+
+import type { ContentPartFileSource } from '../../types'
+import type { FileHandle, FileUploadInput, FilesAdapter } from './adapter'
+
+/** The adapter kind this activity handles */
+export const kind = 'files' as const
+
+/**
+ * Upload a file to a provider's Files API and return its handle. The handle
+ * carries the provider name as a literal type, so passing it to another
+ * provider's lifecycle call is a compile error.
+ *
+ * @example
+ * ```ts
+ * const files = openaiFiles()
+ * const handle = await uploadFile({ adapter: files, input: { data, mimeType: 'image/png' } })
+ * ```
+ */
+export async function uploadFile<TName extends string>(options: {
+  adapter: FilesAdapter<TName> & { kind: typeof kind }
+  input: FileUploadInput
+}): Promise<FileHandle<TName>> {
+  return options.adapter.upload(options.input)
+}
+
+/**
+ * Resolve a lifecycle id from either a raw id string or a {@link FileHandle}
+ * (whose `id` — not its `uri`/wire value — is the lifecycle currency).
+ */
+function toLifecycleId(id: string | FileHandle): string {
+  return typeof id === 'string' ? id : id.id
+}
+
+/**
+ * Fetch metadata for a previously uploaded file. Accepts the handle itself
+ * (preferred — the provider-literal type rejects a foreign provider's handle
+ * at compile time) or its raw lifecycle id.
+ *
+ * @throws if the provider's files adapter has no `get` (e.g. fal storage).
+ */
+export async function getFile<TName extends string>(options: {
+  adapter: FilesAdapter<TName> & { kind: typeof kind }
+  // `NoInfer` so `TName` comes from the adapter only. Otherwise a foreign
+  // handle widens it to a union and the call compiles.
+  id: string | FileHandle<NoInfer<TName>>
+}): Promise<FileHandle<TName>> {
+  const { adapter } = options
+  if (!adapter.get) {
+    throw new Error(
+      `${adapter.name}: files adapter does not support get() — this provider ` +
+        `has no file-retrieval API.`,
+    )
+  }
+  return adapter.get(toLifecycleId(options.id))
+}
+
+/**
+ * Delete a previously uploaded file. Accepts the handle itself (preferred —
+ * the provider-literal type rejects a foreign provider's handle at compile
+ * time) or its raw lifecycle id.
+ *
+ * @throws if the provider's files adapter has no `delete` (e.g. fal storage).
+ */
+export async function deleteFile<TName extends string>(options: {
+  adapter: FilesAdapter<TName> & { kind: typeof kind }
+  id: string | FileHandle<NoInfer<TName>>
+}): Promise<void> {
+  const { adapter } = options
+  if (!adapter.delete) {
+    throw new Error(
+      `${adapter.name}: files adapter does not support delete() — this ` +
+        `provider has no file-deletion API.`,
+    )
+  }
+  return adapter.delete(toLifecycleId(options.id))
+}
+
+/**
+ * Build a `{ type: 'file' }` content source from an uploaded
+ * {@link FileHandle}, for use in a chat message (image/audio/document part
+ * `source`).
+ *
+ * The source's `value` is the handle's wire form: the handle URL when the
+ * provider exposes one (Gemini, fal, Grok), otherwise the opaque id (OpenAI,
+ * Anthropic). `provider` records the issuer, so an adapter for a different
+ * provider rejects the source rather than sending a handle it cannot resolve.
+ *
+ * @example
+ * ```ts
+ * const handle = await uploadFile({ adapter: openaiFiles(), input })
+ * messages.push({ role: 'user', content: [
+ *   { type: 'image', source: fileSourceFromHandle(handle) },
+ * ] })
+ * ```
+ */
+export function fileSourceFromHandle<TProvider extends string>(
+  handle: FileHandle<TProvider>,
+): ContentPartFileSource<TProvider> {
+  return {
+    type: 'file',
+    value: handle.uri ?? handle.id,
+    provider: handle.provider,
+    ...(handle.mimeType ? { mimeType: handle.mimeType } : {}),
+  }
+}

package/src/activities/generateImage/adapter.ts

@@ -51,6 +51,13 @@ export interface ImageAdapter<
   readonly kind: 'image'
   /** Adapter name identifier */
   readonly name: string
+  /**
+   * Declares that this adapter can consume `{ type: 'file' }` content
+   * sources (provider Files API references). The activity dispatcher rejects
+   * file sources in preflight for adapters that don't declare this, so
+   * adapters written before the file arm existed fail closed.
+   */
+  readonly supportsFileSources?: boolean
   /** The model this adapter is configured for */
   readonly model: TModel
 
@@ -103,6 +110,7 @@ export abstract class BaseImageAdapter<
 > {
   readonly kind = 'image' as const
   abstract readonly name: string
+  readonly supportsFileSources: boolean = false
   readonly model: TModel
 
   // Type-only property - never assigned at runtime

package/src/activities/generateImage/index.ts

@@ -24,6 +24,7 @@ import {
   raceWithAbort,
 } from '../../utilities/activity-abort'
 import { resolveMediaPrompt } from '../../utilities/media-prompt'
+import { assertPromptFileSourceSupport } from '../../utilities/content-source'
 import type { InternalLogger } from '../../logger/internal-logger'
 import type { DebugOption } from '../../logger/types'
 import type { GenerationMiddleware } from '../middleware/types'
@@ -248,6 +249,9 @@ export function generateImage<
 >(
   options: ImageActivityOptions<TAdapter, TStream>,
 ): ImageActivityResult<TStream> {
+  // Fail closed before middleware start and before `stream: true` emits
+  // RUN_STARTED, so an unsupported file source never opens a run.
+  assertPromptFileSourceSupport(options.adapter, options.prompt)
   if (options.stream) {
     return streamGenerationResult(
       // Only `runId` is taken from the resolved wire identity. `threadId` stays