};

}

async function cancelUnreadResponseBody(response: Response | undefined): Promise<void> {

if (response?.bodyUsed !== true) {

await response?.body?.cancel().catch(() => undefined);

}

}

async function readPricingJsonObject(

response: Response,

source: string,

return payload as Record<string, unknown>;

}

async function fetchPricingJsonObject(params: {

fetchImpl: typeof fetch;

url: string;

source: string;

failureLabel: string;

signal?: AbortSignal;

}): Promise<Record<string, unknown>> {

let response: Response | undefined;

try {

response = await params.fetchImpl(params.url, {

headers: { Accept: "application/json" },

signal: createPricingFetchSignal(params.signal),

});

if (!response.ok) {

throw new Error(`${params.failureLabel}: HTTP ${response.status}`);

}

return await readPricingJsonObject(response, params.source);

} finally {

await cancelUnreadResponseBody(response);

}

}

// ---------------------------------------------------------------------------

// LiteLLM tiered-pricing parsing

// ---------------------------------------------------------------------------

fetchImpl: typeof fetch,

signal?: AbortSignal,

): Promise<LiteLLMPricingCatalog> {

const response = await fetchImpl(LITELLM_PRICING_URL, {

headers: { Accept: "application/json" },

signal: createPricingFetchSignal(signal),

const payload = await fetchPricingJsonObject({

fetchImpl,

url: LITELLM_PRICING_URL,

source: "LiteLLM",

failureLabel: "LiteLLM pricing fetch failed",

signal,

});

if (!response.ok) {

throw new Error(`LiteLLM pricing fetch failed: HTTP ${response.status}`);

}

const payload = await readPricingJsonObject(response, "LiteLLM");

const catalog: LiteLLMPricingCatalog = new Map();

for (const [key, value] of Object.entries(payload)) {

if (!value || typeof value !== "object") {

fetchImpl: typeof fetch,

signal?: AbortSignal,

): Promise<Map<string, OpenRouterPricingEntry>> {

const response = await fetchImpl(OPENROUTER_MODELS_URL, {

headers: { Accept: "application/json" },

signal: createPricingFetchSignal(signal),

const payload = await fetchPricingJsonObject({

fetchImpl,

url: OPENROUTER_MODELS_URL,

source: "OpenRouter",

failureLabel: "OpenRouter /models failed",

signal,

});

if (!response.ok) {

throw new Error(`OpenRouter /models failed: HTTP ${response.status}`);

}

const payload = await readPricingJsonObject(response, "OpenRouter");

const entries = Array.isArray(payload.data) ? payload.data : [];

const catalog = new Map<string, OpenRouterPricingEntry>();

for (const entry of entries) {