Skip to content

A desktop coding agent with free access to frontier models.

TypeScript

fix: avoid repeated provider catalog notifications

Task Builderb2c0c626e92b
diff --git a/apps/app/src/react-app/infra/provider-list-query.ts b/apps/app/src/react-app/infra/provider-list-query.ts
index adf29865..fe825006 100644
--- a/apps/app/src/react-app/infra/provider-list-query.ts
+++ b/apps/app/src/react-app/infra/provider-list-query.ts
@@ -28,6 +28,9 @@ export type ConnectedProviderSnapshotChange = {
const CONNECTED_PROVIDER_SNAPSHOT_LIMIT = 16;
const connectedProviderSnapshots = new Map<string, ConnectedProviderSnapshot>();
const connectedProviderSnapshotChanges = new Map<string, ConnectedProviderSnapshotChange>();
+// Discovery history survives temporary catalog shrinkage while the current
+// snapshot still reflects availability for model recovery.
+const observedProviderModels = new Map<string, Map<string, Set<string>>>();
export function providerListQueryKey(input: {
baseUrl?: string | null;
@@ -50,6 +53,7 @@ export function clearProviderListQueries(queryClient: QueryClient) {
queryClient.removeQueries({ queryKey: PROVIDER_LIST_QUERY_ROOT });
connectedProviderSnapshots.clear();
connectedProviderSnapshotChanges.clear();
+ observedProviderModels.clear();
}
export async function fetchProviderList(input: {
@@ -126,9 +130,10 @@ function recordConnectedProviderSnapshot(
if (oldest === undefined) break;
connectedProviderSnapshots.delete(oldest);
connectedProviderSnapshotChanges.delete(oldest);
+ observedProviderModels.delete(oldest);
}
- if (changed) {
- dispatchConnectedProviderChanges(previous, next);
+ if (changed || previous === null) {
+ dispatchConnectedProviderChanges(key, next);
}
}
@@ -140,34 +145,44 @@ function connectedProviderSnapshotKey(input: {
}
function dispatchConnectedProviderChanges(
- previous: ConnectedProviderSnapshot | null,
+ key: string,
next: ConnectedProviderSnapshot,
) {
- if (!previous) return;
- const previousById = new Map(previous.map((provider) => [provider.id, provider]));
- const newProviders = next.filter((provider) => !previousById.has(provider.id));
- const changedProviders = new Map<string, ConnectedProviderSnapshot[number]>();
+ const observed = observedProviderModels.get(key);
+ if (!observed) {
+ // Startup can briefly return an empty catalog. The first populated
+ // response establishes the baseline without announcing existing models.
+ if (next.length > 0) {
+ observedProviderModels.set(
+ key,
+ new Map(next.map((provider) => [provider.id, new Set(Object.keys(provider.models))])),
+ );
+ }
+ return;
+ }
+
+ const changedProviders: ConnectedProviderSnapshot = [];
+ let newProviderCount = 0;
let newModelCount = 0;
for (const provider of next) {
- const before = previousById.get(provider.id);
- if (!before) {
- newModelCount += Object.keys(provider.models).length;
- changedProviders.set(provider.id, provider);
- continue;
- }
- for (const [id, model] of Object.entries(provider.models)) {
- if (JSON.stringify(before.models[id]) !== JSON.stringify(model)) {
- newModelCount += 1;
- changedProviders.set(provider.id, provider);
- }
+ let modelIds = observed.get(provider.id);
+ const newProvider = !modelIds;
+ if (!modelIds) {
+ modelIds = new Set<string>();
+ observed.set(provider.id, modelIds);
+ newProviderCount += 1;
}
+ const addedModelIds = Object.keys(provider.models).filter((id) => !modelIds.has(id));
+ for (const id of addedModelIds) modelIds.add(id);
+ newModelCount += addedModelIds.length;
+ if (newProvider || addedModelIds.length > 0) changedProviders.push(provider);
}
- if (newProviders.length === 0 && newModelCount === 0) return;
+ if (newProviderCount === 0 && newModelCount === 0) return;
dispatchNewProviders({
- providers: [...changedProviders.values()].map((provider) => {
+ providers: changedProviders.map((provider) => {
const firstModelId = Object.keys(provider.models)[0];
return {
id: provider.id,
@@ -179,7 +194,7 @@ function dispatchConnectedProviderChanges(
: undefined,
};
}),
- newProviderCount: newProviders.length,
+ newProviderCount,
newModelCount,
source: "models_refresh",
});
diff --git a/apps/app/src/react-app/shell/new-providers-listener.tsx b/apps/app/src/react-app/shell/new-providers-listener.tsx
index 3394e3e6..6ca48e83 100644
--- a/apps/app/src/react-app/shell/new-providers-listener.tsx
+++ b/apps/app/src/react-app/shell/new-providers-listener.tsx
@@ -95,9 +95,17 @@ export function NewProvidersListener() {
const showProviders = useCallback((detail: NewProvidersEventDetail) => {
const seen = readSeenProviderIds();
const genuinelyNew = detail.providers.filter((p) => !seen.has(p.id));
- const newProviderCount = detail.newProviderCount ?? genuinelyNew.length;
+ const newProviderCount = Math.min(
+ detail.newProviderCount ?? genuinelyNew.length,
+ genuinelyNew.length,
+ );
const newModelCount = detail.newModelCount ?? 0;
- if (genuinelyNew.length === 0 && newModelCount === 0) return;
+ if (newProviderCount === 0 && newModelCount === 0) return;
+
+ // Remember synchronously so duplicate sync sources cannot both announce
+ // a provider before React writes the notification. Onboarding owns sign-in.
+ markProvidersSeen(detail.providers.map((provider) => provider.id));
+ if (detail.source === "sign_in") return;
setState((prev) => ({
active: true,
@@ -151,8 +159,6 @@ export function NewProvidersListener() {
return;
}
- markProvidersSeen(state.providers.map((p) => p.id));
-
const parts: string[] = [];
if (state.newProviderCount > 0) {
parts.push(`${state.newProviderCount} new ${state.newProviderCount === 1 ? "provider" : "providers"}`);
diff --git a/apps/app/tests/renderer-bounded-caches.test.ts b/apps/app/tests/renderer-bounded-caches.test.ts
index f4ff8d42..5d9b36c6 100644
--- a/apps/app/tests/renderer-bounded-caches.test.ts
+++ b/apps/app/tests/renderer-bounded-caches.test.ts
@@ -1,8 +1,12 @@
-import { expect, test } from "bun:test";
+import { afterEach, beforeEach, expect, test } from "bun:test";
+import { QueryClient } from "@tanstack/react-query";
import type { ProviderListResponse } from "@opencode-ai/sdk/v2/client";
-import type { Client } from "../src/app/types";
+import type { Client, ProviderListItem } from "../src/app/types";
+import { createClient } from "../src/app/lib/opencode";
+import { newProvidersEvent, type NewProvidersEventDetail } from "../src/app/lib/provider-events";
import {
+ clearProviderListQueries,
fetchProviderList,
getConnectedProviderSnapshotChange,
} from "../src/react-app/infra/provider-list-query";
@@ -69,3 +73,94 @@ test("connected provider snapshot cache evicts the oldest workspace keys", async
expect(getConnectedProviderSnapshotChange({ baseUrl: "http://localhost:1", directory: "/tmp/workspace-4" })).not.toBeNull();
expect(getConnectedProviderSnapshotChange({ baseUrl: "http://localhost:1", directory: "/tmp/workspace-5" })).not.toBeNull();
});
+
+
+const originalWindow = globalThis.window;
+let discoveries: NewProvidersEventDetail[] = [];
+
+beforeEach(() => {
+ clearProviderListQueries(new QueryClient());
+ discoveries = [];
+ const events = new EventTarget();
+ events.addEventListener(newProvidersEvent, (event) => {
+ if (event instanceof CustomEvent) discoveries.push(event.detail);
+ });
+ Object.defineProperty(globalThis, "window", { configurable: true, value: events });
+});
+
+afterEach(() => {
+ Object.defineProperty(globalThis, "window", { configurable: true, value: originalWindow });
+});
+
+function providerCatalog(entries: Array<{ id: string; modelIds: string[] }>, revision = 0): ProviderListResponse {
+ return {
+ all: entries.map(({ id, modelIds }): ProviderListItem => ({
+ id, name: id, source: "config", env: [], options: {},
+ models: Object.fromEntries<ProviderListItem["models"][string]>(modelIds.map((modelId) => [modelId, {
+ id: modelId, providerID: id, name: modelId + " revision " + revision,
+ api: { id: modelId, url: "https://models.example", npm: "@ai-sdk/openai-compatible" },
+ capabilities: {
+ temperature: true, reasoning: false, attachment: false, toolcall: true,
+ input: { text: true, audio: false, image: false, video: false, pdf: false },
+ output: { text: true, audio: false, image: false, video: false, pdf: false },
+ interleaved: false,
+ },
+ cost: { input: revision, output: 0, cache: { read: 0, write: 0 } },
+ limit: { context: 100_000, output: 10_000 },
+ status: "active", options: {}, headers: {}, release_date: "2026-01-01",
+ }])),
+ })),
+ connected: entries.map(({ id }) => id),
+ default: {},
+ };
+}
+
+test("provider discovery stays quiet through startup, metadata refreshes, and reconnects", async () => {
+ let response = providerCatalog([]);
+ const server = Bun.serve({ hostname: "127.0.0.1", port: 0, fetch: () => Response.json(response) });
+ const client = createClient(server.url.toString(), "/tmp/catalog-regression");
+ const input = { client, baseUrl: server.url.toString(), directory: "/tmp/catalog-regression" };
+ const modelIds = Array.from({ length: 41 }, (_, index) => "model-" + index);
+ const baseline = [{ id: "catalog-provider", modelIds }];
+ const refresh = async (entries: Array<{ id: string; modelIds: string[] }>, revision = 0) => {
+ response = providerCatalog(entries, revision);
+ await fetchProviderList(input);
+ };
+ try {
+ await refresh([]);
+ await refresh(baseline);
+ await refresh(baseline, 1);
+ expect(discoveries).toHaveLength(0);
+
+ await refresh([]);
+ const unavailable = getConnectedProviderSnapshotChange(input);
+ expect(unavailable?.changed).toBe(true);
+ expect(unavailable?.next).toHaveLength(0);
+ await refresh(baseline, 2);
+ expect(discoveries).toHaveLength(0);
+
+ const expanded = [{ id: "catalog-provider", modelIds: [...modelIds, "new-model"] }];
+ await refresh(expanded, 3);
+ expect(discoveries).toHaveLength(1);
+ expect(discoveries[0]).toMatchObject({ newProviderCount: 0, newModelCount: 1, source: "models_refresh" });
+
+ await refresh(expanded, 4);
+ await refresh(baseline);
+ await refresh(expanded);
+ expect(discoveries).toHaveLength(1);
+
+ const newProvider = { id: "second-provider", modelIds: ["second-a", "second-b"] };
+ await refresh([...expanded, newProvider]);
+ expect(discoveries).toHaveLength(2);
+ expect(discoveries[1]).toMatchObject({ newProviderCount: 1, newModelCount: 2 });
+ await refresh(expanded);
+ await refresh([...expanded, newProvider], 5);
+ expect(discoveries).toHaveLength(2);
+
+ clearProviderListQueries(new QueryClient());
+ await refresh([...expanded, newProvider]);
+ expect(discoveries).toHaveLength(2);
+ } finally {
+ server.stop(true);
+ }
+});
diff --git a/evals/specs/provider-catalog-notifications.e2e.test.ts b/evals/specs/provider-catalog-notifications.e2e.test.ts
new file mode 100644
index 00000000..d5644f9a
--- /dev/null
+++ b/evals/specs/provider-catalog-notifications.e2e.test.ts
@@ -0,0 +1,77 @@
+import { expect } from "vitest";
+import { control, readAvailableModels } from "@omnirush/behaviors";
+import { eventually, spec } from "@omnirush/testkit";
+import { providerCatalogNotifications } from "../worlds/chat.ts";
+
+const test = spec.world(providerCatalogNotifications, { timeout: 600_000 });
+
+function providerNotifications(value: unknown) {
+ if (!Array.isArray(value)) throw new Error("Notification center did not return an array.");
+ return value.filter((entry) => typeof entry === "object" && entry !== null && Reflect.get(entry, "kind") === "providers");
+}
+
+test("catalog refreshes announce new models once and keep metadata updates and reconnects quiet", async ({ world, user, step, evidence }) => {
+ const notifications = async () => providerNotifications(await control(world.app, "notifications.list"));
+ const models = () => readAvailableModels(world.app);
+ await eventually(async () => {
+ const rows = await models();
+ return rows.some((model) => model.id === world.modelIds[0]);
+ }, { within: 60_000, label: "baseline catalog available", until: (value) => value === true });
+ await user.press("Escape");
+ await user.click({ role: "button", label: /^Notifications/ });
+ if ((await notifications()).length > 0) await user.click({ role: "button", label: "Clear all" });
+ await user.press("Escape");
+ expect(await notifications()).toHaveLength(0);
+
+ await step("a metadata refresh updates the picker without announcing 41 new models", async () => {
+ await world.updateCatalog(world.modelIds, 1);
+ await eventually(async () => (await models()).some((model) => model.name === world.modelIds[0] + " revision 1"), {
+ within: 60_000, label: "updated model metadata visible", until: (value) => value === true,
+ });
+ const entries = await notifications();
+ expect(entries).toHaveLength(0);
+ evidence.recordAssertionEvidence("Metadata updates do not announce existing models", "The picker shows revision 1; notifications=" + JSON.stringify(entries), entries.length === 0);
+ await user.press("Escape");
+ });
+
+ await step("a disconnected provider returns without being announced again", async () => {
+ await world.updateCatalog(world.modelIds, 1, true);
+ await eventually(async () => (await models()).every((model) => model.id !== world.modelIds[0]), {
+ within: 60_000, label: "provider disconnected", until: (value) => value === true,
+ });
+ await user.press("Escape");
+ await world.updateCatalog(world.modelIds, 1);
+ await eventually(async () => (await models()).some((model) => model.id === world.modelIds[0]), {
+ within: 60_000, label: "provider reconnected", until: (value) => value === true,
+ });
+ const entries = await notifications();
+ expect(entries).toHaveLength(0);
+ evidence.recordAssertionEvidence("Reconnecting does not announce the same provider and models", "The existing model disappeared and returned; notifications=" + JSON.stringify(entries), entries.length === 0);
+ await user.press("Escape");
+ });
+
+ await step("a genuinely new model produces one announcement", async () => {
+ const expanded = [...world.modelIds, "catalog-new-model"];
+ await world.updateCatalog(expanded, 2);
+ await eventually(async () => (await models()).some((model) => model.id === "catalog-new-model"), {
+ within: 60_000, label: "new model selectable", until: (value) => value === true,
+ });
+ await eventually(notifications, { within: 10_000, label: "new model notification", until: (value) => value.length === 1 });
+ const entries = await notifications();
+ expect(entries).toHaveLength(1);
+ expect(entries[0]).toMatchObject({ title: "1 new model available" });
+ await user.press("Escape");
+ await user.click({ role: "button", label: /^Notifications/ });
+ await user.see({ text: "1 new model available" });
+ await user.click({ role: "button", label: "Clear all" });
+ await user.press("Escape");
+
+ await world.updateCatalog(expanded, 3);
+ await eventually(async () => (await models()).some((model) => model.name === "catalog-new-model revision 3"), {
+ within: 60_000, label: "repeated refresh settled", until: (value) => value === true,
+ });
+ const afterRefresh = await notifications();
+ expect(afterRefresh).toHaveLength(0);
+ evidence.recordAssertionEvidence("A new model is announced once, including after the notification is cleared", "New-model notifications=" + JSON.stringify(entries) + "; after refresh=" + JSON.stringify(afterRefresh), entries.length === 1 && afterRefresh.length === 0);
+ });
+});
diff --git a/evals/worlds/chat.ts b/evals/worlds/chat.ts
index 0f83b6c8..b807af02 100644
--- a/evals/worlds/chat.ts
+++ b/evals/worlds/chat.ts
@@ -504,6 +504,50 @@ export async function modelPicker(seed: Seed) {
return { app, den, session };
}
+export async function providerCatalogNotifications(seed: Seed) {
+ const den = await seed.den();
+ const app = await seed.desktop({ den, signIn: false, name: "provider-catalog-notifications" });
+ const workspace = await seed.workspace(app, seed.tmpPath("provider-catalog-notifications"));
+ const providerId = "catalog-notifications-fixture";
+ const modelIds = Array.from({ length: 41 }, (_, index) => "catalog-model-" + index);
+ const catalog = (ids: string[], revision: number, disabled: boolean) => ({
+ disabled_providers: disabled ? [providerId] : [],
+ provider: {
+ [providerId]: {
+ name: "Catalog Notification Models",
+ npm: "@ai-sdk/openai-compatible",
+ options: { baseURL: "http://127.0.0.1:9/v1", apiKey: "local-catalog-fixture" },
+ models: Object.fromEntries(ids.map((id) => [id, {
+ name: id + " revision " + revision,
+ limit: { context: 100_000, output: 10_000 },
+ cost: { input: revision, output: 0 },
+ }])),
+ },
+ },
+ });
+ await configureProvider(seed, app, workspace.workspaceId, providerId, modelIds[0], catalog(modelIds, 0, false));
+ const session = await seedSessionRetry(seed, app);
+
+ const updateCatalog = async (ids: string[], revision: number, disabled = false) => {
+ const result = await seed.evalIn(app, browserScript(async (workspaceId, configJson) => {
+ const port = localStorage.getItem("omnirush.server.port");
+ const token = localStorage.getItem("omnirush.server.token");
+ if (!port || !token) return "missing local server credentials";
+ const base = "http://127.0.0.1:" + port + "/workspace/" + encodeURIComponent(workspaceId);
+ const headers = { Authorization: "Bearer " + token, "Content-Type": "application/json" };
+ const patched = await fetch(base + "/config", {
+ method: "PATCH", headers, body: JSON.stringify({ opencode: JSON.parse(configJson) }),
+ });
+ if (!patched.ok) return "config patch failed: " + patched.status;
+ const reloaded = await fetch(base + "/engine/reload", { method: "POST", headers });
+ return reloaded.ok || reloaded.status === 504 ? "ok" : "engine reload failed: " + reloaded.status;
+ }, [workspace.workspaceId, JSON.stringify(catalog(ids, revision, disabled))]), { awaitPromise: true, timeoutMs: 120_000 });
+ if (result !== "ok") throw new Error("Catalog fixture update failed: " + String(result));
+ };
+
+ return { app, den, workspace, session, providerId, modelIds, updateCatalog };
+}
+
export async function connectionsMenu(seed: Seed) {
const connector = seed.mock();
const den = await seed.den({ mocks: { connector } });