The easy-to-use open source Business Intelligence and Embedded Analytics tool that lets everyone work with data :bar_chart:
TypeScript analyticsbibusiness-intelligencebusinessintelligenceclojuredashboarddatadata-analysisdata-visualizationdatabasemetabasemysqlpostgrespostgresqlreportingslacksql-editorvisualization
Add AI provider step to onboarding flow (#78001)
Maksym Yakubychecf701f7f6dd
diff --git a/.clj-kondo/config/modules/config.edn b/.clj-kondo/config/modules/config.ednindex d5f5782f73b..8f6b5cb4da5 100644--- a/.clj-kondo/config/modules/config.edn+++ b/.clj-kondo/config/modules/config.edn@@ -1216,6 +1216,7 @@premium-featuresrequestsettings+ setupsql-toolssyncutildiff --git a/e2e/support/helpers/e2e-mock-llm-tasks.ts b/e2e/support/helpers/e2e-mock-llm-tasks.tsindex 5357ebd2019..83554cd13d4 100644--- a/e2e/support/helpers/e2e-mock-llm-tasks.ts+++ b/e2e/support/helpers/e2e-mock-llm-tasks.ts@@ -74,11 +74,18 @@ function buildAnthropicToolUseSSE({ name, input }: MockLlmToolCall): string {return lines.join("\n");}+const MOCK_MODEL_CATALOG = [+ { id: "claude-haiku-4-5", display_name: "Claude Haiku 4.5" },+ { id: "claude-sonnet-4-6", display_name: "Claude Sonnet 4.6" },+];+/**- * Start a mock server that impersonates the Anthropic Messages API.+ * Start a mock server that impersonates the Anthropic API.*- * Every POST to /v1/messages responds with a valid SSE stream containing- * either the given `responseText` or a tool-use call. The server listens on `port`.+ * GET /v1/models responds with a static model catalog (used by the provider+ * credential validation when connecting). Every other request responds with a+ * valid /v1/messages SSE stream containing either the given `responseText` or+ * a tool-use call. The server listens on `port`.** Call `stopMockLlmServer` to tear it down.*/@@ -97,7 +104,13 @@ export function startMockLlmServer(? buildAnthropicToolUseSSE(options.toolCall): buildAnthropicSSE(options.responseText);- server = http.createServer((_req, res) => {+ server = http.createServer((req, res) => {+ if (req.method === "GET" && req.url?.includes("/models")) {+ res.writeHead(200, { "content-type": "application/json" });+ res.end(JSON.stringify({ data: MOCK_MODEL_CATALOG }));+ return;+ }+res.writeHead(200, {"content-type": "text/event-stream","cache-control": "no-cache",diff --git a/e2e/test/scenarios/onboarding/setup/setup.cy.spec.ts b/e2e/test/scenarios/onboarding/setup/setup.cy.spec.tsindex 10e2143cbeb..4a608ef1341 100644--- a/e2e/test/scenarios/onboarding/setup/setup.cy.spec.ts+++ b/e2e/test/scenarios/onboarding/setup/setup.cy.spec.ts@@ -415,7 +415,7 @@ describe("scenarios > setup", () => {cy.button("Connect database").click();});- cy.findByRole("status").should("contain", `Connected to ${dbName}`);+ H.undoToastList().should("contain", `Connected to ${dbName}`);skipLicenseStepOnEE();@@ -537,6 +537,228 @@ describe("scenarios > setup", () => {});});+describe("scenarios > setup > AI config step", () => {+ const MOCK_LLM_PORT = 6123;++ beforeEach(() => {+ H.restore("blank");+ });++ afterEach(() => {+ cy.task("stopMockLlmServer");+ });++ const navigateToAiConfigStep = () => {+ navigateToDatabaseStep();+ cy.findByTestId("setup-forms")+ .findByText("Continue with sample data")+ .click();+ finishSetup();+ startAiConfigStep();+ };++ it("should offer BYOK providers without the managed option and allow skipping", () => {+ navigateToAiConfigStep();++ cy.findByLabelText("Connect to an AI provider")+ .findByLabelText("Provider")+ .click();++ H.popover().within(() => {+ cy.findByText("Anthropic").should("be.visible");+ cy.findByText("OpenAI").should("be.visible");+ cy.findByText("OpenRouter").should("be.visible");+ cy.findByText("Microsoft Azure").should("be.visible");+ cy.findByText("Amazon Bedrock").should("be.visible");+ cy.findByText("Metabase").should("not.exist");+ });+ H.popover().findByText("Anthropic").click();++ cy.findByLabelText("Connect to an AI provider").within(() => {+ cy.findByLabelText("API key").should("be.visible");+ cy.button("I'll set this up later").click();+ });++ cy.findByLabelText("I'll set up AI later").should("be.visible");+ cy.findByTestId("setup-forms").within(() => {+ cy.findByText("You're all set up!").should("be.visible");+ cy.button("Set up AI").should("not.exist");+ });+ });++ it("should connect an Anthropic API key during setup", () => {+ cy.task("startMockLlmServer", {+ port: MOCK_LLM_PORT,+ responseText: "Hello from mock LLM!",+ });+ cy.intercept("PUT", "/api/metabot/settings").as("connectProvider");++ navigateToAiConfigStep();++ // The wizard runs as the freshly created admin, so settings can be+ // updated mid-flow. Point the Anthropic client at the mock server that+ // answers the credential-validating /v1/models call.+ H.updateSetting(+ "llm-anthropic-api-base-url",+ `http://localhost:${MOCK_LLM_PORT}`,+ );++ cy.findByLabelText("Connect to an AI provider")+ .findByLabelText("Provider")+ .click();+ H.popover().findByText("Anthropic").click();++ cy.findByLabelText("Connect to an AI provider").within(() => {+ cy.findByLabelText("API key").type("sk-ant-api03-e2e-test-key");+ cy.button("Connect").click();+ cy.wait("@connectProvider");++ cy.findByLabelText("Model").should("be.visible");+ cy.button("Done").click();+ });++ cy.findByLabelText("Connected to Anthropic").should("be.visible");+ });++ it("should connect the Metabase managed provider during setup", () => {+ // The "Metabase" provider option is gated on token features read at page+ // bootstrap (plugin init), before any interceptable API call — so patch+ // the server-embedded payload as it is assigned. We can't use+ // `H.activateToken` here because the endpoint requires a user.. which+ // isn't created yet.+ // The store-backed calls (add-ons pricing, the managed connect itself)+ // have no real backing in e2e and are stubbed at the network layer.+ type BootstrapPayload = {+ "token-features"?: Record<string, boolean>;+ } & Record<string, unknown>;++ const enableManagedAiFeatures = (win: Cypress.AUTWindow) => {+ let bootstrap: BootstrapPayload | undefined;+ Object.defineProperty(win, "MetabaseBootstrap", {+ configurable: true,+ get: () => bootstrap,+ set: (value: BootstrapPayload) => {+ bootstrap = {+ ...value,+ "token-features": {+ ...value["token-features"],+ "metabase-ai-managed": true,+ "offer-metabase-ai-managed": true,+ },+ };+ },+ });+ };++ let isConnected = false;+ cy.intercept("GET", "/api/session/properties", (req) => {+ req.reply((res) => {+ res.body["token-features"] = {+ ...res.body["token-features"],+ "metabase-ai-managed": true,+ "offer-metabase-ai-managed": true,+ };+ if (isConnected) {+ res.body["llm-metabot-configured?"] = true;+ res.body["llm-metabot-provider"] =+ "metabase/anthropic/claude-sonnet-4-6";+ }+ });+ });+ cy.intercept("GET", "/api/ee/cloud-add-ons/addons", [+ {+ id: 1,+ active: true,+ self_service: true,+ deployment: "hosting",+ billing_period_months: 1,+ default_base_fee: 0,+ default_included_units: 0,+ default_prepaid_units: 1,+ free_units: 1_000_000,+ default_price_per_unit: 3.75 / 1_000_000,+ default_total_units: 1,+ description: null,+ is_metered: true,+ name: "Metabase AI Managed",+ product_tiers: [],+ product_type: "metabase-ai-managed",+ short_name: "Metabase AI Managed",+ token_features: [],+ trial_days: null,+ },+ ]);+ cy.intercept("GET", "/api/ee/metabot/usage", {+ is_locked: false,+ tokens: 0,+ free_tokens: 1000000,+ updated_at: null,+ });+ cy.intercept("POST", "/api/premium-features/token/refresh", {});+ cy.intercept("PUT", "/api/metabot/settings", (req) => {+ isConnected = true;+ req.reply({ value: "metabase/anthropic/claude-sonnet-4-6", models: [] });+ }).as("connectManaged");++ cy.visit(+ "/setup?first_name=John&last_name=Doe&[email protected]&site_name=Doe%20Unlimited",+ { onBeforeLoad: enableManagedAiFeatures },+ );++ skipWelcomePage();++ cy.findByTestId("setup-forms").within(() => {+ const password = "12341234";+ cy.findByLabelText("Create a password").type(password);+ cy.findByLabelText("Confirm your password").type(password);+ cy.button("Next").click();++ cy.findByLabelText("What will you use Metabase for?").should(+ "be.visible",+ );+ cy.button("Next").click();++ cy.findByText("Continue with sample data").click();++ // the patched token features make this a paid plan, so the license step+ // is skipped even on EE+ cy.findByText("Finish").click();+ });++ startAiConfigStep();++ cy.findByLabelText("Connect to an AI provider").within(() => {+ cy.findByLabelText("Provider").should("have.value", "Metabase");+ cy.findByText("About Metabase AI service").should("be.visible");+ cy.findByText(/You get 1M tokens for free/).should("be.visible");+ cy.button("Connect").click();+ });++ cy.wait("@connectManaged")+ .its("request.body")+ .should("deep.equal", { provider: "metabase", model: "" });+ cy.findByLabelText("Connected to Metabase").should("be.visible");+ });++ it("should not offer the step when AI features are disabled", () => {+ H.mockSessionProperty("ai-features-enabled?", false);++ navigateToDatabaseStep();+ cy.findByTestId("setup-forms")+ .findByText("Continue with sample data")+ .click();++ skipLicenseStepOnEE();+ cy.findByLabelText("Usage data preferences").should("be.visible");+ cy.findByTestId("setup-forms").within(() => {+ cy.findByText("Finish").click();++ cy.findByText("You're all set up!").should("be.visible");+ cy.button("Set up AI").should("not.exist");+ });+ });+});+describe("scenarios > setup (EE)", () => {beforeEach(() => H.restore("blank"));@@ -665,6 +887,26 @@ describe("scenarios > setup", () => {step: "completed",});+ cy.button("Set up AI").click();++ H.expectUnstructuredSnowplowEvent({+ event: "ai_setup_started",+ triggered_from: "setup",+ });++ H.expectUnstructuredSnowplowEvent({+ event: "step_seen",+ step_number: IS_ENTERPRISE ? 6 : 5,+ step: "ai_config",+ });++ cy.button("I'll set this up later").click();++ H.expectUnstructuredSnowplowEvent({+ event: "ai_setup_later_clicked",+ triggered_from: "setup",+ });+cy.findByLabelText("Get infrequent emails about new releases and feature updates.",).click();@@ -747,6 +989,17 @@ const skipLicenseStepOnEE = () => {}};+const finishSetup = () => {+ skipLicenseStepOnEE();+ cy.findByText("Finish").click();+};++const startAiConfigStep = () => {+ cy.findByText("You're all set up!").should("be.visible");+ cy.button("Set up AI").click();+ cy.findByLabelText("Connect to an AI provider").should("be.visible");+};+const typeToken = (token: string) => {// hides the requests from the logs as the token is passed as a GET paramcy.intercept({ resourceType: "xhr" }, { log: false });diff --git a/frontend/src/metabase-types/analytics/event.ts b/frontend/src/metabase-types/analytics/event.tsindex a4dbfb65cd4..270276ae1df 100644--- a/frontend/src/metabase-types/analytics/event.ts+++ b/frontend/src/metabase-types/analytics/event.ts@@ -47,6 +47,22 @@ export type CustomVizEvent =| CustomVizPluginRefreshedEvent| CustomVizSelectedEvent;+export type AiSetupStartedEvent = ValidateEvent<{+ event: "ai_setup_started";+ triggered_from: "setup";+}>;++export type AiProviderConnectedEvent = ValidateEvent<{+ event: "ai_provider_connected";+ triggered_from: "setup";+ event_detail: string | null;+}>;++export type AiSetupLaterClickedEvent = ValidateEvent<{+ event: "ai_setup_later_clicked";+ triggered_from: "setup";+}>;+export type UserInvitedEvent = ValidateEvent<{event: "user_invited";triggered_from: "admin" | "setup" | "dashboard" | "question";diff --git a/frontend/src/metabase-types/analytics/setup.ts b/frontend/src/metabase-types/analytics/setup.tsindex e4d58b0af98..a0532fb6191 100644--- a/frontend/src/metabase-types/analytics/setup.ts+++ b/frontend/src/metabase-types/analytics/setup.ts@@ -14,7 +14,7 @@ type ValidateEvent<Record<Exclude<keyof T, keyof SetupEventSchema>, never>,> = T;-export type SetupVersion = "1.4.0";+export type SetupVersion = "1.5.0";export type StepSeenEvent = ValidateEvent<{event: "step_seen";@@ -24,6 +24,7 @@ export type StepSeenEvent = ValidateEvent<{| "language"| "user_info"| "db_connection"+ | "ai_config"| "usage_question"| "license_token"| "db_scheduling"diff --git a/frontend/src/metabase/analytics/event.ts b/frontend/src/metabase/analytics/event.tsindex 88baa6ca91a..02958d7e674 100644--- a/frontend/src/metabase/analytics/event.ts+++ b/frontend/src/metabase/analytics/event.ts@@ -28,7 +28,7 @@ const VERSIONS: Record<SchemaType, SchemaVersion> = {search: "1-1-4",serialization: "1-0-1",settings: "1-0-2",- setup: "1-0-3",+ setup: "1-0-4",timeline: "1-0-0",upsell: "1-0-0",};diff --git a/frontend/src/metabase/metabot/components/AIProviderConfigurationForm/AIProviderConfigurationForm.tsx b/frontend/src/metabase/metabot/components/AIProviderConfigurationForm/AIProviderConfigurationForm.tsxindex 4072168fe5e..b4f8bbc8671 100644--- a/frontend/src/metabase/metabot/components/AIProviderConfigurationForm/AIProviderConfigurationForm.tsx+++ b/frontend/src/metabase/metabot/components/AIProviderConfigurationForm/AIProviderConfigurationForm.tsx@@ -15,7 +15,18 @@ import { ConfirmModal } from "metabase/common/components/ConfirmModal";import { SetByEnvVar } from "metabase/common/components/SetByEnvVar";import { useSetting, useToast } from "metabase/common/hooks";import { PLUGIN_METABOT } from "metabase/plugins";-import { Button, Flex, Group, Select, Stack, Text } from "metabase/ui";+import {+ Box,+ Button,+ Center,+ Divider,+ Flex,+ Group,+ Loader,+ Select,+ Stack,+ Text,+} from "metabase/ui";import type { MetabotProvider } from "metabase-types/api";import { AIProviderConfigurationContext } from "./AIProviderConfigurationContext";@@ -29,13 +40,38 @@ import {parseProviderAndModel,} from "./utils";-export function AIProviderConfigurationForm({+interface AIProviderConfigurationFormProps {+ isModal?: boolean;+ defaultProvider?: MetabotProvider;+ onClose?: (connectedProvider?: MetabotProvider) => void;+ onSkip?: VoidFunction;+}++export function AIProviderConfigurationForm(+ props: AIProviderConfigurationFormProps,+) {+ const { isLoading } = useAdminSetting("llm-metabot-provider");++ // The saved provider loads asynchronously, and the form body computes its+ // initial selection once at mount. Mounting before the value arrives would+ // let `defaultProvider` win over an existing connection.+ if (props.defaultProvider && isLoading) {+ return (+ <Center p="lg">+ <Loader data-testid="loading-indicator" />+ </Center>+ );+ }++ return <AIProviderConfigurationFormBody {...props} />;+}++function AIProviderConfigurationFormBody({isModal = false,+ defaultProvider,onClose,-}: {- isModal?: boolean;- onClose?: VoidFunction;-}) {+ onSkip,+}: AIProviderConfigurationFormProps) {const MetabaseAIProviderSetup = PLUGIN_METABOT.MetabaseAIProviderSetup;const offerMetabaseAiManaged = PLUGIN_METABOT.isEnabled;const [sendToast] = useToast();@@ -57,9 +93,16 @@ export function AIProviderConfigurationForm({);const connectedProvider = isConfigured ? config?.provider : undefined;const connectedModel = isConfigured ? config?.model : undefined;- const [provider, setProvider] = useState<MetabotProvider | undefined>(- isModal ? undefined : connectedProvider,- );+ // `defaultProvider` is only a suggestion for the unconfigured state — an+ // existing connection always wins over it. A modal without a suggestion+ // starts unselected on purpose, even when connected (the "switch provider"+ // flow).+ const [provider, setProvider] = useState<MetabotProvider | undefined>(() => {+ if (!isModal) {+ return connectedProvider;+ }+ return defaultProvider ? (connectedProvider ?? defaultProvider) : undefined;+ });const isCurrentConfigured = connectedProvider === provider && isConfigured;@@ -260,7 +303,9 @@ export function AIProviderConfigurationForm({? null: match(provider).with("metabase", () => (- <MetabaseAIProviderSetup onConnect={onClose} />+ <MetabaseAIProviderSetup+ onConnect={() => onClose?.("metabase")}+ />)).with("azure", () => (<AzureProviderFields@@ -290,14 +335,14 @@ export function AIProviderConfigurationForm({{envSettingName && <SetByEnvVar varName={envSettingName} />}- <Flex justify="end">+ <Flex justify={onSkip ? "flex-start" : "end"}>{match({ isCurrentConfigured, isConnectButtonEnabled, isModal }).with({ isModal: true, isCurrentConfigured: true }, () => (<Buttonvariant="filled"loading={isMutating}disabled={isMutating}- onClick={onClose}+ onClick={() => onClose?.(provider)}>{t`Done`}</Button>@@ -331,6 +376,24 @@ export function AIProviderConfigurationForm({).exhaustive()}</Flex>++ {onSkip && !isCurrentConfigured && (+ <>+ <Divider mx={{ base: "-2rem", sm: "-4rem" }} mt="xl" mb="md" />+ <Box>+ <Button+ onClick={onSkip}+ variant="subtle"+ px={0}+ fw="normal"+ disabled={isMutating}+ >{t`I'll set this up later`}</Button>+ <Text c="text-disabled" size="sm">+ {t`You won't be able to use AI features until you connect a provider.`}+ </Text>+ </Box>+ </>+ )}<ConfirmModalopened={isDisconnectConfirmOpen}onClose={() => setIsDisconnectConfirmOpen(false)}diff --git a/frontend/src/metabase/redux/store/mocks/setup.ts b/frontend/src/metabase/redux/store/mocks/setup.tsindex 5b457b7eb59..8cd813a6b47 100644--- a/frontend/src/metabase/redux/store/mocks/setup.ts+++ b/frontend/src/metabase/redux/store/mocks/setup.ts@@ -45,5 +45,6 @@ export const createMockSetupState = (isEmbeddingUseCase: false,isLocaleLoaded: false,isTrackingAllowed: true,+ isAiConfigRequested: false,...opts,});diff --git a/frontend/src/metabase/redux/store/setup.ts b/frontend/src/metabase/redux/store/setup.tsindex afa114884a1..56d73abc80d 100644--- a/frontend/src/metabase/redux/store/setup.ts+++ b/frontend/src/metabase/redux/store/setup.ts@@ -6,6 +6,7 @@ export type SetupStep =| "user_info"| "usage_question"| "db_connection"+ | "ai_config"| "license_token"| "data_usage"| "completed";@@ -45,5 +46,6 @@ export interface SetupState {isEmbeddingUseCase: boolean;isLocaleLoaded: boolean;isTrackingAllowed: boolean;+ isAiConfigRequested: boolean;licenseToken?: string | null;}diff --git a/frontend/src/metabase/setup/actions.ts b/frontend/src/metabase/setup/actions.tsindex dad1b82cd64..13cbd213b02 100644--- a/frontend/src/metabase/setup/actions.ts+++ b/frontend/src/metabase/setup/actions.ts@@ -19,6 +19,7 @@ import type {State,UserInfo,} from "metabase/redux/store";+import { refreshCurrentUser } from "metabase/redux/user";import { createAsyncThunk } from "metabase/redux/utils";import { getSetting } from "metabase/selectors/settings";import MetabaseSettings from "metabase/utils/settings";@@ -26,6 +27,9 @@ import type { DatabaseData, Settings, UsageReason } from "metabase-types/api";import {trackAddDataLaterClicked,+ trackAiProviderConnected,+ trackAiSetupLaterClicked,+ trackAiSetupStarted,trackDatabaseSelected,trackLicenseTokenStepSubmitted,trackTrackingChanged,@@ -117,6 +121,8 @@ export const submitUser = createAsyncThunk<void, UserInfo, ThunkConfig>(dispatch(goToNextStep());// load the settings after the user is logged, needed later by setEmbeddingHomepageFlagsdispatch(refetchSiteSettings());+ // the AI config step needs to know the created user is an admin+ dispatch(refreshCurrentUser());},);@@ -197,6 +203,33 @@ export const submitUserInvite = createAsyncThunk(},);+export const START_AI_CONFIG = "metabase/setup/START_AI_CONFIG";+export const startAiConfig = createAsyncThunk(+ START_AI_CONFIG,+ (_: void, { dispatch }) => {+ trackAiSetupStarted();+ dispatch(selectStep("ai_config"));+ },+);++export const SUBMIT_AI_CONFIG = "metabase/setup/SUBMIT_AI_CONFIG";+export const submitAiConfig = createAsyncThunk(+ SUBMIT_AI_CONFIG,+ (provider: string | undefined, { dispatch }) => {+ trackAiProviderConnected(provider);+ dispatch(selectStep("completed"));+ },+);++export const SKIP_AI_CONFIG = "metabase/setup/SKIP_AI_CONFIG";+export const skipAiConfig = createAsyncThunk(+ SKIP_AI_CONFIG,+ (_: void, { dispatch }) => {+ trackAiSetupLaterClicked();+ dispatch(selectStep("completed"));+ },+);+export const submitLicenseToken = createAsyncThunk("metabase/setup/SUBMIT_LICENSE_TOKEN",async (licenseToken: string | null, { dispatch, rejectWithValue }) => {diff --git a/frontend/src/metabase/setup/analytics.ts b/frontend/src/metabase/setup/analytics.tsindex 4a1d8eb5eda..833c9412b52 100644--- a/frontend/src/metabase/setup/analytics.ts+++ b/frontend/src/metabase/setup/analytics.ts@@ -1,4 +1,4 @@-import { trackSchemaEvent } from "metabase/analytics";+import { trackSchemaEvent, trackSimpleEvent } from "metabase/analytics";import type { SetupStep } from "metabase/redux/store";import type { SetupVersion } from "metabase-types/analytics/setup";import type { UsageReason } from "metabase-types/api";@@ -9,7 +9,7 @@ import type { UsageReason } from "metabase-types/api";* entry to the corresponding Notion doc:* {@link https://www.notion.so/metabase/Set-up-step-seen-19f39925938d401da2111f8a3d0dc36c}.*/-const ONBOARDING_VERSION: SetupVersion = "1.4.0";+const ONBOARDING_VERSION: SetupVersion = "1.5.0";export const trackStepSeen = ({stepName,@@ -58,6 +58,28 @@ export const trackAddDataLaterClicked = (engine?: string) => {});};+export const trackAiSetupStarted = () => {+ trackSimpleEvent({+ event: "ai_setup_started",+ triggered_from: "setup",+ });+};++export const trackAiProviderConnected = (provider?: string) => {+ trackSimpleEvent({+ event: "ai_provider_connected",+ event_detail: provider ?? null,+ triggered_from: "setup",+ });+};++export const trackAiSetupLaterClicked = () => {+ trackSimpleEvent({+ event: "ai_setup_later_clicked",+ triggered_from: "setup",+ });+};+export const trackTrackingChanged = (isTrackingAllowed: boolean) => {trackSchemaEvent("settings", {event: isTrackingAlloweddiff --git a/frontend/src/metabase/setup/components/AIConfigStep/AIConfigStep.tsx b/frontend/src/metabase/setup/components/AIConfigStep/AIConfigStep.tsxnew file mode 100644index 00000000000..f2a293a3aa3--- /dev/null+++ b/frontend/src/metabase/setup/components/AIConfigStep/AIConfigStep.tsx@@ -0,0 +1,85 @@+import { P, match } from "ts-pattern";+import { t } from "ttag";++import { useSetting } from "metabase/common/hooks";+import {+ AIProviderConfigurationForm,+ getProviderOptions,+ parseProviderAndModel,+} from "metabase/metabot";+import { PLUGIN_METABOT } from "metabase/plugins";+import { useDispatch } from "metabase/redux";+import { Text } from "metabase/ui";+import type { MetabotProvider } from "metabase-types/api";++import { skipAiConfig, submitAiConfig } from "../../actions";+import { useStep } from "../../useStep";+import { ActiveStep } from "../ActiveStep";+import { InactiveStep } from "../InactiveStep";+import type { NumberedStepProps } from "../types";++export const AIConfigStep = ({ stepLabel }: NumberedStepProps) => {+ const { isStepActive, isStepCompleted } = useStep("ai_config");+ const dispatch = useDispatch();+ const offerMetabaseAiManaged = PLUGIN_METABOT.isEnabled;++ const isConfigured = !!useSetting("llm-metabot-configured?");+ const savedProviderValue = useSetting("llm-metabot-provider");+ const connectedProvider = isConfigured+ ? parseProviderAndModel(savedProviderValue)?.provider+ : undefined;++ const handleSubmit = (provider?: MetabotProvider) => {+ dispatch(submitAiConfig(provider ?? connectedProvider));+ };++ const handleSkip = () => {+ dispatch(skipAiConfig());+ };++ if (!isStepActive) {+ return (+ <InactiveStep+ title={getStepTitle({+ connectedProvider,+ isStepCompleted,+ offerMetabaseAiManaged,+ })}+ label={stepLabel}+ isStepCompleted={isStepCompleted}+ />+ );+ }++ return (+ <ActiveStep title={t`Connect to an AI provider`} label={stepLabel}>+ <Text mb="lg" c="text-secondary">+ {t`Select your AI provider to use AI explorations, SQL generation and Metabot.`}+ </Text>+ <AIProviderConfigurationForm+ isModal+ defaultProvider={offerMetabaseAiManaged ? "metabase" : undefined}+ onClose={handleSubmit}+ onSkip={handleSkip}+ />+ </ActiveStep>+ );+};++const getStepTitle = ({+ connectedProvider,+ isStepCompleted,+ offerMetabaseAiManaged,+}: {+ connectedProvider: MetabotProvider | undefined;+ isStepCompleted: boolean;+ offerMetabaseAiManaged: boolean;+}): string =>+ match({ isStepCompleted, connectedProvider })+ .with({ isStepCompleted: false }, () => t`Connect to an AI provider`)+ .with({ connectedProvider: P.nonNullable }, ({ connectedProvider }) => {+ return t`Connected to ${+ getProviderOptions(offerMetabaseAiManaged)[connectedProvider]?.label+ }`;+ })+ .otherwise(() => t`I'll set up AI later`);diff --git a/frontend/src/metabase/setup/components/AIConfigStep/AIConfigStep.unit.spec.tsx b/frontend/src/metabase/setup/components/AIConfigStep/AIConfigStep.unit.spec.tsxnew file mode 100644index 00000000000..bcf6a9ca10a--- /dev/null+++ b/frontend/src/metabase/setup/components/AIConfigStep/AIConfigStep.unit.spec.tsx@@ -0,0 +1,298 @@+import userEvent from "@testing-library/user-event";+import fetchMock from "fetch-mock";++import { setupEnterpriseOnlyPlugin } from "__support__/enterprise";+import {+ setupMetabaseManagedAiEndpoints,+ setupMetabotSettingsEndpoint,+ setupPropertiesEndpoints,+} from "__support__/server-mocks";+import { mockSettings } from "__support__/settings";+import { renderWithProviders, screen } from "__support__/ui";+import { reinitialize } from "metabase/plugins";+import type { SetupStep } from "metabase/redux/store";+import {+ createMockSetupState,+ createMockState,+} from "metabase/redux/store/mocks";+import type {+ EnterpriseSettings,+ SettingDefinition,+ TokenFeatures,+} from "metabase-types/api";+import {+ createMockSettingDefinition,+ createMockSettings,+ createMockTokenFeatures,+ createMockUser,+} from "metabase-types/api/mocks";++import { AIConfigStep } from "./AIConfigStep";++interface SetupOpts {+ step?: SetupStep;+ settings?: Partial<EnterpriseSettings>;+ tokenFeatures?: Partial<TokenFeatures>;+ hasMetabotPlugin?: boolean;+ settingOverrides?: SettingDefinition[];+}++const setup = ({+ step = "ai_config",+ settings = {},+ tokenFeatures = {},+ hasMetabotPlugin = false,+ settingOverrides = [],+}: SetupOpts = {}) => {+ const state = createMockState({+ currentUser: createMockUser({ is_superuser: true }),+ setup: createMockSetupState({ step, isAiConfigRequested: true }),+ settings: mockSettings({+ ...settings,+ "token-features": createMockTokenFeatures(tokenFeatures),+ }),+ });++ if (hasMetabotPlugin) {+ setupEnterpriseOnlyPlugin("metabot");+ }++ // Served through closures so tests can mutate them to simulate the backend+ // state changing after a connect.+ const sessionProperties = createMockSettings({+ ...settings,+ "token-features": createMockTokenFeatures(tokenFeatures),+ });+ const settingDefinitions = [...settingOverrides];++ fetchMock.get("path:/api/setting", () => settingDefinitions);+ setupPropertiesEndpoints(sessionProperties);++ renderWithProviders(<AIConfigStep stepLabel={5} />, {+ storeInitialState: state,+ });++ return { sessionProperties, settingDefinitions };+};++const ANTHROPIC_MODELS = [+ { id: "claude-haiku-4-5", display_name: "Claude Haiku 4.5" },+ { id: "claude-sonnet-4-6", display_name: "Claude Sonnet 4.6" },+];++const connectAnthropic = async ({+ sessionProperties,+ settingDefinitions,+}: ReturnType<typeof setup>) => {+ setupMetabotSettingsEndpoint({+ provider: "anthropic",+ response: { value: "anthropic/claude-haiku-4-5", models: ANTHROPIC_MODELS },+ });+ fetchMock.put("path:/api/metabot/settings", () => {+ sessionProperties["llm-metabot-provider"] = "anthropic/claude-haiku-4-5";+ sessionProperties["llm-metabot-configured?"] = true;+ settingDefinitions.push(+ createMockSettingDefinition({+ key: "llm-anthropic-api-key",+ value: "**********ey",+ }),+ );+ return { value: "anthropic/claude-haiku-4-5", models: ANTHROPIC_MODELS };+ });++ await userEvent.click(screen.getByLabelText("Provider"));+ await userEvent.click(+ await screen.findByRole("option", { name: "Anthropic" }),+ );+ await userEvent.type(+ screen.getByLabelText("API key"),+ "sk-ant-api03-unit-test-key",+ );+ await userEvent.click(screen.getByRole("button", { name: "Connect" }));+};++describe("AIConfigStep", () => {+ afterEach(() => {+ reinitialize();+ });++ it("should render in inactive state", () => {+ setup({ step: "db_connection" });++ expect(screen.getByText("Connect to an AI provider")).toBeInTheDocument();+ expect(screen.queryByLabelText("Provider")).not.toBeInTheDocument();+ });++ it("should not offer the managed provider without access to it", async () => {+ setup();++ await userEvent.click(screen.getByLabelText("Provider"));++ expect(+ await screen.findByRole("option", { name: "Anthropic" }),+ ).toBeInTheDocument();+ expect(screen.getByRole("option", { name: /OpenAI/ })).toBeInTheDocument();+ expect(+ screen.queryByRole("option", { name: "Metabase" }),+ ).not.toBeInTheDocument();+ });++ it("should not preselect a provider without access to the managed provider", () => {+ setup();++ expect(screen.getByLabelText("Provider")).toHaveValue("");+ });++ it("should suggest the managed provider when the instance has access to it", async () => {+ setupMetabaseManagedAiEndpoints();+ setup({+ tokenFeatures: { "offer-metabase-ai-managed": true },+ hasMetabotPlugin: true,+ });++ expect(await screen.findByLabelText("Provider")).toHaveValue("Metabase");+ expect(+ await screen.findByText("About Metabase AI service"),+ ).toBeInTheDocument();+ expect(+ await screen.findByRole("checkbox", {+ name: /I agree with the Metabase AI Service/i,+ }),+ ).toBeInTheDocument();+ });++ it("should show the existing connection instead of the managed suggestion when already connected", async () => {+ setupMetabaseManagedAiEndpoints();+ setupMetabotSettingsEndpoint({+ provider: "anthropic",+ response: { value: "anthropic/claude-haiku-4-5", models: [] },+ });+ setup({+ tokenFeatures: { "offer-metabase-ai-managed": true },+ hasMetabotPlugin: true,+ settings: {+ "llm-metabot-configured?": true,+ "llm-metabot-provider": "anthropic/claude-haiku-4-5",+ },+ settingOverrides: [+ createMockSettingDefinition({+ key: "llm-metabot-provider",+ value: "anthropic/claude-haiku-4-5",+ }),+ createMockSettingDefinition({+ key: "llm-anthropic-api-key",+ value: "**********45",+ }),+ ],+ });++ expect(+ await screen.findByRole("button", { name: "Done" }),+ ).toBeInTheDocument();+ expect(+ screen.queryByText("About Metabase AI service"),+ ).not.toBeInTheDocument();+ expect(screen.queryByLabelText("Provider")).not.toBeInTheDocument();+ expect(+ screen.queryByRole("button", { name: "I'll set this up later" }),+ ).not.toBeInTheDocument();+ });++ it("should advance to the next step when skipping", async () => {+ setup();++ await userEvent.click(+ screen.getByRole("button", { name: "I'll set this up later" }),+ );++ expect(await screen.findByText("I'll set up AI later")).toBeInTheDocument();+ expect(screen.queryByLabelText("Provider")).not.toBeInTheDocument();+ });++ it("should show the model picker after connecting a provider", async () => {+ const mocks = setup();++ await connectAnthropic(mocks);++ expect(await screen.findByLabelText("Model")).toBeInTheDocument();+ expect(+ await screen.findByRole("button", { name: "Done" }),+ ).toBeInTheDocument();+ expect(+ screen.queryByRole("button", { name: "I'll set this up later" }),+ ).not.toBeInTheDocument();+ });++ it("should advance to the next step after confirming the connection", async () => {+ const mocks = setup();++ await connectAnthropic(mocks);+ await userEvent.click(await screen.findByRole("button", { name: "Done" }));++ expect(+ await screen.findByText("Connected to Anthropic"),+ ).toBeInTheDocument();+ expect(screen.queryByLabelText("Provider")).not.toBeInTheDocument();+ expect(screen.queryByLabelText("Model")).not.toBeInTheDocument();+ });++ it("should connect the managed provider and advance to the next step", async () => {+ setupMetabaseManagedAiEndpoints();+ fetchMock.post("path:/api/premium-features/token/refresh", 200);++ const { sessionProperties } = setup({+ tokenFeatures: {+ "offer-metabase-ai-managed": true,+ "metabase-ai-managed": true,+ },+ hasMetabotPlugin: true,+ });++ fetchMock.put("path:/api/metabot/settings", () => {+ sessionProperties["llm-metabot-provider"] =+ "metabase/anthropic/claude-sonnet-4-6";+ sessionProperties["llm-metabot-configured?"] = true;+ return { value: "metabase/anthropic/claude-sonnet-4-6", models: [] };+ });++ expect(+ await screen.findByText("About Metabase AI service"),+ ).toBeInTheDocument();+ expect(+ screen.queryByRole("checkbox", {+ name: /I agree with the Metabase AI Service/i,+ }),+ ).not.toBeInTheDocument();++ await userEvent.click(screen.getByRole("button", { name: "Connect" }));++ expect(+ await screen.findByText("Connected to Metabase"),+ ).toBeInTheDocument();+ expect(screen.queryByLabelText("Provider")).not.toBeInTheDocument();+ expect(+ fetchMock.callHistory.called("path:/api/metabot/settings", {+ method: "PUT",+ body: { provider: "metabase", model: "" },+ }),+ ).toBe(true);+ });++ it("should show the connected provider when completed after connecting", () => {+ setup({+ step: "completed",+ settings: {+ "llm-metabot-configured?": true,+ "llm-metabot-provider": "anthropic/claude-haiku-4-5",+ },+ });++ expect(screen.getByText("Connected to Anthropic")).toBeInTheDocument();+ });++ it("should show the skipped title when completed without connecting", () => {+ setup({ step: "completed" });++ expect(screen.getByText("I'll set up AI later")).toBeInTheDocument();+ });+});diff --git a/frontend/src/metabase/setup/components/AIConfigStep/index.ts b/frontend/src/metabase/setup/components/AIConfigStep/index.tsnew file mode 100644index 00000000000..833f271f2ec--- /dev/null+++ b/frontend/src/metabase/setup/components/AIConfigStep/index.ts@@ -0,0 +1 @@+export { AIConfigStep } from "./AIConfigStep";diff --git a/frontend/src/metabase/setup/components/CompletedStep/CompletedStep.tsx b/frontend/src/metabase/setup/components/CompletedStep/CompletedStep.tsxindex b3e120085cc..100530f8c37 100644--- a/frontend/src/metabase/setup/components/CompletedStep/CompletedStep.tsx+++ b/frontend/src/metabase/setup/components/CompletedStep/CompletedStep.tsx@@ -3,11 +3,16 @@ import { type ChangeEvent, useState } from "react";import { t } from "ttag";import ButtonsS from "metabase/css/components/buttons.module.css";-import { useSelector } from "metabase/redux";+import { useDispatch, useSelector } from "metabase/redux";import { subscribeToNewsletter } from "metabase/setup/utils";-import { Switch, Title } from "metabase/ui";+import { Box, Button, Flex, Switch, Text, Title } from "metabase/ui";-import { getIsStepActive, getUserEmail } from "../../selectors";+import { startAiConfig } from "../../actions";+import {+ getIsStepActive,+ getShouldOfferAiConfig,+ getUserEmail,+} from "../../selectors";import { StepBody, StepFooter, StepRoot } from "./CompletedStep.styled";import { trackNewsletterToggleClicked } from "./analytics";@@ -15,6 +20,8 @@ import { trackNewsletterToggleClicked } from "./analytics";export const CompletedStep = (): JSX.Element | null => {const [checkboxValue, setCheckboxValue] = useState(false);const email = useSelector(getUserEmail);+ const shouldOfferAiConfig = useSelector(getShouldOfferAiConfig);+ const dispatch = useDispatch();const isStepActive = useSelector((state) =>getIsStepActive(state, "completed"),@@ -39,6 +46,22 @@ export const CompletedStep = (): JSX.Element | null => {return (<StepRoot><Title order={2}>{t`You're all set up!`}</Title>+ {shouldOfferAiConfig && (+ <StepBody>+ <Flex align="center" justify="space-between" gap="lg">+ <Box>+ <Text fw="bold">{t`Want to use AI in Metabase?`}</Text>+ <Text c="text-secondary">+ {t`Connect an AI provider to use AI explorations, SQL generation and Metabot.`}+ </Text>+ </Box>+ <Button+ flex="0 0 auto"+ onClick={() => dispatch(startAiConfig())}+ >{t`Set up AI`}</Button>+ </Flex>+ </StepBody>+ )}<StepBody><Switchchecked={checkboxValue}diff --git a/frontend/src/metabase/setup/components/CompletedStep/CompletedStep.unit.spec.tsx b/frontend/src/metabase/setup/components/CompletedStep/CompletedStep.unit.spec.tsxindex 302432db5ea..456d22de375 100644--- a/frontend/src/metabase/setup/components/CompletedStep/CompletedStep.unit.spec.tsx+++ b/frontend/src/metabase/setup/components/CompletedStep/CompletedStep.unit.spec.tsx@@ -1,21 +1,32 @@+import { mockSettings } from "__support__/settings";import { renderWithProviders, screen } from "__support__/ui";-import type { SetupStep } from "metabase/redux/store";+import type { SetupState, SetupStep } from "metabase/redux/store";import {createMockSetupState,createMockState,} from "metabase/redux/store/mocks";+import type { EnterpriseSettings } from "metabase-types/api";+import { createMockSettings } from "metabase-types/api/mocks";import { CompletedStep } from "./CompletedStep";interface SetupOpts {step?: SetupStep;+ setupState?: Partial<SetupState>;+ settings?: Partial<EnterpriseSettings>;}-const setup = ({ step = "completed" }: SetupOpts = {}) => {+const setup = ({+ step = "completed",+ setupState = {},+ settings = {},+}: SetupOpts = {}) => {const state = createMockState({setup: createMockSetupState({step,+ ...setupState,}),+ settings: mockSettings(createMockSettings(settings)),});renderWithProviders(<CompletedStep />, { storeInitialState: state });@@ -38,4 +49,27 @@ describe("CompletedStep", () => {).toBeInTheDocument();expect(screen.getByText("Take me to Metabase")).toBeInTheDocument();});++ it("should offer to set up AI", () => {+ setup();++ expect(screen.getByText("Want to use AI in Metabase?")).toBeInTheDocument();+ expect(screen.getByRole("button", { name: "Set up AI" })).toBeEnabled();+ });++ it("should not offer to set up AI once it has been requested", () => {+ setup({ setupState: { isAiConfigRequested: true } });++ expect(+ screen.queryByRole("button", { name: "Set up AI" }),+ ).not.toBeInTheDocument();+ });++ it("should not offer to set up AI when AI features are disabled", () => {+ setup({ settings: { "ai-features-enabled?": false } });++ expect(+ screen.queryByRole("button", { name: "Set up AI" }),+ ).not.toBeInTheDocument();+ });});diff --git a/frontend/src/metabase/setup/components/SettingsPage/SettingsPage.tsx b/frontend/src/metabase/setup/components/SettingsPage/SettingsPage.tsxindex f436bfd4f82..44611575a5b 100644--- a/frontend/src/metabase/setup/components/SettingsPage/SettingsPage.tsx+++ b/frontend/src/metabase/setup/components/SettingsPage/SettingsPage.tsx@@ -5,6 +5,7 @@ import type { SetupStep } from "metabase/redux/store";import { getSteps } from "metabase/setup/selectors";import { Box, Flex, Icon, Text, Tooltip } from "metabase/ui";+import { AIConfigStep } from "../AIConfigStep";import { CloudMigrationHelp } from "../CloudMigrationHelp";import { CompletedStep } from "../CompletedStep";import { DataUsageStep } from "../DataUsageStep";@@ -27,6 +28,7 @@ const STEP_COMPONENTS: Partial<user_info: UserStep,usage_question: UsageQuestionStep,db_connection: DatabaseStep,+ ai_config: AIConfigStep,license_token: LicenseTokenStep,data_usage: DataUsageStep,};diff --git a/frontend/src/metabase/setup/reducers.ts b/frontend/src/metabase/setup/reducers.tsindex 5ab17f47913..5ec4c0245bc 100644--- a/frontend/src/metabase/setup/reducers.ts+++ b/frontend/src/metabase/setup/reducers.ts@@ -6,6 +6,7 @@ import {loadLocaleDefaults,selectStep,skipDatabase,+ startAiConfig,submitDatabase,submitLicenseToken,submitUsageReason,@@ -44,6 +45,7 @@ const initialState: SetupState = {step: getInitialStep(),isLocaleLoaded: false,isTrackingAllowed: true,+ isAiConfigRequested: false,user: getUserFromQueryParams(),isEmbeddingUseCase,};@@ -95,6 +97,9 @@ export const reducer = createReducer(initialState, (builder) => {state.database = undefined;state.invite = undefined;});+ builder.addCase(startAiConfig.pending, (state) => {+ state.isAiConfigRequested = true;+ });builder.addCase(updateTracking.fulfilled, (state, { meta }) => {state.isTrackingAllowed = meta.arg;});diff --git a/frontend/src/metabase/setup/selectors.ts b/frontend/src/metabase/setup/selectors.tsindex 6489505bfb6..89db847fe1b 100644--- a/frontend/src/metabase/setup/selectors.ts+++ b/frontend/src/metabase/setup/selectors.ts@@ -85,6 +85,31 @@ export const getIsEmailConfigured = (state: State): boolean => {return getSetting(state, "email-configured?");};+export const getIsAiConfigRequested = (state: State): boolean => {+ return state.setup.isAiConfigRequested;+};++export const getIsAiConfigAvailable = createSelector(+ [+ (state: State) => getUsageReason(state),+ (state: State) => getIsEmbeddingUseCase(state),+ (state: State) => getSetting(state, "ai-features-enabled?"),+ ],+ (usageReason, isEmbeddingUseCase, areAiFeaturesEnabled) =>+ usageReason !== "embedding" &&+ !isEmbeddingUseCase &&+ areAiFeaturesEnabled !== false,+);++export const getShouldOfferAiConfig = createSelector(+ [+ (state: State) => getIsAiConfigAvailable(state),+ (state: State) => getIsAiConfigRequested(state),+ ],+ (isAiConfigAvailable, isAiConfigRequested) =>+ isAiConfigAvailable && !isAiConfigRequested,+);+export const getSteps = createSelector([(state: State) => getUsageReason(state),@@ -92,6 +117,8 @@ export const getSteps = createSelector((state: State) => getSetting(state, "token-features"),(state: State) => state.setup.licenseToken,(state: State) => getIsEmbeddingUseCase(state),+ (state: State) => getIsAiConfigAvailable(state),+ (state: State) => getIsAiConfigRequested(state),],(usageReason,@@ -99,6 +126,8 @@ export const getSteps = createSelector(tokenFeatures,licenseToken,isEmbeddingUseCase,+ isAiConfigAvailable,+ isAiConfigRequested,) => {const isPaidPlan =tokenFeatures &&@@ -136,6 +165,10 @@ export const getSteps = createSelector(),...maybeAddStep("license_token", shouldShowLicenseStep),...maybeAddStep("data_usage", shouldShowDataUsageStep),+ // Opted into from the completed step, so it always comes last. The+ // managed-AI offer relies on PLUGIN_METABOT.isEnabled, which is frozen+ // at plugin init: a token entered in license_token can't surface it.+ ...maybeAddStep("ai_config", isAiConfigAvailable && isAiConfigRequested),"completed",];diff --git a/frontend/src/metabase/setup/selectors.unit.spec.ts b/frontend/src/metabase/setup/selectors.unit.spec.tsnew file mode 100644index 00000000000..126767c9a8f--- /dev/null+++ b/frontend/src/metabase/setup/selectors.unit.spec.ts@@ -0,0 +1,101 @@+import { mockSettings } from "__support__/settings";+import type { SetupState } from "metabase/redux/store";+import {+ createMockSetupState,+ createMockState,+} from "metabase/redux/store/mocks";+import type { EnterpriseSettings } from "metabase-types/api";+import { createMockSettings } from "metabase-types/api/mocks";++import { getShouldOfferAiConfig, getSteps } from "./selectors";++interface SetupOpts {+ setup?: Partial<SetupState>;+ settings?: Partial<EnterpriseSettings>;+}++const getStepKeys = ({ setup = {}, settings = {} }: SetupOpts = {}) => {+ const state = createMockState({+ setup: createMockSetupState(setup),+ settings: mockSettings(createMockSettings(settings)),+ });++ return getSteps(state).map((step) => step.key);+};++const getShouldOffer = ({ setup = {}, settings = {} }: SetupOpts = {}) => {+ const state = createMockState({+ setup: createMockSetupState(setup),+ settings: mockSettings(createMockSettings(settings)),+ });++ return getShouldOfferAiConfig(state);+};++describe("getSteps", () => {+ it("should omit the AI config step until it is requested", () => {+ expect(getStepKeys()).toEqual([+ "welcome",+ "user_info",+ "usage_question",+ "db_connection",+ "data_usage",+ "completed",+ ]);+ });++ it("should append the AI config step after the last step once requested", () => {+ expect(getStepKeys({ setup: { isAiConfigRequested: true } })).toEqual([+ "welcome",+ "user_info",+ "usage_question",+ "db_connection",+ "data_usage",+ "ai_config",+ "completed",+ ]);+ });++ it("should omit the requested AI config step when AI features are disabled", () => {+ const stepKeys = getStepKeys({+ setup: { isAiConfigRequested: true },+ settings: { "ai-features-enabled?": false },+ });++ expect(stepKeys).not.toContain("ai_config");+ });++ it("should omit the requested AI config step for the embedding usage reason", () => {+ const stepKeys = getStepKeys({+ setup: { isAiConfigRequested: true, usageReason: "embedding" },+ });++ expect(stepKeys).not.toContain("ai_config");+ });+});++describe("getShouldOfferAiConfig", () => {+ it("should offer the AI config step by default", () => {+ expect(getShouldOffer()).toBe(true);+ });++ it("should not offer the AI config step once it has been requested", () => {+ expect(getShouldOffer({ setup: { isAiConfigRequested: true } })).toBe(+ false,+ );+ });++ it("should not offer the AI config step when AI features are disabled", () => {+ expect(+ getShouldOffer({ settings: { "ai-features-enabled?": false } }),+ ).toBe(false);+ });++ it("should not offer the AI config step for the embedding usage reason", () => {+ expect(getShouldOffer({ setup: { usageReason: "embedding" } })).toBe(false);+ });++ it("should not offer the AI config step for the embedding use case", () => {+ expect(getShouldOffer({ setup: { isEmbeddingUseCase: true } })).toBe(false);+ });+});diff --git a/frontend/src/metabase/setup/tests/common.unit.spec.tsx b/frontend/src/metabase/setup/tests/common.unit.spec.tsxindex 12eb244bf0b..431cb27a84b 100644--- a/frontend/src/metabase/setup/tests/common.unit.spec.tsx+++ b/frontend/src/metabase/setup/tests/common.unit.spec.tsx@@ -1,10 +1,12 @@import userEvent from "@testing-library/user-event";+import fetchMock from "fetch-mock";import { screen } from "__support__/ui";import { createMockSettingDefinition } from "metabase-types/api/mocks";import { SUBSCRIBE_TOKEN, SUBSCRIBE_URL } from "../constants";+import type { SetupOpts } from "./setup";import {clickNextStep,expectSectionToHaveLabel,@@ -13,7 +15,9 @@ import {getSection,selectUsageReason,setup,+ skipAiConfigStep,skipWelcomeScreen,+ startAiConfigStep,submitUserInfoStep,} from "./setup";@@ -123,6 +127,59 @@ describe("setup (OSS)", () => {});});+ describe("AI config step", () => {+ const completeSetup = async (opts?: SetupOpts) => {+ await setup(opts);+ await skipWelcomeScreen();+ await submitUserInfoStep();+ await selectUsageReason("self-service-analytics");+ await clickNextStep();+ await userEvent.click(screen.getByText("Continue with sample data"));+ await userEvent.click(screen.getByText("Finish"));+ };++ it("should not be part of the wizard until it is opted into", async () => {+ await completeSetup();++ expect(+ screen.queryByText("Connect to an AI provider"),+ ).not.toBeInTheDocument();+ expect(screen.getByText("You're all set up!")).toBeInTheDocument();+ });++ it("should become the last step when opting in from the completed step", async () => {+ await completeSetup();+ await startAiConfigStep();++ expect(getSection("Connect to an AI provider")).toHaveAttribute(+ "aria-current",+ "step",+ );+ expectSectionToHaveLabel("Connect to an AI provider", "5");+ expect(screen.queryByText("You're all set up!")).not.toBeInTheDocument();+ });++ it("should go back to the completed step when skipping, without offering AI again", async () => {+ await completeSetup();+ await startAiConfigStep();+ await skipAiConfigStep();++ expect(await screen.findByText("You're all set up!")).toBeInTheDocument();+ expect(screen.getByText("I'll set up AI later")).toBeInTheDocument();+ expect(+ screen.queryByRole("button", { name: "Set up AI" }),+ ).not.toBeInTheDocument();+ });++ it("should not offer the step when AI features are disabled", async () => {+ await completeSetup({ settings: { "ai-features-enabled?": false } });++ expect(+ screen.queryByRole("button", { name: "Set up AI" }),+ ).not.toBeInTheDocument();+ });+ });+describe("embedding homepage flags", () => {it("should set the correct flags when interested in embedding", async () => {await setup();@@ -161,8 +218,9 @@ describe("setup (OSS)", () => {});it("should not autoenable embedding if it was set by an env", async () => {- await setup({- settingOverrides: [+ await setup();+ fetchMock.modifyRoute("settings-list", {+ response: [createMockSettingDefinition({key: "enable-embedding",value: false,diff --git a/frontend/src/metabase/setup/tests/enterprise.unit.spec.tsx b/frontend/src/metabase/setup/tests/enterprise.unit.spec.tsxindex 2399fa97371..48faa511174 100644--- a/frontend/src/metabase/setup/tests/enterprise.unit.spec.tsx+++ b/frontend/src/metabase/setup/tests/enterprise.unit.spec.tsx@@ -1,8 +1,12 @@import userEvent from "@testing-library/user-event";import fetchMock from "fetch-mock";-import { setupForTokenCheckEndpoint } from "__support__/server-mocks";+import {+ setupForTokenCheckEndpoint,+ setupMetabaseManagedAiEndpoints,+} from "__support__/server-mocks";import { screen, waitFor } from "__support__/ui";+import { createMockTokenFeatures } from "metabase-types/api/mocks";import { trackLicenseTokenStepSubmitted } from "../analytics";@@ -16,6 +20,7 @@ import {setup,skipTokenStep,skipWelcomeScreen,+ startAiConfigStep,submitUserInfoStep,} from "./setup";@@ -159,6 +164,38 @@ describe("setup (EE build, but no token)", () => {});});});++ describe("AI config step with the managed AI offer", () => {+ it("should preselect the managed provider and ask the admin to accept the terms", async () => {+ await setupEnterprise({+ tokenFeatures: createMockTokenFeatures({+ hosting: true,+ "offer-metabase-ai-managed": true,+ }),+ });+ setupMetabaseManagedAiEndpoints();++ await skipWelcomeScreen();+ await submitUserInfoStep();+ await selectUsageReason("self-service-analytics");+ await clickNextStep();+ await userEvent.click(screen.getByText("Continue with sample data"));+ await startAiConfigStep();++ expect(+ await screen.findByText("About Metabase AI service"),+ ).toBeInTheDocument();+ expect(screen.getByLabelText("Provider")).toHaveValue("Metabase");+ expect(+ await screen.findByRole("checkbox", {+ name: /I agree with the Metabase AI Service/i,+ }),+ ).toBeInTheDocument();+ expect(+ screen.queryByText("Please ask an Admin user to enable this for you."),+ ).not.toBeInTheDocument();+ });+ });});const input = () => screen.getByRole("textbox", { name: "Token" });diff --git a/frontend/src/metabase/setup/tests/setup.tsx b/frontend/src/metabase/setup/tests/setup.tsxindex 60e20559afc..742ecc0e21d 100644--- a/frontend/src/metabase/setup/tests/setup.tsx+++ b/frontend/src/metabase/setup/tests/setup.tsx@@ -7,6 +7,7 @@ import {setupEnterprisePlugins,} from "__support__/enterprise";import {+ setupCurrentUserEndpoint,setupPropertiesEndpoints,setupSettingsEndpoints,} from "__support__/server-mocks";@@ -18,13 +19,14 @@ import {createMockState,} from "metabase/redux/store/mocks";import type {- SettingDefinition,+ EnterpriseSettings,TokenFeatures,UsageReason,} from "metabase-types/api";import {createMockSettings,createMockTokenFeatures,+ createMockUser,} from "metabase-types/api/mocks";import { Setup } from "../components/Setup";@@ -33,13 +35,13 @@ export interface SetupOpts {step?: SetupStep;tokenFeatures?: TokenFeatures;enterprisePlugins?: Parameters<typeof setupEnterpriseOnlyPlugin>[0][] | "*";- settingOverrides?: SettingDefinition[];+ settings?: Partial<EnterpriseSettings>;}export async function setup({tokenFeatures = createMockTokenFeatures(),enterprisePlugins,- settingOverrides = [],+ settings = {},}: SetupOpts = {}) {localStorage.clear();jest.clearAllMocks();@@ -50,6 +52,7 @@ export async function setup({}),settings: mockSettings(createMockSettings({+ ...settings,"token-features": tokenFeatures,"available-locales": [["en", "English"]],}),@@ -66,11 +69,12 @@ export async function setup({fetchMock.post("path:/api/session/password-check", { valid: true });fetchMock.post("path:/api/setup", {});+ setupCurrentUserEndpoint(createMockUser({ is_superuser: true }));fetchMock.put("path:/api/setting/anon-tracking-enabled", 200);setupPropertiesEndpoints(- createMockSettings({ "token-features": tokenFeatures }),+ createMockSettings({ ...settings, "token-features": tokenFeatures }),);- setupSettingsEndpoints(settingOverrides);+ setupSettingsEndpoints([]);fetchMock.put("path:/api/setting", 200);renderWithProviders(<Setup />, { storeInitialState: state });@@ -168,3 +172,11 @@ export const getLastSettingsPutPayload = async () => {export const skipTokenStep = async (name = "Skip") =>await userEvent.click(screen.getByRole("button", { name }));++export const startAiConfigStep = async () =>+ await userEvent.click(screen.getByRole("button", { name: "Set up AI" }));++export const skipAiConfigStep = async () =>+ await userEvent.click(+ screen.getByRole("button", { name: "I'll set this up later" }),+ );diff --git a/snowplow/iglu-client-embedded/schemas/com.metabase/setup/jsonschema/1-0-4 b/snowplow/iglu-client-embedded/schemas/com.metabase/setup/jsonschema/1-0-4new file mode 100644index 00000000000..ffe3502a820--- /dev/null+++ b/snowplow/iglu-client-embedded/schemas/com.metabase/setup/jsonschema/1-0-4@@ -0,0 +1,105 @@+{+ "$schema": "http://iglucentral.com/schemas/com.snowplowanalytics.self-desc/schema/jsonschema/1-0-0#",+ "description": "Setup flow",+ "self": {+ "vendor": "com.metabase",+ "name": "setup",+ "format": "jsonschema",+ "version": "1-0-4"+ },+ "type": "object",+ "properties": {+ "event": {+ "description": "Event name",+ "type": "string",+ "enum": [+ "step_seen",+ "usage_reason_selected",+ "license_token_step_submitted",+ "database_selected",+ "add_data_later_clicked"+ ],+ "maxLength": 1024+ },+ "version": {+ "description": "String describing the version of onboarding we're on",+ "type": "string",+ "maxLength": 1024+ },+ "step": {+ "description": "String describing the step that the set up step",+ "type": [+ "string",+ "null"+ ],+ "enum": [+ "welcome",+ "language",+ "user_info",+ "db_connection",+ "ai_config",+ "usage_question",+ "license_token",+ "db_scheduling",+ "data_usage",+ "completed"+ ],+ "maxLength": 1024+ },+ "step_number": {+ "description": "Integer describing the order of the referenced step",+ "type": [+ "integer",+ "null"+ ],+ "minimum": 0,+ "maximum": 1024+ },+ "usage_reason": {+ "description": "Answer to the usage reason question",+ "type": [+ "string",+ "null"+ ],+ "enum": [+ "self-service-analytics",+ "embedding",+ "both",+ "not-sure"+ ],+ "maxLength": 1024+ },+ "database": {+ "description": "String with the database type that the user selected",+ "type": [+ "string",+ "null"+ ],+ "maxLength": 1024+ },+ "valid_token_present": {+ "description": "Boolean indicating if a valid token was submitted",+ "type": [+ "boolean",+ "null"+ ]+ },+ "source": {+ "description": "String with the product location that the event took place",+ "type": [+ "string",+ "null"+ ],+ "enum": [+ "pre_selection",+ "post_selection"+ ],+ "maxLength": 1024+ }+ },+ "required": [+ "event",+ "version"+ ],+ "additionalProperties": true+}diff --git a/src/metabase/llm/startup.clj b/src/metabase/llm/startup.cljindex 50279ae88bf..418425d3937 100644--- a/src/metabase/llm/startup.clj+++ b/src/metabase/llm/startup.clj@@ -5,6 +5,7 @@[metabase.metabot.settings :as metabot.settings][metabase.premium-features.core :as premium-features][metabase.settings.core :as setting]+ [metabase.setup.core :as setup][metabase.util.log :as log]))(set! *warn-on-reflection* true)@@ -32,6 +33,11 @@(defn check-and-sync-settings-on-startup!"For legacy `:metabot-v3` customers that do not have `:metabase-ai-managed`,switch the default unmanaged Metabot provider to the managed `metabase/...`- provider on startup."+ provider on startup.++ This is a migration for existing instances only: it is skipped until initial+ setup has completed, so fresh instances choose their AI provider in the setup+ wizard instead of booting pre-configured."[]- (maybe-sync-managed-metabot-provider!))+ (when (setup/has-user-setup)+ (maybe-sync-managed-metabot-provider!)))diff --git a/test/metabase/llm/startup_test.clj b/test/metabase/llm/startup_test.cljindex fb473c7a6e7..c2909a39607 100644--- a/test/metabase/llm/startup_test.clj+++ b/test/metabase/llm/startup_test.clj@@ -13,15 +13,29 @@(deftest check-and-sync-settings-on-startup-syncs-legacy-metabot-default-test(mt/discard-setting-changes [llm-metabot-provider](mt/with-temporary-raw-setting-values [llm-metabot-provider nil]- (mt/with-dynamic-fn-redefs [premium-features/canonically-has-feature?- (fn [feature]- (case feature- :metabot-v3 true- :metabase-ai-managed false))- metabot.settings/llm-metabot-configured? (constantly false)]- (llm.startup/check-and-sync-settings-on-startup!)- (is (= metabot.settings/default-metabase-llm-metabot-provider- (metabot.settings/llm-metabot-provider)))))))+ (mt/with-temporary-setting-values [has-user-setup true]+ (mt/with-dynamic-fn-redefs [premium-features/canonically-has-feature?+ (fn [feature]+ (case feature+ :metabot-v3 true+ :metabase-ai-managed false))+ metabot.settings/llm-metabot-configured? (constantly false)]+ (llm.startup/check-and-sync-settings-on-startup!)+ (is (= metabot.settings/default-metabase-llm-metabot-provider+ (metabot.settings/llm-metabot-provider))))))))++(deftest check-and-sync-settings-on-startup-skips-fresh-instances-test+ (mt/discard-setting-changes [llm-metabot-provider]+ (mt/with-temporary-raw-setting-values [llm-metabot-provider nil]+ (mt/with-temporary-setting-values [has-user-setup false]+ (mt/with-dynamic-fn-redefs [premium-features/canonically-has-feature?+ (fn [feature]+ (case feature+ :metabot-v3 true+ :metabase-ai-managed false))+ metabot.settings/llm-metabot-configured? (constantly false)]+ (llm.startup/check-and-sync-settings-on-startup!)+ (is (nil? (setting/db-stored-value :llm-metabot-provider))))))))(deftest check-and-sync-settings-on-startup-feature-permutations-test(doseq [legacy-result [nil false true]@@ -29,34 +43,37 @@(testing (format ":metabot-v3=%s :metabase-ai-managed=%s" legacy-result managed-result)(mt/discard-setting-changes [llm-metabot-provider](mt/with-temporary-raw-setting-values [llm-metabot-provider nil]- (mt/with-dynamic-fn-redefs [premium-features/canonically-has-feature?- (fn [feature]- (case feature- :metabot-v3 legacy-result- :metabase-ai-managed managed-result))- metabot.settings/llm-metabot-configured? (constantly false)]- (llm.startup/check-and-sync-settings-on-startup!)- (is (= (case [legacy-result managed-result]- [true false] metabot.settings/default-metabase-llm-metabot-provider- nil)- (setting/db-stored-value :llm-metabot-provider)))))))))+ (mt/with-temporary-setting-values [has-user-setup true]+ (mt/with-dynamic-fn-redefs [premium-features/canonically-has-feature?+ (fn [feature]+ (case feature+ :metabot-v3 legacy-result+ :metabase-ai-managed managed-result))+ metabot.settings/llm-metabot-configured? (constantly false)]+ (llm.startup/check-and-sync-settings-on-startup!)+ (is (= (case [legacy-result managed-result]+ [true false] metabot.settings/default-metabase-llm-metabot-provider+ nil)+ (setting/db-stored-value :llm-metabot-provider))))))))))(deftest check-and-sync-settings-on-startup-does-not-overwrite-configured-byok-test(mt/discard-setting-changes [llm-metabot-provider](mt/with-temporary-raw-setting-values [llm-metabot-provider nil]- (mt/with-dynamic-fn-redefs [premium-features/canonically-has-feature?- (fn [feature]- (case feature- :metabot-v3 true- :metabase-ai-managed false))- metabot.settings/llm-metabot-configured? (constantly true)]- (llm.startup/check-and-sync-settings-on-startup!)- (is (= metabot.settings/default-llm-metabot-provider- (metabot.settings/llm-metabot-provider)))))))+ (mt/with-temporary-setting-values [has-user-setup true]+ (mt/with-dynamic-fn-redefs [premium-features/canonically-has-feature?+ (fn [feature]+ (case feature+ :metabot-v3 true+ :metabase-ai-managed false))+ metabot.settings/llm-metabot-configured? (constantly true)]+ (llm.startup/check-and-sync-settings-on-startup!)+ (is (= metabot.settings/default-llm-metabot-provider+ (metabot.settings/llm-metabot-provider))))))))(deftest check-and-sync-settings-on-startup-does-not-overwrite-explicit-provider-test(mt/discard-setting-changes [llm-metabot-provider]- (mt/with-temporary-setting-values [llm-metabot-provider "openai/gpt-4.1-mini"]+ (mt/with-temporary-setting-values [llm-metabot-provider "openai/gpt-4.1-mini"+ has-user-setup true](mt/with-dynamic-fn-redefs [premium-features/canonically-has-feature?(fn [feature](case feature@@ -70,12 +87,13 @@(deftest check-and-sync-settings-on-startup-syncs-blank-provider-test(mt/discard-setting-changes [llm-metabot-provider](mt/with-temporary-raw-setting-values [llm-metabot-provider ""]- (mt/with-dynamic-fn-redefs [premium-features/canonically-has-feature?- (fn [feature]- (case feature- :metabot-v3 true- :metabase-ai-managed false))- metabot.settings/llm-metabot-configured? (constantly false)]- (llm.startup/check-and-sync-settings-on-startup!)- (is (= metabot.settings/default-metabase-llm-metabot-provider- (metabot.settings/llm-metabot-provider)))))))+ (mt/with-temporary-setting-values [has-user-setup true]+ (mt/with-dynamic-fn-redefs [premium-features/canonically-has-feature?+ (fn [feature]+ (case feature+ :metabot-v3 true+ :metabase-ai-managed false))+ metabot.settings/llm-metabot-configured? (constantly false)]+ (llm.startup/check-and-sync-settings-on-startup!)+ (is (= metabot.settings/default-metabase-llm-metabot-provider+ (metabot.settings/llm-metabot-provider))))))))