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

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/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__/error-report.test.ts

@@ -4,11 +4,51 @@
 import { describe, expect, it } from "vitest";
 import { cellId } from "@/__tests__/branded";
 import type { MarimoError } from "@/core/kernel/messages";
-import { buildErrorReport } from "../error-report";
+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[] = [
@@ -27,6 +67,7 @@ describe("buildErrorReport", () => {
       code: "failed()",
       output: {
         type: "error",
+        instructions: ERROR_MESSAGE_INSTRUCTIONS,
         message: "bad <value>\nanother error",
         traceback,
       },
@@ -49,7 +90,11 @@ describe("buildErrorReport", () => {
     ).toEqual({
       type: "cell-output",
       cell_id: CELL_ID,
-      output: { type: "error", message: "legacy error" },
+      output: {
+        type: "error",
+        instructions: ERROR_MESSAGE_INSTRUCTIONS,
+        message: "legacy error",
+      },
     });
   });
 
@@ -63,7 +108,11 @@ describe("buildErrorReport", () => {
       type: "cell-output",
       cell_id: CELL_ID,
       code: "",
-      output: { type: "error", message: "invalid code" },
+      output: {
+        type: "error",
+        instructions: ERROR_MESSAGE_INSTRUCTIONS,
+        message: "invalid code",
+      },
     });
   });
 
@@ -80,6 +129,7 @@ describe("buildErrorReport", () => {
       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",
@@ -201,8 +204,9 @@ describe("notebookStateFromSession", () => {
             {
               type: "stream",
               name: "stderr",
-              text: "<pre>ValueError: cached failure</pre>",
+              text: "ValueError: cached <failure>",
               mimetype: "application/vnd.marimo+traceback",
+              traceback_format: "text",
               code,
             },
           ],
@@ -212,9 +216,20 @@ describe("notebookStateFromSession", () => {
       invariant(state, "state is null");
       expect(state.cellRuntime[CELL_1].output).toMatchObject({
         code,
-        data: [{ type: "unknown", msg: "cached failure" }],
+        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", () => {

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

@@ -6,26 +6,29 @@ import { sanitizeHtml } from "@/plugins/core/sanitize-html";
 import { parseHtmlContent } from "@/utils/dom";
 import type { CellId } from "./ids";
 
-export interface CellOutputHandoff<Output> {
+export interface CellOutputMessage<Output> {
   type: "cell-output";
   cell_id: CellId;
   code?: string;
   output: Output;
 }
 
-export interface ErrorHandoffOutput {
+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 }
+    | { traceback: string; tracebackFormat: "html" | "text" }
   ),
-): CellOutputHandoff<ErrorHandoffOutput> {
+): CellOutputMessage<ErrorMessageOutput> {
   let message: string;
   let traceback: string;
   if ("errors" in evidence) {
@@ -38,18 +41,23 @@ export function buildErrorReport(
       )
       .join("\n\n");
   } else {
-    traceback = parseHtmlContent(sanitizeHtml(evidence.traceback));
+    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,
-    ...(evidence.code === undefined ? {} : { code: evidence.code }),
     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",
@@ -240,6 +252,9 @@ 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
             ? {}
@@ -251,6 +266,9 @@ 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
           ? {}

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);

package/src/mount.tsx

@@ -10,7 +10,7 @@ import {
   userConfigAtom,
 } from "@/core/config/config";
 import { KnownQueryParams } from "@/core/constants";
-import { pairPreviewAtom, pairPreviewSchema } from "@/core/config/pair";
+import { pairConfigAtom, pairConfigSchema } from "@/core/config/pair";
 import { getFilenameFromDOM } from "@/core/dom/htmlUtils";
 import { getMarimoCode } from "@/core/meta/globals";
 import {
@@ -209,7 +209,7 @@ const mountOptionsSchema = z.object({
    * marimo config overrides
    */
   configOverrides: passthroughObject,
-  pairPreview: pairPreviewSchema.optional(),
+  pairConfig: pairConfigSchema.optional(),
   /**
    * marimo app config
    */
@@ -347,7 +347,7 @@ function initStore(options: unknown) {
   );
   store.set(userConfigAtom, parseUserConfig(parsedOptions.data.config));
   store.set(appConfigAtom, parseAppConfig(parsedOptions.data.appConfig));
-  store.set(pairPreviewAtom, parsedOptions.data.pairPreview);
+  store.set(pairConfigAtom, parsedOptions.data.pairConfig);
 
   // Runtime config
   if (parsedOptions.data.runtimeConfig.length > 0) {