@stigmer/react 1.0.2 → 1.0.4

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([]);
+  });
+});

package/src/session/useNewSessionFlow.ts

@@ -11,9 +11,12 @@ import { useWorkspaceEntries, type UseWorkspaceEntriesReturn } from "../workspac
 import { useSessionVariables, type UseSessionVariablesReturn } from "../execution/useSessionVariables";
 import type { SessionComposerSubmitContext } from "../composer";
 import { useRunnerList } from "../runner/useRunnerList";
+import { withTimeout } from "../internal/withTimeout";
 import { useCreateSession } from "./useCreateSession";
 import { useCreateAgentExecution } from "../execution/useCreateAgentExecution";
 
+const DEFAULT_AGENT_TIMEOUT_MS = 10_000;
+
 const STORAGE_KEY_HARNESS = "stigmer:session:harness";
 const STORAGE_KEY_RUNNER = "stigmer:session:runner";
 
@@ -164,6 +167,7 @@ export function useNewSessionFlow(
     agent: defaultAgent,
     isLoading: isDefaultAgentLoading,
     error: defaultAgentError,
+    waitForResolution: waitForDefaultAgent,
   } = useDefaultAgent(org);
   const workspace = useWorkspaceEntries();
   const sessionVariables = useSessionVariables();
@@ -293,25 +297,29 @@ export function useNewSessionFlow(
             }));
           }
         } else {
-          const defaultInstanceId = defaultAgent?.status?.defaultInstanceId;
-          if (!defaultInstanceId) {
+          let resolvedInstanceId = defaultAgent?.status?.defaultInstanceId;
+          if (!resolvedInstanceId) {
             if (isDefaultAgentLoading) {
+              const resolved = await withTimeout(
+                waitForDefaultAgent(),
+                DEFAULT_AGENT_TIMEOUT_MS,
+                "Default agent did not load in time. Please try again.",
+              );
+              resolvedInstanceId = resolved?.status?.defaultInstanceId;
+            } else if (defaultAgentError) {
               throw new Error(
-                "Loading default agent. Please try again in a moment.",
+                "Failed to load default agent. Please try again.",
               );
             }
-            if (defaultAgentError) {
+            if (!resolvedInstanceId) {
               throw new Error(
-                "Failed to load default agent. Please try again.",
+                "No default agent available. Select an agent to start a session.",
               );
             }
-            throw new Error(
-              "No default agent available. Select an agent to start a session.",
-            );
           }
           ({ sessionId } = await createSession({
             ...sessionFields,
-            agentInstanceId: defaultInstanceId,
+            agentInstanceId: resolvedInstanceId,
           }));
         }
 
@@ -340,6 +348,7 @@ export function useNewSessionFlow(
       defaultAgent,
       isDefaultAgentLoading,
       defaultAgentError,
+      waitForDefaultAgent,
       createSession,
       createExecution,
       sessionVariables,