zidane-ui 0.0.0-stage → 9.0.2

package/dist/chat/composer/suggestion-extension.js

@@ -0,0 +1,106 @@
+import { TRIGGER } from "./suggestions.js";
+import { PluginKey } from "@tiptap/pm/state";
+import Mention from "@tiptap/extension-mention";
+//#region src/chat/composer/suggestion-extension.ts
+/**
+* One completion trigger as a Tiptap Mention node. Apart from the popup
+* (`suggestions.tsx`) so the Tiptap code stays in the composer's lazy editor
+* chunk.
+*/
+function anchorOf(rect, fallback) {
+	let r = null;
+	try {
+		r = rect?.() ?? null;
+	} catch {}
+	const box = r ?? fallback.getBoundingClientRect();
+	return {
+		x: box.left,
+		y: box.top
+	};
+}
+/**
+* One trigger as a Tiptap extension. `source` and `state` are refs so the
+* editor, built once, always reads the latest props and popup.
+*
+* @param kind - Which trigger the extension handles.
+* @param source - Ref to the source that supplies items and serialization.
+* @param state - Ref to the popup state the keyboard handler reads.
+* @param setState - Updates the popup state.
+*/
+function suggestionExtension(kind, source, state, setState) {
+	const char = TRIGGER[kind];
+	const text = (attrs) => {
+		const item = {
+			id: String(attrs.id ?? ""),
+			label: String(attrs.label ?? attrs.id ?? "")
+		};
+		return source.current?.serialize?.(item) ?? `${char}${item.label}`;
+	};
+	return Mention.extend({ name: kind }).configure({
+		renderText: ({ node }) => text(node.attrs),
+		renderHTML: ({ node }) => [
+			"span",
+			{
+				class: "zg-composer-mention",
+				"data-kind": kind,
+				"data-id": String(node.attrs.id ?? "")
+			},
+			`${char}${String(node.attrs.label ?? node.attrs.id ?? "")}`
+		],
+		suggestion: {
+			char,
+			pluginKey: new PluginKey(`composer-${kind}`),
+			...kind === "command" ? { allow: ({ range }) => range.from <= 1 } : {},
+			items: async ({ query }) => [...await source.current?.items(query) ?? []],
+			render: () => {
+				const open = (props) => {
+					const top = props.items[0];
+					if (kind === "command" && top && text(top) === props.text) {
+						setState(null);
+						return;
+					}
+					setState({
+						kind,
+						items: props.items,
+						active: 0,
+						anchor: anchorOf(props.clientRect, props.editor.view.dom),
+						pick: (item) => props.command({
+							id: item.id,
+							label: item.label
+						})
+					});
+				};
+				return {
+					onStart: open,
+					onUpdate: open,
+					onExit: () => setState(null),
+					onKeyDown: ({ event }) => {
+						const s = state.current;
+						if (!s) return false;
+						if (event.key === "Escape") {
+							setState(null);
+							return true;
+						}
+						if (s.items.length === 0) return false;
+						if (event.key === "ArrowDown" || event.key === "ArrowUp") {
+							const step = event.key === "ArrowDown" ? 1 : -1;
+							setState({
+								...s,
+								active: (s.active + step + s.items.length) % s.items.length
+							});
+							return true;
+						}
+						if (event.key === "Enter" || event.key === "Tab") {
+							const item = s.items[s.active];
+							if (item) s.pick(item);
+							return true;
+						}
+						return false;
+					}
+				};
+			}
+		}
+	});
+}
+//#endregion
+export { suggestionExtension };

package/dist/chat/composer/suggestions.d.ts

@@ -0,0 +1,57 @@
+import { CSSProperties } from "react";
+//#region src/chat/composer/suggestions.d.ts
+/** One completion offered by a {@link SuggestionSource}: a file, a session, a command. */
+interface MentionItem {
+  /** What the host resolves (a path, a session id, a command name). */
+  id: string;
+  /** What the popup and the badge show. */
+  label: string;
+  /** Short text shown under the label in the popup. */
+  description?: string;
+  /** A Uno icon class (`i-ph-file`) drawn in the row. */
+  icon?: string;
+}
+/** Feeds one completion trigger of the composer: the items for what the user typed, and how a picked item is written into the prompt. */
+interface SuggestionSource {
+  /** Items for what follows the trigger, ranked. Called on every keystroke while the popup is open. */
+  items(query: string): Promise<readonly MentionItem[]> | readonly MentionItem[];
+  /** The prompt text for a picked item. Default: `@label` for mentions, `/label` for commands. */
+  serialize?(item: Pick<MentionItem, 'id' | 'label'>): string;
+}
+/** Which trigger a completion belongs to: `mention` (`@`) or `command` (`/`). */
+type SuggestionKind = 'mention' | 'command';
+/** The open popup, as the composer renders it. */
+interface SuggestionState {
+  /** Which trigger opened the popup. */
+  kind: SuggestionKind;
+  /** The items shown, ranked. */
+  items: readonly MentionItem[];
+  /** Index in `items` of the row under the keyboard cursor. */
+  active: number;
+  /** Viewport position the popup attaches to, at the caret. */
+  anchor: {
+    x: number;
+    y: number;
+  };
+  /** Inserts an item into the draft as a badge. */
+  pick(item: MentionItem): void;
+}
+/** The character that opens each completion: `@` for mentions and `/` for commands. */
+declare const TRIGGER: Record<SuggestionKind, string>;
+/** Props for {@link SuggestionPopup}. */
+interface SuggestionPopupProps {
+  /** The open popup, or `null` to hide it. */
+  state: SuggestionState | null;
+  /** Extra classes on the root element (the floating surface). */
+  className?: string;
+  /** Inline styles on the root element, merged after the component's own. */
+  style?: CSSProperties;
+}
+/**
+ * The popup over the caret: one row per item, the keyboard cursor raised.
+ *
+ * @param props - Popup props: the `state` to show.
+ */
+declare function SuggestionPopup({ state, className, style }: SuggestionPopupProps): import("react").JSX.Element;
+//#endregion
+export { MentionItem, SuggestionKind, SuggestionPopup, SuggestionPopupProps, SuggestionSource, SuggestionState, TRIGGER };

package/dist/chat/composer/suggestions.js

@@ -0,0 +1,69 @@
+import { Menu, MenuNote, MenuRow } from "../../components/Menu.js";
+import { FloatingSurface } from "../../components/floating/FloatingSurface.js";
+import { useChatLabels } from "../useChatLabels.js";
+import { jsx } from "react/jsx-runtime";
+import { useEffect, useRef } from "react";
+//#region src/chat/composer/suggestions.tsx
+/**
+* The composer's two completion hooks, `@` mentions and `/` commands: each
+* a Tiptap Mention node (`suggestion-extension.ts`) fed by an app's `items(query)`, with the popup drawn
+* by the kit (a `FloatingSurface` holding a `Menu` of rows) instead of a
+* DOM library. A picked item becomes an inline badge; on send it serialises
+* to plain text the host understands, `@label` / `/label` unless the
+* source says otherwise.
+*/
+/** The character that opens each completion: `@` for mentions and `/` for commands. */
+const TRIGGER = {
+	mention: "@",
+	command: "/"
+};
+/**
+* The popup over the caret: one row per item, the keyboard cursor raised.
+*
+* @param props - Popup props: the `state` to show.
+*/
+function SuggestionPopup({ state, className, style }) {
+	const labels = useChatLabels();
+	const listRef = useRef(null);
+	const active = state?.active ?? 0;
+	useEffect(() => {
+		listRef.current?.querySelector("[data-active]")?.scrollIntoView?.({ block: "nearest" });
+	}, [active]);
+	const label = state?.kind === "command" ? labels.commandSuggestions : labels.mentionSuggestions;
+	return /* @__PURE__ */ jsx(FloatingSurface, {
+		open: state !== null,
+		anchor: { point: state?.anchor ?? {
+			x: 0,
+			y: 0
+		} },
+		side: "top",
+		align: "start",
+		offset: 6,
+		width: 320,
+		className,
+		style,
+		"data-testid": "composer-suggestions",
+		children: state && /* @__PURE__ */ jsx("div", {
+			ref: listRef,
+			className: "max-h-[min(40vh,280px)] overflow-y-auto",
+			children: state.items.length === 0 ? /* @__PURE__ */ jsx(MenuNote, { children: labels.noSuggestions }) : /* @__PURE__ */ jsx(Menu, {
+				role: "listbox",
+				"aria-label": label,
+				children: state.items.map((item, i) => /* @__PURE__ */ jsx(MenuRow, {
+					"aria-selected": i === state.active,
+					active: i === state.active,
+					icon: item.icon ? /* @__PURE__ */ jsx("span", {
+						"aria-hidden": true,
+						className: item.icon
+					}) : void 0,
+					title: item.label,
+					description: item.description,
+					onMouseDown: (e) => e.preventDefault(),
+					onClick: () => state.pick(item)
+				}, item.id))
+			})
+		})
+	});
+}
+//#endregion
+export { SuggestionPopup, TRIGGER };

package/dist/chat/composer/use-agent-profiles.d.ts

@@ -0,0 +1,37 @@
+import { ComposerAgentProfile, ComposerAgents, ComposerSessionView } from "../headless/composer/host-chrome.js";
+//#region src/chat/composer/use-agent-profiles.d.ts
+/**
+ * The profiles `cwd` offers (`''`: no folder). Empty until read, and without `agents`.
+ *
+ * @param cwd - The folder.
+ * @param agentsOverride - The profiles' source. Default: the host's `agents`.
+ */
+declare function useAgentProfiles(cwd: string, agentsOverride?: ComposerAgents): readonly ComposerAgentProfile[];
+/**
+ * The profile after `currentId` in `ids`, wrapping; the first one when
+ * `currentId` is not listed. `null` when there is nothing to switch to.
+ *
+ * @param ids - The offered profile ids, in the picker's order.
+ * @param currentId - The current profile.
+ */
+declare function nextProfileId(ids: readonly string[], currentId: string): string | null;
+/** Options for {@link useCycleAgent}. */
+interface CycleAgentOptions {
+  /** The session runs now (no switch mid-run). */
+  running: boolean;
+  /** Called once a switch is written (refresh the app's session list). */
+  onCommitted?: () => void | Promise<void>;
+}
+/**
+ * Quick-cycle through the folder's agent profiles (the `cycleAgent`
+ * shortcut). Mirrors the TUI's Shift+Tab: the next profile in the picker's
+ * order, wrapping; a no-op with one profile, while the session runs, or while
+ * it waits on an approval (`ApprovalsHost`) or a question (`ChatHost`).
+ *
+ * @param session - The session, `null` for none (the callback does nothing).
+ * @param options - Whether it runs, and what to do after a switch.
+ * @returns A callback that moves the session to its next profile.
+ */
+declare function useCycleAgent(session: ComposerSessionView | null, options: CycleAgentOptions): () => Promise<void>;
+//#endregion
+export { CycleAgentOptions, nextProfileId, useAgentProfiles, useCycleAgent };

package/dist/chat/composer/use-agent-profiles.js

@@ -0,0 +1,87 @@
+import { useSessionApprovalHead } from "../../approvals/ApprovalsProvider.js";
+import { useComposerHost } from "./ComposerHostProvider.js";
+import { useInteractionHead } from "../interactions/hooks.js";
+import { useCallback, useEffect, useState } from "react";
+//#region src/chat/composer/use-agent-profiles.ts
+/**
+* The agent profiles a folder offers (`ComposerHost.agents`): read for the
+* folder, and again whenever the host says they may have changed
+* (`agents.onChanged`: extensions reloaded, settings changed), so an
+* extension's new agent shows without reopening anything.
+*/
+const NONE = [];
+/**
+* The profiles `cwd` offers (`''`: no folder). Empty until read, and without `agents`.
+*
+* @param cwd - The folder.
+* @param agentsOverride - The profiles' source. Default: the host's `agents`.
+*/
+function useAgentProfiles(cwd, agentsOverride) {
+	const hostAgents = useComposerHost().agents;
+	const agents = agentsOverride ?? hostAgents;
+	const [profiles, setProfiles] = useState(NONE);
+	const [generation, setGeneration] = useState(0);
+	useEffect(() => agents?.onChanged?.(() => setGeneration((n) => n + 1)), [agents]);
+	useEffect(() => {
+		if (!agents) return void 0;
+		let cancelled = false;
+		agents.list(cwd).then((list) => {
+			if (!cancelled) setProfiles(list);
+		}).catch(() => void 0);
+		return () => {
+			cancelled = true;
+		};
+	}, [
+		agents,
+		cwd,
+		generation
+	]);
+	return profiles;
+}
+/**
+* The profile after `currentId` in `ids`, wrapping; the first one when
+* `currentId` is not listed. `null` when there is nothing to switch to.
+*
+* @param ids - The offered profile ids, in the picker's order.
+* @param currentId - The current profile.
+*/
+function nextProfileId(ids, currentId) {
+	if (ids.length <= 1) return null;
+	const index = ids.indexOf(currentId);
+	return ids[(index < 0 ? 0 : index + 1) % ids.length] ?? null;
+}
+/**
+* Quick-cycle through the folder's agent profiles (the `cycleAgent`
+* shortcut). Mirrors the TUI's Shift+Tab: the next profile in the picker's
+* order, wrapping; a no-op with one profile, while the session runs, or while
+* it waits on an approval (`ApprovalsHost`) or a question (`ChatHost`).
+*
+* @param session - The session, `null` for none (the callback does nothing).
+* @param options - Whether it runs, and what to do after a switch.
+* @returns A callback that moves the session to its next profile.
+*/
+function useCycleAgent(session, options) {
+	const { running, onCommitted } = options;
+	const setAgent = useComposerHost().controls?.setAgent;
+	const profiles = useAgentProfiles(session?.cwd ?? "");
+	const sessionId = session?.id ?? null;
+	const approval = useSessionApprovalHead(sessionId);
+	const interaction = useInteractionHead(sessionId);
+	return useCallback(async () => {
+		if (!session || !setAgent || running || approval || interaction) return;
+		const next = nextProfileId(profiles.map((p) => p.id), session.agentId ?? "build");
+		if (!next) return;
+		await setAgent(session.id, next);
+		await onCommitted?.();
+	}, [
+		session,
+		setAgent,
+		running,
+		approval,
+		interaction,
+		profiles,
+		onCommitted
+	]);
+}
+//#endregion
+export { nextProfileId, useAgentProfiles, useCycleAgent };

package/dist/chat/composer/use-cache-hints.d.ts

@@ -0,0 +1,16 @@
+import { ComposerCacheImpactChange } from "../headless/composer/host-chrome.js";
+//#region src/chat/composer/use-cache-hints.d.ts
+/**
+ * Cache hints for a picker's options, fetched once per open: an option's
+ * estimate is asked the first time it renders. The first answer decides for
+ * all: no live agent, an expired cache, a short prompt or an older daemon
+ * means no option can show one, so nothing more is asked. Never blocks a
+ * pick; a failed estimate shows nothing.
+ *
+ * @param sessionId - The session the pick applies to; `null` (a draft) shows no hints.
+ * @param open - Whether the picker is showing. A modal is (the default); a popover passes its open state: closed asks nothing, and each opening asks afresh.
+ * @returns A lookup: the hint for option `key` (the change it would make), `undefined` while unknown or when there is none. A new lookup each time an answer arrives, so it can key a memo.
+ */
+declare function useCacheHints(sessionId: string | null, open?: boolean): (key: string, change: ComposerCacheImpactChange) => string | undefined;
+//#endregion
+export { useCacheHints };

package/dist/chat/composer/use-cache-hints.js

@@ -0,0 +1,75 @@
+import { useComposerHost } from "./ComposerHostProvider.js";
+import { useCallback, useEffect, useReducer, useRef } from "react";
+import { CACHE_HINT_MIN_TOKENS, cacheHintText } from "zidane/chat/pure";
+//#region src/chat/composer/use-cache-hints.ts
+/**
+* What a pick would cost the session's prompt cache, for the pickers: the
+* TUI's wording and floor (`cacheHintText`), from the composer's host
+* (`ComposerHost.controls.cacheImpact`; without it, no hints).
+*/
+/** Whether any option can show a hint, judged from one answer: every re-read is the same last prompt. */
+function hintsPossible(impact) {
+	return impact !== null && !impact.expired && (impact.keepsCache || impact.tokens >= CACHE_HINT_MIN_TOKENS);
+}
+/**
+* Cache hints for a picker's options, fetched once per open: an option's
+* estimate is asked the first time it renders. The first answer decides for
+* all: no live agent, an expired cache, a short prompt or an older daemon
+* means no option can show one, so nothing more is asked. Never blocks a
+* pick; a failed estimate shows nothing.
+*
+* @param sessionId - The session the pick applies to; `null` (a draft) shows no hints.
+* @param open - Whether the picker is showing. A modal is (the default); a popover passes its open state: closed asks nothing, and each opening asks afresh.
+* @returns A lookup: the hint for option `key` (the change it would make), `undefined` while unknown or when there is none. A new lookup each time an answer arrives, so it can key a memo.
+*/
+function useCacheHints(sessionId, open = true) {
+	const cacheImpact = useComposerHost().controls?.cacheImpact;
+	const known = useRef(/* @__PURE__ */ new Map());
+	const wanted = useRef(/* @__PURE__ */ new Map());
+	const asked = useRef(/* @__PURE__ */ new Set());
+	const gate = useRef("unknown");
+	const round = useRef(0);
+	const wasOpen = useRef(false);
+	const mounted = useRef(true);
+	const [answers, refresh] = useReducer((n) => n + 1, 0);
+	if (open && !wasOpen.current) {
+		round.current += 1;
+		known.current.clear();
+		wanted.current.clear();
+		asked.current.clear();
+		gate.current = "unknown";
+	}
+	wasOpen.current = open;
+	useEffect(() => () => {
+		mounted.current = false;
+	}, []);
+	useEffect(() => {
+		if (!sessionId || !open || !cacheImpact || wanted.current.size === 0) return;
+		if (gate.current === "probing" || gate.current === "closed") return;
+		const batch = gate.current === "unknown" ? [...wanted.current].slice(0, 1) : [...wanted.current];
+		if (gate.current === "unknown") gate.current = "probing";
+		const asking = round.current;
+		for (const [key, change] of batch) {
+			wanted.current.delete(key);
+			asked.current.add(key);
+			cacheImpact(sessionId, change).catch(() => null).then((impact) => {
+				if (asking !== round.current) return;
+				known.current.set(key, impact);
+				if (gate.current === "probing") gate.current = hintsPossible(impact) ? "open" : "closed";
+				if (mounted.current) refresh();
+			});
+		}
+	});
+	return useCallback((key, change) => {
+		if (!sessionId || !open || !cacheImpact || gate.current === "closed") return void 0;
+		if (known.current.has(key)) return cacheHintText(known.current.get(key));
+		if (!asked.current.has(key)) wanted.current.set(key, change);
+	}, [
+		sessionId,
+		open,
+		cacheImpact,
+		answers
+	]);
+}
+//#endregion
+export { useCacheHints };

package/dist/chat/composer/use-composer-stores.d.ts

@@ -0,0 +1,62 @@
+import { Readable } from "../headless/store.js";
+import { ResourceSnapshot } from "../../app/headless/resource.js";
+import { ComposerModelEntry } from "../headless/composer/models.js";
+import { ModelPickerPrefs, ModelPickerPrefsStore } from "../headless/composer/model-picker-prefs.js";
+import { ModelKnobs, ModelKnobsStore } from "../headless/composer/model-knobs.js";
+import "../headless/index.js";
+import { ModelNamer, SessionKnobs } from "zidane/chat/pure";
+//#region src/chat/composer/use-composer-stores.d.ts
+/**
+ * A host resource, kept current while mounted (`IDLE_RESOURCE` for `null`).
+ *
+ * @param resource - The resource; memoize it (a new one each render resubscribes).
+ */
+declare function useHostResource<T>(resource: Readable<ResourceSnapshot<T>> | null): ResourceSnapshot<T>;
+/**
+ * The text of a resource's error, `null` for none.
+ *
+ * @param error - The snapshot's `error`.
+ */
+declare function resourceErrorText(error: unknown): string | null;
+/** A model catalog as a picker reads it. */
+interface ModelCatalogState {
+  /** The rows, `null` while loading. */
+  catalog: readonly ComposerModelEntry[] | null;
+  /** Why it failed to load. */
+  error: string | null;
+  /** Reads it again. */
+  retry: (() => void) | undefined;
+}
+/**
+ * The catalog to list: `outer` when the caller loaded one, else the host's for `cwd` on `hostId`.
+ *
+ * @param outer - A catalog the caller already holds.
+ * @param cwd - The folder.
+ * @param hostId - The server, `null` for this computer.
+ */
+declare function useModelCatalog(outer: readonly ComposerModelEntry[] | null, cwd?: string, hostId?: string | null): ModelCatalogState;
+/** The host's picker preferences store (an in-memory one when it has none). */
+declare function useModelPickerPrefsStore(): ModelPickerPrefsStore;
+/** The model picker's preferences, live. */
+declare function useModelPickerPrefs(): ModelPickerPrefs;
+/**
+ * The last effort and options used with `modelId`, live.
+ *
+ * @param modelId - The model.
+ */
+declare function useRememberedKnobs(modelId: string | null): ModelKnobs;
+/**
+ * A new chat's starting effort and options on `modelId`, live (its draft's pick, the configured defaults, the last used).
+ *
+ * @param modelId - The model the draft starts on.
+ * @param configured - The configured defaults.
+ */
+declare function useDraftKnobs(modelId: string | null, configured: SessionKnobs | undefined): ModelKnobs;
+/** Names a model as the model picker does; re-renders when the catalog arrives or changes. */
+declare function useComposerModelName(): ModelNamer;
+/** A provider's label as the model picker groups it (`Anthropic`). */
+declare function useComposerProviderLabel(): (providerKey: string) => string;
+/** The remembered knobs of the nearest host, for actions. */
+declare function useModelKnobs(): ModelKnobsStore;
+//#endregion
+export { ModelCatalogState, resourceErrorText, useComposerModelName, useComposerProviderLabel, useDraftKnobs, useHostResource, useModelCatalog, useModelKnobs, useModelPickerPrefs, useModelPickerPrefsStore, useRememberedKnobs };

package/dist/chat/composer/use-composer-stores.js

@@ -0,0 +1,118 @@
+import { IDLE_RESOURCE } from "../../app/headless/resource.js";
+import { createModelPickerPrefs } from "../headless/composer/model-picker-prefs.js";
+import { useComposerHost } from "./ComposerHostProvider.js";
+import { modelKnobsOf } from "../headless/composer/model-knobs.js";
+import { modelNamesOf } from "../headless/composer/model-names.js";
+import { useEffect, useMemo, useSyncExternalStore } from "react";
+//#region src/chat/composer/use-composer-stores.ts
+/**
+* The composer chrome's reads in a component: a host resource (a catalog, a
+* context gauge), the model catalog, the picker preferences and the
+* remembered knobs. Each reads the nearest `ComposerHost`.
+*/
+const noSubscribe = () => () => void 0;
+const idle = () => IDLE_RESOURCE;
+/**
+* A host resource, kept current while mounted (`IDLE_RESOURCE` for `null`).
+*
+* @param resource - The resource; memoize it (a new one each render resubscribes).
+*/
+function useHostResource(resource) {
+	return useSyncExternalStore(resource ? resource.subscribe : noSubscribe, resource ? resource.get : idle, resource ? resource.get : idle);
+}
+/**
+* The text of a resource's error, `null` for none.
+*
+* @param error - The snapshot's `error`.
+*/
+function resourceErrorText(error) {
+	if (error === void 0 || error === null) return null;
+	return typeof error === "string" ? error : error instanceof Error ? error.message : String(error);
+}
+/**
+* The catalog to list: `outer` when the caller loaded one, else the host's for `cwd` on `hostId`.
+*
+* @param outer - A catalog the caller already holds.
+* @param cwd - The folder.
+* @param hostId - The server, `null` for this computer.
+*/
+function useModelCatalog(outer, cwd, hostId = null) {
+	const models = useComposerHost().models;
+	const resource = useMemo(() => outer || !models ? null : models.catalog(cwd, hostId), [
+		outer,
+		models,
+		cwd,
+		hostId
+	]);
+	const snap = useHostResource(resource);
+	if (outer) return {
+		catalog: outer,
+		error: null,
+		retry: void 0
+	};
+	return {
+		catalog: snap.data ?? null,
+		error: snap.status === "error" ? resourceErrorText(snap.error) : null,
+		retry: resource ? snap.refresh : void 0
+	};
+}
+const memoryPrefs = createModelPickerPrefs({
+	getItem: () => null,
+	setItem: () => void 0
+});
+/** The host's picker preferences store (an in-memory one when it has none). */
+function useModelPickerPrefsStore() {
+	return useComposerHost().pickerPrefs ?? memoryPrefs;
+}
+/** The model picker's preferences, live. */
+function useModelPickerPrefs() {
+	const store = useModelPickerPrefsStore();
+	return useSyncExternalStore(store.subscribe, store.get, store.get);
+}
+function useKnobsMemory() {
+	const store = modelKnobsOf(useComposerHost().prefs);
+	useEffect(() => {
+		store.load();
+	}, [store]);
+	return {
+		store,
+		memory: useSyncExternalStore(store.subscribe, store.snapshot, store.snapshot)
+	};
+}
+/**
+* The last effort and options used with `modelId`, live.
+*
+* @param modelId - The model.
+*/
+function useRememberedKnobs(modelId) {
+	const { store, memory } = useKnobsMemory();
+	return store.remembered(modelId, memory);
+}
+/**
+* A new chat's starting effort and options on `modelId`, live (its draft's pick, the configured defaults, the last used).
+*
+* @param modelId - The model the draft starts on.
+* @param configured - The configured defaults.
+*/
+function useDraftKnobs(modelId, configured) {
+	const { store, memory } = useKnobsMemory();
+	return store.draft(modelId, configured, memory);
+}
+function useNames() {
+	const store = modelNamesOf(useComposerHost().models);
+	return useSyncExternalStore(store.subscribe, store.get, store.get);
+}
+/** Names a model as the model picker does; re-renders when the catalog arrives or changes. */
+function useComposerModelName() {
+	return useNames().model;
+}
+/** A provider's label as the model picker groups it (`Anthropic`). */
+function useComposerProviderLabel() {
+	return useNames().provider;
+}
+/** The remembered knobs of the nearest host, for actions. */
+function useModelKnobs() {
+	return modelKnobsOf(useComposerHost().prefs);
+}
+//#endregion
+export { resourceErrorText, useComposerModelName, useComposerProviderLabel, useDraftKnobs, useHostResource, useModelCatalog, useModelKnobs, useModelPickerPrefs, useModelPickerPrefsStore, useRememberedKnobs };