@marimo-team/frontend 0.23.11-dev2 → 0.23.11-dev21

package/src/components/chat/chat-panel.tsx

@@ -23,6 +23,7 @@ import {
   PlusIcon,
   SparklesIcon,
   SettingsIcon,
+  CodeIcon,
 } from "lucide-react";
 import { memo, useEffect, useRef, useState } from "react";
 import useEvent from "react-use-event-hook";
@@ -268,24 +269,32 @@ const ChatInputFooter: React.FC<ChatInputFooterProps> = memo(
       {
         value: "ask",
         label: "Ask",
-        subtitle:
-          "Use AI with access to read-only tools like documentation search",
+        subtitle: "AI with access to read-only tools like documentation search",
         Icon: NotebookText,
       },
       {
         value: "agent",
-        label: "Agent (beta)",
-        subtitle: "Use AI with access to read and write tools",
+        label: "Agent",
+        subtitle: "AI with access to read and write tools",
         Icon: HatGlasses,
       },
     ];
 
+    if (import.meta.env.DEV) {
+      modeOptions.push({
+        value: "code_mode",
+        label: "Code Mode (experimental)",
+        subtitle: "AI with access to the notebook's kernel. Use with caution.",
+        Icon: CodeIcon,
+      });
+    }
+
     const isAttachmentSupported =
       PROVIDERS_THAT_SUPPORT_ATTACHMENTS.has(currentProvider);
 
-    const CurrentModeIcon = modeOptions.find(
-      (o) => o.value === currentMode,
-    )?.Icon;
+    const currentModeOption = modeOptions.find((o) => o.value === currentMode);
+    const CurrentModeIcon = currentModeOption?.Icon;
+    const CurrentModeLabel = currentModeOption?.label;
 
     return (
       <TooltipProvider>
@@ -294,7 +303,7 @@ const ChatInputFooter: React.FC<ChatInputFooterProps> = memo(
             <Select value={currentMode} onValueChange={saveModeChange}>
               <SelectTrigger className="h-6 text-xs border-border shadow-none! ring-0! bg-muted hover:bg-muted/30 py-0 px-2 gap-1.5">
                 {CurrentModeIcon && <CurrentModeIcon className="h-3 w-3" />}
-                <span className="capitalize">{currentMode}</span>
+                <span>{CurrentModeLabel}</span>
               </SelectTrigger>
               <SelectContent>
                 <SelectGroup>

package/src/components/datasources/__tests__/column-preview.test.tsx

@@ -0,0 +1,97 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import { render } from "@testing-library/react";
+import { Provider } from "jotai";
+import type React from "react";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { MockRequestClient } from "@/__mocks__/requests";
+import type { SQLTableContext } from "@/core/datasets/data-source-connections";
+import type { DataTable, DataTableColumn } from "@/core/kernel/messages";
+import { requestClientAtom } from "@/core/network/requests";
+import { store } from "@/core/state/jotai";
+import { DatasetColumnPreview } from "../column-preview";
+
+const wrapper = ({ children }: { children: React.ReactNode }) => (
+  <Provider store={store}>{children}</Provider>
+);
+
+const table: DataTable = {
+  name: "users",
+  columns: [],
+  source: "my_engine",
+  // Not "connection"/"catalog", so a preview is requested on mount.
+  source_type: "duckdb",
+  type: "table",
+  engine: "my_engine" as DataTable["engine"],
+  indexes: null,
+  num_columns: null,
+  num_rows: null,
+  variable_name: null,
+  primary_keys: null,
+};
+
+const column = { name: "email" } as DataTableColumn;
+
+function renderPreview(sqlTableContext?: SQLTableContext) {
+  const client = MockRequestClient.create();
+  store.set(requestClientAtom, client);
+  render(
+    <DatasetColumnPreview
+      table={table}
+      column={column}
+      preview={undefined}
+      onAddColumnChart={vi.fn()}
+      sqlTableContext={sqlTableContext}
+    />,
+    { wrapper },
+  );
+  return client;
+}
+
+const ctx = (
+  overrides: Partial<SQLTableContext> & { database: string; schema: string },
+): SQLTableContext => ({
+  engine: "my_engine",
+  dialect: "duckdb",
+  ...overrides,
+});
+
+describe("DatasetColumnPreview fullyQualifiedTableName", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("uses just the table name without a SQL context", () => {
+    const client = renderPreview(undefined);
+    expect(client.previewDatasetColumn).toHaveBeenCalledWith(
+      expect.objectContaining({ fullyQualifiedTableName: "users" }),
+    );
+  });
+
+  it("qualifies with database and schema for flat engines", () => {
+    const client = renderPreview(ctx({ database: "db", schema: "public" }));
+    expect(client.previewDatasetColumn).toHaveBeenCalledWith(
+      expect.objectContaining({ fullyQualifiedTableName: "db.public.users" }),
+    );
+  });
+
+  it("does not emit a double dot for schemaless tables", () => {
+    // Regression: previously produced "db..users".
+    const client = renderPreview(ctx({ database: "db", schema: "" }));
+    expect(client.previewDatasetColumn).toHaveBeenCalledWith(
+      expect.objectContaining({ fullyQualifiedTableName: "db.users" }),
+    );
+  });
+
+  it("includes the full schema path for nested namespaces", () => {
+    // Regression: previously dropped schemaPath and emitted "top.deep.users".
+    const client = renderPreview(
+      ctx({ database: "top", schema: "deep", schemaPath: ["nested", "deep"] }),
+    );
+    expect(client.previewDatasetColumn).toHaveBeenCalledWith(
+      expect.objectContaining({
+        fullyQualifiedTableName: "top.nested.deep.users",
+      }),
+    );
+  });
+});

package/src/components/datasources/__tests__/utils.test.ts

@@ -3,8 +3,18 @@
 import { describe, expect, it } from "vitest";
 import type { SQLTableContext } from "@/core/datasets/data-source-connections";
 import { DUCKDB_ENGINE } from "@/core/datasets/engines";
-import type { DataTable, DataTableColumn } from "@/core/kernel/messages";
-import { sqlCode, tableUniqueId } from "../utils";
+import type {
+  Database,
+  DatabaseSchema,
+  DataTable,
+  DataTableColumn,
+} from "@/core/kernel/messages";
+import {
+  schemaSubtreeMatchesSearch,
+  shouldExpandDatabaseForSearch,
+  sqlCode,
+  tableUniqueId,
+} from "../utils";
 
 describe("sqlCode", () => {
   const mockTable: DataTable = {
@@ -519,3 +529,118 @@ describe("tableUniqueId", () => {
     );
   });
 });
+
+function makeTable(name: string): DataTable {
+  return {
+    name,
+    columns: [],
+    source: "memory",
+    source_type: "local",
+    type: "table",
+    engine: null,
+    indexes: null,
+    num_columns: null,
+    num_rows: null,
+    variable_name: null,
+    primary_keys: null,
+  };
+}
+
+function makeSchema(opts: {
+  name: string;
+  tables: DataTable[];
+  tables_resolved?: boolean;
+  child_schemas?: DatabaseSchema[];
+  child_schemas_resolved?: boolean;
+}): DatabaseSchema {
+  return {
+    name: opts.name,
+    tables: opts.tables,
+    tables_resolved: opts.tables_resolved ?? true,
+    child_schemas: opts.child_schemas ?? [],
+    child_schemas_resolved: opts.child_schemas_resolved ?? true,
+  };
+}
+
+function makeDatabase(
+  name: string,
+  schemas: DatabaseSchema[],
+  schemas_resolved = true,
+): Database {
+  return { name, dialect: "duckdb", schemas, schemas_resolved, engine: null };
+}
+
+describe("schemaSubtreeMatchesSearch", () => {
+  it("returns false for an empty query", () => {
+    const schema = makeSchema({ name: "main", tables: [makeTable("users")] });
+    expect(schemaSubtreeMatchesSearch(schema, "")).toBe(false);
+    expect(schemaSubtreeMatchesSearch(schema, "   ")).toBe(false);
+    expect(schemaSubtreeMatchesSearch(schema, undefined)).toBe(false);
+  });
+
+  it("matches a table name case-insensitively", () => {
+    const schema = makeSchema({ name: "main", tables: [makeTable("Users")] });
+    expect(schemaSubtreeMatchesSearch(schema, "user")).toBe(true);
+    expect(schemaSubtreeMatchesSearch(schema, "orders")).toBe(false);
+  });
+
+  it("matches a table in a resolved child schema", () => {
+    const schema = makeSchema({
+      name: "parent",
+      tables: [],
+      child_schemas: [
+        makeSchema({ name: "child", tables: [makeTable("orders")] }),
+      ],
+    });
+    expect(schemaSubtreeMatchesSearch(schema, "orders")).toBe(true);
+  });
+
+  it("ignores deferred tables so search never triggers a fetch", () => {
+    const schema = makeSchema({
+      name: "main",
+      tables: [makeTable("users")],
+      tables_resolved: false,
+    });
+    expect(schemaSubtreeMatchesSearch(schema, "users")).toBe(false);
+  });
+
+  it("ignores deferred child schemas", () => {
+    const schema = makeSchema({
+      name: "parent",
+      tables: [],
+      child_schemas: [
+        makeSchema({ name: "child", tables: [makeTable("orders")] }),
+      ],
+      child_schemas_resolved: false,
+    });
+    expect(schemaSubtreeMatchesSearch(schema, "orders")).toBe(false);
+  });
+});
+
+describe("shouldExpandDatabaseForSearch", () => {
+  it("returns false for an empty query", () => {
+    const db = makeDatabase("memory", [
+      makeSchema({ name: "main", tables: [makeTable("users")] }),
+    ]);
+    expect(shouldExpandDatabaseForSearch(db, "")).toBe(false);
+    expect(shouldExpandDatabaseForSearch(db, undefined)).toBe(false);
+  });
+
+  it("expands when a loaded schema contains a matching table", () => {
+    const db = makeDatabase("memory", [
+      makeSchema({ name: "main", tables: [makeTable("users")] }),
+      makeSchema({ name: "other", tables: [makeTable("orders")] }),
+    ]);
+    expect(shouldExpandDatabaseForSearch(db, "user")).toBe(true);
+    expect(shouldExpandDatabaseForSearch(db, "nomatch")).toBe(false);
+  });
+
+  it("does not expand when the schema list itself is deferred", () => {
+    const db = makeDatabase(
+      "memory",
+      [makeSchema({ name: "main", tables: [makeTable("users")] })],
+      /* schemas_resolved */ false,
+    );
+    expect(shouldExpandDatabaseForSearch(db, "users")).toBe(false);
+  });
+});

package/src/components/datasources/column-preview.tsx

@@ -29,7 +29,7 @@ import { Button } from "../ui/button";
 import { Tooltip } from "../ui/tooltip";
 import { ColumnPreviewContainer } from "./components";
 import { InstallPackageButton } from "./install-package-button";
-import { convertStatsName, sqlCode } from "./utils";
+import { convertStatsName, sqlCode, tableUniqueId } from "./utils";
 
 export const DatasetColumnPreview: React.FC<{
   table: DataTable;
@@ -48,9 +48,7 @@ export const DatasetColumnPreview: React.FC<{
       tableName: table.name,
       columnName: column.name,
       sourceType: table.source_type,
-      fullyQualifiedTableName: sqlTableContext
-        ? `${sqlTableContext.database}.${sqlTableContext.schema}.${table.name}`
-        : table.name,
+      fullyQualifiedTableName: tableUniqueId(sqlTableContext, table.name),
     });
   };
 

package/src/components/datasources/datasources.tsx

@@ -83,6 +83,8 @@ import {
   areSchemasResolved,
   areTablesResolved,
   isSchemaless,
+  schemaSubtreeMatchesSearch,
+  shouldExpandDatabaseForSearch,
   sqlCode,
   tableUniqueId,
 } from "./utils";
@@ -360,7 +362,6 @@ export const DataSources: React.FC = () => {
                 key={database.name}
                 connection={connection}
                 database={database}
-                hasSearch={hasSearch}
                 searchValue={searchValue}
               />
             ))}
@@ -435,7 +436,6 @@ interface DataSourceTree {
   dialect: string;
   engineName: string;
   databaseName: string;
-  hasSearch: boolean;
   searchValue?: string;
 }
 
@@ -470,9 +470,8 @@ function buildSqlTableContext(
 const DatabaseTree: React.FC<{
   connection: DataSourceConnection;
   database: Database;
-  hasSearch: boolean;
   searchValue?: string;
-}> = ({ connection, database, hasSearch, searchValue }) => {
+}> = ({ connection, database, searchValue }) => {
   const tree = React.useMemo<DataSourceTree>(
     () => ({
       engineName: connection.name,
@@ -480,7 +479,6 @@ const DatabaseTree: React.FC<{
       dialect: connection.dialect,
       defaultSchema: connection.default_schema,
       defaultDatabase: connection.default_database,
-      hasSearch,
       searchValue,
     }),
     [
@@ -489,7 +487,6 @@ const DatabaseTree: React.FC<{
       connection.default_schema,
       connection.default_database,
       database.name,
-      hasSearch,
       searchValue,
     ],
   );
@@ -498,7 +495,7 @@ const DatabaseTree: React.FC<{
     <DatabaseItem
       engineName={connection.name}
       database={database}
-      hasSearch={hasSearch}
+      searchValue={searchValue}
     >
       <DataSourceTreeContext.Provider value={tree}>
         <SchemaList
@@ -513,18 +510,30 @@ const DatabaseTree: React.FC<{
 };
 
 const DatabaseItem: React.FC<{
-  hasSearch: boolean;
+  searchValue?: string;
   engineName: string;
   database: Database;
   children: React.ReactNode;
-}> = ({ hasSearch, engineName, database, children }) => {
-  const [isExpanded, setIsExpanded] = React.useState(false);
+}> = ({ searchValue, engineName, database, children }) => {
+  // Auto-expand during search only when a loaded schema under this database
+  // contains a matching table.
+  const expandForSearch = shouldExpandDatabaseForSearch(database, searchValue);
+  const [isExpanded, setIsExpanded] = React.useState(expandForSearch);
   const [isSelected, setIsSelected] = React.useState(false);
-  const [prevHasSearch, setPrevHasSearch] = React.useState(hasSearch);
-
-  if (prevHasSearch !== hasSearch) {
-    setPrevHasSearch(hasSearch);
-    setIsExpanded(hasSearch);
+  const [prevSearchValue, setPrevSearchValue] = React.useState(searchValue);
+  const [prevExpandForSearch, setPrevExpandForSearch] =
+    React.useState(expandForSearch);
+
+  // Re-sync when the query changes or when newly resolved data turns this
+  // branch into a match under the same query (deferred subtrees resolve
+  // asynchronously, so the decision can flip without the query changing).
+  if (
+    prevSearchValue !== searchValue ||
+    prevExpandForSearch !== expandForSearch
+  ) {
+    setPrevSearchValue(searchValue);
+    setPrevExpandForSearch(expandForSearch);
+    setIsExpanded(expandForSearch);
   }
 
   return (
@@ -657,12 +666,30 @@ interface SchemaNodeProps {
 const SchemaNode: React.FC<SchemaNodeProps> = (props) => {
   const { schema, schemaPath, depth } = props;
   const tree = useDataSourceTree();
-  const { databaseName, hasSearch, searchValue } = tree;
-  const [isExpanded, setIsExpanded] = React.useState(hasSearch);
+  const { databaseName, searchValue } = tree;
+  // Auto-expand during search only when this schema's loaded subtree contains a
+  // matching table.
+  const expandForSearch = schemaSubtreeMatchesSearch(schema, searchValue);
+  const [isExpanded, setIsExpanded] = React.useState(expandForSearch);
   const [isSelected, setIsSelected] = React.useState(false);
+  const [prevSearchValue, setPrevSearchValue] = React.useState(searchValue);
+  const [prevExpandForSearch, setPrevExpandForSearch] =
+    React.useState(expandForSearch);
   const uniqueValue = `${databaseName}:${schemaPath.join(".")}`;
   const childSchemas = schema.child_schemas ?? [];
 
+  // Re-sync when the query changes or when newly resolved data turns this
+  // subtree into a match under the same query (deferred tables/child schemas
+  // resolve asynchronously, so the decision can flip without the query changing).
+  if (
+    prevSearchValue !== searchValue ||
+    prevExpandForSearch !== expandForSearch
+  ) {
+    setPrevSearchValue(searchValue);
+    setPrevExpandForSearch(expandForSearch);
+    setIsExpanded(expandForSearch);
+  }
+
   return (
     <>
       <CommandItem

package/src/components/datasources/utils.ts

@@ -52,6 +52,51 @@ export function areChildSchemasResolved(schema: DatabaseSchema): boolean {
   return schema.child_schemas_resolved !== false;
 }
 
+/**
+ * Whether a loaded schema subtree contains a table whose name matches
+ * `searchValue`. Deferred (not-yet-fetched) tables and child schemas are
+ * treated as non-matching, so searching never triggers a lazy catalog fetch on
+ * large/remote connections.
+ */
+export function schemaSubtreeMatchesSearch(
+  schema: DatabaseSchema,
+  searchValue: string | undefined,
+): boolean {
+  const query = searchValue?.trim().toLowerCase();
+  if (!query) {
+    return false;
+  }
+  if (
+    areTablesResolved(schema) &&
+    schema.tables.some((table) => table.name.toLowerCase().includes(query))
+  ) {
+    return true;
+  }
+  if (areChildSchemasResolved(schema)) {
+    return (schema.child_schemas ?? []).some((child) =>
+      schemaSubtreeMatchesSearch(child, query),
+    );
+  }
+  return false;
+}
+
+/**
+ * Auto-expand a database row during search only when one of its loaded schemas
+ * contains a matching table. Returns false when the schema list itself is
+ * deferred.
+ */
+export function shouldExpandDatabaseForSearch(
+  database: Database,
+  searchValue: string | undefined,
+): boolean {
+  if (!searchValue?.trim() || !areSchemasResolved(database)) {
+    return false;
+  }
+  return database.schemas.some((schema) =>
+    schemaSubtreeMatchesSearch(schema, searchValue),
+  );
+}
+
 interface SqlCodeFormatter {
   /**
    * Format the table path based on dialect-specific rules

package/src/components/editor/actions/useNotebookActions.tsx

@@ -41,7 +41,10 @@ import {
   YoutubeIcon,
   ZapIcon,
 } from "lucide-react";
-import { settingDialogAtom } from "@/components/app-config/state";
+import {
+  settingDialogAtom,
+  useOpenSettingsToTab,
+} from "@/components/app-config/state";
 import { MarkdownIcon } from "@/components/editor/cell/code/icons";
 import { MarimoPlusIcon } from "@/components/icons/marimo-icons";
 import { useImperativeModal } from "@/components/modal/ImperativeModal";
@@ -57,7 +60,8 @@ import {
   useCellActions,
 } from "@/core/cells/cells";
 import { disabledCellIds } from "@/core/cells/utils";
-import { useResolvedMarimoConfig } from "@/core/config/config";
+import { capabilitiesAtom } from "@/core/config/capabilities";
+import { aiEnabledAtom, useResolvedMarimoConfig } from "@/core/config/config";
 import { Constants } from "@/core/constants";
 import {
   updateCellOutputsWithScreenshots,
@@ -86,7 +90,7 @@ import { Strings } from "@/utils/strings";
 import { newNotebookURL } from "@/utils/urls";
 import { useRunAllCells } from "../cell/useRunCells";
 import { useChromeActions, useChromeState } from "../chrome/state";
-import { PANELS } from "../chrome/types";
+import { isPanelHidden, PANELS } from "../chrome/types";
 import { AddConnectionDialogContent } from "../connections/add-connection-dialog";
 import { keyboardShortcutsAtom } from "../controls/keyboard-shortcuts";
 import { commandPaletteAtom } from "../controls/state";
@@ -112,6 +116,8 @@ export function useNotebookActions() {
   const kioskMode = useAtomValue(kioskModeAtom);
   const hideAllMarkdownCode = useHideAllMarkdownCode();
   const [resolvedConfig] = useResolvedMarimoConfig();
+  const capabilities = useAtomValue(capabilitiesAtom);
+  const aiEnabled = useAtomValue(aiEnabledAtom);
 
   const {
     updateCellConfig,
@@ -126,6 +132,7 @@ export function useNotebookActions() {
   const copyNotebook = useCopyNotebook(filename);
   const setCommandPaletteOpen = useSetAtom(commandPaletteAtom);
   const setSettingsDialogOpen = useSetAtom(settingDialogAtom);
+  const { handleClick: openSettings } = useOpenSettingsToTab();
   const setKeyboardShortcutsOpen = useSetAtom(keyboardShortcutsAtom);
   const {
     exportAsIPYNB,
@@ -407,20 +414,31 @@ export function useNotebookActions() {
       label: "Helper panel",
       redundant: true,
       handle: NOOP_HANDLER,
-      dropdown: PANELS.flatMap(
-        ({ type: id, Icon, hidden, additionalKeywords }) => {
-          if (hidden) {
-            return [];
-          }
-          return {
-            label: Strings.startCase(id),
-            rightElement: renderCheckboxElement(selectedPanel === id),
-            icon: <Icon size={14} strokeWidth={1.5} />,
-            handle: () => toggleApplication(id),
-            additionalKeywords,
-          };
-        },
-      ),
+      dropdown: PANELS.flatMap((panel) => {
+        // Still show the AI panel in the command palette so users can try AI
+        // features. When AI is disabled, open settings instead of the panel.
+        const openAiSettingsWhenDisabled = panel.type === "ai" && !aiEnabled;
+        if (
+          isPanelHidden({ panel, capabilities, aiEnabled }) &&
+          !openAiSettingsWhenDisabled
+        ) {
+          return [];
+        }
+        const { type: id, Icon, additionalKeywords } = panel;
+        return {
+          label: Strings.startCase(id),
+          rightElement: renderCheckboxElement(selectedPanel === id),
+          icon: <Icon size={14} strokeWidth={1.5} />,
+          handle: () => {
+            if (openAiSettingsWhenDisabled) {
+              openSettings("ai", "ai-features");
+              return;
+            }
+            toggleApplication(id);
+          },
+          additionalKeywords,
+        };
+      }),
     },
 
     {

package/src/components/editor/connections/components.tsx

@@ -1,6 +1,7 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
 import { zodResolver } from "@hookform/resolvers/zod";
+import { useAtomValue } from "jotai";
 import React from "react";
 import { type DefaultValues, type FieldValues, useForm } from "react-hook-form";
 import type { z } from "zod";
@@ -16,8 +17,10 @@ import {
   SelectTrigger,
   SelectValue,
 } from "@/components/ui/select";
+import { maybeAddMarimoImport } from "@/core/cells/add-missing-import";
 import { useCellActions } from "@/core/cells/cells";
 import { useLastFocusedCellId } from "@/core/cells/focus";
+import { autoInstantiateAtom } from "@/core/config/config";
 import { ENV_RENDERER, SecretsProvider } from "./form-renderers";
 
 const RENDERERS: FormRenderer[] = [ENV_RENDERER];
@@ -106,8 +109,18 @@ export const ConnectionFormFooter = <L extends string>({
 export function useInsertCode() {
   const { createNewCell } = useCellActions();
   const lastFocusedCellId = useLastFocusedCellId();
+  const autoInstantiate = useAtomValue(autoInstantiateAtom);
 
   return (code: string) => {
+    // Ensure `mo` is importable when the generated code references it
+    if (/\bmo\./.test(code)) {
+      maybeAddMarimoImport({
+        autoInstantiate,
+        createNewCell,
+        fromCellId: lastFocusedCellId,
+      });
+    }
+
     createNewCell({
       code,
       before: false,

package/src/components/editor/connections/storage/__tests__/__snapshots__/as-code.test.ts.snap

@@ -85,14 +85,14 @@ store = GCSStore("my-bucket")"
 exports[`generateStorageCode > Google Drive > with default auth (no credentials) 1`] = `
 "from gdrive_fsspec import GoogleDriveFileSystem
 
-fs = GoogleDriveFileSystem(use_listings_cache=False)"
+fs = GoogleDriveFileSystem(use_listings_cache=False, skip_instance_cache=True)"
 `;
 
 exports[`generateStorageCode > Google Drive > with embedded auth (no credentials) 1`] = `
 "from gdrive_fsspec import GoogleDriveFileSystem
 
-fs = GoogleDriveFileSystem(use_listings_cache=False, auth_kwargs={"use_local_webserver": False})
-print("Google Drive connected! Important: Run this cell again to clear the console")"
+fs = GoogleDriveFileSystem(use_listings_cache=False, skip_instance_cache=True, auth_kwargs={"use_local_webserver": False})
+mo.output.clear_console()"
 `;
 
 exports[`generateStorageCode > Google Drive > with service account credentials 1`] = `
@@ -100,7 +100,7 @@ exports[`generateStorageCode > Google Drive > with service account credentials 1
 import json
 
 _creds = json.loads("""{"type": "service_account", "client_email": "test@test.iam.gserviceaccount.com"}""")
-fs = GoogleDriveFileSystem(creds=_creds, token="service_account", use_listings_cache=False)"
+fs = GoogleDriveFileSystem(creds=_creds, token="service_account", use_listings_cache=False, skip_instance_cache=True)"
 `;
 
 exports[`generateStorageCode > S3 > basic connection with all fields 1`] = `