@marimo-team/islands 0.25.3-dev308 → 0.25.3-dev310

package/dist/{wardleyDiagram-VM6X3IG4-BEQN7g62.js → wardleyDiagram-VM6X3IG4-zD_2guVe.js}

@@ -2,7 +2,7 @@ import { i as e } from "./chunk-75Z2AOVW-9jQIEAxd.js";
 import { n as t } from "./src-D5uZaZib.js";
 import { n } from "./chunk-Y2CYZVJY-DKKS1VyV.js";
 import { D as r, H as i, K as a, U as o, a as s, b as c, c as l, v as u, w as d, x as f, y as p } from "./chunk-DU6HZSFF-B20LZ-hE.js";
-import { p as m } from "./mermaid-DMPMkVqY.js";
+import { p as m } from "./mermaid-CNgH43ED.js";
 import { n as h } from "./mermaid-parser.core-DtOnl7m4.js";
 import { t as g } from "./chunk-JWPE2WC7-DJvv1t8U.js";
 //#region ../node_modules/.pnpm/mermaid@11.17.2/node_modules/mermaid/dist/chunks/mermaid.core/wardleyDiagram-VM6X3IG4.mjs

package/dist/{xychartDiagram-S5SC5T6Z-D8-e5Z0R.js → xychartDiagram-S5SC5T6Z-CA0Dy1ZM.js}

@@ -9,7 +9,7 @@ import { n as s } from "./chunk-Y2CYZVJY-DKKS1VyV.js";
 import { D as c, H as l, K as u, U as d, a as f, b as p, c as m, f as h, v as g, w as _, y as v, z as y } from "./chunk-DU6HZSFF-B20LZ-hE.js";
 import "./chunk-PWAF6VOD-oT_Qd2OU.js";
 import { t as b } from "./chunk-GMAD6QVW-DokpSFdf.js";
-import { p as x } from "./mermaid-DMPMkVqY.js";
+import { p as x } from "./mermaid-CNgH43ED.js";
 //#region ../node_modules/.pnpm/d3-scale@4.0.2/node_modules/d3-scale/src/band.js
 function S() {
 	var e = t().unknown(void 0), r = e.domain, i = e.range, o = 0, s = 1, c, l, u = !1, d = 0, f = 0, p = .5;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@marimo-team/islands",
-  "version": "0.25.3-dev308",
+  "version": "0.25.3-dev310",
   "main": "dist/main.js",
   "types": "dist/index.d.ts",
   "type": "module",

package/src/__mocks__/executions.ts

@@ -11,6 +11,7 @@ import {
   type Document,
   type Execution,
   type Executions,
+  type NotebookBackend,
   type NotebookReplica,
   type Results,
 } from "@/core/notebook/replica";
@@ -18,6 +19,12 @@ import { activeNotebookReplicaAtom } from "@/core/session/active-notebook";
 
 type Store = ReturnType<typeof createStore>;
 
+const CONFIG: Protocol.CellConfig = {
+  column: null,
+  disabled: false,
+  hide_code: false,
+  expand_output: false,
+};
 const T0 = "2026-10-01T09:20:11Z";
 const T1 = "2026-10-01T09:20:12.500Z";
 
@@ -138,6 +145,17 @@ export const MockExecutions = {
     });
   },
 
+  notebook(id: Protocol.NotebookId = "n1"): Protocol.Notebook {
+    return {
+      id,
+      project_id: "p1",
+      path: null,
+      name: "Notebook",
+      operations: [],
+      updated_at: null,
+    };
+  },
+
   runtime(status: Protocol.RuntimeStatus): Protocol.Runtime {
     return {
       id: "r1",
@@ -149,15 +167,24 @@ export const MockExecutions = {
     };
   },
 
-  /** What the selectors read, with `latest` and the results derived from `records`. */
+  /**
+   * What the selectors read. `latest` and the results are derived from
+   * `records`, and the document is taken to have every cell they name,
+   * with nothing keeping it from running.
+   */
   inputs(
     records: Protocol.Execution[],
-    extra: Partial<Pick<CellExecutionInputs, "submissions" | "blocked">> = {},
+    extra: Partial<Pick<CellExecutionInputs, "requested" | "blocked">> = {},
   ): CellExecutionInputs {
     return {
       executions: mirror(records),
       results: results(records),
-      submissions: new Map(),
+      cells: new Map(
+        records.flatMap((record) =>
+          record.cell_id === null ? [] : [[record.cell_id, { config: CONFIG }]],
+        ),
+      ),
+      requested: new Set(),
       blocked: new Set(),
       ...extra,
     };
@@ -172,20 +199,15 @@ export const MockExecutions = {
   ) {
     const current = store.get(activeNotebookReplicaAtom);
     const replica = {
-      connectionAtom: atom<ConnectionStatus>({ state: ConnectionState.OPEN }),
-      backendAtom: atom(null),
       attachmentsAtom: atom([]),
       connect: () => () => undefined,
       reconnect: () => Promise.resolve(),
       ...current,
-      notebookAtom: atom<Protocol.Notebook>({
-        id: "n1",
-        project_id: "p1",
-        path: null,
-        name: "Notebook",
-        operations: [],
-        updated_at: null,
-      }),
+      // Settable, so a test can close the connection or give the replica a
+      // backend to command.
+      connectionAtom: atom<ConnectionStatus>({ state: ConnectionState.OPEN }),
+      backendAtom: atom<NotebookBackend | null>(null),
+      notebookAtom: atom<Protocol.Notebook | null>(MockExecutions.notebook()),
       documentAtom: atom<Document | null>(document),
       runtimeAtom: atom(runtime),
       executionsAtom: atom(mirror(records)),

package/src/__mocks__/requests.ts

@@ -23,7 +23,6 @@ export const MockRequestClient = {
       sendFormat: vi.fn().mockResolvedValue({ codes: {} }),
       sendInterrupt: vi.fn().mockResolvedValue({}),
       sendShutdown: vi.fn().mockResolvedValue({}),
-      sendRun: vi.fn().mockResolvedValue({}),
       sendRunScratchpad: vi.fn().mockResolvedValue({}),
       sendInstantiate: vi.fn().mockResolvedValue({}),
       sendCodeCompletionRequest: vi.fn().mockResolvedValue({ items: [] }),

package/src/components/editor/cell/__tests__/useRunCells.test.tsx

@@ -1,169 +1,154 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
+import type * as Protocol from "@marimo-team/client/protocol";
 import { act, renderHook } from "@testing-library/react";
-import { Provider } from "jotai";
+import { atom, Provider } from "jotai";
 import type { ReactNode } from "react";
-import { afterEach, describe, expect, it, vi } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { MockExecutions } from "@/__mocks__/executions";
 import { MockNotebook } from "@/__mocks__/notebook";
-import { MockRequestClient } from "@/__mocks__/requests";
 import { cellId } from "@/__tests__/branded";
 import { notebookAtom } from "@/core/cells/cells";
-import {
-  cellExecutionInputsAtom,
-  cellExecutionView,
-  notebookQueuedOrRunningCountAtom,
-} from "@/core/executions";
-import { requestClientAtom } from "@/core/network/requests";
 import type { DocumentModel } from "@/core/notebook/document";
 import {
   cell,
   document as documentOf,
   withCells,
 } from "@/core/notebook/document/__tests__/fixtures";
+import {
+  type FakeRun,
+  fakeBackend,
+} from "@/core/notebook/replica/__tests__/fixtures";
 import { activeDocumentModelAtom } from "@/core/session/active-notebook";
 import { store } from "@/core/state/jotai";
-import { runCells, useRunStaleCells } from "../useRunCells";
-
-const ENABLED = cellId("enabled");
-const DISABLED = cellId("disabled");
-
-describe("runCells", () => {
-  it("sends a disabled cell to the kernel without reading it as queued", async () => {
-    MockExecutions.seed(store, []);
-    const notebook = MockNotebook.notebookState({
-      cellData: {
-        [ENABLED]: { code: "x = 1" },
-        [DISABLED]: { code: "y = 2", config: { disabled: true } },
-      },
-    });
-    const sendRun = vi.fn(async () => null);
-
-    await runCells({
-      cellIds: [ENABLED, DISABLED],
-      sendRun,
-      prepareForRun: vi.fn(),
-      notebook,
-    });
-
-    expect(sendRun).toHaveBeenCalledWith({
-      cellIds: [ENABLED, DISABLED],
-      codes: ["x = 1", "y = 2"],
-    });
-    const inputs = store.get(cellExecutionInputsAtom);
-    expect(cellExecutionView(inputs, ENABLED).status).toBe("queued");
-    expect(cellExecutionView(inputs, DISABLED).status).toBe("idle");
-    expect(store.get(notebookQueuedOrRunningCountAtom)).toBe(1);
-  });
-});
+import { useRunStaleCells } from "../useRunCells";
+
+const toast = vi.fn();
+vi.mock("@/components/ui/use-toast", () => ({
+  toast: (...args: unknown[]) => toast(...args),
+}));
+vi.mock("@/core/runtime/config", () => ({
+  startRuntimeIfLazy: async () => undefined,
+}));
+
+const C1 = cellId("c1");
+const C2 = cellId("c2");
+
+const wrapper = ({ children }: { children: ReactNode }) => (
+  <Provider store={store}>{children}</Provider>
+);
+
+function accepted(cells: Protocol.CellId[]): Protocol.Run {
+  return {
+    id: "run-1",
+    notebook_id: "n1",
+    runtime_id: "r1",
+    cells,
+    status: "queued",
+    outcome: null,
+    started_at: null,
+    completed_at: null,
+  };
+}
 
 describe("useRunStaleCells", () => {
-  const C1 = cellId("c1");
-  const C2 = cellId("c2");
+  let run: ReturnType<typeof vi.fn<FakeRun>>;
+
+  beforeEach(() => {
+    toast.mockClear();
+    run = vi.fn<FakeRun>(async (_notebookId, request) => ({
+      ok: true,
+      status: 202,
+      data: accepted(request.cells?.map((cell) => cell.id) ?? []),
+    }));
+  });
 
   afterEach(() => {
     store.set(activeDocumentModelAtom, null);
   });
 
-  it("flushes pending edits before choosing the stale cells", async () => {
+  function seed(records: Protocol.Execution[]) {
     const document = documentOf();
     const replica = MockExecutions.seed(
       store,
-      [
-        MockExecutions.completed(C1, { code_fingerprint: "c1-hash" }),
-        MockExecutions.completed(C2, { code_fingerprint: "c2-hash" }),
-      ],
-      null,
+      records,
+      MockExecutions.runtime("running"),
       document,
     );
+    store.set(replica.backendAtom, fakeBackend({ run }));
+    return { replica, document };
+  }
+
+  function model(sync: () => Promise<Protocol.Document>) {
+    store.set(activeDocumentModelAtom, {
+      retry: sync,
+      documentAtom: atom(null),
+    } as unknown as DocumentModel);
+  }
+
+  it("syncs pending edits before choosing the stale cells", async () => {
+    const { replica, document } = seed([
+      MockExecutions.completed(C1, { code_fingerprint: "c1-hash" }),
+      MockExecutions.completed(C2, { code_fingerprint: "c2-hash" }),
+    ]);
     store.set(
       notebookAtom,
       MockNotebook.notebookState({
         cellData: { [C1]: { code: "x = 2" }, [C2]: { code: "y = 2" } },
       }),
     );
-    const client = MockRequestClient.create();
-    store.set(requestClientAtom, client);
-    // The edit to c1 is still in flight: the host confirms it on flush.
-    const flush = vi.fn(async () => {
+    // The edit to c1 is still in flight: the host confirms it on sync.
+    const sync = vi.fn(async () => {
       await new Promise((resolve) => setTimeout(resolve, 0));
-      store.set(
-        replica.documentAtom,
-        withCells(document, {
-          [C1]: cell(C1, "x = 2", { code_fingerprint: "c1-hash-2" }),
-        }),
-      );
+      const confirmed = withCells(document, {
+        [C1]: cell(C1, "x = 2", { code_fingerprint: "c1-hash-2" }),
+      });
+      store.set(replica.documentAtom, confirmed);
+      return confirmed.revision;
     });
-    store.set(activeDocumentModelAtom, { flush } as unknown as DocumentModel);
-    const wrapper = ({ children }: { children: ReactNode }) => (
-      <Provider store={store}>{children}</Provider>
-    );
+    model(sync);
     const { result } = renderHook(useRunStaleCells, { wrapper });
 
     await act(() => result.current());
 
-    expect(flush).toHaveBeenCalledOnce();
-    expect(client.sendRun).toHaveBeenCalledWith({
-      cellIds: [C1],
-      codes: ["x = 2"],
-    });
+    expect(sync).toHaveBeenCalled();
+    expect(run).toHaveBeenCalledWith("n1", { cells: [{ id: C1 }] });
   });
 
   it("does nothing when the notebook changed while the flush was pending", async () => {
-    MockExecutions.seed(
-      store,
-      [MockExecutions.completed(C1, { code_fingerprint: "stale" })],
-      null,
-      documentOf(),
-    );
+    seed([MockExecutions.completed(C1, { code_fingerprint: "stale" })]);
     store.set(
       notebookAtom,
       MockNotebook.notebookState({ cellData: { [C1]: { code: "x = 1" } } }),
     );
-    const client = MockRequestClient.create();
-    store.set(requestClientAtom, client);
-    const flush = vi.fn(async () => {
+    model(async () => {
       store.set(activeDocumentModelAtom, null);
       throw new Error("aborted");
     });
-    store.set(activeDocumentModelAtom, { flush } as unknown as DocumentModel);
-    const wrapper = ({ children }: { children: ReactNode }) => (
-      <Provider store={store}>{children}</Provider>
-    );
     const { result } = renderHook(useRunStaleCells, { wrapper });
 
     await act(() => result.current());
 
-    expect(client.sendRun).not.toHaveBeenCalled();
+    expect(run).not.toHaveBeenCalled();
+    expect(toast).not.toHaveBeenCalled();
   });
 
-  it("still runs what is stale when the flush fails", async () => {
-    MockExecutions.seed(
-      store,
-      [MockExecutions.completed(C1, { code_fingerprint: "stale" })],
-      null,
-      documentOf(),
-    );
+  it("runs nothing while edits cannot reach the host", async () => {
+    seed([MockExecutions.completed(C1, { code_fingerprint: "stale" })]);
     store.set(
       notebookAtom,
       MockNotebook.notebookState({ cellData: { [C1]: { code: "x = 1" } } }),
     );
-    const client = MockRequestClient.create();
-    store.set(requestClientAtom, client);
-    const flush = vi.fn(async () => {
+    model(async () => {
       throw new Error("offline");
     });
-    store.set(activeDocumentModelAtom, { flush } as unknown as DocumentModel);
-    const wrapper = ({ children }: { children: ReactNode }) => (
-      <Provider store={store}>{children}</Provider>
-    );
     const { result } = renderHook(useRunStaleCells, { wrapper });
 
     await act(() => result.current());
 
-    expect(client.sendRun).toHaveBeenCalledWith({
-      cellIds: [C1],
-      codes: ["x = 1"],
-    });
+    expect(run).not.toHaveBeenCalled();
+    expect(toast).toHaveBeenCalledWith(
+      expect.objectContaining({ title: "Edits not yet synced" }),
+    );
   });
 });

package/src/components/editor/cell/useRunCells.ts

@@ -4,22 +4,21 @@ import { closeCompletion } from "@codemirror/autocomplete";
 import { atom, useSetAtom } from "jotai";
 import useEvent from "react-use-event-hook";
 import { toast } from "@/components/ui/use-toast";
-import { getNotebook, type NotebookState } from "@/core/cells/cells";
+import { getNotebook } from "@/core/cells/cells";
 import { useCellActions } from "@/core/cells/actions";
 import type { CellId } from "@/core/cells/ids";
 import { enabledCellIds, staleCellIds } from "@/core/cells/utils";
 import {
   cellExecutionInputsAtom,
   cellFreshnessAtom,
-  submitCells,
-  withdrawCells,
+  runCells,
+  syncEdits,
+  waitForRuntime,
 } from "@/core/executions";
 import { getCurrentLanguageAdapter } from "@/core/codemirror/language/commands";
-import { getEditorCodeAsPython } from "@/core/codemirror/language/utils";
-import { useRequestClient } from "@/core/network/requests";
-import type { ExecuteCellsRequest } from "@/core/network/types";
 import { activeDocumentModelAtom } from "@/core/session/active-notebook";
 import { store } from "@/core/state/jotai";
+import { prettyError } from "@/utils/errors";
 import { Logger } from "@/utils/Logger";
 
 export const hasRunAnyCellAtom = atom<boolean>(false);
@@ -33,18 +32,36 @@ export function useRunStaleCells() {
     // Freshness reads the confirmed document, so an edit still in flight
     // reaches the host before the stale cells are chosen.
     const model = store.get(activeDocumentModelAtom);
+    if (model === null) {
+      return;
+    }
     try {
-      await model?.flush();
+      await waitForRuntime(store);
     } catch (error) {
       if (store.get(activeDocumentModelAtom) !== model) {
         return;
       }
-      Logger.warn("Running stale cells with unsynced edits", error);
+      Logger.warn("Stale cells not run without a runtime", error);
+      toast({
+        title: "Failed to run",
+        description: prettyError(error),
+        variant: "danger",
+      });
+      return;
+    }
+    try {
+      await syncEdits(model);
+    } catch (error) {
+      if (store.get(activeDocumentModelAtom) !== model) {
+        return;
+      }
+      Logger.warn("Stale cells not run with unsynced edits", error);
       toast({
         title: "Edits not yet synced",
-        description: "Stale cells were chosen from the last synced source.",
+        description: "Stale cells were not run. Retry once the edits sync.",
         variant: "danger",
       });
+      return;
     }
     // The request was for the notebook that was open when it was made.
     if (store.get(activeDocumentModelAtom) !== model) {
@@ -82,78 +99,34 @@ export function useRunAllCells() {
 }
 
 /**
- * Creates a function that runs the given cells.
+ * Creates a function that runs the given cells through the host.
+ *
+ * The editor settles each cell first: an open completion closes and the
+ * debugger view clears, as they would on any run.
  */
 export function useRunCells() {
   const { prepareForRun } = useCellActions();
-  const { sendRun } = useRequestClient();
   const setHasRunAnyCell = useSetAtom(hasRunAnyCellAtom);
 
   const runCellsMemoized = useEvent(async (cellIds: CellId[]) => {
     if (cellIds.length === 0) {
       return;
     }
-
-    const notebook = getNotebook();
-
     // Set a flag that a user has manually run at least one cell.
     setHasRunAnyCell(true);
 
-    return runCells({ cellIds, sendRun, prepareForRun, notebook });
-  });
-
-  return runCellsMemoized;
-}
-
-export async function runCells({
-  cellIds,
-  sendRun,
-  prepareForRun,
-  notebook,
-}: {
-  cellIds: CellId[];
-  sendRun: (request: ExecuteCellsRequest) => Promise<null>;
-  prepareForRun: (action: { cellId: CellId }) => void;
-  notebook: NotebookState;
-}) {
-  if (cellIds.length === 0) {
-    return;
-  }
-
-  const { cellHandles, cellData } = notebook;
-
-  const codes: string[] = [];
-  for (const cellId of cellIds) {
-    const ref = cellHandles[cellId];
-    const ev = ref?.current?.editorView;
-    let code: string;
-    // Performs side-effects that must run whenever the cell is run, but doesn't
-    // actually run the cell.
-    if (ev) {
+    const { cellHandles } = getNotebook();
+    for (const cellId of cellIds) {
+      const ev = cellHandles[cellId]?.current?.editorView;
       // Skip close on markdown, since we autorun, otherwise we'll close the
       // completion each time.
-      if (getCurrentLanguageAdapter(ev) !== "markdown") {
+      if (ev && getCurrentLanguageAdapter(ev) !== "markdown") {
         closeCompletion(ev);
       }
-      // Prefer code from editor
-      code = getEditorCodeAsPython(ev);
-    } else {
-      code = cellData[cellId]?.code || "";
+      prepareForRun({ cellId });
     }
-
-    codes.push(code);
-    prepareForRun({ cellId });
-  }
-  // The kernel sets a disabled cell aside without planning an execution,
-  // so a submission for it would never be superseded.
-  submitCells(
-    store,
-    cellIds.filter((cellId) => !cellData[cellId]?.config.disabled),
-  );
-
-  // TODO(MO-8346): Submit through the host's `runtime.run`.
-  await sendRun({ cellIds: cellIds, codes: codes }).catch((error) => {
-    withdrawCells(store, cellIds);
-    Logger.error(error);
+    return runCells(store, cellIds);
   });
+
+  return runCellsMemoized;
 }

package/src/components/editor/notebook-cell.tsx

@@ -2,7 +2,7 @@
 import { closeCompletion, completionStatus } from "@codemirror/autocomplete";
 import type { EditorView } from "@codemirror/view";
 import clsx from "clsx";
-import { useAtomValue, useSetAtom } from "jotai";
+import { useAtomValue, useSetAtom, useStore } from "jotai";
 import {
   HelpCircleIcon,
   MoreHorizontalIcon,
@@ -40,14 +40,16 @@ import { canCollapseOutline } from "@/core/dom/outline";
 import { isErrorMime } from "@/core/mime";
 import type { AppMode } from "@/core/mode";
 import { connectionAtom } from "@/core/network/connection";
-import { useRequestClient } from "@/core/network/requests";
 import {
   type CellExecutionView,
   type CellFreshness,
   type CellRunStatus,
+  replyInput,
   useCellExecution,
   useCellFreshness,
 } from "@/core/executions";
+import type { WithResponse } from "@/core/cells/types";
+import type { OutputMessage } from "@/core/kernel/messages";
 import type { CellConfig } from "@/core/network/types";
 import { useResizeObserver } from "@/hooks/useResizeObserver";
 import { cn } from "@/utils/cn";
@@ -241,6 +243,30 @@ export interface CellHandle {
   editorViewOrNull: EditorView | null;
 }
 
+/**
+ * Answer the prompt at `index` of the cell's console through the host.
+ *
+ * The console entry is marked answered right away, as before. The reply
+ * itself names the prompt, so the host can mark it answered and turn away
+ * a late reply meant for an earlier prompt.
+ */
+function useAnswerPrompt(
+  cellId: CellId,
+  consoleOutputs: readonly WithResponse<OutputMessage>[],
+) {
+  const store = useStore();
+  const actions = useCellActions();
+  return useEvent((text: string, index: number) => {
+    actions.setStdinResponse({ cellId, response: text, outputIndex: index });
+    const prompt = consoleOutputs[index];
+    if (prompt?.input_id === undefined) {
+      Logger.error("The prompt has no id to answer it by", prompt);
+      return;
+    }
+    void replyInput(store, prompt.input_id, text);
+  });
+}
+
 export interface CellProps {
   cellId: CellId;
   theme: Theme;
@@ -404,7 +430,7 @@ const EditableCellComponent = ({
   const setAiCompletionCell = useSetAtom(aiCompletionCellAtom);
   const deleteCell = useDeleteCellCallback();
   const runCell = useRunCell(cellId);
-  const { sendStdin } = useRequestClient();
+  const answerPrompt = useAnswerPrompt(cellId, cellRuntime.consoleOutputs);
   const isPendingCut = useIsPendingCut(cellId);
 
   const [languageAdapter, setLanguageAdapter] = useState<LanguageAdapterType>();
@@ -823,14 +849,7 @@ const EditableCellComponent = ({
                   // breakpoints; no-op when none are set.
                   clearCellBreakpoints(cellId);
                 }}
-                onSubmitDebugger={(text, index) => {
-                  actions.setStdinResponse({
-                    cellId,
-                    response: text,
-                    outputIndex: index,
-                  });
-                  sendStdin({ text });
-                }}
+                onSubmitDebugger={answerPrompt}
                 cellId={cellId}
                 debuggerActive={cellRuntime.debuggerActive}
               />
@@ -1060,10 +1079,10 @@ const SetupCellComponent = ({
   const connection = useAtomValue(connectionAtom);
 
   const actions = useCellActions();
-  const requestClient = useRequestClient();
   const deleteCell = useDeleteCellCallback();
   const setAiCompletionCell = useSetAtom(aiCompletionCellAtom);
   const runCell = useRunCell(cellId);
+  const answerPrompt = useAnswerPrompt(cellId, cellRuntime.consoleOutputs);
 
   const uninstantiated = isUninstantiated(execution);
 
@@ -1293,14 +1312,7 @@ const SetupCellComponent = ({
                 // breakpoints; no-op when none are set.
                 clearCellBreakpoints(cellId);
               }}
-              onSubmitDebugger={(text, index) => {
-                actions.setStdinResponse({
-                  cellId,
-                  response: text,
-                  outputIndex: index,
-                });
-                requestClient.sendStdin({ text });
-              }}
+              onSubmitDebugger={answerPrompt}
               cellId={cellId}
               debuggerActive={cellRuntime.debuggerActive}
             />