@jini-ai/chat 0.5.3 → 0.5.5

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

@@ -1,5 +1,6 @@
+import type { UserTextRedactionOptions } from '../../core/user-text-redaction.js';
 import type { QuestionForm as QuestionFormType } from '../../core/index.js';
-export interface QuestionsPanelProps {
+export interface QuestionsPanelProps extends UserTextRedactionOptions {
     form: QuestionFormType | null;
     interactive: boolean;
     /** Disables Continue/Skip while the turn is busy, without locking the form itself. */
@@ -9,5 +10,5 @@ export interface QuestionsPanelProps {
     generating?: boolean;
     onSubmit: (text: string, answers: Record<string, string | string[]>) => void;
 }
-export declare function QuestionsPanel({ form, interactive, submitDisabled, submittedAnswers, generating, onSubmit }: QuestionsPanelProps): import("react").JSX.Element | null;
+export declare function QuestionsPanel({ form, interactive, submitDisabled, submittedAnswers, generating, onSubmit, redactUserText, onSecretRedacted }: QuestionsPanelProps): import("react").JSX.Element | null;
 //# sourceMappingURL=QuestionsPanel.d.ts.map

package/dist/react/components/QuestionsPanel.js

@@ -20,7 +20,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useRef, useState } from 'react';
 import { useT } from '../hooks/context.js';
 import { QuestionForm } from './QuestionForm.js';
-export function QuestionsPanel({ form, interactive, submitDisabled = false, submittedAnswers, generating = false, onSubmit }) {
+export function QuestionsPanel({ form, interactive, submitDisabled = false, submittedAnswers, generating = false, onSubmit, redactUserText, onSecretRedacted }) {
     const t = useT();
     const formRef = useRef(null);
     const [ready, setReady] = useState(false);
@@ -28,6 +28,6 @@ export function QuestionsPanel({ form, interactive, submitDisabled = false, subm
         return null;
     const answered = submittedAnswers !== undefined;
     const busy = submitDisabled || generating;
-    return (_jsxs("div", { className: "qp-panel", children: [_jsx(QuestionForm, { ref: formRef, form: form, interactive: interactive, ...(submittedAnswers !== undefined ? { submittedAnswers } : {}), hideInternalSubmit: true, onReadyChange: setReady, onSubmit: onSubmit }), !answered ? (_jsxs("div", { className: "qp-foot", children: [generating ? _jsx("span", { className: "qp-hint", children: t('Still generating…') }) : null, _jsx("button", { type: "button", className: "qp-skip", disabled: busy, onClick: () => formRef.current?.skipAll(), children: t('Skip') }), _jsx("button", { type: "button", className: "qp-continue primary", disabled: busy || !ready, onClick: () => formRef.current?.submit(), children: t('Continue') })] })) : null] }));
+    return (_jsxs("div", { className: "qp-panel", children: [_jsx(QuestionForm, { ref: formRef, form: form, interactive: interactive, ...(submittedAnswers !== undefined ? { submittedAnswers } : {}), hideInternalSubmit: true, ...(redactUserText ? { redactUserText } : {}), ...(onSecretRedacted ? { onSecretRedacted } : {}), onReadyChange: setReady, onSubmit: onSubmit }), !answered ? (_jsxs("div", { className: "qp-foot", children: [generating ? _jsx("span", { className: "qp-hint", children: t('Still generating…') }) : null, _jsx("button", { type: "button", className: "qp-skip", disabled: busy, onClick: () => formRef.current?.skipAll(), children: t('Skip') }), _jsx("button", { type: "button", className: "qp-continue primary", disabled: busy || !ready, onClick: () => formRef.current?.submit(), children: t('Continue') })] })) : null] }));
 }
 //# sourceMappingURL=QuestionsPanel.js.map

package/dist/react/features/chat-pane/agent-tools.d.ts

@@ -1,4 +1,4 @@
-import { type CapabilityDef, type CapabilityInputSchema, type CapabilityRisk } from '@jini-ai/agentic';
+import type { CapabilityDef, CapabilityInputSchema, CapabilityRisk } from '@jini-ai/agentic';
 /** @deprecated Use `CapabilityRisk` from `@jini-ai/agentic`. */
 export type ChatPaneAgentToolRisk = CapabilityRisk;
 /** @deprecated Use `CapabilityInputSchema` from `@jini-ai/agentic`. */

package/dist/react/features/chat-pane/agent-tools.js

@@ -12,7 +12,6 @@
  * `@jini-ai/agentic` directly.
  */
 import { CHAT_CAPABILITIES } from '@jini-ai/chat';
-import {} from '@jini-ai/agentic';
 /**
  * The bounded, explicit set of chat-pane capabilities every transport surface hosts.
  *

package/dist/react/features/chat-pane/components/AgentRuntimePicker.js

@@ -1,4 +1,5 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { pickerModelValue, pickerCatalogNote, pickerModelOptions } from '../model-options.js';
 import { createPortal } from 'react-dom';
 import { AgentIcon, RemixIcon, SearchableModelSelect } from '@jini-ai/ui';
 import { useT } from '../../../hooks/context.js';
@@ -30,11 +31,13 @@ function RuntimeAgentList({ orderedAgents, value, onChange, agentIconBasePath, t
 function RuntimeModelSelects({ selectedAgent, value, onChange, t }) {
     if (!selectedAgent)
         return null;
-    return (_jsxs("div", { className: "jini-runtime-models", children: [(selectedAgent.models?.length ?? 0) > 0 ? (_jsxs("label", { className: "jini-runtime-select", children: [_jsx("span", { children: t('Model') }), _jsx("select", { "aria-label": t('Model'), value: value.model ?? '', onChange: (event) => onChange({
+    const models = pickerModelOptions(selectedAgent);
+    const note = pickerCatalogNote(selectedAgent, t);
+    return (_jsxs("div", { className: "jini-runtime-models", children: [note ? _jsx("small", { children: note }) : null, models.length > 0 ? (_jsxs("label", { className: "jini-runtime-select", children: [_jsx("span", { children: t('Model') }), _jsxs("select", { "aria-label": t('Model'), value: pickerModelValue(selectedAgent, value.model), onChange: (event) => onChange({
                             agentId: value.agentId,
                             model: event.target.value,
                             ...(value.reasoning ? { reasoning: value.reasoning } : {}),
-                        }), children: selectedAgent.models?.map((model) => (_jsx("option", { value: model.id, children: model.label }, model.id))) })] })) : null, (selectedAgent.reasoningOptions?.length ?? 0) > 0 ? (_jsxs("label", { className: "jini-runtime-select", children: [_jsx("span", { children: t('Reasoning') }), _jsx("select", { "aria-label": t('Reasoning'), value: value.reasoning ?? '', onChange: (event) => onChange({
+                        }), children: [_jsx("option", { value: "", disabled: true, children: t('Choose model') }), models.map((model) => (_jsx("option", { value: model.id, children: model.label }, model.id)))] })] })) : null, (selectedAgent.reasoningOptions?.length ?? 0) > 0 ? (_jsxs("label", { className: "jini-runtime-select", children: [_jsx("span", { children: t('Reasoning') }), _jsx("select", { "aria-label": t('Reasoning'), value: value.reasoning ?? '', onChange: (event) => onChange({
                             agentId: value.agentId,
                             ...(value.model ? { model: value.model } : {}),
                             reasoning: event.target.value,

package/dist/react/features/chat-pane/components/ChatPane.d.ts

@@ -6,5 +6,5 @@ import type { ChatPaneProps } from '../types.js';
  * @complexity Time/space: O(n) in rendered messages, agents, and suggestions.
  * @overallScore 100/100
  */
-export declare function ChatPane({ transport, agents: injectedAgents, runtimeAccess, runtimeStatusPollMs, title, variant, initialMessages, conversationId, initialSelection, selection: controlledSelection, onSelectionChange, runContext, agentControl, onActivityChange, onMessagesChange, onRescanAgents, scanningAgents, daemonOnline, executionMode, apiModeAvailable, onExecutionModeChange, byokRuntime, onByokModelChange, initialDraft, validateAttachments, deliverTypedAnswer, composerHandle, placeholder, placeholders, suggestions, workingDirectory, initialWorkingDirectory, onChangeWorkingDirectory, workingDirectoryAccess, workingDirectoryControlPlacement, projectFileNames, uploadAttachments, attachmentAccept, disabled, runtimePickerPlacement, composerSlots, header, leadingAccessory, footer, className, style, }: ChatPaneProps): import("react").JSX.Element;
+export declare function ChatPane({ transport, agents: injectedAgents, runtimeAccess, runtimeStatusPollMs, title, variant, initialMessages, conversationId, initialSelection, selection: controlledSelection, onSelectionChange, runContext, agentControl, onActivityChange, onMessagesChange, redactUserText, onSecretRedacted, onRescanAgents, scanningAgents, daemonOnline, executionMode, apiModeAvailable, onExecutionModeChange, byokRuntime, onByokModelChange, initialDraft, composerHistoryScope, composerHistoryStorage, validateAttachments, deliverTypedAnswer, composerHandle, placeholder, placeholders, suggestions, workingDirectory, initialWorkingDirectory, onChangeWorkingDirectory, workingDirectoryAccess, workingDirectoryControlPlacement, projectFileNames, uploadAttachments, attachmentAccept, disabled, runtimePickerPlacement, composerSlots, header, leadingAccessory, footer, className, style, }: ChatPaneProps): import("react").JSX.Element;
 //# sourceMappingURL=ChatPane.d.ts.map

package/dist/react/features/chat-pane/components/ChatPane.js

@@ -1,4 +1,5 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { SECRET_REDACTED_NOTICE } from '../../../../core/user-text-redaction.js';
 import { useEffect, useRef } from 'react';
 import { WorkingDirPicker } from '@jini-ai/ui';
 import { Composer } from '../../../components/Composer.js';
@@ -73,8 +74,8 @@ function ChatPaneNoUsableCliMessage({ executionMode, apiModeAvailable, onExecuti
 }
 /** The pane's stack of mutually-independent error/status banners — each condition is its own
  * source of truth, so they are rendered as siblings rather than folded into one derived state. */
-function ChatPaneStatusMessages({ unavailable, scanningAgents, connectingAgents, executionMode, apiModeAvailable, onExecutionModeChange, conversationError, attachmentError, dropReadError, workingDirectoryError, workingDirectoryPending, workingDirectoryInvalid, runtimeInventoryError, typedAnswerNotice, onSendAsNewMessage, t, }) {
-    return (_jsxs(_Fragment, { children: [unavailable && connectingAgents ? (_jsx("div", { className: "jini-chat-pane__status", role: "status", children: t('Connecting to the assistant…') })) : unavailable && scanningAgents ? (_jsx("div", { className: "jini-chat-pane__status", role: "status", children: t('Loading available CLIs') })) : unavailable ? (_jsx(ChatPaneNoUsableCliMessage, { executionMode: executionMode, apiModeAvailable: apiModeAvailable, onExecutionModeChange: onExecutionModeChange, t: t })) : null, conversationError ? (_jsx("div", { className: "jini-chat-pane__error", role: "alert", children: conversationError.message })) : null, attachmentError ? (_jsx("div", { className: "jini-chat-pane__error", role: "alert", children: attachmentError.message })) : null, dropReadError ? (_jsx("div", { className: "jini-chat-pane__error", role: "alert", children: dropReadError })) : null, workingDirectoryError ? (_jsx("div", { className: "jini-chat-pane__error", role: "alert", children: workingDirectoryError.message })) : null, workingDirectoryPending ? (_jsx("div", { className: "jini-chat-pane__status", role: "status", children: t('Checking working directory…') })) : workingDirectoryInvalid ? (_jsx("div", { className: "jini-chat-pane__error", role: "alert", children: t('Working directory is unavailable.') })) : null, runtimeInventoryError && !connectingAgents ? (_jsx("div", { className: "jini-chat-pane__error", role: "alert", children: runtimeInventoryError.message })) : null, typedAnswerNotice ? (_jsxs("div", { className: "jini-chat-pane__error", role: "alert", children: [t(describeTypedAnswerNotice({ notice: typedAnswerNotice })), typedAnswerNotice === 'not-pending' ? (_jsxs(_Fragment, { children: [' ', _jsx("button", { type: "button", className: "jini-chat-pane__error-action", onClick: onSendAsNewMessage, children: t('Send as a new message') })] })) : null] })) : null] }));
+function ChatPaneStatusMessages({ unavailable, scanningAgents, connectingAgents, executionMode, apiModeAvailable, onExecutionModeChange, attachmentError, dropReadError, workingDirectoryError, workingDirectoryPending, workingDirectoryInvalid, runtimeInventoryError, typedAnswerNotice, onSendAsNewMessage, t, }) {
+    return (_jsxs(_Fragment, { children: [unavailable && connectingAgents ? (_jsx("div", { className: "jini-chat-pane__status", role: "status", children: t('Connecting to the assistant…') })) : unavailable && scanningAgents ? (_jsx("div", { className: "jini-chat-pane__status", role: "status", children: t('Loading available CLIs') })) : unavailable ? (_jsx(ChatPaneNoUsableCliMessage, { executionMode: executionMode, apiModeAvailable: apiModeAvailable, onExecutionModeChange: onExecutionModeChange, t: t })) : null, attachmentError ? (_jsx("div", { className: "jini-chat-pane__error", role: "alert", children: attachmentError.message })) : null, dropReadError ? (_jsx("div", { className: "jini-chat-pane__error", role: "alert", children: dropReadError })) : null, workingDirectoryError ? (_jsx("div", { className: "jini-chat-pane__error", role: "alert", children: workingDirectoryError.message })) : null, workingDirectoryPending ? (_jsx("div", { className: "jini-chat-pane__status", role: "status", children: t('Checking working directory…') })) : workingDirectoryInvalid ? (_jsx("div", { className: "jini-chat-pane__error", role: "alert", children: t('Working directory is unavailable.') })) : null, runtimeInventoryError && !connectingAgents ? (_jsx("div", { className: "jini-chat-pane__error", role: "alert", children: runtimeInventoryError.message })) : null, typedAnswerNotice ? (_jsxs("div", { className: "jini-chat-pane__error", role: "alert", children: [t(describeTypedAnswerNotice({ notice: typedAnswerNotice })), typedAnswerNotice === 'not-pending' ? (_jsxs(_Fragment, { children: [' ', _jsx("button", { type: "button", className: "jini-chat-pane__error-action", onClick: onSendAsNewMessage, children: t('Send as a new message') })] })) : null] })) : null] }));
 }
 function ChatPaneWorkingDirectoryBlock({ workingDirectoryAccess, workingDirectoryControlPlacement, pane, t, }) {
     if (workingDirectoryAccess && workingDirectoryControlPlacement === 'below') {
@@ -178,7 +179,7 @@ function ChatPaneComposerArea({ fileDrop, uploadAttachments, pane, disabled, una
  * @complexity Time/space: O(n) in rendered messages, agents, and suggestions.
  * @overallScore 100/100
  */
-export function ChatPane({ transport, agents: injectedAgents = EMPTY_AGENTS, runtimeAccess, runtimeStatusPollMs = 5_000, title, variant = 'workspace', initialMessages, conversationId, initialSelection, selection: controlledSelection, onSelectionChange, runContext, agentControl, onActivityChange, onMessagesChange, onRescanAgents, scanningAgents = false, daemonOnline = true, executionMode = 'local', apiModeAvailable = false, onExecutionModeChange, byokRuntime, onByokModelChange, initialDraft, validateAttachments, deliverTypedAnswer, composerHandle, placeholder, placeholders, suggestions = [], workingDirectory, initialWorkingDirectory, onChangeWorkingDirectory, workingDirectoryAccess, workingDirectoryControlPlacement = 'below', projectFileNames, uploadAttachments, attachmentAccept, disabled = false, runtimePickerPlacement = 'up', composerSlots, header, leadingAccessory, footer, className, style, }) {
+export function ChatPane({ transport, agents: injectedAgents = EMPTY_AGENTS, runtimeAccess, runtimeStatusPollMs = 5_000, title, variant = 'workspace', initialMessages, conversationId, initialSelection, selection: controlledSelection, onSelectionChange, runContext, agentControl, onActivityChange, onMessagesChange, redactUserText, onSecretRedacted, onRescanAgents, scanningAgents = false, daemonOnline = true, executionMode = 'local', apiModeAvailable = false, onExecutionModeChange, byokRuntime, onByokModelChange, initialDraft, composerHistoryScope, composerHistoryStorage, validateAttachments, deliverTypedAnswer, composerHandle, placeholder, placeholders, suggestions = [], workingDirectory, initialWorkingDirectory, onChangeWorkingDirectory, workingDirectoryAccess, workingDirectoryControlPlacement = 'below', projectFileNames, uploadAttachments, attachmentAccept, disabled = false, runtimePickerPlacement = 'up', composerSlots, header, leadingAccessory, footer, className, style, }) {
     const t = useT();
     const composerPlaceholder = useChatPaneComposerPlaceholder({ placeholder: placeholder, placeholders: placeholders });
     const inventory = useChatPaneRuntimeInventory(definedProps({ source: {
@@ -201,10 +202,14 @@ export function ChatPane({ transport, agents: injectedAgents = EMPTY_AGENTS, run
             onSelectionChange,
             runContext,
             initialDraft,
+            composerHistoryScope,
+            composerHistoryStorage,
             validateAttachments,
             uploadAttachments,
             onActivityChange,
             onMessagesChange,
+            redactUserText,
+            onSecretRedacted,
             workingDirectory,
             initialWorkingDirectory,
             onChangeWorkingDirectory,
@@ -263,6 +268,6 @@ export function ChatPane({ transport, agents: injectedAgents = EMPTY_AGENTS, run
             footerAccessories: (_jsx(AgentRuntimePicker, { agents: runtimeView.agents, value: pane.selection, onChange: pane.setSelection, ...definedProps({ source: { onRescan: runtimeView.rescanAgents } }), scanning: runtimeView.scanningAgents, daemonOnline: runtimeView.daemonOnline, placement: runtimePickerPlacement, executionMode: executionMode, apiModeAvailable: apiModeAvailable, ...definedProps({ source: { onExecutionModeChange, byokRuntime, onByokModelChange } }) })),
         } });
     const { rootRef, controlsRef } = useChatPaneControlsHeight();
-    return (_jsxs("section", { className: chatPaneClassName(variant, className), style: style, "data-activity": pane.activity, ref: rootRef, children: [_jsx("style", { "data-jini-chat-pane-styles": "true", children: CHAT_PANE_STYLES }), resolveChatPaneHeader(header, title, pane.reset, t), _jsxs("div", { className: "jini-chat-pane__body", children: [_jsx(MessageList, { messages: pane.conversation.messages, isStreaming: pane.conversation.isStreaming, scrollIntent: pane.conversation.scrollIntent, onScrolled: pane.conversation.acknowledgeScroll, pendingPrompt: pane.queuedPrompt === null ? null : { text: pane.queuedPrompt, onCancel: pane.cancelQueued }, ...(projectFileNames === undefined ? {} : { projectFileNames: new Set(projectFileNames) }) }), _jsxs("div", { className: "jini-chat-pane__controls", ref: controlsRef, children: [_jsx(ChatPaneSuggestionsRow, { suggestions: suggestions, onSelect: pane.composer.setDraft, t: t }), _jsx(ChatPaneStatusMessages, { unavailable: unavailable, scanningAgents: runtimeView.scanningAgents, connectingAgents: runtimeView.connectingAgents, executionMode: executionMode, apiModeAvailable: apiModeAvailable, onExecutionModeChange: onExecutionModeChange, conversationError: pane.conversation.error, attachmentError: pane.attachmentError, dropReadError: fileDrop.dropReadError, workingDirectoryError: pane.workingDirectoryError, workingDirectoryPending: pane.workingDirectoryPending, workingDirectoryInvalid: pane.workingDirectoryInvalid, runtimeInventoryError: inventory.runtimeInventoryError, typedAnswerNotice: pane.typedAnswerNotice, onSendAsNewMessage: () => void pane.sendAsNewMessage(), t: t }), _jsx(ChatPaneComposerArea, { fileDrop: fileDrop, uploadAttachments: uploadAttachments, pane: pane, disabled: disabled, unavailable: unavailable, placeholder: composerPlaceholder, slots: slots, attachmentAccept: attachmentAccept, workingDirectoryAccess: workingDirectoryAccess, workingDirectoryControlPlacement: workingDirectoryControlPlacement, t: t })] })] }), footer] }));
+    return (_jsxs("section", { className: chatPaneClassName(variant, className), style: style, "data-activity": pane.activity, ref: rootRef, children: [_jsx("style", { "data-jini-chat-pane-styles": "true", children: CHAT_PANE_STYLES }), resolveChatPaneHeader(header, title, pane.reset, t), _jsxs("div", { className: "jini-chat-pane__body", children: [_jsx(MessageList, { messages: pane.conversation.messages, isStreaming: pane.conversation.isStreaming, scrollIntent: pane.conversation.scrollIntent, onScrolled: pane.conversation.acknowledgeScroll, pendingPrompt: pane.queuedPrompt === null ? null : { text: pane.queuedPrompt, onCancel: pane.cancelQueued }, ...(projectFileNames === undefined ? {} : { projectFileNames: new Set(projectFileNames) }) }), _jsxs("div", { className: "jini-chat-pane__controls", ref: controlsRef, children: [_jsx(ChatPaneSuggestionsRow, { suggestions: suggestions, onSelect: pane.composer.setDraft, t: t }), pane.secretRedacted ? _jsx("div", { className: "jini-chat-pane__notice", role: "status", children: t(SECRET_REDACTED_NOTICE) }) : null, _jsx(ChatPaneStatusMessages, { unavailable: unavailable, scanningAgents: runtimeView.scanningAgents, connectingAgents: runtimeView.connectingAgents, executionMode: executionMode, apiModeAvailable: apiModeAvailable, onExecutionModeChange: onExecutionModeChange, conversationError: pane.conversation.error, attachmentError: pane.attachmentError, dropReadError: fileDrop.dropReadError, workingDirectoryError: pane.workingDirectoryError, workingDirectoryPending: pane.workingDirectoryPending, workingDirectoryInvalid: pane.workingDirectoryInvalid, runtimeInventoryError: inventory.runtimeInventoryError, typedAnswerNotice: pane.typedAnswerNotice, onSendAsNewMessage: () => void pane.sendAsNewMessage(), t: t }), _jsx(ChatPaneComposerArea, { fileDrop: fileDrop, uploadAttachments: uploadAttachments, pane: pane, disabled: disabled, unavailable: unavailable, placeholder: composerPlaceholder, slots: slots, attachmentAccept: attachmentAccept, workingDirectoryAccess: workingDirectoryAccess, workingDirectoryControlPlacement: workingDirectoryControlPlacement, t: t })] })] }), footer] }));
 }
 //# sourceMappingURL=ChatPane.js.map

package/dist/react/features/chat-pane/create-typed-answer-poster.d.ts

@@ -26,8 +26,9 @@
  * new run: 202 delivered it; 409 means nothing is waiting any more (answered, expired, or never
  * open); anything else is a failure the human can retry. A rejection would collapse the last two.
  */
+import { type UserTextRedactionOptions } from '../../../core/user-text-redaction.js';
 import type { DeliverTypedAnswer } from './types.js';
-export interface CreateTypedAnswerPosterOptions {
+export interface CreateTypedAnswerPosterOptions extends UserTextRedactionOptions {
     /** Path appended to `baseUrl`. Defaults to `/api/mcp-ui/tool-calls`, as for `createMcpUiToolCaller`. */
     readonly path?: string;
     /** Abandon a post after this many ms (reported as `'failed'`). Defaults to 30s. */

package/dist/react/features/chat-pane/create-typed-answer-poster.js

@@ -1,3 +1,32 @@
+/**
+ * @module create-typed-answer-poster
+ *
+ * The client half of a typed answer: a ready-made {@link DeliverTypedAnswer} that posts text the
+ * human typed into the composer to the MCP-UI tool-call route, for the question a running agent is
+ * holding open. Pass it as `ChatPane`'s `deliverTypedAnswer`.
+ *
+ * ```tsx
+ * <ChatPane deliverTypedAnswer={createTypedAnswerPoster({ baseUrl: '', fetch, toolName: 'ask_choice' })} />
+ * ```
+ *
+ * Sibling of `create-mcp-ui-tool-caller.ts`, and the same wire shape: `{toolName, params}` to the
+ * same route. The difference is what the params carry and what the caller needs back.
+ *
+ * ## Why the body names no exchange
+ *
+ * A human typing into the composer has never seen an exchange id; the only client-side copy lives
+ * inside the surface's own (model-influenced, sandboxed) HTML. So the body carries only the tool and
+ * the text under {@link TYPED_ANSWER_PARAM}, and the server resolves which open exchange — for that
+ * tool and the request's own authenticated principal — the answer is for (`@jini-ai/daemon`'s
+ * `findTypedAnswerTarget`).
+ *
+ * ## Why it resolves an outcome instead of throwing
+ *
+ * The pane must tell three cases apart and act differently on each, never by queueing the text as a
+ * new run: 202 delivered it; 409 means nothing is waiting any more (answered, expired, or never
+ * open); anything else is a failure the human can retry. A rejection would collapse the last two.
+ */
+import { redactUserText } from '../../../core/user-text-redaction.js';
 /**
  * The params key a typed answer travels under. Spelled here rather than imported because this
  * browser package cannot depend on `@jini-ai/daemon`, which owns the canonical
@@ -28,6 +57,9 @@ export function createTypedAnswerPoster({ baseUrl, fetch, toolName }, options =
     const endpoint = `${baseUrl.replace(/\/$/u, '')}${options.path ?? DEFAULT_PATH}`;
     const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
     const deliver = async ({ text }) => {
+        const result = (options.redactUserText ?? redactUserText)({ text });
+        if (result.secretRedacted)
+            options.onSecretRedacted?.({ secretRedacted: true, count: result.count });
         const controller = new AbortController();
         const timer = setTimeout(() => controller.abort(), timeoutMs);
         const outcome = await fetch(endpoint, {
@@ -35,7 +67,7 @@ export function createTypedAnswerPoster({ baseUrl, fetch, toolName }, options =
             // Same-origin cookie session: the human's own credentials authorize the answer.
             credentials: 'same-origin',
             headers: { ...options.headers, 'content-type': 'application/json' },
-            body: JSON.stringify({ toolName, params: { [TYPED_ANSWER_PARAM]: text } }),
+            body: JSON.stringify({ toolName, params: { [TYPED_ANSWER_PARAM]: result.text } }),
             signal: controller.signal,
         }).then((response) => deliveryFor(response.status), () => 'failed');
         clearTimeout(timer);

package/dist/react/features/chat-pane/hooks/useAgentRuntimePicker.hooks.js

@@ -1,3 +1,4 @@
+import { pickerModelLabel } from '../model-options.js';
 /**
  * All of `AgentRuntimePicker`'s behavior, so the component itself is only markup.
  *
@@ -146,12 +147,12 @@ export function useAgentRuntimePicker({ agents, value, placement, t, executionMo
     const [position, setPosition] = useState();
     const triggerRef = useRef(null);
     const popoverRef = useRef(null);
-    const orderedAgents = useMemo(() => orderChatPaneAgents({ agents: agents.filter((agent) => agent.available !== false) }), [agents]);
+    const orderedAgents = useMemo(() => orderChatPaneAgents({ agents: agents.filter((agent) => agent.available !== false && agent.id !== 'gemini') }), [agents]);
     const selectedAgent = orderedAgents.find((agent) => agent.id === value.agentId);
     // `selectedAgent` stays resolved in BOTH modes on purpose — the CLI selection is still the stored
     // one, and switching back to Local CLI must not have silently lost it. What changes in `'api'` is
     // only what gets DESCRIBED, because none of the CLI's labels are true of an API turn.
-    const localModelLabel = runtimeOptionLabel({ options: selectedAgent?.models, value: value.model, fallback: t('Default model') });
+    const localModelLabel = pickerModelLabel(selectedAgent, value.model, t);
     const byok = byokSummaryText({ byokRuntime: byokRuntime, t: t });
     const isApi = executionMode === 'api';
     const modelLabel = isApi ? byok.modelLabel : localModelLabel;

package/dist/react/features/chat-pane/hooks/useChatPane.hooks.d.ts

@@ -1,11 +1,13 @@
+import type { UserTextRedactionOptions } from '../../../../core/user-text-redaction.js';
 import { type ChatPaneSendBlocker } from '../rules.js';
 import type { ChatPaneActivity, ChatPaneAgent, ChatPaneAttachmentUploadOptions, ChatPaneAgentSelection, ChatPaneRunContext, ChatPaneWorkingDirectoryAccess, DeliverTypedAnswer, TypedAnswerNotice } from '../types.js';
 import type { ChatAttachment, ChatMessage } from '@jini-ai/chat';
+import type { ComposerHistoryStoragePort } from '../../../../core/composer-history.js';
 import type { ChatTransport } from '@jini-ai/chat';
 import { type UseComposerResult } from '../../../hooks/useComposer.js';
 import { type UseConversationResult } from '../../../hooks/useConversation.js';
 import { type UseChatPaneWorkingDirectoryResult } from './useChatPaneWorkingDirectory.hooks.js';
-export interface UseChatPaneOptions {
+export interface UseChatPaneOptions extends UserTextRedactionOptions {
     transport: ChatTransport;
     agents: readonly ChatPaneAgent[];
     initialMessages?: ChatMessage[];
@@ -15,6 +17,8 @@ export interface UseChatPaneOptions {
     onSelectionChange?: (selection: ChatPaneAgentSelection) => void;
     runContext?: ChatPaneRunContext;
     initialDraft?: string;
+    composerHistoryScope?: string;
+    composerHistoryStorage?: ComposerHistoryStoragePort;
     /** Forwarded verbatim to `useComposer`; see `validateAttachments` there for the contract. */
     validateAttachments?: (attachments: readonly ChatAttachment[]) => Promise<readonly ChatAttachment[]>;
     uploadAttachments?: (files: File[], options?: ChatPaneAttachmentUploadOptions) => Promise<ChatAttachment[]>;
@@ -34,6 +38,8 @@ export interface UseChatPaneOptions {
     deliverTypedAnswer?: DeliverTypedAnswer;
 }
 export interface UseChatPaneResult extends UseChatPaneWorkingDirectoryResult {
+    /** Show a localized non-secret notice when a paste was removed. */
+    secretRedacted: boolean;
     conversation: UseConversationResult;
     composer: UseComposerResult;
     selection: ChatPaneAgentSelection;

package/dist/react/features/chat-pane/hooks/useChatPane.hooks.js

@@ -1,3 +1,4 @@
+import { useUserTextGuard } from '../../../hooks/useUserTextGuard.js';
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { describeChatPaneSendBlocker, findAwaitedTypedAnswerId, findChatPaneSendBlocker, isChatPaneQueueableBlocker, isTypedAnswerTurn, resolveChatPaneSelection, } from '../rules.js';
 import { definedProps } from '../../../util/defined-props.js';
@@ -73,9 +74,11 @@ async function uploadAttachmentBatch(files, effects) {
     }
 }
 export function useChatPane(options) {
+    const guard = useUserTextGuard(options);
     const [activeUploadCount, setActiveUploadCount] = useState(0);
     const [attachmentError, setAttachmentError] = useState(null);
-    const [queuedPrompt, setQueuedPrompt] = useState(null);
+    // Keep the signal with sanitized queue text; re-redacting it later cannot detect the original paste.
+    const [queuedTurn, setQueuedTurn] = useState(null);
     const [typedAnswerNotice, setTypedAnswerNotice] = useState(null);
     // Set across the await of one typed-answer delivery so a second Enter cannot post the same text
     // twice — the second post would find the question already answered and wrongly report it closed.
@@ -114,20 +117,25 @@ export function useChatPane(options) {
     const requestedSelection = options.selection ?? internalSelection;
     const selection = useMemo(() => resolveChatPaneSelection({ agents: options.agents, requested: requestedSelection }), [options.agents, requestedSelection]);
     const selectedAgent = options.agents.find((agent) => agent.id === selection.agentId);
-    const composer = useComposer(definedProps({ source: {
-            initialDraft: options.initialDraft,
-            initialAgent: selection,
-            conversationId: options.conversationId,
-            validateAttachments: options.validateAttachments,
-        } }));
     const conversation = useConversation(definedProps({ source: {
             transport: options.transport,
+            redactUserText: options.redactUserText,
+            onSecretRedacted: guard.notifyRedaction,
             initialMessages: options.initialMessages,
             conversationId: options.conversationId,
             // Keys off an empty string, not `undefined` — `selection.agentId` is always a string (never
             // absent), so only the falsy "no agent selected" case should omit the key.
             agentId: selection.agentId || undefined,
         } }));
+    const composer = useComposer(definedProps({ source: {
+            initialDraft: options.initialDraft,
+            historyMessages: conversation.messages,
+            historyScope: options.composerHistoryScope,
+            historyStorage: options.composerHistoryStorage,
+            initialAgent: selection,
+            conversationId: options.conversationId,
+            validateAttachments: options.validateAttachments,
+        } }));
     const activity = resolveChatPaneActivity(selectedAgent, conversation);
     useEffect(() => {
         options.onActivityChange?.(activity);
@@ -172,6 +180,7 @@ export function useChatPane(options) {
         options.onSelectionChange?.(validated);
     }, [composer, options.agents, options.onSelectionChange]);
     const sendBlocker = findChatPaneSendBlocker({
+        ...(selection.model ? { model: selection.model } : {}),
         selectedAgent,
         isStreaming: conversation.isStreaming,
         activeUploadCount,
@@ -264,8 +273,8 @@ export function useChatPane(options) {
             }
         }
     }, [composer, options.conversationId, options.uploadAttachments]);
-    const sendPrompt = useCallback(async (prompt) => {
-        const trimmed = prompt.trim();
+    const sendGuardedPrompt = useCallback(async ({ redaction }, _optional = {}) => {
+        const trimmed = redaction.text.trim();
         if (!trimmed)
             throw new Error('cannot send: the prompt is empty');
         if (sendBlocker !== null) {
@@ -284,6 +293,7 @@ export function useChatPane(options) {
         attachmentBatchIdRef.current = createAttachmentBatchId();
         options.onActivityChange?.('queued');
         await conversation.sendMessage(trimmed, definedProps({ source: {
+                secretRedaction: redaction.secretRedacted ? { secretRedacted: true, count: redaction.count } : undefined,
                 agentId: selection.agentId,
                 // Omitted when the array is EMPTY, not merely absent — an empty `attachments: []` would be a
                 // different (valid, present) value to the transport than "no attachments key at all".
@@ -299,12 +309,16 @@ export function useChatPane(options) {
         sendBlocker,
         workingDirectoryState.workingDirectory,
     ]);
+    const sendPrompt = useCallback(async (prompt) => {
+        await sendGuardedPrompt({ redaction: guard.redact({ text: prompt.trim() }, {}) }, {});
+    }, [guard.redact, sendGuardedPrompt]);
     const answerWaitingQuestion = useCallback(async ({ deliver, text }) => {
+        const safeText = guard.redactText(text);
         const generation = typedAnswerGenerationRef.current;
         const submittedDraft = latestDraftRef.current;
         const questionId = awaitedQuestionId;
         deliveringTypedAnswerRef.current = true;
-        const outcome = await deliverTypedAnswerSafely({ deliver, text });
+        const outcome = await deliverTypedAnswerSafely({ deliver, text: safeText });
         deliveringTypedAnswerRef.current = false;
         if (!mountedRef.current || generation !== typedAnswerGenerationRef.current)
             return;
@@ -320,21 +334,21 @@ export function useChatPane(options) {
         // correction or next message typed while the host answered.
         if (latestDraftRef.current === submittedDraft)
             composer.setDraft('');
-    }, [awaitedQuestionId, composer]);
+    }, [awaitedQuestionId, composer, guard.redactText]);
     // The ordinary next-turn path: queue behind a running run, else send now.
     const sendOrdinaryTurn = useCallback(async (prompt) => {
         // Queue instead of no-op'ing. `setDraft('')` and NOT `composer.reset()`: reset also discards
         // staged attachments, which this turn still needs when it finally goes out.
         if (isChatPaneQueueableBlocker({ blocker: sendBlocker })) {
             queuedConversationIdRef.current = options.conversationId;
-            setQueuedPrompt(prompt);
+            setQueuedTurn(guard.redact({ text: prompt }, {}));
             composer.setDraft('');
             return;
         }
         if (!canSend)
             return;
         await sendPrompt(prompt);
-    }, [canSend, composer, options.conversationId, sendBlocker, sendPrompt]);
+    }, [canSend, composer, options.conversationId, sendBlocker, sendPrompt, guard.redact]);
     const send = useCallback(async () => {
         const prompt = composerPrompt(composer);
         if (!prompt || deliveringTypedAnswerRef.current)
@@ -382,31 +396,31 @@ export function useChatPane(options) {
         if (!prompt)
             return;
         queuedConversationIdRef.current = options.conversationId;
-        setQueuedPrompt(prompt);
+        setQueuedTurn(guard.redact({ text: prompt }, {}));
         composer.setDraft('');
         conversation.cancel();
-    }, [composer, conversation, options.conversationId]);
+    }, [composer, conversation, options.conversationId, guard.redact]);
     const cancelQueued = useCallback(() => {
         queuedConversationIdRef.current = undefined;
-        setQueuedPrompt(null);
+        setQueuedTurn(null);
     }, []);
     // Flush on a FULLY clear blocker, not merely on streaming ending — see
     // `isChatPaneQueueableBlocker`'s note about `findChatPaneSendBlocker`'s ordering. Clearing the
     // queue slot BEFORE awaiting keeps a re-render from double-sending the same prompt.
     useEffect(() => {
-        if (queuedPrompt === null || sendBlocker !== null)
+        if (queuedTurn === null || sendBlocker !== null)
             return;
         if (queuedConversationIdRef.current !== options.conversationId) {
             // The conversation changed while this prompt waited behind a streaming run — sending it now
             // would post it into a conversation the user never saw it queued against. Drop it instead
             // (same as `cancelQueued`) rather than misrouting it.
             queuedConversationIdRef.current = undefined;
-            setQueuedPrompt(null);
+            setQueuedTurn(null);
             return;
         }
-        setQueuedPrompt(null);
-        void sendPrompt(queuedPrompt);
-    }, [options.conversationId, queuedPrompt, sendBlocker, sendPrompt]);
+        setQueuedTurn(null);
+        void sendGuardedPrompt({ redaction: queuedTurn }, {});
+    }, [options.conversationId, queuedTurn, sendBlocker, sendGuardedPrompt]);
     const reset = useCallback(() => {
         attachmentGenerationRef.current += 1;
         attachmentBatchIdRef.current = createAttachmentBatchId();
@@ -425,9 +439,10 @@ export function useChatPane(options) {
         // `conversation.cancel()` above clears the streaming blocker — the flush effect fires it into
         // the just-reset conversation instead of discarding it like the rest of this turn's state.
         queuedConversationIdRef.current = undefined;
-        setQueuedPrompt(null);
+        setQueuedTurn(null);
     }, [composer, conversation, options.initialMessages]);
     return {
+        secretRedacted: guard.secretRedacted,
         conversation,
         composer,
         selection,
@@ -443,7 +458,7 @@ export function useChatPane(options) {
         addAttachments,
         send,
         sendPrompt,
-        queuedPrompt,
+        queuedPrompt: queuedTurn?.text ?? null,
         cancelQueued,
         typedAnswerNotice,
         sendAsNewMessage,

package/dist/react/features/chat-pane/model-options.d.ts

@@ -0,0 +1,10 @@
+import type { I18nAdapter } from '../../slots.js';
+import type { ChatPaneAgent, ChatPaneAgentOption } from './types.js';
+export declare function isConcretePickerModel(id: string): boolean;
+/** Aliases are selectable only as their evidence-backed concrete ID. Never render a Default row. */
+export declare function pickerModelOptions(agent: ChatPaneAgent): ChatPaneAgentOption[];
+export declare function configuredPickerModel(agent: ChatPaneAgent): string | undefined;
+export declare function pickerModelLabel(agent: ChatPaneAgent | undefined, requested?: string, t?: I18nAdapter['t']): string;
+export declare function pickerModelValue(agent: ChatPaneAgent, requested?: string): string;
+export declare function pickerCatalogNote(agent: ChatPaneAgent, t?: I18nAdapter['t']): string | undefined;
+//# sourceMappingURL=model-options.d.ts.map

package/dist/react/features/chat-pane/model-options.js

@@ -0,0 +1,51 @@
+// Model names and timestamps are metadata; only surrounding picker copy is translated.
+const passthrough = key => key;
+export function isConcretePickerModel(id) {
+    const token = id.slice(id.lastIndexOf('/') + 1);
+    return !/^(?:opus|sonnet|haiku|fable|best|latest|claude|gemini|gpt|codex|swe)(?:\[.*\])?$/i.test(token) && !/^(default|auto|adaptive|smart|deep|rush|ultimate|premium|balanced|fast|grok-build|vercel-ai-gateway)$/i.test(token) && !/(?:^|[-/])(gateway|latest)$/i.test(id);
+}
+/** Aliases are selectable only as their evidence-backed concrete ID. Never render a Default row. */
+export function pickerModelOptions(agent) {
+    if (agent.supportsConcreteModelSelection === false)
+        return [];
+    const seen = new Set();
+    const options = (agent.models || []).flatMap((row) => {
+        const id = row.resolvedId || (row.identityKind === 'routing-mode' || row.identityKind === 'alias' ? undefined : row.id);
+        if (!id || !isConcretePickerModel(id) || seen.has(id))
+            return [];
+        seen.add(id);
+        return [{ ...row, id, label: row.label, identityKind: 'concrete' }];
+    });
+    const resolution = agent.defaultModelResolution;
+    // A host may publish a resolved default outside its visible catalog. Preserve its concrete ID.
+    if (resolution?.status === 'resolved' && isConcretePickerModel(resolution.id) && !seen.has(resolution.id))
+        options.unshift({ id: resolution.id, label: resolution.id, identityKind: 'concrete' });
+    return options;
+}
+export function configuredPickerModel(agent) {
+    if (agent.supportsConcreteModelSelection === false)
+        return undefined;
+    const resolution = agent.defaultModelResolution;
+    return resolution?.status === 'resolved' && isConcretePickerModel(resolution.id) ? resolution.id : undefined;
+}
+export function pickerModelLabel(agent, requested, t = passthrough) {
+    if (!agent)
+        return t('Choose model');
+    const id = !requested || requested === 'default' ? configuredPickerModel(agent) : requested;
+    if (!id || !isConcretePickerModel(id))
+        return t('Choose model');
+    return pickerModelOptions(agent).find((row) => row.id === id)?.label || id;
+}
+export function pickerModelValue(agent, requested) {
+    const id = requested && requested !== 'default' ? requested : configuredPickerModel(agent);
+    return id && pickerModelOptions(agent).some((row) => row.id === id) ? id : '';
+}
+export function pickerCatalogNote(agent, t = passthrough) {
+    const catalog = agent.modelCatalog;
+    if (catalog?.freshness === 'stale')
+        return `${t('Cached')} · ${catalog.fetchedAt}`;
+    if (catalog?.freshness === 'offline-fallback' || !catalog && agent.models)
+        return t('Offline fallback');
+    return undefined;
+}
+//# sourceMappingURL=model-options.js.map

package/dist/react/features/chat-pane/rules.d.ts

@@ -14,9 +14,10 @@ export declare function resolveChatPaneSelection({ agents, requested }: {
  * precondition (`composer.canSubmit`), not a property of the pane. An agent-driven send supplies
  * its own prompt and must still clear every blocker below.
  */
-export type ChatPaneSendBlocker = 'no-agent-selected' | 'agent-unavailable' | 'streaming' | 'uploads-pending' | 'working-directory-pending' | 'working-directory-invalid' | 'working-directory-error';
+export type ChatPaneSendBlocker = 'no-agent-selected' | 'agent-unavailable' | 'model-unresolved' | 'streaming' | 'uploads-pending' | 'working-directory-pending' | 'working-directory-invalid' | 'working-directory-error';
 export interface ChatPaneSendability {
-    readonly selectedAgent: Pick<ChatPaneAgent, 'available'> | undefined;
+    readonly selectedAgent: Pick<ChatPaneAgent, 'available' | 'modelCatalog' | 'supportsConcreteModelSelection'> | undefined;
+    readonly model?: string;
     readonly isStreaming: boolean;
     readonly activeUploadCount: number;
     readonly workingDirectoryPending: boolean;

package/dist/react/features/chat-pane/rules.js

@@ -1,3 +1,4 @@
+import { configuredPickerModel, pickerModelOptions, isConcretePickerModel } from './model-options.js';
 function preferredOptionId(options) {
     return options?.find((option) => option.id === 'default')?.id ?? options?.[0]?.id;
 }
@@ -7,7 +8,9 @@ function validatedOptionId(options, requested, fallback) {
     return fallback;
 }
 export function defaultChatPaneSelection({ agent }) {
-    const model = preferredOptionId(agent.models);
+    // An unresolved native route requires an intentional concrete choice. Legacy hosts without
+    // structured resolution retain their first-concrete-entry behavior.
+    const model = configuredPickerModel(agent) || (agent.defaultModelResolution?.status === 'unresolved' ? undefined : pickerModelOptions(agent)[0]?.id);
     const reasoning = preferredOptionId(agent.reasoningOptions);
     return {
         agentId: agent.id,
@@ -16,17 +19,19 @@ export function defaultChatPaneSelection({ agent }) {
     };
 }
 export function resolveChatPaneSelection({ agents, requested }) {
-    const requestedAgent = agents.find((agent) => agent.id === requested.agentId && agent.available !== false);
-    const agent = requestedAgent ?? agents.find((candidate) => candidate.available !== false);
+    const requestedAgent = agents.find((agent) => agent.id === requested.agentId && agent.id !== 'gemini' && agent.available !== false);
+    const agent = requestedAgent ?? agents.find((candidate) => candidate.id !== 'gemini' && candidate.available !== false);
     if (!agent)
         return { agentId: '' };
     const defaults = defaultChatPaneSelection({ agent: agent });
     if (agent !== requestedAgent)
         return defaults;
     const model = requested.model
+        && isConcretePickerModel(requested.model)
         && agent.supportsCustomModel
+        && agent.supportsConcreteModelSelection !== false
         ? requested.model
-        : validatedOptionId(agent.models, requested.model, defaults.model);
+        : validatedOptionId(pickerModelOptions(agent), requested.model, defaults.model);
     const reasoning = validatedOptionId(agent.reasoningOptions, requested.reasoning, defaults.reasoning);
     return {
         agentId: agent.id,
@@ -64,6 +69,8 @@ export function findChatPaneSendBlocker(state) {
     else if (state.selectedAgent.available === false) {
         return 'agent-unavailable';
     }
+    if (!state.apiModeConfigured && state.selectedAgent && (state.selectedAgent.modelCatalog || state.selectedAgent.supportsConcreteModelSelection === false) && (!state.model || !isConcretePickerModel(state.model) || state.selectedAgent.supportsConcreteModelSelection === false))
+        return 'model-unresolved';
     if (state.isStreaming)
         return 'streaming';
     if (state.activeUploadCount > 0)
@@ -79,6 +86,7 @@ export function findChatPaneSendBlocker(state) {
 const SEND_BLOCKER_MESSAGES = {
     'no-agent-selected': 'no agent is selected',
     'agent-unavailable': 'the selected agent is unavailable',
+    'model-unresolved': 'choose a concrete model before sending',
     streaming: 'a run is already streaming — cancel it first',
     'uploads-pending': 'attachment uploads are still in flight',
     'working-directory-pending': 'the working directory is still being validated',