@stigmer/react 0.2.3 → 0.3.1

package/src/runner/__tests__/phase.test.ts

@@ -3,8 +3,11 @@ import { RunnerPhase } from "@stigmer/protos/ai/stigmer/agentic/runner/v1/enum_p
 import { isTransitionalPhase, isActivePhase } from "../phase";
 
 describe("isTransitionalPhase", () => {
-  it("returns true for PENDING", () => {
-    expect(isTransitionalPhase(RunnerPhase.PENDING)).toBe(true);
+  it.each([
+    ["PENDING", RunnerPhase.PENDING],
+    ["STARTING", RunnerPhase.STARTING],
+  ] as const)("returns true for %s", (_label, phase) => {
+    expect(isTransitionalPhase(phase)).toBe(true);
   });
 
   it.each([
@@ -21,6 +24,7 @@ describe("isTransitionalPhase", () => {
     const allPhases = [
       RunnerPhase.READY,
       RunnerPhase.BUSY,
+      RunnerPhase.STARTING,
       RunnerPhase.PENDING,
       RunnerPhase.STOPPED,
       RunnerPhase.FAILED,

package/src/runner/phase.ts

@@ -9,15 +9,17 @@ import { RunnerPhase } from "@stigmer/protos/ai/stigmer/agentic/runner/v1/enum_p
 export const PHASE_SORT_ORDER: Record<RunnerPhase, number> = {
   [RunnerPhase.READY]: 0,
   [RunnerPhase.BUSY]: 1,
-  [RunnerPhase.PENDING]: 2,
-  [RunnerPhase.STOPPED]: 3,
-  [RunnerPhase.FAILED]: 4,
-  [RunnerPhase.UNSPECIFIED]: 5,
+  [RunnerPhase.STARTING]: 2,
+  [RunnerPhase.PENDING]: 3,
+  [RunnerPhase.STOPPED]: 4,
+  [RunnerPhase.FAILED]: 5,
+  [RunnerPhase.UNSPECIFIED]: 6,
 };
 
 const LABELS: Record<RunnerPhase, string> = {
   [RunnerPhase.READY]: "Ready",
   [RunnerPhase.BUSY]: "Busy",
+  [RunnerPhase.STARTING]: "Starting",
   [RunnerPhase.PENDING]: "Pending",
   [RunnerPhase.STOPPED]: "Stopped",
   [RunnerPhase.FAILED]: "Failed",
@@ -37,9 +39,10 @@ export function phaseLabel(phase: RunnerPhase): string {
 /**
  * Tailwind `bg-*` class for the small colored dot indicator.
  *
- * - Ready  → `bg-success`  (green)
- * - Busy   → `bg-warning`  (amber)
- * - Others → `bg-muted-foreground` (neutral)
+ * - Ready    → `bg-success`  (green)
+ * - Busy     → `bg-warning`  (amber)
+ * - Starting → `bg-primary`  (blue)
+ * - Others   → `bg-muted-foreground` (neutral)
  */
 export function phaseDotColor(phase: RunnerPhase): string {
   switch (phase) {
@@ -47,6 +50,8 @@ export function phaseDotColor(phase: RunnerPhase): string {
       return "bg-success";
     case RunnerPhase.BUSY:
       return "bg-warning";
+    case RunnerPhase.STARTING:
+      return "bg-primary";
     default:
       return "bg-muted-foreground";
   }
@@ -65,14 +70,15 @@ export function isActivePhase(phase: RunnerPhase): boolean {
  * Whether the runner is in a transitional phase whose status is
  * expected to change soon without user action.
  *
- * Currently only `PENDING` — the runner has registered but hasn't
- * completed its startup handshake yet. This is distinct from
- * {@link isActivePhase} (READY | BUSY) where the runner is stable
- * and accepting work.
+ * `PENDING` — resource created, no process launched yet.
+ * `STARTING` — process launched, runtime bootstrapping in progress.
+ *
+ * This is distinct from {@link isActivePhase} (READY | BUSY) where
+ * the runner is stable and accepting work.
  *
  * Useful for driving conditional polling: poll while transitional
  * runners exist, stop when all runners reach a stable state.
  */
 export function isTransitionalPhase(phase: RunnerPhase): boolean {
-  return phase === RunnerPhase.PENDING;
+  return phase === RunnerPhase.PENDING || phase === RunnerPhase.STARTING;
 }

package/src/session/__tests__/useCreateSession.test.tsx

@@ -0,0 +1,296 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { renderHook, act } from "@testing-library/react";
+import type { ReactNode } from "react";
+import { Harness } from "@stigmer/protos/ai/stigmer/agentic/session/v1/enum_pb";
+import type { Stigmer } from "@stigmer/sdk";
+import { StigmerContext } from "../../context";
+import { useCreateSession } from "../useCreateSession";
+
+function buildMockClient(overrides: {
+  sessionCreate?: ReturnType<typeof vi.fn>;
+  agentGetByReference?: ReturnType<typeof vi.fn>;
+} = {}) {
+  return {
+    session: {
+      create: overrides.sessionCreate ?? vi.fn(),
+    },
+    agent: {
+      getByReference: overrides.agentGetByReference ?? vi.fn(),
+    },
+  } as unknown as Stigmer;
+}
+
+function makeWrapper(client: Stigmer) {
+  return ({ children }: { children: ReactNode }) => (
+    <StigmerContext.Provider value={client}>{children}</StigmerContext.Provider>
+  );
+}
+
+function fakeSessionResponse(sessionId: string) {
+  return { metadata: { id: sessionId } };
+}
+
+describe("useCreateSession", () => {
+  let sessionCreateMock: ReturnType<typeof vi.fn>;
+  let agentGetByRefMock: ReturnType<typeof vi.fn>;
+  let client: Stigmer;
+
+  beforeEach(() => {
+    sessionCreateMock = vi.fn();
+    agentGetByRefMock = vi.fn();
+    client = buildMockClient({
+      sessionCreate: sessionCreateMock,
+      agentGetByReference: agentGetByRefMock,
+    });
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("starts in idle state", () => {
+    const { result } = renderHook(() => useCreateSession(), {
+      wrapper: makeWrapper(client),
+    });
+    expect(result.current.isCreating).toBe(false);
+    expect(result.current.error).toBeNull();
+  });
+
+  describe("agentInstanceId path", () => {
+    it("creates a session with the given instance ID", async () => {
+      sessionCreateMock.mockResolvedValueOnce(fakeSessionResponse("sess-1"));
+
+      const { result } = renderHook(() => useCreateSession(), {
+        wrapper: makeWrapper(client),
+      });
+
+      let outcome: { sessionId: string } | undefined;
+      await act(async () => {
+        outcome = await result.current.create({
+          org: "acme",
+          agentInstanceId: "inst-abc",
+        });
+      });
+
+      expect(outcome!.sessionId).toBe("sess-1");
+      expect(sessionCreateMock).toHaveBeenCalledOnce();
+      expect(sessionCreateMock.mock.calls[0][0]).toMatchObject({
+        org: "acme",
+        agentInstanceId: "inst-abc",
+      });
+    });
+  });
+
+  describe("agentRef path", () => {
+    it("resolves the agent reference to its default instance", async () => {
+      agentGetByRefMock.mockResolvedValueOnce({
+        status: { defaultInstanceId: "inst-resolved" },
+      });
+      sessionCreateMock.mockResolvedValueOnce(fakeSessionResponse("sess-2"));
+
+      const { result } = renderHook(() => useCreateSession(), {
+        wrapper: makeWrapper(client),
+      });
+
+      await act(async () => {
+        await result.current.create({
+          org: "acme",
+          agentRef: { org: "acme", slug: "my-agent" },
+        });
+      });
+
+      expect(agentGetByRefMock).toHaveBeenCalledWith({
+        org: "acme",
+        slug: "my-agent",
+      });
+      expect(sessionCreateMock.mock.calls[0][0]).toMatchObject({
+        agentInstanceId: "inst-resolved",
+      });
+    });
+
+    it("throws when agent has no default instance", async () => {
+      agentGetByRefMock.mockResolvedValueOnce({ status: {} });
+
+      const { result } = renderHook(() => useCreateSession(), {
+        wrapper: makeWrapper(client),
+      });
+
+      await act(async () => {
+        await expect(
+          result.current.create({
+            org: "acme",
+            agentRef: { org: "acme", slug: "no-instance" },
+          }),
+        ).rejects.toThrow("does not have a default instance");
+      });
+
+      expect(result.current.error).not.toBeNull();
+      expect(result.current.error!.message).toContain(
+        "does not have a default instance",
+      );
+    });
+  });
+
+  describe("harness proto conversion", () => {
+    it("passes Harness.CURSOR when harness is cursor", async () => {
+      sessionCreateMock.mockResolvedValueOnce(fakeSessionResponse("sess-h1"));
+
+      const { result } = renderHook(() => useCreateSession(), {
+        wrapper: makeWrapper(client),
+      });
+
+      await act(async () => {
+        await result.current.create({
+          org: "acme",
+          agentInstanceId: "inst-1",
+          harness: "cursor",
+        });
+      });
+
+      expect(sessionCreateMock.mock.calls[0][0].harness).toBe(Harness.CURSOR);
+    });
+
+    it("passes Harness.NATIVE when harness is native", async () => {
+      sessionCreateMock.mockResolvedValueOnce(fakeSessionResponse("sess-h2"));
+
+      const { result } = renderHook(() => useCreateSession(), {
+        wrapper: makeWrapper(client),
+      });
+
+      await act(async () => {
+        await result.current.create({
+          org: "acme",
+          agentInstanceId: "inst-1",
+          harness: "native",
+        });
+      });
+
+      expect(sessionCreateMock.mock.calls[0][0].harness).toBe(Harness.NATIVE);
+    });
+
+    it("passes undefined when harness is omitted", async () => {
+      sessionCreateMock.mockResolvedValueOnce(fakeSessionResponse("sess-h3"));
+
+      const { result } = renderHook(() => useCreateSession(), {
+        wrapper: makeWrapper(client),
+      });
+
+      await act(async () => {
+        await result.current.create({
+          org: "acme",
+          agentInstanceId: "inst-1",
+        });
+      });
+
+      expect(sessionCreateMock.mock.calls[0][0].harness).toBeUndefined();
+    });
+  });
+
+  describe("loading state lifecycle", () => {
+    it("isCreating is true during the RPC and false after", async () => {
+      let resolveCreate!: (v: unknown) => void;
+      sessionCreateMock.mockReturnValueOnce(
+        new Promise((r) => { resolveCreate = r; }),
+      );
+
+      const { result } = renderHook(() => useCreateSession(), {
+        wrapper: makeWrapper(client),
+      });
+
+      let createPromise: Promise<unknown>;
+      act(() => {
+        createPromise = result.current.create({
+          org: "acme",
+          agentInstanceId: "inst-1",
+        });
+      });
+
+      expect(result.current.isCreating).toBe(true);
+
+      await act(async () => {
+        resolveCreate(fakeSessionResponse("sess-lc"));
+        await createPromise;
+      });
+
+      expect(result.current.isCreating).toBe(false);
+    });
+  });
+
+  describe("error handling", () => {
+    it("sets error on RPC failure and resets isCreating", async () => {
+      sessionCreateMock.mockRejectedValueOnce(new Error("network timeout"));
+
+      const { result } = renderHook(() => useCreateSession(), {
+        wrapper: makeWrapper(client),
+      });
+
+      await act(async () => {
+        await expect(
+          result.current.create({
+            org: "acme",
+            agentInstanceId: "inst-1",
+          }),
+        ).rejects.toThrow("network timeout");
+      });
+
+      expect(result.current.isCreating).toBe(false);
+      expect(result.current.error).toBeInstanceOf(Error);
+      expect(result.current.error!.message).toBe("network timeout");
+    });
+
+    it("clearError resets error to null", async () => {
+      sessionCreateMock.mockRejectedValueOnce(new Error("fail"));
+
+      const { result } = renderHook(() => useCreateSession(), {
+        wrapper: makeWrapper(client),
+      });
+
+      await act(async () => {
+        try {
+          await result.current.create({
+            org: "acme",
+            agentInstanceId: "inst-1",
+          });
+        } catch { /* expected */ }
+      });
+
+      expect(result.current.error).not.toBeNull();
+
+      act(() => {
+        result.current.clearError();
+      });
+
+      expect(result.current.error).toBeNull();
+    });
+
+    it("clears previous error on new create attempt", async () => {
+      sessionCreateMock
+        .mockRejectedValueOnce(new Error("first fail"))
+        .mockResolvedValueOnce(fakeSessionResponse("sess-retry"));
+
+      const { result } = renderHook(() => useCreateSession(), {
+        wrapper: makeWrapper(client),
+      });
+
+      await act(async () => {
+        try {
+          await result.current.create({
+            org: "acme",
+            agentInstanceId: "inst-1",
+          });
+        } catch { /* expected */ }
+      });
+
+      expect(result.current.error).not.toBeNull();
+
+      await act(async () => {
+        await result.current.create({
+          org: "acme",
+          agentInstanceId: "inst-1",
+        });
+      });
+
+      expect(result.current.error).toBeNull();
+    });
+  });
+});

package/src/session/__tests__/useNewSessionFlow.test.tsx

@@ -0,0 +1,258 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { renderHook, act } from "@testing-library/react";
+import { DEFAULT_MODEL_ID, DEFAULT_CURSOR_MODEL_ID } from "../../models/registry";
+import type { UseCreateSessionReturn } from "../useCreateSession";
+
+const mockCreateSession = vi.fn<UseCreateSessionReturn["create"]>();
+vi.mock("../useCreateSession", () => ({
+  useCreateSession: () => ({
+    create: mockCreateSession,
+    isCreating: false,
+    error: null,
+    clearError: vi.fn(),
+  }),
+}));
+
+const mockCreateExecution = vi.fn();
+vi.mock("../../execution/useCreateAgentExecution", () => ({
+  useCreateAgentExecution: () => ({
+    create: mockCreateExecution,
+    isCreating: false,
+    error: null,
+    clearError: vi.fn(),
+  }),
+}));
+
+const mockDefaultAgent = {
+  agent: null as { status?: { defaultInstanceId?: string } } | null,
+  isLoading: false,
+  error: null,
+  refetch: vi.fn(),
+};
+vi.mock("../../agent", () => ({
+  useDefaultAgent: () => mockDefaultAgent,
+}));
+
+const mockWorkspace = {
+  entries: [],
+  hasEntries: false,
+  toInput: vi.fn().mockReturnValue([]),
+  addGitRepo: vi.fn(),
+  addLocalPath: vi.fn(),
+  removeEntry: vi.fn(),
+  clear: vi.fn(),
+};
+vi.mock("../../workspace", () => ({
+  useWorkspaceEntries: () => mockWorkspace,
+}));
+
+const mockSessionVariables = {
+  variables: [],
+  hasVariables: false,
+  setVariable: vi.fn(),
+  removeVariable: vi.fn(),
+  clear: vi.fn(),
+  toMap: vi.fn().mockReturnValue(new Map()),
+};
+vi.mock("../../execution/useSessionVariables", () => ({
+  useSessionVariables: () => mockSessionVariables,
+}));
+
+import { useNewSessionFlow } from "../useNewSessionFlow";
+
+const STORAGE_KEY_HARNESS = "stigmer:session:harness";
+const STORAGE_KEY_MODEL_NATIVE = "stigmer:session:model";
+const STORAGE_KEY_MODEL_CURSOR = "stigmer:session:model:cursor";
+
+function defaultOptions() {
+  return {
+    org: "acme",
+    onSessionCreated: vi.fn(),
+    onError: vi.fn(),
+  };
+}
+
+describe("useNewSessionFlow", () => {
+  beforeEach(() => {
+    localStorage.clear();
+    mockDefaultAgent.agent = {
+      status: { defaultInstanceId: "default-inst" },
+    };
+    mockDefaultAgent.isLoading = false;
+    mockDefaultAgent.error = null;
+    mockCreateSession.mockResolvedValue({ sessionId: "sess-new" });
+    mockCreateExecution.mockResolvedValue({});
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    localStorage.clear();
+  });
+
+  describe("harness state", () => {
+    it("defaults to native when localStorage is empty", () => {
+      const { result } = renderHook(() => useNewSessionFlow(defaultOptions()));
+      expect(result.current.harness).toBe("native");
+    });
+
+    it("restores cursor harness from localStorage", () => {
+      localStorage.setItem(STORAGE_KEY_HARNESS, "cursor");
+      const { result } = renderHook(() => useNewSessionFlow(defaultOptions()));
+      expect(result.current.harness).toBe("cursor");
+    });
+
+    it("falls back to native for unknown localStorage values", () => {
+      localStorage.setItem(STORAGE_KEY_HARNESS, "unknown-value");
+      const { result } = renderHook(() => useNewSessionFlow(defaultOptions()));
+      expect(result.current.harness).toBe("native");
+    });
+
+    it("persists harness to localStorage on change", () => {
+      const { result } = renderHook(() => useNewSessionFlow(defaultOptions()));
+
+      act(() => result.current.setHarness("cursor"));
+
+      expect(localStorage.getItem(STORAGE_KEY_HARNESS)).toBe("cursor");
+      expect(result.current.harness).toBe("cursor");
+    });
+
+    it("persists native harness to localStorage", () => {
+      localStorage.setItem(STORAGE_KEY_HARNESS, "cursor");
+      const { result } = renderHook(() => useNewSessionFlow(defaultOptions()));
+
+      act(() => result.current.setHarness("native"));
+
+      expect(localStorage.getItem(STORAGE_KEY_HARNESS)).toBe("native");
+    });
+  });
+
+  describe("per-harness model persistence", () => {
+    it("uses separate storage keys for native and cursor models", () => {
+      const { result } = renderHook(() => useNewSessionFlow(defaultOptions()));
+
+      act(() => result.current.setModelId(DEFAULT_MODEL_ID));
+
+      expect(localStorage.getItem(STORAGE_KEY_MODEL_NATIVE)).toBe(
+        DEFAULT_MODEL_ID,
+      );
+      expect(localStorage.getItem(STORAGE_KEY_MODEL_CURSOR)).toBeNull();
+    });
+
+    it("persists cursor model to cursor-specific key", () => {
+      localStorage.setItem(STORAGE_KEY_HARNESS, "cursor");
+      const { result } = renderHook(() => useNewSessionFlow(defaultOptions()));
+
+      act(() => result.current.setModelId(DEFAULT_CURSOR_MODEL_ID));
+
+      expect(localStorage.getItem(STORAGE_KEY_MODEL_CURSOR)).toBe(
+        DEFAULT_CURSOR_MODEL_ID,
+      );
+    });
+
+    it("restores per-harness model when switching harness", () => {
+      localStorage.setItem(STORAGE_KEY_MODEL_CURSOR, DEFAULT_CURSOR_MODEL_ID);
+
+      const { result } = renderHook(() => useNewSessionFlow(defaultOptions()));
+
+      act(() => result.current.setHarness("cursor"));
+
+      expect(result.current.modelId).toBe(DEFAULT_CURSOR_MODEL_ID);
+    });
+
+    it("clears modelId when switching to a harness with no stored model", () => {
+      const { result } = renderHook(() => useNewSessionFlow(defaultOptions()));
+
+      act(() => result.current.setModelId(DEFAULT_MODEL_ID));
+      expect(result.current.modelId).toBe(DEFAULT_MODEL_ID);
+
+      act(() => result.current.setHarness("cursor"));
+
+      // No stored cursor model → modelId should be undefined
+      // (unless the model happens to be valid in the cursor registry)
+      if (result.current.modelId !== undefined) {
+        // If it has a value, it must be valid for cursor harness
+        expect(result.current.modelId).toBe(
+          localStorage.getItem(STORAGE_KEY_MODEL_CURSOR),
+        );
+      }
+    });
+
+    it("invalidates modelId when it is not in the active harness registry", () => {
+      const { result } = renderHook(() => useNewSessionFlow(defaultOptions()));
+
+      // Set a native-only model
+      act(() => result.current.setModelId(DEFAULT_MODEL_ID));
+      expect(result.current.modelId).toBe(DEFAULT_MODEL_ID);
+
+      // Switch to cursor → native model should be invalidated
+      act(() => result.current.setHarness("cursor"));
+
+      // DEFAULT_MODEL_ID (anthropic) is not in cursor registry
+      expect(result.current.modelId).not.toBe(DEFAULT_MODEL_ID);
+    });
+  });
+
+  describe("submit with harness", () => {
+    it("passes harness field to createSession", async () => {
+      const opts = defaultOptions();
+      const { result } = renderHook(() => useNewSessionFlow(opts));
+
+      await act(async () => {
+        await result.current.submit("Hello");
+      });
+
+      expect(mockCreateSession).toHaveBeenCalledOnce();
+      const sessionInput = mockCreateSession.mock.calls[0][0];
+      expect(sessionInput.harness).toBe("native");
+    });
+
+    it("passes cursor harness to createSession after switching", async () => {
+      const opts = defaultOptions();
+      const { result } = renderHook(() => useNewSessionFlow(opts));
+
+      act(() => result.current.setHarness("cursor"));
+
+      await act(async () => {
+        await result.current.submit("Hello");
+      });
+
+      const sessionInput = mockCreateSession.mock.calls[0][0];
+      expect(sessionInput.harness).toBe("cursor");
+    });
+
+    it("calls onSessionCreated on success", async () => {
+      const opts = defaultOptions();
+      const { result } = renderHook(() => useNewSessionFlow(opts));
+
+      await act(async () => {
+        await result.current.submit("Hello");
+      });
+
+      expect(opts.onSessionCreated).toHaveBeenCalledWith("sess-new");
+    });
+
+    it("sets submitError and calls onError on failure", async () => {
+      mockCreateSession.mockRejectedValueOnce(new Error("RPC fail"));
+      const opts = defaultOptions();
+      const { result } = renderHook(() => useNewSessionFlow(opts));
+
+      await act(async () => {
+        await result.current.submit("Hello");
+      });
+
+      expect(result.current.submitError).not.toBeNull();
+      expect(opts.onError).toHaveBeenCalled();
+    });
+
+    it("resets isSubmitting after completion", async () => {
+      const opts = defaultOptions();
+      const { result } = renderHook(() => useNewSessionFlow(opts));
+
+      await act(async () => {
+        await result.current.submit("Hello");
+      });
+
+      expect(result.current.isSubmitting).toBe(false);
+    });
+  });
+});

package/src/session/__tests__/useSessionConversation.test.tsx

@@ -302,4 +302,57 @@ describe("useSessionConversation", () => {
       expect(result.current.pendingUserMessage).toBeNull();
     });
   });
+
+  it("full follow-up lifecycle: active execution completes → canSendFollowUp → sendFollowUp succeeds", async () => {
+    // Start with one IN_PROGRESS execution (simulates a Cursor execution running)
+    const activeExec = makeExecution("exec-1", ExecutionPhase.EXECUTION_IN_PROGRESS);
+    methods.listBySession.mockResolvedValue({ entries: [activeExec] });
+
+    const execStream = createControllableStream<AgentExecution>();
+    methods.subscribe.mockReturnValue(execStream.generator);
+
+    const { result } = renderHook(
+      () => useSessionConversation("session-1", "org"),
+      { wrapper: createWrapper(mockStigmer) },
+    );
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+    // Initially canSendFollowUp should be false (execution is active)
+    expect(result.current.canSendFollowUp).toBe(false);
+
+    // Stream delivers EXECUTION_COMPLETED — simulating Cursor run finishing
+    const completedExec = makeExecution("exec-1", ExecutionPhase.EXECUTION_COMPLETED);
+    act(() => {
+      execStream.push(completedExec);
+    });
+
+    // After stream completes, the hook should refetch executions.
+    // Mock the refetch to return the completed execution.
+    methods.listBySession.mockResolvedValue({ entries: [completedExec] });
+
+    // Wait for canSendFollowUp to become true
+    await waitFor(() => {
+      expect(result.current.canSendFollowUp).toBe(true);
+    });
+
+    // Now send a follow-up message
+    const followUpExec = makeExecution("exec-2", ExecutionPhase.EXECUTION_PENDING);
+    followUpExec.metadata!.id = "exec-2";
+    methods.executionCreate.mockResolvedValue(followUpExec);
+
+    await act(async () => {
+      await result.current.sendFollowUp("Follow-up message", { modelName: "default" });
+    });
+
+    // Verify the create call was made with the correct session and message
+    expect(methods.executionCreate).toHaveBeenCalledWith(
+      expect.objectContaining({
+        org: "org",
+        sessionId: "session-1",
+        message: "Follow-up message",
+        executionConfig: expect.objectContaining({ modelName: "default" }),
+      }),
+    );
+  });
 });