- Tlon/Urbit: report malformed SSE event JSON with an owned parser error instead of logging raw parser failures.

- Signal: return a stable installer error when GitHub release metadata is malformed JSON.

- ClawHub: report malformed successful marketplace JSON responses with owned errors instead of leaking raw parser failures.

- Provider usage: report malformed successful usage JSON responses with stable provider errors instead of leaking raw parser failures.

- Matrix: ignore malformed percent-encoding in optional location URI parameters instead of letting a bad `geo:` event abort inbound message handling.

- Web search: auto-detect Brave through its legacy `tools.web.search.apiKey` compatibility fallback while keeping doctor migration to `plugins.entries.brave.config.webSearch.apiKey` as the canonical repair, so allowlisted isolated cron runs do not report `web_search` unavailable before migration. Fixes #81538. Thanks @atomicmonk.

- Plugins: memoize repeated in-process plugin metadata snapshots and keep vanished managed-install residue from forcing full derived discovery, reducing gateway/status startup scans under large plugin sets. Fixes #81143 and #79806. (#81570) Thanks @Kaspre, @holgergruenhagen, @JanPlessow, and @mjamiv.

expect(result.windows).toHaveLength(0);

});

it("returns a stable error for malformed successful oauth usage JSON", async () => {

const mockFetch = createProviderUsageFetch(async () => makeResponse(200, "{not json"));

const result = await fetchClaudeUsage("token", 5000, mockFetch);

expect(result.error).toBe("Malformed usage response");

expect(result.windows).toHaveLength(0);

});

it("falls back to claude web usage when oauth scope is missing", async () => {

vi.stubEnv("CLAUDE_AI_SESSION_KEY", "sk-ant-session-key");

import { buildUsageHttpErrorSnapshot, fetchJson } from "./provider-usage.fetch.shared.js";

import {

buildUsageHttpErrorSnapshot,

fetchJson,

readUsageJson,

} from "./provider-usage.fetch.shared.js";

import { clampPercent, PROVIDER_LABELS } from "./provider-usage.shared.js";

import type { ProviderUsageSnapshot, UsageWindow } from "./provider-usage.types.js";

return null;

}

const orgs = (await orgRes.json()) as ClaudeWebOrganizationsResponse;

const parsedOrgs = await readUsageJson("anthropic", orgRes);

if (!parsedOrgs.ok) {

return null;

}

const orgs = parsedOrgs.data as ClaudeWebOrganizationsResponse;

const orgId = orgs?.[0]?.uuid?.trim();

if (!orgId) {

return null;

return null;

}

const data = (await usageRes.json()) as ClaudeWebUsageResponse;

const parsedUsage = await readUsageJson("anthropic", usageRes);

if (!parsedUsage.ok) {

return null;

}

const data = parsedUsage.data as ClaudeWebUsageResponse;

const windows = buildClaudeUsageWindows(data);

if (windows.length === 0) {

});

}

const data = (await res.json()) as ClaudeUsageResponse;

const parsed = await readUsageJson("anthropic", res);

if (!parsed.ok) {

return parsed.snapshot;

}

const data = parsed.data as ClaudeUsageResponse;

const windows = buildClaudeUsageWindows(data);

return {

expect(result.windows).toHaveLength(0);

});

it("returns a stable error for malformed successful usage JSON", async () => {

const mockFetch = createProviderUsageFetch(async () => makeResponse(200, "{not json"));

const result = await fetchCodexUsage("token", undefined, 5000, mockFetch);

expect(result.error).toBe("Malformed usage response");

expect(result.windows).toHaveLength(0);

});

it("parses windows, reset times, and plan balance", async () => {

const mockFetch = createProviderUsageFetch(async (_url, init) => {

const headers = (init?.headers as Record<string, string> | undefined) ?? {};

import { resolveProviderRequestHeaders } from "../agents/provider-request-config.js";

import { buildUsageHttpErrorSnapshot, fetchJson } from "./provider-usage.fetch.shared.js";

import {

buildUsageHttpErrorSnapshot,

fetchJson,

readUsageJson,

} from "./provider-usage.fetch.shared.js";

import { clampPercent, PROVIDER_LABELS } from "./provider-usage.shared.js";

import type { ProviderUsageSnapshot, UsageWindow } from "./provider-usage.types.js";

});

}

const data = (await res.json()) as CodexUsageResponse;

const parsed = await readUsageJson("openai-codex", res);

if (!parsed.ok) {

return parsed.snapshot;

}

const data = parsed.data as CodexUsageResponse;

const windows: UsageWindow[] = [];

if (data.rate_limit?.primary_window) {

expect(result.windows).toHaveLength(0);

});

it("returns a stable error for malformed successful usage JSON", async () => {

const mockFetch = createProviderUsageFetch(async () => makeResponse(200, "{not json"));

const result = await fetchGeminiUsage("token", 5000, mockFetch, usageProvider);

expect(result.error).toBe("Malformed usage response");

expect(result.windows).toHaveLength(0);

});

it("selects the lowest remaining fraction per model family", async () => {

const mockFetch = createProviderUsageFetch(async (_url, init) => {

const headers = (init?.headers as Record<string, string> | undefined) ?? {};

import { normalizeLowercaseStringOrEmpty } from "../shared/string-coerce.js";

import { buildUsageHttpErrorSnapshot, fetchJson } from "./provider-usage.fetch.shared.js";

import {

buildUsageHttpErrorSnapshot,

fetchJson,

readUsageJson,

} from "./provider-usage.fetch.shared.js";

import { clampPercent, PROVIDER_LABELS } from "./provider-usage.shared.js";

import type {

ProviderUsageSnapshot,

});

}

const data = (await res.json()) as GeminiUsageResponse;

const parsed = await readUsageJson(provider, res);

if (!parsed.ok) {

return parsed.snapshot;

}

const data = parsed.data as GeminiUsageResponse;

const quotas: Record<string, number> = {};

for (const bucket of data.buckets || []) {

const suffix = options.message?.trim() ? `: ${options.message.trim()}` : "";

return buildUsageErrorSnapshot(options.provider, `HTTP ${options.status}${suffix}`);

}

export async function readUsageJson(

provider: UsageProviderId,

response: Response,

): Promise<{ ok: true; data: unknown } | { ok: false; snapshot: ProviderUsageSnapshot }> {

try {

return { ok: true, data: await response.json() };

} catch {

return {

ok: false,

snapshot: buildUsageErrorSnapshot(provider, "Malformed usage response"),

};

}

}

expect(result.windows).toHaveLength(0);

});

it("returns a stable error for malformed successful usage JSON", async () => {

const mockFetch = createProviderUsageFetch(async () => makeResponse(200, "{not json"));

const result = await fetchZaiUsage("key", 5000, mockFetch);

expect(result.error).toBe("Malformed usage response");

expect(result.windows).toHaveLength(0);

});

it("returns API message errors for unsuccessful payloads", async () => {

const mockFetch = createProviderUsageFetch(async () =>

makeResponse(200, {

import { buildUsageHttpErrorSnapshot, fetchJson } from "./provider-usage.fetch.shared.js";

import {

buildUsageHttpErrorSnapshot,

fetchJson,

readUsageJson,

} from "./provider-usage.fetch.shared.js";

import { clampPercent, PROVIDER_LABELS } from "./provider-usage.shared.js";

import type { ProviderUsageSnapshot, UsageWindow } from "./provider-usage.types.js";

});

}

const data = (await res.json()) as ZaiUsageResponse;

const parsed = await readUsageJson("zai", res);

if (!parsed.ok) {

return parsed.snapshot;

}

const data = parsed.data as ZaiUsageResponse;

if (!data.success || data.code !== 200) {

const errorMessage = typeof data.msg === "string" ? data.msg.trim() : "";

return {