@ulearning/ai-sdk-adapter 0.0.0-stage → 1.0.0-next.0

package/dist/runtime/useMessageQueue.d.ts

@@ -0,0 +1,14 @@
+import { type AppendMessage } from "@ulearning/ai-core";
+export declare const useMessageQueue: ({ enabled, isRunning, isSendDisabled, send, cancel, onError, }: {
+    enabled: boolean;
+    isRunning: boolean;
+    isSendDisabled: boolean;
+    send: (message: AppendMessage) => Promise<void>;
+    cancel: () => Promise<void>;
+    onError?: ((error: Error | undefined) => void) | undefined;
+}) => {
+    adapter: import("@ulearning/ai-core").ExternalThreadQueueAdapter | undefined;
+    cancel: () => Promise<void>;
+    clear: () => void;
+};
+//# sourceMappingURL=useMessageQueue.d.ts.map

package/dist/runtime/useMessageQueue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMessageQueue.d.ts","mappings":"AASA,OAAO,EAEL,KAAK,aAAa,EAEnB,MAAM,oBAAoB;AAK3B,eAAO,MAAM,eAAe,GAAI,gEAO7B;IACD,OAAO,EAAE,OAAO;IAChB,SAAS,EAAE,OAAO;IAClB,cAAc,EAAE,OAAO;IACvB,IAAI,EAAE,CAAC,OAAO,EAAE,aAAa,KAAK,OAAO,CAAC,IAAI,CAAC;IAC/C,MAAM,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC;IAC3B,OAAO,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,KAAK,GAAG,SAAS,KAAK,IAAI,CAAC,GAAG,SAAS;CAC3D;;;;CA4JA","names":[],"ignoreList":[],"sources":["../../src/runtime/useMessageQueue.ts"],"sourcesContent":[null]}

package/dist/runtime/useMessageQueue.js

@@ -0,0 +1,142 @@
+"use client";
+import { createMessageQueue } from "@ulearning/ai-core";
+import { useCallback, useEffect, useInsertionEffect, useRef, useSyncExternalStore } from "@ulearning/ai-tap";
+// src/runtime/useMessageQueue.ts
+const subscribeNoop = () => () => {};
+const getNoItems = () => void 0;
+const useMessageQueue = ({ enabled, isRunning, isSendDisabled, send, cancel, onError }) => {
+	const sendRef = useRef(send);
+	const cancelRef = useRef(cancel);
+	const onErrorRef = useRef(onError);
+	const heldRef = useRef(!enabled || isSendDisabled);
+	const runningRef = useRef(isRunning);
+	useInsertionEffect(() => {
+		sendRef.current = send;
+		cancelRef.current = cancel;
+		onErrorRef.current = onError;
+		heldRef.current = !enabled || isSendDisabled;
+		runningRef.current = isRunning;
+	});
+	const cancelsRef = useRef(0);
+	const cancelRun = useCallback(() => {
+		cancelsRef.current++;
+		return cancelRef.current();
+	}, []);
+	const reportedRef = useRef({
+		controller: null,
+		busy: isRunning
+	});
+	const busyEdgesRef = useRef(0);
+	const idleWaitersRef = useRef([]);
+	const lastDispatchRef = useRef(Promise.resolve());
+	const mountedRef = useRef(true);
+	const generationRef = useRef(0);
+	const queueRef = useRef(null);
+	if (enabled && !queueRef.current) {
+		const controller = createMessageQueue({ run: (message) => {
+			const previous = lastDispatchRef.current;
+			const cancels = cancelsRef.current;
+			const generation = generationRef.current;
+			const busyEdgesAtDispatch = busyEdgesRef.current;
+			const dispatch = (async () => {
+				await previous;
+				let settledCancels = cancels;
+				while (true) {
+					if (!mountedRef.current || generation !== generationRef.current) {
+						if (mountedRef.current && (!runningRef.current || busyEdgesAtDispatch === busyEdgesRef.current)) controller.notifyIdle();
+						return;
+					}
+					if (heldRef.current || runningRef.current || reportedRef.current.busy) {
+						await new Promise((resolve) => {
+							idleWaitersRef.current.push(resolve);
+						});
+						continue;
+					}
+					if (settledCancels !== cancelsRef.current) {
+						settledCancels = cancelsRef.current;
+						await new Promise((resolve) => setTimeout(resolve));
+						continue;
+					}
+					break;
+				}
+				const overtaken = settledCancels !== cancels;
+				const busyEdges = busyEdgesRef.current;
+				onErrorRef.current?.(void 0);
+				try {
+					if (overtaken) {
+						const error = /* @__PURE__ */ new Error("Queued send cancelled before dispatch");
+						error.name = "AbortError";
+						throw error;
+					}
+					await sendRef.current(message);
+				} catch (error) {
+					if (mountedRef.current && generation === generationRef.current) onErrorRef.current?.(error instanceof Error ? error : new Error(String(error)));
+					throw error;
+				}
+				if (busyEdgesRef.current === busyEdges && !runningRef.current) controller.notifyIdle();
+			})();
+			lastDispatchRef.current = dispatch.catch(() => {});
+			return dispatch;
+		} });
+		queueRef.current = controller;
+	}
+	const controller = queueRef.current;
+	useSyncExternalStore(controller?.subscribe ?? subscribeNoop, () => controller?.adapter.items, getNoItems);
+	useSyncExternalStore(controller?.subscribe ?? subscribeNoop, () => controller?.adapter.steerItems, getNoItems);
+	useEffect(() => {
+		mountedRef.current = true;
+		return () => {
+			mountedRef.current = false;
+			controller?.hold();
+			const waiters = idleWaitersRef.current;
+			idleWaitersRef.current = [];
+			for (const resolve of waiters) resolve();
+		};
+	}, [controller]);
+	useEffect(() => {
+		if (!controller) return;
+		if (!enabled || isSendDisabled) controller.hold();
+		else controller.release();
+	}, [
+		controller,
+		enabled,
+		isSendDisabled
+	]);
+	useEffect(() => {
+		const reported = reportedRef.current;
+		if (reported.controller !== controller || reported.busy !== isRunning) {
+			reportedRef.current = {
+				controller,
+				busy: isRunning
+			};
+			if (isRunning) {
+				busyEdgesRef.current++;
+				controller?.notifyBusy();
+			} else controller?.notifyIdle();
+		}
+		if (!enabled || isSendDisabled || isRunning) return;
+		const waiters = idleWaitersRef.current;
+		idleWaitersRef.current = [];
+		for (const resolve of waiters) resolve();
+	}, [
+		controller,
+		enabled,
+		isRunning,
+		isSendDisabled
+	]);
+	return {
+		adapter: enabled ? controller?.adapter : void 0,
+		cancel: cancelRun,
+		clear: () => {
+			onErrorRef.current?.(void 0);
+			generationRef.current++;
+			controller?.clear();
+			const waiters = idleWaitersRef.current;
+			idleWaitersRef.current = [];
+			for (const resolve of waiters) resolve();
+		}
+	};
+};
+export { useMessageQueue };
+
+//# sourceMappingURL=useMessageQueue.js.map

package/dist/runtime/useMessageQueue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMessageQueue.js","names":[],"sources":["../../src/runtime/useMessageQueue.ts"],"sourcesContent":["\"use client\";\n\nimport {\n  useCallback,\n  useEffect,\n  useInsertionEffect,\n  useRef,\n  useSyncExternalStore,\n} from \"@ulearning/ai-tap\";\nimport {\n  createMessageQueue,\n  type AppendMessage,\n  type MessageQueueController,\n} from \"@ulearning/ai-core\";\n\nconst subscribeNoop = () => () => {};\nconst getNoItems = () => undefined;\n\nexport const useMessageQueue = ({\n  enabled,\n  isRunning,\n  isSendDisabled,\n  send,\n  cancel,\n  onError,\n}: {\n  enabled: boolean;\n  isRunning: boolean;\n  isSendDisabled: boolean;\n  send: (message: AppendMessage) => Promise<void>;\n  cancel: () => Promise<void>;\n  onError?: ((error: Error | undefined) => void) | undefined;\n}) => {\n  const sendRef = useRef(send);\n  const cancelRef = useRef(cancel);\n  const onErrorRef = useRef(onError);\n  const heldRef = useRef(!enabled || isSendDisabled);\n  const runningRef = useRef(isRunning);\n  useInsertionEffect(() => {\n    sendRef.current = send;\n    cancelRef.current = cancel;\n    onErrorRef.current = onError;\n    heldRef.current = !enabled || isSendDisabled;\n    runningRef.current = isRunning;\n  });\n\n  const cancelsRef = useRef(0);\n  const cancelRun = useCallback(() => {\n    cancelsRef.current++;\n    return cancelRef.current();\n  }, []);\n\n  const reportedRef = useRef<{\n    controller: MessageQueueController | null;\n    busy: boolean;\n  }>({ controller: null, busy: isRunning });\n  const busyEdgesRef = useRef(0);\n  const idleWaitersRef = useRef<(() => void)[]>([]);\n  const lastDispatchRef = useRef<Promise<void>>(Promise.resolve());\n  const mountedRef = useRef(true);\n  const generationRef = useRef(0);\n\n  const queueRef = useRef<MessageQueueController | null>(null);\n  if (enabled && !queueRef.current) {\n    const controller = createMessageQueue({\n      run: (message) => {\n        const previous = lastDispatchRef.current;\n        const cancels = cancelsRef.current;\n        const generation = generationRef.current;\n        const busyEdgesAtDispatch = busyEdgesRef.current;\n        const dispatch = (async () => {\n          await previous;\n          let settledCancels = cancels;\n          while (true) {\n            if (!mountedRef.current || generation !== generationRef.current) {\n              if (\n                mountedRef.current &&\n                (!runningRef.current ||\n                  busyEdgesAtDispatch === busyEdgesRef.current)\n              ) {\n                controller.notifyIdle();\n              }\n              return;\n            }\n            if (\n              heldRef.current ||\n              runningRef.current ||\n              reportedRef.current.busy\n            ) {\n              await new Promise<void>((resolve) => {\n                idleWaitersRef.current.push(resolve);\n              });\n              continue;\n            }\n            if (settledCancels !== cancelsRef.current) {\n              settledCancels = cancelsRef.current;\n              await new Promise((resolve) => setTimeout(resolve));\n              continue;\n            }\n            break;\n          }\n          const overtaken = settledCancels !== cancels;\n          const busyEdges = busyEdgesRef.current;\n          onErrorRef.current?.(undefined);\n          try {\n            if (overtaken) {\n              const error = new Error(\"Queued send cancelled before dispatch\");\n              error.name = \"AbortError\";\n              throw error;\n            }\n            await sendRef.current(message);\n          } catch (error) {\n            if (mountedRef.current && generation === generationRef.current) {\n              onErrorRef.current?.(\n                error instanceof Error ? error : new Error(String(error)),\n              );\n            }\n            throw error;\n          }\n          if (busyEdgesRef.current === busyEdges && !runningRef.current) {\n            controller.notifyIdle();\n          }\n        })();\n        lastDispatchRef.current = dispatch.catch(() => {});\n        return dispatch;\n      },\n    });\n    queueRef.current = controller;\n  }\n  const controller = queueRef.current;\n\n  useSyncExternalStore(\n    controller?.subscribe ?? subscribeNoop,\n    () => controller?.adapter.items,\n    getNoItems,\n  );\n  useSyncExternalStore(\n    controller?.subscribe ?? subscribeNoop,\n    () => controller?.adapter.steerItems,\n    getNoItems,\n  );\n\n  useEffect(() => {\n    mountedRef.current = true;\n    return () => {\n      mountedRef.current = false;\n      controller?.hold();\n      const waiters = idleWaitersRef.current;\n      idleWaitersRef.current = [];\n      for (const resolve of waiters) resolve();\n    };\n  }, [controller]);\n\n  useEffect(() => {\n    if (!controller) return;\n    if (!enabled || isSendDisabled) controller.hold();\n    else controller.release();\n  }, [controller, enabled, isSendDisabled]);\n\n  useEffect(() => {\n    const reported = reportedRef.current;\n    if (reported.controller !== controller || reported.busy !== isRunning) {\n      reportedRef.current = { controller, busy: isRunning };\n      if (isRunning) {\n        busyEdgesRef.current++;\n        controller?.notifyBusy();\n      } else {\n        controller?.notifyIdle();\n      }\n    }\n    if (!enabled || isSendDisabled || isRunning) return;\n    const waiters = idleWaitersRef.current;\n    idleWaitersRef.current = [];\n    for (const resolve of waiters) resolve();\n  }, [controller, enabled, isRunning, isSendDisabled]);\n\n  return {\n    adapter: enabled ? controller?.adapter : undefined,\n    cancel: cancelRun,\n    clear: () => {\n      onErrorRef.current?.(undefined);\n      generationRef.current++;\n      controller?.clear();\n      const waiters = idleWaitersRef.current;\n      idleWaitersRef.current = [];\n      for (const resolve of waiters) resolve();\n    },\n  };\n};\n"],"mappings":"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"}

package/dist/runtime/useResourceCleanup.d.ts

@@ -0,0 +1,2 @@
+export declare const useResourceCleanup: (enabled: boolean, cleanup: () => void, hostDestroySignal?: AbortSignal) => void;
+//# sourceMappingURL=useResourceCleanup.d.ts.map

package/dist/runtime/useResourceCleanup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useResourceCleanup.d.ts","mappings":"AAGA,eAAO,MAAM,kBAAkB,GAC7B,SAAS,OAAO,EAChB,SAAS,MAAM,IAAI,EACnB,oBAAoB,WAAW,SAmDhC","names":[],"ignoreList":[],"sources":["../../src/runtime/useResourceCleanup.ts"],"sourcesContent":[null]}

package/dist/runtime/useResourceCleanup.js

@@ -0,0 +1,47 @@
+import { useEffect, useRef } from "@ulearning/ai-tap";
+import { useAssistantClientDestroySignal } from "@ulearning/ai-store/internal";
+// src/runtime/useResourceCleanup.ts
+const useResourceCleanup = (enabled, cleanup, hostDestroySignal) => {
+	const destroySignal = useAssistantClientDestroySignal();
+	const cleanupRef = useRef(cleanup);
+	const enabledRef = useRef(enabled);
+	const registrationRef = useRef(null);
+	useEffect(() => {
+		cleanupRef.current = cleanup;
+		enabledRef.current = enabled;
+	});
+	useEffect(() => {
+		if (!enabled || !destroySignal && !hostDestroySignal) return void 0;
+		const current = registrationRef.current;
+		if (current !== null && current.destroySignal === destroySignal && current.hostDestroySignal === hostDestroySignal) return;
+		current?.controller.abort();
+		const registration = new AbortController();
+		registrationRef.current = {
+			destroySignal,
+			hostDestroySignal,
+			controller: registration
+		};
+		const run = () => {
+			if (registration.signal.aborted) return;
+			registration.abort();
+			if (enabledRef.current) cleanupRef.current();
+		};
+		if (destroySignal?.aborted || hostDestroySignal?.aborted) {
+			run();
+			return;
+		}
+		const options = {
+			once: true,
+			signal: registration.signal
+		};
+		destroySignal?.addEventListener("abort", run, options);
+		hostDestroySignal?.addEventListener("abort", run, options);
+	}, [
+		destroySignal,
+		enabled,
+		hostDestroySignal
+	]);
+};
+export { useResourceCleanup };
+
+//# sourceMappingURL=useResourceCleanup.js.map

package/dist/runtime/useResourceCleanup.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useResourceCleanup.js","names":[],"sources":["../../src/runtime/useResourceCleanup.ts"],"sourcesContent":["import { useEffect, useRef } from \"@ulearning/ai-tap\";\nimport { useAssistantClientDestroySignal } from \"@ulearning/ai-store/internal\";\n\nexport const useResourceCleanup = (\n  enabled: boolean,\n  cleanup: () => void,\n  hostDestroySignal?: AbortSignal,\n) => {\n  const destroySignal = useAssistantClientDestroySignal();\n  const cleanupRef = useRef(cleanup);\n  const enabledRef = useRef(enabled);\n  const registrationRef = useRef<{\n    destroySignal: AbortSignal | undefined;\n    hostDestroySignal: AbortSignal | undefined;\n    controller: AbortController;\n  } | null>(null);\n\n  useEffect(() => {\n    cleanupRef.current = cleanup;\n    enabledRef.current = enabled;\n  });\n\n  useEffect(() => {\n    if (!enabled || (!destroySignal && !hostDestroySignal)) return undefined;\n    const current = registrationRef.current;\n    if (\n      current !== null &&\n      current.destroySignal === destroySignal &&\n      current.hostDestroySignal === hostDestroySignal\n    ) {\n      return undefined;\n    }\n    current?.controller.abort();\n\n    const registration = new AbortController();\n    registrationRef.current = {\n      destroySignal,\n      hostDestroySignal,\n      controller: registration,\n    };\n    const run = () => {\n      if (registration.signal.aborted) return;\n      registration.abort();\n      if (enabledRef.current) cleanupRef.current();\n    };\n    if (destroySignal?.aborted || hostDestroySignal?.aborted) {\n      run();\n      return undefined;\n    }\n    const options = { once: true, signal: registration.signal };\n    destroySignal?.addEventListener(\"abort\", run, options);\n    hostDestroySignal?.addEventListener(\"abort\", run, options);\n\n    // The listeners must survive standalone soft unmounts so a later\n    // permanent destroy still cleans up the retained resource state.\n    return undefined;\n  }, [destroySignal, enabled, hostDestroySignal]);\n};\n"],"mappings":";;;AAGA,MAAa,sBACX,SACA,SACA,sBACG;CACH,MAAM,gBAAgB,gCAAgC;CACtD,MAAM,aAAa,OAAO,OAAO;CACjC,MAAM,aAAa,OAAO,OAAO;CACjC,MAAM,kBAAkB,OAId,IAAI;CAEd,gBAAgB;EACd,WAAW,UAAU;EACrB,WAAW,UAAU;CACvB,CAAC;CAED,gBAAgB;EACd,IAAI,CAAC,WAAY,CAAC,iBAAiB,CAAC,mBAAoB,OAAO,KAAA;EAC/D,MAAM,UAAU,gBAAgB;EAChC,IACE,YAAY,QACZ,QAAQ,kBAAkB,iBAC1B,QAAQ,sBAAsB,mBAE9B;EAEF,SAAS,WAAW,MAAM;EAE1B,MAAM,eAAe,IAAI,gBAAgB;EACzC,gBAAgB,UAAU;GACxB;GACA;GACA,YAAY;EACd;EACA,MAAM,YAAY;GAChB,IAAI,aAAa,OAAO,SAAS;GACjC,aAAa,MAAM;GACnB,IAAI,WAAW,SAAS,WAAW,QAAQ;EAC7C;EACA,IAAI,eAAe,WAAW,mBAAmB,SAAS;GACxD,IAAI;GACJ;EACF;EACA,MAAM,UAAU;GAAE,MAAM;GAAM,QAAQ,aAAa;EAAO;EAC1D,eAAe,iBAAiB,SAAS,KAAK,OAAO;EACrD,mBAAmB,iBAAiB,SAAS,KAAK,OAAO;CAK3D,GAAG;EAAC;EAAe;EAAS;CAAiB,CAAC;AAChD"}

package/dist/runtime/useStreamingTiming.d.ts

@@ -0,0 +1,12 @@
+import type { UIMessage } from "ai";
+import type { MaybeRefOrGetter } from "vue";
+import { type StreamingTimingAccessors } from "@ulearning/ai-core/vue";
+export declare const aiSdkStreamingTimingAccessors: StreamingTimingAccessors<UIMessage>;
+/**
+ * Tracks streaming timing for AI SDK messages client-side. Delegates to the
+ * shared `useStreamingTiming` primitive in `@ulearning/ai-core/vue`,
+ * adapted to the `UIMessage` shape. Timing is finalized when streaming ends
+ * and stored per message id.
+ */
+export declare const useStreamingTiming: (messages: MaybeRefOrGetter<readonly UIMessage[]>, isRunning: MaybeRefOrGetter<boolean>) => import("vue").ComputedRef<Record<string, import("@ulearning/ai-core").MessageTiming>>;
+//# sourceMappingURL=useStreamingTiming.d.ts.map

package/dist/runtime/useStreamingTiming.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useStreamingTiming.d.ts","mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,IAAI;AACnC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,KAAK;AAE3C,OAAO,EAEL,KAAK,wBAAwB,EAC9B,MAAM,wBAAwB;AAsC/B,eAAO,MAAM,6BAA6B,EAAE,wBAAwB,CAAC,SAAS,CAM3E;AAEH;;;;;;AAMA,eAAO,MAAM,kBAAkB,GAC7B,UAAU,gBAAgB,CAAC,SAAS,SAAS,EAAE,CAAC,EAChD,WAAW,gBAAgB,CAAC,OAAO,CAAC,0FAMnC","names":[],"ignoreList":[],"sources":["../../src/runtime/useStreamingTiming.ts"],"sourcesContent":[null]}

package/dist/runtime/useStreamingTiming.js

@@ -0,0 +1,36 @@
+"use client";
+import { isToolUIPart } from "ai";
+import { useStreamingTiming as useStreamingTiming$1 } from "@ulearning/ai-core/vue";
+// src/runtime/useStreamingTiming.ts
+const findAssistant = (messages, messageId) => messages.find((m) => m.role === "assistant" && m.id === messageId);
+const getTextLength = (messages, messageId) => {
+	const message = findAssistant(messages, messageId);
+	if (!message?.parts) return 0;
+	let len = 0;
+	for (const part of message.parts) if (part?.type === "text") len += part.text?.length ?? 0;
+	return len;
+};
+const getToolCallCount = (messages, messageId) => {
+	const message = findAssistant(messages, messageId);
+	if (!message?.parts) return 0;
+	let count = 0;
+	for (const part of message.parts) if (typeof part?.type === "string" && isToolUIPart(part)) count++;
+	return count;
+};
+const getAssistantMessageId = (messages) => messages.findLast((m) => m.role === "assistant")?.id;
+const aiSdkStreamingTimingAccessors = {
+	getAssistantMessageId,
+	getTextLength,
+	getToolCallCount,
+	getMessageContent: (messages, id) => findAssistant(messages, id)?.parts
+};
+/**
+* Tracks streaming timing for AI SDK messages client-side. Delegates to the
+* shared `useStreamingTiming` primitive in `@ulearning/ai-core/vue`,
+* adapted to the `UIMessage` shape. Timing is finalized when streaming ends
+* and stored per message id.
+*/
+const useStreamingTiming = (messages, isRunning) => useStreamingTiming$1(messages, isRunning, aiSdkStreamingTimingAccessors);
+export { aiSdkStreamingTimingAccessors, useStreamingTiming };
+
+//# sourceMappingURL=useStreamingTiming.js.map

package/dist/runtime/useStreamingTiming.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useStreamingTiming.js","names":["useStreamingTimingPrimitive"],"sources":["../../src/runtime/useStreamingTiming.ts"],"sourcesContent":["\"use client\";\n\nimport type { UIMessage } from \"ai\";\nimport type { MaybeRefOrGetter } from \"vue\";\nimport { isToolUIPart } from \"ai\";\nimport {\n  useStreamingTiming as useStreamingTimingPrimitive,\n  type StreamingTimingAccessors,\n} from \"@ulearning/ai-core/vue\";\n\nconst findAssistant = (\n  messages: readonly UIMessage[],\n  messageId: string,\n): UIMessage | undefined =>\n  messages.find((m) => m.role === \"assistant\" && m.id === messageId);\n\nconst getTextLength = (\n  messages: readonly UIMessage[],\n  messageId: string,\n): number => {\n  const message = findAssistant(messages, messageId);\n  if (!message?.parts) return 0;\n  let len = 0;\n  for (const part of message.parts) {\n    if (part?.type === \"text\") len += part.text?.length ?? 0;\n  }\n  return len;\n};\n\nconst getToolCallCount = (\n  messages: readonly UIMessage[],\n  messageId: string,\n): number => {\n  const message = findAssistant(messages, messageId);\n  if (!message?.parts) return 0;\n  let count = 0;\n  for (const part of message.parts) {\n    if (typeof part?.type === \"string\" && isToolUIPart(part)) count++;\n  }\n  return count;\n};\n\nconst getAssistantMessageId = (\n  messages: readonly UIMessage[],\n): string | undefined => messages.findLast((m) => m.role === \"assistant\")?.id;\n\nexport const aiSdkStreamingTimingAccessors: StreamingTimingAccessors<UIMessage> =\n  {\n    getAssistantMessageId,\n    getTextLength,\n    getToolCallCount,\n    getMessageContent: (messages, id) => findAssistant(messages, id)?.parts,\n  };\n\n/**\n * Tracks streaming timing for AI SDK messages client-side. Delegates to the\n * shared `useStreamingTiming` primitive in `@ulearning/ai-core/vue`,\n * adapted to the `UIMessage` shape. Timing is finalized when streaming ends\n * and stored per message id.\n */\nexport const useStreamingTiming = (\n  messages: MaybeRefOrGetter<readonly UIMessage[]>,\n  isRunning: MaybeRefOrGetter<boolean>,\n) =>\n  useStreamingTimingPrimitive(\n    messages,\n    isRunning,\n    aiSdkStreamingTimingAccessors,\n  );\n"],"mappings":";;;;AAUA,MAAM,iBACJ,UACA,cAEA,SAAS,MAAM,MAAM,EAAE,SAAS,eAAe,EAAE,OAAO,SAAS;AAEnE,MAAM,iBACJ,UACA,cACW;CACX,MAAM,UAAU,cAAc,UAAU,SAAS;CACjD,IAAI,CAAC,SAAS,OAAO,OAAO;CAC5B,IAAI,MAAM;CACV,KAAK,MAAM,QAAQ,QAAQ,OACzB,IAAI,MAAM,SAAS,QAAQ,OAAO,KAAK,MAAM,UAAU;CAEzD,OAAO;AACT;AAEA,MAAM,oBACJ,UACA,cACW;CACX,MAAM,UAAU,cAAc,UAAU,SAAS;CACjD,IAAI,CAAC,SAAS,OAAO,OAAO;CAC5B,IAAI,QAAQ;CACZ,KAAK,MAAM,QAAQ,QAAQ,OACzB,IAAI,OAAO,MAAM,SAAS,YAAY,aAAa,IAAI,GAAG;CAE5D,OAAO;AACT;AAEA,MAAM,yBACJ,aACuB,SAAS,UAAU,MAAM,EAAE,SAAS,WAAW,CAAC,EAAE;AAE3E,MAAa,gCACX;CACE;CACA;CACA;CACA,oBAAoB,UAAU,OAAO,cAAc,UAAU,EAAE,CAAC,EAAE;AACpE;;;;;;;AAQF,MAAa,sBACX,UACA,cAEAA,qBACE,UACA,WACA,6BACF"}

package/dist/tools/generativeTools.d.ts

@@ -0,0 +1,71 @@
+import { type ToolSet } from "ai";
+import type { Toolkit } from "@ulearning/ai-core/vue";
+import { type FrontendTools } from "@ulearning/ai-stream/ai-sdk";
+/**
+ * @deprecated Options for the deprecated {@link generativeTools}. Use
+ * {@link AISDKToolkit} with {@link AISDKToolkitOptions} /
+ * {@link AISDKToolkitToolsOptions} instead.
+ */
+export interface GenerativeToolsOptions {
+    /**
+     * The server build of a generative toolkit (schema + server `execute`). Typed
+     * as the canonical {@link Toolkit} so callers don't need to cast; the server
+     * build carries `execute`, recovered internally as {@link ToolkitDefinition}.
+     */
+    toolkit: Toolkit;
+    /**
+     * Tools uploaded by the frontend (the request body's `tools`). Merged in
+     * alongside the `toolkit`; a server `execute` from `toolkit` takes precedence
+     * over an uploaded entry of the same name.
+     */
+    frontendTools?: FrontendTools;
+}
+export type AISDKToolkitOptions = {
+    toolkit: Toolkit;
+};
+export type AISDKToolkitToolsOptions = {
+    /**
+     * Tools uploaded by the frontend request body.
+     */
+    frontend?: FrontendTools;
+};
+/**
+ * Builds an AI SDK `ToolSet` for server-side use with `streamText` /
+ * `generateText` from a generative `toolkit` and the frontend-uploaded tools.
+ *
+ * Each toolkit tool's `execute` runs on the server. Pair this with the
+ * `"use generative"` compiler: import the toolkit in a server route (where it
+ * resolves to the server build — schema + `execute`, with `render` stripped) and
+ * pass it here. Tools without an `execute` are still exposed to the model but
+ * left for the client to fulfill. `frontendTools` lets the client contribute
+ * tools that aren't in the static toolkit.
+ *
+ * @deprecated Use {@link AISDKToolkit} instead:
+ * `new AISDKToolkit({ toolkit }).tools({ frontend })`. It is a strict superset
+ * (it also opens MCP server connections), so it replaces `generativeTools`
+ * everywhere. The `frontendTools` option is named `frontend` on `.tools()`, and
+ * `.tools()` is async. `generativeTools` will be removed in a future version.
+ *
+ * @example
+ * ```ts
+ * // Define once at module scope so any MCP connections pool across requests.
+ * const aiToolkit = new AISDKToolkit({ toolkit: docsToolkit });
+ *
+ * // In your route handler:
+ * const { tools } = await req.json();
+ * streamText({
+ *   abortSignal: req.signal,
+ *   model,
+ *   messages,
+ *   tools: await aiToolkit.tools({ frontend: tools }),
+ * });
+ * ```
+ */
+export declare const generativeTools: (options: GenerativeToolsOptions) => ToolSet;
+export declare class AISDKToolkit {
+    #private;
+    constructor(options: AISDKToolkitOptions);
+    tools(options?: AISDKToolkitToolsOptions): Promise<ToolSet>;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=generativeTools.d.ts.map

package/dist/tools/generativeTools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generativeTools.d.ts","mappings":"AAAA,OAAO,EAAc,KAAK,OAAO,EAAE,MAAM,IAAI;AAU7C,OAAO,KAAK,EAEV,OAAO,EAER,MAAM,wBAAwB;AAC/B,OAAO,EAAiB,KAAK,aAAa,EAAE,MAAM,6BAA6B;AAqF/E;;;;;AAKA,MAAM,WAAW,sBAAsB;IACrC;;;;;IAKA,OAAO,EAAE,OAAO;IAChB;;;;;IAKA,aAAa,CAAC,EAAE,aAAa;;AAG/B,MAAM,MAAM,mBAAmB,GAAG;IAChC,OAAO,EAAE,OAAO;CACjB;AAED,MAAM,MAAM,wBAAwB,GAAG;IACrC;;;IAGA,QAAQ,CAAC,EAAE,aAAa;CACzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,eAAO,MAAM,eAAe,GAAI,SAAS,sBAAsB,KAAG,OAUjE;AAED,qBAAa,YAAY;;gBAIX,OAAO,EAAE,mBAAmB;IAIlC,KAAK,CAAC,OAAO,GAAE,wBAA6B,GAAG,OAAO,CAAC,OAAO,CAAC;IAsB/D,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC","names":[],"ignoreList":[],"sources":["../../src/tools/generativeTools.ts"],"sourcesContent":[null]}

package/dist/tools/generativeTools.js

@@ -0,0 +1,258 @@
+import { jsonSchema } from "ai";
+import { toAISDKContent, toAISDKDefaultOutput, unwrapModelContentEnvelope } from "@ulearning/ai-stream/internal";
+import { toJSONSchema } from "@ulearning/ai-stream";
+import { frontendTools } from "@ulearning/ai-stream/ai-sdk";
+import { createMCPClient } from "@ai-sdk/mcp";
+import { Experimental_StdioMCPTransport } from "#mcp-stdio";
+// src/tools/generativeTools.ts
+const EMPTY_SCHEMA = {
+	type: "object",
+	properties: {}
+};
+const humanNotSupported = () => {
+	throw new Error("`human()` is not available during server-side tool execution.");
+};
+const neverAbort = new AbortController().signal;
+var MCPConnectionTimeoutError = class extends Error {};
+const createMcpConnectionTimeoutError = (name, phase, timeoutMs) => new MCPConnectionTimeoutError(`MCP toolkit entry "${name}" timed out while ${phase} after ${timeoutMs}ms.`);
+const withMcpConnectionTimeout = async (promise, options) => {
+	const timeoutMs = options.config.connectionTimeout;
+	if (timeoutMs === void 0) return await promise;
+	const remainingMs = timeoutMs - (Date.now() - options.startedAt);
+	const timeoutError = () => createMcpConnectionTimeoutError(options.name, options.phase, timeoutMs);
+	if (remainingMs <= 0) throw timeoutError();
+	let timeout;
+	try {
+		return await Promise.race([promise, new Promise((_, reject) => {
+			timeout = setTimeout(() => reject(timeoutError()), remainingMs);
+		})]);
+	} finally {
+		if (timeout !== void 0) clearTimeout(timeout);
+	}
+};
+const convertedParameterSchemas = /* @__PURE__ */ new WeakMap();
+const getOrConvertParameterSchema = (parameters) => {
+	const cached = convertedParameterSchemas.get(parameters);
+	if (cached) return cached;
+	const converted = toJSONSchema(parameters);
+	convertedParameterSchemas.set(parameters, converted);
+	return converted;
+};
+const parametersToInputSchema = (parameters) => {
+	if (!parameters) return jsonSchema(EMPTY_SCHEMA);
+	return jsonSchema(getOrConvertParameterSchema(parameters));
+};
+/**
+* Builds an AI SDK `ToolSet` for server-side use with `streamText` /
+* `generateText` from a generative `toolkit` and the frontend-uploaded tools.
+*
+* Each toolkit tool's `execute` runs on the server. Pair this with the
+* `"use generative"` compiler: import the toolkit in a server route (where it
+* resolves to the server build — schema + `execute`, with `render` stripped) and
+* pass it here. Tools without an `execute` are still exposed to the model but
+* left for the client to fulfill. `frontendTools` lets the client contribute
+* tools that aren't in the static toolkit.
+*
+* @deprecated Use {@link AISDKToolkit} instead:
+* `new AISDKToolkit({ toolkit }).tools({ frontend })`. It is a strict superset
+* (it also opens MCP server connections), so it replaces `generativeTools`
+* everywhere. The `frontendTools` option is named `frontend` on `.tools()`, and
+* `.tools()` is async. `generativeTools` will be removed in a future version.
+*
+* @example
+* ```ts
+* // Define once at module scope so any MCP connections pool across requests.
+* const aiToolkit = new AISDKToolkit({ toolkit: docsToolkit });
+*
+* // In your route handler:
+* const { tools } = await req.json();
+* streamText({
+*   abortSignal: req.signal,
+*   model,
+*   messages,
+*   tools: await aiToolkit.tools({ frontend: tools }),
+* });
+* ```
+*/
+const generativeTools = (options) => {
+	assertNoMcpToolkitTools(options.toolkit);
+	return {
+		...options.frontendTools ? frontendTools(options.frontendTools) : {},
+		...toProviderToolSet(options.toolkit),
+		...toServerToolSet(options.toolkit)
+	};
+};
+var AISDKToolkit = class {
+	#toolkit;
+	#mcpClients = /* @__PURE__ */ new Map();
+	constructor(options) {
+		this.#toolkit = options.toolkit;
+	}
+	async tools(options = {}) {
+		const frontendToolSet = options.frontend ? frontendTools(options.frontend) : {};
+		const mcpToolSet = await this.#mcpTools();
+		const providerToolSet = toProviderToolSet(this.#toolkit);
+		const serverToolSet = toServerToolSet(this.#toolkit);
+		assertNoMcpToolNameCollisions(mcpToolSet, [
+			{
+				source: "frontend",
+				tools: frontendToolSet
+			},
+			{
+				source: "provider",
+				tools: providerToolSet
+			},
+			{
+				source: "toolkit",
+				tools: serverToolSet
+			}
+		]);
+		return {
+			...frontendToolSet,
+			...mcpToolSet.tools,
+			...providerToolSet,
+			...serverToolSet
+		};
+	}
+	async close() {
+		const clientEntries = [...this.#mcpClients.entries()];
+		const clientNames = clientEntries.map(([name]) => name);
+		this.#mcpClients.clear();
+		const clientResults = await Promise.allSettled(clientEntries.map(([, clientPromise]) => clientPromise));
+		const clients = clientResults.flatMap((result, index) => result.status === "fulfilled" ? [[clientNames[index], result.value]] : []);
+		const closeResults = await Promise.allSettled(clients.map(([, client]) => client.close()));
+		const errors = [...clientResults.flatMap((result, index) => result.status === "rejected" ? [toMcpToolkitError(clientNames[index], "connect", result.reason)] : []), ...closeResults.flatMap((result, index) => result.status === "rejected" ? [toMcpToolkitError(clients[index][0], "close", result.reason)] : [])];
+		if (errors.length === 1) throw errors[0];
+		if (errors.length > 1) throw new AggregateError(errors, "Failed to close one or more MCP clients");
+	}
+	async #mcpTools() {
+		const toolSets = await Promise.all(Object.entries(this.#toolkit).filter((entry) => isMcpToolkitTool(entry[1])).map(async ([name, tool]) => {
+			const startedAt = Date.now();
+			const clientPromise = this.#mcpClient(name, tool.server, startedAt);
+			const client = await clientPromise.catch((error) => {
+				if (error instanceof MCPConnectionTimeoutError) throw error;
+				throw toMcpToolkitError(name, "connect", error);
+			});
+			try {
+				return [
+					name,
+					tool,
+					await withMcpConnectionTimeout(client.tools(), {
+						name,
+						config: tool.server,
+						phase: "listing tools",
+						startedAt
+					})
+				];
+			} catch (error) {
+				if (error instanceof MCPConnectionTimeoutError) {
+					if (this.#mcpClients.get(name) === clientPromise) {
+						this.#mcpClients.delete(name);
+						client.close().catch(() => {});
+					}
+					throw error;
+				}
+				throw toMcpToolkitError(name, "list tools", error);
+			}
+		}));
+		const tools = Object.create(null);
+		const toolSources = /* @__PURE__ */ new Map();
+		for (const [serverName, mcpTool, toolSet] of toolSets) for (const [toolName, tool] of Object.entries(toolSet)) {
+			if (isDisabledMcpTool(mcpTool.tools?.[toolName])) continue;
+			const exposedName = `${mcpTool.prefix ?? ""}${toolName}`;
+			const existingServerName = toolSources.get(exposedName);
+			if (existingServerName) throw new Error(`MCP tool name collision: "${exposedName}" is exposed by both "${existingServerName}" and "${serverName}". Rename one of the toolkit entries or expose distinct MCP tool names.`);
+			toolSources.set(exposedName, serverName);
+			tools[exposedName] = tool;
+		}
+		return {
+			tools,
+			sources: toolSources
+		};
+	}
+	#mcpClient(name, config, startedAt) {
+		const existing = this.#mcpClients.get(name);
+		if (existing) return existing;
+		const createPromise = createMCPClient(toMCPClientConfig(config));
+		let next;
+		next = withMcpConnectionTimeout(createPromise, {
+			name,
+			config,
+			phase: "connecting",
+			startedAt
+		}).catch((error) => {
+			if (this.#mcpClients.get(name) === next) this.#mcpClients.delete(name);
+			if (error instanceof MCPConnectionTimeoutError) createPromise.then((client) => client.close()).catch(() => {});
+			throw error;
+		});
+		this.#mcpClients.set(name, next);
+		return next;
+	}
+};
+const toMCPClientConfig = (config) => {
+	if (config.type === "stdio") return { transport: new Experimental_StdioMCPTransport({
+		command: config.command,
+		...config.args && { args: [...config.args] },
+		...config.env && { env: config.env },
+		...config.cwd && { cwd: config.cwd }
+	}) };
+	return { transport: {
+		type: config.type,
+		url: config.url,
+		...config.headers && { headers: config.headers },
+		...config.redirect && { redirect: config.redirect }
+	} };
+};
+const assertNoMcpToolNameCollisions = (mcp, toolSets) => {
+	for (const [toolName, serverName] of mcp.sources) for (const { source, tools } of toolSets) {
+		if (!Object.prototype.hasOwnProperty.call(tools, toolName)) continue;
+		throw new Error(`MCP tool "${toolName}" from "${serverName}" conflicts with ${source} tool "${toolName}". Rename one of the tools so each model-visible tool name is unique.`);
+	}
+};
+const isMcpToolkitTool = (tool) => tool.type === "mcp" && !tool.disabled;
+const getErrorMessage = (error) => error instanceof Error ? error.message || error.name : String(error);
+const toMcpToolkitError = (entryName, action, error) => {
+	return new Error(`MCP toolkit entry "${entryName}" failed to ${action}: ${getErrorMessage(error)}`, { cause: error });
+};
+const isDisabledMcpTool = (config) => config?.disabled === true;
+const assertNoMcpToolkitTools = (toolkit) => {
+	const mcpToolName = Object.entries(toolkit).find(([, tool]) => isMcpToolkitTool(tool))?.[0];
+	if (!mcpToolName) return;
+	throw new Error(`MCP toolkit entry "${mcpToolName}" requires AISDKToolkit. Use new AISDKToolkit({ toolkit }).tools(...) instead of generativeTools(...).`);
+};
+const toAISDKToModelOutput = (toModelOutput) => async (options) => {
+	const { result, modelContent } = unwrapModelContentEnvelope(options.output);
+	if (modelContent !== void 0) return toAISDKContent(modelContent, { taggedFileData: true });
+	if (!toModelOutput) return toAISDKDefaultOutput(result);
+	const parts = await toModelOutput({
+		...options,
+		output: result
+	});
+	return toAISDKContent(parts, { taggedFileData: true });
+};
+const toServerToolSet = (toolkit) => Object.fromEntries(Object.entries(toolkit).filter(([, t]) => t.type !== "mcp" && t.type !== "provider" && !t.disabled).map(([name, t]) => {
+	const execute = t.execute;
+	return [name, {
+		...t.description !== void 0 && { description: t.description },
+		inputSchema: parametersToInputSchema(t.parameters),
+		toModelOutput: toAISDKToModelOutput(t.toModelOutput),
+		...t.providerOptions && { providerOptions: t.providerOptions },
+		...execute && { execute: (args, callOptions) => execute(args, {
+			toolCallId: callOptions.toolCallId,
+			abortSignal: callOptions.abortSignal ?? neverAbort,
+			human: humanNotSupported
+		}) }
+	}];
+}));
+const toProviderToolSet = (toolkit) => Object.fromEntries(Object.entries(toolkit).filter((entry) => isProviderToolkitTool(entry[1])).map(([name, t]) => [name, {
+	type: "provider",
+	id: t.providerId,
+	args: t.args,
+	...t.parameters && { inputSchema: parametersToInputSchema(t.parameters) },
+	...t.providerOptions && { providerOptions: t.providerOptions },
+	...t.supportsDeferredResults !== void 0 && { supportsDeferredResults: t.supportsDeferredResults }
+}]));
+const isProviderToolkitTool = (tool) => tool.type === "provider" && !tool.disabled;
+export { AISDKToolkit, generativeTools };
+
+//# sourceMappingURL=generativeTools.js.map