From d34f226b5e8342ef7e97373c73d52ecda3dce0d0 Mon Sep 17 00:00:00 2001
From: Ryan Zhang <zyratlo@gmail.com>
Date: Wed, 12 Aug 2026 12:26:11 -0700
Subject: [PATCH 01/10] feat(python-notebook-migration, frontend): add AI
 generate workflow entry point on the dashboard

---
 .../user-workflow.component.html              |  14 ++
 .../user-workflow.component.spec.ts           | 204 +++++++++++++++-
 .../user-workflow/user-workflow.component.ts  | 130 ++++++++++-
 .../notebook-import-modal.component.html      | 221 +++++++++---------
 .../notebook-import-modal.component.scss      |  43 +++-
 .../notebook-import-modal.component.spec.ts   |  93 +++++++-
 .../notebook-import-modal.component.ts        |  74 ++++--
 .../component/workspace.component.spec.ts     |  20 +-
 .../component/workspace.component.ts          |  12 +-
 .../jupyter-panel/jupyter-panel.service.ts    |  12 +-
 .../notebook-migration.service.spec.ts        |  60 ++++-
 .../notebook-migration.service.ts             |  51 +++-
 12 files changed, 776 insertions(+), 158 deletions(-)

diff --git a/frontend/src/app/dashboard/component/user/user-workflow/user-workflow.component.html b/frontend/src/app/dashboard/component/user/user-workflow/user-workflow.component.html
index 492efc53766..d945a21d36e 100644
--- a/frontend/src/app/dashboard/component/user/user-workflow/user-workflow.component.html
+++ b/frontend/src/app/dashboard/component/user/user-workflow/user-workflow.component.html
@@ -51,6 +51,20 @@ <h2 class="page-title">Workflows</h2>
               nzTheme="outline"></i>
           </button>
         </nz-upload>
+        <button
+          *ngIf="pythonNotebookMigrationEnabled"
+          [disabled]="accessLevel === 'READ'"
+          nz-button
+          (click)="openAiGenerateModal()"
+          title="AI generate a workflow from a Python notebook"
+          nz-tooltip="AI generate a workflow from a Python notebook"
+          nzTooltipPlacement="bottom"
+          type="button">
+          <i
+            nz-icon
+            nzType="robot"
+            nzTheme="outline"></i>
+        </button>
         <button
           *ngIf="multiWorkflowsOperationButtonEnabled()"
           (click)="toggleSelection()"
diff --git a/frontend/src/app/dashboard/component/user/user-workflow/user-workflow.component.spec.ts b/frontend/src/app/dashboard/component/user/user-workflow/user-workflow.component.spec.ts
index 64a305aadf7..d2bf07febc6 100644
--- a/frontend/src/app/dashboard/component/user/user-workflow/user-workflow.component.spec.ts
+++ b/frontend/src/app/dashboard/component/user/user-workflow/user-workflow.component.spec.ts
@@ -67,12 +67,17 @@ import { StubSearchService } from "../../../service/user/stub-search.service";
 import { SearchResultsComponent } from "../search-results/search-results.component";
 import { delay, firstValueFrom, of, throwError } from "rxjs";
 import JSZip from "jszip";
-import { NzModalService } from "ng-zorro-antd/modal";
+import { ModalOptions, NzModalRef, NzModalService } from "ng-zorro-antd/modal";
 import { NzButtonModule } from "ng-zorro-antd/button";
 import { DownloadService } from "../../../service/user/download/download.service";
 import { commonTestProviders } from "../../../../common/testing/test-utils";
 import { Router } from "@angular/router";
 import { USER_WORKSPACE } from "../../../../app-routing.constant";
+import { GuiConfigService } from "../../../../common/service/gui-config.service";
+import { MockGuiConfigService } from "../../../../common/service/gui-config.service.mock";
+import { NotebookMigrationService } from "../../../../workspace/service/notebook-migration/notebook-migration.service";
+import { NotebookImportModalComponent } from "../../../../workspace/component/notebook-import-modal/notebook-import-modal.component";
+import { NzUploadFile } from "ng-zorro-antd/upload";
 import type { Mocked } from "vitest";
 describe("SavedWorkflowSectionComponent", () => {
   let component: UserWorkflowComponent;
@@ -340,6 +345,203 @@ describe("SavedWorkflowSectionComponent", () => {
     });
   });
 
+  describe("AI generate workflow (dashboard entry point)", () => {
+    const ipynbFile = { name: "analysis.ipynb" } as NzUploadFile;
+    const AI_BUTTON_SELECTOR = 'button[title="AI generate a workflow from a Python notebook"]';
+
+    // Opens the modal and returns the requestImport callback the component handed to it; calling
+    // it runs the full generation (true => generation succeeded and navigated, false => stay open).
+    function getRequestImport(): (file: NzUploadFile, model: string) => Promise<boolean> {
+      const modalService = TestBed.inject(NzModalService);
+      const createSpy = vi.spyOn(modalService, "create").mockReturnValue({} as unknown as NzModalRef);
+      component.openAiGenerateModal();
+      const config = createSpy.mock.calls[0][0] as ModalOptions;
+      return (config.nzData as { requestImport: (file: NzUploadFile, model: string) => Promise<boolean> })
+        .requestImport;
+    }
+
+    // Wires the NotebookMigrationService + persistence mocks for a successful generation.
+    function mockGenerationSuccess(wid = 99) {
+      const migration = TestBed.inject(NotebookMigrationService);
+      vi.spyOn(migration, "parseAndTagNotebook").mockResolvedValue({ cells: [] } as any);
+      vi.spyOn(migration, "sendToAIGenerateWorkflow").mockResolvedValue({
+        workflowContent: { operators: [] },
+        mappingContent: { operator_to_cell: {}, cell_to_operator: {} },
+      } as any);
+      const storeSpy = vi.spyOn(migration, "storeNotebookAndMapping").mockReturnValue(of({ success: true }) as any);
+      const persist = TestBed.inject(WorkflowPersistService) as any;
+      persist.createWorkflow = vi.fn().mockReturnValue(of({ workflow: { wid } }));
+      return { storeSpy, persist };
+    }
+
+    it("openAiGenerateModal opens the NotebookImportModalComponent with a requestImport callback and no footer", () => {
+      const modalService = TestBed.inject(NzModalService);
+      const createSpy = vi.spyOn(modalService, "create").mockReturnValue({} as unknown as NzModalRef);
+
+      component.openAiGenerateModal();
+
+      expect(createSpy).toHaveBeenCalledTimes(1);
+      const config = createSpy.mock.calls[0][0] as ModalOptions;
+      expect(config.nzContent).toBe(NotebookImportModalComponent);
+      expect(config.nzFooter).toBeNull();
+      expect(typeof (config.nzData as { requestImport: unknown }).requestImport).toBe("function");
+    });
+
+    it("generates a workflow, stores the notebook and mapping, navigates with autolayout, and resolves true", async () => {
+      const { storeSpy, persist } = mockGenerationSuccess(99);
+      const navigateSpy = vi.spyOn(TestBed.inject(Router), "navigate").mockResolvedValue(true);
+      component.pid = undefined;
+
+      const proceed = await getRequestImport()(ipynbFile, "gpt-4");
+
+      expect(persist.createWorkflow).toHaveBeenCalledTimes(1);
+      // Name is derived from the notebook filename with the generated marker.
+      expect(persist.createWorkflow.mock.calls[0][1]).toBe("analysis_GENERATED_BY_LLM");
+      // The dashboard hands off the key + vid ownership to the service in one call.
+      expect(storeSpy).toHaveBeenCalledWith(99, expect.anything(), expect.anything());
+      expect(navigateSpy).toHaveBeenCalledWith([USER_WORKSPACE, 99], { queryParams: { autolayout: 1 } });
+      expect(proceed).toBe(true);
+    });
+
+    it("adds the new workflow to the current project when opened inside one", async () => {
+      mockGenerationSuccess(99);
+      vi.spyOn(TestBed.inject(Router), "navigate").mockResolvedValue(true);
+      const projectService = TestBed.inject(UserProjectService) as any;
+      const addSpy = vi.spyOn(projectService, "addWorkflowToProject").mockReturnValue(of(undefined));
+      component.pid = 5;
+
+      const proceed = await getRequestImport()(ipynbFile, "gpt-4");
+
+      expect(addSpy).toHaveBeenCalledWith(5, 99);
+      expect(proceed).toBe(true);
+    });
+
+    it("rejects a non-ipynb file: errors, resolves false, and generates nothing", async () => {
+      const parseSpy = vi.spyOn(TestBed.inject(NotebookMigrationService), "parseAndTagNotebook");
+      const errorSpy = vi.spyOn(TestBed.inject(NotificationService), "error").mockImplementation(() => {});
+
+      const proceed = await getRequestImport()({ name: "data.txt" } as NzUploadFile, "gpt-4");
+
+      expect(proceed).toBe(false);
+      expect(errorSpy).toHaveBeenCalledWith("Please upload a valid Jupyter Notebook (.ipynb) file.");
+      expect(parseSpy).not.toHaveBeenCalled();
+    });
+
+    it("reports a parse failure and resolves false without calling the LLM", async () => {
+      const migration = TestBed.inject(NotebookMigrationService);
+      vi.spyOn(migration, "parseAndTagNotebook").mockRejectedValue(new Error("bad json"));
+      const llmSpy = vi.spyOn(migration, "sendToAIGenerateWorkflow");
+      const errorSpy = vi.spyOn(TestBed.inject(NotificationService), "error").mockImplementation(() => {});
+
+      const proceed = await getRequestImport()(ipynbFile, "gpt-4");
+
+      expect(proceed).toBe(false);
+      expect(errorSpy).toHaveBeenCalledWith("Failed to read the notebook file. Please upload a valid .ipynb file.");
+      expect(llmSpy).not.toHaveBeenCalled();
+    });
+
+    it("reports an LLM failure and resolves false without creating a workflow", async () => {
+      const migration = TestBed.inject(NotebookMigrationService);
+      vi.spyOn(migration, "parseAndTagNotebook").mockResolvedValue({ cells: [] } as any);
+      vi.spyOn(migration, "sendToAIGenerateWorkflow").mockRejectedValue(new Error("LLM down"));
+      const persist = TestBed.inject(WorkflowPersistService) as any;
+      persist.createWorkflow = vi.fn();
+      const errorSpy = vi.spyOn(TestBed.inject(NotificationService), "error").mockImplementation(() => {});
+
+      const proceed = await getRequestImport()(ipynbFile, "gpt-4");
+
+      expect(proceed).toBe(false);
+      expect(errorSpy).toHaveBeenCalledWith("Error while communicating with the LLM, check console for details.");
+      expect(persist.createWorkflow).not.toHaveBeenCalled();
+    });
+
+    it("reports a save failure and resolves false when the created workflow has no wid", async () => {
+      const migration = TestBed.inject(NotebookMigrationService);
+      vi.spyOn(migration, "parseAndTagNotebook").mockResolvedValue({ cells: [] } as any);
+      vi.spyOn(migration, "sendToAIGenerateWorkflow").mockResolvedValue({
+        workflowContent: {},
+        mappingContent: {},
+      } as any);
+      const storeSpy = vi.spyOn(migration, "storeNotebookAndMapping");
+      const persist = TestBed.inject(WorkflowPersistService) as any;
+      persist.createWorkflow = vi.fn().mockReturnValue(of({ workflow: {} }));
+      const errorSpy = vi.spyOn(TestBed.inject(NotificationService), "error").mockImplementation(() => {});
+
+      const proceed = await getRequestImport()(ipynbFile, "gpt-4");
+
+      expect(proceed).toBe(false);
+      expect(errorSpy).toHaveBeenCalledWith("Failed to save the generated workflow, check console for details.");
+      expect(storeSpy).not.toHaveBeenCalled();
+    });
+
+    it("still opens the workflow when adding it to the project fails (best effort)", async () => {
+      mockGenerationSuccess(99);
+      const navigateSpy = vi.spyOn(TestBed.inject(Router), "navigate").mockResolvedValue(true);
+      const projectService = TestBed.inject(UserProjectService) as any;
+      vi.spyOn(projectService, "addWorkflowToProject").mockReturnValue(throwError(() => new Error("project down")));
+      component.pid = 5;
+
+      const proceed = await getRequestImport()(ipynbFile, "gpt-4");
+
+      expect(navigateSpy).toHaveBeenCalledWith([USER_WORKSPACE, 99], { queryParams: { autolayout: 1 } });
+      expect(proceed).toBe(true);
+    });
+
+    it("warns but still opens the workflow when storing the notebook fails (no re-generation)", async () => {
+      const { storeSpy, persist } = mockGenerationSuccess(99);
+      storeSpy.mockReturnValue(throwError(() => new Error("store down")) as any);
+      const navigateSpy = vi.spyOn(TestBed.inject(Router), "navigate").mockResolvedValue(true);
+      const warnSpy = vi.spyOn(TestBed.inject(NotificationService), "warning").mockImplementation(() => {});
+      component.pid = undefined;
+
+      const proceed = await getRequestImport()(ipynbFile, "gpt-4");
+
+      // The created workflow is kept and opened; the LLM call is not re-run.
+      expect(persist.createWorkflow).toHaveBeenCalledTimes(1);
+      expect(warnSpy).toHaveBeenCalledWith(
+        "Workflow created, but the notebook could not be attached; the Jupyter panel may not open."
+      );
+      expect(navigateSpy).toHaveBeenCalledWith([USER_WORKSPACE, 99], { queryParams: { autolayout: 1 } });
+      expect(proceed).toBe(true);
+    });
+
+    it("warns but resolves true when navigation is blocked after the workflow is created", async () => {
+      mockGenerationSuccess(99);
+      vi.spyOn(TestBed.inject(Router), "navigate").mockRejectedValue(new Error("blocked"));
+      const warnSpy = vi.spyOn(TestBed.inject(NotificationService), "warning").mockImplementation(() => {});
+      component.pid = undefined;
+
+      const proceed = await getRequestImport()(ipynbFile, "gpt-4");
+
+      expect(warnSpy).toHaveBeenCalledWith("Workflow created. You can open it from your dashboard.");
+      expect(proceed).toBe(true);
+    });
+
+    it("shows the button only when the migration flag is enabled", () => {
+      expect(fixture.nativeElement.querySelector(AI_BUTTON_SELECTOR)).toBeNull();
+
+      (TestBed.inject(GuiConfigService) as unknown as MockGuiConfigService).setConfig({
+        pythonNotebookMigrationEnabled: true,
+      });
+      fixture.detectChanges();
+
+      expect(fixture.nativeElement.querySelector(AI_BUTTON_SELECTOR)).not.toBeNull();
+    });
+
+    it("clicking the toolbar button opens the AI generate modal", () => {
+      (TestBed.inject(GuiConfigService) as unknown as MockGuiConfigService).setConfig({
+        pythonNotebookMigrationEnabled: true,
+      });
+      fixture.detectChanges();
+      const openSpy = vi.spyOn(component, "openAiGenerateModal").mockImplementation(() => {});
+
+      const button = fixture.nativeElement.querySelector(AI_BUTTON_SELECTOR) as HTMLButtonElement;
+      button.click();
+
+      expect(openSpy).toHaveBeenCalled();
+    });
+  });
+
   it("downloads checked files", async () => {
     // If multiple workflows in a single batch download have name conflicts, rename them as workflow-1, workflow-2, etc.
     component.searchResultsComponent.entries = component.searchResultsComponent.entries.concat(
diff --git a/frontend/src/app/dashboard/component/user/user-workflow/user-workflow.component.ts b/frontend/src/app/dashboard/component/user/user-workflow/user-workflow.component.ts
index e46582ea1d0..c90c595329e 100644
--- a/frontend/src/app/dashboard/component/user/user-workflow/user-workflow.component.ts
+++ b/frontend/src/app/dashboard/component/user/user-workflow/user-workflow.component.ts
@@ -46,6 +46,15 @@ import { DashboardWorkflow } from "../../../type/dashboard-workflow.interface";
 import { DownloadService } from "../../../service/user/download/download.service";
 import { USER_WORKSPACE } from "../../../../app-routing.constant";
 import { GuiConfigService } from "../../../../common/service/gui-config.service";
+import {
+  MappingContent,
+  NotebookMigrationService,
+} from "../../../../workspace/service/notebook-migration/notebook-migration.service";
+import { Notebook } from "../../../../workspace/service/notebook-migration/migration-llm";
+import {
+  NotebookImportModalComponent,
+  NotebookImportModalData,
+} from "../../../../workspace/component/notebook-import-modal/notebook-import-modal.component";
 import { NzCardComponent } from "ng-zorro-antd/card";
 import { NzSpaceCompactItemDirective, NzSpaceCompactComponent } from "ng-zorro-antd/space";
 import { NzButtonComponent } from "ng-zorro-antd/button";
@@ -157,7 +166,8 @@ export class UserWorkflowComponent implements AfterViewInit {
     private router: Router,
     private downloadService: DownloadService,
     private searchService: SearchService,
-    private config: GuiConfigService
+    private config: GuiConfigService,
+    private notebookMigrationService: NotebookMigrationService
   ) {
     this.userService
       .userChanged()
@@ -312,6 +322,117 @@ export class UserWorkflowComponent implements AfterViewInit {
       });
   }
 
+  public get pythonNotebookMigrationEnabled(): boolean {
+    return this.config.env.pythonNotebookMigrationEnabled;
+  }
+
+  /**
+   * Open the AI-generate import modal from the dashboard. The modal collects the notebook file and
+   * model and shows a loading state while generation runs (the requestImport callback below).
+   */
+  public openAiGenerateModal(): void {
+    this.modalService.create<NotebookImportModalComponent, NotebookImportModalData>({
+      nzTitle: "AI Generate Workflow from Python Notebook",
+      nzContent: NotebookImportModalComponent,
+      nzWidth: 700,
+      nzFooter: null,
+      nzCentered: true,
+      nzData: {
+        requestImport: (file, model) => this.generateWorkflowFromNotebook(file, model),
+      },
+    });
+  }
+
+  /**
+   * Generate a workflow from the uploaded notebook and open it. Runs entirely on the dashboard while
+   * the modal shows a loading state: parse the notebook, send it to the LLM, save the result as a new
+   * workflow, store the notebook and cell mapping, then navigate to the new workflow. The workspace
+   * lays the generated operators out (via the autolayout query param) and opens the notebook panel
+   * (driven by the workflow id). Resolves true so the modal closes on success, or false (leaving the
+   * modal open with the selection intact) when the file is not a notebook or generation fails.
+   */
+  private async generateWorkflowFromNotebook(file: NzUploadFile, model: string): Promise<boolean> {
+    const fileExtension = file.name.split(".").pop()?.toLowerCase();
+    if (fileExtension !== "ipynb") {
+      this.notificationService.error("Please upload a valid Jupyter Notebook (.ipynb) file.");
+      return false;
+    }
+    let notebook: Notebook;
+    try {
+      notebook = await this.notebookMigrationService.parseAndTagNotebook(file as unknown as File);
+    } catch (error) {
+      this.notificationService.error("Failed to read the notebook file. Please upload a valid .ipynb file.");
+      console.error("Notebook parse failed:", error);
+      return false;
+    }
+
+    let generated: { workflowContent: WorkflowContent; mappingContent: MappingContent };
+    try {
+      generated = await this.notebookMigrationService.sendToAIGenerateWorkflow(notebook, model);
+    } catch (error) {
+      this.notificationService.error("Error while communicating with the LLM, check console for details.");
+      console.error("LLM generation failed:", error);
+      return false;
+    }
+
+    // Create the workflow. This is the commit point: persisting captures the expensive LLM
+    // result. If it fails nothing was created, so returning false (letting the user retry) is safe.
+    let wid: number;
+    try {
+      const createdWorkflow = await firstValueFrom(
+        this.workflowPersistService.createWorkflow(
+          generated.workflowContent,
+          this.deriveWorkflowName(file.name) + "_GENERATED_BY_LLM"
+        )
+      );
+      if (!createdWorkflow.workflow.wid) {
+        throw new Error("Created workflow has no wid.");
+      }
+      wid = createdWorkflow.workflow.wid;
+    } catch (error) {
+      this.notificationService.error("Failed to save the generated workflow, check console for details.");
+      console.error("Saving the generated workflow failed:", error);
+      return false;
+    }
+
+    // Past the commit point the follow-up steps are best-effort: a transient failure must not
+    // discard the created workflow or the LLM result, so we log/warn and still open the workflow
+    // rather than force a full re-generation.
+    if (this.pid) {
+      try {
+        await firstValueFrom(this.userProjectService.addWorkflowToProject(this.pid, wid));
+      } catch (error) {
+        console.error("Adding the generated workflow to the project failed:", error);
+      }
+    }
+    try {
+      await firstValueFrom(
+        this.notebookMigrationService.storeNotebookAndMapping(wid, generated.mappingContent, notebook)
+      );
+    } catch (error) {
+      this.notificationService.warning(
+        "Workflow created, but the notebook could not be attached; the Jupyter panel may not open."
+      );
+      console.error("Storing the notebook and mapping failed:", error);
+    }
+
+    const navigated = await this.router
+      .navigate([USER_WORKSPACE, wid], { queryParams: { autolayout: 1 } })
+      .catch(() => false);
+    if (!navigated) {
+      this.notificationService.warning("Workflow created. You can open it from your dashboard.");
+    }
+    return true;
+  }
+
+  // Strips the extension from an uploaded file name, falling back to DEFAULT_WORKFLOW_NAME when the
+  // result is empty. Shared by the file-upload and AI-generate flows to name the created workflow.
+  private deriveWorkflowName(fileName: string): string {
+    const extensionIndex = fileName.lastIndexOf(".");
+    const baseName = extensionIndex === -1 ? fileName : fileName.substring(0, extensionIndex);
+    return baseName.trim() === "" ? DEFAULT_WORKFLOW_NAME : baseName;
+  }
+
   /**
    * duplicate the current workflow. A new record will appear in frontend
    * workflow list and backend database.
@@ -444,13 +565,8 @@ export class UserWorkflowComponent implements AfterViewInit {
             throw new Error("Incorrect format: file is not a string");
           }
           const workflowContent = JSON.parse(result) as WorkflowContent;
-          const fileExtensionIndex = name.lastIndexOf(".");
-          let workflowName = fileExtensionIndex === -1 ? name : name.substring(0, fileExtensionIndex);
-          if (workflowName.trim() === "") {
-            workflowName = DEFAULT_WORKFLOW_NAME;
-          }
           this.workflowPersistService
-            .createWorkflow(workflowContent, workflowName)
+            .createWorkflow(workflowContent, this.deriveWorkflowName(name))
             .pipe(untilDestroyed(this))
             .subscribe({
               next: uploadedWorkflow => {
diff --git a/frontend/src/app/workspace/component/notebook-import-modal/notebook-import-modal.component.html b/frontend/src/app/workspace/component/notebook-import-modal/notebook-import-modal.component.html
index 4e6a3d60378..4edfc7dbe02 100644
--- a/frontend/src/app/workspace/component/notebook-import-modal/notebook-import-modal.component.html
+++ b/frontend/src/app/workspace/component/notebook-import-modal/notebook-import-modal.component.html
@@ -17,122 +17,131 @@
  under the License.
 -->
 
-<form
-  class="import-modal-form"
-  [formGroup]="importForm"
-  nz-form>
-  <div class="import-modal-diagram">
-    <img
-      ngSrc="assets/notebook_migration_tool/tool_popup_diagram.png"
-      alt="Notebook to Workflow"
-      width="1132"
-      height="290" />
-  </div>
+<div class="import-modal-diagram">
+  <img
+    ngSrc="assets/notebook_migration_tool/tool_popup_diagram.png"
+    alt="Notebook to Workflow"
+    width="1132"
+    height="290" />
+</div>
 
-  <nz-alert
-    class="import-modal-warning"
-    nzType="warning"
-    nzShowIcon
-    nzMessage="Generating overwrites your current workflow; the previous version is kept in version history."></nz-alert>
+<div class="import-modal-content">
+  <form
+    class="import-modal-form"
+    [formGroup]="importForm"
+    nz-form>
+    <nz-form-item>
+      <p class="import-modal-text">
+        This tool converts a Python Jupyter Notebook into a Texera workflow using LLM capabilities. After you submit a
+        notebook, the LLM service generates a corresponding Texera workflow. The conversion time depends on the
+        notebook's complexity and can take 1-5 minutes. Once generation finishes, you are taken to the new workflow,
+        which opens with:
+      </p>
+      <ol class="import-modal-list">
+        <li>
+          The generated workflow ready to use (Note: you will still need to upload the dataset and connect it to the
+          workflow).
+        </li>
+        <li>A floating Jupyter window containing the uploaded notebook for reference.</li>
+      </ol>
+      <p class="import-modal-text">
+        Generation runs here after you submit. Please keep this window open while you wait.
+      </p>
+    </nz-form-item>
 
-  <nz-form-item>
-    <p class="import-modal-text">
-      This tool converts a Python Jupyter Notebook into a Texera workflow using LLM capabilities. After you submit a
-      notebook, the LLM service will generate a corresponding Texera workflow. The conversion time depends on the
-      notebook’s complexity and can take 1–5 minutes. Once the process is complete, the workflow workspace will reload
-      with:
-    </p>
-    <ol class="import-modal-list">
-      <li>
-        The generated workflow ready to use (Note: you will still need to upload the dataset and connect it to the
-        workflow).
-      </li>
-      <li>A floating Jupyter window containing the uploaded notebook for reference.</li>
-    </ol>
-    <p class="import-modal-text">
-      Feel free to navigate away from this tab while you wait for the workflow to generate. Please do not close the
-      window.
-    </p>
-  </nz-form-item>
+    <nz-form-item>
+      <nz-form-label [nzNoColon]="true">
+        <span class="import-modal-label"> Upload Python Jupyter Notebook </span>
+      </nz-form-label>
+      <nz-form-control>
+        <div class="import-modal-upload-row">
+          <nz-upload
+            nzAccept=".ipynb"
+            [nzBeforeUpload]="beforeUpload"
+            [nzShowUploadList]="false">
+            <button
+              nz-button
+              type="button"
+              title="Upload notebook"
+              aria-label="Upload notebook">
+              <i
+                nz-icon
+                nzType="upload"></i>
+            </button>
+          </nz-upload>
 
-  <nz-form-item>
-    <nz-form-label [nzNoColon]="true">
-      <span class="import-modal-label"> Upload Python Jupyter Notebook </span>
-    </nz-form-label>
-    <nz-form-control>
-      <div class="import-modal-upload-row">
-        <nz-upload
-          nzAccept=".ipynb"
-          [nzBeforeUpload]="beforeUpload"
-          [nzShowUploadList]="false">
-          <button
-            nz-button
-            type="button"
-            title="Upload notebook"
-            aria-label="Upload notebook">
-            <i
-              nz-icon
-              nzType="upload"></i>
-          </button>
-        </nz-upload>
+          <span *ngIf="importForm.get('file')?.value?.name">
+            Selected file: {{ importForm.get('file')?.value?.name }}
+          </span>
+        </div>
+      </nz-form-control>
+    </nz-form-item>
 
-        <span *ngIf="importForm.get('file')?.value?.name">
-          Selected file: {{ importForm.get('file')?.value?.name }}
-        </span>
-      </div>
-    </nz-form-control>
-  </nz-form-item>
+    <nz-form-item>
+      <nz-form-label [nzNoColon]="true">
+        <span class="import-modal-label"> Select Model Type </span>
+      </nz-form-label>
 
-  <nz-form-item>
-    <nz-form-label [nzNoColon]="true">
-      <span class="import-modal-label"> Select Model Type </span>
-    </nz-form-label>
+      <nz-form-control>
+        <ng-container *ngIf="models$ | async as models; else loadingTpl">
+          <nz-select
+            *ngIf="models.length > 0; else noModelsTpl"
+            class="import-modal-select"
+            formControlName="model"
+            nzPlaceHolder="Select a model">
+            <nz-option
+              *ngFor="let model of models"
+              [nzValue]="model.name"
+              [nzLabel]="model.name"></nz-option>
+          </nz-select>
+          <ng-template #noModelsTpl>
+            <nz-select
+              class="import-modal-select"
+              nzPlaceHolder="No models available"
+              [nzDisabled]="true"></nz-select>
+          </ng-template>
+        </ng-container>
 
-    <nz-form-control>
-      <ng-container *ngIf="models$ | async as models; else loadingTpl">
-        <nz-select
-          *ngIf="models.length > 0; else noModelsTpl"
-          class="import-modal-select"
-          formControlName="model"
-          nzPlaceHolder="Select a model">
-          <nz-option
-            *ngFor="let model of models"
-            [nzValue]="model.name"
-            [nzLabel]="model.name"></nz-option>
-        </nz-select>
-        <ng-template #noModelsTpl>
+        <ng-template #loadingTpl>
           <nz-select
             class="import-modal-select"
-            nzPlaceHolder="No models available"
+            nzPlaceHolder="Loading models..."
+            [nzLoading]="true"
             [nzDisabled]="true"></nz-select>
         </ng-template>
-      </ng-container>
+      </nz-form-control>
+    </nz-form-item>
+  </form>
 
-      <ng-template #loadingTpl>
-        <nz-select
-          class="import-modal-select"
-          nzPlaceHolder="Loading models..."
-          [nzLoading]="true"
-          [nzDisabled]="true"></nz-select>
-      </ng-template>
-    </nz-form-control>
-  </nz-form-item>
-</form>
+  <div class="import-modal-footer">
+    <button
+      nz-button
+      type="button"
+      [disabled]="isSubmitting"
+      (click)="onCancel()">
+      Cancel
+    </button>
+    <button
+      nz-button
+      type="button"
+      nzType="primary"
+      [disabled]="!importForm.valid || isSubmitting"
+      (click)="onSubmit()">
+      Submit
+    </button>
+  </div>
 
-<div class="import-modal-footer">
-  <button
-    nz-button
-    type="button"
-    [disabled]="isSubmitting"
-    (click)="onCancel()">
-    Cancel
-  </button>
-  <button
-    nz-button
-    type="button"
-    nzType="primary"
-    [disabled]="!importForm.valid || isSubmitting"
-    (click)="onSubmit()">
-    Submit
-  </button>
+  <div
+    *ngIf="isSubmitting"
+    class="import-modal-loading">
+    <nz-spin
+      nzSimple
+      [nzSize]="'large'"></nz-spin>
+    <p class="import-modal-loading-title">Generating your workflow</p>
+    <p class="import-modal-loading-elapsed">Elapsed time: {{ formattedElapsedTime }}</p>
+    <p class="import-modal-loading-text">This can take 1-5 minutes depending on the notebook's complexity.</p>
+    <p class="import-modal-loading-text">
+      Please keep this window open. You will be taken to the new workflow when it is ready.
+    </p>
+  </div>
 </div>
diff --git a/frontend/src/app/workspace/component/notebook-import-modal/notebook-import-modal.component.scss b/frontend/src/app/workspace/component/notebook-import-modal/notebook-import-modal.component.scss
index 2f898489821..d5d60d1a345 100644
--- a/frontend/src/app/workspace/component/notebook-import-modal/notebook-import-modal.component.scss
+++ b/frontend/src/app/workspace/component/notebook-import-modal/notebook-import-modal.component.scss
@@ -70,9 +70,46 @@
     width: 50%;
   }
 
-  &-warning {
-    display: block;
-    margin-bottom: 12px;
+  // Wraps the form and footer so the loading overlay can cover them without changing the
+  // modal's height (which would otherwise resize and re-center the centered modal on submit).
+  &-content {
+    position: relative;
+  }
+
+  &-loading {
+    position: absolute;
+    inset: 0;
+    z-index: 1;
+    // Solid background so the form and footer underneath are fully hidden.
+    background-color: #fff;
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    gap: 14px;
+    padding: 16px 24px 28px;
+    text-align: center;
+  }
+
+  &-loading-title {
+    margin: 8px 0 0;
+    font-size: 20px;
+    font-weight: 700;
+  }
+
+  &-loading-elapsed {
+    margin: 0;
+    font-size: 18px;
+    font-weight: 600;
+    font-variant-numeric: tabular-nums;
+  }
+
+  &-loading-text {
+    margin: 0;
+    max-width: 480px;
+    font-size: 16px;
+    line-height: 1.5;
+    color: rgba(0, 0, 0, 0.65);
   }
 
   &-footer {
diff --git a/frontend/src/app/workspace/component/notebook-import-modal/notebook-import-modal.component.spec.ts b/frontend/src/app/workspace/component/notebook-import-modal/notebook-import-modal.component.spec.ts
index eb6d199bd17..6587a89057b 100644
--- a/frontend/src/app/workspace/component/notebook-import-modal/notebook-import-modal.component.spec.ts
+++ b/frontend/src/app/workspace/component/notebook-import-modal/notebook-import-modal.component.spec.ts
@@ -32,7 +32,7 @@ describe("NotebookImportModalComponent", () => {
   let fixture: ComponentFixture<NotebookImportModalComponent>;
   let component: NotebookImportModalComponent;
   let notebookMigrationService: NotebookMigrationService;
-  let modalRef: { close: ReturnType<typeof vi.fn> };
+  let modalRef: { close: ReturnType<typeof vi.fn>; updateConfig: ReturnType<typeof vi.fn> };
   // The opener-supplied gate; tests set its resolved value to drive close vs stay-open.
   let requestImport: ReturnType<typeof vi.fn>;
 
@@ -56,19 +56,28 @@ describe("NotebookImportModalComponent", () => {
   }
 
   beforeEach(() => {
-    modalRef = { close: vi.fn() };
+    modalRef = { close: vi.fn(), updateConfig: vi.fn() };
     requestImport = vi.fn().mockResolvedValue(true);
   });
 
-  it("renders the warning, diagram, and a usable model select once models load", async () => {
+  it("renders the diagram and a usable model select once models load", async () => {
     await createWith(of([{ name: "gpt-4" }]));
     const root = fixture.nativeElement as HTMLElement;
-    expect(root.querySelector(".import-modal-warning")).not.toBeNull();
     expect(root.querySelector("img[alt='Notebook to Workflow']")).not.toBeNull();
     expect(root.querySelector("nz-select")).not.toBeNull();
     expect(root.textContent).toContain("Select a model");
   });
 
+  it("shows the loading spinner only while a submission is in flight", async () => {
+    await createWith(of([{ name: "gpt-4" }]));
+    const spinning = () => (fixture.nativeElement as HTMLElement).querySelector(".ant-spin-spinning") !== null;
+    expect(spinning()).toBe(false);
+
+    component.isSubmitting = true;
+    fixture.detectChanges();
+    expect(spinning()).toBe(true);
+  });
+
   it("shows the disabled 'no models available' select when the list is empty", async () => {
     await createWith(of([]));
     expect((fixture.nativeElement as HTMLElement).textContent).toContain("No models available");
@@ -125,7 +134,7 @@ describe("NotebookImportModalComponent", () => {
   });
 
   it("onSubmit keeps the modal open when the opener declines", async () => {
-    // e.g. the user backed out of the overwrite confirmation.
+    // e.g. generation failed and the user can retry.
     requestImport.mockResolvedValue(false);
     await createWith(of([{ name: "gpt-4" }]));
     component.importForm.setValue({ file: { name: "x.ipynb" } as NzUploadFile, model: "gpt-4" });
@@ -136,6 +145,80 @@ describe("NotebookImportModalComponent", () => {
     expect(modalRef.close).not.toHaveBeenCalled();
   });
 
+  it("locks the modal shut while generating and restores the close controls on failure", async () => {
+    let resolveRequest!: (proceed: boolean) => void;
+    requestImport.mockReturnValue(new Promise<boolean>(resolve => (resolveRequest = resolve)));
+    await createWith(of([{ name: "gpt-4" }]));
+    component.importForm.setValue({ file: { name: "x.ipynb" } as NzUploadFile, model: "gpt-4" });
+
+    const submitting = component.onSubmit();
+    // While generation is pending, the X, mask click, and ESC are disabled.
+    expect(modalRef.updateConfig).toHaveBeenCalledWith({
+      nzClosable: false,
+      nzMaskClosable: false,
+      nzKeyboard: false,
+    });
+
+    resolveRequest(false); // generation failed
+    await submitting;
+    // The modal stayed open, so the close controls are restored.
+    expect(modalRef.updateConfig).toHaveBeenLastCalledWith({
+      nzClosable: true,
+      nzMaskClosable: true,
+      nzKeyboard: true,
+    });
+    expect(modalRef.close).not.toHaveBeenCalled();
+  });
+
+  it("computes the elapsed time from the start timestamp as mm:ss", async () => {
+    await createWith(of([{ name: "gpt-4" }]));
+    // No generation started yet -> no start timestamp -> zero.
+    expect(component.formattedElapsedTime).toBe("0:00");
+    (component as any).startTime = 1000;
+    vi.spyOn(Date, "now").mockReturnValue(1000 + 62_000);
+    expect(component.formattedElapsedTime).toBe("1:02");
+  });
+
+  it("runs the stopwatch off wall-clock time while generating and stops the interval when done", async () => {
+    let resolveRequest!: (proceed: boolean) => void;
+    requestImport.mockReturnValue(new Promise<boolean>(resolve => (resolveRequest = resolve)));
+    await createWith(of([{ name: "gpt-4" }]));
+    component.importForm.setValue({ file: { name: "x.ipynb" } as NzUploadFile, model: "gpt-4" });
+
+    vi.useFakeTimers();
+    try {
+      vi.setSystemTime(new Date(0));
+      const submitting = component.onSubmit();
+      expect(component.formattedElapsedTime).toBe("0:00");
+
+      // Advancing the clock (even if the interval were throttled) yields the correct elapsed time.
+      vi.advanceTimersByTime(75_000);
+      expect(component.formattedElapsedTime).toBe("1:15");
+
+      resolveRequest(false);
+      await submitting;
+      expect((component as any).timerHandle).toBeNull();
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it("has a visibilitychange handler that is safe to call (repaint is driven by the zone event)", async () => {
+    await createWith(of([{ name: "gpt-4" }]));
+    expect(() => component.onVisibilityChange()).not.toThrow();
+  });
+
+  it("clears the stopwatch interval on destroy", async () => {
+    await createWith(of([{ name: "gpt-4" }]));
+    const clearSpy = vi.spyOn(globalThis, "clearInterval");
+    (component as any).timerHandle = setInterval(() => {}, 1000);
+
+    component.ngOnDestroy();
+
+    expect(clearSpy).toHaveBeenCalled();
+    expect((component as any).timerHandle).toBeNull();
+  });
+
   it("ignores a second submit while the first is still pending", async () => {
     // A pending requestImport models the opener still showing its overwrite confirmation.
     let resolveRequest!: (proceed: boolean) => void;
diff --git a/frontend/src/app/workspace/component/notebook-import-modal/notebook-import-modal.component.ts b/frontend/src/app/workspace/component/notebook-import-modal/notebook-import-modal.component.ts
index 70ee5745d1e..7a47da759fa 100644
--- a/frontend/src/app/workspace/component/notebook-import-modal/notebook-import-modal.component.ts
+++ b/frontend/src/app/workspace/component/notebook-import-modal/notebook-import-modal.component.ts
@@ -17,7 +17,7 @@
  * under the License.
  */
 
-import { Component, inject } from "@angular/core";
+import { Component, HostListener, inject, OnDestroy } from "@angular/core";
 import { FormBuilder, FormGroup, Validators, ReactiveFormsModule } from "@angular/forms";
 import { NZ_MODAL_DATA, NzModalRef } from "ng-zorro-antd/modal";
 import { NzUploadComponent, NzUploadFile } from "ng-zorro-antd/upload";
@@ -25,26 +25,25 @@ import { Observable } from "rxjs";
 import { AsyncPipe, NgIf, NgFor, NgOptimizedImage } from "@angular/common";
 import { NzFormModule } from "ng-zorro-antd/form";
 import { NzSelectModule } from "ng-zorro-antd/select";
-import { NzAlertModule } from "ng-zorro-antd/alert";
+import { NzSpinComponent } from "ng-zorro-antd/spin";
 import { NzButtonComponent } from "ng-zorro-antd/button";
 import { NzIconDirective } from "ng-zorro-antd/icon";
 import { NotebookMigrationService } from "../../service/notebook-migration/notebook-migration.service";
 
-// Passed in via nzData. The modal delegates "may I proceed?" to the opener so the
-// opener can keep the overwrite-confirm and generation logic (and the workflow state it
-// needs) without the modal knowing about them. Resolve true to close the modal (the
-// import has started), false to keep it open with the user's selection intact.
+// Passed in via nzData. The modal hands the selected file and model to the opener, which runs the
+// generation and persistence. The modal shows a loading state while this promise is pending.
+// Resolve true to close the modal (generation succeeded and the opener navigated away), false to
+// keep it open with the user's selection intact (bad file or a failure the user can retry).
 export interface NotebookImportModalData {
   requestImport: (file: NzUploadFile, model: string) => Promise<boolean>;
 }
 
 /**
  * The "AI Generate Workflow from Python Notebook" modal body. It owns the upload form and
- * the three model-dropdown states (loading / has models / none). On Submit it delegates the
- * decision to proceed to its opener via the requestImport callback (passed in through
- * nzData); the opener runs the overwrite-confirm and generation pipeline and the modal
- * closes itself only when that resolves true. Mirrors the component-as-nzContent pattern
- * used by the other modals opened from the menu (ResultExportationComponent, ...).
+ * the three model-dropdown states (loading / has models / none). On Submit it hands the file
+ * and model to its opener via the requestImport callback (passed in through nzData) and shows a
+ * loading state while generation runs, closing itself only when that resolves true. Mirrors the
+ * component-as-nzContent pattern used by the other modals opened from the menu.
  */
 @Component({
   selector: "texera-notebook-import-modal",
@@ -58,13 +57,13 @@ export interface NotebookImportModalData {
     ReactiveFormsModule,
     NzFormModule,
     NzSelectModule,
-    NzAlertModule,
+    NzSpinComponent,
     NzUploadComponent,
     NzButtonComponent,
     NzIconDirective,
   ],
 })
-export class NotebookImportModalComponent {
+export class NotebookImportModalComponent implements OnDestroy {
   private readonly fb = inject(FormBuilder);
   private readonly modalRef = inject(NzModalRef);
   private readonly notebookMigrationService = inject(NotebookMigrationService);
@@ -90,24 +89,63 @@ export class NotebookImportModalComponent {
     this.modalRef.close();
   }
 
-  // Guards against a second submit while the opener callback (which may show an
-  // overwrite confirmation) is still pending, so a double-click cannot start two imports.
+  // True while generation is running. Guards against a second submit and drives the loading
+  // spinner shown over the form.
   public isSubmitting = false;
+  private startTime: number | null = null;
+  private timerHandle: ReturnType<typeof setInterval> | null = null;
+
+  public ngOnDestroy(): void {
+    this.stopTimer();
+  }
+
+  public get formattedElapsedTime(): string {
+    const diffMs = this.startTime === null ? 0 : Date.now() - this.startTime;
+    const totalSeconds = Math.floor(diffMs / 1000);
+    const minutes = Math.floor(totalSeconds / 60);
+    const seconds = totalSeconds % 60;
+    return `${minutes}:${seconds.toString().padStart(2, "0")}`;
+  }
+
+  // Empty on purpose: with default change detection, the visibilitychange event firing in the
+  // Angular zone is itself what triggers a repaint, so the stopwatch catches up immediately when
+  // the user returns to a backgrounded tab. The handler body is irrelevant.
+  @HostListener("document:visibilitychange")
+  public onVisibilityChange(): void {}
+
+  private startTimer(): void {
+    this.stopTimer();
+    this.startTime = Date.now();
+    // The interval body is intentionally empty: the elapsed value is computed from startTime, and
+    // with default change detection the zone-patched timer firing is what repaints it each second.
+    this.timerHandle = setInterval(() => {}, 1000);
+  }
+
+  private stopTimer(): void {
+    if (this.timerHandle !== null) {
+      clearInterval(this.timerHandle);
+      this.timerHandle = null;
+    }
+  }
 
   public async onSubmit(): Promise<void> {
     if (this.isSubmitting || !this.importForm.valid) return;
     const file: NzUploadFile = this.importForm.get("file")?.value;
     const model: string = this.importForm.get("model")?.value;
     this.isSubmitting = true;
+    this.startTimer();
+    this.modalRef.updateConfig({ nzClosable: false, nzMaskClosable: false, nzKeyboard: false });
     try {
-      // Ask the opener whether to proceed; close only if it does, so cancelling the
-      // overwrite-confirm leaves this modal open with the selection preserved.
+      // Run generation via the opener; close only if it succeeds, so a failure leaves this modal
+      // open with the selection preserved.
       if (await this.data.requestImport(file, model)) {
         this.modalRef.close();
+        return;
       }
+      this.modalRef.updateConfig({ nzClosable: true, nzMaskClosable: true, nzKeyboard: true });
     } finally {
-      // Re-enable submit if the modal is still open (import declined or it threw).
       this.isSubmitting = false;
+      this.stopTimer();
     }
   }
 }
diff --git a/frontend/src/app/workspace/component/workspace.component.spec.ts b/frontend/src/app/workspace/component/workspace.component.spec.ts
index f85294e42ad..588087fba86 100644
--- a/frontend/src/app/workspace/component/workspace.component.spec.ts
+++ b/frontend/src/app/workspace/component/workspace.component.spec.ts
@@ -106,6 +106,7 @@ describe("WorkspaceComponent", () => {
       disableWorkflowModification: vi.fn(),
       enableWorkflowModification: vi.fn(),
       reloadWorkflow: vi.fn(),
+      autoLayoutWorkflow: vi.fn(),
       setNewSharedModel: vi.fn(),
       setWorkflowMetadata: vi.fn(),
       clearWorkflow: vi.fn(),
@@ -253,7 +254,7 @@ describe("WorkspaceComponent", () => {
       await createFixture(configureRoute({ id: "42" }));
       fixture.detectChanges();
       expect(workflowActionService.setNewSharedModel).toHaveBeenCalledWith(42, { uid: 7 });
-      expect(workflowActionService.reloadWorkflow).toHaveBeenCalledWith(stubWorkflow);
+      expect(workflowActionService.reloadWorkflow).toHaveBeenCalledWith(stubWorkflow, undefined);
       expect(undoRedoService.clearUndoStack).toHaveBeenCalled();
       expect(undoRedoService.clearRedoStack).toHaveBeenCalled();
       expect(component.isLoading).toBe(false);
@@ -283,7 +284,22 @@ describe("WorkspaceComponent", () => {
       fixture.detectChanges();
       expect(notificationService.error).toHaveBeenCalledWith(expect.stringContaining("broken"));
       // Workflow still flows through reload — the error is informational, not blocking.
-      expect(workflowActionService.reloadWorkflow).toHaveBeenCalledWith(brokenWorkflow);
+      expect(workflowActionService.reloadWorkflow).toHaveBeenCalledWith(brokenWorkflow, undefined);
+    });
+
+    it("with autolayout=1: renders synchronously and lays the workflow out once", async () => {
+      await createFixture(configureRoute({ id: "42" }, { autolayout: "1" }));
+      fixture.detectChanges();
+      // asyncRendering=false so the operators exist in the graph before layout runs.
+      expect(workflowActionService.reloadWorkflow).toHaveBeenCalledWith(stubWorkflow, false);
+      expect(workflowActionService.autoLayoutWorkflow).toHaveBeenCalledTimes(1);
+    });
+
+    it("without autolayout: uses the default rendering and does not lay out", async () => {
+      await createFixture(configureRoute({ id: "42" }));
+      fixture.detectChanges();
+      expect(workflowActionService.reloadWorkflow).toHaveBeenCalledWith(stubWorkflow, undefined);
+      expect(workflowActionService.autoLayoutWorkflow).not.toHaveBeenCalled();
     });
 
     it("when URL fragment matches an element in the graph, highlights it", async () => {
diff --git a/frontend/src/app/workspace/component/workspace.component.ts b/frontend/src/app/workspace/component/workspace.component.ts
index 2f95ccccfae..eff95ff4e6c 100644
--- a/frontend/src/app/workspace/component/workspace.component.ts
+++ b/frontend/src/app/workspace/component/workspace.component.ts
@@ -259,9 +259,17 @@ export class WorkspaceComponent implements AfterViewInit, OnInit, OnDestroy {
           this.workflowActionService.setNewSharedModel(wid, this.userService.getCurrentUser());
           // remember URL fragment
           const fragment = this.route.snapshot.fragment;
-          // load the fetched workflow
-          this.workflowActionService.reloadWorkflow(workflow);
+          // A freshly AI-generated workflow arrives with autolayout=1: there was no canvas on the
+          // dashboard to lay the operators out on, so render synchronously (asyncRendering = false)
+          // so the operators exist in the graph, then tidy the layout once.
+          const shouldAutoLayout = this.route.snapshot.queryParams.autolayout === "1";
+          // load the fetched workflow (asyncRendering = false for autolayout so the operators
+          // exist synchronously before the layout runs; undefined otherwise uses the config default)
+          this.workflowActionService.reloadWorkflow(workflow, shouldAutoLayout ? false : undefined);
           this.workflowActionService.enableWorkflowModification();
+          if (shouldAutoLayout) {
+            this.workflowActionService.autoLayoutWorkflow();
+          }
           // set the URL fragment to previous value
           // because reloadWorkflow will highlight/unhighlight all elements
           // which will change the URL fragment
diff --git a/frontend/src/app/workspace/service/jupyter-panel/jupyter-panel.service.ts b/frontend/src/app/workspace/service/jupyter-panel/jupyter-panel.service.ts
index c4f8ffcfbbc..6a14b98efed 100644
--- a/frontend/src/app/workspace/service/jupyter-panel/jupyter-panel.service.ts
+++ b/frontend/src/app/workspace/service/jupyter-panel/jupyter-panel.service.ts
@@ -25,7 +25,7 @@ import { HttpClient, HttpHeaders } from "@angular/common/http";
 import { NotificationService } from "src/app/common/service/notification/notification.service";
 import { distinctUntilChanged, switchMap } from "rxjs/operators";
 import { AppSettings } from "../../../common/app-setting";
-import { NotebookMigrationService } from "../notebook-migration/notebook-migration.service";
+import { NotebookMigrationService, notebookMappingKey } from "../notebook-migration/notebook-migration.service";
 import { GuiConfigService } from "../../../common/service/gui-config.service";
 
 @Injectable({
@@ -137,7 +137,7 @@ export class JupyterPanelService {
       switchMap(async (response: any) => {
         // Only load mapping and workflow if they exist
         if (response.exists) {
-          this.notebookMigrationService.setMapping("mapping_wid_" + workflowID, response.mapping);
+          this.notebookMigrationService.setMapping(notebookMappingKey(workflowID), response.mapping);
 
           if ((await this.notebookMigrationService.sendNotebookToJupyter(response.notebook)) == 1) {
             return 1;
@@ -166,7 +166,7 @@ export class JupyterPanelService {
       console.warn("Workflow ID is undefined. Cannot compute highlight mapping.");
       return;
     }
-    const mappingKey = "mapping_wid_" + wid;
+    const mappingKey = notebookMappingKey(wid);
     const mapping = this.notebookMigrationService.getMapping(mappingKey);
 
     if (mapping == undefined) {
@@ -253,7 +253,7 @@ export class JupyterPanelService {
     this.jupyterNotebookPanelVisible.next(false);
     const wid = this.workflowActionService.getWorkflow().wid;
     if (wid != undefined) {
-      this.notebookMigrationService.deleteMapping("mapping_wid_" + wid);
+      this.notebookMigrationService.deleteMapping(notebookMappingKey(wid));
     }
   }
 
@@ -285,7 +285,7 @@ export class JupyterPanelService {
   public openJupyterNotebookPanel(): void {
     if (!this.enabled) return;
     const wid = this.workflowActionService.getWorkflow().wid;
-    const mappingKey = "mapping_wid_" + wid;
+    const mappingKey = notebookMappingKey(wid);
     // Check if there is corresponding mapping data
     if (wid === undefined || !this.notebookMigrationService.hasMapping(mappingKey)) {
       this.notificationService.warning("No Jupyter notebook associated with this workflow.");
@@ -359,7 +359,7 @@ export class JupyterPanelService {
         return;
       }
 
-      const mappingKey = "mapping_wid_" + wid;
+      const mappingKey = notebookMappingKey(wid);
       const mappingEntry = this.notebookMigrationService.getMapping(mappingKey);
 
       if (!mappingEntry) {
diff --git a/frontend/src/app/workspace/service/notebook-migration/notebook-migration.service.spec.ts b/frontend/src/app/workspace/service/notebook-migration/notebook-migration.service.spec.ts
index 6570e47a00d..2b47325fdbc 100644
--- a/frontend/src/app/workspace/service/notebook-migration/notebook-migration.service.spec.ts
+++ b/frontend/src/app/workspace/service/notebook-migration/notebook-migration.service.spec.ts
@@ -18,7 +18,7 @@
  */
 
 import { TestBed } from "@angular/core/testing";
-import { NotebookMigrationService } from "./notebook-migration.service";
+import { NotebookMigrationService, notebookMappingKey } from "./notebook-migration.service";
 import { HttpClient } from "@angular/common/http";
 import { HttpClientTestingModule, HttpTestingController } from "@angular/common/http/testing";
 import { NotificationService } from "src/app/common/service/notification/notification.service";
@@ -220,15 +220,21 @@ describe("NotebookMigrationService", () => {
   });
 
   // storeNotebookAndMapping
-  it("should call storeNotebookAndMapping API", () => {
-    service.storeNotebookAndMapping(1, 1, {}, {}).subscribe();
+  it("should call storeNotebookAndMapping API with the default vid", () => {
+    service.storeNotebookAndMapping(1, {}, {}).subscribe();
 
     const req = httpMock.expectOne(req => req.url.includes("/notebook-migration/store-notebook-and-mapping"));
 
     expect(req.request.method).toBe("POST");
+    expect(req.request.body.wid).toBe(1);
+    expect(req.request.body.vid).toBe(1);
     req.flush({ success: true, message: "stored" });
   });
 
+  it("notebookMappingKey builds the in-memory cache key from the wid", () => {
+    expect(notebookMappingKey(42)).toBe("mapping_wid_42");
+  });
+
   // deleteNotebookAndMapping
   it("should call deleteNotebookAndMapping API with the wid", () => {
     let result: any;
@@ -332,7 +338,7 @@ describe("NotebookMigrationService", () => {
     });
 
     it("storeNotebookAndMapping emits a disabled result without making an HTTP call", async () => {
-      const result = await firstValueFrom(service.storeNotebookAndMapping(1, 1, {}, {}));
+      const result = await firstValueFrom(service.storeNotebookAndMapping(1, {}, {}));
       expect(result.success).toBe(false);
       httpMock.expectNone(req => req.url.includes("/notebook-migration/store-notebook-and-mapping"));
     });
@@ -343,4 +349,50 @@ describe("NotebookMigrationService", () => {
       httpMock.expectNone(req => req.url.includes("/notebook-migration/delete-notebook-and-mapping"));
     });
   });
+
+  // parseAndTagNotebook (reads + validates + uuid-tags an uploaded .ipynb)
+  describe("parseAndTagNotebook", () => {
+    it("parses a valid notebook and tags every cell with a uuid", async () => {
+      const notebook = {
+        cells: [
+          { cell_type: "code", source: "print(1)", metadata: {} },
+          // No metadata: the parser must create it before setting the uuid.
+          { cell_type: "markdown", source: "# title" },
+        ],
+      };
+      const file = new File([JSON.stringify(notebook)], "analysis.ipynb");
+
+      const parsed = await service.parseAndTagNotebook(file);
+
+      expect(parsed.cells.length).toBe(2);
+      expect(parsed.cells[0].metadata?.uuid).toBeTruthy();
+      expect(parsed.cells[1].metadata?.uuid).toBeTruthy();
+    });
+
+    it("rejects when the notebook is not valid JSON", async () => {
+      const file = new File(["not json"], "x.ipynb");
+      await expect(service.parseAndTagNotebook(file)).rejects.toThrow();
+    });
+
+    it("rejects a notebook without a cells array", async () => {
+      const file = new File([JSON.stringify({ nbformat: 4 })], "x.ipynb");
+      await expect(service.parseAndTagNotebook(file)).rejects.toThrow(/Invalid notebook structure/);
+    });
+
+    it("rejects when the file content is not a string", async () => {
+      vi.spyOn(FileReader.prototype, "readAsText").mockImplementation(function (this: any) {
+        // result is a getter-only property, so shadow it with an own non-string value.
+        Object.defineProperty(this, "result", { value: null, configurable: true });
+        this.onload?.(new ProgressEvent("load"));
+      });
+      await expect(service.parseAndTagNotebook(new File([""], "x.ipynb"))).rejects.toThrow(/not a valid string/);
+    });
+
+    it("rejects when the file cannot be read", async () => {
+      vi.spyOn(FileReader.prototype, "readAsText").mockImplementation(function (this: any) {
+        this.onerror?.(new ProgressEvent("error"));
+      });
+      await expect(service.parseAndTagNotebook(new File([""], "x.ipynb"))).rejects.toThrow(/Failed to read/);
+    });
+  });
 });
diff --git a/frontend/src/app/workspace/service/notebook-migration/notebook-migration.service.ts b/frontend/src/app/workspace/service/notebook-migration/notebook-migration.service.ts
index 3d6600c2a2e..5a4c02af8ca 100644
--- a/frontend/src/app/workspace/service/notebook-migration/notebook-migration.service.ts
+++ b/frontend/src/app/workspace/service/notebook-migration/notebook-migration.service.ts
@@ -24,7 +24,9 @@ import { HttpClient, HttpHeaders } from "@angular/common/http";
 import { NotificationService } from "src/app/common/service/notification/notification.service";
 import { GuiConfigService } from "../../../common/service/gui-config.service";
 import { WorkflowUtilService } from "../workflow-graph/util/workflow-util.service";
+import { WorkflowContent } from "../../../common/type/workflow";
 import { catchError, firstValueFrom, map, Observable, of } from "rxjs";
+import { v4 as uuidv4 } from "uuid";
 
 interface LiteLLMModel {
   id: string;
@@ -38,7 +40,7 @@ interface LiteLLMModelsResponse {
   object: string;
 }
 
-interface MappingContent {
+export interface MappingContent {
   cell_to_operator: Record<string, string[]>;
   operator_to_cell: Record<string, string[]>;
 }
@@ -54,6 +56,12 @@ interface DeleteNotebookResponse {
   message?: string;
 }
 
+// Single source of truth for the in-memory mapping cache key. Both the dashboard generate flow
+// and JupyterPanelService key the cell <-> operator mapping by this, so it must not drift.
+export function notebookMappingKey(wid: number | undefined): string {
+  return "mapping_wid_" + wid;
+}
+
 @Injectable({
   providedIn: "root",
 })
@@ -86,7 +94,10 @@ export class NotebookMigrationService {
     );
   }
 
-  public async sendToAIGenerateWorkflow(notebookContent: Notebook, modelType: string) {
+  public async sendToAIGenerateWorkflow(
+    notebookContent: Notebook,
+    modelType: string
+  ): Promise<{ workflowContent: WorkflowContent; mappingContent: MappingContent }> {
     if (!this.enabled) throw new Error("Notebook migration feature is disabled");
     const migrationLLM = this.createMigrationLLM();
     // initialize() defaults to the user's Texera JWT via AuthService.getAccessToken().
@@ -195,9 +206,9 @@ export class NotebookMigrationService {
 
   public storeNotebookAndMapping(
     wid: number | undefined,
-    vid: number = 1,
     mappingContent: any,
-    notebookContent: any
+    notebookContent: any,
+    vid: number = 1
   ): Observable<StoreNotebookResponse> {
     if (!this.enabled) {
       return of({ success: false, message: "Notebook migration feature is disabled" });
@@ -246,4 +257,36 @@ export class NotebookMigrationService {
   public deleteMapping(id: string): void {
     delete this.mapping[id];
   }
+
+  // Reads an uploaded .ipynb file, parses it, validates its structure, and tags each cell with a
+  // uuid (the cell <-> operator mapping keys off these). Rejects on a read error, invalid JSON, or
+  // a notebook without a cells array. Uses FileReader rather than file.text() because jsdom (the
+  // test environment) does not implement Blob/File.text().
+  public parseAndTagNotebook(file: File): Promise<Notebook> {
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader();
+      reader.onerror = () => reject(new Error("Failed to read the notebook file."));
+      reader.onload = () => {
+        try {
+          if (typeof reader.result !== "string") {
+            throw new Error("File content is not a valid string.");
+          }
+          const notebook = JSON.parse(reader.result) as Notebook;
+          if (!notebook || !Array.isArray(notebook.cells)) {
+            throw new Error("Invalid notebook structure.");
+          }
+          for (const cell of notebook.cells) {
+            if (!cell.metadata) {
+              cell.metadata = {};
+            }
+            cell.metadata.uuid = uuidv4();
+          }
+          resolve(notebook);
+        } catch (error) {
+          reject(error);
+        }
+      };
+      reader.readAsText(file);
+    });
+  }
 }

From 3cfee80ca1165570eeae6e5ab45a9614a11f0acd Mon Sep 17 00:00:00 2001
From: Ryan Zhang <zyratlo@gmail.com>
Date: Thu, 13 Aug 2026 11:02:50 -0700
Subject: [PATCH 02/10] fix(python-notebook-migration, frontend): persist the
 auto-layout of generated workflows

---
 .../src/app/workspace/component/workspace.component.spec.ts | 6 ++++++
 frontend/src/app/workspace/component/workspace.component.ts | 5 ++++-
 2 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/frontend/src/app/workspace/component/workspace.component.spec.ts b/frontend/src/app/workspace/component/workspace.component.spec.ts
index 588087fba86..a17d2dbff28 100644
--- a/frontend/src/app/workspace/component/workspace.component.spec.ts
+++ b/frontend/src/app/workspace/component/workspace.component.spec.ts
@@ -289,10 +289,16 @@ describe("WorkspaceComponent", () => {
 
     it("with autolayout=1: renders synchronously and lays the workflow out once", async () => {
       await createFixture(configureRoute({ id: "42" }, { autolayout: "1" }));
+      const registerSpy = vi.spyOn(component, "registerAutoPersistWorkflow");
       fixture.detectChanges();
       // asyncRendering=false so the operators exist in the graph before layout runs.
       expect(workflowActionService.reloadWorkflow).toHaveBeenCalledWith(stubWorkflow, false);
       expect(workflowActionService.autoLayoutWorkflow).toHaveBeenCalledTimes(1);
+      // Auto-persistence must be registered before the layout runs, otherwise the layout's
+      // position-change events fire into no subscriber and the tidied layout is never saved.
+      expect(registerSpy.mock.invocationCallOrder[0]).toBeLessThan(
+        workflowActionService.autoLayoutWorkflow.mock.invocationCallOrder[0]
+      );
     });
 
     it("without autolayout: uses the default rendering and does not lay out", async () => {
diff --git a/frontend/src/app/workspace/component/workspace.component.ts b/frontend/src/app/workspace/component/workspace.component.ts
index eff95ff4e6c..1b4380a688f 100644
--- a/frontend/src/app/workspace/component/workspace.component.ts
+++ b/frontend/src/app/workspace/component/workspace.component.ts
@@ -267,6 +267,10 @@ export class WorkspaceComponent implements AfterViewInit, OnInit, OnDestroy {
           // exist synchronously before the layout runs; undefined otherwise uses the config default)
           this.workflowActionService.reloadWorkflow(workflow, shouldAutoLayout ? false : undefined);
           this.workflowActionService.enableWorkflowModification();
+          // Register auto-persistence before autoLayoutWorkflow() runs: workflowChanged() merges hot,
+          // non-replaying streams, so the layout's position-change events would be lost if we subscribed
+          // afterwards, and the tidied layout would never be saved (autolayout=1 is one-shot).
+          this.registerAutoPersistWorkflow();
           if (shouldAutoLayout) {
             this.workflowActionService.autoLayoutWorkflow();
           }
@@ -292,7 +296,6 @@ export class WorkspaceComponent implements AfterViewInit, OnInit, OnDestroy {
           this.undoRedoService.clearUndoStack();
           this.undoRedoService.clearRedoStack();
           this.setLoadingState(false);
-          this.registerAutoPersistWorkflow();
           this.triggerCenter();
         },
         () => {

From da6da352f15c9201ed202d66a4c875b07cb14527 Mon Sep 17 00:00:00 2001
From: Ryan Zhang <zyratlo@gmail.com>
Date: Thu, 13 Aug 2026 11:08:16 -0700
Subject: [PATCH 03/10] docs(python-notebook-migration, frontend): trim verbose
 comments

---
 .../user-workflow/user-workflow.component.ts  | 24 +++++------------
 .../notebook-import-modal.component.scss      |  5 ++--
 .../notebook-import-modal.component.ts        | 27 +++++++------------
 .../component/workspace.component.ts          | 12 +++------
 .../notebook-migration.service.ts             | 10 +++----
 5 files changed, 26 insertions(+), 52 deletions(-)

diff --git a/frontend/src/app/dashboard/component/user/user-workflow/user-workflow.component.ts b/frontend/src/app/dashboard/component/user/user-workflow/user-workflow.component.ts
index c90c595329e..ab2904425a7 100644
--- a/frontend/src/app/dashboard/component/user/user-workflow/user-workflow.component.ts
+++ b/frontend/src/app/dashboard/component/user/user-workflow/user-workflow.component.ts
@@ -326,10 +326,7 @@ export class UserWorkflowComponent implements AfterViewInit {
     return this.config.env.pythonNotebookMigrationEnabled;
   }
 
-  /**
-   * Open the AI-generate import modal from the dashboard. The modal collects the notebook file and
-   * model and shows a loading state while generation runs (the requestImport callback below).
-   */
+  /** Open the AI-generate import modal, wiring its submit to generateWorkflowFromNotebook. */
   public openAiGenerateModal(): void {
     this.modalService.create<NotebookImportModalComponent, NotebookImportModalData>({
       nzTitle: "AI Generate Workflow from Python Notebook",
@@ -344,12 +341,8 @@ export class UserWorkflowComponent implements AfterViewInit {
   }
 
   /**
-   * Generate a workflow from the uploaded notebook and open it. Runs entirely on the dashboard while
-   * the modal shows a loading state: parse the notebook, send it to the LLM, save the result as a new
-   * workflow, store the notebook and cell mapping, then navigate to the new workflow. The workspace
-   * lays the generated operators out (via the autolayout query param) and opens the notebook panel
-   * (driven by the workflow id). Resolves true so the modal closes on success, or false (leaving the
-   * modal open with the selection intact) when the file is not a notebook or generation fails.
+   * Parse the notebook, generate a workflow via the LLM, save it, store the cell mapping, and open it.
+   * Resolves true on success (modal closes), false to keep the modal open on a bad file or a failure.
    */
   private async generateWorkflowFromNotebook(file: NzUploadFile, model: string): Promise<boolean> {
     const fileExtension = file.name.split(".").pop()?.toLowerCase();
@@ -375,8 +368,8 @@ export class UserWorkflowComponent implements AfterViewInit {
       return false;
     }
 
-    // Create the workflow. This is the commit point: persisting captures the expensive LLM
-    // result. If it fails nothing was created, so returning false (letting the user retry) is safe.
+    // Commit point: persisting captures the expensive LLM result. On failure nothing was created,
+    // so returning false to let the user retry is safe.
     let wid: number;
     try {
       const createdWorkflow = await firstValueFrom(
@@ -395,9 +388,7 @@ export class UserWorkflowComponent implements AfterViewInit {
       return false;
     }
 
-    // Past the commit point the follow-up steps are best-effort: a transient failure must not
-    // discard the created workflow or the LLM result, so we log/warn and still open the workflow
-    // rather than force a full re-generation.
+    // Best-effort follow-ups: never discard the created workflow, so log/warn and still open it.
     if (this.pid) {
       try {
         await firstValueFrom(this.userProjectService.addWorkflowToProject(this.pid, wid));
@@ -425,8 +416,7 @@ export class UserWorkflowComponent implements AfterViewInit {
     return true;
   }
 
-  // Strips the extension from an uploaded file name, falling back to DEFAULT_WORKFLOW_NAME when the
-  // result is empty. Shared by the file-upload and AI-generate flows to name the created workflow.
+  // Strips the extension from a file name, falling back to DEFAULT_WORKFLOW_NAME when empty.
   private deriveWorkflowName(fileName: string): string {
     const extensionIndex = fileName.lastIndexOf(".");
     const baseName = extensionIndex === -1 ? fileName : fileName.substring(0, extensionIndex);
diff --git a/frontend/src/app/workspace/component/notebook-import-modal/notebook-import-modal.component.scss b/frontend/src/app/workspace/component/notebook-import-modal/notebook-import-modal.component.scss
index d5d60d1a345..da51cba51ee 100644
--- a/frontend/src/app/workspace/component/notebook-import-modal/notebook-import-modal.component.scss
+++ b/frontend/src/app/workspace/component/notebook-import-modal/notebook-import-modal.component.scss
@@ -70,8 +70,7 @@
     width: 50%;
   }
 
-  // Wraps the form and footer so the loading overlay can cover them without changing the
-  // modal's height (which would otherwise resize and re-center the centered modal on submit).
+  // Positioning context for the loading overlay, so covering the form does not resize the modal.
   &-content {
     position: relative;
   }
@@ -80,7 +79,7 @@
     position: absolute;
     inset: 0;
     z-index: 1;
-    // Solid background so the form and footer underneath are fully hidden.
+    // Solid background so the form underneath is fully hidden.
     background-color: #fff;
     display: flex;
     flex-direction: column;
diff --git a/frontend/src/app/workspace/component/notebook-import-modal/notebook-import-modal.component.ts b/frontend/src/app/workspace/component/notebook-import-modal/notebook-import-modal.component.ts
index 7a47da759fa..7c9ad86cd66 100644
--- a/frontend/src/app/workspace/component/notebook-import-modal/notebook-import-modal.component.ts
+++ b/frontend/src/app/workspace/component/notebook-import-modal/notebook-import-modal.component.ts
@@ -30,20 +30,15 @@ import { NzButtonComponent } from "ng-zorro-antd/button";
 import { NzIconDirective } from "ng-zorro-antd/icon";
 import { NotebookMigrationService } from "../../service/notebook-migration/notebook-migration.service";
 
-// Passed in via nzData. The modal hands the selected file and model to the opener, which runs the
-// generation and persistence. The modal shows a loading state while this promise is pending.
-// Resolve true to close the modal (generation succeeded and the opener navigated away), false to
-// keep it open with the user's selection intact (bad file or a failure the user can retry).
+// Passed in via nzData. requestImport resolves true to close the modal, false to keep it open
+// with the user's selection intact (bad file or a retryable failure).
 export interface NotebookImportModalData {
   requestImport: (file: NzUploadFile, model: string) => Promise<boolean>;
 }
 
 /**
- * The "AI Generate Workflow from Python Notebook" modal body. It owns the upload form and
- * the three model-dropdown states (loading / has models / none). On Submit it hands the file
- * and model to its opener via the requestImport callback (passed in through nzData) and shows a
- * loading state while generation runs, closing itself only when that resolves true. Mirrors the
- * component-as-nzContent pattern used by the other modals opened from the menu.
+ * The "AI Generate Workflow from Python Notebook" modal body: the upload form and model dropdown.
+ * On Submit it hands the file and model to requestImport and shows a loading state until it resolves.
  */
 @Component({
   selector: "texera-notebook-import-modal",
@@ -89,8 +84,7 @@ export class NotebookImportModalComponent implements OnDestroy {
     this.modalRef.close();
   }
 
-  // True while generation is running. Guards against a second submit and drives the loading
-  // spinner shown over the form.
+  // True while generation runs: guards against a second submit and drives the loading overlay.
   public isSubmitting = false;
   private startTime: number | null = null;
   private timerHandle: ReturnType<typeof setInterval> | null = null;
@@ -107,17 +101,15 @@ export class NotebookImportModalComponent implements OnDestroy {
     return `${minutes}:${seconds.toString().padStart(2, "0")}`;
   }
 
-  // Empty on purpose: with default change detection, the visibilitychange event firing in the
-  // Angular zone is itself what triggers a repaint, so the stopwatch catches up immediately when
-  // the user returns to a backgrounded tab. The handler body is irrelevant.
+  // Empty body on purpose: the zone-patched event firing is itself what repaints the stopwatch,
+  // so it catches up when the user returns to a backgrounded tab. Same reason as the timer below.
   @HostListener("document:visibilitychange")
   public onVisibilityChange(): void {}
 
   private startTimer(): void {
     this.stopTimer();
     this.startTime = Date.now();
-    // The interval body is intentionally empty: the elapsed value is computed from startTime, and
-    // with default change detection the zone-patched timer firing is what repaints it each second.
+    // Empty body: elapsed is computed from startTime; the zone-patched tick just triggers a repaint.
     this.timerHandle = setInterval(() => {}, 1000);
   }
 
@@ -136,8 +128,7 @@ export class NotebookImportModalComponent implements OnDestroy {
     this.startTimer();
     this.modalRef.updateConfig({ nzClosable: false, nzMaskClosable: false, nzKeyboard: false });
     try {
-      // Run generation via the opener; close only if it succeeds, so a failure leaves this modal
-      // open with the selection preserved.
+      // Close only on success, so a failure leaves the modal open with the selection preserved.
       if (await this.data.requestImport(file, model)) {
         this.modalRef.close();
         return;
diff --git a/frontend/src/app/workspace/component/workspace.component.ts b/frontend/src/app/workspace/component/workspace.component.ts
index 1b4380a688f..b451527498b 100644
--- a/frontend/src/app/workspace/component/workspace.component.ts
+++ b/frontend/src/app/workspace/component/workspace.component.ts
@@ -259,17 +259,13 @@ export class WorkspaceComponent implements AfterViewInit, OnInit, OnDestroy {
           this.workflowActionService.setNewSharedModel(wid, this.userService.getCurrentUser());
           // remember URL fragment
           const fragment = this.route.snapshot.fragment;
-          // A freshly AI-generated workflow arrives with autolayout=1: there was no canvas on the
-          // dashboard to lay the operators out on, so render synchronously (asyncRendering = false)
-          // so the operators exist in the graph, then tidy the layout once.
+          // An AI-generated workflow arrives with autolayout=1. Render synchronously
+          // (asyncRendering = false) so the operators exist before the one-shot layout runs.
           const shouldAutoLayout = this.route.snapshot.queryParams.autolayout === "1";
-          // load the fetched workflow (asyncRendering = false for autolayout so the operators
-          // exist synchronously before the layout runs; undefined otherwise uses the config default)
           this.workflowActionService.reloadWorkflow(workflow, shouldAutoLayout ? false : undefined);
           this.workflowActionService.enableWorkflowModification();
-          // Register auto-persistence before autoLayoutWorkflow() runs: workflowChanged() merges hot,
-          // non-replaying streams, so the layout's position-change events would be lost if we subscribed
-          // afterwards, and the tidied layout would never be saved (autolayout=1 is one-shot).
+          // Register before autoLayoutWorkflow(): workflowChanged() streams are hot, so subscribing
+          // afterward would drop the layout's position events and the tidied layout would never save.
           this.registerAutoPersistWorkflow();
           if (shouldAutoLayout) {
             this.workflowActionService.autoLayoutWorkflow();
diff --git a/frontend/src/app/workspace/service/notebook-migration/notebook-migration.service.ts b/frontend/src/app/workspace/service/notebook-migration/notebook-migration.service.ts
index 5a4c02af8ca..5c636240f36 100644
--- a/frontend/src/app/workspace/service/notebook-migration/notebook-migration.service.ts
+++ b/frontend/src/app/workspace/service/notebook-migration/notebook-migration.service.ts
@@ -56,8 +56,7 @@ interface DeleteNotebookResponse {
   message?: string;
 }
 
-// Single source of truth for the in-memory mapping cache key. Both the dashboard generate flow
-// and JupyterPanelService key the cell <-> operator mapping by this, so it must not drift.
+// Single source of truth for the mapping cache key, shared with JupyterPanelService so it can't drift.
 export function notebookMappingKey(wid: number | undefined): string {
   return "mapping_wid_" + wid;
 }
@@ -258,10 +257,9 @@ export class NotebookMigrationService {
     delete this.mapping[id];
   }
 
-  // Reads an uploaded .ipynb file, parses it, validates its structure, and tags each cell with a
-  // uuid (the cell <-> operator mapping keys off these). Rejects on a read error, invalid JSON, or
-  // a notebook without a cells array. Uses FileReader rather than file.text() because jsdom (the
-  // test environment) does not implement Blob/File.text().
+  // Reads and parses an .ipynb file, then tags each cell with a uuid (the mapping keys off these).
+  // Rejects on a read error, invalid JSON, or a missing cells array. Uses FileReader rather than
+  // file.text() because jsdom (the test environment) does not implement Blob/File.text().
   public parseAndTagNotebook(file: File): Promise<Notebook> {
     return new Promise((resolve, reject) => {
       const reader = new FileReader();

From d3c72f6382b0d626f58b2421e4b3326edbdea825 Mon Sep 17 00:00:00 2001
From: Ryan Zhang <zyratlo@gmail.com>
Date: Thu, 13 Aug 2026 11:24:19 -0700
Subject: [PATCH 04/10] fix(python-notebook-migration, frontend): make the
 modal loading overlay accessible

---
 .../notebook-import-modal.component.html      |  9 +++++++--
 .../notebook-import-modal.component.spec.ts   | 19 +++++++++++++++++++
 2 files changed, 26 insertions(+), 2 deletions(-)

diff --git a/frontend/src/app/workspace/component/notebook-import-modal/notebook-import-modal.component.html b/frontend/src/app/workspace/component/notebook-import-modal/notebook-import-modal.component.html
index 4edfc7dbe02..3986eb9c710 100644
--- a/frontend/src/app/workspace/component/notebook-import-modal/notebook-import-modal.component.html
+++ b/frontend/src/app/workspace/component/notebook-import-modal/notebook-import-modal.component.html
@@ -29,6 +29,7 @@
   <form
     class="import-modal-form"
     [formGroup]="importForm"
+    [attr.inert]="isSubmitting ? '' : null"
     nz-form>
     <nz-form-item>
       <p class="import-modal-text">
@@ -113,7 +114,9 @@
     </nz-form-item>
   </form>
 
-  <div class="import-modal-footer">
+  <div
+    class="import-modal-footer"
+    [attr.inert]="isSubmitting ? '' : null">
     <button
       nz-button
       type="button"
@@ -133,7 +136,9 @@
 
   <div
     *ngIf="isSubmitting"
-    class="import-modal-loading">
+    class="import-modal-loading"
+    role="status"
+    aria-live="polite">
     <nz-spin
       nzSimple
       [nzSize]="'large'"></nz-spin>
diff --git a/frontend/src/app/workspace/component/notebook-import-modal/notebook-import-modal.component.spec.ts b/frontend/src/app/workspace/component/notebook-import-modal/notebook-import-modal.component.spec.ts
index 6587a89057b..2e46f2ee655 100644
--- a/frontend/src/app/workspace/component/notebook-import-modal/notebook-import-modal.component.spec.ts
+++ b/frontend/src/app/workspace/component/notebook-import-modal/notebook-import-modal.component.spec.ts
@@ -78,6 +78,25 @@ describe("NotebookImportModalComponent", () => {
     expect(spinning()).toBe(true);
   });
 
+  it("makes the form and footer inert and announces the overlay while submitting", async () => {
+    await createWith(of([{ name: "gpt-4" }]));
+    const root = fixture.nativeElement as HTMLElement;
+    const form = () => root.querySelector(".import-modal-form");
+    const footer = () => root.querySelector(".import-modal-footer");
+
+    expect(form()?.hasAttribute("inert")).toBe(false);
+    expect(footer()?.hasAttribute("inert")).toBe(false);
+
+    component.isSubmitting = true;
+    fixture.detectChanges();
+
+    // While generating, the covered form and footer are pulled out of the focus/a11y tree,
+    // and the overlay is a live region so its status is announced.
+    expect(form()?.hasAttribute("inert")).toBe(true);
+    expect(footer()?.hasAttribute("inert")).toBe(true);
+    expect(root.querySelector(".import-modal-loading")?.getAttribute("role")).toBe("status");
+  });
+
   it("shows the disabled 'no models available' select when the list is empty", async () => {
     await createWith(of([]));
     expect((fixture.nativeElement as HTMLElement).textContent).toContain("No models available");

From 8391c2c0f400b7c0dd461300859060fb5e7fdb5c Mon Sep 17 00:00:00 2001
From: Ryan Zhang <zyratlo@gmail.com>
Date: Thu, 13 Aug 2026 11:39:16 -0700
Subject: [PATCH 05/10] fix(python-notebook-migration, frontend): guard against
 long notebook file names

---
 .../user-workflow/user-workflow.component.spec.ts     | 11 +++++++++++
 .../user/user-workflow/user-workflow.component.ts     |  8 ++++----
 .../notebook-import-modal.component.html              |  7 +++++--
 .../notebook-import-modal.component.scss              | 11 ++++++++++-
 4 files changed, 30 insertions(+), 7 deletions(-)

diff --git a/frontend/src/app/dashboard/component/user/user-workflow/user-workflow.component.spec.ts b/frontend/src/app/dashboard/component/user/user-workflow/user-workflow.component.spec.ts
index d2bf07febc6..eb0dcf3d9ea 100644
--- a/frontend/src/app/dashboard/component/user/user-workflow/user-workflow.component.spec.ts
+++ b/frontend/src/app/dashboard/component/user/user-workflow/user-workflow.component.spec.ts
@@ -403,6 +403,17 @@ describe("SavedWorkflowSectionComponent", () => {
       expect(proceed).toBe(true);
     });
 
+    it("truncates a long notebook basename so the generated name fits the 128-char column", async () => {
+      const { persist } = mockGenerationSuccess(99);
+      vi.spyOn(TestBed.inject(Router), "navigate").mockResolvedValue(true);
+
+      await getRequestImport()({ name: "a".repeat(200) + ".ipynb" } as NzUploadFile, "gpt-4");
+
+      const createdName = persist.createWorkflow.mock.calls[0][1] as string;
+      expect(createdName.length).toBe(128);
+      expect(createdName.endsWith("_GENERATED_BY_LLM")).toBe(true);
+    });
+
     it("adds the new workflow to the current project when opened inside one", async () => {
       mockGenerationSuccess(99);
       vi.spyOn(TestBed.inject(Router), "navigate").mockResolvedValue(true);
diff --git a/frontend/src/app/dashboard/component/user/user-workflow/user-workflow.component.ts b/frontend/src/app/dashboard/component/user/user-workflow/user-workflow.component.ts
index ab2904425a7..614fd204418 100644
--- a/frontend/src/app/dashboard/component/user/user-workflow/user-workflow.component.ts
+++ b/frontend/src/app/dashboard/component/user/user-workflow/user-workflow.component.ts
@@ -372,11 +372,11 @@ export class UserWorkflowComponent implements AfterViewInit {
     // so returning false to let the user retry is safe.
     let wid: number;
     try {
+      // workflow.name is VARCHAR(128); cap the base so base + suffix fits the column.
+      const generatedSuffix = "_GENERATED_BY_LLM";
+      const generatedName = this.deriveWorkflowName(file.name).slice(0, 128 - generatedSuffix.length);
       const createdWorkflow = await firstValueFrom(
-        this.workflowPersistService.createWorkflow(
-          generated.workflowContent,
-          this.deriveWorkflowName(file.name) + "_GENERATED_BY_LLM"
-        )
+        this.workflowPersistService.createWorkflow(generated.workflowContent, generatedName + generatedSuffix)
       );
       if (!createdWorkflow.workflow.wid) {
         throw new Error("Created workflow has no wid.");
diff --git a/frontend/src/app/workspace/component/notebook-import-modal/notebook-import-modal.component.html b/frontend/src/app/workspace/component/notebook-import-modal/notebook-import-modal.component.html
index 3986eb9c710..814b92069c0 100644
--- a/frontend/src/app/workspace/component/notebook-import-modal/notebook-import-modal.component.html
+++ b/frontend/src/app/workspace/component/notebook-import-modal/notebook-import-modal.component.html
@@ -71,8 +71,11 @@
             </button>
           </nz-upload>
 
-          <span *ngIf="importForm.get('file')?.value?.name">
-            Selected file: {{ importForm.get('file')?.value?.name }}
+          <span
+            *ngIf="importForm.get('file')?.value?.name as fileName"
+            class="import-modal-selected-file"
+            [title]="fileName">
+            Selected file: {{ fileName }}
           </span>
         </div>
       </nz-form-control>
diff --git a/frontend/src/app/workspace/component/notebook-import-modal/notebook-import-modal.component.scss b/frontend/src/app/workspace/component/notebook-import-modal/notebook-import-modal.component.scss
index da51cba51ee..ed2b53d725d 100644
--- a/frontend/src/app/workspace/component/notebook-import-modal/notebook-import-modal.component.scss
+++ b/frontend/src/app/workspace/component/notebook-import-modal/notebook-import-modal.component.scss
@@ -57,15 +57,24 @@
   }
 
   &-upload-row {
-    display: inline-flex;
+    display: flex;
     align-items: center;
     gap: 8px;
 
     button {
       white-space: normal;
+      flex: none;
     }
   }
 
+  &-selected-file {
+    flex: 1;
+    min-width: 0;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
+
   &-select {
     width: 50%;
   }

From 511d6c06dd4380bc0abc21b52ac2db35f88f4146 Mon Sep 17 00:00:00 2001
From: Ryan Zhang <zyratlo@gmail.com>
Date: Thu, 13 Aug 2026 12:59:01 -0700
Subject: [PATCH 06/10] fix(python-notebook-migration, frontend): bound the LLM
 request so a stall cannot trap the modal

---
 .../notebook-migration/migration-llm.spec.ts  | 36 +++++++++++++++++--
 .../notebook-migration/migration-llm.ts       | 31 +++++++++++++---
 2 files changed, 61 insertions(+), 6 deletions(-)

diff --git a/frontend/src/app/workspace/service/notebook-migration/migration-llm.spec.ts b/frontend/src/app/workspace/service/notebook-migration/migration-llm.spec.ts
index 40714dd64a5..ac0faf22090 100644
--- a/frontend/src/app/workspace/service/notebook-migration/migration-llm.spec.ts
+++ b/frontend/src/app/workspace/service/notebook-migration/migration-llm.spec.ts
@@ -17,7 +17,7 @@
  * under the License.
  */
 
-import { NotebookMigrationLLM, Notebook } from "./migration-llm";
+import { NotebookMigrationLLM, Notebook, LLM_REQUEST_TIMEOUT_MS } from "./migration-llm";
 import { GuiConfigService } from "../../../common/service/gui-config.service";
 import { WorkflowUtilService } from "../workflow-graph/util/workflow-util.service";
 import { AuthService } from "../../../common/service/user/auth.service";
@@ -371,7 +371,8 @@ describe("NotebookMigrationLLM", () => {
     it("returns true and pings the model with a capped token budget on success", async () => {
       const ok = await makeLLM().verifyConnection();
       expect(ok).toBe(true);
-      expect(callModelSpy).toHaveBeenCalledWith([{ role: "user", content: "ping" }], 10);
+      // The ping goes through the timeout wrapper, so it also carries an abort signal.
+      expect(callModelSpy).toHaveBeenCalledWith([{ role: "user", content: "ping" }], 10, expect.any(AbortSignal));
     });
 
     it("returns false and logs the error when the ping fails", async () => {
@@ -385,6 +386,37 @@ describe("NotebookMigrationLLM", () => {
     });
   });
 
+  describe("request timeout", () => {
+    it("rejects a stalled model call once the timeout elapses so the caller can recover", async () => {
+      vi.useFakeTimers();
+      try {
+        // A request that never settles: only the timeout can end it.
+        callModelSpy.mockReturnValue(new Promise<{ text: string }>(() => {}));
+        const pending = makeLLM().convertNotebookToWorkflow({ cells: [codeCell("AAA", "a = 1")] });
+        // Surface the rejection instead of letting it float as unhandled while timers advance.
+        const assertion = expect(pending).rejects.toThrow(/timed out/);
+        await vi.advanceTimersByTimeAsync(LLM_REQUEST_TIMEOUT_MS);
+        await assertion;
+      } finally {
+        vi.useRealTimers();
+      }
+    });
+
+    it("does not reject a call that resolves before the timeout", async () => {
+      vi.useFakeTimers();
+      try {
+        mockResponses(
+          JSON.stringify({ code: { UDF1: "code1" }, edges: [], outputs: { UDF1: ["a"] } }),
+          JSON.stringify({ UDF1: ["AAA"] })
+        );
+        const result = await makeLLM().convertNotebookToWorkflow({ cells: [codeCell("AAA", "a = 1")] });
+        expect(JSON.parse(result).workflowJSON.operators).toHaveLength(1);
+      } finally {
+        vi.useRealTimers();
+      }
+    });
+  });
+
   describe("initialization guards", () => {
     it("convertNotebookToWorkflow() rejects when the session is enabled but not initialized", async () => {
       const llm = makeUninitializedLLM();
diff --git a/frontend/src/app/workspace/service/notebook-migration/migration-llm.ts b/frontend/src/app/workspace/service/notebook-migration/migration-llm.ts
index 6a1ba8b4894..d68ed6504d6 100644
--- a/frontend/src/app/workspace/service/notebook-migration/migration-llm.ts
+++ b/frontend/src/app/workspace/service/notebook-migration/migration-llm.ts
@@ -79,6 +79,8 @@ interface CombinedMapping {
  * Terminal UDFs (no outgoing edge) declare their outputs as `string` so the result panel
  * renders viewable values rather than opaque binary blobs.
  */
+export const LLM_REQUEST_TIMEOUT_MS = 10 * 60 * 1000;
+
 @Injectable()
 export class NotebookMigrationLLM {
   private model: any;
@@ -175,7 +177,7 @@ export class NotebookMigrationLLM {
     }
 
     try {
-      await this.callModel([{ role: "user", content: "ping" }], 10);
+      await this.callModelWithTimeout([{ role: "user", content: "ping" }], 10);
 
       return true;
     } catch (err) {
@@ -189,8 +191,29 @@ export class NotebookMigrationLLM {
   // builder when "ai" is also loaded by a sibling spec (e.g. via
   // NotebookMigrationService), which silently breaks the mock and hangs these
   // tests on a real network call.
-  protected callModel(messages: ModelMessage[], maxOutputTokens?: number): Promise<{ text: string }> {
-    return generateText({ model: this.model, messages, maxOutputTokens });
+  protected callModel(
+    messages: ModelMessage[],
+    maxOutputTokens?: number,
+    abortSignal?: AbortSignal
+  ): Promise<{ text: string }> {
+    return generateText({ model: this.model, messages, maxOutputTokens, abortSignal });
+  }
+
+  // Wraps callModel with a hard timeout so a stalled request cannot hang forever. The abort
+  // cancels the underlying request when the transport honors it; the race guarantees rejection
+  // even if it does not, so the caller's error path always runs.
+  private callModelWithTimeout(messages: ModelMessage[], maxOutputTokens?: number): Promise<{ text: string }> {
+    const controller = new AbortController();
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    const timeout = new Promise<never>((_resolve, reject) => {
+      timer = setTimeout(() => {
+        controller.abort();
+        reject(new Error(`LLM request timed out after ${LLM_REQUEST_TIMEOUT_MS} ms`));
+      }, LLM_REQUEST_TIMEOUT_MS);
+    });
+    return Promise.race([this.callModel(messages, maxOutputTokens, controller.signal), timeout]).finally(() =>
+      clearTimeout(timer)
+    );
   }
 
   /**
@@ -207,7 +230,7 @@ export class NotebookMigrationLLM {
       content: prompt,
     });
 
-    const result = await this.callModel(this.messages);
+    const result = await this.callModelWithTimeout(this.messages);
 
     this.messages.push({
       role: "assistant",

From 3698d6f30b04ec374c7f120d1b2d517846a5bcd7 Mon Sep 17 00:00:00 2001
From: Ryan Zhang <zyratlo@gmail.com>
Date: Thu, 13 Aug 2026 13:10:57 -0700
Subject: [PATCH 07/10] fix(python-notebook-migration, frontend): don't
 navigate after generation if the dashboard was left

---
 .../user-workflow.component.spec.ts              | 16 ++++++++++++++++
 .../user-workflow/user-workflow.component.ts     | 15 +++++++++++++--
 2 files changed, 29 insertions(+), 2 deletions(-)

diff --git a/frontend/src/app/dashboard/component/user/user-workflow/user-workflow.component.spec.ts b/frontend/src/app/dashboard/component/user/user-workflow/user-workflow.component.spec.ts
index eb0dcf3d9ea..655e4bee62f 100644
--- a/frontend/src/app/dashboard/component/user/user-workflow/user-workflow.component.spec.ts
+++ b/frontend/src/app/dashboard/component/user/user-workflow/user-workflow.component.spec.ts
@@ -414,6 +414,22 @@ describe("SavedWorkflowSectionComponent", () => {
       expect(createdName.endsWith("_GENERATED_BY_LLM")).toBe(true);
     });
 
+    it("saves but does not navigate when the component was destroyed mid-generation", async () => {
+      const { persist } = mockGenerationSuccess(99);
+      const navigateSpy = vi.spyOn(TestBed.inject(Router), "navigate").mockResolvedValue(true);
+      const infoSpy = vi.spyOn(TestBed.inject(NotificationService), "info").mockImplementation(() => {});
+      const requestImport = getRequestImport();
+      component.ngOnDestroy();
+
+      const proceed = await requestImport(ipynbFile, "gpt-4");
+
+      // The workflow is still created and saved, but the user is not yanked into the workspace.
+      expect(persist.createWorkflow).toHaveBeenCalledTimes(1);
+      expect(navigateSpy).not.toHaveBeenCalled();
+      expect(infoSpy).toHaveBeenCalledWith("Workflow generated and saved to your dashboard.");
+      expect(proceed).toBe(true);
+    });
+
     it("adds the new workflow to the current project when opened inside one", async () => {
       mockGenerationSuccess(99);
       vi.spyOn(TestBed.inject(Router), "navigate").mockResolvedValue(true);
diff --git a/frontend/src/app/dashboard/component/user/user-workflow/user-workflow.component.ts b/frontend/src/app/dashboard/component/user/user-workflow/user-workflow.component.ts
index 614fd204418..6deea84134e 100644
--- a/frontend/src/app/dashboard/component/user/user-workflow/user-workflow.component.ts
+++ b/frontend/src/app/dashboard/component/user/user-workflow/user-workflow.component.ts
@@ -17,7 +17,7 @@
  * under the License.
  */
 
-import { AfterViewInit, Component, Input, ViewChild } from "@angular/core";
+import { AfterViewInit, Component, Input, OnDestroy, ViewChild } from "@angular/core";
 import { Router } from "@angular/router";
 import { NzModalService } from "ng-zorro-antd/modal";
 import { firstValueFrom, from, lastValueFrom, Observable, of } from "rxjs";
@@ -121,8 +121,10 @@ import { FormsModule } from "@angular/forms";
     NzSpaceCompactComponent,
   ],
 })
-export class UserWorkflowComponent implements AfterViewInit {
+export class UserWorkflowComponent implements AfterViewInit, OnDestroy {
   private static readonly VIEW_MODE_STORAGE_KEY = "texera.userWorkflow.viewMode";
+  // Set on teardown so a generation that finishes after the user leaves does not navigate them back.
+  private destroyed = false;
   private _searchResultsComponent?: SearchResultsComponent;
   public isLogin = this.userService.isLogin();
   private includePublic = false;
@@ -209,6 +211,10 @@ export class UserWorkflowComponent implements AfterViewInit {
       .subscribe(() => this.search());
   }
 
+  ngOnDestroy(): void {
+    this.destroyed = true;
+  }
+
   /**
    * open the Modal to add workflow(s) to project
    */
@@ -407,6 +413,11 @@ export class UserWorkflowComponent implements AfterViewInit {
       console.error("Storing the notebook and mapping failed:", error);
     }
 
+    if (this.destroyed) {
+      this.notificationService.info("Workflow generated and saved to your dashboard.");
+      return true;
+    }
+
     const navigated = await this.router
       .navigate([USER_WORKSPACE, wid], { queryParams: { autolayout: 1 } })
       .catch(() => false);

From 2981604a282df40805a9541477de204325ed59b3 Mon Sep 17 00:00:00 2001
From: Ryan Zhang <zyratlo@gmail.com>
Date: Thu, 13 Aug 2026 14:02:23 -0700
Subject: [PATCH 08/10] test(python-notebook-migration, frontend): cover the
 callModel ai-SDK transport seam

---
 .../notebook-migration/migration-llm.spec.ts  | 29 +++++++++++++++++++
 .../notebook-migration/migration-llm.ts       |  7 ++---
 2 files changed, 31 insertions(+), 5 deletions(-)

diff --git a/frontend/src/app/workspace/service/notebook-migration/migration-llm.spec.ts b/frontend/src/app/workspace/service/notebook-migration/migration-llm.spec.ts
index ac0faf22090..c1ef22e6afc 100644
--- a/frontend/src/app/workspace/service/notebook-migration/migration-llm.spec.ts
+++ b/frontend/src/app/workspace/service/notebook-migration/migration-llm.spec.ts
@@ -386,6 +386,35 @@ describe("NotebookMigrationLLM", () => {
     });
   });
 
+  describe("callModel transport", () => {
+    it("forwards messages and the abort signal to generateText and returns its text", async () => {
+      // Exercise the real callModel body (the ai-SDK seam every other test stubs) with a minimal
+      // LanguageModelV2 fake, so no network call and no "ai" module mock is involved.
+      callModelSpy.mockRestore();
+      const llm = makeLLM();
+      (llm as any).model = {
+        specificationVersion: "v2",
+        provider: "mock",
+        modelId: "mock",
+        supportedUrls: {},
+        doGenerate: async () => ({
+          content: [{ type: "text", text: "pong" }],
+          finishReason: "stop",
+          usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 },
+          warnings: [],
+        }),
+      };
+
+      const result = await (llm as any).callModel(
+        [{ role: "user", content: "ping" }],
+        10,
+        new AbortController().signal
+      );
+
+      expect(result.text).toBe("pong");
+    });
+  });
+
   describe("request timeout", () => {
     it("rejects a stalled model call once the timeout elapses so the caller can recover", async () => {
       vi.useFakeTimers();
diff --git a/frontend/src/app/workspace/service/notebook-migration/migration-llm.ts b/frontend/src/app/workspace/service/notebook-migration/migration-llm.ts
index d68ed6504d6..ebfc82907f5 100644
--- a/frontend/src/app/workspace/service/notebook-migration/migration-llm.ts
+++ b/frontend/src/app/workspace/service/notebook-migration/migration-llm.ts
@@ -186,11 +186,8 @@ export class NotebookMigrationLLM {
     }
   }
 
-  // Seam over the `ai` transport. Specs stub this by spying the method, instead of
-  // mocking the "ai" module — module mocks are unreliable in the Angular unit-test
-  // builder when "ai" is also loaded by a sibling spec (e.g. via
-  // NotebookMigrationService), which silently breaks the mock and hangs these
-  // tests on a real network call.
+  // Seam over the `ai` transport. Specs spy this method rather than mocking the "ai" module:
+  // a module mock leaks across specs that share the "ai" import and hangs on a real network call.
   protected callModel(
     messages: ModelMessage[],
     maxOutputTokens?: number,

From c006e3063746e02905a1ac802c5bd58cbe2190cc Mon Sep 17 00:00:00 2001
From: Ryan Zhang <zyratlo@gmail.com>
Date: Fri, 14 Aug 2026 11:52:38 -0700
Subject: [PATCH 09/10] feat(python-notebook-migration): make the LLM request
 timeout configurable

---
 common/config/src/main/resources/gui.conf     |  4 +++
 .../texera/common/config/GuiConfig.scala      |  2 ++
 .../texera/common/config/GuiConfigSpec.scala  |  3 ++
 .../service/resource/ConfigResource.scala     |  3 +-
 .../common/service/gui-config.service.mock.ts |  1 +
 frontend/src/app/common/type/gui-config.ts    |  1 +
 .../notebook-migration/migration-llm.spec.ts  | 31 +++++++++++++++++--
 .../notebook-migration/migration-llm.ts       | 20 +++++++++---
 8 files changed, 57 insertions(+), 8 deletions(-)

diff --git a/common/config/src/main/resources/gui.conf b/common/config/src/main/resources/gui.conf
index b9908304fb0..d0f9f2e8cba 100644
--- a/common/config/src/main/resources/gui.conf
+++ b/common/config/src/main/resources/gui.conf
@@ -110,6 +110,10 @@ gui {
     # whether AI python-notebook migration feature is enabled
     python-notebook-migration-enabled = false
     python-notebook-migration-enabled = ${?GUI_WORKFLOW_WORKSPACE_PYTHON_NOTEBOOK_MIGRATION_ENABLED}
+
+    # how long a single AI python-notebook migration LLM request may run before it is aborted
+    python-notebook-migration-timeout-minutes = 10
+    python-notebook-migration-timeout-minutes = ${?GUI_WORKFLOW_WORKSPACE_PYTHON_NOTEBOOK_MIGRATION_TIMEOUT_MINUTES}
   }
 
   # whether to show the "Powered by Texera" attribution link in the sidebar
diff --git a/common/config/src/main/scala/org/apache/texera/common/config/GuiConfig.scala b/common/config/src/main/scala/org/apache/texera/common/config/GuiConfig.scala
index 6897b8e5121..9968d97c3bf 100644
--- a/common/config/src/main/scala/org/apache/texera/common/config/GuiConfig.scala
+++ b/common/config/src/main/scala/org/apache/texera/common/config/GuiConfig.scala
@@ -75,4 +75,6 @@ object GuiConfig {
     conf.getBoolean("gui.deployment-version-check-enabled")
   val guiWorkflowWorkspacePythonNotebookMigrationEnabled: Boolean =
     conf.getBoolean("gui.workflow-workspace.python-notebook-migration-enabled")
+  val guiWorkflowWorkspacePythonNotebookMigrationTimeoutMinutes: Int =
+    conf.getInt("gui.workflow-workspace.python-notebook-migration-timeout-minutes")
 }
diff --git a/common/config/src/test/scala/org/apache/texera/common/config/GuiConfigSpec.scala b/common/config/src/test/scala/org/apache/texera/common/config/GuiConfigSpec.scala
index afb1d908c4e..e121a7cc6cd 100644
--- a/common/config/src/test/scala/org/apache/texera/common/config/GuiConfigSpec.scala
+++ b/common/config/src/test/scala/org/apache/texera/common/config/GuiConfigSpec.scala
@@ -100,5 +100,8 @@ class GuiConfigSpec extends AnyFlatSpec with Matchers {
     ifUnset("GUI_WORKFLOW_WORKSPACE_LIMIT_COLUMNS")(
       GuiConfig.guiWorkflowWorkspaceLimitColumns shouldBe 15
     )
+    ifUnset("GUI_WORKFLOW_WORKSPACE_PYTHON_NOTEBOOK_MIGRATION_TIMEOUT_MINUTES")(
+      GuiConfig.guiWorkflowWorkspacePythonNotebookMigrationTimeoutMinutes shouldBe 10
+    )
   }
 }
diff --git a/config-service/src/main/scala/org/apache/texera/service/resource/ConfigResource.scala b/config-service/src/main/scala/org/apache/texera/service/resource/ConfigResource.scala
index a8887cda92a..18a35edc0a6 100644
--- a/config-service/src/main/scala/org/apache/texera/service/resource/ConfigResource.scala
+++ b/config-service/src/main/scala/org/apache/texera/service/resource/ConfigResource.scala
@@ -94,7 +94,8 @@ class ConfigResource {
       "activeTimeInMinutes" -> GuiConfig.guiWorkflowWorkspaceActiveTimeInMinutes,
       "copilotEnabled" -> GuiConfig.guiWorkflowWorkspaceCopilotEnabled,
       "limitColumns" -> GuiConfig.guiWorkflowWorkspaceLimitColumns,
-      "pythonNotebookMigrationEnabled" -> GuiConfig.guiWorkflowWorkspacePythonNotebookMigrationEnabled
+      "pythonNotebookMigrationEnabled" -> GuiConfig.guiWorkflowWorkspacePythonNotebookMigrationEnabled,
+      "pythonNotebookMigrationTimeoutMinutes" -> GuiConfig.guiWorkflowWorkspacePythonNotebookMigrationTimeoutMinutes
     )
 
   // Engine configs.
diff --git a/frontend/src/app/common/service/gui-config.service.mock.ts b/frontend/src/app/common/service/gui-config.service.mock.ts
index 93c8eaf0fdf..667a774743b 100644
--- a/frontend/src/app/common/service/gui-config.service.mock.ts
+++ b/frontend/src/app/common/service/gui-config.service.mock.ts
@@ -52,6 +52,7 @@ export class MockGuiConfigService {
     limitColumns: 15,
     attributionEnabled: false,
     pythonNotebookMigrationEnabled: false,
+    pythonNotebookMigrationTimeoutMinutes: 10,
     deploymentVersionCheckEnabled: false,
   };
 
diff --git a/frontend/src/app/common/type/gui-config.ts b/frontend/src/app/common/type/gui-config.ts
index 5da549acd96..d9750d7d3b1 100644
--- a/frontend/src/app/common/type/gui-config.ts
+++ b/frontend/src/app/common/type/gui-config.ts
@@ -43,6 +43,7 @@ export interface GuiConfig {
   limitColumns: number;
   attributionEnabled: boolean;
   pythonNotebookMigrationEnabled: boolean;
+  pythonNotebookMigrationTimeoutMinutes: number;
   deploymentVersionCheckEnabled: boolean;
 }
 
diff --git a/frontend/src/app/workspace/service/notebook-migration/migration-llm.spec.ts b/frontend/src/app/workspace/service/notebook-migration/migration-llm.spec.ts
index c1ef22e6afc..93f059121f7 100644
--- a/frontend/src/app/workspace/service/notebook-migration/migration-llm.spec.ts
+++ b/frontend/src/app/workspace/service/notebook-migration/migration-llm.spec.ts
@@ -17,7 +17,7 @@
  * under the License.
  */
 
-import { NotebookMigrationLLM, Notebook, LLM_REQUEST_TIMEOUT_MS } from "./migration-llm";
+import { NotebookMigrationLLM, Notebook, DEFAULT_LLM_REQUEST_TIMEOUT_MINUTES } from "./migration-llm";
 import { GuiConfigService } from "../../../common/service/gui-config.service";
 import { WorkflowUtilService } from "../workflow-graph/util/workflow-util.service";
 import { AuthService } from "../../../common/service/user/auth.service";
@@ -37,6 +37,7 @@ describe("NotebookMigrationLLM", () => {
     const stubConfig = {
       env: {
         pythonNotebookMigrationEnabled: true,
+        pythonNotebookMigrationTimeoutMinutes: 10,
         defaultDataTransferBatchSize: 400,
         defaultExecutionMode: "PIPELINED",
       },
@@ -424,7 +425,8 @@ describe("NotebookMigrationLLM", () => {
         const pending = makeLLM().convertNotebookToWorkflow({ cells: [codeCell("AAA", "a = 1")] });
         // Surface the rejection instead of letting it float as unhandled while timers advance.
         const assertion = expect(pending).rejects.toThrow(/timed out/);
-        await vi.advanceTimersByTimeAsync(LLM_REQUEST_TIMEOUT_MS);
+        // stubConfig sets pythonNotebookMigrationTimeoutMinutes to 10.
+        await vi.advanceTimersByTimeAsync(10 * 60 * 1000);
         await assertion;
       } finally {
         vi.useRealTimers();
@@ -444,6 +446,31 @@ describe("NotebookMigrationLLM", () => {
         vi.useRealTimers();
       }
     });
+
+    it("falls back to the default timeout when the configured value is non-positive", async () => {
+      vi.useFakeTimers();
+      try {
+        const stubConfig = {
+          env: {
+            pythonNotebookMigrationEnabled: true,
+            pythonNotebookMigrationTimeoutMinutes: 0,
+            defaultDataTransferBatchSize: 400,
+            defaultExecutionMode: "PIPELINED",
+          },
+        } as unknown as GuiConfigService;
+        const util = { getNewOperatorPredicate: vi.fn() } as unknown as WorkflowUtilService;
+        const llm = new NotebookMigrationLLM(stubConfig, util);
+        llm.initialize("gpt-5-mini", "test-token");
+
+        callModelSpy.mockReturnValue(new Promise<{ text: string }>(() => {}));
+        const pending = llm.convertNotebookToWorkflow({ cells: [codeCell("AAA", "a = 1")] });
+        const assertion = expect(pending).rejects.toThrow(/timed out/);
+        await vi.advanceTimersByTimeAsync(DEFAULT_LLM_REQUEST_TIMEOUT_MINUTES * 60 * 1000);
+        await assertion;
+      } finally {
+        vi.useRealTimers();
+      }
+    });
   });
 
   describe("initialization guards", () => {
diff --git a/frontend/src/app/workspace/service/notebook-migration/migration-llm.ts b/frontend/src/app/workspace/service/notebook-migration/migration-llm.ts
index ebfc82907f5..67bfdba68d2 100644
--- a/frontend/src/app/workspace/service/notebook-migration/migration-llm.ts
+++ b/frontend/src/app/workspace/service/notebook-migration/migration-llm.ts
@@ -79,7 +79,7 @@ interface CombinedMapping {
  * Terminal UDFs (no outgoing edge) declare their outputs as `string` so the result panel
  * renders viewable values rather than opaque binary blobs.
  */
-export const LLM_REQUEST_TIMEOUT_MS = 10 * 60 * 1000;
+export const DEFAULT_LLM_REQUEST_TIMEOUT_MINUTES = 10;
 
 @Injectable()
 export class NotebookMigrationLLM {
@@ -196,17 +196,27 @@ export class NotebookMigrationLLM {
     return generateText({ model: this.model, messages, maxOutputTokens, abortSignal });
   }
 
+  // Deployment-configurable bound (in minutes), falling back to the default when unset or non-positive.
+  private get timeoutMinutes(): number {
+    const configured = this.config.env.pythonNotebookMigrationTimeoutMinutes;
+    return configured > 0 ? configured : DEFAULT_LLM_REQUEST_TIMEOUT_MINUTES;
+  }
+
   // Wraps callModel with a hard timeout so a stalled request cannot hang forever. The abort
   // cancels the underlying request when the transport honors it; the race guarantees rejection
   // even if it does not, so the caller's error path always runs.
   private callModelWithTimeout(messages: ModelMessage[], maxOutputTokens?: number): Promise<{ text: string }> {
+    const minutes = this.timeoutMinutes;
     const controller = new AbortController();
     let timer: ReturnType<typeof setTimeout> | undefined;
     const timeout = new Promise<never>((_resolve, reject) => {
-      timer = setTimeout(() => {
-        controller.abort();
-        reject(new Error(`LLM request timed out after ${LLM_REQUEST_TIMEOUT_MS} ms`));
-      }, LLM_REQUEST_TIMEOUT_MS);
+      timer = setTimeout(
+        () => {
+          controller.abort();
+          reject(new Error(`LLM request timed out after ${minutes} minutes`));
+        },
+        minutes * 60 * 1000
+      );
     });
     return Promise.race([this.callModel(messages, maxOutputTokens, controller.signal), timeout]).finally(() =>
       clearTimeout(timer)

From 5ca6244b4adbf5affef9cdd86b0147ff81a27c32 Mon Sep 17 00:00:00 2001
From: Ryan Zhang <zyratlo@gmail.com>
Date: Fri, 14 Aug 2026 11:56:29 -0700
Subject: [PATCH 10/10] fix(python-notebook-migration, frontend): show a
 distinct message when generation times out

---
 .../user-workflow.component.spec.ts            | 18 ++++++++++++++++++
 .../user-workflow/user-workflow.component.ts   | 10 ++++++++--
 .../notebook-migration/migration-llm.spec.ts   | 15 +++++++++++----
 .../notebook-migration/migration-llm.ts        | 13 ++++++++++++-
 4 files changed, 49 insertions(+), 7 deletions(-)

diff --git a/frontend/src/app/dashboard/component/user/user-workflow/user-workflow.component.spec.ts b/frontend/src/app/dashboard/component/user/user-workflow/user-workflow.component.spec.ts
index 655e4bee62f..db2c2317b8c 100644
--- a/frontend/src/app/dashboard/component/user/user-workflow/user-workflow.component.spec.ts
+++ b/frontend/src/app/dashboard/component/user/user-workflow/user-workflow.component.spec.ts
@@ -76,6 +76,7 @@ import { USER_WORKSPACE } from "../../../../app-routing.constant";
 import { GuiConfigService } from "../../../../common/service/gui-config.service";
 import { MockGuiConfigService } from "../../../../common/service/gui-config.service.mock";
 import { NotebookMigrationService } from "../../../../workspace/service/notebook-migration/notebook-migration.service";
+import { LlmRequestTimeoutError } from "../../../../workspace/service/notebook-migration/migration-llm";
 import { NotebookImportModalComponent } from "../../../../workspace/component/notebook-import-modal/notebook-import-modal.component";
 import { NzUploadFile } from "ng-zorro-antd/upload";
 import type { Mocked } from "vitest";
@@ -482,6 +483,23 @@ describe("SavedWorkflowSectionComponent", () => {
       expect(persist.createWorkflow).not.toHaveBeenCalled();
     });
 
+    it("reports a distinct timeout message when generation times out", async () => {
+      const migration = TestBed.inject(NotebookMigrationService);
+      vi.spyOn(migration, "parseAndTagNotebook").mockResolvedValue({ cells: [] } as any);
+      vi.spyOn(migration, "sendToAIGenerateWorkflow").mockRejectedValue(new LlmRequestTimeoutError(10));
+      const persist = TestBed.inject(WorkflowPersistService) as any;
+      persist.createWorkflow = vi.fn();
+      const errorSpy = vi.spyOn(TestBed.inject(NotificationService), "error").mockImplementation(() => {});
+
+      const proceed = await getRequestImport()(ipynbFile, "gpt-4");
+
+      expect(proceed).toBe(false);
+      expect(errorSpy).toHaveBeenCalledWith(
+        "Generation timed out after 10 minutes. Try again, choose a faster model, or simplify the notebook."
+      );
+      expect(persist.createWorkflow).not.toHaveBeenCalled();
+    });
+
     it("reports a save failure and resolves false when the created workflow has no wid", async () => {
       const migration = TestBed.inject(NotebookMigrationService);
       vi.spyOn(migration, "parseAndTagNotebook").mockResolvedValue({ cells: [] } as any);
diff --git a/frontend/src/app/dashboard/component/user/user-workflow/user-workflow.component.ts b/frontend/src/app/dashboard/component/user/user-workflow/user-workflow.component.ts
index 6deea84134e..4bd6acda2b9 100644
--- a/frontend/src/app/dashboard/component/user/user-workflow/user-workflow.component.ts
+++ b/frontend/src/app/dashboard/component/user/user-workflow/user-workflow.component.ts
@@ -50,7 +50,7 @@ import {
   MappingContent,
   NotebookMigrationService,
 } from "../../../../workspace/service/notebook-migration/notebook-migration.service";
-import { Notebook } from "../../../../workspace/service/notebook-migration/migration-llm";
+import { LlmRequestTimeoutError, Notebook } from "../../../../workspace/service/notebook-migration/migration-llm";
 import {
   NotebookImportModalComponent,
   NotebookImportModalData,
@@ -369,7 +369,13 @@ export class UserWorkflowComponent implements AfterViewInit, OnDestroy {
     try {
       generated = await this.notebookMigrationService.sendToAIGenerateWorkflow(notebook, model);
     } catch (error) {
-      this.notificationService.error("Error while communicating with the LLM, check console for details.");
+      if (error instanceof LlmRequestTimeoutError) {
+        this.notificationService.error(
+          `Generation timed out after ${error.minutes} minutes. Try again, choose a faster model, or simplify the notebook.`
+        );
+      } else {
+        this.notificationService.error("Error while communicating with the LLM, check console for details.");
+      }
       console.error("LLM generation failed:", error);
       return false;
     }
diff --git a/frontend/src/app/workspace/service/notebook-migration/migration-llm.spec.ts b/frontend/src/app/workspace/service/notebook-migration/migration-llm.spec.ts
index 93f059121f7..da1961efa34 100644
--- a/frontend/src/app/workspace/service/notebook-migration/migration-llm.spec.ts
+++ b/frontend/src/app/workspace/service/notebook-migration/migration-llm.spec.ts
@@ -17,7 +17,12 @@
  * under the License.
  */
 
-import { NotebookMigrationLLM, Notebook, DEFAULT_LLM_REQUEST_TIMEOUT_MINUTES } from "./migration-llm";
+import {
+  NotebookMigrationLLM,
+  Notebook,
+  DEFAULT_LLM_REQUEST_TIMEOUT_MINUTES,
+  LlmRequestTimeoutError,
+} from "./migration-llm";
 import { GuiConfigService } from "../../../common/service/gui-config.service";
 import { WorkflowUtilService } from "../workflow-graph/util/workflow-util.service";
 import { AuthService } from "../../../common/service/user/auth.service";
@@ -423,11 +428,13 @@ describe("NotebookMigrationLLM", () => {
         // A request that never settles: only the timeout can end it.
         callModelSpy.mockReturnValue(new Promise<{ text: string }>(() => {}));
         const pending = makeLLM().convertNotebookToWorkflow({ cells: [codeCell("AAA", "a = 1")] });
-        // Surface the rejection instead of letting it float as unhandled while timers advance.
-        const assertion = expect(pending).rejects.toThrow(/timed out/);
+        // Reject with a typed error carrying the configured minutes, so callers can message precisely.
+        const captured = pending.catch(error => error);
         // stubConfig sets pythonNotebookMigrationTimeoutMinutes to 10.
         await vi.advanceTimersByTimeAsync(10 * 60 * 1000);
-        await assertion;
+        const error = await captured;
+        expect(error).toBeInstanceOf(LlmRequestTimeoutError);
+        expect(error.minutes).toBe(10);
       } finally {
         vi.useRealTimers();
       }
diff --git a/frontend/src/app/workspace/service/notebook-migration/migration-llm.ts b/frontend/src/app/workspace/service/notebook-migration/migration-llm.ts
index 67bfdba68d2..4bafa095e2c 100644
--- a/frontend/src/app/workspace/service/notebook-migration/migration-llm.ts
+++ b/frontend/src/app/workspace/service/notebook-migration/migration-llm.ts
@@ -81,6 +81,17 @@ interface CombinedMapping {
  */
 export const DEFAULT_LLM_REQUEST_TIMEOUT_MINUTES = 10;
 
+// Thrown when a model request exceeds the configured timeout, so callers can tell a slow-but-timed-out
+// request apart from a genuine transport error and message the user accordingly.
+export class LlmRequestTimeoutError extends Error {
+  constructor(public readonly minutes: number) {
+    super(`LLM request timed out after ${minutes} minutes`);
+    this.name = "LlmRequestTimeoutError";
+    // Keep instanceof correct regardless of the compile target.
+    Object.setPrototypeOf(this, LlmRequestTimeoutError.prototype);
+  }
+}
+
 @Injectable()
 export class NotebookMigrationLLM {
   private model: any;
@@ -213,7 +224,7 @@ export class NotebookMigrationLLM {
       timer = setTimeout(
         () => {
           controller.abort();
-          reject(new Error(`LLM request timed out after ${minutes} minutes`));
+          reject(new LlmRequestTimeoutError(minutes));
         },
         minutes * 60 * 1000
       );