@dungle-scrubs/admin-ui-soft 0.0.0-stage → 0.0.0

package/dist/ai/testing/mock-runtime.d.ts

@@ -0,0 +1,86 @@
+import { ManualClock, MockClock, createManualClock, realClock } from "./mock-clock.js";
+import { MockReasoningPart, MockReply, MockReplyPart, MockSourcePart, MockTextPart, MockToolCallPart, MockWaitPart } from "./mock-reply.js";
+import { ReactNode } from "react";
+import { AuiConfig, ThreadMessageLike, ThreadSuggestion } from "@assistant-ui/react";
+//#region src/ai/testing/mock-runtime.d.ts
+/** A canned conversation in the thread list. */
+export type MockThread = {
+  /** Stable id. */
+  readonly id: string;
+  /** The title shown in the list; untitled threads read "New Chat". */
+  readonly title?: string;
+  /** Archived threads are listed apart from regular ones. */
+  readonly archived?: boolean;
+  /** The thread's messages, shown when it is selected. */
+  readonly messages?: readonly ThreadMessageLike[];
+};
+/** One scripted turn of a voice session. */
+export type MockVoiceTurn = {
+  readonly role: "user" | "assistant";
+  readonly text: string;
+  /** Delay after the previous turn, in ms. Default 1500. */
+  readonly afterMs?: number;
+};
+/** A scripted realtime voice session, played on the provider's clock. */
+export type MockVoiceScript = {
+  /** How long connecting takes, in ms. Default 600. */
+  readonly connectMs?: number;
+  /** The transcript turns, in order. */
+  readonly turns: readonly MockVoiceTurn[];
+};
+export type MockRuntimeProviderProps = {
+  readonly children: ReactNode;
+  /** The conversation already on screen. Messages without an id get one. */
+  readonly messages?: readonly ThreadMessageLike[];
+  /** The reply streamed after each message the user sends. Without it, sends get no answer. */
+  readonly reply?: MockReply;
+  /** Stream `reply` as soon as the provider mounts, answering the last canned message. */
+  readonly replyOnMount?: boolean;
+  /**
+   * With `replyOnMount`, play the reply up to its first approval gate at once,
+   * so the story opens on the waiting call instead of mid-stream. The rest of
+   * the reply streams on the clock once the owner answers.
+   */
+  readonly startAtApproval?: boolean;
+  /** The time source for streaming. Pass a manual clock to drive it from a play function. */
+  readonly clock?: MockClock;
+  /** Threads for the thread list; the first (or `threadId`) is active. */
+  readonly threads?: readonly MockThread[];
+  /** The active thread when `threads` is given. */
+  readonly threadId?: string;
+  /** Show the thread list in its loading state. */
+  readonly threadsLoading?: boolean;
+  /** Show the active thread's history as still loading. */
+  readonly isLoading?: boolean;
+  /** Disable the whole thread, composer included. */
+  readonly isDisabled?: boolean;
+  /** Suggested prompts: welcome suggestions on an empty thread, follow-ups after a reply. */
+  readonly suggestions?: readonly ThreadSuggestion[];
+  /** Accept image and text attachments in the composer (read locally, never uploaded). */
+  readonly attachments?: boolean;
+  /** Offer thumbs up and down on assistant messages. Default true. */
+  readonly feedback?: boolean;
+  /** Enable realtime voice with this scripted session. */
+  readonly voice?: MockVoiceScript;
+  /** Called with the text of every message the user sends. */
+  readonly onSend?: (text: string) => void;
+  /** Extra assistant-ui scopes for the provider, such as an MCP manager. */
+  readonly config?: AuiConfig;
+};
+/**
+ * An assistant-ui runtime for stories and tests: canned messages, an optional
+ * scripted reply streamed on a controllable clock, and local stand-ins for the
+ * thread list, feedback, attachments and voice. It makes no network call.
+ *
+ * Built on `useExternalStoreRuntime`: the provider owns the messages and
+ * rewrites them as the script plays, the way an app's store would.
+ *
+ * Drive the stream from a play function with a manual clock:
+ *
+ *   const clock = createManualClock();
+ *   <MockRuntimeProvider clock={clock} reply={reply} replyOnMount>...</MockRuntimeProvider>
+ *   // in play: await act(() => clock.tick(1000));
+ */
+export declare function MockRuntimeProvider(props: MockRuntimeProviderProps): import("react").JSX.Element;
+//#endregion
+export { type ManualClock, type MockClock, type MockReasoningPart, type MockReply, type MockReplyPart, type MockSourcePart, type MockTextPart, type MockToolCallPart, type MockWaitPart, createManualClock, realClock };

package/dist/ai/testing/mock-runtime.js

@@ -0,0 +1,384 @@
+"use client";
+import { createManualClock, realClock } from "./mock-clock.js";
+import { planReply } from "./mock-reply.js";
+import { useEffect, useRef, useState } from "react";
+import { jsx } from "react/jsx-runtime";
+import { useLatest, useUnmount } from "ahooks";
+import { AssistantRuntimeProvider, CompositeAttachmentAdapter, SimpleImageAttachmentAdapter, SimpleTextAttachmentAdapter, createVoiceSession, generateId, useExternalStoreRuntime } from "@assistant-ui/react";
+//#region src/ai/testing/mock-runtime.tsx
+const DEFAULT_THREAD_ID = "main";
+const withIds = (messages, prefix) => messages.map((message, index) => message.id === void 0 ? {
+	...message,
+	id: `${prefix}-${index}`
+} : message);
+function initialState(props) {
+	const threads = props.threads ?? [{ id: DEFAULT_THREAD_ID }];
+	const activeId = props.threadId ?? threads[0]?.id ?? DEFAULT_THREAD_ID;
+	const messages = {};
+	for (const thread of threads) messages[thread.id] = withIds(thread.messages ?? [], thread.id);
+	if (props.messages !== void 0) messages[activeId] = withIds(props.messages, activeId);
+	return {
+		activeId,
+		threads,
+		messages
+	};
+}
+/** The messages up to and including `parentId`; none when it is null. */
+const upTo = (messages, parentId) => parentId === null ? [] : messages.slice(0, messages.findIndex((m) => m.id === parentId) + 1);
+const textOf = (message) => message.content.map((part) => part.type === "text" ? part.text : "").join("").trim();
+function applyOp(content, op, now) {
+	switch (op.type) {
+		case "add-part": return [...content, op.part.type === "tool-call" ? {
+			...op.part,
+			timing: { startedAt: now }
+		} : op.part];
+		case "append-text": return content.map((part, index) => index === op.index && (part.type === "text" || part.type === "reasoning") ? {
+			...part,
+			text: part.text + op.text
+		} : part);
+		case "settle-tool": return content.map((part) => part.type === "tool-call" && part.toolCallId === op.toolCallId ? {
+			...part,
+			result: op.result,
+			isError: op.isError,
+			timing: {
+				startedAt: part.timing?.startedAt ?? now,
+				completedAt: now
+			}
+		} : part);
+		case "await-approval": return [...content];
+	}
+}
+const countTokens = (content) => content.reduce((total, part) => part.type === "text" || part.type === "reasoning" ? total + (part.text.match(/\S+/g)?.length ?? 0) : total, 0);
+/**
+* An assistant-ui runtime for stories and tests: canned messages, an optional
+* scripted reply streamed on a controllable clock, and local stand-ins for the
+* thread list, feedback, attachments and voice. It makes no network call.
+*
+* Built on `useExternalStoreRuntime`: the provider owns the messages and
+* rewrites them as the script plays, the way an app's store would.
+*
+* Drive the stream from a play function with a manual clock:
+*
+*   const clock = createManualClock();
+*   <MockRuntimeProvider clock={clock} reply={reply} replyOnMount>...</MockRuntimeProvider>
+*   // in play: await act(() => clock.tick(1000));
+*/
+function MockRuntimeProvider(props) {
+	const { children, reply, replyOnMount = false, startAtApproval = false, clock = realClock, threadsLoading, isLoading, isDisabled, suggestions, attachments = false, feedback = true, voice, onSend, config } = props;
+	const [state, setState] = useState(() => initialState(props));
+	const [isRunning, setIsRunning] = useState(false);
+	const playerRef = useRef(void 0);
+	const latest = useLatest({
+		reply,
+		clock,
+		onSend
+	});
+	const messages = state.messages[state.activeId] ?? [];
+	const updateMessages = (update) => setState((current) => ({
+		...current,
+		messages: {
+			...current.messages,
+			[current.activeId]: update(current.messages[current.activeId] ?? [])
+		}
+	}));
+	const writeAssistant = (player, patch) => updateMessages((current) => current.map((message) => message.id === player.assistantId ? {
+		...message,
+		content: [...player.content],
+		...patch
+	} : message));
+	const stopTimer = () => {
+		const player = playerRef.current;
+		if (player?.timer !== void 0) {
+			latest.current.clock.clear(player.timer);
+			player.timer = void 0;
+		}
+	};
+	/** The run's timing so far, on the provider's clock, as assistant-ui's message metadata. */
+	const timingOf = (player) => {
+		const end = latest.current.clock.now();
+		const firstTokenTime = player.firstTokenAt === void 0 ? void 0 : player.firstTokenAt - player.startedAt;
+		const totalStreamTime = end - player.startedAt;
+		const tokenCount = countTokens(player.content);
+		return { timing: {
+			streamStartTime: player.startedAt,
+			...firstTokenTime !== void 0 ? { firstTokenTime } : {},
+			totalStreamTime,
+			tokenCount,
+			...totalStreamTime > 0 ? { tokensPerSecond: tokenCount / (totalStreamTime / 1e3) } : {},
+			totalChunks: player.index,
+			toolCallCount: player.content.filter((part) => part.type === "tool-call").length
+		} };
+	};
+	const finish = (player) => {
+		writeAssistant(player, {
+			status: player.error === void 0 ? {
+				type: "complete",
+				reason: "stop"
+			} : {
+				type: "incomplete",
+				reason: "error",
+				error: player.error
+			},
+			metadata: timingOf(player)
+		});
+		playerRef.current = void 0;
+		setIsRunning(false);
+	};
+	/** Applies every step before the first approval gate at once, then stops at the gate. */
+	const playToApproval = (player) => {
+		const now = latest.current.clock.now();
+		for (let step = player.steps[player.index]; step !== void 0 && step.op.type !== "await-approval"; step = player.steps[player.index]) {
+			player.index += 1;
+			player.firstTokenAt ??= now;
+			player.content = applyOp(player.content, step.op, now);
+		}
+		const gate = player.steps[player.index];
+		if (gate === void 0) finish(player);
+		else runStep(player, gate);
+	};
+	const scheduleNext = (player) => {
+		const step = player.steps[player.index];
+		if (step === void 0) {
+			finish(player);
+			return;
+		}
+		player.timer = latest.current.clock.schedule(() => {
+			player.timer = void 0;
+			runStep(player, step);
+		}, step.delayMs);
+	};
+	const runStep = (player, step) => {
+		const now = latest.current.clock.now();
+		player.index += 1;
+		if (step.op.type === "await-approval") {
+			player.awaiting = step.op;
+			writeAssistant(player, {
+				status: {
+					type: "requires-action",
+					reason: "tool-calls"
+				},
+				metadata: timingOf(player)
+			});
+			setIsRunning(false);
+			return;
+		}
+		player.firstTokenAt ??= now;
+		player.content = applyOp(player.content, step.op, now);
+		writeAssistant(player, {
+			status: { type: "running" },
+			metadata: timingOf(player)
+		});
+		scheduleNext(player);
+	};
+	const startReply = (atApproval = false) => {
+		const script = latest.current.reply;
+		if (script === void 0) return;
+		stopTimer();
+		const assistantId = generateId();
+		const player = {
+			assistantId,
+			steps: planReply(script, assistantId),
+			error: script.error,
+			startedAt: latest.current.clock.now(),
+			index: 0,
+			content: [],
+			firstTokenAt: void 0,
+			timer: void 0,
+			awaiting: void 0
+		};
+		playerRef.current = player;
+		updateMessages((current) => [...current, {
+			id: assistantId,
+			role: "assistant",
+			content: [],
+			status: { type: "running" },
+			createdAt: new Date(player.startedAt)
+		}]);
+		setIsRunning(true);
+		if (atApproval) playToApproval(player);
+		else scheduleNext(player);
+	};
+	/** Appends the user's message after its parent, dropping anything after the parent (an edit). */
+	const appendUserMessage = (message) => {
+		const userMessage = {
+			id: generateId(),
+			role: "user",
+			content: message.content,
+			attachments: message.attachments,
+			createdAt: new Date(latest.current.clock.now())
+		};
+		updateMessages((current) => [...upTo(current, message.parentId), userMessage]);
+		latest.current.onSend?.(textOf(message));
+	};
+	useEffect(() => {
+		const player = playerRef.current;
+		if (player === void 0) {
+			if (replyOnMount) startReply(startAtApproval);
+		} else if (player.timer === void 0 && player.awaiting === void 0) scheduleNext(player);
+		return stopTimer;
+	}, []);
+	useUnmount(stopTimer);
+	const threadList = props.threads === void 0 ? void 0 : {
+		threadId: state.activeId,
+		isLoading: threadsLoading,
+		threads: state.threads.filter((thread) => !thread.archived).map((thread) => ({
+			status: "regular",
+			id: thread.id,
+			title: thread.title
+		})),
+		archivedThreads: state.threads.filter((thread) => thread.archived).map((thread) => ({
+			status: "archived",
+			id: thread.id,
+			title: thread.title
+		})),
+		onSwitchToNewThread: () => {
+			const id = generateId();
+			setState((current) => ({
+				activeId: id,
+				threads: [{ id }, ...current.threads],
+				messages: {
+					...current.messages,
+					[id]: []
+				}
+			}));
+		},
+		onSwitchToThread: (threadId) => setState((current) => ({
+			...current,
+			activeId: threadId
+		})),
+		onRename: (threadId, title) => setState((current) => ({
+			...current,
+			threads: current.threads.map((thread) => thread.id === threadId ? {
+				...thread,
+				title
+			} : thread)
+		})),
+		onArchive: (threadId) => setState((current) => ({
+			...current,
+			threads: current.threads.map((thread) => thread.id === threadId ? {
+				...thread,
+				archived: true
+			} : thread)
+		})),
+		onUnarchive: (threadId) => setState((current) => ({
+			...current,
+			threads: current.threads.map((thread) => thread.id === threadId ? {
+				...thread,
+				archived: false
+			} : thread)
+		})),
+		onDelete: (threadId) => setState((current) => ({
+			...current,
+			threads: current.threads.filter((thread) => thread.id !== threadId)
+		}))
+	};
+	const feedbackAdapter = feedback ? { submit: () => {} } : void 0;
+	const attachmentAdapter = useRef(new CompositeAttachmentAdapter([new SimpleImageAttachmentAdapter(), new SimpleTextAttachmentAdapter()])).current;
+	const voiceAdapter = voice === void 0 ? void 0 : { connect: ({ abortSignal }) => createVoiceSession(abortSignal ? { abortSignal } : {}, async (helpers) => {
+		const { clock: time } = latest.current;
+		const handles = [];
+		let at = 0;
+		const later = (ms, run) => {
+			at += ms;
+			handles.push(time.schedule(run, at));
+		};
+		later(voice.connectMs ?? 600, () => {
+			helpers.setStatus({ type: "running" });
+			helpers.emitMode("listening");
+			helpers.emitVolume(.2);
+		});
+		for (const turn of voice.turns) later(turn.afterMs ?? 1500, () => {
+			helpers.emitMode(turn.role === "assistant" ? "speaking" : "listening");
+			helpers.emitVolume(turn.role === "assistant" ? .7 : .45);
+			helpers.emitTranscript({
+				role: turn.role,
+				text: turn.text,
+				isFinal: true
+			});
+		});
+		return {
+			disconnect: () => {
+				for (const handle of handles) time.clear(handle);
+			},
+			mute: () => helpers.emitVolume(0),
+			unmute: () => helpers.emitVolume(.2)
+		};
+	}) };
+	const runtime = useExternalStoreRuntime({
+		messages,
+		convertMessage: (message) => message,
+		isRunning: isRunning || messages.at(-1)?.status?.type === "running",
+		isLoading,
+		isDisabled,
+		suggestions,
+		setMessages: (next) => updateMessages(() => next),
+		onNew: async (message) => {
+			appendUserMessage(message);
+			startReply();
+		},
+		onEdit: async (message) => {
+			stopTimer();
+			playerRef.current = void 0;
+			appendUserMessage(message);
+			startReply();
+		},
+		onReload: async (parentId) => {
+			stopTimer();
+			playerRef.current = void 0;
+			updateMessages((current) => upTo(current, parentId));
+			startReply();
+		},
+		onCancel: async () => {
+			const player = playerRef.current;
+			stopTimer();
+			if (player !== void 0) writeAssistant(player, {
+				status: {
+					type: "incomplete",
+					reason: "cancelled"
+				},
+				metadata: timingOf(player)
+			});
+			playerRef.current = void 0;
+			setIsRunning(false);
+		},
+		onRespondToToolApproval: ({ approvalId, approved, reason }) => {
+			const player = playerRef.current;
+			const awaiting = player?.awaiting;
+			if (player === void 0 || awaiting === void 0) return;
+			player.awaiting = void 0;
+			player.content = player.content.map((part) => part.type === "tool-call" && part.approval?.id === approvalId ? {
+				...part,
+				approval: {
+					...part.approval,
+					approved,
+					...reason ? { reason } : {}
+				}
+			} : part);
+			setIsRunning(true);
+			if (!approved) {
+				player.content = [...player.content, {
+					type: "text",
+					text: awaiting.deniedText
+				}];
+				finish(player);
+				return;
+			}
+			writeAssistant(player, { status: { type: "running" } });
+			scheduleNext(player);
+		},
+		onVoiceTranscript: (message) => updateMessages((current) => [...current, message]),
+		adapters: {
+			...threadList !== void 0 ? { threadList } : {},
+			...feedbackAdapter !== void 0 ? { feedback: feedbackAdapter } : {},
+			...attachments ? { attachments: attachmentAdapter } : {},
+			...voiceAdapter !== void 0 ? { voice: voiceAdapter } : {}
+		}
+	});
+	return /* @__PURE__ */ jsx(AssistantRuntimeProvider, {
+		runtime,
+		...config !== void 0 ? { config } : {},
+		children
+	});
+}
+//#endregion
+export { MockRuntimeProvider, createManualClock, realClock };