@adoptai/genui-components 0.1.32

package/dist/schemas/index.cjs

@@ -0,0 +1,3509 @@
+'use strict';
+
+var zod = require('zod');
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var dataTableSchema = zod.z.object({
+  type: zod.z.literal("data-table"),
+  title: zod.z.string().optional(),
+  columns: zod.z.array(
+    zod.z.object({
+      key: zod.z.string(),
+      label: zod.z.string(),
+      align: zod.z.enum(["start", "center", "end"]).default("start")
+    })
+  ).min(1).max(10),
+  rows: zod.z.array(
+    zod.z.record(zod.z.string(), zod.z.union([zod.z.string(), zod.z.number(), zod.z.boolean(), zod.z.null()]))
+  ).max(100),
+  pagination: zod.z.boolean().default(false)
+});
+var dataTableTool = {
+  name: "render_data_table",
+  description: "Render a structured data table with labeled columns and rows",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["data-table"] },
+      title: { type: "string" },
+      columns: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            key: { type: "string" },
+            label: { type: "string" },
+            align: { type: "string", enum: ["start", "center", "end"] }
+          },
+          required: ["key", "label"]
+        }
+      },
+      rows: {
+        type: "array",
+        items: { type: "object", additionalProperties: true }
+      },
+      pagination: { type: "boolean" }
+    },
+    required: ["type", "columns", "rows"]
+  }
+};
+var variantMap = {
+  outlined: "bordered",
+  outline: "bordered",
+  filled: "solid",
+  solid: "solid",
+  bordered: "bordered",
+  light: "light",
+  flat: "flat",
+  ghost: "ghost"
+};
+var colorMap = {
+  default: "default",
+  primary: "primary",
+  secondary: "secondary",
+  success: "success",
+  warning: "warning",
+  danger: "danger",
+  error: "danger",
+  info: "primary",
+  neutral: "default"
+};
+var statusCardSchema = zod.z.object({
+  type: zod.z.literal("status-card"),
+  title: zod.z.string(),
+  subtitle: zod.z.string().optional(),
+  status: zod.z.enum(["default", "success", "warning", "danger", "primary"]).default("default"),
+  fields: zod.z.array(
+    zod.z.object({
+      label: zod.z.string(),
+      value: zod.z.string(),
+      highlight: zod.z.boolean().default(false)
+    })
+  ).max(12),
+  actions: zod.z.array(
+    zod.z.object({
+      label: zod.z.string(),
+      variant: zod.z.string().transform((v) => {
+        var _a;
+        return (_a = variantMap[v]) != null ? _a : "bordered";
+      }).default("bordered"),
+      color: zod.z.string().transform((v) => {
+        var _a;
+        return (_a = colorMap[v]) != null ? _a : "default";
+      }).default("default")
+    })
+  ).max(3).optional()
+});
+var statusCardTool = {
+  name: "render_status_card",
+  description: "Render a card for a single entity \u2014 person, order, product, task",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["status-card"] },
+      title: { type: "string" },
+      subtitle: { type: "string" },
+      status: {
+        type: "string",
+        enum: ["default", "success", "warning", "danger", "primary"]
+      },
+      fields: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            label: { type: "string" },
+            value: { type: "string" },
+            highlight: { type: "boolean" }
+          },
+          required: ["label", "value"]
+        }
+      },
+      actions: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            label: { type: "string" },
+            variant: { type: "string" },
+            color: { type: "string" }
+          },
+          required: ["label"]
+        }
+      }
+    },
+    required: ["type", "title", "fields"]
+  }
+};
+var alertSchema = zod.z.object({
+  type: zod.z.literal("alert"),
+  color: zod.z.enum([
+    "default",
+    "primary",
+    "secondary",
+    "success",
+    "warning",
+    "danger"
+  ]),
+  title: zod.z.string(),
+  description: zod.z.string().optional()
+});
+var alertTool = {
+  name: "render_alert",
+  description: "Render a short important message \u2014 success, warning, error, or info",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["alert"] },
+      color: {
+        type: "string",
+        enum: ["default", "primary", "secondary", "success", "warning", "danger"]
+      },
+      title: { type: "string" },
+      description: { type: "string" }
+    },
+    required: ["type", "color", "title"]
+  }
+};
+var statGridSchema = zod.z.object({
+  type: zod.z.literal("stat-grid"),
+  stats: zod.z.array(
+    zod.z.object({
+      label: zod.z.string(),
+      value: zod.z.string(),
+      change: zod.z.string().optional(),
+      changeType: zod.z.enum(["positive", "negative", "neutral"]).optional(),
+      description: zod.z.string().optional()
+    })
+  ).min(2).max(4)
+});
+var statGridTool = {
+  name: "render_stat_grid",
+  description: "Render 2\u20134 KPI metric cards side by side",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["stat-grid"] },
+      stats: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            label: { type: "string" },
+            value: { type: "string" },
+            change: { type: "string" },
+            changeType: {
+              type: "string",
+              enum: ["positive", "negative", "neutral"]
+            },
+            description: { type: "string" }
+          },
+          required: ["label", "value"]
+        }
+      }
+    },
+    required: ["type", "stats"]
+  }
+};
+var tabsPanelSchema = zod.z.object({
+  type: zod.z.literal("tabs-panel"),
+  tabs: zod.z.array(
+    zod.z.object({
+      key: zod.z.string(),
+      label: zod.z.string(),
+      content: zod.z.string()
+    })
+  ).min(2).max(6)
+});
+var tabsPanelTool = {
+  name: "render_tabs_panel",
+  description: "Render multiple sections the user can switch between via tabs",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["tabs-panel"] },
+      tabs: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            key: { type: "string" },
+            label: { type: "string" },
+            content: { type: "string" }
+          },
+          required: ["key", "label", "content"]
+        }
+      }
+    },
+    required: ["type", "tabs"]
+  }
+};
+var sparklineTableSchema = zod.z.object({
+  type: zod.z.literal("sparkline-table"),
+  title: zod.z.string().optional(),
+  sparklineLabel: zod.z.string().default("Trend"),
+  columns: zod.z.array(zod.z.object({ key: zod.z.string(), label: zod.z.string(), align: zod.z.enum(["start", "center", "end"]).default("start") })).min(1).max(12),
+  rows: zod.z.array(
+    zod.z.object({
+      sparkline: zod.z.array(zod.z.number()).min(2).max(60)
+    }).catchall(zod.z.union([zod.z.string(), zod.z.number(), zod.z.boolean(), zod.z.null()]))
+  ).max(50)
+});
+var sparklineTableTool = {
+  name: "render_sparkline_table",
+  description: "Render a table where one column shows a 30-day sparkline trend per row \u2014 watchlist, holdings, options chain",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["sparkline-table"] },
+      title: { type: "string" },
+      sparklineLabel: { type: "string" },
+      columns: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: { key: { type: "string" }, label: { type: "string" }, align: { type: "string", enum: ["start", "center", "end"] } },
+          required: ["key", "label"]
+        }
+      },
+      rows: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: { sparkline: { type: "array", items: { type: "number" } } },
+          required: ["sparkline"],
+          additionalProperties: true
+        }
+      }
+    },
+    required: ["type", "columns", "rows"]
+  }
+};
+var heatmapCellSchema = zod.z.object({ value: zod.z.string(), zScore: zod.z.number() });
+var heatmapTableSchema = zod.z.object({
+  type: zod.z.literal("heatmap-table"),
+  title: zod.z.string().optional(),
+  columns: zod.z.array(zod.z.object({ key: zod.z.string(), label: zod.z.string() })).min(1).max(12),
+  rows: zod.z.array(
+    zod.z.object({
+      rowLabel: zod.z.string(),
+      cells: zod.z.array(heatmapCellSchema)
+    })
+  ).max(30)
+});
+var heatmapTableTool = {
+  name: "render_heatmap_table",
+  description: "Render a comparison table where cells are color-scaled by z-score \u2014 fund comparison, peer group, macro heatmap",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["heatmap-table"] },
+      title: { type: "string" },
+      columns: {
+        type: "array",
+        items: { type: "object", properties: { key: { type: "string" }, label: { type: "string" } }, required: ["key", "label"] }
+      },
+      rows: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            rowLabel: { type: "string" },
+            cells: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: { value: { type: "string" }, zScore: { type: "number" } },
+                required: ["value", "zScore"]
+              }
+            }
+          },
+          required: ["rowLabel", "cells"]
+        }
+      }
+    },
+    required: ["type", "columns", "rows"]
+  }
+};
+var screenerTableSchema = zod.z.object({
+  type: zod.z.literal("screener-table"),
+  title: zod.z.string().optional(),
+  columns: zod.z.array(
+    zod.z.object({
+      key: zod.z.string(),
+      label: zod.z.string(),
+      align: zod.z.enum(["start", "center", "end"]).default("start"),
+      meterKey: zod.z.boolean().default(false),
+      meterMax: zod.z.number().optional()
+    })
+  ).min(1).max(10),
+  rows: zod.z.array(zod.z.record(zod.z.string(), zod.z.union([zod.z.string(), zod.z.number(), zod.z.boolean(), zod.z.null()]))).max(100),
+  activeFilters: zod.z.array(zod.z.string()).default([])
+});
+var screenerTableTool = {
+  name: "render_screener_table",
+  description: "Render a sortable table with inline meter bars for scores/ratings \u2014 stock screener, fund search, bond filter",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["screener-table"] },
+      title: { type: "string" },
+      columns: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            key: { type: "string" },
+            label: { type: "string" },
+            align: { type: "string", enum: ["start", "center", "end"] },
+            meterKey: { type: "boolean" },
+            meterMax: { type: "number" }
+          },
+          required: ["key", "label"]
+        }
+      },
+      rows: { type: "array", items: { type: "object", additionalProperties: true } },
+      activeFilters: { type: "array", items: { type: "string" } }
+    },
+    required: ["type", "columns", "rows"]
+  }
+};
+var groupedRowSchema = zod.z.record(zod.z.string(), zod.z.union([zod.z.string(), zod.z.number(), zod.z.boolean(), zod.z.null()]));
+var groupSchema = zod.z.object({
+  groupLabel: zod.z.string(),
+  rows: zod.z.array(groupedRowSchema).max(20),
+  subGroups: zod.z.array(zod.z.object({ groupLabel: zod.z.string(), rows: zod.z.array(groupedRowSchema).max(20) })).optional()
+});
+var groupedTableSchema = zod.z.object({
+  type: zod.z.literal("grouped-table"),
+  title: zod.z.string().optional(),
+  columns: zod.z.array(zod.z.object({
+    key: zod.z.string(),
+    label: zod.z.string(),
+    align: zod.z.string().transform((v) => {
+      var _a;
+      const map = { left: "start", right: "end", start: "start", center: "center", end: "end" };
+      return (_a = map[v]) != null ? _a : "start";
+    }).default("start")
+  })).min(1).max(10),
+  groups: zod.z.array(groupSchema).min(1).max(20)
+});
+var groupedTableTool = {
+  name: "render_grouped_table",
+  description: "Render a table with collapsible row groups \u2014 portfolio hierarchy, sleeve breakdown, consolidated view",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["grouped-table"] },
+      title: { type: "string" },
+      columns: {
+        type: "array",
+        items: { type: "object", properties: { key: { type: "string" }, label: { type: "string" }, align: { type: "string" } }, required: ["key", "label"] }
+      },
+      groups: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            groupLabel: { type: "string" },
+            rows: { type: "array", items: { type: "object", additionalProperties: true } },
+            subGroups: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  groupLabel: { type: "string" },
+                  rows: { type: "array", items: { type: "object", additionalProperties: true } }
+                },
+                required: ["groupLabel", "rows"]
+              }
+            }
+          },
+          required: ["groupLabel", "rows"]
+        }
+      }
+    },
+    required: ["type", "columns", "groups"]
+  }
+};
+var newsFeedSchema = zod.z.object({
+  type: zod.z.literal("news-feed"),
+  title: zod.z.string().optional(),
+  items: zod.z.array(
+    zod.z.object({
+      headline: zod.z.string(),
+      source: zod.z.string(),
+      timestamp: zod.z.string(),
+      sentiment: zod.z.enum(["positive", "neutral", "negative"]),
+      summary: zod.z.string().optional(),
+      url: zod.z.string().optional()
+    })
+  ).min(1).max(20)
+});
+var newsFeedTool = {
+  name: "render_news_feed",
+  description: "Render a list of news items with AI sentiment chips \u2014 news, catalysts, sentiment, macro",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["news-feed"] },
+      title: { type: "string" },
+      items: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            headline: { type: "string" },
+            source: { type: "string" },
+            timestamp: { type: "string" },
+            sentiment: { type: "string", enum: ["positive", "neutral", "negative"] },
+            summary: { type: "string" },
+            url: { type: "string" }
+          },
+          required: ["headline", "source", "timestamp", "sentiment"]
+        }
+      }
+    },
+    required: ["type", "items"]
+  }
+};
+var areaChartSchema = zod.z.object({
+  type: zod.z.literal("area-chart"),
+  title: zod.z.string().optional(),
+  xKey: zod.z.string(),
+  series: zod.z.array(zod.z.object({ name: zod.z.string(), dataKey: zod.z.string(), color: zod.z.string() })).min(1).max(4),
+  data: zod.z.array(zod.z.record(zod.z.string(), zod.z.union([zod.z.string(), zod.z.number()]))).min(2).max(500)
+});
+var areaChartTool = {
+  name: "render_area_chart",
+  description: "Render a multi-series area chart for time series \u2014 cumulative return, benchmark comparison, drawdown",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["area-chart"] },
+      title: { type: "string" },
+      xKey: { type: "string", description: "The key in each data row used as the X-axis label (e.g. 'date')" },
+      series: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: { name: { type: "string" }, dataKey: { type: "string" }, color: { type: "string", description: "CSS color, e.g. #6366f1" } },
+          required: ["name", "dataKey", "color"]
+        }
+      },
+      data: {
+        type: "array",
+        items: { type: "object", additionalProperties: true },
+        description: "Array of data rows. Each row must have xKey and all series dataKeys."
+      }
+    },
+    required: ["type", "xKey", "series", "data"]
+  }
+};
+var allocationDonutSchema = zod.z.object({
+  type: zod.z.literal("allocation-donut"),
+  title: zod.z.string().optional(),
+  slices: zod.z.array(
+    zod.z.object({
+      label: zod.z.string(),
+      value: zod.z.number(),
+      color: zod.z.string().optional(),
+      benchmark: zod.z.number().optional()
+    })
+  ).min(2).max(12)
+});
+var allocationDonutTool = {
+  name: "render_allocation_donut",
+  description: "Render a donut chart with allocation breakdown table \u2014 portfolio, asset class, sector, geography",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["allocation-donut"] },
+      title: { type: "string" },
+      slices: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            label: { type: "string" },
+            value: { type: "number", description: "Percentage 0-100" },
+            color: { type: "string", description: "Optional CSS color" },
+            benchmark: { type: "number", description: "Benchmark weight for over/underweight chip" }
+          },
+          required: ["label", "value"]
+        }
+      }
+    },
+    required: ["type", "slices"]
+  }
+};
+var waterfallChartSchema = zod.z.object({
+  type: zod.z.literal("waterfall-chart"),
+  title: zod.z.string().optional(),
+  bars: zod.z.array(
+    zod.z.object({
+      label: zod.z.string(),
+      value: zod.z.number(),
+      isTotal: zod.z.boolean().default(false)
+    })
+  ).min(2).max(20),
+  unit: zod.z.string().default("%")
+});
+var waterfallChartTool = {
+  name: "render_waterfall_chart",
+  description: "Render a waterfall bar chart showing contribution of each factor to total return \u2014 factor attribution, P&L attribution",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["waterfall-chart"] },
+      title: { type: "string" },
+      bars: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            label: { type: "string" },
+            value: { type: "number", description: "Positive or negative contribution" },
+            isTotal: { type: "boolean", description: "True for the total/net bar" }
+          },
+          required: ["label", "value"]
+        }
+      },
+      unit: { type: "string", description: "Unit label, e.g. '%' or 'bps'" }
+    },
+    required: ["type", "bars"]
+  }
+};
+var flowCanvasSchema = zod.z.object({
+  type: zod.z.literal("flow-canvas"),
+  // Stable identity. Re-send render_flow_canvas with the SAME id to update the
+  // existing card in place (e.g. as pipeline stages progress) instead of adding a
+  // new one.
+  id: zod.z.string().optional(),
+  title: zod.z.string().optional(),
+  description: zod.z.string().optional(),
+  diagram: zod.z.string().min(1),
+  // Per-node run status, keyed by Mermaid node id OR its label. Drives the
+  // pending/active/done/error styling + transition animation.
+  node_states: zod.z.record(zod.z.string(), zod.z.enum(["pending", "active", "done", "error"])).optional(),
+  // Auto-animate the flow running (loops) — for live demos. No on-screen controls.
+  autoplay: zod.z.boolean().optional()
+});
+var flowCanvasTool = {
+  name: "render_flow_canvas",
+  description: `Render a Mermaid diagram for user flows, workflows, system architecture, process maps, mind maps, ER diagrams, sequence diagrams, and any visual design artifact. Use when the user asks to visualize a process, flow, system, or diagram of any kind.`,
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["flow-canvas"] },
+      id: {
+        type: "string",
+        description: "Stable id for this diagram. To UPDATE a previously shown flow (e.g. a pipeline as its stages progress), re-render with the SAME id and updated node_states \u2014 the existing card updates in place instead of a new one being added. Omit for one-off diagrams."
+      },
+      title: { type: "string", description: "Diagram title, shown above the canvas" },
+      description: { type: "string", description: "One-line description of what the diagram shows" },
+      node_states: {
+        type: "object",
+        description: "Optional per-node run status, keyed by the Mermaid node id or its label, value one of 'pending' | 'active' | 'done' | 'error'. Drives stage coloring + a paint animation. Update these (with the same id) as the workflow progresses.",
+        additionalProperties: { type: "string", enum: ["pending", "active", "done", "error"] }
+      },
+      autoplay: {
+        type: "boolean",
+        description: "When true, the flow auto-animates each node lighting up in sequence (loops) \u2014 use only to DEMO a workflow running when there is no real per-stage status to report."
+      },
+      diagram: {
+        type: "string",
+        description: `A valid Mermaid diagram string. Keep diagrams COMPACT \u2014 max 15 nodes, short labels (1-4 words each). No emojis anywhere.
+
+flowchart TD (top-down flows and processes):
+  flowchart TD
+    A([Start]) --> B[Step One]
+    B --> C{Decision?}
+    C -->|Yes| D[Path A]
+    C -->|No| E[Path B]
+    D --> F([End])
+    E --> F
+
+flowchart LR (left-right pipelines):
+  flowchart LR
+    A[Input] --> B[Process] --> C[Output]
+
+sequenceDiagram (actor interactions):
+  sequenceDiagram
+    participant U as User
+    participant S as Server
+    U->>S: POST /login
+    S-->>U: 200 OK
+
+erDiagram:
+  erDiagram
+    USER ||--o{ ORDER : places
+    ORDER ||--|{ LINE_ITEM : contains
+
+classDiagram:
+  classDiagram
+    Animal <|-- Dog
+    Animal: +name string
+
+RULES \u2014 follow these exactly:
+- Max 15 nodes total. For complex topics, show the happy path only; omit edge cases
+- Labels: 1-4 words, no punctuation other than / or &
+- No emojis anywhere
+- No inline style directives (style A fill:#...)
+- Prefer TD for flows, LR for pipelines, sequence for interactions
+- Use subgraph only when 2+ clear groups exist; max 2 subgraphs
+- Do NOT wrap output in \`\`\`mermaid fences`
+      }
+    },
+    required: ["type", "diagram"]
+  }
+};
+var trialBalanceSchema = zod.z.object({
+  type: zod.z.literal("trial-balance"),
+  title: zod.z.string().optional(),
+  asOfDate: zod.z.string().optional(),
+  currency: zod.z.string().default("USD"),
+  groups: zod.z.array(
+    zod.z.object({
+      category: zod.z.enum(["assets", "liabilities", "equity", "revenue", "expenses", "other"]),
+      accounts: zod.z.array(
+        zod.z.object({
+          code: zod.z.string(),
+          name: zod.z.string(),
+          debit: zod.z.number().min(0).default(0),
+          credit: zod.z.number().min(0).default(0)
+        })
+      ).min(1).max(30)
+    })
+  ).min(1).max(6)
+});
+var trialBalanceTool = {
+  name: "render_trial_balance",
+  description: "Render a debit/credit trial balance grouped by account category \u2014 chart of accounts, balance verification",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["trial-balance"] },
+      title: { type: "string" },
+      asOfDate: { type: "string", description: "As-of date for the balance" },
+      currency: { type: "string", description: "ISO currency code, e.g. USD" },
+      groups: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            category: {
+              type: "string",
+              enum: ["assets", "liabilities", "equity", "revenue", "expenses", "other"]
+            },
+            accounts: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  code: { type: "string" },
+                  name: { type: "string" },
+                  debit: { type: "number", minimum: 0 },
+                  credit: { type: "number", minimum: 0 }
+                },
+                required: ["code", "name"]
+              }
+            }
+          },
+          required: ["category", "accounts"]
+        }
+      }
+    },
+    required: ["type", "groups"]
+  }
+};
+var journalEntrySchema = zod.z.object({
+  type: zod.z.literal("journal-entry"),
+  title: zod.z.string().optional(),
+  entries: zod.z.array(
+    zod.z.object({
+      entryId: zod.z.string(),
+      date: zod.z.string(),
+      memo: zod.z.string().optional(),
+      status: zod.z.enum(["draft", "posted", "reversed", "pending-approval"]).default("posted"),
+      lines: zod.z.array(
+        zod.z.object({
+          account: zod.z.string(),
+          description: zod.z.string().optional(),
+          debit: zod.z.number().min(0).default(0),
+          credit: zod.z.number().min(0).default(0)
+        })
+      ).min(2).max(20)
+    })
+  ).min(1).max(10),
+  currency: zod.z.string().default("USD")
+});
+var journalEntryTool = {
+  name: "render_journal_entry",
+  description: "Render journal entries with debit/credit lines \u2014 transactions, adjusting entries, postings",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["journal-entry"] },
+      title: { type: "string" },
+      entries: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            entryId: { type: "string" },
+            date: { type: "string", description: "ISO date" },
+            memo: { type: "string" },
+            status: { type: "string", enum: ["draft", "posted", "reversed", "pending-approval"] },
+            lines: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  account: { type: "string" },
+                  description: { type: "string" },
+                  debit: { type: "number", minimum: 0 },
+                  credit: { type: "number", minimum: 0 }
+                },
+                required: ["account"]
+              }
+            }
+          },
+          required: ["entryId", "date", "lines"]
+        }
+      },
+      currency: { type: "string" }
+    },
+    required: ["type", "entries"]
+  }
+};
+var agingReportSchema = zod.z.object({
+  type: zod.z.literal("aging-report"),
+  title: zod.z.string().optional(),
+  reportType: zod.z.enum(["receivable", "payable"]).default("receivable"),
+  asOfDate: zod.z.string().optional(),
+  currency: zod.z.string().default("USD"),
+  buckets: zod.z.array(zod.z.string()).min(2).max(7),
+  entities: zod.z.array(
+    zod.z.object({
+      name: zod.z.string(),
+      amounts: zod.z.array(zod.z.number()).min(2).max(7),
+      total: zod.z.number()
+    })
+  ).min(1).max(50)
+});
+var agingReportTool = {
+  name: "render_aging_report",
+  description: "Render an AR/AP aging report with time buckets \u2014 overdue invoices, collections, payables aging",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["aging-report"] },
+      title: { type: "string" },
+      reportType: { type: "string", enum: ["receivable", "payable"] },
+      asOfDate: { type: "string" },
+      currency: { type: "string" },
+      buckets: {
+        type: "array",
+        items: { type: "string" },
+        description: "Aging bucket labels, e.g. ['Current','1-30','31-60','61-90','90+']"
+      },
+      entities: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            name: { type: "string" },
+            amounts: { type: "array", items: { type: "number" }, description: "One amount per bucket" },
+            total: { type: "number" }
+          },
+          required: ["name", "amounts", "total"]
+        }
+      }
+    },
+    required: ["type", "buckets", "entities"]
+  }
+};
+var varianceAnalysisSchema = zod.z.object({
+  type: zod.z.literal("variance-analysis"),
+  title: zod.z.string().optional(),
+  currency: zod.z.string().default("USD"),
+  period: zod.z.string().optional(),
+  rows: zod.z.array(
+    zod.z.object({
+      lineItem: zod.z.string(),
+      budget: zod.z.number(),
+      actual: zod.z.number(),
+      isSubtotal: zod.z.boolean().default(false),
+      indent: zod.z.number().min(0).max(3).default(0)
+    })
+  ).min(1).max(50),
+  favorableDirection: zod.z.enum(["higher", "lower"]).default("higher")
+});
+var varianceAnalysisTool = {
+  name: "render_variance_analysis",
+  description: "Render a budget vs actual table with variance columns \u2014 cost analysis, performance vs target",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["variance-analysis"] },
+      title: { type: "string" },
+      currency: { type: "string" },
+      period: { type: "string" },
+      rows: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            lineItem: { type: "string" },
+            budget: { type: "number" },
+            actual: { type: "number" },
+            isSubtotal: { type: "boolean" },
+            indent: { type: "number", minimum: 0, maximum: 3 }
+          },
+          required: ["lineItem", "budget", "actual"]
+        }
+      },
+      favorableDirection: {
+        type: "string",
+        enum: ["higher", "lower"],
+        description: "Whether higher actual is favorable (revenue) or unfavorable (cost)"
+      }
+    },
+    required: ["type", "rows"]
+  }
+};
+var stackedBreakdownSchema = zod.z.object({
+  type: zod.z.literal("stacked-breakdown"),
+  title: zod.z.string().optional(),
+  currency: zod.z.string().default("USD"),
+  periods: zod.z.array(zod.z.string()).min(1).max(12),
+  categories: zod.z.array(
+    zod.z.object({
+      name: zod.z.string(),
+      color: zod.z.string().optional(),
+      values: zod.z.array(zod.z.number()).min(1).max(12)
+    })
+  ).min(1).max(8),
+  totals: zod.z.array(zod.z.number()).optional()
+});
+var stackedBreakdownTool = {
+  name: "render_stacked_breakdown",
+  description: "Render a stacked bar chart with category breakdown across periods \u2014 cost breakdown, revenue by segment, liability composition, budget allocation",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["stacked-breakdown"] },
+      title: { type: "string" },
+      currency: { type: "string" },
+      periods: {
+        type: "array",
+        items: { type: "string" },
+        description: "Period labels, e.g. ['Q1 2024','Q2 2024']"
+      },
+      categories: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            name: { type: "string" },
+            color: { type: "string" },
+            values: { type: "array", items: { type: "number" }, description: "One value per period" }
+          },
+          required: ["name", "values"]
+        }
+      },
+      totals: { type: "array", items: { type: "number" }, description: "Optional pre-computed totals per period" }
+    },
+    required: ["type", "periods", "categories"]
+  }
+};
+var comparativeBarChartSchema = zod.z.object({
+  type: zod.z.literal("comparative-bar-chart"),
+  title: zod.z.string().optional(),
+  mode: zod.z.enum(["grouped", "stacked"]).default("grouped"),
+  orientation: zod.z.enum(["vertical", "horizontal"]).default("vertical"),
+  xKey: zod.z.string(),
+  series: zod.z.array(
+    zod.z.object({
+      name: zod.z.string(),
+      dataKey: zod.z.string(),
+      color: zod.z.string().optional()
+    })
+  ).min(1).max(6),
+  data: zod.z.array(zod.z.record(zod.z.string(), zod.z.union([zod.z.string(), zod.z.number()]))).min(1).max(24),
+  unit: zod.z.string().default(""),
+  showValues: zod.z.boolean().default(false)
+});
+var comparativeBarChartTool = {
+  name: "render_comparative_bar_chart",
+  description: "Render a grouped or stacked bar chart for comparisons \u2014 period-over-period, multi-entity benchmarks",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["comparative-bar-chart"] },
+      title: { type: "string" },
+      mode: { type: "string", enum: ["grouped", "stacked"] },
+      orientation: { type: "string", enum: ["vertical", "horizontal"] },
+      xKey: { type: "string", description: "Key in data objects for x-axis labels" },
+      series: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            name: { type: "string" },
+            dataKey: { type: "string" },
+            color: { type: "string" }
+          },
+          required: ["name", "dataKey"]
+        }
+      },
+      data: { type: "array", items: { type: "object", additionalProperties: true } },
+      unit: { type: "string" },
+      showValues: { type: "boolean" }
+    },
+    required: ["type", "xKey", "series", "data"]
+  }
+};
+var complianceChecklistSchema = zod.z.object({
+  type: zod.z.literal("compliance-checklist"),
+  title: zod.z.string().optional(),
+  sections: zod.z.array(
+    zod.z.object({
+      sectionTitle: zod.z.string(),
+      items: zod.z.array(
+        zod.z.object({
+          id: zod.z.string(),
+          description: zod.z.string(),
+          status: zod.z.enum(["completed", "in-progress", "not-started", "overdue", "blocked", "na"]),
+          dueDate: zod.z.string().optional(),
+          assignee: zod.z.string().optional(),
+          notes: zod.z.string().optional(),
+          priority: zod.z.enum(["critical", "high", "medium", "low"]).default("medium")
+        })
+      ).min(1).max(25)
+    })
+  ).min(1).max(10)
+});
+var complianceChecklistTool = {
+  name: "render_compliance_checklist",
+  description: "Render a regulatory checklist with status tracking \u2014 audit checklist, SOX, filing deadlines",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["compliance-checklist"] },
+      title: { type: "string" },
+      sections: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            sectionTitle: { type: "string" },
+            items: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  id: { type: "string" },
+                  description: { type: "string" },
+                  status: {
+                    type: "string",
+                    enum: ["completed", "in-progress", "not-started", "overdue", "blocked", "na"]
+                  },
+                  dueDate: { type: "string" },
+                  assignee: { type: "string" },
+                  notes: { type: "string" },
+                  priority: { type: "string", enum: ["critical", "high", "medium", "low"] }
+                },
+                required: ["id", "description", "status"]
+              }
+            }
+          },
+          required: ["sectionTitle", "items"]
+        }
+      }
+    },
+    required: ["type", "sections"]
+  }
+};
+var reconciliationViewSchema = zod.z.object({
+  type: zod.z.literal("reconciliation-view"),
+  title: zod.z.string().optional(),
+  currency: zod.z.string().default("USD"),
+  sourceA: zod.z.object({ label: zod.z.string() }),
+  sourceB: zod.z.object({ label: zod.z.string() }),
+  matched: zod.z.array(
+    zod.z.object({
+      date: zod.z.string(),
+      description: zod.z.string(),
+      amountA: zod.z.number(),
+      amountB: zod.z.number(),
+      reference: zod.z.string().optional()
+    })
+  ).max(50).default([]),
+  unmatchedA: zod.z.array(
+    zod.z.object({
+      date: zod.z.string(),
+      description: zod.z.string(),
+      amount: zod.z.number(),
+      reference: zod.z.string().optional()
+    })
+  ).max(30).default([]),
+  unmatchedB: zod.z.array(
+    zod.z.object({
+      date: zod.z.string(),
+      description: zod.z.string(),
+      amount: zod.z.number(),
+      reference: zod.z.string().optional()
+    })
+  ).max(30).default([]),
+  summary: zod.z.object({
+    balanceA: zod.z.number(),
+    balanceB: zod.z.number(),
+    difference: zod.z.number()
+  }).optional()
+});
+var reconciliationViewTool = {
+  name: "render_reconciliation_view",
+  description: "Render a side-by-side reconciliation of two sources \u2014 bank recon, intercompany matching",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["reconciliation-view"] },
+      title: { type: "string" },
+      currency: { type: "string" },
+      sourceA: {
+        type: "object",
+        properties: { label: { type: "string" } },
+        required: ["label"]
+      },
+      sourceB: {
+        type: "object",
+        properties: { label: { type: "string" } },
+        required: ["label"]
+      },
+      matched: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            date: { type: "string" },
+            description: { type: "string" },
+            amountA: { type: "number" },
+            amountB: { type: "number" },
+            reference: { type: "string" }
+          },
+          required: ["date", "description", "amountA", "amountB"]
+        }
+      },
+      unmatchedA: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            date: { type: "string" },
+            description: { type: "string" },
+            amount: { type: "number" },
+            reference: { type: "string" }
+          },
+          required: ["date", "description", "amount"]
+        }
+      },
+      unmatchedB: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            date: { type: "string" },
+            description: { type: "string" },
+            amount: { type: "number" },
+            reference: { type: "string" }
+          },
+          required: ["date", "description", "amount"]
+        }
+      },
+      summary: {
+        type: "object",
+        properties: {
+          balanceA: { type: "number" },
+          balanceB: { type: "number" },
+          difference: { type: "number" }
+        },
+        required: ["balanceA", "balanceB", "difference"]
+      }
+    },
+    required: ["type", "sourceA", "sourceB"]
+  }
+};
+var auditTrailSchema = zod.z.object({
+  type: zod.z.literal("audit-trail"),
+  title: zod.z.string().optional(),
+  entityName: zod.z.string().optional(),
+  events: zod.z.array(
+    zod.z.object({
+      timestamp: zod.z.string(),
+      actor: zod.z.string(),
+      action: zod.z.enum([
+        "created",
+        "modified",
+        "approved",
+        "rejected",
+        "deleted",
+        "restored",
+        "submitted",
+        "commented"
+      ]),
+      summary: zod.z.string(),
+      changes: zod.z.array(
+        zod.z.object({
+          field: zod.z.string(),
+          oldValue: zod.z.string().optional(),
+          newValue: zod.z.string().optional()
+        })
+      ).max(10).optional()
+    })
+  ).min(1).max(50)
+});
+var auditTrailTool = {
+  name: "render_audit_trail",
+  description: "Render a chronological change log with diffs \u2014 revision history, modification tracking",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["audit-trail"] },
+      title: { type: "string" },
+      entityName: { type: "string" },
+      events: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            timestamp: { type: "string", description: "ISO datetime" },
+            actor: { type: "string" },
+            action: {
+              type: "string",
+              enum: ["created", "modified", "approved", "rejected", "deleted", "restored", "submitted", "commented"]
+            },
+            summary: { type: "string" },
+            changes: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  field: { type: "string" },
+                  oldValue: { type: "string" },
+                  newValue: { type: "string" }
+                },
+                required: ["field"]
+              }
+            }
+          },
+          required: ["timestamp", "actor", "action", "summary"]
+        }
+      }
+    },
+    required: ["type", "events"]
+  }
+};
+var documentPreviewSchema = zod.z.object({
+  type: zod.z.literal("document-preview"),
+  title: zod.z.string().optional(),
+  documentType: zod.z.enum(["pdf", "excel"]),
+  source: zod.z.object({
+    url: zod.z.string().optional(),
+    base64: zod.z.string().optional(),
+    filename: zod.z.string()
+  }),
+  pages: zod.z.array(
+    zod.z.object({
+      label: zod.z.string(),
+      content: zod.z.string().optional(),
+      imageUrl: zod.z.string().optional()
+    })
+  ).min(1).max(100),
+  metadata: zod.z.object({
+    pageCount: zod.z.number().optional(),
+    fileSize: zod.z.string().optional(),
+    lastModified: zod.z.string().optional()
+  }).optional(),
+  highlights: zod.z.array(
+    zod.z.object({
+      pageIndex: zod.z.number(),
+      text: zod.z.string(),
+      color: zod.z.enum(["yellow", "red", "green", "blue"]).default("yellow"),
+      note: zod.z.string().optional()
+    })
+  ).max(50).optional()
+});
+var documentPreviewTool = {
+  name: "render_document_preview",
+  description: "Render a read-only document viewer for PDF/Excel \u2014 tax returns, financial statements, supporting docs. Demo files available: source.url='/demos/sample-tax-return.pdf' (3-page Q4 2024 tax return) and source.url='/demos/sample-budget.xlsx' (3-sheet Q4 2024 budget). When using a demo file, set source.url and provide pages with labels for fallback.",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["document-preview"] },
+      title: { type: "string" },
+      documentType: { type: "string", enum: ["pdf", "excel"] },
+      source: {
+        type: "object",
+        properties: {
+          url: { type: "string" },
+          base64: { type: "string" },
+          filename: { type: "string" }
+        },
+        required: ["filename"]
+      },
+      pages: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            label: { type: "string" },
+            content: { type: "string", description: "Text content for accessibility" },
+            imageUrl: { type: "string", description: "Pre-rendered page image URL" }
+          },
+          required: ["label"]
+        }
+      },
+      metadata: {
+        type: "object",
+        properties: {
+          pageCount: { type: "number" },
+          fileSize: { type: "string" },
+          lastModified: { type: "string" }
+        }
+      },
+      highlights: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            pageIndex: { type: "number" },
+            text: { type: "string" },
+            color: { type: "string", enum: ["yellow", "red", "green", "blue"] },
+            note: { type: "string" }
+          },
+          required: ["pageIndex", "text"]
+        }
+      }
+    },
+    required: ["type", "documentType", "source", "pages"]
+  }
+};
+var provenanceChainSchema = zod.z.object({
+  type: zod.z.literal("provenance-chain"),
+  title: zod.z.string().optional(),
+  entity: zod.z.object({
+    name: zod.z.string(),
+    type: zod.z.string(),
+    value: zod.z.string()
+  }),
+  steps: zod.z.array(
+    zod.z.object({
+      stepType: zod.z.enum(["source", "extraction", "rag-query", "reasoning", "computation"]),
+      label: zod.z.string(),
+      detail: zod.z.string(),
+      source: zod.z.string().optional(),
+      location: zod.z.string().optional(),
+      confidence: zod.z.number().min(0).max(1).optional(),
+      metadata: zod.z.record(zod.z.string(), zod.z.string()).optional()
+    })
+  ).min(1).max(20),
+  conclusion: zod.z.object({
+    value: zod.z.string(),
+    confidence: zod.z.number().min(0).max(1),
+    status: zod.z.enum(["qualified", "partially-qualified", "not-qualified"])
+  })
+});
+var provenanceChainTool = {
+  name: "render_provenance_chain",
+  description: "Render a provenance chain showing how a data value was derived \u2014 source documents, extractions, reasoning steps, confidence scores. Use for employee qualification traces, data lineage, audit provenance.",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["provenance-chain"] },
+      title: { type: "string" },
+      entity: {
+        type: "object",
+        properties: {
+          name: { type: "string" },
+          type: { type: "string" },
+          value: { type: "string" }
+        },
+        required: ["name", "type", "value"]
+      },
+      steps: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            stepType: {
+              type: "string",
+              enum: ["source", "extraction", "rag-query", "reasoning", "computation"]
+            },
+            label: { type: "string" },
+            detail: { type: "string" },
+            source: { type: "string" },
+            location: { type: "string" },
+            confidence: { type: "number", minimum: 0, maximum: 1 },
+            metadata: {
+              type: "object",
+              additionalProperties: { type: "string" }
+            }
+          },
+          required: ["stepType", "label", "detail"]
+        }
+      },
+      conclusion: {
+        type: "object",
+        properties: {
+          value: { type: "string" },
+          confidence: { type: "number", minimum: 0, maximum: 1 },
+          status: {
+            type: "string",
+            enum: ["qualified", "partially-qualified", "not-qualified"]
+          }
+        },
+        required: ["value", "confidence", "status"]
+      }
+    },
+    required: ["type", "entity", "steps", "conclusion"]
+  }
+};
+var searchResultsSchema = zod.z.object({
+  type: zod.z.literal("search-results"),
+  title: zod.z.string().optional(),
+  query: zod.z.string(),
+  totalResults: zod.z.number(),
+  results: zod.z.array(zod.z.object({
+    title: zod.z.string(),
+    source: zod.z.string(),
+    sourceType: zod.z.enum(["tech-memo", "questionnaire", "contract", "workpaper", "regulation", "other"]).optional(),
+    relevance: zod.z.number().min(0).max(1),
+    snippet: zod.z.string(),
+    highlights: zod.z.array(zod.z.string()).optional(),
+    location: zod.z.string().optional(),
+    url: zod.z.string().optional()
+  })).min(1).max(20)
+});
+var searchResultsTool = {
+  name: "render_search_results",
+  description: "Render ranked search results with relevance scores, source attribution, and content snippets \u2014 document search, regulatory search, knowledge base queries.",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["search-results"] },
+      title: { type: "string" },
+      query: { type: "string" },
+      totalResults: { type: "number" },
+      results: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            title: { type: "string" },
+            source: { type: "string" },
+            sourceType: {
+              type: "string",
+              enum: ["tech-memo", "questionnaire", "contract", "workpaper", "regulation", "other"]
+            },
+            relevance: { type: "number", minimum: 0, maximum: 1 },
+            snippet: { type: "string" },
+            highlights: { type: "array", items: { type: "string" } },
+            location: { type: "string" },
+            url: { type: "string" }
+          },
+          required: ["title", "source", "relevance", "snippet"]
+        }
+      }
+    },
+    required: ["type", "query", "totalResults", "results"]
+  }
+};
+var legalTestResultSchema = zod.z.object({
+  type: zod.z.literal("legal-test-result"),
+  title: zod.z.string().optional(),
+  citation: zod.z.string().optional(),
+  overallResult: zod.z.enum(["pass", "fail", "inconclusive", "partial"]),
+  overallNarrative: zod.z.string().optional(),
+  parts: zod.z.array(
+    zod.z.object({
+      partLabel: zod.z.string(),
+      result: zod.z.enum(["pass", "fail", "inconclusive", "na"]),
+      narrative: zod.z.string(),
+      subRequirements: zod.z.array(
+        zod.z.object({
+          label: zod.z.string(),
+          result: zod.z.enum(["pass", "fail", "inconclusive", "na"]),
+          detail: zod.z.string().optional(),
+          threshold: zod.z.string().optional(),
+          evidence: zod.z.string().optional()
+        })
+      ).max(10).optional(),
+      examples: zod.z.array(
+        zod.z.object({
+          scenario: zod.z.string(),
+          qualifies: zod.z.boolean(),
+          explanation: zod.z.string()
+        })
+      ).max(6).optional()
+    })
+  ).min(1).max(8)
+});
+var legalTestResultTool = {
+  name: "render_legal_test_result",
+  description: "Render a hierarchical legal test result \u2014 IRC 41 four-part test, funded-research exclusion two-prong test, regulatory compliance determinations with pass/fail at each level, narrative reasoning, and evidence.",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["legal-test-result"] },
+      title: { type: "string" },
+      citation: { type: "string" },
+      overallResult: {
+        type: "string",
+        enum: ["pass", "fail", "inconclusive", "partial"]
+      },
+      overallNarrative: { type: "string" },
+      parts: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            partLabel: { type: "string" },
+            result: {
+              type: "string",
+              enum: ["pass", "fail", "inconclusive", "na"]
+            },
+            narrative: { type: "string" },
+            subRequirements: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  label: { type: "string" },
+                  result: {
+                    type: "string",
+                    enum: ["pass", "fail", "inconclusive", "na"]
+                  },
+                  detail: { type: "string" },
+                  threshold: { type: "string" },
+                  evidence: { type: "string" }
+                },
+                required: ["label", "result"]
+              }
+            },
+            examples: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  scenario: { type: "string" },
+                  qualifies: { type: "boolean" },
+                  explanation: { type: "string" }
+                },
+                required: ["scenario", "qualifies", "explanation"]
+              }
+            }
+          },
+          required: ["partLabel", "result", "narrative"]
+        }
+      }
+    },
+    required: ["type", "overallResult", "parts"]
+  }
+};
+var engagementPipelineSchema = zod.z.object({
+  type: zod.z.literal("engagement-pipeline"),
+  title: zod.z.string().optional(),
+  clientName: zod.z.string(),
+  taxYear: zod.z.string(),
+  currentPhase: zod.z.string(),
+  phases: zod.z.array(
+    zod.z.object({
+      label: zod.z.string(),
+      status: zod.z.enum(["completed", "in-progress", "pending", "blocked"]),
+      completedDate: zod.z.string().optional(),
+      progress: zod.z.number().min(0).max(100).optional(),
+      milestones: zod.z.array(
+        zod.z.object({
+          label: zod.z.string(),
+          completed: zod.z.boolean(),
+          note: zod.z.string().optional()
+        })
+      ).max(10).optional(),
+      blockers: zod.z.array(zod.z.string()).max(5).optional()
+    })
+  ).min(2).max(8),
+  summary: zod.z.object({
+    totalCredit: zod.z.string().optional(),
+    daysRemaining: zod.z.number().optional(),
+    lastActivity: zod.z.string().optional()
+  }).optional()
+});
+var engagementPipelineTool = {
+  name: "render_engagement_pipeline",
+  description: "Render a multi-phase engagement pipeline with progress tracking \u2014 client engagement status, tax year progress, sequential workflow phases with milestones and blockers.",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["engagement-pipeline"] },
+      title: { type: "string" },
+      clientName: { type: "string" },
+      taxYear: { type: "string" },
+      currentPhase: { type: "string" },
+      phases: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            label: { type: "string" },
+            status: {
+              type: "string",
+              enum: ["completed", "in-progress", "pending", "blocked"]
+            },
+            completedDate: { type: "string" },
+            progress: { type: "number", minimum: 0, maximum: 100 },
+            milestones: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  label: { type: "string" },
+                  completed: { type: "boolean" },
+                  note: { type: "string" }
+                },
+                required: ["label", "completed"]
+              }
+            },
+            blockers: { type: "array", items: { type: "string" } }
+          },
+          required: ["label", "status"]
+        }
+      },
+      summary: {
+        type: "object",
+        properties: {
+          totalCredit: { type: "string" },
+          daysRemaining: { type: "number" },
+          lastActivity: { type: "string" }
+        }
+      }
+    },
+    required: ["type", "clientName", "taxYear", "currentPhase", "phases"]
+  }
+};
+var entityCardGridSchema = zod.z.object({
+  type: zod.z.literal("entity-card-grid"),
+  title: zod.z.string().optional(),
+  columns: zod.z.union([zod.z.literal(2), zod.z.literal(3), zod.z.literal(4)]).default(3),
+  items: zod.z.array(
+    zod.z.object({
+      id: zod.z.string(),
+      name: zod.z.string(),
+      subtitle: zod.z.string().optional(),
+      avatar: zod.z.string().optional(),
+      badges: zod.z.array(
+        zod.z.object({
+          label: zod.z.string(),
+          color: zod.z.enum(["green", "red", "amber", "blue", "purple", "gray"]).default("gray")
+        })
+      ).optional(),
+      fields: zod.z.array(zod.z.object({ label: zod.z.string(), value: zod.z.string() })).max(6).optional()
+    })
+  ).min(1).max(24)
+});
+var entityCardGridTool = {
+  name: "render_entity_card_grid",
+  description: "Render a grid of entity cards for browsing collections \u2014 clients, contacts, products, teams, resources",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["entity-card-grid"] },
+      title: { type: "string" },
+      columns: { type: "number", enum: [2, 3, 4] },
+      items: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            id: { type: "string" },
+            name: { type: "string" },
+            subtitle: { type: "string" },
+            avatar: { type: "string" },
+            badges: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  label: { type: "string" },
+                  color: {
+                    type: "string",
+                    enum: ["green", "red", "amber", "blue", "purple", "gray"]
+                  }
+                },
+                required: ["label"]
+              }
+            },
+            fields: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  label: { type: "string" },
+                  value: { type: "string" }
+                },
+                required: ["label", "value"]
+              }
+            }
+          },
+          required: ["id", "name"]
+        }
+      }
+    },
+    required: ["type", "items"]
+  }
+};
+var jobTrackerSchema = zod.z.object({
+  type: zod.z.literal("job-tracker"),
+  title: zod.z.string().optional(),
+  jobId: zod.z.string(),
+  status: zod.z.enum(["queued", "running", "completed", "failed", "cancelled"]),
+  progress: zod.z.number().min(0).max(100).optional(),
+  startedAt: zod.z.string().optional(),
+  completedAt: zod.z.string().optional(),
+  steps: zod.z.array(zod.z.object({
+    label: zod.z.string(),
+    status: zod.z.enum(["pending", "running", "completed", "failed", "skipped"]),
+    duration: zod.z.string().optional()
+  })).optional(),
+  result: zod.z.object({
+    summary: zod.z.string(),
+    data: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
+  }).optional(),
+  error: zod.z.object({
+    message: zod.z.string(),
+    code: zod.z.string().optional()
+  }).optional()
+});
+var jobTrackerTool = {
+  name: "render_job_tracker",
+  description: "Render a job or task status tracker with progress bar, steps, and result \u2014 for async operations, builds, imports, exports",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["job-tracker"] },
+      title: { type: "string" },
+      jobId: { type: "string" },
+      status: { type: "string", enum: ["queued", "running", "completed", "failed", "cancelled"] },
+      progress: { type: "number", minimum: 0, maximum: 100 },
+      startedAt: { type: "string" },
+      completedAt: { type: "string" },
+      steps: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            label: { type: "string" },
+            status: { type: "string", enum: ["pending", "running", "completed", "failed", "skipped"] },
+            duration: { type: "string" }
+          },
+          required: ["label", "status"]
+        }
+      },
+      result: {
+        type: "object",
+        properties: {
+          summary: { type: "string" },
+          data: { type: "object" }
+        },
+        required: ["summary"]
+      },
+      error: {
+        type: "object",
+        properties: {
+          message: { type: "string" },
+          code: { type: "string" }
+        },
+        required: ["message"]
+      }
+    },
+    required: ["type", "jobId", "status"]
+  }
+};
+var citedAnswerSchema = zod.z.object({
+  type: zod.z.literal("cited-answer"),
+  title: zod.z.string().optional(),
+  answer: zod.z.string(),
+  citations: zod.z.array(zod.z.object({
+    id: zod.z.string(),
+    label: zod.z.string(),
+    source: zod.z.string(),
+    sourceType: zod.z.string().optional(),
+    snippet: zod.z.string(),
+    url: zod.z.string().optional(),
+    confidence: zod.z.number().min(0).max(1).optional()
+  })).min(1).max(20),
+  followUps: zod.z.array(zod.z.string()).max(5).optional()
+});
+var citedAnswerTool = {
+  name: "render_cited_answer",
+  description: "Render an AI-synthesized answer with inline numbered citations linking to source documents \u2014 for RAG answers, research synthesis, document Q&A",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["cited-answer"] },
+      title: { type: "string" },
+      answer: { type: "string", description: "Answer text with [n] citation markers" },
+      citations: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            id: { type: "string" },
+            label: { type: "string" },
+            source: { type: "string" },
+            sourceType: { type: "string" },
+            snippet: { type: "string" },
+            url: { type: "string" },
+            confidence: { type: "number", minimum: 0, maximum: 1 }
+          },
+          required: ["id", "label", "source", "snippet"]
+        }
+      },
+      followUps: { type: "array", items: { type: "string" } }
+    },
+    required: ["type", "answer", "citations"]
+  }
+};
+var transactionFeedSchema = zod.z.object({
+  type: zod.z.literal("transaction-feed"),
+  title: zod.z.string().optional(),
+  currency: zod.z.string().default("USD"),
+  transactions: zod.z.array(zod.z.object({
+    id: zod.z.string().optional(),
+    date: zod.z.string(),
+    description: zod.z.string(),
+    amount: zod.z.number(),
+    category: zod.z.string().optional(),
+    counterparty: zod.z.string().optional(),
+    balance: zod.z.number().optional(),
+    status: zod.z.enum(["cleared", "pending", "reversed"]).default("cleared"),
+    metadata: zod.z.record(zod.z.string(), zod.z.string()).optional()
+  })).min(1).max(100)
+});
+var transactionFeedTool = {
+  name: "render_transaction_feed",
+  description: "Render a chronological transaction feed with amounts, categories, and running balance \u2014 for bank statements, ledger activity, order history",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["transaction-feed"] },
+      title: { type: "string" },
+      currency: { type: "string" },
+      transactions: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            id: { type: "string" },
+            date: { type: "string" },
+            description: { type: "string" },
+            amount: { type: "number" },
+            category: { type: "string" },
+            counterparty: { type: "string" },
+            balance: { type: "number" },
+            status: { type: "string", enum: ["cleared", "pending", "reversed"] },
+            metadata: { type: "object", additionalProperties: { type: "string" } }
+          },
+          required: ["date", "description", "amount"]
+        }
+      }
+    },
+    required: ["type", "transactions"]
+  }
+};
+var fileBrowserSchema = zod.z.object({
+  type: zod.z.literal("file-browser"),
+  title: zod.z.string().optional(),
+  items: zod.z.array(zod.z.object({
+    id: zod.z.string(),
+    name: zod.z.string(),
+    docType: zod.z.string().optional(),
+    group: zod.z.string().optional(),
+    size: zod.z.string().optional(),
+    createdAt: zod.z.string().optional(),
+    modifiedAt: zod.z.string().optional(),
+    author: zod.z.string().optional(),
+    tags: zod.z.array(zod.z.string()).optional(),
+    // Optional: sandbox/agent-harness files often have no public URL. The
+    // resolver falls back to read-only display when url is absent.
+    url: zod.z.string().optional(),
+    preview: zod.z.string().optional()
+  })).min(1).max(50)
+});
+var fileBrowserTool = {
+  name: "render_file_browser",
+  description: "Render a document or file browser with type badges, grouping, and metadata \u2014 for document collections, file libraries, client documents",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["file-browser"] },
+      title: { type: "string" },
+      items: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            id: { type: "string" },
+            name: { type: "string" },
+            docType: { type: "string" },
+            group: { type: "string" },
+            size: { type: "string" },
+            createdAt: { type: "string" },
+            modifiedAt: { type: "string" },
+            author: { type: "string" },
+            tags: { type: "array", items: { type: "string" } },
+            url: { type: "string" },
+            preview: { type: "string" }
+          },
+          required: ["id", "name"]
+        }
+      }
+    },
+    required: ["type", "items"]
+  }
+};
+var downloadCardSchema = zod.z.object({
+  type: zod.z.literal("download-card"),
+  title: zod.z.string().optional(),
+  files: zod.z.array(zod.z.object({
+    filename: zod.z.string(),
+    url: zod.z.string(),
+    fileType: zod.z.string().optional(),
+    size: zod.z.string().optional(),
+    expiresAt: zod.z.string().optional(),
+    description: zod.z.string().optional(),
+    // Opt out of inline preview for an otherwise-previewable type. Preview is
+    // auto-enabled from the file type when the url is present; set false to
+    // force download-only.
+    preview: zod.z.boolean().optional()
+  })).min(1).max(10)
+});
+var downloadCardTool = {
+  name: "render_download_card",
+  description: "Render download cards for files with filename, size, and download link \u2014 for export results, generated reports, file delivery",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["download-card"] },
+      title: { type: "string" },
+      files: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            filename: { type: "string" },
+            url: { type: "string" },
+            fileType: { type: "string" },
+            size: { type: "string" },
+            expiresAt: { type: "string" },
+            description: { type: "string" },
+            preview: { type: "boolean" }
+          },
+          required: ["filename", "url"]
+        }
+      }
+    },
+    required: ["type", "files"]
+  }
+};
+var opsDashboardSchema = zod.z.object({
+  type: zod.z.literal("ops-dashboard"),
+  title: zod.z.string().optional(),
+  items: zod.z.array(zod.z.object({
+    id: zod.z.string(),
+    name: zod.z.string(),
+    state: zod.z.enum(["running", "paused", "stopped", "error"]),
+    schedule: zod.z.string().optional(),
+    lastRunAt: zod.z.string().optional(),
+    nextRunAt: zod.z.string().optional(),
+    metrics: zod.z.array(zod.z.object({ label: zod.z.string(), value: zod.z.string() })).max(4).optional(),
+    health: zod.z.enum(["healthy", "degraded", "down"]).optional()
+  })).min(1).max(12)
+});
+var opsDashboardTool = {
+  name: "render_ops_dashboard",
+  description: "Render an operational dashboard grid showing pipeline or service status cards \u2014 for monitoring pipelines, services, cron jobs, microservices",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["ops-dashboard"] },
+      title: { type: "string" },
+      items: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            id: { type: "string" },
+            name: { type: "string" },
+            state: { type: "string", enum: ["running", "paused", "stopped", "error"] },
+            schedule: { type: "string" },
+            lastRunAt: { type: "string" },
+            nextRunAt: { type: "string" },
+            metrics: { type: "array", items: { type: "object", properties: { label: { type: "string" }, value: { type: "string" } }, required: ["label", "value"] } },
+            health: { type: "string", enum: ["healthy", "degraded", "down"] }
+          },
+          required: ["id", "name", "state"]
+        }
+      }
+    },
+    required: ["type", "items"]
+  }
+};
+var kvItemSchema = zod.z.object({
+  key: zod.z.string(),
+  value: zod.z.string(),
+  type: zod.z.enum(["text", "date", "url", "boolean", "code", "currency"]).default("text"),
+  copyable: zod.z.boolean().default(false)
+});
+var keyValueListSchema = zod.z.object({
+  type: zod.z.literal("key-value-list"),
+  title: zod.z.string().optional(),
+  groups: zod.z.array(zod.z.object({
+    label: zod.z.string(),
+    items: zod.z.array(kvItemSchema).min(1).max(20)
+  })).optional(),
+  items: zod.z.array(kvItemSchema).max(30).optional()
+});
+var keyValueListTool = {
+  name: "render_key_value_list",
+  description: "Render a structured key-value list with optional grouping and type-aware formatting \u2014 for API responses, config displays, metadata, extraction results",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["key-value-list"] },
+      title: { type: "string" },
+      groups: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            label: { type: "string" },
+            items: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  key: { type: "string" },
+                  value: { type: "string" },
+                  type: { type: "string", enum: ["text", "date", "url", "boolean", "code", "currency"] },
+                  copyable: { type: "boolean" }
+                },
+                required: ["key", "value"]
+              }
+            }
+          },
+          required: ["label", "items"]
+        }
+      },
+      items: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            key: { type: "string" },
+            value: { type: "string" },
+            type: { type: "string", enum: ["text", "date", "url", "boolean", "code", "currency"] },
+            copyable: { type: "boolean" }
+          },
+          required: ["key", "value"]
+        }
+      }
+    },
+    required: ["type"]
+  }
+};
+var totalLineSchema = zod.z.object({
+  currentPeriod: zod.z.number(),
+  priorPeriod: zod.z.number().optional()
+});
+var balanceSheetSchema = zod.z.object({
+  type: zod.z.literal("balance-sheet"),
+  title: zod.z.string().optional(),
+  currency: zod.z.string().default("USD"),
+  metadata: zod.z.object({
+    companyName: zod.z.string().optional(),
+    preparedBy: zod.z.string().optional(),
+    reviewedBy: zod.z.string().optional(),
+    approvedBy: zod.z.string().optional(),
+    status: zod.z.enum(["draft", "pending-review", "approved", "filed"]).optional(),
+    date: zod.z.string().optional()
+  }).optional(),
+  currentPeriodLabel: zod.z.string(),
+  priorPeriodLabel: zod.z.string().optional(),
+  sections: zod.z.array(
+    zod.z.object({
+      category: zod.z.enum(["assets", "liabilities", "equity"]),
+      subsections: zod.z.array(
+        zod.z.object({
+          label: zod.z.string(),
+          items: zod.z.array(
+            zod.z.object({
+              name: zod.z.string(),
+              currentPeriod: zod.z.number(),
+              priorPeriod: zod.z.number().optional()
+            })
+          ).max(15),
+          subtotal: totalLineSchema.optional()
+        })
+      ).min(1).max(5),
+      total: totalLineSchema.optional()
+    })
+  ).min(1).max(3),
+  totalLiabilitiesAndEquity: totalLineSchema.optional()
+});
+var balanceSheetTool = {
+  name: "render_balance_sheet",
+  description: "Render a balance sheet with assets, liabilities, and equity sections \u2014 statement of financial position, A = L + E comparison",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["balance-sheet"] },
+      title: { type: "string" },
+      currency: { type: "string", description: "ISO currency code, e.g. USD" },
+      metadata: {
+        type: "object",
+        properties: {
+          companyName: { type: "string" },
+          preparedBy: { type: "string" },
+          reviewedBy: { type: "string" },
+          approvedBy: { type: "string" },
+          status: { type: "string", enum: ["draft", "pending-review", "approved", "filed"] },
+          date: { type: "string" }
+        }
+      },
+      currentPeriodLabel: { type: "string", description: "Label for current period column, e.g. Dec 31, 2024" },
+      priorPeriodLabel: { type: "string", description: "Label for prior period column, e.g. Dec 31, 2023" },
+      sections: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            category: {
+              type: "string",
+              enum: ["assets", "liabilities", "equity"]
+            },
+            subsections: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  label: { type: "string", description: "Subsection label, e.g. Current Assets" },
+                  items: {
+                    type: "array",
+                    items: {
+                      type: "object",
+                      properties: {
+                        name: { type: "string" },
+                        currentPeriod: { type: "number" },
+                        priorPeriod: { type: "number" }
+                      },
+                      required: ["name", "currentPeriod"]
+                    }
+                  },
+                  subtotal: {
+                    type: "object",
+                    properties: {
+                      currentPeriod: { type: "number" },
+                      priorPeriod: { type: "number" }
+                    },
+                    required: ["currentPeriod"]
+                  }
+                },
+                required: ["label", "items"]
+              }
+            }
+          },
+          required: ["category", "subsections"]
+        }
+      },
+      totalLiabilitiesAndEquity: {
+        type: "object",
+        properties: {
+          currentPeriod: { type: "number" },
+          priorPeriod: { type: "number" }
+        },
+        required: ["currentPeriod"]
+      }
+    },
+    required: ["type", "currentPeriodLabel", "sections"]
+  }
+};
+var incomeStatementSchema = zod.z.object({
+  type: zod.z.literal("income-statement"),
+  title: zod.z.string().optional(),
+  currency: zod.z.string().default("USD"),
+  metadata: zod.z.object({
+    companyName: zod.z.string().optional(),
+    preparedBy: zod.z.string().optional(),
+    reviewedBy: zod.z.string().optional(),
+    approvedBy: zod.z.string().optional(),
+    status: zod.z.enum(["draft", "pending-review", "approved", "filed"]).optional(),
+    date: zod.z.string().optional()
+  }).optional(),
+  periods: zod.z.array(zod.z.string()).min(1).max(8),
+  showPercentOfRevenue: zod.z.boolean().default(false),
+  sections: zod.z.array(
+    zod.z.object({
+      label: zod.z.string(),
+      lineItems: zod.z.array(
+        zod.z.object({
+          name: zod.z.string(),
+          amounts: zod.z.array(zod.z.number()),
+          indent: zod.z.number().min(0).max(2).default(0),
+          isSubtotal: zod.z.boolean().optional()
+        })
+      ).max(20),
+      sectionType: zod.z.enum(["detail", "subtotal"]).default("detail")
+    })
+  ).min(1).max(10),
+  calculatedTotals: zod.z.object({
+    grossProfit: zod.z.array(zod.z.number()).optional(),
+    operatingIncome: zod.z.array(zod.z.number()).optional(),
+    netIncome: zod.z.array(zod.z.number())
+  })
+});
+var incomeStatementTool = {
+  name: "render_income_statement",
+  description: "Render a multi-period income statement with revenue, COGS, gross profit, operating expenses, and net income \u2014 P&L, profit and loss",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["income-statement"] },
+      title: { type: "string" },
+      currency: { type: "string", description: "ISO currency code, e.g. USD" },
+      metadata: {
+        type: "object",
+        properties: {
+          companyName: { type: "string" },
+          preparedBy: { type: "string" },
+          reviewedBy: { type: "string" },
+          approvedBy: { type: "string" },
+          status: { type: "string", enum: ["draft", "pending-review", "approved", "filed"] },
+          date: { type: "string" }
+        }
+      },
+      periods: {
+        type: "array",
+        items: { type: "string" },
+        minItems: 1,
+        maxItems: 8,
+        description: "Period labels, e.g. Q1 2024, Q2 2024"
+      },
+      showPercentOfRevenue: {
+        type: "boolean",
+        description: "Show each line item as a percentage of revenue"
+      },
+      sections: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            label: { type: "string" },
+            lineItems: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  name: { type: "string" },
+                  amounts: {
+                    type: "array",
+                    items: { type: "number" },
+                    description: "One amount per period"
+                  },
+                  indent: {
+                    type: "number",
+                    minimum: 0,
+                    maximum: 2,
+                    description: "Indentation level 0-2"
+                  },
+                  isSubtotal: {
+                    type: "boolean",
+                    description: "True for a subtotal/total row (e.g. 'Total Revenue'). Excluded from the %-of-revenue base so it isn't double-counted."
+                  }
+                },
+                required: ["name", "amounts"]
+              }
+            },
+            sectionType: {
+              type: "string",
+              enum: ["detail", "subtotal"]
+            }
+          },
+          required: ["label", "lineItems"]
+        }
+      },
+      calculatedTotals: {
+        type: "object",
+        properties: {
+          grossProfit: {
+            type: "array",
+            items: { type: "number" },
+            description: "Gross profit per period"
+          },
+          operatingIncome: {
+            type: "array",
+            items: { type: "number" },
+            description: "Operating income per period"
+          },
+          netIncome: {
+            type: "array",
+            items: { type: "number" },
+            description: "Net income per period"
+          }
+        },
+        required: ["netIncome"]
+      }
+    },
+    required: ["type", "periods", "sections", "calculatedTotals"]
+  }
+};
+var cashFlowStatementSchema = zod.z.object({
+  type: zod.z.literal("cash-flow-statement"),
+  title: zod.z.string().optional(),
+  currency: zod.z.string().default("USD"),
+  metadata: zod.z.object({
+    companyName: zod.z.string().optional(),
+    preparedBy: zod.z.string().optional(),
+    reviewedBy: zod.z.string().optional(),
+    approvedBy: zod.z.string().optional(),
+    status: zod.z.enum(["draft", "pending-review", "approved", "filed"]).optional(),
+    date: zod.z.string().optional()
+  }).optional(),
+  periodLabel: zod.z.string().optional(),
+  priorPeriodLabel: zod.z.string().optional(),
+  activities: zod.z.array(
+    zod.z.object({
+      activityType: zod.z.enum(["operating", "investing", "financing"]),
+      lineItems: zod.z.array(
+        zod.z.object({
+          name: zod.z.string(),
+          amount: zod.z.number(),
+          priorAmount: zod.z.number().optional(),
+          indent: zod.z.number().min(0).max(2).default(0),
+          isSubtotal: zod.z.boolean().default(false)
+        })
+      ).min(1).max(20),
+      netCash: zod.z.number(),
+      priorNetCash: zod.z.number().optional()
+    })
+  ).min(1).max(3),
+  netChange: zod.z.number(),
+  priorNetChange: zod.z.number().optional(),
+  beginningCash: zod.z.number(),
+  endingCash: zod.z.number(),
+  priorBeginningCash: zod.z.number().optional(),
+  priorEndingCash: zod.z.number().optional()
+});
+var cashFlowStatementTool = {
+  name: "render_cash_flow_statement",
+  description: "Render a cash flow statement with operating, investing, and financing activities \u2014 statement of cash flows, net change in cash",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["cash-flow-statement"] },
+      title: { type: "string" },
+      currency: { type: "string", description: "ISO currency code, e.g. USD" },
+      metadata: {
+        type: "object",
+        properties: {
+          companyName: { type: "string" },
+          preparedBy: { type: "string" },
+          reviewedBy: { type: "string" },
+          approvedBy: { type: "string" },
+          status: { type: "string", enum: ["draft", "pending-review", "approved", "filed"] },
+          date: { type: "string" }
+        }
+      },
+      periodLabel: {
+        type: "string",
+        description: "Label for the current period, e.g. Year Ended Dec 31, 2024"
+      },
+      priorPeriodLabel: {
+        type: "string",
+        description: "Label for the prior period, e.g. Year Ended Dec 31, 2023"
+      },
+      activities: {
+        type: "array",
+        minItems: 1,
+        maxItems: 3,
+        items: {
+          type: "object",
+          properties: {
+            activityType: {
+              type: "string",
+              enum: ["operating", "investing", "financing"]
+            },
+            lineItems: {
+              type: "array",
+              minItems: 1,
+              maxItems: 20,
+              items: {
+                type: "object",
+                properties: {
+                  name: { type: "string" },
+                  amount: { type: "number" },
+                  priorAmount: { type: "number" },
+                  indent: {
+                    type: "number",
+                    minimum: 0,
+                    maximum: 2,
+                    description: "Indentation level 0-2"
+                  },
+                  isSubtotal: { type: "boolean" }
+                },
+                required: ["name", "amount"]
+              }
+            },
+            netCash: { type: "number" },
+            priorNetCash: { type: "number" }
+          },
+          required: ["activityType", "lineItems", "netCash"]
+        }
+      },
+      netChange: { type: "number" },
+      priorNetChange: { type: "number" },
+      beginningCash: { type: "number" },
+      endingCash: { type: "number" },
+      priorBeginningCash: { type: "number" },
+      priorEndingCash: { type: "number" }
+    },
+    required: ["type", "activities", "netChange", "beginningCash", "endingCash"]
+  }
+};
+var generalLedgerSchema = zod.z.object({
+  type: zod.z.literal("general-ledger"),
+  title: zod.z.string().optional(),
+  currency: zod.z.string().default("USD"),
+  account: zod.z.object({
+    code: zod.z.string(),
+    name: zod.z.string(),
+    accountType: zod.z.enum(["asset", "liability", "equity", "revenue", "expense"]).optional()
+  }),
+  dateRange: zod.z.object({
+    from: zod.z.string(),
+    to: zod.z.string()
+  }).optional(),
+  openingBalance: zod.z.number().default(0),
+  transactions: zod.z.array(
+    zod.z.object({
+      date: zod.z.string(),
+      description: zod.z.string(),
+      reference: zod.z.string().optional(),
+      source: zod.z.string().optional(),
+      debit: zod.z.number().default(0),
+      credit: zod.z.number().default(0),
+      runningBalance: zod.z.number()
+    })
+  ).min(1).max(100),
+  closingBalance: zod.z.number()
+});
+var generalLedgerTool = {
+  name: "render_general_ledger",
+  description: "Render a general ledger with account-level transaction detail and running balance \u2014 GL detail, account ledger, ledger entries",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["general-ledger"] },
+      title: { type: "string" },
+      currency: { type: "string", description: "ISO currency code, e.g. USD" },
+      account: {
+        type: "object",
+        properties: {
+          code: { type: "string" },
+          name: { type: "string" },
+          accountType: {
+            type: "string",
+            enum: ["asset", "liability", "equity", "revenue", "expense"]
+          }
+        },
+        required: ["code", "name"]
+      },
+      dateRange: {
+        type: "object",
+        properties: {
+          from: { type: "string" },
+          to: { type: "string" }
+        },
+        required: ["from", "to"]
+      },
+      openingBalance: { type: "number", description: "Opening balance for the period" },
+      transactions: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            date: { type: "string" },
+            description: { type: "string" },
+            reference: { type: "string" },
+            source: { type: "string", description: "Source document, e.g. JE-001, AP-INV-042" },
+            debit: { type: "number" },
+            credit: { type: "number" },
+            runningBalance: { type: "number" }
+          },
+          required: ["date", "description", "runningBalance"]
+        }
+      },
+      closingBalance: { type: "number" }
+    },
+    required: ["type", "account", "transactions", "closingBalance"]
+  }
+};
+var chartOfAccountsSchema = zod.z.object({
+  type: zod.z.literal("chart-of-accounts"),
+  title: zod.z.string().optional(),
+  currency: zod.z.string().default("USD"),
+  showBalances: zod.z.boolean().default(false),
+  accounts: zod.z.array(
+    zod.z.object({
+      code: zod.z.string(),
+      name: zod.z.string(),
+      accountType: zod.z.enum(["asset", "liability", "equity", "revenue", "expense"]),
+      subType: zod.z.string().optional(),
+      status: zod.z.enum(["active", "inactive"]).default("active"),
+      indent: zod.z.number().min(0).max(3).default(0),
+      isHeader: zod.z.boolean().default(false),
+      balance: zod.z.number().optional()
+    })
+  ).min(1).max(100)
+});
+var chartOfAccountsTool = {
+  name: "render_chart_of_accounts",
+  description: "Render a chart of accounts with account codes, types, hierarchy, and optional balances \u2014 COA, account structure, account directory",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["chart-of-accounts"] },
+      title: { type: "string" },
+      currency: { type: "string", description: "ISO currency code, e.g. USD" },
+      showBalances: { type: "boolean", description: "Whether to show balance column" },
+      accounts: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            code: { type: "string", description: "Account code, e.g. 1000" },
+            name: { type: "string", description: "Account name" },
+            accountType: {
+              type: "string",
+              enum: ["asset", "liability", "equity", "revenue", "expense"]
+            },
+            subType: { type: "string", description: "Sub-type, e.g. Current Asset, Fixed Asset, COGS" },
+            status: { type: "string", enum: ["active", "inactive"] },
+            indent: { type: "number", description: "Indentation level 0-3" },
+            isHeader: { type: "boolean", description: "Whether this row is a section header" },
+            balance: { type: "number", description: "Account balance" }
+          },
+          required: ["code", "name", "accountType"]
+        }
+      }
+    },
+    required: ["type", "accounts"]
+  }
+};
+var invoiceDetailSchema = zod.z.object({
+  type: zod.z.literal("invoice-detail"),
+  invoiceNumber: zod.z.string(),
+  status: zod.z.enum(["draft", "sent", "paid", "partial", "overdue", "void"]),
+  issueDate: zod.z.string(),
+  dueDate: zod.z.string(),
+  currency: zod.z.string().default("USD"),
+  client: zod.z.object({
+    name: zod.z.string(),
+    address: zod.z.string().optional(),
+    email: zod.z.string().optional()
+  }),
+  lineItems: zod.z.array(
+    zod.z.object({
+      description: zod.z.string(),
+      quantity: zod.z.number(),
+      unitPrice: zod.z.number(),
+      amount: zod.z.number()
+    })
+  ).min(1).max(30),
+  subtotal: zod.z.number(),
+  taxLabel: zod.z.string().optional(),
+  taxAmount: zod.z.number().default(0),
+  discount: zod.z.number().default(0),
+  total: zod.z.number(),
+  amountPaid: zod.z.number().default(0),
+  amountDue: zod.z.number(),
+  payments: zod.z.array(
+    zod.z.object({
+      date: zod.z.string(),
+      method: zod.z.string(),
+      amount: zod.z.number(),
+      reference: zod.z.string().optional()
+    })
+  ).optional(),
+  notes: zod.z.string().optional(),
+  terms: zod.z.string().optional()
+});
+var invoiceDetailTool = {
+  name: "render_invoice_detail",
+  description: "Render a single invoice with line items, totals, tax, payments, and status \u2014 invoice detail, billing, AR invoice",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["invoice-detail"] },
+      invoiceNumber: { type: "string" },
+      status: {
+        type: "string",
+        enum: ["draft", "sent", "paid", "partial", "overdue", "void"]
+      },
+      issueDate: { type: "string" },
+      dueDate: { type: "string" },
+      currency: { type: "string" },
+      client: {
+        type: "object",
+        properties: {
+          name: { type: "string" },
+          address: { type: "string" },
+          email: { type: "string" }
+        },
+        required: ["name"]
+      },
+      lineItems: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            description: { type: "string" },
+            quantity: { type: "number" },
+            unitPrice: { type: "number" },
+            amount: { type: "number" }
+          },
+          required: ["description", "quantity", "unitPrice", "amount"]
+        }
+      },
+      subtotal: { type: "number" },
+      taxLabel: { type: "string" },
+      taxAmount: { type: "number" },
+      discount: { type: "number" },
+      total: { type: "number" },
+      amountPaid: { type: "number" },
+      amountDue: { type: "number" },
+      payments: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            date: { type: "string" },
+            method: { type: "string" },
+            amount: { type: "number" },
+            reference: { type: "string" }
+          },
+          required: ["date", "method", "amount"]
+        }
+      },
+      notes: { type: "string" },
+      terms: { type: "string" }
+    },
+    required: [
+      "type",
+      "invoiceNumber",
+      "status",
+      "issueDate",
+      "dueDate",
+      "client",
+      "lineItems",
+      "subtotal",
+      "total",
+      "amountDue"
+    ]
+  }
+};
+var amortizationTableSchema = zod.z.object({
+  type: zod.z.literal("amortization-table"),
+  title: zod.z.string().optional(),
+  currency: zod.z.string().default("USD"),
+  summary: zod.z.object({
+    originalAmount: zod.z.number(),
+    interestRate: zod.z.string(),
+    term: zod.z.string(),
+    monthlyPayment: zod.z.number().optional(),
+    totalInterest: zod.z.number().optional(),
+    startDate: zod.z.string().optional()
+  }).optional(),
+  payments: zod.z.array(
+    zod.z.object({
+      period: zod.z.string(),
+      paymentDate: zod.z.string().optional(),
+      payment: zod.z.number(),
+      principal: zod.z.number(),
+      interest: zod.z.number(),
+      balance: zod.z.number(),
+      extra: zod.z.number().default(0)
+    })
+  ).min(1).max(372)
+});
+var amortizationTableTool = {
+  name: "render_amortization_table",
+  description: "Render a loan or lease amortization schedule with principal, interest, and remaining balance \u2014 mortgage, lease payments, ASC 842, loan servicing",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["amortization-table"] },
+      title: { type: "string" },
+      currency: { type: "string", default: "USD" },
+      summary: {
+        type: "object",
+        properties: {
+          originalAmount: { type: "number" },
+          interestRate: { type: "string" },
+          term: { type: "string" },
+          monthlyPayment: { type: "number" },
+          totalInterest: { type: "number" },
+          startDate: { type: "string" }
+        },
+        required: ["originalAmount", "interestRate", "term"]
+      },
+      payments: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            period: { type: "string" },
+            paymentDate: { type: "string" },
+            payment: { type: "number" },
+            principal: { type: "number" },
+            interest: { type: "number" },
+            balance: { type: "number" },
+            extra: { type: "number", default: 0 }
+          },
+          required: ["period", "payment", "principal", "interest", "balance"]
+        },
+        minItems: 1,
+        maxItems: 372
+      }
+    },
+    required: ["type", "payments"]
+  }
+};
+var depreciationScheduleSchema = zod.z.object({
+  type: zod.z.literal("depreciation-schedule"),
+  title: zod.z.string().optional(),
+  currency: zod.z.string().default("USD"),
+  asOfDate: zod.z.string().optional(),
+  method: zod.z.string().optional(),
+  assets: zod.z.array(
+    zod.z.object({
+      id: zod.z.string(),
+      name: zod.z.string(),
+      category: zod.z.enum(["Buildings", "Equipment", "Vehicles", "Furniture"]).optional(),
+      acquiredDate: zod.z.string(),
+      cost: zod.z.number(),
+      salvageValue: zod.z.number().default(0),
+      usefulLife: zod.z.string().optional(),
+      method: zod.z.string().optional(),
+      currentYearDepreciation: zod.z.number(),
+      accumulatedDepreciation: zod.z.number(),
+      bookValue: zod.z.number()
+    })
+  ).min(1).max(50),
+  totals: zod.z.object({
+    totalCost: zod.z.number(),
+    totalCurrentYear: zod.z.number(),
+    totalAccumulated: zod.z.number(),
+    totalBookValue: zod.z.number()
+  }).optional()
+});
+var depreciationScheduleTool = {
+  name: "render_depreciation_schedule",
+  description: "Render a fixed asset depreciation schedule with cost, useful life, method, annual depreciation, accumulated depreciation, and book value \u2014 asset register, MACRS, straight-line",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["depreciation-schedule"] },
+      title: { type: "string" },
+      currency: {
+        type: "string",
+        description: "ISO currency code, e.g. USD"
+      },
+      asOfDate: {
+        type: "string",
+        description: "As-of date for the schedule"
+      },
+      method: {
+        type: "string",
+        description: "Default depreciation method, e.g. Straight-Line, MACRS"
+      },
+      assets: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            id: { type: "string" },
+            name: { type: "string" },
+            category: {
+              type: "string",
+              enum: ["Buildings", "Equipment", "Vehicles", "Furniture"]
+            },
+            acquiredDate: { type: "string" },
+            cost: { type: "number" },
+            salvageValue: { type: "number" },
+            usefulLife: {
+              type: "string",
+              description: "e.g. 5 years, 39 years"
+            },
+            method: {
+              type: "string",
+              description: "Per-asset depreciation method override"
+            },
+            currentYearDepreciation: { type: "number" },
+            accumulatedDepreciation: { type: "number" },
+            bookValue: { type: "number" }
+          },
+          required: [
+            "id",
+            "name",
+            "acquiredDate",
+            "cost",
+            "currentYearDepreciation",
+            "accumulatedDepreciation",
+            "bookValue"
+          ]
+        }
+      },
+      totals: {
+        type: "object",
+        properties: {
+          totalCost: { type: "number" },
+          totalCurrentYear: { type: "number" },
+          totalAccumulated: { type: "number" },
+          totalBookValue: { type: "number" }
+        },
+        required: [
+          "totalCost",
+          "totalCurrentYear",
+          "totalAccumulated",
+          "totalBookValue"
+        ]
+      }
+    },
+    required: ["type", "assets"]
+  }
+};
+var escalationCardSchema = zod.z.object({
+  type: zod.z.literal("escalation-card"),
+  title: zod.z.string().optional(),
+  description: zod.z.string().optional(),
+  url: zod.z.string(),
+  ctaLabel: zod.z.string().optional(),
+  priority: zod.z.enum(["low", "medium", "high"]).optional()
+});
+var escalationCardTool = {
+  name: "render_escalation_card",
+  description: "Render a human-in-the-loop (HITL) escalation card with a title, description, priority, and a deeplink CTA button to resolve it \u2014 use for review requests, low-confidence extractions, data conflicts, or any item needing manual resolution in the review portal",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["escalation-card"] },
+      title: { type: "string" },
+      description: { type: "string" },
+      url: { type: "string" },
+      ctaLabel: { type: "string" },
+      priority: { type: "string", enum: ["low", "medium", "high"] }
+    },
+    required: ["type", "url"]
+  }
+};
+var lineChartSchema = zod.z.object({
+  type: zod.z.literal("line-chart"),
+  title: zod.z.string().optional(),
+  xKey: zod.z.string(),
+  unit: zod.z.string().optional(),
+  smooth: zod.z.boolean().optional(),
+  series: zod.z.array(zod.z.object({ name: zod.z.string(), dataKey: zod.z.string(), color: zod.z.string().optional() })).min(1).max(6),
+  data: zod.z.array(zod.z.record(zod.z.string(), zod.z.union([zod.z.string(), zod.z.number()]))).min(2).max(500)
+});
+var lineChartTool = {
+  name: "render_line_chart",
+  description: "Render a multi-series line chart for trends over time \u2014 net income trend, cash position, revenue vs expense, KPI over months/quarters. Use when comparing how one or more numeric measures move across an ordered axis (lines, not filled areas).",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["line-chart"] },
+      title: { type: "string" },
+      xKey: { type: "string", description: "Key in each data row for the X-axis label (e.g. 'month')" },
+      unit: { type: "string", description: "Value unit/prefix, e.g. '$', '%', 'bps'" },
+      smooth: { type: "boolean", description: "Use smooth (monotone) curves instead of straight segments" },
+      series: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            name: { type: "string" },
+            dataKey: { type: "string" },
+            color: { type: "string", description: "Optional CSS color; auto-assigned from palette if omitted" }
+          },
+          required: ["name", "dataKey"]
+        }
+      },
+      data: {
+        type: "array",
+        items: { type: "object", additionalProperties: true },
+        description: "Data rows; each row has xKey and every series dataKey"
+      }
+    },
+    required: ["type", "xKey", "series", "data"]
+  }
+};
+var seriesRef = zod.z.object({
+  name: zod.z.string(),
+  dataKey: zod.z.string(),
+  color: zod.z.string().optional(),
+  axis: zod.z.enum(["left", "right"]).optional()
+});
+var comboChartSchema = zod.z.object({
+  type: zod.z.literal("combo-chart"),
+  title: zod.z.string().optional(),
+  xKey: zod.z.string(),
+  leftUnit: zod.z.string().optional(),
+  rightUnit: zod.z.string().optional(),
+  bars: zod.z.array(seriesRef).max(4).optional(),
+  lines: zod.z.array(seriesRef).max(4).optional(),
+  data: zod.z.array(zod.z.record(zod.z.string(), zod.z.union([zod.z.string(), zod.z.number()]))).min(2).max(500)
+}).refine((v) => {
+  var _a, _b, _c, _d;
+  return ((_b = (_a = v.bars) == null ? void 0 : _a.length) != null ? _b : 0) + ((_d = (_c = v.lines) == null ? void 0 : _c.length) != null ? _d : 0) >= 1;
+}, {
+  message: "combo-chart needs at least one bar or line series"
+});
+var comboChartTool = {
+  name: "render_combo_chart",
+  description: "Render a combined bar + line chart with an optional secondary (right) Y-axis \u2014 revenue bars with a margin % line, actuals bars with a cumulative budget line, volume vs rate. Use when one measure is best shown as bars and another (often a %, ratio, or running total on a different scale) as a line.",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["combo-chart"] },
+      title: { type: "string" },
+      xKey: { type: "string", description: "Key in each data row for the X-axis label" },
+      leftUnit: { type: "string", description: "Unit for the left Y-axis (e.g. '$')" },
+      rightUnit: { type: "string", description: "Unit for the right Y-axis (e.g. '%')" },
+      bars: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            name: { type: "string" },
+            dataKey: { type: "string" },
+            color: { type: "string" },
+            axis: { type: "string", enum: ["left", "right"], description: "Which Y-axis; default left" }
+          },
+          required: ["name", "dataKey"]
+        }
+      },
+      lines: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            name: { type: "string" },
+            dataKey: { type: "string" },
+            color: { type: "string" },
+            axis: { type: "string", enum: ["left", "right"], description: "Which Y-axis; default right" }
+          },
+          required: ["name", "dataKey"]
+        }
+      },
+      data: {
+        type: "array",
+        items: { type: "object", additionalProperties: true },
+        description: "Data rows; each row has xKey and every bar/line dataKey"
+      }
+    },
+    required: ["type", "xKey", "data"]
+  }
+};
+var gaugeChartSchema = zod.z.object({
+  type: zod.z.literal("gauge-chart"),
+  title: zod.z.string().optional(),
+  items: zod.z.array(
+    zod.z.object({
+      label: zod.z.string(),
+      value: zod.z.number(),
+      max: zod.z.number(),
+      target: zod.z.number().optional(),
+      unit: zod.z.string().optional()
+    })
+  ).min(1).max(4)
+});
+var gaugeChartTool = {
+  name: "render_gauge_chart",
+  description: "Render one to four radial gauge dials showing a single KPI against its max and an optional target \u2014 budget utilization %, DSO/DPO vs target, collection rate, cash-runway months, capacity used. The arc colors green/amber/red relative to the target.",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["gauge-chart"] },
+      title: { type: "string" },
+      items: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            label: { type: "string" },
+            value: { type: "number", description: "Current value" },
+            max: { type: "number", description: "Full-scale value of the dial" },
+            target: { type: "number", description: "Optional goal threshold; drives arc color" },
+            unit: { type: "string", description: "e.g. '%', '$', 'days'" }
+          },
+          required: ["label", "value", "max"]
+        }
+      }
+    },
+    required: ["type", "items"]
+  }
+};
+var treemapChartSchema = zod.z.object({
+  type: zod.z.literal("treemap-chart"),
+  title: zod.z.string().optional(),
+  currency: zod.z.string().optional(),
+  nodes: zod.z.array(
+    zod.z.object({
+      name: zod.z.string(),
+      value: zod.z.number(),
+      color: zod.z.string().optional()
+    })
+  ).min(1).max(30)
+});
+var treemapChartTool = {
+  name: "render_treemap_chart",
+  description: "Render a treemap where each rectangle's area is proportional to its value \u2014 expense breakdown by GL account, revenue by segment or product, spend by cost center, asset mix. Use to show how a total decomposes into many parts ranked by magnitude.",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["treemap-chart"] },
+      title: { type: "string" },
+      currency: { type: "string", description: "Currency symbol/prefix for values, e.g. '$'" },
+      nodes: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            name: { type: "string" },
+            value: { type: "number", description: "Positive magnitude; sets rectangle area" },
+            color: { type: "string", description: "Optional; auto-assigned from palette if omitted" }
+          },
+          required: ["name", "value"]
+        }
+      }
+    },
+    required: ["type", "nodes"]
+  }
+};
+var radarChartSchema = zod.z.object({
+  type: zod.z.literal("radar-chart"),
+  title: zod.z.string().optional(),
+  unit: zod.z.string().optional(),
+  series: zod.z.array(zod.z.object({ name: zod.z.string(), dataKey: zod.z.string(), color: zod.z.string().optional() })).min(1).max(4),
+  data: zod.z.array(
+    zod.z.object({ metric: zod.z.string() }).catchall(zod.z.union([zod.z.string(), zod.z.number()]))
+  ).min(3).max(12)
+});
+var radarChartTool = {
+  name: "render_radar_chart",
+  description: "Render a radar (spider) chart comparing several entities or periods across the same set of metrics \u2014 financial-ratio profiles (liquidity, profitability, leverage, efficiency, coverage), scorecard comparison, multi-dimensional benchmarking. One axis per metric; one shape per series.",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["radar-chart"] },
+      title: { type: "string" },
+      unit: { type: "string", description: "Optional value unit, e.g. 'x', '%'" },
+      series: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            name: { type: "string" },
+            dataKey: { type: "string" },
+            color: { type: "string", description: "Optional; auto-assigned from palette if omitted" }
+          },
+          required: ["name", "dataKey"]
+        }
+      },
+      data: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: { metric: { type: "string", description: "Axis label" } },
+          required: ["metric"],
+          additionalProperties: true
+        },
+        description: "One row per metric; each row has 'metric' and every series dataKey"
+      }
+    },
+    required: ["type", "series", "data"]
+  }
+};
+var funnelChartSchema = zod.z.object({
+  type: zod.z.literal("funnel-chart"),
+  title: zod.z.string().optional(),
+  currency: zod.z.string().optional(),
+  stages: zod.z.array(
+    zod.z.object({
+      label: zod.z.string(),
+      value: zod.z.number(),
+      color: zod.z.string().optional()
+    })
+  ).min(2).max(8)
+});
+var funnelChartTool = {
+  name: "render_funnel_chart",
+  description: "Render a funnel chart showing how a quantity narrows across ordered stages \u2014 collections funnel (billed \u2192 collected \u2192 overdue \u2192 written off), quote \u2192 invoice \u2192 paid, lead \u2192 close. Use for stage-to-stage conversion or drop-off. Each stage shows its value and % of the prior stage.",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["funnel-chart"] },
+      title: { type: "string" },
+      currency: { type: "string", description: "Currency symbol/prefix, e.g. '$'" },
+      stages: {
+        type: "array",
+        description: "Ordered widest \u2192 narrowest",
+        items: {
+          type: "object",
+          properties: {
+            label: { type: "string" },
+            value: { type: "number" },
+            color: { type: "string", description: "Optional; auto-assigned from palette if omitted" }
+          },
+          required: ["label", "value"]
+        }
+      }
+    },
+    required: ["type", "stages"]
+  }
+};
+var bulletChartSchema = zod.z.object({
+  type: zod.z.literal("bullet-chart"),
+  title: zod.z.string().optional(),
+  items: zod.z.array(
+    zod.z.object({
+      label: zod.z.string(),
+      value: zod.z.number(),
+      target: zod.z.number(),
+      max: zod.z.number().optional(),
+      unit: zod.z.string().optional()
+    })
+  ).min(1).max(10)
+});
+var bulletChartTool = {
+  name: "render_bullet_chart",
+  description: "Render a compact bullet-chart scorecard: one horizontal row per KPI showing actual value vs target against a qualitative range \u2014 actual vs budget, vs forecast, vs prior year. Use for dense KPI-vs-target dashboards where each measure has its own target. The bar turns green/amber/red by how the value compares to its target.",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["bullet-chart"] },
+      title: { type: "string" },
+      items: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            label: { type: "string" },
+            value: { type: "number", description: "Actual measured value" },
+            target: { type: "number", description: "Goal / budget marker" },
+            max: { type: "number", description: "Optional scale max; defaults to max(value,target)*1.25" },
+            unit: { type: "string", description: "e.g. '$', '%', 'days'" }
+          },
+          required: ["label", "value", "target"]
+        }
+      }
+    },
+    required: ["type", "items"]
+  }
+};
+var scatterChartSchema = zod.z.object({
+  type: zod.z.literal("scatter-chart"),
+  title: zod.z.string().optional(),
+  xLabel: zod.z.string().optional(),
+  yLabel: zod.z.string().optional(),
+  xUnit: zod.z.string().optional(),
+  yUnit: zod.z.string().optional(),
+  series: zod.z.array(
+    zod.z.object({
+      name: zod.z.string(),
+      color: zod.z.string().optional(),
+      points: zod.z.array(
+        zod.z.object({
+          x: zod.z.number(),
+          y: zod.z.number(),
+          z: zod.z.number().optional(),
+          label: zod.z.string().optional()
+        })
+      ).min(1).max(200)
+    })
+  ).min(1).max(4)
+});
+var scatterChartTool = {
+  name: "render_scatter_chart",
+  description: "Render a scatter / bubble chart plotting points on two numeric axes (optional bubble size as a third dimension) \u2014 AR aging days vs outstanding amount, account size vs activity, risk vs return, price vs volume. Use to reveal correlation, clustering, or outliers across accounts/entities.",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["scatter-chart"] },
+      title: { type: "string" },
+      xLabel: { type: "string" },
+      yLabel: { type: "string" },
+      xUnit: { type: "string", description: "e.g. 'days'" },
+      yUnit: { type: "string", description: "e.g. '$'" },
+      series: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            name: { type: "string" },
+            color: { type: "string", description: "Optional; auto-assigned from palette if omitted" },
+            points: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  x: { type: "number" },
+                  y: { type: "number" },
+                  z: { type: "number", description: "Optional magnitude \u2192 bubble size" },
+                  label: { type: "string", description: "Optional point name for tooltip" }
+                },
+                required: ["x", "y"]
+              }
+            }
+          },
+          required: ["name", "points"]
+        }
+      }
+    },
+    required: ["type", "series"]
+  }
+};
+var connectIntegrationSchema = zod.z.object({
+  type: zod.z.literal("connect-integration"),
+  integrationName: zod.z.string(),
+  description: zod.z.string().optional(),
+  url: zod.z.string(),
+  status: zod.z.enum(["connected", "not_connected"]).optional(),
+  iconUrl: zod.z.string().optional(),
+  ctaLabel: zod.z.string().optional()
+});
+var connectIntegrationTool = {
+  name: "render_connect_integration",
+  description: "Render a compact card for a single third-party integration (e.g. Gmail, Slack, Google Drive). Use it three ways via `status`: (1) status='not_connected' \u2014 prompt the user to connect it, the button deep-links to the connections settings page (set `url` to /settings/connections?integration=<id>); (2) status='connected' \u2014 show it as connected, the button is an Open deep-link into the integration or its settings; (3) as a plain deep-link to an external resource. `url` is the button target; `ctaLabel` overrides the button text (defaults: Connect when not connected, Open when connected).",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["connect-integration"] },
+      integrationName: { type: "string" },
+      description: { type: "string" },
+      url: { type: "string" },
+      status: { type: "string", enum: ["connected", "not_connected"] },
+      iconUrl: { type: "string" },
+      ctaLabel: { type: "string" }
+    },
+    required: ["type", "integrationName", "url"]
+  }
+};
+var integrationsListSchema = zod.z.object({
+  type: zod.z.literal("integrations-list"),
+  title: zod.z.string().optional(),
+  description: zod.z.string().optional(),
+  integrations: zod.z.array(
+    zod.z.object({
+      name: zod.z.string(),
+      status: zod.z.enum(["connected", "not_connected"]),
+      capability: zod.z.string().optional(),
+      connectUrl: zod.z.string().optional(),
+      iconUrl: zod.z.string().optional()
+    })
+  )
+});
+var integrationsListTool = {
+  name: "render_integrations_list",
+  description: "Render a grouped list of multiple third-party integrations with their connection status (connected vs not connected) and a per-row Connect link for the ones that are not connected. Prefer this over multiple separate connect-integration cards whenever there are 2 or more integrations \u2014 e.g. to orient the user on what's available, or to offer several providers to connect (Gmail, Outlook, ...). Optional `description` is a one-line subtitle under the title.",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["integrations-list"] },
+      title: { type: "string" },
+      description: { type: "string" },
+      integrations: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            name: { type: "string" },
+            status: { type: "string", enum: ["connected", "not_connected"] },
+            capability: { type: "string" },
+            connectUrl: { type: "string" },
+            iconUrl: { type: "string" }
+          },
+          required: ["name", "status"]
+        }
+      }
+    },
+    required: ["type", "integrations"]
+  }
+};
+var pipelineStepSchema = zod.z.lazy(
+  () => zod.z.object({
+    id: zod.z.string(),
+    operation: zod.z.string(),
+    label: zod.z.string().optional(),
+    description: zod.z.string().optional(),
+    subSteps: zod.z.array(pipelineStepSchema).optional(),
+    branches: zod.z.array(
+      zod.z.object({
+        label: zod.z.string(),
+        condition: zod.z.string().optional(),
+        steps: zod.z.array(pipelineStepSchema)
+      })
+    ).optional()
+  })
+);
+var pipelinePreviewSchema = zod.z.object({
+  type: zod.z.literal("pipeline-preview"),
+  name: zod.z.string(),
+  description: zod.z.string().optional(),
+  state: zod.z.enum(["draft", "running", "paused"]).optional(),
+  source: zod.z.object({ name: zod.z.string(), kind: zod.z.string().optional() }).optional(),
+  destinations: zod.z.array(zod.z.object({ name: zod.z.string(), kind: zod.z.string().optional() })).optional(),
+  schedule: zod.z.object({
+    type: zod.z.enum(["manual", "cron"]),
+    cron: zod.z.string().optional(),
+    label: zod.z.string().optional()
+  }).optional(),
+  steps: zod.z.array(pipelineStepSchema).min(1),
+  workstreams: zod.z.array(zod.z.string()).optional(),
+  cta: zod.z.object({ label: zod.z.string(), url: zod.z.string() }).optional()
+});
+var STEP_LEAF_PROPS = {
+  id: { type: "string" },
+  operation: { type: "string" },
+  label: { type: "string" },
+  description: { type: "string" }
+};
+var STEP_LEAF = {
+  type: "object",
+  properties: STEP_LEAF_PROPS,
+  required: ["id", "operation"]
+};
+var BRANCH_LEAF = {
+  type: "object",
+  properties: {
+    label: { type: "string" },
+    condition: { type: "string" },
+    steps: { type: "array", items: STEP_LEAF }
+  },
+  required: ["label", "steps"]
+};
+var STEP_NODE = {
+  type: "object",
+  properties: __spreadProps(__spreadValues({}, STEP_LEAF_PROPS), {
+    subSteps: { type: "array", items: STEP_LEAF },
+    branches: { type: "array", items: BRANCH_LEAF }
+  }),
+  required: ["id", "operation"]
+};
+var pipelinePreviewTool = {
+  name: "render_pipeline_preview",
+  description: "Render a read-only blueprint preview of a data pipeline / workflow \u2014 its name, source \u2192 destination(s), schedule, and the ordered flow of WDL operation steps (with nested FAN_OUT sub-steps and CONDITION branches) plus an optional deeplink CTA. Use to show a pipeline you designed or are proposing before it is created/activated. NOT for live run status (use job-tracker) or a grid of running services (use ops-dashboard).",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["pipeline-preview"] },
+      name: { type: "string" },
+      description: { type: "string" },
+      state: { type: "string", enum: ["draft", "running", "paused"] },
+      source: {
+        type: "object",
+        properties: {
+          name: { type: "string" },
+          kind: { type: "string" }
+        },
+        required: ["name"]
+      },
+      destinations: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            name: { type: "string" },
+            kind: { type: "string" }
+          },
+          required: ["name"]
+        }
+      },
+      schedule: {
+        type: "object",
+        properties: {
+          type: { type: "string", enum: ["manual", "cron"] },
+          cron: { type: "string" },
+          label: { type: "string" }
+        },
+        required: ["type"]
+      },
+      steps: { type: "array", items: STEP_NODE },
+      workstreams: { type: "array", items: { type: "string" } },
+      cta: {
+        type: "object",
+        properties: {
+          label: { type: "string" },
+          url: { type: "string" }
+        },
+        required: ["label", "url"]
+      }
+    },
+    required: ["type", "name", "steps"]
+  }
+};
+
+// src/schemas/buildRenderUITool.ts
+function buildRenderUITool(selectedSchemas) {
+  const selected = selectedSchemas.filter((name) => name in schemaRegistry).map((name) => schemaRegistry[name].tool.input_schema);
+  if (selected.length === 0) {
+    throw new Error("buildRenderUITool: no valid schemas selected");
+  }
+  return {
+    name: "render_ui",
+    description: "Render a rich UI component for the user. Use this when the response benefits from structured visual presentation (tables, charts, metrics, cards) rather than plain text. The `type` field selects the component. You may call this tool multiple times in a single response to render multiple components.",
+    input_schema: selected.length === 1 ? selected[0] : { type: "object", anyOf: selected }
+  };
+}
+
+// src/schemas/coercePayload.ts
+function coercePayload(data) {
+  var _a, _b, _c;
+  if (!data || typeof data !== "object" || Array.isArray(data)) return data;
+  const obj = data;
+  const type = obj.type;
+  if (typeof type !== "string" || !(type in schemaRegistry)) return data;
+  const props = (_c = (_b = (_a = schemaRegistry[type]) == null ? void 0 : _a.tool) == null ? void 0 : _b.input_schema) == null ? void 0 : _c.properties;
+  if (!props || typeof props !== "object") return data;
+  let out = null;
+  for (const [key, propSchema] of Object.entries(props)) {
+    const expected = propSchema == null ? void 0 : propSchema.type;
+    if (expected !== "array" && expected !== "object") continue;
+    const value = obj[key];
+    if (typeof value !== "string") continue;
+    const trimmed = value.trim();
+    if (!trimmed || trimmed[0] !== "[" && trimmed[0] !== "{") continue;
+    try {
+      const parsed = JSON.parse(trimmed);
+      const ok = expected === "array" ? Array.isArray(parsed) : parsed !== null && typeof parsed === "object" && !Array.isArray(parsed);
+      if (ok) {
+        if (!out) out = __spreadValues({}, obj);
+        out[key] = parsed;
+      }
+    } catch (e) {
+    }
+  }
+  return out != null ? out : data;
+}
+
+// src/schemas/validatePayload.ts
+function validatePayload(schemaName, data) {
+  if (!(schemaName in schemaRegistry)) {
+    return { success: false, error: `Unknown schema: ${schemaName}` };
+  }
+  const { schema } = schemaRegistry[schemaName];
+  const result = schema.safeParse(coercePayload(data));
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  return {
+    success: false,
+    error: result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ")
+  };
+}
+
+// src/schemas/index.ts
+var schemaRegistry = {
+  "data-table": { schema: dataTableSchema, tool: dataTableTool },
+  "status-card": { schema: statusCardSchema, tool: statusCardTool },
+  "alert": { schema: alertSchema, tool: alertTool },
+  "stat-grid": { schema: statGridSchema, tool: statGridTool },
+  "tabs-panel": { schema: tabsPanelSchema, tool: tabsPanelTool },
+  "sparkline-table": { schema: sparklineTableSchema, tool: sparklineTableTool },
+  "heatmap-table": { schema: heatmapTableSchema, tool: heatmapTableTool },
+  "screener-table": { schema: screenerTableSchema, tool: screenerTableTool },
+  "grouped-table": { schema: groupedTableSchema, tool: groupedTableTool },
+  "news-feed": { schema: newsFeedSchema, tool: newsFeedTool },
+  "area-chart": { schema: areaChartSchema, tool: areaChartTool },
+  "allocation-donut": { schema: allocationDonutSchema, tool: allocationDonutTool },
+  "waterfall-chart": { schema: waterfallChartSchema, tool: waterfallChartTool },
+  "flow-canvas": { schema: flowCanvasSchema, tool: flowCanvasTool },
+  "trial-balance": { schema: trialBalanceSchema, tool: trialBalanceTool },
+  "journal-entry": { schema: journalEntrySchema, tool: journalEntryTool },
+  "aging-report": { schema: agingReportSchema, tool: agingReportTool },
+  "variance-analysis": { schema: varianceAnalysisSchema, tool: varianceAnalysisTool },
+  "stacked-breakdown": { schema: stackedBreakdownSchema, tool: stackedBreakdownTool },
+  "comparative-bar-chart": { schema: comparativeBarChartSchema, tool: comparativeBarChartTool },
+  "compliance-checklist": { schema: complianceChecklistSchema, tool: complianceChecklistTool },
+  "reconciliation-view": { schema: reconciliationViewSchema, tool: reconciliationViewTool },
+  "audit-trail": { schema: auditTrailSchema, tool: auditTrailTool },
+  "document-preview": { schema: documentPreviewSchema, tool: documentPreviewTool },
+  "provenance-chain": { schema: provenanceChainSchema, tool: provenanceChainTool },
+  "search-results": { schema: searchResultsSchema, tool: searchResultsTool },
+  "legal-test-result": { schema: legalTestResultSchema, tool: legalTestResultTool },
+  "engagement-pipeline": { schema: engagementPipelineSchema, tool: engagementPipelineTool },
+  "entity-card-grid": { schema: entityCardGridSchema, tool: entityCardGridTool },
+  "job-tracker": { schema: jobTrackerSchema, tool: jobTrackerTool },
+  "cited-answer": { schema: citedAnswerSchema, tool: citedAnswerTool },
+  "transaction-feed": { schema: transactionFeedSchema, tool: transactionFeedTool },
+  "file-browser": { schema: fileBrowserSchema, tool: fileBrowserTool },
+  "download-card": { schema: downloadCardSchema, tool: downloadCardTool },
+  "ops-dashboard": { schema: opsDashboardSchema, tool: opsDashboardTool },
+  "key-value-list": { schema: keyValueListSchema, tool: keyValueListTool },
+  "balance-sheet": { schema: balanceSheetSchema, tool: balanceSheetTool },
+  "income-statement": { schema: incomeStatementSchema, tool: incomeStatementTool },
+  "cash-flow-statement": { schema: cashFlowStatementSchema, tool: cashFlowStatementTool },
+  "general-ledger": { schema: generalLedgerSchema, tool: generalLedgerTool },
+  "chart-of-accounts": { schema: chartOfAccountsSchema, tool: chartOfAccountsTool },
+  "invoice-detail": { schema: invoiceDetailSchema, tool: invoiceDetailTool },
+  "amortization-table": { schema: amortizationTableSchema, tool: amortizationTableTool },
+  "depreciation-schedule": { schema: depreciationScheduleSchema, tool: depreciationScheduleTool },
+  "escalation-card": { schema: escalationCardSchema, tool: escalationCardTool },
+  "line-chart": { schema: lineChartSchema, tool: lineChartTool },
+  "combo-chart": { schema: comboChartSchema, tool: comboChartTool },
+  "gauge-chart": { schema: gaugeChartSchema, tool: gaugeChartTool },
+  "treemap-chart": { schema: treemapChartSchema, tool: treemapChartTool },
+  "radar-chart": { schema: radarChartSchema, tool: radarChartTool },
+  "funnel-chart": { schema: funnelChartSchema, tool: funnelChartTool },
+  "bullet-chart": { schema: bulletChartSchema, tool: bulletChartTool },
+  "scatter-chart": { schema: scatterChartSchema, tool: scatterChartTool },
+  "connect-integration": { schema: connectIntegrationSchema, tool: connectIntegrationTool },
+  "integrations-list": { schema: integrationsListSchema, tool: integrationsListTool },
+  "pipeline-preview": { schema: pipelinePreviewSchema, tool: pipelinePreviewTool }
+};
+
+exports.buildRenderUITool = buildRenderUITool;
+exports.schemaRegistry = schemaRegistry;
+exports.validatePayload = validatePayload;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map