feat: generate dsl i/o a2ui

Author: manfredsteyer

ai-server/src/mastra/agents/dashboard-agent.prompt.ts

@@ -1,48 +1,17 @@
 import { Agent } from '@mastra/core/agent';
 import { Memory } from '@mastra/memory';
 
-import {
-  addCustomCatalogInstructions,
-  renderA2uiTool,
-} from '../../../../libs/ag-ui-server/index.js';
-import { aggregateDataTool } from '../tools/aggregate-data.js';
-import { findBookedFlightsTool } from '../tools/find-booked-flights.js';
-import { renderChartTool } from '../tools/render-chart.js';
-import { renderFlightChartTool } from '../tools/render-flight-chart.js';
-import { searchFlightsTool } from '../tools/search-flights.js';
-import { searchHotelsTool } from '../tools/search-hotels.js';
-import { searchRentalCarsTool } from '../tools/search-rental-cars.js';
-import { weatherForecastTool } from '../tools/weather-forecast.js';
+import { renderDashboardTool } from '../tools/render-dashboard.js';
 import { dashboardAgentPrompt } from './dashboard-agent.prompt.js';
 
 export const dashboardAgent = new Agent({
   id: 'dashboardAgent',
   name: 'Flight42 Dashboard Composer',
-  instructions: addCustomCatalogInstructions({
-    systemInstructions: dashboardAgentPrompt,
-    log: false,
-  }),
+  instructions: dashboardAgentPrompt,
   model: 'openai/gpt-5.3-chat-latest',
-  tools: {
-    searchFlightsTool,
-    aggregateDataTool,
-    weatherForecastTool,
-    findBookedFlightsTool,
-    renderChartTool,
-    renderFlightChartTool,
-    searchRentalCarsTool,
-    searchHotelsTool,
-    renderA2uiTool,
-  },
-  // A typical dashboard request issues many tool calls before the final
-  // `renderA2uiTool`: searchFlights, several aggregateData runs, one or two
-  // renderChart calls, optionally weatherForecast and findBookedFlights, and
-  // finally renderA2uiTool. Mastra's default step limit is 5, which makes
-  // the agent stop right before the rendering step and produces an empty
-  // dashboard. `defaultOptions` is the option bag for the new
-  // `agent.stream()` / `agent.generate()` APIs in Mastra >= 1.x; the
-  // `*Legacy` variants only apply to `streamLegacy()` / `generateLegacy()`
-  // and are silently ignored by the AG-UI route.
-  defaultOptions: { maxSteps: 20 },
+  tools: { renderDashboardTool },
+  // The agent's only job is to issue ONE renderDashboard tool call,
+  // so a small step budget is plenty.
+  defaultOptions: { maxSteps: 3 },
   memory: new Memory(),
 });

ai-server/src/mastra/agents/dashboard-agent.ts

@@ -3,43 +3,32 @@ import { access, mkdir, readFile, writeFile } from 'node:fs/promises';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
+import {
+  type DashboardSpec,
+  dashboardSpecSchema,
+} from '../dashboard-dsl/dashboard-spec.js';
+
 // File-system based cache for the dashboard agent. Resolves to
 // `<repo>/ai-server/cache/` relative to this source file so the location is
 // stable regardless of which directory `mastra dev` is launched from.
+//
+// Since the move to the dashboard DSL we cache only the parsed
+// `DashboardSpec`. A2UI structural ops are recompiled deterministically
+// from the spec by `compileDashboard` on every refresh, and the data
+// ops are reproduced fresh from the live data sources. The .json
+// extension is new on purpose so old `.a2ui.txt` files (which used a
+// different layout) no longer collide.
 const SOURCE_DIR = dirname(fileURLToPath(import.meta.url));
 const CACHE_DIR = resolve(SOURCE_DIR, '../../../cache');
-const FILE_SUFFIX = '.a2ui.txt';
+const FILE_SUFFIX = '.dashboard.json';
 
 interface RequestMessage {
   readonly role: string;
   readonly content?: unknown;
 }
 
 export interface DashboardCacheEntry {
-  /**
-   * Surface-shaping operations: `createSurface` + `updateComponents`.
-   * Re-emitted as-is on every cache hit so the renderer rebuilds the
-   * component tree.
-   */
-  structural: unknown[];
-  /**
-   * Initial `updateDataModel` operations from the original turn. Used as
-   * a template for the delta-refresh agent: it sees these paths and
-   * re-emits them with fresh values.
-   */
-  dataModel: unknown[];
-  /**
-   * The surface id used by `structural` and `dataModel`. Convenience
-   * cache; could also be derived from the operations list.
-   */
-  surfaceId: string;
-}
-
-interface MaybeOperation {
-  readonly createSurface?: { readonly surfaceId?: unknown };
-  readonly updateComponents?: { readonly surfaceId?: unknown };
-  readonly updateDataModel?: unknown;
-  readonly deleteSurface?: unknown;
+  spec: DashboardSpec;
 }
 
 export function computeDashboardRequestHash(
@@ -82,12 +71,9 @@ export async function readDashboardCache(
 
 export async function writeDashboardCache(
   hash: string,
-  operations: readonly unknown[],
-): Promise<DashboardCacheEntry | null> {
-  const entry = splitA2uiOperations(operations);
-  if (!entry) {
-    return null;
-  }
+  spec: DashboardSpec,
+): Promise<DashboardCacheEntry> {
+  const entry: DashboardCacheEntry = { spec };
   await mkdir(CACHE_DIR, { recursive: true });
   await writeFile(
     getCacheFilePath(hash),
@@ -97,66 +83,19 @@ export async function writeDashboardCache(
   return entry;
 }
 
-/**
- * Splits a fresh A2UI operations array into the structural part
- * (`createSurface` + `updateComponents`) and the initial data-model
- * part (`updateDataModel`). Returns `null` when the operations don't
- * contain a `createSurface` (in which case caching makes no sense).
- */
-export function splitA2uiOperations(
-  operations: readonly unknown[],
-): DashboardCacheEntry | null {
-  const structural: unknown[] = [];
-  const dataModel: unknown[] = [];
-  let surfaceId: string | null = null;
-
-  for (const op of operations) {
-    if (!op || typeof op !== 'object') {
-      continue;
-    }
-    const candidate = op as MaybeOperation;
-    if (candidate.createSurface) {
-      structural.push(op);
-      const id = candidate.createSurface.surfaceId;
-      if (typeof id === 'string') {
-        surfaceId = id;
-      }
-      continue;
-    }
-    if (candidate.updateComponents) {
-      structural.push(op);
-      continue;
-    }
-    if (candidate.updateDataModel) {
-      dataModel.push(op);
-      continue;
-    }
-  }
-
-  if (!surfaceId || structural.length === 0) {
-    return null;
-  }
-
-  return { structural, dataModel, surfaceId };
-}
-
 function toCacheEntry(value: unknown): DashboardCacheEntry | null {
   if (!value || typeof value !== 'object') {
     return null;
   }
-  const candidate = value as Partial<DashboardCacheEntry>;
-  if (
-    !Array.isArray(candidate.structural) ||
-    !Array.isArray(candidate.dataModel) ||
-    typeof candidate.surfaceId !== 'string'
-  ) {
+  const candidate = value as { spec?: unknown };
+  if (!candidate.spec) {
+    return null;
+  }
+  const result = dashboardSpecSchema.safeParse(candidate.spec);
+  if (!result.success) {
     return null;
   }
-  return {
-    structural: candidate.structural,
-    dataModel: candidate.dataModel,
-    surfaceId: candidate.surfaceId,
-  };
+  return { spec: result.data };
 }
 
 function getCacheFilePath(hash: string): string {