@ai-sdk/workflow 2.0.53 → 2.0.54

package/dist/video.d.ts

@@ -1,5 +1,5 @@
-import { experimental_startVideo, GetVideoStatusResult } from 'ai';
-
+import { GetVideoStatusResult, experimental_startVideo } from "ai";
+//#region src/generate-video.d.ts
 type StartVideoOptions = Parameters<typeof experimental_startVideo>[0];
 /**
  * Options for durable video generation in a workflow.
@@ -10,7 +10,7 @@ type WorkflowGenerateVideoOptions = Omit<StartVideoOptions, 'abortSignal' | 'web
  * Hosted videos remain URLs and are not downloaded automatically.
  */
 type WorkflowGenerateVideoResult = Extract<GetVideoStatusResult, {
-    status: 'completed';
+  status: 'completed';
 }>;
 /**
  * Generates a video durably inside a workflow using a provider webhook.
@@ -19,6 +19,7 @@ type WorkflowGenerateVideoResult = Extract<GetVideoStatusResult, {
  * generated webhook URL. The returned video data is not downloaded, allowing
  * the workflow to decide how to handle provider-hosted URLs.
  */
-declare function experimental_generateVideo(options: WorkflowGenerateVideoOptions): Promise<WorkflowGenerateVideoResult>;
-
-export { type WorkflowGenerateVideoOptions, type WorkflowGenerateVideoResult, experimental_generateVideo };
+export declare function experimental_generateVideo(options: WorkflowGenerateVideoOptions): Promise<WorkflowGenerateVideoResult>;
+//#endregion
+export type { WorkflowGenerateVideoOptions, WorkflowGenerateVideoResult };
+//# sourceMappingURL=video.d.ts.map

package/dist/video.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"video.d.ts","names":[],"sources":["../src/generate-video.ts"],"mappings":";;KAQK,oBAAoB,kBAAkB;;;;KAM/B,+BAA+B,KACzC;;;;;KAQU,8BAA8B,QACxC;EACE;;;;;;;;;wBA6CkB,2BACpB,SAAS,+BACR,QAAQ"}

package/dist/video.js

@@ -1,79 +1,118 @@
-import {
-  __callDispose,
-  __using
-} from "./chunk-UAWBPTDW.js";
-
-// src/generate-video.ts
-import {
-  experimental_getVideoStatus,
-  experimental_startVideo
-} from "ai";
+import { experimental_getVideoStatus, experimental_startVideo } from "ai";
 import { createWebhook, getStepMetadata } from "workflow";
+//#region \0@oxc-project+runtime@0.151.0/helpers/esm/usingCtx.js
+function _usingCtx() {
+	var r = "function" == typeof SuppressedError ? SuppressedError : function(r, e) {
+		var n = Error();
+		return n.name = "SuppressedError", n.error = r, n.suppressed = e, n;
+	}, e = {}, n = [];
+	function using(r, e) {
+		if (null != e) {
+			if (Object(e) !== e) throw new TypeError("using declarations can only be used with objects, functions, null, or undefined.");
+			if (r) var o = e[Symbol.asyncDispose || Symbol["for"]("Symbol.asyncDispose")];
+			if (void 0 === o && (o = e[Symbol.dispose || Symbol["for"]("Symbol.dispose")], r)) var t = o;
+			if ("function" != typeof o) throw new TypeError("Object is not disposable.");
+			t && (o = function o() {
+				try {
+					t.call(e);
+				} catch (r) {
+					return Promise.reject(r);
+				}
+			}), n.push({
+				v: e,
+				d: o,
+				a: r
+			});
+		} else r && n.push({
+			d: e,
+			a: r
+		});
+		return e;
+	}
+	return {
+		e,
+		u: using.bind(null, !1),
+		a: using.bind(null, !0),
+		d: function d() {
+			var o, t = this.e, s = 0;
+			function next() {
+				for (; o = n.pop();) try {
+					if (!o.a && 1 === s) return s = 0, n.push(o), Promise.resolve().then(next);
+					if (o.d) {
+						var r = o.d.call(o.v);
+						if (o.a) return s |= 2, Promise.resolve(r).then(next, err);
+					} else s |= 1;
+				} catch (r) {
+					return err(r);
+				}
+				if (1 === s) return t !== e ? Promise.reject(t) : Promise.resolve();
+				if (t !== e) throw t;
+			}
+			function err(n) {
+				return t = t !== e ? new r(n, t) : n, next();
+			}
+			return next();
+		}
+	};
+}
+//#endregion
+//#region src/generate-video.ts
 async function startVideoStep(options) {
-  "use step";
-  const hasIdempotencyKey = Object.keys(options.headers ?? {}).some(
-    (key) => key.toLowerCase() === "idempotency-key"
-  );
-  return experimental_startVideo({
-    ...options,
-    headers: {
-      ...options.headers,
-      ...hasIdempotencyKey ? {} : {
-        "idempotency-key": `aisdk_workflow_video_${getStepMetadata().stepId}`
-      }
-    }
-  });
+	"use step";
+	const hasIdempotencyKey = Object.keys(options.headers ?? {}).some((key) => key.toLowerCase() === "idempotency-key");
+	return experimental_startVideo({
+		...options,
+		headers: {
+			...options.headers,
+			...hasIdempotencyKey ? {} : { "idempotency-key": `aisdk_workflow_video_${getStepMetadata().stepId}` }
+		}
+	});
 }
 startVideoStep.maxRetries = 0;
 async function getVideoStatusStep(model, options) {
-  "use step";
-  return experimental_getVideoStatus(model, options);
+	"use step";
+	return experimental_getVideoStatus(model, options);
 }
 getVideoStatusStep.maxRetries = 0;
+/**
+* Generates a video durably inside a workflow using a provider webhook.
+*
+* The workflow suspends without consuming compute until the provider calls the
+* generated webhook URL. The returned video data is not downloaded, allowing
+* the workflow to decide how to handle provider-hosted URLs.
+*/
 async function experimental_generateVideo(options) {
-  if (typeof options.model !== "string" && (options.model.specificationVersion !== "v4" || options.model.handleWebhookOption == null)) {
-    throw new Error(
-      "Workflow video generation requires a model with native webhook support."
-    );
-  }
-  let operation;
-  let startWarnings;
-  {
-    var _stack = [];
-    try {
-      const webhook = __using(_stack, createWebhook());
-      const startResult = await startVideoStep({
-        ...options,
-        webhookUrl: webhook.url
-      });
-      operation = startResult.operation;
-      startWarnings = startResult.warnings;
-      await webhook;
-    } catch (_) {
-      var _error = _, _hasError = true;
-    } finally {
-      __callDispose(_stack, _error, _hasError);
-    }
-  }
-  const statusResult = await getVideoStatusStep(options.model, {
-    operation,
-    headers: options.headers,
-    maxRetries: options.maxRetries
-  });
-  if (statusResult.status === "error") {
-    throw new Error(statusResult.error);
-  }
-  if (statusResult.status !== "completed") {
-    throw new Error(
-      "Video generation did not complete after webhook notification."
-    );
-  }
-  return {
-    ...statusResult,
-    warnings: [...startWarnings, ...statusResult.warnings]
-  };
+	if (typeof options.model !== "string" && (options.model.specificationVersion !== "v4" || options.model.handleWebhookOption == null)) throw new Error("Workflow video generation requires a model with native webhook support.");
+	let operation;
+	let startWarnings;
+	try {
+		var _usingCtx$1 = _usingCtx();
+		const webhook = _usingCtx$1.u(createWebhook());
+		const startResult = await startVideoStep({
+			...options,
+			webhookUrl: webhook.url
+		});
+		operation = startResult.operation;
+		startWarnings = startResult.warnings;
+		await webhook;
+	} catch (_) {
+		_usingCtx$1.e = _;
+	} finally {
+		_usingCtx$1.d();
+	}
+	const statusResult = await getVideoStatusStep(options.model, {
+		operation,
+		headers: options.headers,
+		maxRetries: options.maxRetries
+	});
+	if (statusResult.status === "error") throw new Error(statusResult.error);
+	if (statusResult.status !== "completed") throw new Error("Video generation did not complete after webhook notification.");
+	return {
+		...statusResult,
+		warnings: [...startWarnings, ...statusResult.warnings]
+	};
 }
-export {
-  experimental_generateVideo
-};
+//#endregion
+export { experimental_generateVideo };
+
 //# sourceMappingURL=video.js.map

package/dist/video.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/generate-video.ts"],"sourcesContent":["import {\n  experimental_getVideoStatus,\n  experimental_startVideo,\n  type GetVideoStatusResult,\n  type StartVideoResult,\n} from 'ai';\nimport { createWebhook, getStepMetadata } from 'workflow';\n\ntype StartVideoOptions = Parameters<typeof experimental_startVideo>[0];\ntype GetVideoStatusOptions = Parameters<typeof experimental_getVideoStatus>[1];\n\n/**\n * Options for durable video generation in a workflow.\n */\nexport type WorkflowGenerateVideoOptions = Omit<\n  StartVideoOptions,\n  'abortSignal' | 'webhookUrl'\n>;\n\n/**\n * A completed video generation result containing provider video data.\n * Hosted videos remain URLs and are not downloaded automatically.\n */\nexport type WorkflowGenerateVideoResult = Extract<\n  GetVideoStatusResult,\n  { status: 'completed' }\n>;\n\nasync function startVideoStep(\n  options: StartVideoOptions,\n): Promise<StartVideoResult> {\n  'use step';\n\n  const hasIdempotencyKey = Object.keys(options.headers ?? {}).some(\n    key => key.toLowerCase() === 'idempotency-key',\n  );\n\n  return experimental_startVideo({\n    ...options,\n    headers: {\n      ...options.headers,\n      ...(hasIdempotencyKey\n        ? {}\n        : {\n            'idempotency-key': `aisdk_workflow_video_${getStepMetadata().stepId}`,\n          }),\n    },\n  });\n}\n\nstartVideoStep.maxRetries = 0;\n\nasync function getVideoStatusStep(\n  model: StartVideoOptions['model'],\n  options: GetVideoStatusOptions,\n): Promise<GetVideoStatusResult> {\n  'use step';\n\n  return experimental_getVideoStatus(model, options);\n}\n\ngetVideoStatusStep.maxRetries = 0;\n\n/**\n * Generates a video durably inside a workflow using a provider webhook.\n *\n * The workflow suspends without consuming compute until the provider calls the\n * generated webhook URL. The returned video data is not downloaded, allowing\n * the workflow to decide how to handle provider-hosted URLs.\n */\nexport async function experimental_generateVideo(\n  options: WorkflowGenerateVideoOptions,\n): Promise<WorkflowGenerateVideoResult> {\n  if (\n    typeof options.model !== 'string' &&\n    (options.model.specificationVersion !== 'v4' ||\n      options.model.handleWebhookOption == null)\n  ) {\n    throw new Error(\n      'Workflow video generation requires a model with native webhook support.',\n    );\n  }\n\n  let operation: StartVideoResult['operation'];\n  let startWarnings: StartVideoResult['warnings'];\n\n  {\n    using webhook = createWebhook();\n\n    const startResult = await startVideoStep({\n      ...options,\n      webhookUrl: webhook.url,\n    });\n\n    operation = startResult.operation;\n    startWarnings = startResult.warnings;\n    await webhook;\n  }\n\n  const statusResult = await getVideoStatusStep(options.model, {\n    operation,\n    headers: options.headers,\n    maxRetries: options.maxRetries,\n  });\n\n  if (statusResult.status === 'error') {\n    throw new Error(statusResult.error);\n  }\n\n  if (statusResult.status !== 'completed') {\n    throw new Error(\n      'Video generation did not complete after webhook notification.',\n    );\n  }\n\n  return {\n    ...statusResult,\n    warnings: [...startWarnings, ...statusResult.warnings],\n  };\n}\n"],"mappings":";;;;;;AAAA;AAAA,EACE;AAAA,EACA;AAAA,OAGK;AACP,SAAS,eAAe,uBAAuB;AAsB/C,eAAe,eACb,SAC2B;AAC3B;AAEA,QAAM,oBAAoB,OAAO,KAAK,QAAQ,WAAW,CAAC,CAAC,EAAE;AAAA,IAC3D,SAAO,IAAI,YAAY,MAAM;AAAA,EAC/B;AAEA,SAAO,wBAAwB;AAAA,IAC7B,GAAG;AAAA,IACH,SAAS;AAAA,MACP,GAAG,QAAQ;AAAA,MACX,GAAI,oBACA,CAAC,IACD;AAAA,QACE,mBAAmB,wBAAwB,gBAAgB,EAAE,MAAM;AAAA,MACrE;AAAA,IACN;AAAA,EACF,CAAC;AACH;AAEA,eAAe,aAAa;AAE5B,eAAe,mBACb,OACA,SAC+B;AAC/B;AAEA,SAAO,4BAA4B,OAAO,OAAO;AACnD;AAEA,mBAAmB,aAAa;AAShC,eAAsB,2BACpB,SACsC;AACtC,MACE,OAAO,QAAQ,UAAU,aACxB,QAAQ,MAAM,yBAAyB,QACtC,QAAQ,MAAM,uBAAuB,OACvC;AACA,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AAEA,MAAI;AACJ,MAAI;AAEJ;AACE;AAAA;AAAA,YAAM,UAAU,8BAAc;AAE9B,YAAM,cAAc,MAAM,eAAe;AAAA,QACvC,GAAG;AAAA,QACH,YAAY,QAAQ;AAAA,MACtB,CAAC;AAED,kBAAY,YAAY;AACxB,sBAAgB,YAAY;AAC5B,YAAM;AAAA,aATN;AAAA;AAAA;AAAA;AAAA;AAAA,EAUF;AAEA,QAAM,eAAe,MAAM,mBAAmB,QAAQ,OAAO;AAAA,IAC3D;AAAA,IACA,SAAS,QAAQ;AAAA,IACjB,YAAY,QAAQ;AAAA,EACtB,CAAC;AAED,MAAI,aAAa,WAAW,SAAS;AACnC,UAAM,IAAI,MAAM,aAAa,KAAK;AAAA,EACpC;AAEA,MAAI,aAAa,WAAW,aAAa;AACvC,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AAAA,IACL,GAAG;AAAA,IACH,UAAU,CAAC,GAAG,eAAe,GAAG,aAAa,QAAQ;AAAA,EACvD;AACF;","names":[]}
+{"version":3,"file":"video.js","names":[],"sources":["../src/generate-video.ts"],"sourcesContent":["import {\n  experimental_getVideoStatus,\n  experimental_startVideo,\n  type GetVideoStatusResult,\n  type StartVideoResult,\n} from 'ai';\nimport { createWebhook, getStepMetadata } from 'workflow';\n\ntype StartVideoOptions = Parameters<typeof experimental_startVideo>[0];\ntype GetVideoStatusOptions = Parameters<typeof experimental_getVideoStatus>[1];\n\n/**\n * Options for durable video generation in a workflow.\n */\nexport type WorkflowGenerateVideoOptions = Omit<\n  StartVideoOptions,\n  'abortSignal' | 'webhookUrl'\n>;\n\n/**\n * A completed video generation result containing provider video data.\n * Hosted videos remain URLs and are not downloaded automatically.\n */\nexport type WorkflowGenerateVideoResult = Extract<\n  GetVideoStatusResult,\n  { status: 'completed' }\n>;\n\nasync function startVideoStep(\n  options: StartVideoOptions,\n): Promise<StartVideoResult> {\n  'use step';\n\n  const hasIdempotencyKey = Object.keys(options.headers ?? {}).some(\n    key => key.toLowerCase() === 'idempotency-key',\n  );\n\n  return experimental_startVideo({\n    ...options,\n    headers: {\n      ...options.headers,\n      ...(hasIdempotencyKey\n        ? {}\n        : {\n            'idempotency-key': `aisdk_workflow_video_${getStepMetadata().stepId}`,\n          }),\n    },\n  });\n}\n\nstartVideoStep.maxRetries = 0;\n\nasync function getVideoStatusStep(\n  model: StartVideoOptions['model'],\n  options: GetVideoStatusOptions,\n): Promise<GetVideoStatusResult> {\n  'use step';\n\n  return experimental_getVideoStatus(model, options);\n}\n\ngetVideoStatusStep.maxRetries = 0;\n\n/**\n * Generates a video durably inside a workflow using a provider webhook.\n *\n * The workflow suspends without consuming compute until the provider calls the\n * generated webhook URL. The returned video data is not downloaded, allowing\n * the workflow to decide how to handle provider-hosted URLs.\n */\nexport async function experimental_generateVideo(\n  options: WorkflowGenerateVideoOptions,\n): Promise<WorkflowGenerateVideoResult> {\n  if (\n    typeof options.model !== 'string' &&\n    (options.model.specificationVersion !== 'v4' ||\n      options.model.handleWebhookOption == null)\n  ) {\n    throw new Error(\n      'Workflow video generation requires a model with native webhook support.',\n    );\n  }\n\n  let operation: StartVideoResult['operation'];\n  let startWarnings: StartVideoResult['warnings'];\n\n  {\n    using webhook = createWebhook();\n\n    const startResult = await startVideoStep({\n      ...options,\n      webhookUrl: webhook.url,\n    });\n\n    operation = startResult.operation;\n    startWarnings = startResult.warnings;\n    await webhook;\n  }\n\n  const statusResult = await getVideoStatusStep(options.model, {\n    operation,\n    headers: options.headers,\n    maxRetries: options.maxRetries,\n  });\n\n  if (statusResult.status === 'error') {\n    throw new Error(statusResult.error);\n  }\n\n  if (statusResult.status !== 'completed') {\n    throw new Error(\n      'Video generation did not complete after webhook notification.',\n    );\n  }\n\n  return {\n    ...statusResult,\n    warnings: [...startWarnings, ...statusResult.warnings],\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,eAAe,eACb,SAC2B;CAC3B;CAEA,MAAM,oBAAoB,OAAO,KAAK,QAAQ,WAAW,CAAC,CAAC,CAAC,CAAC,MAC3D,QAAO,IAAI,YAAY,MAAM,iBAC/B;CAEA,OAAO,wBAAwB;EAC7B,GAAG;EACH,SAAS;GACP,GAAG,QAAQ;GACX,GAAI,oBACA,CAAC,IACD,EACE,mBAAmB,wBAAwB,gBAAgB,CAAC,CAAC,SAC/D;EACN;CACF,CAAC;AACH;AAEA,eAAe,aAAa;AAE5B,eAAe,mBACb,OACA,SAC+B;CAC/B;CAEA,OAAO,4BAA4B,OAAO,OAAO;AACnD;AAEA,mBAAmB,aAAa;;;;;;;;AAShC,eAAsB,2BACpB,SACsC;CACtC,IACE,OAAO,QAAQ,UAAU,aACxB,QAAQ,MAAM,yBAAyB,QACtC,QAAQ,MAAM,uBAAuB,OAEvC,MAAM,IAAI,MACR,yEACF;CAGF,IAAI;CACJ,IAAI;CAEJ,IAAA;;EACE,MAAM,UAAA,YAAA,EAAU,cAAc,CAAA;EAE9B,MAAM,cAAc,MAAM,eAAe;GACvC,GAAG;GACH,YAAY,QAAQ;EACtB,CAAC;EAED,YAAY,YAAY;EACxB,gBAAgB,YAAY;EAC5B,MAAM;;;;;;CAGR,MAAM,eAAe,MAAM,mBAAmB,QAAQ,OAAO;EAC3D;EACA,SAAS,QAAQ;EACjB,YAAY,QAAQ;CACtB,CAAC;CAED,IAAI,aAAa,WAAW,SAC1B,MAAM,IAAI,MAAM,aAAa,KAAK;CAGpC,IAAI,aAAa,WAAW,aAC1B,MAAM,IAAI,MACR,+DACF;CAGF,OAAO;EACL,GAAG;EACH,UAAU,CAAC,GAAG,eAAe,GAAG,aAAa,QAAQ;CACvD;AACF"}

package/dist/workflow-chat-transport-Bduf4ZDx.js

@@ -0,0 +1,366 @@
+import { convertAsyncIteratorToReadableStream, getErrorMessage } from "@ai-sdk/provider-utils";
+import { parseJsonEventStream, uiMessageChunkSchema } from "ai";
+import { createAsyncIterableStream } from "ai/internal";
+//#region src/normalize-ui-message-stream.ts
+const newPartFrameState = () => ({
+	open: /* @__PURE__ */ new Set(),
+	ended: /* @__PURE__ */ new Set()
+});
+/**
+* Repairs the framing for a single `*-start` / `*-delta` / `*-end` chunk
+* against the running framing state, yielding the chunks the consumer should
+* see. Text and reasoning parts share this logic (`startType` differentiates
+* the synthesized start chunk).
+*
+* @yields the chunks (possibly synthesized, possibly none) the consumer should see.
+*/
+function* repairPart(kind, id, chunk, state, startType) {
+	if (kind === "start") {
+		if (state.open.has(id) || state.ended.has(id)) return;
+		state.open.add(id);
+		yield chunk;
+		return;
+	}
+	if (state.ended.has(id)) return;
+	if (!state.open.has(id)) {
+		state.open.add(id);
+		yield {
+			type: startType,
+			id
+		};
+	}
+	if (kind === "end") {
+		state.open.delete(id);
+		state.ended.add(id);
+	}
+	yield chunk;
+}
+/**
+* Normalizes the part framing of a UI message stream so it is always
+* well-formed for the AI SDK's stream consumer (`processUIMessageStream`,
+* which backs `useChat`/`readUIMessageStream`).
+*
+* ## Why this exists
+*
+* The consumer maintains a map of "active" text/reasoning parts keyed by id.
+* A `text-delta`/`text-end` for an id that has no open part is a fatal error
+* (`Received text-delta for missing text part with ID "0" ...`) that kills the
+* whole turn. Two properties of the durable streaming model make that error
+* reachable:
+*
+* - A workflow run owns a single shared stream. Multi-step turns can reuse the
+*   same part id (commonly `"0"`), so a dropped or duplicated `*-start` can
+*   orphan the rest of that part's content.
+* - The same stream is read across reconnects, and a stream-producing step can
+*   run more than once (retry/redelivery, or the concurrent-worker duplication
+*   tracked in vercel/workflow#2331 and #2039). Either can interleave or
+*   duplicate chunks on the shared stream — e.g. a `finish-step` landing in the
+*   middle of another execution's text part.
+*
+* Since the content is still flowing and only the framing is damaged, repairing
+* the framing here degrades the worst case to "text begins slightly into the
+* step" or "a duplicated tail is dropped" instead of a dead turn.
+*
+* ## What it does
+*
+* Mirrors the consumer's explicit-end part-lifetime state machine per part type:
+* - keeps open parts active across `finish-step`, while allowing ended ids to
+*   be reused by a later step;
+* - synthesizes a missing `*-start` when an orphaned `*-delta`/`*-end` arrives;
+* - drops a re-delivered `*-start`/`*-delta`/`*-end` for a part already
+*   open or ended since the latest step boundary (reconnect/replay overlap).
+*
+* A well-formed stream passes through unchanged.
+*
+* ## Scope: text and reasoning only
+*
+* `tool-input-delta` raises the same class of fatal error (`Received
+* tool-input-delta for missing tool call ...`), but tool parts are deliberately
+* left untouched: the consumer does not reset its tool-call map on `finish-step`
+* and tool-call ids are unique, so the step-boundary id-reuse orphaning that
+* makes text/reasoning fragile does not apply to them. If a future duplication
+* mode is found to orphan tool-input parts, extend the same machine to that
+* family rather than special-casing it.
+*
+* @param source the raw UI message chunk stream to normalize.
+* @yields the framing-corrected UI message chunks.
+*/
+async function* normalizeUIMessageStreamParts(source) {
+	const text = newPartFrameState();
+	const reasoning = newPartFrameState();
+	for await (const chunk of source) switch (chunk.type) {
+		case "reset-step":
+			text.open.clear();
+			text.ended.clear();
+			reasoning.open.clear();
+			reasoning.ended.clear();
+			yield chunk;
+			break;
+		case "finish-step":
+			text.ended.clear();
+			reasoning.ended.clear();
+			yield chunk;
+			break;
+		case "text-start":
+			yield* repairPart("start", chunk.id, chunk, text, "text-start");
+			break;
+		case "text-delta":
+			yield* repairPart("delta", chunk.id, chunk, text, "text-start");
+			break;
+		case "text-end":
+			yield* repairPart("end", chunk.id, chunk, text, "text-start");
+			break;
+		case "reasoning-start":
+			yield* repairPart("start", chunk.id, chunk, reasoning, "reasoning-start");
+			break;
+		case "reasoning-delta":
+			yield* repairPart("delta", chunk.id, chunk, reasoning, "reasoning-start");
+			break;
+		case "reasoning-end":
+			yield* repairPart("end", chunk.id, chunk, reasoning, "reasoning-start");
+			break;
+		default: yield chunk;
+	}
+}
+//#endregion
+//#region src/workflow-chat-transport.ts
+function createOrphanFilter() {
+	const seenStartedIds = /* @__PURE__ */ new Set();
+	const seenStartedToolCallIds = /* @__PURE__ */ new Set();
+	let warnedOnce = false;
+	function warnOnce(orphanKind, orphanRef) {
+		if (warnedOnce) return;
+		warnedOnce = true;
+		console.warn(`[WorkflowChatTransport] Dropping orphan UI chunk (${orphanKind} for id "${orphanRef}") on resume — the resume position landed mid-part. The dropped chunk(s) reference a part whose start chunk wasn't in the resumed window. To preserve the full message, configure your stream endpoint to rewind to a step boundary before returning the readable. See: https://workflow.dev/docs/ai/resumable-streams#mid-part-resumes`);
+	}
+	function shouldDrop(chunk) {
+		switch (chunk.type) {
+			case "reset-step":
+				seenStartedIds.clear();
+				seenStartedToolCallIds.clear();
+				return false;
+			case "text-start":
+			case "reasoning-start":
+				seenStartedIds.add(chunk.id);
+				return false;
+			case "tool-input-start":
+			case "tool-input-available":
+			case "tool-input-error":
+				seenStartedToolCallIds.add(chunk.toolCallId);
+				return false;
+			case "text-delta":
+			case "text-end":
+			case "reasoning-delta":
+			case "reasoning-end":
+				if (seenStartedIds.has(chunk.id)) return false;
+				warnOnce(chunk.type, chunk.id);
+				return true;
+			case "tool-input-delta":
+			case "tool-approval-request":
+			case "tool-output-available":
+			case "tool-output-error":
+			case "tool-output-denied":
+				if (seenStartedToolCallIds.has(chunk.toolCallId)) return false;
+				warnOnce(chunk.type, chunk.toolCallId);
+				return true;
+			default: return false;
+		}
+	}
+	return { shouldDrop };
+}
+/**
+* A transport implementation for managing chat workflows with support for
+* streaming responses and automatic reconnection to interrupted streams.
+*
+* This class implements the ChatTransport interface from the AI SDK and provides
+* reliable message streaming with automatic recovery from network interruptions
+* or function timeouts.
+*
+* @template UI_MESSAGE - The type of UI messages being sent and received,
+*                        must extend the UIMessage interface from the AI SDK.
+*
+* @implements {ChatTransport<UI_MESSAGE>}
+*/
+var WorkflowChatTransport = class {
+	/**
+	* Creates a new WorkflowChatTransport instance.
+	*
+	* @param options - Configuration options for the transport
+	* @param options.api - API endpoint for chat requests (defaults to '/api/chat')
+	* @param options.fetch - Custom fetch implementation (defaults to global fetch)
+	* @param options.onChatSendMessage - Callback after sending messages
+	* @param options.onChatEnd - Callback when chat stream ends
+	* @param options.maxConsecutiveErrors - Maximum consecutive errors for reconnection
+	* @param options.prepareSendMessagesRequest - Function to prepare send messages request
+	* @param options.prepareReconnectToStreamRequest - Function to prepare reconnect request
+	*/
+	constructor(options = {}) {
+		this.api = options.api ?? "/api/chat";
+		this.fetch = options.fetch ?? fetch.bind(globalThis);
+		this.onChatSendMessage = options.onChatSendMessage;
+		this.onChatEnd = options.onChatEnd;
+		this.maxConsecutiveErrors = options.maxConsecutiveErrors ?? 3;
+		this.initialStartIndex = options.initialStartIndex ?? 0;
+		this.prepareSendMessagesRequest = options.prepareSendMessagesRequest;
+		this.prepareReconnectToStreamRequest = options.prepareReconnectToStreamRequest;
+	}
+	/**
+	* Sends messages to the chat endpoint and returns a stream of response chunks.
+	*
+	* This method handles the entire chat lifecycle including:
+	* - Sending messages to the /api/chat endpoint
+	* - Streaming response chunks
+	* - Automatic reconnection if the stream is interrupted
+	*
+	* @param options - Options for sending messages
+	* @param options.trigger - The type of message submission ('submit-message' or 'regenerate-message')
+	* @param options.chatId - Unique identifier for this chat session
+	* @param options.messageId - Optional message ID for tracking specific messages
+	* @param options.messages - Array of UI messages to send
+	* @param options.abortSignal - Optional AbortSignal to cancel the request
+	*
+	* @returns A ReadableStream of UIMessageChunk objects containing the response
+	* @throws Error if the fetch request fails or returns a non-OK status
+	*/
+	async sendMessages(options) {
+		return convertAsyncIteratorToReadableStream(normalizeUIMessageStreamParts(this.sendMessagesIterator(options)));
+	}
+	async *sendMessagesIterator(options) {
+		const { chatId, messages, abortSignal, trigger, messageId } = options;
+		let gotFinish = false;
+		let chunkIndex = 0;
+		const requestConfig = this.prepareSendMessagesRequest ? await this.prepareSendMessagesRequest({
+			id: chatId,
+			messages,
+			requestMetadata: options.metadata,
+			body: options.body,
+			credentials: void 0,
+			headers: options.headers,
+			api: this.api,
+			trigger,
+			messageId
+		}) : void 0;
+		const url = requestConfig?.api ?? this.api;
+		const response = await this.fetch(url, {
+			method: "POST",
+			body: JSON.stringify(requestConfig?.body ?? {
+				messages,
+				...options.body
+			}),
+			headers: requestConfig?.headers,
+			credentials: requestConfig?.credentials,
+			signal: abortSignal
+		});
+		if (!response.ok || !response.body) throw new Error(`Failed to fetch chat: ${response.status} ${await response.text()}`);
+		const workflowRunId = response.headers.get("x-workflow-run-id");
+		if (!workflowRunId) throw new Error("Workflow run ID not found in \"x-workflow-run-id\" response header");
+		await this.onChatSendMessage?.(response, options);
+		try {
+			const chunkStream = parseJsonEventStream({
+				stream: response.body,
+				schema: uiMessageChunkSchema
+			});
+			for await (const chunk of createAsyncIterableStream(chunkStream)) {
+				if (!chunk.success) throw chunk.error;
+				chunkIndex++;
+				yield chunk.value;
+				if (chunk.value.type === "finish") gotFinish = true;
+			}
+		} catch (error) {
+			console.error("Error in chat POST stream", error);
+		}
+		if (gotFinish) await this.onFinish(gotFinish, {
+			chatId,
+			chunkIndex
+		});
+		else yield* this.reconnectToStreamIterator(options, workflowRunId, chunkIndex);
+	}
+	/**
+	* Reconnects to an existing chat stream that was previously interrupted.
+	*
+	* This method is useful for resuming a chat session after network issues,
+	* page refreshes, or Vercel Function timeouts.
+	*
+	* @param options - Options for reconnecting to the stream
+	* @param options.chatId - The chat ID to reconnect to
+	*
+	* @returns A ReadableStream of UIMessageChunk objects
+	* @throws Error if the reconnection request fails or returns a non-OK status
+	*/
+	async reconnectToStream(options) {
+		const reconnectIterator = normalizeUIMessageStreamParts(this.reconnectToStreamIterator(options));
+		return convertAsyncIteratorToReadableStream(reconnectIterator);
+	}
+	async *reconnectToStreamIterator(options, workflowRunId, initialChunkIndex = 0) {
+		let chunkIndex = initialChunkIndex;
+		const explicitStartIndex = options.startIndex ?? this.initialStartIndex;
+		let useExplicitStartIndex = initialChunkIndex === 0 && explicitStartIndex !== 0;
+		const defaultApi = `${this.api}/${encodeURIComponent(workflowRunId ?? options.chatId)}/stream`;
+		const requestConfig = this.prepareReconnectToStreamRequest ? await this.prepareReconnectToStreamRequest({
+			id: options.chatId,
+			requestMetadata: options.metadata,
+			body: void 0,
+			credentials: void 0,
+			headers: void 0,
+			api: defaultApi
+		}) : void 0;
+		const baseUrl = requestConfig?.api ?? defaultApi;
+		let gotFinish = false;
+		let consecutiveErrors = 0;
+		let replayFromStart = false;
+		const orphanFilter = useExplicitStartIndex && explicitStartIndex < 0 ? createOrphanFilter() : null;
+		while (!gotFinish) {
+			const url = `${baseUrl}?startIndex=${useExplicitStartIndex ? explicitStartIndex : replayFromStart ? 0 : chunkIndex}`;
+			const response = await this.fetch(url, {
+				headers: requestConfig?.headers,
+				credentials: requestConfig?.credentials,
+				signal: options.abortSignal
+			});
+			if (!response.ok || !response.body) throw new Error(`Failed to fetch chat: ${response.status} ${await response.text()}`);
+			if (useExplicitStartIndex && explicitStartIndex > 0) chunkIndex = explicitStartIndex;
+			else if (useExplicitStartIndex && explicitStartIndex < 0) {
+				const tailIndexHeader = response.headers.get("x-workflow-stream-tail-index");
+				const tailIndex = tailIndexHeader !== null ? parseInt(tailIndexHeader, 10) : NaN;
+				if (!Number.isNaN(tailIndex)) chunkIndex = Math.max(0, tailIndex + 1 + explicitStartIndex);
+				else {
+					console.warn(`[WorkflowChatTransport] Negative initialStartIndex is configured (${explicitStartIndex}) but the reconnection endpoint did not return a valid "x-workflow-stream-tail-index" header. Retries will replay the stream from the beginning. See: https://workflow.dev/docs/ai/resumable-streams#resuming-from-the-end-of-the-stream`);
+					replayFromStart = true;
+				}
+			}
+			useExplicitStartIndex = false;
+			try {
+				const chunkStream = parseJsonEventStream({
+					stream: response.body,
+					schema: uiMessageChunkSchema
+				});
+				for await (const chunk of createAsyncIterableStream(chunkStream)) {
+					if (!chunk.success) throw chunk.error;
+					chunkIndex++;
+					if (orphanFilter?.shouldDrop(chunk.value)) continue;
+					yield chunk.value;
+					if (chunk.value.type === "finish") gotFinish = true;
+				}
+				consecutiveErrors = 0;
+			} catch (error) {
+				console.error("Error in chat GET reconnectToStream", error);
+				consecutiveErrors++;
+				if (consecutiveErrors >= this.maxConsecutiveErrors) throw new Error(`Failed to reconnect after ${this.maxConsecutiveErrors} consecutive errors. Last error: ${getErrorMessage(error)}`);
+			}
+		}
+		await this.onFinish(gotFinish, {
+			chatId: options.chatId,
+			chunkIndex
+		});
+	}
+	async onFinish(gotFinish, { chatId, chunkIndex }) {
+		if (gotFinish) await this.onChatEnd?.({
+			chatId,
+			chunkIndex
+		});
+		else throw new Error("No finish chunk received");
+	}
+};
+//#endregion
+export { normalizeUIMessageStreamParts as n, WorkflowChatTransport as t };
+
+//# sourceMappingURL=workflow-chat-transport-Bduf4ZDx.js.map