@stigmer/react 1.0.3 → 2.0.0

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

@@ -4,6 +4,7 @@ import type { ReactNode } from "react";
 import { DEFAULT_MODEL_ID, DEFAULT_CURSOR_MODEL_ID, parseRegistryJson } from "../../models/registry";
 import { ModelRegistryContext } from "../../models/ModelRegistryContext";
 import type { ModelRegistryState } from "../../models/ModelRegistryContext";
+import { ExecutionTargetContext } from "../../execution-target-context";
 import type { UseCreateSessionReturn } from "../useCreateSession";
 
 const mockCreateSession = vi.fn<UseCreateSessionReturn["create"]>();
@@ -29,8 +30,9 @@ vi.mock("../../execution/useCreateAgentExecution", () => ({
 const mockDefaultAgent = {
   agent: null as { status?: { defaultInstanceId?: string } } | null,
   isLoading: false,
-  error: null,
+  error: null as Error | null,
   refetch: vi.fn(),
+  waitForResolution: vi.fn<() => Promise<unknown>>(),
 };
 vi.mock("../../agent", () => ({
   useDefaultAgent: () => mockDefaultAgent,
@@ -61,17 +63,6 @@ vi.mock("../../execution/useSessionVariables", () => ({
   useSessionVariables: () => mockSessionVariables,
 }));
 
-const mockRunnerList = {
-  runners: [] as { metadata?: { id: string; name?: string } }[],
-  isLoading: false,
-  isRefetching: false,
-  error: null,
-  refetch: vi.fn(),
-};
-vi.mock("../../runner/useRunnerList", () => ({
-  useRunnerList: () => mockRunnerList,
-}));
-
 import { useNewSessionFlow } from "../useNewSessionFlow";
 
 const TEST_MODELS = parseRegistryJson({
@@ -81,13 +72,15 @@ const TEST_MODELS = parseRegistryJson({
   ],
 });
 
-function createWrapper() {
+function createWrapper(executionTarget?: "local" | "cloud") {
   const state: ModelRegistryState = { models: TEST_MODELS, isLoading: false, error: null, refetch: () => {} };
   return function Wrapper({ children }: { children: ReactNode }) {
     return (
-      <ModelRegistryContext.Provider value={state}>
-        {children}
-      </ModelRegistryContext.Provider>
+      <ExecutionTargetContext.Provider value={executionTarget}>
+        <ModelRegistryContext.Provider value={state}>
+          {children}
+        </ModelRegistryContext.Provider>
+      </ExecutionTargetContext.Provider>
     );
   };
 }
@@ -112,8 +105,6 @@ describe("useNewSessionFlow", () => {
     };
     mockDefaultAgent.isLoading = false;
     mockDefaultAgent.error = null;
-    mockRunnerList.runners = [];
-    mockRunnerList.isLoading = false;
     mockCreateSession.mockResolvedValue({ sessionId: "sess-new" });
     mockCreateExecution.mockResolvedValue({});
   });
@@ -248,39 +239,6 @@ describe("useNewSessionFlow", () => {
     });
   });
 
-  describe("runner validation gate", () => {
-    it("restores runner when it exists in the live runner list", () => {
-      localStorage.setItem("stigmer:session:runner", "runner-abc");
-      mockRunnerList.runners = [{ metadata: { id: "runner-abc", name: "My Runner" } }];
-      mockRunnerList.isLoading = false;
-
-      const { result } = renderHook(() => useNewSessionFlow(defaultOptions()), { wrapper: createWrapper() });
-
-      expect(result.current.runnerId).toBe("runner-abc");
-    });
-
-    it("discards stale runner that no longer exists in the runner list", () => {
-      localStorage.setItem("stigmer:session:runner", "deleted-runner");
-      mockRunnerList.runners = [{ metadata: { id: "runner-abc", name: "My Runner" } }];
-      mockRunnerList.isLoading = false;
-
-      const { result } = renderHook(() => useNewSessionFlow(defaultOptions()), { wrapper: createWrapper() });
-
-      expect(result.current.runnerId).toBeNull();
-      expect(localStorage.getItem("stigmer:session:runner")).toBeNull();
-    });
-
-    it("does not restore runner while runner list is loading", () => {
-      localStorage.setItem("stigmer:session:runner", "runner-abc");
-      mockRunnerList.runners = [];
-      mockRunnerList.isLoading = true;
-
-      const { result } = renderHook(() => useNewSessionFlow(defaultOptions()), { wrapper: createWrapper() });
-
-      expect(result.current.runnerId).toBeNull();
-    });
-  });
-
   describe("model validation timing", () => {
     it("does not restore model while registry is loading", () => {
       localStorage.setItem(STORAGE_KEY_MODEL_NATIVE, DEFAULT_MODEL_ID);
@@ -379,4 +337,152 @@ describe("useNewSessionFlow", () => {
       expect(result.current.isSubmitting).toBe(false);
     });
   });
+
+  describe("submit with executionTarget", () => {
+    it("passes executionTarget to createSession when provided", async () => {
+      const opts = { ...defaultOptions(), executionTarget: "local" as const };
+      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
+
+      await act(async () => {
+        await result.current.submit("Hello");
+      });
+
+      expect(mockCreateSession).toHaveBeenCalledOnce();
+      const sessionInput = mockCreateSession.mock.calls[0][0];
+      expect(sessionInput.executionTarget).toBe("local");
+    });
+
+    it("does not include executionTarget when not provided", async () => {
+      const opts = defaultOptions();
+      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
+
+      await act(async () => {
+        await result.current.submit("Hello");
+      });
+
+      expect(mockCreateSession).toHaveBeenCalledOnce();
+      const sessionInput = mockCreateSession.mock.calls[0][0];
+      expect(sessionInput.executionTarget).toBeUndefined();
+    });
+
+    it("uses context executionTarget when per-hook option is omitted", async () => {
+      const opts = defaultOptions();
+      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper("local") });
+
+      await act(async () => {
+        await result.current.submit("Hello");
+      });
+
+      expect(mockCreateSession).toHaveBeenCalledOnce();
+      const sessionInput = mockCreateSession.mock.calls[0][0];
+      expect(sessionInput.executionTarget).toBe("local");
+    });
+
+    it("per-hook executionTarget option overrides context", async () => {
+      const opts = { ...defaultOptions(), executionTarget: "local" as const };
+      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper("cloud") });
+
+      await act(async () => {
+        await result.current.submit("Hello");
+      });
+
+      expect(mockCreateSession).toHaveBeenCalledOnce();
+      const sessionInput = mockCreateSession.mock.calls[0][0];
+      expect(sessionInput.executionTarget).toBe("local");
+    });
+  });
+
+  describe("submit while default agent is loading", () => {
+    it("awaits default agent and creates session when fetch resolves", async () => {
+      const resolvedAgent = { status: { defaultInstanceId: "awaited-inst" } };
+      mockDefaultAgent.agent = null;
+      mockDefaultAgent.isLoading = true;
+      mockDefaultAgent.error = null;
+      mockDefaultAgent.waitForResolution.mockResolvedValue(resolvedAgent);
+
+      const opts = defaultOptions();
+      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
+
+      await act(async () => {
+        await result.current.submit("Hello");
+      });
+
+      expect(mockDefaultAgent.waitForResolution).toHaveBeenCalledOnce();
+      expect(mockCreateSession).toHaveBeenCalledOnce();
+      expect(mockCreateSession.mock.calls[0][0].agentInstanceId).toBe("awaited-inst");
+      expect(opts.onSessionCreated).toHaveBeenCalledWith("sess-new");
+      expect(result.current.submitError).toBeNull();
+    });
+
+    it("surfaces error when fetch fails during await", async () => {
+      mockDefaultAgent.agent = null;
+      mockDefaultAgent.isLoading = true;
+      mockDefaultAgent.error = null;
+      mockDefaultAgent.waitForResolution.mockRejectedValue(
+        new Error("Network failure"),
+      );
+
+      const opts = defaultOptions();
+      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
+
+      await act(async () => {
+        await result.current.submit("Hello");
+      });
+
+      expect(result.current.submitError).toBeTruthy();
+      expect(opts.onError).toHaveBeenCalled();
+      expect(mockCreateSession).not.toHaveBeenCalled();
+    });
+
+    it("surfaces timeout error when fetch never resolves", async () => {
+      vi.useFakeTimers();
+
+      mockDefaultAgent.agent = null;
+      mockDefaultAgent.isLoading = true;
+      mockDefaultAgent.error = null;
+      mockDefaultAgent.waitForResolution.mockReturnValue(
+        new Promise(() => {}),
+      );
+
+      const opts = defaultOptions();
+      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
+
+      let submitPromise: Promise<void>;
+      act(() => {
+        submitPromise = result.current.submit("Hello") as unknown as Promise<void>;
+      });
+
+      await act(async () => {
+        vi.advanceTimersByTime(10_000);
+      });
+
+      await act(async () => {
+        await submitPromise;
+      });
+
+      expect(result.current.submitError).toContain("did not load in time");
+      expect(opts.onError).toHaveBeenCalled();
+      expect(mockCreateSession).not.toHaveBeenCalled();
+
+      vi.useRealTimers();
+    });
+
+    it("errors immediately when default agent has already failed", async () => {
+      mockDefaultAgent.agent = null;
+      mockDefaultAgent.isLoading = false;
+      mockDefaultAgent.error = new Error("Already failed");
+
+      const opts = defaultOptions();
+      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
+
+      await act(async () => {
+        await result.current.submit("Hello");
+      });
+
+      expect(result.current.submitError).toContain("Failed to load default agent");
+      expect(opts.onError).toHaveBeenCalled();
+      expect(mockCreateSession).not.toHaveBeenCalled();
+      expect(mockDefaultAgent.waitForResolution).not.toHaveBeenCalled();
+    });
+  });
 });

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

@@ -1,53 +1,25 @@
-import { describe, it, expect, vi } from "vitest";
-import { renderHook, act } from "@testing-library/react";
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { renderHook, waitFor, act } from "@testing-library/react";
 import type { ReactNode } from "react";
-import { create } from "@bufbuild/protobuf";
-import {
-  SessionSchema,
-  type Session,
-} from "@stigmer/protos/ai/stigmer/agentic/session/v1/api_pb";
-import { ApiResourceMetadataSchema } from "@stigmer/protos/ai/stigmer/commons/apiresource/metadata_pb";
-import type { Stigmer } from "@stigmer/sdk";
 import { StigmerContext } from "../../context";
 import { FetchCacheContext } from "../../internal/FetchCacheProvider";
-import { FetchCache } from "../../internal/fetch-cache";
 import { useSession } from "../useSession";
 
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function makeSession(id: string): Session {
-  const session = create(SessionSchema);
-  const metadata = create(ApiResourceMetadataSchema);
-  metadata.id = id;
-  session.metadata = metadata;
-  return session;
-}
-
-function createMockStigmer(sessionGet: ReturnType<typeof vi.fn>): Stigmer {
+function createMockStigmer(overrides: {
+  get?: (...args: unknown[]) => Promise<unknown>;
+} = {}) {
   return {
-    session: { get: sessionGet },
-  } as unknown as Stigmer;
-}
-
-async function flush(): Promise<void> {
-  await act(async () => {
-    await Promise.resolve();
-  });
+    session: {
+      get: overrides.get ?? vi.fn().mockResolvedValue(null),
+    },
+  } as never;
 }
 
-/**
- * Wrapper that provides both the Stigmer client and a shared FetchCache
- * instance via context. Sharing the cache instance across renderHook
- * calls mirrors the production layout where FetchCacheProvider sits
- * above the key-based remount boundary.
- */
-function createWrapper(client: Stigmer, cache: FetchCache) {
+function wrapper(client: unknown) {
   return function Wrapper({ children }: { children: ReactNode }) {
     return (
-      <FetchCacheContext.Provider value={cache}>
-        <StigmerContext.Provider value={client}>
+      <FetchCacheContext.Provider value={null}>
+        <StigmerContext.Provider value={client as never}>
           {children}
         </StigmerContext.Provider>
       </FetchCacheContext.Provider>
@@ -55,133 +27,102 @@ function createWrapper(client: Stigmer, cache: FetchCache) {
   };
 }
 
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
+describe("useSession", () => {
+  beforeEach(() => {
+    vi.restoreAllMocks();
+  });
 
-describe("useSession — cache behavior", () => {
-  it("first visit shows loading then resolves data", async () => {
-    const session = makeSession("ses_1");
-    const sessionGet = vi.fn().mockResolvedValue(session);
-    const cache = new FetchCache();
-    const wrapper = createWrapper(createMockStigmer(sessionGet), cache);
+  it("fetches session by ID", async () => {
+    const session = {
+      metadata: { id: "ses-1", name: "Test Session" },
+      status: { subject: "Hello world" },
+    };
+    const get = vi.fn().mockResolvedValue(session);
+    const client = createMockStigmer({ get });
 
-    const { result } = renderHook(() => useSession("ses_1"), { wrapper });
+    const { result } = renderHook(() => useSession("ses-1"), {
+      wrapper: wrapper(client),
+    });
 
     expect(result.current.isLoading).toBe(true);
     expect(result.current.session).toBeNull();
 
-    await flush();
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
 
-    expect(result.current.isLoading).toBe(false);
     expect(result.current.session).toBe(session);
-    expect(sessionGet).toHaveBeenCalledOnce();
+    expect(result.current.error).toBeNull();
+    expect(get).toHaveBeenCalledWith("ses-1");
   });
 
-  it("remount serves cached data instantly (no isLoading)", async () => {
-    const session1 = makeSession("ses_1");
-    const sessionGet = vi.fn().mockResolvedValue(session1);
-    const client = createMockStigmer(sessionGet);
-    const cache = new FetchCache();
-    const wrapper = createWrapper(client, cache);
-
-    // First mount — populates the cache.
-    const { result: r1, unmount } = renderHook(
-      () => useSession("ses_1"),
-      { wrapper },
-    );
-    await flush();
-    expect(r1.current.session).toBe(session1);
-    unmount();
-
-    // Second mount (simulates remount after key={activeSessionId} change).
-    const freshSession = makeSession("ses_1");
-    sessionGet.mockResolvedValue(freshSession);
-
-    const { result: r2 } = renderHook(
-      () => useSession("ses_1"),
-      { wrapper },
-    );
+  it("skips fetching when id is null", () => {
+    const get = vi.fn();
+    const client = createMockStigmer({ get });
 
-    // Cached data is served synchronously — no loading skeleton.
-    expect(r2.current.isLoading).toBe(false);
-    expect(r2.current.session).toBe(session1);
-    expect(r2.current.isRefetching).toBe(true);
+    const { result } = renderHook(() => useSession(null), {
+      wrapper: wrapper(client),
+    });
 
-    // Background fetch completes with fresh data.
-    await flush();
-    expect(r2.current.session).toBe(freshSession);
-    expect(r2.current.isRefetching).toBe(false);
+    expect(result.current.isLoading).toBe(false);
+    expect(result.current.session).toBeNull();
+    expect(get).not.toHaveBeenCalled();
   });
 
-  it("different session IDs have independent cache entries", async () => {
-    const sessionA = makeSession("ses_A");
-    const sessionB = makeSession("ses_B");
-    const sessionGet = vi.fn()
-      .mockResolvedValueOnce(sessionA)
-      .mockResolvedValueOnce(sessionB)
-      .mockResolvedValue(sessionA);
-    const cache = new FetchCache();
-    const wrapper = createWrapper(createMockStigmer(sessionGet), cache);
-
-    // Mount session A.
-    const { unmount: unmountA } = renderHook(
-      () => useSession("ses_A"),
-      { wrapper },
-    );
-    await flush();
-    unmountA();
+  it("exposes error on fetch failure", async () => {
+    const apiError = new Error("Connection refused");
+    const get = vi.fn().mockRejectedValue(apiError);
+    const client = createMockStigmer({ get });
 
-    // Mount session B.
-    const { unmount: unmountB } = renderHook(
-      () => useSession("ses_B"),
-      { wrapper },
-    );
-    await flush();
-    unmountB();
+    const { result } = renderHook(() => useSession("ses-bad"), {
+      wrapper: wrapper(client),
+    });
 
-    // Remount session A — should get A's cached data, not B's.
-    const { result } = renderHook(
-      () => useSession("ses_A"),
-      { wrapper },
-    );
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
 
-    expect(result.current.isLoading).toBe(false);
-    expect(result.current.session?.metadata?.id).toBe("ses_A");
+    expect(result.current.error).toBeTruthy();
+    expect(result.current.error!.message).toBe("Connection refused");
+    expect(result.current.session).toBeNull();
   });
 
-  it("works without FetchCacheProvider (standard loading flow)", async () => {
-    const session = makeSession("ses_1");
-    const sessionGet = vi.fn().mockResolvedValue(session);
-    const client = createMockStigmer(sessionGet);
-
-    function NoCacheWrapper({ children }: { children: ReactNode }) {
-      return (
-        <StigmerContext.Provider value={client}>
-          {children}
-        </StigmerContext.Provider>
-      );
-    }
+  it("refetch triggers a new fetch", async () => {
+    const session = { metadata: { id: "ses-1" } };
+    const get = vi.fn().mockResolvedValue(session);
+    const client = createMockStigmer({ get });
 
-    const { result } = renderHook(() => useSession("ses_1"), {
-      wrapper: NoCacheWrapper,
+    const { result } = renderHook(() => useSession("ses-1"), {
+      wrapper: wrapper(client),
     });
 
-    expect(result.current.isLoading).toBe(true);
-    await flush();
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(get).toHaveBeenCalledTimes(1);
+
+    act(() => result.current.refetch());
+
+    await waitFor(() => expect(get).toHaveBeenCalledTimes(2));
     expect(result.current.session).toBe(session);
   });
 
-  it("null id skips fetching and caching", async () => {
-    const sessionGet = vi.fn();
-    const cache = new FetchCache();
-    const wrapper = createWrapper(createMockStigmer(sessionGet), cache);
+  it("re-fetches when id changes", async () => {
+    const session1 = { metadata: { id: "ses-1" } };
+    const session2 = { metadata: { id: "ses-2" } };
+    const get = vi.fn()
+      .mockResolvedValueOnce(session1)
+      .mockResolvedValueOnce(session2);
+    const client = createMockStigmer({ get });
+
+    const { result, rerender } = renderHook(
+      ({ id }: { id: string }) => useSession(id),
+      {
+        wrapper: wrapper(client),
+        initialProps: { id: "ses-1" },
+      },
+    );
 
-    const { result } = renderHook(() => useSession(null), { wrapper });
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.session).toBe(session1);
 
-    expect(result.current.isLoading).toBe(false);
-    expect(result.current.session).toBeNull();
-    expect(sessionGet).not.toHaveBeenCalled();
-    expect(cache.size).toBe(0);
+    rerender({ id: "ses-2" });
+
+    await waitFor(() => expect(get).toHaveBeenCalledTimes(2));
+    expect(get).toHaveBeenLastCalledWith("ses-2");
   });
 });

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

@@ -0,0 +1,86 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { renderHook, waitFor } from "@testing-library/react";
+import type { ReactNode } from "react";
+import { StigmerContext } from "../../context";
+import { FetchCacheContext } from "../../internal/FetchCacheProvider";
+import { useSessionList } from "../useSessionList";
+
+function createMockStigmer(overrides: {
+  list?: (...args: unknown[]) => Promise<unknown>;
+} = {}) {
+  return {
+    session: {
+      list: overrides.list ?? vi.fn().mockResolvedValue({ entries: [], totalPages: 0 }),
+    },
+  } as never;
+}
+
+function wrapper(client: unknown) {
+  return function Wrapper({ children }: { children: ReactNode }) {
+    return (
+      <FetchCacheContext.Provider value={null}>
+        <StigmerContext.Provider value={client as never}>
+          {children}
+        </StigmerContext.Provider>
+      </FetchCacheContext.Provider>
+    );
+  };
+}
+
+describe("useSessionList", () => {
+  beforeEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("fetches session list with default page size", async () => {
+    const sessions = [
+      { metadata: { id: "ses-1", name: "Session 1" } },
+      { metadata: { id: "ses-2", name: "Session 2" } },
+    ];
+    const list = vi.fn().mockResolvedValue({ entries: sessions, totalPages: 1 });
+    const client = createMockStigmer({ list });
+
+    const { result } = renderHook(() => useSessionList(), {
+      wrapper: wrapper(client),
+    });
+
+    expect(result.current.isLoading).toBe(true);
+    expect(result.current.sessions).toEqual([]);
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+    expect(result.current.sessions).toHaveLength(2);
+    expect(result.current.error).toBeNull();
+    expect(list).toHaveBeenCalledTimes(1);
+  });
+
+  it("passes custom page size to the API", async () => {
+    const list = vi.fn().mockResolvedValue({ entries: [], totalPages: 0 });
+    const client = createMockStigmer({ list });
+
+    renderHook(() => useSessionList({ pageSize: 10 }), {
+      wrapper: wrapper(client),
+    });
+
+    await waitFor(() => expect(list).toHaveBeenCalled());
+
+    const callArg = list.mock.calls[0][0];
+    expect(callArg.pageSize).toBe(10);
+  });
+
+  it("exposes error on fetch failure", async () => {
+    const apiError = new Error("Network failure");
+    const list = vi.fn().mockRejectedValue(apiError);
+    const client = createMockStigmer({ list });
+
+    const { result } = renderHook(() => useSessionList(), {
+      wrapper: wrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+    expect(result.current.error).toBeTruthy();
+    expect(result.current.error!.message).toBe("Network failure");
+    expect(result.current.sessions).toEqual([]);
+  });
+});