@marimo-team/islands 0.25.3-dev4 → 0.25.3-dev6

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/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__/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,

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

@@ -0,0 +1,63 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import { describeError } from "@/core/errors/error-entries";
+import type { MarimoError } from "@/core/kernel/messages";
+import { sanitizeHtml } from "@/plugins/core/sanitize-html";
+import { parseHtmlContent } from "@/utils/dom";
+import type { CellId } from "./ids";
+
+export interface CellOutputMessage<Output> {
+  type: "cell-output";
+  cell_id: CellId;
+  code?: string;
+  output: Output;
+}
+
+export interface ErrorMessageOutput {
+  type: "error";
+  instructions: string;
+  message: string;
+  traceback?: string;
+}
+
+export const ERROR_MESSAGE_INSTRUCTIONS = "Fix this notebook error.";
+
+export function buildErrorReport(
+  cellId: CellId,
+  evidence: { code?: string } & (
+    | { errors: MarimoError[] }
+    | { traceback: string; tracebackFormat: "html" | "text" }
+  ),
+): CellOutputMessage<ErrorMessageOutput> {
+  let message: string;
+  let traceback: string;
+  if ("errors" in evidence) {
+    message = evidence.errors.map(describeError).join("\n");
+    traceback = evidence.errors
+      .flatMap((error) =>
+        "traceback" in error && error.traceback
+          ? [parseHtmlContent(sanitizeHtml(error.traceback))]
+          : [],
+      )
+      .join("\n\n");
+  } else {
+    traceback =
+      evidence.tracebackFormat === "html"
+        ? parseHtmlContent(sanitizeHtml(evidence.traceback))
+        : evidence.traceback;
+    message = traceback.split("\n").findLast((line) => line.length > 0) ?? "";
+  }
+
+  // Put repair intent before evidence so it survives prefix truncation.
+  return {
+    type: "cell-output",
+    cell_id: cellId,
+    output: {
+      type: "error",
+      instructions: ERROR_MESSAGE_INSTRUCTIONS,
+      message,
+      ...(traceback ? { traceback } : {}),
+    },
+    ...(evidence.code === undefined ? {} : { code: evidence.code }),
+  };
+}

package/src/core/cells/session.ts

@@ -206,8 +206,20 @@ function createCellRuntimeFromSession(
         channel: "marimo-error",
         data: [
           {
-            type: "unknown",
+            type: "exception",
+            exception_type: primaryOutput.ename,
             msg: primaryOutput.evalue,
+            raising_cell: null,
+            traceback:
+              primaryOutput.traceback.length === 0
+                ? null
+                : primaryOutput.traceback
+                    .map((line, index, lines) =>
+                      index < lines.length - 1 && !line.endsWith("\n")
+                        ? `${line}\n`
+                        : line,
+                    )
+                    .join(""),
           },
         ],
         mimetype: "application/vnd.marimo+error",
@@ -223,6 +235,9 @@ function createCellRuntimeFromSession(
         timestamp: DEFAULT_TIMESTAMP,
       };
     }
+    if (runtimeState.output && primaryOutput.code !== undefined) {
+      runtimeState.output.code = primaryOutput.code;
+    }
   }
 
   const consoleOutputs = sessionCell.console || [];
@@ -237,7 +252,13 @@ function createCellRuntimeFromSession(
           channel: "media",
           data: consoleOutput.data,
           mimetype: consoleOutput.mimetype,
+          ...(consoleOutput.traceback_format === undefined
+            ? {}
+            : { traceback_format: consoleOutput.traceback_format }),
           timestamp: DEFAULT_TIMESTAMP,
+          ...(consoleOutput.code === undefined
+            ? {}
+            : { code: consoleOutput.code }),
         };
       }
       // Handle StreamOutput (type: "stream")
@@ -245,7 +266,13 @@ function createCellRuntimeFromSession(
         channel: consoleOutput.name === "stderr" ? "stderr" : "stdout",
         data: consoleOutput.text,
         mimetype: consoleOutput.mimetype ?? "text/plain",
+        ...(consoleOutput.traceback_format === undefined
+          ? {}
+          : { traceback_format: consoleOutput.traceback_format }),
         timestamp: DEFAULT_TIMESTAMP,
+        ...(consoleOutput.code === undefined
+          ? {}
+          : { code: consoleOutput.code }),
       };
     }),
   };

package/src/core/config/pair.ts

@@ -3,16 +3,18 @@
 import { atom } from "jotai";
 import { z } from "zod";
 
-export const pairPreviewSchema = z.object({
+export const pairConfigSchema = z.object({
   command: z.string(),
+  hostEnabled: z.boolean().default(false),
   templates: z.object({
     prompt: z.string(),
+    notebook: z.string(),
     session: z.string(),
     token_file: z.string(),
     token: z.string(),
   }),
 });
 
-export type PairPreviewConfig = z.infer<typeof pairPreviewSchema>;
+export type PairConfig = z.infer<typeof pairConfigSchema>;
 
-export const pairPreviewAtom = atom<PairPreviewConfig | undefined>(undefined);
+export const pairConfigAtom = atom<PairConfig | undefined>(undefined);