@jini-ai/chat 0.6.21 → 0.6.22

package/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 0.6.22
+
+- The full CLI access notice shows once per conversation, also after replay or remount.
+- A validated extension renderer can declare that it shows a failed turn's explanation (`terminalNotice`); the generic notice stays when the renderer is absent or refuses the payload.
+
 ## 0.6.21
 
 - Per-chat memory churn stopped: run checkpoints are size-scaled (`checkpointIntervalMs({ bytes })`: 1 s, 3 s from 1 MB, 10 s from 5 MB) and written as guarded SQL deltas (append or text-tail splice under a length+tail receipt), falling back to a full checkpoint on mismatch. A completed checkpoint is never retried unchanged.

package/dist/react/components/MessageList.js

@@ -20,9 +20,9 @@ import { MessageRow } from './MessageRow.js';
 import { SentAttachmentButton } from './SentAttachment.js';
 import { AttachmentPreviewModal } from './AttachmentPreviewModal.js';
 import { useAttachmentGallery } from './AttachmentGallery.hooks.js';
-function renderMessageRow({ message, isLast, isStreaming, usageSummary, sending }, { activeQuestionFormMessageId, questionFormSubmittedAnswersByMessageId, onQuestionFormSubmit, ...rowProps } = {}) {
+function renderMessageRow({ message, isLast, isStreaming, usageSummary, sending, showAccessNotice }, { activeQuestionFormMessageId, questionFormSubmittedAnswersByMessageId, onQuestionFormSubmit, ...rowProps } = {}) {
     const runStreaming = isLast && isStreaming && !isTerminalRunStatus({ status: message.runStatus });
-    return (_jsx(MessageRow, { message: message, ...rowProps, ...(usageSummary === undefined ? {} : { usageSummary }), runStreaming: runStreaming, runSending: sending, runSucceeded: message.runStatus === 'succeeded', questionFormInteractive: message.id === activeQuestionFormMessageId, ...(questionFormSubmittedAnswersByMessageId?.[message.id] !== undefined ? { questionFormSubmittedAnswers: questionFormSubmittedAnswersByMessageId[message.id] } : {}), ...(onQuestionFormSubmit !== undefined ? { onQuestionFormSubmit: (text, answers) => onQuestionFormSubmit(message.id, text, answers) } : {}) }, message.id));
+    return (_jsx(MessageRow, { message: message, ...rowProps, showAccessNotice: showAccessNotice, ...(usageSummary === undefined ? {} : { usageSummary }), runStreaming: runStreaming, runSending: sending, runSucceeded: message.runStatus === 'succeeded', questionFormInteractive: message.id === activeQuestionFormMessageId, ...(questionFormSubmittedAnswersByMessageId?.[message.id] !== undefined ? { questionFormSubmittedAnswers: questionFormSubmittedAnswersByMessageId[message.id] } : {}), ...(onQuestionFormSubmit !== undefined ? { onQuestionFormSubmit: (text, answers) => onQuestionFormSubmit(message.id, text, answers) } : {}) }, message.id));
 }
 /**
  * Memoized: the pane re-renders on every composer keystroke, and re-rendering a long transcript
@@ -33,9 +33,13 @@ function renderMessageRow({ message, isLast, isStreaming, usageSummary, sending
 export const MessageList = memo(function MessageList({ messages: sourceMessages, isStreaming = false, scrollIntent = false, onScrolled, pendingPrompt, pendingPrompts, ...rowProps }) {
     const messages = useMemo(() => projectAcceptedInputMessages({ messages: sourceMessages }), [sourceMessages]);
     const usageByMessage = useConversationUsage({ messages });
+    // Derive from the conversation's saved events, so replay/remount does not repeat the notice.
+    const accessNoticeId = useMemo(() => messages.find(message => message.role === 'assistant'
+        && message.events?.some(event => event.kind === 'status' && event.label === 'full_cli_access' && event.detail))?.id, [messages]);
     const { containerRef, onScroll, awayFromLatest, jumpToLatest } = useMessageListAutoScroll({ messages, scrollIntent }, onScrolled !== undefined ? { onScrolled } : {});
     return (_jsxs("div", { className: "jini-message-list", ref: containerRef, onScroll: onScroll, "data-agent-element": "chat-transcript", "data-agent-role": "list", "data-agent-label": "The conversation transcript, oldest message first", children: [messages.map((message, index) => renderMessageRow({
                 message,
+                showAccessNotice: message.id === accessNoticeId,
                 isLast: message.id === messages[messages.length - 1]?.id,
                 // A reply's start is accepted together with its user turn (`inputPending` clears then).
                 // A run id also proves acceptance after reload, when a legacy pending flag can survive.

package/dist/react/components/MessageRow.d.ts

@@ -54,6 +54,8 @@ import type { ChatAttachment, ChatMessage } from '../../core/index.js';
 import { type ToolCallDisplay } from '../tool-call-display.js';
 export interface MessageRowProps {
     message: ChatMessage;
+    /** Conversation hosts show the first access status only; standalone rows retain it by default. */
+    showAccessNotice?: boolean;
     /** Per-turn charge and prefix total derived from the complete conversation's persisted events. */
     usageSummary?: ChatUsageSummary;
     /** Append the chat's running total as of each reply ("· total $3.95") to its Done line. On by default

package/dist/react/components/MessageRow.js

@@ -147,7 +147,7 @@ function RunAccessNotice({ events }) {
     const notice = events?.find(event => event.kind === 'status' && event.label === 'full_cli_access');
     if (notice?.kind !== 'status' || !notice.detail)
         return null;
-    return _jsx("div", { className: "jini-chat-pane__notice", role: "note", children: t(notice.detail) });
+    return _jsx("div", { className: "jini-chat-pane__notice", role: "status", children: t(notice.detail) });
 }
 function ThinkingBlock({ text }) {
     const t = useT();
@@ -187,13 +187,16 @@ function UserMessageRow({ message, renderAttachment }) {
     const gallery = useAttachmentGallery({ attachments: message.attachments ?? NO_ATTACHMENTS });
     return (_jsxs("div", { className: "jini-message jini-message-user", "data-message-id": message.id, "data-agent-element": `chat-message-${message.id}`, "data-agent-role": "region", "data-agent-label": "A message from the user", children: [(message.attachments?.length || message.folders?.length) ? (_jsxs("div", { className: "jini-message-attachments", children: [_jsx(FolderChips, { folders: message.folders }), (message.attachments ?? []).map((a) => (_jsx(SentAttachmentButton, { attachment: a, onOpen: gallery.open, renderAttachment: renderAttachment }, a.path)))] })) : null, _jsx("div", { className: "jini-message-content", children: message.content }), _jsx("div", { className: "jini-message-actions jini-message-actions--user", children: _jsx(CopyMessageButton, { text: message.content, label: t('Copy message') }) }), gallery.opened ? (_jsx(AttachmentPreviewModal, { attachment: gallery.opened, onClose: gallery.close, navigation: gallery.navigation })) : null] }));
 }
-function AssistantMessageRow({ message, usageSummary, showUsageTotal, showUsageLine, toolCallDisplay, showThinking, runStreaming, runSending, sendingLabel, runSucceeded, questionFormInteractive, questionFormSubmittedAnswers, onQuestionFormSubmit, projectFileNames, onRequestOpenFile, }) {
+function AssistantMessageRow({ showAccessNotice = true, message, usageSummary, showUsageTotal, showUsageLine, toolCallDisplay, showThinking, runStreaming, runSending, sendingLabel, runSucceeded, questionFormInteractive, questionFormSubmittedAnswers, onQuestionFormSubmit, projectFileNames, onRequestOpenFile, }) {
     const registry = useExtEventRendererRegistry();
     const messageUsage = useMessageUsage({ message, ...(usageSummary === undefined ? {} : { summary: usageSummary }) });
     const timeline = useToolTimeline({ events: message.events }, { runStreaming, runSucceeded });
     const extGroups = useExtEventGroups({ events: message.events }, { slotOf: (name, data) => registry.slot({ name, data }) });
     const answeredCards = useAnsweredCards({ slotOf: registry.slot, events: message.events ?? [], groups: extGroups, runStreaming, runStatus: message.runStatus });
-    const terminalNotice = terminalMessageNotice({ message }, {});
+    // A validated extension may already show the explanation. Keep the generic fallback when its
+    // renderer is absent or refuses the payload, so malformed history never hides a failed turn.
+    const extensionExplainsFailure = !runStreaming && !runSucceeded && extGroups.some(group => registry.hasTerminalNotice(group));
+    const terminalNotice = extensionExplainsFailure ? null : terminalMessageNotice({ message }, {});
     const visibleContent = stripArtifact({ content: message.content });
     const displayBlocks = messageBlocks({ message, rows: timeline.rows, registry }, { toolCallDisplay, includeThinking: showThinking });
     // Artifact stripping trims/replaces text, invalidating the event offsets for rendering. Keep the
@@ -286,11 +289,11 @@ function AssistantMessageRow({ message, usageSummary, showUsageTotal, showUsageL
     // in their original receipt order, outside the assistant's actions and usage footer.
     // Keep the same child-array nesting as the interleaved path so React preserves the footer.
     if (blocks === null)
-        return _jsxs(_Fragment, { children: [_jsx(RunAccessNotice, { events: message.events }), [renderAssistantSection({ section: null, key: message.id, footer: true })], extGroups.filter(group => group.name === MID_RUN_USER_MESSAGE_EXT_EVENT_NAME).map(renderExtGroup)] });
+        return _jsxs(_Fragment, { children: [showAccessNotice && _jsx(RunAccessNotice, { events: message.events }), [renderAssistantSection({ section: null, key: message.id, footer: true })], extGroups.filter(group => group.name === MID_RUN_USER_MESSAGE_EXT_EVENT_NAME).map(renderExtGroup)] });
     // A reply boundary without reported usage renders nothing; it must not create an empty row's gap.
     const visibleBlocks = blocks.filter(block => block.kind !== 'reply-end' || (showUsageLine && usage.replies[block.index] !== undefined));
     const { sections, footerIndex } = transcriptSections({ blocks: visibleBlocks, runInProgress });
-    return _jsxs(_Fragment, { children: [_jsx(RunAccessNotice, { events: message.events }), sections.map((section, index) => isUserSection({ section })
+    return _jsxs(_Fragment, { children: [showAccessNotice && _jsx(RunAccessNotice, { events: message.events }), sections.map((section, index) => isUserSection({ section })
                 ? _jsx(React.Fragment, { children: section.map(renderBlock) }, section[0].key)
                 : renderAssistantSection({ section, key: section[0]?.key ?? message.id, footer: index === footerIndex }))] });
 }

package/dist/react/ext-event-renderer-registry.d.ts

@@ -97,6 +97,10 @@ export type ExtEventSlotKey = (required: {
 export interface ExtEventRendererOptions {
     /** See {@link ExtEventSlotKey}. Omit for one shared slot per `name`. */
     slotKey?: ExtEventSlotKey;
+    /** True only when the renderer will show the terminal explanation for these validated events. */
+    terminalNotice?: (required: {
+        events: readonly unknown[];
+    }) => boolean;
 }
 /** Owned renderer and slot-key state for one chat tree. */
 export interface ExtEventRendererRegistry {
@@ -111,6 +115,10 @@ export interface ExtEventRendererRegistry {
         name: string;
         data: unknown;
     }): string;
+    hasTerminalNotice(required: {
+        name: string;
+        events: readonly unknown[];
+    }): boolean;
     clear(): void;
 }
 /** Create independent extension renderer state, including each protocol's slot grouping.

package/dist/react/ext-event-renderer-registry.js

@@ -10,7 +10,7 @@ export function createExtEventRendererRegistry(_required = {}) {
      * can dispose cleanly. Re-registering the same name overwrites — last writer wins.
      */
     function register({ name, renderer }, options = {}) {
-        const entry = { renderer, slotKey: options.slotKey };
+        const entry = { renderer, slotKey: options.slotKey, terminalNotice: options.terminalNotice };
         renderers.set(name, entry);
         return () => {
             if (renderers.get(name) === entry)
@@ -20,6 +20,17 @@ export function createExtEventRendererRegistry(_required = {}) {
     function get({ name }) {
         return renderers.get(name)?.renderer;
     }
+    /** Let a registered, validated explanation own the terminal surface; failures retain the fallback.
+     * @complexity O(1) registry lookup plus the host's validation; no effects.
+     */
+    function hasTerminalNotice({ name, events }) {
+        try {
+            return renderers.get(name)?.terminalNotice?.({ events }) === true;
+        }
+        catch {
+            return false;
+        }
+    }
     /**
      * The render slot an ext event belongs to: its `name`, or `name:key` when the name's renderer was
      * registered with a {@link ExtEventSlotKey} that recognizes this event. A throwing key function
@@ -42,7 +53,7 @@ export function createExtEventRendererRegistry(_required = {}) {
     }
     /** Visible mainly for tests. */
     function clear() { renderers.clear(); }
-    return { register, get, slot, clear };
+    return { register, get, slot, hasTerminalNotice, clear };
 }
 /** Compatibility default for hosts that have not supplied owned state. */
 export const defaultExtEventRendererRegistry = createExtEventRendererRegistry({});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jini-ai/chat",
-  "version": "0.6.21",
+  "version": "0.6.22",
   "description": "Jini's chat/artifact frontend, consolidated into one package with two subpaths: framework-free chat vocabulary and pure parsers in `/core`, headless hooks + presentational components + slots in `/react`. Import only the layer you need.",
   "license": "Apache-2.0",
   "repository": {
@@ -214,9 +214,9 @@
   },
   "dependencies": {
     "kysely": "^0.29.6",
-    "@jini-ai/core": "^0.6.21",
-    "@jini-ai/diagnostics": "^0.6.19",
+    "@jini-ai/core": "^0.6.22",
     "@jini-ai/agentic": "^0.6.19",
+    "@jini-ai/diagnostics": "^0.6.22",
     "@jini-ai/db": "^0.6.19"
   },
   "peerDependencies": {
@@ -261,13 +261,13 @@
     "pg": "8.23.0",
     "@ag-ui/core": "0.0.58",
     "fast-check": "4.3.0",
+    "@jini-ai/agent-runtime": "0.6.22",
     "@jini-ai/agentic": "^0.6.19",
-    "@jini-ai/core": "^0.6.21",
-    "@jini-ai/agent-runtime": "0.6.19",
-    "@jini-ai/diagnostics": "^0.6.19",
-    "@jini-ai/db": "0.6.19",
     "@jini-ai/protocol": "^0.6.19",
-    "@jini-ai/ui": "^0.6.19"
+    "@jini-ai/core": "^0.6.22",
+    "@jini-ai/diagnostics": "^0.6.22",
+    "@jini-ai/ui": "^0.6.22",
+    "@jini-ai/db": "0.6.19"
   },
   "typesVersions": {
     "*": {