@coffer-org/plugin-webchat 2.2.6 → 2.3.0

package/dist/{ChatWidget-By7bmS3U.js → ChatWidget-BvI5pRWb.js}

@@ -507,6 +507,26 @@ var createLucideIcon = (iconName, iconNode) => {
 * This source code is licensed under the ISC license.
 * See the LICENSE file in the root directory of this source tree.
 */
+var Check = createLucideIcon("check", [["path", {
+	d: "M20 6 9 17l-5-5",
+	key: "1gmf2c"
+}]]);
+/**
+* @license lucide-react v1.24.0 - ISC
+*
+* This source code is licensed under the ISC license.
+* See the LICENSE file in the root directory of this source tree.
+*/
+var ChevronDown = createLucideIcon("chevron-down", [["path", {
+	d: "m6 9 6 6 6-6",
+	key: "qrunsl"
+}]]);
+/**
+* @license lucide-react v1.24.0 - ISC
+*
+* This source code is licensed under the ISC license.
+* See the LICENSE file in the root directory of this source tree.
+*/
 var FileText = createLucideIcon("file-text", [
 	["path", {
 		d: "M6 22a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.704.706l3.588 3.588A2.4 2.4 0 0 1 20 8v12a2 2 0 0 1-2 2z",
@@ -6291,28 +6311,45 @@ async function* readSse(body) {
 /** Web-chat transport. Session cookies are sent automatically (same-origin), so there is no
 *  separate authorization here; the gate is on the server. */
 var BASE = "/api/plugins/webchat/user";
+/** POST a member-level webchat action with a JSON body: the one request path every call
+*  in this file (except the SSE stream in `sendMessage`) goes through. Throws `Error(action)`
+*  on any non-OK response — every caller below relies on that to build its own error message. */
+async function postAction(action, body) {
+	const r = await fetch(`${BASE}/${action}`, {
+		method: "POST",
+		headers: { "content-type": "application/json" },
+		body: JSON.stringify(body)
+	});
+	if (!r.ok) throw new Error(action);
+	return await r.json();
+}
 /**
 * Throws on any rejection, including 404 (“plugin was disabled AFTER the widget bundle
 * loaded”). There is deliberately no separate `null` for this case: the caller keeps
 * the current thread list either way, so two return codes would mean the same thing.
 */
 async function fetchThreads() {
-	const r = await fetch(`${BASE}/threads`, {
-		method: "POST",
-		headers: { "content-type": "application/json" },
-		body: "{}"
-	});
-	if (!r.ok) throw new Error("threads");
-	return (await r.json()).threads;
+	return (await postAction("threads", {})).threads;
 }
 async function fetchHistory(convId) {
-	const r = await fetch(`${BASE}/history`, {
-		method: "POST",
-		headers: { "content-type": "application/json" },
-		body: JSON.stringify({ convId })
-	});
-	if (!r.ok) throw new Error("history");
-	return await r.json();
+	return postAction("history", { convId });
+}
+async function fetchAgents(convId) {
+	const out = await postAction("agents", { convId });
+	return {
+		agents: out.agents ?? [],
+		defaultAgentId: out.defaultAgentId ?? null,
+		selection: out.selection ?? {
+			agentId: null,
+			presetId: null
+		}
+	};
+}
+async function selectAgent(convId, patch) {
+	return (await postAction("selectAgent", {
+		convId,
+		...patch
+	})).selection;
 }
 async function sendMessage(req) {
 	const r = await fetch(`${BASE}/send/stream`, {
@@ -6356,6 +6393,12 @@ function useChat() {
 	const [pending, setPending] = useState(null);
 	const [pendingReasoning, setPendingReasoning] = useState(null);
 	const [error, setError] = useState(null);
+	const [agents, setAgents] = useState([]);
+	const [defaultAgentId, setDefaultAgentId] = useState(null);
+	const [selection, setSelection] = useState({
+		agentId: null,
+		presetId: null
+	});
 	const headRef = useRef(null);
 	const abortRef = useRef(null);
 	const sendingRef = useRef(false);
@@ -6374,6 +6417,32 @@ function useChat() {
 			if (aliveRef.current) setThreads(list);
 		}).catch(() => {});
 	}, []);
+	useEffect(() => {
+		if (!convId) return;
+		let cancelled = false;
+		fetchAgents(convId).then((r) => {
+			if (cancelled) return;
+			setAgents(r.agents);
+			setDefaultAgentId(r.defaultAgentId);
+			setSelection(r.selection);
+		}).catch(() => {});
+		return () => {
+			cancelled = true;
+		};
+	}, [convId]);
+	const chooseAgent = useCallback((next) => {
+		const previous = selection;
+		setSelection(next);
+		if (convId) selectAgent(convId, next).then(setSelection).catch((err) => {
+			setSelection(previous);
+			setError(err instanceof Error ? err.message : String(err));
+		});
+	}, [convId, selection]);
+	const attachmentsAllowed = useMemo(() => {
+		const preset = agents.find((a) => a.id === selection.agentId)?.presets.find((p) => p.id === selection.presetId);
+		if (!preset?.capabilities) return true;
+		return preset.capabilities.vision !== false || preset.capabilities.documents !== false;
+	}, [agents, selection]);
 	const newConversation = useCallback(() => {
 		abortRef.current?.abort();
 		abortRef.current = null;
@@ -6419,6 +6488,11 @@ function useChat() {
 		pending,
 		pendingReasoning,
 		error,
+		agents,
+		defaultAgentId,
+		selection,
+		attachmentsAllowed,
+		chooseAgent,
 		send: useCallback((text, context, attachments = []) => {
 			if (!text.trim() || sendingRef.current) return false;
 			sendingRef.current = true;
@@ -29309,8 +29383,97 @@ var Bubble = memo(function Bubble({ role, text, reasoning, attachments }) {
 	});
 });
 //#endregion
+//#region src/ui/AgentPicker.tsx
+/** Flatten the catalog to one list: with a single registered agent the agent
+*  level is noise, and with several the agent name simply prefixes its presets. */
+function AgentPicker({ agents, defaultAgentId, selection, onChange }) {
+	const { t } = useTranslation();
+	const [open, setOpen] = useState(false);
+	const rootRef = useRef(null);
+	const triggerRef = useRef(null);
+	useEffect(() => {
+		if (!open) return;
+		function onPointerDown(e) {
+			if (rootRef.current && !rootRef.current.contains(e.target)) setOpen(false);
+		}
+		function onKeyDown(e) {
+			if (e.key === "Escape") {
+				setOpen(false);
+				triggerRef.current?.focus();
+			}
+		}
+		document.addEventListener("pointerdown", onPointerDown);
+		document.addEventListener("keydown", onKeyDown);
+		return () => {
+			document.removeEventListener("pointerdown", onPointerDown);
+			document.removeEventListener("keydown", onKeyDown);
+		};
+	}, [open]);
+	const multi = agents.length > 1;
+	const rows = agents.flatMap((a) => a.presets.map((p) => ({
+		agentId: a.id,
+		presetId: p.id,
+		label: multi ? `${a.title} · ${p.title}` : p.title,
+		hint: p.hint,
+		isDefault: p.default === true
+	})));
+	if (rows.length === 0) return null;
+	const current = rows.find((r) => r.agentId === selection.agentId && r.presetId === selection.presetId) ?? rows.find((r) => r.agentId === defaultAgentId && r.isDefault) ?? rows.find((r) => r.isDefault) ?? rows[0];
+	return /* @__PURE__ */ jsxs("div", {
+		className: "relative",
+		ref: rootRef,
+		children: [/* @__PURE__ */ jsxs("button", {
+			ref: triggerRef,
+			type: "button",
+			"aria-haspopup": "menu",
+			"aria-expanded": open,
+			className: "flex items-center gap-1 rounded-md px-2 py-1 text-xs text-muted hover:text-text focus-visible:outline-2 focus-visible:outline-accent",
+			onClick: () => setOpen((v) => !v),
+			children: [/* @__PURE__ */ jsx("span", {
+				className: "max-w-40 truncate",
+				children: current.label
+			}), /* @__PURE__ */ jsx(ChevronDown, {
+				size: 12,
+				className: "shrink-0"
+			})]
+		}), open && /* @__PURE__ */ jsx("ul", {
+			"aria-label": t("webchat.agentPicker"),
+			className: "absolute bottom-full z-10 mb-1 max-h-64 w-64 overflow-y-auto rounded-md border border-border bg-elevated py-1 shadow-lg",
+			children: rows.map((r) => {
+				const selected = r === current;
+				return /* @__PURE__ */ jsx("li", { children: /* @__PURE__ */ jsxs("button", {
+					type: "button",
+					...selected ? { "aria-current": true } : {},
+					className: "flex w-full items-center gap-2 px-2 py-1.5 text-left text-xs hover:bg-surface focus-visible:outline-2 focus-visible:outline-accent",
+					onClick: () => {
+						setOpen(false);
+						onChange({
+							agentId: r.agentId,
+							presetId: r.presetId
+						});
+					},
+					children: [
+						/* @__PURE__ */ jsx(Check, {
+							size: 12,
+							className: selected ? "shrink-0 text-accent" : "shrink-0 opacity-0"
+						}),
+						/* @__PURE__ */ jsx("span", {
+							className: "min-w-0 flex-1 truncate",
+							children: r.label
+						}),
+						r.hint && /* @__PURE__ */ jsx("span", {
+							className: "shrink-0 text-muted",
+							children: r.hint
+						})
+					]
+				}) }, `${r.agentId}/${r.presetId}`);
+			})
+		})]
+	});
+}
+//#endregion
 //#region src/ui/ChatComposer.tsx
-function ChatComposer({ streaming, onSend, onStop, attachments, uploading, uploadError, uploadProgress, canRetryUpload, onRetryUpload, onPickFiles, onRemoveAttachment }) {
+function ChatComposer({ streaming, onSend, onStop, attachments, uploading, uploadError, uploadProgress, canRetryUpload, onRetryUpload, onPickFiles, onRemoveAttachment, agents, defaultAgentId, selection, onChooseAgent, attachmentsAllowed }) {
 	const { t } = useTranslation();
 	const [text, setText] = useState("");
 	function submit() {
@@ -29389,7 +29552,7 @@ function ChatComposer({ streaming, onSend, onStop, attachments, uploading, uploa
 		}), /* @__PURE__ */ jsxs("div", {
 			className: "flex items-end gap-2",
 			children: [
-				/* @__PURE__ */ jsxs("label", {
+				attachmentsAllowed && /* @__PURE__ */ jsxs("label", {
 					"aria-label": t("webchat.attach"),
 					className: `cursor-pointer rounded-lg p-2 text-muted hover:bg-elevated hover:text-accent ${uploading ? "pointer-events-none opacity-60" : ""}`,
 					children: [/* @__PURE__ */ jsx(Paperclip, { size: 18 }), /* @__PURE__ */ jsx("input", {
@@ -29416,6 +29579,12 @@ function ChatComposer({ streaming, onSend, onStop, attachments, uploading, uploa
 						}
 					}
 				}),
+				/* @__PURE__ */ jsx(AgentPicker, {
+					agents,
+					defaultAgentId,
+					selection,
+					onChange: onChooseAgent
+				}),
 				streaming ? /* @__PURE__ */ jsx("button", {
 					"aria-label": t("webchat.stop"),
 					className: "rounded-lg p-2 hover:bg-elevated",
@@ -29520,9 +29689,10 @@ function ChatDropSurface({ children, onFiles, className }) {
 }
 /** What to do with the widget after following a link from a response. On desktop a 380px
 *  panel does not obstruct the page (a darkened modal does, so it collapses into it);
-*  below the nav breakpoint the panel consumes nearly the whole screen. */
+*  on narrow screens the chat remains expanded so the user does not lose the active
+*  conversation after an in-app navigation. */
 function nextModeAfterNav(wideNav) {
-	return wideNav ? "panel" : "bubble";
+	return wideNav ? "panel" : "modal";
 }
 function ChatWidget() {
 	const { t } = useTranslation();
@@ -29567,6 +29737,14 @@ function ChatWidget() {
 	useEffect(() => {
 		if (isOpen) chat.loadThreads();
 	}, [isOpen, chat.loadThreads]);
+	const { convId, newConversation } = chat;
+	useEffect(() => {
+		if (isOpen && convId === null) newConversation();
+	}, [
+		isOpen,
+		convId,
+		newConversation
+	]);
 	function startNew() {
 		chat.newConversation();
 		setAttachments([]);
@@ -29675,6 +29853,11 @@ function ChatWidget() {
 					onRetryUpload: retryUploads,
 					onPickFiles: (files) => void pickFiles(Array.from(files)),
 					onRemoveAttachment: (index) => setAttachments((prev) => prev.filter((_, i) => i !== index)),
+					agents: chat.agents,
+					defaultAgentId: chat.defaultAgentId,
+					selection: chat.selection,
+					onChooseAgent: chat.chooseAgent,
+					attachmentsAllowed: chat.attachmentsAllowed,
 					onSend: (text, refs) => {
 						const accepted = refs.length ? chat.send(text, page, refs) : chat.send(text, page);
 						if (accepted) {

package/dist/runtime/actions.d.ts

@@ -1,4 +1,6 @@
 import { type ActionCaller } from '@coffer-org/server/plugin-hooks';
+import { type AgentDescriptor } from '@coffer-org/plugin-orchestrator/runtime';
+import { type ThreadSelection } from './chain-store.ts';
 export interface ThreadSummary {
     convId: string;
     title: string;
@@ -26,3 +28,11 @@ export declare function historyAction(body: Record<string, unknown>, caller: Act
     messages: HistoryMsg[];
     headMsgId: string | null;
 }>;
+export declare function agentsAction(body: Record<string, unknown>, caller: ActionCaller): Promise<{
+    agents: AgentDescriptor[];
+    defaultAgentId: string | null;
+    selection: ThreadSelection;
+}>;
+export declare function selectAgentAction(body: Record<string, unknown>, caller: ActionCaller): Promise<{
+    selection: ThreadSelection;
+}>;

package/dist/runtime/actions.js

@@ -1,5 +1,6 @@
 import { HttpError } from '@coffer-org/server/plugin-hooks';
-import { chatIdFor, conversations, history } from "./chain-store.js";
+import { listAgentCatalog, getDefaultAgentId, listRegisteredAgents, } from '@coffer-org/plugin-orchestrator/runtime';
+import { chatIdFor, conversations, history, getSelection, setSelection } from "./chain-store.js";
 const TITLE_MAX = 60;
 function title(firstUserText) {
     const t = firstUserText.trim().replace(/\s+/g, ' ');
@@ -17,10 +18,14 @@ export async function threadsAction(_body, caller) {
         })),
     };
 }
-export async function historyAction(body, caller) {
+function requireConvId(body) {
     const convId = body['convId'];
     if (typeof convId !== 'string' || !convId)
         throw new HttpError(400, 'missing required field: convId');
+    return convId;
+}
+export async function historyAction(body, caller) {
+    const convId = requireConvId(body);
     const rows = await history(chatIdFor(caller.id, convId));
     const reasoningByBot = new Map(rows.filter((m) => m.role === 'reasoning').map((m) => [m.msgId.slice(0, -2), m.text]));
     const visible = rows.filter((m) => m.role !== 'reasoning');
@@ -37,3 +42,26 @@ export async function historyAction(body, caller) {
         headMsgId: visible.at(-1)?.msgId ?? null,
     };
 }
+export async function agentsAction(body, caller) {
+    const convId = requireConvId(body);
+    return {
+        agents: await listAgentCatalog(),
+        defaultAgentId: getDefaultAgentId() ?? null,
+        selection: await getSelection(chatIdFor(caller.id, convId)),
+    };
+}
+export async function selectAgentAction(body, caller) {
+    const convId = requireConvId(body);
+    const chatId = chatIdFor(caller.id, convId);
+    const patch = {};
+    if ('agentId' in body) {
+        const agentId = typeof body['agentId'] === 'string' && body['agentId'] ? body['agentId'] : null;
+        if (agentId && !listRegisteredAgents().includes(agentId))
+            throw new HttpError(400, `unknown agent: ${agentId}`);
+        patch.agentId = agentId;
+    }
+    if ('presetId' in body)
+        patch.presetId = typeof body['presetId'] === 'string' && body['presetId'] ? body['presetId'] : null;
+    await setSelection(chatId, patch);
+    return { selection: await getSelection(chatId) };
+}

package/dist/runtime/chain-store.d.ts

@@ -1,4 +1,5 @@
 import { type ThreadChat, type StoredMsg } from '@coffer-org/server/thread-store';
+import { type ThreadSelection } from '@coffer-org/server/thread-state';
 import type { ConvMessage } from '@coffer-org/plugin-orchestrator/runtime';
 export declare const CONNECTOR = "webchat";
 export declare function chatIdFor(userId: string, convId: string): string;
@@ -32,3 +33,7 @@ export declare function buildChain(headMsgId: string, opts: {
 }): Promise<ConvMessage[]>;
 export declare function history(chatId: string, limit?: number): Promise<StoredMsg[]>;
 export declare function conversations(userId: string): Promise<ThreadChat[]>;
+export type { ThreadSelection };
+export declare function getSelection(chatId: string): Promise<ThreadSelection>;
+export declare function setSelection(chatId: string, patch: Partial<ThreadSelection>): Promise<void>;
+export declare function readSelectionForTurn(chatId: string): Promise<ThreadSelection>;

package/dist/runtime/chain-store.js

@@ -1,4 +1,5 @@
-import { getThreadMessage, putThreadMessage, listThreadMessages, listThreadChats } from '@coffer-org/server/thread-store';
+import { getThreadMessage, putThreadMessage, listThreadMessages, listThreadChats, } from '@coffer-org/server/thread-store';
+import { getThreadState, setThreadState, readAndTouchThreadState, } from '@coffer-org/server/thread-state';
 import { getLogger } from '@coffer-org/sdk/logger';
 const log = getLogger('webchat');
 export const CONNECTOR = 'webchat';
@@ -25,7 +26,15 @@ export async function recordUser(m) {
 export async function recordAssistant(m) {
     if (m.botMsgId == null || !m.text.trim())
         return false;
-    await putThreadMessage({ connector: CONNECTOR, chatId: m.chatId, msgId: m.botMsgId, role: 'assistant', text: m.text, ts: m.now, replyToId: m.parentMsgId });
+    await putThreadMessage({
+        connector: CONNECTOR,
+        chatId: m.chatId,
+        msgId: m.botMsgId,
+        role: 'assistant',
+        text: m.text,
+        ts: m.now,
+        replyToId: m.parentMsgId,
+    });
     return true;
 }
 export async function recordReasoning(m) {
@@ -76,3 +85,12 @@ export function history(chatId, limit) {
 export function conversations(userId) {
     return listThreadChats(CONNECTOR, chatPrefixFor(userId));
 }
+export async function getSelection(chatId) {
+    return getThreadState(CONNECTOR, chatId);
+}
+export async function setSelection(chatId, patch) {
+    await setThreadState(CONNECTOR, chatId, patch);
+}
+export async function readSelectionForTurn(chatId) {
+    return readAndTouchThreadState(CONNECTOR, chatId);
+}

package/dist/runtime/connector.js

@@ -11,8 +11,13 @@ export function makeStreamingConnector(opts) {
         reply(_chatId, _ctx) {
             const ch = makeLiveChannel({
                 ops: {
-                    send: async (text) => { opts.emit('message', { msgId: opts.botMsgId, text }); return opts.botMsgId; },
-                    edit: async (msgId, text) => { opts.emit('delta', { msgId, text }); },
+                    send: async (text) => {
+                        opts.emit('message', { msgId: opts.botMsgId, text });
+                        return opts.botMsgId;
+                    },
+                    edit: async (msgId, text) => {
+                        opts.emit('delta', { msgId, text });
+                    },
                 },
                 throttleMs: WEBCHAT_THROTTLE_MS,
                 maxLength: WEBCHAT_MAX,
@@ -29,10 +34,22 @@ export function makeStreamingConnector(opts) {
         },
         async recordAssistant(m) {
             const now = Math.floor(Date.now() / 1000);
-            const wrote = await record({ chatId: opts.chatId, parentMsgId: m.parentMsgId, botMsgId: m.botMsgId, text: m.text, now });
+            const wrote = await record({
+                chatId: opts.chatId,
+                parentMsgId: m.parentMsgId,
+                botMsgId: m.botMsgId,
+                text: m.text,
+                now,
+            });
             recordedId = wrote ? m.botMsgId : null;
             if (wrote && opts.display !== 'off' && m.reasoning && m.botMsgId) {
-                await recordReasoningFn({ chatId: opts.chatId, botMsgId: m.botMsgId, parentMsgId: m.parentMsgId, text: m.reasoning, now });
+                await recordReasoningFn({
+                    chatId: opts.chatId,
+                    botMsgId: m.botMsgId,
+                    parentMsgId: m.parentMsgId,
+                    text: m.reasoning,
+                    now,
+                });
             }
         },
     };

package/dist/runtime/index.d.ts

@@ -2,6 +2,6 @@ import type { PluginHooks } from '@coffer-org/server/plugin-hooks';
 export type { ThreadSummary, HistoryMsg } from './actions.ts';
 export { WEB_FORMAT } from './format.ts';
 export { makeStreamingConnector } from './connector.ts';
-export { chatIdFor, chatPrefixFor, recordUser, recordAssistant, buildChain } from './chain-store.ts';
+export { chatIdFor, chatPrefixFor, recordUser, recordAssistant, buildChain, getSelection, setSelection, } from './chain-store.ts';
 export { sendAction, pageContext } from './send.ts';
 export declare const serverHooks: PluginHooks;

package/dist/runtime/index.js

@@ -1,5 +1,6 @@
 import { pruneThreadMessages } from '@coffer-org/server/thread-store';
-import { threadsAction, historyAction } from "./actions.js";
+import { pruneThreadState } from '@coffer-org/server/thread-state';
+import { threadsAction, historyAction, agentsAction, selectAgentAction } from "./actions.js";
 import { sendAction } from "./send.js";
 import { CONNECTOR } from "./chain-store.js";
 import { registerConnector } from '@coffer-org/plugin-orchestrator/runtime';
@@ -7,14 +8,21 @@ const THREAD_TTL_MS = Number(process.env['WEBCHAT_THREAD_TTL_MS'] ?? 30 * 86_400
 let unregisterConnector;
 export { WEB_FORMAT } from "./format.js";
 export { makeStreamingConnector } from "./connector.js";
-export { chatIdFor, chatPrefixFor, recordUser, recordAssistant, buildChain } from "./chain-store.js";
+export { chatIdFor, chatPrefixFor, recordUser, recordAssistant, buildChain, getSelection, setSelection, } from "./chain-store.js";
 export { sendAction, pageContext } from "./send.js";
 export const serverHooks = {
-    init: () => { unregisterConnector = registerConnector({ id: 'webchat' }); },
-    teardown: () => { unregisterConnector?.(); unregisterConnector = undefined; },
+    init: () => {
+        unregisterConnector = registerConnector({ id: 'webchat' });
+    },
+    teardown: () => {
+        unregisterConnector?.();
+        unregisterConnector = undefined;
+    },
     userActions: {
         threads: threadsAction,
         history: historyAction,
+        agents: agentsAction,
+        selectAgent: selectAgentAction,
     },
     streamActions: {
         send: (body, ctx) => sendAction(body, ctx),
@@ -24,7 +32,9 @@ export const serverHooks = {
             name: 'webchat-thread-prune',
             intervalMs: 86_400_000,
             run: async () => {
-                await pruneThreadMessages(CONNECTOR, Math.floor((Date.now() - THREAD_TTL_MS) / 1000));
+                const cutoff = new Date(Date.now() - THREAD_TTL_MS);
+                await pruneThreadMessages(CONNECTOR, Math.floor(cutoff.getTime() / 1000));
+                await pruneThreadState(CONNECTOR, cutoff.toISOString());
             },
         },
     ],

package/dist/runtime/send.js

@@ -1,6 +1,6 @@
 import { randomUUID } from 'node:crypto';
-import { handleIncoming } from '@coffer-org/plugin-orchestrator/runtime';
-import { chatIdFor, recordUser, buildChain, history } from "./chain-store.js";
+import { handleIncoming, liveAgentId } from '@coffer-org/plugin-orchestrator/runtime';
+import { chatIdFor, recordUser, buildChain, history, readSelectionForTurn } from "./chain-store.js";
 import { policy } from "./config.js";
 import { makeStreamingConnector } from "./connector.js";
 import { WEB_FORMAT } from "./format.js";
@@ -31,6 +31,8 @@ export async function sendAction(body, ctx, deps = {}) {
         return;
     }
     const chatId = chatIdFor(ctx.caller.id, convId);
+    const selection = await readSelectionForTurn(chatId);
+    const agentId = liveAgentId(selection.agentId);
     const msgId = randomUUID();
     const botMsgId = randomUUID();
     const nowSec = Math.floor(Date.now() / 1000);
@@ -50,6 +52,8 @@ export async function sendAction(body, ctx, deps = {}) {
         connectorId: 'webchat',
         channelSystem: WEB_FORMAT,
         ...(volatileSystem ? { volatileSystem } : {}),
+        ...(agentId ? { agentId } : {}),
+        ...(selection.presetId ? { presetId: selection.presetId } : {}),
         chatId,
         sender: { id: ctx.caller.id },
         messages,
@@ -65,12 +69,14 @@ function parseAttachments(value) {
         const r = item;
         if (typeof r['name'] !== 'string' || !r['name'])
             return [];
-        return [{
+        return [
+            {
                 name: r['name'],
                 ...(typeof r['mime'] === 'string' ? { mime: r['mime'] } : {}),
                 ...(typeof r['size'] === 'number' ? { size: r['size'] } : {}),
                 ...(typeof r['label'] === 'string' ? { label: r['label'] } : {}),
-            }];
+            },
+        ];
     });
     return refs.length ? refs : undefined;
 }

package/dist/schema.js

@@ -4502,6 +4502,8 @@ function normalizeOpts(rawIn) {
 		unique: r.unique,
 		fixed: r.fixed,
 		exts: r.exts,
+		ext: r.ext,
+		maxBytes: r.maxBytes,
 		lead: r.lead,
 		by: r.by,
 		min: r.min,
@@ -4913,6 +4915,42 @@ function snippet(raw) {
 		}
 	});
 }
+/** A NUL byte, or U+FFFD left behind by decoding non-UTF-8 bytes as text. */
+function isBinaryText(v) {
+	return v.includes("\0") || v.includes("�");
+}
+function source(raw) {
+	const o = normalizeOpts(raw);
+	const required = o.required ?? false;
+	const ext = o.ext ?? "txt";
+	const maxBytes = o.maxBytes ?? 262144;
+	const s = string$1(reqTypeErr()).superRefine((v, ctx) => {
+		if (isBinaryText(v)) {
+			ctx.addIssue({
+				code: ZodIssueCode.custom,
+				message: vmsg("source_binary")
+			});
+			return;
+		}
+		if (new TextEncoder().encode(v).length > maxBytes) ctx.addIssue({
+			code: ZodIssueCode.custom,
+			message: vmsg("source_too_large", { maxBytes })
+		});
+	});
+	return wrapKey(o, {
+		kind: "source",
+		label: o.label ?? "",
+		required,
+		prim: "text",
+		column: "text",
+		hints: {
+			ext,
+			maxBytes,
+			noEditControl: true
+		},
+		zod: optionalize(s, required)
+	});
+}
 function rating(raw) {
 	const o = normalizeOpts(raw);
 	const required = o.required ?? false;
@@ -5049,6 +5087,7 @@ var presets = {
 	tags,
 	markdown,
 	snippet,
+	source,
 	rating,
 	duration,
 	reminder,
@@ -6349,11 +6388,18 @@ function triState(raw) {
 		zod: optionalize(s, required)
 	});
 }
+/** Inline option entry → OptionItem (plain string = value and label at once). */
+function toOptionItem(o) {
+	return typeof o === "string" ? {
+		value: o,
+		title: o
+	} : o;
+}
 function select(raw) {
 	const o = normalizeOpts(raw);
 	const required = o.required ?? false;
 	const source = typeof o.options === "string" ? o.options : null;
-	const inlineOpts = Array.isArray(o.options) ? o.options : [];
+	const inlineOpts = Array.isArray(o.options) ? o.options.map(toOptionItem) : [];
 	const s = inlineOpts.length > 0 ? _enum(inlineOpts.map((x) => x.value), { error: () => vmsg("enum") }) : string$1(reqErr());
 	return wrapKey(o, applyMultiple({
 		kind: "select",

package/dist/web.js

@@ -11,7 +11,7 @@ import { definePluginUI } from "@coffer-org/web-sdk";
 var ui_default = definePluginUI({ slots: [{
 	slot: "overlay",
 	id: "webchat",
-	load: () => import("./ChatWidget-By7bmS3U.js")
+	load: () => import("./ChatWidget-BvI5pRWb.js")
 }] });
 //#endregion
 export { ui_default as default };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coffer-org/plugin-webchat",
-  "version": "2.2.6",
+  "version": "2.3.0",
   "type": "module",
   "engines": {
     "node": ">=24"
@@ -26,9 +26,9 @@
     "test:ui": "vitest run --root ."
   },
   "dependencies": {
-    "@coffer-org/plugin-orchestrator": "^2.3.3",
-    "@coffer-org/sdk": "^2.1.3",
-    "@coffer-org/server": "^2.5.2",
+    "@coffer-org/plugin-orchestrator": "^2.4.0",
+    "@coffer-org/sdk": "^2.2.1",
+    "@coffer-org/server": "^2.7.0",
     "react-markdown": "^10.1.0",
     "remark-gfm": "^4.0.1"
   },