@databrainhq/mcp-server 0.2.6 → 0.2.8

package/dist/index.js

@@ -1479,7 +1479,7 @@ function registerListDatasources(server, client) {
         return toolSuccess(JSON.stringify({
           count: active.length,
           datasources: active.map((ds) => ({
-            id: ds.id,
+            id: ds._id || ds.id || null,
             name: ds.name,
             type: ds.dbName || ds.datasourceType || "unknown"
           })),
@@ -4481,14 +4481,14 @@ 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 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.",
+    "AI-generate a widget draft from a natural-language prompt. Does NOT persist \u2014 returns a draft to review and pass to `add_widget`. Data app and datasource auto-resolve from `embedId` (preferred) or sole workspace defaults. On resolve failure, ask the user for the datasource by name and pass `integrationName`.",
     {
       clientId: z25.string().describe("Client/tenant identifier"),
       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. 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.")
+      integrationId: z25.string().optional().describe("Technical override \u2014 the datasource UUID. Most flows should leave this blank and rely on auto-resolution from `embedId`. If you must override, prefer `integrationName` (business-user friendly)."),
+      integrationName: z25.string().optional().describe('Datasource display name (e.g. "Snowflake", "demo datasource"). Use this when the user picks a datasource by name \u2014 the id is looked up automatically. Leave blank if `embedId` is provided (auto-resolved).')
     },
     READ_ONLY,
     async (params) => {
@@ -4545,6 +4545,9 @@ function registerGenerateWidget(server, client) {
     }
   );
 }
+function isActiveDatasource(ds) {
+  return Boolean(ds.isAuthenticated) && !ds.isDisabled;
+}
 async function resolveDataAppName(services, provided, embedId) {
   if (provided) return { ok: true, value: provided };
   if (embedId) {
@@ -4575,25 +4578,32 @@ async function resolveDatasource(services, guestToken, params) {
       }
     };
   }
+  if (params.integrationId || params.integrationName) {
+    return completeFromDatasources(services, {
+      integrationId: params.integrationId,
+      integrationName: params.integrationName
+    });
+  }
+  let embedProbe = null;
   if (params.embedId) {
-    const fromEmbed = await resolveDatasourceFromEmbed(
+    embedProbe = await probeDatasourceFromEmbed(
       services,
       guestToken,
       params.embedId,
       params.clientId
     );
-    if (fromEmbed) {
+    if (embedProbe.kind === "ok") {
       return {
         ok: true,
         value: {
-          integrationId: params.integrationId || fromEmbed.integrationId,
-          integrationName: params.integrationName || fromEmbed.integrationName
+          integrationId: params.integrationId || embedProbe.value.integrationId,
+          integrationName: params.integrationName || embedProbe.value.integrationName
         }
       };
     }
   }
   const datasources = await services.datasourcesApi.listDatasources();
-  const named = datasources.filter(
+  const named = datasources.filter(isActiveDatasource).filter(
     (ds) => typeof ds.name === "string" && ds.name.trim().length > 0
   );
   if (named.length === 1) {
@@ -4610,23 +4620,101 @@ async function resolveDatasource(services, guestToken, params) {
       error: "No datasources found in this workspace. Connect one in the Databrain UI first (technical setup)."
     };
   }
+  const nameList = named.map((d) => `"${d.name}"`).join(", ");
+  let embedReason = "";
+  if (params.embedId && embedProbe) {
+    if (embedProbe.kind === "no_widgets") {
+      embedReason = ` Embed "${params.embedId}" has no widgets for clientId "${params.clientId}" to inherit from, so the datasource can't be auto-detected.`;
+    } else if (embedProbe.kind === "no_metric_fields") {
+      embedReason = ` Checked ${embedProbe.widgetsTried} widget(s) on embed "${params.embedId}"` + (embedProbe.fetchErrors > 0 ? ` (${embedProbe.fetchErrors} could not be fetched)` : "") + `, but none had datasource metadata to inherit from.`;
+    }
+  }
   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.`
+    error: `Could not auto-resolve a datasource.${embedReason} Ask the user which datasource this widget should query \u2014 available options: ${nameList}. Then retry with \`integrationName: "<chosen name>"\` (no other fields needed). Technical callers can pass \`integrationId\` instead \u2014 see \`list_datasources\` for UUIDs.`
+  };
+}
+async function completeFromDatasources(services, provided) {
+  const allDatasources = await services.datasourcesApi.listDatasources();
+  const datasources = allDatasources.filter(isActiveDatasource);
+  const matchPredicate = (ds) => {
+    const id2 = ds._id || ds.id || "";
+    const name2 = typeof ds.name === "string" ? ds.name : "";
+    if (provided.integrationId && id2 === provided.integrationId) return true;
+    if (provided.integrationName && name2.toLowerCase() === provided.integrationName.toLowerCase()) {
+      return true;
+    }
+    return false;
   };
+  const target = datasources.find(matchPredicate);
+  if (!target) {
+    const available = datasources.filter((ds) => typeof ds.name === "string" && ds.name.trim().length > 0).map((ds) => `"${ds.name}"`).join(", ");
+    const inactiveMatch = allDatasources.find(
+      (ds) => !isActiveDatasource(ds) && matchPredicate(ds)
+    );
+    if (inactiveMatch) {
+      const reason = inactiveMatch.isDisabled ? "disabled" : "not authenticated";
+      return {
+        ok: false,
+        error: `Datasource "${inactiveMatch.name ?? provided.integrationName ?? provided.integrationId}" is ${reason}. Fix the connection in the Databrain UI, or pick another datasource. Active options: ${available || "(none)"}.`
+      };
+    }
+    const hint = provided.integrationId ? `No active datasource matches integrationId "${provided.integrationId}". Available datasources: ${available || "(none)"}.` : `No active datasource matches integrationName "${provided.integrationName}". Available datasources: ${available || "(none)"}. Match is case-insensitive \u2014 double-check the name with the user.`;
+    return { ok: false, error: hint };
+  }
+  const id = target._id || target.id || "";
+  const name = typeof target.name === "string" ? target.name : "";
+  if (!id || !name) {
+    return {
+      ok: false,
+      error: `Datasource match is missing id or name (id: "${id}", name: "${name}").`
+    };
+  }
+  return { ok: true, value: { integrationId: id, integrationName: name } };
 }
-async function resolveDatasourceFromEmbed(services, guestToken, embedId, clientId) {
+async function probeDatasourceFromEmbed(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 };
+  const candidates = widgets.filter(
+    (w) => typeof w.metricId === "string" && w.metricId.length > 0
+  );
+  if (candidates.length === 0) return { kind: "no_widgets" };
+  const MAX_PROBES = 5;
+  const toProbe = candidates.slice(0, MAX_PROBES);
+  let fetchErrors = 0;
+  let datasourcesCache = null;
+  for (const widget of toProbe) {
+    let response;
+    try {
+      response = await services.widgetsApi.fetchEmbeddedMetric(
+        guestToken,
+        widget.metricId
+      );
+    } catch {
+      fetchErrors += 1;
+      continue;
+    }
+    const metric = response?.externalMetric;
+    if (!metric || typeof metric !== "object") continue;
+    const rec = metric;
+    const integrationId = typeof rec.companyIntegrationId === "string" && rec.companyIntegrationId ? rec.companyIntegrationId : null;
+    let integrationName = typeof rec.integrationName === "string" && rec.integrationName ? rec.integrationName : null;
+    if (integrationId && !integrationName) {
+      if (!datasourcesCache) {
+        datasourcesCache = await services.datasourcesApi.listDatasources();
+      }
+      const match = datasourcesCache.find((ds) => {
+        const id = ds._id || ds.id || "";
+        return id === integrationId;
+      });
+      if (match && typeof match.name === "string" && match.name) {
+        integrationName = match.name;
+      }
+    }
+    if (integrationId && integrationName) {
+      return { kind: "ok", value: { integrationId, integrationName } };
+    }
+  }
+  return { kind: "no_metric_fields", widgetsTried: toProbe.length, fetchErrors };
 }
 
 // src/tools/registry.ts
@@ -7693,7 +7781,7 @@ This is a business-user flow. NEVER ask the user for a datasource, \`companyInte
    - \`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.
+   - If \`generate_widget\` reports "Multiple data apps", pass \`embedId\` or \`dataAppName\`. If it reports "Could not auto-resolve a datasource", ASK the user which datasource to use by NAME (the error lists available options) and retry with \`integrationName: "<name>"\`. Never ask the user for \`integrationId\` or any UUID \u2014 \`integrationName\` alone is enough.
 
 **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\`).