feat: fetch and render charts for chat answers via /api/v1/charts

- Add getCharts client and ChartSpec/ChartItem/ChartsResponse types
- Auto-fetch charts for each completed AI message once message_id is known, mirroring the existing traceability fetch pattern
- Treat empty/not_found chart status as silent no-op (no error shown); log not_found for debugging only
- Render fetched charts under the assistant bubble reusing PlotlyChartBlock from report rendering

docs/API_CONTRACT_BE_PYTHON.md

@@ -1,8 +1,8 @@
 # Backend Agentic Service API Contract
 
-**Last updated**: 2026-07-13
+**Last updated**: 2026-07-14
 
-This document describes the Python agentic backend used by the frontend for AI chat, help/report tools, and traceability data shown alongside chat answers.
+This document describes the Python agentic backend used by the frontend for AI chat, help/report tools, charts, and traceability data shown alongside chat answers.
 
 Base path examples use relative URLs. Configure the frontend with the deployed Python service base URL.
 
@@ -12,8 +12,9 @@ The Python backend owns the generative AI interaction surface:
 
 1. Stream chat answers from the AI agent.
 2. Execute tool-style actions for help and report generation.
-3. Return report versions and report details.
+3. Return report versions, report details, and report-readiness signals.
 4. Return traceability for a completed assistant answer.
+5. Return chart specifications produced for a completed assistant answer.
 
 The frontend uses this service during the analysis conversation flow:
 
@@ -21,7 +22,8 @@ The frontend uses this service during the analysis conversation flow:
 2. Frontend calls `POST /api/v2/chat/stream` and renders the streamed answer.
 3. When the stream emits `done`, frontend uses the returned `message_id` as the assistant answer correlation id.
 4. Frontend calls `GET /api/v1/traceability` for planning, tool calls, and source provenance.
-5. Frontend calls `/api/v1/tools/help` for guided help and `/api/v1/tools/report` for report generation.
+5. Frontend calls `GET /api/v1/charts` with the same `message_id` and renders any returned charts under the answer.
+6. Frontend calls `/api/v1/tools/help` for guided help and `/api/v1/tools/report` for report generation (the Generate-Report button; `GET …/readiness` drives the button state).
 
 ## Endpoint Summary
 
@@ -32,8 +34,11 @@ The frontend uses this service during the analysis conversation flow:
 | `POST` | `/api/v1/tools/help` | Stream contextual help for the current analysis conversation. |
 | `POST` | `/api/v1/tools/report` | Generate and persist a new report version. |
 | `GET` | `/api/v1/tools/report/{analysis_id}` | List report versions for an analysis. |
+| `GET` | `/api/v1/tools/report/{analysis_id}/records` | List analysis records for report curation. |
+| `GET` | `/api/v1/tools/report/{analysis_id}/readiness` | Report-readiness signal for the Generate-Report button. |
 | `GET` | `/api/v1/tools/report/{analysis_id}/{version}` | Retrieve one report version. |
 | `GET` | `/api/v1/traceability` | Retrieve provenance for one assistant answer. |
+| `GET` | `/api/v1/charts` | Retrieve chart(s) produced for one assistant answer. |
 
 ## Common Concepts
 
@@ -41,7 +46,7 @@ The frontend uses this service during the analysis conversation flow:
 
 - `user_id`: user identifier passed by the frontend.
 - `analysis_id`: analysis conversation identifier.
-- `message_id`: assistant answer identifier generated by Python and returned in the stream `done` event; used to correlate chat streaming, Golang message persistence, and traceability.
+- `message_id`: assistant answer identifier generated by Python and returned in the stream `done` event; used to correlate chat streaming, Golang message persistence, traceability, and charts. It is a UUID string (e.g. `77f06761-0fdf-4cc5-84f8-5f81bcbb6f84`); the `msg_…` values in the examples below are illustrative placeholders only. Never generate or send it from the frontend.
 
 ### Server-Sent Events
 
@@ -53,13 +58,13 @@ Common event types:
 
 | Event | Data | Meaning |
 | --- | --- | --- |
-| `sources` | JSON array | Sources available early in the stream. May be empty. |
+| `sources` | JSON array | Always `[]` — real sources moved to `GET /api/v1/traceability`. Event kept for backward compatibility. |
 | `status` | text | Optional progress update for slower paths. |
 | `chunk` | text | Answer text fragment. Concatenate chunks in order. |
 | `done` | JSON object | Terminal success event. Includes `message_id`. |
 | `error` | text | Terminal error event. Stream stops after this. |
 
-The stream carries answer text only. Planning, tool call details, and full provenance are fetched from `GET /api/v1/traceability` after the stream is done.
+The stream carries answer text only. Planning, tool call details, and full provenance are fetched from `GET /api/v1/traceability` after the stream is done; charts are fetched from `GET /api/v1/charts`. The `done` event carries no chart hint — fetch `GET /api/v1/charts` unconditionally on every `done` (the response tells you if there is nothing to render).
 
 ## Chat
 
@@ -91,7 +96,7 @@ Example structured answer:
 
 ```text
 event: sources
-data: [{"document_id":"u_1a2b3c_orders","filename":"orders","page_label":null}]
+data: []
 
 event: status
 data: Planning analysis...
@@ -126,9 +131,10 @@ Behavior notes:
 
 - Greeting and farewell messages may use a fast canned path.
 - Stateless `chat` intent may use a 1-hour Redis response cache.
-- The router may classify messages into intents such as `chat`, `help`, `check`, `unstructured_flow`, or `structured_flow`.
-- `sources` can be empty for chat/help/error paths.
+- The router may classify messages into intents such as `chat`, `help`, `check`, `unstructured_flow`, `structured_flow`, or `out_of_scope`.
+- `sources` in the stream is **always `[]`** — read the real `sources[]` from `GET /api/v1/traceability` after `done`.
 - `status` events are optional and should be safe for the frontend to ignore.
+- When the user explicitly asks to plot/visualize ("show me a bar chart of…", "buatkan grafik…"), the answer text describes the result and the chart itself is delivered via `GET /api/v1/charts` — it is never embedded in `chunk` text.
 
 ## Tools
 
@@ -142,24 +148,20 @@ Response `200`:
 
 ```json
 {
-  "count": 2,
+  "count": 1,
   "tools": [
     {
       "command": "/help",
       "name": "help",
       "type": "skill",
       "description": "Show what the assistant can do and guide your next step."
-    },
-    {
-      "command": "/report",
-      "name": "report",
-      "type": "skill",
-      "description": "Generate a versioned analysis report with background, EDA, key findings, and insights."
     }
   ]
 }
 ```
 
+The catalog is `/help` only. `/report` is not a slash command — report generation is a right-side **Generate** button; the button calls `POST /api/v1/tools/report`.
+
 Tool item shape:
 
 ```json
@@ -174,7 +176,7 @@ Tool item shape:
 Frontend behavior:
 
 - Surface `/help` in the slash menu.
-- Surface report generation as a button or explicit UI action.
+- Surface report generation as a button or explicit UI action, driven by `GET /tools/report/{analysis_id}/readiness`.
 
 ### `POST /api/v1/tools/help`
 
@@ -218,11 +220,13 @@ Query params:
 | --- | --- | --- |
 | `analysis_id` | Yes | Analysis identifier. |
 | `user_id` | Yes | User identifier. |
+| `exclude_record_ids` | No | Record ids to leave out of this version (repeat the param per id). Get ids from `GET /tools/report/{analysis_id}/records`. Excluded runs are listed in the report's "Excluded Analyses" section. Excluding every substantive record returns `409`. |
 
 Example:
 
 ```text
 POST /api/v1/tools/report?analysis_id=an_42&user_id=u_1a2b3c
+POST /api/v1/tools/report?analysis_id=an_42&user_id=u_1a2b3c&exclude_record_ids=rec_a1&exclude_record_ids=rec_c3
 ```
 
 Status codes:
@@ -251,6 +255,20 @@ Response `201`:
   },
   "record_ids": ["rec_a1", "rec_b2"],
   "executive_summary": "Revenue is concentrated in the Central region (38% of total). The West was the only region to contract, down 12% QoQ, the main driver of the Q1 dip.",
+  "bq_answers": [
+    {
+      "question": "Which regions contribute most to total revenue?",
+      "answer": "The Central region leads with 38% of total revenue.",
+      "status": "answered",
+      "record_ids": ["rec_a1"]
+    },
+    {
+      "question": "Did any region decline quarter-over-quarter?",
+      "answer": "Yes — the West region fell 12% QoQ.",
+      "status": "answered",
+      "record_ids": ["rec_b2"]
+    }
+  ],
   "findings": [
     {
       "text": "Central region contributed 38% of total revenue, the largest share.",
@@ -275,6 +293,36 @@ Response `201`:
       "record_ids": ["rec_b2"]
     }
   ],
+  "unresolved": [
+    {
+      "text": "Correlate churn with tenure — churn column not found in the source.",
+      "record_ids": ["rec_d4"]
+    }
+  ],
+  "excluded": [],
+  "evidence_tables": {
+    "rec_a1": [
+      {
+        "title": "Aggregate revenue by region",
+        "columns": ["region", "total_revenue"],
+        "rows": [["Central", "18321"], ["West", "9954"]],
+        "truncated": false
+      }
+    ]
+  },
+  "charts": {
+    "rec_a1": [
+      {
+        "schema": "dataeyond.chart.v1",
+        "chart_type": "bar",
+        "title": "Revenue by region",
+        "plotly": {
+          "data": [{ "type": "bar", "x": ["Central", "East", "West"], "y": [1210000, 740000, 550000], "name": "revenue" }],
+          "layout": { "title": { "text": "Revenue by region" }, "xaxis": { "title": { "text": "region" } }, "yaxis": { "title": { "text": "revenue" } } }
+        }
+      }
+    ]
+  },
   "data_sources": [
     {
       "source_id": "src_sales_db",
@@ -307,6 +355,32 @@ Response `201`:
 }
 ```
 
+Field notes:
+
+- `bq_answers` — one entry per business question. `status` is `answered` | `partial` | `unanswered`; `record_ids` cite the backing analyses. Written in the analysis's language (Indonesian objective → Indonesian answers).
+- `unresolved` — runs that were attempted but produced no usable evidence. Not part of the findings body.
+- `excluded` — runs the caller excluded via `exclude_record_ids`.
+- `evidence_tables` — `record_id` → small result tables copied from the run's stored outputs (max 3 tables per record, max 10 rows each; `truncated: true` when rows were capped). Rendered as markdown tables under the matching Key Findings group in `rendered_markdown`.
+- `charts` — `record_id` → chart envelopes (same `dataeyond.chart.v1` shape as `GET /api/v1/charts` returns; max 3 per record) copied from the run's stored outputs. `rendered_markdown` contains an `## EDA` section where each chart appears as a fenced block:
+
+  ````text
+  ```plotly
+  {
+    "schema": "dataeyond.chart.v1",
+    "chart_type": "bar",
+    "title": "…",
+    "plotly": { "data": [ … ], "layout": { … } }
+  }
+  ```
+  ````
+
+  The fence content is the full envelope — parse it and render `Plotly.newPlot(el, parsed.plotly.data, parsed.plotly.layout)`. A bold caption line (the chart title) precedes each fence.
+
+Precondition:
+
+- Reports require at least one completed analysis record for the session. A run counts when an analysis step succeeded **or** a chart was produced — a chart-only session can generate a report.
+- If slow-path analysis recording is disabled, report generation can return `409` by design.
+
 Response `409`:
 
 ```json
@@ -315,11 +389,6 @@ Response `409`:
 }
 ```
 
-Precondition:
-
-- Reports require at least one completed analysis record for the session.
-- If slow-path analysis recording is disabled, report generation can return `409` by design.
-
 ### `GET /api/v1/tools/report/{analysis_id}`
 
 Lists report versions for one analysis, oldest first.
@@ -345,6 +414,48 @@ Response `200`:
 
 If no reports exist, returns `[]`.
 
+### `GET /api/v1/tools/report/{analysis_id}/records`
+
+Lists the persisted analysis runs a report would be built from, oldest first. The frontend shows this before generating so the user can deselect runs; the chosen ids go to `POST /tools/report` as `exclude_record_ids`.
+
+Response `200`:
+
+```json
+[
+  {
+    "record_id": "rec_a1",
+    "goal_restated": "Rank regions by total revenue",
+    "created_at": "2026-06-30T08:55:02Z",
+    "substantive": true,
+    "findings_count": 2
+  },
+  {
+    "record_id": "rec_d4",
+    "goal_restated": "Correlate churn with tenure",
+    "created_at": "2026-06-30T09:01:47Z",
+    "substantive": false,
+    "findings_count": 1
+  }
+]
+```
+
+`substantive: false` means the run produced no usable result (no analysis step or chart succeeded) — that run is listed in the report's `unresolved` JSON field rather than the findings body. If no runs exist, returns `[]`.
+
+### `GET /api/v1/tools/report/{analysis_id}/readiness`
+
+Deterministic report-readiness signal for the Generate-Report button — the same producer as Help's readiness signal, so the button and Help never disagree.
+
+Response `200`:
+
+```json
+{
+  "ready": false,
+  "missing": ["a new analysis since the last report"]
+}
+```
+
+Note: `POST /tools/report` itself only enforces the floor (at least one completed analysis). The delta gap in `missing` is a soft warning the frontend can surface ("nothing new since the last report") without blocking the button.
+
 ### `GET /api/v1/tools/report/{analysis_id}/{version}`
 
 Returns one report version. Shape is the same as the `201` response from `POST /api/v1/tools/report`.
@@ -357,6 +468,106 @@ Response `404`:
 }
 ```
 
+## Charts
+
+A chart is produced when the user explicitly asks to plot/visualize something in chat. The chart is never embedded in the streamed text — it is fetched separately after the stream completes, then rendered with plotly.js under the assistant message.
+
+### `GET /api/v1/charts`
+
+Returns every chart produced during one assistant answer.
+
+Call this after the chat stream emits `done`, using the `message_id` from the `done` event (same fetch-on-`done` pattern as traceability). Chart rows are written before `done`, so there is no polling race. Every response is HTTP `200` — branch on the `status` field, not the HTTP code.
+
+Query params:
+
+| Query | Required | Description |
+| --- | --- | --- |
+| `message_id` | Yes | Assistant answer identifier returned by the stream's `done` event. |
+
+Example:
+
+```text
+GET /api/v1/charts?message_id=88f10c3a-6f03-4204-bf98-41ffc20388b2
+```
+
+Response `200` — `status: "success"` (≥1 chart to render):
+
+```json
+{
+  "status": "success",
+  "message": "1 chart(s) for this message.",
+  "count": 1,
+  "charts": [
+    {
+      "chart_id": "3fbd8e2e-8e21-4d4b-9b21-9e6b6a0a6a6e",
+      "chart_type": "bar",
+      "title": "Revenue by region",
+      "spec": {
+        "schema": "dataeyond.chart.v1",
+        "chart_type": "bar",
+        "title": "Revenue by region",
+        "plotly": {
+          "data": [{ "type": "bar", "x": ["Central", "East", "West"], "y": [1210000, 740000, 550000], "name": "revenue" }],
+          "layout": { "title": { "text": "Revenue by region" }, "xaxis": { "title": { "text": "region" } }, "yaxis": { "title": { "text": "revenue" } } }
+        }
+      },
+      "created_at": "2026-07-13T03:21:09.114Z"
+    }
+  ]
+}
+```
+
+Response `200` — `status: "empty"` (the turn completed but produced no charts; the common case, not an error):
+
+```json
+{
+  "status": "empty",
+  "message": "This message completed without producing charts.",
+  "count": 0,
+  "charts": []
+}
+```
+
+Response `200` — `status: "not_found"` (no completed turn is known for this `message_id`; usually a stale or mistyped id):
+
+```json
+{
+  "status": "not_found",
+  "message": "No completed turn is known for this message_id.",
+  "count": 0,
+  "charts": []
+}
+```
+
+The `dataeyond.chart.v1` envelope (the shape of `charts[].spec`):
+
+```json
+{
+  "schema": "dataeyond.chart.v1",
+  "chart_type": "bar",
+  "title": "Revenue by region",
+  "plotly": {
+    "data": [{ "type": "bar", "x": ["A", "B"], "y": [1, 2], "name": "revenue" }],
+    "layout": { "title": { "text": "Revenue by region" } }
+  }
+}
+```
+
+Field rules:
+
+- `status` is the outcome marker: `success` | `empty` | `not_found`. Branch on it; do not parse `message` (human-readable, for logs only).
+- `spec` is the full envelope, unmodified — render straight from it: `Plotly.newPlot(el, spec.plotly.data, spec.plotly.layout)`.
+- `chart_type` / `title` are copied out of `spec` for convenience (list rendering without parsing `spec`); `title` may be `null`. Chart types: `bar`, `line`, `pie`, `scatter`.
+- A turn can produce more than one chart; `charts` is ordered by creation time.
+
+Frontend rendering guidance:
+
+- Fetch unconditionally on every `done`; `status: "empty"` means render nothing extra.
+- Render each chart under the assistant message it belongs to.
+- Treat `status: "not_found"` as a signal worth logging (stale id or fetch bug) — not as a user-facing error.
+- Chart iteration is a follow-up chat turn (e.g. "make it a line chart") — there is no separate edit endpoint.
+- The same envelope shape appears inside report markdown as ` ```plotly ` fenced blocks (see Reports → `charts`), so one renderer can serve both surfaces.
+
 ## Traceability
 
 ### `GET /api/v1/traceability`
@@ -378,16 +589,20 @@ Example:
 GET /api/v1/traceability?analysis_id=an_42&message_id=msg_88f1
 ```
 
-`intent` values the frontend may see: `chat` · `help` · `check` · `unstructured_flow` · `structured_flow` · `out_of_scope` · `blocked` (`blocked` = input-guard or Azure content-filter refusal; `chat` also covers the greeting fast-path and cache replays).
+`intent` values the frontend may see: `chat` · `help` · `check` · `unstructured_flow` · `structured_flow` · `out_of_scope` · `blocked` (`blocked` = input-guard or content-filter refusal; `chat` also covers the greeting fast-path and cache replays).
 
 Field rules:
 
 - `planning`: present only when the planner ran (`structured_flow`); otherwise `null`.
-- `thinking`: **always `null` in v1** — our agents are plain chat completions with no native reasoning output, and synthesizing it post-hoc would be unfaithful. The field stays in the payload so it can be populated later without a contract change.
-- `tool_calls`: every invoked tool with `input`, `output`, `status`, `task_id` (nullable), and `error` (nullable); empty for chat / help / greeting / refusal paths.
-- `sources`: required for retrieval flows; empty for chat / help / refusal paths and for `check`.
+- `thinking`: **always `null` in v1** — the field stays in the payload so it can be populated later without a contract change.
+- `tool_calls`: every invoked tool with `summary` (plain-English one-liner), `input`, `output`, `status`, `task_id` (nullable), and `error` (nullable); empty for chat / help / greeting / refusal paths. `input`/`output` are the raw tool I/O (opaque ids) — render them in a collapsible "technical details" section, not the headline; use `summary` for the headline.
+- A `render_chart` tool call reports a compact chart summary in `output` (`chart_type`, `title`, `trace_count`, `point_count`) — the full spec is served by `GET /api/v1/charts`, not here.
+- `data_used`: one entry per structured data pull, resolved to **real names** for display (empty when no structured pull ran). Split into `columns_read` (columns read straight from the user's data, each tagged with its `roles`) and `output_columns` (`kind: "column"` = read from data, `kind: "computed"` = calculated, carrying a `formula` and no id). Also carries `tables` (all touched, including join targets), `joins`, `filters` (with a plain-language `description`), `group_by`, `order_by`, `limit`, `rows_returned`, and the executed `query`.
+- **`id` fields are machine-only.** Every `id` in `data_used` (`source.id`, `tables[].id`, `columns_read[].id`) is for linking/audit — **the frontend must never render it.** Show `name` (qualified as `table.name`). A `computed` output column has no id by design.
+- `sources`: required for retrieval flows; empty for chat / help / refusal paths and for `check`. Database sources also carry `source_name` (the DB's real name) and `tables` (every table touched).
+- Summaries and filter descriptions are built from fixed templates, never an LLM — traceability adds no latency and cannot hallucinate.
 - The payload also carries an internal `user_id` (ownership); the frontend may ignore it.
-- Truncation: `preview` ≤ 5 rows; any string inside `input`/`output`/`preview`/`snippet` ≤ 300 chars; rows beyond the preview are dropped (`row_count` is preserved).
+- Truncation: `preview` ≤ 5 rows; any string inside `input`/`output`/`preview`/`snippet` ≤ 300 chars (executed `query` ≤ 2000); rows beyond the preview are dropped (`row_count` is preserved).
 
 Response `200` for `structured_flow`:
 
@@ -556,4 +771,4 @@ Frontend rendering guidance:
 - Render traceability separately from the streamed answer.
 - Default state can be collapsed.
 - Show planning, tool calls, and sources as separate sections.
-- Treat `planning: null`, `tool_calls: []`, and `sources: []` as valid states.
+- Treat `planning: null`, `tool_calls: []`, and `sources: []` as valid states.

src/app/components/analysis/AnalysisShell.tsx

@@ -17,7 +17,7 @@ import {
   type AnalysisMessage,
   type DataBindItem,
 } from "@/services/orchestrationApi";
-import { AgenticApiError, getObservability, streamChat, streamHelp, type AgentStreamEvent } from "@/services/agenticApi";
+import { AgenticApiError, getCharts, getObservability, streamChat, streamHelp, type AgentStreamEvent } from "@/services/agenticApi";
 import { AnalysisHeader } from "./AnalysisHeader";
 import { AppNavigation, type AppMenuKey } from "./AppNavigation";
 import { ChatInput } from "./ChatInput";
@@ -176,6 +176,37 @@ export function AnalysisShell() {
       });
   }, [activeAnalysis?.id, loadingMessages, messages]);
 
+  const fetchCharts = async (messageId: string | undefined, uiMessageId: string) => {
+    if (!messageId) return;
+    try {
+      const result = await getCharts(messageId);
+      if (result.status === "not_found") {
+        console.warn(`No completed turn found for chart lookup of message ${messageId}`);
+      }
+      const charts = result.status === "success" ? result.charts : [];
+      setMessages((prev) => prev.map((msg) => (msg.id === uiMessageId ? { ...msg, charts } : msg)));
+    } catch {
+      setMessages((prev) => prev.map((msg) => (msg.id === uiMessageId ? { ...msg, charts: [] } : msg)));
+    }
+  };
+
+  useEffect(() => {
+    if (!activeAnalysis?.id || loadingMessages) return;
+
+    messages
+      .filter(
+        (message) =>
+          message.role === "ai" &&
+          message.status === "complete" &&
+          Boolean(message.messageId) &&
+          message.messageId !== RESERVED_FAILED_MESSAGE_ID &&
+          !message.charts
+      )
+      .forEach((message) => {
+        fetchCharts(message.messageId, message.id);
+      });
+  }, [activeAnalysis?.id, loadingMessages, messages]);
+
   const runAgentStream = async (kind: "chat" | "help", prompt?: string) => {
     if (!session?.user_id || !activeAnalysis || streamState !== "idle") return;
 

src/app/components/analysis/MessageList.tsx

@@ -3,6 +3,7 @@ import { Bot, Sparkles, User } from "lucide-react";
 import type { UiMessage } from "./types";
 import { MarkdownContent } from "./MarkdownContent";
 import { MessageTraceability } from "./MessageTraceability";
+import { PlotlyChartBlock } from "./PlotlyChartBlock";
 import { cx, compactQuestions, formatDateTime } from "./utils";
 
 export function MessageList({
@@ -86,6 +87,16 @@ export function MessageList({
               {isUser ? <p className="whitespace-pre-wrap break-words text-sm leading-6 text-slate-800 [overflow-wrap:anywhere]">{message.content}</p> : <MarkdownContent content={message.content || "..."} />}
               {message.status === "streaming" && message.statusText && <p className="mt-2 text-xs text-slate-500">{message.statusText}</p>}
               {message.status === "error" && <p className="mt-2 text-xs text-red-600">{message.statusText ?? "Stream failed"}</p>}
+              {!isUser && message.charts && message.charts.length > 0 && (
+                <div className="mt-2 space-y-3">
+                  {message.charts.map((chart) => (
+                    <div key={chart.chart_id}>
+                      {chart.title && <p className="mb-1 text-xs font-semibold text-slate-700">{chart.title}</p>}
+                      <PlotlyChartBlock spec={chart.spec} />
+                    </div>
+                  ))}
+                </div>
+              )}
               {!isUser && (
                 <MessageTraceability
                   observability={message.traceability}

src/app/components/analysis/types.ts

@@ -1,4 +1,4 @@
-import type { Observability } from "@/services/agenticApi";
+import type { ChartItem, Observability } from "@/services/agenticApi";
 import type { AnalysisMessage } from "@/services/orchestrationApi";
 
 export type StreamState = "idle" | "streaming-chat" | "streaming-help";
@@ -17,6 +17,7 @@ export interface UiMessage {
   traceability?: Observability | null;
   traceabilityLoading?: boolean;
   traceabilityError?: string | null;
+  charts?: ChartItem[];
 }
 
 export interface AnalysisDraft {

src/services/agenticApi.ts

@@ -1,3 +1,4 @@
+import type { Data, Layout } from "plotly.js";
 import { getEnv } from "@/env";
 
 const AGENTIC_BASE_URL = getEnv("VITE_AGENTIC_API_BASE_URL");
@@ -99,6 +100,31 @@ export interface ObservabilityDataUsed {
   query?: string;
 }
 
+export interface ChartSpec {
+  schema: string;
+  chart_type: string;
+  title?: string | null;
+  plotly: {
+    data: Data[];
+    layout?: Partial<Layout>;
+  };
+}
+
+export interface ChartItem {
+  chart_id: string;
+  chart_type: string;
+  title?: string | null;
+  spec: ChartSpec;
+  created_at: string;
+}
+
+export interface ChartsResponse {
+  status: "success" | "empty" | "not_found";
+  message: string;
+  count: number;
+  charts: ChartItem[];
+}
+
 export interface Observability {
   analysis_id: string;
   message_id: string;
@@ -254,6 +280,9 @@ export const getObservability = (analysisId: string, messageId: string): Promise
     `/api/v1/traceability?analysis_id=${encodeURIComponent(analysisId)}&message_id=${encodeURIComponent(messageId)}`
   );
 
+export const getCharts = (messageId: string): Promise<ChartsResponse> =>
+  agenticJson(`/api/v1/charts?message_id=${encodeURIComponent(messageId)}`);
+
 export const generateReport = (analysisId: string, userId: string): Promise<ReportDetail> =>
   agenticJson(
     `/api/v1/tools/report?analysis_id=${encodeURIComponent(analysisId)}&user_id=${encodeURIComponent(userId)}`,