@assistant-ui/core 0.3.12 → 0.3.14

package/dist/react/runtimes/assistant-transport/commandQueue.d.ts

@@ -0,0 +1,17 @@
+import { AssistantTransportCommand, CommandQueueState, QueuedCommand } from "./types.js";
+//#region src/react/runtimes/assistant-transport/commandQueue.d.ts
+declare const createInitialQueueState: () => CommandQueueState;
+declare const useCommandQueue: (opts: {
+  onQueue: () => void;
+}) => {
+  readonly state: CommandQueueState;
+  enqueue: (command: AssistantTransportCommand, options?: {
+    schedule?: boolean;
+  }) => void;
+  flush: () => QueuedCommand[];
+  markDelivered: () => void;
+  reset: () => void;
+};
+//#endregion
+export { createInitialQueueState, useCommandQueue };
+//# sourceMappingURL=commandQueue.d.ts.map

package/dist/react/runtimes/assistant-transport/commandQueue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commandQueue.d.ts","names":[],"sources":["../../../../src/react/runtimes/assistant-transport/commandQueue.ts"],"mappings":";;cAOa,+BAA8B;cAK9B,kBAAmB;EAAQ;;;EAU3B,UAAA,SAAA,2BAAyB;IACtB;;EAWI,aAAA"}

package/dist/react/runtimes/assistant-transport/commandQueue.js

@@ -0,0 +1,55 @@
+import { useCallback, useEffect, useRef, useState } from "@assistant-ui/tap/react-shim";
+//#region src/react/runtimes/assistant-transport/commandQueue.ts
+const createInitialQueueState = () => ({
+	queued: [],
+	inTransit: []
+});
+const useCommandQueue = (opts) => {
+	const onQueueRef = useRef(opts.onQueue);
+	useEffect(() => {
+		onQueueRef.current = opts.onQueue;
+	});
+	const [, rerender] = useState(0);
+	const queueStateRef = useRef(createInitialQueueState());
+	const enqueue = (command, options) => {
+		queueStateRef.current = {
+			queued: [...queueStateRef.current.queued, command],
+			inTransit: queueStateRef.current.inTransit
+		};
+		rerender((prev) => prev + 1);
+		if (options?.schedule !== false) onQueueRef.current();
+	};
+	const flush = () => {
+		if (queueStateRef.current.queued.length === 0) return [];
+		const queued = queueStateRef.current.queued;
+		queueStateRef.current = {
+			queued: [],
+			inTransit: [...queueStateRef.current.inTransit, ...queued]
+		};
+		rerender((prev_0) => prev_0 + 1);
+		return queued;
+	};
+	const markDelivered = () => {
+		queueStateRef.current = {
+			...queueStateRef.current,
+			inTransit: []
+		};
+		rerender((prev_1) => prev_1 + 1);
+	};
+	return {
+		get state() {
+			return queueStateRef.current;
+		},
+		enqueue,
+		flush,
+		markDelivered,
+		reset: useCallback(() => {
+			queueStateRef.current = createInitialQueueState();
+			rerender((prev_2) => prev_2 + 1);
+		}, [])
+	};
+};
+//#endregion
+export { createInitialQueueState, useCommandQueue };
+
+//# sourceMappingURL=commandQueue.js.map

package/dist/react/runtimes/assistant-transport/commandQueue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"commandQueue.js","names":["useState","useCallback","useRef","useEffect","AssistantTransportCommand","CommandQueueState","QueuedCommand","createInitialQueueState","queued","inTransit","useCommandQueue","opts","onQueue","onQueueRef","current","rerender","queueStateRef","enqueue","command","options","schedule","prev","flush","length","markDelivered","reset","state"],"sources":["../../../../src/react/runtimes/assistant-transport/commandQueue.ts"],"sourcesContent":["import { useState, useCallback, useRef, useEffect } from \"react\";\nimport type {\n  AssistantTransportCommand,\n  CommandQueueState,\n  QueuedCommand,\n} from \"./types\";\n\nexport const createInitialQueueState = (): CommandQueueState => ({\n  queued: [],\n  inTransit: [],\n});\n\nexport const useCommandQueue = (opts: { onQueue: () => void }) => {\n  const onQueueRef = useRef(opts.onQueue);\n  useEffect(() => {\n    onQueueRef.current = opts.onQueue;\n  });\n\n  const [, rerender] = useState(0);\n  const queueStateRef = useRef<CommandQueueState>(createInitialQueueState());\n\n  const enqueue = (\n    command: AssistantTransportCommand,\n    options?: { schedule?: boolean },\n  ) => {\n    queueStateRef.current = {\n      queued: [...queueStateRef.current.queued, command],\n      inTransit: queueStateRef.current.inTransit,\n    };\n    rerender((prev) => prev + 1);\n\n    if (options?.schedule !== false) onQueueRef.current();\n  };\n\n  const flush = (): QueuedCommand[] => {\n    if (queueStateRef.current.queued.length === 0) return [];\n\n    const queued = queueStateRef.current.queued;\n    queueStateRef.current = {\n      queued: [],\n      inTransit: [...queueStateRef.current.inTransit, ...queued],\n    };\n    rerender((prev) => prev + 1);\n\n    return queued;\n  };\n\n  const markDelivered = () => {\n    queueStateRef.current = { ...queueStateRef.current, inTransit: [] };\n    rerender((prev) => prev + 1);\n  };\n\n  const reset = useCallback(() => {\n    queueStateRef.current = createInitialQueueState();\n    rerender((prev) => prev + 1);\n  }, []);\n\n  return {\n    // live getter — callbacks firing between renders must not see a stale snapshot\n    get state() {\n      return queueStateRef.current;\n    },\n    enqueue,\n    flush,\n    markDelivered,\n    reset,\n  };\n};\n"],"mappings":";;AAOA,MAAaO,iCAAoD;CAC/DC,QAAQ,CAAA;CACRC,WAAW,CAAA;AACb;AAEA,MAAaC,mBAAmBC,SAAkC;CAChE,MAAME,aAAaX,OAAOS,KAAKC,OAAO;CACtCT,gBAAgB;EACdU,WAAWC,UAAUH,KAAKC;CAC5B,CAAC;CAED,MAAM,GAAGG,YAAYf,SAAS,CAAC;CAC/B,MAAMgB,gBAAgBd,OAA0BK,wBAAwB,CAAC;CAEzE,MAAMU,WACJC,SACAC,YACG;EACHH,cAAcF,UAAU;GACtBN,QAAQ,CAAC,GAAGQ,cAAcF,QAAQN,QAAQU,OAAO;GACjDT,WAAWO,cAAcF,QAAQL;EACnC;EACAM,UAAUM,SAASA,OAAO,CAAC;EAE3B,IAAIF,SAASC,aAAa,OAAOP,WAAWC,QAAQ;CACtD;CAEA,MAAMQ,cAA+B;EACnC,IAAIN,cAAcF,QAAQN,OAAOe,WAAW,GAAG,OAAO,CAAA;EAEtD,MAAMf,SAASQ,cAAcF,QAAQN;EACrCQ,cAAcF,UAAU;GACtBN,QAAQ,CAAA;GACRC,WAAW,CAAC,GAAGO,cAAcF,QAAQL,WAAW,GAAGD,MAAM;EAC3D;EACAO,UAAUM,WAASA,SAAO,CAAC;EAE3B,OAAOb;CACT;CAEA,MAAMgB,sBAAsB;EAC1BR,cAAcF,UAAU;GAAE,GAAGE,cAAcF;GAASL,WAAW,CAAA;EAAG;EAClEM,UAAUM,WAASA,SAAO,CAAC;CAC7B;CAOA,OAAO;EAEL,IAAIK,QAAQ;GACV,OAAOV,cAAcF;EACvB;EACAG;EACAK;EACAE;EACAC,OAbYxB,kBAAkB;GAC9Be,cAAcF,UAAUP,wBAAwB;GAChDQ,UAAUM,WAASA,SAAO,CAAC;EAC7B,GAAG,CAAA,CAUDI;CACF;AACF"}

package/dist/react/runtimes/assistant-transport/replayBoundaryStream.d.ts

@@ -0,0 +1,11 @@
+//#region src/react/runtimes/assistant-transport/replayBoundaryStream.d.ts
+declare const REPLAY_CONTENT_LENGTH_HEADER = "Aui-Replay-Content-Length";
+type ReplayBoundaryStreamOptions = {
+  setReplaying: (value: boolean) => void;
+  waitForRender: () => Promise<void>;
+};
+declare const useReplayRenderWait: () => () => Promise<void>;
+declare const createReplayBoundaryStream: (response: Response, { setReplaying, waitForRender: waitForReplayRender }: ReplayBoundaryStreamOptions) => Promise<ReadableStream<Uint8Array>>;
+//#endregion
+export { REPLAY_CONTENT_LENGTH_HEADER, createReplayBoundaryStream, useReplayRenderWait };
+//# sourceMappingURL=replayBoundaryStream.d.ts.map

package/dist/react/runtimes/assistant-transport/replayBoundaryStream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replayBoundaryStream.d.ts","names":[],"sources":["../../../../src/react/runtimes/assistant-transport/replayBoundaryStream.ts"],"mappings":";cAIa;KAER;EACH,eAAe;EACf,qBAAqB;;cAGV,iCAAmB;cA6DnB,6BACX,UAAU,YACV,cAAA,eAAA,uBAGG,gCACF,QAAQ,eAAe"}

package/dist/react/runtimes/assistant-transport/replayBoundaryStream.js

@@ -0,0 +1,165 @@
+"use client";
+import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
+import { useEffect, useRef, useState } from "@assistant-ui/tap/react-shim";
+//#region src/react/runtimes/assistant-transport/replayBoundaryStream.ts
+const REPLAY_CONTENT_LENGTH_HEADER = "Aui-Replay-Content-Length";
+const useReplayRenderWait = () => {
+	const $ = c(8);
+	const [renderTicket, setRenderTicket] = useState(0);
+	const mountedRef = useRef(true);
+	const nextTicketRef = useRef(0);
+	let t0;
+	if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+		t0 = [];
+		$[0] = t0;
+	} else t0 = $[0];
+	const waitersRef = useRef(t0);
+	let t1;
+	if ($[1] === Symbol.for("react.memo_cache_sentinel")) {
+		t1 = (committedTicket) => {
+			const pendingWaiters = [];
+			for (const waiter of waitersRef.current) if (committedTicket === void 0 || waiter.ticket <= committedTicket) waiter.resolve();
+			else pendingWaiters.push(waiter);
+			waitersRef.current = pendingWaiters;
+		};
+		$[1] = t1;
+	} else t1 = $[1];
+	const resolveWaiters = t1;
+	let t2;
+	let t3;
+	if ($[2] !== renderTicket) {
+		t2 = () => {
+			mountedRef.current = true;
+			resolveWaiters(renderTicket);
+		};
+		t3 = [renderTicket, resolveWaiters];
+		$[2] = renderTicket;
+		$[3] = t2;
+		$[4] = t3;
+	} else {
+		t2 = $[3];
+		t3 = $[4];
+	}
+	useEffect(t2, t3);
+	let t4;
+	let t5;
+	if ($[5] === Symbol.for("react.memo_cache_sentinel")) {
+		t4 = () => () => {
+			mountedRef.current = false;
+			resolveWaiters();
+		};
+		t5 = [resolveWaiters];
+		$[5] = t4;
+		$[6] = t5;
+	} else {
+		t4 = $[5];
+		t5 = $[6];
+	}
+	useEffect(t4, t5);
+	let t6;
+	if ($[7] === Symbol.for("react.memo_cache_sentinel")) {
+		t6 = () => new Promise((resolve) => {
+			setTimeout(() => {
+				if (!mountedRef.current) {
+					resolve();
+					return;
+				}
+				const ticket = nextTicketRef.current + 1;
+				nextTicketRef.current = ticket;
+				waitersRef.current.push({
+					ticket,
+					resolve
+				});
+				setRenderTicket(ticket);
+			}, 0);
+		});
+		$[7] = t6;
+	} else t6 = $[7];
+	return t6;
+};
+const parseReplayContentLength = (headers) => {
+	const raw = headers.get(REPLAY_CONTENT_LENGTH_HEADER);
+	if (raw == null) return 0;
+	const boundary = Number(raw);
+	return Number.isSafeInteger(boundary) && boundary > 0 ? boundary : 0;
+};
+const createReplayBoundaryStream = async (response, { setReplaying, waitForRender: waitForReplayRender }) => {
+	const body = response.body;
+	const replayContentLength = parseReplayContentLength(response.headers);
+	if (replayContentLength <= 0) return body;
+	setReplaying(true);
+	await waitForReplayRender();
+	const reader = body.getReader();
+	let bytesForwarded = 0;
+	let replayFinished = false;
+	let readerCleanup;
+	const releaseReader = () => {
+		if (readerCleanup) return readerCleanup;
+		reader.releaseLock();
+		readerCleanup = Promise.resolve();
+		return readerCleanup;
+	};
+	const cancelReader = (reason) => {
+		if (readerCleanup) return readerCleanup;
+		readerCleanup = (async () => {
+			try {
+				await reader.cancel(reason);
+			} finally {
+				reader.releaseLock();
+			}
+		})();
+		return readerCleanup;
+	};
+	const finishReplay = async () => {
+		if (replayFinished) return;
+		replayFinished = true;
+		await waitForReplayRender();
+		setReplaying(false);
+		await waitForReplayRender();
+	};
+	return new ReadableStream({
+		async pull(controller) {
+			try {
+				const { done, value } = await reader.read();
+				if (done) {
+					await releaseReader();
+					await finishReplay();
+					controller.close();
+					return;
+				}
+				if (replayFinished) {
+					controller.enqueue(value);
+					return;
+				}
+				const nextBytesForwarded = bytesForwarded + value.byteLength;
+				if (nextBytesForwarded < replayContentLength) {
+					bytesForwarded = nextBytesForwarded;
+					controller.enqueue(value);
+					return;
+				}
+				if (nextBytesForwarded === replayContentLength) {
+					controller.enqueue(value);
+					await finishReplay();
+					return;
+				}
+				const replayBytesInChunk = replayContentLength - bytesForwarded;
+				controller.enqueue(value.subarray(0, replayBytesInChunk));
+				await finishReplay();
+				controller.enqueue(value.subarray(replayBytesInChunk));
+			} catch (error) {
+				await cancelReader(error).catch(() => {});
+				throw error;
+			}
+		},
+		async cancel(reason) {
+			const wasFinished = replayFinished;
+			replayFinished = true;
+			if (!wasFinished) setReplaying(false);
+			await cancelReader(reason);
+		}
+	});
+};
+//#endregion
+export { REPLAY_CONTENT_LENGTH_HEADER, createReplayBoundaryStream, useReplayRenderWait };
+
+//# sourceMappingURL=replayBoundaryStream.js.map

package/dist/react/runtimes/assistant-transport/replayBoundaryStream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"replayBoundaryStream.js","names":["c","_c","useCallback","useEffect","useRef","useState","REPLAY_CONTENT_LENGTH_HEADER","ReplayBoundaryStreamOptions","setReplaying","value","waitForRender","Promise","useReplayRenderWait","$","renderTicket","setRenderTicket","mountedRef","nextTicketRef","t0","Symbol","for","waitersRef","t1","committedTicket","pendingWaiters","waiter","current","undefined","ticket","resolve","push","resolveWaiters","t2","t3","t4","t5","t6","setTimeout","parseReplayContentLength","headers","Headers","raw","get","boundary","Number","isSafeInteger","createReplayBoundaryStream","response","Response","waitForReplayRender","ReadableStream","Uint8Array","body","replayContentLength","reader","getReader","bytesForwarded","replayFinished","readerCleanup","releaseReader","releaseLock","cancelReader","reason","cancel","finishReplay","pull","controller","done","read","close","enqueue","nextBytesForwarded","byteLength","replayBytesInChunk","subarray","error","catch","wasFinished"],"sources":["../../../../src/react/runtimes/assistant-transport/replayBoundaryStream.ts"],"sourcesContent":["\"use client\";\n\nimport { useCallback, useEffect, useRef, useState } from \"react\";\n\nexport const REPLAY_CONTENT_LENGTH_HEADER = \"Aui-Replay-Content-Length\";\n\ntype ReplayBoundaryStreamOptions = {\n  setReplaying: (value: boolean) => void;\n  waitForRender: () => Promise<void>;\n};\n\nexport const useReplayRenderWait = () => {\n  const [renderTicket, setRenderTicket] = useState(0);\n  const mountedRef = useRef(true);\n  const nextTicketRef = useRef(0);\n  const waitersRef = useRef<Array<{ ticket: number; resolve: () => void }>>([]);\n\n  const resolveWaiters = useCallback((committedTicket?: number) => {\n    const pendingWaiters = [];\n\n    for (const waiter of waitersRef.current) {\n      if (committedTicket === undefined || waiter.ticket <= committedTicket) {\n        waiter.resolve();\n      } else {\n        pendingWaiters.push(waiter);\n      }\n    }\n\n    waitersRef.current = pendingWaiters;\n  }, []);\n\n  useEffect(() => {\n    mountedRef.current = true;\n    resolveWaiters(renderTicket);\n  }, [renderTicket, resolveWaiters]);\n\n  useEffect(\n    () => () => {\n      mountedRef.current = false;\n      resolveWaiters();\n    },\n    [resolveWaiters],\n  );\n\n  return useCallback(\n    () =>\n      new Promise<void>((resolve) => {\n        setTimeout(() => {\n          if (!mountedRef.current) {\n            resolve();\n            return;\n          }\n\n          const ticket = nextTicketRef.current + 1;\n          nextTicketRef.current = ticket;\n          waitersRef.current.push({ ticket, resolve });\n          setRenderTicket(ticket);\n        }, 0);\n      }),\n    [],\n  );\n};\n\nconst parseReplayContentLength = (headers: Headers): number => {\n  const raw = headers.get(REPLAY_CONTENT_LENGTH_HEADER);\n  if (raw == null) return 0;\n\n  const boundary = Number(raw);\n  return Number.isSafeInteger(boundary) && boundary > 0 ? boundary : 0;\n};\n\n// Gates replay bytes until isReplaying:true renders, then releases live bytes after isReplaying:false renders.\nexport const createReplayBoundaryStream = async (\n  response: Response,\n  {\n    setReplaying,\n    waitForRender: waitForReplayRender,\n  }: ReplayBoundaryStreamOptions,\n): Promise<ReadableStream<Uint8Array>> => {\n  const body = response.body as ReadableStream<Uint8Array>;\n  const replayContentLength = parseReplayContentLength(response.headers);\n\n  if (replayContentLength <= 0) {\n    return body;\n  }\n\n  setReplaying(true);\n  await waitForReplayRender();\n\n  const reader = body.getReader();\n  let bytesForwarded = 0;\n  let replayFinished = false;\n  let readerCleanup: Promise<void> | undefined;\n\n  const releaseReader = () => {\n    if (readerCleanup) return readerCleanup;\n    reader.releaseLock();\n    readerCleanup = Promise.resolve();\n    return readerCleanup;\n  };\n\n  const cancelReader = (reason?: unknown) => {\n    if (readerCleanup) return readerCleanup;\n    readerCleanup = (async () => {\n      try {\n        await reader.cancel(reason);\n      } finally {\n        reader.releaseLock();\n      }\n    })();\n    return readerCleanup;\n  };\n\n  const finishReplay = async () => {\n    if (replayFinished) return;\n    replayFinished = true;\n\n    // Let replay bytes drain before rendering live mode, then render live mode before releasing live bytes.\n    await waitForReplayRender();\n    setReplaying(false);\n    await waitForReplayRender();\n  };\n\n  return new ReadableStream<Uint8Array>({\n    async pull(controller) {\n      try {\n        const { done, value } = await reader.read();\n\n        if (done) {\n          await releaseReader();\n          await finishReplay();\n          controller.close();\n          return;\n        }\n\n        if (replayFinished) {\n          controller.enqueue(value);\n          return;\n        }\n\n        const nextBytesForwarded = bytesForwarded + value.byteLength;\n\n        if (nextBytesForwarded < replayContentLength) {\n          bytesForwarded = nextBytesForwarded;\n          controller.enqueue(value);\n          return;\n        }\n\n        if (nextBytesForwarded === replayContentLength) {\n          controller.enqueue(value);\n          await finishReplay();\n          return;\n        }\n\n        const replayBytesInChunk = replayContentLength - bytesForwarded;\n\n        controller.enqueue(value.subarray(0, replayBytesInChunk));\n        await finishReplay();\n        controller.enqueue(value.subarray(replayBytesInChunk));\n      } catch (error) {\n        await cancelReader(error).catch(() => {});\n        throw error;\n      }\n    },\n    async cancel(reason) {\n      const wasFinished = replayFinished;\n      replayFinished = true;\n      if (!wasFinished) setReplaying(false);\n      await cancelReader(reason);\n    },\n  });\n};\n"],"mappings":"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"}

package/dist/react/runtimes/assistant-transport/runManager.d.ts

@@ -0,0 +1,15 @@
+//#region src/react/runtimes/assistant-transport/runManager.d.ts
+type RunManager = Readonly<{
+  isRunning: boolean;
+  schedule: () => void;
+  cancel: () => void;
+}>;
+declare function useRunManager(config: {
+  onRun: (signal: AbortSignal) => Promise<void>;
+  onFinish?: (() => void) | undefined;
+  onCancel?: (() => void) | undefined;
+  onError?: ((error: Error) => void | Promise<void>) | undefined;
+}): RunManager;
+//#endregion
+export { RunManager, useRunManager };
+//# sourceMappingURL=runManager.d.ts.map

package/dist/react/runtimes/assistant-transport/runManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runManager.d.ts","names":[],"sources":["../../../../src/react/runtimes/assistant-transport/runManager.ts"],"mappings":";KAGY,aAAa;EACvB;EACA;EACA;;iBA2Bc,cAAc;EAC5B,QAAQ,QAAQ,gBAAgB;EAChC;EACA;EACA,YAAY,OAAO,iBAAiB;IAClC"}

package/dist/react/runtimes/assistant-transport/runManager.js

@@ -0,0 +1,86 @@
+import { useLatestRef } from "./useLatestRef.js";
+import { useCallback, useEffect, useRef, useState } from "@assistant-ui/tap/react-shim";
+//#region src/react/runtimes/assistant-transport/runManager.ts
+const disposeReason = Symbol("assistant-transport-dispose");
+const reportCallbackError = (name, error) => {
+	console.error(`[assistant-ui] Assistant transport ${name} callback threw an error`, error);
+};
+const invokeCallback = async (name, callback) => {
+	try {
+		await callback?.();
+	} catch (error) {
+		try {
+			reportCallbackError(name, error);
+		} catch {}
+	}
+};
+function useRunManager(config) {
+	const [isRunning, setIsRunning] = useState(false);
+	const stateRef = useRef({
+		pending: false,
+		disposed: false,
+		abortController: null
+	});
+	const onRunRef = useLatestRef(config.onRun);
+	const onFinishRef = useLatestRef(config.onFinish);
+	const onCancelRef = useLatestRef(config.onCancel);
+	const onErrorRef = useLatestRef(config.onError);
+	const startRun = useCallback(() => {
+		setIsRunning(true);
+		stateRef.current.pending = false;
+		const ac = new AbortController();
+		stateRef.current.abortController = ac;
+		const disposeAborted = () => ac.signal.reason === disposeReason;
+		queueMicrotask(async () => {
+			try {
+				if (!disposeAborted()) await onRunRef.current(ac.signal);
+			} catch (error) {
+				if (!disposeAborted() && !stateRef.current.disposed) {
+					stateRef.current.pending = false;
+					if (ac.signal.aborted) invokeCallback("onCancel", onCancelRef.current);
+					else await invokeCallback("onError", () => onErrorRef.current?.(error));
+				}
+			} finally {
+				if (!disposeAborted() && !stateRef.current.disposed) invokeCallback("onFinish", onFinishRef.current);
+				if (!stateRef.current.disposed && stateRef.current.pending) startRun();
+				else {
+					setIsRunning(false);
+					if (stateRef.current.abortController === ac) stateRef.current.abortController = null;
+				}
+			}
+		});
+	}, [
+		onRunRef,
+		onFinishRef,
+		onErrorRef,
+		onCancelRef
+	]);
+	const schedule = useCallback(() => {
+		if (stateRef.current.disposed) return;
+		if (stateRef.current.abortController) {
+			stateRef.current.pending = true;
+			return;
+		}
+		startRun();
+	}, [startRun]);
+	useEffect(() => {
+		stateRef.current.disposed = false;
+		return () => {
+			stateRef.current.disposed = true;
+			stateRef.current.pending = false;
+			stateRef.current.abortController?.abort(disposeReason);
+		};
+	}, []);
+	return {
+		isRunning,
+		schedule,
+		cancel: useCallback(() => {
+			stateRef.current.pending = false;
+			stateRef.current.abortController?.abort();
+		}, [])
+	};
+}
+//#endregion
+export { useRunManager };
+
+//# sourceMappingURL=runManager.js.map

package/dist/react/runtimes/assistant-transport/runManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runManager.js","names":["useCallback","useEffect","useRef","useState","useLatestRef","RunManager","Readonly","isRunning","schedule","cancel","disposeReason","Symbol","LifecycleCallbackName","reportCallbackError","name","error","console","invokeCallback","callback","Promise","useRunManager","config","onRun","signal","AbortSignal","onFinish","onCancel","onError","Error","setIsRunning","stateRef","pending","disposed","abortController","AbortController","onRunRef","onFinishRef","onCancelRef","onErrorRef","startRun","current","ac","disposeAborted","reason","queueMicrotask","aborted","abort"],"sources":["../../../../src/react/runtimes/assistant-transport/runManager.ts"],"sourcesContent":["import { useCallback, useEffect, useRef, useState } from \"react\";\nimport { useLatestRef } from \"./useLatestRef\";\n\nexport type RunManager = Readonly<{\n  isRunning: boolean;\n  schedule: () => void;\n  cancel: () => void;\n}>;\n\nconst disposeReason = Symbol(\"assistant-transport-dispose\");\n\ntype LifecycleCallbackName = \"onCancel\" | \"onError\" | \"onFinish\";\n\nconst reportCallbackError = (name: LifecycleCallbackName, error: unknown) => {\n  console.error(\n    `[assistant-ui] Assistant transport ${name} callback threw an error`,\n    error,\n  );\n};\n\nconst invokeCallback = async (\n  name: LifecycleCallbackName,\n  callback: (() => unknown) | undefined,\n): Promise<void> => {\n  try {\n    await callback?.();\n  } catch (error) {\n    try {\n      reportCallbackError(name, error);\n    } catch {}\n  }\n};\n\nexport function useRunManager(config: {\n  onRun: (signal: AbortSignal) => Promise<void>;\n  onFinish?: (() => void) | undefined;\n  onCancel?: (() => void) | undefined;\n  onError?: ((error: Error) => void | Promise<void>) | undefined;\n}): RunManager {\n  const [isRunning, setIsRunning] = useState(false);\n  const stateRef = useRef({\n    pending: false,\n    disposed: false,\n    abortController: null as AbortController | null,\n  });\n  const onRunRef = useLatestRef(config.onRun);\n  const onFinishRef = useLatestRef(config.onFinish);\n  const onCancelRef = useLatestRef(config.onCancel);\n  const onErrorRef = useLatestRef(config.onError);\n\n  const startRun = useCallback(() => {\n    setIsRunning(true);\n    stateRef.current.pending = false;\n    const ac = new AbortController();\n    stateRef.current.abortController = ac;\n\n    // The dispose marker rides on the abort reason so a settling run detects\n    // its own disposal even after an effect cycle re-arms the manager.\n    const disposeAborted = () => ac.signal.reason === disposeReason;\n\n    queueMicrotask(async () => {\n      try {\n        if (!disposeAborted()) {\n          await onRunRef.current(ac.signal);\n        }\n      } catch (error) {\n        if (!disposeAborted() && !stateRef.current.disposed) {\n          stateRef.current.pending = false;\n          if (ac.signal.aborted) {\n            void invokeCallback(\"onCancel\", onCancelRef.current);\n          } else {\n            await invokeCallback(\"onError\", () =>\n              onErrorRef.current?.(error as Error),\n            );\n          }\n        }\n      } finally {\n        if (!disposeAborted() && !stateRef.current.disposed) {\n          void invokeCallback(\"onFinish\", onFinishRef.current);\n        }\n        if (!stateRef.current.disposed && stateRef.current.pending) {\n          startRun();\n        } else {\n          setIsRunning(false);\n          if (stateRef.current.abortController === ac) {\n            stateRef.current.abortController = null;\n          }\n        }\n      }\n    });\n  }, [onRunRef, onFinishRef, onErrorRef, onCancelRef]);\n\n  const schedule = useCallback(() => {\n    if (stateRef.current.disposed) return;\n    if (stateRef.current.abortController) {\n      // Coalesce multiple schedules while running into a single follow-up run.\n      stateRef.current.pending = true;\n      return;\n    }\n    startRun();\n  }, [startRun]);\n\n  // Strict-mode effects run setup / cleanup / setup on the same instance;\n  // arming on setup undoes the cleanup's dispose.\n  useEffect(() => {\n    stateRef.current.disposed = false;\n    return () => {\n      stateRef.current.disposed = true;\n      stateRef.current.pending = false;\n      stateRef.current.abortController?.abort(disposeReason);\n    };\n  }, []);\n\n  const cancel = useCallback(() => {\n    stateRef.current.pending = false;\n    stateRef.current.abortController?.abort();\n  }, []);\n\n  return {\n    isRunning,\n    schedule,\n    cancel,\n  };\n}\n"],"mappings":";;;AASA,MAAMU,gBAAgBC,OAAO,6BAA6B;AAI1D,MAAME,uBAAuBC,MAA6BC,UAAmB;CAC3EC,QAAQD,MACN,sCAAsCD,KAAI,2BAC1CC,KACF;AACF;AAEA,MAAME,iBAAiB,OACrBH,MACAI,aACkB;CAClB,IAAI;EACF,MAAMA,WAAW;CACnB,SAASH,OAAO;EACd,IAAI;GACFF,oBAAoBC,MAAMC,KAAK;EACjC,QAAQ,CAAC;CACX;AACF;AAEA,SAAgBK,cAAcC,QAKf;CACb,MAAM,CAACd,WAAWsB,gBAAgB1B,SAAS,KAAK;CAChD,MAAM2B,WAAW5B,OAAO;EACtB6B,SAAS;EACTC,UAAU;EACVC,iBAAiB;CACnB,CAAC;CACD,MAAME,WAAW/B,aAAaiB,OAAOC,KAAK;CAC1C,MAAMc,cAAchC,aAAaiB,OAAOI,QAAQ;CAChD,MAAMY,cAAcjC,aAAaiB,OAAOK,QAAQ;CAChD,MAAMY,aAAalC,aAAaiB,OAAOM,OAAO;CAE9C,MAAMY,WAAWvC,kBAAkB;EACjC6B,aAAa,IAAI;EACjBC,SAASU,QAAQT,UAAU;EAC3B,MAAMU,KAAK,IAAIP,gBAAgB;EAC/BJ,SAASU,QAAQP,kBAAkBQ;EAInC,MAAMC,uBAAuBD,GAAGlB,OAAOoB,WAAWjC;EAElDkC,eAAe,YAAY;GACzB,IAAI;IACF,IAAI,CAACF,eAAe,GAClB,MAAMP,SAASK,QAAQC,GAAGlB,MAAM;GAEpC,SAASR,OAAO;IACd,IAAI,CAAC2B,eAAe,KAAK,CAACZ,SAASU,QAAQR,UAAU;KACnDF,SAASU,QAAQT,UAAU;KAC3B,IAAIU,GAAGlB,OAAOsB,SACZ,eAAoB,YAAYR,YAAYG,OAAO;UAEnD,MAAMvB,eAAe,iBACnBqB,WAAWE,UAAUzB,KAAc,CACrC;IAEJ;GACF,UAAU;IACR,IAAI,CAAC2B,eAAe,KAAK,CAACZ,SAASU,QAAQR,UACzC,eAAoB,YAAYI,YAAYI,OAAO;IAErD,IAAI,CAACV,SAASU,QAAQR,YAAYF,SAASU,QAAQT,SACjDQ,SAAS;SACJ;KACLV,aAAa,KAAK;KAClB,IAAIC,SAASU,QAAQP,oBAAoBQ,IACvCX,SAASU,QAAQP,kBAAkB;IAEvC;GACF;EACF,CAAC;CACH,GAAG;EAACE;EAAUC;EAAaE;EAAYD;CAAW,CAAC;CAEnD,MAAM7B,WAAWR,kBAAkB;EACjC,IAAI8B,SAASU,QAAQR,UAAU;EAC/B,IAAIF,SAASU,QAAQP,iBAAiB;GAEpCH,SAASU,QAAQT,UAAU;GAC3B;EACF;EACAQ,SAAS;CACX,GAAG,CAACA,QAAQ,CAAC;CAIbtC,gBAAgB;EACd6B,SAASU,QAAQR,WAAW;EAC5B,aAAa;GACXF,SAASU,QAAQR,WAAW;GAC5BF,SAASU,QAAQT,UAAU;GAC3BD,SAASU,QAAQP,iBAAiBa,MAAMpC,aAAa;EACvD;CACF,GAAG,CAAA,CAAE;CAOL,OAAO;EACLH;EACAC;EACAC,QARaT,kBAAkB;GAC/B8B,SAASU,QAAQT,UAAU;GAC3BD,SAASU,QAAQP,iBAAiBa,MAAM;EAC1C,GAAG,CAAA,CAKDrC;CACF;AACF"}

package/dist/react/runtimes/assistant-transport/types.d.ts

@@ -0,0 +1,130 @@
+import { ThreadMessage } from "../../../types/message.js";
+import { AttachmentAdapter } from "../../../adapters/attachment.js";
+import { LanguageModelConfig, LanguageModelV1CallSettings } from "../../../model-context/types.js";
+import { ThreadHistoryAdapter } from "../../../adapters/thread-history.js";
+import { UserCommands } from "../../../types/augmentations.js";
+import { ToolExecutionStatus } from "../../../runtimes/tool-invocations/ToolInvocationTracker.js";
+import { ToolModelContentPart } from "assistant-stream";
+import { ReadonlyJSONValue } from "assistant-stream/utils";
+//#region src/react/runtimes/assistant-transport/types.d.ts
+type TextPart = {
+  readonly type: "text";
+  readonly text: string;
+};
+type ImagePart = {
+  readonly type: "image";
+  readonly image: string;
+};
+type UserMessagePart = TextPart | ImagePart;
+type UserMessage = {
+  readonly role: "user";
+  readonly parts: readonly UserMessagePart[];
+};
+type AssistantMessage = {
+  readonly role: "assistant";
+  readonly parts: readonly TextPart[];
+};
+type AddMessageCommand = {
+  readonly type: "add-message";
+  readonly message: UserMessage | AssistantMessage;
+  readonly parentId: string | null;
+  readonly sourceId: string | null;
+};
+type AddToolResultCommand = {
+  readonly type: "add-tool-result";
+  readonly toolCallId: string;
+  readonly toolName: string;
+  readonly result: ReadonlyJSONValue;
+  readonly isError: boolean;
+  readonly artifact?: ReadonlyJSONValue;
+  readonly modelContent?: readonly ToolModelContentPart[];
+};
+type AssistantTransportCommand = AddMessageCommand | AddToolResultCommand | UserCommands;
+type AssistantTransportState = {
+  readonly messages: readonly ThreadMessage[];
+  readonly state?: ReadonlyJSONValue;
+  readonly isRunning: boolean;
+};
+type AssistantTransportConnectionMetadata = {
+  pendingCommands: AssistantTransportCommand[];
+  isSending: boolean;
+  toolStatuses: Record<string, ToolExecutionStatus>;
+};
+type AssistantTransportStateConverter<T> = (state: T, connectionMetadata: AssistantTransportConnectionMetadata) => AssistantTransportState;
+type CommandQueueState = {
+  queued: AssistantTransportCommand[];
+  inTransit: AssistantTransportCommand[];
+};
+type QueuedCommand = AssistantTransportCommand;
+type HeadersValue = Record<string, string> | Headers;
+type AssistantTransportProtocol = "data-stream" | "assistant-transport";
+type SendCommandsRequestBody = {
+  commands: QueuedCommand[];
+  /** Absent on a resume with `resumeStateApi`; the server replays from its retained snapshot. */
+  state?: unknown;
+  runId?: string;
+  system: string | undefined;
+  tools: Record<string, unknown> | undefined;
+  callSettings: LanguageModelV1CallSettings | undefined;
+  config: LanguageModelConfig | undefined;
+  threadId: string | null;
+  parentId?: string | null;
+  [key: string]: unknown;
+};
+type AssistantTransportOptions<T> = {
+  initialState: T;
+  api: string;
+  resumeApi?: string;
+  /** Endpoint that returns the retained initial state and run ID for a resume stream. A 204 response means no run is active and the resume is skipped. */
+  resumeStateApi?: string;
+  protocol?: AssistantTransportProtocol;
+  /**
+   * When `false`, stream decoding and state reconciliation tolerate malformed
+   * input (invalid chunks are dropped with a console log) instead of throwing.
+   * Resume runs always decode leniently. Defaults to `true`.
+   */
+  strict?: boolean;
+  converter: AssistantTransportStateConverter<T>;
+  headers: HeadersValue | (() => Promise<HeadersValue>);
+  body?: object | (() => Promise<object | undefined>);
+  /**
+   * Transform the request body before it is sent to the API.
+   * Receives the fully assembled body and returns the (potentially transformed) body.
+   *
+   * @example
+   * ```ts
+   * prepareSendCommandsRequest: (body) => ({
+   *   ...body,
+   *   trackingId: crypto.randomUUID(),
+   * })
+   * ```
+   */
+  prepareSendCommandsRequest?: (body: SendCommandsRequestBody) => Record<string, unknown> | Promise<Record<string, unknown>>;
+  onResponse?: (response: Response) => void | Promise<void>;
+  onFinish?: () => void;
+  onError?: (error: Error, params: {
+    commands: AssistantTransportCommand[];
+    updateState: (updater: (state: T) => T) => void;
+  }) => void | Promise<void>;
+  /**
+   * Called when commands are cancelled.
+   *
+   * When an error occurs, queued commands are automatically cancelled after `onError` settles.
+   * In this case, the `error` parameter contains the error that caused the cancellation.
+   */
+  onCancel?: (params: {
+    commands: AssistantTransportCommand[];
+    updateState: (updater: (state: T) => T) => void;
+    error?: Error;
+  }) => void;
+  capabilities?: {
+    edit?: boolean;
+  };
+  adapters?: {
+    attachments?: AttachmentAdapter | undefined;
+    history?: ThreadHistoryAdapter | undefined;
+  };
+};
+//#endregion
+export { AddMessageCommand, AddToolResultCommand, AssistantMessage, AssistantTransportCommand, AssistantTransportConnectionMetadata, AssistantTransportOptions, AssistantTransportProtocol, AssistantTransportState, AssistantTransportStateConverter, CommandQueueState, HeadersValue, ImagePart, QueuedCommand, SendCommandsRequestBody, TextPart, UserMessage, UserMessagePart };
+//# sourceMappingURL=types.d.ts.map

package/dist/react/runtimes/assistant-transport/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../../src/react/runtimes/assistant-transport/types.ts"],"mappings":";;;;;;;;;KAaY;WACD;WACA;;KAGC;WACD;WACA;;KAGC,kBAAkB,WAAW;KAE7B;WACD;WACA,gBAAgB;;KAGf;WACD;WACA,gBAAgB;;KAIf;WACD;WACA,SAAS,cAAc;WACvB;WACA;;KAGC;WACD;WACA;WACA;WACA,QAAQ;WACR;WACA,WAAW;WACX,wBAAwB;;KAGvB,4BACR,oBACA,uBACA;KAGQ;WACD,mBAAmB;WACnB,QAAQ;WACR;;KAGC;EACV,iBAAiB;EACjB;EACA,cAAc,eAAe;;KAGnB,iCAAiC,MAC3C,OAAO,GACP,oBAAoB,yCACjB;KAGO;EACV,QAAQ;EACR,WAAW;;KAID,gBAAgB;KAKhB,eAAe,yBAAyB;KAExC;KAEA;EACV,UAAU;;EAEV;EACA;EACA;EACA,OAAO;EACP,cAAc;EACd,QAAQ;EACR;EACA;GAIC;;KAGS,0BAA0B;EACpC,cAAc;EACd;EACA;;EAEA;EACA,WAAW;;;;;;EAMX;EACA,WAAW,iCAAiC;EAC5C,SAAS,sBAAsB,QAAQ;EACvC,uBAAuB;;;;;;;;;;;;;EAavB,8BACE,MAAM,4BACH,0BAA0B,QAAQ;EACvC,cAAc,UAAU,oBAAoB;EAC5C;EACA,WACE,OAAO,OACP;IACE,UAAU;IACV,cAAc,UAAU,OAAO,MAAM;eAE7B;;;;;;;EAOZ,YAAY;IACV,UAAU;IACV,cAAc,UAAU,OAAO,MAAM;IACrC,QAAQ;;EAEV;IACE;;EAEF;IACE,cAAc;IACd,UAAU"}

package/dist/react/runtimes/assistant-transport/useAssistantTransportRuntime.d.ts

@@ -0,0 +1,14 @@
+import { UserExternalState } from "../../../types/augmentations.js";
+import { AssistantRuntime } from "../../../runtime/api/assistant-runtime.js";
+import { AssistantTransportCommand, AssistantTransportOptions } from "./types.js";
+//#region src/react/runtimes/assistant-transport/useAssistantTransportRuntime.d.ts
+declare const useAssistantTransportSendCommand: () => (command: AssistantTransportCommand) => void;
+declare function useAssistantTransportState(): UserExternalState;
+declare function useAssistantTransportState<T>(selector: (state: UserExternalState) => T): T;
+/**
+ * @alpha This is an experimental API that is subject to change.
+ */
+declare const useAssistantTransportRuntime: <T>(options: AssistantTransportOptions<T>) => AssistantRuntime;
+//#endregion
+export { useAssistantTransportRuntime, useAssistantTransportSendCommand, useAssistantTransportState };
+//# sourceMappingURL=useAssistantTransportRuntime.d.ts.map

package/dist/react/runtimes/assistant-transport/useAssistantTransportRuntime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAssistantTransportRuntime.d.ts","names":[],"sources":["../../../../src/react/runtimes/assistant-transport/useAssistantTransportRuntime.ts"],"mappings":";;;;cA8Ha,yCAGH,SAAS;iBAOH,8BAA8B;iBAC9B,2BAA2B,GACzC,WAAW,OAAO,sBAAsB,IACvC;;;;cA0UU,+BAAgC,GAC3C,SAAS,0BAA0B,OAClC"}