@absolutejs/ai 0.0.29 → 0.0.31

package/dist/ai/index.js

@@ -3501,6 +3501,618 @@ var generateObjectAI = async (options) => {
   }
   throw lastError instanceof Error ? lastError : new Error(`generateObjectAI: failed to produce valid output`);
 };
+
+// src/ai/streamAIWithTools.ts
+var DEFAULT_STREAM_TOOL_MAX_TURNS = 8;
+var toolCallKey = (call) => `${call.name}:${JSON.stringify(call.input)}`;
+var pushText = (blocks, content) => {
+  const last = blocks[blocks.length - 1];
+  if (last && last.type === "text") {
+    last.content += content;
+    return;
+  }
+  blocks.push({ content, type: "text" });
+};
+var flushThinking3 = (blocks, thinking) => {
+  if (!thinking)
+    return null;
+  blocks.push({
+    signature: thinking.signature || undefined,
+    thinking: thinking.text,
+    type: "thinking"
+  });
+  return null;
+};
+var executeToolHandler = async (tools, call) => {
+  const definition = tools[call.name];
+  if (!definition) {
+    return { ok: false, result: `Error: unknown tool "${call.name}"` };
+  }
+  try {
+    return { ok: true, result: await definition.handler(call.input) };
+  } catch (err) {
+    return {
+      ok: false,
+      result: `Error: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+};
+var streamAIWithTools = async function* (options) {
+  const {
+    maxTurns = DEFAULT_STREAM_TOOL_MAX_TURNS,
+    provider,
+    toolChoice,
+    tools,
+    ...base
+  } = options;
+  const providerTools = toProviderTools(tools);
+  const allToolCalls = [];
+  const executedKeys = new Set;
+  const messages = [...options.messages];
+  let usage;
+  let fullText = "";
+  let turn = 0;
+  const streamOneTurn = async function* () {
+    const stream = provider.stream({
+      cacheSystemPrompt: base.cacheSystemPrompt,
+      maxTokens: base.maxTokens,
+      messages,
+      model: base.model,
+      promptCaching: base.promptCaching,
+      reasoning: base.reasoning,
+      signal: base.signal,
+      stopSequences: base.stopSequences,
+      systemPrompt: base.systemPrompt,
+      temperature: base.temperature,
+      toolChoice: toolChoice ?? "auto",
+      tools: providerTools,
+      topP: base.topP
+    });
+    const blocks = [];
+    const pending = [];
+    let thinking = null;
+    let turnUsage;
+    for await (const chunk of stream) {
+      if (base.signal?.aborted)
+        break;
+      if (chunk.type === "thinking") {
+        if (chunk.content)
+          yield { content: chunk.content, type: "thinking" };
+        thinking = thinking ?? { signature: "", text: "" };
+        thinking.text += chunk.content;
+        if (chunk.signature)
+          thinking.signature = chunk.signature;
+      } else if (chunk.type === "text") {
+        thinking = flushThinking3(blocks, thinking);
+        fullText += chunk.content;
+        pushText(blocks, chunk.content);
+        yield { content: chunk.content, type: "text" };
+      } else if (chunk.type === "tool_use") {
+        thinking = flushThinking3(blocks, thinking);
+        pending.push({ id: chunk.id, input: chunk.input, name: chunk.name });
+        blocks.push({
+          id: chunk.id,
+          input: chunk.input && typeof chunk.input === "object" ? chunk.input : {},
+          name: chunk.name,
+          type: "tool_use"
+        });
+      } else if (chunk.type === "done") {
+        thinking = flushThinking3(blocks, thinking);
+        turnUsage = chunk.usage;
+      }
+    }
+    thinking = flushThinking3(blocks, thinking);
+    return { blocks, pending, usage: turnUsage };
+  };
+  while (turn < maxTurns) {
+    turn += 1;
+    const outcome = yield* streamOneTurn();
+    usage = mergeUsage(usage, outcome.usage);
+    yield { type: "turn", usage: outcome.usage };
+    const { blocks, pending } = outcome;
+    allToolCalls.push(...pending);
+    const allRepeats = pending.length > 0 && pending.every((call) => executedKeys.has(toolCallKey(call)));
+    const finished = pending.length === 0 || turn >= maxTurns || allRepeats || base.signal?.aborted === true;
+    if (finished)
+      break;
+    messages.push({ content: blocks, role: "assistant" });
+    const resultBlocks = [];
+    for (const call of pending) {
+      yield {
+        id: call.id,
+        input: call.input,
+        name: call.name,
+        type: "tool_start"
+      };
+      const startedAt = Date.now();
+      const { ok, result } = await executeToolHandler(tools, call);
+      executedKeys.add(toolCallKey(call));
+      yield {
+        id: call.id,
+        input: call.input,
+        ms: Date.now() - startedAt,
+        name: call.name,
+        ok,
+        result,
+        type: "tool_result"
+      };
+      resultBlocks.push({
+        content: result,
+        tool_use_id: call.id,
+        type: "tool_result"
+      });
+    }
+    messages.push({ content: resultBlocks, role: "user" });
+  }
+  const summary = {
+    text: fullText,
+    toolCalls: allToolCalls,
+    turns: turn,
+    usage
+  };
+  yield { ...summary, type: "done" };
+  return summary;
+};
+// src/ai/ui/uiCards.ts
+var createUiCards = (definitions) => {
+  const byName = new Map(definitions.map((definition) => [definition.name, definition]));
+  const tools = Object.fromEntries(definitions.map((definition) => [
+    definition.name,
+    {
+      description: definition.description,
+      handler: () => definition.ack,
+      input: definition.inputSchema
+    }
+  ]));
+  const collect = (calls) => {
+    const events = [];
+    for (const call of calls) {
+      const definition = byName.get(call.name);
+      if (!definition)
+        continue;
+      const data = definition.parse(call.input);
+      if (data !== null)
+        events.push({ card: definition.name, data });
+    }
+    return events;
+  };
+  return { collect, has: (name) => byName.has(name), tools };
+};
+// src/ai/ui/catalog.ts
+var CHART_TYPES = ["bar", "line", "donut"];
+var CHART_MAX_SERIES = 8;
+var CHART_MAX_POINTS = 24;
+var TABLE_MAX_COLUMNS = 8;
+var TABLE_MAX_ROWS = 30;
+var STAT_TILES_MAX = 6;
+var LABEL_MAX_CHARS = 80;
+var TITLE_MAX_CHARS = 120;
+var CELL_MAX_CHARS = 160;
+var UNIT_MAX_CHARS = 8;
+var isRecord6 = (value) => typeof value === "object" && value !== null;
+var cleanString = (value, maxChars) => typeof value === "string" && value.trim().length > 0 ? value.trim().slice(0, maxChars) : null;
+var cleanStringArray = (value, maxItems, maxChars) => {
+  if (!Array.isArray(value) || value.length === 0)
+    return null;
+  const cleaned = [];
+  for (const entry of value.slice(0, maxItems)) {
+    const text = cleanString(entry, maxChars);
+    cleaned.push(text ?? "");
+  }
+  return cleaned;
+};
+var cleanNumberArray = (value, maxItems) => {
+  if (!Array.isArray(value) || value.length === 0)
+    return null;
+  const cleaned = [];
+  for (const entry of value.slice(0, maxItems)) {
+    if (typeof entry !== "number" || !Number.isFinite(entry))
+      return null;
+    cleaned.push(entry);
+  }
+  return cleaned;
+};
+var parseChartSpec = (input) => {
+  if (!isRecord6(input))
+    return null;
+  const type = CHART_TYPES.find((entry) => entry === input.type);
+  const title = cleanString(input.title, TITLE_MAX_CHARS);
+  const labels = cleanStringArray(input.labels, CHART_MAX_POINTS, LABEL_MAX_CHARS);
+  if (!type || !title || !labels)
+    return null;
+  if (!Array.isArray(input.series) || input.series.length === 0)
+    return null;
+  const series = [];
+  for (const raw of input.series.slice(0, CHART_MAX_SERIES)) {
+    if (!isRecord6(raw))
+      return null;
+    const name = cleanString(raw.name, LABEL_MAX_CHARS);
+    const values = cleanNumberArray(raw.values, CHART_MAX_POINTS);
+    if (!name || !values)
+      return null;
+    if (values.length !== labels.length)
+      return null;
+    series.push({ name, values });
+  }
+  if (type === "donut") {
+    const [only] = series;
+    if (series.length !== 1 || !only)
+      return null;
+    if (only.values.some((value) => value < 0))
+      return null;
+  }
+  const spec = { labels, series, title, type };
+  const unitPrefix = cleanString(input.unitPrefix, UNIT_MAX_CHARS);
+  const unitSuffix = cleanString(input.unitSuffix, UNIT_MAX_CHARS);
+  if (unitPrefix)
+    spec.unitPrefix = unitPrefix;
+  if (unitSuffix)
+    spec.unitSuffix = unitSuffix;
+  return spec;
+};
+var parseTableSpec = (input) => {
+  if (!isRecord6(input))
+    return null;
+  const columns = cleanStringArray(input.columns, TABLE_MAX_COLUMNS, LABEL_MAX_CHARS);
+  if (!columns)
+    return null;
+  if (!Array.isArray(input.rows) || input.rows.length === 0)
+    return null;
+  const rows = [];
+  for (const raw of input.rows.slice(0, TABLE_MAX_ROWS)) {
+    const cells = cleanStringArray(raw, TABLE_MAX_COLUMNS, CELL_MAX_CHARS);
+    if (!cells)
+      return null;
+    while (cells.length < columns.length)
+      cells.push("");
+    rows.push(cells.slice(0, columns.length));
+  }
+  const spec = { columns, rows };
+  const title = cleanString(input.title, TITLE_MAX_CHARS);
+  if (title)
+    spec.title = title;
+  return spec;
+};
+var parseStatTilesSpec = (input) => {
+  if (!isRecord6(input))
+    return null;
+  if (!Array.isArray(input.tiles) || input.tiles.length === 0)
+    return null;
+  const tiles = [];
+  for (const raw of input.tiles.slice(0, STAT_TILES_MAX)) {
+    if (!isRecord6(raw))
+      return null;
+    const label = cleanString(raw.label, LABEL_MAX_CHARS);
+    const value = cleanString(raw.value, LABEL_MAX_CHARS);
+    if (!label || !value)
+      return null;
+    const tile = { label, value };
+    const delta = cleanString(raw.delta, LABEL_MAX_CHARS);
+    if (delta)
+      tile.delta = delta;
+    if (raw.deltaDirection === "up" || raw.deltaDirection === "down" || raw.deltaDirection === "flat") {
+      tile.deltaDirection = raw.deltaDirection;
+    }
+    tiles.push(tile);
+  }
+  return { tiles };
+};
+var SERIES_SCHEMA = {
+  properties: {
+    name: { description: "Series name (shown in the legend)", type: "string" },
+    values: {
+      description: "One number per label, same order as labels",
+      items: { type: "number" },
+      type: "array"
+    }
+  },
+  required: ["name", "values"],
+  type: "object"
+};
+var chartCard = {
+  ack: "(chart rendered inline \u2014 do not repeat its numbers as text; add at most a 1-2 line takeaway)",
+  description: "Render a real chart inline in the chat from data you have (tool results, the conversation). Use whenever numbers COMPARE or TREND: revenue by partner (bar), pipeline over time (line), share of a whole (donut). Rules: bar/line take up to 8 series aligned to the same labels; donut takes exactly ONE series of non-negative values (one slice per label). Prefer a chart over a wall of numbers, but never invent data for it.",
+  inputSchema: {
+    properties: {
+      labels: {
+        description: "Category labels \u2014 x-axis for bar/line, slice names for donut (max 24)",
+        items: { type: "string" },
+        type: "array"
+      },
+      series: {
+        description: "Data series (max 8; donut exactly 1)",
+        items: SERIES_SCHEMA,
+        type: "array"
+      },
+      title: { description: "Short chart title", type: "string" },
+      type: { enum: [...CHART_TYPES], type: "string" },
+      unitPrefix: {
+        description: 'Prepended to values, e.g. "$"',
+        type: "string"
+      },
+      unitSuffix: {
+        description: 'Appended to values, e.g. "%"',
+        type: "string"
+      }
+    },
+    required: ["type", "title", "labels", "series"],
+    type: "object"
+  },
+  name: "render_chart",
+  parse: parseChartSpec
+};
+var tableCard = {
+  ack: "(table rendered inline \u2014 do not repeat its rows as text)",
+  description: "Render a compact data table inline in the chat (max 8 columns \xD7 30 rows). Use for structured comparisons the member will scan \u2014 matches side by side, deal terms, task lists with dates. All cells are strings; format numbers yourself.",
+  inputSchema: {
+    properties: {
+      columns: {
+        description: "Column headers (max 8)",
+        items: { type: "string" },
+        type: "array"
+      },
+      rows: {
+        description: "Rows of cells, each aligned to columns (max 30)",
+        items: { items: { type: "string" }, type: "array" },
+        type: "array"
+      },
+      title: { description: "Optional table title", type: "string" }
+    },
+    required: ["columns", "rows"],
+    type: "object"
+  },
+  name: "render_table",
+  parse: parseTableSpec
+};
+var statTilesCard = {
+  ack: "(stat tiles rendered inline \u2014 do not repeat the numbers as text)",
+  description: "Render a row of headline stat tiles inline in the chat (max 6): a label, a big value, and an optional delta with direction. Use for the 2-4 numbers that ARE the answer \u2014 total attributed revenue, pipeline value, credits remaining \u2014 instead of burying them in prose.",
+  inputSchema: {
+    properties: {
+      tiles: {
+        description: "The tiles (max 6)",
+        items: {
+          properties: {
+            delta: {
+              description: 'Optional change note, e.g. "+12% vs last month"',
+              type: "string"
+            },
+            deltaDirection: { enum: ["up", "down", "flat"], type: "string" },
+            label: { description: "What the number is", type: "string" },
+            value: {
+              description: 'The formatted headline value, e.g. "$42,300"',
+              type: "string"
+            }
+          },
+          required: ["label", "value"],
+          type: "object"
+        },
+        type: "array"
+      }
+    },
+    required: ["tiles"],
+    type: "object"
+  },
+  name: "render_stat_tiles",
+  parse: parseStatTilesSpec
+};
+var BUILTIN_UI_CARDS = [chartCard, tableCard, statTilesCard];
+// src/ai/ui/svg.ts
+var LIGHT_UI_THEME = {
+  grid: "#e4e4e0",
+  palette: [
+    "#2a78d6",
+    "#1baf7a",
+    "#eda100",
+    "#008300",
+    "#4a3aa7",
+    "#e34948",
+    "#e87ba4",
+    "#eb6834"
+  ],
+  surface: "#fcfcfb",
+  textPrimary: "#0b0b0b",
+  textSecondary: "#52514e"
+};
+var DARK_UI_THEME = {
+  grid: "#333331",
+  palette: [
+    "#3987e5",
+    "#199e70",
+    "#c98500",
+    "#008300",
+    "#9085e9",
+    "#e66767",
+    "#d55181",
+    "#d95926"
+  ],
+  surface: "#1a1a19",
+  textPrimary: "#ffffff",
+  textSecondary: "#c3c2b7"
+};
+var WIDTH = 640;
+var HEIGHT = 340;
+var MARGIN = { bottom: 42, left: 56, right: 16, top: 64 };
+var BAR_END_RADIUS = 4;
+var MARK_GAP = 2;
+var LINE_WIDTH = 2;
+var MAX_DIRECT_LABELED_SERIES = 4;
+var TICK_TARGET = 4;
+var FONT = "system-ui, -apple-system, 'Segoe UI', Roboto, Helvetica, Arial, sans-serif";
+var escapeXml = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+var formatValue = (value, spec) => {
+  const sign = value < 0 ? "-" : "";
+  const abs = Math.abs(value);
+  const compact = abs >= 1e6 ? `${(abs / 1e6).toFixed(1).replace(/\.0$/, "")}M` : abs >= 1e4 ? `${(abs / 1000).toFixed(1).replace(/\.0$/, "")}k` : abs >= 1000 ? abs.toLocaleString("en-US") : `${Number.isInteger(abs) ? abs : abs.toFixed(1)}`;
+  return `${sign}${spec.unitPrefix ?? ""}${compact}${spec.unitSuffix ?? ""}`;
+};
+var niceTicks = (min, max) => {
+  const span = max - min || 1;
+  const rough = span / TICK_TARGET;
+  const power = Math.pow(10, Math.floor(Math.log10(rough)));
+  const candidates = [1, 2, 5, 10].map((step2) => step2 * power);
+  const step = candidates.find((candidate) => candidate >= rough) ?? candidates[candidates.length - 1] ?? rough;
+  const start = Math.floor(min / step) * step;
+  const ticks = [];
+  for (let tick = start;tick <= max + step / 2; tick += step) {
+    ticks.push(Math.abs(tick) < step / 1e6 ? 0 : tick);
+  }
+  return ticks;
+};
+var headerSvg = (spec, frame) => {
+  const { theme } = frame;
+  const parts = [
+    `<text x="${frame.plotLeft}" y="24" fill="${theme.textPrimary}" font-size="15" font-weight="600">${escapeXml(spec.title)}</text>`
+  ];
+  if (spec.series.length > 1) {
+    let x = frame.plotLeft;
+    const swatches = spec.series.map((series, index) => {
+      const color = theme.palette[index % theme.palette.length];
+      const label = escapeXml(series.name);
+      const item = `<rect x="${x}" y="38" width="10" height="10" rx="2" fill="${color}"/><text x="${x + 14}" y="47" fill="${theme.textSecondary}" font-size="11">${label}</text>`;
+      x += 14 + series.name.length * 6 + 18;
+      return item;
+    });
+    parts.push(...swatches);
+  }
+  return parts.join("");
+};
+var gridSvg = (ticks, yFor, spec, frame) => ticks.map((tick) => {
+  const y = yFor(tick);
+  const isZero = tick === 0;
+  return `<line x1="${frame.plotLeft}" y1="${y}" x2="${frame.plotRight}" y2="${y}" stroke="${isZero ? frame.theme.textSecondary : frame.theme.grid}" stroke-width="1"/><text x="${frame.plotLeft - 8}" y="${y + 3.5}" fill="${frame.theme.textSecondary}" font-size="10" text-anchor="end">${escapeXml(formatValue(tick, spec))}</text>`;
+}).join("");
+var xLabelsSvg = (spec, xCenter, frame) => {
+  const every = Math.ceil(spec.labels.length / 12);
+  return spec.labels.map((label, index) => {
+    if (index % every !== 0)
+      return "";
+    const short = label.length > 12 ? `${label.slice(0, 11)}\u2026` : label;
+    return `<text x="${xCenter(index)}" y="${frame.plotBottom + 18}" fill="${frame.theme.textSecondary}" font-size="10" text-anchor="middle">${escapeXml(short)}</text>`;
+  }).join("");
+};
+var barPath = (x, yValue, yBase, width) => {
+  const up = yValue <= yBase;
+  const top = Math.min(yValue, yBase);
+  const bottom = Math.max(yValue, yBase);
+  const radius = Math.min(BAR_END_RADIUS, width / 2, bottom - top);
+  if (radius <= 0)
+    return "";
+  if (up) {
+    return `M${x},${bottom} L${x},${top + radius} Q${x},${top} ${x + radius},${top} L${x + width - radius},${top} Q${x + width},${top} ${x + width},${top + radius} L${x + width},${bottom} Z`;
+  }
+  return `M${x},${top} L${x},${bottom - radius} Q${x},${bottom} ${x + radius},${bottom} L${x + width - radius},${bottom} Q${x + width},${bottom} ${x + width},${bottom - radius} L${x + width},${top} Z`;
+};
+var valueDomain = (spec) => {
+  const all = spec.series.flatMap((series) => series.values);
+  const min = Math.min(0, ...all);
+  const max = Math.max(0, ...all);
+  return max === min ? { max: min + 1, min } : { max, min };
+};
+var cartesianSvg = (spec, frame) => {
+  const { theme } = frame;
+  const domain = valueDomain(spec);
+  const ticks = niceTicks(domain.min, domain.max);
+  const lo = Math.min(domain.min, ticks[0] ?? domain.min);
+  const hi = Math.max(domain.max, ticks[ticks.length - 1] ?? domain.max);
+  const yFor = (value) => frame.plotBottom - (value - lo) / (hi - lo) * (frame.plotBottom - frame.plotTop);
+  const slot = (frame.plotRight - frame.plotLeft) / spec.labels.length;
+  const xCenter = (index) => frame.plotLeft + slot * (index + 0.5);
+  const parts = [gridSvg(ticks, yFor, spec, frame)];
+  if (spec.type === "bar") {
+    const group = Math.min(slot * 0.72, 64);
+    const barWidth = Math.max(2, (group - MARK_GAP * (spec.series.length - 1)) / spec.series.length);
+    const yBase = yFor(Math.max(lo, Math.min(hi, 0)));
+    spec.series.forEach((series, seriesIndex) => {
+      const color = theme.palette[seriesIndex % theme.palette.length];
+      series.values.forEach((value, index) => {
+        const x = xCenter(index) - group / 2 + seriesIndex * (barWidth + MARK_GAP);
+        const tooltip = `${escapeXml(series.name)} \xB7 ${escapeXml(spec.labels[index] ?? "")}: ${escapeXml(formatValue(value, spec))}`;
+        parts.push(`<path d="${barPath(x, yFor(value), yBase, barWidth)}" fill="${color}"><title>${tooltip}</title></path>`);
+      });
+    });
+    const [only] = spec.series;
+    if (spec.series.length === 1 && only && spec.labels.length <= 8) {
+      only.values.forEach((value, index) => {
+        const above = value >= 0;
+        parts.push(`<text x="${xCenter(index)}" y="${yFor(value) + (above ? -6 : 14)}" fill="${theme.textSecondary}" font-size="10" text-anchor="middle">${escapeXml(formatValue(value, spec))}</text>`);
+      });
+    }
+  } else {
+    spec.series.forEach((series, seriesIndex) => {
+      const color = theme.palette[seriesIndex % theme.palette.length];
+      const points = series.values.map((value, index) => `${xCenter(index)},${yFor(value)}`);
+      parts.push(`<polyline points="${points.join(" ")}" fill="none" stroke="${color}" stroke-width="${LINE_WIDTH}" stroke-linejoin="round" stroke-linecap="round"/>`);
+      series.values.forEach((value, index) => {
+        const tooltip = `${escapeXml(series.name)} \xB7 ${escapeXml(spec.labels[index] ?? "")}: ${escapeXml(formatValue(value, spec))}`;
+        parts.push(`<circle cx="${xCenter(index)}" cy="${yFor(value)}" r="4" fill="${color}" stroke="${theme.surface}" stroke-width="2"><title>${tooltip}</title></circle>`);
+      });
+      const last = series.values[series.values.length - 1];
+      if (spec.series.length <= MAX_DIRECT_LABELED_SERIES && last !== undefined) {
+        parts.push(`<text x="${frame.plotRight + 4}" y="${yFor(last) + 3.5}" fill="${theme.textSecondary}" font-size="10">${escapeXml(series.name)}</text>`);
+      }
+    });
+  }
+  parts.push(xLabelsSvg(spec, xCenter, frame));
+  return parts.join("");
+};
+var donutSvg = (spec, frame) => {
+  const { theme } = frame;
+  const [series] = spec.series;
+  if (!series)
+    return "";
+  const total = series.values.reduce((sum, value) => sum + value, 0);
+  if (total <= 0)
+    return "";
+  const cx = (frame.plotLeft + frame.plotRight) / 2;
+  const cy = (frame.plotTop + frame.plotBottom) / 2 + 4;
+  const radius = Math.min((frame.plotBottom - frame.plotTop) / 2 - 4, (frame.plotRight - frame.plotLeft) / 4);
+  const ring = Math.max(14, radius * 0.34);
+  const mid = radius - ring / 2;
+  const gapAngle = MARK_GAP / mid;
+  const parts = [];
+  let angle = -Math.PI / 2;
+  series.values.forEach((value, index) => {
+    const sweep = value / total * Math.PI * 2;
+    const start = angle + gapAngle / 2;
+    const end = angle + sweep - gapAngle / 2;
+    angle += sweep;
+    if (end <= start)
+      return;
+    const large = end - start > Math.PI ? 1 : 0;
+    const x1 = cx + mid * Math.cos(start);
+    const y1 = cy + mid * Math.sin(start);
+    const x2 = cx + mid * Math.cos(end);
+    const y2 = cy + mid * Math.sin(end);
+    const color = theme.palette[index % theme.palette.length];
+    const share = `${Math.round(value / total * 100)}%`;
+    const tooltip = `${escapeXml(spec.labels[index] ?? "")}: ${escapeXml(formatValue(value, spec))} (${share})`;
+    parts.push(`<path d="M${x1},${y1} A${mid},${mid} 0 ${large} 1 ${x2},${y2}" fill="none" stroke="${color}" stroke-width="${ring}"><title>${tooltip}</title></path>`);
+  });
+  parts.push(`<text x="${cx}" y="${cy + 5}" fill="${theme.textPrimary}" font-size="16" font-weight="600" text-anchor="middle">${escapeXml(formatValue(total, spec))}</text>`);
+  let x = frame.plotLeft;
+  spec.labels.forEach((label, index) => {
+    const color = theme.palette[index % theme.palette.length];
+    parts.push(`<rect x="${x}" y="38" width="10" height="10" rx="2" fill="${color}"/><text x="${x + 14}" y="47" fill="${theme.textSecondary}" font-size="11">${escapeXml(label)}</text>`);
+    x += 14 + label.length * 6 + 18;
+  });
+  return parts.join("");
+};
+var renderChartSvg = (spec, options = {}) => {
+  const base = options.mode === "dark" ? DARK_UI_THEME : LIGHT_UI_THEME;
+  const theme = { ...base, ...options.theme };
+  const width = options.width ?? WIDTH;
+  const height = options.height ?? HEIGHT;
+  const frame = {
+    plotBottom: height - MARGIN.bottom,
+    plotLeft: MARGIN.left,
+    plotRight: width - MARGIN.right - (spec.type === "line" ? 64 : 0),
+    plotTop: MARGIN.top,
+    theme
+  };
+  const body = spec.type === "donut" ? donutSvg(spec, frame) : cartesianSvg(spec, frame);
+  return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${width} ${height}" role="img" aria-label="${escapeXml(spec.title)}" font-family="${FONT}"><rect width="${width}" height="${height}" fill="${theme.surface}" rx="12"/>${spec.type === "donut" ? headerSvg({ ...spec, series: [] }, frame) : headerSvg(spec, frame)}${body}</svg>`;
+};
 // src/ai/conversationManager.ts
 var NOT_FOUND3 = -1;
 var TITLE_MAX_LENGTH2 = 80;
@@ -4332,16 +4944,16 @@ var AVAILABLE_COMPONENT_STATUSES = new Set([
   "degraded_performance"
 ]);
 var AVAILABLE_PAGE_INDICATORS = new Set(["none", "minor"]);
-var isRecord6 = (value) => typeof value === "object" && value !== null;
+var isRecord7 = (value) => typeof value === "object" && value !== null;
 var readString = (record, key) => typeof record[key] === "string" ? record[key] : "";
 var findComponentStatus = (body, componentName) => {
-  if (!isRecord6(body) || !Array.isArray(body.components))
+  if (!isRecord7(body) || !Array.isArray(body.components))
     return null;
-  const match = body.components.filter(isRecord6).find((component) => readString(component, "name") === componentName);
+  const match = body.components.filter(isRecord7).find((component) => readString(component, "name") === componentName);
   return match ? readString(match, "status") : null;
 };
 var readPageIndicator = (body) => {
-  if (!isRecord6(body) || !isRecord6(body.status))
+  if (!isRecord7(body) || !isRecord7(body.status))
     return null;
   const indicator = readString(body.status, "indicator");
   return indicator === "" ? null : indicator;
@@ -4422,14 +5034,21 @@ var startProviderStatusMonitor = (options) => {
 export {
   xai,
   withResilience,
+  tableCard,
+  streamAIWithTools,
   streamAIToSSE,
   streamAI,
+  statTilesCard,
   startProviderStatusMonitor,
   setProviderAvailability,
   serverMessageToAction,
   serializeAIMessage,
   resolveRenderers,
+  renderChartSvg,
   providerStatusPage,
+  parseTableSpec,
+  parseStatTilesSpec,
+  parseChartSpec,
   parseAIMessage,
   openaiResponses,
   openaiCompatible,
@@ -4447,6 +5066,7 @@ export {
   gemini,
   fetchProviderApiStatus,
   deepseek,
+  createUiCards,
   createSyncConversationStore,
   createOAuth2ClientCredentialsTokenSource,
   createMemoryStore,
@@ -4454,12 +5074,22 @@ export {
   createAIStream,
   createAIConnection,
   configureProviderResilience,
+  chartCard,
   anthropic,
   alibaba,
   aiChat,
+  TABLE_MAX_ROWS,
+  TABLE_MAX_COLUMNS,
+  STAT_TILES_MAX,
   ProviderError,
-  PROVIDER_STATUS_PAGES
+  PROVIDER_STATUS_PAGES,
+  LIGHT_UI_THEME,
+  DARK_UI_THEME,
+  CHART_TYPES,
+  CHART_MAX_SERIES,
+  CHART_MAX_POINTS,
+  BUILTIN_UI_CARDS
 };
 
-//# debugId=AAB25EB53BF9BE9064756E2164756E21
+//# debugId=D43CDA3E59D2F6FB64756E2164756E21
 //# sourceMappingURL=index.js.map