@stigmer/react 0.5.0 → 0.5.1

package/src/models/__tests__/useModelRegistry.test.tsx

@@ -90,8 +90,10 @@ const TEST_REGISTRY_JSON = {
 
 const TEST_MODELS: readonly ModelInfo[] = parseRegistryJson(TEST_REGISTRY_JSON);
 
+const noopRefetch = () => {};
+
 function createWrapper(models: readonly ModelInfo[] = TEST_MODELS) {
-  const state: ModelRegistryState = { models, isLoading: false, error: null };
+  const state: ModelRegistryState = { models, isLoading: false, error: null, refetch: noopRefetch };
   return function Wrapper({ children }: { children: ReactNode }) {
     return (
       <ModelRegistryContext.Provider value={state}>
@@ -285,7 +287,7 @@ describe("useModelRegistry", () => {
 
   describe("loading state", () => {
     it("exposes isLoading from context", () => {
-      const loadingState: ModelRegistryState = { models: [], isLoading: true, error: null };
+      const loadingState: ModelRegistryState = { models: [], isLoading: true, error: null, refetch: noopRefetch };
       const wrapper = ({ children }: { children: ReactNode }) => (
         <ModelRegistryContext.Provider value={loadingState}>
           {children}
@@ -298,7 +300,7 @@ describe("useModelRegistry", () => {
 
     it("exposes error from context", () => {
       const err = new Error("fetch failed");
-      const errorState: ModelRegistryState = { models: [], isLoading: false, error: err };
+      const errorState: ModelRegistryState = { models: [], isLoading: false, error: err, refetch: noopRefetch };
       const wrapper = ({ children }: { children: ReactNode }) => (
         <ModelRegistryContext.Provider value={errorState}>
           {children}

package/src/models/useModelRegistry.ts

@@ -55,6 +55,8 @@ export interface UseModelRegistryReturn {
   readonly isLoading: boolean;
   /** Non-null if the API fetch failed. Models will be empty in this case. */
   readonly error: Error | null;
+  /** Retry fetching the model registry. No-op while a fetch is in flight. */
+  readonly refetch: () => void;
 }
 
 /**
@@ -85,7 +87,7 @@ export interface UseModelRegistryReturn {
  */
 export function useModelRegistry(options?: UseModelRegistryOptions): UseModelRegistryReturn {
   const harness = options?.harness;
-  const { models: allModels, isLoading, error } = useModelRegistryContext();
+  const { models: allModels, isLoading, error, refetch } = useModelRegistryContext();
 
   return useMemo(() => {
     const isUnified = harness === undefined;
@@ -143,6 +145,7 @@ export function useModelRegistry(options?: UseModelRegistryOptions): UseModelReg
       getByKey: (key: string) => byCompoundKey.get(key),
       isLoading,
       error,
+      refetch,
     };
-  }, [harness, allModels, isLoading, error]);
+  }, [harness, allModels, isLoading, error, refetch]);
 }

package/src/provider.tsx

@@ -1,6 +1,6 @@
 "use client";
 
-import { useEffect, useRef, useState, type ReactNode } from "react";
+import { useCallback, useEffect, useRef, useState, type ReactNode } from "react";
 import type { Stigmer, DeploymentMode } from "@stigmer/sdk";
 import { cn, resolvePresetClass } from "@stigmer/theme";
 import type { ThemePresetId } from "@stigmer/theme";
@@ -151,15 +151,23 @@ export function StigmerProvider({
   );
 }
 
+const RETRY_DELAYS_MS = [1_000, 2_000, 4_000];
+const TOKEN_POLL_INTERVAL_MS = 500;
+const TOKEN_POLL_MAX_MS = 10_000;
+
 /**
- * Fetches the model registry from the authenticated API on mount and
- * caches the result for the lifetime of the provider.
+ * Fetches the model registry from the authenticated API and caches
+ * the result for the lifetime of the provider.
  *
- * Uses the client's `baseUrl` and `getAuthCredential()` so the fetch
- * is authenticated with the same token the SDK uses for all other calls.
+ * Handles the auth race condition where `StigmerProvider` mounts before
+ * PKCE authentication is established (e.g. desktop release builds with
+ * a fresh localStorage). When the initial token is `null`, polls for
+ * a valid token before giving up. Retries on transient failures with
+ * exponential backoff. Exposes `refetch` for manual retry from the UI.
  */
 function useModelRegistryFetch(client: Stigmer): ModelRegistryState {
-  const [state, setState] = useState<ModelRegistryState>({
+  const [version, setVersion] = useState(0);
+  const [state, setState] = useState<Omit<ModelRegistryState, "refetch">>({
     models: [],
     isLoading: true,
     error: null,
@@ -168,31 +176,74 @@ function useModelRegistryFetch(client: Stigmer): ModelRegistryState {
   const clientRef = useRef(client);
   clientRef.current = client;
 
-  useEffect(() => {
-    let cancelled = false;
+  const fetchAttemptRef = useRef(0);
 
+  const doFetch = useCallback(async (signal: AbortSignal) => {
     const c = clientRef.current;
-    c.getAuthCredential()
-      .then((token) => fetchModelRegistry(c.baseUrl, token, c.fetch))
-      .then((models) => {
-        if (!cancelled) {
+    let token = await c.getAuthCredential();
+
+    if (!token) {
+      const start = Date.now();
+      while (!token && Date.now() - start < TOKEN_POLL_MAX_MS) {
+        if (signal.aborted) return;
+        await new Promise((r) => setTimeout(r, TOKEN_POLL_INTERVAL_MS));
+        if (signal.aborted) return;
+        token = await c.getAuthCredential();
+      }
+    }
+
+    return fetchModelRegistry(c.baseUrl, token, c.fetch);
+  }, []);
+
+  useEffect(() => {
+    const controller = new AbortController();
+    const { signal } = controller;
+
+    fetchAttemptRef.current = 0;
+
+    const attempt = async () => {
+      if (signal.aborted) return;
+
+      setState((prev) => (prev.isLoading ? prev : { ...prev, isLoading: true }));
+
+      try {
+        const models = await doFetch(signal);
+        if (!signal.aborted && models) {
           setState({ models, isLoading: false, error: null });
+          fetchAttemptRef.current = 0;
         }
-      })
-      .catch((err: unknown) => {
-        if (!cancelled) {
+      } catch (err: unknown) {
+        if (signal.aborted) return;
+
+        const retryIdx = fetchAttemptRef.current;
+        fetchAttemptRef.current = retryIdx + 1;
+
+        if (retryIdx < RETRY_DELAYS_MS.length) {
+          setTimeout(() => { if (!signal.aborted) attempt(); }, RETRY_DELAYS_MS[retryIdx]);
+        } else {
           setState({
             models: [],
             isLoading: false,
             error: err instanceof Error ? err : new Error(String(err)),
           });
         }
-      });
+      }
+    };
+
+    attempt();
+
+    return () => { controller.abort(); };
+  }, [doFetch, version]);
 
-    return () => { cancelled = true; };
+  const refetch = useCallback(() => {
+    setState((prev) => {
+      if (prev.isLoading) return prev;
+      return { ...prev, isLoading: true, error: null };
+    });
+    setVersion((v) => v + 1);
   }, []);
 
-  return state;
+  return { ...state, refetch };
 }
 
 /**

package/src/session/__tests__/session-spec-converters.test.ts

@@ -0,0 +1,185 @@
+import { describe, it, expect } from "vitest";
+import {
+  specWorkspaceToInput,
+  specMcpUsagesToInput,
+  specSkillRefsToInput,
+} from "../session-spec-converters";
+import type { Session } from "@stigmer/protos/ai/stigmer/agentic/session/v1/api_pb";
+import { ApiResourceKind } from "@stigmer/protos/ai/stigmer/commons/apiresource/apiresourcekind/api_resource_kind_pb";
+
+type SessionSpec = Session["spec"];
+
+function makeSpec(overrides: Partial<NonNullable<SessionSpec>> = {}): SessionSpec {
+  return {
+    agentInstanceId: "",
+    subject: "",
+    threadId: "",
+    sandboxId: "",
+    metadata: {},
+    workspaceEntries: [],
+    mcpServerUsages: [],
+    skillRefs: [],
+    runnerId: "",
+    harness: 0,
+    cursorMode: 0,
+    ...overrides,
+  } as unknown as SessionSpec;
+}
+
+describe("specWorkspaceToInput", () => {
+  it("returns undefined for undefined spec", () => {
+    expect(specWorkspaceToInput(undefined)).toBeUndefined();
+  });
+
+  it("returns empty array for spec with no workspace entries", () => {
+    expect(specWorkspaceToInput(makeSpec())).toEqual([]);
+  });
+
+  it("converts git repo entries", () => {
+    const spec = makeSpec({
+      workspaceEntries: [
+        {
+          name: "my-repo",
+          source: {
+            source: {
+              case: "gitRepo" as const,
+              value: { url: "https://github.com/org/repo", branch: "main", commit: "", depth: 0 },
+            },
+          },
+        },
+      ] as unknown as SessionSpec extends undefined ? never : NonNullable<SessionSpec>["workspaceEntries"],
+    });
+
+    const result = specWorkspaceToInput(spec);
+    expect(result).toEqual([
+      {
+        name: "my-repo",
+        source: {
+          gitRepo: {
+            url: "https://github.com/org/repo",
+            branch: "main",
+            commit: undefined,
+            depth: undefined,
+          },
+        },
+      },
+    ]);
+  });
+
+  it("converts local path entries", () => {
+    const spec = makeSpec({
+      workspaceEntries: [
+        {
+          name: "local",
+          source: {
+            source: {
+              case: "localPath" as const,
+              value: { path: "/home/user/project" },
+            },
+          },
+        },
+      ] as unknown as SessionSpec extends undefined ? never : NonNullable<SessionSpec>["workspaceEntries"],
+    });
+
+    const result = specWorkspaceToInput(spec);
+    expect(result).toEqual([
+      {
+        name: "local",
+        source: {
+          localPath: { path: "/home/user/project" },
+        },
+      },
+    ]);
+  });
+});
+
+describe("specMcpUsagesToInput", () => {
+  it("returns undefined for undefined spec", () => {
+    expect(specMcpUsagesToInput(undefined)).toBeUndefined();
+  });
+
+  it("returns empty array for spec with no MCP server usages", () => {
+    expect(specMcpUsagesToInput(makeSpec())).toEqual([]);
+  });
+
+  it("converts MCP server usages with ref and enabled tools", () => {
+    const spec = makeSpec({
+      mcpServerUsages: [
+        {
+          mcpServerRef: {
+            org: "acme",
+            slug: "github-tools",
+            version: "v1",
+            kind: ApiResourceKind.mcp_server,
+          },
+          enabledTools: ["create_issue", "list_prs"],
+          toolApprovalOverrides: [],
+        },
+      ] as unknown as NonNullable<SessionSpec>["mcpServerUsages"],
+    });
+
+    const result = specMcpUsagesToInput(spec);
+    expect(result).toEqual([
+      {
+        mcpServerRef: {
+          org: "acme",
+          slug: "github-tools",
+          version: "v1",
+          kind: ApiResourceKind.mcp_server,
+        },
+        enabledTools: ["create_issue", "list_prs"],
+        toolApprovalOverrides: undefined,
+      },
+    ]);
+  });
+
+  it("converts MCP server usages with tool approval overrides", () => {
+    const spec = makeSpec({
+      mcpServerUsages: [
+        {
+          mcpServerRef: {
+            org: "acme",
+            slug: "shell",
+            version: "",
+            kind: ApiResourceKind.mcp_server,
+          },
+          enabledTools: [],
+          toolApprovalOverrides: [
+            { toolName: "exec", requiresApproval: true, message: "Dangerous" },
+          ],
+        },
+      ] as unknown as NonNullable<SessionSpec>["mcpServerUsages"],
+    });
+
+    const result = specMcpUsagesToInput(spec);
+    expect(result).toHaveLength(1);
+    expect(result![0].toolApprovalOverrides).toEqual([
+      { toolName: "exec", requiresApproval: true, message: "Dangerous" },
+    ]);
+  });
+});
+
+describe("specSkillRefsToInput", () => {
+  it("returns undefined for undefined spec", () => {
+    expect(specSkillRefsToInput(undefined)).toBeUndefined();
+  });
+
+  it("returns empty array for spec with no skill refs", () => {
+    expect(specSkillRefsToInput(makeSpec())).toEqual([]);
+  });
+
+  it("converts skill references", () => {
+    const spec = makeSpec({
+      skillRefs: [
+        { org: "acme", slug: "code-review", version: "v2", kind: ApiResourceKind.skill },
+        { org: "acme", slug: "testing", version: "", kind: ApiResourceKind.skill },
+      ] as unknown as NonNullable<SessionSpec>["skillRefs"],
+    });
+
+    const result = specSkillRefsToInput(spec);
+    expect(result).toEqual([
+      { org: "acme", slug: "code-review", version: "v2", kind: ApiResourceKind.skill },
+      { org: "acme", slug: "testing", version: undefined, kind: ApiResourceKind.skill },
+    ]);
+  });
+});

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

@@ -82,7 +82,7 @@ const TEST_MODELS = parseRegistryJson({
 });
 
 function createWrapper() {
-  const state: ModelRegistryState = { models: TEST_MODELS, isLoading: false, error: null };
+  const state: ModelRegistryState = { models: TEST_MODELS, isLoading: false, error: null, refetch: () => {} };
   return function Wrapper({ children }: { children: ReactNode }) {
     return (
       <ModelRegistryContext.Provider value={state}>
@@ -284,7 +284,7 @@ describe("useNewSessionFlow", () => {
   describe("model validation timing", () => {
     it("does not restore model while registry is loading", () => {
       localStorage.setItem(STORAGE_KEY_MODEL_NATIVE, DEFAULT_MODEL_ID);
-      const loadingState: ModelRegistryState = { models: [], isLoading: true, error: null };
+      const loadingState: ModelRegistryState = { models: [], isLoading: true, error: null, refetch: () => {} };
 
       function LoadingWrapper({ children }: { children: ReactNode }) {
         return (

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

@@ -14,7 +14,7 @@ const TEST_MODELS = parseRegistryJson({
 });
 
 function createWrapper() {
-  const state: ModelRegistryState = { models: TEST_MODELS, isLoading: false, error: null };
+  const state: ModelRegistryState = { models: TEST_MODELS, isLoading: false, error: null, refetch: () => {} };
   return function Wrapper({ children }: { children: ReactNode }) {
     return (
       <ModelRegistryContext.Provider value={state}>

package/src/session/group-sessions.ts

@@ -1,4 +1,5 @@
 import type { Session } from "@stigmer/protos/ai/stigmer/agentic/session/v1/api_pb";
+import type { SearchResult } from "@stigmer/protos/ai/stigmer/search/v1/io_pb";
 import { timestampDate } from "@bufbuild/protobuf/wkt";
 
 /** A time-based group of sessions produced by {@link groupSessionsByTime}. */
@@ -9,11 +10,24 @@ export interface SessionGroup {
   readonly sessions: readonly Session[];
 }
 
+/** A time-based group of search results produced by {@link groupSearchResultsByTime}. */
+export interface SearchResultGroup {
+  /** Display label for this group (e.g. "Today", "Yesterday"). */
+  readonly label: string;
+  /** Search results belonging to this group, in their original input order. */
+  readonly entries: readonly SearchResult[];
+}
+
 interface Bucket {
   label: string;
   sessions: Session[];
 }
 
+interface SearchResultBucket {
+  label: string;
+  entries: SearchResult[];
+}
+
 /**
  * Groups sessions by their creation timestamp into time-based buckets:
  * "Today", "Yesterday", "Previous 7 Days", "Previous 30 Days", "Older".
@@ -91,6 +105,57 @@ export function groupSessionsByTime(
   return buckets.filter((b) => b.sessions.length > 0);
 }
 
+/**
+ * Groups SearchResult entries by their `createdAt` timestamp into time-based
+ * buckets, identical to {@link groupSessionsByTime} but for lightweight
+ * search results.
+ *
+ * @param entries - SearchResult entries (from SearchService session search).
+ * @param now - Reference time for grouping; defaults to current time.
+ */
+export function groupSearchResultsByTime(
+  entries: readonly SearchResult[],
+  now?: Date,
+): readonly SearchResultGroup[] {
+  const ref = now ?? new Date();
+  const todayStart = startOfDay(ref);
+  const yesterdayStart = addDays(todayStart, -1);
+  const sevenDaysAgo = addDays(todayStart, -6);
+  const thirtyDaysAgo = addDays(todayStart, -29);
+
+  const buckets: SearchResultBucket[] = [
+    { label: "Today", entries: [] },
+    { label: "Yesterday", entries: [] },
+    { label: "Previous 7 Days", entries: [] },
+    { label: "Previous 30 Days", entries: [] },
+    { label: "Older", entries: [] },
+  ];
+
+  for (const entry of entries) {
+    const ts = entry.createdAt;
+    const date = ts ? timestampDate(ts) : null;
+
+    if (!date) {
+      buckets[buckets.length - 1].entries.push(entry);
+      continue;
+    }
+
+    if (date >= todayStart) {
+      buckets[0].entries.push(entry);
+    } else if (date >= yesterdayStart) {
+      buckets[1].entries.push(entry);
+    } else if (date >= sevenDaysAgo) {
+      buckets[2].entries.push(entry);
+    } else if (date >= thirtyDaysAgo) {
+      buckets[3].entries.push(entry);
+    } else {
+      buckets[4].entries.push(entry);
+    }
+  }
+
+  return buckets.filter((b) => b.entries.length > 0);
+}
+
 function startOfDay(date: Date): Date {
   const d = new Date(date);
   d.setHours(0, 0, 0, 0);

package/src/session/index.ts

@@ -76,8 +76,14 @@ export type {
   DraftParams,
 } from "./draft";
 
-export { groupSessionsByTime } from "./group-sessions";
-export type { SessionGroup } from "./group-sessions";
+export { groupSessionsByTime, groupSearchResultsByTime } from "./group-sessions";
+export type { SessionGroup, SearchResultGroup } from "./group-sessions";
+
+export { useSessionSearch } from "./useSessionSearch";
+export type {
+  UseSessionSearchOptions,
+  UseSessionSearchReturn,
+} from "./useSessionSearch";
 
 // Session utilities (re-exported from @stigmer/sdk)
 export { PENDING_SUBJECT, resolvedSubject } from "@stigmer/sdk";

package/src/session/session-spec-converters.ts

@@ -0,0 +1,86 @@
+import type { Session } from "@stigmer/protos/ai/stigmer/agentic/session/v1/api_pb";
+import type {
+  McpServerUsageInput,
+  ResourceRef,
+  WorkspaceEntryInput,
+} from "@stigmer/sdk";
+
+/**
+ * Convert proto workspace entries back to SDK input format.
+ *
+ * Used by `useSessionConversation` (session update with replace semantics)
+ * and `useSessionPageFlow` (hydrating composer state from a loaded session).
+ */
+export function specWorkspaceToInput(
+  spec: Session["spec"],
+): WorkspaceEntryInput[] | undefined {
+  return spec?.workspaceEntries?.map((e): WorkspaceEntryInput => {
+    if (e.source?.source.case === "gitRepo") {
+      const v = e.source.source.value;
+      return {
+        name: e.name || undefined,
+        source: {
+          gitRepo: {
+            url: v.url,
+            branch: v.branch || undefined,
+            commit: v.commit || undefined,
+            depth: v.depth || undefined,
+          },
+        },
+      };
+    }
+    if (e.source?.source.case === "localPath") {
+      return {
+        name: e.name || undefined,
+        source: {
+          localPath: { path: e.source.source.value.path || undefined },
+        },
+      };
+    }
+    return { name: e.name || undefined, source: {} };
+  });
+}
+
+/**
+ * Convert proto MCP server usages back to SDK input format.
+ *
+ * Used by `useSessionConversation` (session update with replace semantics)
+ * and `useSessionPageFlow` (hydrating composer state from a loaded session).
+ */
+export function specMcpUsagesToInput(
+  spec: Session["spec"],
+): McpServerUsageInput[] | undefined {
+  return spec?.mcpServerUsages?.map((u) => ({
+    mcpServerRef: {
+      org: u.mcpServerRef?.org ?? "",
+      slug: u.mcpServerRef?.slug ?? "",
+      version: u.mcpServerRef?.version || undefined,
+      kind: u.mcpServerRef?.kind,
+    },
+    enabledTools: u.enabledTools?.length ? [...u.enabledTools] : undefined,
+    toolApprovalOverrides: u.toolApprovalOverrides?.length
+      ? u.toolApprovalOverrides.map((o) => ({
+          toolName: o.toolName || undefined,
+          requiresApproval: o.requiresApproval || undefined,
+          message: o.message || undefined,
+        }))
+      : undefined,
+  }));
+}
+
+/**
+ * Convert proto skill references back to SDK input format.
+ *
+ * Used by `useSessionConversation` (session update with replace semantics)
+ * and `useSessionPageFlow` (hydrating composer state from a loaded session).
+ */
+export function specSkillRefsToInput(
+  spec: Session["spec"],
+): ResourceRef[] | undefined {
+  return spec?.skillRefs?.map((r) => ({
+    org: r.org ?? "",
+    slug: r.slug ?? "",
+    version: r.version || undefined,
+    kind: r.kind,
+  }));
+}

package/src/session/useSessionConversation.ts

@@ -24,6 +24,11 @@ import { useSubmitApproval } from "../execution/useSubmitApproval";
 import { useSession } from "./useSession";
 import { useSessionExecutions } from "./useSessionExecutions";
 import { useUpdateSession } from "./useUpdateSession";
+import {
+  specWorkspaceToInput,
+  specMcpUsagesToInput,
+  specSkillRefsToInput,
+} from "./session-spec-converters";
 
 /**
  * Options for {@link UseSessionConversationReturn.sendFollowUp}.
@@ -479,67 +484,3 @@ function buildUpdateInput(
   };
 }
 
-/** Convert proto workspace entries back to SDK input format. */
-function specWorkspaceToInput(
-  spec: Session["spec"],
-): WorkspaceEntryInput[] | undefined {
-  return spec?.workspaceEntries?.map((e): WorkspaceEntryInput => {
-    if (e.source?.source.case === "gitRepo") {
-      const v = e.source.source.value;
-      return {
-        name: e.name || undefined,
-        source: {
-          gitRepo: {
-            url: v.url,
-            branch: v.branch || undefined,
-            commit: v.commit || undefined,
-            depth: v.depth || undefined,
-          },
-        },
-      };
-    }
-    if (e.source?.source.case === "localPath") {
-      return {
-        name: e.name || undefined,
-        source: {
-          localPath: { path: e.source.source.value.path || undefined },
-        },
-      };
-    }
-    return { name: e.name || undefined, source: {} };
-  });
-}
-
-/** Convert proto MCP server usages back to SDK input format. */
-function specMcpUsagesToInput(
-  spec: Session["spec"],
-): McpServerUsageInput[] | undefined {
-  return spec?.mcpServerUsages?.map((u) => ({
-    mcpServerRef: {
-      org: u.mcpServerRef?.org ?? "",
-      slug: u.mcpServerRef?.slug ?? "",
-      version: u.mcpServerRef?.version || undefined,
-      kind: u.mcpServerRef?.kind,
-    },
-    enabledTools: u.enabledTools?.length ? [...u.enabledTools] : undefined,
-    toolApprovalOverrides: u.toolApprovalOverrides?.length
-      ? u.toolApprovalOverrides.map((o) => ({
-          toolName: o.toolName || undefined,
-          requiresApproval: o.requiresApproval || undefined,
-          message: o.message || undefined,
-        }))
-      : undefined,
-  }));
-}
-
-/** Convert proto skill references back to SDK input format. */
-function specSkillRefsToInput(
-  spec: Session["spec"],
-): ResourceRef[] | undefined {
-  return spec?.skillRefs?.map((r) => ({
-    org: r.org ?? "",
-    slug: r.slug ?? "",
-    version: r.version || undefined,
-    kind: r.kind,
-  }));
-}