@ai-sdk/workflow 2.0.32 → 2.0.34

package/CHANGELOG.md

@@ -1,5 +1,34 @@
 # @ai-sdk/workflow
 
+## 2.0.34
+
+### Patch Changes
+
+- Updated dependencies [91c2128]
+- Updated dependencies [25a0447]
+- Updated dependencies [2cd80b3]
+- Updated dependencies [d06bb2a]
+- Updated dependencies [123d71f]
+- Updated dependencies [2fa5e0e]
+  - @ai-sdk/provider-utils@5.0.42
+  - ai@7.0.103
+  - @ai-sdk/provider@4.0.16
+
+## 2.0.33
+
+### Patch Changes
+
+- 0916fe8: fix(workflow): add a browser-safe client entry point for WorkflowChatTransport
+- 8f9808e: fix(workflow): make agent timeouts compatible with workflow functions
+- Updated dependencies [5c0054d]
+- Updated dependencies [39535af]
+- Updated dependencies [8b92ba9]
+- Updated dependencies [4b306c2]
+- Updated dependencies [4b306c2]
+  - @ai-sdk/provider@4.0.15
+  - ai@7.0.102
+  - @ai-sdk/provider-utils@5.0.41
+
 ## 2.0.32
 
 ### Patch Changes

package/dist/chunk-FJHDNS6E.js

@@ -0,0 +1,362 @@
+// src/normalize-ui-message-stream.ts
+var newPartFrameState = () => ({
+  open: /* @__PURE__ */ new Set(),
+  ended: /* @__PURE__ */ new Set()
+});
+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;
+}
+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;
+    }
+  }
+}
+
+// src/workflow-chat-transport.ts
+import {
+  parseJsonEventStream,
+  uiMessageChunkSchema
+} from "ai";
+import {
+  convertAsyncIteratorToReadableStream,
+  getErrorMessage
+} from "@ai-sdk/provider-utils";
+import { createAsyncIterableStream } from "ai/internal";
+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 \u2014 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":
+      // `tool-input-available` / `tool-input-error` are self-contained: the
+      // AI SDK creates the tool part from them directly (non-streamed tool
+      // calls are emitted as a bare `tool-input-available`), so they must
+      // never be dropped. They also carry the full input, so they recover a
+      // tool call whose `tool-input-start` fell outside the resumed window.
+      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 };
+}
+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 = {}) {
+    var _a, _b, _c, _d;
+    this.api = (_a = options.api) != null ? _a : "/api/chat";
+    this.fetch = (_b = options.fetch) != null ? _b : fetch.bind(globalThis);
+    this.onChatSendMessage = options.onChatSendMessage;
+    this.onChatEnd = options.onChatEnd;
+    this.maxConsecutiveErrors = (_c = options.maxConsecutiveErrors) != null ? _c : 3;
+    this.initialStartIndex = (_d = options.initialStartIndex) != null ? _d : 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) {
+    var _a, _b, _c;
+    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 = (_a = requestConfig == null ? void 0 : requestConfig.api) != null ? _a : this.api;
+    const response = await this.fetch(url, {
+      method: "POST",
+      body: JSON.stringify(
+        (_b = requestConfig == null ? void 0 : requestConfig.body) != null ? _b : { messages, ...options.body }
+      ),
+      headers: requestConfig == null ? void 0 : requestConfig.headers,
+      credentials: requestConfig == null ? void 0 : 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 ((_c = this.onChatSendMessage) == null ? void 0 : _c.call(this, 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) {
+    var _a, _b;
+    let chunkIndex = initialChunkIndex;
+    const explicitStartIndex = (_a = options.startIndex) != null ? _a : this.initialStartIndex;
+    let useExplicitStartIndex = initialChunkIndex === 0 && explicitStartIndex !== 0;
+    const defaultApi = `${this.api}/${encodeURIComponent(workflowRunId != null ? 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 = (_b = requestConfig == null ? void 0 : requestConfig.api) != null ? _b : defaultApi;
+    let gotFinish = false;
+    let consecutiveErrors = 0;
+    let replayFromStart = false;
+    const orphanFilter = useExplicitStartIndex && explicitStartIndex < 0 ? createOrphanFilter() : null;
+    while (!gotFinish) {
+      const startIndex = useExplicitStartIndex ? explicitStartIndex : replayFromStart ? 0 : chunkIndex;
+      const url = `${baseUrl}?startIndex=${startIndex}`;
+      const response = await this.fetch(url, {
+        headers: requestConfig == null ? void 0 : requestConfig.headers,
+        credentials: requestConfig == null ? void 0 : 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 == null ? void 0 : 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 }) {
+    var _a;
+    if (gotFinish) {
+      await ((_a = this.onChatEnd) == null ? void 0 : _a.call(this, { chatId, chunkIndex }));
+    } else {
+      throw new Error("No finish chunk received");
+    }
+  }
+};
+
+export {
+  normalizeUIMessageStreamParts,
+  WorkflowChatTransport
+};
+//# sourceMappingURL=chunk-FJHDNS6E.js.map

package/dist/chunk-FJHDNS6E.js.map

@@ -0,0 +1 @@
+{"version":3,"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   * 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 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        // Reset consecutive error count only after successful stream parsing\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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","names":[]}

package/dist/client.d.ts

@@ -0,0 +1,160 @@
+import { UIMessage, ChatTransport, PrepareSendMessagesRequest, PrepareReconnectToStreamRequest, ChatRequestOptions, UIMessageChunk } from 'ai';
+
+interface SendMessagesOptions<UI_MESSAGE extends UIMessage> {
+    trigger: 'submit-message' | 'regenerate-message';
+    chatId: string;
+    messageId?: string;
+    messages: UI_MESSAGE[];
+    abortSignal?: AbortSignal;
+}
+interface ReconnectToStreamOptions {
+    chatId: string;
+    abortSignal?: AbortSignal;
+    /**
+     * Override the `startIndex` for this reconnection.
+     * Negative values read from the end when the server's durable stream and
+     * tail-index header use the same UIMessageChunk index space.
+     * When omitted, falls back to the constructor's `initialStartIndex`.
+     */
+    startIndex?: number;
+}
+type OnChatSendMessage<UI_MESSAGE extends UIMessage> = (response: Response, options: SendMessagesOptions<UI_MESSAGE>) => void | Promise<void>;
+type OnChatEnd = ({ chatId, chunkIndex, }: {
+    chatId: string;
+    chunkIndex: number;
+}) => void | Promise<void>;
+/**
+ * Configuration options for the WorkflowChatTransport.
+ *
+ * @template UI_MESSAGE - The type of UI messages being sent and received,
+ *                        must extend the UIMessage interface from the AI SDK.
+ */
+interface WorkflowChatTransportOptions<UI_MESSAGE extends UIMessage> {
+    /**
+     * API endpoint for chat requests
+     * Defaults to /api/chat if not provided
+     */
+    api?: string;
+    /**
+     * Custom fetch implementation to use for HTTP requests.
+     * Defaults to the global fetch function if not provided.
+     */
+    fetch?: typeof fetch;
+    /**
+     * Callback invoked after successfully sending messages to the chat endpoint.
+     * Useful for tracking chat history and inspecting response headers.
+     *
+     * @param response - The HTTP response object from the chat endpoint
+     * @param options - The original options passed to sendMessages
+     */
+    onChatSendMessage?: OnChatSendMessage<UI_MESSAGE>;
+    /**
+     * Callback invoked when a chat stream ends (receives a "finish" chunk).
+     * Useful for cleanup operations or state updates.
+     *
+     * @param chatId - The ID of the chat that ended
+     * @param chunkIndex - The total number of chunks received
+     */
+    onChatEnd?: OnChatEnd;
+    /**
+     * Maximum number of consecutive errors allowed during reconnection attempts.
+     * Defaults to 3 if not provided.
+     */
+    maxConsecutiveErrors?: number;
+    /**
+     * Default `startIndex` to use when reconnecting to a stream without a known
+     * chunk position (i.e. the initial reconnection, not a retry).
+     * Negative values read from the end of a durable UIMessageChunk stream (e.g.
+     * `-10` fetches the last 10 chunks), which is useful for resuming a chat UI
+     * after a page refresh without replaying the full conversation. Raw
+     * ModelCallStreamPart streams do not support negative UI chunk indexes.
+     *
+     * Can be overridden per-call via `ReconnectToStreamOptions.startIndex`.
+     *
+     * Defaults to `0` (replay from the beginning).
+     */
+    initialStartIndex?: number;
+    /**
+     * Function to prepare the request for sending messages.
+     * Allows customizing the API endpoint, headers, credentials, and body.
+     */
+    prepareSendMessagesRequest?: PrepareSendMessagesRequest<UI_MESSAGE>;
+    /**
+     * Function to prepare the request for reconnecting to a stream.
+     * Allows customizing the API endpoint, headers, and credentials.
+     */
+    prepareReconnectToStreamRequest?: PrepareReconnectToStreamRequest;
+}
+/**
+ * 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>}
+ */
+declare class WorkflowChatTransport<UI_MESSAGE extends UIMessage> implements ChatTransport<UI_MESSAGE> {
+    private readonly api;
+    private readonly fetch;
+    private readonly onChatSendMessage?;
+    private readonly onChatEnd?;
+    private readonly maxConsecutiveErrors;
+    private readonly initialStartIndex;
+    private readonly prepareSendMessagesRequest?;
+    private readonly prepareReconnectToStreamRequest?;
+    /**
+     * 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?: WorkflowChatTransportOptions<UI_MESSAGE>);
+    /**
+     * 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
+     */
+    sendMessages(options: SendMessagesOptions<UI_MESSAGE> & ChatRequestOptions): Promise<ReadableStream<UIMessageChunk>>;
+    private sendMessagesIterator;
+    /**
+     * 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
+     */
+    reconnectToStream(options: ReconnectToStreamOptions & ChatRequestOptions): Promise<ReadableStream<UIMessageChunk> | null>;
+    private reconnectToStreamIterator;
+    private onFinish;
+}
+
+export { type ReconnectToStreamOptions, type SendMessagesOptions, WorkflowChatTransport, type WorkflowChatTransportOptions };

package/dist/client.js

@@ -0,0 +1,8 @@
+import {
+  WorkflowChatTransport
+} from "./chunk-FJHDNS6E.js";
+import "./chunk-UAWBPTDW.js";
+export {
+  WorkflowChatTransport
+};
+//# sourceMappingURL=client.js.map

package/dist/client.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}