Skip to content

πŸ™Œ OpenHands: AI-Driven Development

fix(backends): silence expected recovery model and version probes (#18369)

Engel Nyst47decad46ee8
diff --git a/__tests__/components/backends/backend-version.test.tsx b/__tests__/components/backends/backend-version.test.tsx
new file mode 100644
index 0000000000..ca31332349
--- /dev/null
+++ b/__tests__/components/backends/backend-version.test.tsx
@@ -0,0 +1,57 @@
+import React from "react";
+import { render, screen, waitFor } from "@testing-library/react";
+import { QueryClientProvider } from "@tanstack/react-query";
+import { HttpError } from "@openhands/typescript-client";
+import { ServerClient } from "@openhands/typescript-client/clients";
+import { afterEach, expect, it, vi } from "vitest";
+import type { Backend } from "#/api/backend-registry/types";
+import { BackendVersion } from "#/components/features/backends/backend-version";
+import { createAgentServerQueryClient } from "#/query-client-config";
+import * as ToastHandlers from "#/utils/custom-toast-handlers";
+
+vi.mock("react-i18next", () => ({
+ useTranslation: () => ({
+ t: (_key: string, options: { version: string }) => options.version,
+ }),
+}));
+
+afterEach(() => vi.restoreAllMocks());
+
+it("keeps failed version probes quiet and shows the version after recovery", async () => {
+ const backend: Backend = {
+ id: "local-version-test",
+ name: "Local",
+ kind: "local",
+ host: "http://127.0.0.1:18160",
+ apiKey: "fixture-key",
+ };
+ const probe = vi
+ .spyOn(ServerClient.prototype, "getServerInfo")
+ .mockRejectedValue(
+ new HttpError(503, "Service Unavailable", {
+ detail: "Version probe unavailable",
+ }),
+ );
+ const toast = vi.spyOn(ToastHandlers, "displayErrorToast");
+ const client = createAgentServerQueryClient();
+ render(
+ <QueryClientProvider client={client}>
+ <BackendVersion backend={backend} />
+ </QueryClientProvider>,
+ );
+ await waitFor(() =>
+ expect(client.getQueryCache().getAll()[0]?.state.status).toBe("error"),
+ );
+ expect(toast).not.toHaveBeenCalled();
+ expect(
+ screen.queryByTestId("manage-backends-version-Local"),
+ ).not.toBeInTheDocument();
+ probe.mockResolvedValue({ version: "1.54.0" } as Awaited<
+ ReturnType<ServerClient["getServerInfo"]>
+ >);
+ await client.refetchQueries();
+ expect(
+ await screen.findByTestId("manage-backends-version-Local"),
+ ).toHaveTextContent("1.54.0");
+ client.clear();
+});
diff --git a/__tests__/hooks/query/use-free-models.test.tsx b/__tests__/hooks/query/use-free-models.test.tsx
index 82a5ce06e2..2bda7d2b34 100644
--- a/__tests__/hooks/query/use-free-models.test.tsx
+++ b/__tests__/hooks/query/use-free-models.test.tsx
@@ -1,4 +1,6 @@
import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { HttpError } from "@openhands/typescript-client";
+import { LLMMetadataClient } from "@openhands/typescript-client/clients";
import { renderHook, waitFor } from "@testing-library/react";
import React from "react";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
@@ -134,19 +136,47 @@ describe("useHydrateFreeModels", () => {
expect(useFreeModelsStore.getState().defaultModel).toBeNull();
});
- it("still toasts a real backend failure once a backend is configured", async () => {
+ it.each(["local", "cloud"] as const)(
+ "settles quietly when the registered %s backend is unreachable",
+ async (kind) => {
+ const toastSpy = vi.spyOn(ToastHandlers, "displayErrorToast");
+ const backend: Backend = { ...cloudBackend, kind };
+ setRegisteredBackends([backend]);
+ setActiveSelection({ backendId: backend.id, orgId: null });
+ const unavailable = new HttpError(503, "Service Unavailable", {
+ detail: `${kind} backend unavailable`,
+ });
+ vi.spyOn(
+ LLMMetadataClient.prototype,
+ "getVerifiedModels",
+ ).mockRejectedValue(unavailable);
+ vi.mocked(callCloudProxy).mockRejectedValue(unavailable);
+
+ renderHook(() => useHydratedFreeModelState(), {
+ wrapper: appProvidersWrapper(),
+ });
+
+ await waitFor(() =>
+ expect(useFreeModelsStore.getState().defaultModelReady).toBe(true),
+ );
+ expect(toastSpy).not.toHaveBeenCalled();
+ },
+ );
+
+ it("still toasts ordinary post-bootstrap query failures", async () => {
const toastSpy = vi.spyOn(ToastHandlers, "displayErrorToast");
- vi.mocked(callCloudProxy).mockRejectedValue(
- new Error("Model search is unavailable"),
- );
-
- renderHook(() => useHydratedFreeModelState(), {
- wrapper: appProvidersWrapper(),
- });
-
- await waitFor(() =>
- expect(toastSpy).toHaveBeenCalledWith("Model search is unavailable"),
- );
- expect(useFreeModelsStore.getState().defaultModelReady).toBe(true);
+ const client = createAgentServerQueryClient();
+ const error = new Error("Conversation action failed");
+ await expect(
+ client.fetchQuery({
+ queryKey: ["conversation-action-test"],
+ queryFn: async () => {
+ throw error;
+ },
+ retry: false,
+ }),
+ ).rejects.toBe(error);
+ expect(toastSpy).toHaveBeenCalledWith(error.message);
+ client.clear();
});
});
diff --git a/src/components/features/backends/backend-version.tsx b/src/components/features/backends/backend-version.tsx
index e041521951..81598a8407 100644
--- a/src/components/features/backends/backend-version.tsx
+++ b/src/components/features/backends/backend-version.tsx
@@ -24,6 +24,7 @@ export function BackendVersion({ backend }: { backend: Backend }) {
retry: false,
staleTime: 60_000,
enabled: backend.kind === "local",
+ meta: { disableToast: true },
});
if (!version) return null;
diff --git a/src/hooks/query/use-free-models.ts b/src/hooks/query/use-free-models.ts
index f1d67117b7..87517f007c 100644
--- a/src/hooks/query/use-free-models.ts
+++ b/src/hooks/query/use-free-models.ts
@@ -90,12 +90,14 @@ const useOpenHandsModels = (hasBackend: boolean) => {
queryKey: [...VERIFIED_MODELS_QUERY_KEY, ...backendScope],
queryFn: fetchVerifiedModelsByProvider,
staleTime: VERIFIED_MODELS_STALE_TIME,
+ meta: { disableToast: true },
});
return fetchAllOpenHandsModels(verifiedByProvider, null, new Set(), 0);
},
enabled: hasBackend,
staleTime: VERIFIED_MODELS_STALE_TIME,
gcTime: VERIFIED_MODELS_GC_TIME,
+ meta: { disableToast: true },
});
};