@ai-sdk/workflow 2.0.8 → 2.0.12

package/dist/video.d.ts

@@ -0,0 +1,24 @@
+import { experimental_startVideo, GetVideoStatusResult } from 'ai';
+
+type StartVideoOptions = Parameters<typeof experimental_startVideo>[0];
+/**
+ * Options for durable video generation in a workflow.
+ */
+type WorkflowGenerateVideoOptions = Omit<StartVideoOptions, 'abortSignal' | 'webhookUrl'>;
+/**
+ * A completed video generation result containing provider video data.
+ * Hosted videos remain URLs and are not downloaded automatically.
+ */
+type WorkflowGenerateVideoResult = Extract<GetVideoStatusResult, {
+    status: 'completed';
+}>;
+/**
+ * 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.
+ */
+declare function experimental_generateVideo(options: WorkflowGenerateVideoOptions): Promise<WorkflowGenerateVideoResult>;
+
+export { type WorkflowGenerateVideoOptions, type WorkflowGenerateVideoResult, experimental_generateVideo };

package/dist/video.js

@@ -0,0 +1,80 @@
+import {
+  __callDispose,
+  __using
+} from "./chunk-UAWBPTDW.js";
+
+// src/generate-video.ts
+import {
+  experimental_getVideoStatus,
+  experimental_startVideo
+} from "ai";
+import { createWebhook, getStepMetadata } from "workflow";
+async function startVideoStep(options) {
+  "use step";
+  var _a;
+  const hasIdempotencyKey = Object.keys((_a = options.headers) != null ? _a : {}).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);
+}
+getVideoStatusStep.maxRetries = 0;
+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]
+  };
+}
+export {
+  experimental_generateVideo
+};
+//# sourceMappingURL=video.js.map

package/dist/video.js.map

@@ -0,0 +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;AA/BF;AAiCE,QAAM,oBAAoB,OAAO,MAAK,aAAQ,YAAR,YAAmB,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":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/workflow",
-  "version": "2.0.8",
+  "version": "2.0.12",
   "type": "module",
   "description": "WorkflowAgent for building AI agents with AI SDK",
   "license": "Apache-2.0",
@@ -23,23 +23,28 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
       "default": "./dist/index.js"
+    },
+    "./video": {
+      "types": "./dist/video.d.ts",
+      "import": "./dist/video.js",
+      "default": "./dist/video.js"
     }
   },
   "dependencies": {
-    "ajv": "^8.20.0",
-    "@ai-sdk/provider": "4.0.7",
-    "@ai-sdk/provider-utils": "5.0.29",
-    "ai": "7.0.78"
+    "@ai-sdk/provider": "4.0.8",
+    "@ai-sdk/provider-utils": "5.0.32",
+    "ai": "7.0.82",
+    "ajv": "^8.20.0"
   },
   "devDependencies": {
     "@types/node": "22.19.19",
+    "@vercel/ai-tsconfig": "0.0.0",
     "@workflow/vitest": "5.0.0-beta.42",
     "tsup": "^8.5.1",
     "typescript": "5.8.3",
     "vitest": "4.1.6",
     "workflow": "5.0.0-beta.42",
-    "zod": "4.4.3",
-    "@vercel/ai-tsconfig": "0.0.0"
+    "zod": "4.4.3"
   },
   "peerDependencies": {
     "workflow": "^5.0.0-beta.42",

package/src/generate-video.ts

@@ -0,0 +1,120 @@
+import {
+  experimental_getVideoStatus,
+  experimental_startVideo,
+  type GetVideoStatusResult,
+  type StartVideoResult,
+} from 'ai';
+import { createWebhook, getStepMetadata } from 'workflow';
+
+type StartVideoOptions = Parameters<typeof experimental_startVideo>[0];
+type GetVideoStatusOptions = Parameters<typeof experimental_getVideoStatus>[1];
+
+/**
+ * Options for durable video generation in a workflow.
+ */
+export type WorkflowGenerateVideoOptions = Omit<
+  StartVideoOptions,
+  'abortSignal' | 'webhookUrl'
+>;
+
+/**
+ * A completed video generation result containing provider video data.
+ * Hosted videos remain URLs and are not downloaded automatically.
+ */
+export type WorkflowGenerateVideoResult = Extract<
+  GetVideoStatusResult,
+  { status: 'completed' }
+>;
+
+async function startVideoStep(
+  options: StartVideoOptions,
+): Promise<StartVideoResult> {
+  '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: StartVideoOptions['model'],
+  options: GetVideoStatusOptions,
+): Promise<GetVideoStatusResult> {
+  '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.
+ */
+export async function experimental_generateVideo(
+  options: WorkflowGenerateVideoOptions,
+): Promise<WorkflowGenerateVideoResult> {
+  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: StartVideoResult['operation'];
+  let startWarnings: StartVideoResult['warnings'];
+
+  {
+    using webhook = createWebhook();
+
+    const startResult = await startVideoStep({
+      ...options,
+      webhookUrl: webhook.url,
+    });
+
+    operation = startResult.operation;
+    startWarnings = startResult.warnings;
+    await webhook;
+  }
+
+  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],
+  };
+}

package/src/normalize-ui-message-stream.ts

@@ -2,12 +2,12 @@ import type { UIMessageChunk } from 'ai';
 
 /**
  * Tracks, for one part family (text or reasoning), which part ids are open or
- * ended within the current step.
+ * have ended since the latest step boundary.
  */
 interface PartFrameState {
-  /** A `*-start` was seen and not yet ended in the current step. */
+  /** A `*-start` was seen and has not yet received its explicit `*-end`. */
   open: Set<string>;
-  /** A part that was opened and ended in the current step. */
+  /** A part that ended since the latest step boundary. */
   ended: Set<string>;
 }
 
@@ -18,7 +18,7 @@ const newPartFrameState = (): PartFrameState => ({
 
 /**
  * Repairs the framing for a single `*-start` / `*-delta` / `*-end` chunk
- * against the running per-step state, yielding the chunks the consumer should
+ * 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).
  *
@@ -32,7 +32,8 @@ function* repairPart(
   startType: 'text-start' | 'reasoning-start',
 ): Generator<UIMessageChunk> {
   if (kind === 'start') {
-    // Drop a duplicate/replayed start for a part already framed this step.
+    // Drop a duplicate/replayed start for a part that is still open or has
+    // already ended since the latest step boundary.
     if (state.open.has(id) || state.ended.has(id)) {
       return;
     }
@@ -70,10 +71,9 @@ function* repairPart(
  * whole turn. Two properties of the durable streaming model make that error
  * reachable:
  *
- * - A workflow run owns a single shared stream, and the consumer resets its
- *   active-part maps on every `finish-step`. Multi-step turns reuse the same
- *   part id (commonly `"0"`) in each step, so a single dropped or duplicated
- *   `*-start` across a step boundary orphans the rest of that step's content.
+ * - 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
@@ -86,11 +86,12 @@ function* repairPart(
  *
  * ## What it does
  *
- * Mirrors the consumer's part-lifetime state machine, per part type, per step:
- * - resets tracking on `finish-step` (exactly where the consumer resets);
+ * 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 in the current step (reconnect/replay overlap).
+ *   open or ended since the latest step boundary (reconnect/replay overlap).
  *
  * A well-formed stream passes through unchanged.
  *
@@ -126,11 +127,10 @@ export async function* normalizeUIMessageStreamParts(
         break;
 
       case 'finish-step':
-        // The consumer clears its active-part maps here, so part ids may be
-        // legitimately reused in the next step. Reset to match.
-        text.open.clear();
+        // Open parts are closed only by explicit end chunks. A finish-step can
+        // come from another interleaved execution while a part is still open.
+        // Ended ids may be reused by the next step.
         text.ended.clear();
-        reasoning.open.clear();
         reasoning.ended.clear();
         yield chunk;
         break;

package/src/serializable-schema.ts

@@ -27,6 +27,10 @@ import Ajv from 'ajv';
 export type SerializableToolDef = {
   description?: string;
   inputSchema: JSONSchema7;
+  /** Input examples forwarded to providers that support them. */
+  inputExamples?: Array<{ input: unknown }>;
+  /** Provider-specific options attached to the tool definition. */
+  providerOptions?: Tool['providerOptions'];
   /** Present on provider tools (e.g. anthropic.tools.webSearch). */
   type?: 'provider';
   /** Provider tool is executed by the provider. */
@@ -38,10 +42,9 @@ export type SerializableToolDef = {
 };
 
 /**
- * Converts a ToolSet (with zod/standard schemas and execute functions) to a
- * serializable record of tool definitions. Only description and inputSchema
- * (as JSON Schema) are preserved — execute functions are stripped since they
- * run outside the step.
+ * Converts a ToolSet (with Zod/standard schemas and execute functions) to a
+ * serializable record of tool definitions. Execution functions and callbacks
+ * are stripped because they run outside the step.
  */
 export function serializeToolSet<TOOLS extends ToolSet>(
   tools: TOOLS,
@@ -63,6 +66,8 @@ export function serializeToolSet<TOOLS extends ToolSet>(
           experimental_sandbox: sandbox,
         }),
         inputSchema: asSchema(t.inputSchema).jsonSchema as JSONSchema7,
+        inputExamples: t.inputExamples,
+        providerOptions: t.providerOptions,
       };
 
       // Preserve provider tool identity so the Gateway can recognize
@@ -125,6 +130,7 @@ export function resolveSerializableTools(
             args: t.args ?? {},
             isProviderExecuted: t.isProviderExecuted ?? false,
             inputSchema: jsonSchema(t.inputSchema),
+            providerOptions: t.providerOptions,
           }),
         ];
       }
@@ -135,6 +141,8 @@ export function resolveSerializableTools(
         name,
         tool({
           description: t.description,
+          inputExamples: t.inputExamples,
+          providerOptions: t.providerOptions,
           inputSchema: jsonSchema(t.inputSchema, {
             validate: value => {
               if (validateFn(value)) {

package/src/test/serializable-video-model.ts

@@ -0,0 +1,87 @@
+import type { Experimental_VideoModelV4 } from '@ai-sdk/provider';
+import {
+  WORKFLOW_DESERIALIZE,
+  WORKFLOW_SERIALIZE,
+} from '@ai-sdk/provider-utils';
+import { resumeWebhook } from 'workflow/api';
+
+class SerializableVideoModel implements Experimental_VideoModelV4 {
+  readonly specificationVersion = 'v4';
+  readonly provider = 'workflow-test';
+  readonly modelId = 'workflow-test-video';
+  readonly maxVideosPerCall = 1;
+
+  static [WORKFLOW_SERIALIZE]() {
+    return {};
+  }
+
+  static [WORKFLOW_DESERIALIZE]() {
+    return new SerializableVideoModel();
+  }
+
+  async handleWebhookOption({
+    webhook,
+  }: Parameters<
+    NonNullable<Experimental_VideoModelV4['handleWebhookOption']>
+  >[0]) {
+    const result = await webhook();
+    return { webhookUrl: result.url, received: result.received };
+  }
+
+  async doStart(
+    options: Parameters<NonNullable<Experimental_VideoModelV4['doStart']>>[0],
+  ) {
+    if (options.webhookUrl == null) {
+      throw new Error('Expected a webhook URL.');
+    }
+
+    const webhookUrl = new URL(options.webhookUrl);
+    const token = webhookUrl.pathname.split('/').at(-1);
+    if (token == null || token.length === 0) {
+      throw new Error('Expected a webhook token.');
+    }
+
+    const response = await resumeWebhook(
+      token,
+      new Request(options.webhookUrl, { method: 'POST' }),
+    );
+    if (!response.ok) {
+      throw new Error(
+        `Webhook delivery failed with status ${response.status}.`,
+      );
+    }
+
+    return {
+      operation: { id: 'operation-1' },
+      warnings: [{ type: 'other' as const, message: 'start warning' }],
+      response: {
+        timestamp: new Date(0),
+        modelId: this.modelId,
+        headers: {},
+      },
+    };
+  }
+
+  async doStatus() {
+    return {
+      status: 'completed' as const,
+      videos: [
+        {
+          type: 'url' as const,
+          url: 'https://example.com/video.mp4',
+          mediaType: 'video/mp4',
+        },
+      ],
+      warnings: [],
+      response: {
+        timestamp: new Date(0),
+        modelId: this.modelId,
+        headers: {},
+      },
+    };
+  }
+}
+
+export function createSerializableVideoModel(): Experimental_VideoModelV4 {
+  return new SerializableVideoModel();
+}

package/src/test/video-generation-workflow.ts

@@ -0,0 +1,11 @@
+import { experimental_generateVideo } from '../generate-video.js';
+import { createSerializableVideoModel } from './serializable-video-model.js';
+
+export async function videoGenerationWorkflow() {
+  'use workflow';
+
+  return experimental_generateVideo({
+    model: createSerializableVideoModel(),
+    prompt: 'A lighthouse in fog',
+  });
+}

package/src/video.ts

@@ -0,0 +1,5 @@
+export {
+  experimental_generateVideo,
+  type WorkflowGenerateVideoOptions,
+  type WorkflowGenerateVideoResult,
+} from './generate-video.js';