@genkit-ai/vercel-ai 0.2.0-rc.0

package/lib/client.mjs

@@ -0,0 +1,345 @@
+import { applyPatch, streamFlow } from "genkit/beta/client";
+import {
+  asRestartInterrupt,
+  currentTurnResolvedTools,
+  findLastNonEmptyUserMessage,
+  mapUIMessageToGenkit
+} from "./mapping.mjs";
+import {
+  mapGenkitMessageToUI,
+  messagesFromSnapshot,
+  restartInterrupt
+} from "./mapping.mjs";
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function errorTextFromUnknown(err) {
+  if (err instanceof Error) {
+    return err.message || "Agent execution failed";
+  }
+  if (typeof err === "string") {
+    return err || "Agent execution failed";
+  }
+  if (err === void 0 || err === null) {
+    return "Agent execution failed";
+  }
+  try {
+    return JSON.stringify(err);
+  } catch {
+    return String(err);
+  }
+}
+function errorStream(errorText) {
+  return new ReadableStream({
+    start(controller) {
+      controller.enqueue({
+        type: "start",
+        messageId: `msg-${crypto.randomUUID()}`
+      });
+      controller.enqueue({ type: "error", errorText });
+      controller.enqueue({ type: "finish" });
+      controller.close();
+    }
+  });
+}
+class GenkitChatTransport {
+  url;
+  headersConfig;
+  constructor(config) {
+    this.url = config.url;
+    this.headersConfig = config.headers;
+  }
+  resolveHeaders(extra) {
+    const base = typeof this.headersConfig === "function" ? this.headersConfig() : this.headersConfig;
+    let extraRecord;
+    if (extra instanceof Headers) {
+      extraRecord = {};
+      extra.forEach((value, key) => {
+        extraRecord[key] = value;
+      });
+    } else {
+      extraRecord = extra;
+    }
+    if (!base && !extraRecord) return void 0;
+    return { ...base, ...extraRecord };
+  }
+  // The `trigger` parameter is either 'submit-message' (a new user turn) or
+  // 'regenerate-message' (re-run the last assistant response). Because state
+  // is server-managed by `sessionId`, regeneration is treated as a fresh turn
+  // from the current session state (there is no client-side snapshot pointer
+  // to rewind to).
+  async sendMessages({
+    trigger,
+    chatId,
+    messages,
+    abortSignal,
+    headers
+  }) {
+    if (!UUID_PATTERN.test(chatId)) {
+      return errorStream(
+        `Invalid chatId '${chatId}': the useChat 'id' is used as the Genkit sessionId and must be a UUID. Generate one with crypto.randomUUID().`
+      );
+    }
+    const isRegenerate = trigger === "regenerate-message";
+    const resolvedTools = isRegenerate ? [] : currentTurnResolvedTools(messages);
+    const isResume = resolvedTools.length > 0;
+    const init = { sessionId: chatId };
+    let agentInput;
+    const respondedInterruptIds = /* @__PURE__ */ new Set();
+    if (isResume) {
+      const respond = [];
+      const restart = [];
+      for (const tr of resolvedTools) {
+        const asRestart = asRestartInterrupt(tr.result);
+        if (asRestart) {
+          restart.push({
+            toolRequest: {
+              name: tr.toolName,
+              ref: tr.toolCallId,
+              input: tr.input
+            },
+            metadata: { resumed: asRestart.metadata ?? true }
+          });
+        } else {
+          respondedInterruptIds.add(tr.toolCallId);
+          respond.push({
+            toolResponse: {
+              name: tr.toolName,
+              ref: tr.toolCallId,
+              output: tr.result
+            }
+          });
+        }
+      }
+      agentInput = {
+        resume: {
+          ...respond.length > 0 && { respond },
+          ...restart.length > 0 && { restart }
+        }
+      };
+    } else {
+      const lastUserMsg = findLastNonEmptyUserMessage(messages);
+      if (!lastUserMsg) {
+        return errorStream("No user message found");
+      }
+      const genkitMsg = mapUIMessageToGenkit(lastUserMsg);
+      agentInput = { message: genkitMsg };
+    }
+    const response = streamFlow({
+      url: this.url,
+      input: agentInput,
+      init,
+      headers: this.resolveHeaders(headers),
+      abortSignal
+    });
+    let aborted = false;
+    return new ReadableStream({
+      start: async (controller) => {
+        const onAbort = () => {
+          aborted = true;
+        };
+        abortSignal?.addEventListener("abort", onAbort, { once: true });
+        let started = false;
+        let textBlockId = null;
+        let reasoningBlockId = null;
+        let inStep = false;
+        let customState;
+        const emittedToolInputs = /* @__PURE__ */ new Set();
+        const pendingRefByToolName = /* @__PURE__ */ new Map();
+        const correlateRequestId = (name) => {
+          const id = crypto.randomUUID();
+          const queue = pendingRefByToolName.get(name) ?? [];
+          queue.push(id);
+          pendingRefByToolName.set(name, queue);
+          return id;
+        };
+        const correlateResponseId = (name) => {
+          const queue = pendingRefByToolName.get(name);
+          if (queue && queue.length > 0) {
+            return queue.shift();
+          }
+          return crypto.randomUUID();
+        };
+        const enqueue = (chunk) => {
+          try {
+            controller.enqueue(chunk);
+          } catch {
+          }
+        };
+        const ensureStarted = () => {
+          if (!started) {
+            enqueue({
+              type: "start",
+              messageId: `msg-${crypto.randomUUID()}`
+            });
+            started = true;
+          }
+        };
+        const ensureStep = () => {
+          if (!inStep) {
+            enqueue({ type: "start-step" });
+            inStep = true;
+          }
+        };
+        const closeTextBlock = () => {
+          if (textBlockId) {
+            enqueue({ type: "text-end", id: textBlockId });
+            textBlockId = null;
+          }
+        };
+        const closeReasoningBlock = () => {
+          if (reasoningBlockId) {
+            enqueue({ type: "reasoning-end", id: reasoningBlockId });
+            reasoningBlockId = null;
+          }
+        };
+        const closeStep = () => {
+          if (inStep) {
+            enqueue({ type: "finish-step" });
+            inStep = false;
+          }
+        };
+        try {
+          for await (const chunk of response.stream) {
+            if (aborted) break;
+            if (chunk?.customPatch) {
+              customState = applyPatch(customState, chunk.customPatch);
+              ensureStarted();
+              enqueue({
+                type: "data-custom",
+                data: customState,
+                transient: true
+              });
+            }
+            const mc = chunk?.modelChunk;
+            if (!mc?.content) continue;
+            ensureStarted();
+            for (const part of mc.content) {
+              if (typeof part.reasoning === "string" && part.reasoning !== "") {
+                ensureStep();
+                if (!reasoningBlockId) {
+                  reasoningBlockId = `reasoning-${crypto.randomUUID()}`;
+                  enqueue({ type: "reasoning-start", id: reasoningBlockId });
+                }
+                enqueue({
+                  type: "reasoning-delta",
+                  id: reasoningBlockId,
+                  delta: part.reasoning
+                });
+              }
+              if (part.text !== void 0 && part.text !== "") {
+                closeReasoningBlock();
+                ensureStep();
+                if (!textBlockId) {
+                  textBlockId = `text-${crypto.randomUUID()}`;
+                  enqueue({ type: "text-start", id: textBlockId });
+                }
+                enqueue({
+                  type: "text-delta",
+                  id: textBlockId,
+                  delta: part.text
+                });
+              }
+              if (part.toolRequest) {
+                const tr = part.toolRequest;
+                const toolCallId = tr.ref ?? correlateRequestId(tr.name);
+                if (!emittedToolInputs.has(toolCallId)) {
+                  emittedToolInputs.add(toolCallId);
+                  closeReasoningBlock();
+                  closeTextBlock();
+                  ensureStep();
+                  enqueue({
+                    type: "tool-input-start",
+                    toolCallId,
+                    toolName: tr.name
+                  });
+                  enqueue({
+                    type: "tool-input-available",
+                    toolCallId,
+                    toolName: tr.name,
+                    input: tr.input
+                  });
+                }
+              }
+              if (part.toolResponse) {
+                const tr = part.toolResponse;
+                const toolCallId = tr.ref ?? correlateResponseId(tr.name);
+                if (!respondedInterruptIds.has(toolCallId)) {
+                  enqueue({
+                    type: "tool-output-available",
+                    toolCallId,
+                    output: tr.output
+                  });
+                  closeStep();
+                }
+              }
+            }
+            if (chunk?.turnEnd) {
+              closeReasoningBlock();
+              closeTextBlock();
+              closeStep();
+            }
+          }
+          if (aborted) {
+            ensureStarted();
+            closeReasoningBlock();
+            closeTextBlock();
+            closeStep();
+            enqueue({ type: "abort", reason: "Request was aborted" });
+            enqueue({ type: "finish" });
+            try {
+              controller.close();
+            } catch {
+            }
+            return;
+          }
+          await response.output;
+        } catch (err) {
+          if (err instanceof DOMException && err.name === "AbortError") {
+            ensureStarted();
+            closeReasoningBlock();
+            closeTextBlock();
+            closeStep();
+            enqueue({ type: "abort", reason: "Request was aborted" });
+          } else {
+            ensureStarted();
+            enqueue({
+              type: "error",
+              errorText: errorTextFromUnknown(err)
+            });
+          }
+        } finally {
+          closeReasoningBlock();
+          closeTextBlock();
+          closeStep();
+          ensureStarted();
+          enqueue({ type: "finish" });
+          abortSignal?.removeEventListener("abort", onAbort);
+          try {
+            controller.close();
+          } catch {
+          }
+        }
+      },
+      cancel: () => {
+        aborted = true;
+      }
+    });
+  }
+  /**
+   * Genkit transport does not support stream reconnection.
+   *
+   * Genkit has a durable streaming feature on the server side; support
+   * for reconnection may be added in a future version.
+   *
+   * @returns Always returns `null`.
+   */
+  async reconnectToStream() {
+    return null;
+  }
+}
+export {
+  GenkitChatTransport,
+  mapGenkitMessageToUI,
+  messagesFromSnapshot,
+  restartInterrupt
+};
+//# sourceMappingURL=client.mjs.map

package/lib/client.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/client.ts"],"sourcesContent":["/**\n * Copyright 2026 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport type { ChatTransport, UIMessage, UIMessageChunk } from 'ai';\n// Type-only imports are erased at compile time, so importing from `genkit`\n// keeps this module browser-safe (no Node-only runtime code is pulled in)\n// while staying in sync with the canonical agent protocol types.\nimport type { AgentOutput, AgentStreamChunk } from 'genkit/beta';\nimport { applyPatch, streamFlow } from 'genkit/beta/client';\n\nimport {\n  asRestartInterrupt,\n  currentTurnResolvedTools,\n  findLastNonEmptyUserMessage,\n  mapUIMessageToGenkit,\n} from './mapping.mjs';\n\nexport {\n  mapGenkitMessageToUI,\n  messagesFromSnapshot,\n  restartInterrupt,\n} from './mapping.mjs';\nexport type { ResolvedToolResult, RestartInterruptOutput } from './mapping.mjs';\n\nexport type { ChatTransport, UIMessage, UIMessageChunk };\n\n// A bare RFC-4122 UUID, used to validate `chatId` (which doubles as the Genkit\n// `sessionId`). The agent server requires session ids to be bare UUIDs, so we\n// validate client-side too for a clearer, earlier error.\nconst UUID_PATTERN =\n  /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;\n\n/**\n * Derives a human-readable error message from an unknown thrown value,\n * preserving as much context as possible.\n *\n * `streamFlow` throws `Error`s whose `.message` already embeds the HTTP status\n * and any Genkit error status/message/details, so those are returned verbatim.\n * Non-Error throwables are stringified (JSON when possible) instead of being\n * collapsed to a generic label, so detail isn't silently lost.\n */\nfunction errorTextFromUnknown(err: unknown): string {\n  if (err instanceof Error) {\n    return err.message || 'Agent execution failed';\n  }\n  if (typeof err === 'string') {\n    return err || 'Agent execution failed';\n  }\n  if (err === undefined || err === null) {\n    return 'Agent execution failed';\n  }\n  try {\n    return JSON.stringify(err);\n  } catch {\n    return String(err);\n  }\n}\n\n/**\n * Builds a `ReadableStream` that emits a single error inside the standard\n * `start`/`error`/`finish` envelope, matching the shape of a normal stream.\n */\nfunction errorStream(errorText: string): ReadableStream<UIMessageChunk> {\n  return new ReadableStream<UIMessageChunk>({\n    start(controller) {\n      controller.enqueue({\n        type: 'start',\n        messageId: `msg-${crypto.randomUUID()}`,\n      });\n      controller.enqueue({ type: 'error', errorText });\n      controller.enqueue({ type: 'finish' });\n      controller.close();\n    },\n  });\n}\n\n// ---------------------------------------------------------------------------\n// GenkitChatTransport\n// ---------------------------------------------------------------------------\n\n/**\n * Configuration for {@link GenkitChatTransport}.\n */\nexport interface GenkitChatTransportConfig {\n  /** URL of the Genkit agent endpoint (e.g. `/api/weatherAgent`). */\n  url: string;\n\n  /**\n   * Additional HTTP headers to include in every request.\n   * Can be a static object or a function that returns headers (useful for\n   * dynamic auth tokens).\n   */\n  headers?: Record<string, string> | (() => Record<string, string>);\n}\n\n/**\n * A Vercel AI SDK `ChatTransport` implementation that communicates with a\n * Genkit agent using Genkit's native streaming protocol via `streamFlow`.\n *\n * Conversation state is **fully server-managed**: the transport sends the\n * `useChat` `id` (the `chatId`) to the agent as its `sessionId`, and the agent\n * persists per-session state in its configured `SessionStore`. Each turn\n * resumes the session's latest snapshot automatically — there is no\n * client-side snapshot bookkeeping to manage or persist.\n *\n * Because the agent server requires session ids to be bare UUIDs, the\n * `chatId` (the `id` you pass to `useChat`) must be a UUID. Generate one with\n * `crypto.randomUUID()`.\n *\n * Interrupt resumes are derived directly from the `messages` the SDK already\n * holds: when the latest turn's assistant message carries resolved tool\n * outputs (e.g. via `addToolResult`), the transport sends them back to the\n * agent as a `resume` payload.\n *\n * @example\n * ```tsx\n * import { useMemo } from 'react';\n * import { useChat } from '@ai-sdk/react';\n * import { GenkitChatTransport } from '@genkit-ai/vercel-ai/client';\n *\n * const chatId = useMemo(() => crypto.randomUUID(), []);\n * const { messages, sendMessage } = useChat({\n *   id: chatId,\n *   transport: new GenkitChatTransport({\n *     url: '/api/weatherAgent',\n *   }),\n * });\n * ```\n */\nexport class GenkitChatTransport implements ChatTransport<UIMessage> {\n  private readonly url: string;\n  private readonly headersConfig?:\n    | Record<string, string>\n    | (() => Record<string, string>);\n\n  constructor(config: GenkitChatTransportConfig) {\n    this.url = config.url;\n    this.headersConfig = config.headers;\n  }\n\n  private resolveHeaders(\n    extra?: Record<string, string> | Headers\n  ): Record<string, string> | undefined {\n    const base =\n      typeof this.headersConfig === 'function'\n        ? this.headersConfig()\n        : this.headersConfig;\n    // Normalize Headers objects to plain records.\n    let extraRecord: Record<string, string> | undefined;\n    if (extra instanceof Headers) {\n      extraRecord = {};\n      extra.forEach((value, key) => {\n        extraRecord![key] = value;\n      });\n    } else {\n      extraRecord = extra;\n    }\n    if (!base && !extraRecord) return undefined;\n    return { ...base, ...extraRecord };\n  }\n\n  // The `trigger` parameter is either 'submit-message' (a new user turn) or\n  // 'regenerate-message' (re-run the last assistant response). Because state\n  // is server-managed by `sessionId`, regeneration is treated as a fresh turn\n  // from the current session state (there is no client-side snapshot pointer\n  // to rewind to).\n  async sendMessages({\n    trigger,\n    chatId,\n    messages,\n    abortSignal,\n    headers,\n  }: {\n    trigger: 'submit-message' | 'regenerate-message';\n    chatId: string;\n    messageId: string | undefined;\n    messages: UIMessage[];\n    abortSignal: AbortSignal | undefined;\n    headers?: Record<string, string> | Headers;\n    body?: object;\n    metadata?: unknown;\n  }): Promise<ReadableStream<UIMessageChunk>> {\n    // `chatId` doubles as the Genkit session id and must be a bare UUID.\n    if (!UUID_PATTERN.test(chatId)) {\n      return errorStream(\n        `Invalid chatId '${chatId}': the useChat 'id' is used as the Genkit ` +\n          `sessionId and must be a UUID. Generate one with crypto.randomUUID().`\n      );\n    }\n\n    const isRegenerate = trigger === 'regenerate-message';\n\n    // Detect an interrupt resume from the message history alone: the current\n    // turn's assistant message(s) carry resolved tool outputs that have not\n    // been followed by a new user message. Regeneration never resumes an\n    // interrupt — it replays from the current session state.\n    const resolvedTools = isRegenerate\n      ? []\n      : currentTurnResolvedTools(messages);\n    const isResume = resolvedTools.length > 0;\n\n    // The session id is always sent so the agent resumes (or seeds) the\n    // server-managed session for this chat.\n    const init: Record<string, unknown> = { sessionId: chatId };\n    let agentInput: Record<string, unknown>;\n\n    // Tool call ids that were resolved with a user-supplied *response* (not a\n    // restart). Their outputs are already on the client, so the transport\n    // suppresses re-emitting them. Restarted tools, by contrast, re-execute\n    // server-side and produce a *fresh* output that the client must receive.\n    const respondedInterruptIds = new Set<string>();\n\n    if (isResume) {\n      // Split resolutions into restarts (re-run the tool) and responds\n      // (user-supplied output). A single resume turn can carry both.\n      const respond: Array<Record<string, unknown>> = [];\n      const restart: Array<Record<string, unknown>> = [];\n      for (const tr of resolvedTools) {\n        const asRestart = asRestartInterrupt(tr.result);\n        if (asRestart) {\n          // A restart re-runs the tool with the *original* input (the server\n          // validates it matches the interrupted request exactly) and passes\n          // any metadata through as the tool's `resumed` value.\n          restart.push({\n            toolRequest: {\n              name: tr.toolName,\n              ref: tr.toolCallId,\n              input: tr.input,\n            },\n            metadata: { resumed: asRestart.metadata ?? true },\n          });\n        } else {\n          respondedInterruptIds.add(tr.toolCallId);\n          respond.push({\n            toolResponse: {\n              name: tr.toolName,\n              ref: tr.toolCallId,\n              output: tr.result,\n            },\n          });\n        }\n      }\n      agentInput = {\n        resume: {\n          ...(respond.length > 0 && { respond }),\n          ...(restart.length > 0 && { restart }),\n        },\n      };\n    } else {\n      const lastUserMsg = findLastNonEmptyUserMessage(messages);\n      if (!lastUserMsg) {\n        return errorStream('No user message found');\n      }\n\n      const genkitMsg = mapUIMessageToGenkit(lastUserMsg);\n      agentInput = { message: genkitMsg };\n    }\n\n    // Call streamFlow — Genkit's native streaming protocol.\n    const response = streamFlow<AgentOutput, AgentStreamChunk>({\n      url: this.url,\n      input: agentInput,\n      init,\n      headers: this.resolveHeaders(headers),\n      abortSignal,\n    });\n\n    // Track whether the stream was aborted so we can emit a clean abort chunk.\n    let aborted = false;\n\n    return new ReadableStream<UIMessageChunk>({\n      start: async (controller) => {\n        // Listen for abort to break out of the streaming loop cleanly.\n        const onAbort = () => {\n          aborted = true;\n        };\n        abortSignal?.addEventListener('abort', onAbort, { once: true });\n\n        // Streaming state machine.\n        let started = false;\n        let textBlockId: string | null = null;\n        let reasoningBlockId: string | null = null;\n        let inStep = false;\n        // Locally tracked agent custom state, kept live by applying each\n        // streamed RFC 6902 JSON Patch (`chunk.customPatch`). The first patch\n        // of a turn is a whole-document replace that re-bases us onto the\n        // server's current baseline.\n        let customState: unknown;\n        const emittedToolInputs = new Set<string>();\n\n        // Deterministic fallback for tool calls that arrive without a `ref`.\n        // The model may omit refs, in which case the request and its matching\n        // response must still share the same `toolCallId`.\n        //\n        // We pair each ref-less response with the *oldest* unmatched ref-less\n        // request for the same tool name (FIFO by arrival order). Allocating a\n        // fresh id per request — rather than reusing one id per tool name —\n        // means two ref-less calls to the *same* tool in one turn don't share\n        // an id and cross-wire each other's request/response. (In practice\n        // Genkit tool requests carry refs, so this is a safety net.)\n        const pendingRefByToolName = new Map<string, string[]>();\n        const correlateRequestId = (name: string): string => {\n          const id = crypto.randomUUID();\n          const queue = pendingRefByToolName.get(name) ?? [];\n          queue.push(id);\n          pendingRefByToolName.set(name, queue);\n          return id;\n        };\n        const correlateResponseId = (name: string): string => {\n          const queue = pendingRefByToolName.get(name);\n          if (queue && queue.length > 0) {\n            return queue.shift()!;\n          }\n          // No matching request seen (shouldn't happen) — mint a new id.\n          return crypto.randomUUID();\n        };\n\n        const enqueue = (chunk: UIMessageChunk) => {\n          try {\n            controller.enqueue(chunk);\n          } catch {\n            // Controller already closed (e.g. consumer cancelled).\n          }\n        };\n\n        const ensureStarted = () => {\n          if (!started) {\n            enqueue({\n              type: 'start',\n              messageId: `msg-${crypto.randomUUID()}`,\n            });\n            started = true;\n          }\n        };\n\n        const ensureStep = () => {\n          if (!inStep) {\n            enqueue({ type: 'start-step' });\n            inStep = true;\n          }\n        };\n\n        const closeTextBlock = () => {\n          if (textBlockId) {\n            enqueue({ type: 'text-end', id: textBlockId });\n            textBlockId = null;\n          }\n        };\n\n        const closeReasoningBlock = () => {\n          if (reasoningBlockId) {\n            enqueue({ type: 'reasoning-end', id: reasoningBlockId });\n            reasoningBlockId = null;\n          }\n        };\n\n        const closeStep = () => {\n          if (inStep) {\n            enqueue({ type: 'finish-step' });\n            inStep = false;\n          }\n        };\n\n        try {\n          for await (const chunk of response.stream) {\n            // If aborted during iteration, break out cleanly.\n            if (aborted) break;\n\n            // Agent custom-state update. The runtime auto-emits a `customPatch`\n            // (RFC 6902 JSON Patch) whenever the session's custom state\n            // mutates. Apply it to our locally tracked copy and surface the\n            // full, post-patch state as a transient `data-custom` UI chunk so\n            // the React app can render live progress. Must run BEFORE the\n            // `modelChunk` early-continue below, since custom-only chunks carry\n            // no `modelChunk`.\n            if (chunk?.customPatch) {\n              customState = applyPatch(customState, chunk.customPatch);\n              ensureStarted();\n              enqueue({\n                type: 'data-custom',\n                data: customState,\n                transient: true,\n              } as UIMessageChunk);\n            }\n\n            const mc = chunk?.modelChunk;\n            if (!mc?.content) continue;\n\n            ensureStarted();\n\n            for (const part of mc.content) {\n              // Reasoning delta (model's \"thinking\"). Genkit reasoning parts\n              // use the `reasoning` field; map them to AI SDK reasoning chunks\n              // so they can be surfaced separately from the final answer.\n              if (typeof part.reasoning === 'string' && part.reasoning !== '') {\n                ensureStep();\n                if (!reasoningBlockId) {\n                  reasoningBlockId = `reasoning-${crypto.randomUUID()}`;\n                  enqueue({ type: 'reasoning-start', id: reasoningBlockId });\n                }\n                enqueue({\n                  type: 'reasoning-delta',\n                  id: reasoningBlockId,\n                  delta: part.reasoning,\n                });\n              }\n\n              // Text delta\n              if (part.text !== undefined && part.text !== '') {\n                // Reasoning precedes the answer; close any open reasoning\n                // block before streaming visible text.\n                closeReasoningBlock();\n                ensureStep();\n                if (!textBlockId) {\n                  textBlockId = `text-${crypto.randomUUID()}`;\n                  enqueue({ type: 'text-start', id: textBlockId });\n                }\n                enqueue({\n                  type: 'text-delta',\n                  id: textBlockId,\n                  delta: part.text,\n                });\n              }\n\n              // Tool request (tool call from model)\n              if (part.toolRequest) {\n                const tr = part.toolRequest;\n                const toolCallId = tr.ref ?? correlateRequestId(tr.name);\n                if (!emittedToolInputs.has(toolCallId)) {\n                  emittedToolInputs.add(toolCallId);\n                  closeReasoningBlock();\n                  closeTextBlock();\n                  ensureStep();\n                  enqueue({\n                    type: 'tool-input-start',\n                    toolCallId,\n                    toolName: tr.name,\n                  });\n                  enqueue({\n                    type: 'tool-input-available',\n                    toolCallId,\n                    toolName: tr.name,\n                    input: tr.input,\n                  });\n                }\n              }\n\n              // Tool response (tool executed by agent)\n              if (part.toolResponse) {\n                const tr = part.toolResponse;\n                const toolCallId = tr.ref ?? correlateResponseId(tr.name);\n\n                // Skip interrupt responses the client already supplied — it\n                // has the result and re-emitting would confuse the UI SDK.\n                // Restarted tools are NOT skipped: they re-execute server-side\n                // and produce a fresh output the client must receive.\n                if (!respondedInterruptIds.has(toolCallId)) {\n                  enqueue({\n                    type: 'tool-output-available',\n                    toolCallId,\n                    output: tr.output,\n                  });\n                  closeStep();\n                }\n              }\n            }\n\n            // Handle turn end signals.\n            if (chunk?.turnEnd) {\n              closeReasoningBlock();\n              closeTextBlock();\n              closeStep();\n            }\n          }\n\n          // If aborted, emit an abort chunk and skip output processing.\n          if (aborted) {\n            ensureStarted();\n            closeReasoningBlock();\n            closeTextBlock();\n            closeStep();\n            enqueue({ type: 'abort', reason: 'Request was aborted' });\n            enqueue({ type: 'finish' });\n            try {\n              controller.close();\n            } catch {\n              /* already closed */\n            }\n            return;\n          }\n\n          // Wait for final output (drains the stream / surfaces server errors).\n          await response.output;\n        } catch (err: unknown) {\n          // If the error is an AbortError, treat it as an abort, not an error.\n          if (err instanceof DOMException && err.name === 'AbortError') {\n            ensureStarted();\n            closeReasoningBlock();\n            closeTextBlock();\n            closeStep();\n            enqueue({ type: 'abort', reason: 'Request was aborted' });\n          } else {\n            ensureStarted();\n            // `streamFlow` throws plain `Error`s whose message already embeds\n            // the HTTP status and any Genkit error status/message/details\n            // (e.g. `\"Server returned: 500: ...\"` or `\"<status>: <message>\\n\n            // <details>\"`), so `err.message` preserves that context. For\n            // non-Error throwables, stringify rather than collapsing to a\n            // generic label so detail isn't lost.\n            enqueue({\n              type: 'error',\n              errorText: errorTextFromUnknown(err),\n            });\n          }\n        } finally {\n          closeReasoningBlock();\n          closeTextBlock();\n          closeStep();\n          ensureStarted();\n          enqueue({ type: 'finish' });\n          abortSignal?.removeEventListener('abort', onAbort);\n          try {\n            controller.close();\n          } catch {\n            /* already closed */\n          }\n        }\n      },\n\n      cancel: () => {\n        // The ReadableStream consumer cancelled (e.g. useChat unmounted).\n        // The abort signal (if provided) will handle the fetch cancellation.\n        aborted = true;\n      },\n    });\n  }\n\n  /**\n   * Genkit transport does not support stream reconnection.\n   *\n   * Genkit has a durable streaming feature on the server side; support\n   * for reconnection may be added in a future version.\n   *\n   * @returns Always returns `null`.\n   */\n  async reconnectToStream(): Promise<ReadableStream<UIMessageChunk> | null> {\n    return null;\n  }\n}\n"],"mappings":"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","names":[]}

package/lib/index.d.mts

@@ -0,0 +1,3 @@
+export { UIMessage } from 'ai';
+export { ResolvedToolResult, RestartInterruptOutput, currentTurnResolvedTools, extractResolvedToolResults, findLastNonEmptyUserMessage, findLastUserMessage, mapGenkitMessageToUI, mapUIMessageToGenkit, mapUIPartToGenkit, messagesFromSnapshot, restartInterrupt } from './mapping.mjs';
+import 'genkit';

package/lib/index.d.ts

@@ -0,0 +1,3 @@
+export { UIMessage } from 'ai';
+export { ResolvedToolResult, RestartInterruptOutput, currentTurnResolvedTools, extractResolvedToolResults, findLastNonEmptyUserMessage, findLastUserMessage, mapGenkitMessageToUI, mapUIMessageToGenkit, mapUIPartToGenkit, messagesFromSnapshot, restartInterrupt } from './mapping.js';
+import 'genkit';

package/lib/index.js

@@ -0,0 +1,45 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var index_exports = {};
+__export(index_exports, {
+  currentTurnResolvedTools: () => import_mapping.currentTurnResolvedTools,
+  extractResolvedToolResults: () => import_mapping.extractResolvedToolResults,
+  findLastNonEmptyUserMessage: () => import_mapping.findLastNonEmptyUserMessage,
+  findLastUserMessage: () => import_mapping.findLastUserMessage,
+  mapGenkitMessageToUI: () => import_mapping.mapGenkitMessageToUI,
+  mapUIMessageToGenkit: () => import_mapping.mapUIMessageToGenkit,
+  mapUIPartToGenkit: () => import_mapping.mapUIPartToGenkit,
+  messagesFromSnapshot: () => import_mapping.messagesFromSnapshot,
+  restartInterrupt: () => import_mapping.restartInterrupt
+});
+module.exports = __toCommonJS(index_exports);
+var import_mapping = require("./mapping.js");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  currentTurnResolvedTools,
+  extractResolvedToolResults,
+  findLastNonEmptyUserMessage,
+  findLastUserMessage,
+  mapGenkitMessageToUI,
+  mapUIMessageToGenkit,
+  mapUIPartToGenkit,
+  messagesFromSnapshot,
+  restartInterrupt
+});
+//# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["/**\n * Copyright 2026 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport type { UIMessage } from 'ai';\n\nexport {\n  currentTurnResolvedTools,\n  extractResolvedToolResults,\n  findLastNonEmptyUserMessage,\n  findLastUserMessage,\n  mapGenkitMessageToUI,\n  mapUIMessageToGenkit,\n  mapUIPartToGenkit,\n  messagesFromSnapshot,\n  restartInterrupt,\n  type ResolvedToolResult,\n  type RestartInterruptOutput,\n} from './mapping.js';\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAkBA,qBAYO;","names":[]}

package/lib/index.mjs

@@ -0,0 +1,23 @@
+import {
+  currentTurnResolvedTools,
+  extractResolvedToolResults,
+  findLastNonEmptyUserMessage,
+  findLastUserMessage,
+  mapGenkitMessageToUI,
+  mapUIMessageToGenkit,
+  mapUIPartToGenkit,
+  messagesFromSnapshot,
+  restartInterrupt
+} from "./mapping.mjs";
+export {
+  currentTurnResolvedTools,
+  extractResolvedToolResults,
+  findLastNonEmptyUserMessage,
+  findLastUserMessage,
+  mapGenkitMessageToUI,
+  mapUIMessageToGenkit,
+  mapUIPartToGenkit,
+  messagesFromSnapshot,
+  restartInterrupt
+};
+//# sourceMappingURL=index.mjs.map

package/lib/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["/**\n * Copyright 2026 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport type { UIMessage } from 'ai';\n\nexport {\n  currentTurnResolvedTools,\n  extractResolvedToolResults,\n  findLastNonEmptyUserMessage,\n  findLastUserMessage,\n  mapGenkitMessageToUI,\n  mapUIMessageToGenkit,\n  mapUIPartToGenkit,\n  messagesFromSnapshot,\n  restartInterrupt,\n  type ResolvedToolResult,\n  type RestartInterruptOutput,\n} from './mapping.mjs';\n"],"mappings":"AAkBA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OAGK;","names":[]}

package/lib/mapping.d.mts

@@ -0,0 +1,162 @@
+import { UIMessage } from 'ai';
+import { MessageData, Part } from 'genkit';
+
+/**
+ * Copyright 2026 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Maps a single Vercel AI SDK v6 UIMessagePart to zero or more Genkit Parts.
+ *
+ * Handles `text`, `file`, and tool parts (both `ToolUIPart` with
+ * `type: 'tool-<name>'` and `DynamicToolUIPart` with `type: 'dynamic-tool'`).
+ *
+ * A tool part with state `output-available` produces both a `toolRequest`
+ * and a `toolResponse` part (matching Genkit's conversation model).
+ */
+declare function mapUIPartToGenkit(part: UIMessage['parts'][number]): Part[];
+/**
+ * Maps a Vercel AI SDK UIMessage to a Genkit MessageData.
+ */
+declare function mapUIMessageToGenkit(msg: UIMessage): MessageData;
+/**
+ * Maps a single Genkit {@link MessageData} to an AI SDK {@link UIMessage}.
+ *
+ * Pass `responsesByRef` (built across the whole conversation) so each
+ * `toolRequest` can be paired with the `toolResponse` that resolved it, even
+ * though they live in different messages. When omitted, all tool parts are
+ * emitted in the `input-available` state.
+ */
+declare function mapGenkitMessageToUI(msg: MessageData, responsesByRef?: Map<string, unknown>, id?: string): UIMessage;
+/**
+ * Converts the `messages` of a Genkit `SessionSnapshot` (an array of
+ * {@link MessageData}) into AI SDK {@link UIMessage}s suitable for seeding
+ * `useChat` (via its `messages` option or `setMessages`) to rehydrate a
+ * previous conversation after a reload.
+ *
+ * Tool requests and their responses (which Genkit stores in separate
+ * `model`/`tool` messages) are merged into single AI SDK tool parts, so the
+ * UI renders each tool call as one element with both its input and output.
+ * `tool`-role messages are therefore omitted from the result. Unresolved tool
+ * requests (e.g. a pending interrupt) are emitted in the `input-available`
+ * state.
+ *
+ * Conversation state is server-managed by `sessionId` (the `useChat` `id`), so
+ * to resume the *next* turn you only need to reuse the same chat `id` — there
+ * is no snapshot to restore on the client.
+ *
+ * @example
+ * ```ts
+ * const snapshot = await runFlow({ url: '/api/chat/weather/state', input: sessionId });
+ * const messages = messagesFromSnapshot(snapshot.state.messages);
+ * // pass `messages` to useChat({ id: sessionId, messages })
+ * ```
+ */
+declare function messagesFromSnapshot(messages: MessageData[]): UIMessage[];
+/**
+ * Marker placed on a tool output to signal that the user chose to *restart*
+ * (re-run) an interrupted tool rather than supply a final response.
+ *
+ * `Symbol.for` is intentionally avoided because tool outputs are serialized to
+ * JSON before reaching the transport; a string marker survives that round-trip.
+ */
+declare const RESTART_MARKER = "__genkitVercelAiRestart__";
+/**
+ * The serialized shape produced by {@link restartInterrupt}.
+ */
+interface RestartInterruptOutput {
+    [RESTART_MARKER]: true;
+    /**
+     * Optional metadata surfaced to the tool as its `resumed` argument when it
+     * re-runs server-side. Defaults to `true` when omitted.
+     */
+    metadata?: unknown;
+}
+/**
+ * Builds a tool output that instructs the Genkit agent to **restart** (re-run)
+ * an interrupted tool instead of accepting a user-supplied response.
+ *
+ * Pass the result to the AI SDK's `addToolResult` as the tool `output`:
+ *
+ * ```tsx
+ * addToolResult({
+ *   tool: 'userApproval',
+ *   toolCallId,
+ *   output: restartInterrupt({ note: 'user revised the request' }),
+ * });
+ * ```
+ *
+ * The transport detects this marker and emits a `resume.restart` entry (with
+ * the original tool input, which the server requires to match exactly) instead
+ * of a `resume.respond` entry. Any `metadata` is passed through to the tool as
+ * its `resumed` value.
+ */
+declare function restartInterrupt(metadata?: unknown): RestartInterruptOutput;
+/**
+ * Returns the restart payload if `output` was produced by
+ * {@link restartInterrupt}, otherwise `undefined`.
+ */
+declare function asRestartInterrupt(output: unknown): RestartInterruptOutput | undefined;
+/**
+ * A resolved tool invocation extracted from the frontend message history.
+ */
+interface ResolvedToolResult {
+    toolCallId: string;
+    toolName: string;
+    /** The original tool input (needed to build a `resume.restart`). */
+    input: unknown;
+    /** The user-supplied output (or a {@link restartInterrupt} marker). */
+    result: unknown;
+}
+/**
+ * Extracts resolved tool invocations from a UIMessage array.
+ *
+ * Supports the v6 per-tool format (`type === 'tool-<toolName>'`) as well as
+ * dynamic tools (`type === 'dynamic-tool'`, with an explicit `toolName`),
+ * matching `state === 'output-available'`.
+ *
+ * Scans **all** messages (most-recent first) and returns every resolved tool
+ * result, de-duplicated by `toolCallId` (keeping the most recent).
+ *
+ * Prefer {@link currentTurnResolvedTools} for interrupt-resume detection — it
+ * scopes the scan to the most recent turn so prior turns' (already-completed)
+ * tool calls are not re-sent as a resume payload.
+ */
+declare function extractResolvedToolResults(messages: UIMessage[]): ResolvedToolResult[];
+/**
+ * Returns the resolved tool invocations that constitute an interrupt resume
+ * for the *current* turn, or an empty array if this is a fresh user turn.
+ *
+ * An interrupt resume is identified by the last assistant message carrying
+ * resolved tool outputs (e.g. supplied via `addToolResult`) with no *non-empty*
+ * user message after it. A real user message following the assistant turn means
+ * the user started a new turn, so no resume is performed.
+ *
+ * This deliberately scopes detection to the most recent turn: tool calls from
+ * earlier turns are already part of the server-side session state and must not
+ * be replayed as a resume payload.
+ */
+declare function currentTurnResolvedTools(messages: UIMessage[]): ResolvedToolResult[];
+/**
+ * Finds the last user message in a UIMessage array.
+ */
+declare function findLastUserMessage(messages: UIMessage[]): UIMessage | undefined;
+/**
+ * Finds the last *non-empty* user message in a UIMessage array, skipping
+ * phantom empty messages produced by `sendMessage({ text: '' })`.
+ */
+declare function findLastNonEmptyUserMessage(messages: UIMessage[]): UIMessage | undefined;
+
+export { type ResolvedToolResult, type RestartInterruptOutput, asRestartInterrupt, currentTurnResolvedTools, extractResolvedToolResults, findLastNonEmptyUserMessage, findLastUserMessage, mapGenkitMessageToUI, mapUIMessageToGenkit, mapUIPartToGenkit, messagesFromSnapshot, restartInterrupt };