@databrainhq/mcp-server 0.3.0-rc.10 → 0.3.0-rc.12

package/dist/{chunk-ERTAKB2H.js → chunk-OLOC2MTA.js}

@@ -3,22 +3,31 @@ import {
   CustomChartsApi,
   DatabrainApiError,
   apiProblems,
-  buildProject,
-  bundleSizeBytes,
-  contentHash,
   createCustomChartsApi,
+  editWithBryn,
   logger,
-  optionSchema,
   planUpload,
-  readDist,
   scaffoldProject,
-  slotSchema,
   stringify,
+  studioDraftSchema,
   toolContext,
   toolError,
-  toolSuccess,
+  toolSuccess
+} from "./chunk-347U6GXR.js";
+import {
+  MAX_BUNDLE_CSS_BYTES,
+  MAX_BUNDLE_JS_BYTES,
+  MAX_ICON_BYTES,
+  MAX_MANIFEST_BYTES,
+  buildProject,
+  buildSource,
+  bundleSizeBytes,
+  contentHash,
+  optionSchema,
+  readDist,
+  slotSchema,
   validateBundle
-} from "./chunk-OCBTNAAO.js";
+} from "./chunk-Q5EYDKSA.js";
 
 // src/apps/contract.ts
 import { z } from "zod";
@@ -28,10 +37,15 @@ var APP_MIME = "text/html;profile=mcp-app";
 var RESOURCE_URI_META_KEY = "ui/resourceUri";
 var PAGE_SIZE = 50;
 var MAX_RESULT_CHARS = 124e3;
+var MAX_CUSTOM_BUNDLE_CHARS = 6 * (MAX_BUNDLE_JS_BYTES + MAX_BUNDLE_CSS_BYTES + MAX_ICON_BYTES) + MAX_MANIFEST_BYTES + 128;
+var CUSTOM_BUNDLE_CHUNK_CHARS = 32e3;
 var id = z.string().trim().min(1).max(256);
 var cell = z.union([z.string().max(2e3), z.number().finite(), z.boolean(), z.null()]);
 var rowsSchema = z.array(z.record(cell)).max(PAGE_SIZE);
-var referenceSchema = z.object({ embedId: id, clientId: id, widgetId: id }).strict();
+var referenceSchema = z.union([
+  z.object({ embedId: id, clientId: id, widgetId: id, dataAppName: id.optional() }).strict(),
+  z.object({ dashboardId: id, widgetId: id, clientId: id.optional(), display: z.enum(["chart", "kpi"]).optional() }).strict()
+]);
 var point = z.object({
   key: id,
   label: z.string().max(2e3),
@@ -52,22 +66,33 @@ var viewSchema = z.object({
   drillId: id.optional()
 }).strict();
 var pageSchema = z.object({
-  kind: z.enum(["chart", "kpi"]),
+  kind: z.enum(["chart", "kpi", "table"]),
   title: z.string().max(500),
+  description: z.string().max(2e3).optional(),
+  rowsTotal: z.number().int().nonnegative().optional(),
   chartSpec: z.object({ type: z.string().max(80) }).strict(),
   rows: rowsSchema,
   columns: z.array(z.string().max(128)).max(20),
   svg: z.string().max(1e5).optional(),
+  customChart: z.object({
+    key: z.string().regex(/^[a-z][a-z0-9_-]{0,63}$/),
+    bindings: z.record(z.array(z.string().max(128)).max(20)),
+    options: z.record(z.union([z.string().max(2e3), z.number().finite(), z.boolean()]))
+  }).strict().optional(),
+  fallback: z.string().max(1e3).optional(),
   width: z.number().int().min(240).max(1200),
   height: z.number().int().min(120).max(800),
   points: z.array(point).max(PAGE_SIZE),
   value: cell.optional(),
   nextCursor: z.string().min(1).max(2048).optional()
 }).strict().superRefine((page, ctx) => {
-  if (page.kind === "chart" && !page.svg) ctx.addIssue({ code: "custom", message: "SVG required" });
+  if (page.kind === "chart" && !page.svg && !page.customChart) ctx.addIssue({ code: "custom", message: "SVG required" });
   if (page.kind === "kpi" && (page.svg || page.points.length || page.value === void 0)) {
     ctx.addIssue({ code: "custom", message: "KPI requires a value and no SVG/points" });
   }
+  if (page.kind === "table" && (page.svg || page.points.length || page.value !== void 0)) {
+    ctx.addIssue({ code: "custom", message: "Table requires rows without SVG/points/value" });
+  }
   if (new Set(page.points.map((p) => p.key)).size !== page.points.length || page.points.some((p) => p.x + p.width > page.width || p.y + p.height > page.height)) {
     ctx.addIssue({ code: "custom", message: "Invalid point geometry" });
   }
@@ -88,8 +113,8 @@ function firstRows(value) {
 }
 
 // src/apps/feature.ts
-function appMeta(visibility) {
-  return { ui: { resourceUri: CHART_URI, visibility }, [RESOURCE_URI_META_KEY]: CHART_URI };
+function appMeta(visibility, uri = CHART_URI) {
+  return { ui: { resourceUri: uri, visibility }, [RESOURCE_URI_META_KEY]: uri };
 }
 var enabled = /* @__PURE__ */ new WeakSet();
 function enableChartApps(server) {
@@ -105,9 +130,196 @@ function chartResult(summary, payload) {
   return bounded({
     content: [{ type: "text", text: summary }],
     structuredContent: payload,
-    _meta: appMeta(["model", "app"])
+    _meta: appMeta(["model", "app"], payload.kind === "kpi" ? KPI_URI : CHART_URI)
   });
 }
+function chartIndex(dashboardId, charts) {
+  return `To draw one, call render_metric_tile with dashboardId ${JSON.stringify(dashboardId)} and metricId set to a widgetId below.
+` + JSON.stringify(charts.slice(0, 50).map((c) => ({ widgetId: c.widgetId, name: (c.name || "Untitled widget").slice(0, 200), chartType: c.chartType || null }))) + (charts.length > 50 ? `
+Showing the first 50 of ${charts.length}.` : "");
+}
+
+// src/tools/custom-chart/author.ts
+import { z as z3 } from "zod";
+
+// src/tools/annotations.ts
+var READ_ONLY = {
+  readOnlyHint: true,
+  destructiveHint: false,
+  idempotentHint: true,
+  openWorldHint: false
+};
+var WRITE_IDEMPOTENT = {
+  readOnlyHint: false,
+  destructiveHint: false,
+  idempotentHint: true,
+  openWorldHint: false
+};
+var WRITE_CREATE = {
+  readOnlyHint: false,
+  destructiveHint: false,
+  idempotentHint: false,
+  openWorldHint: false
+};
+var DESTRUCTIVE = {
+  readOnlyHint: false,
+  destructiveHint: true,
+  idempotentHint: false,
+  openWorldHint: false
+};
+
+// src/tools/custom-chart/shared.ts
+import { z as z2 } from "zod";
+var slotInputSchema = slotSchema;
+var optionInputSchema = optionSchema;
+var manifestInputSchema = z2.record(z2.unknown()).describe("manifest.json as an object (schemaVersion 2). Validated with the same rules as the server.");
+var bundleInputShape = {
+  manifest: manifestInputSchema.optional(),
+  chartTs: z2.string().max(64e3).optional().describe("Hosted source: export render(ctx) in TypeScript or JavaScript. Compiled in memory without filesystem or imports. Pass instead of bundleJs/projectDir."),
+  bundleJs: z2.string().optional().describe("dist/index.js from `databrain custom-chart build` (the shim plus the chart module)."),
+  bundleCss: z2.string().optional().describe("The raw chart.css, kept for provenance."),
+  iconSvg: z2.string().optional().describe("icon.svg, at most 16 KiB, no script, no foreignObject, no external href."),
+  projectDir: z2.string().optional().describe("Local only: a chart project folder. The tool reads it instead of manifest/bundleJs/iconSvg.")
+};
+function formatProblems(problems) {
+  if (problems.length === 0) return "No problems.";
+  return problems.map((p) => `${p.path || "/"}  ${p.code}  ${p.message}`).join("\n");
+}
+function projectDirRefusal() {
+  if (process.env.DATABRAIN_HOSTED_PUBLIC_URL) {
+    return "projectDir is not available on the hosted server. Pass chartTs, manifest, bundleCss and iconSvg to compile in memory, or pass an already built bundleJs.";
+  }
+  return null;
+}
+async function resolveBundleInput(params, options) {
+  if (params.chartTs !== void 0) {
+    if (params.projectDir || params.bundleJs || !params.manifest || !params.iconSvg) {
+      return { problems: [], error: "chartTs needs manifest and iconSvg, and cannot be combined with bundleJs or projectDir.", source: "arguments" };
+    }
+    const result = await buildSource({ manifest: params.manifest, chartTs: params.chartTs, bundleCss: params.bundleCss, iconSvg: params.iconSvg });
+    return { bundle: result.outputs, problems: result.problems, source: "arguments" };
+  }
+  if (params.projectDir) {
+    const refusal = projectDirRefusal();
+    if (refusal) return { problems: [], error: refusal, source: "projectDir" };
+    if (params.manifest || params.bundleJs || params.iconSvg) {
+      return { problems: [], error: "Pass either projectDir or manifest/bundleJs/iconSvg, not both.", source: "projectDir" };
+    }
+    if (options.build) {
+      const result = await buildProject(params.projectDir, { write: false });
+      if (!result.ok || !result.outputs) return { problems: result.problems, source: "projectDir" };
+      const { manifest, bundleJs, bundleCss, iconSvg } = result.outputs;
+      return { bundle: { manifest, bundleJs, bundleCss, iconSvg }, problems: [], source: "projectDir" };
+    }
+    const dist = readDist(params.projectDir);
+    if (!dist.bundle) return { problems: dist.problems, source: "projectDir" };
+    return { bundle: dist.bundle, problems: [], source: "projectDir" };
+  }
+  if (!params.manifest) {
+    return { problems: [], error: "manifest is required (or pass projectDir when running locally).", source: "arguments" };
+  }
+  return {
+    bundle: {
+      manifest: params.manifest,
+      bundleJs: params.bundleJs,
+      bundleCss: params.bundleCss,
+      iconSvg: params.iconSvg
+    },
+    problems: [],
+    source: "arguments"
+  };
+}
+async function remoteValidate(client, bundle) {
+  try {
+    const result = await createCustomChartsApi(client).validate(bundle);
+    return { status: "ok", result };
+  } catch (err) {
+    if (err instanceof DatabrainApiError) {
+      if (err.code === "MISSING_SERVICE_TOKEN") {
+        return { status: "skipped", reason: "No service token is configured, so only the local validator ran." };
+      }
+      return { status: "failed", reason: err.message, problems: apiProblems(err) };
+    }
+    return { status: "failed", reason: err.message, problems: [] };
+  }
+}
+function isCompleteBundle(bundle) {
+  return typeof bundle.bundleJs === "string" && typeof bundle.iconSvg === "string";
+}
+
+// src/tools/custom-chart/author.ts
+function registerCustomChartAuthor(server, client) {
+  server.tool(
+    "custom_chart_edit",
+    "Iterate a custom chart draft with Chart studio Bryn in a granted workspace. Never saves a version or publishes. Feature-detects the backend route. If absent, returns the draft for the calling agent to edit and validate with chartTs, without a local build.",
+    {
+      key: z3.string().regex(/^[a-z][a-z0-9_-]{0,63}$/),
+      workspaceId: z3.string().uuid(),
+      message: z3.string().trim().min(1).max(8e3),
+      draft: studioDraftSchema,
+      sessionId: z3.string().uuid().optional()
+    },
+    WRITE_CREATE,
+    async (input) => {
+      try {
+        if (input.draft.manifest.id !== input.key) return toolError("The draft manifest id must match key.");
+        const result = await editWithBryn(client, input);
+        return toolSuccess(JSON.stringify({
+          ...result,
+          nextStep: result.available ? "Check the returned draft. Validate and preview before saving. Publishing still requires the author to confirm." : "Studio Bryn is not installed. Edit draft.code as plain JavaScript defining render(ctx), then use custom_chart_validate / custom_chart_preview / custom_chart_upload with chartTs=draft.code, manifest, bundleCss=draft.css and iconSvg. Nothing was saved."
+        }));
+      } catch (error) {
+        return error instanceof DatabrainApiError ? error.toToolResponse() : toolError("Bryn could not edit the draft. No version was saved.");
+      }
+    }
+  );
+  const preview = server.tool(
+    "custom_chart_preview",
+    "Validate and preview a draft custom chart as an MCP App tile using bounded sample query rows. No version is saved. Pass chartTs to compile on the server without local files; bindings map manifest slot ids to row column names. Hosts without MCP Apps get the rows and validation result.",
+    {
+      ...bundleInputShape,
+      rows: rowsSchema,
+      bindings: z3.record(z3.array(z3.string().max(128)).max(20)),
+      options: z3.record(z3.union([z3.string().max(2e3), z3.number().finite(), z3.boolean()])).default({})
+    },
+    READ_ONLY,
+    async (input) => {
+      try {
+        const resolved = await resolveBundleInput(input, { build: true });
+        if (resolved.error) return toolError(resolved.error);
+        if (!resolved.bundle || !isCompleteBundle(resolved.bundle)) return toolError(formatProblems(resolved.problems));
+        const { validateBundle: validateBundle2 } = await import("./bundle-TDQXWIPM.js");
+        const problems = validateBundle2(resolved.bundle);
+        if (problems.length) return toolError(formatProblems(problems));
+        const manifest = resolved.bundle.manifest;
+        const columns = Object.keys(input.rows[0] ?? {});
+        const missing = manifest.slots.filter((slot) => slot.required && !(input.bindings[slot.id] ?? []).some((column) => columns.includes(column)));
+        if (input.rows.length && missing.length) return toolError(`Bind required slots ${missing.map((slot) => slot.id).join(", ")} to sample columns: ${columns.join(", ") || "(none)"}.`);
+        const customChart = { key: manifest.id, bindings: input.bindings, options: input.options };
+        const payload = {
+          kind: "chart",
+          title: manifest.name,
+          chartSpec: { type: `custom:${manifest.id}` },
+          rows: input.rows,
+          columns: Object.keys(input.rows[0] ?? {}),
+          width: 600,
+          height: 320,
+          points: [],
+          customChart,
+          fallback: "Draft validated. An MCP Apps host can preview it. These are sample rows, not a saved metric."
+        };
+        if (!hasChartApps(server)) return toolSuccess(JSON.stringify({ ...payload, ok: true }));
+        const result = chartResult("Custom chart draft validated. Preview uses sample rows. Nothing was saved or published.", payload);
+        result._meta = { ...result._meta, "databrain/custom-chart-bundle": resolved.bundle };
+        if (JSON.stringify(result).length > MAX_RESULT_CHARS) return toolError("Draft preview exceeds the MCP host result budget. Reduce the source, CSS or sample rows before previewing.");
+        return result;
+      } catch (error) {
+        return error instanceof DatabrainApiError ? error.toToolResponse() : toolError(error instanceof Error && error.message === "Chart page exceeds payload budget" ? "Draft preview exceeds the MCP host result budget. Reduce the source, CSS or sample rows before previewing." : "Custom chart preview could not be prepared. Check the manifest, source and bindings.");
+      }
+    }
+  );
+  tagChartTool(server, preview);
+}
 
 // src/tools/tool-metadata.ts
 var DEFAULT_TOOL_META = {
@@ -182,6 +394,7 @@ var TOOL_METADATA = {
   preview_chart: { category: "internal_analytics", workflowIntent: "query_data", effect: "view" },
   save_chart_as_dashboard: { category: "internal_analytics", workflowIntent: "author_dashboard", effect: "commit" },
   // Read-only to the user, but each interaction mints an embed-scoped guest credential.
+  render_metric_tile: { category: "internal_analytics", workflowIntent: "chart_app", effect: "read" },
   render_chart: { category: "embedding", workflowIntent: "chart_app", effect: "commit" },
   refresh_widget: { category: "embedding", workflowIntent: "chart_app", effect: "commit" },
   drill_down: { category: "embedding", workflowIntent: "chart_app", effect: "commit" },
@@ -204,6 +417,10 @@ var TOOL_METADATA = {
   list_scheduled_reports: { category: "reports", workflowIntent: "reports", effect: "read" },
   // Custom chart types (DAT-925)
   // Returns template files; nothing is written or persisted.
+  custom_chart_edit: { category: "custom_charts", workflowIntent: "custom_chart", effect: "commit" },
+  custom_chart_preview: { category: "custom_charts", workflowIntent: "custom_chart", effect: "read" },
+  load_custom_chart_bundle: { category: "custom_charts", workflowIntent: "custom_chart", effect: "read" },
+  load_custom_chart_runtime: { category: "custom_charts", workflowIntent: "custom_chart", effect: "read" },
   custom_chart_scaffold: { category: "custom_charts", workflowIntent: "custom_chart", effect: "read" },
   // Local rules plus POST /validate, which never persists.
   custom_chart_validate: { category: "custom_charts", workflowIntent: "custom_chart", effect: "read" },
@@ -214,7 +431,7 @@ var TOOL_METADATA = {
 };
 
 // src/tools/data-app/list-data-apps.ts
-import { z as z2 } from "zod";
+import { z as z4 } from "zod";
 
 // src/api/dashboards-api.ts
 var DashboardsApi = class {
@@ -399,10 +616,12 @@ var EmbedsApi = class {
     this.client = client;
   }
   async createEmbed(body) {
+    const { dataAppName, ...payload } = body;
     return this.client.request({
       method: "POST",
       path: "/api/v2/data-app/embeds",
-      body,
+      query: typeof dataAppName === "string" ? { dataAppName } : void 0,
+      body: payload,
       auth: "api",
       invalidateCache: ["list_embeds"]
     });
@@ -424,12 +643,12 @@ var EmbedsApi = class {
       cacheTtlMs: 5 * 60 * 1e3
     });
   }
-  async getByEmbedId(embedId) {
+  async getByEmbedId(embedId, dataAppName) {
     return this.client.request({
       method: "GET",
       path: "/api/v2/data-app/embeds",
       auth: "api",
-      query: { embedId }
+      query: { embedId, ...dataAppName ? { dataAppName } : {} }
     });
   }
   async updateEmbed(body) {
@@ -509,7 +728,7 @@ var QueryApi = class {
   async startSemanticLayerGeneration(datamartId2) {
     return this.client.request({
       method: "POST",
-      path: `/api/v2/data-app/datamarts/${encodeURIComponent(datamartId2)}/semantic-layer/generate`,
+      path: `/schema/datamart/${encodeURIComponent(datamartId2)}/semantic-layer/auto-generate`,
       auth: "service",
       invalidateCache: ["semantic_layer_"]
     });
@@ -517,7 +736,7 @@ var QueryApi = class {
   async getSemanticLayerGenerationStatus(datamartId2) {
     return this.client.request({
       method: "GET",
-      path: `/api/v2/data-app/datamarts/${encodeURIComponent(datamartId2)}/semantic-layer/generation-status`,
+      path: `/schema/datamart/${encodeURIComponent(datamartId2)}/semantic-layer/generation-status`,
       auth: "service"
     });
   }
@@ -556,6 +775,7 @@ var ScheduledReportsApi = class {
       embedId: params.embedId,
       clientId: params.clientId
     };
+    if (params.dataAppName) query.dataAppName = params.dataAppName;
     if (params.userIdentifier) query.userIdentifier = params.userIdentifier;
     if (params.pageNumber !== void 0) query.pageNumber = String(params.pageNumber);
     if (params.isPagination !== void 0) {
@@ -579,15 +799,15 @@ var SemanticModelApi = class {
   path(id2, verb) {
     return `/api/v2/semantic/${encodeURIComponent(id2)}/${verb}`;
   }
-  pull(id2) {
-    return this.client.request({ method: "GET", path: this.path(id2, "pull"), auth: "service" });
+  pull(id2, mode) {
+    return this.client.request({ method: "GET", path: this.path(id2, "pull"), auth: "service", ...mode ? { query: { mode } } : {} });
   }
   retrieve(id2, q, k) {
     return this.client.request({
-      method: "GET",
+      method: "POST",
       path: this.path(id2, "retrieve"),
       auth: "service",
-      query: { q, k: String(k) }
+      body: { q, k }
     });
   }
   validate(id2, source2) {
@@ -663,12 +883,12 @@ var WidgetsApi = class {
   constructor(client) {
     this.client = client;
   }
-  async listWidgets(embedId, clientId) {
+  async listWidgets(embedId, clientId, dataAppName) {
     return this.client.request({
       method: "GET",
       path: "/api/v2/data-app/metrics",
       auth: "api",
-      query: { embedId, clientId }
+      query: { embedId, clientId, ...dataAppName ? { dataAppName } : {} }
     });
   }
   async createMetric(guestToken, body) {
@@ -677,7 +897,7 @@ var WidgetsApi = class {
       path: "/api/v2/dashboard/createMetric",
       auth: "none",
       token: guestToken,
-      body
+      body: { ...body, isLive: body.isLive ?? false }
     });
   }
   async updateMetric(guestToken, body) {
@@ -692,7 +912,7 @@ var WidgetsApi = class {
   async markArchived(guestToken, body) {
     return this.client.request({
       method: "POST",
-      path: "/api/v2/dashboard/markArchived",
+      path: "/api/v3/metric/markArchived",
       auth: "none",
       token: guestToken,
       body
@@ -758,7 +978,7 @@ var DiscoveryService = class {
   normalizeDashboard(dashboard) {
     return {
       name: isNonEmptyString(dashboard.name) && dashboard.name || isNonEmptyString(dashboard.dashboardName) && dashboard.dashboardName || "Unnamed Dashboard",
-      dashboardId: isNonEmptyString(dashboard.dashboardId) && dashboard.dashboardId || isNonEmptyString(dashboard.externalDashboardId) && dashboard.externalDashboardId || isNonEmptyString(dashboard._id) && dashboard._id || isNonEmptyString(dashboard.id) && dashboard.id || isNonEmptyString(dashboard.uid) && dashboard.uid || null,
+      dashboardId: isNonEmptyString(dashboard.dashboardId) && dashboard.dashboardId || isNonEmptyString(dashboard._id) && dashboard._id || isNonEmptyString(dashboard.id) && dashboard.id || isNonEmptyString(dashboard.uid) && dashboard.uid || isNonEmptyString(dashboard.externalDashboardId) && dashboard.externalDashboardId || null,
       externalDashboardId: isNonEmptyString(dashboard.externalDashboardId) && dashboard.externalDashboardId || null,
       workspaceName: isNonEmptyString(dashboard.workspaceName) && dashboard.workspaceName || isNonEmptyString(dashboard.workspace) && dashboard.workspace || isNonEmptyString(dashboard.workspaceId) && dashboard.workspaceId || null,
       metricCount: typeof dashboard.metricCount === "number" ? dashboard.metricCount : null
@@ -874,8 +1094,8 @@ var EmbedService = class {
     };
     return this.embedsApi.createEmbed(body);
   }
-  async resolveEmbedStrict(embedId) {
-    const response = await this.embedsApi.getByEmbedId(embedId);
+  async resolveEmbedStrict(embedId, dataAppName) {
+    const response = await this.embedsApi.getByEmbedId(embedId, dataAppName);
     const records = Array.isArray(response) ? response.filter((r) => !!r && typeof r === "object") : [response];
     const exact = records.filter((r) => r.embedId === embedId);
     if (exact.length === 1) return exact[0];
@@ -890,8 +1110,8 @@ var EmbedService = class {
 Received records (sample): ${sample || "none"}`
     );
   }
-  async buildUpdateBase(embedId) {
-    const embed = await this.resolveEmbedStrict(embedId);
+  async buildUpdateBase(embedId, dataAppName) {
+    const embed = await this.resolveEmbedStrict(embedId, dataAppName);
     const existingAccess = extractAccessSettings(embed);
     if (existingAccess) {
       return { embedId, accessSettings: existingAccess };
@@ -939,8 +1159,8 @@ Run \`update_embed\` with explicit \`accessSettings.datamartName\`, or recreate
       }
     };
   }
-  async updateEmbed(embedId, updatePatch) {
-    const body = await this.buildUpdateBase(embedId);
+  async updateEmbed(embedId, updatePatch, dataAppName) {
+    const body = await this.buildUpdateBase(embedId, dataAppName);
     const baseAccessSettings = asRecord2(body.accessSettings);
     const patchAccessSettings = asRecord2(updatePatch.accessSettings);
     for (const [key, value] of Object.entries(updatePatch)) {
@@ -955,7 +1175,7 @@ Run \`update_embed\` with explicit \`accessSettings.datamartName\`, or recreate
     } else if (patchAccessSettings) {
       body.accessSettings = patchAccessSettings;
     }
-    return this.embedsApi.updateEmbed(body);
+    return this.embedsApi.updateEmbed({ ...body, ...dataAppName ? { dataAppName } : {} });
   }
 };
 
@@ -1023,7 +1243,7 @@ var WidgetService = class {
    * where the user only knows the dashboard + workspace, not the embedId or
    * data app name. Returns a business-user-friendly error on ambiguity.
    */
-  async resolveEmbedFromDashboard(dashboardName, workspaceName) {
+  async resolveEmbedFromDashboard(dashboardName, workspaceName, dataAppName) {
     const wsProvided = workspaceName && workspaceName.trim().length > 0 ? workspaceName.trim() : void 0;
     let dashboards;
     try {
@@ -1065,8 +1285,23 @@ var WidgetService = class {
       };
     }
     let embeds;
+    let dataAppSelectionAvailable = false;
     try {
-      embeds = await this.embedsApi.listEmbeds();
+      try {
+        embeds = await this.embedsApi.listEmbeds(dataAppName);
+      } catch (error) {
+        if (!(error instanceof DatabrainApiError) || error.code !== "DATA_APP_REQUIRED") throw error;
+        dataAppSelectionAvailable = true;
+        const apps = await this.dataAppsApi.listDataApps(dashboard.workspaceName || wsProvided);
+        embeds = [];
+        for (const app of apps) {
+          const name = app.name || app.dataAppName;
+          if (typeof name === "string" && name.trim()) {
+            const scoped = await this.embedsApi.listEmbeds(name);
+            embeds.push(...scoped.map((e) => ({ ...e, embedMetadata: { ...e.embedMetadata, dataAppName: name } })));
+          }
+        }
+      }
     } catch (err) {
       return {
         ok: false,
@@ -1092,10 +1327,11 @@ var WidgetService = class {
       };
     }
     if (embedMatches.length > 1) {
-      const names = embedMatches.map((x) => `"${x.n.name}"`).join(", ");
+      const names = embedMatches.map((x) => `"${x.n.name}" (embedId: ${x.n.embedId})`).join(", ");
+      const apps = [...new Set(embedMatches.map((x) => x.n.dataAppName).filter(Boolean))];
       return {
         ok: false,
-        error: `Dashboard "${dashboard.name}" has multiple embeds (${names}). Ask the user which embed name they want to customize.`
+        error: `Dashboard "${dashboard.name}" has multiple embeds (${names}). ` + (dataAppSelectionAvailable && apps.length > 1 ? `Pass dataAppName to choose one of: ${apps.join(", ")}, or select an embedId. (DATA_APP_REQUIRED)` : "Select an embedId and retry.")
       };
     }
     return {
@@ -1121,7 +1357,8 @@ var WidgetService = class {
     if (params.dashboardName && params.dashboardName.trim().length > 0) {
       const res = await this.resolveEmbedFromDashboard(
         params.dashboardName,
-        params.workspaceName
+        params.workspaceName,
+        params.dataAppName
       );
       if (!res.ok) return res;
       return {
@@ -1171,7 +1408,7 @@ var WidgetService = class {
         error: "`clientId` cannot be empty. Pick a tenant/client first."
       };
     }
-    const ctx = await this.resolveEmbedContext(params.embedId);
+    const ctx = await this.resolveEmbedContext(params.embedId, params.dataAppName);
     if (ctx.externalDashboardCreatedBy === clientId) {
       return {
         ok: true,
@@ -1246,7 +1483,7 @@ var WidgetService = class {
     }
     let ctx;
     try {
-      ctx = await this.resolveEmbedContext(params.embedId);
+      ctx = await this.resolveEmbedContext(params.embedId, params.dataAppName);
     } catch (err) {
       return { ok: false, error: err.message };
     }
@@ -1354,7 +1591,17 @@ Do not guess between the two \u2014 wait for the user to choose.`
       }
       return false;
     };
-    const target = datasources.find(matchPredicate);
+    let target = datasources.find(matchPredicate);
+    if (!target && provided.integrationId) {
+      for (const datasource of datasources) {
+        if (datasource._id || datasource.id || typeof datasource.name !== "string") continue;
+        const id3 = await this.datasourcesApi.resolveIdByName(datasource.name);
+        if (id3 === provided.integrationId) {
+          target = { ...datasource, id: id3 };
+          break;
+        }
+      }
+    }
     if (!target) {
       const available = datasources.filter((ds) => typeof ds.name === "string" && ds.name.trim().length > 0).map((ds) => `"${ds.name}"`).join(", ");
       const inactiveMatch = allDatasources.find(
@@ -1424,8 +1671,8 @@ Do not guess between the two \u2014 wait for the user to choose.`
     }
     return { kind: "no_metric_fields", widgetsTried: toProbe.length, fetchErrors };
   }
-  async resolveEmbedContext(embedId) {
-    const response = await this.embedsApi.getByEmbedId(embedId);
+  async resolveEmbedContext(embedId, dataAppNameHint) {
+    const response = await this.embedsApi.getByEmbedId(embedId, dataAppNameHint);
     const records = Array.isArray(response) ? response : response ? [response] : [];
     const exact = records.find((r) => r && r.embedId === embedId) || records[0];
     if (!exact) {
@@ -1577,32 +1824,6 @@ function createServiceBundle(client) {
   };
 }
 
-// src/tools/annotations.ts
-var READ_ONLY = {
-  readOnlyHint: true,
-  destructiveHint: false,
-  idempotentHint: true,
-  openWorldHint: false
-};
-var WRITE_IDEMPOTENT = {
-  readOnlyHint: false,
-  destructiveHint: false,
-  idempotentHint: true,
-  openWorldHint: false
-};
-var WRITE_CREATE = {
-  readOnlyHint: false,
-  destructiveHint: false,
-  idempotentHint: false,
-  openWorldHint: false
-};
-var DESTRUCTIVE = {
-  readOnlyHint: false,
-  destructiveHint: true,
-  idempotentHint: false,
-  openWorldHint: false
-};
-
 // src/tools/data-app/list-data-apps.ts
 function registerListDataApps(server, client) {
   const services = createServiceBundle(client);
@@ -1610,7 +1831,7 @@ function registerListDataApps(server, client) {
     "list_data_apps",
     "List data apps in your organization. Start here for embed setup.",
     {
-      workspaceName: z2.string().optional().describe("Filter by workspace name")
+      workspaceName: z4.string().optional().describe("Filter by workspace name")
     },
     READ_ONLY,
     async (params) => {
@@ -1639,7 +1860,7 @@ function registerListDataApps(server, client) {
 }
 
 // src/tools/data-app/list-tenants.ts
-import { z as z3 } from "zod";
+import { z as z5 } from "zod";
 var isNonEmptyString4 = (value) => typeof value === "string" && value.trim().length > 0;
 function workspaceIdFrom(workspace) {
   return isNonEmptyString4(workspace.id) && workspace.id || isNonEmptyString4(workspace._id) && workspace._id || isNonEmptyString4(workspace.workspaceId) && workspace.workspaceId || null;
@@ -1677,12 +1898,12 @@ function registerListTenants(server, client) {
     "list_tenants",
     "List available tenants/clients from the workspace tenancy database. Use this to pick a valid clientId before creating guest tokens or editing customer dashboards.",
     {
-      workspaceName: z3.string().optional().describe("Workspace name. Preferred for non-technical callers; the tool resolves it to a workspaceId."),
-      workspaceId: z3.string().optional().describe("Technical workspace UUID. Provide this instead of workspaceName if already known."),
-      searchValue: z3.string().optional().describe("Optional case-insensitive search string for tenant/client labels."),
-      limit: z3.number().int().positive().max(500).optional().describe("Maximum number of tenants to return. Backend may apply connector-specific limits."),
-      datasourceId: z3.string().optional().describe("Optional datasource UUID override when the workspace has multiple datasource contexts."),
-      datamartId: z3.string().optional().describe("Optional datamart UUID override when tenant lookup should use a specific datamart.")
+      workspaceName: z5.string().optional().describe("Workspace name. Preferred for non-technical callers; the tool resolves it to a workspaceId."),
+      workspaceId: z5.string().optional().describe("Technical workspace UUID. Provide this instead of workspaceName if already known."),
+      searchValue: z5.string().optional().describe("Optional case-insensitive search string for tenant/client labels."),
+      limit: z5.number().int().positive().max(500).optional().describe("Maximum number of tenants to return. Backend may apply connector-specific limits."),
+      datasourceId: z5.string().optional().describe("Optional datasource UUID override when the workspace has multiple datasource contexts."),
+      datamartId: z5.string().optional().describe("Optional datamart UUID override when tenant lookup should use a specific datamart.")
     },
     READ_ONLY,
     async (params) => {
@@ -1776,15 +1997,15 @@ function registerListTenants(server, client) {
 }
 
 // src/tools/data-app/create-data-app.ts
-import { z as z4 } from "zod";
+import { z as z6 } from "zod";
 function registerCreateDataApp(server, client) {
   server.tool(
     "create_data_app",
     "Create a new data app.",
     {
-      name: z4.string().describe("Data app name"),
-      workspaceName: z4.string().optional().describe("Optional workspace name if required by backend"),
-      body: z4.record(z4.unknown()).optional().describe("Raw API body passthrough for POST /api/v2/data-app/")
+      name: z6.string().describe("Data app name"),
+      workspaceName: z6.string().optional().describe("Optional workspace name if required by backend"),
+      body: z6.record(z6.unknown()).optional().describe("Raw API body passthrough for POST /api/v2/data-app/")
     },
     WRITE_CREATE,
     async (params) => {
@@ -1818,7 +2039,7 @@ function registerCreateDataApp(server, client) {
 }
 
 // src/tools/data-app/list-api-tokens.ts
-import { z as z5 } from "zod";
+import { z as z7 } from "zod";
 
 // src/utils/resolve-resource.ts
 function resolveResource(options) {
@@ -1887,7 +2108,7 @@ function registerListApiTokens(server, client) {
     "list_api_tokens",
     "List API tokens for a data app. Omit dataAppName to auto-resolve.",
     {
-      dataAppName: z5.string().optional().describe("Data app name. Omit to list available data apps.")
+      dataAppName: z7.string().optional().describe("Data app name. Omit to list available data apps.")
     },
     READ_ONLY,
     async (params) => {
@@ -1932,16 +2153,16 @@ function registerListApiTokens(server, client) {
 }
 
 // src/tools/data-app/create-api-token.ts
-import { z as z6 } from "zod";
+import { z as z8 } from "zod";
 function registerCreateApiToken(server, client) {
   const services = createServiceBundle(client);
   server.tool(
     "create_api_token",
     "Create an API token for a data app and activate it for this session. Omit dataAppName to auto-resolve.",
     {
-      dataAppName: z6.string().optional().describe("Data app name. Omit to list available data apps."),
-      name: z6.string().optional().describe("Optional token name"),
-      body: z6.record(z6.unknown()).optional().describe("Raw API body passthrough for POST /api/v2/data-app/api-tokens")
+      dataAppName: z8.string().optional().describe("Data app name. Omit to list available data apps."),
+      name: z8.string().optional().describe("Optional token name"),
+      body: z8.record(z8.unknown()).optional().describe("Raw API body passthrough for POST /api/v2/data-app/api-tokens")
     },
     WRITE_CREATE,
     async (params) => {
@@ -1994,16 +2215,17 @@ Save this in backend secrets immediately. This value may not be returned again.`
 }
 
 // src/tools/data-app/rotate-api-token.ts
-import { z as z7 } from "zod";
+import { randomUUID } from "crypto";
+import { z as z9 } from "zod";
 function registerRotateApiToken(server, client) {
   const services = createServiceBundle(client);
   server.tool(
     "rotate_api_token",
-    "Rotate (invalidate and replace) an API token. Previous token becomes stale.",
+    "Rotate through the raw token-authenticated endpoint, or issue a replacement token for a data app. The replacement fallback does not revoke existing tokens.",
     {
-      dataAppName: z7.string().optional().describe("Data app name. Omit to list available data apps."),
-      tokenId: z7.string().optional().describe("Optional token ID to rotate"),
-      body: z7.record(z7.unknown()).optional().describe("Raw API body passthrough for rotate endpoint")
+      dataAppName: z9.string().optional().describe("Data app name. Omit to list available data apps."),
+      tokenId: z9.string().optional().describe("Optional token ID to rotate"),
+      body: z9.record(z9.unknown()).optional().describe("Raw API body passthrough for rotate endpoint")
     },
     DESTRUCTIVE,
     async (params) => {
@@ -2039,13 +2261,14 @@ function registerRotateApiToken(server, client) {
 ` : "") + "Update backend secrets immediately."
           );
         }
+        if (params.tokenId) return toolError("Rotating a named token requires the token-authenticated raw body endpoint. No replacement was issued. Use the API token settings to retire a specific token.");
         const createRes = await client.request({
           method: "POST",
           path: "/api/v2/data-app/api-tokens",
           auth: "service",
           body: {
             dataAppName,
-            name: `${dataAppName}-api-token-rotated`
+            name: `${dataAppName}-rotated-${randomUUID()}`
           }
         });
         if (createRes.error) {
@@ -2058,7 +2281,7 @@ function registerRotateApiToken(server, client) {
 
 ` + (key ? `**New Token:** \`${key}\`
 
-` : "") + "Treat previous tokens as stale and update backend secrets."
+` : "") + "Existing tokens remain active. Update backend secrets, then retire the old token in API token settings."
         );
       } catch (err) {
         if (err instanceof DatabrainApiError) return err.toToolResponse();
@@ -2122,14 +2345,14 @@ function registerListDatasources(server, client) {
 }
 
 // src/tools/infrastructure/discover-datasource-schema.ts
-import { z as z8 } from "zod";
+import { z as z10 } from "zod";
 function registerDiscoverDatasourceSchema(server, client) {
   const services = createServiceBundle(client);
   server.tool(
     "discover_datasource_schema",
     "Inspect tables and columns in a datasource. Omit datasourceName to list available datasources.",
     {
-      datasourceName: z8.string().optional().describe(
+      datasourceName: z10.string().optional().describe(
         "Name of the datasource to inspect. Omit to list available datasources."
       )
     },
@@ -2212,13 +2435,13 @@ Fix the connection or add a new database in the **Databrain UI**.`
 }
 
 // src/tools/infrastructure/list-datamarts.ts
-import { z as z9 } from "zod";
+import { z as z11 } from "zod";
 function registerListDatamarts(server, client) {
   server.tool(
     "list_datamarts",
     "List datamarts with table counts and semantic layer scores.",
     {
-      dataAppName: z9.string().optional().describe("Filter by data app name")
+      dataAppName: z11.string().optional().describe("Filter by data app name")
     },
     READ_ONLY,
     async (params) => {
@@ -2307,7 +2530,7 @@ function registerListWorkspaces(server, client) {
 }
 
 // src/tools/infrastructure/create-datamart.ts
-import { z as z10 } from "zod";
+import { z as z12 } from "zod";
 
 // src/tools/widgets/production-guards.ts
 var APPLY_TO_PRODUCTION_CONFIRMATION = "APPLY_TO_PRODUCTION";
@@ -2325,29 +2548,29 @@ function genericProductionSafetyNote() {
 }
 
 // src/tools/infrastructure/create-datamart.ts
-var columnSchema = z10.object({
-  name: z10.string(),
-  alias: z10.string().optional(),
-  label: z10.string().optional(),
-  isHide: z10.boolean().optional(),
-  isCustomColumn: z10.boolean().optional(),
-  sql: z10.string().optional()
+var columnSchema = z12.object({
+  name: z12.string(),
+  alias: z12.string().optional(),
+  label: z12.string().optional(),
+  isHide: z12.boolean().optional(),
+  isCustomColumn: z12.boolean().optional(),
+  sql: z12.string().optional()
 });
-var tableSchema = z10.object({
-  name: z10.string(),
-  schemaName: z10.string().optional(),
-  clientColumn: z10.string().optional(),
-  label: z10.string().optional(),
-  columns: z10.array(columnSchema)
+var tableSchema = z12.object({
+  name: z12.string(),
+  schemaName: z12.string().optional(),
+  clientColumn: z12.string().optional(),
+  label: z12.string().optional(),
+  columns: z12.array(columnSchema)
 });
-var relationshipSchema = z10.object({
-  parentTableName: z10.string(),
-  parentColumnName: z10.string(),
-  childTableName: z10.string(),
-  childColumnName: z10.string(),
-  cardinality: z10.enum(["OneToOne", "OneToMany", "ManyToOne", "ManyToMany"]),
-  join: z10.enum(["INNER JOIN", "LEFT JOIN", "RIGHT JOIN", "FULL JOIN"]),
-  relationshipName: z10.string()
+var relationshipSchema = z12.object({
+  parentTableName: z12.string(),
+  parentColumnName: z12.string(),
+  childTableName: z12.string(),
+  childColumnName: z12.string(),
+  cardinality: z12.enum(["OneToOne", "OneToMany", "ManyToOne", "ManyToMany"]),
+  join: z12.enum(["INNER JOIN", "LEFT JOIN", "RIGHT JOIN", "FULL JOIN"]),
+  relationshipName: z12.string()
 });
 function datamartSuccessMessage(name, result) {
   return `Datamart "${name}" created successfully (ID: ${result.id || result._id || "UNKNOWN"}).
@@ -2368,21 +2591,21 @@ function registerCreateDatamart(server, client) {
     "create_datamart",
     "Create a production datamart from selected tables and relationships. Defaults to dry-run; apply requires explicit confirmation.",
     {
-      mode: z10.enum(["dry_run", "apply"]).default("dry_run").describe("dry_run returns the plan only; apply creates the datamart"),
-      confirm: z10.string().optional().describe(`Required for apply: ${APPLY_TO_PRODUCTION_CONFIRMATION}`),
-      name: z10.string().describe("Unique datamart name"),
-      datasourceName: z10.string().optional().describe("Name of the datasource to use. Omit to list available datasources."),
-      tableList: z10.array(tableSchema).optional().describe("Array of tables with their columns"),
-      relationships: z10.array(relationshipSchema).optional().describe("Join definitions between tables"),
-      tenancySettings: z10.object({
-        tenancyLevel: z10.enum(["TABLE", "DATABASE"]).optional(),
-        clientColumnType: z10.string().optional(),
-        schemaName: z10.string().optional(),
-        tableName: z10.string().optional(),
-        tableClientNameColumn: z10.string().optional(),
-        tablePrimaryKeyColumn: z10.string().optional()
+      mode: z12.enum(["dry_run", "apply"]).default("dry_run").describe("dry_run returns the plan only; apply creates the datamart"),
+      confirm: z12.string().optional().describe(`Required for apply: ${APPLY_TO_PRODUCTION_CONFIRMATION}`),
+      name: z12.string().describe("Unique datamart name"),
+      datasourceName: z12.string().optional().describe("Name of the datasource to use. Omit to list available datasources."),
+      tableList: z12.array(tableSchema).optional().describe("Array of tables with their columns"),
+      relationships: z12.array(relationshipSchema).optional().describe("Join definitions between tables"),
+      tenancySettings: z12.object({
+        tenancyLevel: z12.enum(["TABLE", "DATABASE"]).optional(),
+        clientColumnType: z12.string().optional(),
+        schemaName: z12.string().optional(),
+        tableName: z12.string().optional(),
+        tableClientNameColumn: z12.string().optional(),
+        tablePrimaryKeyColumn: z12.string().optional()
       }).optional().describe("Multi-tenant configuration"),
-      body: z10.record(z10.unknown()).optional().describe("Raw API body passthrough for POST /api/v2/data-app/datamarts")
+      body: z12.record(z12.unknown()).optional().describe("Raw API body passthrough for POST /api/v2/data-app/datamarts")
     },
     WRITE_CREATE,
     async (params) => {
@@ -2477,14 +2700,14 @@ function registerCreateDatamart(server, client) {
 }
 
 // src/tools/infrastructure/sync-datasource.ts
-import { z as z11 } from "zod";
+import { z as z13 } from "zod";
 function registerSyncDatasource(server, client) {
   const datasourcesApi = new DatasourcesApi(client);
   server.tool(
     "sync_datasource",
     "Trigger a datasource schema sync to refresh table and column metadata. If datasourceName is omitted and there are multiple datasources, returns the list so the user can choose.",
     {
-      datasourceName: z11.string().optional().describe("Name of the datasource to sync. Omit to list available datasources.")
+      datasourceName: z13.string().optional().describe("Name of the datasource to sync. Omit to list available datasources.")
     },
     WRITE_IDEMPOTENT,
     async (params) => {
@@ -2533,7 +2756,7 @@ The schema metadata will be refreshed. You can now use \`discover_datasource_sch
 }
 
 // src/tools/embed/create-embed.ts
-import { z as z12 } from "zod";
+import { z as z14 } from "zod";
 var DEFAULT_ACCESS_SETTINGS2 = {
   isAllowMetricCreation: false,
   isAllowMetricDeletion: false,
@@ -2546,18 +2769,18 @@ var DEFAULT_ACCESS_SETTINGS2 = {
   isAllowCreateDashboardView: false,
   metricCreationMode: "DRAG_DROP"
 };
-var accessSettingsSchema = z12.object({
-  datamartName: z12.string().describe("Name of the datamart (required)"),
-  isAllowMetricCreation: z12.boolean().optional().describe("Allow end-users to create metrics"),
-  metricCreationMode: z12.enum(["DRAG_DROP", "CHAT"]).optional().describe("Metric creation mode"),
-  isAllowMetricDeletion: z12.boolean().optional().describe("Allow metric deletion"),
-  isAllowMetricUpdate: z12.boolean().optional().describe("Allow metric editing"),
-  isAllowMetricLayoutChange: z12.boolean().optional().describe("Allow layout changes"),
-  isAllowManageMetrics: z12.boolean().optional().describe("Show manage metrics UI"),
-  isAllowUnderlyingData: z12.boolean().optional().describe("Allow viewing underlying data"),
-  isAllowAiPilot: z12.boolean().optional().describe("Enable AI pilot features"),
-  isAllowEmailReports: z12.boolean().optional().describe("Allow email report scheduling"),
-  isAllowCreateDashboardView: z12.boolean().optional().describe("Allow creating dashboard views")
+var accessSettingsSchema = z14.object({
+  datamartName: z14.string().describe("Name of the datamart (required)"),
+  isAllowMetricCreation: z14.boolean().optional().describe("Allow end-users to create metrics"),
+  metricCreationMode: z14.enum(["DRAG_DROP", "CHAT"]).optional().describe("Metric creation mode"),
+  isAllowMetricDeletion: z14.boolean().optional().describe("Allow metric deletion"),
+  isAllowMetricUpdate: z14.boolean().optional().describe("Allow metric editing"),
+  isAllowMetricLayoutChange: z14.boolean().optional().describe("Allow layout changes"),
+  isAllowManageMetrics: z14.boolean().optional().describe("Show manage metrics UI"),
+  isAllowUnderlyingData: z14.boolean().optional().describe("Allow viewing underlying data"),
+  isAllowAiPilot: z14.boolean().optional().describe("Enable AI pilot features"),
+  isAllowEmailReports: z14.boolean().optional().describe("Allow email report scheduling"),
+  isAllowCreateDashboardView: z14.boolean().optional().describe("Allow creating dashboard views")
 }).describe("Embed access settings. Only datamartName is required \u2014 all flags default to false.");
 function registerCreateEmbed(server, client) {
   const services = createServiceBundle(client);
@@ -2565,28 +2788,37 @@ function registerCreateEmbed(server, client) {
     "create_embed",
     "Create an embed. Provide dashboardId, workspaceName, accessSettings.datamartName. Add clientId for multi-tenant per-client dashboards. All isAllow* flags default to false.",
     {
-      body: z12.record(z12.unknown()).optional().describe(
+      body: z14.record(z14.unknown()).optional().describe(
         "Raw API body passthrough. If provided, all other fields are ignored."
       ),
-      dashboardId: z12.string().optional().describe("Dashboard identifier for embed creation"),
-      workspaceName: z12.string().optional().describe("Workspace name. Omit to auto-resolve if only one exists."),
-      embedType: z12.enum(["dashboard", "metric"]).optional().describe("Embed type"),
-      metricId: z12.string().optional().describe("Required for metric embed type"),
-      name: z12.string().optional().describe("Human-readable embed config name"),
+      dataAppName: z14.string().optional().describe("Data app name; required when the workspace has more than one"),
+      dashboardId: z14.string().optional().describe("Existing dashboard UUID or externalDashboardId slug for a standard embed; a new unique slug for a client dashboard copy"),
+      workspaceName: z14.string().optional().describe("Workspace name. Omit to auto-resolve if only one exists."),
+      embedType: z14.enum(["dashboard", "metric"]).optional().describe("Embed type"),
+      metricId: z14.string().optional().describe("Required for metric embed type"),
+      name: z14.string().optional().describe("Human-readable embed config name"),
       accessSettings: accessSettingsSchema.optional(),
       // Multi-tenant (dashboard embed) params
-      clientId: z12.string().optional().describe(
+      clientId: z14.string().optional().describe(
         "Client identifier for multi-tenant isolation. When provided, creates a dashboard embed (each client gets their own dashboard copy)."
       ),
-      templateDashboardId: z12.string().optional().describe("Template dashboard ID to clone metrics from"),
-      isImportMetrics: z12.boolean().optional().describe("Import metrics from template dashboard"),
-      metricImportMode: z12.enum(["COPY", "LINK"]).optional().describe("COPY duplicates metrics, LINK shares them"),
-      isRenameDashboard: z12.boolean().optional().describe("Rename the dashboard for this client")
+      templateDashboardId: z14.string().optional().describe("Template dashboard UUID or externalDashboardId slug to clone metrics from"),
+      isImportMetrics: z14.boolean().optional().describe("Import metrics from template dashboard"),
+      metricImportMode: z14.enum(["GALLERY", "METRIC"]).optional().describe("GALLERY imports dashboard gallery metrics; METRIC imports selected metrics"),
+      isRenameDashboard: z14.boolean().optional().describe("Rename the dashboard for this client")
     },
     WRITE_CREATE,
     async (params) => {
       try {
         const isMultiTenant = !!params.clientId;
+        const dashboardSlug = async (value, workspace) => {
+          if (typeof value !== "string" || !z14.string().uuid().safeParse(value).success) return value;
+          if (typeof workspace !== "string" || !workspace) throw new Error("workspaceName is required to resolve a dashboard UUID.");
+          const boards = await services.dashboardsApi.listDashboardsForWorkspace(workspace);
+          const board = boards.find((item) => item.id === value || item.dashboardId === value);
+          if (!board?.externalDashboardId) throw new Error("Dashboard not found in this workspace. Use list_dashboards to choose one.");
+          return board.externalDashboardId;
+        };
         let resolvedWorkspaceName = params.workspaceName;
         if (!params.body && isMultiTenant && !resolvedWorkspaceName) {
           const workspaces = await services.workspacesApi.listWorkspaces();
@@ -2604,6 +2836,7 @@ function registerCreateEmbed(server, client) {
         if (isMultiTenant) {
           const body2 = params.body ? { ...params.body } : {
             dashboardId: params.dashboardId,
+            dataAppName: params.dataAppName,
             workspaceName: resolvedWorkspaceName,
             clientId: params.clientId,
             name: params.name,
@@ -2615,10 +2848,13 @@ function registerCreateEmbed(server, client) {
           };
           const callerAccess = body2.accessSettings && typeof body2.accessSettings === "object" ? body2.accessSettings : {};
           body2.accessSettings = { ...DEFAULT_ACCESS_SETTINGS2, ...callerAccess };
+          if (body2.templateDashboardId) body2.templateDashboardId = await dashboardSlug(body2.templateDashboardId, body2.workspaceName);
+          const { dataAppName, ...payload } = body2;
           const result2 = await client.request({
             method: "POST",
             path: "/api/v2/data-app/dashboard-embeds",
-            body: body2,
+            query: typeof dataAppName === "string" ? { dataAppName } : void 0,
+            body: payload,
             auth: "api",
             invalidateCache: ["list_embeds"]
           });
@@ -2639,6 +2875,7 @@ Next: use \`generate_guest_token\` with the clientId and \`generate_embed_code\`
         }
         const body = params.body ? { ...params.body } : {
           dashboardId: params.dashboardId,
+          dataAppName: params.dataAppName,
           workspaceName: params.workspaceName,
           embedType: params.embedType || "dashboard",
           metricId: params.metricId,
@@ -2659,6 +2896,7 @@ Next: use \`generate_guest_token\` with the clientId and \`generate_embed_code\`
         if (!datamartName || typeof datamartName !== "string") {
           return toolError("create_embed requires `accessSettings.datamartName`.");
         }
+        body.dashboardId = await dashboardSlug(body.dashboardId, body.workspaceName);
         const result = await services.embedService.createEmbedStrict(body);
         if (result.error) {
           return toolError(`Embed creation failed: ${stringify(result.error)}`);
@@ -2683,14 +2921,14 @@ Next: run \`get_embed_details\` to verify the embed configuration.`
 }
 
 // src/tools/embed/list-embeds.ts
-import { z as z13 } from "zod";
+import { z as z15 } from "zod";
 function registerListEmbeds(server, client) {
   const services = createServiceBundle(client);
   server.tool(
     "list_embeds",
     "List embed configurations. Requires an API token (use create_api_token first). Use `list_tenants` for authoritative client discovery from the tenancy database.",
     {
-      dataAppName: z13.string().optional().describe("Filter by data app name")
+      dataAppName: z15.string().optional().describe("Filter by data app name")
     },
     READ_ONLY,
     async (params) => {
@@ -2741,19 +2979,20 @@ function registerListEmbeds(server, client) {
 }
 
 // src/tools/embed/get-embed-details.ts
-import { z as z14 } from "zod";
+import { z as z16 } from "zod";
 function registerGetEmbedDetails(server, client) {
   const services = createServiceBundle(client);
   server.tool(
     "get_embed_details",
     "Get full embed configuration including access settings and theme.",
     {
-      embedId: z14.string().describe("ID of the embed")
+      embedId: z16.string().describe("ID of the embed"),
+      dataAppName: z16.string().trim().min(1).optional().describe("Data app when this embed ID belongs to several apps")
     },
     READ_ONLY,
     async (params) => {
       try {
-        const embed = await services.embedService.resolveEmbedStrict(params.embedId);
+        const embed = await services.embedService.resolveEmbedStrict(params.embedId, params.dataAppName);
         return toolSuccess(JSON.stringify({ embedId: params.embedId, ...embed }));
       } catch (err) {
         if (err instanceof DatabrainApiError) return err.toToolResponse();
@@ -2764,7 +3003,7 @@ function registerGetEmbedDetails(server, client) {
 }
 
 // src/tools/embed/update-embed.ts
-import { z as z15 } from "zod";
+import { z as z17 } from "zod";
 
 // src/tools/embed/helpers.ts
 var GUEST_TOKEN_REMINDER = "\n\n\u26A0\uFE0F **Guest tokens must be regenerated** for these changes to take effect. Existing guest tokens still carry the old settings. Call `generate_guest_token` to create a new token with the updated configuration.";
@@ -2802,15 +3041,16 @@ function registerUpdateEmbed(server, client) {
     "update_embed",
     "Update embed access settings, permissions, theme, or name.",
     {
-      embedId: z15.string().describe("ID of the embed to update"),
-      body: z15.record(z15.unknown()).optional().describe(
+      embedId: z17.string().describe("ID of the embed to update"),
+      dataAppName: z17.string().trim().min(1).optional().describe("Data app when this embed ID belongs to several apps"),
+      body: z17.record(z17.unknown()).optional().describe(
         "Raw API body for PUT /api/v2/data-app/embeds. If provided, it is sent directly (passthrough mode)."
       ),
-      name: z15.string().optional().describe("New name for the embed"),
-      accessSettings: z15.record(z15.unknown()).optional().describe(
+      name: z17.string().optional().describe("New name for the embed"),
+      accessSettings: z17.record(z17.unknown()).optional().describe(
         "Partial update of access settings. See `get_embed_details` for current settings."
       ),
-      theme: z15.record(z15.unknown()).optional().describe(
+      theme: z17.record(z17.unknown()).optional().describe(
         "Theme configuration object. See databrain://theme-reference for the full schema."
       )
     },
@@ -2820,6 +3060,7 @@ function registerUpdateEmbed(server, client) {
         if (params.body) {
           const rawBody = { ...params.body };
           if (!rawBody.embedId) rawBody.embedId = params.embedId;
+          if (params.dataAppName) rawBody.dataAppName = params.dataAppName;
           const result2 = await services.embedsApi.updateEmbed(rawBody);
           if (result2.error) {
             return toolError(`Embed update failed: ${stringify(result2.error)}`);
@@ -2834,7 +3075,8 @@ function registerUpdateEmbed(server, client) {
         if (params.theme) patch.theme = params.theme;
         const result = await services.embedService.updateEmbed(
           params.embedId,
-          patch
+          patch,
+          params.dataAppName
         );
         if (result.error) {
           return toolError(`Embed update failed: ${stringify(result.error)}`);
@@ -2856,7 +3098,7 @@ function registerUpdateEmbed(server, client) {
 }
 
 // src/tools/embed/customize-theme.ts
-import { z as z16 } from "zod";
+import { z as z18 } from "zod";
 var THEME_PRESETS = {
   light: {
     general: {
@@ -2990,7 +3232,7 @@ var ACCESS_PRESETS = {
     metricCreationMode: "CHAT"
   }
 };
-var fontFamilyEnum = z16.enum([
+var fontFamilyEnum = z18.enum([
   "Inter",
   "Roboto",
   "Open Sans",
@@ -3002,17 +3244,17 @@ var fontFamilyEnum = z16.enum([
   "Nunito",
   "system-ui"
 ]).describe("Font family");
-var tooltipFontSchema = z16.object({
-  fontFamily: z16.string().optional(),
-  fontSize: z16.number().optional(),
-  fontWeight: z16.number().optional(),
-  fontColor: z16.string().optional()
+var tooltipFontSchema = z18.object({
+  fontFamily: z18.string().optional(),
+  fontSize: z18.number().optional(),
+  fontWeight: z18.number().optional(),
+  fontColor: z18.string().optional()
 }).optional();
-var fontConfigInputSchema = z16.object({
-  fontSize: z16.number().optional(),
-  fontFamily: z16.string().optional(),
-  fontWeight: z16.number().optional(),
-  color: z16.string().optional()
+var fontConfigInputSchema = z18.object({
+  fontSize: z18.number().optional(),
+  fontFamily: z18.string().optional(),
+  fontWeight: z18.number().optional(),
+  color: z18.string().optional()
 }).optional();
 function mapToFrontendFontConfig(input) {
   if (!input) return void 0;
@@ -3023,23 +3265,23 @@ function mapToFrontendFontConfig(input) {
     ...input.color && { color: input.color }
   };
 }
-var axisSchema = z16.object({
-  hideAxisLines: z16.boolean().optional().describe("Hide axis lines"),
-  hideSplitLines: z16.boolean().optional().describe("Hide grid/split lines"),
-  hideAxisLabels: z16.boolean().optional().describe("Hide axis labels"),
-  hideAxisTicks: z16.boolean().optional().describe("Hide axis tick marks"),
-  axisName: z16.string().optional().describe("Axis title text"),
-  axisNameOffset: z16.number().optional().describe("Axis title offset from axis"),
-  axisLabelMargin: z16.number().optional().describe("Margin between axis labels and chart area in pixels"),
-  fontSize: z16.number().optional().describe("Axis label font size"),
-  fontFamily: z16.string().optional().describe("Axis label font family"),
-  fontWeight: z16.number().optional().describe("Axis label font weight"),
-  color: z16.string().optional().describe("Axis label color (hex)"),
-  axisColor: z16.string().optional().describe("Axis line color (hex)"),
-  axisNameFontConfig: z16.object({
-    fontFamily: z16.string().optional(),
-    fontSize: z16.number().optional(),
-    fontWeight: z16.number().optional()
+var axisSchema = z18.object({
+  hideAxisLines: z18.boolean().optional().describe("Hide axis lines"),
+  hideSplitLines: z18.boolean().optional().describe("Hide grid/split lines"),
+  hideAxisLabels: z18.boolean().optional().describe("Hide axis labels"),
+  hideAxisTicks: z18.boolean().optional().describe("Hide axis tick marks"),
+  axisName: z18.string().optional().describe("Axis title text"),
+  axisNameOffset: z18.number().optional().describe("Axis title offset from axis"),
+  axisLabelMargin: z18.number().optional().describe("Margin between axis labels and chart area in pixels"),
+  fontSize: z18.number().optional().describe("Axis label font size"),
+  fontFamily: z18.string().optional().describe("Axis label font family"),
+  fontWeight: z18.number().optional().describe("Axis label font weight"),
+  color: z18.string().optional().describe("Axis label color (hex)"),
+  axisColor: z18.string().optional().describe("Axis line color (hex)"),
+  axisNameFontConfig: z18.object({
+    fontFamily: z18.string().optional(),
+    fontSize: z18.number().optional(),
+    fontWeight: z18.number().optional()
   }).optional().describe("Axis title font configuration")
 }).optional();
 function buildAdminTheme(p, presetBase) {
@@ -3195,94 +3437,95 @@ function registerCustomizeTheme(server, client) {
     "customize_embed_theme",
     `Theme an embed: presets (${Object.keys(THEME_PRESETS).join("/")}), colors, fonts, cards, chart appearance, responsive layout, or access presets (${Object.keys(ACCESS_PRESETS).join("/")}).`,
     {
-      embedId: z16.string().describe("ID of the embed to theme"),
-      body: z16.record(z16.unknown()).optional().describe(
+      embedId: z18.string().describe("ID of the embed to theme"),
+      dataAppName: z18.string().trim().min(1).optional().describe("Data app when this embed ID belongs to several apps"),
+      body: z18.record(z18.unknown()).optional().describe(
         "Raw API body for PUT /api/v2/data-app/embeds. If provided, sent directly and all convenience fields are ignored."
       ),
       // --- Presets ---
-      themePreset: z16.enum(["light", "dark", "corporate", "minimal"]).optional().describe("Apply a theme preset as the base. Granular params below override preset values."),
-      accessPreset: z16.enum(["view-only", "power-user", "export-only", "ai-enabled"]).optional().describe("Apply an access settings preset"),
+      themePreset: z18.enum(["light", "dark", "corporate", "minimal"]).optional().describe("Apply a theme preset as the base. Granular params below override preset values."),
+      accessPreset: z18.enum(["view-only", "power-user", "export-only", "ai-enabled"]).optional().describe("Apply an access settings preset"),
       // --- General ---
       fontFamily: fontFamilyEnum.optional().describe("Global font family"),
-      datePickerFormat: z16.string().optional().describe("Date picker display format"),
+      datePickerFormat: z18.string().optional().describe("Date picker display format"),
       // --- Colors ---
-      primaryColor: z16.string().optional().describe("Primary accent color (hex)"),
-      backgroundColor: z16.string().optional().describe("Overall background color (hex)"),
-      textColor: z16.string().optional().describe("Default text color (hex)"),
-      ctaColor: z16.string().optional().describe("Call-to-action button color (hex)"),
-      ctaTextColor: z16.string().optional().describe("CTA button text color (hex)"),
+      primaryColor: z18.string().optional().describe("Primary accent color (hex)"),
+      backgroundColor: z18.string().optional().describe("Overall background color (hex)"),
+      textColor: z18.string().optional().describe("Default text color (hex)"),
+      ctaColor: z18.string().optional().describe("Call-to-action button color (hex)"),
+      ctaTextColor: z18.string().optional().describe("CTA button text color (hex)"),
       // --- Dashboard ---
-      dashboardBackgroundColor: z16.string().optional().describe("Dashboard container background (hex)"),
-      selectBoxSize: z16.enum(["small", "medium", "large"]).optional().describe("Filter select box size"),
-      selectBoxVariant: z16.enum(["floating", "outlined", "standard"]).optional().describe("Filter select box style"),
-      selectBoxBorderRadius: z16.string().optional().describe('Select box border radius (e.g. "20px")'),
-      selectBoxTextColor: z16.string().optional().describe("Select box text color (hex)"),
-      metricCardColor: z16.string().optional().describe("Metric card background color (hex)"),
+      dashboardBackgroundColor: z18.string().optional().describe("Dashboard container background (hex)"),
+      selectBoxSize: z18.enum(["small", "medium", "large"]).optional().describe("Filter select box size"),
+      selectBoxVariant: z18.enum(["floating", "outlined", "standard"]).optional().describe("Filter select box style"),
+      selectBoxBorderRadius: z18.string().optional().describe('Select box border radius (e.g. "20px")'),
+      selectBoxTextColor: z18.string().optional().describe("Select box text color (hex)"),
+      metricCardColor: z18.string().optional().describe("Metric card background color (hex)"),
       // --- Card Title ---
-      cardTitleFontSize: z16.string().optional().describe('Card title font size (e.g. "16px")'),
-      cardTitleFontWeight: z16.string().optional().describe('Card title font weight (e.g. "600")'),
-      cardTitleColor: z16.string().optional().describe("Card title text color (hex)"),
+      cardTitleFontSize: z18.string().optional().describe('Card title font size (e.g. "16px")'),
+      cardTitleFontWeight: z18.string().optional().describe('Card title font weight (e.g. "600")'),
+      cardTitleColor: z18.string().optional().describe("Card title text color (hex)"),
       // --- Card Description ---
-      cardDescriptionFontSize: z16.string().optional().describe("Card description font size"),
-      cardDescriptionFontWeight: z16.string().optional().describe("Card description font weight"),
-      cardDescriptionColor: z16.string().optional().describe("Card description text color (hex)"),
+      cardDescriptionFontSize: z18.string().optional().describe("Card description font size"),
+      cardDescriptionFontWeight: z18.string().optional().describe("Card description font weight"),
+      cardDescriptionColor: z18.string().optional().describe("Card description text color (hex)"),
       // --- Card Customization ---
-      cardPadding: z16.string().optional().describe("Card internal padding"),
-      cardBorderRadius: z16.string().optional().describe("Card border radius"),
-      cardShadow: z16.string().optional().describe("Card box-shadow CSS value"),
-      disableShadowOnHover: z16.boolean().optional().describe("Disable shadow on card hover"),
-      disableCardStroke: z16.boolean().optional().describe("Remove card border stroke"),
-      cardStrokeColor: z16.string().optional().describe("Card border stroke color (hex)"),
+      cardPadding: z18.string().optional().describe("Card internal padding"),
+      cardBorderRadius: z18.string().optional().describe("Card border radius"),
+      cardShadow: z18.string().optional().describe("Card box-shadow CSS value"),
+      disableShadowOnHover: z18.boolean().optional().describe("Disable shadow on card hover"),
+      disableCardStroke: z18.boolean().optional().describe("Remove card border stroke"),
+      cardStrokeColor: z18.string().optional().describe("Card border stroke color (hex)"),
       // --- Chart Colors (admin theme level) ---
-      chartFontFamily: z16.string().optional().describe("Font family for chart text"),
-      chartFontColor: z16.string().optional().describe("Font color for chart text (hex)"),
-      chartColors: z16.array(z16.string()).optional().describe("Array of chart series colors (hex)"),
-      chartPaletteName: z16.string().optional().describe("Name for a custom palette"),
-      chartPaletteColors: z16.array(z16.string()).optional().describe("9 colors for a custom palette"),
+      chartFontFamily: z18.string().optional().describe("Font family for chart text"),
+      chartFontColor: z18.string().optional().describe("Font color for chart text (hex)"),
+      chartColors: z18.array(z18.string()).optional().describe("Array of chart series colors (hex)"),
+      chartPaletteName: z18.string().optional().describe("Name for a custom palette"),
+      chartPaletteColors: z18.array(z18.string()).optional().describe("9 colors for a custom palette"),
       // --- Chart Tooltip (admin theme level) ---
       tooltipHeader: tooltipFontSchema.describe("Tooltip header font config"),
       tooltipLabel: tooltipFontSchema.describe("Tooltip label font config"),
       tooltipValue: tooltipFontSchema.describe("Tooltip value font config"),
       // --- Component Theme ---
-      buttonPrimaryColor: z16.string().optional().describe("Primary button background (hex)"),
-      buttonPrimaryTextColor: z16.string().optional().describe("Primary button text (hex)"),
-      buttonSecondaryColor: z16.string().optional().describe("Secondary button background (hex)"),
-      buttonSecondaryTextColor: z16.string().optional().describe("Secondary button text (hex)"),
-      checkboxCheckedColor: z16.string().optional().describe("Checked checkbox color (hex)"),
-      checkboxUncheckedColor: z16.string().optional().describe("Unchecked checkbox color (hex)"),
-      switchEnabledColor: z16.string().optional().describe("Enabled switch color (hex)"),
-      switchDisabledColor: z16.string().optional().describe("Disabled switch color (hex)"),
-      breadcrumbFontFamily: z16.string().optional().describe("Drill breadcrumb font family"),
-      breadcrumbFontColor: z16.string().optional().describe("Drill breadcrumb font color (hex)"),
-      breadcrumbActiveColor: z16.string().optional().describe("Active breadcrumb color (hex)"),
-      filterBadgeColor: z16.string().optional().describe("Multi-select filter badge color (hex)"),
-      filterBadgeTextColor: z16.string().optional().describe("Filter badge text color (hex)"),
-      datePickerColor: z16.string().optional().describe("Date picker accent color (hex)"),
+      buttonPrimaryColor: z18.string().optional().describe("Primary button background (hex)"),
+      buttonPrimaryTextColor: z18.string().optional().describe("Primary button text (hex)"),
+      buttonSecondaryColor: z18.string().optional().describe("Secondary button background (hex)"),
+      buttonSecondaryTextColor: z18.string().optional().describe("Secondary button text (hex)"),
+      checkboxCheckedColor: z18.string().optional().describe("Checked checkbox color (hex)"),
+      checkboxUncheckedColor: z18.string().optional().describe("Unchecked checkbox color (hex)"),
+      switchEnabledColor: z18.string().optional().describe("Enabled switch color (hex)"),
+      switchDisabledColor: z18.string().optional().describe("Disabled switch color (hex)"),
+      breadcrumbFontFamily: z18.string().optional().describe("Drill breadcrumb font family"),
+      breadcrumbFontColor: z18.string().optional().describe("Drill breadcrumb font color (hex)"),
+      breadcrumbActiveColor: z18.string().optional().describe("Active breadcrumb color (hex)"),
+      filterBadgeColor: z18.string().optional().describe("Multi-select filter badge color (hex)"),
+      filterBadgeTextColor: z18.string().optional().describe("Filter badge text color (hex)"),
+      datePickerColor: z18.string().optional().describe("Date picker accent color (hex)"),
       // --- Responsive Breakpoints ---
-      breakpointXl: z16.number().optional().describe("XL breakpoint width in px"),
-      breakpointLg: z16.number().optional().describe("LG breakpoint width in px"),
-      breakpointMd: z16.number().optional().describe("MD breakpoint width in px"),
-      breakpointSm: z16.number().optional().describe("SM breakpoint width in px"),
-      breakpointXs: z16.number().optional().describe("XS breakpoint width in px"),
+      breakpointXl: z18.number().optional().describe("XL breakpoint width in px"),
+      breakpointLg: z18.number().optional().describe("LG breakpoint width in px"),
+      breakpointMd: z18.number().optional().describe("MD breakpoint width in px"),
+      breakpointSm: z18.number().optional().describe("SM breakpoint width in px"),
+      breakpointXs: z18.number().optional().describe("XS breakpoint width in px"),
       // --- Metric Layout Columns ---
-      layoutColsXl: z16.number().optional().describe("Grid columns at XL breakpoint"),
-      layoutColsLg: z16.number().optional().describe("Grid columns at LG breakpoint"),
-      layoutColsMd: z16.number().optional().describe("Grid columns at MD breakpoint"),
-      layoutColsSm: z16.number().optional().describe("Grid columns at SM breakpoint"),
-      layoutColsXs: z16.number().optional().describe("Grid columns at XS breakpoint"),
-      layoutColsXxs: z16.number().optional().describe("Grid columns at XXS breakpoint"),
+      layoutColsXl: z18.number().optional().describe("Grid columns at XL breakpoint"),
+      layoutColsLg: z18.number().optional().describe("Grid columns at LG breakpoint"),
+      layoutColsMd: z18.number().optional().describe("Grid columns at MD breakpoint"),
+      layoutColsSm: z18.number().optional().describe("Grid columns at SM breakpoint"),
+      layoutColsXs: z18.number().optional().describe("Grid columns at XS breakpoint"),
+      layoutColsXxs: z18.number().optional().describe("Grid columns at XXS breakpoint"),
       // --- Chart Appearance (detailed) ---
       tooltipHeaderStyle: fontConfigInputSchema.describe("Tooltip header: fontSize, fontFamily, fontWeight, color"),
       tooltipLabelStyle: fontConfigInputSchema.describe("Tooltip label: fontSize, fontFamily, fontWeight, color"),
       tooltipValueStyle: fontConfigInputSchema.describe("Tooltip value: fontSize, fontFamily, fontWeight, color"),
-      labelPosition: z16.enum(["hidden", "top", "left", "right", "bottom", "inside"]).optional().describe("Data label position on charts"),
-      radialLabelPosition: z16.enum(["outside", "inside"]).optional().describe("Label position for radial/pie charts"),
-      marginTop: z16.number().optional().describe("Chart top margin in pixels"),
-      marginLeft: z16.number().optional().describe("Chart left margin in pixels"),
-      marginRight: z16.number().optional().describe("Chart right margin in pixels"),
-      marginBottom: z16.number().optional().describe("Chart bottom margin in pixels"),
-      legendShow: z16.boolean().optional().describe("Show or hide chart legend"),
-      legendPosition: z16.enum([
+      labelPosition: z18.enum(["hidden", "top", "left", "right", "bottom", "inside"]).optional().describe("Data label position on charts"),
+      radialLabelPosition: z18.enum(["outside", "inside"]).optional().describe("Label position for radial/pie charts"),
+      marginTop: z18.number().optional().describe("Chart top margin in pixels"),
+      marginLeft: z18.number().optional().describe("Chart left margin in pixels"),
+      marginRight: z18.number().optional().describe("Chart right margin in pixels"),
+      marginBottom: z18.number().optional().describe("Chart bottom margin in pixels"),
+      legendShow: z18.boolean().optional().describe("Show or hide chart legend"),
+      legendPosition: z18.enum([
         "top-left",
         "top-center",
         "top-right",
@@ -3292,27 +3535,28 @@ function registerCustomizeTheme(server, client) {
         "bottom-center",
         "bottom-right"
       ]).optional().describe("Legend position"),
-      legendLayout: z16.enum(["horizontal", "vertical"]).optional().describe("Legend layout direction"),
-      legendShape: z16.enum(["circle", "rect", "roundRect", "triangle", "diamond", "arrow", "none"]).optional().describe("Legend icon shape"),
-      legendFontSize: z16.number().optional().describe("Legend font size"),
-      legendFontWeight: z16.number().optional().describe("Legend font weight"),
-      legendFontFamily: z16.string().optional().describe("Legend font family"),
-      legendColor: z16.string().optional().describe("Legend text color (hex)"),
-      legendTruncateLength: z16.number().optional().describe("Max characters before truncating legend"),
-      disableLegendScrolling: z16.boolean().optional().describe("Disable scrolling in legend"),
-      enableVariableLegendPosition: z16.boolean().optional().describe("Allow user to drag legend"),
-      legendTop: z16.number().optional().describe("Custom legend top offset"),
-      legendLeft: z16.number().optional().describe("Custom legend left offset"),
+      legendLayout: z18.enum(["horizontal", "vertical"]).optional().describe("Legend layout direction"),
+      legendShape: z18.enum(["circle", "rect", "roundRect", "triangle", "diamond", "arrow", "none"]).optional().describe("Legend icon shape"),
+      legendFontSize: z18.number().optional().describe("Legend font size"),
+      legendFontWeight: z18.number().optional().describe("Legend font weight"),
+      legendFontFamily: z18.string().optional().describe("Legend font family"),
+      legendColor: z18.string().optional().describe("Legend text color (hex)"),
+      legendTruncateLength: z18.number().optional().describe("Max characters before truncating legend"),
+      disableLegendScrolling: z18.boolean().optional().describe("Disable scrolling in legend"),
+      enableVariableLegendPosition: z18.boolean().optional().describe("Allow user to drag legend"),
+      legendTop: z18.number().optional().describe("Custom legend top offset"),
+      legendLeft: z18.number().optional().describe("Custom legend left offset"),
       verticalAxis: axisSchema.describe("Vertical (Y) axis configuration"),
       horizontalAxis: axisSchema.describe("Horizontal (X) axis configuration")
     },
     WRITE_IDEMPOTENT,
     async (params) => {
-      const { embedId, body, themePreset, accessPreset, ...themeParams } = params;
+      const { embedId, dataAppName, body, themePreset, accessPreset, ...themeParams } = params;
       if (body) {
         try {
           const rawBody = { ...body };
           if (!rawBody.embedId) rawBody.embedId = embedId;
+          if (dataAppName) rawBody.dataAppName = dataAppName;
           const result = await services.embedsApi.updateEmbed(rawBody);
           if (result.error) {
             return toolError(`Theme update failed: ${stringify(result.error)}`);
@@ -3345,7 +3589,7 @@ function registerCustomizeTheme(server, client) {
         return toolError("No theme properties provided. Specify at least one property, or use a themePreset.");
       }
       try {
-        const result = await services.embedService.updateEmbed(embedId, patch);
+        const result = await services.embedService.updateEmbed(embedId, patch, dataAppName);
         if (result.error) {
           return toolError(`Theme update failed: ${stringify(result.error)}`);
         }
@@ -3377,7 +3621,7 @@ Use \`get_embed_details\` to view the full current theme configuration.` + GUEST
 }
 
 // src/tools/embed/get-demo-link.ts
-import { z as z17 } from "zod";
+import { z as z19 } from "zod";
 var HOUR_MS = 60 * 60 * 1e3;
 var DEFAULT_EXPIRY_HOURS = 24;
 var MAX_EXPIRY_HOURS = 24 * 30;
@@ -3387,11 +3631,12 @@ function registerGetDemoLink(server, client) {
     "get_demo_link",
     `Get a shareable demo URL for a dashboard embed scoped to a specific clientId \u2014 same link the UI's "Share Demo Link" generates. Loads the dashboard as that end-customer sees it. Use to verify ops-built widgets without a test app.`,
     {
-      clientId: z17.string().describe("End-customer identifier to scope the preview to."),
-      dashboardName: z17.string().optional().describe("Dashboard name (non-technical). Preferred \u2014 pass with optional `workspaceName`."),
-      workspaceName: z17.string().optional().describe("Workspace name. Only needed if `dashboardName` is ambiguous."),
-      embedId: z17.string().optional().describe("Technical alternative to `dashboardName`."),
-      expiryHours: z17.number().min(1).max(MAX_EXPIRY_HOURS).optional().describe(`Token TTL in hours. Defaults to ${DEFAULT_EXPIRY_HOURS}. Max ${MAX_EXPIRY_HOURS} (30 days).`)
+      clientId: z19.string().describe("End-customer identifier to scope the preview to."),
+      dashboardName: z19.string().optional().describe("Dashboard name (non-technical). Preferred \u2014 pass with optional `workspaceName`."),
+      workspaceName: z19.string().optional().describe("Workspace name. Only needed if `dashboardName` is ambiguous."),
+      dataAppName: z19.string().trim().min(1).optional().describe("Data app name when dashboard embeds span several apps"),
+      embedId: z19.string().optional().describe("Technical alternative to `dashboardName`."),
+      expiryHours: z19.number().min(1).max(MAX_EXPIRY_HOURS).optional().describe(`Token TTL in hours. Defaults to ${DEFAULT_EXPIRY_HOURS}. Max ${MAX_EXPIRY_HOURS} (30 days).`)
     },
     WRITE_CREATE,
     async (params) => {
@@ -3400,12 +3645,13 @@ function registerGetDemoLink(server, client) {
           embedId: params.embedId,
           dashboardName: params.dashboardName,
           workspaceName: params.workspaceName,
+          dataAppName: params.dataAppName,
           required: true
         });
         if (!embed.ok) return toolError(embed.error);
         const embedId = embed.value.embedId;
         const dashboardName = embed.value.resolvedFrom?.dashboardName || null;
-        const ctx = await services.widgetService.resolveEmbedContext(embedId);
+        const ctx = await services.widgetService.resolveEmbedContext(embedId, params.dataAppName);
         if (!ctx.dataAppName) {
           return toolError(
             `Could not resolve the data app for embed "${embedId}". The demo link needs a data app to mint a guest token against. Run \`list_data_apps\` to confirm one exists, or pass \`embedId\` for an embed with metadata.dataAppName populated.`
@@ -3447,70 +3693,70 @@ function registerGetDemoLink(server, client) {
 }
 
 // src/tools/frontend/generate-guest-token.ts
-import { z as z18 } from "zod";
+import { z as z20 } from "zod";
 function registerGenerateGuestToken(server, client) {
   const services = createServiceBundle(client);
   server.tool(
     "generate_guest_token",
     "Generate a guest token for frontend embedding. Requires clientId. Omit dataAppName to auto-resolve.",
     {
-      clientId: z18.string().describe('Unique end-user identifier for multi-tenant filtering. Use "None" if no tenancy.'),
-      dataAppName: z18.string().optional().describe("Name of the data app. Omit to list available data apps."),
-      body: z18.record(z18.unknown()).optional().describe(
+      clientId: z20.string().describe('Unique end-user identifier for multi-tenant filtering. Use "None" if no tenancy.'),
+      dataAppName: z20.string().optional().describe("Name of the data app. Omit to list available data apps."),
+      body: z20.record(z20.unknown()).optional().describe(
         "Raw API body for POST /api/v2/guest-token/create. If provided, sent directly and convenience fields are ignored."
       ),
-      params: z18.object({
-        allowedEmbeds: z18.array(z18.string()).optional().describe("Restrict token to specific embed IDs"),
-        rlsSettings: z18.array(z18.object({
-          metricId: z18.string().describe("Metric ID"),
-          values: z18.record(z18.unknown()).describe("RLS values by column name")
+      params: z20.object({
+        allowedEmbeds: z20.array(z20.string()).optional().describe("Restrict token to specific embed IDs"),
+        rlsSettings: z20.array(z20.object({
+          metricId: z20.string().describe("Metric ID"),
+          values: z20.record(z20.unknown()).describe("RLS values by column name")
         })).optional().describe("Legacy alias used in docs/examples; forwarded as params.rlsSettings"),
-        appFilters: z18.array(z18.object({
-          metricId: z18.string().describe("Metric ID"),
-          values: z18.record(z18.unknown()).describe("Filter values by column name")
+        appFilters: z20.array(z20.object({
+          metricId: z20.string().describe("Metric ID"),
+          values: z20.record(z20.unknown()).describe("Filter values by column name")
         })).optional().describe("Metric-level app filters"),
-        dashboardAppFilters: z18.array(z18.object({
-          dashboardId: z18.string().describe("Dashboard ID"),
-          values: z18.record(z18.unknown()).describe("Filter values by dashboard filter name"),
-          isShowOnUrl: z18.boolean().optional().describe("Whether filters are shown in URL params")
+        dashboardAppFilters: z20.array(z20.object({
+          dashboardId: z20.string().describe("Dashboard ID"),
+          values: z20.record(z20.unknown()).describe("Filter values by dashboard filter name"),
+          isShowOnUrl: z20.boolean().optional().describe("Whether filters are shown in URL params")
         })).optional().describe("Dashboard-level app filters"),
-        hideDashboardFilters: z18.array(z18.string()).optional().describe("Dashboard filter names to hide"),
-        userIdentifier: z18.string().optional().describe("End-user identifier for private metrics support"),
-        timezone: z18.string().optional().describe('IANA timezone, e.g. "America/New_York"')
+        hideDashboardFilters: z20.array(z20.string()).optional().describe("Dashboard filter names to hide"),
+        userIdentifier: z20.string().optional().describe("End-user identifier for private metrics support"),
+        timezone: z20.string().optional().describe('IANA timezone, e.g. "America/New_York"')
       }).optional().describe("Advanced token params"),
       // Legacy convenience fields (auto-mapped into params for backward compatibility)
-      timezone: z18.string().optional().describe("Legacy: moved under params.timezone"),
-      allowedEmbeds: z18.array(z18.string()).optional().describe("Legacy: moved under params.allowedEmbeds"),
-      rlsSettings: z18.array(z18.object({
-        metricId: z18.string().describe("Metric ID"),
-        values: z18.record(z18.unknown()).describe("RLS values by column name")
+      timezone: z20.string().optional().describe("Legacy: moved under params.timezone"),
+      allowedEmbeds: z20.array(z20.string()).optional().describe("Legacy: moved under params.allowedEmbeds"),
+      rlsSettings: z20.array(z20.object({
+        metricId: z20.string().describe("Metric ID"),
+        values: z20.record(z20.unknown()).describe("RLS values by column name")
       })).optional().describe("Legacy: moved under params.rlsSettings"),
-      appFilters: z18.array(z18.object({
-        metricId: z18.string().describe("Metric ID"),
-        values: z18.record(z18.unknown()).describe("Filter values by column name")
+      appFilters: z20.array(z20.object({
+        metricId: z20.string().describe("Metric ID"),
+        values: z20.record(z20.unknown()).describe("Filter values by column name")
       })).optional().describe("Legacy: moved under params.appFilters"),
-      dashboardAppFilters: z18.array(z18.object({
-        dashboardId: z18.string().describe("Dashboard ID to apply filters to"),
-        values: z18.record(z18.unknown()).describe("Filter values for this dashboard"),
-        isShowOnUrl: z18.boolean().optional().describe("Whether filters are shown in URL params")
+      dashboardAppFilters: z20.array(z20.object({
+        dashboardId: z20.string().describe("Dashboard ID to apply filters to"),
+        values: z20.record(z20.unknown()).describe("Filter values for this dashboard"),
+        isShowOnUrl: z20.boolean().optional().describe("Whether filters are shown in URL params")
       })).optional().describe("Legacy: moved under params.dashboardAppFilters"),
-      permissions: z18.object({
-        isEnableArchiveMetrics: z18.boolean().optional(),
-        isEnableManageMetrics: z18.boolean().optional(),
-        isEnableCreateDashboardView: z18.boolean().optional(),
-        isEnableMetricUpdation: z18.boolean().optional(),
-        isEnableCustomizeLayout: z18.boolean().optional(),
-        isEnableUnderlyingData: z18.boolean().optional(),
-        isEnableDownloadMetrics: z18.boolean().optional(),
-        isShowSideBar: z18.boolean().optional(),
-        isShowDashboardName: z18.boolean().optional(),
-        isDisableMetricCreation: z18.boolean().optional()
+      permissions: z20.object({
+        isEnableArchiveMetrics: z20.boolean().optional(),
+        isEnableManageMetrics: z20.boolean().optional(),
+        isEnableCreateDashboardView: z20.boolean().optional(),
+        isEnableMetricUpdation: z20.boolean().optional(),
+        isEnableCustomizeLayout: z20.boolean().optional(),
+        isEnableUnderlyingData: z20.boolean().optional(),
+        isEnableDownloadMetrics: z20.boolean().optional(),
+        isShowSideBar: z20.boolean().optional(),
+        isShowDashboardName: z20.boolean().optional(),
+        isDisableMetricCreation: z20.boolean().optional()
       }).optional().describe("Runtime permission overrides (merge with and override embed-level settings)"),
-      theme: z18.record(z18.unknown()).optional().describe("Runtime theme overrides (overrides embed-level theme)"),
-      hideDashboardFilters: z18.array(z18.string()).optional().describe("Legacy: moved under params.hideDashboardFilters"),
-      userIdentifier: z18.string().optional().describe("Legacy: moved under params.userIdentifier"),
-      expiryTime: z18.number().optional().describe("Token TTL in milliseconds"),
-      datasourceName: z18.string().optional().describe("Datasource name for multi-datasource routing")
+      theme: z20.record(z20.unknown()).optional().describe("Runtime theme overrides (overrides embed-level theme)"),
+      hideDashboardFilters: z20.array(z20.string()).optional().describe("Legacy: moved under params.hideDashboardFilters"),
+      userIdentifier: z20.string().optional().describe("Legacy: moved under params.userIdentifier"),
+      expiryTime: z20.number().optional().describe("Token TTL in milliseconds"),
+      datasourceName: z20.string().optional().describe("Datasource name for multi-datasource routing")
     },
     WRITE_CREATE,
     async (params) => {
@@ -3563,7 +3809,7 @@ Next step: Use \`generate_embed_code\` to get copy-paste-ready frontend code.`
 }
 
 // src/tools/frontend/generate-embed-code.ts
-import { z as z19 } from "zod";
+import { z as z21 } from "zod";
 
 // src/templates/react.ts
 function kebabCase(str) {
@@ -4559,22 +4805,22 @@ function registerGenerateEmbedCode(server, _client) {
     "generate_embed_code",
     "Generate framework-specific embed code (React, Next.js, Vue, Angular, Svelte, SolidJS, vanilla HTML).",
     {
-      embedId: z19.string().describe("The embed ID to generate code for"),
-      framework: z19.enum(FRAMEWORKS).describe("Frontend framework"),
-      embedType: z19.enum(["dashboard", "metric"]).optional().default("dashboard"),
-      options: z19.object({
-        enableDownloadCsv: z19.boolean().optional(),
-        enableEmailCsv: z19.boolean().optional(),
-        enableDownloadAllMetrics: z19.boolean().optional(),
-        enableDownloadAllPdf: z19.boolean().optional(),
-        disableFullscreen: z19.boolean().optional(),
-        isHideTablePreview: z19.boolean().optional(),
-        isHideChartSettings: z19.boolean().optional(),
-        isStickyDashboardFilters: z19.boolean().optional(),
-        enableMultiMetricFilters: z19.boolean().optional(),
-        themeName: z19.string().optional(),
-        customTheme: z19.record(z19.unknown()).optional(),
-        optionsIcon: z19.enum(["kebab-menu-vertical", "download"]).optional()
+      embedId: z21.string().describe("The embed ID to generate code for"),
+      framework: z21.enum(FRAMEWORKS).describe("Frontend framework"),
+      embedType: z21.enum(["dashboard", "metric"]).optional().default("dashboard"),
+      options: z21.object({
+        enableDownloadCsv: z21.boolean().optional(),
+        enableEmailCsv: z21.boolean().optional(),
+        enableDownloadAllMetrics: z21.boolean().optional(),
+        enableDownloadAllPdf: z21.boolean().optional(),
+        disableFullscreen: z21.boolean().optional(),
+        isHideTablePreview: z21.boolean().optional(),
+        isHideChartSettings: z21.boolean().optional(),
+        isStickyDashboardFilters: z21.boolean().optional(),
+        enableMultiMetricFilters: z21.boolean().optional(),
+        themeName: z21.string().optional(),
+        customTheme: z21.record(z21.unknown()).optional(),
+        optionsIcon: z21.enum(["kebab-menu-vertical", "download"]).optional()
       }).optional()
     },
     READ_ONLY,
@@ -4614,17 +4860,17 @@ ${generated.instructions}`;
 }
 
 // src/tools/analytics/list-dashboards.ts
-import { z as z20 } from "zod";
+import { z as z22 } from "zod";
 function registerListDashboards(server, client) {
   const services = createServiceBundle(client);
   server.tool(
     "list_dashboards",
     "List dashboards globally or for a specific data app.",
     {
-      scope: z20.enum(["auto", "global", "data_app"]).optional().describe(
+      scope: z22.enum(["auto", "global", "data_app"]).optional().describe(
         "Dashboard listing scope. auto: use data_app when dataAppName + API token are available, otherwise global."
       ),
-      dataAppName: z20.string().optional().describe("Data app name for data_app scope. Ignored for global scope.")
+      dataAppName: z22.string().optional().describe("Data app name for data_app scope. Ignored for global scope.")
     },
     READ_ONLY,
     async (params) => {
@@ -4641,9 +4887,11 @@ function registerListDashboards(server, client) {
           count: result.length,
           scope: useDataAppScope ? "data_app" : "global",
           dashboards: result.map((d) => {
-            const { name, dashboardId, workspaceName, metricCount } = services.discoveryService.normalizeDashboard(d);
+            const { name, dashboardId, externalDashboardId, workspaceName, metricCount } = services.discoveryService.normalizeDashboard(d);
             return {
               id: dashboardId || null,
+              dashboardId,
+              externalDashboardId,
               name,
               workspace: workspaceName || null,
               metricCount: metricCount ?? null
@@ -4659,36 +4907,36 @@ function registerListDashboards(server, client) {
 }
 
 // src/tools/dashboard/schema.ts
-import { z as z21 } from "zod";
-var dashboardPositionSchema = z21.object({
-  x: z21.number().int().min(0).max(23),
-  y: z21.number().int().min(0),
-  w: z21.number().int().min(1).max(24),
-  h: z21.number().int().min(1).max(40)
+import { z as z23 } from "zod";
+var dashboardPositionSchema = z23.object({
+  x: z23.number().int().min(0).max(23),
+  y: z23.number().int().min(0),
+  w: z23.number().int().min(1).max(24),
+  h: z23.number().int().min(1).max(40)
 }).strict();
-var dashboardChartSchema = z21.object({
-  type: z21.string(),
-  metricRef: z21.string().optional(),
-  query: z21.string().optional(),
-  companyIntegrationId: z21.string().optional(),
-  chartOptions: z21.record(z21.unknown()).optional()
+var dashboardChartSchema = z23.object({
+  type: z23.string(),
+  metricRef: z23.string().optional(),
+  query: z23.string().optional(),
+  companyIntegrationId: z23.string().optional(),
+  chartOptions: z23.record(z23.unknown()).optional()
 }).passthrough();
-var dashboardTileSchema = z21.object({
-  id: z21.string().regex(/^[a-z0-9][a-z0-9-]{0,62}$/),
-  kind: z21.literal("databrain-chart"),
+var dashboardTileSchema = z23.object({
+  id: z23.string().regex(/^[a-z0-9][a-z0-9-]{0,62}$/),
+  kind: z23.literal("databrain-chart"),
   position: dashboardPositionSchema,
-  title: z21.string().min(1).max(200),
+  title: z23.string().min(1).max(200),
   chart: dashboardChartSchema.optional()
 }).strict();
 var dashboardDocumentShape = {
-  schemaVersion: z21.literal(1),
-  title: z21.string().min(1).max(200),
-  description: z21.string().max(2e3).optional(),
-  layout: z21.object({ columns: z21.union([z21.literal(12), z21.literal(24)]).default(24) }).strict().optional(),
-  tiles: z21.array(dashboardTileSchema).min(1).max(50)
+  schemaVersion: z23.literal(1),
+  title: z23.string().min(1).max(200),
+  description: z23.string().max(2e3).optional(),
+  layout: z23.object({ columns: z23.union([z23.literal(12), z23.literal(24)]).default(24) }).strict().optional(),
+  tiles: z23.array(dashboardTileSchema).min(1).max(50)
 };
-var workspaceNameSchema = z21.string().min(1).describe("Target workspace name");
-var idempotencyKeySchema = z21.string().regex(
+var workspaceNameSchema = z23.string().min(1).describe("Target workspace name");
+var idempotencyKeySchema = z23.string().regex(
   /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
   "idempotencyKey must be a UUID v4"
 ).describe("UUID v4 unique to this workspace dashboard create request");
@@ -4741,7 +4989,7 @@ ${stringify(validation)}`
 }
 
 // src/tools/dashboard/generate-dashboard-tiles.ts
-import { z as z22 } from "zod";
+import { z as z24 } from "zod";
 function registerGenerateDashboardTiles(server, client) {
   const services = createServiceBundle(client);
   server.tool(
@@ -4749,15 +4997,16 @@ function registerGenerateDashboardTiles(server, client) {
     "Generate multiple workspace dashboard tile drafts without persisting them.",
     {
       workspaceName: workspaceNameSchema,
-      dataAppName: z22.string().optional().describe("Data app in the workspace; auto-resolved when unique"),
-      integrationId: z22.string().optional().describe("Datasource UUID override"),
-      integrationName: z22.string().optional().describe("Datasource name override"),
-      tiles: z22.array(
-        z22.object({
-          id: z22.string().regex(/^[a-z0-9][a-z0-9-]{0,62}$/),
-          title: z22.string().min(1).max(200),
+      clientId: z24.string().trim().min(1).describe("Tenant client identifier in this data app; use list_tenants to choose it"),
+      dataAppName: z24.string().optional().describe("Data app in the workspace; auto-resolved when unique"),
+      integrationId: z24.string().optional().describe("Datasource UUID override"),
+      integrationName: z24.string().optional().describe("Datasource name override"),
+      tiles: z24.array(
+        z24.object({
+          id: z24.string().regex(/^[a-z0-9][a-z0-9-]{0,62}$/),
+          title: z24.string().min(1).max(200),
           position: dashboardPositionSchema,
-          userInputs: z22.record(z22.unknown())
+          userInputs: z24.record(z24.unknown())
         }).strict()
       ).min(1).max(50)
     },
@@ -4778,10 +5027,10 @@ function registerGenerateDashboardTiles(server, client) {
           method: "POST",
           path: "/api/v2/guest-token/create",
           auth: "service",
-          body: { clientId: "None", dataAppName: resolution.name }
+          body: { clientId: params.clientId, dataAppName: resolution.name }
         });
         const datasource = await services.widgetService.resolveDatasource(guest.token, {
-          clientId: "None",
+          clientId: params.clientId,
           integrationId: params.integrationId,
           integrationName: params.integrationName
         });
@@ -4802,11 +5051,6 @@ function registerGenerateDashboardTiles(server, client) {
               `Tile "${item.input.id}" generation failed: ${stringify(item.result.error)}`
             );
           }
-          if (typeof item.result.chartType !== "string" || !item.result.chartType) {
-            return toolError(
-              `Tile "${item.input.id}" returned no chartType. Refine its userInputs and retry.`
-            );
-          }
         }
         return toolSuccess(
           stringify({
@@ -4818,7 +5062,7 @@ function registerGenerateDashboardTiles(server, client) {
               position: input.position,
               title: input.title,
               chart: {
-                type: result.chartType,
+                type: result.chartType || "table",
                 query: result.query,
                 companyIntegrationId: datasource.value.integrationId
               }
@@ -4841,14 +5085,15 @@ function registerGenerateDashboardTiles(server, client) {
 }
 
 // src/tools/dashboard/get-dashboard.ts
-import { z as z23 } from "zod";
+import { z as z25 } from "zod";
 function registerGetDashboard(server, client) {
-  server.tool(
+  const tool = server.tool(
     "get_dashboard",
     "Retrieve a workspace dashboard projected back into the versioned tile-list contract.",
     {
-      workspaceName: workspaceNameSchema,
-      dashboardId: z23.string().min(1).describe("Dashboard identifier returned by create_dashboard")
+      workspaceName: workspaceNameSchema.optional(),
+      workspaceId: z25.string().min(1).optional().describe("Workspace UUID from a dashboard link wid parameter"),
+      dashboardId: z25.string().min(1).describe("Dashboard UUID or externalDashboardId slug returned by list_dashboards or create_dashboard")
     },
     READ_ONLY,
     async (params) => {
@@ -4858,10 +5103,33 @@ function registerGetDashboard(server, client) {
           path: "/api/v2/workspace/dashboard",
           auth: "service",
           query: {
-            workspaceName: params.workspaceName,
+            ...params.workspaceName ? { workspaceName: params.workspaceName } : {},
+            ...params.workspaceId ? { workspaceId: params.workspaceId } : {},
             dashboardId: params.dashboardId
           }
         });
+        if (hasChartApps(server) && client.isHosted()) {
+          const tiles = Array.isArray(result.tiles) ? result.tiles : [];
+          const charts = tiles.filter((t) => !t.unavailable && t.chart?.metricRef);
+          const dashboardId = String(result.dashboardId || params.dashboardId);
+          const picker = {
+            kind: "dashboard",
+            title: result.title || "Dashboard",
+            rows: [],
+            widgets: charts.map((t) => ({
+              name: t.title || "Widget",
+              chartType: t.chart.type || null,
+              reference: { dashboardId, widgetId: t.chart.metricRef }
+            })),
+            dashboardId: result.dashboardId
+          };
+          try {
+            return chartResult(stringify(result), picker);
+          } catch (error) {
+            if (!(error instanceof Error) || error.message !== "Chart page exceeds payload budget") throw error;
+            return chartResult(`Dashboard ready. ${picker.widgets.length} saved charts. The tile shows a compact picker because the full dashboard document exceeds the App payload budget. ` + chartIndex(dashboardId, picker.widgets.map((w) => ({ widgetId: w.reference.widgetId, name: w.name, chartType: w.chartType }))), picker);
+          }
+        }
         return toolSuccess(stringify(result));
       } catch (err) {
         if (err instanceof DatabrainApiError) return err.toToolResponse();
@@ -4869,10 +5137,11 @@ function registerGetDashboard(server, client) {
       }
     }
   );
+  tagChartTool(server, tool);
 }
 
 // src/tools/dashboard/dashboard-snapshot.ts
-import { z as z24 } from "zod";
+import { z as z26 } from "zod";
 var SNAPSHOT_REQUEST_MS = 45e3;
 function registerDashboardSnapshot(server, client) {
   server.tool(
@@ -4880,10 +5149,10 @@ function registerDashboardSnapshot(server, client) {
     "Get a PNG picture of a dashboard, or of one chart on it (metricId), as the signed-in user sees it in Databrain. Light or dark, 480 to 1600 px wide. Needs a Databrain sign-in (OAuth), not a service token.",
     {
       workspaceName: workspaceNameSchema.optional(),
-      dashboardId: z24.string().min(1).max(200).optional().describe("Dashboard id from list_dashboards. Needed unless metricId is given."),
-      metricId: z24.string().min(1).max(200).optional().describe("One chart (metric) id: draw only that chart, from a dashboard it is on."),
-      theme: z24.enum(["light", "dark"]).default("light").describe("Picture colours"),
-      width: z24.number().int().min(480).max(1600).default(1200).describe("Picture width in pixels")
+      dashboardId: z26.string().min(1).max(200).optional().describe("Dashboard id from list_dashboards. Needed unless metricId is given."),
+      metricId: z26.string().min(1).max(200).optional().describe("One chart (metric) id: draw only that chart, from a dashboard it is on."),
+      theme: z26.enum(["light", "dark"]).default("light").describe("Picture colours"),
+      width: z26.number().int().min(480).max(1600).default(1200).describe("Picture width in pixels")
     },
     READ_ONLY,
     async (params) => {
@@ -4928,18 +5197,18 @@ function registerDashboardSnapshot(server, client) {
 
 // src/apps/preview.ts
 import { createHash } from "crypto";
-import { z as z25 } from "zod";
-var draftSchema = z25.object({
-  question: z25.string().min(1).max(2e3),
-  sql: z25.string().min(1).max(2e4),
-  datamartName: z25.string().min(1).max(256),
-  dimensions: z25.array(z25.string().max(128)).max(20).default([]),
-  measures: z25.array(z25.string().max(128)).max(20).default([]),
-  chartType: z25.string().min(1).max(80),
-  title: z25.string().min(1).max(200),
-  sessionId: z25.string().max(256).optional(),
+import { z as z27 } from "zod";
+var draftSchema = z27.object({
+  question: z27.string().min(1).max(2e3),
+  sql: z27.string().min(1).max(2e4),
+  datamartName: z27.string().min(1).max(256),
+  dimensions: z27.array(z27.string().max(128)).max(20).default([]),
+  measures: z27.array(z27.string().max(128)).max(20).default([]),
+  chartType: z27.string().min(1).max(80),
+  title: z27.string().min(1).max(200),
+  sessionId: z27.string().max(256).optional(),
   /** Workspaces built on this datamart. One means Save needs no choice. */
-  workspaces: z25.array(z25.string().max(256)).max(50).default([])
+  workspaces: z27.array(z27.string().max(256)).max(50).default([])
 }).strict();
 var PREVIEW_PATH = "/api/v2/data-app/chart-preview";
 var METRIC_PATH = "/api/mcp/metrics/create";
@@ -5066,7 +5335,7 @@ async function saveDraftAsDashboard(client, draft, input) {
 }
 
 // src/tools/query/ask-question.ts
-import { z as z26 } from "zod";
+import { z as z28 } from "zod";
 
 // src/tools/query/answer-format.ts
 function formatConfidence(value) {
@@ -5123,29 +5392,29 @@ function registerAskQuestion(server, client) {
     "ask_question",
     "Ask a natural language question \u2014 converts to SQL, returns data + chart suggestion. Requires datamartName with a populated semantic layer.",
     {
-      question: z26.string().describe(
+      question: z28.string().describe(
         'The natural language question to ask (e.g. "What was total revenue last month?")'
       ),
-      datamartName: z26.string().optional().describe(
+      datamartName: z28.string().optional().describe(
         "Name of the datamart to query. Use `list_datamarts` to find available names. REQUIRED unless exactly one datamart exists (auto-resolved). Do NOT pass a workspace name here."
       ),
-      sessionId: z26.string().optional().describe(
+      sessionId: z28.string().optional().describe(
         "Session ID from a previous ask_question response, for follow-up questions."
       ),
-      timezone: z26.string().optional().describe('IANA timezone (e.g. "America/New_York"). Defaults to UTC.')
+      timezone: z28.string().optional().describe('IANA timezone (e.g. "America/New_York"). Defaults to UTC.')
     },
     WRITE_CREATE,
     async (params) => {
       try {
         let datamartName = params.datamartName;
-        if (!datamartName) {
+        {
           const datamarts = await services.datamartsApi.listDatamarts();
           if (!Array.isArray(datamarts) || datamarts.length === 0) {
             return toolError(
-              "No datamarts found. A datamart is **required** before you can query data.\n\nTell the user they need to create a datamart in the **Databrain UI** first:\n1. Go to the Databrain platform and connect a datasource\n2. Create a datamart by selecting tables from the datasource\n3. Come back here and use `ask_question` with the `datamartName`\n\nYou can use `list_datasources` and `discover_datasource_schema` to explore what's available."
+              "No datamarts are available in this workspace. A datamart is **required** before you can query data.\n\nTell the user they need to create a datamart in the **Databrain UI** first:\n1. Go to the Databrain platform and connect a datasource\n2. Create a datamart by selecting tables from the datasource\n3. Come back here and use `ask_question` with the `datamartName`\n\nYou can use `list_datasources` and `discover_datasource_schema` to explore what's available."
             );
           }
-          if (datamarts.length === 1) {
+          if (!datamartName && datamarts.length === 1) {
             const resolvedName = datamarts[0].name || datamarts[0].datamartName;
             if (!resolvedName) {
               return toolError(
@@ -5153,7 +5422,7 @@ function registerAskQuestion(server, client) {
               );
             }
             datamartName = resolvedName;
-          } else {
+          } else if (!datamartName) {
             const list = datamarts.map(formatDatamart).join("\n");
             return toolSuccess(
               `Found ${datamarts.length} datamarts. Please specify which one to query:
@@ -5332,14 +5601,14 @@ To fix this:
 }
 
 // src/tools/query/get-semantic-layer.ts
-import { z as z27 } from "zod";
+import { z as z29 } from "zod";
 function registerGetSemanticLayer(server, client) {
   const services = createServiceBundle(client);
   server.tool(
     "get_semantic_layer",
     "Get semantic layer metadata for a datamart: table/column descriptions, synonyms, completion score. Omit datamartName to auto-resolve.",
     {
-      datamartName: z27.string().optional().describe(
+      datamartName: z29.string().optional().describe(
         "Name of the datamart to inspect. Omit to list available datamarts."
       )
     },
@@ -5449,7 +5718,7 @@ ${result.feedback}`);
 }
 
 // src/tools/query/semantic-model.ts
-import { z as z28 } from "zod";
+import { z as z30 } from "zod";
 
 // src/services/semantic-source.ts
 import { parseDocument, stringify as stringify2 } from "yaml";
@@ -5649,21 +5918,21 @@ function retrieveSemanticSource(source2, question, k) {
 }
 
 // src/tools/query/semantic-model.ts
-var datamartId = z28.string().trim().min(1).max(256).describe("Datamart ID from list_datamarts.");
-var source = z28.string().min(1).max(2e6).describe("Complete proposed semantic model as YAML.");
-var entityKind = z28.enum(["table", "column", "measure", "metric", "join", "entity", "glossary", "saved_query", "instruction", "access_rule"]);
+var datamartId = z30.string().trim().min(1).max(256).describe("Datamart ID from list_datamarts.");
+var source = z30.string().min(1).max(2e6).describe("Complete proposed semantic model as YAML.");
+var entityKind = z30.enum(["table", "column", "measure", "metric", "join", "entity", "glossary", "saved_query", "instruction", "access_rule"]);
 var changeInputs = {
   source: source.optional(),
-  yaml_patch: z28.string().min(1).max(2e6).optional().describe("YAML mapping merged into the pulled model. Named lists merge by name. Other lists replace. Null removes a field. An empty list clears it."),
-  change: z28.object({
-    operation: z28.enum(["upsert", "remove"]),
+  yaml_patch: z30.string().min(1).max(2e6).optional().describe("YAML mapping merged into the pulled model. Named lists merge by name. Other lists replace. Null removes a field. An empty list clears it."),
+  change: z30.object({
+    operation: z30.enum(["upsert", "remove"]),
     kind: entityKind,
-    name: z28.string().trim().min(1),
-    table: z28.string().trim().min(1).optional().describe("Required for columns. Use the table name and an unqualified column name."),
-    value: z28.record(z28.unknown()).optional().describe("Fields to merge for upsert. Omit for remove.")
+    name: z30.string().trim().min(1),
+    table: z30.string().trim().min(1).optional().describe("Required for columns. Use the table name and an unqualified column name."),
+    value: z30.record(z30.unknown()).optional().describe("Fields to merge for upsert. Omit for remove.")
   }).strict().optional().describe("One named entity change. Supply exactly one of source, yaml_patch or change.")
 };
-var expectedHash = z28.string().trim().min(1).nullable().optional().describe("Stored content_hash from the reviewed proposal. Null explicitly means the first apply. Required when dry_run is false.");
+var expectedHash = z30.string().trim().min(1).nullable().optional().describe("Stored content_hash from the reviewed proposal. Null explicitly means the first apply. Required when dry_run is false.");
 function errorCode(error) {
   const nested = isObject(error.details) && isObject(error.details.error) ? error.details.error : void 0;
   return typeof nested?.code === "string" ? nested.code : error.code;
@@ -5722,7 +5991,7 @@ function registerSearchSemanticModel(server, client) {
   server.tool(
     "search_semantic_model",
     "Find semantic model entities relevant to a question. Ranks names, aliases, synonyms and descriptions, then includes related entities. Uses the stored model and never writes.",
-    { datamartId, question: z28.string().trim().min(1).max(1e4), k: z28.number().int().min(1).max(100).default(10) },
+    { datamartId, question: z30.string().trim().min(1).max(1e4), k: z30.number().int().min(1).max(100).default(10) },
     READ_ONLY,
     async ({ datamartId: datamartId2, question, k }) => {
       try {
@@ -5745,7 +6014,7 @@ function registerGetSemanticEntity(server, client) {
   server.tool(
     "get_semantic_entity",
     "Read one entity by kind and exact name from the stored semantic model. For a column, use table.column. Returns the stored content hash for change review.",
-    { datamartId, kind: entityKind, name: z28.string().trim().min(1) },
+    { datamartId, kind: entityKind, name: z30.string().trim().min(1) },
     READ_ONLY,
     async ({ datamartId: datamartId2, kind, name }) => {
       try {
@@ -5783,9 +6052,9 @@ function registerApplySemanticChange(server, client) {
     {
       datamartId,
       ...changeInputs,
-      dry_run: z28.boolean().default(true),
+      dry_run: z30.boolean().default(true),
       expected_content_hash: expectedHash,
-      confirm: z28.string().optional().describe("User supplied APPLY_TO_PRODUCTION after reviewing the plan. Never invent confirmation.")
+      confirm: z30.string().optional().describe("User supplied APPLY_TO_PRODUCTION after reviewing the plan. Never invent confirmation.")
     },
     DESTRUCTIVE,
     async (params) => {
@@ -5808,19 +6077,17 @@ function registerEvalSemanticModel(server, client) {
   const api = createServiceBundle(client).semanticModelApi;
   server.tool(
     "eval_semantic_model",
-    "Evaluate saved queries and optional questions against a proposed or stored semantic model. Returns the pass rate and each verdict with its reason. Runs warehouse queries without changing the model.",
-    { datamartId, source: source.optional(), questions: z28.array(z28.union([z28.string().trim().min(1), z28.object({
-      name: z28.string().optional(),
-      question: z28.string().min(1),
-      sql: z28.string().optional(),
-      expected_columns: z28.array(z28.string()).optional(),
-      expected_empty: z28.boolean().optional()
-    }).strict()])).max(100).optional() },
+    "Evaluate closed world semantic assertions against proposed or stored YAML. Each question must name an id and the model entities it exercises. Does not execute warehouse SQL or write the model.",
+    { datamartId, source: source.optional(), questions: z30.array(z30.object({
+      id: z30.string().trim().min(1),
+      question: z30.string().trim().min(1),
+      exercises: z30.array(z30.string().trim().min(1)).describe("Exact model entity names asserted by this question; an empty list is reported as unscoreable.")
+    }).strict()).max(100).default([]) },
     READ_ONLY,
     async ({ datamartId: datamartId2, source: source2, questions }) => {
-      const shaped = questions?.map((entry) => typeof entry === "string" ? { question: entry } : entry);
       try {
-        return toolSuccess(stringify(await api.evaluate(datamartId2, { source: source2, questions: shaped })));
+        const yaml = source2 ?? (await api.pull(datamartId2, "combined")).source;
+        return toolSuccess(stringify(await api.evaluate(datamartId2, { source: yaml, questions })));
       } catch (error) {
         return failure(error);
       }
@@ -5829,15 +6096,15 @@ function registerEvalSemanticModel(server, client) {
 }
 
 // src/tools/query/update-semantic-layer.ts
-import { z as z29 } from "zod";
-var columnSchema2 = z29.object({
-  name: z29.string().describe("Column name (must exist in the datamart)"),
-  description: z29.string().optional().describe("Business-friendly description of what this column represents"),
-  synonyms: z29.array(z29.string()).optional().describe(
+import { z as z31 } from "zod";
+var columnSchema2 = z31.object({
+  name: z31.string().describe("Column name (must exist in the datamart)"),
+  description: z31.string().optional().describe("Business-friendly description of what this column represents"),
+  synonyms: z31.array(z31.string()).optional().describe(
     'Alternative names users might use for this column (e.g. ["revenue", "sales amount"])'
   ),
-  miscellaneousInfo: z29.string().optional().describe("Additional context such as valid values, units, or caveats"),
-  columnType: z29.enum([
+  miscellaneousInfo: z31.string().optional().describe("Additional context such as valid values, units, or caveats"),
+  columnType: z31.enum([
     "String",
     "Long String",
     "String (Custom)",
@@ -5852,21 +6119,21 @@ var columnSchema2 = z29.object({
   // The public PUT accepts these three as well (docs: Update Semantic Layer).
   // They were missing here, and zod strips unknown keys, so a caller who set
   // `isIdentifier: true` got a success message and a row with `false`.
-  columnTypeConfig: z29.union([z29.record(z29.string(), z29.string()), z29.string(), z29.object({ lowerLimit: z29.number(), upperLimit: z29.number() }), z29.null()]).optional().describe("Shape depends on columnType: value-to-description object for String / String (Custom) / ENUM / Mapper, { lowerLimit, upperLimit } for Range, a string for Expression and JSON. Omit for Identifier, Number and Long String."),
-  isIdentifier: z29.boolean().optional().describe("Mark the column as an identifier (primary or foreign key)."),
-  isNotIndexed: z29.boolean().optional().describe("Exclude the column from AI indexing.")
+  columnTypeConfig: z31.union([z31.record(z31.string(), z31.string()), z31.string(), z31.object({ lowerLimit: z31.number(), upperLimit: z31.number() }), z31.null()]).optional().describe("Shape depends on columnType: value-to-description object for String / String (Custom) / ENUM / Mapper, { lowerLimit, upperLimit } for Range, a string for Expression and JSON. Omit for Identifier, Number and Long String."),
+  isIdentifier: z31.boolean().optional().describe("Mark the column as an identifier (primary or foreign key)."),
+  isNotIndexed: z31.boolean().optional().describe("Exclude the column from AI indexing.")
 });
-var tableSchema2 = z29.object({
-  name: z29.string().describe("Table name (must exist in the datamart)"),
-  schemaName: z29.string().optional().describe("Schema the table lives in, when the datamart has the same table name in more than one schema."),
-  description: z29.string().optional().describe(
+var tableSchema2 = z31.object({
+  name: z31.string().describe("Table name (must exist in the datamart)"),
+  schemaName: z31.string().optional().describe("Schema the table lives in, when the datamart has the same table name in more than one schema."),
+  description: z31.string().optional().describe(
     "Business-friendly description of what this table represents"
   ),
-  synonyms: z29.array(z29.string()).optional().describe("Alternative names for this table"),
-  miscellaneousInfo: z29.string().optional().describe(
+  synonyms: z31.array(z31.string()).optional().describe("Alternative names for this table"),
+  miscellaneousInfo: z31.string().optional().describe(
     "Additional context such as how the table relates to other tables"
   ),
-  columns: z29.array(columnSchema2).optional().describe("Column-level semantic definitions to update")
+  columns: z31.array(columnSchema2).optional().describe("Column-level semantic definitions to update")
 });
 function columnKey(tableName, columnName) {
   return `${tableName.toLowerCase()}\0${columnName.toLowerCase()}`;
@@ -5943,13 +6210,13 @@ function registerUpdateSemanticLayer(server, client) {
     "update_semantic_layer",
     "Populate or update the semantic layer for a datamart. Add table/column descriptions, synonyms, context. Required before ask_question works. Auto-generate descriptions from column names when empty.",
     {
-      datamartName: z29.string().optional().describe(
+      datamartName: z31.string().optional().describe(
         "Name of the datamart to update. Omit to list available datamarts."
       ),
-      tables: z29.array(tableSchema2).optional().describe(
+      tables: z31.array(tableSchema2).optional().describe(
         "Table and column definitions to update. Only include tables/columns you want to change."
       ),
-      feedback: z29.string().optional().describe(
+      feedback: z31.string().optional().describe(
         'General feedback or context about the datamart (e.g. "This datamart contains e-commerce data for the US market").'
       )
     },
@@ -6011,7 +6278,7 @@ You can now:
 }
 
 // src/tools/query/semantic-generation.ts
-import { z as z30 } from "zod";
+import { z as z32 } from "zod";
 function nonEmptyString(value) {
   return typeof value === "string" && value.trim().length > 0 ? value : null;
 }
@@ -6115,11 +6382,11 @@ function registerStartSemanticLayerGeneration(server, client) {
   const services = createServiceBundle(client);
   server.tool(
     "start_semantic_layer_generation",
-    "Start backend semantic-layer auto-generation for a datamart. Returns an async job id to poll.",
+    "Start backend semantic-layer auto-generation for a datamart through a hosted OAuth sign-in. Static service-token authentication is not supported by this backend route. Returns an async job id to poll.",
     {
-      datamartName: z30.string().optional().describe("Datamart name. Omit to list available datamarts"),
-      workspaceName: z30.string().optional().describe("Workspace linked to the datamart. Use when datamartName resolution needs a dataMartId bridge."),
-      datamartId: z30.string().optional().describe("Datamart UUID. Use only when already known.")
+      datamartName: z32.string().optional().describe("Datamart name. Omit to list available datamarts"),
+      workspaceName: z32.string().optional().describe("Workspace linked to the datamart. Use when datamartName resolution needs a dataMartId bridge."),
+      datamartId: z32.string().optional().describe("Datamart UUID. Use only when already known.")
     },
     WRITE_CREATE,
     async (params) => {
@@ -6159,11 +6426,11 @@ function registerGetSemanticLayerGenerationStatus(server, client) {
   const services = createServiceBundle(client);
   server.tool(
     "get_semantic_layer_generation_status",
-    "Get semantic-layer auto-generation job status for a datamart.",
+    "Get semantic-layer auto-generation job status for a datamart through a hosted OAuth sign-in. Static service-token authentication is not supported by this backend route.",
     {
-      datamartName: z30.string().optional().describe("Datamart name. Omit to list available datamarts"),
-      workspaceName: z30.string().optional().describe("Workspace linked to the datamart. Use when datamartName resolution needs a dataMartId bridge."),
-      datamartId: z30.string().optional().describe("Datamart UUID. Use only when already known.")
+      datamartName: z32.string().optional().describe("Datamart name. Omit to list available datamarts"),
+      workspaceName: z32.string().optional().describe("Workspace linked to the datamart. Use when datamartName resolution needs a dataMartId bridge."),
+      datamartId: z32.string().optional().describe("Datamart UUID. Use only when already known.")
     },
     READ_ONLY,
     async (params) => {
@@ -6200,7 +6467,7 @@ function registerGetSemanticLayerGenerationStatus(server, client) {
 }
 
 // src/tools/widgets/list-widgets.ts
-import { z as z31 } from "zod";
+import { z as z33 } from "zod";
 function widgetReferenceId(widget) {
   for (const candidate2 of [widget.externalMetricId, widget.id, widget._id, widget.metricId]) {
     if (typeof candidate2 === "string" && candidate2.trim().length > 0) return candidate2.trim();
@@ -6211,27 +6478,75 @@ function registerListWidgets(server, client) {
   const services = createServiceBundle(client);
   const tool = server.tool(
     "list_widgets",
-    "List widgets on a customer dashboard. Non-technical flow: pass `clientId` + `dashboardName` (+ optional `workspaceName` if ambiguous). Returns each widget's externalMetricId (uuid, used for update/remove), metricId (slug), name, published state, and creator identifier.",
+    "List saved widgets. Hosted sign-ins read an authorized workspace dashboard without an embed; guest/API flows use clientId and an embed.  Non-technical flow: pass `clientId` + `dashboardName` (+ optional `workspaceName` if ambiguous). Returns each widget's externalMetricId (uuid, used for update/remove), metricId (slug), name, published state, and creator identifier.",
     {
-      clientId: z31.string().describe("Client/tenant identifier for this dashboard"),
-      dashboardName: z31.string().optional().describe("Dashboard name (non-technical). Preferred input \u2014 pass this with optional `workspaceName` instead of `embedId`."),
-      workspaceName: z31.string().optional().describe("Workspace name (non-technical). Only needed if `dashboardName` is ambiguous across workspaces."),
-      embedId: z31.string().optional().describe("Technical alternative to `dashboardName`. Pass only if you already have the embed identifier.")
+      clientId: z33.string().optional().describe("Client/tenant identifier for this dashboard"),
+      dataAppName: z33.string().trim().min(1).optional().describe("Data app for a tenant/embed read. Omit to resolve it from the embed; hosted workspace reads need none."),
+      workspaceId: z33.string().min(1).optional().describe("Workspace UUID from the wid query parameter in a dashboard link."),
+      dashboardId: z33.string().min(1).optional().describe("Dashboard UUID or slug returned by list_dashboards. Hosted sign-ins only."),
+      dashboardName: z33.string().optional().describe("Dashboard name (non-technical). Preferred input \u2014 pass this with optional `workspaceName` instead of `embedId`."),
+      workspaceName: z33.string().optional().describe("Workspace name (non-technical). Only needed if `dashboardName` is ambiguous across workspaces."),
+      embedId: z33.string().optional().describe("Technical alternative to `dashboardName`. Pass only if you already have the embed identifier.")
     },
     READ_ONLY,
     async (params) => {
       try {
+        if (params.dashboardId && (params.clientId !== void 0 || params.embedId)) {
+          return toolError("dashboardId is for hosted workspace reads. For a tenant, use clientId with dashboardName or embedId.");
+        }
+        if (client.isHosted() && params.clientId === void 0 && !params.embedId) {
+          const result = await client.request({
+            method: "POST",
+            path: "/api/v2/workspace/dashboard/widgets",
+            auth: "service",
+            body: {
+              ...params.dashboardId ? { dashboardId: params.dashboardId } : {},
+              ...params.dashboardName ? { dashboardName: params.dashboardName } : {},
+              workspaceName: params.workspaceName,
+              workspaceId: params.workspaceId
+            }
+          });
+          const widgets2 = result.widgets;
+          if (hasChartApps(server)) {
+            const references = widgets2.slice(0, 50).flatMap((widget) => {
+              const widgetId = widgetReferenceId(widget);
+              return widgetId ? [{
+                name: widget.name || "Untitled widget",
+                chartType: typeof widget.chartType === "string" ? widget.chartType : null,
+                reference: { dashboardId: result.dashboardId, widgetId }
+              }] : [];
+            });
+            return chartResult(`${widgets2.length} saved widgets available. ` + chartIndex(
+              result.dashboardId,
+              references.map((r) => ({ widgetId: r.reference.widgetId, name: r.name, chartType: r.chartType }))
+            ), {
+              kind: "dashboard",
+              title: params.dashboardName || "Dashboard",
+              rows: [],
+              widgets: references,
+              dashboardId: result.dashboardId,
+              externalDashboardId: result.externalDashboardId,
+              description: widgets2.length > 50 ? "Showing the first 50 widgets." : ""
+            });
+          }
+          return toolSuccess(JSON.stringify(result));
+        }
+        if (!params.clientId) return toolError("clientId is required for an embed/tenant dashboard. Hosted sign-ins may omit it for a workspace dashboard.");
         const embed = await services.widgetService.resolveEmbedId({
           embedId: params.embedId,
           dashboardName: params.dashboardName,
           workspaceName: params.workspaceName,
+          dataAppName: params.dataAppName,
           required: true
         });
         if (!embed.ok) return toolError(embed.error);
         const embedId = embed.value.embedId;
+        const app = client.isHosted() ? await services.widgetService.resolveDataAppName(params.dataAppName, embedId) : { ok: true, value: params.dataAppName };
+        if (!app.ok) return toolError(app.error);
         const widgets = await services.widgetsApi.listWidgets(
           embedId,
-          params.clientId
+          params.clientId,
+          app.value
         );
         if (hasChartApps(server)) {
           const visible = (Array.isArray(widgets) ? widgets : []).slice(0, 50);
@@ -6239,7 +6554,12 @@ function registerListWidgets(server, client) {
             const widgetId = widgetReferenceId(w);
             return widgetId ? [{
               name: typeof w.name === "string" ? w.name.slice(0, 500) : "Untitled widget",
-              reference: { widgetId, embedId, clientId: params.clientId }
+              reference: {
+                widgetId,
+                embedId,
+                clientId: params.clientId,
+                ...app.value ? { dataAppName: app.value } : {}
+              }
             }] : [];
           });
           return chartResult(`${references.length} widgets available in the first dashboard page.`, {
@@ -6280,29 +6600,29 @@ function registerListWidgets(server, client) {
 }
 
 // src/tools/widgets/add-widget.ts
-import { z as z32 } from "zod";
+import { z as z34 } from "zod";
 function registerAddWidget(server, client) {
   const services = createServiceBundle(client);
   server.tool(
     "add_widget",
     "Add a widget to a customer dashboard. Non-technical flow: pass `clientId` + `dashboardName` (+ optional `workspaceName` if ambiguous). Cloning via `templateMetricId` is the recommended path \u2014 query, chart config, and datasource are all inherited. Data app and datasource auto-resolve; never ask the user for them.",
     {
-      clientId: z32.string().describe("Client/tenant identifier (widget is created in their scope)"),
-      dashboardName: z32.string().optional().describe("Dashboard name (non-technical). Preferred input \u2014 pass this with optional `workspaceName` instead of `embedId`."),
-      workspaceName: z32.string().optional().describe("Workspace name (non-technical). Only needed if `dashboardName` is ambiguous across workspaces."),
-      embedId: z32.string().optional().describe("Technical alternative to `dashboardName`. Pass only if you already have the embed identifier."),
-      dataAppName: z32.string().optional().describe("Technical override. Auto-resolved from the embed; non-technical callers should leave this blank."),
-      templateMetricId: z32.string().optional().describe("Source widget metricId to clone from. Copies query, chartOptions, and datasource fields; caller can override via other params."),
-      name: z32.string().optional().describe("Widget name (overrides template)"),
-      metricId: z32.string().optional().describe("Unique slug for the new widget (auto-generated if omitted)"),
-      query: z32.string().optional().describe("SQL query body (overrides template)"),
-      chartOptions: z32.record(z32.unknown()).optional().describe("Chart config JSON (chart type, colors, legend, axes). Overrides template."),
-      description: z32.string().optional(),
-      companyIntegrationId: z32.string().optional().describe("Datasource UUID override. Auto-resolved from `embedId` or sole active datasource; leave blank unless the user explicitly picked one by ID."),
-      integrationName: z32.string().optional().describe('Datasource display name (e.g. "Snowflake"). Use this when the user picks a datasource by name \u2014 the id is looked up automatically.'),
-      isPublished: z32.boolean().optional().describe("Publish immediately (default true)"),
-      body: z32.record(z32.unknown()).optional().describe("Raw createMetric body passthrough. If provided, used as-is (after defaults). Overrides all other params."),
-      widgets: z32.array(z32.record(z32.unknown())).min(1).max(50).optional().describe("Batch of raw createMetric bodies. Dashboard attachment is added to each body.")
+      clientId: z34.string().describe("Client/tenant identifier (widget is created in their scope)"),
+      dashboardName: z34.string().optional().describe("Dashboard name (non-technical). Preferred input \u2014 pass this with optional `workspaceName` instead of `embedId`."),
+      workspaceName: z34.string().optional().describe("Workspace name (non-technical). Only needed if `dashboardName` is ambiguous across workspaces."),
+      embedId: z34.string().optional().describe("Technical alternative to `dashboardName`. Pass only if you already have the embed identifier."),
+      dataAppName: z34.string().optional().describe("Technical override. Auto-resolved from the embed; non-technical callers should leave this blank."),
+      templateMetricId: z34.string().optional().describe("Source widget metricId to clone from. Copies query, chartOptions, and datasource fields; caller can override via other params."),
+      name: z34.string().optional().describe("Widget name (overrides template)"),
+      metricId: z34.string().optional().describe("Unique slug for the new widget (auto-generated if omitted)"),
+      query: z34.string().optional().describe("SQL query body (overrides template)"),
+      chartOptions: z34.record(z34.unknown()).optional().describe("Chart config JSON (chart type, colors, legend, axes). Overrides template."),
+      description: z34.string().optional(),
+      companyIntegrationId: z34.string().optional().describe("Datasource UUID override. Auto-resolved from `embedId` or sole active datasource; leave blank unless the user explicitly picked one by ID."),
+      integrationName: z34.string().optional().describe('Datasource display name (e.g. "Snowflake"). Use this when the user picks a datasource by name \u2014 the id is looked up automatically.'),
+      isPublished: z34.boolean().optional().describe("Publish immediately (default true)"),
+      body: z34.record(z34.unknown()).optional().describe("Raw createMetric body passthrough. If provided, used as-is (after defaults). Overrides all other params."),
+      widgets: z34.array(z34.record(z34.unknown())).min(1).max(50).optional().describe("Batch of raw createMetric bodies. Dashboard attachment is added to each body.")
     },
     WRITE_CREATE,
     async (params) => {
@@ -6311,11 +6631,12 @@ function registerAddWidget(server, client) {
           embedId: params.embedId,
           dashboardName: params.dashboardName,
           workspaceName: params.workspaceName,
+          dataAppName: params.dataAppName,
           required: true
         });
         if (!embed.ok) return toolError(embed.error);
         const embedId = embed.value.embedId;
-        const ctx = await services.widgetService.resolveEmbedContext(embedId);
+        const ctx = await services.widgetService.resolveEmbedContext(embedId, params.dataAppName);
         if (!ctx.externalDashboardId) {
           return toolError(
             `Dashboard "${params.dashboardName || embedId}" has no externalDashboardId \u2014 cannot attach a widget. Verify via \`get_embed_details\`.`
@@ -6450,20 +6771,20 @@ Use \`list_widgets\` to verify, or \`update_widget\`/\`remove_widget\` to adjust
 }
 
 // src/tools/widgets/update-widget.ts
-import { z as z33 } from "zod";
+import { z as z35 } from "zod";
 function registerUpdateWidget(server, client) {
   const services = createServiceBundle(client);
   server.tool(
     "update_widget",
     "Update a widget on a customer dashboard. Non-technical flow: pass `clientId` + `dashboardName` (+ optional `workspaceName` if ambiguous) + `externalMetricId` + `set`. Data app auto-resolves from the dashboard.",
     {
-      externalMetricId: z33.string().describe("Internal uuid of the widget (externalMetrics.id). Not the user-facing metricId slug."),
-      clientId: z33.string().describe("Client/tenant identifier"),
-      dashboardName: z33.string().optional().describe("Dashboard name (non-technical). Preferred input \u2014 pass this with optional `workspaceName` instead of `embedId`."),
-      workspaceName: z33.string().optional().describe("Workspace name (non-technical). Only needed if `dashboardName` is ambiguous across workspaces."),
-      embedId: z33.string().optional().describe("Technical alternative to `dashboardName`. Pass only if you already have the embed identifier."),
-      dataAppName: z33.string().optional().describe("Technical override. Auto-resolved from the dashboard; non-technical callers should leave this blank."),
-      set: z33.record(z33.unknown()).describe("Partial patch. Keys can include: name, query, chartOptions, description, isPublished, isLive, selectedGroupBy, drillDownSettings, limit, etc.")
+      externalMetricId: z35.string().describe("Internal uuid of the widget (externalMetrics.id). Not the user-facing metricId slug."),
+      clientId: z35.string().describe("Client/tenant identifier"),
+      dashboardName: z35.string().optional().describe("Dashboard name (non-technical). Preferred input \u2014 pass this with optional `workspaceName` instead of `embedId`."),
+      workspaceName: z35.string().optional().describe("Workspace name (non-technical). Only needed if `dashboardName` is ambiguous across workspaces."),
+      embedId: z35.string().optional().describe("Technical alternative to `dashboardName`. Pass only if you already have the embed identifier."),
+      dataAppName: z35.string().optional().describe("Technical override. Auto-resolved from the dashboard; non-technical callers should leave this blank."),
+      set: z35.record(z35.unknown()).describe("Partial patch. Keys can include: name, query, chartOptions, description, isPublished, isLive, selectedGroupBy, drillDownSettings, limit, etc.")
     },
     WRITE_IDEMPOTENT,
     async (params) => {
@@ -6475,6 +6796,7 @@ function registerUpdateWidget(server, client) {
           embedId: params.embedId,
           dashboardName: params.dashboardName,
           workspaceName: params.workspaceName,
+          dataAppName: params.dataAppName,
           required: true
         });
         if (!embed.ok) return toolError(embed.error);
@@ -6526,19 +6848,19 @@ Use \`list_widgets\` to verify.`
 }
 
 // src/tools/widgets/remove-widget.ts
-import { z as z34 } from "zod";
+import { z as z36 } from "zod";
 function registerRemoveWidget(server, client) {
   const services = createServiceBundle(client);
   server.tool(
     "remove_widget",
     "Remove a widget from a customer dashboard. Non-technical flow: pass `clientId` + `dashboardName` (+ optional `workspaceName` if ambiguous) + `externalMetricId`. Per-client soft delete \u2014 the widget stays on the template dashboard and on other customers' dashboards.",
     {
-      externalMetricId: z34.string().describe("Internal uuid of the widget (externalMetrics.id)"),
-      clientId: z34.string().describe("Client/tenant identifier \u2014 the widget will be hidden for this client only"),
-      dashboardName: z34.string().optional().describe("Dashboard name (non-technical). Preferred input \u2014 pass this with optional `workspaceName` instead of `embedId`."),
-      workspaceName: z34.string().optional().describe("Workspace name (non-technical). Only needed if `dashboardName` is ambiguous across workspaces."),
-      embedId: z34.string().optional().describe("Technical alternative to `dashboardName`. Pass only if you already have the embed identifier."),
-      dataAppName: z34.string().optional().describe("Technical override. Auto-resolved from the dashboard; non-technical callers should leave this blank.")
+      externalMetricId: z36.string().describe("Internal uuid of the widget (externalMetrics.id)"),
+      clientId: z36.string().describe("Client/tenant identifier \u2014 the widget will be hidden for this client only"),
+      dashboardName: z36.string().optional().describe("Dashboard name (non-technical). Preferred input \u2014 pass this with optional `workspaceName` instead of `embedId`."),
+      workspaceName: z36.string().optional().describe("Workspace name (non-technical). Only needed if `dashboardName` is ambiguous across workspaces."),
+      embedId: z36.string().optional().describe("Technical alternative to `dashboardName`. Pass only if you already have the embed identifier."),
+      dataAppName: z36.string().optional().describe("Technical override. Auto-resolved from the dashboard; non-technical callers should leave this blank.")
     },
     DESTRUCTIVE,
     async (params) => {
@@ -6547,6 +6869,7 @@ function registerRemoveWidget(server, client) {
           embedId: params.embedId,
           dashboardName: params.dashboardName,
           workspaceName: params.workspaceName,
+          dataAppName: params.dataAppName,
           required: true
         });
         if (!embed.ok) return toolError(embed.error);
@@ -6594,21 +6917,21 @@ Note: this is a per-client soft delete. The widget remains available for other c
 }
 
 // src/tools/widgets/generate-widget.ts
-import { z as z35 } from "zod";
+import { z as z37 } from "zod";
 function registerGenerateWidget(server, client) {
   const services = createServiceBundle(client);
   const tool = server.tool(
     "generate_widget",
     "AI-generate a widget draft from a natural-language prompt. Does NOT persist \u2014 returns a draft to pass to `add_widget`. Non-technical flow: `clientId` + `dashboardName` (+ `workspaceName` if ambiguous); data app and datasource auto-resolve. Never ask the user for data app, datasource, or integration.",
     {
-      clientId: z35.string().describe("Client/tenant identifier"),
-      userInputs: z35.record(z35.unknown()).describe('Prompt + context object. Typical shape: { prompt: "calls per day over last 30 days", schema: {...}, examples: [...] }. Backend decides which keys it honors.'),
-      dashboardName: z35.string().optional().describe("Dashboard name (non-technical). Preferred input for CS/CX flows \u2014 pass this with optional `workspaceName` instead of `embedId`."),
-      workspaceName: z35.string().optional().describe("Workspace name (non-technical). Only needed if `dashboardName` is ambiguous across workspaces."),
-      embedId: z35.string().optional().describe("Technical alternative to `dashboardName`. Pass only if you already have the embed identifier."),
-      dataAppName: z35.string().optional().describe("Technical override. Auto-resolved from the embed; non-technical callers should leave this blank."),
-      integrationId: z35.string().optional().describe("Technical override \u2014 the datasource UUID. Non-technical callers must leave this blank; the datasource is inherited from the dashboard's existing widgets."),
-      integrationName: z35.string().optional().describe("Technical override \u2014 datasource display name. Non-technical callers must leave this blank; the datasource is inherited from the dashboard's existing widgets.")
+      clientId: z37.string().describe("Client/tenant identifier"),
+      userInputs: z37.record(z37.unknown()).describe('Prompt + context object. Typical shape: { prompt: "calls per day over last 30 days", schema: {...}, examples: [...] }. Backend decides which keys it honors.'),
+      dashboardName: z37.string().optional().describe("Dashboard name (non-technical). Preferred input for CS/CX flows \u2014 pass this with optional `workspaceName` instead of `embedId`."),
+      workspaceName: z37.string().optional().describe("Workspace name (non-technical). Only needed if `dashboardName` is ambiguous across workspaces."),
+      embedId: z37.string().optional().describe("Technical alternative to `dashboardName`. Pass only if you already have the embed identifier."),
+      dataAppName: z37.string().optional().describe("Technical override. Auto-resolved from the embed; non-technical callers should leave this blank."),
+      integrationId: z37.string().optional().describe("Technical override \u2014 the datasource UUID. Non-technical callers must leave this blank; the datasource is inherited from the dashboard's existing widgets."),
+      integrationName: z37.string().optional().describe("Technical override \u2014 datasource display name. Non-technical callers must leave this blank; the datasource is inherited from the dashboard's existing widgets.")
     },
     READ_ONLY,
     async (params) => {
@@ -6617,6 +6940,7 @@ function registerGenerateWidget(server, client) {
           embedId: params.embedId,
           dashboardName: params.dashboardName,
           workspaceName: params.workspaceName,
+          dataAppName: params.dataAppName,
           required: true
         });
         if (!embed.ok) return toolError(embed.error);
@@ -6693,9 +7017,9 @@ function registerGenerateWidget(server, client) {
 }
 
 // src/tools/widgets/create-or-update-metric-from-query.ts
-import { z as z36 } from "zod";
-var modeSchema = z36.enum(["dry_run", "apply"]).default("dry_run");
-var conflictStrategySchema = z36.enum(["fail", "update", "create_new"]).default("fail");
+import { z as z38 } from "zod";
+var modeSchema = z38.enum(["dry_run", "apply"]).default("dry_run");
+var conflictStrategySchema = z38.enum(["fail", "update", "create_new"]).default("fail");
 function makePlanText(plan) {
   return JSON.stringify(plan, null, 2);
 }
@@ -6712,22 +7036,22 @@ function registerCreateOrUpdateMetricFromQuery(server, client) {
     "[EMBEDDING] Create or update a production metric/widget on a customer dashboard from validated SQL. Requires clientId (multi-tenant embed). Defaults to dry-run; apply requires explicit confirmation.",
     {
       mode: modeSchema.describe("dry_run returns the plan only; apply executes after confirmation"),
-      confirm: z36.string().optional().describe(`Required for apply: ${APPLY_TO_PRODUCTION_CONFIRMATION}`),
+      confirm: z38.string().optional().describe(`Required for apply: ${APPLY_TO_PRODUCTION_CONFIRMATION}`),
       conflictStrategy: conflictStrategySchema.describe("What to do if metricId already exists on the target dashboard"),
-      clientId: z36.string().describe("Client/tenant identifier for the dashboard widget scope"),
-      workspaceName: z36.string().describe("Target workspace name"),
-      dashboardName: z36.string().optional().describe("Dashboard name to attach to"),
-      embedId: z36.string().optional().describe("Technical embed id alternative to dashboardName"),
-      dataAppName: z36.string().optional().describe("Optional data app override"),
-      name: z36.string().describe("Metric/widget display name"),
-      metricId: z36.string().describe("Stable metric slug to create or update"),
-      query: z36.string().describe("SQL query already validated against the warehouse"),
-      description: z36.string().optional().describe("Metric description"),
-      chartOptions: z36.record(z36.unknown()).optional().describe("Chart configuration JSON"),
-      companyIntegrationId: z36.string().optional().describe("Datasource UUID override"),
-      integrationName: z36.string().optional().describe("Datasource display name override"),
-      isPublished: z36.boolean().optional().describe("Publish after apply. Defaults to false for production safety"),
-      requestedBy: z36.string().optional().describe("Human operator/request context to store on the metric when supported")
+      clientId: z38.string().describe("Client/tenant identifier for the dashboard widget scope"),
+      workspaceName: z38.string().describe("Target workspace name"),
+      dashboardName: z38.string().optional().describe("Dashboard name to attach to"),
+      embedId: z38.string().optional().describe("Technical embed id alternative to dashboardName"),
+      dataAppName: z38.string().optional().describe("Optional data app override"),
+      name: z38.string().describe("Metric/widget display name"),
+      metricId: z38.string().describe("Stable metric slug to create or update"),
+      query: z38.string().describe("SQL query already validated against the warehouse"),
+      description: z38.string().optional().describe("Metric description"),
+      chartOptions: z38.record(z38.unknown()).optional().describe("Chart configuration JSON"),
+      companyIntegrationId: z38.string().optional().describe("Datasource UUID override"),
+      integrationName: z38.string().optional().describe("Datasource display name override"),
+      isPublished: z38.boolean().optional().describe("Publish after apply. Defaults to false for production safety"),
+      requestedBy: z38.string().optional().describe("Human operator/request context to store on the metric when supported")
     },
     WRITE_IDEMPOTENT,
     async (params) => {
@@ -6741,11 +7065,12 @@ function registerCreateOrUpdateMetricFromQuery(server, client) {
           embedId: params.embedId,
           dashboardName: params.dashboardName,
           workspaceName: params.workspaceName,
+          dataAppName: params.dataAppName,
           required: true
         });
         if (!embed.ok) return toolError(embed.error);
         const embedId = embed.value.embedId;
-        const ctx = await services.widgetService.resolveEmbedContext(embedId);
+        const ctx = await services.widgetService.resolveEmbedContext(embedId, params.dataAppName);
         if (!ctx.externalDashboardId) {
           return toolError(
             `Dashboard "${params.dashboardName || embedId}" has no externalDashboardId. Verify with get_embed_details before creating metrics.`
@@ -6887,8 +7212,8 @@ function registerCreateOrUpdateMetricFromQuery(server, client) {
 }
 
 // src/tools/widgets/create-workspace-metric.ts
-import { z as z37 } from "zod";
-var modeSchema2 = z37.enum(["dry_run", "apply"]).default("dry_run");
+import { z as z39 } from "zod";
+var modeSchema2 = z39.enum(["dry_run", "apply"]).default("dry_run");
 function registerCreateWorkspaceMetric(server, client) {
   server.tool(
     "create_workspace_metric",
@@ -6897,18 +7222,18 @@ function registerCreateWorkspaceMetric(server, client) {
       mode: modeSchema2.describe(
         "dry_run validates the SQL only (no write); apply creates or updates the metric after confirmation"
       ),
-      confirm: z37.string().optional().describe(`Required for apply: ${APPLY_TO_PRODUCTION_CONFIRMATION}`),
-      workspaceName: z37.string().describe("Target workspace name"),
-      name: z37.string().describe("Metric display name"),
-      query: z37.string().describe(
+      confirm: z39.string().optional().describe(`Required for apply: ${APPLY_TO_PRODUCTION_CONFIRMATION}`),
+      workspaceName: z39.string().describe("Target workspace name"),
+      name: z39.string().describe("Metric display name"),
+      query: z39.string().describe(
         "SQL query to validate and store. In a TABLE-tenancy workspace never compare the client column to a fixed client value; use `client_id_variable` so each client sees only its own rows (the backend refuses it with TENANT_KEY_LITERAL)."
       ),
-      metricId: z37.string().optional().describe(
+      metricId: z39.string().optional().describe(
         "Stable metric slug. Pass an existing slug to UPDATE that metric in place. Omit to create \u2014 the slug is derived deterministically from the name (no random/uniqueness suffix), so re-running with the same name upserts the same metric rather than creating a duplicate."
       ),
-      description: z37.string().optional().describe("Metric description"),
-      datasourceId: z37.string().optional().describe("Datasource UUID override; defaults to the workspace datasource"),
-      isPublished: z37.boolean().optional().describe(
+      description: z39.string().optional().describe("Metric description"),
+      datasourceId: z39.string().optional().describe("Datasource UUID override; defaults to the workspace datasource"),
+      isPublished: z39.boolean().optional().describe(
         "Publish after apply. Defaults to false. Applies to creates; on updates the existing publish state is preserved."
       )
     },
@@ -6964,25 +7289,25 @@ function registerCreateWorkspaceMetric(server, client) {
 }
 
 // src/tools/widgets/validate-metric-spec.ts
-import { z as z38 } from "zod";
+import { z as z40 } from "zod";
 function registerValidateMetricSpec(server, client) {
   const services = createServiceBundle(client);
   server.tool(
     "validate_metric_spec",
     "Validate a production metric spec from SQL without saving it. Resolves dashboard, data app, datasource, conflicts, and required fields.",
     {
-      clientId: z38.string().describe("Client/tenant identifier used to validate dashboard widget scope"),
-      workspaceName: z38.string().describe("Target production-backed workspace name"),
-      dashboardName: z38.string().optional().describe("Dashboard name to attach to"),
-      embedId: z38.string().optional().describe("Technical embed id alternative to dashboardName"),
-      dataAppName: z38.string().optional().describe("Optional data app override"),
-      name: z38.string().describe("Metric/widget display name"),
-      metricId: z38.string().describe("Stable metric slug to create or update"),
-      query: z38.string().describe("SQL query already validated against the warehouse"),
-      description: z38.string().optional().describe("Metric description"),
-      chartOptions: z38.record(z38.unknown()).optional().describe("Chart configuration JSON"),
-      companyIntegrationId: z38.string().optional().describe("Datasource UUID override"),
-      integrationName: z38.string().optional().describe("Datasource display name override")
+      clientId: z40.string().describe("Client/tenant identifier used to validate dashboard widget scope"),
+      workspaceName: z40.string().describe("Target production-backed workspace name"),
+      dashboardName: z40.string().optional().describe("Dashboard name to attach to"),
+      embedId: z40.string().optional().describe("Technical embed id alternative to dashboardName"),
+      dataAppName: z40.string().optional().describe("Optional data app override"),
+      name: z40.string().describe("Metric/widget display name"),
+      metricId: z40.string().describe("Stable metric slug to create or update"),
+      query: z40.string().describe("SQL query already validated against the warehouse"),
+      description: z40.string().optional().describe("Metric description"),
+      chartOptions: z40.record(z40.unknown()).optional().describe("Chart configuration JSON"),
+      companyIntegrationId: z40.string().optional().describe("Datasource UUID override"),
+      integrationName: z40.string().optional().describe("Datasource display name override")
     },
     READ_ONLY,
     async (params) => {
@@ -6994,11 +7319,12 @@ function registerValidateMetricSpec(server, client) {
           embedId: params.embedId,
           dashboardName: params.dashboardName,
           workspaceName: params.workspaceName,
+          dataAppName: params.dataAppName,
           required: true
         });
         if (!embed.ok) return toolError(embed.error);
         const embedId = embed.value.embedId;
-        const ctx = await services.widgetService.resolveEmbedContext(embedId);
+        const ctx = await services.widgetService.resolveEmbedContext(embedId, params.dataAppName);
         if (!ctx.externalDashboardId) {
           return toolError(
             `Dashboard "${params.dashboardName || embedId}" has no externalDashboardId. Verify with get_embed_details before creating metrics.`
@@ -7073,20 +7399,21 @@ function registerValidateMetricSpec(server, client) {
 }
 
 // src/tools/reports/list-scheduled-reports.ts
-import { z as z39 } from "zod";
+import { z as z41 } from "zod";
 function registerListScheduledReports(server, client) {
   const services = createServiceBundle(client);
   server.tool(
     "list_scheduled_reports",
     "List configured scheduled reports for a specific client/dashboard embed. Shows schedule metadata, not delivery success history.",
     {
-      clientId: z39.string().describe("Client/tenant identifier. Required by the current backend API for non-empty results"),
-      dashboardName: z39.string().optional().describe("Dashboard name to inspect"),
-      workspaceName: z39.string().optional().describe("Workspace name if dashboardName is ambiguous"),
-      embedId: z39.string().optional().describe("Technical embed id alternative to dashboardName"),
-      userIdentifier: z39.string().optional().describe("Optional creator/user filter"),
-      pageNumber: z39.number().int().positive().optional().describe("Page number when pagination is enabled"),
-      isPagination: z39.boolean().optional().describe("Enable backend pagination")
+      clientId: z41.string().describe("Client/tenant identifier. Required by the current backend API for non-empty results"),
+      dashboardName: z41.string().optional().describe("Dashboard name to inspect"),
+      workspaceName: z41.string().optional().describe("Workspace name if dashboardName is ambiguous"),
+      dataAppName: z41.string().trim().min(1).optional().describe("Data app name when dashboard embeds span several apps"),
+      embedId: z41.string().optional().describe("Technical embed id alternative to dashboardName"),
+      userIdentifier: z41.string().optional().describe("Optional creator/user filter"),
+      pageNumber: z41.number().int().positive().optional().describe("Page number when pagination is enabled"),
+      isPagination: z41.boolean().optional().describe("Enable backend pagination")
     },
     READ_ONLY,
     async (params) => {
@@ -7095,12 +7422,16 @@ function registerListScheduledReports(server, client) {
           embedId: params.embedId,
           dashboardName: params.dashboardName,
           workspaceName: params.workspaceName,
+          dataAppName: params.dataAppName,
           required: true
         });
         if (!embed.ok) return toolError(embed.error);
         const embedId = embed.value.embedId;
+        const app = client.isHosted() ? await services.widgetService.resolveDataAppName(params.dataAppName, embedId) : { ok: true, value: params.dataAppName };
+        if (!app.ok) return toolError(app.error);
         const reports = await services.scheduledReportsApi.listByEmbed({
           embedId,
+          dataAppName: app.value,
           clientId: params.clientId,
           userIdentifier: params.userIdentifier,
           pageNumber: params.pageNumber,
@@ -7196,90 +7527,18 @@ function registerWhoami(server, client) {
 }
 
 // src/tools/custom-chart/scaffold.ts
-import { z as z41 } from "zod";
-
-// src/tools/custom-chart/shared.ts
-import { z as z40 } from "zod";
-var slotInputSchema = slotSchema;
-var optionInputSchema = optionSchema;
-var manifestInputSchema = z40.record(z40.unknown()).describe("manifest.json as an object (schemaVersion 2). Validated with the same rules as the server.");
-var bundleInputShape = {
-  manifest: manifestInputSchema.optional(),
-  bundleJs: z40.string().optional().describe("dist/index.js from `databrain custom-chart build` (the shim plus the chart module)."),
-  bundleCss: z40.string().optional().describe("The raw chart.css, kept for provenance."),
-  iconSvg: z40.string().optional().describe("icon.svg, at most 16 KiB, no script, no foreignObject, no external href."),
-  projectDir: z40.string().optional().describe("Local only: a chart project folder. The tool reads it instead of manifest/bundleJs/iconSvg.")
-};
-function formatProblems(problems) {
-  if (problems.length === 0) return "No problems.";
-  return problems.map((p) => `${p.path || "/"}  ${p.code}  ${p.message}`).join("\n");
-}
-function projectDirRefusal() {
-  if (process.env.DATABRAIN_HOSTED_PUBLIC_URL) {
-    return "projectDir is not available on the hosted server. Pass manifest, bundleJs, bundleCss and iconSvg instead.";
-  }
-  return null;
-}
-async function resolveBundleInput(params, options) {
-  if (params.projectDir) {
-    const refusal = projectDirRefusal();
-    if (refusal) return { problems: [], error: refusal, source: "projectDir" };
-    if (params.manifest || params.bundleJs || params.iconSvg) {
-      return { problems: [], error: "Pass either projectDir or manifest/bundleJs/iconSvg, not both.", source: "projectDir" };
-    }
-    if (options.build) {
-      const result = await buildProject(params.projectDir, { write: false });
-      if (!result.ok || !result.outputs) return { problems: result.problems, source: "projectDir" };
-      const { manifest, bundleJs, bundleCss, iconSvg } = result.outputs;
-      return { bundle: { manifest, bundleJs, bundleCss, iconSvg }, problems: [], source: "projectDir" };
-    }
-    const dist = readDist(params.projectDir);
-    if (!dist.bundle) return { problems: dist.problems, source: "projectDir" };
-    return { bundle: dist.bundle, problems: [], source: "projectDir" };
-  }
-  if (!params.manifest) {
-    return { problems: [], error: "manifest is required (or pass projectDir when running locally).", source: "arguments" };
-  }
-  return {
-    bundle: {
-      manifest: params.manifest,
-      bundleJs: params.bundleJs,
-      bundleCss: params.bundleCss,
-      iconSvg: params.iconSvg
-    },
-    problems: [],
-    source: "arguments"
-  };
-}
-async function remoteValidate(client, bundle) {
-  try {
-    const result = await createCustomChartsApi(client).validate(bundle);
-    return { status: "ok", result };
-  } catch (err) {
-    if (err instanceof DatabrainApiError) {
-      if (err.code === "MISSING_SERVICE_TOKEN") {
-        return { status: "skipped", reason: "No service token is configured, so only the local validator ran." };
-      }
-      return { status: "failed", reason: err.message, problems: apiProblems(err) };
-    }
-    return { status: "failed", reason: err.message, problems: [] };
-  }
-}
-function isCompleteBundle(bundle) {
-  return typeof bundle.bundleJs === "string" && typeof bundle.iconSvg === "string";
-}
-
-// src/tools/custom-chart/scaffold.ts
+import { transformSync } from "esbuild";
+import { z as z42 } from "zod";
 function registerCustomChartScaffold(server, _client) {
   server.tool(
     "custom_chart_scaffold",
-    "Return the files of a new custom chart project (manifest.json, chart.ts, chart.css, icon.svg, sample data, guide). Nothing is written or persisted; write the files yourself.",
+    "Return the files of a new custom chart project (manifest.json, chart.ts, chart.css, icon.svg, sample data, guide). Nothing is persisted. For a hosted AI app, edit the returned draft and pass chartTs to validate, preview and upload without local files.",
     {
-      key: z41.string().describe("Chart key, becomes chart type custom:<key>. Lowercase letters, digits, _ and -, 64 max."),
-      name: z41.string().describe("Display name shown in the chart picker, 1 to 256 characters."),
-      description: z41.string().optional().describe("Optional description, up to 500 characters."),
-      slots: z41.array(slotInputSchema).optional().describe("Data slots. Defaults to category (dimension), value (measure), target (optional measure)."),
-      options: z41.array(optionInputSchema).optional().describe("Chart options. Defaults to the template options (labels, subtitle, radius, colour, sort).")
+      key: z42.string().describe("Chart key, becomes chart type custom:<key>. Lowercase letters, digits, _ and -, 64 max."),
+      name: z42.string().describe("Display name shown in the chart picker, 1 to 256 characters."),
+      description: z42.string().optional().describe("Optional description, up to 500 characters."),
+      slots: z42.array(slotInputSchema).optional().describe("Data slots. Defaults to category (dimension), value (measure), target (optional measure)."),
+      options: z42.array(optionInputSchema).optional().describe("Chart options. Defaults to the template options (labels, subtitle, radius, colour, sort).")
     },
     READ_ONLY,
     async (params) => {
@@ -7302,7 +7561,19 @@ ${formatProblems(result.problems)}`);
               key: params.key,
               chartType: `custom:${params.key}`,
               files: result.files,
-              nextStep: result.nextStep
+              draft: {
+                code: transformSync(result.files["chart.ts"], { loader: "ts", format: "esm" }).code.replace(/export\s*\{[^}]*\};?\s*$/, ""),
+                css: result.files["chart.css"],
+                manifest: JSON.parse(result.files["manifest.json"]),
+                sampleData: (() => {
+                  const sample = JSON.parse(result.files["sample-data.json"]);
+                  return { columns: sample.columns.map(({ id: id2, label, type, slotId }) => ({ id: id2, label, type, ...slotId ? { slotId } : {} })), rows: sample.rows };
+                })(),
+                name: params.name,
+                description: params.description ?? "",
+                iconSvg: result.files["icon.svg"]
+              },
+              nextStep: "Hosted: pass draft to custom_chart_edit with a description and workspaceId. Then validate/preview/upload using chartTs=draft.code, manifest, bundleCss=draft.css and iconSvg. Upload saves a version; publishing requires explicit confirmation. Local project: " + result.nextStep
             },
             null,
             2
@@ -7371,18 +7642,18 @@ function registerCustomChartValidate(server, client) {
 }
 
 // src/tools/custom-chart/upload.ts
-import { z as z42 } from "zod";
+import { z as z43 } from "zod";
 function registerCustomChartUpload(server, client) {
   const api = createCustomChartsApi(client);
   server.tool(
     "custom_chart_upload",
     "Upload a built custom chart bundle to the company. Creates the chart (private, version 1) or a new preview version. Defaults to dry_run; apply requires explicit confirmation and can publish in the same call.",
     {
-      mode: z42.enum(["dry_run", "apply"]).default("dry_run").describe("dry_run validates and returns the plan; apply uploads."),
-      confirm: z42.string().optional().describe(`Required for apply: ${APPLY_TO_PRODUCTION_CONFIRMATION}`),
-      publish: z42.boolean().default(false).describe("After a successful apply, publish the uploaded version so every builder can use it."),
-      name: z42.string().optional().describe("Display name override. Defaults to manifest.name."),
-      description: z42.string().optional().describe("Description override. Defaults to manifest.description."),
+      mode: z43.enum(["dry_run", "apply"]).default("dry_run").describe("dry_run validates and returns the plan; apply uploads."),
+      confirm: z43.string().optional().describe(`Required for apply: ${APPLY_TO_PRODUCTION_CONFIRMATION}`),
+      publish: z43.boolean().default(false).describe("After a successful apply, publish the uploaded version so every builder can use it."),
+      name: z43.string().optional().describe("Display name override. Defaults to manifest.name."),
+      description: z43.string().optional().describe("Description override. Defaults to manifest.description."),
       ...bundleInputShape
     },
     WRITE_CREATE,
@@ -7523,17 +7794,17 @@ function registerListCustomCharts(server, client) {
 }
 
 // src/tools/custom-chart/publish.ts
-import { z as z43 } from "zod";
+import { z as z44 } from "zod";
 function registerPublishCustomChart(server, client) {
   const api = createCustomChartsApi(client);
   server.tool(
     "publish_custom_chart",
     "Publish a custom chart version so every builder in the company can use chart type custom:<key>. Defaults to the preview version. Defaults to dry_run; apply requires explicit confirmation.",
     {
-      key: z43.string().describe("The chart key (manifest.id), for example revenue-bars."),
-      versionId: z43.string().optional().describe("A specific version id to publish. Defaults to the preview version."),
-      mode: z43.enum(["dry_run", "apply"]).default("dry_run").describe("dry_run shows what would be published; apply publishes."),
-      confirm: z43.string().optional().describe(`Required for apply: ${APPLY_TO_PRODUCTION_CONFIRMATION}`)
+      key: z44.string().describe("The chart key (manifest.id), for example revenue-bars."),
+      versionId: z44.string().optional().describe("A specific version id to publish. Defaults to the preview version."),
+      mode: z44.enum(["dry_run", "apply"]).default("dry_run").describe("dry_run shows what would be published; apply publishes."),
+      confirm: z44.string().optional().describe(`Required for apply: ${APPLY_TO_PRODUCTION_CONFIRMATION}`)
     },
     WRITE_IDEMPOTENT,
     async (params) => {
@@ -7629,6 +7900,7 @@ var TOOL_TITLES = {
   apply_semantic_change: "Apply semantic model change",
   eval_semantic_model: "Evaluate semantic model",
   list_widgets: "List widgets",
+  render_metric_tile: "Render a saved metric tile",
   validate_metric_spec: "Validate metric spec",
   create_or_update_metric_from_query: "Create or update metric from SQL",
   create_workspace_metric: "Create workspace metric",
@@ -7728,6 +8000,7 @@ function registerAllTools(server, client) {
   registerGenerateWidget(server, client);
   registerListScheduledReports(server, client);
   registerCustomChartScaffold(server, client);
+  registerCustomChartAuthor(server, client);
   registerCustomChartValidate(server, client);
   registerCustomChartUpload(server, client);
   registerListCustomCharts(server, client);
@@ -9619,7 +9892,7 @@ The v2 source is one YAML document. Use the configured service credential and a
 
 1. \`search_semantic_model\` finds entities by question. \`get_semantic_entity\` reads one entity by kind and name. Column names use table.column.
 2. \`propose_semantic_change\` takes complete source YAML, a YAML patch or one structured change. It returns candidate source, validation errors, a plan and the stored expected hash without writing.
-3. \`eval_semantic_model\` evaluates the proposed source.
+3. \`eval_semantic_model\` checks closed-world assertions against the proposed source; optional questions use id, question and exercises (exact entity names). It does not execute SQL.
 4. \`apply_semantic_change\` defaults to a dry run. Live apply requires the exact reviewed source, \`expected_content_hash\`, \`dry_run: false\` and user supplied \`confirm: "APPLY_TO_PRODUCTION"\`. Never supply confirmation yourself. Apply changes the live model for all consumers. On a conflict, prepare a fresh proposal and review it again.
 
 YAML patches merge mappings and named lists by name. Other lists replace. Empty lists clear; null removes a field. Structured changes use operation upsert or remove, kind, name, and value for upsert. Column changes also require table. Patch output normalizes formatting and comments, so review the returned source before apply.
@@ -10700,7 +10973,7 @@ var populateSemanticLayerPrompt = `You are helping the user populate the semanti
 If \`list_datamarts\` reports \`semanticLayerVersion: "v2"\`, or the selected datamart is already known to use v2, use this workflow instead of the legacy steps below:
 1. Inspect relevant entities with \`search_semantic_model\` and \`get_semantic_entity\`, using the datamart ID.
 2. Call \`propose_semantic_change\` with a YAML patch or structured change. Show its errors and plan. Correct errors before continuing.
-3. Call \`eval_semantic_model\` with the returned source. Show the verdicts and let the user review the candidate.
+3. Call \`eval_semantic_model\` with the returned source. For scored assertions, supply questions with id, question and exercises (exact model entity names); this does not run SQL. Show the verdicts and let the user review the candidate.
 4. Stop for the user's explicit \`APPLY_TO_PRODUCTION\` confirmation. Never supply it yourself.
 5. Call \`apply_semantic_change\` with the exact reviewed source, its \`expected_content_hash\`, \`dry_run: false\` and the user's confirmation. A conflict requires a new proposal and review.
 6. Call \`get_semantic_entity\` and inspect the changed entity. Do not call \`update_semantic_layer\` for a v2 model.
@@ -11066,20 +11339,24 @@ function registerAllPrompts(server) {
 }
 
 export {
-  createServiceBundle,
   READ_ONLY,
   WRITE_CREATE,
-  APPLY_TO_PRODUCTION_CONFIRMATION,
   CHART_URI,
   KPI_URI,
   APP_MIME,
+  MAX_CUSTOM_BUNDLE_CHARS,
+  CUSTOM_BUNDLE_CHUNK_CHARS,
   rowsSchema,
   referenceSchema,
+  dateRangeSchema,
   viewSchema,
   pageSchema,
+  bounded,
   appMeta,
   enableChartApps,
   chartResult,
+  createServiceBundle,
+  APPLY_TO_PRODUCTION_CONFIRMATION,
   draftSchema,
   PREVIEW_PATH,
   RENDER_TYPES,
@@ -11090,4 +11367,4 @@ export {
   registerAllResources,
   registerAllPrompts
 };
-//# sourceMappingURL=chunk-ERTAKB2H.js.map
+//# sourceMappingURL=chunk-OLOC2MTA.js.map