@databrainhq/mcp-server 0.2.5 → 0.2.6

package/dist/index.js

@@ -4481,26 +4481,39 @@ function registerGenerateWidget(server, client) {
   const services = createServiceBundle(client);
   server.tool(
     "generate_widget",
-    "AI-generate a widget draft from a natural-language prompt. Does NOT persist \u2014 returns a draft (query, metadata) the caller can review and pass to `add_widget`. Mints a guest token internally.",
+    "AI-generate a widget draft from a natural-language prompt. Does NOT persist \u2014 returns a draft the caller can review and pass to `add_widget`. Data app and datasource auto-resolve from `embedId` (preferred) or from the sole workspace defaults. `dataAppName`/`integrationId`/`integrationName` are technical overrides.",
     {
       clientId: z25.string().describe("Client/tenant identifier"),
-      dataAppName: z25.string().describe("Data app name (required to mint guest token)"),
-      integrationId: z25.string().describe("Datasource ID to generate the widget against. Use `list_datasources` to find."),
-      integrationName: z25.string().describe("Datasource name (matches integrationId)"),
       userInputs: z25.record(z25.unknown()).describe('Prompt + context object. Typical shape: { prompt: "calls per day over last 30 days", schema: {...}, examples: [...] }. Backend decides which keys it honors.'),
-      embedId: z25.string().optional().describe("Optional \u2014 scopes the guest token to this embed.")
+      embedId: z25.string().optional().describe("Optional. When provided, data app and datasource are inherited from the embed's existing widgets \u2014 the preferred path for CS/CX flows."),
+      dataAppName: z25.string().optional().describe("Optional override. Auto-resolved from embedId, or from the sole data app when there is only one."),
+      integrationId: z25.string().optional().describe("Optional datasource override (technical users only). Auto-resolved from the embed's widgets, or from the sole datasource when there is only one."),
+      integrationName: z25.string().optional().describe("Optional datasource name override. Auto-resolved alongside integrationId.")
     },
     READ_ONLY,
     async (params) => {
       try {
+        const dataAppName = await resolveDataAppName(
+          services,
+          params.dataAppName,
+          params.embedId
+        );
+        if (!dataAppName.ok) return toolError(dataAppName.error);
         const guestToken = await services.widgetService.mintGuestToken(
           params.clientId,
-          params.dataAppName,
+          dataAppName.value,
           params.embedId ? [params.embedId] : void 0
         );
-        const result = await services.widgetsApi.generateMetric(guestToken, {
+        const datasource = await resolveDatasource(services, guestToken, {
+          embedId: params.embedId,
+          clientId: params.clientId,
           integrationId: params.integrationId,
-          integrationName: params.integrationName,
+          integrationName: params.integrationName
+        });
+        if (!datasource.ok) return toolError(datasource.error);
+        const result = await services.widgetsApi.generateMetric(guestToken, {
+          integrationId: datasource.value.integrationId,
+          integrationName: datasource.value.integrationName,
           userInputs: params.userInputs
         });
         const resultRec = result;
@@ -4512,6 +4525,10 @@ function registerGenerateWidget(server, client) {
         return toolSuccess(
           JSON.stringify({
             message: "Draft generated. Review the `query` and `result` fields below, then pass to `add_widget` (using raw `body` passthrough) to persist.",
+            resolved: {
+              dataAppName: dataAppName.value,
+              integrationName: datasource.value.integrationName
+            },
             draft: {
               query: resultRec.query ?? null,
               result: resultRec.result ?? null,
@@ -4528,6 +4545,89 @@ function registerGenerateWidget(server, client) {
     }
   );
 }
+async function resolveDataAppName(services, provided, embedId) {
+  if (provided) return { ok: true, value: provided };
+  if (embedId) {
+    const ctx = await services.widgetService.resolveEmbedContext(embedId);
+    if (ctx.dataAppName) return { ok: true, value: ctx.dataAppName };
+  }
+  const apps = await services.dataAppsApi.listDataApps();
+  const normalized = apps.map((a) => services.discoveryService.normalizeDataApp(a)).filter((a) => a.name && a.name !== "Unnamed Data App");
+  if (normalized.length === 1) return { ok: true, value: normalized[0].name };
+  if (normalized.length === 0) {
+    return {
+      ok: false,
+      error: "No data apps found in this workspace. Create one in the Databrain UI first."
+    };
+  }
+  return {
+    ok: false,
+    error: `Multiple data apps exist (${normalized.map((a) => `"${a.name}"`).join(", ")}). Pass \`dataAppName\` explicitly, or pass \`embedId\` to auto-resolve.`
+  };
+}
+async function resolveDatasource(services, guestToken, params) {
+  if (params.integrationId && params.integrationName) {
+    return {
+      ok: true,
+      value: {
+        integrationId: params.integrationId,
+        integrationName: params.integrationName
+      }
+    };
+  }
+  if (params.embedId) {
+    const fromEmbed = await resolveDatasourceFromEmbed(
+      services,
+      guestToken,
+      params.embedId,
+      params.clientId
+    );
+    if (fromEmbed) {
+      return {
+        ok: true,
+        value: {
+          integrationId: params.integrationId || fromEmbed.integrationId,
+          integrationName: params.integrationName || fromEmbed.integrationName
+        }
+      };
+    }
+  }
+  const datasources = await services.datasourcesApi.listDatasources();
+  const named = datasources.filter(
+    (ds) => typeof ds.name === "string" && ds.name.trim().length > 0
+  );
+  if (named.length === 1) {
+    const ds = named[0];
+    const id = ds._id || ds.id || "";
+    const name = ds.name;
+    if (id && name) {
+      return { ok: true, value: { integrationId: id, integrationName: name } };
+    }
+  }
+  if (named.length === 0) {
+    return {
+      ok: false,
+      error: "No datasources found in this workspace. Connect one in the Databrain UI first (technical setup)."
+    };
+  }
+  return {
+    ok: false,
+    error: `Could not auto-resolve a datasource. Options: ${named.map((d) => `"${d.name}"`).join(", ")}. Either pass \`embedId\` (to inherit from the embed's existing widgets), or pass \`integrationId\` + \`integrationName\` explicitly.`
+  };
+}
+async function resolveDatasourceFromEmbed(services, guestToken, embedId, clientId) {
+  const widgets = await services.widgetsApi.listWidgets(embedId, clientId);
+  const first = widgets.find((w) => typeof w.metricId === "string" && w.metricId.length > 0);
+  if (!first || !first.metricId) return null;
+  const response = await services.widgetsApi.fetchEmbeddedMetric(guestToken, first.metricId);
+  const metric = response.externalMetric;
+  if (!metric || typeof metric !== "object") return null;
+  const rec = metric;
+  const integrationId = typeof rec.companyIntegrationId === "string" ? rec.companyIntegrationId : null;
+  const integrationName = typeof rec.integrationName === "string" ? rec.integrationName : null;
+  if (!integrationId || !integrationName) return null;
+  return { integrationId, integrationName };
+}
 
 // src/tools/registry.ts
 function registerAllTools(server, client) {
@@ -7581,21 +7681,23 @@ STOP and present the list: \`{metricId, name, isPublished, createdByUser}\` per
 ASK: "What would you like to change? (add / modify / remove)" \u2014 or more specifically, "Which widgets should I add, update, or remove?"
 
 **Step 3a \u2014 ADD a widget**
-If the user wants to add a widget, STOP and ASK which sourcing mode:
+This is a business-user flow. NEVER ask the user for a datasource, \`companyIntegrationId\`, \`integrationId\`, or raw SQL unless they explicitly say they want to write SQL. Prefer the two paths below in order.
 
-1. **Clone from template** (cheapest, most common):
-   - ASK for the source \`templateMetricId\` \u2014 or call \`list_widgets\` on the template embed / another customer's embed to help pick.
-   - Call \`add_widget({ embedId, clientId, templateMetricId, name? })\`. The tool inherits query, chartOptions, and datasource from the template.
+1. **Clone an existing chart** (default \u2014 try this first):
+   - ASK: "Which existing chart should I copy from?" Call \`list_widgets\` on this embed, or on the template embed / another customer's embed, and present the widgets by name. Let the user pick by name.
+   - Call \`add_widget({ embedId, clientId, templateMetricId, name? })\` using the picked widget's \`metricId\`. The tool inherits the query, chart config, and datasource automatically.
 
-2. **Fresh spec** (SQL + chart config):
-   - ASK for: \`name\`, \`query\` (SQL), \`chartOptions\` (chart type + config), \`companyIntegrationId\` (datasource ID \u2014 use \`list_datasources\` if needed).
-   - Call \`add_widget({ embedId, clientId, name, query, chartOptions, companyIntegrationId, ... })\`.
-
-3. **AI generate** (NL prompt):
-   - ASK for a prompt describing the widget (e.g., "calls per day over last 30 days") and the \`integrationId\` / \`integrationName\` to query against.
-   - Call \`generate_widget({ clientId, dataAppName, integrationId, integrationName, userInputs: { prompt: "..." } })\`.
+2. **Describe the chart in plain English** (AI generate \u2014 use if no suitable template exists):
+   - ASK: "Describe the chart you want" (e.g., "calls per day over last 30 days").
+   - Call \`generate_widget({ embedId, clientId, userInputs: { prompt: "..." } })\` \u2014 data app and datasource auto-resolve from the embed's existing widgets. Do NOT ask the user for a datasource or data app.
+   - \`embedId\` is optional on \`generate_widget\` (the tool will fall back to the sole data app / sole datasource if absent), but pass it when you have one \u2014 resolution is more reliable.
    - Review the returned \`draft\` with the user. If they approve, call \`add_widget({ embedId, clientId, body: <draft + externalDashboardIds> })\` to persist.
    - If they want changes, re-run \`generate_widget\` with a refined prompt.
+   - If \`generate_widget\` reports "Multiple data apps" or "Could not auto-resolve a datasource", either pass \`embedId\` or ask the user which data app/chart to mirror \u2014 still avoid technical datasource IDs.
+
+**Advanced \u2014 write SQL directly** (technical users only; ONLY if the user explicitly asks to write SQL):
+- ASK for: \`name\`, \`query\` (SQL), \`chartOptions\`, \`companyIntegrationId\` (use \`list_datasources\`).
+- Call \`add_widget({ embedId, clientId, name, query, chartOptions, companyIntegrationId, ... })\`.
 
 Show the user the new widget's \`externalMetricId\` and \`metricId\` after each add.