@ai-sdk/workflow 2.0.69 → 2.0.71

package/dist/{workflow-chat-transport-DwOgX7dK.d.ts → workflow-chat-transport-Bw-K44A5.d.ts}

@@ -58,6 +58,7 @@ interface WorkflowChatTransportOptions<UI_MESSAGE extends UIMessage> {
   onChatEnd?: OnChatEnd;
   /**
    * Maximum number of consecutive errors allowed during reconnection attempts.
+   * Streams that end without receiving any UI message chunks count as errors.
    * Defaults to 3 if not provided.
    */
   maxConsecutiveErrors?: number;
@@ -158,4 +159,4 @@ declare class WorkflowChatTransport<UI_MESSAGE extends UIMessage> implements Cha
 }
 //#endregion
 export { WorkflowChatTransportOptions as i, SendMessagesOptions as n, WorkflowChatTransport as r, ReconnectToStreamOptions as t };
-//# sourceMappingURL=workflow-chat-transport-DwOgX7dK.d.ts.map
+//# sourceMappingURL=workflow-chat-transport-Bw-K44A5.d.ts.map

package/dist/workflow-chat-transport-Bw-K44A5.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-chat-transport-Bw-K44A5.d.ts","names":[],"sources":["../src/workflow-chat-transport.ts"],"mappings":";;UAsGiB,oBAAoB,mBAAmB;EACtD;EACA;EACA;EACA,UAAU;EACV,cAAc;;UAGC;EACf;EACA,cAAc;;;;;;;EAOd;;KAGG,kBAAkB,mBAAmB,cACxC,UAAU,UACV,SAAS,oBAAoB,uBACnB;KAEP,eACH,QACA;EAEA;EACA;aACW;;;;;;;UAQI,6BAA6B,mBAAmB;;;;;EAK/D;;;;;EAMA,eAAe;;;;;;;;EASf,oBAAoB,kBAAkB;;;;;;;;EAStC,YAAY;;;;;;EAOZ;;;;;;;;;;;;;EAcA;;;;;EAMA,6BAA6B,2BAA2B;;;;;EAMxD,kCAAkC;;;;;;;;;;;;;;;cAgBvB,sBACX,mBAAmB,sBACR,cAAc;mBACR;mBACA;mBACA;mBACA;mBACA;mBACA;mBACA;mBACA;;;;;;;;;;;;;EAcL,YAAA,UAAS,6BAA6B;;;;;;;;;;;;;;;;;;;EA8B5C,aACJ,SAAS,oBAAoB,cAAc,qBAC1C,QAAQ,eAAe;UAMX;;;;;;;;;;;;;EAmGT,kBACJ,SAAS,2BAA2B,qBACnC,QAAQ,eAAe;UAOX;UAiJD"}

package/dist/{workflow-chat-transport-Bduf4ZDx.js → workflow-chat-transport-Dj1poviu.js}

@@ -329,6 +329,7 @@ var WorkflowChatTransport = class {
 			}
 			useExplicitStartIndex = false;
 			try {
+				const streamStartIndex = chunkIndex;
 				const chunkStream = parseJsonEventStream({
 					stream: response.body,
 					schema: uiMessageChunkSchema
@@ -340,6 +341,7 @@ var WorkflowChatTransport = class {
 					yield chunk.value;
 					if (chunk.value.type === "finish") gotFinish = true;
 				}
+				if (chunkIndex === streamStartIndex) throw new Error("Reconnect stream ended without receiving chunks.");
 				consecutiveErrors = 0;
 			} catch (error) {
 				console.error("Error in chat GET reconnectToStream", error);
@@ -363,4 +365,4 @@ var WorkflowChatTransport = class {
 //#endregion
 export { normalizeUIMessageStreamParts as n, WorkflowChatTransport as t };
 
-//# sourceMappingURL=workflow-chat-transport-Bduf4ZDx.js.map
+//# sourceMappingURL=workflow-chat-transport-Dj1poviu.js.map

package/dist/workflow-chat-transport-Dj1poviu.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-chat-transport-Dj1poviu.js","names":[],"sources":["../src/normalize-ui-message-stream.ts","../src/workflow-chat-transport.ts"],"sourcesContent":["import type { UIMessageChunk } from 'ai';\n\n/**\n * Tracks, for one part family (text or reasoning), which part ids are open or\n * have ended since the latest step boundary.\n */\ninterface PartFrameState {\n  /** A `*-start` was seen and has not yet received its explicit `*-end`. */\n  open: Set<string>;\n  /** A part that ended since the latest step boundary. */\n  ended: Set<string>;\n}\n\nconst newPartFrameState = (): PartFrameState => ({\n  open: new Set(),\n  ended: new Set(),\n});\n\n/**\n * Repairs the framing for a single `*-start` / `*-delta` / `*-end` chunk\n * against the running framing state, yielding the chunks the consumer should\n * see. Text and reasoning parts share this logic (`startType` differentiates\n * the synthesized start chunk).\n *\n * @yields the chunks (possibly synthesized, possibly none) the consumer should see.\n */\nfunction* repairPart(\n  kind: 'start' | 'delta' | 'end',\n  id: string,\n  chunk: UIMessageChunk,\n  state: PartFrameState,\n  startType: 'text-start' | 'reasoning-start',\n): Generator<UIMessageChunk> {\n  if (kind === 'start') {\n    // Drop a duplicate/replayed start for a part that is still open or has\n    // already ended since the latest step boundary.\n    if (state.open.has(id) || state.ended.has(id)) {\n      return;\n    }\n    state.open.add(id);\n    yield chunk;\n    return;\n  }\n\n  // delta / end: drop a re-delivered chunk for an already-ended part.\n  if (state.ended.has(id)) {\n    return;\n  }\n  // Synthesize the missing start for an orphaned delta/end.\n  if (!state.open.has(id)) {\n    state.open.add(id);\n    yield { type: startType, id } as UIMessageChunk;\n  }\n  if (kind === 'end') {\n    state.open.delete(id);\n    state.ended.add(id);\n  }\n  yield chunk;\n}\n\n/**\n * Normalizes the part framing of a UI message stream so it is always\n * well-formed for the AI SDK's stream consumer (`processUIMessageStream`,\n * which backs `useChat`/`readUIMessageStream`).\n *\n * ## Why this exists\n *\n * The consumer maintains a map of \"active\" text/reasoning parts keyed by id.\n * A `text-delta`/`text-end` for an id that has no open part is a fatal error\n * (`Received text-delta for missing text part with ID \"0\" ...`) that kills the\n * whole turn. Two properties of the durable streaming model make that error\n * reachable:\n *\n * - A workflow run owns a single shared stream. Multi-step turns can reuse the\n *   same part id (commonly `\"0\"`), so a dropped or duplicated `*-start` can\n *   orphan the rest of that part's content.\n * - The same stream is read across reconnects, and a stream-producing step can\n *   run more than once (retry/redelivery, or the concurrent-worker duplication\n *   tracked in vercel/workflow#2331 and #2039). Either can interleave or\n *   duplicate chunks on the shared stream — e.g. a `finish-step` landing in the\n *   middle of another execution's text part.\n *\n * Since the content is still flowing and only the framing is damaged, repairing\n * the framing here degrades the worst case to \"text begins slightly into the\n * step\" or \"a duplicated tail is dropped\" instead of a dead turn.\n *\n * ## What it does\n *\n * Mirrors the consumer's explicit-end part-lifetime state machine per part type:\n * - keeps open parts active across `finish-step`, while allowing ended ids to\n *   be reused by a later step;\n * - synthesizes a missing `*-start` when an orphaned `*-delta`/`*-end` arrives;\n * - drops a re-delivered `*-start`/`*-delta`/`*-end` for a part already\n *   open or ended since the latest step boundary (reconnect/replay overlap).\n *\n * A well-formed stream passes through unchanged.\n *\n * ## Scope: text and reasoning only\n *\n * `tool-input-delta` raises the same class of fatal error (`Received\n * tool-input-delta for missing tool call ...`), but tool parts are deliberately\n * left untouched: the consumer does not reset its tool-call map on `finish-step`\n * and tool-call ids are unique, so the step-boundary id-reuse orphaning that\n * makes text/reasoning fragile does not apply to them. If a future duplication\n * mode is found to orphan tool-input parts, extend the same machine to that\n * family rather than special-casing it.\n *\n * @param source the raw UI message chunk stream to normalize.\n * @yields the framing-corrected UI message chunks.\n */\nexport async function* normalizeUIMessageStreamParts(\n  source: AsyncIterable<UIMessageChunk>,\n): AsyncGenerator<UIMessageChunk> {\n  const text = newPartFrameState();\n  const reasoning = newPartFrameState();\n\n  for await (const chunk of source) {\n    switch (chunk.type) {\n      case 'reset-step':\n        // A retried model-call step starts a new frame. Forget parts from the\n        // invalidated attempt so reused ids are framed normally.\n        text.open.clear();\n        text.ended.clear();\n        reasoning.open.clear();\n        reasoning.ended.clear();\n        yield chunk;\n        break;\n\n      case 'finish-step':\n        // Open parts are closed only by explicit end chunks. A finish-step can\n        // come from another interleaved execution while a part is still open.\n        // Ended ids may be reused by the next step.\n        text.ended.clear();\n        reasoning.ended.clear();\n        yield chunk;\n        break;\n\n      case 'text-start':\n        yield* repairPart('start', chunk.id, chunk, text, 'text-start');\n        break;\n      case 'text-delta':\n        yield* repairPart('delta', chunk.id, chunk, text, 'text-start');\n        break;\n      case 'text-end':\n        yield* repairPart('end', chunk.id, chunk, text, 'text-start');\n        break;\n\n      case 'reasoning-start':\n        yield* repairPart(\n          'start',\n          chunk.id,\n          chunk,\n          reasoning,\n          'reasoning-start',\n        );\n        break;\n      case 'reasoning-delta':\n        yield* repairPart(\n          'delta',\n          chunk.id,\n          chunk,\n          reasoning,\n          'reasoning-start',\n        );\n        break;\n      case 'reasoning-end':\n        yield* repairPart('end', chunk.id, chunk, reasoning, 'reasoning-start');\n        break;\n\n      default:\n        yield chunk;\n    }\n  }\n}\n","import {\n  parseJsonEventStream,\n  uiMessageChunkSchema,\n  type ChatRequestOptions,\n  type ChatTransport,\n  type PrepareReconnectToStreamRequest,\n  type PrepareSendMessagesRequest,\n  type UIMessage,\n  type UIMessageChunk,\n} from 'ai';\nimport {\n  convertAsyncIteratorToReadableStream,\n  getErrorMessage,\n} from '@ai-sdk/provider-utils';\nimport { createAsyncIterableStream } from 'ai/internal';\nimport { normalizeUIMessageStreamParts } from './normalize-ui-message-stream.js';\n\n/**\n * Tracks `*-start` chunks the client has accepted so we can drop deltas/ends\n * that refer to a part whose start was emitted before the resume cursor.\n *\n * AI SDK's UI stream processor throws on `text-delta`/`reasoning-delta`/\n * `tool-input-delta` (and the matching `*-end`) when the start chunk for that\n * id was never observed, and on tool output/approval chunks when no tool part\n * exists for the call id. A negative `startIndex` on a flat chunk stream can\n * easily land mid-part, so without this guard the client crashes on resume.\n *\n * A tool part is established by `tool-input-start` OR by a self-contained\n * `tool-input-available`/`tool-input-error` chunk (the AI SDK creates the\n * part from those directly), so all three mark the call id as seen.\n *\n * This is a best-effort safety net — it preserves only the parts that the\n * resumed window includes a `*-start` for. Server-side rewinding to a step\n * boundary is the proper fix when you want the full message preserved.\n */\ntype OrphanFilter = {\n  shouldDrop: (chunk: UIMessageChunk) => boolean;\n};\n\nfunction createOrphanFilter(): OrphanFilter {\n  const seenStartedIds = new Set<string>();\n  const seenStartedToolCallIds = new Set<string>();\n  let warnedOnce = false;\n\n  function warnOnce(orphanKind: string, orphanRef: string) {\n    if (warnedOnce) return;\n    warnedOnce = true;\n    console.warn(\n      '[WorkflowChatTransport] Dropping orphan UI chunk ' +\n        `(${orphanKind} for id \"${orphanRef}\") on resume — ` +\n        'the resume position landed mid-part. The dropped chunk(s) ' +\n        \"reference a part whose start chunk wasn't in the resumed \" +\n        'window. To preserve the full message, configure your ' +\n        'stream endpoint to rewind to a step boundary before ' +\n        'returning the readable. See: ' +\n        'https://workflow.dev/docs/ai/resumable-streams#mid-part-resumes',\n    );\n  }\n\n  function shouldDrop(chunk: UIMessageChunk): boolean {\n    switch (chunk.type) {\n      case 'reset-step':\n        seenStartedIds.clear();\n        seenStartedToolCallIds.clear();\n        return false;\n      case 'text-start':\n      case 'reasoning-start':\n        seenStartedIds.add(chunk.id);\n        return false;\n      case 'tool-input-start':\n      // `tool-input-available` / `tool-input-error` are self-contained: the\n      // AI SDK creates the tool part from them directly (non-streamed tool\n      // calls are emitted as a bare `tool-input-available`), so they must\n      // never be dropped. They also carry the full input, so they recover a\n      // tool call whose `tool-input-start` fell outside the resumed window.\n      case 'tool-input-available':\n      case 'tool-input-error':\n        seenStartedToolCallIds.add(chunk.toolCallId);\n        return false;\n      case 'text-delta':\n      case 'text-end':\n      case 'reasoning-delta':\n      case 'reasoning-end':\n        if (seenStartedIds.has(chunk.id)) return false;\n        warnOnce(chunk.type, chunk.id);\n        return true;\n      case 'tool-input-delta':\n      case 'tool-approval-request':\n      case 'tool-output-available':\n      case 'tool-output-error':\n      case 'tool-output-denied':\n        if (seenStartedToolCallIds.has(chunk.toolCallId)) return false;\n        warnOnce(chunk.type, chunk.toolCallId);\n        return true;\n      default:\n        return false;\n    }\n  }\n\n  return { shouldDrop };\n}\n\nexport interface SendMessagesOptions<UI_MESSAGE extends UIMessage> {\n  trigger: 'submit-message' | 'regenerate-message';\n  chatId: string;\n  messageId?: string;\n  messages: UI_MESSAGE[];\n  abortSignal?: AbortSignal;\n}\n\nexport interface ReconnectToStreamOptions {\n  chatId: string;\n  abortSignal?: AbortSignal;\n  /**\n   * Override the `startIndex` for this reconnection.\n   * Negative values read from the end when the server's durable stream and\n   * tail-index header use the same UIMessageChunk index space.\n   * When omitted, falls back to the constructor's `initialStartIndex`.\n   */\n  startIndex?: number;\n}\n\ntype OnChatSendMessage<UI_MESSAGE extends UIMessage> = (\n  response: Response,\n  options: SendMessagesOptions<UI_MESSAGE>,\n) => void | Promise<void>;\n\ntype OnChatEnd = ({\n  chatId,\n  chunkIndex,\n}: {\n  chatId: string;\n  chunkIndex: number;\n}) => void | Promise<void>;\n\n/**\n * Configuration options for the WorkflowChatTransport.\n *\n * @template UI_MESSAGE - The type of UI messages being sent and received,\n *                        must extend the UIMessage interface from the AI SDK.\n */\nexport interface WorkflowChatTransportOptions<UI_MESSAGE extends UIMessage> {\n  /**\n   * API endpoint for chat requests\n   * Defaults to /api/chat if not provided\n   */\n  api?: string;\n\n  /**\n   * Custom fetch implementation to use for HTTP requests.\n   * Defaults to the global fetch function if not provided.\n   */\n  fetch?: typeof fetch;\n\n  /**\n   * Callback invoked after successfully sending messages to the chat endpoint.\n   * Useful for tracking chat history and inspecting response headers.\n   *\n   * @param response - The HTTP response object from the chat endpoint\n   * @param options - The original options passed to sendMessages\n   */\n  onChatSendMessage?: OnChatSendMessage<UI_MESSAGE>;\n\n  /**\n   * Callback invoked when a chat stream ends (receives a \"finish\" chunk).\n   * Useful for cleanup operations or state updates.\n   *\n   * @param chatId - The ID of the chat that ended\n   * @param chunkIndex - The total number of chunks received\n   */\n  onChatEnd?: OnChatEnd;\n\n  /**\n   * Maximum number of consecutive errors allowed during reconnection attempts.\n   * Streams that end without receiving any UI message chunks count as errors.\n   * Defaults to 3 if not provided.\n   */\n  maxConsecutiveErrors?: number;\n\n  /**\n   * Default `startIndex` to use when reconnecting to a stream without a known\n   * chunk position (i.e. the initial reconnection, not a retry).\n   * Negative values read from the end of a durable UIMessageChunk stream (e.g.\n   * `-10` fetches the last 10 chunks), which is useful for resuming a chat UI\n   * after a page refresh without replaying the full conversation. Raw\n   * ModelCallStreamPart streams do not support negative UI chunk indexes.\n   *\n   * Can be overridden per-call via `ReconnectToStreamOptions.startIndex`.\n   *\n   * Defaults to `0` (replay from the beginning).\n   */\n  initialStartIndex?: number;\n\n  /**\n   * Function to prepare the request for sending messages.\n   * Allows customizing the API endpoint, headers, credentials, and body.\n   */\n  prepareSendMessagesRequest?: PrepareSendMessagesRequest<UI_MESSAGE>;\n\n  /**\n   * Function to prepare the request for reconnecting to a stream.\n   * Allows customizing the API endpoint, headers, and credentials.\n   */\n  prepareReconnectToStreamRequest?: PrepareReconnectToStreamRequest;\n}\n\n/**\n * A transport implementation for managing chat workflows with support for\n * streaming responses and automatic reconnection to interrupted streams.\n *\n * This class implements the ChatTransport interface from the AI SDK and provides\n * reliable message streaming with automatic recovery from network interruptions\n * or function timeouts.\n *\n * @template UI_MESSAGE - The type of UI messages being sent and received,\n *                        must extend the UIMessage interface from the AI SDK.\n *\n * @implements {ChatTransport<UI_MESSAGE>}\n */\nexport class WorkflowChatTransport<\n  UI_MESSAGE extends UIMessage,\n> implements ChatTransport<UI_MESSAGE> {\n  private readonly api: string;\n  private readonly fetch: typeof fetch;\n  private readonly onChatSendMessage?: OnChatSendMessage<UI_MESSAGE>;\n  private readonly onChatEnd?: OnChatEnd;\n  private readonly maxConsecutiveErrors: number;\n  private readonly initialStartIndex: number;\n  private readonly prepareSendMessagesRequest?: PrepareSendMessagesRequest<UI_MESSAGE>;\n  private readonly prepareReconnectToStreamRequest?: PrepareReconnectToStreamRequest;\n\n  /**\n   * Creates a new WorkflowChatTransport instance.\n   *\n   * @param options - Configuration options for the transport\n   * @param options.api - API endpoint for chat requests (defaults to '/api/chat')\n   * @param options.fetch - Custom fetch implementation (defaults to global fetch)\n   * @param options.onChatSendMessage - Callback after sending messages\n   * @param options.onChatEnd - Callback when chat stream ends\n   * @param options.maxConsecutiveErrors - Maximum consecutive errors for reconnection\n   * @param options.prepareSendMessagesRequest - Function to prepare send messages request\n   * @param options.prepareReconnectToStreamRequest - Function to prepare reconnect request\n   */\n  constructor(options: WorkflowChatTransportOptions<UI_MESSAGE> = {}) {\n    this.api = options.api ?? '/api/chat';\n    this.fetch = options.fetch ?? fetch.bind(globalThis);\n    this.onChatSendMessage = options.onChatSendMessage;\n    this.onChatEnd = options.onChatEnd;\n    this.maxConsecutiveErrors = options.maxConsecutiveErrors ?? 3;\n    this.initialStartIndex = options.initialStartIndex ?? 0;\n    this.prepareSendMessagesRequest = options.prepareSendMessagesRequest;\n    this.prepareReconnectToStreamRequest =\n      options.prepareReconnectToStreamRequest;\n  }\n\n  /**\n   * Sends messages to the chat endpoint and returns a stream of response chunks.\n   *\n   * This method handles the entire chat lifecycle including:\n   * - Sending messages to the /api/chat endpoint\n   * - Streaming response chunks\n   * - Automatic reconnection if the stream is interrupted\n   *\n   * @param options - Options for sending messages\n   * @param options.trigger - The type of message submission ('submit-message' or 'regenerate-message')\n   * @param options.chatId - Unique identifier for this chat session\n   * @param options.messageId - Optional message ID for tracking specific messages\n   * @param options.messages - Array of UI messages to send\n   * @param options.abortSignal - Optional AbortSignal to cancel the request\n   *\n   * @returns A ReadableStream of UIMessageChunk objects containing the response\n   * @throws Error if the fetch request fails or returns a non-OK status\n   */\n  async sendMessages(\n    options: SendMessagesOptions<UI_MESSAGE> & ChatRequestOptions,\n  ): Promise<ReadableStream<UIMessageChunk>> {\n    return convertAsyncIteratorToReadableStream(\n      normalizeUIMessageStreamParts(this.sendMessagesIterator(options)),\n    );\n  }\n\n  private async *sendMessagesIterator(\n    options: SendMessagesOptions<UI_MESSAGE> & ChatRequestOptions,\n  ): AsyncGenerator<UIMessageChunk> {\n    const { chatId, messages, abortSignal, trigger, messageId } = options;\n\n    // We keep track of if the \"finish\" chunk is received to determine\n    // if we need to reconnect, and keep track of the chunk index to resume from.\n    let gotFinish = false;\n    let chunkIndex = 0;\n\n    // Prepare the request using the configurator if provided\n    const requestConfig = this.prepareSendMessagesRequest\n      ? await this.prepareSendMessagesRequest({\n          id: chatId,\n          messages,\n          requestMetadata: options.metadata,\n          body: options.body,\n          credentials: undefined,\n          headers: options.headers,\n          api: this.api,\n          trigger,\n          messageId,\n        })\n      : undefined;\n\n    const url = requestConfig?.api ?? this.api;\n    const response = await this.fetch(url, {\n      method: 'POST',\n      body: JSON.stringify(\n        requestConfig?.body ?? { messages, ...options.body },\n      ),\n      headers: requestConfig?.headers,\n      credentials: requestConfig?.credentials,\n      signal: abortSignal,\n    });\n\n    if (!response.ok || !response.body) {\n      throw new Error(\n        `Failed to fetch chat: ${response.status} ${await response.text()}`,\n      );\n    }\n\n    const workflowRunId = response.headers.get('x-workflow-run-id');\n    if (!workflowRunId) {\n      throw new Error(\n        'Workflow run ID not found in \"x-workflow-run-id\" response header',\n      );\n    }\n\n    // Notify the caller that the chat POST request was sent.\n    // This is useful for tracking the chat history on the client\n    // side and allows for inspecting response headers.\n    await this.onChatSendMessage?.(response, options);\n\n    // Flush the initial stream until the end or an error occurs\n    try {\n      const chunkStream = parseJsonEventStream({\n        stream: response.body,\n        schema: uiMessageChunkSchema,\n      });\n      for await (const chunk of createAsyncIterableStream(chunkStream)) {\n        if (!chunk.success) {\n          throw chunk.error;\n        }\n\n        chunkIndex++;\n\n        yield chunk.value;\n\n        if (chunk.value.type === 'finish') {\n          gotFinish = true;\n        }\n      }\n    } catch (error) {\n      console.error('Error in chat POST stream', error);\n    }\n\n    if (gotFinish) {\n      await this.onFinish(gotFinish, { chatId, chunkIndex });\n    } else {\n      // If the initial POST request did not include the \"finish\" chunk,\n      // we need to reconnect to the stream. This could indicate that a\n      // network error occurred or the Vercel Function timed out.\n      yield* this.reconnectToStreamIterator(options, workflowRunId, chunkIndex);\n    }\n  }\n\n  /**\n   * Reconnects to an existing chat stream that was previously interrupted.\n   *\n   * This method is useful for resuming a chat session after network issues,\n   * page refreshes, or Vercel Function timeouts.\n   *\n   * @param options - Options for reconnecting to the stream\n   * @param options.chatId - The chat ID to reconnect to\n   *\n   * @returns A ReadableStream of UIMessageChunk objects\n   * @throws Error if the reconnection request fails or returns a non-OK status\n   */\n  async reconnectToStream(\n    options: ReconnectToStreamOptions & ChatRequestOptions,\n  ): Promise<ReadableStream<UIMessageChunk> | null> {\n    const reconnectIterator = normalizeUIMessageStreamParts(\n      this.reconnectToStreamIterator(options),\n    );\n    return convertAsyncIteratorToReadableStream(reconnectIterator);\n  }\n\n  private async *reconnectToStreamIterator(\n    options: ReconnectToStreamOptions & ChatRequestOptions,\n    workflowRunId?: string,\n    initialChunkIndex = 0,\n  ): AsyncGenerator<UIMessageChunk> {\n    let chunkIndex = initialChunkIndex;\n\n    // When called from the public reconnectToStream (initialChunkIndex === 0),\n    // honour the caller's startIndex (or the constructor default) for the\n    // first request. This enables negative values so the client can read only\n    // the tail of the stream (e.g. the last 10 chunks) instead of replaying\n    // everything. After the first request, fall back to the running chunkIndex\n    // so that retries resume from the correct position.\n    const explicitStartIndex = options.startIndex ?? this.initialStartIndex;\n    let useExplicitStartIndex =\n      initialChunkIndex === 0 && explicitStartIndex !== 0;\n\n    const defaultApi = `${this.api}/${encodeURIComponent(workflowRunId ?? options.chatId)}/stream`;\n\n    // Prepare the request using the configurator if provided\n    const requestConfig = this.prepareReconnectToStreamRequest\n      ? await this.prepareReconnectToStreamRequest({\n          id: options.chatId,\n          requestMetadata: options.metadata,\n          body: undefined,\n          credentials: undefined,\n          headers: undefined,\n          api: defaultApi,\n        })\n      : undefined;\n\n    const baseUrl = requestConfig?.api ?? defaultApi;\n\n    let gotFinish = false;\n    let consecutiveErrors = 0;\n    // When a negative startIndex is used but the tail-index header is absent,\n    // retries fall back to startIndex 0 (replay everything) instead of using\n    // the incremental chunkIndex which would be wrong.\n    let replayFromStart = false;\n\n    // When resuming with a negative startIndex, the resolved chunk can land in\n    // the middle of a `*-start` / `*-delta` / `*-end` sequence, which crashes\n    // the AI SDK UI stream processor. The orphan filter drops chunks whose\n    // start chunk was emitted before the resume window. Only activated for\n    // negative resumes — non-negative startIndex is the caller's explicit\n    // choice and we trust them. See: https://github.com/vercel/workflow/issues/1835\n    const orphanFilter =\n      useExplicitStartIndex && explicitStartIndex < 0\n        ? createOrphanFilter()\n        : null;\n\n    while (!gotFinish) {\n      const startIndex = useExplicitStartIndex\n        ? explicitStartIndex\n        : replayFromStart\n          ? 0\n          : chunkIndex;\n\n      const url = `${baseUrl}?startIndex=${startIndex}`;\n      const response = await this.fetch(url, {\n        headers: requestConfig?.headers,\n        credentials: requestConfig?.credentials,\n        signal: options.abortSignal,\n      });\n\n      if (!response.ok || !response.body) {\n        throw new Error(\n          `Failed to fetch chat: ${response.status} ${await response.text()}`,\n        );\n      }\n\n      // When using a negative startIndex, the server resolves it to an\n      // absolute position. The reconnection endpoint should return the tail\n      // index so we can compute the resolved position for subsequent retries.\n      if (useExplicitStartIndex && explicitStartIndex > 0) {\n        // Positive startIndex: the first request starts at this absolute\n        // position, so set chunkIndex to match so subsequent retries\n        // resume from (explicitStartIndex + chunks received).\n        chunkIndex = explicitStartIndex;\n      } else if (useExplicitStartIndex && explicitStartIndex < 0) {\n        const tailIndexHeader = response.headers.get(\n          'x-workflow-stream-tail-index',\n        );\n        const tailIndex =\n          tailIndexHeader !== null ? parseInt(tailIndexHeader, 10) : NaN;\n\n        if (!Number.isNaN(tailIndex)) {\n          // Resolve: e.g. tailIndex=499, startIndex=-20 → 500 + (-20) = 480\n          chunkIndex = Math.max(0, tailIndex + 1 + explicitStartIndex);\n        } else {\n          // Header missing or unparseable — fall back to replaying from the\n          // beginning so retries don't resume from a wrong position.\n          console.warn(\n            '[WorkflowChatTransport] Negative initialStartIndex is configured ' +\n              `(${explicitStartIndex}) but the reconnection endpoint did not ` +\n              'return a valid \"x-workflow-stream-tail-index\" header. Retries ' +\n              'will replay the stream from the beginning. See: ' +\n              'https://workflow.dev/docs/ai/resumable-streams#resuming-from-the-end-of-the-stream',\n          );\n          replayFromStart = true;\n        }\n      }\n      useExplicitStartIndex = false;\n\n      try {\n        const streamStartIndex = chunkIndex;\n        const chunkStream = parseJsonEventStream({\n          stream: response.body,\n          schema: uiMessageChunkSchema,\n        });\n        for await (const chunk of createAsyncIterableStream(chunkStream)) {\n          if (!chunk.success) {\n            throw chunk.error;\n          }\n\n          chunkIndex++;\n\n          if (orphanFilter?.shouldDrop(chunk.value)) continue;\n\n          yield chunk.value;\n\n          if (chunk.value.type === 'finish') {\n            gotFinish = true;\n          }\n        }\n        if (chunkIndex === streamStartIndex) {\n          throw new Error('Reconnect stream ended without receiving chunks.');\n        }\n        // Reset consecutive errors only after successful parsing with progress.\n        consecutiveErrors = 0;\n      } catch (error) {\n        console.error('Error in chat GET reconnectToStream', error);\n        consecutiveErrors++;\n\n        if (consecutiveErrors >= this.maxConsecutiveErrors) {\n          throw new Error(\n            `Failed to reconnect after ${this.maxConsecutiveErrors} consecutive errors. Last error: ${getErrorMessage(error)}`,\n          );\n        }\n      }\n    }\n\n    await this.onFinish(gotFinish, { chatId: options.chatId, chunkIndex });\n  }\n\n  private async onFinish(\n    gotFinish: boolean,\n    { chatId, chunkIndex }: { chatId: string; chunkIndex: number },\n  ) {\n    if (gotFinish) {\n      await this.onChatEnd?.({ chatId, chunkIndex });\n    } else {\n      throw new Error('No finish chunk received');\n    }\n  }\n}\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/workflow",
-  "version": "2.0.69",
+  "version": "2.0.71",
   "type": "module",
   "description": "WorkflowAgent for building AI agents with AI SDK",
   "license": "Apache-2.0",
@@ -36,12 +36,15 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/provider": "4.0.26",
-    "@ai-sdk/provider-utils": "5.0.58",
-    "ai": "7.0.137",
+    "@ai-sdk/provider": "4.0.27",
+    "@ai-sdk/provider-utils": "5.0.59",
+    "ai": "7.0.139",
     "ajv": "^8.20.0"
   },
   "devDependencies": {
+    "@ai-sdk/otel": "1.0.139",
+    "@opentelemetry/api": "1.9.1",
+    "@opentelemetry/sdk-trace-base": "2.7.1",
     "@types/node": "22.19.19",
     "@vercel/ai-tsconfig": "0.0.0",
     "@workflow/vitest": "5.0.2",
@@ -49,7 +52,7 @@
     "typescript": "6.0.3",
     "vitest": "4.1.11",
     "workflow": "5.1.0",
-    "zod": "4.4.3"
+    "zod": "4.5.4"
   },
   "peerDependencies": {
     "workflow": "^5.1.0",

package/src/build-model-step-result.ts

@@ -25,6 +25,7 @@ export async function buildModelStepResult(
   finish: ModelCallFinish | undefined,
   providerExecutedToolResults: Map<string, ProviderExecutedToolResult>,
   opts: {
+    callId?: string;
     tools?: ToolSet;
     requestMessages?: ModelMessage[];
     stepNumber: number;
@@ -72,7 +73,7 @@ export async function buildModelStepResult(
     const rate = (tokens: number | undefined) =>
       calculateTokensPerSecond({ tokens, durationMs: duration });
     return new DefaultStepResult({
-      callId: 'workflow-agent',
+      callId: opts.callId ?? 'workflow-agent',
       stepNumber: opts.stepNumber,
       provider: raw.generation.provider,
       modelId: raw.generation.modelId,
@@ -258,7 +259,7 @@ export async function buildModelStepResult(
   ) as StepResult<ToolSet, any>['toolResults'];
 
   return {
-    callId: 'workflow-agent',
+    callId: opts.callId ?? 'workflow-agent',
     stepNumber: opts.stepNumber,
     model: {
       provider: responseMetadata?.modelId?.split(':')[0] ?? 'unknown',

package/src/do-generate-step.ts

@@ -7,6 +7,7 @@ import {
 } from 'ai';
 import {
   asLanguageModelUsage,
+  convertToLanguageModelPrompt,
   parseToolCall,
   prepareLanguageModelCallOptions,
   prepareRetries,
@@ -14,6 +15,7 @@ import {
   prepareTools,
   resolveLanguageModel,
 } from 'ai/internal';
+import { languageModelPromptToModelMessages } from './language-model-prompt-to-model-messages.js';
 import type {
   ModelCallOptions,
   ModelCallRawContentPart,
@@ -25,6 +27,10 @@ import {
   resolveSerializableTools,
   type SerializableToolDef,
 } from './serializable-schema.js';
+import {
+  runModelCallWithTelemetry,
+  type LanguageModelCallTelemetry,
+} from './model-call-telemetry.js';
 
 /** A single durable provider call; orchestration and callbacks stay in the workflow. */
 export async function doGenerateStep(
@@ -35,19 +41,34 @@ export async function doGenerateStep(
 ): Promise<ModelCallResult> {
   'use step';
 
-  try {
-    return await generateModelCall(prompt, modelInit, serializedTools, options);
-  } catch (error) {
-    // Carry failures as data so Workflow does not normalize arbitrary thrown
-    // values (including undefined) before the agent rejects in workflow code.
-    return {
-      toolCalls: [],
-      finish: undefined,
-      raw: { content: [], reasoning: [] },
-      providerExecutedToolResults: new Map(),
-      terminalError: error,
-    };
-  }
+  return runModelCallWithTelemetry({
+    telemetry: options.telemetry,
+    modelInit,
+    prompt,
+    serializedTools,
+    options,
+    execute: async languageModelCallTelemetry => {
+      try {
+        return await generateModelCall(
+          prompt,
+          modelInit,
+          serializedTools,
+          options,
+          languageModelCallTelemetry,
+        );
+      } catch (error) {
+        // Carry failures as data so Workflow does not normalize arbitrary thrown
+        // values (including undefined) before the agent rejects in workflow code.
+        return {
+          toolCalls: [],
+          finish: undefined,
+          raw: { content: [], reasoning: [] },
+          providerExecutedToolResults: new Map(),
+          terminalError: error,
+        };
+      }
+    },
+  });
 }
 
 async function generateModelCall(
@@ -55,6 +76,7 @@ async function generateModelCall(
   modelInit: LanguageModel,
   serializedTools: Record<string, SerializableToolDef>,
   options: ModelCallOptions,
+  languageModelCallTelemetry: LanguageModelCallTelemetry | undefined,
 ): Promise<ModelCallResult> {
   const remaining =
     options.timeoutAt == null ? undefined : options.timeoutAt - Date.now();
@@ -70,6 +92,16 @@ async function generateModelCall(
           AbortSignal.timeout(remaining),
         ]);
   const model = resolveLanguageModel(modelInit);
+  const modelPrompt = await convertToLanguageModelPrompt({
+    prompt: {
+      instructions: undefined,
+      messages: languageModelPromptToModelMessages(prompt),
+    },
+    supportedUrls: await model.supportedUrls,
+    download: options.download,
+    abortSignal,
+    provider: model.provider.split('.')[0],
+  });
   const tools = resolveSerializableTools(serializedTools);
   const toolChoice = prepareToolChoice({ toolChoice: options.toolChoice });
   const modelTools = await prepareTools({ tools });
@@ -78,6 +110,20 @@ async function generateModelCall(
     maxRetries: options.maxRetries,
     abortSignal,
   });
+  const callId = languageModelCallTelemetry?.callId;
+  const executeLanguageModelCall =
+    languageModelCallTelemetry?.executeLanguageModelCallInTelemetryContext ??
+    (({ execute }) => execute());
+  await languageModelCallTelemetry?.onLanguageModelCallStart?.({
+    callId,
+    provider: model.provider,
+    modelId: model.modelId,
+    messages: prompt,
+    tools: modelTools,
+    ...settings,
+    providerOptions: options.providerOptions,
+    headers: options.headers,
+  });
   const start = Date.now();
   const response = await retry(async () => {
     abortSignal?.throwIfAborted();
@@ -86,19 +132,36 @@ async function generateModelCall(
         'The generation deadline expired.',
         'TimeoutError',
       );
-    return model.doGenerate({
-      ...settings,
-      prompt: [...prompt],
-      tools: modelTools,
-      toolChoice,
-      responseFormat: options.responseFormat,
-      providerOptions: options.providerOptions,
-      headers: options.headers,
-      abortSignal,
+    return executeLanguageModelCall({
+      callId: callId ?? '',
+      execute: () =>
+        model.doGenerate({
+          ...settings,
+          prompt: modelPrompt,
+          tools: modelTools,
+          toolChoice,
+          responseFormat: options.responseFormat,
+          providerOptions: options.providerOptions,
+          headers: options.headers,
+          abortSignal,
+        }),
     });
   });
-  abortSignal?.throwIfAborted();
   const responseTimeMs = Date.now() - start;
+  await languageModelCallTelemetry?.onLanguageModelCallEnd?.({
+    callId,
+    provider: model.provider,
+    modelId: response.response?.modelId ?? model.modelId,
+    finishReason: response.finishReason.unified,
+    usage: asLanguageModelUsage(response.usage),
+    content: response.content,
+    responseId: response.response?.id,
+    ...(response.providerMetadata != null
+      ? { providerMetadata: response.providerMetadata }
+      : {}),
+    performance: { responseTimeMs },
+  });
+  abortSignal?.throwIfAborted();
   const toolCalls = await Promise.all(
     response.content
       .filter(part => part.type === 'tool-call')
@@ -108,7 +171,7 @@ async function generateModelCall(
           tools,
           repairToolCall: options.repairToolCall,
           instructions:
-            prompt
+            modelPrompt
               .filter(message => message.role === 'system')
               .map(message => message.content)
               .join('\n') || undefined,

package/src/do-stream-step.ts

@@ -7,17 +7,22 @@ import { asArray, isAbortError } from '@ai-sdk/provider-utils';
 import {
   experimental_streamLanguageModelCall as streamModelCall,
   gateway,
+  NoOutputGeneratedError,
   wrapLanguageModel,
   type LanguageModel,
-  type ModelMessage,
   type ToolSet,
 } from 'ai';
-import { prepareRetries } from 'ai/internal';
+import { isOutputChunk, prepareRetries } from 'ai/internal';
+import { languageModelPromptToModelMessages } from './language-model-prompt-to-model-messages.js';
 import type { StreamTextTransform } from './workflow-agent.js';
 import {
   resolveSerializableTools,
   type SerializableToolDef,
 } from './serializable-schema.js';
+import {
+  runModelCallWithTelemetry,
+  type LanguageModelCallTelemetry,
+} from './model-call-telemetry.js';
 
 import type {
   ModelCallFinish as StreamFinish,
@@ -54,6 +59,36 @@ export async function doStreamStep(
 ): Promise<DoStreamStepResult> {
   'use step';
 
+  return runModelCallWithTelemetry({
+    telemetry: options?.telemetry,
+    modelInit,
+    prompt: conversationPrompt,
+    serializedTools,
+    options,
+    execute: languageModelCallTelemetry =>
+      streamModelStep(
+        conversationPrompt,
+        modelInit,
+        writable,
+        serializedTools,
+        options,
+        languageModelCallTelemetry,
+      ),
+  });
+}
+
+// Model-call retries are handled below so the workflow runtime must not add
+// another retry layer around the durable step.
+doStreamStep.maxRetries = 0;
+
+async function streamModelStep(
+  conversationPrompt: LanguageModelV4Prompt,
+  modelInit: LanguageModel,
+  writable: WritableStream<ModelCallStreamPart<ToolSet>> | undefined,
+  serializedTools: Record<string, SerializableToolDef> | undefined,
+  options: DoStreamStepOptions | undefined,
+  languageModelCallTelemetry: LanguageModelCallTelemetry | undefined,
+): Promise<DoStreamStepResult> {
   const timeout =
     options?.timeoutAt == null ? undefined : options.timeoutAt - Date.now();
 
@@ -143,21 +178,7 @@ export async function doStreamStep(
           // streamModelCall expects Prompt (ModelMessage[]) but we pass the
           // pre-converted LanguageModelV4Prompt. standardizePrompt inside
           // streamModelCall handles both formats.
-          messages: conversationPrompt.map(message =>
-            message.role !== 'tool'
-              ? message
-              : {
-                  ...message,
-                  // Provider prompt approval responses have already been filtered by
-                  // convertToLanguageModelPrompt. Restore the marker expected by the
-                  // model-call helper when it converts these messages again.
-                  content: message.content.map(part =>
-                    part.type === 'tool-approval-response'
-                      ? { ...part, providerExecuted: true }
-                      : part,
-                  ),
-                },
-          ) as unknown as ModelMessage[],
+          messages: languageModelPromptToModelMessages(conversationPrompt),
           allowSystemInMessages: true,
           tools,
           toolChoice: options?.toolChoice,
@@ -176,6 +197,8 @@ export async function doStreamStep(
           stopSequences: options?.stopSequences,
           seed: options?.seed,
           repairToolCall: options?.repairToolCall,
+          download: options?.download,
+          ...languageModelCallTelemetry,
         }),
       );
 
@@ -216,6 +239,7 @@ export async function doStreamStep(
   let performance: ModelCallPerformance | undefined;
   let terminalError: unknown;
   let hasTerminalError = false;
+  let hasReceivedOutputChunk = false;
   const ongoingToolCallToolNames = new Map<string, string>();
 
   // Acquire writer once before the loop to avoid per-chunk lock overhead
@@ -228,6 +252,10 @@ export async function doStreamStep(
     await writer?.write({ type: 'reset-step' });
 
     for await (const part of modelStream) {
+      if (isOutputChunk(part)) {
+        hasReceivedOutputChunk = true;
+      }
+
       switch (part.type) {
         case 'tool-input-start':
           ongoingToolCallToolNames.set(part.id, part.toolName);
@@ -452,6 +480,14 @@ export async function doStreamStep(
     return { aborted: true };
   }
 
+  if (finish == null && !hasReceivedOutputChunk && !hasTerminalError) {
+    terminalError = new NoOutputGeneratedError({
+      message:
+        'No output generated. The model stream ended without a finish chunk.',
+    });
+    hasTerminalError = true;
+  }
+
   return {
     toolCalls,
     finish,
@@ -468,10 +504,6 @@ export async function doStreamStep(
   };
 }
 
-// Model-call retries are handled above so the workflow runtime must not add
-// another retry layer around the durable step.
-doStreamStep.maxRetries = 0;
-
 function applyStreamTransforms({
   stream,
   transforms,

package/src/language-model-prompt-to-model-messages.ts

@@ -0,0 +1,28 @@
+import type { LanguageModelV4Prompt } from '@ai-sdk/provider';
+import type { ModelMessage } from 'ai';
+
+/**
+ * Prepares a workflow-side `LanguageModelV4Prompt` for a second, model-aware
+ * `convertToLanguageModelPrompt` pass inside a model step.
+ *
+ * The workflow-side conversion preserves URLs (it cannot download them) and
+ * filters out approval responses for tools that are not provider-executed.
+ * The remaining approval responses are restored with the `providerExecuted`
+ * marker that the second conversion expects.
+ */
+export function languageModelPromptToModelMessages(
+  prompt: LanguageModelV4Prompt,
+): ModelMessage[] {
+  return prompt.map(message =>
+    message.role !== 'tool'
+      ? message
+      : {
+          ...message,
+          content: message.content.map(part =>
+            part.type === 'tool-approval-response'
+              ? { ...part, providerExecuted: true }
+              : part,
+          ),
+        },
+  ) as unknown as ModelMessage[];
+}

package/src/model-call-iterator.ts

@@ -24,6 +24,7 @@ import {
 import { buildModelStepResult } from './build-model-step-result.js';
 import { doGenerateStep } from './do-generate-step.js';
 import { doStreamStep } from './do-stream-step.js';
+import { shouldDispatchModelCallTelemetryInStep } from './model-call-telemetry.js';
 import type {
   ModelCallStreamPart,
   ModelCallOptions,
@@ -142,6 +143,7 @@ export async function* modelCallIterator({
   includeRawChunks = false,
   timeoutAt,
   repairToolCall,
+  download,
   responseFormat,
   experimental_transform,
   experimental_sandbox: sandbox,
@@ -169,6 +171,7 @@ export async function* modelCallIterator({
   includeRawChunks?: boolean;
   timeoutAt?: number;
   repairToolCall?: ToolCallRepairFunction<ToolSet>;
+  download?: ModelCallOptions['download'];
   responseFormat?: LanguageModelV4CallOptions['responseFormat'];
   experimental_transform?:
     | StreamTextTransform<ToolSet>
@@ -218,6 +221,8 @@ export async function* modelCallIterator({
     includeRuntimeContext: telemetry?.includeRuntimeContext,
     includeToolsContext: telemetry?.includeToolsContext,
   }) as any;
+  const dispatchTelemetryInStep =
+    shouldDispatchModelCallTelemetryInStep(telemetry);
 
   while (!done) {
     // Check for abort signal
@@ -377,9 +382,18 @@ export async function* modelCallIterator({
         includeRawChunks,
         timeoutAt,
         repairToolCall,
+        download,
         responseFormat,
         include,
         experimental_transform,
+        telemetry: dispatchTelemetryInStep
+          ? {
+              functionId: telemetry?.functionId,
+              recordInputs: telemetry?.recordInputs,
+              recordOutputs: telemetry?.recordOutputs,
+              stepNumber,
+            }
+          : undefined,
       };
       const modelCallResult =
         mode === 'generate'
@@ -481,16 +495,22 @@ export async function* modelCallIterator({
       }
 
       const shouldProcessTools =
-        isToolExecutionAllowed &&
-        (toolCalls.length > 0 || providerExecutedToolResults.size > 0);
+        (isToolExecutionAllowed &&
+          (toolCalls.length > 0 || providerExecutedToolResults.size > 0)) ||
+        (finishReason === 'length' && providerExecutedToolResults.size > 0);
 
-      if (hasTerminalError) {
-        // The error crossed the durable step boundary as data. End the loop
-        // without throwing so WorkflowAgent can preserve the existing
-        // resolved-result contract and expose the original value.
-        done = true;
-      } else if (shouldProcessTools) {
+      if (!hasTerminalError && shouldProcessTools) {
         lastStepWasYielded = true;
+        // Invalid local calls still need validation error results when execution
+        // is disallowed. WorkflowAgent handles them without executing the tools.
+        const processableToolCalls = isToolExecutionAllowed
+          ? toolCalls
+          : toolCalls.filter(
+              toolCall =>
+                (!toolCall.providerExecuted && toolCall.invalid) ||
+                (toolCall.providerExecuted &&
+                  providerExecutedToolResults.has(toolCall.toolCallId)),
+            );
 
         const {
           content: assistantContent,
@@ -523,7 +543,7 @@ export async function* modelCallIterator({
         // This allows executeTool to pass the conversation context to tool execute functions
         // Also include provider-executed tool results so they can be used instead of local execution
         const toolResults = yield {
-          toolCalls,
+          toolCalls: processableToolCalls,
           tools: effectiveTools,
           messages: conversationPrompt,
           step,
@@ -538,7 +558,7 @@ export async function* modelCallIterator({
           messages: conversationPrompt,
           toolResults,
           providerExecutedToolCallIds: new Set([
-            ...toolCalls.flatMap(toolCall =>
+            ...processableToolCalls.flatMap(toolCall =>
               toolCall.providerExecuted ? [toolCall.toolCallId] : [],
             ),
             ...providerExecutedToolResults.keys(),
@@ -565,13 +585,20 @@ export async function* modelCallIterator({
         );
 
         done =
+          !isToolExecutionAllowed ||
           stopConditionMet ||
           (!hasClientToolCalls && pendingDeferredToolCallIds.size === 0);
       } else if (
+        hasTerminalError ||
         mode === 'generate' ||
         finishReason === 'stop' ||
         finishReason === 'tool-calls' ||
-        finishReason === 'length'
+        finishReason === 'length' ||
+        finishReason === 'content-filter' ||
+        finishReason === 'error' ||
+        finishReason === 'other' ||
+        finishReason === 'unknown' ||
+        !finishReason
       ) {
         // Add assistant response content to the conversation
         const { content: assistantContent } = getAssistantMessageContent(
@@ -594,21 +621,6 @@ export async function* modelCallIterator({
           );
         }
 
-        done = true;
-      } else if (finishReason === 'content-filter') {
-        // Content filter triggered - stop but don't throw
-        done = true;
-      } else if (finishReason === 'error') {
-        // Model error - stop but don't throw
-        done = true;
-      } else if (finishReason === 'other') {
-        // Other reason - stop but don't throw
-        done = true;
-      } else if (finishReason === 'unknown') {
-        // Unknown reason - stop but don't throw
-        done = true;
-      } else if (!finishReason) {
-        // No finish reason - this might happen on incomplete streams
         done = true;
       } else {
         throw new Error(