@marimo-team/frontend 0.25.2-dev99 → 0.25.3-dev10

package/src/components/editor/output/MarimoTracebackOutput.tsx

@@ -22,6 +22,7 @@ import {
 import { Kbd } from "@/components/ui/kbd";
 import { Tooltip } from "@/components/ui/tooltip";
 import { getCellEditorView } from "@/core/cells/cells";
+import { buildErrorReport } from "@/core/cells/error-report";
 import type { CellId } from "@/core/cells/ids";
 import { SCRATCH_CELL_ID } from "@/core/cells/ids";
 import { toggleBreakpoint } from "@/core/codemirror/cells/debugger-state";
@@ -34,6 +35,7 @@ import { isWasm } from "@/core/wasm/utils";
 import { renderHTML } from "@/plugins/core/RenderHTML";
 import { sanitizeHtml } from "@/plugins/core/sanitize-html";
 import { copyToClipboard } from "@/utils/copy";
+import { parseHtmlContent } from "@/utils/dom";
 import {
   containsMangledLocal,
   splitMangledLocals,
@@ -46,33 +48,45 @@ import {
 import { useOpenAiAssistant } from "../chrome/wrapper/useOpenAiAssistant";
 import { AIFixButton, buildFixInChatPrompt } from "../errors/auto-fix";
 import { MangledSegments } from "../errors/mangled-local-chip";
+import { SendErrorReportButton } from "../errors/send-error-report-button";
 import { CellLinkTraceback } from "../links/cell-link";
 import type { OnRefactorWithAI } from "../Output";
 
 interface Props {
   cellId: CellId | undefined;
   traceback: string;
+  tracebackFormat?: "html" | "text";
+  code?: string;
   onRefactorWithAI?: OnRefactorWithAI;
 }
 
-/**
- * List of errors due to violations of Marimo semantics.
- */
+/** Render a traceback and actions for its captured execution. */
 export const MarimoTracebackOutput = ({
   onRefactorWithAI,
   traceback,
+  tracebackFormat = "html",
   cellId,
+  code,
 }: Props): JSX.Element => {
-  const htmlTraceback = renderHTML({
-    html: traceback,
-    additionalReplacements: [
-      replaceTracebackFilenames,
-      replaceTracebackPrefix,
-      replaceMangledLocal,
-    ],
-  });
+  const htmlTraceback =
+    tracebackFormat === "text" ? (
+      <pre>{traceback}</pre>
+    ) : (
+      renderHTML({
+        html: traceback,
+        additionalReplacements: [
+          replaceTracebackFilenames,
+          replaceTracebackPrefix,
+          replaceMangledLocal,
+        ],
+      })
+    );
 
-  const lastTracebackLine = lastLine(traceback);
+  const textTraceback =
+    tracebackFormat === "html"
+      ? parseHtmlContent(sanitizeHtml(traceback))
+      : traceback;
+  const lastTracebackLine = lastLine(textTraceback);
   const aiFeaturesEnabled = useAtomValue(aiFeaturesEnabledAtom);
   const openAiAssistant = useOpenAiAssistant();
 
@@ -131,6 +145,13 @@ export const MarimoTracebackOutput = ({
         </div>
       )}
       <div className="flex gap-2">
+        {cellId && lastTracebackLine && (
+          <SendErrorReportButton
+            getContent={() =>
+              buildErrorReport(cellId, { code, traceback, tracebackFormat })
+            }
+          />
+        )}
         {showAIFix && (
           <AIFixButton
             tooltip="Fix with AI"
@@ -186,11 +207,7 @@ export const MarimoTracebackOutput = ({
               </DropdownMenuItem>
               <DropdownMenuItem
                 onClick={() => {
-                  // Strip HTML from the traceback (sanitize first to prevent XSS)
-                  const div = document.createElement("div");
-                  div.innerHTML = sanitizeHtml(traceback);
-                  const textContent = div.textContent || "";
-                  copyToClipboard(textContent);
+                  copyToClipboard(textTraceback);
                 }}
               >
                 <CopyIcon className="h-4 w-4 mr-2" />
@@ -205,9 +222,7 @@ export const MarimoTracebackOutput = ({
 };
 
 function lastLine(text: string): string {
-  const el = document.createElement("div");
-  el.innerHTML = sanitizeHtml(text);
-  const lines = el.textContent?.split("\n").filter(Boolean);
+  const lines = text.split("\n").filter(Boolean);
   return lines?.at(-1) || "";
 }
 

package/src/components/editor/output/__tests__/ansi-reduce.test.ts

@@ -7,6 +7,24 @@ import {
   TerminalBuffer,
 } from "../ansi-reduce";
 
+test("preserves source evidence through stateful output and serialization", () => {
+  const output = StatefulOutputMessage.create({
+    channel: "stderr",
+    mimetype: "application/vnd.marimo+traceback",
+    timestamp: 1,
+    data: "<pre>ValueError:",
+    code: "raise ValueError('failed code')",
+  }).appendData(" failed code</pre>");
+  expect(output.code).toBe("raise ValueError('failed code')");
+  expect(output.toJSON()).toEqual({
+    channel: "stderr",
+    mimetype: "application/vnd.marimo+traceback",
+    timestamp: 1,
+    data: "<pre>ValueError: failed code</pre>",
+    code: "raise ValueError('failed code')",
+  });
+});
+
 describe("TerminalBuffer", () => {
   test("writeChar writes single character", () => {
     const buffer = new TerminalBuffer();

package/src/components/editor/output/ansi-reduce.ts

@@ -368,6 +368,7 @@ export class StatefulOutputMessage implements OutputMessage {
   public readonly mimetype: OutputMessage["mimetype"];
   public readonly channel: OutputMessage["channel"];
   public readonly timestamp: OutputMessage["timestamp"];
+  public readonly code: OutputMessage["code"];
   private ansiReducer = new AnsiReducer();
   private _data: string;
 
@@ -383,6 +384,7 @@ export class StatefulOutputMessage implements OutputMessage {
       message.channel,
       message.timestamp,
       ansiReducer,
+      message.code,
     );
   }
 
@@ -391,10 +393,12 @@ export class StatefulOutputMessage implements OutputMessage {
     channel: OutputMessage["channel"],
     timestamp: OutputMessage["timestamp"],
     ansiReducer: AnsiReducer,
+    code: OutputMessage["code"],
   ) {
     this.mimetype = mimetype;
     this.channel = channel;
     this.timestamp = timestamp;
+    this.code = code;
     this.ansiReducer = ansiReducer;
     this._data = this.ansiReducer.render();
   }
@@ -406,6 +410,7 @@ export class StatefulOutputMessage implements OutputMessage {
       this.channel,
       this.timestamp,
       this.ansiReducer,
+      this.code,
     );
   }
 
@@ -415,6 +420,7 @@ export class StatefulOutputMessage implements OutputMessage {
       channel: this.channel,
       timestamp: this.timestamp,
       data: this.data,
+      ...(this.code === undefined ? {} : { code: this.code }),
     };
   }
 }

package/src/components/editor/output/console/ConsoleOutput.tsx

@@ -360,10 +360,12 @@ const StdInput = (props: {
           }
 
           if (e.key === "Enter" && !e.shiftKey) {
-            if (value && !isPassword) {
-              addToHistory(value);
+            // Submit the visible input even if its change has not committed yet.
+            const submittedValue = e.currentTarget.value;
+            if (submittedValue && !isPassword) {
+              addToHistory(submittedValue);
             }
-            onSubmit(value);
+            onSubmit(submittedValue);
             setValue("");
             e.preventDefault();
             e.stopPropagation();

package/src/components/editor/output/console/__tests__/ConsoleOutput.test.tsx

@@ -179,6 +179,24 @@ describe("ConsoleOutput pdb history", () => {
     expect(nextInput).toHaveValue("");
   });
 
+  it("submits the visible input when its change has not reached React state", () => {
+    const onSubmitDebugger = vi.fn();
+    renderWithProvider(
+      <ConsoleOutput
+        {...defaultProps}
+        consoleOutputs={[stdinPrompt("Name: ")]}
+        onSubmitDebugger={onSubmitDebugger}
+      />,
+    );
+
+    const input = screen.getByTestId<HTMLInputElement>("console-input");
+    // Browser autofill or input events can precede the controlled-state update.
+    input.value = "marimo";
+    fireEvent.keyDown(input, { key: "Enter" });
+
+    expect(onSubmitDebugger).toHaveBeenCalledWith("marimo", 0);
+  });
+
   it("should submit an empty string when Enter is pressed with no input", () => {
     // Many CLIs prompt "Press Enter to continue" and expect "" back.
     const onSubmitDebugger = vi.fn();

package/src/components/storage/__tests__/storage-file-viewer.test.tsx

@@ -2,6 +2,7 @@
 
 import { render, screen } from "@testing-library/react";
 import { afterEach, describe, expect, it, vi } from "vitest";
+import { requestId } from "@/__tests__/branded";
 import { TooltipProvider } from "@/components/ui/tooltip";
 import { DownloadStorage } from "@/core/storage/request-registry";
 import { StorageFileViewer } from "../storage-file-viewer";
@@ -41,7 +42,7 @@ describe("StorageFileViewer", () => {
 
   it("renders TOML from generic storage metadata as read-only TOML", async () => {
     const request = vi.spyOn(DownloadStorage, "request").mockResolvedValue({
-      request_id: "request-id",
+      request_id: requestId("request-id"),
       url: "https://example.com/pyproject.toml?signature=secret",
     });
     vi.stubGlobal(

package/src/core/attachments/__tests__/toast.test.tsx

@@ -0,0 +1,58 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+// @vitest-environment jsdom
+
+import { act, render, renderHook } from "@testing-library/react";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { Toaster } from "@/components/ui/toaster";
+import { clearToasts, toast, useToast } from "@/components/ui/use-toast";
+import { agentToast } from "../toast";
+
+describe("agent notifications", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    clearToasts();
+  });
+
+  afterEach(() => {
+    act(() => {
+      clearToasts();
+      vi.runOnlyPendingTimers();
+    });
+    vi.useRealTimers();
+  });
+
+  it.each([
+    { variant: undefined, duration: 3000 },
+    { variant: "danger" as const, duration: 5000 },
+  ])("expires while the window is blurred: %j", ({ variant, duration }) => {
+    const { result } = renderHook(useToast);
+    render(<Toaster />);
+    act(() => agentToast({ title: "Agent notice", variant }));
+    act(() => window.dispatchEvent(new Event("blur")));
+    act(() => vi.advanceTimersByTime(duration - 1));
+    expect(result.current.toasts[0].open).toBe(true);
+    act(() => vi.advanceTimersByTime(1));
+    expect(result.current.toasts[0].open).toBe(false);
+  });
+
+  it("preserves pause behavior for ordinary notifications", () => {
+    const { result } = renderHook(useToast);
+    render(<Toaster />);
+    act(() => toast({ title: "Ordinary notice", duration: 3000 }));
+    act(() => window.dispatchEvent(new Event("blur")));
+    act(() => vi.advanceTimersByTime(5000));
+    expect(result.current.toasts[0].open).toBe(true);
+  });
+
+  it("does not let an older timer dismiss a newer notification", () => {
+    const { result } = renderHook(useToast);
+    act(() => agentToast({ title: "First" }));
+    act(() => vi.advanceTimersByTime(1000));
+    act(() => agentToast({ title: "Second" }));
+    act(() => vi.advanceTimersByTime(2000));
+    expect(result.current.toasts[0].title).toBe("Second");
+    expect(result.current.toasts[0].open).toBe(true);
+    act(() => vi.advanceTimersByTime(1000));
+    expect(result.current.toasts[0].open).toBe(false);
+  });
+});

package/src/core/attachments/state.ts

@@ -0,0 +1,21 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import type { components } from "@marimo-team/marimo-api";
+import { atom } from "jotai";
+import { isConnectedAtom } from "@/core/network/connection";
+
+export type Attachment = components["schemas"]["Attachment"];
+
+export const attachmentsAtom = atom<Attachment[]>([]);
+export const agentAttachmentsAtom = atom((get) => {
+  if (!get(isConnectedAtom)) {
+    return [];
+  }
+  return get(attachmentsAtom).filter(
+    (attachment) => attachment.kind === "agent",
+  );
+});
+
+export function attachmentLabel(attachment: Attachment): string {
+  return attachment.name || "Agent";
+}

package/src/core/attachments/toast.ts

@@ -0,0 +1,15 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import { toast } from "@/components/ui/use-toast";
+
+export function agentToast(
+  options: Pick<
+    Parameters<typeof toast>[0],
+    "title" | "variant" | "description"
+  >,
+) {
+  const duration = options.variant === "danger" ? 5000 : 3000;
+  const { dismiss } = toast({ ...options, duration });
+  // Agent notices must also expire while the user focuses the agent terminal.
+  window.setTimeout(dismiss, duration);
+}

package/src/core/cells/__tests__/cells.test.ts

@@ -789,6 +789,58 @@ describe("cell reducer", () => {
     `);
   });
 
+  it("keeps error evidence after an edit and a new queued run", () => {
+    const code = "raise ValueError('old failure')";
+    const output: OutputMessage = {
+      channel: "marimo-error",
+      mimetype: "application/vnd.marimo+error",
+      data: [
+        {
+          type: "exception",
+          msg: "old failure",
+          exception_type: "ValueError",
+          raising_cell: null,
+          traceback: "<pre>ValueError: old failure</pre>",
+        },
+      ],
+      code,
+      timestamp: 1,
+    };
+    actions.handleCellMessage({
+      cell_id: firstCellId,
+      output,
+      console: {
+        channel: "stderr",
+        mimetype: "application/vnd.marimo+traceback",
+        data: "<pre>ValueError: old failure</pre>",
+        code,
+        timestamp: 1,
+      },
+      status: "idle",
+      stale_inputs: null,
+      timestamp: 1,
+    });
+    actions.updateCellCode({
+      cellId: firstCellId,
+      code: "print('new code')",
+      formattingChange: false,
+    });
+    actions.prepareForRun({ cellId: firstCellId });
+    actions.handleCellMessage({
+      cell_id: firstCellId,
+      output: null,
+      console: null,
+      status: "queued",
+      stale_inputs: null,
+      timestamp: 2,
+    });
+    const runtime = state.cellRuntime[firstCellId];
+    expect(state.cellData[firstCellId].lastCodeRun).toBe("print('new code')");
+    expect(runtime.output).toEqual(output);
+    expect(runtime.consoleOutputs[0].code).toBe(code);
+    expect(runtime.consoleOutputs[0].data).toContain("old failure");
+  });
+
   it("can run cell and receive cell messages", () => {
     // HAPPY PATH
     /////////////////

package/src/core/cells/__tests__/document-roundtrip.test.ts

@@ -178,6 +178,22 @@ function documentSnapshot(state: NotebookState) {
 }
 
 describe("document round-trip", () => {
+  it("applies a server transaction that deletes every cell", () => {
+    setup("a", "b");
+    applyTransactionChanges(
+      [
+        ...replica.cellIds.inOrderIds.map((cellId) => ({
+          type: "delete-cell" as const,
+          cellId,
+        })),
+        { type: "reorder-cells", cellIds: [] },
+      ],
+      replicaActions,
+      () => replica.cellIds.inOrderIds,
+    );
+    expect(documentSnapshot(replica)).toEqual([]);
+  });
+
   it("initial setup converges", () => {
     setup("a", "b", "c");
     expect(documentSnapshot(primary)).toEqual(documentSnapshot(replica));

package/src/core/cells/__tests__/error-report.test.ts

@@ -0,0 +1,139 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+// @vitest-environment jsdom
+
+import { describe, expect, it } from "vitest";
+import { cellId } from "@/__tests__/branded";
+import type { MarimoError } from "@/core/kernel/messages";
+import { buildErrorReport, ERROR_MESSAGE_INSTRUCTIONS } from "../error-report";
+
+const CELL_ID = cellId("failed-cell");
+
+describe("buildErrorReport", () => {
+  it("preserves plain traceback text without treating angle brackets as HTML", () => {
+    const traceback =
+      '  File "<cell>", line 1\nValueError: expected <value> & got <other>';
+    expect(
+      buildErrorReport(CELL_ID, { traceback, tracebackFormat: "text" }).output,
+    ).toEqual({
+      type: "error",
+      instructions: ERROR_MESSAGE_INSTRUCTIONS,
+      message: "ValueError: expected <value> & got <other>",
+      traceback,
+    });
+  });
+  it("owns the instruction to repair the live notebook", () => {
+    const report = buildErrorReport(CELL_ID, {
+      errors: [{ type: "syntax", msg: "invalid code" }],
+    });
+    expect(report.output.instructions).toEqual("Fix this notebook error.");
+  });
+
+  it("keeps repair intent visible before oversized evidence", () => {
+    const report = buildErrorReport(CELL_ID, {
+      code: "# long code\n".repeat(10_000),
+      errors: [
+        {
+          type: "exception",
+          exception_type: "ValueError",
+          msg: "long error ".repeat(10_000),
+          raising_cell: null,
+          traceback: `<pre>Traceback\n${"long frame\n".repeat(10_000)}</pre>`,
+        },
+      ],
+    });
+    const serialized = JSON.stringify(report);
+
+    expect(serialized.length).toBeGreaterThan(8192);
+    expect(serialized.slice(0, 256)).toContain(
+      '"instructions":"Fix this notebook error."',
+    );
+  });
+
+  it("retains every message and complete traceback without display limits", () => {
+    const traceback = `Traceback\n${"long frame\n".repeat(10_000)}ValueError: bad <value>`;
+    const errors: MarimoError[] = [
+      {
+        type: "exception",
+        msg: "bad <value>",
+        exception_type: "ValueError",
+        raising_cell: null,
+        traceback: `<pre>${traceback.replaceAll("<", "&lt;").replaceAll(">", "&gt;")}</pre>`,
+      },
+      { type: "syntax", msg: "another error" },
+    ];
+    expect(buildErrorReport(CELL_ID, { code: "failed()", errors })).toEqual({
+      type: "cell-output",
+      cell_id: CELL_ID,
+      code: "failed()",
+      output: {
+        type: "error",
+        instructions: ERROR_MESSAGE_INSTRUCTIONS,
+        message: "bad <value>\nanother error",
+        traceback,
+      },
+    });
+  });
+
+  it("leaves source unknown for a restored legacy exception", () => {
+    expect(
+      buildErrorReport(CELL_ID, {
+        errors: [
+          {
+            type: "exception",
+            exception_type: "exception",
+            msg: "legacy error",
+            raising_cell: null,
+            traceback: null,
+          },
+        ],
+      }),
+    ).toEqual({
+      type: "cell-output",
+      cell_id: CELL_ID,
+      output: {
+        type: "error",
+        instructions: ERROR_MESSAGE_INSTRUCTIONS,
+        message: "legacy error",
+      },
+    });
+  });
+
+  it("preserves empty captured code", () => {
+    expect(
+      buildErrorReport(CELL_ID, {
+        code: "",
+        errors: [{ type: "syntax", msg: "invalid code" }],
+      }),
+    ).toEqual({
+      type: "cell-output",
+      cell_id: CELL_ID,
+      code: "",
+      output: {
+        type: "error",
+        instructions: ERROR_MESSAGE_INSTRUCTIONS,
+        message: "invalid code",
+      },
+    });
+  });
+
+  it("keeps separate structured tracebacks in order", () => {
+    const errors: MarimoError[] = ["first", "second"].map((message) => ({
+      type: "exception",
+      exception_type: "ValueError",
+      raising_cell: null,
+      msg: message,
+      traceback: `<pre>Traceback\nValueError: ${message}</pre>`,
+    }));
+    expect(buildErrorReport(CELL_ID, { errors })).toEqual({
+      type: "cell-output",
+      cell_id: CELL_ID,
+      output: {
+        type: "error",
+        instructions: ERROR_MESSAGE_INSTRUCTIONS,
+        message: "first\nsecond",
+        traceback:
+          "Traceback\nValueError: first\n\nTraceback\nValueError: second",
+      },
+    });
+  });
+});

package/src/core/cells/__tests__/session.test.ts

@@ -174,8 +174,11 @@ describe("notebookStateFromSession", () => {
         channel: "marimo-error",
         data: [
           {
-            type: "unknown",
+            type: "exception",
+            exception_type: "ValueError",
             msg: "Something went wrong",
+            raising_cell: null,
+            traceback: "Traceback line 1",
           },
         ],
         mimetype: "application/vnd.marimo+error",
@@ -183,6 +186,52 @@ describe("notebookStateFromSession", () => {
       });
     });
 
+    it("restores matching code from the session", () => {
+      const code = "raise ValueError('cached failure')";
+      const session = createSession([
+        createSessionCell(
+          "cell-1",
+          [
+            {
+              type: "error",
+              ename: "ValueError",
+              evalue: "cached failure",
+              traceback: ["Traceback\n", "ValueError: cached failure"],
+              code,
+            },
+          ],
+          [
+            {
+              type: "stream",
+              name: "stderr",
+              text: "ValueError: cached <failure>",
+              mimetype: "application/vnd.marimo+traceback",
+              traceback_format: "text",
+              code,
+            },
+          ],
+        ),
+      ]);
+      const state = notebookStateFromSession(session, null);
+      invariant(state, "state is null");
+      expect(state.cellRuntime[CELL_1].output).toMatchObject({
+        code,
+        data: [
+          {
+            type: "exception",
+            exception_type: "ValueError",
+            msg: "cached failure",
+            traceback: "Traceback\nValueError: cached failure",
+          },
+        ],
+      });
+      expect(state.cellRuntime[CELL_1].consoleOutputs[0].code).toBe(code);
+      expect(state.cellRuntime[CELL_1].consoleOutputs[0]).toMatchObject({
+        traceback_format: "text",
+        data: "ValueError: cached <failure>",
+      });
+    });
+
     it("handles data output in session cell", () => {
       const dataOutput = {
         type: "data" as const,