-
);
@@ -60,11 +90,12 @@ export function ReasoningBlock({
return (
- {/* Clickable summary row: chevron + label */}
+ {/* Clickable summary row: chevron + label. Same SUMMARY_ROW_CLASS the
+ pending row above uses, plus the interactive-only extras. */}
setIsExpanded((prev) => !prev)}
- className="flex items-center gap-2 cursor-pointer bg-transparent border-none p-0 text-left w-full"
+ className={`${SUMMARY_ROW_CLASS} cursor-pointer bg-transparent border-none`}
aria-expanded={isExpanded}
aria-label="Toggle reasoning details"
>
diff --git a/src/components/__tests__/ChatBubble.test.tsx b/src/components/__tests__/ChatBubble.test.tsx
index cbd76ef2..ce482ff0 100644
--- a/src/components/__tests__/ChatBubble.test.tsx
+++ b/src/components/__tests__/ChatBubble.test.tsx
@@ -394,14 +394,28 @@ describe('ChatBubble', () => {
content=""
index={0}
isThinkingPending={true}
+ pendingLabel="Starting up the model…"
/>,
);
expect(screen.getByTestId('reasoning-block')).toBeInTheDocument();
expect(screen.getByTestId('loading-label').textContent).toBe(
- 'Warming up...',
+ 'Starting up the model…',
);
});
+ it('renders bare dots for the pending /think placeholder before the engine label threshold elapses', () => {
+ render(
+ {
expect(container.innerHTML).toBe('');
});
- it('shows the pending placeholder label before thinking tokens arrive', () => {
+ it('renders bare dots with no label when pending and no pendingLabel is supplied', () => {
render((null);
const phaseRef = useRef('idle');
@@ -57,14 +74,14 @@ export function useEngineLoadingLabel(
timersRef.current = [];
};
- // Enters (or no-ops if already in) phase 2: cancels any pending phase-1
- // timers and schedules phase 2's own independent sequence, timed from
- // now rather than from when the turn began.
+ // Enters (or no-ops if already in) phase 2: cancels any pending timers
+ // from the "waiting" phase and schedules phase 2's own independent
+ // sequence, timed from now rather than from when the turn began.
const enterPhase2 = () => {
if (phaseRef.current === 'phase2') return;
phaseRef.current = 'phase2';
clearTimers();
- // eslint-disable-next-line @eslint-react/set-state-in-effect -- intended: the real warming signal must override whatever phase-1 filler is showing the instant it fires
+ // eslint-disable-next-line @eslint-react/set-state-in-effect -- intended: the real warming signal must override whatever filler is showing the instant it fires
setLabel(ENGINE_PHASE2_PHRASES[0]);
timersRef.current.push(
setTimeout(
@@ -74,10 +91,11 @@ export function useEngineLoadingLabel(
);
};
- // Turn lifecycle: (re)starts phase 1 when the turn becomes active for a
- // local provider, tears everything down when it ends. Deliberately does
- // NOT depend on `warming` - a warming flip must never restart this effect,
- // or an in-progress phase 2 would be clobbered back to phase 1's schedule.
+ // Turn lifecycle: (re)starts the "waiting" schedule when the turn becomes
+ // active for a local provider, tears everything down when it ends.
+ // Deliberately does NOT depend on `warming` or `engineState` - either
+ // changing later must never restart this effect, or an in-progress phase
+ // 2 (or an already-decided cold-vs-warm schedule) would be clobbered.
useEffect(() => {
if (!active || !LOCAL_PROVIDER_KINDS.has(providerKind)) {
phaseRef.current = 'idle';
@@ -87,22 +105,34 @@ export function useEngineLoadingLabel(
return;
}
- phaseRef.current = 'phase1';
+ phaseRef.current = 'waiting';
// eslint-disable-next-line @eslint-react/set-state-in-effect -- intended: a fresh turn always starts dots-only until the threshold elapses
setLabel(null);
- timersRef.current = ENGINE_PHASE1_PHRASES.map((phrase, i) =>
- // eslint-disable-next-line @eslint-react/web-api-no-leaked-timeout -- cleared via clearTimers() on the next transition
- setTimeout(
- () => setLabel(phrase),
- ENGINE_LOADING_THRESHOLD_MS + i * ENGINE_PHASE1_INTERVAL_MS,
- ),
- );
+
+ if (providerKind === 'builtin' && engineState === 'loaded') {
+ timersRef.current = [
+ // eslint-disable-next-line @eslint-react/web-api-no-leaked-timeout -- cleared via clearTimers() on the next transition
+ setTimeout(
+ () => setLabel(ENGINE_SLOW_WARM_LABEL),
+ ENGINE_LOADING_THRESHOLD_MS,
+ ),
+ ];
+ } else {
+ timersRef.current = ENGINE_PHASE1_PHRASES.map((phrase, i) =>
+ // eslint-disable-next-line @eslint-react/web-api-no-leaked-timeout -- cleared via clearTimers() on the next transition
+ setTimeout(
+ () => setLabel(phrase),
+ ENGINE_LOADING_THRESHOLD_MS + i * ENGINE_PHASE1_INTERVAL_MS,
+ ),
+ );
+ }
return clearTimers;
+ // eslint-disable-next-line @eslint-react/exhaustive-deps -- intended: warming/engineState are deliberately excluded, see the comment above
}, [active, providerKind]);
// Reacts to the real warming signal the instant it fires, independent of
- // how far phase 1's timer has progressed.
+ // how far the "waiting" schedule has progressed.
useEffect(() => {
if (!active || !LOCAL_PROVIDER_KINDS.has(providerKind)) return;
if (warming) enterPhase2();
diff --git a/src/hooks/useEngineWarmupStatus.ts b/src/hooks/useEngineWarmupStatus.ts
index e98cb5d0..97a1b488 100644
--- a/src/hooks/useEngineWarmupStatus.ts
+++ b/src/hooks/useEngineWarmupStatus.ts
@@ -1,10 +1,11 @@
/**
- * Live snapshot of the built-in engine's prefill-priming state, sourced from
- * the same global Tauri events the Settings Providers pane uses for its
- * "Warming up…" status line (`warmup:builtin-warming` / `warmup:builtin-warmed`,
+ * Live snapshot of the built-in engine's lifecycle, sourced from the same
+ * global Tauri events the Settings Providers pane uses for its status line
+ * (`engine:status`, `warmup:builtin-warming` / `warmup:builtin-warmed`, all
* emitted app-wide so any window can subscribe). Ollama has no equivalent
- * signal — Thuki does not manage its process — so `warming` never flips true
- * while Ollama is the active provider.
+ * signal for either, since Thuki does not manage its process, so `warming`
+ * never flips true and `engineState` stays at its initial value while
+ * Ollama is the active provider.
*
* Meant to be mounted once near the app root (the main window's React tree
* stays alive for the app's lifetime, even while hidden), so the value is
@@ -15,21 +16,26 @@
import { useEffect, useState } from 'react';
import { listen, type UnlistenFn } from '@tauri-apps/api/event';
+import type { EngineStatus } from '../types/starter';
export interface EngineWarmupStatus {
/** True while the built-in engine is priming the system-prompt prefix. */
warming: boolean;
+ /** The built-in engine's last known lifecycle state. */
+ engineState: EngineStatus['state'];
}
export function useEngineWarmupStatus(): EngineWarmupStatus {
const [warming, setWarming] = useState(false);
+ const [engineState, setEngineState] =
+ useState('stopped');
useEffect(() => {
let cancelled = false;
const unlisteners: UnlistenFn[] = [];
- const subscribe = (event: string, handler: () => void) => {
- void listen(event, handler)
+ const subscribe = (event: string, handler: (payload: T) => void) => {
+ void listen(event, (e) => handler(e.payload))
.then((stop) => {
if (cancelled) {
stop();
@@ -44,6 +50,9 @@ export function useEngineWarmupStatus(): EngineWarmupStatus {
subscribe('warmup:builtin-warming', () => setWarming(true));
subscribe('warmup:builtin-warmed', () => setWarming(false));
+ subscribe('engine:status', (status) =>
+ setEngineState(status.state),
+ );
return () => {
cancelled = true;
@@ -51,5 +60,5 @@ export function useEngineWarmupStatus(): EngineWarmupStatus {
};
}, []);
- return { warming };
+ return { warming, engineState };
}
diff --git a/src/view/ConversationView.tsx b/src/view/ConversationView.tsx
index 2f4b6f5f..a72ef4b8 100644
--- a/src/view/ConversationView.tsx
+++ b/src/view/ConversationView.tsx
@@ -120,6 +120,13 @@ interface ConversationViewProps {
* mounted once near the app root. Only ever true for the built-in engine.
*/
engineWarming?: boolean;
+ /**
+ * Live `engine:status` state from the same hook, describing only the
+ * built-in engine (meaningless for Ollama). Lets the loading label skip
+ * "starting up" language when the engine was already resident at the
+ * moment a turn began.
+ */
+ engineState?: string;
}
/**
@@ -155,27 +162,30 @@ export function ConversationView({
isExportOpen,
providerKind = '',
engineWarming = false,
+ engineState = 'stopped',
}: ConversationViewProps) {
const scrollContainerRef = useRef(null);
// True while the trailing assistant message is waiting on its first token
- // from a plain (non-search, non-think) chat turn - the exact condition
- // that renders the bare-dots loading row below. Drives the cold-start
- // label timer; think/search turns render their own loading state inside
- // ChatBubble and never reach this row.
+ // (or, for a /think turn, its first thinking token) from a non-search chat
+ // turn. Search turns render their own loading state inside ChatBubble's
+ // SearchTraceBlock and never reach this. Drives the cold-start label timer
+ // for BOTH surfaces: the bare-dots row below (plain turns) and, for a
+ // /think turn, the pending state inside ReasoningBlock (see `pendingLabel`
+ // below) - one shared source of truth for the cue instead of two.
const lastMessage = messages[messages.length - 1];
const isAwaitingFirstToken = Boolean(
isGenerating &&
lastMessage?.role === 'assistant' &&
!lastMessage?.content &&
!lastMessage?.thinkingContent &&
- !lastMessage?.fromSearch &&
- !lastMessage?.fromThink,
+ !lastMessage?.fromSearch,
);
const engineLoadingLabel = useEngineLoadingLabel(
isAwaitingFirstToken,
providerKind,
engineWarming,
+ engineState,
);
/** Threshold in pixels - if within this distance of the bottom, consider "near bottom". */
@@ -329,6 +339,7 @@ export function ConversationView({
onSwitchModel={onSwitchModel}
thinkingContent={msg.thinkingContent}
isThinkingPending={isThinkingPending}
+ pendingLabel={engineLoadingLabel}
// "Still thinking" reflects the real stream state, not whether
// /think was used: thinking tokens have arrived, the answer has
// not started, and the turn is still generating (isLastAssistant
@@ -355,8 +366,10 @@ export function ConversationView({
{/* Loading row: always show 9-dot indicator when waiting for first
content. For search turns, show the stage label inline as plain
text next to the dots; for a plain turn stuck behind a cold
- provider spin-up, show the engine loading label instead. */}
- {isAwaitingFirstToken ? (
+ provider spin-up, show the engine loading label instead. A
+ /think turn gets the same engine label, but rendered inside its
+ own ChatBubble (ReasoningBlock's pending state) rather than here. */}
+ {isAwaitingFirstToken && !lastMessage?.fromThink ? (
{
/>,
);
expect(screen.getByTestId('reasoning-block')).toBeInTheDocument();
+ expect(screen.queryByTestId('loading-label')).toBeNull();
+ });
+
+ it('shows the shared engine loading label inside the /think pending placeholder for a builtin cold start', () => {
+ vi.useFakeTimers();
+ render(
+