From 17bb87f432e2531772163a95873ff0f8b195abad Mon Sep 17 00:00:00 2001 From: Peter Steinberger Date: Tue, 3 Mar 2026 03:20:46 +0000 Subject: [PATCH] fix(venice): retry model discovery on transient fetch failures --- src/agents/venice-models.test.ts | 110 ++++++++++++++++++++++++ src/agents/venice-models.ts | 122 +++++++++++++++++++++++++-- src/scripts/ci-changed-scope.test.ts | 3 +- 3 files changed, 225 insertions(+), 10 deletions(-) create mode 100644 src/agents/venice-models.test.ts diff --git a/src/agents/venice-models.test.ts b/src/agents/venice-models.test.ts new file mode 100644 index 00000000000..95fc7f61f8a --- /dev/null +++ b/src/agents/venice-models.test.ts @@ -0,0 +1,110 @@ +import { afterEach, describe, expect, it, vi } from "vitest"; +import { + buildVeniceModelDefinition, + discoverVeniceModels, + VENICE_MODEL_CATALOG, +} from "./venice-models.js"; + +const ORIGINAL_NODE_ENV = process.env.NODE_ENV; +const ORIGINAL_VITEST = process.env.VITEST; + +function restoreDiscoveryEnv(): void { + if (ORIGINAL_NODE_ENV === undefined) { + delete process.env.NODE_ENV; + } else { + process.env.NODE_ENV = ORIGINAL_NODE_ENV; + } + + if (ORIGINAL_VITEST === undefined) { + delete process.env.VITEST; + } else { + process.env.VITEST = ORIGINAL_VITEST; + } +} + +async function runWithDiscoveryEnabled(operation: () => Promise): Promise { + process.env.NODE_ENV = "development"; + delete process.env.VITEST; + try { + return await operation(); + } finally { + restoreDiscoveryEnv(); + } +} + +function makeModelsResponse(id: string): Response { + return new Response( + JSON.stringify({ + data: [ + { + id, + model_spec: { + name: id, + privacy: "private", + availableContextTokens: 131072, + capabilities: { + supportsReasoning: false, + supportsVision: false, + supportsFunctionCalling: true, + }, + }, + }, + ], + }), + { + status: 200, + headers: { "Content-Type": "application/json" }, + }, + ); +} + +describe("venice-models", () => { + afterEach(() => { + vi.unstubAllGlobals(); + restoreDiscoveryEnv(); + }); + + it("buildVeniceModelDefinition returns config with required fields", () => { + const entry = VENICE_MODEL_CATALOG[0]; + const def = buildVeniceModelDefinition(entry); + expect(def.id).toBe(entry.id); + expect(def.name).toBe(entry.name); + expect(def.reasoning).toBe(entry.reasoning); + expect(def.input).toEqual(entry.input); + expect(def.cost).toEqual({ input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }); + expect(def.contextWindow).toBe(entry.contextWindow); + expect(def.maxTokens).toBe(entry.maxTokens); + }); + + it("retries transient fetch failures before succeeding", async () => { + let attempts = 0; + const fetchMock = vi.fn(async () => { + attempts += 1; + if (attempts < 3) { + throw Object.assign(new TypeError("fetch failed"), { + cause: { code: "ECONNRESET", message: "socket hang up" }, + }); + } + return makeModelsResponse("llama-3.3-70b"); + }); + vi.stubGlobal("fetch", fetchMock as unknown as typeof fetch); + + const models = await runWithDiscoveryEnabled(() => discoverVeniceModels()); + expect(attempts).toBe(3); + expect(models.map((m) => m.id)).toContain("llama-3.3-70b"); + }); + + it("falls back to static catalog after retry budget is exhausted", async () => { + const fetchMock = vi.fn(async () => { + throw Object.assign(new TypeError("fetch failed"), { + cause: { code: "ENOTFOUND", message: "getaddrinfo ENOTFOUND api.venice.ai" }, + }); + }); + vi.stubGlobal("fetch", fetchMock as unknown as typeof fetch); + + const models = await runWithDiscoveryEnabled(() => discoverVeniceModels()); + expect(fetchMock).toHaveBeenCalledTimes(3); + expect(models).toHaveLength(VENICE_MODEL_CATALOG.length); + expect(models.map((m) => m.id)).toEqual(VENICE_MODEL_CATALOG.map((m) => m.id)); + }); +}); diff --git a/src/agents/venice-models.ts b/src/agents/venice-models.ts index 99af6d5f5b7..b33b51c60a8 100644 --- a/src/agents/venice-models.ts +++ b/src/agents/venice-models.ts @@ -1,4 +1,5 @@ import type { ModelDefinitionConfig } from "../config/types.js"; +import { retryAsync } from "../infra/retry.js"; import { createSubsystemLogger } from "../logging/subsystem.js"; const log = createSubsystemLogger("venice-models"); @@ -16,6 +17,24 @@ export const VENICE_DEFAULT_COST = { cacheWrite: 0, }; +const VENICE_DISCOVERY_TIMEOUT_MS = 10_000; +const VENICE_DISCOVERY_RETRYABLE_HTTP_STATUS = new Set([408, 425, 429, 500, 502, 503, 504]); +const VENICE_DISCOVERY_RETRYABLE_NETWORK_CODES = new Set([ + "ECONNABORTED", + "ECONNREFUSED", + "ECONNRESET", + "EAI_AGAIN", + "ENETDOWN", + "ENETUNREACH", + "ENOTFOUND", + "ETIMEDOUT", + "UND_ERR_BODY_TIMEOUT", + "UND_ERR_CONNECT_TIMEOUT", + "UND_ERR_CONNECT_ERROR", + "UND_ERR_HEADERS_TIMEOUT", + "UND_ERR_SOCKET", +]); + /** * Complete catalog of Venice AI models. * @@ -332,6 +351,67 @@ interface VeniceModelsResponse { data: VeniceModel[]; } +class VeniceDiscoveryHttpError extends Error { + readonly status: number; + + constructor(status: number) { + super(`HTTP ${status}`); + this.name = "VeniceDiscoveryHttpError"; + this.status = status; + } +} + +function staticVeniceModelDefinitions(): ModelDefinitionConfig[] { + return VENICE_MODEL_CATALOG.map(buildVeniceModelDefinition); +} + +function hasRetryableNetworkCode(err: unknown): boolean { + const queue: unknown[] = [err]; + const seen = new Set(); + while (queue.length > 0) { + const current = queue.shift(); + if (!current || typeof current !== "object" || seen.has(current)) { + continue; + } + seen.add(current); + const candidate = current as { + cause?: unknown; + errors?: unknown; + code?: unknown; + errno?: unknown; + }; + const code = + typeof candidate.code === "string" + ? candidate.code + : typeof candidate.errno === "string" + ? candidate.errno + : undefined; + if (code && VENICE_DISCOVERY_RETRYABLE_NETWORK_CODES.has(code)) { + return true; + } + if (candidate.cause) { + queue.push(candidate.cause); + } + if (Array.isArray(candidate.errors)) { + queue.push(...candidate.errors); + } + } + return false; +} + +function isRetryableVeniceDiscoveryError(err: unknown): boolean { + if (err instanceof VeniceDiscoveryHttpError) { + return true; + } + if (err instanceof Error && err.name === "AbortError") { + return true; + } + if (err instanceof TypeError && err.message.toLowerCase() === "fetch failed") { + return true; + } + return hasRetryableNetworkCode(err); +} + /** * Discover models from Venice API with fallback to static catalog. * The /models endpoint is public and doesn't require authentication. @@ -339,23 +419,45 @@ interface VeniceModelsResponse { export async function discoverVeniceModels(): Promise { // Skip API discovery in test environment if (process.env.NODE_ENV === "test" || process.env.VITEST) { - return VENICE_MODEL_CATALOG.map(buildVeniceModelDefinition); + return staticVeniceModelDefinitions(); } try { - const response = await fetch(`${VENICE_BASE_URL}/models`, { - signal: AbortSignal.timeout(5000), - }); + const response = await retryAsync( + async () => { + const currentResponse = await fetch(`${VENICE_BASE_URL}/models`, { + signal: AbortSignal.timeout(VENICE_DISCOVERY_TIMEOUT_MS), + headers: { + Accept: "application/json", + }, + }); + if ( + !currentResponse.ok && + VENICE_DISCOVERY_RETRYABLE_HTTP_STATUS.has(currentResponse.status) + ) { + throw new VeniceDiscoveryHttpError(currentResponse.status); + } + return currentResponse; + }, + { + attempts: 3, + minDelayMs: 300, + maxDelayMs: 2000, + jitter: 0.2, + label: "venice-model-discovery", + shouldRetry: isRetryableVeniceDiscoveryError, + }, + ); if (!response.ok) { log.warn(`Failed to discover models: HTTP ${response.status}, using static catalog`); - return VENICE_MODEL_CATALOG.map(buildVeniceModelDefinition); + return staticVeniceModelDefinitions(); } const data = (await response.json()) as VeniceModelsResponse; if (!Array.isArray(data.data) || data.data.length === 0) { log.warn("No models found from API, using static catalog"); - return VENICE_MODEL_CATALOG.map(buildVeniceModelDefinition); + return staticVeniceModelDefinitions(); } // Merge discovered models with catalog metadata @@ -395,9 +497,13 @@ export async function discoverVeniceModels(): Promise { } } - return models.length > 0 ? models : VENICE_MODEL_CATALOG.map(buildVeniceModelDefinition); + return models.length > 0 ? models : staticVeniceModelDefinitions(); } catch (error) { + if (error instanceof VeniceDiscoveryHttpError) { + log.warn(`Failed to discover models: HTTP ${error.status}, using static catalog`); + return staticVeniceModelDefinitions(); + } log.warn(`Discovery failed: ${String(error)}, using static catalog`); - return VENICE_MODEL_CATALOG.map(buildVeniceModelDefinition); + return staticVeniceModelDefinitions(); } } diff --git a/src/scripts/ci-changed-scope.test.ts b/src/scripts/ci-changed-scope.test.ts index 42f9a7aebb9..2de370a48ab 100644 --- a/src/scripts/ci-changed-scope.test.ts +++ b/src/scripts/ci-changed-scope.test.ts @@ -1,8 +1,7 @@ import { createRequire } from "node:module"; import { describe, expect, it } from "vitest"; -const require = createRequire(import.meta.url); -const { detectChangedScope } = require("../../scripts/ci-changed-scope.mjs") as { +const { detectChangedScope } = (await import("../../scripts/ci-changed-scope.mjs")) as unknown as { detectChangedScope: (paths: string[]) => { runNode: boolean; runMacos: boolean;