@tuturuuu/ui 0.32.0 → 0.33.0

package/src/components/ui/calendar-app/components/refresh-calendar-sync-status.test.tsx

@@ -0,0 +1,321 @@
+import {
+  focusManager,
+  onlineManager,
+  QueryClient,
+  QueryClientProvider,
+  useQuery,
+} from '@tanstack/react-query';
+import { act, renderHook } from '@testing-library/react';
+import type { CalendarSyncStatusResponse } from '@tuturuuu/internal-api/calendar';
+import {
+  getWorkspaceCalendarSyncStatus,
+  syncWorkspaceCalendar,
+} from '@tuturuuu/internal-api/calendar';
+import type { ReactNode } from 'react';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { runCalendarProviderSync } from '../../../../hooks/calendar-provider-sync';
+import {
+  calendarSyncStatusQueryOptions,
+  refreshCalendarSyncStatus,
+} from './refresh-calendar-sync-status';
+
+vi.mock('@tuturuuu/internal-api/calendar', () => ({
+  getWorkspaceCalendarSyncStatus: vi.fn(),
+  syncWorkspaceCalendar: vi.fn(),
+}));
+const interval = 5 * 60_000;
+let client: QueryClient;
+let status: CalendarSyncStatusResponse;
+const getStatus = vi.mocked(getWorkspaceCalendarSyncStatus);
+const sync = vi.mocked(syncWorkspaceCalendar);
+beforeEach(() => {
+  vi.useFakeTimers();
+  vi.setSystemTime(new Date('2026-09-11T12:00:00Z'));
+  focusManager.setFocused(true);
+  onlineManager.setOnline(true);
+  client = new QueryClient({ defaultOptions: { queries: { retry: false } } });
+  status = {
+    health: {
+      state: 'degraded',
+      reason: 'sync_stale',
+      currentlyRunning: false,
+      lastSuccessAt: null,
+      lastFailureAt: null,
+      retryAfterSeconds: null,
+    },
+    accountsSummary: { total: 1, google: 1, microsoft: 0 },
+    connectionsSummary: { total: 2, enabled: 2 },
+  };
+  getStatus.mockReset().mockImplementation(async () => structuredClone(status));
+  sync.mockReset().mockImplementation(async () => {
+    status.health = {
+      ...status.health,
+      state: 'healthy',
+      reason: 'ok',
+      lastSuccessAt: new Date().toISOString(),
+    };
+    return { ok: true };
+  });
+});
+afterEach(() => {
+  client.clear();
+  vi.restoreAllMocks();
+  focusManager.setFocused(undefined);
+  onlineManager.setOnline(true);
+  vi.useRealTimers();
+});
+
+describe('automatic provider synchronization', () => {
+  it('imports stale calendars and refreshes every loaded event range without touching other workspaces', async () => {
+    client.setQueryData(['databaseCalendarEvents', 'ws', 'week'], []);
+    client.setQueryData(['databaseCalendarEvents', 'ws', 'month'], []);
+    client.setQueryData(['databaseCalendarEvents', 'other'], []);
+    const result = await refreshCalendarSyncStatus(client, 'ws');
+    expect(sync).toHaveBeenCalledExactlyOnceWith('ws');
+    expect(result.health.state).toBe('healthy');
+    expect(
+      client.getQueryState(['databaseCalendarEvents', 'ws', 'week'])
+        ?.isInvalidated
+    ).toBe(true);
+    expect(
+      client.getQueryState(['databaseCalendarEvents', 'ws', 'month'])
+        ?.isInvalidated
+    ).toBe(true);
+    expect(
+      client.getQueryState(['databaseCalendarEvents', 'other'])?.isInvalidated
+    ).toBe(false);
+  });
+
+  it.each(['paused', 'disconnected', 'syncing'] as const)(
+    'does not start a sync when %s',
+    async (state) => {
+      status.health.state = state;
+      status.health.currentlyRunning = state === 'syncing';
+      await refreshCalendarSyncStatus(client, 'ws');
+      expect(sync).not.toHaveBeenCalled();
+    }
+  );
+  it.each(['auth', 'reconnect_required', 'configuration'])(
+    'leaves %s failures for recovery',
+    async (reason) => {
+      status.health.reason = reason;
+      await refreshCalendarSyncStatus(client, 'ws');
+      expect(sync).not.toHaveBeenCalled();
+    }
+  );
+  it('honors cooldowns, disabled calendars and the active-sync switch', async () => {
+    status.health.retryAfterSeconds = 30;
+    await refreshCalendarSyncStatus(client, 'ws');
+    status.health.retryAfterSeconds = null;
+    status.connectionsSummary.enabled = 0;
+    await refreshCalendarSyncStatus(client, 'ws');
+    status.connectionsSummary.enabled = 2;
+    await refreshCalendarSyncStatus(client, 'ws', true);
+    expect(sync).not.toHaveBeenCalled();
+  });
+  it('waits for an in-flight manual sync', async () => {
+    let finish!: () => void;
+    const mutation = client.getMutationCache().build(client, {
+      mutationKey: ['calendar-provider-sync', 'ws'],
+      mutationFn: () =>
+        new Promise<void>((resolve) => {
+          finish = resolve;
+        }),
+    });
+    const pending = mutation.execute(undefined);
+    await vi.advanceTimersByTimeAsync(0);
+    await refreshCalendarSyncStatus(client, 'ws');
+    expect(sync).not.toHaveBeenCalled();
+    finish();
+    await pending;
+  });
+  it('waits until healthy calendars are five minutes old', async () => {
+    status.health.state = 'healthy';
+    status.health.lastSuccessAt = new Date().toISOString();
+    await refreshCalendarSyncStatus(client, 'ws');
+    expect(sync).not.toHaveBeenCalled();
+    vi.advanceTimersByTime(interval);
+    await refreshCalendarSyncStatus(client, 'ws');
+    expect(sync).toHaveBeenCalledOnce();
+  });
+  it('deduplicates overlapping controls while exposing neutral syncing state', async () => {
+    let finish!: () => void;
+    sync.mockImplementationOnce(
+      () =>
+        new Promise((resolve) => {
+          finish = () => resolve({ ok: true });
+        })
+    );
+    const first = refreshCalendarSyncStatus(client, 'ws');
+    await vi.advanceTimersByTimeAsync(0);
+    expect(
+      client.getQueryData<CalendarSyncStatusResponse>([
+        'calendar-sync-status',
+        'ws',
+      ])?.health.currentlyRunning
+    ).toBe(true);
+    await refreshCalendarSyncStatus(client, 'ws');
+    expect(sync).toHaveBeenCalledOnce();
+    finish();
+    await first;
+  });
+  it('backs off after partial failures and still refreshes imported events', async () => {
+    sync.mockResolvedValue({ ok: false, partialFailure: true });
+    const invalidate = vi.spyOn(client, 'invalidateQueries');
+    await refreshCalendarSyncStatus(client, 'ws');
+    expect(invalidate).toHaveBeenCalledWith({
+      queryKey: ['databaseCalendarEvents', 'ws'],
+    });
+    vi.advanceTimersByTime(interval);
+    await refreshCalendarSyncStatus(client, 'ws');
+    expect(sync).toHaveBeenCalledTimes(1);
+    vi.advanceTimersByTime(interval);
+    await refreshCalendarSyncStatus(client, 'ws');
+    expect(sync).toHaveBeenCalledTimes(2);
+    vi.advanceTimersByTime(interval * 2);
+    await refreshCalendarSyncStatus(client, 'ws');
+    expect(sync).toHaveBeenCalledTimes(2);
+  });
+  it('handles network failures quietly and respects provider retry-after', async () => {
+    sync.mockRejectedValueOnce(new Error('Network unavailable'));
+    await expect(
+      refreshCalendarSyncStatus(client, 'ws')
+    ).resolves.toBeDefined();
+    vi.advanceTimersByTime(interval * 2);
+    sync.mockResolvedValueOnce({ ok: false, retryAfterSeconds: 3600 });
+    await refreshCalendarSyncStatus(client, 'ws');
+    vi.advanceTimersByTime(interval * 7);
+    await refreshCalendarSyncStatus(client, 'ws');
+    expect(sync).toHaveBeenCalledTimes(2);
+  });
+  it('does not sync while hidden or offline', async () => {
+    focusManager.setFocused(false);
+    await refreshCalendarSyncStatus(client, 'ws');
+    focusManager.setFocused(true);
+    onlineManager.setOnline(false);
+    await refreshCalendarSyncStatus(client, 'ws');
+    expect(sync).not.toHaveBeenCalled();
+  });
+});
+
+it('polls while open and catches up on focus and reconnect without a manual click', async () => {
+  const wrapper = ({ children }: { children: ReactNode }) => (
+    <QueryClientProvider client={client}>{children}</QueryClientProvider>
+  );
+  const view = renderHook(
+    () => useQuery(calendarSyncStatusQueryOptions(client, 'ws')),
+    { wrapper }
+  );
+  await act(() => vi.advanceTimersByTimeAsync(1));
+  expect(sync).toHaveBeenCalledTimes(1);
+  await act(() => vi.advanceTimersByTimeAsync(interval));
+  expect(sync).toHaveBeenCalledTimes(2);
+  act(() => focusManager.setFocused(false));
+  await act(() => vi.advanceTimersByTimeAsync(interval * 2));
+  expect(sync).toHaveBeenCalledTimes(2);
+  await act(async () => {
+    focusManager.setFocused(true);
+    await vi.advanceTimersByTimeAsync(1);
+  });
+  expect(sync).toHaveBeenCalledTimes(3);
+  act(() => onlineManager.setOnline(false));
+  await act(() => vi.advanceTimersByTimeAsync(interval * 2));
+  expect(sync).toHaveBeenCalledTimes(3);
+  await act(async () => {
+    onlineManager.setOnline(true);
+    await vi.advanceTimersByTimeAsync(1);
+  });
+  expect(sync).toHaveBeenCalledTimes(4);
+  view.unmount();
+  await act(() => vi.advanceTimersByTimeAsync(interval * 2));
+  expect(sync).toHaveBeenCalledTimes(4);
+});
+
+it('shares provider work with legacy/manual sync started during a health fetch', async () => {
+  let finishStatus!: (value: CalendarSyncStatusResponse) => void;
+  let finishSync!: () => void;
+  getStatus.mockImplementationOnce(
+    () =>
+      new Promise((resolve) => {
+        finishStatus = resolve;
+      })
+  );
+  sync.mockImplementationOnce(
+    () =>
+      new Promise((resolve) => {
+        finishSync = () => resolve({ ok: true });
+      })
+  );
+  const polling = refreshCalendarSyncStatus(client, 'ws');
+  const manual = runCalendarProviderSync(client, 'ws');
+  expect(runCalendarProviderSync(client, 'ws')).toBe(manual);
+  finishStatus(structuredClone(status));
+  await polling;
+  expect(sync).toHaveBeenCalledOnce();
+  finishSync();
+  await manual;
+  await runCalendarProviderSync(client, 'ws');
+  expect(sync).toHaveBeenCalledTimes(2);
+});
+
+it('seeds a new session cooldown from the last server failure', async () => {
+  status.health.reason = 'api_limit';
+  status.health.lastFailureAt = new Date().toISOString();
+  await refreshCalendarSyncStatus(client, 'ws');
+  vi.advanceTimersByTime(interval);
+  await refreshCalendarSyncStatus(client, 'ws');
+  expect(sync).not.toHaveBeenCalled();
+  vi.advanceTimersByTime(interval);
+  await refreshCalendarSyncStatus(client, 'ws');
+  expect(sync).toHaveBeenCalledOnce();
+});
+
+it('checks again shortly when another session already started provider work', async () => {
+  sync.mockResolvedValueOnce({ ok: true, alreadyRunning: true });
+  await refreshCalendarSyncStatus(client, 'ws');
+  vi.advanceTimersByTime(29_999);
+  await refreshCalendarSyncStatus(client, 'ws');
+  expect(sync).toHaveBeenCalledTimes(1);
+  vi.advanceTimersByTime(1);
+  await refreshCalendarSyncStatus(client, 'ws');
+  expect(sync).toHaveBeenCalledTimes(2);
+});
+
+it('does not sync a hidden document even when the focus manager reports focused', async () => {
+  vi.spyOn(document, 'visibilityState', 'get').mockReturnValue('hidden');
+  await refreshCalendarSyncStatus(client, 'ws');
+  expect(sync).not.toHaveBeenCalled();
+});
+
+it('treats a healthy response with no success timestamp as stale but throttles retries', async () => {
+  status.health.state = 'healthy';
+  sync.mockResolvedValue({ ok: true });
+  await refreshCalendarSyncStatus(client, 'ws');
+  await refreshCalendarSyncStatus(client, 'ws');
+  expect(sync).toHaveBeenCalledOnce();
+  vi.advanceTimersByTime(interval);
+  await refreshCalendarSyncStatus(client, 'ws');
+  expect(sync).toHaveBeenCalledTimes(2);
+});
+
+it('refreshes event ranges after another session finishes importing, not on its pending response', async () => {
+  const invalidate = vi.spyOn(client, 'invalidateQueries');
+  sync.mockImplementationOnce(async () => {
+    status.health.state = 'syncing';
+    status.health.currentlyRunning = true;
+    return { ok: true, alreadyRunning: true };
+  });
+  await refreshCalendarSyncStatus(client, 'ws');
+  expect(invalidate).not.toHaveBeenCalled();
+  status.health.state = 'healthy';
+  status.health.currentlyRunning = false;
+  status.health.lastSuccessAt = new Date().toISOString();
+  await refreshCalendarSyncStatus(client, 'ws');
+  expect(invalidate).toHaveBeenCalledWith({
+    queryKey: ['databaseCalendarEvents', 'ws'],
+  });
+  expect(sync).toHaveBeenCalledOnce();
+  invalidate.mockClear();
+  await refreshCalendarSyncStatus(client, 'ws');
+  expect(invalidate).not.toHaveBeenCalled();
+});

package/src/components/ui/calendar-app/components/refresh-calendar-sync-status.ts

@@ -0,0 +1,182 @@
+import {
+  focusManager,
+  onlineManager,
+  type QueryClient,
+  queryOptions,
+} from '@tanstack/react-query';
+import type { CalendarSyncStatusResponse } from '@tuturuuu/internal-api/calendar';
+import { getWorkspaceCalendarSyncStatus } from '@tuturuuu/internal-api/calendar';
+
+import {
+  isCalendarProviderSyncRunning,
+  runCalendarProviderSync,
+} from '../../../../hooks/calendar-provider-sync';
+
+const SYNC_INTERVAL_MS = 5 * 60_000;
+const MAX_BACKOFF_MS = 30 * 60_000;
+type Attempt = { running: boolean; nextAt: number; failures: number };
+// All calendar controls in one app share a coordinator, scoped to their session.
+const attempts = new WeakMap<QueryClient, Map<string, Attempt>>();
+
+const observedHealth = new WeakMap<
+  QueryClient,
+  Map<string, CalendarSyncStatusResponse['health']>
+>();
+
+function observeSyncCompletion(
+  client: QueryClient,
+  wsId: string,
+  status: CalendarSyncStatusResponse
+) {
+  let workspaces = observedHealth.get(client);
+  if (!workspaces) {
+    workspaces = new Map();
+    observedHealth.set(client, workspaces);
+  }
+  const previous = workspaces.get(wsId);
+  const health = status.health;
+  workspaces.set(wsId, { ...health });
+  return (
+    !!previous &&
+    !health.currentlyRunning &&
+    (previous.currentlyRunning ||
+      previous.lastSuccessAt !== health.lastSuccessAt ||
+      previous.lastFailureAt !== health.lastFailureAt)
+  );
+}
+
+async function invalidateImportedEvents(client: QueryClient, wsId: string) {
+  await Promise.all([
+    client.invalidateQueries({ queryKey: ['databaseCalendarEvents', wsId] }),
+    client.invalidateQueries({ queryKey: ['provider-calendar-list', wsId] }),
+  ]);
+}
+
+export function calendarSyncStatusQueryOptions(
+  queryClient: QueryClient,
+  wsId: string,
+  syncBlocked = false
+) {
+  return queryOptions({
+    queryKey: ['calendar-sync-status', wsId],
+    queryFn: () => refreshCalendarSyncStatus(queryClient, wsId, syncBlocked),
+    enabled: !!wsId,
+    staleTime: 15_000,
+    refetchOnWindowFocus: 'always',
+    refetchOnReconnect: 'always',
+    refetchIntervalInBackground: false,
+    retry: 1,
+    refetchInterval: (query) =>
+      query.state.data?.health.currentlyRunning ||
+      query.state.data?.health.retryAfterSeconds
+        ? 5_000
+        : 30_000,
+  });
+}
+
+/** The foreground health poll also keeps connected providers up to date. */
+export async function refreshCalendarSyncStatus(
+  queryClient: QueryClient,
+  wsId: string,
+  syncBlocked = false
+): Promise<CalendarSyncStatusResponse> {
+  const status = await getWorkspaceCalendarSyncStatus(wsId);
+  const { health } = status;
+  if (observeSyncCompletion(queryClient, wsId, status)) {
+    await invalidateImportedEvents(queryClient, wsId);
+  }
+  const now = Date.now();
+  let workspaceAttempts = attempts.get(queryClient);
+  if (!workspaceAttempts) {
+    workspaceAttempts = new Map();
+    attempts.set(queryClient, workspaceAttempts);
+  }
+  const previous = workspaceAttempts.get(wsId);
+  const lastSuccess = Date.parse(health.lastSuccessAt ?? '');
+  const lastFailure = Date.parse(health.lastFailureAt ?? '');
+  const recentFailure =
+    health.state === 'degraded' && now - lastFailure < SYNC_INTERVAL_MS * 2;
+  if (
+    !focusManager.isFocused() ||
+    !onlineManager.isOnline() ||
+    (typeof document !== 'undefined' &&
+      document.visibilityState === 'hidden') ||
+    syncBlocked ||
+    recentFailure ||
+    isCalendarProviderSyncRunning(queryClient, wsId) ||
+    queryClient.isMutating({ mutationKey: ['calendar-provider-sync', wsId] }) >
+      0 ||
+    previous?.running ||
+    (previous?.nextAt ?? 0) > now ||
+    !status.accountsSummary.total ||
+    !status.connectionsSummary.enabled ||
+    health.currentlyRunning ||
+    health.state === 'paused' ||
+    health.state === 'disconnected' ||
+    (health.retryAfterSeconds ?? 0) > 0 ||
+    ['auth', 'reconnect_required', 'configuration'].includes(health.reason) ||
+    // Missing or malformed timestamps are treated as stale, with normal throttling.
+    (health.state === 'healthy' &&
+      Number.isFinite(lastSuccess) &&
+      now - lastSuccess < SYNC_INTERVAL_MS)
+  )
+    return status;
+
+  const attempt: Attempt = {
+    running: true,
+    nextAt: now + SYNC_INTERVAL_MS,
+    failures: previous?.failures ?? 0,
+  };
+  workspaceAttempts.set(wsId, attempt);
+  queryClient.setQueryData(['calendar-sync-status', wsId], {
+    ...status,
+    health: { ...health, state: 'syncing', currentlyRunning: true },
+  });
+  let failed = false;
+  let alreadyRunning = false;
+  try {
+    const result = await runCalendarProviderSync(queryClient, wsId);
+    alreadyRunning = !!result.alreadyRunning;
+    if (alreadyRunning) attempt.nextAt = Date.now() + 30_000;
+    failed = !result.ok;
+    if (result.retryAfterSeconds) {
+      attempt.nextAt = Math.max(
+        attempt.nextAt,
+        Date.now() + result.retryAfterSeconds * 1000
+      );
+    }
+  } catch {
+    // Polling failures stay in the recovery UI; background work never spams toasts.
+    failed = true;
+  } finally {
+    attempt.running = false;
+    if (!alreadyRunning) attempt.failures = failed ? attempt.failures + 1 : 0;
+    if (!alreadyRunning)
+      attempt.nextAt = Math.max(
+        attempt.nextAt,
+        Date.now() +
+          Math.min(
+            MAX_BACKOFF_MS,
+            SYNC_INTERVAL_MS * 2 ** Math.min(attempt.failures, 3)
+          )
+      );
+    // Only completed requests can have imported changes. Remote runs are
+    // observed by subsequent health polls before their ranges are invalidated.
+    if (!alreadyRunning) await invalidateImportedEvents(queryClient, wsId);
+  }
+  const refreshed = await getWorkspaceCalendarSyncStatus(wsId);
+  const remoteCompleted = observeSyncCompletion(queryClient, wsId, refreshed);
+  if (alreadyRunning && remoteCompleted)
+    await invalidateImportedEvents(queryClient, wsId);
+  if (failed && refreshed.health.state === 'healthy') {
+    return {
+      ...refreshed,
+      health: {
+        ...refreshed.health,
+        state: 'degraded',
+        reason: 'last_run_failed',
+      },
+    };
+  }
+  return refreshed;
+}

package/src/components/ui/calendar-app/components/use-calendar-connections-manager.ts

@@ -3,10 +3,8 @@ import {
   getGoogleCalendarAuthUrl,
   getWorkspaceCalendarDefaultSource,
   getWorkspaceCalendarSyncPreferences,
-  getWorkspaceCalendarSyncStatus,
   listCalendarAccounts,
   listProviderCalendars,
-  syncWorkspaceCalendar,
   updateCalendarConnection as updateCalendarConnectionRequest,
   updateWorkspaceCalendarDefaultSource,
   updateWorkspaceCalendarSyncPreferences,
@@ -15,6 +13,7 @@ import { createClient } from '@tuturuuu/supabase/next/client';
 import { useRouter } from 'next/navigation';
 import { useTranslations } from 'next-intl';
 import { useMemo, useState } from 'react';
+import { runCalendarProviderSync } from '../../../../hooks/calendar-provider-sync';
 import { useCalendarSync } from '../../../../hooks/use-calendar-sync';
 import { toast } from '../../sonner';
 import {
@@ -25,6 +24,7 @@ import {
 } from './calendar-connections-manager-helpers';
 import type { AuthResponse } from './calendar-types';
 import { mergeProviderCalendarsByAccount } from './merge-provider-calendars';
+import { calendarSyncStatusQueryOptions } from './refresh-calendar-sync-status';
 
 export type CalendarConnectionsUnifiedVariant =
   | 'compact'
@@ -57,11 +57,13 @@ export function useCalendarConnectionsManager(wsId: string) {
     updateCalendarConnection,
     setCalendarConnections,
     syncToTuturuuu,
+    isActiveSyncOn,
     isSyncing,
   } = useCalendarSync();
 
   const syncMutation = useMutation({
-    mutationFn: () => syncWorkspaceCalendar(wsId),
+    mutationKey: ['calendar-provider-sync', wsId],
+    mutationFn: () => runCalendarProviderSync(queryClient, wsId),
     onSuccess: (result) => {
       if (!result.ok) toast.error(t('sync_recovery.partial_failure'));
       else if (result.alreadyRunning) toast.info(t('syncing_calendars'));
@@ -116,17 +118,13 @@ export function useCalendarConnectionsManager(wsId: string) {
   const accounts = accountsQuery.data?.accounts || [];
   const isLoadingAccounts = accountsQuery.isLoading;
   const hasConnectedAccounts = accounts.length > 0;
-  const syncStatusQuery = useQuery({
-    queryKey: ['calendar-sync-status', wsId],
-    queryFn: () => getWorkspaceCalendarSyncStatus(wsId),
-    staleTime: 15_000,
-    retry: 1,
-    refetchInterval: (query) =>
-      query.state.data?.health.currentlyRunning ||
-      query.state.data?.health.retryAfterSeconds
-        ? 5_000
-        : 30_000,
-  });
+  const syncStatusQuery = useQuery(
+    calendarSyncStatusQueryOptions(
+      queryClient,
+      wsId,
+      isSyncing || !isActiveSyncOn
+    )
+  );
   const syncStatusData = syncStatusQuery.data;
 
   const { data: defaultSourceData } = useQuery({

package/src/components/ui/chat/ai-message-parts.test.tsx

@@ -0,0 +1,47 @@
+import { render, screen } from '@testing-library/react';
+import { expect, it, vi } from 'vitest';
+import { AiMessageParts } from './ai-message-parts';
+
+vi.mock('next-intl', () => ({ useTranslations: () => (key: string) => key }));
+vi.mock('./ai-message-markdown', () => ({
+  AssistantMarkdown: ({ text }: { text: string }) => <p>{text}</p>,
+}));
+vi.mock('./ai-message-tool-part', () => ({
+  isAiToolPart: (part: { type: string }) => part.type === 'dynamic-tool',
+  ToolGroup: ({ parts }: { parts: { toolCallId: string }[] }) => (
+    <div>{parts.map((part) => part.toolCallId).join(',')}</div>
+  ),
+}));
+
+it('keeps text between tool batches in the rendered history timeline', () => {
+  const { container } = render(
+    <AiMessageParts
+      parts={[
+        { type: 'text', text: 'Before lookup' },
+        { type: 'dynamic-tool', toolCallId: 'lookup-1' },
+        { type: 'dynamic-tool', toolCallId: 'lookup-2' },
+        { type: 'text', text: 'After lookup' },
+        { type: 'dynamic-tool', toolCallId: 'save-1' },
+        { type: 'text', text: 'Saved' },
+      ]}
+    />
+  );
+  expect(container.textContent).toBe(
+    'Before lookuplookup-1,lookup-2After lookupsave-1Saved'
+  );
+  expect(screen.getByText('lookup-1,lookup-2')).toBeInTheDocument();
+});
+
+it('restores compact text references in place without duplicating fallback text', () => {
+  const { container } = render(
+    <AiMessageParts
+      textFallback={'Before\n\nAfter'}
+      parts={[
+        { type: 'text', textStart: 0, textLength: 6 },
+        { type: 'dynamic-tool', toolCallId: 'lookup' },
+        { type: 'text', textStart: 8, textLength: 5 },
+      ]}
+    />
+  );
+  expect(container.textContent).toBe('BeforelookupAfter');
+});

package/src/components/ui/chat/ai-message-parts.tsx

@@ -51,27 +51,34 @@ export function AiMessageParts({
     thinking: t('ai_thinking_mode'),
     thought: t('ai_thought'),
   };
-  const contentParts = normalizedParts.filter((part) => !isAiToolPart(part));
-  const toolParts = normalizedParts.filter(isAiToolPart);
+  const groups: AiMessagePart[][] = [];
+  for (const part of normalizedParts) {
+    const previous = groups.at(-1);
+    if (isAiToolPart(part) && previous?.every(isAiToolPart))
+      previous.push(part);
+    else groups.push([part]);
+  }
 
   if (normalizedParts.length === 0) return null;
 
   return (
     <div className={cn('flex min-w-0 max-w-full flex-col gap-2', className)}>
-      {contentParts.map((part, index) => (
-        <AiPartRenderer
-          isStreaming={Boolean(isStreaming)}
-          key={getPartKey(part, index)}
-          labels={labels}
-          part={part}
-        />
-      ))}
-      {toolParts.length > 0 && (
-        <ToolGroup
-          isStreaming={Boolean(isStreaming)}
-          labels={labels}
-          parts={toolParts}
-        />
+      {groups.map((group, index) =>
+        isAiToolPart(group[0]!) ? (
+          <ToolGroup
+            key={getPartKey(group[0]!, index)}
+            isStreaming={Boolean(isStreaming)}
+            labels={labels}
+            parts={group}
+          />
+        ) : (
+          <AiPartRenderer
+            key={getPartKey(group[0]!, index)}
+            isStreaming={Boolean(isStreaming)}
+            labels={labels}
+            part={group[0]!}
+          />
+        )
       )}
     </div>
   );