@oh-my-pi/pi-catalog 18.2.4 → 18.2.6

package/src/compat/taxonomy.ts

@@ -201,28 +201,60 @@ function ranksInClass(classId: string, model: string, lenient: boolean): Omit<Cl
 	return out;
 }
 
-function findIdentityOverride(
-	provider: string,
-	bareModel: string,
-	observedAtMs: number | undefined,
-): CompiledIdentityOverride | undefined {
-	const lowerModel = bareModel.toLowerCase();
-	const lowerProvider = provider.toLowerCase();
-	let agnostic: CompiledIdentityOverride | undefined;
+// Lowercase override index built once per process: avoids re-lowercasing every
+// override model/provider string on every classifyModel call. First override
+// in tree order wins per (model, provider) slot, matching the linear scan it
+// replaced.
+interface OverrideBucket {
+	byProvider: Map<string, CompiledIdentityOverride>;
+	agnostic: CompiledIdentityOverride | undefined;
+}
+
+let overrideIndex: Map<string, OverrideBucket> | undefined;
+
+function getOverrideIndex(): Map<string, OverrideBucket> {
+	if (overrideIndex !== undefined) return overrideIndex;
+	const index = new Map<string, OverrideBucket>();
 	for (const cls of rules.taxonomy.classes) {
 		for (const override of cls.overrides) {
-			if (override.model.toLowerCase() !== lowerModel) continue;
-			if (override.expiresAtMs !== undefined && observedAtMs !== undefined && observedAtMs >= override.expiresAtMs) {
-				continue;
+			const key = override.model.toLowerCase();
+			let bucket = index.get(key);
+			if (bucket === undefined) {
+				bucket = { byProvider: new Map(), agnostic: undefined };
+				index.set(key, bucket);
 			}
 			if (override.provider !== undefined) {
-				if (override.provider.toLowerCase() === lowerProvider) return override;
+				const providerKey = override.provider.toLowerCase();
+				if (!bucket.byProvider.has(providerKey)) bucket.byProvider.set(providerKey, override);
 			} else {
-				agnostic ??= override;
+				bucket.agnostic ??= override;
 			}
 		}
 	}
-	return agnostic;
+	overrideIndex = index;
+	return index;
+}
+
+function findIdentityOverride(
+	provider: string,
+	bareModel: string,
+	observedAtMs: number | undefined,
+): CompiledIdentityOverride | undefined {
+	const bucket = getOverrideIndex().get(bareModel.toLowerCase());
+	if (bucket === undefined) return undefined;
+	const scoped = bucket.byProvider.get(provider.toLowerCase());
+	if (scoped !== undefined) {
+		if (scoped.expiresAtMs === undefined || observedAtMs === undefined || observedAtMs < scoped.expiresAtMs) {
+			return scoped;
+		}
+	}
+	const agnostic = bucket.agnostic;
+	if (agnostic !== undefined) {
+		if (agnostic.expiresAtMs === undefined || observedAtMs === undefined || observedAtMs < agnostic.expiresAtMs) {
+			return agnostic;
+		}
+	}
+	return undefined;
 }
 
 /** Result of collapsing a wire id through the suffix vocabulary. */
@@ -330,10 +362,37 @@ export function stripThinkingVariantSuffix(model: string): string | undefined {
  * Classifies a model into its structured identity: reviewed override first,
  * then suffix collapse, then class/family/revision ranks over the logical id.
  *
+ * Results are memoized per (provider, model, lenient) — the rule tree is
+ * static per process. Cached identities are frozen and each caller receives
+ * a shallow copy, so a consumer that mutates its copy (e.g. `buildModel`
+ * storing `policy.identity` on the model) cannot poison the cache or any
+ * other model classified under the same key. Calls with an explicit
+ * observedAtMs skip the memo so override expiry stays exact.
+ *
  * @throws AmbiguousIdentityError on equal-rank cross-class or cross-family
  * matches unless `opts.lenient`.
  */
+const classifyMemo = new Map<string, ModelIdentity>();
+const CLASSIFY_MEMO_MAX = 4096;
+
+function classifyMemoKey(provider: string, modelId: string, lenient: boolean): string {
+	return `${provider.length}:${provider}${modelId.length}:${modelId}${lenient ? 1 : 0}`;
+}
+
 export function classifyModel(provider: string, modelId: string, opts?: ClassifyOptions): ModelIdentity {
+	if (opts?.observedAtMs === undefined) {
+		const key = classifyMemoKey(provider, modelId, opts?.lenient === true);
+		const cached = classifyMemo.get(key);
+		if (cached !== undefined) return { ...cached };
+		const identity = classifyModelUncached(provider, modelId, opts);
+		if (classifyMemo.size >= CLASSIFY_MEMO_MAX) classifyMemo.clear();
+		classifyMemo.set(key, Object.freeze(identity));
+		return { ...identity };
+	}
+	return classifyModelUncached(provider, modelId, opts);
+}
+
+function classifyModelUncached(provider: string, modelId: string, opts?: ClassifyOptions): ModelIdentity {
 	const lenient = opts?.lenient === true;
 	const trimmed = modelId.trim();
 	const bare = bareOf(trimmed);

package/src/compat/types.ts

@@ -456,6 +456,10 @@ export interface CompiledOAuthCodeLogin {
 	kind: "oauth-code";
 	clientId?: CompiledAuthValue;
 	clientSecret?: CompiledAuthValue;
+	/** `{base}` placeholder source (the provider's API origin). */
+	baseUrl?: CompiledAuthValue;
+	/** `{auth}` placeholder source for the authorize, token, and userinfo URLs when the issuer is a separate host. */
+	authUrl?: CompiledAuthValue;
 	authorizeUrl: CompiledAuthValue;
 	scopes: string[];
 	scopeSeparator: string;

package/src/discovery/gemini.ts

@@ -8,15 +8,20 @@ const GOOGLE_GENERATIVE_AI_BASE_URL = "https://generativelanguage.googleapis.com
 const DEFAULT_PAGE_SIZE = 100;
 const DEFAULT_MAX_PAGES = 25;
 
+// Hoisted: constructing type("string")/type("number") per property per row
+// builds a fresh schema (~2 closures + 13 slots) on a discovery hot path.
+const stringSchema = type("string");
+const numberSchema = type("number");
+
 const resilientString = type("unknown").pipe(val => {
 	if (val === undefined) return undefined;
-	const out = type("string")(val);
+	const out = stringSchema(val);
 	return out instanceof type.errors ? undefined : out;
 });
 
 const resilientNumber = type("unknown").pipe(val => {
 	if (val === undefined) return undefined;
-	const out = type("number")(val);
+	const out = numberSchema(val);
 	return out instanceof type.errors ? undefined : out;
 });
 

package/src/discovery/gitlab-duo-workflow.ts

@@ -53,15 +53,19 @@ const ProjectRootNamespaceQuery = `query omp_gitlabDuoWorkflowProjectRootNamespa
   }
 }`;
 
+// Hoisted: per-element schema construction on a discovery hot path.
+const stringSchema = type("string");
+const unknownArraySchema = type("unknown[]");
+
 const resilientString = type("unknown").pipe(value => {
 	if (value === undefined) return undefined;
-	const parsed = type("string")(value);
+	const parsed = stringSchema(value);
 	return parsed instanceof type.errors ? undefined : parsed;
 });
 
 const resilientUnknownArray = type("unknown").pipe(value => {
 	if (value === undefined || value === null) return value;
-	const parsed = type("unknown[]")(value);
+	const parsed = unknownArraySchema(value);
 	return parsed instanceof type.errors ? [] : parsed;
 });
 

package/src/model-tokenizer.ts

@@ -52,10 +52,14 @@ function glmTokenizer(identity: ModelIdentity): ModelTokenizer | undefined {
  * This is catalog policy, not a runtime caller heuristic: [`buildModel`](./build.ts)
  * materializes the result as `Model.tokenizer`; consumers read that property.
  */
-export function resolveModelTokenizer(modelId: string): ModelTokenizer | undefined {
-	const cached = modelTokenizerCache.get(modelId);
+export function resolveModelTokenizer(modelId: string, provider = ""): ModelTokenizer | undefined {
+	const cacheKey = `${provider}\0${modelId}`;
+	const cached = modelTokenizerCache.get(cacheKey);
 	if (cached !== undefined) return cached ?? undefined;
-	const identity = classifyModel("", bareModelId(modelId), { lenient: true });
+	// Provider-scoped identity overrides (e.g. Yolo-Auto's `yolo` alias for
+	// Qwen3.8 Flash) only apply when the provider is known; bare ids stay
+	// provider-agnostic so unrelated namespaces never inherit them.
+	const identity = classifyModel(provider, bareModelId(modelId), { lenient: true });
 	const tokenizer =
 		claudeTokenizer(identity) ??
 		qwenTokenizer(identity) ??
@@ -63,6 +67,6 @@ export function resolveModelTokenizer(modelId: string): ModelTokenizer | undefin
 		kimiTokenizer(identity) ??
 		glmTokenizer(identity);
 	if (modelTokenizerCache.size === MAX_TOKENIZER_CACHE_ENTRIES) modelTokenizerCache.clear();
-	modelTokenizerCache.set(modelId, tokenizer ?? null);
+	modelTokenizerCache.set(cacheKey, tokenizer ?? null);
 	return tokenizer;
 }