@micha.bigler/ui-core-micha 4.2.0 → 4.3.0

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## 4.3.0 - UCM-CHAT-5
+
+`ChatWorkspace` gets three optional props; without them it behaves as in 4.2.x. `getSendContext()` (synchronous, no
+arguments) is called once per `send` frame, right before it is sent, for every route: the composer, `send(text)` from
+the answer slot, `sendRequest` and the retry of a failed turn. A plain object is sent as `context` on the frame
+(`{ type: 'send', message, context }`, read by `django-core-micha` 3.3.0, DCM-CHAT-11); `undefined` or `null` sends no
+`context`; anything else, or a thrown error, sends nothing, keeps the draft and shows the generic action-error notice
+(a failed retry also keeps the failed turn on screen). The surface does not interpret or size-check the context; the core
+answers `invalid_frame` for a bad or oversized one. The context never appears in the displayed turn text.
+`sendRequest` (`{ id, text }`) sends `text` as the next message of the shown chat, like a typed send including
+`getSendContext`. Each new `id` is handled once; with no chat shown, an archived chat, no connection, a running turn,
+blank text or `activeChatId` `null` it is not sent. A request that arrives together with an `activeChatId` switch waits
+for that chat. `onSendRequestHandled({ id, sent })` is called once per request so a host can fall back to
+`composerPrefill` when `sent` is `false`. Give every request a fresh `id` (a counter); an `id` that was answered earlier
+is treated as the same request and ignored.
+
 ## 4.2.0 - UCM-CHAT-4
 
 `ChatWorkspace` takes two optional props so a host can control which chat is shown. `activeChatId` shows that chat

package/README.md

@@ -44,3 +44,12 @@ The main entry needs only the required peers. Charts, the chat surface and `Mark
 extra peers are optional: `@micha.bigler/ui-core-micha/charts` (`@mui/x-charts`), `/chat` and `/markdown`
 (`react-markdown`, `remark-gfm`). Install those peers only in apps that import the sub-path. The 4.0.0 entry in
 `CHANGELOG.md` has the migration table.
+
+## Shared chat: host controls
+
+`ChatWorkspace` (from `@micha.bigler/ui-core-micha/chat`) takes optional props for apps that put UI around the surface;
+without them it behaves as before. Each is described in `CHANGELOG.md` under the release that added it.
+Since 4.3.0: `getSendContext()` (a plain object attached as `context` to every `send` frame, read by
+`django-core-micha` 3.3.0), `sendRequest` (`{ id, text }`, sends a message on the host's behalf) and
+`onSendRequestHandled({ id, sent })`. Since 4.2.0: `activeChatId`, `onActiveChatChange`, `composerPrefill` and
+`send(text)` / `canSend` in `renderAnswerExtra`.

package/dist/chat/ChatWorkspace.js

@@ -9,6 +9,26 @@ import ChatThread from './ChatThread';
 import ChatComposer from './ChatComposer';
 import ModelPicker from './ModelPicker';
 const PENDING_ID = 'pending';
+const buildSendFrame = (message, getContext) => {
+    if (typeof getContext !== 'function')
+        return { frame: { type: 'send', message } };
+    try {
+        const context = getContext();
+        if (context == null)
+            return { frame: { type: 'send', message } };
+        if (typeof context !== 'object' || Array.isArray(context))
+            return { error: true };
+        const prototype = Object.getPrototypeOf(context);
+        if (prototype !== Object.prototype && prototype !== null)
+            return { error: true };
+        if (typeof JSON.stringify(context) !== 'string')
+            return { error: true };
+        return { frame: { type: 'send', message, context } };
+    }
+    catch (_a) {
+        return { error: true };
+    }
+};
 const bySeq = (a, b) => { var _a, _b; return ((_a = a.seq) !== null && _a !== void 0 ? _a : Number.MAX_SAFE_INTEGER) - ((_b = b.seq) !== null && _b !== void 0 ? _b : Number.MAX_SAFE_INTEGER); };
 const chronological = (turns) => [...(turns || [])].sort(bySeq);
 const isGenerating = (turn) => turn.state === 'generating';
@@ -42,7 +62,7 @@ const appendDelta = (turns, text) => {
  * Props: `apiBase` and `wsUrl` (where the app mounted the chat routes), `api` (partial overrides of the REST
  * calls; every function not given keeps its default), `scope` (passed when creating a chat), `sx`.
  */
-export function ChatWorkspace({ apiBase, wsUrl, api: apiOverrides, scope, sx, unavailableReasonText, sidePanel, sidePanelLabel, renderAnswerExtra, renderComposerExtra, onAppFrame, activeChatId, onActiveChatChange, composerPrefill, layout = 'viewport', compactBelow = 720 }) {
+export function ChatWorkspace({ apiBase, wsUrl, api: apiOverrides, scope, sx, unavailableReasonText, sidePanel, sidePanelLabel, renderAnswerExtra, renderComposerExtra, onAppFrame, activeChatId, onActiveChatChange, composerPrefill, getSendContext, sendRequest, onSendRequestHandled, layout = 'viewport', compactBelow = 720 }) {
     const { t } = useTranslation();
     const theme = useTheme();
     const viewportNarrow = useMediaQuery(theme.breakpoints.down('md'));
@@ -78,6 +98,13 @@ export function ChatWorkspace({ apiBase, wsUrl, api: apiOverrides, scope, sx, un
     const [draft, setDraft] = useState('');
     const composerInputRef = useRef(null);
     const lastPrefillId = useRef(undefined);
+    const lastSendRequestId = useRef(undefined);
+    const deferredSendRequest = useRef(null); // `{ id, wanted }`: a request that had to wait for the chat named by `activeChatId`
+    const connectedChatId = useRef(null);
+    const getSendContextRef = useRef(getSendContext);
+    getSendContextRef.current = getSendContext;
+    const sendRequestHandledRef = useRef(onSendRequestHandled);
+    sendRequestHandledRef.current = onSendRequestHandled;
     const [focusRequest, setFocusRequest] = useState(0);
     const focusPending = useRef(false);
     const [problem, setProblem] = useState(null);
@@ -186,6 +213,7 @@ export function ChatWorkspace({ apiBase, wsUrl, api: apiOverrides, scope, sx, un
     }, [activeChatId, status, listsLoaded]);
     // Clear the previous chat's content before the browser paints, so a host-driven switch never flashes it under the new title.
     useLayoutEffect(() => {
+        connectedChatId.current = null; // the socket of the new chat has not opened yet
         setTurns([]);
         setOlderCursor(null);
         setTool(null);
@@ -239,8 +267,8 @@ export function ChatWorkspace({ apiBase, wsUrl, api: apiOverrides, scope, sx, un
                 setUnavailableReason(frame.reason || unavailableReason);
         }
     }, [chat === null || chat === void 0 ? void 0 : chat.id]);
-    const onOpen = useCallback(() => { setOpenedOnce(true); setProblem((current) => (current === 'connection_lost' ? null : current)); }, []);
-    const onClose = useCallback(({ reason, retrying }) => { if (!retrying)
+    const onOpen = useCallback((chatId) => { connectedChatId.current = String(chatId); setOpenedOnce(true); setProblem((current) => (current === 'connection_lost' ? null : current)); }, []);
+    const onClose = useCallback(({ reason, retrying }) => { connectedChatId.current = null; if (!retrying)
         setProblem(reason); }, []);
     const socket = useChatSocket(chat === null || chat === void 0 ? void 0 : chat.id, { wsUrl, onFrame, onOpen, onClose });
     useEffect(() => {
@@ -262,6 +290,53 @@ export function ChatWorkspace({ apiBase, wsUrl, api: apiOverrides, scope, sx, un
         focusPending.current = true;
         setFocusRequest((count) => count + 1);
     }, [composerPrefill, chat, isArchived, activeChatId]);
+    // Host send request, handled once per id. A request that arrives before the chat named by `activeChatId` is shown waits
+    // for that chat AND for its socket to open (sending needs a connected socket of that chat); a chat that cannot be found
+    // ends the wait. Every other request is decided at once. Decided = sent if the surface can send right now, otherwise
+    // reported as not sent.
+    useEffect(() => {
+        var _a;
+        const answerFor = (id, sent) => {
+            var _a, _b;
+            lastSendRequestId.current = id;
+            if (((_a = deferredSendRequest.current) === null || _a === void 0 ? void 0 : _a.id) === id)
+                deferredSendRequest.current = null;
+            (_b = sendRequestHandledRef.current) === null || _b === void 0 ? void 0 : _b.call(sendRequestHandledRef, { id, sent });
+        };
+        // A waiting request that the host replaced or withdrew is answered as not sent, exactly once.
+        const waiting = deferredSendRequest.current;
+        if (waiting && waiting.id !== (sendRequest === null || sendRequest === void 0 ? void 0 : sendRequest.id))
+            answerFor(waiting.id, false);
+        if (sendRequest == null || sendRequest.id === lastSendRequestId.current)
+            return;
+        const answer = (sent) => answerFor(sendRequest.id, sent);
+        const blank = typeof sendRequest.text !== 'string' || !sendRequest.text.trim();
+        if (activeChatId === null || blank) {
+            answer(false);
+            return;
+        }
+        const wanted = activeChatId === undefined ? null : String(activeChatId);
+        const deferred = ((_a = deferredSendRequest.current) === null || _a === void 0 ? void 0 : _a.id) === sendRequest.id ? deferredSendRequest.current : null;
+        // The host named another chat while the request was waiting: it belonged to the earlier one, so it is not sent.
+        if (deferred && deferred.wanted !== wanted) {
+            answer(false);
+            return;
+        }
+        if (wanted !== null && !unloadableIds.current.has(wanted)) {
+            if (String(chat === null || chat === void 0 ? void 0 : chat.id) !== wanted) {
+                deferredSendRequest.current = { id: sendRequest.id, wanted };
+                return;
+            }
+            // Only a request that could be sent once connected is worth waiting for.
+            if (deferred && connectedChatId.current !== wanted && !isArchived && !running)
+                return;
+        }
+        const text = sendRequest.text;
+        const sent = Boolean(canSendRef.current && typeof text === 'string' && text.trim() && startTurn(text));
+        if (sent)
+            canSendRef.current = false;
+        answer(sent);
+    }, [sendRequest, chat, activeChatId, socket.connected, running]);
     // Runs after the render that carries the prefilled draft; a counter, so the same text requested twice focuses twice.
     // A disabled input (connection down) cannot take focus, so the request stays pending until it is enabled again.
     useEffect(() => {
@@ -319,7 +394,12 @@ export function ChatWorkspace({ apiBase, wsUrl, api: apiOverrides, scope, sx, un
         }
     });
     const startTurn = (message) => {
-        if (!socket.send({ type: 'send', message }))
+        const built = buildSendFrame(message, getSendContextRef.current);
+        if (built.error) {
+            setProblem('action_error');
+            return false;
+        }
+        if (!socket.send(built.frame))
             return false;
         setProblem(null);
         setTurns((current) => [...current, {
@@ -349,8 +429,8 @@ export function ChatWorkspace({ apiBase, wsUrl, api: apiOverrides, scope, sx, un
     const retry = (turn) => {
         if (!socket.connected)
             return;
-        setTurns((current) => current.filter((item) => item.id !== turn.id));
-        startTurn(turn.user_text);
+        if (startTurn(turn.user_text))
+            setTurns((current) => current.filter((item) => item.id !== turn.id));
     };
     const noticeFor = () => {
         const texts = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@micha.bigler/ui-core-micha",
-  "version": "4.2.0",
+  "version": "4.3.0",
   "main": "dist/index.js",
   "module": "dist/index.js",
   "exports": {