@stigmer/react 3.1.13 → 3.1.15

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

@@ -7,16 +7,9 @@ import type { ModelRegistryState } from "../../models/ModelRegistryContext";
 import { ExecutionTargetContext } from "../../execution-target-context";
 import { RunnerAdapterContext } from "../../runner-adapter";
 import type { RunnerAdapter } from "../../runner-adapter";
-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 mockGetByReference = vi.fn();
+vi.mock("../../hooks", () => ({
+  useStigmer: () => ({ agent: { getByReference: mockGetByReference } }),
 }));
 
 const mockCreateExecution = vi.fn();
@@ -127,8 +120,10 @@ describe("useNewSessionFlow", () => {
     };
     mockDefaultAgent.isLoading = false;
     mockDefaultAgent.error = null;
-    mockCreateSession.mockResolvedValue({ sessionId: "sess-new" });
-    mockCreateExecution.mockResolvedValue({});
+    mockCreateExecution.mockResolvedValue({
+      executionId: "exec-new",
+      sessionId: "sess-new",
+    });
   });
 
   afterEach(() => {
@@ -296,8 +291,8 @@ describe("useNewSessionFlow", () => {
     });
   });
 
-  describe("submit with harness", () => {
-    it("passes harness field to createSession", async () => {
+  describe("submit — one-call bootstrap", () => {
+    it("creates the execution with an embedded sessionSpec in a single call", async () => {
       const opts = defaultOptions();
       const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
 
@@ -305,12 +300,27 @@ describe("useNewSessionFlow", () => {
         await result.current.submit("Hello");
       });
 
-      expect(mockCreateSession).toHaveBeenCalledOnce();
-      const sessionInput = mockCreateSession.mock.calls[0][0];
-      expect(sessionInput.harness).toBe("native");
+      expect(mockCreateExecution).toHaveBeenCalledOnce();
+      const execInput = mockCreateExecution.mock.calls[0][0];
+      expect(execInput.message).toBe("Hello");
+      expect(execInput.sessionSpec).toBeDefined();
+      expect(execInput.sessionSpec.agentInstanceId).toBe("default-inst");
+      expect(execInput.sessionId).toBeUndefined();
+    });
+
+    it("passes harness in the sessionSpec", async () => {
+      const opts = defaultOptions();
+      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
+
+      await act(async () => {
+        await result.current.submit("Hello");
+      });
+
+      const execInput = mockCreateExecution.mock.calls[0][0];
+      expect(execInput.sessionSpec.harness).toBe("native");
     });
 
-    it("passes cursor harness to createSession after switching", async () => {
+    it("passes cursor harness in the sessionSpec after switching", async () => {
       const opts = defaultOptions();
       const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
 
@@ -320,11 +330,11 @@ describe("useNewSessionFlow", () => {
         await result.current.submit("Hello");
       });
 
-      const sessionInput = mockCreateSession.mock.calls[0][0];
-      expect(sessionInput.harness).toBe("cursor");
+      const execInput = mockCreateExecution.mock.calls[0][0];
+      expect(execInput.sessionSpec.harness).toBe("cursor");
     });
 
-    it("calls onSessionCreated on success", async () => {
+    it("calls onSessionCreated with the server-assigned session id", async () => {
       const opts = defaultOptions();
       const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
 
@@ -336,7 +346,7 @@ describe("useNewSessionFlow", () => {
     });
 
     it("sets submitError and calls onError on failure", async () => {
-      mockCreateSession.mockRejectedValueOnce(new Error("RPC fail"));
+      mockCreateExecution.mockRejectedValueOnce(new Error("RPC fail"));
       const opts = defaultOptions();
       const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
 
@@ -360,8 +370,48 @@ describe("useNewSessionFlow", () => {
     });
   });
 
+  describe("submit — agent resolution strategies", () => {
+    it("uses the saved resolution's instance directly (no agent lookup)", async () => {
+      const opts = defaultOptions();
+      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
+
+      act(() => {
+        result.current.setAgentRef({ org: "acme", slug: "reviewer" });
+        result.current.setResolution({ mode: "saved", instanceId: "saved-inst" });
+      });
+      await act(async () => {
+        await result.current.submit("Hello");
+      });
+
+      expect(mockGetByReference).not.toHaveBeenCalled();
+      const execInput = mockCreateExecution.mock.calls[0][0];
+      expect(execInput.sessionSpec.agentInstanceId).toBe("saved-inst");
+      expect(execInput.agentId).toBeUndefined();
+    });
+
+    it("resolves a non-saved agentRef to agentId and lets the server pick the instance", async () => {
+      mockGetByReference.mockResolvedValueOnce({ metadata: { id: "agt-resolved" } });
+      const opts = defaultOptions();
+      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
+
+      act(() => {
+        result.current.setAgentRef({ org: "acme", slug: "reviewer" });
+        result.current.setResolution({ mode: "direct" });
+      });
+      await act(async () => {
+        await result.current.submit("Hello");
+      });
+
+      expect(mockGetByReference).toHaveBeenCalledWith({ org: "acme", slug: "reviewer" });
+      const execInput = mockCreateExecution.mock.calls[0][0];
+      expect(execInput.agentId).toBe("agt-resolved");
+      // The server resolves (and if needed creates) the default instance.
+      expect(execInput.sessionSpec.agentInstanceId).toBeUndefined();
+    });
+  });
+
   describe("submit with executionTarget", () => {
-    it("passes executionTarget to createSession when provided", async () => {
+    it("passes executionTarget in the sessionSpec when provided", async () => {
       const opts = { ...defaultOptions(), executionTarget: "local" as const };
       const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
 
@@ -369,9 +419,9 @@ describe("useNewSessionFlow", () => {
         await result.current.submit("Hello");
       });
 
-      expect(mockCreateSession).toHaveBeenCalledOnce();
-      const sessionInput = mockCreateSession.mock.calls[0][0];
-      expect(sessionInput.executionTarget).toBe("local");
+      expect(mockCreateExecution).toHaveBeenCalledOnce();
+      const execInput = mockCreateExecution.mock.calls[0][0];
+      expect(execInput.sessionSpec.executionTarget).toBe("local");
     });
 
     it("does not include executionTarget when not provided", async () => {
@@ -382,9 +432,9 @@ describe("useNewSessionFlow", () => {
         await result.current.submit("Hello");
       });
 
-      expect(mockCreateSession).toHaveBeenCalledOnce();
-      const sessionInput = mockCreateSession.mock.calls[0][0];
-      expect(sessionInput.executionTarget).toBeUndefined();
+      expect(mockCreateExecution).toHaveBeenCalledOnce();
+      const execInput = mockCreateExecution.mock.calls[0][0];
+      expect(execInput.sessionSpec.executionTarget).toBeUndefined();
     });
 
     it("uses context executionTarget when per-hook option is omitted", async () => {
@@ -395,9 +445,9 @@ describe("useNewSessionFlow", () => {
         await result.current.submit("Hello");
       });
 
-      expect(mockCreateSession).toHaveBeenCalledOnce();
-      const sessionInput = mockCreateSession.mock.calls[0][0];
-      expect(sessionInput.executionTarget).toBe("local");
+      expect(mockCreateExecution).toHaveBeenCalledOnce();
+      const execInput = mockCreateExecution.mock.calls[0][0];
+      expect(execInput.sessionSpec.executionTarget).toBe("local");
     });
 
     it("per-hook executionTarget option overrides context", async () => {
@@ -408,14 +458,14 @@ describe("useNewSessionFlow", () => {
         await result.current.submit("Hello");
       });
 
-      expect(mockCreateSession).toHaveBeenCalledOnce();
-      const sessionInput = mockCreateSession.mock.calls[0][0];
-      expect(sessionInput.executionTarget).toBe("local");
+      expect(mockCreateExecution).toHaveBeenCalledOnce();
+      const execInput = mockCreateExecution.mock.calls[0][0];
+      expect(execInput.sessionSpec.executionTarget).toBe("local");
     });
   });
 
-  describe("submit — local runner worker (eager attach)", () => {
-    it("attaches the worker before creating the first execution", async () => {
+  describe("submit — local runner worker (post-create attach)", () => {
+    it("attaches the worker after the bootstrap create returns the session id", async () => {
       const adapter = createMockAdapter();
       const opts = defaultOptions();
       const { result } = renderHook(() => useNewSessionFlow(opts), {
@@ -430,10 +480,12 @@ describe("useNewSessionFlow", () => {
       expect(adapter.onSessionOpened).toHaveBeenCalledWith("sess-new");
       expect(adapter.onSessionClosed).not.toHaveBeenCalled();
 
-      // The worker must be polling before the first execution exists.
+      // The session ID only exists after the one-call create, so the attach
+      // follows it. This is safe: the first activity waits on the session's
+      // task queue for a worker (5-minute ScheduleToStart window).
       const openedOrder = adapter.onSessionOpened.mock.invocationCallOrder[0];
       const execOrder = mockCreateExecution.mock.invocationCallOrder[0];
-      expect(openedOrder).toBeLessThan(execOrder);
+      expect(execOrder).toBeLessThan(openedOrder);
     });
 
     it("does not attach a worker when the target is cloud", async () => {
@@ -450,7 +502,7 @@ describe("useNewSessionFlow", () => {
       expect(adapter.onSessionOpened).not.toHaveBeenCalled();
     });
 
-    it("detaches the worker when the first execution fails (no leak)", async () => {
+    it("never attaches a worker when the bootstrap create fails (no leak)", async () => {
       const adapter = createMockAdapter();
       mockCreateExecution.mockRejectedValueOnce(new Error("execution boom"));
       const opts = defaultOptions();
@@ -462,11 +514,30 @@ describe("useNewSessionFlow", () => {
         await result.current.submit("Hello");
       });
 
-      expect(adapter.onSessionOpened).toHaveBeenCalledWith("sess-new");
-      expect(adapter.onSessionClosed).toHaveBeenCalledWith("sess-new");
+      // The create failed before a session existed, so there is no worker
+      // to attach — and therefore nothing to compensate/detach.
+      expect(adapter.onSessionOpened).not.toHaveBeenCalled();
+      expect(adapter.onSessionClosed).not.toHaveBeenCalled();
       expect(result.current.submitError).not.toBeNull();
       expect(opts.onError).toHaveBeenCalled();
     });
+
+    it("surfaces an attach failure without navigating", async () => {
+      const adapter = createMockAdapter();
+      adapter.onSessionOpened.mockRejectedValueOnce(new Error("runner down"));
+      const opts = defaultOptions();
+      const { result } = renderHook(() => useNewSessionFlow(opts), {
+        wrapper: createWrapper("local", adapter),
+      });
+
+      await act(async () => {
+        await result.current.submit("Hello");
+      });
+
+      expect(result.current.submitError).not.toBeNull();
+      expect(opts.onError).toHaveBeenCalled();
+      expect(opts.onSessionCreated).not.toHaveBeenCalled();
+    });
   });
 
   describe("host runtime env (getRuntimeEnv)", () => {
@@ -528,7 +599,6 @@ describe("useNewSessionFlow", () => {
       });
 
       // No orphan session, no execution — the failure is fully pre-flight.
-      expect(mockCreateSession).not.toHaveBeenCalled();
       expect(mockCreateExecution).not.toHaveBeenCalled();
       expect(result.current.submitError).toContain("token mint failed");
       expect(opts.onError).toHaveBeenCalled();
@@ -587,7 +657,7 @@ describe("useNewSessionFlow", () => {
         await result.current.submit("Hello");
       });
 
-      expect(mockCreateSession.mock.calls[0][0].harness).toBe("cursor");
+      expect(mockCreateExecution.mock.calls[0][0].sessionSpec.harness).toBe("cursor");
     });
   });
 
@@ -607,8 +677,8 @@ describe("useNewSessionFlow", () => {
       });
 
       expect(mockDefaultAgent.waitForResolution).toHaveBeenCalledOnce();
-      expect(mockCreateSession).toHaveBeenCalledOnce();
-      expect(mockCreateSession.mock.calls[0][0].agentInstanceId).toBe("awaited-inst");
+      expect(mockCreateExecution).toHaveBeenCalledOnce();
+      expect(mockCreateExecution.mock.calls[0][0].sessionSpec.agentInstanceId).toBe("awaited-inst");
       expect(opts.onSessionCreated).toHaveBeenCalledWith("sess-new");
       expect(result.current.submitError).toBeNull();
     });
@@ -630,7 +700,7 @@ describe("useNewSessionFlow", () => {
 
       expect(result.current.submitError).toBeTruthy();
       expect(opts.onError).toHaveBeenCalled();
-      expect(mockCreateSession).not.toHaveBeenCalled();
+      expect(mockCreateExecution).not.toHaveBeenCalled();
     });
 
     it("surfaces timeout error when fetch never resolves", async () => {
@@ -661,7 +731,7 @@ describe("useNewSessionFlow", () => {
 
       expect(result.current.submitError).toContain("did not load in time");
       expect(opts.onError).toHaveBeenCalled();
-      expect(mockCreateSession).not.toHaveBeenCalled();
+      expect(mockCreateExecution).not.toHaveBeenCalled();
 
       vi.useRealTimers();
     });
@@ -680,7 +750,7 @@ describe("useNewSessionFlow", () => {
 
       expect(result.current.submitError).toContain("Failed to load default agent");
       expect(opts.onError).toHaveBeenCalled();
-      expect(mockCreateSession).not.toHaveBeenCalled();
+      expect(mockCreateExecution).not.toHaveBeenCalled();
       expect(mockDefaultAgent.waitForResolution).not.toHaveBeenCalled();
     });
   });
@@ -711,8 +781,8 @@ describe("useNewSessionFlow", () => {
         await result.current.submit("Hello");
       });
 
-      expect(mockCreateSession).toHaveBeenCalledOnce();
-      expect(mockCreateSession.mock.calls[0][0].agentInstanceId).toBe("shared-inst");
+      expect(mockCreateExecution).toHaveBeenCalledOnce();
+      expect(mockCreateExecution.mock.calls[0][0].sessionSpec.agentInstanceId).toBe("shared-inst");
       expect(opts.onSessionCreated).toHaveBeenCalledWith("sess-new");
     });
 
@@ -726,7 +796,6 @@ describe("useNewSessionFlow", () => {
         await result.current.submit("Hello");
       });
 
-      expect(mockCreateSession).not.toHaveBeenCalled();
       expect(mockCreateExecution).not.toHaveBeenCalled();
       expect(result.current.submitError).toContain("still loading");
       expect(opts.onError).toHaveBeenCalled();

package/src/session/useNewSessionFlow.ts

@@ -10,8 +10,8 @@ import { DEFAULT_HARNESS, type HarnessOption } from "../models/harness.js";
 import { useWorkspaceEntries, type UseWorkspaceEntriesReturn } from "../workspace/index.js";
 import { useSessionVariables, type UseSessionVariablesReturn } from "../execution/useSessionVariables.js";
 import type { SessionComposerSubmitContext } from "../composer/index.js";
+import { useStigmer } from "../hooks.js";
 import { withTimeout } from "../internal/withTimeout.js";
-import { useCreateSession } from "./useCreateSession.js";
 import { useCreateAgentExecution } from "../execution/useCreateAgentExecution.js";
 import type { ExecutionTargetOption } from "./execution-target.js";
 import { useExecutionTarget } from "../execution-target-context.js";
@@ -140,8 +140,9 @@ export interface UseNewSessionFlowReturn {
    * Create a session with the first execution.
    *
    * Composes all managed state (agent, workspace, MCP servers, skills,
-   * model, session variables) into the session and execution
-   * creation RPCs, then calls `onSessionCreated` on success.
+   * model, session variables) into a single bootstrap RPC —
+   * `agentExecution.create` with an embedded session spec — then calls
+   * `onSessionCreated` on success.
    *
    * The `model` parameter overrides `modelId` for this submission only
    * (used when SessionComposer passes a per-message model selection).
@@ -160,7 +161,9 @@ export interface UseNewSessionFlowReturn {
  * model selection (with localStorage persistence), agent resolution,
  * MCP server/skill selection, workspace entries, and session
  * variables. On submission, creates the session and its first execution
- * in sequence, then notifies the consumer via `onSessionCreated`.
+ * with a single one-call bootstrap RPC (`agentExecution.create` with an
+ * embedded session spec), then notifies the consumer via
+ * `onSessionCreated`.
  *
  * This hook is framework-agnostic — it works identically in Next.js,
  * Vite, Tauri, or any React environment. Navigation, toast notifications,
@@ -210,8 +213,8 @@ export function useNewSessionFlow(
     return defaultHarness ?? DEFAULT_HARNESS;
   });
 
+  const stigmer = useStigmer();
   const { getModel, isLoading: isModelsLoading } = useModelRegistry({ harness });
-  const { create: createSession } = useCreateSession();
   const { create: createExecution } = useCreateAgentExecution();
   // Guests cannot read the org default agent (and must never run it) —
   // `null` puts the hook in its stable no-op mode, and the submit path
@@ -296,8 +299,7 @@ export function useNewSessionFlow(
           ? await resolveExecutionRuntimeEnv(getRuntimeEnv, context?.runtimeEnv)
           : context?.runtimeEnv;
 
-        const sessionFields = {
-          org,
+        const sessionSpecBase = {
           workspaceEntries: workspace.hasEntries
             ? workspace.toInput()
             : undefined,
@@ -317,19 +319,21 @@ export function useNewSessionFlow(
           workspaceFileRefs: context?.workspaceFileRefs,
         };
 
-        let sessionId: string;
+        // Resolve which agent the bootstrapped session runs against: an
+        // explicit instance when one is known, otherwise an agent ID the
+        // server resolves to its default instance (creating it if missing).
+        let agentInstanceId: string | undefined;
+        let agentId: string | undefined;
 
         if (agentRef && resolution) {
           if (resolution.mode === "saved") {
-            ({ sessionId } = await createSession({
-              ...sessionFields,
-              agentInstanceId: resolution.instanceId,
-            }));
+            agentInstanceId = resolution.instanceId;
           } else {
-            ({ sessionId } = await createSession({
-              ...sessionFields,
-              agentRef,
-            }));
+            // Slug reference → agent ID; the server handles instance
+            // resolution, including auto-creating a missing default
+            // instance (which a client-side lookup cannot).
+            const agent = await stigmer.agent.getByReference(agentRef);
+            agentId = agent.metadata!.id;
           }
         } else if (isGuest) {
           // Fail closed: a guest session is only ever created against the
@@ -360,32 +364,29 @@ export function useNewSessionFlow(
               );
             }
           }
-          ({ sessionId } = await createSession({
-            ...sessionFields,
-            agentInstanceId: resolvedInstanceId,
-          }));
+          agentInstanceId = resolvedInstanceId;
         }
 
-        // Local execution: attach the session's runner worker before creating
-        // the first execution. The session view (useSessionConversation) owns
-        // the steady-state lifecycle, but it is not mounted yet — navigation
-        // happens after onSessionCreated below — so without this eager attach
-        // the first execution would have no poller until the view mounts.
+        // One-call bootstrap: the embedded session spec and the first
+        // message travel in a single create — the server creates the
+        // session and dispatches the execution atomically.
+        const { sessionId } = await createExecution({
+          ...executionFields,
+          agentId,
+          sessionSpec: { ...sessionSpecBase, agentInstanceId },
+        });
+
+        // Local execution: attach the session's runner worker now that the
+        // session ID is known. The session view (useSessionConversation)
+        // owns the steady-state lifecycle, but it is not mounted yet —
+        // navigation happens after onSessionCreated below. Attaching after
+        // the create is safe: the first activity waits on the session's
+        // task queue for a worker (5-minute ScheduleToStart window), so the
+        // worker attached here picks it up immediately.
         if (adapter && executionTarget === "local") {
           await adapter.onSessionOpened(sessionId);
         }
 
-        try {
-          await createExecution({ ...executionFields, sessionId });
-        } catch (err) {
-          // The first execution failed and the session view will not mount,
-          // so detach the worker we just attached to avoid leaking it.
-          if (adapter && executionTarget === "local") {
-            adapter.onSessionClosed(sessionId).catch(() => {});
-          }
-          throw err;
-        }
-
         sessionVariables.clear();
         onSessionCreated(sessionId);
       } catch (err) {
@@ -414,7 +415,7 @@ export function useNewSessionFlow(
       isDefaultAgentLoading,
       defaultAgentError,
       waitForDefaultAgent,
-      createSession,
+      stigmer.agent,
       createExecution,
       sessionVariables,
       onSessionCreated,