@databrainhq/mcp-server 0.1.0 → 0.1.1-test

package/dist/index.js

@@ -173,7 +173,7 @@ var DatabrainClient = class {
       throw new DatabrainApiError(
         401,
         "MISSING_TOKEN",
-        `${tokenType} is required for this operation but is not configured.${options.auth === "api" ? " Use the `create_api_token` tool to generate one." : " Set it in your MCP server environment variables."}`
+        `${tokenType} is required for this operation but is not configured.${options.auth === "api" ? " Use `set_api_token` to provide an existing token, or `create_api_token` to generate a new one." : " Set it in your MCP server environment variables."}`
       );
     }
     let url = `${this.config.apiUrl}${options.path}`;
@@ -290,14 +290,117 @@ ${formatted}`);
   );
 }
 
-// src/tools/data-app/create-data-app.ts
+// src/tools/infrastructure/create-datasource.ts
 import { z as z2 } from "zod";
+var DATASOURCE_TYPES = [
+  "postgres",
+  "snowflake",
+  "bigquery",
+  "mysql",
+  "redshift",
+  "cockroachdb",
+  "mssql",
+  "clickhouse",
+  "singlestore",
+  "mongodb",
+  "databricks",
+  "elasticsearch",
+  "opensearch",
+  "firebolt",
+  "athena",
+  "trino",
+  "awss3",
+  "csv"
+];
+var schema = {
+  datasourceType: z2.enum(DATASOURCE_TYPES).describe("Database type to connect"),
+  credentials: z2.record(z2.unknown()).describe(
+    "Connection credentials object. Required fields vary by type. Always include `name` (unique datasource name). Postgres/MySQL: host, port, username, password, database. Snowflake: host, username, role, warehouse, database, schema, password. BigQuery: credentials_json, project_id, dataset_location."
+  ),
+  tenancySettings: z2.object({
+    tenancyLevel: z2.enum(["TABLE", "DATABASE"]).optional(),
+    clientColumnType: z2.string().optional(),
+    schemaName: z2.string().optional(),
+    tableName: z2.string().optional(),
+    tableClientNameColumn: z2.string().optional(),
+    tablePrimaryKeyColumn: z2.string().optional()
+  }).optional().describe("Multi-tenant configuration")
+};
+function registerCreateDatasource(server, client) {
+  server.tool(
+    "create_datasource",
+    "Connect a new database to Databrain. Supports Postgres, Snowflake, BigQuery, MySQL, Redshift, and more.",
+    schema,
+    async (params) => {
+      try {
+        const body = {
+          datasourceType: params.datasourceType,
+          ...params.credentials
+        };
+        if (params.tenancySettings) {
+          body.tenancySettings = params.tenancySettings;
+        }
+        const result = await client.request({
+          method: "POST",
+          path: "/api/v2/datasource/",
+          body,
+          auth: "service",
+          invalidateCache: ["list_datasources"]
+        });
+        return toolSuccess(
+          `Datasource "${result.name}" created successfully.
+
+Next steps:
+1. Use \`sync_datasource\` to refresh the schema metadata
+2. Use \`create_data_app\` to create a data app
+3. Use \`create_datamart\` to select tables for analytics`
+        );
+      } catch (err) {
+        if (err instanceof DatabrainApiError) return err.toToolResponse();
+        return toolError(`Unexpected error: ${err.message}`);
+      }
+    }
+  );
+}
+
+// src/tools/infrastructure/sync-datasource.ts
+import { z as z3 } from "zod";
+function registerSyncDatasource(server, client) {
+  server.tool(
+    "sync_datasource",
+    "Trigger a datasource schema sync to refresh table and column metadata.",
+    {
+      datasourceName: z3.string().describe("Name of the datasource to sync")
+    },
+    async (params) => {
+      try {
+        const result = await client.request({
+          method: "POST",
+          path: "/api/v2/datasource/sync",
+          body: { datasourceName: params.datasourceName },
+          auth: "service"
+        });
+        return toolSuccess(
+          `Datasource "${params.datasourceName}" sync triggered.
+Status: ${result.status || "initiated"}
+` + (result.message ? `Message: ${result.message}` : "") + "\n\nThe schema metadata will be refreshed. You can now use `create_datamart` to select tables."
+        );
+      } catch (err) {
+        if (err instanceof DatabrainApiError) return err.toToolResponse();
+        return toolError(`Unexpected error: ${err.message}`);
+      }
+    }
+  );
+}
+
+// src/tools/data-app/create-data-app.ts
+import { z as z4 } from "zod";
 function registerCreateDataApp(server, client) {
   server.tool(
     "create_data_app",
     "Create a new data app \u2014 a logical container for embeds, tokens, and dashboards.",
     {
-      name: z2.string().describe("Unique alphanumeric name for the data app")
+      name: z4.string().describe("Unique alphanumeric name for the data app")
     },
     async (params) => {
       try {
@@ -324,13 +427,13 @@ Next steps:
 }
 
 // src/tools/data-app/list-data-apps.ts
-import { z as z3 } from "zod";
+import { z as z5 } from "zod";
 function registerListDataApps(server, client) {
   server.tool(
     "list_data_apps",
     "List all data apps in your Databrain organization.",
     {
-      workspaceName: z3.string().optional().describe("Filter by workspace name")
+      workspaceName: z5.string().optional().describe("Filter by workspace name")
     },
     async (params) => {
       try {
@@ -364,17 +467,35 @@ ${formatted}`);
 }
 
 // src/tools/data-app/create-api-token.ts
-import { z as z4 } from "zod";
+import { z as z6 } from "zod";
 function registerCreateApiToken(server, client) {
   server.tool(
     "create_api_token",
-    "Create an API token scoped to a data app. The token is shown once \u2014 save it securely. The server will use it for subsequent embed/guest-token operations in this session.",
+    "Create an API token scoped to a data app. There should be ONE API token per data app \u2014 do not create duplicates. Call `list_api_tokens` first to check if one already exists. If it does, use `set_api_token` instead.",
     {
-      dataAppName: z4.string().describe("Name of the data app to scope the token to"),
-      name: z4.string().describe('Descriptive label for the token (e.g., "Production API Key")')
+      dataAppName: z6.string().describe("Name of the data app to scope the token to"),
+      name: z6.string().describe('Descriptive label for the token (e.g., "Production API Key")')
     },
     async (params) => {
       try {
+        const existing = await client.request({
+          method: "GET",
+          path: "/api/v2/data-app/api-tokens",
+          auth: "service",
+          query: { dataAppName: params.dataAppName }
+        });
+        if (Array.isArray(existing) && existing.length > 0) {
+          const tokenNames = existing.map((t) => t.name || "Unnamed").join(", ");
+          return toolError(
+            `An API token already exists for "${params.dataAppName}": ${tokenNames}
+
+There should be **one API token per data app** \u2014 do not create duplicates.
+
+Options:
+1. If you have the token \u2192 use \`set_api_token\` to configure it for this session
+2. If the token is lost \u2192 use \`rotate_api_token\` to get a new one (old token stops working)`
+          );
+        }
         const result = await client.request({
           method: "POST",
           path: "/api/v2/data-app/api-tokens",
@@ -388,8 +509,10 @@ function registerCreateApiToken(server, client) {
 **Token:** \`${result.key}\`
 
 \u26A0\uFE0F **IMPORTANT:** Save this token securely \u2014 it will not be shown again.
+Store it as \`DATABRAIN_API_TOKEN\` in your backend environment.
+This is the **only** API token needed for this data app \u2014 reuse it across sessions.
 
-This token has been set for use in this session. You can also set it as the \`DATABRAIN_API_TOKEN\` environment variable for future sessions.
+This token has been set for use in this session.
 
 Next steps:
 1. Use \`create_embed\` to configure an embed
@@ -404,13 +527,13 @@ Next steps:
 }
 
 // src/tools/data-app/list-api-tokens.ts
-import { z as z5 } from "zod";
+import { z as z7 } from "zod";
 function registerListApiTokens(server, client) {
   server.tool(
     "list_api_tokens",
     "List API tokens for a data app.",
     {
-      dataAppName: z5.string().describe("Name of the data app")
+      dataAppName: z7.string().describe("Name of the data app")
     },
     async (params) => {
       try {
@@ -440,13 +563,13 @@ ${formatted}`);
 }
 
 // src/tools/data-app/rotate-api-token.ts
-import { z as z6 } from "zod";
+import { z as z8 } from "zod";
 function registerRotateApiToken(server, client) {
   server.tool(
     "rotate_api_token",
     "Rotate an API token for a data app. The old token is immediately invalidated.",
     {
-      dataAppName: z6.string().describe("Name of the data app")
+      dataAppName: z8.string().describe("Name of the data app")
     },
     async (params) => {
       try {
@@ -473,14 +596,32 @@ Save it securely \u2014 it will not be shown again.`
   );
 }
 
+// src/tools/data-app/set-api-token.ts
+import { z as z9 } from "zod";
+function registerSetApiToken(server, client) {
+  server.tool(
+    "set_api_token",
+    "Set an existing API token for this MCP session. Use this when you already have an API token (from a previous `create_api_token` call or from your team) but it is not configured in the DATABRAIN_API_TOKEN environment variable. This unlocks all embed, guest token, and query tools for the session.",
+    {
+      apiToken: z9.string().describe("The API token to use for this session")
+    },
+    async (params) => {
+      client.setRuntimeApiToken(params.apiToken);
+      return toolSuccess(
+        "API token set for this session.\n\nYou can now use all embed, guest token, and query tools.\n\nTo avoid this step in future sessions, set `DATABRAIN_API_TOKEN` in your MCP server environment variables."
+      );
+    }
+  );
+}
+
 // src/tools/datamart/list-datamarts.ts
-import { z as z7 } from "zod";
+import { z as z10 } from "zod";
 function registerListDatamarts(server, client) {
   server.tool(
     "list_datamarts",
     "List datamarts with table and schema information.",
     {
-      dataAppName: z7.string().optional().describe("Filter by data app name")
+      dataAppName: z10.string().optional().describe("Filter by data app name")
     },
     async (params) => {
       try {
@@ -515,14 +656,86 @@ ${formatted}`);
   );
 }
 
+// src/tools/datamart/create-datamart.ts
+import { z as z11 } from "zod";
+var columnSchema = z11.object({
+  name: z11.string(),
+  alias: z11.string().optional(),
+  label: z11.string().optional(),
+  isHide: z11.boolean().optional(),
+  isCustomColumn: z11.boolean().optional(),
+  sql: z11.string().optional()
+});
+var tableSchema = z11.object({
+  name: z11.string(),
+  schemaName: z11.string().optional(),
+  clientColumn: z11.string().optional(),
+  label: z11.string().optional(),
+  columns: z11.array(columnSchema)
+});
+var relationshipSchema = z11.object({
+  parentTableName: z11.string(),
+  parentColumnName: z11.string(),
+  childTableName: z11.string(),
+  childColumnName: z11.string(),
+  cardinality: z11.enum(["OneToOne", "OneToMany", "ManyToOne", "ManyToMany"]),
+  join: z11.enum(["INNER JOIN", "LEFT JOIN", "RIGHT JOIN", "FULL JOIN"]),
+  relationshipName: z11.string()
+});
+function registerCreateDatamart(server, client) {
+  server.tool(
+    "create_datamart",
+    "Create a datamart \u2014 a curated subset of tables for analytics. Select tables, columns, and define relationships.",
+    {
+      name: z11.string().describe("Unique datamart name"),
+      datasourceName: z11.string().describe("Name of the datasource to use"),
+      tableList: z11.array(tableSchema).describe("Array of tables with their columns"),
+      relationships: z11.array(relationshipSchema).optional().describe("Join definitions between tables"),
+      tenancySettings: z11.object({
+        tenancyLevel: z11.enum(["TABLE", "DATABASE"]).optional(),
+        clientColumnType: z11.string().optional(),
+        schemaName: z11.string().optional(),
+        tableName: z11.string().optional(),
+        tableClientNameColumn: z11.string().optional(),
+        tablePrimaryKeyColumn: z11.string().optional()
+      }).optional().describe("Multi-tenant configuration")
+    },
+    async (params) => {
+      try {
+        const result = await client.request({
+          method: "POST",
+          path: "/api/v2/data-app/datamarts",
+          body: params,
+          auth: "service",
+          invalidateCache: ["list_datamarts"]
+        });
+        if (result.error) {
+          return toolError(`Datamart creation failed: ${result.error}`);
+        }
+        return toolSuccess(
+          `Datamart "${params.name}" created successfully (ID: ${result.id}).
+
+Next steps:
+1. Use \`generate_semantic_layer\` to make this datamart AI-ready (recommended for AI chat mode)
+2. Create a dashboard in the Databrain UI using this datamart
+3. Use \`create_embed\` to embed the dashboard`
+        );
+      } catch (err) {
+        if (err instanceof DatabrainApiError) return err.toToolResponse();
+        return toolError(`Unexpected error: ${err.message}`);
+      }
+    }
+  );
+}
+
 // src/tools/datamart/get-semantic-layer-status.ts
-import { z as z8 } from "zod";
+import { z as z12 } from "zod";
 function registerGetSemanticLayerStatus(server, client) {
   server.tool(
     "get_semantic_layer_status",
     "Check progress of a semantic layer generation job.",
     {
-      datamartId: z8.string().describe("ID of the datamart")
+      datamartId: z12.string().describe("ID of the datamart")
     },
     async (params) => {
       try {
@@ -552,24 +765,55 @@ Progress: ${progress}
   );
 }
 
+// src/tools/datamart/generate-semantic-layer.ts
+import { z as z13 } from "zod";
+function registerGenerateSemanticLayer(server, client) {
+  server.tool(
+    "generate_semantic_layer",
+    "Trigger AI-powered semantic layer auto-generation for a datamart. Required for AI chat mode to work well. This is an async job \u2014 use `get_semantic_layer_status` to check progress.",
+    {
+      datamartId: z13.string().describe("ID of the datamart to generate semantic layer for")
+    },
+    async (params) => {
+      try {
+        const result = await client.request({
+          method: "POST",
+          path: `/api/schema/datamart/${params.datamartId}/semantic-layer/auto-generate`,
+          body: {},
+          auth: "service"
+        });
+        return toolSuccess(
+          "Semantic layer generation started.\n\n" + (result.jobId ? `Job ID: ${result.jobId}
+` : "") + `Status: ${result.status || "initiated"}
+
+Use \`get_semantic_layer_status\` to check progress. This may take a few minutes depending on the number of tables and columns.`
+        );
+      } catch (err) {
+        if (err instanceof DatabrainApiError) return err.toToolResponse();
+        return toolError(`Unexpected error: ${err.message}`);
+      }
+    }
+  );
+}
+
 // src/tools/embed/create-embed.ts
-import { z as z9 } from "zod";
-var accessSettingsSchema = z9.object({
-  datamartName: z9.string(),
-  isAllowAiPilot: z9.boolean().optional().default(false),
-  isAllowEmailReports: z9.boolean(),
-  isAllowManageMetrics: z9.boolean(),
-  isAllowCreateDashboardView: z9.boolean(),
-  isAllowMetricCreation: z9.boolean(),
-  isAllowMetricDeletion: z9.boolean(),
-  isAllowMetricLayoutChange: z9.boolean(),
-  isAllowMetricUpdate: z9.boolean(),
-  isAllowUnderlyingData: z9.boolean(),
-  metricCreationMode: z9.enum(["DRAG_DROP", "CHAT"]),
-  joinModel: z9.enum(["single", "multi"]).optional().default("multi"),
-  tableTenancySettings: z9.array(z9.object({
-    name: z9.string(),
-    clientColumn: z9.string()
+import { z as z14 } from "zod";
+var accessSettingsSchema = z14.object({
+  datamartName: z14.string(),
+  isAllowAiPilot: z14.boolean().optional().default(false),
+  isAllowEmailReports: z14.boolean(),
+  isAllowManageMetrics: z14.boolean(),
+  isAllowCreateDashboardView: z14.boolean(),
+  isAllowMetricCreation: z14.boolean(),
+  isAllowMetricDeletion: z14.boolean(),
+  isAllowMetricLayoutChange: z14.boolean(),
+  isAllowMetricUpdate: z14.boolean(),
+  isAllowUnderlyingData: z14.boolean(),
+  metricCreationMode: z14.enum(["DRAG_DROP", "CHAT"]),
+  joinModel: z14.enum(["single", "multi"]).optional().default("multi"),
+  tableTenancySettings: z14.array(z14.object({
+    name: z14.string(),
+    clientColumn: z14.string()
   })).optional()
 });
 function registerCreateEmbed(server, client) {
@@ -577,11 +821,11 @@ function registerCreateEmbed(server, client) {
     "create_embed",
     "Create an embed configuration for a dashboard or metric. Requires an API token.",
     {
-      dashboardId: z9.string().describe("ID of the dashboard to embed"),
-      embedType: z9.enum(["dashboard", "metric"]).describe("Type of embed"),
-      workspaceName: z9.string().describe("Workspace name"),
-      metricId: z9.string().optional().describe('Required if embedType is "metric"'),
-      name: z9.string().optional().describe("Human-readable name for the embed"),
+      dashboardId: z14.string().describe("ID of the dashboard to embed"),
+      embedType: z14.enum(["dashboard", "metric"]).describe("Type of embed"),
+      workspaceName: z14.string().describe("Workspace name"),
+      metricId: z14.string().optional().describe('Required if embedType is "metric"'),
+      name: z14.string().optional().describe("Human-readable name for the embed"),
       accessSettings: accessSettingsSchema.describe("Access and permission settings for the embed")
     },
     async (params) => {
@@ -612,13 +856,13 @@ Next steps:
 }
 
 // src/tools/embed/list-embeds.ts
-import { z as z10 } from "zod";
+import { z as z15 } from "zod";
 function registerListEmbeds(server, client) {
   server.tool(
     "list_embeds",
     "List all embed configurations. Requires an API token.",
     {
-      dataAppName: z10.string().optional().describe("Filter by data app name")
+      dataAppName: z15.string().optional().describe("Filter by data app name")
     },
     async (params) => {
       try {
@@ -656,13 +900,13 @@ ${formatted}`);
 }
 
 // src/tools/embed/get-embed-details.ts
-import { z as z11 } from "zod";
+import { z as z16 } from "zod";
 function registerGetEmbedDetails(server, client) {
   server.tool(
     "get_embed_details",
     "Get detailed configuration for a specific embed, including all access settings.",
     {
-      embedId: z11.string().describe("ID of the embed")
+      embedId: z16.string().describe("ID of the embed")
     },
     async (params) => {
       try {
@@ -687,26 +931,43 @@ function registerGetEmbedDetails(server, client) {
 }
 
 // src/tools/embed/update-embed.ts
-import { z as z12 } 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.";
+async function getEmbedForUpdate(client, embedId) {
+  const existing = await client.request({
+    method: "GET",
+    path: "/api/v2/data-app/embeds",
+    auth: "api",
+    query: { embedId }
+  });
+  return {
+    embedId,
+    accessSettings: existing.accessSettings ?? {}
+  };
+}
+
+// src/tools/embed/update-embed.ts
 function registerUpdateEmbed(server, client) {
   server.tool(
     "update_embed",
     "Update embed configuration \u2014 access settings, permissions, theme, or name.",
     {
-      embedId: z12.string().describe("ID of the embed to update"),
-      name: z12.string().optional().describe("New name for the embed"),
-      accessSettings: z12.record(z12.unknown()).optional().describe(
+      embedId: z17.string().describe("ID of the embed to update"),
+      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: z12.record(z12.unknown()).optional().describe(
+      theme: z17.record(z17.unknown()).optional().describe(
         "Theme configuration object. See databrain://theme-reference for the full schema."
       )
     },
     async (params) => {
       try {
-        const body = { embedId: params.embedId };
+        const body = await getEmbedForUpdate(client, params.embedId);
         if (params.name) body.name = params.name;
-        if (params.accessSettings) body.accessSettings = params.accessSettings;
+        if (params.accessSettings) body.accessSettings = { ...body.accessSettings, ...params.accessSettings };
         if (params.theme) body.theme = params.theme;
         const result = await client.request({
           method: "PUT",
@@ -718,7 +979,7 @@ function registerUpdateEmbed(server, client) {
         if (result.error) {
           return toolError(`Embed update failed: ${stringify(result.error)}`);
         }
-        return toolSuccess(`Embed "${params.embedId}" updated successfully.`);
+        return toolSuccess(`Embed "${params.embedId}" updated successfully.` + GUEST_TOKEN_REMINDER);
       } catch (err) {
         if (err instanceof DatabrainApiError) return err.toToolResponse();
         return toolError(`Unexpected error: ${err.message}`);
@@ -728,13 +989,13 @@ function registerUpdateEmbed(server, client) {
 }
 
 // src/tools/embed/delete-embed.ts
-import { z as z13 } from "zod";
+import { z as z18 } from "zod";
 function registerDeleteEmbed(server, client) {
   server.tool(
     "delete_embed",
     "Delete an embed configuration. This is irreversible.",
     {
-      embedId: z13.string().describe("ID of the embed to delete")
+      embedId: z18.string().describe("ID of the embed to delete")
     },
     async (params) => {
       try {
@@ -754,14 +1015,14 @@ function registerDeleteEmbed(server, client) {
 }
 
 // src/tools/embed/rename-embed.ts
-import { z as z14 } from "zod";
+import { z as z19 } from "zod";
 function registerRenameEmbed(server, client) {
   server.tool(
     "rename_embed",
     "Rename an embed configuration.",
     {
-      embedId: z14.string().describe("ID of the embed to rename"),
-      name: z14.string().describe("New name for the embed")
+      embedId: z19.string().describe("ID of the embed to rename"),
+      name: z19.string().describe("New name for the embed")
     },
     async (params) => {
       try {
@@ -782,7 +1043,7 @@ function registerRenameEmbed(server, client) {
 }
 
 // src/tools/embed/apply-theme-preset.ts
-import { z as z15 } from "zod";
+import { z as z20 } from "zod";
 var THEME_PRESETS = {
   light: {
     general: {
@@ -928,25 +1189,760 @@ var ACCESS_PRESETS = {
 };
 function registerApplyThemePreset(server, client) {
   server.tool(
-    "apply_embed_preset",
-    `Apply a theme and/or access preset to an embed. Theme presets: ${Object.keys(THEME_PRESETS).join(", ")}. Access presets: ${Object.keys(ACCESS_PRESETS).join(", ")}. You can apply one or both.`,
+    "apply_embed_preset",
+    `Apply a theme and/or access preset to an embed. Theme presets: ${Object.keys(THEME_PRESETS).join(", ")}. Access presets: ${Object.keys(ACCESS_PRESETS).join(", ")}. You can apply one or both.`,
+    {
+      embedId: z20.string().describe("ID of the embed to update"),
+      themePreset: z20.enum(["light", "dark", "corporate", "minimal"]).optional().describe("Theme preset to apply"),
+      accessPreset: z20.enum(["view-only", "power-user", "export-only", "ai-enabled"]).optional().describe("Access settings preset to apply")
+    },
+    async (params) => {
+      if (!params.themePreset && !params.accessPreset) {
+        return toolError("Provide at least one of themePreset or accessPreset.");
+      }
+      try {
+        const body = await getEmbedForUpdate(client, params.embedId);
+        if (params.themePreset) {
+          body.theme = THEME_PRESETS[params.themePreset];
+        }
+        if (params.accessPreset) {
+          body.accessSettings = { ...body.accessSettings, ...ACCESS_PRESETS[params.accessPreset] };
+        }
+        const result = await client.request({
+          method: "PUT",
+          path: "/api/v2/data-app/embeds",
+          body,
+          auth: "api",
+          invalidateCache: ["list_embeds"]
+        });
+        if (result.error) {
+          return toolError(`Failed to apply preset: ${stringify(result.error)}`);
+        }
+        const applied = [];
+        if (params.themePreset) applied.push(`theme: **${params.themePreset}**`);
+        if (params.accessPreset) applied.push(`access: **${params.accessPreset}**`);
+        let details = "";
+        if (params.accessPreset) {
+          const settings = ACCESS_PRESETS[params.accessPreset];
+          const enabled = Object.entries(settings).filter(([, v]) => v === true).map(([k]) => k).join(", ");
+          details = `
+
+Enabled settings: ${enabled || "none"}`;
+          if (settings.metricCreationMode) {
+            details += `
+Metric creation mode: ${settings.metricCreationMode}`;
+          }
+        }
+        return toolSuccess(
+          `Preset applied to embed "${params.embedId}": ${applied.join(", ")}.${details}` + GUEST_TOKEN_REMINDER
+        );
+      } catch (err) {
+        if (err instanceof DatabrainApiError) return err.toToolResponse();
+        return toolError(`Unexpected error: ${err.message}`);
+      }
+    }
+  );
+}
+
+// src/tools/embed/customize-theme.ts
+import { z as z21 } from "zod";
+var fontFamilyEnum = z21.enum([
+  "Inter",
+  "Roboto",
+  "Open Sans",
+  "Lato",
+  "Poppins",
+  "Montserrat",
+  "IBM Plex Sans",
+  "Source Sans Pro",
+  "Nunito",
+  "system-ui"
+]).describe("Font family");
+var tooltipFontSchema = z21.object({
+  fontFamily: z21.string().optional(),
+  fontSize: z21.number().optional(),
+  fontWeight: z21.number().optional(),
+  fontColor: z21.string().optional()
+}).optional();
+function registerCustomizeTheme(server, client) {
+  server.tool(
+    "customize_embed_theme",
+    "Customize the visual theme of an embed \u2014 colors, typography, card styling, dashboard layout, and chart appearance. Apply granular theming without needing to know the full JSON schema.",
+    {
+      embedId: z21.string().describe("ID of the embed to theme"),
+      // General
+      fontFamily: fontFamilyEnum.optional().describe("Global font family"),
+      datePickerFormat: z21.string().optional().describe("Date picker display format"),
+      // Colors
+      primaryColor: z21.string().optional().describe("Primary accent color (hex)"),
+      backgroundColor: z21.string().optional().describe("Overall background color (hex)"),
+      textColor: z21.string().optional().describe("Default text color (hex)"),
+      ctaColor: z21.string().optional().describe("Call-to-action button color (hex)"),
+      ctaTextColor: z21.string().optional().describe("CTA button text color (hex)"),
+      // Dashboard
+      dashboardBackgroundColor: z21.string().optional().describe("Dashboard container background color (hex)"),
+      selectBoxSize: z21.enum(["small", "medium", "large"]).optional().describe("Filter select box size"),
+      selectBoxVariant: z21.enum(["floating", "outlined", "standard"]).optional().describe("Filter select box style"),
+      selectBoxBorderRadius: z21.string().optional().describe('Select box border radius (e.g. "20px")'),
+      selectBoxTextColor: z21.string().optional().describe("Select box text color (hex)"),
+      // Card Title
+      cardTitleFontSize: z21.string().optional().describe('Card title font size (e.g. "16px")'),
+      cardTitleFontWeight: z21.string().optional().describe('Card title font weight (e.g. "600")'),
+      cardTitleColor: z21.string().optional().describe("Card title text color (hex)"),
+      // Card Description
+      cardDescriptionFontSize: z21.string().optional().describe('Card description font size (e.g. "13px")'),
+      cardDescriptionFontWeight: z21.string().optional().describe('Card description font weight (e.g. "400")'),
+      cardDescriptionColor: z21.string().optional().describe("Card description text color (hex)"),
+      // Card Customization
+      cardPadding: z21.string().optional().describe('Card internal padding (e.g. "20px")'),
+      cardBorderRadius: z21.string().optional().describe('Card border radius (e.g. "12px")'),
+      cardShadow: z21.string().optional().describe("Card box-shadow CSS value"),
+      disableShadowOnHover: z21.boolean().optional().describe("Disable shadow effect on card hover"),
+      disableCardStroke: z21.boolean().optional().describe("Remove card border stroke"),
+      cardStrokeColor: z21.string().optional().describe("Card border stroke color (hex)"),
+      // Chart
+      chartFontFamily: z21.string().optional().describe("Font family for chart text"),
+      chartFontColor: z21.string().optional().describe("Font color for chart text (hex)"),
+      chartColors: z21.array(z21.string()).optional().describe("Array of chart series colors (hex values)"),
+      chartPaletteName: z21.string().optional().describe("Name for a custom palette"),
+      chartPaletteColors: z21.array(z21.string()).optional().describe("9 colors for a custom palette"),
+      // Chart Tooltip
+      tooltipHeader: tooltipFontSchema.describe("Tooltip header font config"),
+      tooltipLabel: tooltipFontSchema.describe("Tooltip label font config"),
+      tooltipValue: tooltipFontSchema.describe("Tooltip value font config"),
+      // Component-level theme (buttons, checkboxes, switches, etc.)
+      buttonPrimaryColor: z21.string().optional().describe("Primary button background color (hex)"),
+      buttonPrimaryTextColor: z21.string().optional().describe("Primary button text color (hex)"),
+      buttonSecondaryColor: z21.string().optional().describe("Secondary button background color (hex)"),
+      buttonSecondaryTextColor: z21.string().optional().describe("Secondary button text color (hex)"),
+      checkboxCheckedColor: z21.string().optional().describe("Checked checkbox color (hex)"),
+      checkboxUncheckedColor: z21.string().optional().describe("Unchecked checkbox color (hex)"),
+      switchEnabledColor: z21.string().optional().describe("Enabled switch color (hex)"),
+      switchDisabledColor: z21.string().optional().describe("Disabled switch color (hex)"),
+      breadcrumbFontFamily: z21.string().optional().describe("Drill breadcrumb font family"),
+      breadcrumbFontColor: z21.string().optional().describe("Drill breadcrumb font color (hex)"),
+      breadcrumbActiveColor: z21.string().optional().describe("Active breadcrumb color (hex)"),
+      filterBadgeColor: z21.string().optional().describe("Multi-select filter badge color (hex)"),
+      filterBadgeTextColor: z21.string().optional().describe("Multi-select filter badge text color (hex)")
+    },
+    async (params) => {
+      const { embedId, ...themeParams } = params;
+      const adminTheme = {};
+      const general = {};
+      if (themeParams.fontFamily) general.fontFamily = themeParams.fontFamily;
+      if (themeParams.datePickerFormat) general.datePickerFormat = themeParams.datePickerFormat;
+      if (Object.keys(general).length) adminTheme.general = general;
+      const dashboard = {};
+      if (themeParams.dashboardBackgroundColor) dashboard.backgroundColor = themeParams.dashboardBackgroundColor;
+      if (themeParams.ctaColor) dashboard.ctaColor = themeParams.ctaColor;
+      if (themeParams.ctaTextColor) dashboard.ctaTextColor = themeParams.ctaTextColor;
+      if (themeParams.selectBoxSize) dashboard.selectBoxSize = themeParams.selectBoxSize;
+      if (themeParams.selectBoxVariant) dashboard.selectBoxVariant = themeParams.selectBoxVariant;
+      if (themeParams.selectBoxBorderRadius) dashboard.selectBoxBorderRadius = themeParams.selectBoxBorderRadius;
+      if (themeParams.selectBoxTextColor) dashboard.selectBoxTextColor = themeParams.selectBoxTextColor;
+      if (Object.keys(dashboard).length) adminTheme.dashboard = dashboard;
+      const cardTitle = {};
+      if (themeParams.cardTitleFontSize) cardTitle.fontSize = themeParams.cardTitleFontSize;
+      if (themeParams.cardTitleFontWeight) cardTitle.fontWeight = themeParams.cardTitleFontWeight;
+      if (themeParams.cardTitleColor) cardTitle.color = themeParams.cardTitleColor;
+      if (Object.keys(cardTitle).length) adminTheme.cardTitle = cardTitle;
+      const cardDescription = {};
+      if (themeParams.cardDescriptionFontSize) cardDescription.fontSize = themeParams.cardDescriptionFontSize;
+      if (themeParams.cardDescriptionFontWeight) cardDescription.fontWeight = themeParams.cardDescriptionFontWeight;
+      if (themeParams.cardDescriptionColor) cardDescription.color = themeParams.cardDescriptionColor;
+      if (Object.keys(cardDescription).length) adminTheme.cardDescription = cardDescription;
+      const cardCustomization = {};
+      if (themeParams.cardPadding) cardCustomization.padding = themeParams.cardPadding;
+      if (themeParams.cardBorderRadius) cardCustomization.borderRadius = themeParams.cardBorderRadius;
+      if (themeParams.cardShadow) cardCustomization.shadow = themeParams.cardShadow;
+      if (themeParams.disableShadowOnHover !== void 0) cardCustomization.disableShadowOnHover = themeParams.disableShadowOnHover;
+      if (themeParams.disableCardStroke !== void 0) cardCustomization.disableStroke = themeParams.disableCardStroke;
+      if (themeParams.cardStrokeColor) cardCustomization.metricStrokeColor = themeParams.cardStrokeColor;
+      if (Object.keys(cardCustomization).length) adminTheme.cardCustomization = cardCustomization;
+      const chart = {};
+      if (themeParams.chartFontFamily) chart.chartFontFamily = themeParams.chartFontFamily;
+      if (themeParams.chartFontColor) chart.chartFontColor = themeParams.chartFontColor;
+      if (themeParams.chartColors) chart.paletteOptions = themeParams.chartColors;
+      if (themeParams.chartPaletteName && themeParams.chartPaletteColors) {
+        chart.palettes = [{ name: themeParams.chartPaletteName, colors: themeParams.chartPaletteColors }];
+        chart.selected = themeParams.chartPaletteName;
+      }
+      const tooltip = {};
+      if (themeParams.tooltipHeader) tooltip.header = themeParams.tooltipHeader;
+      if (themeParams.tooltipLabel) tooltip.label = themeParams.tooltipLabel;
+      if (themeParams.tooltipValue) tooltip.value = themeParams.tooltipValue;
+      if (Object.keys(tooltip).length) chart.tooltip = tooltip;
+      if (Object.keys(chart).length) adminTheme.chart = chart;
+      const componentTheme = {};
+      if (themeParams.buttonPrimaryColor || themeParams.buttonPrimaryTextColor || themeParams.buttonSecondaryColor || themeParams.buttonSecondaryTextColor) {
+        componentTheme.button = {
+          ...themeParams.buttonPrimaryColor && { primary: themeParams.buttonPrimaryColor },
+          ...themeParams.buttonPrimaryTextColor && { primaryText: themeParams.buttonPrimaryTextColor },
+          ...themeParams.buttonSecondaryColor && { secondary: themeParams.buttonSecondaryColor },
+          ...themeParams.buttonSecondaryTextColor && { secondaryText: themeParams.buttonSecondaryTextColor }
+        };
+      }
+      if (themeParams.checkboxCheckedColor || themeParams.checkboxUncheckedColor) {
+        componentTheme.checkbox = {
+          ...themeParams.checkboxCheckedColor && { checked: themeParams.checkboxCheckedColor },
+          ...themeParams.checkboxUncheckedColor && { unChecked: themeParams.checkboxUncheckedColor }
+        };
+      }
+      if (themeParams.switchEnabledColor || themeParams.switchDisabledColor) {
+        componentTheme.switch = {
+          ...themeParams.switchEnabledColor && { enabled: themeParams.switchEnabledColor },
+          ...themeParams.switchDisabledColor && { disabled: themeParams.switchDisabledColor }
+        };
+      }
+      if (themeParams.breadcrumbFontFamily || themeParams.breadcrumbFontColor || themeParams.breadcrumbActiveColor) {
+        componentTheme.drillBreadCrumbs = {
+          ...themeParams.breadcrumbFontFamily && { fontFamily: themeParams.breadcrumbFontFamily },
+          ...themeParams.breadcrumbFontColor && { fontColor: themeParams.breadcrumbFontColor },
+          ...themeParams.breadcrumbActiveColor && { activeColor: themeParams.breadcrumbActiveColor }
+        };
+      }
+      if (themeParams.filterBadgeColor || themeParams.filterBadgeTextColor) {
+        componentTheme.multiSelectFilterDropdown = {
+          ...themeParams.filterBadgeColor && { badgeColor: themeParams.filterBadgeColor },
+          ...themeParams.filterBadgeTextColor && { badgeTextColor: themeParams.filterBadgeTextColor }
+        };
+      }
+      const body = await getEmbedForUpdate(client, embedId);
+      if (Object.keys(adminTheme).length) body.adminThemeOptions = adminTheme;
+      if (Object.keys(componentTheme).length) body.theme = componentTheme;
+      if (themeParams.primaryColor) {
+        if (!body.adminThemeOptions) body.adminThemeOptions = {};
+        const g = body.adminThemeOptions.general || {};
+        g.primaryColor = themeParams.primaryColor;
+        body.adminThemeOptions.general = g;
+      }
+      if (themeParams.backgroundColor) {
+        if (!body.adminThemeOptions) body.adminThemeOptions = {};
+        const g = body.adminThemeOptions.general || {};
+        g.backgroundColor = themeParams.backgroundColor;
+        body.adminThemeOptions.general = g;
+      }
+      if (themeParams.textColor) {
+        if (!body.adminThemeOptions) body.adminThemeOptions = {};
+        const g = body.adminThemeOptions.general || {};
+        g.textColor = themeParams.textColor;
+        body.adminThemeOptions.general = g;
+      }
+      if (Object.keys(body).length <= 1) {
+        return toolError("No theme properties provided. Specify at least one property to customize.");
+      }
+      try {
+        const result = await client.request({
+          method: "PUT",
+          path: "/api/v2/data-app/embeds",
+          body,
+          auth: "api",
+          invalidateCache: ["list_embeds"]
+        });
+        if (result.error) {
+          return toolError(`Theme update failed: ${stringify(result.error)}`);
+        }
+        const sections = [];
+        if (Object.keys(adminTheme).length) sections.push(`admin theme (${Object.keys(adminTheme).join(", ")})`);
+        if (Object.keys(componentTheme).length) sections.push(`component theme (${Object.keys(componentTheme).join(", ")})`);
+        return toolSuccess(
+          `Theme updated for embed "${embedId}".
+
+**Updated sections:** ${sections.join(", ")}
+
+Use \`get_embed_details\` to view the full current theme configuration.` + GUEST_TOKEN_REMINDER
+        );
+      } catch (err) {
+        if (err instanceof DatabrainApiError) return err.toToolResponse();
+        return toolError(`Unexpected error: ${err.message}`);
+      }
+    }
+  );
+}
+
+// src/tools/embed/configure-chart-appearance.ts
+import { z as z22 } from "zod";
+var fontConfigSchema = z22.object({
+  fontSize: z22.number().optional(),
+  fontFamily: z22.string().optional(),
+  fontWeight: z22.number().optional(),
+  color: z22.string().optional()
+}).optional();
+var axisSchema = z22.object({
+  hideAxisLines: z22.boolean().optional().describe("Hide axis lines"),
+  hideSplitLines: z22.boolean().optional().describe("Hide grid/split lines"),
+  hideAxisLabels: z22.boolean().optional().describe("Hide axis labels"),
+  hideAxisTicks: z22.boolean().optional().describe("Hide axis tick marks"),
+  axisName: z22.string().optional().describe("Axis title text"),
+  axisNameOffset: z22.number().optional().describe("Axis title offset from axis"),
+  fontSize: z22.number().optional().describe("Axis label font size"),
+  fontFamily: z22.string().optional().describe("Axis label font family"),
+  fontWeight: z22.number().optional().describe("Axis label font weight"),
+  color: z22.string().optional().describe("Axis label color (hex)"),
+  axisColor: z22.string().optional().describe("Axis line color (hex)"),
+  axisNameFontConfig: z22.object({
+    fontFamily: z22.string().optional(),
+    fontSize: z22.number().optional(),
+    fontWeight: z22.number().optional()
+  }).optional().describe("Axis title font configuration")
+}).optional();
+function registerConfigureChartAppearance(server, client) {
+  server.tool(
+    "configure_chart_appearance",
+    "Configure granular chart appearance for an embed \u2014 tooltip styles, legend position/shape, axis configuration, label positioning, margins, and colors.",
+    {
+      embedId: z22.string().describe("ID of the embed to configure"),
+      // Chart Colors
+      chartColors: z22.array(z22.string()).optional().describe("Array of chart series colors (hex values)"),
+      // Tooltip
+      tooltipHeaderStyle: fontConfigSchema.describe("Tooltip header font: fontSize, fontFamily, fontWeight, color"),
+      tooltipLabelStyle: fontConfigSchema.describe("Tooltip label font: fontSize, fontFamily, fontWeight, color"),
+      tooltipValueStyle: fontConfigSchema.describe("Tooltip value font: fontSize, fontFamily, fontWeight, color"),
+      // Labels
+      labelPosition: z22.enum(["hidden", "top", "left", "right", "bottom", "inside"]).optional().describe("Data label position on charts"),
+      radialLabelPosition: z22.enum(["outside", "inside"]).optional().describe("Label position for radial/pie charts"),
+      // Margins
+      marginTop: z22.number().optional().describe("Chart top margin in pixels"),
+      marginLeft: z22.number().optional().describe("Chart left margin in pixels"),
+      marginRight: z22.number().optional().describe("Chart right margin in pixels"),
+      marginBottom: z22.number().optional().describe("Chart bottom margin in pixels"),
+      // Legend
+      legendShow: z22.boolean().optional().describe("Show or hide the chart legend"),
+      legendPosition: z22.enum([
+        "top-left",
+        "top-center",
+        "top-right",
+        "left-center",
+        "right-center",
+        "bottom-left",
+        "bottom-center",
+        "bottom-right"
+      ]).optional().describe("Fixed legend position"),
+      legendLayout: z22.enum(["horizontal", "vertical"]).optional().describe("Legend layout direction"),
+      legendShape: z22.enum(["circle", "rect", "roundRect", "triangle", "diamond", "arrow", "none"]).optional().describe("Legend icon shape"),
+      legendFontSize: z22.number().optional().describe("Legend font size"),
+      legendFontWeight: z22.number().optional().describe("Legend font weight"),
+      legendFontFamily: z22.string().optional().describe("Legend font family"),
+      legendColor: z22.string().optional().describe("Legend text color (hex)"),
+      legendTruncateLength: z22.number().optional().describe("Max characters before truncating legend labels"),
+      disableLegendScrolling: z22.boolean().optional().describe("Disable scrolling in legend"),
+      enableVariableLegendPosition: z22.boolean().optional().describe("Allow user to drag/reposition legend"),
+      legendTop: z22.number().optional().describe("Custom legend top offset"),
+      legendLeft: z22.number().optional().describe("Custom legend left offset"),
+      // Axes
+      verticalAxis: axisSchema.describe("Vertical (Y) axis configuration"),
+      horizontalAxis: axisSchema.describe("Horizontal (X) axis configuration")
+    },
+    async (params) => {
+      const { embedId, ...chartParams } = params;
+      const chartAppearance = {};
+      const chartTooltip = {};
+      if (chartParams.tooltipHeaderStyle) chartTooltip.tooltipHeader = chartParams.tooltipHeaderStyle;
+      if (chartParams.tooltipLabelStyle) chartTooltip.labelStyle = chartParams.tooltipLabelStyle;
+      if (chartParams.tooltipValueStyle) chartTooltip.valueStyle = chartParams.tooltipValueStyle;
+      if (Object.keys(chartTooltip).length) chartAppearance.chartTooltip = chartTooltip;
+      const chartLabel = {};
+      if (chartParams.labelPosition) chartLabel.position = chartParams.labelPosition;
+      if (chartParams.radialLabelPosition) chartLabel.radialChartposition = chartParams.radialLabelPosition;
+      if (Object.keys(chartLabel).length) chartAppearance.chartLabel = chartLabel;
+      if (chartParams.marginTop !== void 0 || chartParams.marginLeft !== void 0 || chartParams.marginRight !== void 0 || chartParams.marginBottom !== void 0) {
+        chartAppearance.chartMargin = {
+          ...chartParams.marginTop !== void 0 && { marginTop: chartParams.marginTop },
+          ...chartParams.marginLeft !== void 0 && { marginLeft: chartParams.marginLeft },
+          ...chartParams.marginRight !== void 0 && { marginRight: chartParams.marginRight },
+          ...chartParams.marginBottom !== void 0 && { marginBottom: chartParams.marginBottom }
+        };
+      }
+      const chartLegend = {};
+      if (chartParams.legendShow !== void 0) chartLegend.show = chartParams.legendShow;
+      if (chartParams.legendPosition) chartLegend.fixedPosition = chartParams.legendPosition;
+      if (chartParams.legendLayout) chartLegend.legendAppearance = chartParams.legendLayout;
+      if (chartParams.legendShape) chartLegend.legendShape = chartParams.legendShape;
+      if (chartParams.legendFontSize !== void 0) chartLegend.fontSize = chartParams.legendFontSize;
+      if (chartParams.legendFontWeight !== void 0) chartLegend.fontWeight = chartParams.legendFontWeight;
+      if (chartParams.legendFontFamily) chartLegend.fontFamily = chartParams.legendFontFamily;
+      if (chartParams.legendColor) chartLegend.color = chartParams.legendColor;
+      if (chartParams.legendTruncateLength !== void 0) chartLegend.truncateLegend = chartParams.legendTruncateLength;
+      if (chartParams.disableLegendScrolling !== void 0) chartLegend.disableLegendScrolling = chartParams.disableLegendScrolling;
+      if (chartParams.enableVariableLegendPosition !== void 0) chartLegend.enableVariablePosition = chartParams.enableVariableLegendPosition;
+      if (chartParams.legendTop !== void 0) chartLegend.top = chartParams.legendTop;
+      if (chartParams.legendLeft !== void 0) chartLegend.left = chartParams.legendLeft;
+      if (Object.keys(chartLegend).length) chartAppearance.chartLegend = chartLegend;
+      if (chartParams.verticalAxis) chartAppearance.verticalAxis = chartParams.verticalAxis;
+      if (chartParams.horizontalAxis) chartAppearance.horizontalAxis = chartParams.horizontalAxis;
+      const options = {};
+      if (Object.keys(chartAppearance).length) options.chartAppearance = chartAppearance;
+      if (chartParams.chartColors) options.chartColors = chartParams.chartColors;
+      if (Object.keys(options).length === 0) {
+        return toolError("No chart appearance properties provided. Specify at least one property to configure.");
+      }
+      try {
+        const body = await getEmbedForUpdate(client, embedId);
+        body.options = options;
+        const result = await client.request({
+          method: "PUT",
+          path: "/api/v2/data-app/embeds",
+          body,
+          auth: "api",
+          invalidateCache: ["list_embeds"]
+        });
+        if (result.error) {
+          return toolError(`Chart appearance update failed: ${stringify(result.error)}`);
+        }
+        const configured = [];
+        if (chartAppearance.chartTooltip) configured.push("tooltip");
+        if (chartAppearance.chartLabel) configured.push("labels");
+        if (chartAppearance.chartMargin) configured.push("margins");
+        if (chartAppearance.chartLegend) configured.push("legend");
+        if (chartAppearance.verticalAxis) configured.push("vertical axis");
+        if (chartAppearance.horizontalAxis) configured.push("horizontal axis");
+        if (chartParams.chartColors) configured.push("chart colors");
+        return toolSuccess(
+          `Chart appearance updated for embed "${embedId}".
+
+**Configured:** ${configured.join(", ")}
+
+Use \`get_embed_details\` to view the full configuration.` + GUEST_TOKEN_REMINDER
+        );
+      } catch (err) {
+        if (err instanceof DatabrainApiError) return err.toToolResponse();
+        return toolError(`Unexpected error: ${err.message}`);
+      }
+    }
+  );
+}
+
+// src/tools/embed/configure-embed-options.ts
+import { z as z23 } from "zod";
+function registerConfigureEmbedOptions(server, client) {
+  server.tool(
+    "configure_embed_options",
+    "Configure display, permission, and behavior options for an embedded dashboard \u2014 control metric operations, layout, downloads, loaders, UI visibility, and more.",
+    {
+      embedId: z23.string().describe("ID of the embed to configure"),
+      // Metric Operations
+      disableMetricCreation: z23.boolean().optional().describe("Disable creating new metrics"),
+      disableMetricUpdation: z23.boolean().optional().describe("Disable updating existing metrics"),
+      disableMetricDeletion: z23.boolean().optional().describe("Disable deleting metrics"),
+      disableManageMetrics: z23.boolean().optional().describe("Hide the manage metrics interface"),
+      // Layout
+      disableLayoutCustomization: z23.boolean().optional().describe("Prevent layout changes"),
+      disableSaveLayout: z23.boolean().optional().describe("Prevent saving layout changes"),
+      // Downloads & Export
+      enableDownloadCsv: z23.boolean().optional().describe("Enable CSV download for individual metrics"),
+      enableEmailCsv: z23.boolean().optional().describe("Enable emailing metric data as CSV"),
+      disableDownloadPng: z23.boolean().optional().describe("Disable PNG download in fullscreen"),
+      enableDownloadAllMetrics: z23.boolean().optional().describe("Enable bulk download of all metrics as CSV"),
+      enableDownloadAllPdf: z23.boolean().optional().describe("Enable downloading entire dashboard as PDF"),
+      disableDownloadDataNoFilters: z23.boolean().optional().describe("Prevent data download when no filters applied"),
+      disableDownloadUnderlyingDataNoFilters: z23.boolean().optional().describe("Prevent underlying data download without filters"),
+      // UI Visibility
+      hideDashboardName: z23.boolean().optional().describe("Hide the dashboard title"),
+      hideMetricCardShadow: z23.boolean().optional().describe("Remove card shadow effects"),
+      disableMetricCardBorder: z23.boolean().optional().describe("Remove metric card borders"),
+      showDashboardActions: z23.boolean().optional().describe("Show/hide dashboard action buttons"),
+      disableFullscreen: z23.boolean().optional().describe("Disable fullscreen mode"),
+      isHideTablePreview: z23.boolean().optional().describe("Hide table preview in fullscreen"),
+      isHideChartSettings: z23.boolean().optional().describe("Hide chart settings in fullscreen"),
+      shouldFitFullScreen: z23.boolean().optional().describe("Make fullscreen modal fit the component space"),
+      // Loaders
+      disableMainLoader: z23.boolean().optional().describe("Hide the main loading indicator"),
+      disableMetricLoader: z23.boolean().optional().describe("Hide metric-level loading indicators"),
+      // Data Access
+      disableUnderlyingData: z23.boolean().optional().describe("Disable access to underlying data"),
+      isShowNoDataFoundScreen: z23.boolean().optional().describe('Show a "no data" screen when data is unavailable'),
+      // Scheduling
+      disableScheduleEmailReports: z23.boolean().optional().describe("Disable email report scheduling"),
+      // Filters & Interactions
+      isStickyDashboardFilters: z23.boolean().optional().describe("Make filters sticky when scrolling"),
+      enableMultiMetricFilters: z23.boolean().optional().describe("Enable cross-metric filter interactions"),
+      optionsIcon: z23.enum(["kebab-menu-vertical", "download"]).optional().describe("Menu icon style"),
+      hideDatePickerOptions: z23.array(z23.string()).optional().describe('Date picker options to hide (e.g. ["this month", "yesterday"])'),
+      // Custom Messages
+      tokenExpiryMessage: z23.string().optional().describe("Custom message when token expires"),
+      tokenAbsentMessage: z23.string().optional().describe("Custom message when token is missing")
+    },
+    async (params) => {
+      const { embedId, ...opts } = params;
+      const options = {};
+      if (opts.disableMetricCreation !== void 0) options.disableMetricCreation = opts.disableMetricCreation;
+      if (opts.disableMetricUpdation !== void 0) options.disableMetricUpdation = opts.disableMetricUpdation;
+      if (opts.disableMetricDeletion !== void 0) options.disableMetricDeletion = opts.disableMetricDeletion;
+      if (opts.disableManageMetrics !== void 0) options.disableManageMetrics = opts.disableManageMetrics;
+      if (opts.disableLayoutCustomization !== void 0) options.disableLayoutCustomization = opts.disableLayoutCustomization;
+      if (opts.disableSaveLayout !== void 0) options.disableSaveLayout = opts.disableSaveLayout;
+      if (opts.disableDownloadDataNoFilters !== void 0) options.disableDownloadDataNoFilters = opts.disableDownloadDataNoFilters;
+      if (opts.disableDownloadUnderlyingDataNoFilters !== void 0) options.disableDownloadUnderlyingDataNoFilters = opts.disableDownloadUnderlyingDataNoFilters;
+      if (opts.hideDashboardName !== void 0) options.hideDashboardName = opts.hideDashboardName;
+      if (opts.hideMetricCardShadow !== void 0) options.hideMetricCardShadow = opts.hideMetricCardShadow;
+      if (opts.disableMetricCardBorder !== void 0) options.disableMetricCardBorder = opts.disableMetricCardBorder;
+      if (opts.showDashboardActions !== void 0) options.showDashboardActions = opts.showDashboardActions;
+      if (opts.shouldFitFullScreen !== void 0) options.shouldFitFullScreen = opts.shouldFitFullScreen;
+      if (opts.isShowNoDataFoundScreen !== void 0) options.isShowNoDataFoundScreen = opts.isShowNoDataFoundScreen;
+      if (opts.disableMainLoader !== void 0) options.disableMainLoader = opts.disableMainLoader;
+      if (opts.disableMetricLoader !== void 0) options.disableMetricLoader = opts.disableMetricLoader;
+      if (opts.disableUnderlyingData !== void 0) options.disableUnderlyingData = opts.disableUnderlyingData;
+      if (opts.disableScheduleEmailReports !== void 0) options.disableScheduleEmailReports = opts.disableScheduleEmailReports;
+      if (opts.hideDatePickerOptions) options.hideDatePickerOptions = opts.hideDatePickerOptions;
+      const attrs = {};
+      if (opts.enableDownloadCsv !== void 0) attrs.enableDownloadCsv = opts.enableDownloadCsv;
+      if (opts.enableEmailCsv !== void 0) attrs.enableEmailCsv = opts.enableEmailCsv;
+      if (opts.disableDownloadPng !== void 0) attrs.disableDownloadPng = opts.disableDownloadPng;
+      if (opts.enableDownloadAllMetrics !== void 0) attrs.enableDownloadAllMetrics = opts.enableDownloadAllMetrics;
+      if (opts.enableDownloadAllPdf !== void 0) attrs.enableDownloadAllPdf = opts.enableDownloadAllPdf;
+      if (opts.disableFullscreen !== void 0) attrs.disableFullscreen = opts.disableFullscreen;
+      if (opts.isHideTablePreview !== void 0) attrs.isHideTablePreview = opts.isHideTablePreview;
+      if (opts.isHideChartSettings !== void 0) attrs.isHideChartSettings = opts.isHideChartSettings;
+      if (opts.isStickyDashboardFilters !== void 0) attrs.isStickyDashboardFilters = opts.isStickyDashboardFilters;
+      if (opts.enableMultiMetricFilters !== void 0) attrs.enableMultiMetricFilters = opts.enableMultiMetricFilters;
+      if (opts.optionsIcon) attrs.optionsIcon = opts.optionsIcon;
+      const customMessages = {};
+      if (opts.tokenExpiryMessage) customMessages.tokenExpiry = opts.tokenExpiryMessage;
+      if (opts.tokenAbsentMessage) customMessages.tokenAbsent = opts.tokenAbsentMessage;
+      if (Object.keys(customMessages).length) options.customMessages = customMessages;
+      if (Object.keys(options).length === 0 && Object.keys(attrs).length === 0) {
+        return toolError("No options provided. Specify at least one option to configure.");
+      }
+      try {
+        const body = await getEmbedForUpdate(client, embedId);
+        if (Object.keys(options).length) body.options = options;
+        if (Object.keys(attrs).length) body.componentAttributes = attrs;
+        const result = await client.request({
+          method: "PUT",
+          path: "/api/v2/data-app/embeds",
+          body,
+          auth: "api",
+          invalidateCache: ["list_embeds"]
+        });
+        if (result.error) {
+          return toolError(`Options update failed: ${stringify(result.error)}`);
+        }
+        const allKeys = [...Object.keys(options), ...Object.keys(attrs)];
+        return toolSuccess(
+          `Embed options updated for "${embedId}".
+
+**Configured ${allKeys.length} option(s):** ${allKeys.join(", ")}
+
+Use \`get_embed_details\` to view the full configuration.` + GUEST_TOKEN_REMINDER
+        );
+      } catch (err) {
+        if (err instanceof DatabrainApiError) return err.toToolResponse();
+        return toolError(`Unexpected error: ${err.message}`);
+      }
+    }
+  );
+}
+
+// src/tools/embed/configure-filters.ts
+import { z as z24 } from "zod";
+var stringFilterSchema = z24.object({
+  filterName: z24.string().describe("Name of the filter as it appears in the dashboard"),
+  options: z24.array(z24.object({
+    value: z24.string(),
+    label: z24.string()
+  })).describe("Dropdown options"),
+  defaultOption: z24.union([z24.string(), z24.array(z24.string())]).optional().describe("Default selected value (string or array for multi-select)")
+});
+var numberFilterSchema = z24.object({
+  filterName: z24.string().describe("Name of the filter"),
+  min: z24.number().describe("Minimum value"),
+  max: z24.number().describe("Maximum value")
+});
+var datePresetSchema = z24.object({
+  type: z24.string().optional().describe('Preset type (e.g. "Last", "This")'),
+  interval: z24.string().optional().describe('Interval (e.g. "Days", "Months", "Years")'),
+  timeGrain: z24.string().optional().describe("Time grain"),
+  label: z24.string().describe('Display label (e.g. "Last 30 Days")'),
+  startDate: z24.string().optional().describe("Start date (YYYY-MM-DD)"),
+  endDate: z24.string().optional().describe("End date (YYYY-MM-DD)")
+});
+var dateFilterSchema = z24.object({
+  filterName: z24.string().describe("Name of the filter"),
+  startDate: z24.string().optional().describe("Default start date (YYYY-MM-DD)"),
+  endDate: z24.string().optional().describe("Default end date (YYYY-MM-DD)"),
+  datePresetOptions: z24.array(datePresetSchema).optional().describe("Custom date presets to show in the date picker")
+});
+var sqlFilterSchema = z24.object({
+  filterName: z24.string().describe("Name of the filter"),
+  sql: z24.string().describe('SQL query to fetch filter options (e.g. SELECT "name" FROM "table")'),
+  columnName: z24.string().describe("Column name from the SQL result to use as option values")
+});
+function registerConfigureFilters(server, client) {
+  server.tool(
+    "configure_filters",
+    "Configure dashboard and metric filters for an embed \u2014 set default values, dropdown options, date presets, SQL-based filters for large datasets, and hide specific filters.",
+    {
+      embedId: z24.string().describe("ID of the embed to configure"),
+      // Global dashboard filters
+      stringFilters: z24.array(stringFilterSchema).optional().describe("String filter configurations with dropdown options and defaults"),
+      numberFilters: z24.array(numberFilterSchema).optional().describe("Number filter configurations with min/max defaults"),
+      dateFilters: z24.array(dateFilterSchema).optional().describe("Date filter configurations with default ranges and presets"),
+      sqlFilters: z24.array(sqlFilterSchema).optional().describe("SQL-based filter options for filters with large option sets"),
+      // Filter visibility
+      hideDashboardFilters: z24.array(z24.string()).optional().describe("Array of filter names to hide from the dashboard UI"),
+      hideDatePickerOptions: z24.array(z24.string()).optional().describe('Date picker options to hide (e.g. ["this month", "yesterday"])'),
+      // Metric-level filter config
+      metricFilterPosition: z24.enum(["inside", "outside"]).optional().describe("Where to display metric-level filters"),
+      enableMultiMetricFilters: z24.boolean().optional().describe("Allow multiple filters per metric")
+    },
+    async (params) => {
+      const { embedId, ...filterParams } = params;
+      const options = {};
+      const attrs = {};
+      const globalFilterOptions = {};
+      if (filterParams.stringFilters) {
+        for (const f of filterParams.stringFilters) {
+          globalFilterOptions[f.filterName] = {
+            options: f.options,
+            ...f.defaultOption !== void 0 && { defaultOption: f.defaultOption }
+          };
+        }
+      }
+      if (filterParams.numberFilters) {
+        for (const f of filterParams.numberFilters) {
+          globalFilterOptions[f.filterName] = {
+            defaultOption: { min: f.min, max: f.max }
+          };
+        }
+      }
+      if (filterParams.dateFilters) {
+        for (const f of filterParams.dateFilters) {
+          const config = {};
+          if (f.startDate || f.endDate) {
+            config.defaultOption = {
+              ...f.startDate && { startDate: f.startDate },
+              ...f.endDate && { endDate: f.endDate }
+            };
+          }
+          if (f.datePresetOptions) {
+            config.datePresetOptions = f.datePresetOptions;
+          }
+          globalFilterOptions[f.filterName] = config;
+        }
+      }
+      if (filterParams.sqlFilters) {
+        for (const f of filterParams.sqlFilters) {
+          globalFilterOptions[f.filterName] = {
+            sql: f.sql,
+            columnName: f.columnName
+          };
+        }
+      }
+      if (Object.keys(globalFilterOptions).length) {
+        options.globalFilterOptions = globalFilterOptions;
+      }
+      if (filterParams.hideDashboardFilters) {
+        attrs.hideDashboardFilters = filterParams.hideDashboardFilters;
+      }
+      if (filterParams.hideDatePickerOptions) {
+        options.hideDatePickerOptions = filterParams.hideDatePickerOptions;
+      }
+      if (filterParams.metricFilterPosition) {
+        attrs.metricFilterPosition = filterParams.metricFilterPosition;
+      }
+      if (filterParams.enableMultiMetricFilters !== void 0) {
+        attrs.enableMultiMetricFilters = filterParams.enableMultiMetricFilters;
+      }
+      if (Object.keys(options).length === 0 && Object.keys(attrs).length === 0) {
+        return toolError("No filter configuration provided. Specify at least one filter option.");
+      }
+      try {
+        const body = await getEmbedForUpdate(client, embedId);
+        if (Object.keys(options).length) body.options = options;
+        if (Object.keys(attrs).length) body.componentAttributes = attrs;
+        const result = await client.request({
+          method: "PUT",
+          path: "/api/v2/data-app/embeds",
+          body,
+          auth: "api",
+          invalidateCache: ["list_embeds"]
+        });
+        if (result.error) {
+          return toolError(`Filter configuration failed: ${stringify(result.error)}`);
+        }
+        const configured = [];
+        if (filterParams.stringFilters?.length) configured.push(`${filterParams.stringFilters.length} string filter(s)`);
+        if (filterParams.numberFilters?.length) configured.push(`${filterParams.numberFilters.length} number filter(s)`);
+        if (filterParams.dateFilters?.length) configured.push(`${filterParams.dateFilters.length} date filter(s)`);
+        if (filterParams.sqlFilters?.length) configured.push(`${filterParams.sqlFilters.length} SQL filter(s)`);
+        if (filterParams.hideDashboardFilters?.length) configured.push(`hiding ${filterParams.hideDashboardFilters.length} filter(s)`);
+        if (filterParams.hideDatePickerOptions?.length) configured.push(`hiding ${filterParams.hideDatePickerOptions.length} date picker option(s)`);
+        if (filterParams.metricFilterPosition) configured.push(`metric filter position: ${filterParams.metricFilterPosition}`);
+        if (filterParams.enableMultiMetricFilters !== void 0) configured.push(`multi-metric filters: ${filterParams.enableMultiMetricFilters}`);
+        return toolSuccess(
+          `Filter configuration updated for embed "${embedId}".
+
+**Configured:** ${configured.join(", ")}
+
+Use \`get_embed_details\` to view the full configuration.` + GUEST_TOKEN_REMINDER
+        );
+      } catch (err) {
+        if (err instanceof DatabrainApiError) return err.toToolResponse();
+        return toolError(`Unexpected error: ${err.message}`);
+      }
+    }
+  );
+}
+
+// src/tools/embed/configure-internationalization.ts
+import { z as z25 } from "zod";
+var SUPPORTED_LANGUAGES = [
+  "en",
+  "fr",
+  "es",
+  "de",
+  "it",
+  "pt",
+  "zh",
+  "ja",
+  "ko",
+  "hi",
+  "ar",
+  "ru"
+];
+function registerConfigureInternationalization(server, client) {
+  server.tool(
+    "configure_internationalization",
+    "Configure language, translations, calendar type, and custom messages for an embedded dashboard. Supports 12 languages including English, French, Spanish, German, Italian, Portuguese, Chinese, Japanese, Korean, Hindi, Arabic, and Russian.",
     {
-      embedId: z15.string().describe("ID of the embed to update"),
-      themePreset: z15.enum(["light", "dark", "corporate", "minimal"]).optional().describe("Theme preset to apply"),
-      accessPreset: z15.enum(["view-only", "power-user", "export-only", "ai-enabled"]).optional().describe("Access settings preset to apply")
+      embedId: z25.string().describe("ID of the embed to configure"),
+      // Language
+      language: z25.enum(SUPPORTED_LANGUAGES).optional().describe('Primary language code (e.g. "fr" for French, "es" for Spanish, "ja" for Japanese)'),
+      // Calendar
+      calendarType: z25.enum(["default", "ind"]).optional().describe('Calendar system: "default" for standard, "ind" for Indian calendar'),
+      // Translations
+      translations: z25.array(z25.object({
+        key: z25.string().describe("Original text to translate (must match exactly with text in dashboard)"),
+        translations: z25.record(z25.string()).describe('Language code to translation mapping, e.g. { "fr": "Revenus", "es": "Ingresos" }')
+      })).optional().describe("Translation dictionary entries. Keys must match dashboard text exactly. Define longer keys before shorter ones."),
+      // Custom Messages
+      tokenExpiryMessage: z25.string().optional().describe("Custom message shown when the authentication token expires"),
+      tokenAbsentMessage: z25.string().optional().describe("Custom message shown when no token is provided")
     },
     async (params) => {
-      if (!params.themePreset && !params.accessPreset) {
-        return toolError("Provide at least one of themePreset or accessPreset.");
+      const { embedId, ...i18nParams } = params;
+      const attrs = {};
+      const options = {};
+      if (i18nParams.language) attrs.language = i18nParams.language;
+      if (i18nParams.calendarType) attrs.calendarType = i18nParams.calendarType;
+      if (i18nParams.translations?.length) {
+        const dict = {};
+        for (const entry of i18nParams.translations) {
+          dict[entry.key] = entry.translations;
+        }
+        attrs.translationDictionary = dict;
+      }
+      const customMessages = {};
+      if (i18nParams.tokenExpiryMessage) customMessages.tokenExpiry = i18nParams.tokenExpiryMessage;
+      if (i18nParams.tokenAbsentMessage) customMessages.tokenAbsent = i18nParams.tokenAbsentMessage;
+      if (Object.keys(customMessages).length) options.customMessages = customMessages;
+      if (Object.keys(attrs).length === 0 && Object.keys(options).length === 0) {
+        return toolError("No internationalization options provided. Specify at least one option.");
       }
       try {
-        const body = { embedId: params.embedId };
-        if (params.themePreset) {
-          body.theme = THEME_PRESETS[params.themePreset];
-        }
-        if (params.accessPreset) {
-          body.accessSettings = ACCESS_PRESETS[params.accessPreset];
-        }
+        const body = await getEmbedForUpdate(client, embedId);
+        if (Object.keys(attrs).length) body.componentAttributes = attrs;
+        if (Object.keys(options).length) body.options = options;
         const result = await client.request({
           method: "PUT",
           path: "/api/v2/data-app/embeds",
@@ -955,25 +1951,19 @@ function registerApplyThemePreset(server, client) {
           invalidateCache: ["list_embeds"]
         });
         if (result.error) {
-          return toolError(`Failed to apply preset: ${stringify(result.error)}`);
-        }
-        const applied = [];
-        if (params.themePreset) applied.push(`theme: **${params.themePreset}**`);
-        if (params.accessPreset) applied.push(`access: **${params.accessPreset}**`);
-        let details = "";
-        if (params.accessPreset) {
-          const settings = ACCESS_PRESETS[params.accessPreset];
-          const enabled = Object.entries(settings).filter(([, v]) => v === true).map(([k]) => k).join(", ");
-          details = `
-
-Enabled settings: ${enabled || "none"}`;
-          if (settings.metricCreationMode) {
-            details += `
-Metric creation mode: ${settings.metricCreationMode}`;
-          }
+          return toolError(`Internationalization update failed: ${stringify(result.error)}`);
         }
+        const configured = [];
+        if (i18nParams.language) configured.push(`language: ${i18nParams.language}`);
+        if (i18nParams.calendarType) configured.push(`calendar: ${i18nParams.calendarType}`);
+        if (i18nParams.translations?.length) configured.push(`${i18nParams.translations.length} translation(s)`);
+        if (Object.keys(customMessages).length) configured.push("custom messages");
         return toolSuccess(
-          `Preset applied to embed "${params.embedId}": ${applied.join(", ")}.${details}`
+          `Internationalization configured for embed "${embedId}".
+
+**Configured:** ${configured.join(", ")}
+
+Use \`get_embed_details\` to view the full configuration.` + GUEST_TOKEN_REMINDER
         );
       } catch (err) {
         if (err instanceof DatabrainApiError) return err.toToolResponse();
@@ -983,54 +1973,156 @@ Metric creation mode: ${settings.metricCreationMode}`;
   );
 }
 
+// src/tools/embed/get-permission-schema.ts
+var PERMISSION_SCHEMA = {
+  embedAccessSettings: {
+    description: "Fields accepted in embed create/update (`accessSettings` in PUT /api/v2/data-app/embeds). Auth: API token. These are the embed-level defaults.",
+    fields: {
+      isAllowMetricCreation: { type: "boolean", default: false, note: "May require enabling via Databrain UI (Settings > Customize Layout) if API returns 500" },
+      isAllowMetricDeletion: { type: "boolean", default: false },
+      isAllowMetricEditing: { type: "boolean", default: false },
+      isAllowMetricDrag: { type: "boolean", default: false },
+      isAllowMetricResize: { type: "boolean", default: false },
+      isAllowChangeLayout: { type: "boolean", default: false },
+      isAllowFullscreen: { type: "boolean", default: true },
+      isAllowTablePreview: { type: "boolean", default: true },
+      isAllowChartSettings: { type: "boolean", default: true },
+      isAllowDrillDown: { type: "boolean", default: false },
+      isAllowCrossFilter: { type: "boolean", default: false },
+      isAllowSorting: { type: "boolean", default: true },
+      isAllowAiPilot: { type: "boolean", default: false },
+      isAllowAiSummary: { type: "boolean", default: false },
+      isAllowAiRecommendation: { type: "boolean", default: false },
+      isAllowDownloadCsv: { type: "boolean", default: false },
+      isAllowEmailCsv: { type: "boolean", default: false },
+      isAllowDownloadAllMetrics: { type: "boolean", default: false },
+      isAllowDownloadPdf: { type: "boolean", default: false },
+      isAllowShareUrl: { type: "boolean", default: false },
+      isAllowDashboardFilters: { type: "boolean", default: true },
+      isAllowDateRangeFilter: { type: "boolean", default: true },
+      isAllowCustomDateRange: { type: "boolean", default: false },
+      metricCreationMode: { type: "enum", values: ["DRAG_DROP", "CHAT"], default: "DRAG_DROP" }
+    }
+  },
+  guestTokenPermissions: {
+    description: "Fields accepted in `permissions` when generating a guest token (POST /api/v2/guest-token/create). Auth: API token. These override embed-level defaults per session.",
+    fields: {
+      isEnableArchiveMetrics: { type: "boolean" },
+      isEnableManageMetrics: { type: "boolean" },
+      isEnableCreateDashboardView: { type: "boolean" },
+      isEnableMetricUpdation: { type: "boolean" },
+      isEnableCustomizeLayout: { type: "boolean" },
+      isEnableUnderlyingData: { type: "boolean" },
+      isEnableDownloadMetrics: { type: "boolean" },
+      isShowSideBar: { type: "boolean" },
+      isShowDashboardName: { type: "boolean" },
+      isDisableMetricCreation: { type: "boolean" }
+    },
+    rejectedFields: ["accessSettings", "allowedEmbeds"]
+  },
+  guestTokenTopLevel: {
+    description: "Top-level fields accepted in the guest token request body (POST /api/v2/guest-token/create).",
+    required: ["clientId", "dataAppName"],
+    optional: [
+      "timezone",
+      "appFilters",
+      "dashboardAppFilters",
+      "permissions",
+      "theme",
+      "hideDashboardFilters",
+      "expiryTime",
+      "datasourceName"
+    ],
+    rejectedFields: ["allowedEmbeds", "accessSettings"]
+  },
+  precedence: {
+    description: "When the same capability is set at multiple levels, highest precedence wins.",
+    order: [
+      "1. Web component `options` attribute (highest \u2014 client-side, not secure)",
+      "2. Guest token `permissions` (server-side, per session)",
+      "3. Embed `accessSettings` (server-side, default)"
+    ],
+    note: "Embed accessSettings use `isAllow*` naming. Guest token permissions use `isEnable*`/`isShow*`/`isDisable*` naming. They are different schemas."
+  },
+  knownLimitations: [
+    "isAllowMetricCreation in accessSettings may return 500 \u2014 enable via Databrain UI (Settings > Customize Layout) as a workaround.",
+    "accessSettings and allowedEmbeds are rejected by the guest token endpoint \u2014 use permissions instead.",
+    "After updating embed settings, existing guest tokens still carry old config. Regenerate guest tokens for changes to take effect."
+  ]
+};
+function registerGetPermissionSchema(server) {
+  server.tool(
+    "get_permission_schema",
+    "Returns the machine-readable permission/capability schema showing which fields are accepted in embed accessSettings vs guest token permissions, precedence rules, rejected fields, and known limitations. Use this to validate payloads before calling embed or guest token APIs.",
+    {},
+    async () => {
+      return toolSuccess(JSON.stringify(PERMISSION_SCHEMA, null, 2));
+    }
+  );
+}
+
 // src/tools/frontend/generate-guest-token.ts
-import { z as z16 } from "zod";
+import { z as z26 } from "zod";
 function registerGenerateGuestToken(server, client) {
   server.tool(
     "generate_guest_token",
     "Generate a guest token for frontend embedding. This token authenticates end-users to view embedded dashboards.",
     {
-      clientId: z16.string().describe("Unique end-user identifier for multi-tenant filtering"),
-      dataAppName: z16.string().describe("Name of the data app"),
-      params: z16.object({
-        allowedEmbeds: z16.array(z16.string()).optional().describe("Array of embed IDs to whitelist"),
-        timezone: z16.string().optional().describe('Timezone, e.g. "America/New_York"'),
-        appFilters: z16.array(z16.object({
-          metricId: z16.string(),
-          values: z16.array(z16.unknown())
-        })).optional(),
-        dashboardAppFilters: z16.array(z16.object({
-          dashboardId: z16.string(),
-          values: z16.array(z16.unknown())
-        })).optional(),
-        permissions: z16.object({
-          isEnableArchiveMetrics: z16.boolean().optional(),
-          isEnableManageMetrics: z16.boolean().optional(),
-          isEnableCreateDashboardView: z16.boolean().optional(),
-          isEnableMetricUpdation: z16.boolean().optional(),
-          isEnableCustomizeLayout: z16.boolean().optional(),
-          isEnableUnderlyingData: z16.boolean().optional(),
-          isEnableDownloadMetrics: z16.boolean().optional(),
-          isShowSideBar: z16.boolean().optional(),
-          isShowDashboardName: z16.boolean().optional(),
-          isDisableMetricCreation: z16.boolean().optional()
-        }).optional(),
-        hideDashboardFilters: z16.array(z16.string()).optional(),
-        expiryTime: z16.number().optional().describe("Token TTL in milliseconds"),
-        datasourceName: z16.string().optional(),
-        userIdentifier: z16.string().optional()
-      }).optional().describe("Optional token parameters")
+      clientId: z26.string().describe('Unique end-user identifier for multi-tenant filtering. Use "None" if no tenancy.'),
+      dataAppName: z26.string().describe("Name of the data app"),
+      timezone: z26.string().optional().describe('Timezone, e.g. "America/New_York"'),
+      appFilters: z26.array(z26.object({
+        columnName: z26.string().describe("Column name in the database table"),
+        tableName: z26.string().describe("Table name (must match a datamart table)"),
+        operator: z26.string().describe("Comparison operator (=, IN, NOT IN, LIKE, >, <, >=, <=, BETWEEN, IS NULL, IS NOT NULL)"),
+        value: z26.unknown().optional().describe("Filter value(s)"),
+        type: z26.enum(["string", "number", "null"]).describe("Filter data type")
+      })).optional().describe("Global filters applied to all metrics (server-side enforced, cannot be removed by end users)"),
+      dashboardAppFilters: z26.array(z26.object({
+        dashboardId: z26.string().describe("Dashboard ID to apply filters to"),
+        filters: z26.array(z26.object({
+          columnName: z26.string(),
+          tableName: z26.string(),
+          operator: z26.string(),
+          value: z26.unknown().optional(),
+          type: z26.enum(["string", "number", "null"])
+        })).describe("Filters for this specific dashboard")
+      })).optional().describe("Dashboard-specific filters (different filters per dashboard)"),
+      permissions: z26.object({
+        isEnableArchiveMetrics: z26.boolean().optional(),
+        isEnableManageMetrics: z26.boolean().optional(),
+        isEnableCreateDashboardView: z26.boolean().optional(),
+        isEnableMetricUpdation: z26.boolean().optional(),
+        isEnableCustomizeLayout: z26.boolean().optional(),
+        isEnableUnderlyingData: z26.boolean().optional(),
+        isEnableDownloadMetrics: z26.boolean().optional(),
+        isShowSideBar: z26.boolean().optional(),
+        isShowDashboardName: z26.boolean().optional(),
+        isDisableMetricCreation: z26.boolean().optional()
+      }).optional().describe("Runtime permission overrides (merge with and override embed-level settings)"),
+      theme: z26.record(z26.unknown()).optional().describe("Runtime theme overrides (overrides embed-level theme)"),
+      hideDashboardFilters: z26.array(z26.string()).optional().describe("Filter names to hide from the UI"),
+      expiryTime: z26.number().optional().describe("Token TTL in milliseconds"),
+      datasourceName: z26.string().optional().describe("Datasource name for multi-datasource routing")
     },
     async (params) => {
       try {
+        const body = {
+          clientId: params.clientId,
+          dataAppName: params.dataAppName
+        };
+        if (params.timezone) body.timezone = params.timezone;
+        if (params.appFilters) body.appFilters = params.appFilters;
+        if (params.dashboardAppFilters) body.dashboardAppFilters = params.dashboardAppFilters;
+        if (params.permissions) body.permissions = params.permissions;
+        if (params.theme) body.theme = params.theme;
+        if (params.hideDashboardFilters) body.hideDashboardFilters = params.hideDashboardFilters;
+        if (params.expiryTime) body.expiryTime = params.expiryTime;
+        if (params.datasourceName) body.datasourceName = params.datasourceName;
         const result = await client.request({
           method: "POST",
           path: "/api/v2/guest-token/create",
-          body: {
-            clientId: params.clientId,
-            dataAppName: params.dataAppName,
-            ...params.params
-          },
+          body,
           auth: "api"
         });
         return toolSuccess(
@@ -1051,7 +2143,7 @@ Next step: Use \`generate_embed_code\` to get copy-paste-ready frontend code.`
 }
 
 // src/tools/frontend/generate-embed-code.ts
-import { z as z17 } from "zod";
+import { z as z27 } from "zod";
 
 // src/templates/react.ts
 function kebabCase(str) {
@@ -1863,22 +2955,22 @@ function registerGenerateEmbedCode(server, _client) {
     "generate_embed_code",
     "Generate framework-specific, copy-paste-ready code to embed a Databrain dashboard or metric. No API call \u2014 generates code locally.",
     {
-      embedId: z17.string().describe("The embed ID to generate code for"),
-      framework: z17.enum(FRAMEWORKS).describe("Frontend framework"),
-      embedType: z17.enum(["dashboard", "metric"]).optional().default("dashboard"),
-      options: z17.object({
-        enableDownloadCsv: z17.boolean().optional(),
-        enableEmailCsv: z17.boolean().optional(),
-        enableDownloadAllMetrics: z17.boolean().optional(),
-        enableDownloadAllPdf: z17.boolean().optional(),
-        disableFullscreen: z17.boolean().optional(),
-        isHideTablePreview: z17.boolean().optional(),
-        isHideChartSettings: z17.boolean().optional(),
-        isStickyDashboardFilters: z17.boolean().optional(),
-        enableMultiMetricFilters: z17.boolean().optional(),
-        themeName: z17.string().optional(),
-        customTheme: z17.record(z17.unknown()).optional(),
-        optionsIcon: z17.enum(["kebab-menu-vertical", "download"]).optional()
+      embedId: z27.string().describe("The embed ID to generate code for"),
+      framework: z27.enum(FRAMEWORKS).describe("Frontend framework"),
+      embedType: z27.enum(["dashboard", "metric"]).optional().default("dashboard"),
+      options: z27.object({
+        enableDownloadCsv: z27.boolean().optional(),
+        enableEmailCsv: z27.boolean().optional(),
+        enableDownloadAllMetrics: z27.boolean().optional(),
+        enableDownloadAllPdf: z27.boolean().optional(),
+        disableFullscreen: z27.boolean().optional(),
+        isHideTablePreview: z27.boolean().optional(),
+        isHideChartSettings: z27.boolean().optional(),
+        isStickyDashboardFilters: z27.boolean().optional(),
+        enableMultiMetricFilters: z27.boolean().optional(),
+        themeName: z27.string().optional(),
+        customTheme: z27.record(z27.unknown()).optional(),
+        optionsIcon: z27.enum(["kebab-menu-vertical", "download"]).optional()
       }).optional()
     },
     async (params) => {
@@ -1917,13 +3009,13 @@ ${generated.instructions}`;
 }
 
 // src/tools/analytics/list-dashboards.ts
-import { z as z18 } from "zod";
+import { z as z28 } from "zod";
 function registerListDashboards(server, client) {
   server.tool(
     "list_dashboards",
     "List dashboards by data app. Requires an API token.",
     {
-      dataAppName: z18.string().optional().describe("Filter by data app name")
+      dataAppName: z28.string().optional().describe("Filter by data app name")
     },
     async (params) => {
       try {
@@ -1957,18 +3049,19 @@ ${formatted}`);
 }
 
 // src/tools/analytics/list-metrics.ts
-import { z as z19 } from "zod";
+import { z as z29 } from "zod";
 function registerListMetrics(server, client) {
   server.tool(
     "list_metrics",
     "List metrics available for embedding. Requires an API token.",
     {
-      dataAppName: z19.string().describe("Name of the data app"),
-      clientId: z19.string().optional().describe("Client ID for tenant-scoped metrics")
+      dataAppName: z29.string().describe("Name of the data app"),
+      embedId: z29.string().describe("Embed ID"),
+      clientId: z29.string().optional().describe("Client ID for tenant-scoped metrics")
     },
     async (params) => {
       try {
-        const query = { dataAppName: params.dataAppName };
+        const query = { dataAppName: params.dataAppName, embedId: params.embedId };
         if (params.clientId) query.clientId = params.clientId;
         const result = await client.request({
           method: "GET",
@@ -1996,18 +3089,18 @@ ${formatted}`);
 }
 
 // src/tools/analytics/query-metric-data.ts
-import { z as z20 } from "zod";
+import { z as z30 } from "zod";
 function registerQueryMetricData(server, client) {
   server.tool(
     "query_metric_data",
     "Fetch data from a pre-defined metric. Requires an API token.",
     {
-      embedId: z20.string().describe("Embed ID"),
-      metricId: z20.string().describe("Metric ID to query"),
-      clientId: z20.string().describe("Client ID for tenant filtering"),
-      filters: z20.array(z20.record(z20.unknown())).optional().describe("Runtime filters"),
-      limit: z20.number().optional().describe("Row limit"),
-      offset: z20.number().optional().describe("Pagination offset")
+      embedId: z30.string().describe("Embed ID"),
+      metricId: z30.string().describe("Metric ID to query"),
+      clientId: z30.string().describe("Client ID for tenant filtering"),
+      filters: z30.array(z30.record(z30.unknown())).optional().describe("Runtime filters"),
+      limit: z30.number().optional().describe("Row limit"),
+      offset: z30.number().optional().describe("Pagination offset")
     },
     async (params) => {
       try {
@@ -2045,16 +3138,16 @@ function registerQueryMetricData(server, client) {
 }
 
 // src/tools/analytics/get-dashboard-data.ts
-import { z as z21 } from "zod";
+import { z as z31 } from "zod";
 function registerGetDashboardData(server, client) {
   server.tool(
     "get_dashboard_data",
     "Fetch data for all metrics in a dashboard. Requires an API token. This is a composite operation that queries each metric.",
     {
-      dashboardId: z21.string().describe("Dashboard ID"),
-      clientId: z21.string().describe("Client ID for tenant filtering"),
-      embedId: z21.string().describe("Embed ID"),
-      filters: z21.array(z21.record(z21.unknown())).optional().describe("Runtime filters")
+      dashboardId: z31.string().describe("Dashboard ID"),
+      clientId: z31.string().describe("Client ID for tenant filtering"),
+      embedId: z31.string().describe("Embed ID"),
+      filters: z31.array(z31.record(z31.unknown())).optional().describe("Runtime filters")
     },
     async (params) => {
       try {
@@ -2062,7 +3155,7 @@ function registerGetDashboardData(server, client) {
           method: "GET",
           path: "/api/v2/data-app/metrics",
           auth: "api",
-          query: { dashboardId: params.dashboardId }
+          query: { dashboardId: params.dashboardId, embedId: params.embedId, clientId: params.clientId }
         });
         if (!Array.isArray(metrics) || metrics.length === 0) {
           return toolSuccess("No metrics found in this dashboard.");
@@ -2114,15 +3207,15 @@ Use \`query_metric_data\` to fetch detailed data for individual metrics.`
 }
 
 // src/tools/analytics/ask-ai-pilot.ts
-import { z as z22 } from "zod";
+import { z as z32 } from "zod";
 function registerAskAiPilot(server, client) {
   server.tool(
     "ask_ai_pilot",
     "Send a natural language question to Databrain's AI Pilot. Requires the embed to have AI Pilot enabled and a semantic layer configured.",
     {
-      embedId: z22.string().describe("Embed ID with AI Pilot enabled"),
-      question: z22.string().describe('Natural language question, e.g. "What was total revenue last month?"'),
-      clientId: z22.string().describe("Client ID for tenant filtering")
+      embedId: z32.string().describe("Embed ID with AI Pilot enabled"),
+      question: z32.string().describe('Natural language question, e.g. "What was total revenue last month?"'),
+      clientId: z32.string().describe("Client ID for tenant filtering")
     },
     async (params) => {
       try {
@@ -2165,16 +3258,16 @@ ${result.sql}
 }
 
 // src/tools/analytics/download-metric-csv.ts
-import { z as z23 } from "zod";
+import { z as z33 } from "zod";
 function registerDownloadMetricCsv(server, client) {
   server.tool(
     "download_metric_csv",
     "Download metric data as CSV. Returns CSV content or a download URL.",
     {
-      metricId: z23.string().describe("Metric ID"),
-      embedId: z23.string().describe("Embed ID"),
-      clientId: z23.string().describe("Client ID for tenant filtering"),
-      filters: z23.array(z23.record(z23.unknown())).optional().describe("Runtime filters")
+      metricId: z33.string().describe("Metric ID"),
+      embedId: z33.string().describe("Embed ID"),
+      clientId: z33.string().describe("Client ID for tenant filtering"),
+      filters: z33.array(z33.record(z33.unknown())).optional().describe("Runtime filters")
     },
     async (params) => {
       try {
@@ -2215,13 +3308,13 @@ ${preview}
 }
 
 // src/tools/analytics/list-scheduled-reports.ts
-import { z as z24 } from "zod";
+import { z as z34 } from "zod";
 function registerListScheduledReports(server, client) {
   server.tool(
     "list_scheduled_reports",
     "List scheduled email reports for an embed.",
     {
-      embedId: z24.string().describe("Embed ID")
+      embedId: z34.string().describe("Embed ID")
     },
     async (params) => {
       try {
@@ -2249,13 +3342,13 @@ ${formatted}`);
 }
 
 // src/tools/analytics/export-dashboard.ts
-import { z as z25 } from "zod";
+import { z as z35 } from "zod";
 function registerExportDashboard(server, client) {
   server.tool(
     "export_dashboard",
     "Export a dashboard as JSON. Useful for backup or migrating dashboards between environments.",
     {
-      dashboardId: z25.string().describe("ID of the dashboard to export")
+      dashboardId: z35.string().describe("ID of the dashboard to export")
     },
     async (params) => {
       try {
@@ -2280,14 +3373,14 @@ function registerExportDashboard(server, client) {
 }
 
 // src/tools/analytics/import-dashboard.ts
-import { z as z26 } from "zod";
+import { z as z36 } from "zod";
 function registerImportDashboard(server, client) {
   server.tool(
     "import_dashboard",
     "Import a dashboard from a JSON payload (previously exported via `export_dashboard`).",
     {
-      dashboardJson: z26.string().describe("The full dashboard JSON string from export_dashboard"),
-      dataAppName: z26.string().describe("Name of the target data app")
+      dashboardJson: z36.string().describe("The full dashboard JSON string from export_dashboard"),
+      dataAppName: z36.string().describe("Name of the target data app")
     },
     async (params) => {
       try {
@@ -2322,7 +3415,7 @@ Next: Use \`create_embed\` to embed this dashboard.`
 }
 
 // src/tools/orchestration/setup-embed-interactive.ts
-import { z as z27 } from "zod";
+import { z as z37 } from "zod";
 function mapError(err) {
   if (err instanceof DatabrainApiError) {
     const mapped = ERROR_MAP.find((m) => m.match(err));
@@ -2358,14 +3451,14 @@ var ERROR_MAP = [
   }
 ];
 var STEPS = ["discover", "choose_app", "ensure_token", "list_embeds", "choose_embed", "validate", "complete"];
-var stateSchema = z27.object({
-  dataAppId: z27.string().optional(),
-  dataAppName: z27.string().optional(),
-  embedId: z27.string().optional(),
-  dashboardId: z27.string().optional(),
-  apiToken: z27.string().optional(),
-  clientId: z27.string().optional(),
-  workspaceName: z27.string().optional()
+var stateSchema = z37.object({
+  dataAppId: z37.string().optional(),
+  dataAppName: z37.string().optional(),
+  embedId: z37.string().optional(),
+  dashboardId: z37.string().optional(),
+  apiToken: z37.string().optional(),
+  clientId: z37.string().optional(),
+  workspaceName: z37.string().optional()
 }).describe("Accumulated setup state from previous steps");
 function registerSetupEmbedInteractive(server, client) {
   server.tool(
@@ -2381,9 +3474,9 @@ Steps: discover \u2192 choose_app \u2192 ensure_token \u2192 list_embeds \u2192
 
 Pass the accumulated "state" object back on every call so the orchestrator can track progress.`,
     {
-      step: z27.enum(STEPS).describe("Which step to execute"),
+      step: z37.enum(STEPS).describe("Which step to execute"),
       state: stateSchema.optional().describe("State accumulated from previous steps \u2014 pass it back unchanged"),
-      userChoice: z27.string().optional().describe("User selection when a previous step returned CHOICE_REQUIRED")
+      userChoice: z37.string().optional().describe("User selection when a previous step returned CHOICE_REQUIRED")
     },
     async (params) => {
       const state = params.state ?? {};
@@ -2480,10 +3573,38 @@ Next: call \`setup_embed_interactive\` with step \`"list_embeds"\` and state:
 ` + JSON.stringify({ ...state, apiToken: "[CONFIGURED]" }, null, 2) + "\n```"
               );
             }
+            const existingTokens = await client.request({
+              method: "GET",
+              path: "/api/v2/data-app/api-tokens",
+              auth: "service",
+              query: { dataAppName: state.dataAppName }
+            });
+            if (Array.isArray(existingTokens) && existingTokens.length > 0) {
+              const rotateResult = await client.request({
+                method: "POST",
+                path: "/api/v2/data-app/api-tokens/rotate",
+                body: { dataAppName: state.dataAppName },
+                auth: "service"
+              });
+              client.setRuntimeApiToken(rotateResult.key);
+              return toolSuccess(
+                `An API token existed for **${state.dataAppName}** but wasn't available in this session. Rotated to get a new one.
+
+**New Token:** \`${rotateResult.key}\`
+
+\u26A0\uFE0F The old token is now invalid. Save this new token securely \u2014 it will not be shown again.
+Store it as \`DATABRAIN_API_TOKEN\` in your backend environment.
+Update any services that used the old token.
+
+Next: call \`setup_embed_interactive\` with step \`"list_embeds"\` and state:
+\`\`\`json
+` + JSON.stringify({ ...state, apiToken: "[REDACTED \u2014 stored in session]" }, null, 2) + "\n```"
+              );
+            }
             const result = await client.request({
               method: "POST",
               path: "/api/v2/data-app/api-tokens",
-              body: { dataAppName: state.dataAppName, name: `mcp-embed-setup-${Date.now()}` },
+              body: { dataAppName: state.dataAppName, name: `${state.dataAppName}-api-token` },
               auth: "service"
             });
             client.setRuntimeApiToken(result.key);
@@ -2492,7 +3613,9 @@ Next: call \`setup_embed_interactive\` with step \`"list_embeds"\` and state:
 
 **Token:** \`${result.key}\`
 
-WARNING: This token is shown once. Store it backend-side only. Never expose it in frontend code or logs.
+\u26A0\uFE0F Save this token securely \u2014 it will not be shown again.
+Store it as \`DATABRAIN_API_TOKEN\` in your backend environment. Never expose it in frontend code.
+This is the **only** API token needed for this data app \u2014 reuse it across sessions.
 
 Next: call \`setup_embed_interactive\` with step \`"list_embeds"\` and state:
 \`\`\`json
@@ -2562,7 +3685,7 @@ Next: call \`setup_embed_interactive\` with step \`"choose_embed"\` and \`userCh
             const embeds = await client.request({
               method: "GET",
               path: "/api/v2/data-app/embeds",
-              auth: "api",
+              auth: "service",
               cacheKey: "list_embeds",
               cacheTtlMs: 5 * 60 * 1e3
             });
@@ -2672,13 +3795,18 @@ WARNING: The API token from step "create_token" was shown once. If you lost it,
 // src/tools/registry.ts
 function registerAllTools(server, client) {
   registerListDatasources(server, client);
+  registerCreateDatasource(server, client);
+  registerSyncDatasource(server, client);
   registerCreateDataApp(server, client);
   registerListDataApps(server, client);
   registerCreateApiToken(server, client);
   registerListApiTokens(server, client);
   registerRotateApiToken(server, client);
+  registerSetApiToken(server, client);
   registerListDatamarts(server, client);
+  registerCreateDatamart(server, client);
   registerGetSemanticLayerStatus(server, client);
+  registerGenerateSemanticLayer(server, client);
   registerCreateEmbed(server, client);
   registerListEmbeds(server, client);
   registerGetEmbedDetails(server, client);
@@ -2686,6 +3814,12 @@ function registerAllTools(server, client) {
   registerDeleteEmbed(server, client);
   registerRenameEmbed(server, client);
   registerApplyThemePreset(server, client);
+  registerCustomizeTheme(server, client);
+  registerConfigureChartAppearance(server, client);
+  registerConfigureEmbedOptions(server, client);
+  registerConfigureFilters(server, client);
+  registerConfigureInternationalization(server, client);
+  registerGetPermissionSchema(server);
   registerGenerateGuestToken(server, client);
   registerGenerateEmbedCode(server, client);
   registerListDashboards(server, client);
@@ -2848,16 +3982,16 @@ All API requests require authentication via one of two token types passed in the
 \`Authorization\` header:
 
 ### Service Token
-- **Purpose**: Manage workspace-level resources (datasources, data apps, datamarts, embeds).
+- **Purpose**: Manage workspace-level resources (datasources, data apps, datamarts, API tokens).
 - **Header**: \`Authorization: Bearer <service-token>\`
 - **Scope**: Entire workspace. Found in workspace settings.
-- **Used for**: All CRUD operations on datasources, data apps, datamarts, embeds, and dashboards listing.
+- **Used for**: CRUD on datasources, data apps, datamarts, and API token management.
 
 ### API Token
-- **Purpose**: Generate guest tokens for end-user embedding.
+- **Purpose**: Manage data-app-scoped resources and generate guest tokens.
 - **Header**: \`Authorization: Bearer <api-token>\`
-- **Scope**: A single data app.
-- **Used for**: Guest token generation and metric data queries.
+- **Scope**: A single data app. One API token per data app.
+- **Used for**: Embed CRUD, dashboard/metric listing, guest token generation, and data queries.
 
 > **Important**: Service Tokens and API Tokens are **not interchangeable**. Use the
 > correct token type for each endpoint.
@@ -2985,10 +4119,12 @@ available from synced datasources when using additional query parameters.
 ### Create Embed
 \`\`\`
 POST /api/v2/data-app/embeds
-Authorization: Bearer <service-token>
+Authorization: Bearer <api-token>
 Content-Type: application/json
 \`\`\`
 
+**Note**: Embed endpoints use an **API Token** (data-app-scoped), not a Service Token.
+
 Creates an embed configuration linking a dashboard to embeddable settings.
 
 Key body fields:
@@ -3001,27 +4137,27 @@ Key body fields:
 ### List Embeds
 \`\`\`
 GET /api/v2/data-app/embeds?dataAppId=<id>
-Authorization: Bearer <service-token>
+Authorization: Bearer <api-token>
 \`\`\`
 
 Returns all embed configurations for a data app.
 
 ### Get Embed
 \`\`\`
-GET /api/v2/data-app/embeds/<embed-id>
-Authorization: Bearer <service-token>
+GET /api/v2/data-app/embeds?embedId=<embed-id>
+Authorization: Bearer <api-token>
 \`\`\`
 
 Returns a single embed configuration by ID.
 
 ### Update Embed
 \`\`\`
-PUT /api/v2/data-app/embeds/<embed-id>
-Authorization: Bearer <service-token>
+PUT /api/v2/data-app/embeds
+Authorization: Bearer <api-token>
 Content-Type: application/json
 \`\`\`
 
-Updates an existing embed configuration (theme, access settings, etc.).
+Body must include \`embedId\` and \`accessSettings\`. Fetch the current embed via GET first and merge your changes to avoid overwriting existing settings.
 
 ---
 
@@ -3037,12 +4173,17 @@ Content-Type: application/json
 **Note**: This endpoint uses an **API Token**, not a Service Token.
 
 Key body fields:
-- \`embedId\` (string) - The embed configuration ID
-- \`appFilters\` (array) - Global filters applied to all metrics
+- \`clientId\` (string, required) - Tenant identifier for multi-tenancy / row-level security
+- \`dataAppName\` (string, required) - Name of the data app
+- \`appFilters\` (array) - Global filters applied to all metrics (server-side enforced)
 - \`dashboardAppFilters\` (array) - Dashboard-specific filters
-- \`clientId\` (string) - Tenant identifier for multi-tenancy / row-level security
+- \`permissions\` (object) - Runtime permission overrides (e.g. \`isEnableDownloadMetrics\`)
 - \`theme\` (object) - Runtime theme overrides
-- \`accessSettings\` (object) - Runtime permission overrides
+- \`hideDashboardFilters\` (array) - Filter names to hide
+- \`expiryTime\` (number) - Token TTL in milliseconds
+- \`datasourceName\` (string) - Multi-datasource routing
+
+> **Rejected fields**: \`allowedEmbeds\` and \`accessSettings\` are NOT accepted and will return 400.
 
 Returns: \`{ "token": "<guest-token>", "expiresAt": "<timestamp>" }\`
 
@@ -3074,7 +4215,7 @@ Returns the query result data as rows and columns.
 ### List Dashboards
 \`\`\`
 GET /api/v2/data-app/dashboards?dataAppId=<id>
-Authorization: Bearer <service-token>
+Authorization: Bearer <api-token>
 \`\`\`
 
 Returns all dashboards in a data app. Note: dashboards are **created in the Databrain
@@ -3083,7 +4224,7 @@ UI**, not via the API.
 ### List Metrics
 \`\`\`
 GET /api/v2/data-app/metrics?dashboardId=<id>
-Authorization: Bearer <service-token>
+Authorization: Bearer <api-token>
 \`\`\`
 
 Returns all metrics within a dashboard.
@@ -4408,23 +5549,40 @@ Set default access settings when creating or updating an embed:
 
 ### Runtime Overrides via Guest Token
 
-Override access settings at guest token generation time. This is useful for role-based
-access where different users get different permissions:
+Override permissions at guest token generation time using the \`permissions\` field.
+This is useful for role-based access where different users get different permissions.
+
+> **Important**: The guest token API accepts \`permissions\`, NOT \`accessSettings\`.
+> Sending \`accessSettings\` or \`allowedEmbeds\` in a guest token request will return a 400 error.
 
 \`\`\`json
 {
-  "embedId": "embed-789",
   "clientId": "tenant-abc",
-  "accessSettings": {
-    "isAllowMetricCreation": true,
-    "isAllowMetricEditing": true,
-    "isAllowAiPilot": true,
-    "metricCreationMode": "CHAT"
+  "dataAppName": "My App",
+  "permissions": {
+    "isEnableManageMetrics": true,
+    "isEnableDownloadMetrics": true,
+    "isEnableUnderlyingData": true,
+    "isEnableCustomizeLayout": true
   }
 }
 \`\`\`
 
-Guest token access settings **merge with and override** embed-level settings. Only the
+**Accepted \`permissions\` fields:**
+| Field | Description |
+|---|---|
+| \`isEnableArchiveMetrics\` | Allow archiving metrics |
+| \`isEnableManageMetrics\` | Allow managing metrics |
+| \`isEnableCreateDashboardView\` | Allow creating dashboard views |
+| \`isEnableMetricUpdation\` | Allow editing metrics |
+| \`isEnableCustomizeLayout\` | Allow layout customization |
+| \`isEnableUnderlyingData\` | Allow viewing underlying data |
+| \`isEnableDownloadMetrics\` | Allow downloading metric data |
+| \`isShowSideBar\` | Show the sidebar |
+| \`isShowDashboardName\` | Show the dashboard name |
+| \`isDisableMetricCreation\` | Disable metric creation |
+
+Guest token permissions **merge with and override** embed-level access settings. Only the
 flags you specify are overridden; unspecified flags keep their embed-level values.
 
 ### Component-Level Overrides
@@ -4455,7 +5613,7 @@ Override access settings via the web component \`options\` attribute:
 When the same flag is set at multiple levels, the highest precedence wins:
 
 1. **Web component \`options\`** (highest - client-side)
-2. **Guest token \`accessSettings\`** (server-side, per session)
+2. **Guest token \`permissions\`** (server-side, per session)
 3. **Embed configuration \`accessSettings\`** (server-side, default)
 
 > **Best Practice**: Set restrictive defaults at the embed level. Use guest token
@@ -5150,55 +6308,517 @@ function registerAllResources(server) {
   }
 }
 
-// src/prompts/explore-data.ts
-var exploreDataPrompt = `You are helping the user explore what data and resources are available in their Databrain workspace. Gather a complete picture and provide actionable recommendations.
+// src/prompts/setup-from-scratch.ts
+var setupFromScratchPrompt = `You are guiding the user through a complete Databrain setup from scratch. Follow these steps in order, confirming each before moving on.
+
+**Step 1 \u2014 Connect a Database**
+Ask the user for their database type (e.g. PostgreSQL, MySQL, BigQuery, Snowflake, Redshift, etc.) and connection credentials (host, port, database name, username, password, or any provider-specific fields).
+Once you have the details, call \`create_datasource\` with the provided configuration.
 
-**Step 1 \u2014 Inventory All Resources**
-If the user has an API token configured, call all of these to build a full picture:
-- \`list_datasources\` \u2014 connected databases
-- \`list_data_apps\` \u2014 workspace containers
-- \`list_datamarts\` \u2014 configured data models and table selections
-- \`list_dashboards\` \u2014 created dashboards
+**Step 2 \u2014 Sync the Schema**
+After the datasource is created, call \`sync_datasource\` to refresh the schema so Databrain can discover all available tables and columns.
 
-If any call fails due to missing authentication, note which resources could not be retrieved and advise the user to set up an API token first.
+**Step 3 \u2014 Create a Data App**
+Call \`create_data_app\` to create a workspace container that will hold dashboards and embeds. Ask the user for a name, or suggest a sensible default.
 
-**Step 2 \u2014 Summarize the Data Landscape**
-Present a clear summary organized by data app:
-- For each data app, list its datasources, datamarts, dashboards, and embeds.
-- Highlight key details: number of tables in each datamart, whether semantic layers are configured, whether embeds exist, and any multi-tenant settings.
-- Call out anything that looks incomplete (e.g. a datamart with no dashboard, a dashboard with no embed).
+**Step 4 \u2014 Ensure an API Token Exists**
+Call \`list_api_tokens\` for the data app. If a token already exists, ask the user to provide it and call \`set_api_token\`. Only call \`create_api_token\` if **no tokens exist** \u2014 there should be exactly one API token per data app. Warn the user to save the token securely as it will not be shown again.
 
-**Step 3 \u2014 Suggest Next Steps**
-Based on what you find, recommend the most relevant next actions:
+**Step 5 \u2014 Create a Datamart**
+List the synced tables and ask the user which ones they want to include in their datamart. Call \`create_datamart\` with the selected tables. Help the user define joins if multiple tables are selected.
 
-If **no resources exist at all**:
-- Suggest running the \`setup-from-scratch\` prompt to get started with the full onboarding funnel.
+**Step 6 \u2014 (Optional) Generate Semantic Layer**
+Ask the user if they want to enable AI-powered chat on their data. If yes, call \`generate_semantic_layer\` for the datamart. Explain that this lets end-users ask natural-language questions about their data.
 
-If **datasources exist but no datamarts**:
-- Suggest creating datamarts to model the data for dashboarding.
+**Step 7 \u2014 Create a Dashboard (Manual Step)**
+Tell the user: "Now open the Databrain UI to create a dashboard. Add metrics and charts using the datamart you just created. Let me know when you're done and I'll help you embed it."
+Wait for the user to confirm the dashboard is ready before proceeding.
 
-If **datamarts exist but no dashboards**:
-- Suggest the user create dashboards in the Databrain UI.
+**Step 8 \u2014 Create an Embed**
+Once the user confirms the dashboard is ready, call \`create_embed\` with recommended settings:
+- Link it to the dashboard and data app created earlier
+- Enable reasonable defaults (e.g. theme settings, allowed interactivity)
 
-If **dashboards exist but no embeds**:
-- Suggest running the \`embed-dashboard\` prompt to embed a dashboard.
+**Step 9 \u2014 Generate Embed Code**
+Ask the user which frontend framework they use (React, Next.js, Vue, Angular, vanilla HTML, etc.). Call \`generate_embed_code\` with the chosen framework to produce copy-paste-ready integration code.
 
-If **embeds exist but AI chat is not enabled**:
-- Suggest running the \`setup-ai-chat\` prompt to enable AI-powered data exploration.
+**Reference**: Use the \`databrain://getting-started\` resource for additional context on the Databrain entity model and how datasources, data apps, datamarts, dashboards, and embeds relate to each other.
 
-If **everything is set up**:
-- Confirm the workspace looks complete.
-- Suggest enabling multi-tenancy if not configured (reference the \`setup-multi-tenant\` prompt).
-- Suggest regenerating the semantic layer if the schema has changed recently.
+Walk through each step conversationally. Confirm success at each stage before moving to the next. If any step fails, help the user troubleshoot before continuing.`;
 
-Be concise but thorough. The goal is to give the user a clear understanding of their current state and a clear path forward.`;
+// src/prompts/setup-ai-chat.ts
+var setupAiChatPrompt = `You are helping the user enable AI-powered chat (AI Pilot) on their embedded Databrain dashboard. Follow these steps.
+
+**Step 1 \u2014 Check Semantic Layer Status**
+Call \`list_datamarts\` to see all available datamarts. For each relevant datamart, check whether a semantic layer has already been generated.
+
+**Step 2 \u2014 Generate Semantic Layer (if needed)**
+If no semantic layer exists for the target datamart:
+- Call \`generate_semantic_layer\` for that datamart.
+- Explain that the semantic layer teaches the AI about the data's structure, relationships, and business meaning so it can answer natural-language questions accurately.
+- Poll with \`get_semantic_layer_status\` until the generation is complete. Let the user know the progress.
+
+If a semantic layer already exists, confirm this with the user and ask if they want to regenerate it (useful after schema changes).
+
+**Step 3 \u2014 Enable AI Chat on the Embed**
+Call \`update_embed\` to configure the embed for AI chat mode:
+- Set \`isAllowAiPilot\` to true to enable the AI chat interface.
+- Set \`metricCreationMode\` to \`CHAT\` so end-users can ask questions and get chart responses.
+
+Explain what these settings do:
+- \`isAllowAiPilot\`: Adds the AI chat icon/panel to the embedded dashboard.
+- \`metricCreationMode: CHAT\`: Allows the AI to create new metric visualizations in response to user questions.
+
+**Step 4 \u2014 Generate Updated Frontend Code**
+Call \`generate_embed_code\` to produce updated integration code that includes the AI chat configuration. Make sure the user replaces their existing embed code with this updated version.
+
+**Reference**: Use \`databrain://semantic-layer-guide\` for detailed information about how the semantic layer works, how to review and refine it, and best practices for getting accurate AI responses.
+
+Walk the user through each step. If the semantic layer generation takes time, keep them informed of progress. After setup, suggest they test the AI chat by asking a sample question about their data.
+
+**Important:** After enabling AI features on the embed, existing guest tokens still carry the old configuration. Remind the user to **regenerate guest tokens** (or reload their app) for changes to take effect.`;
+
+// src/prompts/brand-my-embed.ts
+var brandMyEmbedPrompt = `You are helping the user brand and visually customize their embedded Databrain dashboard. Follow these steps.
+
+**Step 1 \u2014 Identify the Embed**
+Call \`list_embeds\` to show available embeds. Ask the user which one they want to brand. Then call \`get_embed_details\` to see the current theme and configuration.
+
+**Step 2 \u2014 Understand Brand Requirements**
+Ask the user about their brand. Gather as many of these as they can provide:
+- **Primary brand color** (e.g. "#4F46E5")
+- **Secondary/accent color**
+- **Font family** (e.g. Inter, Roboto, Open Sans, system default)
+- **Style preference** \u2014 modern/rounded vs corporate/sharp vs minimal/clean
+- **Dark or light mode?**
+- **Any specific chart colors they want?**
+
+If they're unsure, suggest starting with a preset (\`light\`, \`dark\`, \`corporate\`, or \`minimal\`) using \`apply_embed_preset\` and refining from there.
+
+**Step 3 \u2014 Apply Theme**
+Use \`customize_embed_theme\` with the gathered brand values. Map their preferences to:
+- \`primaryColor\`, \`backgroundColor\`, \`textColor\` \u2014 from their brand colors
+- \`fontFamily\` \u2014 from their font choice
+- \`cardBorderRadius\` \u2014 "12px" for modern/rounded, "4px" for corporate, "0px" for minimal
+- \`cardShadow\` \u2014 subtle shadow for modern, "none" for minimal
+- \`dashboardBackgroundColor\` \u2014 slightly off-white for light, dark gray for dark
+- \`chartColors\` \u2014 if they provided specific colors, use those
+
+Also set component-level theme if they have button/checkbox color preferences:
+- \`buttonPrimaryColor\`, \`buttonPrimaryTextColor\`
+- \`checkboxCheckedColor\`, \`switchEnabledColor\`
+
+**Step 4 \u2014 Configure Chart Appearance**
+Use \`configure_chart_appearance\` to fine-tune charts:
+- Set \`legendPosition\` \u2014 "bottom-center" is a safe default
+- Set \`legendShape\` \u2014 "circle" for modern, "rect" for corporate
+- Set \`legendLayout\` \u2014 "horizontal" usually works best
+- Set chart colors if not already done via theme
+
+Ask if they want to customize tooltip fonts, axis styling, or label positions.
+
+**Step 5 \u2014 Configure Display Options**
+Use \`configure_embed_options\` to clean up the UI:
+- Ask if they want to hide the dashboard name (\`hideDashboardName\`)
+- Ask about card shadows and borders
+- Ask about download/export options they want to show
+- Suggest disabling chart settings and table preview for a cleaner look for end-users
+
+**Step 6 \u2014 Preview and Iterate**
+Tell the user to refresh their embed to see the changes. Ask:
+- "Does this match your brand?"
+- "Anything you'd like to adjust \u2014 colors, fonts, spacing, chart styling?"
+
+Iterate by calling the relevant tools again with adjusted values. Remember: all customization tools merge with existing config, so they only need to send what changed.
+
+**Important:** After any theme or styling changes, existing guest tokens still carry the old configuration. Remind the user to **regenerate guest tokens** (or reload their app) for changes to take effect.
+
+**Reference**: Use \`databrain://theme-reference\` for the full theme schema and \`databrain://web-component-reference\` for all component attributes.`;
+
+// src/prompts/localize-embed.ts
+var localizeEmbedPrompt = `You are helping the user set up multi-language support for their embedded Databrain dashboard. Follow these steps.
+
+**Step 1 \u2014 Identify the Embed and Target Languages**
+Call \`list_embeds\` and ask the user which embed to localize. Then ask:
+- Which languages do they need? (Supported: English, French, Spanish, German, Italian, Portuguese, Chinese, Japanese, Korean, Hindi, Arabic, Russian)
+- What is the default/primary language?
+
+**Step 2 \u2014 Set the Primary Language**
+Use \`configure_internationalization\` with the \`language\` parameter set to their primary language code (e.g. "fr" for French).
+
+**Step 3 \u2014 Gather Translations**
+Call \`get_embed_details\` to understand what text is in the dashboard. Then help the user build translations:
+
+Ask the user to list the key text elements in their dashboard:
+- Dashboard title
+- Metric titles and descriptions
+- Filter labels
+- Any footnotes or annotations
+
+For each text element, ask for translations in their target languages. Build translation entries like:
+\`\`\`
+{ key: "Revenue", translations: { fr: "Revenus", es: "Ingresos", de: "Einnahmen" } }
+\`\`\`
+
+**Important rules for translation keys:**
+- Keys must match the dashboard text EXACTLY (case-sensitive)
+- Define longer keys before shorter ones to avoid partial matches
+- If a translation is missing for a language, the original key text is shown as fallback
+
+**Step 4 \u2014 Apply Translations**
+Use \`configure_internationalization\` with the \`translations\` array containing all entries.
+
+**Step 5 \u2014 Configure Calendar (if needed)**
+Ask if they need a different calendar system:
+- \`"default"\` \u2014 standard Gregorian calendar
+- \`"ind"\` \u2014 Indian calendar format
+
+Set via \`calendarType\` if needed.
+
+**Step 6 \u2014 Set Custom Messages**
+Ask if they want to translate system messages:
+- Token expiry message (shown when session expires)
+- Token absent message (shown when no auth token)
+
+Use \`configure_internationalization\` with \`tokenExpiryMessage\` and \`tokenAbsentMessage\` in their primary language.
+
+**Step 7 \u2014 Test**
+Tell the user to refresh the embed and verify translations appear correctly. If any text isn't translating, double-check that the key matches exactly.
+
+Remind the user: translations can also be applied per-user at the web component level using the \`translation-dictionary\` attribute, which is useful for dynamically switching languages based on user preferences.
+
+**Important:** After changing language or translation settings, existing guest tokens still carry the old configuration. Remind the user to **regenerate guest tokens** (or reload their app) for changes to take effect.`;
+
+// src/prompts/secure-my-embed.ts
+var secureMyEmbedPrompt = `You are helping the user secure and configure permissions for their embedded Databrain dashboard. Follow these steps.
+
+**Step 1 \u2014 Understand User Roles**
+Ask the user about their end-user roles. Common patterns:
+- **Viewer** \u2014 can see data, maybe filter, but can't modify anything
+- **Analyst** \u2014 can export data, drill down, use filters
+- **Builder/Power User** \u2014 can create/edit metrics, change layouts
+- **Admin** \u2014 full access including AI features
+
+Ask: "What roles do your end-users have? What should each role be allowed to do?"
+
+**Step 2 \u2014 Lock Down the Embed Defaults**
+Use \`configure_embed_options\` to set restrictive defaults (principle of least privilege):
+
+\`\`\`
+configure_embed_options(embedId,
+  disableMetricCreation: true,
+  disableMetricUpdation: true,
+  disableMetricDeletion: true,
+  disableManageMetrics: true,
+  disableLayoutCustomization: true,
+  disableSaveLayout: true,
+  disableUnderlyingData: true,
+  disableScheduleEmailReports: true,
+  enableDownloadCsv: false,
+  enableDownloadAllPdf: false)
+\`\`\`
+
+Explain: "We start with everything locked down, then use guest token permissions to grant access per role."
+
+**Step 3 \u2014 Create Role-Based Guest Token Examples**
+Show the user how to generate tokens for each role:
+
+**Viewer (default \u2014 no overrides needed):**
+\`\`\`
+generate_guest_token(clientId, dataAppName)
+\`\`\`
+
+**Analyst (can export and drill down):**
+\`\`\`
+generate_guest_token(clientId, dataAppName, {
+  permissions: {
+    isEnableDownloadMetrics: true,
+    isEnableUnderlyingData: true
+  }
+})
+\`\`\`
+
+**Builder (can create and edit):**
+\`\`\`
+generate_guest_token(clientId, dataAppName, {
+  permissions: {
+    isEnableManageMetrics: true,
+    isEnableMetricUpdation: true,
+    isEnableCustomizeLayout: true
+  }
+})
+\`\`\`
+
+**Admin (full access with AI):**
+\`\`\`
+generate_guest_token(clientId, dataAppName, {
+  permissions: {
+    isEnableManageMetrics: true,
+    isEnableMetricUpdation: true,
+    isEnableCustomizeLayout: true,
+    isEnableDownloadMetrics: true,
+    isEnableUnderlyingData: true
+  },
+  accessSettings: {
+    isAllowAiPilot: true,
+    isAllowAiSummary: true
+  }
+})
+\`\`\`
+
+**Step 4 \u2014 Multi-Tenancy Check**
+Ask: "Do different customers/organizations see different data?"
+
+If yes:
+- Explain that \`clientId\` in the guest token controls row-level security
+- The \`clientId\` must match values in the datamart's client column
+- Suggest the \`setup-multi-tenant\` prompt for full multi-tenancy setup
+
+**Step 5 \u2014 Security Checklist**
+Walk through this checklist with the user:
+
+1. \u2705 API token is stored server-side only (never in frontend code)
+2. \u2705 Guest tokens are generated server-side per request
+3. \u2705 Guest tokens have appropriate expiry time
+4. \u2705 Embed defaults are restrictive (locked down in Step 2)
+5. \u2705 Role-based permissions are granted via guest token overrides
+6. \u2705 Multi-tenancy is configured if serving multiple customers
+7. \u2705 Download restrictions are set (\`disableDownloadDataNoFilters\` if needed)
+
+**Step 6 \u2014 Generate Secure Frontend Code**
+Call \`generate_embed_code\` for their framework. Emphasize that the generated code includes a backend route for token generation \u2014 this is the secure pattern.
+
+**Important:** After changing embed permissions or access settings, existing guest tokens still carry the old configuration. Remind the user to **regenerate guest tokens** (or reload their app) for changes to take effect.
+
+**Reference**: Use \`databrain://self-serve-reference\` for all permission flags and \`databrain://multi-tenancy-guide\` for row-level security details.`;
+
+// src/prompts/setup-filters.ts
+var setupFiltersPrompt = `You are helping the user configure dashboard filters for their embedded Databrain dashboard. Follow these steps.
+
+**Step 1 \u2014 Understand the Data**
+Call \`list_embeds\` and ask which embed to configure. Then call \`get_embed_details\` to see the current filter configuration.
+
+Also call \`list_datamarts\` to understand what tables and columns are available \u2014 this helps suggest appropriate filters.
+
+**Step 2 \u2014 Identify Filter Needs**
+Ask the user:
+- "What filters do your end-users need?" (e.g. date range, region, product category, status)
+- "Should any filters have default values?"
+- "Are there filters you want to hide from end-users?" (e.g. internal IDs)
+- "Do any filters have very large option lists?" (100+ options \u2014 these benefit from SQL-based filters)
+
+**Step 3 \u2014 Configure String Filters**
+For text/category filters, use \`configure_filters\` with \`stringFilters\`:
+
+\`\`\`
+stringFilters: [{
+  filterName: "Region",
+  options: [
+    { value: "US", label: "United States" },
+    { value: "EU", label: "Europe" },
+    { value: "APAC", label: "Asia Pacific" }
+  ],
+  defaultOption: "US"
+}]
+\`\`\`
+
+For multi-select defaults, use an array: \`defaultOption: ["US", "EU"]\`
+
+**Step 4 \u2014 Configure Date Filters**
+For date range filters, use \`dateFilters\`:
+
+\`\`\`
+dateFilters: [{
+  filterName: "Date Range",
+  startDate: "2024-01-01",
+  endDate: "2024-12-31",
+  datePresetOptions: [
+    { label: "Last 30 Days", type: "Last", interval: "Days" },
+    { label: "This Quarter", type: "This", interval: "Quarter" },
+    { label: "This Year", type: "This", interval: "Year" }
+  ]
+}]
+\`\`\`
+
+**Step 5 \u2014 Configure Number Filters**
+For numeric range filters, use \`numberFilters\`:
+
+\`\`\`
+numberFilters: [{
+  filterName: "Revenue",
+  min: 0,
+  max: 1000000
+}]
+\`\`\`
+
+**Step 6 \u2014 SQL-Based Filters (for large datasets)**
+If a filter has 100+ options (e.g. company names, product SKUs), use \`sqlFilters\`:
+
+\`\`\`
+sqlFilters: [{
+  filterName: "Company",
+  sql: "SELECT DISTINCT \\"company_name\\" FROM \\"companies\\" ORDER BY \\"company_name\\"",
+  columnName: "company_name"
+}]
+\`\`\`
+
+Explain: "SQL filters dynamically fetch options from the database, so they're always up-to-date and don't bloat the embed configuration."
+
+**Step 7 \u2014 Hide Unnecessary Filters**
+If the user has filters that should be hidden (e.g. internal IDs, tenant columns already handled by clientId):
+
+\`\`\`
+hideDashboardFilters: ["internal_id", "tenant_id"]
+\`\`\`
+
+**Step 8 \u2014 Configure Date Picker Options**
+Ask if they want to hide certain date picker presets:
+
+\`\`\`
+hideDatePickerOptions: ["yesterday", "last week"]
+\`\`\`
+
+**Step 9 \u2014 Metric Filter Position**
+Ask: "Do you want metric-level filters inside the card or outside?"
+- \`"inside"\` \u2014 compact, within each metric card (default)
+- \`"outside"\` \u2014 above the card, more prominent
+
+Also ask if they want cross-metric filtering (\`enableMultiMetricFilters\`).
+
+**Step 10 \u2014 Server-Side Filters (via Guest Token)**
+If the user needs filters that end-users cannot remove (e.g. for security):
+- Explain that \`appFilters\` in \`generate_guest_token\` are server-side enforced
+- These are invisible to the end-user and cannot be overridden
+- Perfect for tenant filtering, role-based data access, or compliance requirements
+
+Show an example:
+\`\`\`
+generate_guest_token(clientId, dataAppName, {
+  appFilters: [{
+    columnName: "region",
+    tableName: "sales",
+    operator: "IN",
+    value: ["US", "CA"],
+    type: "string"
+  }]
+})
+\`\`\`
+
+**Important:** After changing filter settings, existing guest tokens still carry the old configuration. Remind the user to **regenerate guest tokens** (or reload their app) for changes to take effect.
+
+**Reference**: Use \`databrain://filter-reference\` for all filter types, operators, and combination rules.`;
+
+// src/prompts/manage-embeds.ts
+var manageEmbedsPrompt = `You are helping the user manage their Databrain embed configurations \u2014 list, compare, rename, delete, and maintain tokens. Follow these steps based on what the user needs.
+
+**Step 1 \u2014 Understand the Task**
+Ask the user what they want to do:
+1. **List and compare embeds** \u2014 see all embeds and their configurations
+2. **Rename an embed** \u2014 change the display name
+3. **Delete an embed** \u2014 remove an embed configuration
+4. **Rotate an API token** \u2014 invalidate an old token and get a new one
+5. **Review embed settings** \u2014 audit theme, permissions, and options
+
+**For Listing and Comparing Embeds:**
+1. Call \`list_embeds\` to show all embed configurations
+2. For detailed comparison, call \`get_embed_details\` on each embed the user wants to compare
+3. Present a comparison table showing:
+   - Embed name and ID
+   - Linked dashboard
+   - Theme (preset or custom)
+   - Key permissions (metric creation, downloads, AI pilot)
+   - Multi-tenancy settings
+
+**For Renaming an Embed:**
+1. Call \`list_embeds\` to show current names
+2. Ask which embed to rename and what the new name should be
+3. Call \`rename_embed\` with the embed ID and new name
+4. Confirm the rename succeeded
+
+**For Deleting an Embed:**
+1. Call \`list_embeds\` to show embeds
+2. Ask which embed to delete
+3. \u26A0\uFE0F **Warn the user**: "Deleting an embed is permanent. Any frontend code using this embed ID will stop working. Guest tokens generated for this embed will be invalidated."
+4. Ask for explicit confirmation before proceeding
+5. Call \`delete_embed\` with the embed ID
+6. Confirm deletion
+
+**For Rotating an API Token:**
+1. Call \`list_api_tokens\` to show existing tokens
+2. Explain: "Rotating a token invalidates the old one immediately and generates a new one. Any backend services using the old token will need to be updated."
+3. Ask for confirmation
+4. Call \`rotate_api_token\` with the token details
+5. Show the new token and warn: "Save this securely \u2014 it will not be shown again"
+6. Remind the user to update:
+   - Their backend \`DATABRAIN_API_TOKEN\` env var
+   - Any CI/CD secrets
+   - Their MCP server configuration (if using env var)
+
+**For Reviewing Embed Settings:**
+1. Call \`get_embed_details\` for the embed
+2. Present a clear summary organized by category:
+
+   **Theme:**
+   - Current preset or custom theme values
+   - Suggest \`customize_embed_theme\` if they want changes
+
+   **Permissions / Access Settings:**
+   - What's enabled vs disabled
+   - Suggest \`configure_embed_options\` for changes
+
+   **Filters:**
+   - Current filter configuration
+   - Suggest \`configure_filters\` for changes
+
+   **Internationalization:**
+   - Current language and translations
+   - Suggest \`configure_internationalization\` for changes
+
+3. Ask: "Would you like to modify any of these settings?"
+
+**Tips:**
+- Embed IDs are permanent \u2014 even if you rename an embed, the ID stays the same
+- Before deleting an embed, consider if you can reconfigure it instead
+- After rotating a token, use \`set_api_token\` to update the current MCP session
+- Regular token rotation is a security best practice \u2014 consider rotating every 90 days
+- After any embed setting changes, existing guest tokens still carry the old configuration \u2014 **regenerate guest tokens** for changes to take effect`;
 
 // src/prompts/registry.ts
 var prompts = [
   {
-    name: "explore-data",
-    description: "Explore what data and dashboards are available in your Databrain workspace",
-    content: exploreDataPrompt
+    name: "setup-from-scratch",
+    description: "Full guided setup: connect a datasource, create datamarts, build a dashboard, create an embed, and generate frontend code",
+    content: setupFromScratchPrompt
+  },
+  {
+    name: "brand-my-embed",
+    description: "Customize colors, fonts, chart styles, and component theme to match your brand",
+    content: brandMyEmbedPrompt
+  },
+  {
+    name: "localize-embed",
+    description: "Set up multi-language support with translations and locale settings",
+    content: localizeEmbedPrompt
+  },
+  {
+    name: "secure-my-embed",
+    description: "Configure permissions, access controls, and role-based guest tokens",
+    content: secureMyEmbedPrompt
+  },
+  {
+    name: "setup-filters",
+    description: "Configure dashboard filters: string, date, number, SQL-based, and server-side filters",
+    content: setupFiltersPrompt
+  },
+  {
+    name: "setup-ai-chat",
+    description: "Enable AI Pilot (natural language Q&A) on your embedded dashboard",
+    content: setupAiChatPrompt
+  },
+  {
+    name: "manage-embeds",
+    description: "List, compare, rename, delete embeds and rotate API tokens",
+    content: manageEmbedsPrompt
   }
 ];
 function registerAllPrompts(server) {