@stigmer/react 0.4.6 → 0.4.8

package/src/models/ModelSelector.tsx

@@ -32,6 +32,14 @@ export interface ModelSelectorProps {
    * to that harness (dropdown hidden). When omitted, shows the harness dropdown.
    */
   readonly harness?: HarnessOption;
+  /**
+   * Initial harness value for the internal state when `harness` prop is
+   * undefined (unlocked mode). Prevents desync when the parent knows the
+   * active harness but delegates the dropdown to this component.
+   *
+   * When `harness` is provided (locked mode), this prop is ignored.
+   */
+  readonly initialHarness?: HarnessOption;
   /** Called when user changes harness in the dropdown. */
   readonly onHarnessChange?: (harness: HarnessOption) => void;
   /**
@@ -85,6 +93,7 @@ export function ModelSelector({
   value,
   onValueChange,
   harness,
+  initialHarness,
   onHarnessChange,
   onHarnessResolved,
   availableHarnesses,
@@ -99,9 +108,17 @@ export function ModelSelector({
   const portalContainer = useStigmerPortalContainer();
 
   const isHarnessLocked = harness !== undefined;
-  const [internalHarness, setInternalHarness] = useState<HarnessOption>(harness ?? "native");
+  const [internalHarness, setInternalHarness] = useState<HarnessOption>(
+    harness ?? initialHarness ?? "native",
+  );
   const activeHarness = harness ?? internalHarness;
 
+  useEffect(() => {
+    if (!isHarnessLocked && initialHarness !== undefined) {
+      setInternalHarness(initialHarness);
+    }
+  }, [initialHarness, isHarnessLocked]);
+
   const { models, featured, defaultModel, getModel, byProvider } = useModelRegistry(
     { harness: activeHarness },
   );

package/src/models/registry.ts

@@ -200,14 +200,22 @@ export function parseRegistryJson(data: unknown): ModelInfo[] {
  *
  * @param apiUrl - Base URL of the Stigmer Cloud API (e.g. `https://api.stigmer.ai`)
  * @param token - Bearer token for authentication (from `client.getAuthCredential()`)
+ * @param customFetch - Optional custom `fetch` implementation. Required in
+ *   Tauri where the global `fetch` is restricted by webview CSP/CORS policies.
+ *   When omitted, the global `fetch` is used.
  * @returns Parsed `ModelInfo[]`.
  */
-export async function fetchModelRegistry(apiUrl: string, token: string | null): Promise<ModelInfo[]> {
+export async function fetchModelRegistry(
+  apiUrl: string,
+  token: string | null,
+  customFetch?: typeof globalThis.fetch,
+): Promise<ModelInfo[]> {
+  const doFetch = customFetch ?? globalThis.fetch;
   const headers: Record<string, string> = {};
   if (token) {
     headers["Authorization"] = `Bearer ${token}`;
   }
-  const res = await fetch(`${apiUrl}/v1/proxy/model-registry`, { headers });
+  const res = await doFetch(`${apiUrl}/v1/proxy/model-registry`, { headers });
   if (!res.ok) throw new Error(`Model registry fetch failed: ${res.status}`);
   const data: unknown = await res.json();
   return parseRegistryJson(data);

package/src/provider.tsx

@@ -173,7 +173,7 @@ function useModelRegistryFetch(client: Stigmer): ModelRegistryState {
 
     const c = clientRef.current;
     c.getAuthCredential()
-      .then((token) => fetchModelRegistry(c.baseUrl, token))
+      .then((token) => fetchModelRegistry(c.baseUrl, token, c.fetch))
       .then((models) => {
         if (!cancelled) {
           setState({ models, isLoading: false, error: null });

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

@@ -61,6 +61,17 @@ 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({
@@ -101,6 +112,8 @@ describe("useNewSessionFlow", () => {
     };
     mockDefaultAgent.isLoading = false;
     mockDefaultAgent.error = null;
+    mockRunnerList.runners = [];
+    mockRunnerList.isLoading = false;
     mockCreateSession.mockResolvedValue({ sessionId: "sess-new" });
     mockCreateExecution.mockResolvedValue({});
   });
@@ -235,6 +248,74 @@ 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);
+      const loadingState: ModelRegistryState = { models: [], isLoading: true, error: null };
+
+      function LoadingWrapper({ children }: { children: ReactNode }) {
+        return (
+          <ModelRegistryContext.Provider value={loadingState}>
+            {children}
+          </ModelRegistryContext.Provider>
+        );
+      }
+
+      const { result } = renderHook(() => useNewSessionFlow(defaultOptions()), { wrapper: LoadingWrapper });
+
+      expect(result.current.modelId).toBeUndefined();
+    });
+
+    it("restores model once registry has loaded", () => {
+      localStorage.setItem(STORAGE_KEY_MODEL_NATIVE, DEFAULT_MODEL_ID);
+
+      const { result } = renderHook(() => useNewSessionFlow(defaultOptions()), { wrapper: createWrapper() });
+
+      expect(result.current.modelId).toBe(DEFAULT_MODEL_ID);
+    });
+
+    it("discards model that no longer exists in the registry", () => {
+      localStorage.setItem(STORAGE_KEY_MODEL_NATIVE, "removed-model-xyz");
+
+      const { result } = renderHook(() => useNewSessionFlow(defaultOptions()), { wrapper: createWrapper() });
+
+      expect(result.current.modelId).toBeUndefined();
+    });
+  });
+
   describe("submit with harness", () => {
     it("passes harness field to createSession", async () => {
       const opts = defaultOptions();

package/src/session/useNewSessionFlow.ts

@@ -10,6 +10,7 @@ import { DEFAULT_HARNESS, type HarnessOption } from "../models/harness";
 import { useWorkspaceEntries, type UseWorkspaceEntriesReturn } from "../workspace";
 import { useSessionVariables, type UseSessionVariablesReturn } from "../execution/useSessionVariables";
 import type { SessionComposerSubmitContext } from "../composer";
+import { useRunnerList } from "../runner/useRunnerList";
 import { useCreateSession } from "./useCreateSession";
 import { useCreateAgentExecution } from "../execution/useCreateAgentExecution";
 
@@ -155,7 +156,8 @@ export function useNewSessionFlow(
     return stored === "cursor" ? "cursor" : DEFAULT_HARNESS;
   });
 
-  const { getModel } = useModelRegistry({ harness });
+  const { getModel, isLoading: isModelsLoading } = useModelRegistry({ harness });
+  const { runners, isLoading: isRunnersLoading } = useRunnerList(org);
   const { create: createSession } = useCreateSession();
   const { create: createExecution } = useCreateAgentExecution();
   const {
@@ -192,8 +194,10 @@ export function useNewSessionFlow(
     [],
   );
 
-  // Restore persisted model on mount (using current harness key)
+  // Restore persisted model — only after the registry has loaded so
+  // getModel can actually validate the stored ID against live data.
   useEffect(() => {
+    if (isModelsLoading) return;
     const stored = localStorage.getItem(modelStorageKey(harness));
     if (stored) {
       const plain = parseModelKey(stored)?.modelId ?? stored;
@@ -201,7 +205,7 @@ export function useNewSessionFlow(
         setModelId(plain);
       }
     }
-  }, [getModel, harness]);
+  }, [getModel, harness, isModelsLoading]);
 
   // Persist model on change (using current harness key).
   // Strip compound keys (e.g. "cursor/default") to plain modelId before storing.
@@ -212,13 +216,20 @@ export function useNewSessionFlow(
     }
   }, [modelId, harness]);
 
-  // Restore persisted runner on mount
+  // Restore persisted runner — validate against the live runner list.
+  // If the stored runner no longer exists, discard it and clean up localStorage.
   useEffect(() => {
+    if (isRunnersLoading) return;
     const stored = localStorage.getItem(STORAGE_KEY_RUNNER);
-    if (stored) {
+    if (!stored) return;
+
+    const exists = runners.some((r) => r.metadata?.id === stored);
+    if (exists) {
       setRunnerId(stored);
+    } else {
+      localStorage.removeItem(STORAGE_KEY_RUNNER);
     }
-  }, []);
+  }, [runners, isRunnersLoading]);
 
   // Persist runner on change
   useEffect(() => {