@marimo-team/islands 0.23.16-dev51 → 0.23.16-dev53

package/src/core/network/__tests__/requests-lazy.test.ts

@@ -114,6 +114,21 @@ describe("createLazyRequests", () => {
     expect(mockInit).toHaveBeenCalledTimes(1);
   });
 
+  it("starts the kernel for datasource discovery", async () => {
+    mockDelegate.discoverDataSources = vi.fn().mockResolvedValue(null);
+    const lazyRequests = createLazyRequests(
+      mockDelegate,
+      mockGetRuntimeManager,
+    );
+
+    await lazyRequests.discoverDataSources({
+      requestId: requestId("discovery"),
+    });
+
+    expect(mockInit).toHaveBeenCalledOnce();
+    expect(mockDelegate.discoverDataSources).toHaveBeenCalledOnce();
+  });
+
   it("should only call init once across multiple requests", async () => {
     const lazyRequests = createLazyRequests(
       mockDelegate,

package/src/core/network/__tests__/requests-network.test.ts

@@ -130,6 +130,20 @@ describe("createNetworkRequests", () => {
       expect(mockClient.GET).toHaveBeenCalledWith("/api/export/availability");
     });
 
+    it("discoverDataSources should POST to the discovery endpoint", async () => {
+      const requests = createNetworkRequests();
+      const request = { requestId: "discovery-request" } as any;
+      await requests.discoverDataSources(request);
+
+      expect(mockClient.POST).toHaveBeenCalledWith(
+        "/api/datasources/discover",
+        expect.objectContaining({
+          body: request,
+          params: expect.anything(),
+        }),
+      );
+    });
+
     it("getPackageList should not require a kernel connection", async () => {
       const { waitForConnectionOpen, waitForConnectionOpenIfNotebook } =
         await import("../connection");

package/src/core/network/requests-lazy.ts

@@ -51,6 +51,7 @@ const ACTIONS: Record<keyof AllRequests, Action> = {
   sendRunScratchpad: "startConnection",
   saveAppConfig: "startConnection",
   saveCellConfig: "startConnection",
+  discoverDataSources: "startConnection",
 
   // Export operations start a connection
   exportAsHTML: "startConnection",

package/src/core/network/requests-network.ts

@@ -267,6 +267,14 @@ export function createNetworkRequests(): EditRequests & RunRequests {
         })
         .then(handleResponseReturnNull);
     },
+    discoverDataSources: (request) => {
+      return getClient()
+        .POST("/api/datasources/discover", {
+          body: request,
+          params: getParams(),
+        })
+        .then(handleResponseReturnNull);
+    },
     validateSQL: (request) => {
       return getClient()
         .POST("/api/sql/validate", {

package/src/core/network/requests-static.ts

@@ -62,6 +62,7 @@ export function createStaticRequests(): EditRequests & RunRequests {
     previewSQLTableList: throwNotInEditMode,
     previewSQLSchemaList: throwNotInEditMode,
     previewDataSourceConnection: throwNotInEditMode,
+    discoverDataSources: throwNotInEditMode,
     validateSQL: throwNotInEditMode,
     openFile: throwNotInEditMode,
     getUsageStats: throwNotInEditMode,

package/src/core/network/requests-toasting.tsx

@@ -43,6 +43,7 @@ export function createErrorToastingRequests(
     previewSQLTableList: "Failed to fetch SQL table list",
     previewSQLSchemaList: "Failed to fetch SQL schema list",
     previewDataSourceConnection: "Failed to preview data source connection",
+    discoverDataSources: "Failed to discover data sources",
     validateSQL: "Failed to validate SQL",
     openFile: "Failed to open file",
     getUsageStats: "", // No toast

package/src/core/network/types.ts

@@ -75,6 +75,7 @@ export type ListSQLTablesRequest = schemas["ListSQLTablesRequest"];
 export type ListSQLSchemasRequest = schemas["ListSQLSchemasRequest"];
 export type ListDataSourceConnectionRequest =
   schemas["ListDataSourceConnectionRequest"];
+export type DiscoverDataSourcesRequest = schemas["DiscoverDataSourcesRequest"];
 export type ValidateSQLRequest = schemas["ValidateSQLRequest"];
 export type DebugCellRequest = schemas["DebugCellRequest"];
 export type SetBreakpointsRequest = schemas["SetBreakpointsRequest"];
@@ -181,6 +182,7 @@ export interface EditRequests {
   previewDataSourceConnection: (
     request: ListDataSourceConnectionRequest,
   ) => Promise<null>;
+  discoverDataSources: (request: DiscoverDataSourcesRequest) => Promise<null>;
   validateSQL: (request: ValidateSQLRequest) => Promise<null>;
   openFile: (request: { path: string; lineNumber?: number }) => Promise<null>;
   getUsageStats: () => Promise<UsageResponse>;

package/src/core/wasm/bridge.ts

@@ -630,6 +630,16 @@ export class PyodideBridge implements RunRequests, EditRequests {
     return null;
   };
 
+  discoverDataSources: EditRequests["discoverDataSources"] = async (
+    request,
+  ) => {
+    await this.putControlRequest({
+      type: "discover-data-sources",
+      ...request,
+    });
+    return null;
+  };
+
   getUsageStats = throwNotImplemented;
   getEnvironmentInfo: EditRequests["getEnvironmentInfo"] = async () => {
     const response = await this.rpc.proxy.request.bridge({

package/src/core/websocket/useMarimoKernelConnection.tsx

@@ -42,6 +42,7 @@ import { connectionTransportTypeAtom, useSetAppConfig } from "../config/config";
 import { useDataSourceActions } from "../datasets/data-source-connections";
 import type { ConnectionName } from "../datasets/engines";
 import {
+  DiscoverDataSources,
   PreviewSQLSchemaList,
   PreviewSQLTable,
   PreviewSQLTableList,
@@ -394,6 +395,9 @@ export function useMarimoKernelConnection(opts: {
       case "validate-sql-result":
         ValidateSQL.resolve(msg.data.request_id as RequestId, msg.data);
         return;
+      case "data-source-discovery-result":
+        DiscoverDataSources.resolve(msg.data.request_id as RequestId, msg.data);
+        return;
       case "secret-keys-result":
         SECRETS_REGISTRY.resolve(msg.data.request_id, msg.data);
         return;

package/src/hooks/__tests__/useDataSourceDiscovery.test.ts

@@ -0,0 +1,80 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { DiscoverDataSources } from "@/core/datasets/request-registry";
+import { loadDataSourceDiscovery } from "../useDataSourceDiscovery";
+
+describe("loadDataSourceDiscovery", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("returns the kernel's secret-free discovery model", async () => {
+    const sources = [
+      {
+        id: "pyiceberg-prod",
+        integration: "pyiceberg",
+        category: "catalog" as const,
+        displayName: "PyIceberg (prod)",
+        confidence: "high" as const,
+        origins: [
+          {
+            type: "configuration" as const,
+            label: "Resolved PyIceberg configuration",
+          },
+        ],
+        configuration: [
+          {
+            field: "Catalog",
+            value: {
+              kind: "safe-literal" as const,
+              value: "prod",
+            },
+          },
+        ],
+        code: 'catalog = load_catalog("prod")',
+      },
+    ];
+    const request = vi.spyOn(DiscoverDataSources, "request").mockResolvedValue({
+      request_id: "request-id",
+      sources,
+    });
+
+    const detected = await loadDataSourceDiscovery();
+
+    expect({ detected, requests: request.mock.calls }).toMatchInlineSnapshot(`
+      {
+        "detected": [
+          {
+            "category": "catalog",
+            "code": "catalog = load_catalog("prod")",
+            "confidence": "high",
+            "configuration": [
+              {
+                "field": "Catalog",
+                "value": {
+                  "kind": "safe-literal",
+                  "value": "prod",
+                },
+              },
+            ],
+            "displayName": "PyIceberg (prod)",
+            "id": "pyiceberg-prod",
+            "integration": "pyiceberg",
+            "origins": [
+              {
+                "label": "Resolved PyIceberg configuration",
+                "type": "configuration",
+              },
+            ],
+          },
+        ],
+        "requests": [
+          [
+            {},
+          ],
+        ],
+      }
+    `);
+  });
+});

package/src/hooks/useDataSourceDiscovery.ts

@@ -0,0 +1,18 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import type { DetectedDataSource } from "@/core/datasets/data-source-discovery";
+import { DiscoverDataSources } from "@/core/datasets/request-registry";
+import { useAsyncData } from "./useAsyncData";
+
+export async function loadDataSourceDiscovery(): Promise<DetectedDataSource[]> {
+  const result = await DiscoverDataSources.request({});
+  return result.sources;
+}
+
+/**
+ * Reusable UI-facing hook for kernel-managed datasource discovery.
+ * Consumers decide how to render, filter, or act on the detected model.
+ */
+export function useDataSourceDiscovery() {
+  return useAsyncData(loadDataSourceDiscovery, []);
+}