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

package/src/core/islands/__tests__/bootstrap.test.ts

@@ -3,6 +3,8 @@
 import { createStore } from "jotai";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import { RuntimeState } from "@/core/kernel/RuntimeState";
+import { attachmentsAtom } from "@/core/attachments/state";
+import { Logger } from "@/utils/Logger";
 import { initializeIslands } from "../bootstrap";
 import type { IslandsPyodideBridge } from "../bridge";
 import { islandsHydratedAtom, islandsPendingInitialRunsAtom } from "../state";
@@ -48,6 +50,30 @@ describe("initializeIslands", () => {
     expect(store.get(islandsHydratedAtom)).toBe(false);
     store.set(islandsPendingInitialRunsAtom, new Set([1, 2]));
 
+    const errors = vi.spyOn(Logger, "error");
+    consumeMessage?.({
+      sessionGeneration: 1,
+      message: JSON.stringify({
+        op: "attachments",
+        data: {
+          op: "attachments",
+          attachments: [
+            {
+              id: "a1",
+              kind: "agent",
+              name: "Pi",
+              since: "2026-10-14T00:00:00Z",
+              notebook_id: "nb-test",
+              identity: "pi-thread",
+            },
+          ],
+        },
+      }) as IslandsKernelMessage["message"],
+    });
+    expect(errors).not.toHaveBeenCalled();
+    expect(store.get(attachmentsAtom)).toEqual([]);
+    expect(store.get(islandsPendingInitialRunsAtom)).toEqual(new Set([1, 2]));
+
     consumeMessage?.(completedRun(1));
     expect(store.get(islandsHydratedAtom)).toBe(false);
 

package/src/core/islands/bootstrap.ts

@@ -209,6 +209,7 @@ function handleMessage(
       case "cache-info":
       case "kernel-startup-error":
       case "notebook-document-transaction":
+      case "attachments":
         return;
 
       case "completed-run":

package/src/core/websocket/__tests__/useMarimoKernelConnection.hook.test.tsx

@@ -43,6 +43,11 @@ vi.mock("@/core/runtime/config", async () => {
 import { MockNotebook } from "@/__mocks__/notebook";
 import { cellId } from "@/__tests__/branded";
 import { alertAtom, getPackageAlert } from "@/core/alerts/state";
+import {
+  type Attachment,
+  attachmentsAtom,
+  agentAttachmentsAtom,
+} from "@/core/attachments/state";
 import { notebookAtom } from "@/core/cells/cells";
 import { AppConfigSchema } from "@/core/config/config-schema";
 import { ConnectionNotice } from "@/components/editor/alerts/connection-notice";
@@ -184,6 +189,46 @@ describe("useMarimoKernelConnection.reconnect()", () => {
 });
 
 describe("useMarimoKernelConnection messages", () => {
+  it("replaces attachment snapshots, including the last detach", () => {
+    const store = createStore();
+    vi.mocked(useConnectionTransport).mockReturnValue(
+      makeTransport(WebSocket.OPEN),
+    );
+    vi.mocked(useRuntimeManager).mockReturnValue(
+      makeRuntimeManager() as unknown as ReturnType<typeof useRuntimeManager>,
+    );
+    renderConnectionHook(store);
+    const options = vi.mocked(useConnectionTransport).mock.calls.at(-1)![0];
+    const agent: Attachment = {
+      id: "a1",
+      kind: "agent",
+      name: "Pi",
+      since: "2026-10-14T00:00:00Z",
+      notebook_id: "nb-test",
+      identity: "pi-thread",
+    };
+    const client: Attachment = {
+      id: "c1",
+      kind: "client",
+      name: null,
+      since: "2026-10-14T00:00:01Z",
+      notebook_id: "nb-test",
+    };
+    for (const attachments of [[agent, client], [client], []]) {
+      act(() =>
+        options.onMessage(
+          new MessageEvent("message", {
+            data: JSON.stringify({
+              op: "attachments",
+              data: { op: "attachments", attachments },
+            }),
+          }),
+        ),
+      );
+      expect(store.get(attachmentsAtom)).toEqual(attachments);
+    }
+  });
+
   it("records completion of the initial run", () => {
     const store = createStore();
     vi.mocked(useConnectionTransport).mockClear();
@@ -211,6 +256,101 @@ describe("useMarimoKernelConnection messages", () => {
   });
 });
 
+describe("attachment snapshots across browser connections", () => {
+  const agent: Attachment = {
+    id: "a1",
+    kind: "agent",
+    name: "Pi",
+    since: "2026-10-14T00:00:00Z",
+    notebook_id: "nb-test",
+    identity: "pi-thread",
+  };
+
+  function connectedSession() {
+    const store = createStore();
+    store.set(connectionAtom, { state: ConnectionState.OPEN });
+    store.set(attachmentsAtom, [agent]);
+    const transport = makeTransport(WebSocket.OPEN);
+    vi.mocked(useConnectionTransport).mockReturnValue(transport);
+    vi.mocked(useRuntimeManager).mockReturnValue(
+      makeRuntimeManager() as unknown as ReturnType<typeof useRuntimeManager>,
+    );
+    renderConnectionHook(store);
+    const options = vi.mocked(useConnectionTransport).mock.calls.at(-1)![0];
+    const receive = (data: NotificationPayload["data"]) =>
+      act(() => {
+        options.onMessage(
+          new MessageEvent("message", {
+            data: JSON.stringify({ op: data.op, data }),
+          }),
+        );
+      });
+    return { store, transport, options, receive };
+  }
+
+  it.each([
+    "MARIMO_NO_FILE_KEY",
+    "MARIMO_NO_SESSION_ID",
+    "MARIMO_NO_SESSION",
+    "MARIMO_SHUTDOWN",
+    "MARIMO_KERNEL_STARTUP_ERROR",
+    "MARIMO_UNAUTHORIZED",
+    "MARIMO_KIOSK_NOT_ALLOWED",
+    "MARIMO_TRANSPORT_EXHAUSTED",
+  ])("clears cached attachments on %s", (reason) => {
+    const { store, transport, options } = connectedSession();
+    act(() => options.onClose(new CloseEvent("close", { reason })));
+    expect(store.get(attachmentsAtom)).toEqual([]);
+    expect(store.get(agentAttachmentsAtom)).toEqual([]);
+    expect(store.get(connectionAtom).state).toBe(ConnectionState.CLOSED);
+    expect(transport.reconnect).not.toHaveBeenCalled();
+  });
+
+  it("clears the snapshot on transport error", () => {
+    const { store, options } = connectedSession();
+    act(() => options.onError(new Event("error")));
+    expect(store.get(attachmentsAtom)).toEqual([]);
+    expect(store.get(agentAttachmentsAtom)).toEqual([]);
+  });
+
+  it("waits for a fresh snapshot after a transient reconnect", async () => {
+    const { store, transport, options, receive } = connectedSession();
+    act(() => options.onClose(new CloseEvent("close")));
+    expect(store.get(attachmentsAtom)).toEqual([]);
+    expect(store.get(connectionAtom).state).toBe(ConnectionState.CONNECTING);
+    expect(transport.reconnect).toHaveBeenCalledOnce();
+
+    await act(async () => options.onOpen(new Event("open")));
+    receive({ op: "reconnected" });
+    expect(store.get(connectionAtom).state).toBe(ConnectionState.OPEN);
+    expect(store.get(agentAttachmentsAtom)).toEqual([]);
+
+    const refreshed = { ...agent, id: "a2", name: "Codex" };
+    receive({ op: "attachments", attachments: [refreshed] });
+    expect(store.get(agentAttachmentsAtom)).toEqual([refreshed]);
+    receive({ op: "attachments", attachments: [] });
+    expect(store.get(agentAttachmentsAtom)).toEqual([]);
+  });
+
+  it("keeps a fresh snapshot hidden until the session is ready", async () => {
+    const { store, options, receive } = connectedSession();
+    act(() => options.onClose(new CloseEvent("close")));
+    await act(async () => options.onOpen(new Event("open")));
+    receive({ op: "attachments", attachments: [agent] });
+    expect(store.get(attachmentsAtom)).toEqual([agent]);
+    expect(store.get(agentAttachmentsAtom)).toEqual([]);
+    receive({ op: "reconnected" });
+    expect(store.get(agentAttachmentsAtom)).toEqual([agent]);
+  });
+
+  it("invalidates an old snapshot when a new transport opens", async () => {
+    const { store, options } = connectedSession();
+    await act(async () => options.onOpen(new Event("open")));
+    expect(store.get(attachmentsAtom)).toEqual([]);
+    expect(store.get(agentAttachmentsAtom)).toEqual([]);
+  });
+});
+
 it.each(["kernel-ready", "reconnected"])(
   "waits for %s before marking the session connected",
   async (op) => {
@@ -261,6 +401,59 @@ it.each(["kernel-ready", "reconnected"])(
   },
 );
 
+it.each([true, false])(
+  "keeps attachments only when kernel-ready resumes the session: %s",
+  (resumed) => {
+    const store = createStore();
+    const attachments: Attachment[] = [
+      {
+        id: "a1",
+        kind: "agent",
+        name: "Pi",
+        since: "2026-10-14T00:00:00Z",
+        notebook_id: "nb-test",
+        identity: "pi-thread",
+      },
+    ];
+    store.set(attachmentsAtom, attachments);
+    vi.mocked(useConnectionTransport).mockReturnValue(
+      makeTransport(WebSocket.OPEN),
+    );
+    vi.mocked(useRuntimeManager).mockReturnValue(
+      makeRuntimeManager() as unknown as ReturnType<typeof useRuntimeManager>,
+    );
+    renderConnectionHook(store);
+    const options = vi.mocked(useConnectionTransport).mock.calls.at(-1)![0];
+    act(() =>
+      options.onMessage(
+        new MessageEvent("message", {
+          data: JSON.stringify({
+            op: "kernel-ready",
+            data: {
+              op: "kernel-ready",
+              cell_ids: [],
+              codes: [],
+              names: [],
+              configs: [],
+              layout: null,
+              resumed,
+              ui_values: {},
+              last_executed_code: {},
+              last_execution_time: {},
+              app_config: { width: "normal" },
+              kiosk: false,
+              capabilities: { terminal: false },
+              auto_instantiated: true,
+              consumer_capabilities: { edit: true, interact: true },
+            },
+          }),
+        }),
+      ),
+    );
+    expect(store.get(attachmentsAtom)).toEqual(resumed ? attachments : []);
+  },
+);
+
 describe("connection notice", () => {
   beforeEach(() => vi.useFakeTimers());
   afterEach(() => vi.useRealTimers());

package/src/core/websocket/useMarimoKernelConnection.tsx

@@ -5,6 +5,7 @@ import { useAtom, useAtomValue, useSetAtom } from "jotai";
 import { useRef } from "react";
 import { useErrorBoundary } from "react-error-boundary";
 import { toast } from "@/components/ui/use-toast";
+import { attachmentsAtom } from "@/core/attachments/state";
 import { getNotebook, useCellActions } from "@/core/cells/cells";
 import { applyTransactionChanges } from "@/core/cells/document-changes";
 import { AUTOCOMPLETER } from "@/core/codemirror/completion/Autocompleter";
@@ -236,6 +237,7 @@ export function useMarimoKernelConnection(opts: {
   } = useAlertActions();
   const setKioskMode = useSetAtom(kioskModeAtom);
   const setStableSessionId = useSetAtom(stableSessionIdAtom);
+  const setAttachments = useSetAtom(attachmentsAtom);
   const setCapabilities = useSetAtom(capabilitiesAtom);
   const runtimeManager = useRuntimeManager();
   const transportType = useAtomValue(connectionTransportTypeAtom);
@@ -252,6 +254,9 @@ export function useMarimoKernelConnection(opts: {
       case "reload":
         reloadSafe();
         return;
+      case "attachments":
+        setAttachments(msg.data.attachments);
+        return;
       case "startup-progress": {
         const { phase } = msg.data;
         updateStartupProgress(msg.data);
@@ -283,6 +288,7 @@ export function useMarimoKernelConnection(opts: {
           existingCells,
         });
         if (!msg.data.resumed) {
+          setAttachments([]);
           // A freshly started kernel may expose a different environment
           // (e.g. new env vars); re-run discovery instead of reusing stale
           // suggestions from the previous kernel instance.
@@ -561,6 +567,7 @@ export function useMarimoKernelConnection(opts: {
      */
     onOpen: async () => {
       updateStartupProgress(null);
+      setAttachments([]);
       // If we are open, we can reset our reconnecting flag.
       shouldTryReconnecting.current = true;
     },
@@ -603,6 +610,7 @@ export function useMarimoKernelConnection(opts: {
      */
     onClose: (e) => {
       Logger.warn("WebSocket closed", e.code, e.reason);
+      setAttachments([]);
       const decision = classifyCloseEvent(e);
       setConnection((previous) => {
         const status = decision.status;
@@ -641,6 +649,7 @@ export function useMarimoKernelConnection(opts: {
      */
     onError: (e) => {
       Logger.warn("WebSocket error", e);
+      setAttachments([]);
       setConnection({
         state: ConnectionState.CLOSED,
         code: WebSocketClosedReason.KERNEL_DISCONNECTED,

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

package/dist/error-entries-CzoYkIQZ.js

@@ -1,56 +0,0 @@
-import { At as e, N as t, b as n, d as r, jt as i, kt as a } from "./cells-C8iCYvLU.js";
-import { C as o } from "./select-BButFi-d.js";
-//#region src/core/errors/error-entries.ts
-function s(t) {
-	if (e(t.mimetype)) {
-		if (!Array.isArray(t.data)) return null;
-		let e = t.data.filter((e) => !e.type.includes("ancestor"));
-		return e.length === 0 ? null : { errorData: e };
-	}
-	return i(t.mimetype) ? typeof t.data != "string" || t.data.length === 0 ? null : {
-		errorData: [],
-		tracebackHtml: t.data
-	} : null;
-}
-function c(e) {
-	return e.some((e) => "traceback" in e && e.traceback);
-}
-function l(e) {
-	let t = e?.find((e) => i(e.mimetype));
-	if (!(!t || typeof t.data != "string" || t.data.length === 0)) return t.data;
-}
-function u(e, t) {
-	if (e.tracebackHtml) return e.tracebackHtml;
-	if (!c(e.errorData)) return l(t);
-}
-function d(e) {
-	let { cellIds: n, cellRuntime: i, cellData: o } = e.get(r), c = [];
-	for (let [e, r] of n.inOrderIds.entries()) {
-		let n = i[r], l = n.output;
-		if (!l || !a(l.mimetype)) continue;
-		let d = s(l);
-		if (!d) continue;
-		let f = t(o[r].name, e), p = o[r].lastCodeRun ?? o[r].code;
-		c.push({
-			cellId: r,
-			cellName: f,
-			cellCode: p,
-			errorData: d.errorData,
-			tracebackHtml: u(d, n.consoleOutputs)
-		});
-	}
-	return c;
-}
-function f(e) {
-	return e.type === "setup-refs" ? "The setup cell cannot have references" : e.type === "cycle" ? "This cell is in a cycle" : e.type === "multiple-defs" ? `The variable '${e.name}' was defined by another cell` : e.type === "import-star" || e.type === "ancestor-stopped" || e.type === "ancestor-prevented" || e.type === "exception" || e.type === "strict-exception" ? e.msg : e.type === "interruption" ? "This cell was interrupted and needs to be re-run" : e.type === "syntax" || e.type === "unknown" || e.type === "sql-error" ? e.msg : e.type === "internal" ? e.msg || "An internal error occurred" : (o(e), "Unknown error");
-}
-function p(e) {
-	let t = f(e);
-	return "traceback" in e && e.traceback && (t += `\n\nTraceback:\n${n(e.traceback)}`), t;
-}
-function m(e) {
-	let t = [e.cellName];
-	return e.tracebackHtml && t.push(n(e.tracebackHtml)), e.errorData.length > 0 && t.push(e.errorData.map(p).join("\n\n")), t.join("\n\n");
-}
-//#endregion
-export { d as i, m as n, p as r, f as t };