better-supabase 0.5.0 → 0.6.0

package/dist/ai-sdk/workflow/index.js

@@ -0,0 +1,575 @@
+import { n as dbError } from "../../errors-B11Duf73.js";
+import { a as problemResponse } from "../../problem-BreOl8b8.js";
+import { d as isRecord } from "../../block-helpers-DWHxHsEQ.js";
+import { h as usageOf, o as toUIMessage, p as runRelease, r as fromModelMessages, t as AI_SDK_UI_FORMAT } from "../../messages-B9-5887d.js";
+import { n as teeToStore, t as resumeFromStore } from "../../tee-CoEppCER.js";
+import { t as WORKFLOW_ATTRIBUTES } from "../../attributes-5dYul0u0.js";
+import { JsonToSseTransformStream, UI_MESSAGE_STREAM_HEADERS } from "ai";
+import { createModelCallToUIChunkTransform, normalizeUIMessageStreamParts } from "@ai-sdk/workflow";
+import { getRun, resumeHook, start } from "workflow/api";
+//#region src/ai-sdk/workflow/turn.ts
+/** The token of the hook that stops a durable turn. */
+function durableStopToken(workflowRunId) {
+	return `ai-chat-stop:${workflowRunId}`;
+}
+/** The token of the hook that continues a turn after its approvals. */
+function durableTurnToken(workflowRunId) {
+	return `ai-chat-turn:${workflowRunId}`;
+}
+const STOPPED = Symbol("stopped");
+function messageOf(cause) {
+	return cause instanceof Error ? cause.message : String(cause);
+}
+/** The approval requests in `messages` that `known` doesn't hold yet. */
+function newRequests(messages, known) {
+	const calls = /* @__PURE__ */ new Map();
+	const requests = [];
+	for (const message of messages) {
+		if (message.role !== "assistant" || typeof message.content === "string") continue;
+		for (const part of message.content) if (part.type === "tool-call") calls.set(part.toolCallId, {
+			toolName: part.toolName,
+			input: part.input
+		});
+		else if (part.type === "tool-approval-request" && !known.has(part.approvalId)) {
+			const call = calls.get(part.toolCallId);
+			const { signature } = part;
+			requests.push({
+				approvalId: part.approvalId,
+				toolCallId: part.toolCallId,
+				toolName: call?.toolName ?? "",
+				input: call?.input,
+				...signature === void 0 ? {} : { signature }
+			});
+		}
+	}
+	return requests;
+}
+function sourcesOf(result) {
+	return result.steps.flatMap((step) => step.sources ?? []);
+}
+/**
+* One durable answer, inside a `"use workflow"` function. Each pass of the
+* agent writes one segment: a World stream namespace, claimed in `ai_runs`.
+* The answer is saved after each pass under `input.messageId`. When the
+* agent asks for approvals, they go to `ai_tool_approvals`, the segment is
+* released and the turn waits on its hook (`durableTurnToken`) for as long
+* as the decisions take; it reads them back from the database rather than
+* from the hook payload. The stop hook (`durableStopToken`) aborts it.
+*/
+async function durableTurn(input, deps) {
+	const abort = new AbortController();
+	const stopped = Promise.resolve(deps.createHook({ token: durableStopToken(deps.runId) })).then(() => {
+		abort.abort();
+		return STOPPED;
+	});
+	const resumes = deps.createHook({ token: durableTurnToken(deps.runId) })[Symbol.asyncIterator]();
+	const historyLength = input.messages.length;
+	const approvals = /* @__PURE__ */ new Map();
+	const sources = [];
+	let conversation = input.messages;
+	let segment = {
+		streamId: input.streamId,
+		runId: input.runId
+	};
+	let segments = 0;
+	for (;;) {
+		segments += 1;
+		let status = "completed";
+		let error;
+		let usage;
+		let requests = [];
+		try {
+			const result = await deps.agent({
+				chatId: input.chatId,
+				runId: segment.runId,
+				messages: conversation,
+				writable: deps.getWritable({ namespace: segment.streamId }),
+				abortSignal: abort.signal,
+				model: input.model,
+				providerOptions: input.providerOptions
+			});
+			conversation = result.messages;
+			sources.push(...sourcesOf(result));
+			requests = newRequests(conversation.slice(historyLength), approvals);
+			usage = usageOf({
+				totalUsage: result.totalUsage,
+				providerMetadata: result.steps.at(-1)?.providerMetadata
+			});
+		} catch (cause) {
+			status = "failed";
+			error = messageOf(cause);
+		}
+		if (abort.signal.aborted) status = "cancelled";
+		if (status !== "completed") requests = [];
+		for (const request of requests) approvals.set(request.approvalId, {
+			approvalId: request.approvalId,
+			toolCallId: request.toolCallId,
+			state: "requested"
+		});
+		await deps.step("save", {
+			chatId: input.chatId,
+			message: fromModelMessages(input.messageId, conversation.slice(historyLength), {
+				sources,
+				approvals: [...approvals.values()]
+			}),
+			parentId: input.parentId,
+			model: input.model,
+			runId: segment.runId,
+			status: status === "completed" ? "complete" : status === "cancelled" ? "aborted" : "error"
+		});
+		if (requests.length > 0) await deps.step("approvals", {
+			chatId: input.chatId,
+			runId: segment.runId,
+			messageId: input.messageId,
+			requests
+		});
+		await deps.step("release", {
+			chatId: input.chatId,
+			streamId: segment.streamId,
+			organizationId: input.organizationId,
+			status,
+			...usage === void 0 ? {} : { usage },
+			...error === void 0 ? {} : { error }
+		});
+		if (requests.length === 0) return {
+			status,
+			messageId: input.messageId,
+			segments
+		};
+		const waiting = requests.map((request) => request.approvalId);
+		let decided = [];
+		let next;
+		const drop = async (claimed) => {
+			if (claimed === void 0) return;
+			await deps.step("release", {
+				chatId: input.chatId,
+				streamId: claimed.streamId,
+				organizationId: input.organizationId,
+				status: "cancelled"
+			});
+		};
+		while (decided.length < waiting.length) {
+			const signal = await Promise.race([resumes.next(), stopped]);
+			if (signal === STOPPED || signal.done === true) {
+				await drop(next);
+				return {
+					status: "cancelled",
+					messageId: input.messageId,
+					segments
+				};
+			}
+			await drop(next);
+			next = signal.value;
+			decided = await deps.step("decisions", {
+				chatId: input.chatId,
+				approvalIds: waiting
+			});
+		}
+		if (next === void 0) return {
+			status: "failed",
+			messageId: input.messageId,
+			segments
+		};
+		for (const decision of decided) {
+			const known = approvals.get(decision.approvalId);
+			if (known !== void 0) approvals.set(decision.approvalId, {
+				...known,
+				state: decision.approved ? "approved" : "denied",
+				...decision.reason === void 0 ? {} : { reason: decision.reason }
+			});
+		}
+		conversation = [...conversation, {
+			role: "tool",
+			content: decided.map((decision) => ({
+				type: "tool-approval-response",
+				approvalId: decision.approvalId,
+				approved: decision.approved,
+				...decision.reason === void 0 ? {} : { reason: decision.reason }
+			}))
+		}];
+		segment = next;
+	}
+}
+//#endregion
+//#region src/ai-sdk/workflow/server.ts
+/** The response header that names the workflow run. */
+const WORKFLOW_RUN_ID_HEADER = "x-workflow-run-id";
+const WORKFLOW_ENGINE = "workflow";
+function badRequest(message) {
+	return problemResponse(dbError("invalid_request", message, { code: "AI_CHAT_BAD_REQUEST" }));
+}
+function busy() {
+	return problemResponse(dbError("conflict", "An answer is already being written.", { code: "AI_CHAT_BUSY" }));
+}
+function notDurable() {
+	return problemResponse(dbError("conflict", "The approvals belong to no durable run.", { code: "AI_CHAT_NOT_DURABLE" }));
+}
+async function readJson(request) {
+	try {
+		return await request.json();
+	} catch {
+		return;
+	}
+}
+/** The `approvals` of a body, `undefined` when it has none, or a message for a malformed one. */
+function decisionsOf$1(value) {
+	if (value === void 0) return void 0;
+	if (!Array.isArray(value) || value.length === 0) return "Expected a list of approvals.";
+	const decisions = [];
+	for (const item of value) {
+		if (!isRecord(item) || typeof item["approvalId"] !== "string" || typeof item["approved"] !== "boolean") return "Expected approvals with an approvalId and approved.";
+		const { reason } = item;
+		decisions.push({
+			approvalId: item["approvalId"],
+			approved: item["approved"],
+			...typeof reason === "string" ? { reason } : {}
+		});
+	}
+	return decisions;
+}
+function streamOf(iterable) {
+	const iterator = iterable[Symbol.asyncIterator]();
+	return new ReadableStream({
+		async pull(controller) {
+			const next = await iterator.next();
+			if (next.done === true) controller.close();
+			else controller.enqueue(next.value);
+		},
+		async cancel(reason) {
+			await iterator.return?.(reason);
+		}
+	});
+}
+async function* chunksOf(stream, signal) {
+	const reader = stream.getReader();
+	const cancel = () => {
+		reader.cancel(signal?.reason).catch(() => void 0);
+	};
+	if (signal?.aborted === true) cancel();
+	else signal?.addEventListener("abort", cancel, { once: true });
+	try {
+		for (;;) {
+			const next = await reader.read();
+			if (next.done) return;
+			yield next.value;
+		}
+	} finally {
+		signal?.removeEventListener("abort", cancel);
+		reader.releaseLock();
+	}
+}
+/** A segment's World stream as UI chunks, with the answer's id on `start`. */
+function segmentChunks(workflowRunId, streamId, messageId, uiStartIndex, signal) {
+	const chunks = getRun(workflowRunId).getReadable({ namespace: streamId }).pipeThrough(createModelCallToUIChunkTransform({ uiStartIndex })).pipeThrough(new TransformStream({ transform(chunk, controller) {
+		controller.enqueue(chunk.type === "start" && messageId !== void 0 ? {
+			...chunk,
+			messageId
+		} : chunk);
+	} }));
+	return streamOf(normalizeUIMessageStreamParts(chunksOf(chunks, signal)));
+}
+/** `stream` once its first chunk arrives, or `undefined` when reading it fails. */
+async function opened(stream) {
+	const reader = stream.getReader();
+	let first;
+	try {
+		first = await reader.read();
+	} catch {
+		return;
+	}
+	let pending = first;
+	return new ReadableStream({
+		async pull(controller) {
+			const next = pending ?? await reader.read();
+			pending = void 0;
+			if (next.done) controller.close();
+			else controller.enqueue(next.value);
+		},
+		async cancel(reason) {
+			await reader.cancel(reason);
+		}
+	});
+}
+function sse(stream, workflowRunId) {
+	return new Response(stream.pipeThrough(new TextEncoderStream()), { headers: {
+		...UI_MESSAGE_STREAM_HEADERS,
+		...workflowRunId === void 0 ? {} : { [WORKFLOW_RUN_ID_HEADER]: workflowRunId }
+	} });
+}
+/**
+* Durable chat routes on the Workflow SDK: each turn is a workflow run
+* (`durableTurn`), so an answer outlives the request, a reload replays it
+* and an approval can wait for hours. The chat's runs stay in `ai_runs`
+* with the workflow run id next to them.
+*/
+function durableChat(options) {
+	const newId = options.generateId ?? (() => crypto.randomUUID());
+	function streamSegment(context, chat, workflowRunId, streamId, messageId) {
+		const teed = teeToStore(options.streams, streamId, segmentChunks(workflowRunId, streamId, messageId, 0).pipeThrough(new JsonToSseTransformStream()), {
+			owner: chat.ownerId,
+			tenant: chat.organizationId,
+			kind: "chat",
+			...options.streamTtl === void 0 ? {} : { ttl: options.streamTtl }
+		});
+		context.waitUntil?.((async () => {
+			await teed.persisted;
+		})());
+		return sse(teed.stream, workflowRunId);
+	}
+	async function startTurn(body, context) {
+		const turn = await options.assistant.prepare(body, context);
+		if (turn instanceof Response) return turn;
+		const { chat, model } = turn;
+		const streamId = newId();
+		const messageId = newId();
+		const claim = await context.chats.runs.claim(chat.id, streamId, {
+			model,
+			messageId,
+			engine: WORKFLOW_ENGINE
+		});
+		if (!claim.ok) return problemResponse(claim.error);
+		const runId = claim.data.runId;
+		if (!claim.data.claimed || runId === void 0) return busy();
+		const input = {
+			chatId: chat.id,
+			organizationId: chat.organizationId,
+			userId: context.userId,
+			model,
+			messageId,
+			parentId: turn.parentId,
+			runId,
+			streamId,
+			messages: turn.messages,
+			providerOptions: turn.providerOptions
+		};
+		let workflowRunId;
+		try {
+			workflowRunId = (await start(options.workflow, [input], { attributes: {
+				[WORKFLOW_ATTRIBUTES.tenant]: chat.organizationId,
+				[WORKFLOW_ATTRIBUTES.actor]: context.userId,
+				[WORKFLOW_ATTRIBUTES.key]: `ai-chat:${chat.id}`
+			} })).runId;
+		} catch (cause) {
+			await context.chats.runs.release(chat.id, streamId, {
+				status: "failed",
+				error: String(cause)
+			});
+			return problemResponse(dbError("unexpected", "The answer could not be started.", { code: "AI_CHAT_RUN_FAILED" }));
+		}
+		const attached = await context.chats.runs.attach(runId, workflowRunId);
+		if (!attached.ok) {
+			await getRun(workflowRunId).cancel().catch(() => void 0);
+			await context.chats.runs.release(chat.id, streamId, {
+				status: "failed",
+				error: attached.error.message
+			});
+			return problemResponse(attached.error);
+		}
+		return streamSegment(context, chat, workflowRunId, streamId, messageId);
+	}
+	/** The durable run the decided approvals belong to, or a problem. */
+	async function runOf(context, decided) {
+		const runId = decided.find((row) => row.runId !== void 0)?.runId;
+		if (runId === void 0) return notDurable();
+		const run = await context.chats.runs.get(runId);
+		if (!run.ok) return problemResponse(run.error);
+		return run.data.engine === WORKFLOW_ENGINE && run.data.externalRunId !== void 0 ? run.data : notDurable();
+	}
+	/** Decides, then claims a segment and resumes the turn when nothing is pending. */
+	async function continueTurn(chatId, decisions, context) {
+		const chat = await context.chats.chats.get(chatId);
+		if (!chat.ok) return problemResponse(chat.error);
+		const decided = [];
+		for (const decision of decisions) {
+			const row = await context.chats.approvals.decide(decision.approvalId, decision.approved, decision.reason);
+			if (!row.ok) return problemResponse(row.error);
+			if (row.data.chatId !== chatId) return badRequest("The approvals belong to another chat.");
+			decided.push(row.data);
+		}
+		const run = await runOf(context, decided);
+		if (run instanceof Response) return run;
+		const all = await context.chats.approvals.list(chatId);
+		if (!all.ok) return problemResponse(all.error);
+		if (all.data.some((row) => row.runId === run.id && row.decision === "pending")) return { continued: false };
+		const workflowRunId = run.externalRunId ?? "";
+		const streamId = newId();
+		const claim = await context.chats.runs.claim(chatId, streamId, {
+			engine: WORKFLOW_ENGINE,
+			externalRunId: workflowRunId,
+			...run.model === void 0 ? {} : { model: run.model },
+			...run.assistantMessageId === void 0 ? {} : { messageId: run.assistantMessageId }
+		});
+		if (!claim.ok) return problemResponse(claim.error);
+		const runId = claim.data.runId;
+		if (!claim.data.claimed || runId === void 0) return busy();
+		const resume = {
+			streamId,
+			runId
+		};
+		try {
+			await resumeHook(durableTurnToken(workflowRunId), resume);
+		} catch (cause) {
+			await context.chats.runs.release(chatId, streamId, {
+				status: "failed",
+				error: String(cause)
+			});
+			return problemResponse(dbError("conflict", "The turn is no longer waiting.", { code: "AI_CHAT_NOT_WAITING" }));
+		}
+		return {
+			continued: true,
+			chat: chat.data,
+			workflowRunId,
+			streamId,
+			messageId: run.assistantMessageId
+		};
+	}
+	async function respond(request, context) {
+		const body = await readJson(request);
+		const approvals = decisionsOf$1(isRecord(body) ? body["approvals"] : void 0);
+		if (approvals === void 0) return startTurn(body, context);
+		if (typeof approvals === "string") return badRequest(approvals);
+		const chatId = isRecord(body) ? body["id"] : void 0;
+		if (typeof chatId !== "string" || chatId === "") return badRequest("Expected the chat id.");
+		const continued = await continueTurn(chatId, approvals, context);
+		if (continued instanceof Response) return continued;
+		if (!continued.continued) return problemResponse(dbError("conflict", "Other approvals of this answer are pending.", { code: "AI_APPROVALS_PENDING" }));
+		return streamSegment(context, continued.chat, continued.workflowRunId, continued.streamId, continued.messageId);
+	}
+	/** The chat's running durable run, else its latest one. */
+	async function latestRun(context, chat) {
+		if (chat.activeRunId !== void 0) {
+			const run = await context.chats.runs.get(chat.activeRunId);
+			if (!run.ok) return problemResponse(run.error);
+			return run.data;
+		}
+		const runs = await context.chats.runs.list({
+			chatId: chat.id,
+			limit: 1
+		});
+		if (!runs.ok) return problemResponse(runs.error);
+		return runs.data[0];
+	}
+	async function resume(chatId, context, resumeOptions = {}) {
+		const chat = await context.chats.chats.get(chatId);
+		if (!chat.ok) return chat.error.kind === "not_found" ? new Response(null, { status: 204 }) : problemResponse(chat.error);
+		const run = await latestRun(context, chat.data);
+		if (run instanceof Response) return run;
+		const streamId = run?.streamId;
+		if (run === void 0 || streamId === void 0) return new Response(null, { status: 204 });
+		const startIndex = Math.max(0, Math.trunc(resumeOptions.startIndex ?? 0));
+		if (run.engine === WORKFLOW_ENGINE && run.externalRunId !== void 0) {
+			let live;
+			try {
+				live = await opened(segmentChunks(run.externalRunId, streamId, run.assistantMessageId, startIndex, resumeOptions.signal).pipeThrough(new JsonToSseTransformStream()));
+			} catch {
+				live = void 0;
+			}
+			if (live !== void 0) return sse(live, run.externalRunId);
+		}
+		const stored = await resumeFromStore(options.streams, streamId, {
+			fromIdx: startIndex,
+			...resumeOptions.signal === void 0 ? {} : { signal: resumeOptions.signal }
+		});
+		if (!stored.ok) return problemResponse(stored.error);
+		return stored.data === void 0 ? new Response(null, { status: 204 }) : sse(stored.data, run.externalRunId);
+	}
+	async function stop(chatId, context) {
+		const stopped = await context.chats.runs.stop(chatId);
+		if (!stopped.ok) return problemResponse(stopped.error);
+		if (stopped.data === void 0) return new Response(null, { status: 204 });
+		const run = await context.chats.runs.get(stopped.data.runId);
+		if (!run.ok) return problemResponse(run.error);
+		const workflowRunId = run.data.externalRunId;
+		if (workflowRunId === void 0) return new Response(null, { status: 204 });
+		try {
+			await resumeHook(durableStopToken(workflowRunId), {});
+		} catch {
+			let cancelled = true;
+			try {
+				await getRun(workflowRunId).cancel();
+			} catch {
+				cancelled = false;
+			}
+			await context.chats.runs.release(chatId, stopped.data.streamId, { status: "cancelled" });
+			if (!cancelled) return problemResponse(dbError("unexpected", "The answer could not be stopped.", { code: "AI_CHAT_STOP_FAILED" }));
+		}
+		return new Response(null, { status: 204 });
+	}
+	async function decide(chatId, decisions, context) {
+		if (decisions.length === 0) return badRequest("Expected approvals.");
+		const continued = await continueTurn(chatId, decisions, context);
+		if (continued instanceof Response) return continued;
+		return Response.json(continued.continued ? {
+			continued: true,
+			streamId: continued.streamId
+		} : { continued: false });
+	}
+	return {
+		respond,
+		resume,
+		stop,
+		decide
+	};
+}
+//#endregion
+//#region src/ai-sdk/workflow/steps.ts
+/**
+* Saves a turn's answer (service role) with its AI SDK form next to the
+* canonical one. The message id is the idempotency key: a retried step, or
+* the save after the next agent pass, updates the same message.
+*/
+async function saveMessagesStep(chats, input) {
+	await chats.messages.saveAssistant(input.chatId, input.message, {
+		parentId: input.parentId,
+		status: input.status,
+		model: input.model,
+		format: AI_SDK_UI_FORMAT,
+		native: toUIMessage(input.message),
+		runId: input.runId
+	}).orThrow();
+}
+async function recordApprovals(chats, input) {
+	for (const request of input.requests) await chats.approvals.request(input.chatId, {
+		approvalId: request.approvalId,
+		tool: request.toolName,
+		toolCallId: request.toolCallId,
+		input: request.input,
+		runId: input.runId,
+		messageId: input.messageId,
+		...request.signature === void 0 ? {} : { signature: request.signature }
+	}).orThrow();
+}
+async function decisionsOf(chats, input) {
+	return (await chats.approvals.list(input.chatId, input.approvalIds).orThrow()).flatMap((row) => row.decision === "pending" ? [] : [{
+		approvalId: row.approvalId,
+		approved: row.decision === "approved",
+		...row.reason === void 0 ? {} : { reason: row.reason }
+	}]);
+}
+async function release(chats, input, options) {
+	await chats.runs.release(input.chatId, input.streamId, runRelease(input.status, input.usage, input.error)).orThrow();
+	const { usage } = input;
+	if (usage?.costMicroUsd === void 0 && usage?.generationId !== void 0 && options.enqueueCostBackfill) await options.enqueueCostBackfill({
+		generationId: usage.generationId,
+		organizationId: input.organizationId
+	});
+}
+/** A durable turn's database steps on a chat block's service transport. */
+function durableSteps(chats, options = {}) {
+	return {
+		save: (input) => saveMessagesStep(chats, input),
+		approvals: (input) => recordApprovals(chats, input),
+		decisions: (input) => decisionsOf(chats, input),
+		release: (input) => release(chats, input, options)
+	};
+}
+/**
+* Runs one of a durable turn's database steps. Call it from the app's one
+* `"use step"` function, so the Workflow SDK records and retries each call;
+* a database error throws, which retries the step.
+*/
+function runDurableStep(chats, name, input, options = {}) {
+	return durableSteps(chats, options)[name](input);
+}
+//#endregion
+export { WORKFLOW_RUN_ID_HEADER, durableChat, durableSteps, durableStopToken, durableTurn, durableTurnToken, runDurableStep, saveMessagesStep };

package/dist/ai-sdk/workflow/react/index.d.ts

@@ -0,0 +1,20 @@
+import { i as AssistantTransportConfig, n as UseAssistantOptions, t as AssistantState } from "../../../index-BpFYMsi0.js";
+import { ChatTransport, UIMessage } from "ai";
+//#region src/ai-sdk/workflow/react/index.d.ts
+/**
+ * The transport for `durableChat`: the Workflow SDK's chat transport, which
+ * reconnects until the segment's `finish` when a request drops. It sends
+ * the user's newest message, or the answered approvals of the last answer
+ * so the waiting turn continues. Pass it as `useAssistant({ transport })`.
+ */
+export declare function durableTransport(config: AssistantTransportConfig): ChatTransport<UIMessage>;
+export type UseDurableAssistantOptions = Omit<UseAssistantOptions, "transport">;
+/**
+ * `useAssistant` on `durableChat`. It continues the answer once every
+ * approval is answered. `resume` defaults to `false`: pass
+ * `chat.activeStreamId !== undefined` from the chat row so a reload picks
+ * up the running answer.
+ */
+export declare function useDurableAssistant(options: UseDurableAssistantOptions): AssistantState;
+//#endregion
+export type { AssistantState };

package/dist/ai-sdk/workflow/react/index.js

@@ -0,0 +1,66 @@
+"use client";
+import { n as assistantBody, t as useAssistant } from "../../../react-4ZqkP8da.js";
+import { lastAssistantMessageIsCompleteWithApprovalResponses } from "ai";
+import { WorkflowChatTransport } from "@ai-sdk/workflow/client";
+//#region src/ai-sdk/workflow/react/index.ts
+/** The decisions in an assistant message whose approvals the user answered. */
+function approvalsOf(message) {
+	if (message?.role !== "assistant") return [];
+	return message.parts.flatMap((part) => "state" in part && part.state === "approval-responded" ? [{
+		approvalId: part.approval.id,
+		approved: part.approval.approved,
+		...part.approval.reason === void 0 ? {} : { reason: part.approval.reason }
+	}] : []);
+}
+/**
+* The transport for `durableChat`: the Workflow SDK's chat transport, which
+* reconnects until the segment's `finish` when a request drops. It sends
+* the user's newest message, or the answered approvals of the last answer
+* so the waiting turn continues. Pass it as `useAssistant({ transport })`.
+*/
+function durableTransport(config) {
+	const { api, headers } = config;
+	const extra = headers === void 0 ? {} : { headers: { ...headers } };
+	const transport = new WorkflowChatTransport({
+		api,
+		prepareSendMessagesRequest: (request) => {
+			const approvals = approvalsOf(request.messages.at(-1));
+			return {
+				...extra,
+				body: approvals.length > 0 ? {
+					...config.body,
+					id: request.id,
+					approvals
+				} : assistantBody(config, request)
+			};
+		},
+		prepareReconnectToStreamRequest: (request) => ({
+			...extra,
+			api: `${api}/${encodeURIComponent(request.id)}/stream`
+		})
+	});
+	return {
+		sendMessages: ({ messageId, abortSignal, ...rest }) => transport.sendMessages({
+			...rest,
+			...messageId === void 0 ? {} : { messageId },
+			...abortSignal === void 0 ? {} : { abortSignal }
+		}),
+		reconnectToStream: (options) => transport.reconnectToStream(options)
+	};
+}
+/**
+* `useAssistant` on `durableChat`. It continues the answer once every
+* approval is answered. `resume` defaults to `false`: pass
+* `chat.activeStreamId !== undefined` from the chat row so a reload picks
+* up the running answer.
+*/
+function useDurableAssistant(options) {
+	return useAssistant({
+		...options,
+		resume: options.resume ?? false,
+		sendAutomaticallyWhen: options.sendAutomaticallyWhen ?? lastAssistantMessageIsCompleteWithApprovalResponses,
+		transport: durableTransport
+	});
+}
+//#endregion
+export { durableTransport, useDurableAssistant };

package/dist/ai-sdk/workflow/react/server.d.ts

@@ -0,0 +1,10 @@
+import { i as AssistantTransportConfig, t as AssistantState } from "../../../index-BpFYMsi0.js";
+import { UseDurableAssistantOptions } from "./index.js";
+import { ChatTransport, UIMessage } from "ai";
+//#region src/ai-sdk/workflow/react/server.d.ts
+/** The `react-server` build of `durableTransport`. */
+export declare const durableTransport: (config: AssistantTransportConfig) => ChatTransport<UIMessage>;
+/** The `react-server` build of `useDurableAssistant`. */
+export declare const useDurableAssistant: (options: UseDurableAssistantOptions) => AssistantState;
+//#endregion
+export type { AssistantState, UseDurableAssistantOptions };

package/dist/ai-sdk/workflow/react/server.js

@@ -0,0 +1,12 @@
+//#region src/ai-sdk/workflow/react/server.ts
+const CLIENT_ONLY = "better-supabase: the durable chat hooks run in Client Components only. In Server Components read the chat row and pass `resume` and `messages` to the client.";
+/** The `react-server` build of `durableTransport`. */
+const durableTransport = () => {
+	throw new Error(CLIENT_ONLY);
+};
+/** The `react-server` build of `useDurableAssistant`. */
+const useDurableAssistant = () => {
+	throw new Error(CLIENT_ONLY);
+};
+//#endregion
+export { durableTransport, useDurableAssistant };