@@ -0,0 +1,14 @@
+---
+'@object-ui/plugin-chatbot': patch
+---
+
+fix(plugin-chatbot): an assistant answer's chart is still there after a reload
+
+Clause-②: yes (widening)
+Metadata-protocol: none
+
+The live stream draws a chart from a transient `data-chart` part that the server never stores, so a reloaded answer used to come back as text only. The `visualize_data` tool result is stored, and its `chart` key holds the same descriptor the part carried. The chat now reads it back:
+
+- **Server history.** A stored message with no `data-chart` part takes its charts from its `visualize_data` results, each placed where its tool part sat among the text. The chart has the same title, series labels and rows as the live one. The result's top-level `rows`, a preview cut for the model's narration, are never drawn. A result stored before the producer wrote `chart` gets no chart, and nothing is rebuilt from its other keys.
+- **API mode.** `useObjectChat` rebuilds a hydrated message's `charts` into the store as `data-chart` parts between the text runs they sat between, so the chart keeps its place after the round trip. A live message that carries both the part and the result still draws the chart once.
+- **New exports** on the package root and `@object-ui/plugin-chatbot/core`: `chartsFromParts(parts)` returns a stored message's charts with their `textOffset`, and `chartAnswerParts(content, charts)` is its inverse (text runs with `data-chart` parts between them), plus the `ChartAnswerPart` type. The console uses both to restore charts from server history and from its message cache.
@@ -68,6 +68,7 @@ import {
   detectAuthoringVerdict,
   detectBuiltAppPackage,
   buildProgressFromDraftReview,
+  chartsFromParts,
   // The authoring/honest -> runtime message seam (objectui#4399 / PR #4416),
   // consumed here one hop up from the plugin's own renderers (objectui#4437).
   // See `runtimeMessages` below for why this host calls it exactly once.
@@ -294,12 +295,20 @@ export function hydratedMessagesToChatMessages(messages: HydratedUIMessage[]): C
       }
     }
 
+    // objectstack#25908 — the answer's charts, read off the `data-chart`
+    // parts the cache wrote or the `visualize_data` results the server
+    // persisted, each at the offset into `content` where its part sat. The
+    // live stream's chart part is never stored, so this is the only way a
+    // chart survives a reload.
+    const charts = message.role === 'assistant' ? chartsFromParts(message.parts) : undefined;
+
     return {
       id: message.id,
       role: message.role,
       content,
       ...(toolInvocations.length > 0 ? { toolInvocations } : {}),
       ...(buildProgress ? { buildProgress } : {}),
+      ...(charts ? { charts } : {}),
     };
   });
 }
 
@@ -0,0 +1,130 @@
+// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
+
+/**
+ * objectstack#25908 — an assistant answer's chart is still there after a
+ * reload, from either place a reload restores a conversation from:
+ *
+ *  - Server history: rows → `toUIMessages` (merges the `visualize_data` result
+ *    onto its call part) → `hydratedMessagesToChatMessages`. The stream's
+ *    `data-chart` part was never stored; the result's `chart` key was.
+ *  - Cache fallback: the live map → `sanitizeChatMessagesForCache` → JSON →
+ *    `hydratedMessagesToChatMessages`.
+ *
+ * The reference is the chart the live mapper draws from the streamed part, so
+ * "restored" means the same title, series labels and every row. The reader and
+ * the API-mode round trip are pinned in plugin-chatbot's
+ * `mapMessages.persistedChart-25908.test.ts` and
+ * `useObjectChat.persistedChart-25908.test.tsx`.
+ */
+import { describe, expect, it } from 'vitest';
+import { uiMessageToChatMessage } from '@object-ui/plugin-chatbot';
+import { hydratedMessagesToChatMessages } from '../AiChatPage';
+import { sanitizeChatMessagesForCache, toUIMessages } from '../../../hooks/useChatConversation';
+
+const ROWS = Array.from({ length: 30 }, (_, i) => ({ stage: `stage_${i}`, amount: i * 10 }));
+
+const DESCRIPTOR = {
+  type: 'chart',
+  chartType: 'bar',
+  title: 'Pipeline by stage',
+  data: ROWS,
+  xAxisKey: 'stage',
+  series: [{ dataKey: 'amount', label: 'Amount' }],
+};
+
+const resultString = (withChart: boolean) =>
+  JSON.stringify({
+    rendered: 'chart',
+    chartType: 'bar',
+    object: 'opportunity',
+    dimension: 'stage',
+    measures: ['amount'],
+    categories: 30,
+    rows: ROWS.slice(0, 20),
+    ...(withChart ? { chart: DESCRIPTOR } : {}),
+  });
+
+const INTRO = 'Here is the pipeline.\n\n';
+const AFTER = 'Most of it sits in the late stages.';
+
+/** The chart the live stream draws: the reference a restored chart must equal. */
+const LIVE_CHART = uiMessageToChatMessage({
+  id: 'live',
+  role: 'assistant',
+  parts: [{ type: 'data-chart', id: 'chart-0', data: DESCRIPTOR }],
+}).charts![0];
+
+/** The stored turn, as the server persists it: the call, then its result row. */
+function serverHistory(withChart: boolean) {
+  return toUIMessages([
+    { id: 'u1', role: 'user', content: 'Show me the pipeline' },
+    {
+      id: 'a1',
+      role: 'assistant',
+      content: [
+        { type: 'text', text: INTRO },
+        { type: 'tool-call', toolCallId: 'call_1', toolName: 'visualize_data', input: {} },
+        { type: 'text', text: AFTER },
+      ],
+    },
+    {
+      id: 't1',
+      role: 'tool',
+      content: [
+        {
+          type: 'tool-result',
+          toolCallId: 'call_1',
+          toolName: 'visualize_data',
+          output: { type: 'text', value: resultString(withChart) },
+        },
+      ],
+    },
+  ]);
+}
+
+describe('a reloaded answer keeps its chart (objectstack#25908)', () => {
+  it('server history: the persisted chart comes back, between the text it sat between', () => {
+    const [, answer] = hydratedMessagesToChatMessages(serverHistory(true));
+    expect(answer.content).toBe(`${INTRO}${AFTER}`);
+    expect(answer.charts).toEqual([{ ...LIVE_CHART, textOffset: INTRO.length }]);
+    expect(answer.charts?.[0]?.data).toHaveLength(30);
+  });
+
+  it('server history: a result persisted before the chart key gets no chart, and does not throw', () => {
+    const [, answer] = hydratedMessagesToChatMessages(serverHistory(false));
+    expect(answer.content).toBe(`${INTRO}${AFTER}`);
+    expect(answer.charts).toBeUndefined();
+    expect(answer.toolInvocations?.map((t) => t.toolName)).toEqual(['visualize_data']);
+  });
+
+  it('cache fallback: the live answer is cached and restored with its chart in place', () => {
+    const live = uiMessageToChatMessage({
+      id: 'a1',
+      role: 'assistant',
+      parts: [
+        { type: 'text', text: INTRO },
+        { type: 'data-chart', id: 'chart-0', data: DESCRIPTOR },
+        {
+          type: 'tool-visualize_data',
+          toolCallId: 'call_1',
+          state: 'output-available',
+          input: {},
+          output: { type: 'text', value: resultString(true) },
+        },
+        { type: 'text', text: AFTER },
+      ],
+    });
+    const cached = JSON.parse(JSON.stringify(sanitizeChatMessagesForCache([live])));
+    const [restored] = hydratedMessagesToChatMessages(cached);
+    expect(restored.content).toBe(`${INTRO}${AFTER}`);
+    expect(restored.charts).toEqual([{ ...LIVE_CHART, textOffset: INTRO.length }]);
+  });
+
+  it('cache fallback: a restored server answer is re-cached without losing the chart', () => {
+    const [, answer] = hydratedMessagesToChatMessages(serverHistory(true));
+    const cached = JSON.parse(JSON.stringify(sanitizeChatMessagesForCache([answer])));
+    const [restored] = hydratedMessagesToChatMessages(cached);
+    expect(restored.charts).toEqual(answer.charts);
+    expect(restored.content).toBe(answer.content);
+  });
+});
@@ -16,7 +16,7 @@ import { useCallback, useEffect, useRef, useState } from 'react';
 // `@object-ui/plugin-chatbot` is already a static member of this package's
 // barrel closure (`index.ts` re-exports `AiChatPage`, which imports it), so
 // this adds no package edge and no eager bundle weight.
-import { detectPendingApproval } from '@object-ui/plugin-chatbot/core';
+import { chartAnswerParts, detectPendingApproval } from '@object-ui/plugin-chatbot/core';
 
 /** Minimal UIMessage shape compatible with `@ai-sdk/react`'s `useChat`. */
 export interface HydratedUIMessagePart {
@@ -213,6 +213,8 @@ interface CacheableChatMessage {
   role: 'user' | 'assistant' | 'system';
   content?: string;
   toolInvocations?: CacheableChatToolInvocation[];
+  /** The answer's charts, each at its `textOffset` into `content`. */
+  charts?: Parameters<typeof chartAnswerParts>[1];
 }
 
 /**
@@ -443,10 +445,15 @@ export function sanitizeChatMessagesForCache(
 ): HydratedUIMessage[] {
   return messages
     .map<HydratedUIMessage | undefined>((message) => {
-      const parts: HydratedUIMessagePart[] = [];
-      if (message.content) {
-        parts.push({ type: 'text', text: message.content });
-      }
+      // objectstack#25908 — an answer's charts are cached as the `data-chart`
+      // parts the live stream gave, between the text runs they sat between:
+      // the stream's own chart part is never stored, and a tool part carries
+      // no position, so this is the one record that keeps both the chart and
+      // its place. `hydratedMessagesToChatMessages` reads them back.
+      const parts: HydratedUIMessagePart[] = chartAnswerParts(
+        message.content ?? '',
+        message.role === 'assistant' ? message.charts : undefined,
+      );
       if (message.role === 'assistant') {
         for (const tool of message.toolInvocations ?? []) {
           // Re-serialize the draft/plan affordance into a compact tool `output`.
 
@@ -0,0 +1,150 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/**
+ * objectstack#25908 — an assistant answer's chart survives a reload.
+ *
+ * The live stream draws a chart from a transient `data-chart` part that is
+ * never stored. What the server stores is the `visualize_data` tool result: one
+ * JSON string whose `chart` key is the same descriptor the part carried as
+ * `data`, beside a top-level `rows` preview cut to 20 for the model's
+ * narration. These pins hold the one reader of that key and the part writer
+ * that carries a hydrated chart back to the mapper at its offset. The app-shell
+ * half (server history and the message cache) is pinned in
+ * `AiChatPage.persistedChart-25908.test.ts`.
+ */
+import { describe, expect, it } from 'vitest';
+import * as specSystem from '@objectstack/spec/system';
+import {
+  VISUALIZE_DATA_TOOL,
+  chartAnswerParts,
+  chartsFromParts,
+  uiMessageToChatMessage,
+} from '../mapMessages';
+
+/** 30 categories: more than the 20-row preview, so a chart drawn from `rows` would show. */
+const ROWS = Array.from({ length: 30 }, (_, i) => ({ stage: `stage_${i}`, amount: i * 10 }));
+
+/** The descriptor the producer streams as the part's `data` and persists under `chart`. */
+const DESCRIPTOR = {
+  type: 'chart',
+  chartType: 'bar',
+  title: 'Pipeline by stage',
+  data: ROWS,
+  xAxisKey: 'stage',
+  series: [{ dataKey: 'amount', label: 'Amount' }],
+};
+
+/** The persisted result string: the narration preview AND the full descriptor. */
+const RESULT = JSON.stringify({
+  rendered: 'chart',
+  chartType: 'bar',
+  object: 'opportunity',
+  dimension: 'stage',
+  measures: ['amount'],
+  categories: 30,
+  rows: ROWS.slice(0, 20),
+  note: 'Showing the first 20 of 30 rows.',
+  chart: DESCRIPTOR,
+});
+
+/** A result written before the producer persisted `chart`. */
+const LEGACY_RESULT = JSON.stringify({
+  rendered: 'chart',
+  chartType: 'bar',
+  object: 'opportunity',
+  dimension: 'stage',
+  measures: ['amount'],
+  categories: 30,
+  rows: ROWS.slice(0, 20),
+});
+
+const toolPart = (output: unknown, type = `tool-${VISUALIZE_DATA_TOOL}`) => ({
+  type,
+  toolCallId: 'call_1',
+  state: 'output-available',
+  input: {},
+  output,
+});
+
+const INTRO = 'Here is the pipeline.\n\n';
+const AFTER = 'Most of it sits in the late stages.';
+
+/** What the live mapper draws from the streamed part: the reference chart. */
+const LIVE = uiMessageToChatMessage({
+  id: 'live',
+  role: 'assistant',
+  parts: [{ type: 'data-chart', id: 'chart-0', data: DESCRIPTOR }],
+}).charts![0];
+
+describe('the persisted visualize_data chart is read back (objectstack#25908)', () => {
+  it('reads the same chart the live stream drew: title, series labels and every row', () => {
+    const charts = chartsFromParts([
+      { type: 'text', text: INTRO },
+      toolPart({ type: 'text', value: RESULT }),
+      { type: 'text', text: AFTER },
+    ]);
+    expect(charts).toEqual([{ ...LIVE, textOffset: INTRO.length }]);
+    expect(charts?.[0]?.data).toHaveLength(30);
+    expect(charts?.[0]?.series).toEqual([{ dataKey: 'amount', label: 'Amount' }]);
+  });
+
+  it('reads a bare result string too, the shape a legacy tool row keeps', () => {
+    expect(chartsFromParts([toolPart(RESULT)])?.[0]?.title).toBe('Pipeline by stage');
+  });
+
+  it('a result persisted before the chart key gets no chart, and does not throw', () => {
+    expect(chartsFromParts([toolPart({ type: 'text', value: LEGACY_RESULT })])).toBeUndefined();
+    expect(chartsFromParts([toolPart('not json at all')])).toBeUndefined();
+  });
+
+  it('only the visualize_data result is read', () => {
+    expect(chartsFromParts([toolPart({ type: 'text', value: RESULT }, 'tool-query_data')])).toBeUndefined();
+  });
+
+  it('the tool name is the one the spec registry declares for service-ai', () => {
+    const registry = (
+      specSystem as { PLATFORM_TOOLS_BY_PACKAGE?: Readonly<Record<string, readonly string[]>> }
+    ).PLATFORM_TOOLS_BY_PACKAGE;
+    expect(registry?.['service-ai']).toContain(VISUALIZE_DATA_TOOL);
+  });
+
+  it('a live message carrying both the part and the result draws the chart once', () => {
+    const out = uiMessageToChatMessage({
+      id: 'a1',
+      role: 'assistant',
+      parts: [
+        { type: 'text', text: INTRO },
+        { type: 'data-chart', id: 'chart-0', data: DESCRIPTOR },
+        toolPart({ type: 'text', value: RESULT }),
+        { type: 'text', text: AFTER },
+      ],
+    });
+    expect(out.charts).toEqual([{ ...LIVE, textOffset: INTRO.length }]);
+  });
+});
+
+describe('a hydrated chart goes back to the mapper at its offset (objectstack#25908)', () => {
+  const content = `${INTRO}${AFTER}`;
+  const charts = [{ ...LIVE, textOffset: INTRO.length }];
+
+  it('chartAnswerParts cuts the text at the chart and maps back to the same message', () => {
+    const parts = chartAnswerParts(content, charts);
+    expect(parts.map((p) => p.type)).toEqual(['text', 'data-chart', 'text']);
+    const out = uiMessageToChatMessage({ id: 'a1', role: 'assistant', parts });
+    expect(out.content).toBe(content);
+    expect(out.charts).toEqual(charts);
+  });
+
+  it('a chart with no offset follows all of the text, and no empty run is written', () => {
+    const { textOffset: _placement, ...unplaced } = charts[0];
+    expect(chartAnswerParts(content, [unplaced]).map((p) => p.type)).toEqual(['text', 'data-chart']);
+    expect(chartAnswerParts('', undefined)).toEqual([]);
+    expect(chartAnswerParts(content, undefined)).toEqual([{ type: 'text', text: content }]);
+  });
+});