@jini-ai/chat 0.6.5 → 0.6.7

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

@@ -44,12 +44,13 @@ export function useChatPaneControlsHeight() {
         if (!root || !controls || typeof ResizeObserver !== 'function')
             return;
         const observer = new ResizeObserver((entries) => {
-            const entry = entries[0];
-            if (!entry)
-                return;
-            // Rounded up: a fractional px short would let one glyph's descender clip against the
-            // gradient's opaque end, which `Math.ceil` never risks understating.
-            root.style.setProperty(CHAT_PANE_CONTROLS_HEIGHT_CSS_VAR, `${Math.ceil(entry.contentRect.height)}px`);
+            // Only `controls` is observed, so a notification carries at most one entry: `slice(0, 1)`
+            // reads it without a branch for the empty list the ResizeObserver spec never delivers.
+            for (const entry of entries.slice(0, 1)) {
+                // Rounded up: a fractional px short would let one glyph's descender clip against the
+                // gradient's opaque end, which `Math.ceil` never risks understating.
+                root.style.setProperty(CHAT_PANE_CONTROLS_HEIGHT_CSS_VAR, `${Math.ceil(entry.contentRect.height)}px`);
+            }
         });
         observer.observe(controls);
         return () => observer.disconnect();

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

@@ -25,6 +25,32 @@ const NEW_TAB_PROTOCOLS = new Set(['http:', 'https:']);
 function openInNewTabDefault(url) {
     window.open(url, '_blank', 'noopener,noreferrer');
 }
+/**
+ * Whether the click is a plain primary click nobody has handled yet: modified or non-primary
+ * clicks are left to the browser, which already opens those however the user asked.
+ *
+ * @param input.event - The native click.
+ * @returns `true` when the guard may take the click over.
+ */
+function isPlainPrimaryClick({ event }) {
+    if (event.defaultPrevented || event.button !== 0)
+        return false;
+    return !(event.metaKey || event.ctrlKey || event.shiftKey || event.altKey);
+}
+/**
+ * Whether an anchor is an ordinary in-tab web link the guard should redirect to a new tab — not
+ * one already opening elsewhere, a download, an action styled as a link, or a `#` same-document jump.
+ *
+ * @param input.link - An anchor matched by `a[href]`, so its `href` attribute is present.
+ * @returns `true` when following the link would navigate the chat's own tab to an http(s) page.
+ */
+function isInTabWebLink({ link }) {
+    if (link.target === '_blank' || link.hasAttribute('download') || link.getAttribute('role') === 'button')
+        return false;
+    if (link.getAttribute('href').startsWith('#'))
+        return false;
+    return NEW_TAB_PROTOCOLS.has(link.protocol);
+}
 /**
  * Decides whether a click inside the pane should open a link in a new tab.
  *
@@ -34,21 +60,13 @@ function openInNewTabDefault(url) {
  * @complexity O(d) for `closest` over the target's ancestor depth d.
  */
 export function newTabLinkHref({ event, root }) {
-    if (event.defaultPrevented || event.button !== 0)
-        return null;
-    if (event.metaKey || event.ctrlKey || event.shiftKey || event.altKey)
-        return null;
     const target = event.target;
-    if (!(target instanceof Element))
+    if (!isPlainPrimaryClick({ event }) || !(target instanceof Element))
         return null;
     const link = target.closest('a[href]');
     if (!(link instanceof HTMLAnchorElement) || !root.contains(link))
         return null;
-    if (link.target === '_blank' || link.hasAttribute('download') || link.getAttribute('role') === 'button')
-        return null;
-    if (link.getAttribute('href').startsWith('#'))
-        return null;
-    return NEW_TAB_PROTOCOLS.has(link.protocol) ? link.href : null;
+    return isInTabWebLink({ link }) ? link.href : null;
 }
 /**
  * The pane root's `onClickCapture` handler: opens qualifying link clicks in a new tab and cancels

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

@@ -3,7 +3,7 @@ export interface UseChatPaneRuntimeInventoryOptions {
     access?: ChatPaneRuntimeAccess;
     initialAgents?: readonly ChatPaneAgent[];
     pollIntervalMs?: number;
-    /** Backoff between retries of a failed inventory load; the last entry repeats. */
+    /** Failure backoff; pending discovery doubles the final step until its finite window ends. */
     retryDelaysMs?: readonly number[];
 }
 export interface UseChatPaneRuntimeInventoryResult {
@@ -30,13 +30,13 @@ export interface UseChatPaneRuntimeInventoryResult {
  * daemon restarting under an open pane left it on "No usable CLI is selected" until a hard
  * reload). Until the first successful answer the hook retries on a backoff, and immediately when
  * the daemon goes from offline to online, the window regains focus, or the tab becomes visible.
- * A RESOLVED list — even an empty one — is a finished answer; hosts reject when theirs is not one.
+ * A RESOLVED list is an answer, including an empty one. Entries marked discoveryPending retry
+ * within a finite sweep window, honoring the host cache's next eligible refresh deadline.
  *
  * Health polling runs only while the tab is visible (hidden tabs made no-op status calls every
  * `pollIntervalMs` forever), and never overlaps a status call still in flight.
  *
  * @complexity Time: O(n) per inventory response; space: O(n) for the snapshot.
- * @overallScore 100/100
  */
 export declare function useChatPaneRuntimeInventory({ access, initialAgents, pollIntervalMs, retryDelaysMs, }: UseChatPaneRuntimeInventoryOptions): UseChatPaneRuntimeInventoryResult;
 //# sourceMappingURL=useChatPaneRuntimeInventory.hooks.d.ts.map

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

@@ -4,6 +4,11 @@ const EMPTY_AGENTS = [];
 /** Waits between inventory retries while `listAgents` keeps failing: quick at first (a daemon
  *  restart takes seconds), then every 30s for as long as the pane stays mounted. */
 const DEFAULT_RETRY_DELAYS_MS = [1_000, 2_000, 4_000, 8_000, 15_000, 30_000];
+// The native host serializes metadata for 29 definitions: version/help/auth checks and up to
+// 15s per catalog can take minutes in a cold sweep. Include queue time and a final cache cooldown
+// margin, then stop; extending backoff beyond 30s keeps this to ten default retries, not polling.
+const PENDING_DISCOVERY_WINDOW_MS = 15 * 60_000;
+const PENDING_DISCOVERY_RETRY_LIMIT = 10;
 /**
  * Owns agent inventory, explicit rescans, and daemon-health polling while the
  * host supplies only the environment-specific I/O effects.
@@ -15,13 +20,13 @@ const DEFAULT_RETRY_DELAYS_MS = [1_000, 2_000, 4_000, 8_000, 15_000, 30_000];
  * daemon restarting under an open pane left it on "No usable CLI is selected" until a hard
  * reload). Until the first successful answer the hook retries on a backoff, and immediately when
  * the daemon goes from offline to online, the window regains focus, or the tab becomes visible.
- * A RESOLVED list — even an empty one — is a finished answer; hosts reject when theirs is not one.
+ * A RESOLVED list is an answer, including an empty one. Entries marked discoveryPending retry
+ * within a finite sweep window, honoring the host cache's next eligible refresh deadline.
  *
  * Health polling runs only while the tab is visible (hidden tabs made no-op status calls every
  * `pollIntervalMs` forever), and never overlaps a status call still in flight.
  *
  * @complexity Time: O(n) per inventory response; space: O(n) for the snapshot.
- * @overallScore 100/100
  */
 export function useChatPaneRuntimeInventory({ access, initialAgents = EMPTY_AGENTS, pollIntervalMs = 5_000, retryDelaysMs = DEFAULT_RETRY_DELAYS_MS, }) {
     const [agents, setAgents] = useState(initialAgents);
@@ -51,16 +56,19 @@ export function useChatPaneRuntimeInventory({ access, initialAgents = EMPTY_AGEN
         if (!access)
             return;
         retry.cancel();
+        if (rescan)
+            retry.restart();
         setScanningAgents(true);
         setRuntimeInventoryError(null);
         await inventory.run({ body: async (token) => {
                 const nextAgents = await (rescan ? access.rescanAgents() : access.listAgents());
                 token.ensureCurrent();
-                retry.answered();
-                // Successful cached data paints immediately. Poll only while the host says its single
-                // background scan is pending; reads never imply an explicit Rescan.
-                if (nextAgents.some(agent => agent.discoveryPending))
-                    retry.schedule(() => void loadAgents(false));
+                const pending = nextAgents.some(agent => agent.discoveryPending);
+                retry.answered({ pending });
+                if (pending)
+                    retry.schedule(() => void loadAgents(false), {
+                        pending: true, nextRefreshAt: access.getAgentsRefreshAt?.() ?? Date.now(),
+                    });
                 setAgents([...nextAgents]);
                 setConnectingAgents(false);
                 setScanningAgents(false);
@@ -182,13 +190,15 @@ export function useChatPaneRuntimeInventory({ access, initialAgents = EMPTY_AGEN
 }
 /**
  * The retry bookkeeping `useChatPaneRuntimeInventory` needs, in refs so none of it re-renders:
- * whether an answer has arrived, the pending retry timer, the backoff step, and the last health
- * result (`null` until the first one, so the first "online" report is not a reconnect).
+ * whether an answer has arrived, the retry timer, separate failure/discovery steps, a finite
+ * discovery deadline, and the last health result (`null` until the first health response).
  */
 function useInventoryRetry(delaysMs) {
     const answeredRef = useRef(false);
     const timerRef = useRef(undefined);
     const stepRef = useRef(0);
+    const pendingStepRef = useRef(0);
+    const pendingDeadlineRef = useRef(undefined);
     const lastOnlineRef = useRef(null);
     const delaysRef = useRef(delaysMs);
     delaysRef.current = delaysMs;
@@ -200,15 +210,33 @@ function useInventoryRetry(delaysMs) {
         const restart = () => {
             cancel();
             stepRef.current = 0;
+            pendingStepRef.current = 0;
+            pendingDeadlineRef.current = undefined;
+        };
+        const schedulePending = (attempt, nextRefreshAt) => {
+            const now = Date.now();
+            pendingDeadlineRef.current ??= now + PENDING_DISCOVERY_WINDOW_MS;
+            const delay = pendingRetryDelayMs({
+                delaysMs: delaysRef.current, step: pendingStepRef.current, now, deadline: pendingDeadlineRef.current, nextRefreshAt,
+            });
+            if (delay === null)
+                return;
+            pendingStepRef.current += 1;
+            timerRef.current = window.setTimeout(attempt, delay);
         };
         return {
             hasAnswer: () => answeredRef.current,
-            answered: () => {
+            answered: ({ pending }) => {
                 answeredRef.current = true;
-                restart();
+                if (!pending)
+                    restart();
             },
-            schedule: (attempt) => {
+            schedule: (attempt, { pending = false, nextRefreshAt = 0 } = {}) => {
                 cancel();
+                if (pending) {
+                    schedulePending(attempt, nextRefreshAt);
+                    return;
+                }
                 const delays = delaysRef.current;
                 const delay = delays[Math.min(stepRef.current, delays.length - 1)] ?? 0;
                 stepRef.current += 1;
@@ -230,4 +258,24 @@ function useInventoryRetry(delaysMs) {
     });
     return retry;
 }
+/**
+ * The wait before the next pending-discovery retry: the backoff step (doubling the final step once
+ * the list runs out), pushed out to the host cache's next eligible refresh, capped at the window.
+ *
+ * @param input.delaysMs - Failure backoff steps; empty means no pending retries at all.
+ * @param input.step - Pending retries already made in this discovery window.
+ * @param input.now - Current epoch ms.
+ * @param input.deadline - Epoch ms the finite discovery window closes.
+ * @param input.nextRefreshAt - Earliest epoch ms the host cache can refresh.
+ * @returns Milliseconds to wait, or `null` when the retry budget or window is spent.
+ * @complexity O(1).
+ */
+function pendingRetryDelayMs({ delaysMs, step, now, deadline, nextRefreshAt }) {
+    const lastDelay = delaysMs[delaysMs.length - 1];
+    if (lastDelay === undefined || step >= PENDING_DISCOVERY_RETRY_LIMIT || now >= deadline)
+        return null;
+    const delay = delaysMs[step] ?? lastDelay * 2 ** (step - delaysMs.length + 1);
+    const refreshAt = Math.max(nextRefreshAt, Math.min(now + delay, deadline));
+    return refreshAt > deadline ? null : refreshAt - now;
+}
 //# sourceMappingURL=useChatPaneRuntimeInventory.hooks.js.map

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

@@ -0,0 +1,49 @@
+/**
+ * Mechanics for the composer bar's small model / reasoning-effort menus ("drop-ups"): open/close,
+ * outside-click and Escape dismissal, a viewport-fixed position anchored ABOVE the trigger, focus
+ * on open and back to the trigger on close, and arrow-key roving between the items.
+ *
+ * Same idiom as `useAgentRuntimePicker` (whose pure `resolveRovingIndex` this reuses), minus what a
+ * flat list of choices does not need: no portal (the menu renders inline, so it inherits the
+ * host's `data-theme` and the pane's scoped CSS; `position: fixed` still escapes the dock's
+ * `overflow: hidden`, as `composerDiscoveryMenuPosition` documents) and no Tab trap (Tab simply
+ * closes the menu and lets focus move on).
+ */
+import { type CSSProperties, type KeyboardEvent as ReactKeyboardEvent, type RefObject } from 'react';
+/**
+ * Viewport-fixed geometry for a drop-up: right-aligned with the trigger, clamped into the
+ * viewport and (when given) into `bounds`, bottom edge just above it, and never taller than the
+ * space above. Right-aligned because the model/effort cluster sits at the composer bar's trailing
+ * edge, so the menu grows back into the pane instead of past the dock's right edge; `bounds` (the
+ * composer box) keeps a menu wider than the room left of the trigger from spilling out of a narrow
+ * dock onto the page beside it.
+ *
+ * @complexity Time/space: O(1).
+ */
+export declare function runtimeDropUpPosition({ trigger, width }: {
+    trigger: DOMRect;
+    width: number;
+}, { bounds }?: {
+    bounds?: Pick<DOMRect, 'left' | 'right'>;
+}): CSSProperties;
+export interface UseRuntimeDropUpResult {
+    menuId: string;
+    open: boolean;
+    /** Undefined until the trigger has been measured; the menu does not render before then. */
+    position: CSSProperties | undefined;
+    triggerRef: RefObject<HTMLButtonElement | null>;
+    menuRef: RefObject<HTMLDivElement | null>;
+    toggleOpen: () => void;
+    /** ArrowUp/ArrowDown on the closed trigger opens the menu, like a native select. */
+    handleTriggerKeyDown: (event: ReactKeyboardEvent<HTMLButtonElement>) => void;
+    handleMenuKeyDown: (event: ReactKeyboardEvent<HTMLDivElement>) => void;
+    /** Runs the selection, closes, and returns focus to the trigger. */
+    choose: (apply: () => void) => void;
+}
+/**
+ * @complexity Time: O(1) per render; key handling is O(n) in the menu's item count.
+ */
+export declare function useRuntimeDropUp({ width }: {
+    width: number;
+}): UseRuntimeDropUpResult;
+//# sourceMappingURL=useRuntimeDropUp.hooks.d.ts.map

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

@@ -0,0 +1,143 @@
+/**
+ * Mechanics for the composer bar's small model / reasoning-effort menus ("drop-ups"): open/close,
+ * outside-click and Escape dismissal, a viewport-fixed position anchored ABOVE the trigger, focus
+ * on open and back to the trigger on close, and arrow-key roving between the items.
+ *
+ * Same idiom as `useAgentRuntimePicker` (whose pure `resolveRovingIndex` this reuses), minus what a
+ * flat list of choices does not need: no portal (the menu renders inline, so it inherits the
+ * host's `data-theme` and the pane's scoped CSS; `position: fixed` still escapes the dock's
+ * `overflow: hidden`, as `composerDiscoveryMenuPosition` documents) and no Tab trap (Tab simply
+ * closes the menu and lets focus move on).
+ */
+import { useCallback, useEffect, useId, useRef, useState, } from 'react';
+import { resolveRovingIndex } from './useAgentRuntimePicker.hooks.js';
+const MENU_ITEMS = '[role="menuitemradio"]';
+/**
+ * Viewport-fixed geometry for a drop-up: right-aligned with the trigger, clamped into the
+ * viewport and (when given) into `bounds`, bottom edge just above it, and never taller than the
+ * space above. Right-aligned because the model/effort cluster sits at the composer bar's trailing
+ * edge, so the menu grows back into the pane instead of past the dock's right edge; `bounds` (the
+ * composer box) keeps a menu wider than the room left of the trigger from spilling out of a narrow
+ * dock onto the page beside it.
+ *
+ * @complexity Time/space: O(1).
+ */
+export function runtimeDropUpPosition({ trigger, width }, { bounds } = {}) {
+    const margin = 12;
+    const gap = 6;
+    const minLeft = Math.max(margin, bounds?.left ?? -Infinity);
+    const maxRight = Math.min(window.innerWidth - margin, bounds?.right ?? Infinity);
+    const menuWidth = Math.max(0, Math.min(width, maxRight - minLeft));
+    return {
+        position: 'fixed',
+        left: Math.min(Math.max(trigger.right - menuWidth, minLeft), maxRight - menuWidth),
+        bottom: Math.max(margin, window.innerHeight - trigger.top + gap),
+        width: menuWidth,
+        maxHeight: Math.min(320, Math.max(0, trigger.top - gap - margin)),
+        overflowY: 'auto',
+        zIndex: 1000,
+    };
+}
+/**
+ * @complexity Time: O(1) per render; key handling is O(n) in the menu's item count.
+ */
+export function useRuntimeDropUp({ width }) {
+    const menuId = useId();
+    const [open, setOpen] = useState(false);
+    const [position, setPosition] = useState();
+    const triggerRef = useRef(null);
+    const menuRef = useRef(null);
+    const closeToTrigger = useCallback(() => {
+        setOpen(false);
+        triggerRef.current?.focus();
+    }, []);
+    const toggleOpen = useCallback(() => {
+        setOpen((current) => !current);
+    }, []);
+    useEffect(() => {
+        if (!open)
+            return;
+        const closeOnOutsidePointer = (event) => {
+            const target = event.target;
+            if (triggerRef.current?.contains(target) || menuRef.current?.contains(target))
+                return;
+            // No focus restore: the pointer is already going somewhere else.
+            setOpen(false);
+        };
+        const closeOnEscape = (event) => {
+            if (event.key === 'Escape')
+                closeToTrigger();
+        };
+        document.addEventListener('mousedown', closeOnOutsidePointer);
+        document.addEventListener('keydown', closeOnEscape);
+        return () => {
+            document.removeEventListener('mousedown', closeOnOutsidePointer);
+            document.removeEventListener('keydown', closeOnEscape);
+        };
+    }, [closeToTrigger, open]);
+    useEffect(() => {
+        if (!open)
+            return;
+        const update = () => {
+            const rect = triggerRef.current?.getBoundingClientRect();
+            const bounds = triggerRef.current?.closest('.jini-composer')?.getBoundingClientRect();
+            if (rect)
+                setPosition(runtimeDropUpPosition({ trigger: rect, width }, bounds ? { bounds } : {}));
+        };
+        update();
+        window.addEventListener('resize', update);
+        // Capture phase: a scroll inside any ancestor moves the trigger too, and scroll does not bubble.
+        window.addEventListener('scroll', update, true);
+        return () => {
+            window.removeEventListener('resize', update);
+            window.removeEventListener('scroll', update, true);
+        };
+    }, [open, width]);
+    useEffect(() => {
+        if (!open || !position)
+            return;
+        const menu = menuRef.current;
+        const checked = menu?.querySelector(`${MENU_ITEMS}[aria-checked="true"]`);
+        (checked ?? menu?.querySelector(MENU_ITEMS))?.focus();
+    }, [open, position]);
+    const handleTriggerKeyDown = useCallback((event) => {
+        if (open || (event.key !== 'ArrowUp' && event.key !== 'ArrowDown'))
+            return;
+        event.preventDefault();
+        setOpen(true);
+    }, [open]);
+    const handleMenuKeyDown = useCallback((event) => {
+        if (event.key === 'Tab') {
+            setOpen(false);
+            return;
+        }
+        // Only reachable via the element `menuRef` is attached to, so the ref is set by now; and the
+        // menu is never rendered without items (the caller omits a drop-up that has no choices).
+        const items = [...menuRef.current.querySelectorAll(MENU_ITEMS)];
+        const next = resolveRovingIndex({
+            key: event.key,
+            currentIndex: items.indexOf(document.activeElement),
+            count: items.length,
+        });
+        if (next === null)
+            return;
+        event.preventDefault();
+        items[next]?.focus();
+    }, []);
+    const choose = useCallback((apply) => {
+        apply();
+        closeToTrigger();
+    }, [closeToTrigger]);
+    return {
+        menuId,
+        open,
+        position,
+        triggerRef,
+        menuRef,
+        toggleOpen,
+        handleTriggerKeyDown,
+        handleMenuKeyDown,
+        choose,
+    };
+}
+//# sourceMappingURL=useRuntimeDropUp.hooks.js.map

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

@@ -2,11 +2,28 @@ 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.
- * @complexity O(n) time and space in catalog rows, with set-based deduplication.
+ * Keeps the first position per concrete ID, upgrading raw-ID labels from later human labels.
+ * Legacy Default labels are rewritten to the ID before deduplication, never used as human labels.
+ * @returns Distinct concrete picker rows without changing the source catalog. No side effects or errors.
+ * @complexity O(n) time and space in catalog rows, using insertion-ordered Map keys.
  */
 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;
+/**
+ * The composer bar's compact model name: the catalog label (or a prettified raw id when the catalog
+ * has no label), minus the leading vendor word the agent's icon already conveys, capped with "…".
+ * The full label stays in the drop-up list and the trigger's tooltip.
+ * @example shortModelLabel({ label: 'GPT-6.1-Sol', agentId: 'codex' }) // "6.1 Sol"
+ * @example shortModelLabel({ label: 'claude-opus-5-5', agentId: 'claude' }) // "Opus 5.5"
+ * @complexity O(n) in the label length. Pure.
+ */
+export declare function shortModelLabel({ label, agentId }: {
+    label: string;
+    agentId?: string | undefined;
+}, { max }?: {
+    max?: number;
+}): string;
 //# sourceMappingURL=model-options.d.ts.map

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

@@ -1,30 +1,17 @@
+import { concreteModelOptions, modelIdentityKind } from '@jini-ai/agent-runtime/model-selection';
 // 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);
+    return modelIdentityKind(id) === 'concrete';
 }
 /** Aliases are selectable only as their evidence-backed concrete ID. Never render a Default row.
- * @complexity O(n) time and space in catalog rows, with set-based deduplication.
+ * Keeps the first position per concrete ID, upgrading raw-ID labels from later human labels.
+ * Legacy Default labels are rewritten to the ID before deduplication, never used as human labels.
+ * @returns Distinct concrete picker rows without changing the source catalog. No side effects or errors.
+ * @complexity O(n) time and space in catalog rows, using insertion-ordered Map keys.
  */
 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);
-        // Older cached inventories can attach a default-policy label to a resolved concrete ID.
-        const label = row.id === 'default' || /^default\b/i.test(row.label) ? id : row.label;
-        return [{ ...row, id, 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;
+    return concreteModelOptions(agent);
 }
 export function configuredPickerModel(agent) {
     if (agent.supportsConcreteModelSelection === false)
@@ -52,4 +39,46 @@ export function pickerCatalogNote(agent, t = passthrough) {
         return t('Offline fallback');
     return undefined;
 }
+// The vendor word each CLI's own icon already shows beside the bar label (owner 2026-10-18).
+// Agents not listed keep every word: a Cursor icon says nothing about whether a model is GPT.
+const BAR_VENDOR_WORDS = {
+    claude: ['claude', 'anthropic'],
+    codex: ['gpt', 'openai'],
+    antigravity: ['gemini', 'google'],
+};
+// A bare catalog id ("claude-opus-5-5", "gpt-6-astra[1m]", "anthropic/claude-sonnet-5") rather than a display name.
+const RAW_MODEL_ID = /^(?:[a-z0-9._-]+\/)*[a-z0-9][a-z0-9._-]*(?:\[[^\]]*\])?$/;
+const BRAND_CASING = { gpt: 'GPT' };
+function prettifyRawModelId(id) {
+    // A routing prefix ("anthropic/") is the full name's job; the bar names only the model.
+    const tokens = id.slice(id.lastIndexOf('/') + 1).replace(/\[[^\]]*\]$/, '').split(/[-_]+/).filter((token) => token && !/^\d{8}$/.test(token));
+    const words = [];
+    for (const token of tokens) {
+        const previous = words[words.length - 1];
+        // Dash-separated version digits read as one dotted version: "5-5" → "5.5".
+        if (/^\d+$/.test(token) && previous && /^\d+(?:\.\d+)*$/.test(previous))
+            words[words.length - 1] = `${previous}.${token}`;
+        else
+            words.push(BRAND_CASING[token] ?? token.charAt(0).toUpperCase() + token.slice(1));
+    }
+    return words;
+}
+/**
+ * The composer bar's compact model name: the catalog label (or a prettified raw id when the catalog
+ * has no label), minus the leading vendor word the agent's icon already conveys, capped with "…".
+ * The full label stays in the drop-up list and the trigger's tooltip.
+ * @example shortModelLabel({ label: 'GPT-6.1-Sol', agentId: 'codex' }) // "6.1 Sol"
+ * @example shortModelLabel({ label: 'claude-opus-5-5', agentId: 'claude' }) // "Opus 5.5"
+ * @complexity O(n) in the label length. Pure.
+ */
+export function shortModelLabel({ label, agentId }, { max = 16 } = {}) {
+    const trimmed = label.trim();
+    const raw = RAW_MODEL_ID.test(trimmed);
+    const words = raw ? prettifyRawModelId(trimmed) : trimmed.split(/[\s-]+/).filter(Boolean);
+    const vendors = (agentId && BAR_VENDOR_WORDS[agentId]) || [];
+    const dropVendor = words.length > 1 && vendors.includes(words[0].toLowerCase());
+    // A display name with no vendor word to drop is shown as the catalog wrote it.
+    const short = dropVendor ? words.slice(1).join(' ') : raw ? words.join(' ') : trimmed;
+    return short.length > max ? `${short.slice(0, max - 1).trimEnd()}…` : short;
+}
 //# sourceMappingURL=model-options.js.map

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

@@ -108,7 +108,7 @@ export declare function isChatPaneQueueableBlocker({ blocker }: {
  *
  * A surface is attributed to the newest call still open when it arrived — the same rule
  * `useExtEventGroups` uses to give a card its `call` — so an older call returning does not settle
- * it. Once its call returns (answered, expired, abandoned), typing is a next turn again.
+ * it. A terminal run, a later turn, a returned call or an accepted answer receipt closes it.
  *
  * @complexity O(e·c): e events in the newest message, c calls open at once (one or two in practice).
  */
@@ -118,8 +118,7 @@ export declare function isAwaitingTypedAnswer({ messages, toolName }: {
 }): boolean;
 /**
  * The tool-use id of the question {@link isAwaitingTypedAnswer} sees waiting, or `null` — the newest
- * one when several are open. The id lets the pane tell one question from the next: a draft typed
- * for a question stays tied to THAT question after it closes (see `useChatPane`'s held answer).
+ * one when several are open. Only an active assistant run can hold a question open.
  *
  * @complexity O(e·c), as {@link isAwaitingTypedAnswer}.
  */
@@ -143,20 +142,20 @@ export declare function isTypedAnswerTurn({ blocker, attachmentCount, messages,
 }): boolean;
 /**
  * The run a composer send can go INTO instead of queueing behind, or `null`: a run is streaming
- * ({@link isChatPaneQueueableBlocker}), the turn has no attachments (a mid-run message carries text
- * only — the live agent's stdin takes no files), and the newest message is that run's assistant
+ * ({@link isChatPaneQueueableBlocker}), and the newest message is that run's assistant
  * turn with a known `runId`.
+ * Attachment support is decided by the host's delivery, never by dropping them here.
  *
  * @complexity O(1).
  */
-export declare function findMidRunMessageRunId({ blocker, attachmentCount, messages }: {
+export declare function findMidRunMessageRunId({ blocker, messages }: {
     blocker: ChatPaneSendBlocker | null;
     attachmentCount: number;
     messages: readonly ChatMessage[];
 }): string | null;
 /**
- * The queued next turn after one more message joins it. The pane holds ONE queued turn, so a second
- * message sent behind the same run is appended to it (a blank line apart) rather than replacing it:
+ * MOVE: Display is per-message; delivery is ONE queued turn. A second message behind the same run
+ * is appended to that delivery (a blank line apart) rather than replacing it:
  * replacing silently dropped the first message (owner, 2026-10-10). One turn, not two, because both
  * were written for the run still going and the agent should read them together — two queued turns
  * would also start two paid runs back to back.
@@ -166,7 +165,7 @@ export declare function findMidRunMessageRunId({ blocker, attachmentCount, messa
 export declare function appendQueuedTurn({ queued, next }: {
     queued: UserTextRedaction | null;
     next: UserTextRedaction;
-}): UserTextRedaction;
+}, _options?: {}): UserTextRedaction;
 /** The English copy (and i18n key) for why a typed answer was not sent. */
 export declare function describeTypedAnswerNotice({ notice }: {
     notice: TypedAnswerNotice;