zidane 6.4.1 → 6.4.2

package/dist/{openai-compat-70-QNsmd.js → openai-compat-0MJq4-g9.js}

@@ -124,6 +124,154 @@ function buildPromptMessage(provider, parts) {
 	return defaultPromptMessage(parts);
 }
 //#endregion
+//#region src/providers/model-catalog.ts
+const holder = { current: void 0 };
+/**
+* Normalization cache. Per-call catalogs arrive on every turn; without this a
+* table form would allocate a fresh closure per lookup. Weak so a discarded
+* catalog doesn't pin memory.
+*/
+const normalized = /* @__PURE__ */ new WeakMap();
+/**
+* Install (or clear, with `null`) the process-wide catalog. Latest call wins.
+*
+* Prefer `behavior.modelCatalog` when you can: it needs no global state and
+* scopes to one agent or one run. Use this for a deployment-wide correction,
+* or when the host's model picker must see the override too.
+*/
+function setModelCatalog(catalog) {
+	holder.current = catalog ? normalize(catalog) : void 0;
+}
+/** The process-wide catalog, normalized to source form. */
+function getModelCatalog() {
+	return holder.current;
+}
+function normalize(catalog) {
+	const cached = normalized.get(catalog);
+	if (cached) return cached;
+	const source = isSource(catalog) ? catalog : (() => {
+		const table = catalog;
+		return {
+			table,
+			get: (provider, modelId) => table[`${provider}:${modelId}`]
+		};
+	})();
+	normalized.set(catalog, source);
+	return source;
+}
+/** A `ModelCatalog` is a source when it declares either accessor. */
+function isSource(catalog) {
+	const candidate = catalog;
+	return typeof candidate.get === "function" || typeof candidate.list === "function";
+}
+/**
+* Resolve one model through the catalog chain, WITHOUT consulting the bundled
+* registry — callers own that fallback because each reader has a different
+* bundled shape (pi-ai `Model`, `CodexModel`, `ModelInfo`).
+*
+* `perCall` (an agent's / run's `behavior.modelCatalog`) shadows the global.
+*/
+function lookupModel(provider, modelId, perCall) {
+	for (const source of sourcesFor(perCall)) {
+		const entry = source.get?.(provider, modelId);
+		if (entry) return entry;
+	}
+}
+/**
+* Authoritative model list for a provider, or `undefined` when no catalog
+* claims ownership (the caller then uses the bundled list).
+*
+* Only the function form can claim ownership; table entries are overlaid via
+* {@link listModelOverlay} instead.
+*/
+function listModels(provider, perCall) {
+	for (const source of sourcesFor(perCall)) {
+		const list = source.list?.(provider);
+		if (list) return list;
+	}
+}
+/**
+* Table-form entries for one provider, to merge on top of a bundled list
+* (these win on id collision). Empty when no table-form catalog is active.
+*/
+function listModelOverlay(provider, perCall) {
+	const prefix = `${provider}:`;
+	const out = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const source of sourcesFor(perCall)) {
+		if (!source.table) continue;
+		for (const [key, entry] of Object.entries(source.table)) {
+			if (!key.startsWith(prefix)) continue;
+			const id = entry.id ?? key.slice(prefix.length);
+			if (seen.has(id)) continue;
+			seen.add(id);
+			out.push(entry.id ? entry : {
+				...entry,
+				id
+			});
+		}
+	}
+	return out;
+}
+/**
+* View of `catalog` that resolves a model under several provider ids, in
+* order — for providers whose metadata and pricing live under DIFFERENT
+* registry keys.
+*
+* The Codex provider is the case: model records come from `openai-codex`
+* while cost estimation runs under `openai`. Without this, one catalog entry
+* fixes the ceiling or the price but not both, depending on which key the
+* consumer guessed — and neither key is guessable.
+*
+* Returns `undefined` for an absent catalog so callers can pass it straight
+* through.
+*/
+function aliasCatalogProviders(catalog, providers) {
+	if (!catalog) return void 0;
+	return { get: (_provider, modelId) => {
+		for (const id of providers) {
+			const entry = lookupModel(id, modelId, catalog);
+			if (entry) return entry;
+		}
+	} };
+}
+/**
+* Overlay a catalog entry onto a bundled model record (pi-ai `Model`, the
+* chat layer's `ModelInfo`, …). Only fields the entry actually defines are
+* replaced, so a one-field override corrects that field and inherits the rest.
+*
+* `cost` merges per-rate rather than wholesale, so `{ cost: { output: 30 } }`
+* keeps the bundled input/cache rates instead of zeroing them.
+*
+* Kept here rather than at each reader so the merge semantics can't drift
+* between the wire path and the host layer.
+*/
+function mergeCatalogEntry(base, entry) {
+	if (!entry) return base;
+	const patch = {};
+	if (entry.id !== void 0) patch.id = entry.id;
+	if (entry.name !== void 0) patch.name = entry.name;
+	if (entry.maxTokens !== void 0) patch.maxTokens = entry.maxTokens;
+	if (entry.contextWindow !== void 0) patch.contextWindow = entry.contextWindow;
+	if (entry.reasoning !== void 0) patch.reasoning = entry.reasoning;
+	if (entry.input !== void 0) patch.input = entry.input;
+	if (entry.cost !== void 0) patch.cost = {
+		...base.cost,
+		...entry.cost
+	};
+	return {
+		...base,
+		...patch
+	};
+}
+/** Per-call source first (it shadows), then the process-wide one. */
+function sourcesFor(perCall) {
+	const out = [];
+	if (perCall) out.push(normalize(perCall));
+	if (holder.current) out.push(holder.current);
+	return out;
+}
+//#endregion
 //#region src/providers/cost.ts
 let getModelPromise;
 function loadGetModel() {
@@ -134,6 +282,11 @@ function loadGetModel() {
 * Per-MTok rates for models not yet in pi-ai's bundled registry. Keyed by
 * `provider:modelId`. Consulted only when pi-ai's `getModel` misses, so a
 * later dep bump that bundles the model transparently takes over.
+*
+* MAINTAINER-side stopgap only. Consumers with custom / gateway / private
+* models should install a catalog instead of sending PRs against this table:
+* `behavior.modelCatalog` per agent, or `setModelCatalog()` process-wide
+* (see `./model-catalog`) — both outrank the registry AND this table.
 */
 const EXTRA_COST_RATES = {
 	"anthropic:claude-opus-5": {
@@ -238,33 +391,53 @@ const EXTRA_COST_RATES = {
 * rate miss (unknown provider/model, or no published cache-write rate) —
 * better than fabricating a $0. An optional `multiplier` scales the base
 * rates for premium modes (e.g. Anthropic fast mode, 1h-TTL writes at 2x).
+*
+* `catalog` is caller-supplied because this helper has no run context to read
+* `behavior.modelCatalog` from: cache-break telemetry is computed by the host
+* that owns the `cache:break` hook, not by the loop. A host using a model
+* catalog must pass the same one here, or a re-bill estimate for an
+* override-only model comes back `undefined` while the per-turn cost is
+* priced correctly.
 */
-async function estimateRebilledCostUsd(provider, modelId, rebilledTokens, multiplier) {
-	if (!modelId || rebilledTokens <= 0) return void 0;
+/**
+* Rates for one model: catalog over pi-ai registry over local table.
+*
+* A catalog entry wins because it's an explicit claim about a model we may not
+* know (gateway alias, private deployment, post-pin release) — but it merges
+* PER-RATE over whatever the registry knows, matching `mergeCatalogEntry` and
+* the documented contract. Replacing the whole rate object would zero the rates
+* a partial entry doesn't mention, so `{ cost: { output: 30 } }` would bill
+* input and cache traffic at $0 — and the picker (which merges per-rate) would
+* disagree with the invoice.
+*/
+async function resolveRates(provider, modelId, catalog) {
+	const override = lookupModel(provider, modelId, catalog)?.cost;
 	const getModel = await loadGetModel();
-	let model;
+	let base;
 	if (getModel) try {
-		model = getModel(provider, modelId);
+		base = getModel(provider, modelId)?.cost;
 	} catch {
-		model = void 0;
+		base = void 0;
 	}
-	const rates = model?.cost ?? EXTRA_COST_RATES[`${provider}:${modelId}`];
+	base ??= EXTRA_COST_RATES[`${provider}:${modelId}`];
+	if (!override) return base;
+	return base ? {
+		...base,
+		...override
+	} : override;
+}
+async function estimateRebilledCostUsd(provider, modelId, rebilledTokens, multiplier, catalog) {
+	if (!modelId || rebilledTokens <= 0) return void 0;
+	const rates = await resolveRates(provider, modelId, catalog);
 	if (!rates || rates.cacheWrite === void 0) return void 0;
 	const write = rates.cacheWrite * (multiplier?.cacheWrite ?? 1);
 	const read = (rates.cacheRead ?? 0) * (multiplier?.cacheRead ?? 1);
 	return Math.max(0, (write - read) * rebilledTokens / 1e6);
 }
-async function fillEstimatedCost(usage, provider, multiplier) {
+async function fillEstimatedCost(usage, provider, multiplier, catalog) {
 	if (usage.cost !== void 0) return usage;
 	if (!usage.modelId) return usage;
-	const getModel = await loadGetModel();
-	let model;
-	if (getModel) try {
-		model = getModel(provider, usage.modelId);
-	} catch {
-		model = void 0;
-	}
-	const rates = model?.cost ?? EXTRA_COST_RATES[`${provider}:${usage.modelId}`];
+	const rates = await resolveRates(provider, usage.modelId, catalog);
 	if (!rates) return usage;
 	const mul = multiplier ?? {};
 	const total = ((rates.input ?? 0) * (mul.input ?? 1) * (usage.input ?? 0) + (rates.output ?? 0) * (mul.output ?? 1) * (usage.output ?? 0) + (rates.cacheRead ?? 0) * (mul.cacheRead ?? 1) * (usage.cacheRead ?? 0) + (rates.cacheWrite ?? 0) * (mul.cacheWrite ?? 1) * (usage.cacheCreation ?? 0)) / 1e6;
@@ -1838,7 +2011,7 @@ function openaiCompat(params) {
 				...usage.cost !== void 0 ? { cost: usage.cost } : {},
 				...finishReason ? { finishReason } : {},
 				modelId
-			}, name);
+			}, name, void 0, options.modelCatalog);
 			const toolCalls = result.toolCalls.map((call) => ({
 				...call,
 				name: nameBoundary.fromWire(call.name)
@@ -1854,6 +2027,6 @@ function openaiCompat(params) {
 	};
 }
 //#endregion
-export { estimateRebilledCostUsd as C, defaultPromptMessage as D, canonicalizePrompt as E, unsupportedMediaError as O, resolvePromptCacheKey as S, buildPromptMessage as T, userMessage as _, applyOAICacheBreakpoints as a, sanitizeToolSpecs as b, buildAssistantContent as c, formatTools as d, mapOAIFinishReason as f, toolResultsMessage as g, toOAIMessages as h, TOOL_RESULTS_TAG as i, classifyOpenAICompatError as l, openaiCompat as m, OpenAICompatHttpError as n, applyOAIToolCacheBreakpoint as o, openAICompatPromptMessage as p, OpenAICompatStreamError as r, assistantMessage as s, ASSISTANT_TOOL_CALLS_TAG as t, consumeSSE as u, createToolNameBoundary as v, fillEstimatedCost as w, derivePromptCacheKey as x, sanitizeToolSchema as y };
+export { mergeCatalogEntry as A, estimateRebilledCostUsd as C, listModelOverlay as D, getModelCatalog as E, unsupportedMediaError as F, buildPromptMessage as M, canonicalizePrompt as N, listModels as O, defaultPromptMessage as P, resolvePromptCacheKey as S, aliasCatalogProviders as T, userMessage as _, applyOAICacheBreakpoints as a, sanitizeToolSpecs as b, buildAssistantContent as c, formatTools as d, mapOAIFinishReason as f, toolResultsMessage as g, toOAIMessages as h, TOOL_RESULTS_TAG as i, setModelCatalog as j, lookupModel as k, classifyOpenAICompatError as l, openaiCompat as m, OpenAICompatHttpError as n, applyOAIToolCacheBreakpoint as o, openAICompatPromptMessage as p, OpenAICompatStreamError as r, assistantMessage as s, ASSISTANT_TOOL_CALLS_TAG as t, consumeSSE as u, createToolNameBoundary as v, fillEstimatedCost as w, derivePromptCacheKey as x, sanitizeToolSchema as y };
 
-//# sourceMappingURL=openai-compat-70-QNsmd.js.map
+//# sourceMappingURL=openai-compat-0MJq4-g9.js.map