fix(db): apply node-id boolean overrides to prefix-addressed models

PATCH stores a custom node's <prefix>/<model> target under the node id, so
the boolean capability lookup now maps a prefix back to its node id after
the direct match, like the compat-vision lookup. Value normalization and
the snapshot's nested boolean map move into small helpers to keep the
cognitive-complexity ratchet flat.

Refs #20127
This commit is contained in:
Rafa Martins
2026-11-18 21:45:14 -03:00
committed by diegosouzapw
parent a6caab4b86
commit 087c600d87
4 changed files with 95 additions and 37 deletions

View File

@@ -207,35 +207,42 @@ export function getReasoningEffortsOverride(
}
}
export function setModelCapabilityOverride(
target: string,
key: ModelCapabilityOverrideKey,
value: number | string | boolean | readonly string[]
): boolean {
const parsedTarget = parseModelOverrideTarget(target);
if (!parsedTarget || !isSupportedKey(key)) return false;
type OverrideInputValue = number | string | boolean | readonly string[];
type NormalizedOverrideValue = number | boolean | ReasoningEffortOverrideValue[];
let normalizedValue: number | boolean | ReasoningEffortOverrideValue[];
/** Accepts a boolean or its "true"/"false" string form (query-string style input). */
function normalizeBooleanValue(value: OverrideInputValue): boolean | null {
if (typeof value === "boolean") return value;
if (value === "true") return true;
if (value === "false") return false;
return null;
}
/** The value as stored for `key`, or null when it is not valid for that key. */
function normalizeOverrideValue(
key: ModelCapabilityOverrideKey,
value: OverrideInputValue
): NormalizedOverrideValue | null {
if (key === "reasoning_efforts") {
const parsed = Array.isArray(value)
? parseReasoningEffortsOverride(value.join(","))
: parseReasoningEffortsOverride(typeof value === "string" ? value : "");
if (!parsed.ok) return false;
normalizedValue = parsed.efforts;
} else if (isBooleanKey(key)) {
if (typeof value === "boolean") {
normalizedValue = value;
} else if (value === "true") {
normalizedValue = true;
} else if (value === "false") {
normalizedValue = false;
} else {
return false;
}
} else {
if (!isPositiveInteger(value)) return false;
normalizedValue = value;
return parsed.ok ? parsed.efforts : null;
}
if (isBooleanKey(key)) return normalizeBooleanValue(value);
return isPositiveInteger(value) ? value : null;
}
export function setModelCapabilityOverride(
target: string,
key: ModelCapabilityOverrideKey,
value: OverrideInputValue
): boolean {
const parsedTarget = parseModelOverrideTarget(target);
if (!parsedTarget || !isSupportedKey(key)) return false;
const normalizedValue = normalizeOverrideValue(key, value);
if (normalizedValue === null) return false;
getDbInstance()
.prepare(

View File

@@ -720,6 +720,14 @@ function getBooleanCapabilityOverride(
const bulk = snapshot?.booleanCapabilityOverrides ?? null;
const canonical = getBooleanModelCapabilityOverride(resolved.provider, resolved.model, key, bulk);
if (canonical !== null) return canonical;
// PATCH stores a custom node's `<prefix>/<model>` target under the node id, while a
// prefix-addressed lookup (the catalog alias) arrives with the prefix: map it back,
// after the direct match, as getCompatVisionOverride() does.
const nodeId = resolved.provider ? getProviderNodeIdByPrefixSync(resolved.provider) : null;
if (nodeId && nodeId !== resolved.provider) {
const mapped = getBooleanModelCapabilityOverride(nodeId, resolved.model, key, bulk);
if (mapped !== null) return mapped;
}
return resolved.rawModel && resolved.rawModel !== resolved.model
? getBooleanModelCapabilityOverride(resolved.provider, resolved.rawModel, key, bulk)
: null;

View File

@@ -81,6 +81,26 @@ function setNestedOverride(
byModel.set(modelId, value);
}
function setNestedBooleanOverride(
map: Map<string, Map<string, Map<BooleanModelCapabilityOverrideKey, boolean>>>,
provider: string,
modelId: string,
key: BooleanModelCapabilityOverrideKey,
value: boolean
): void {
let byModel = map.get(provider);
if (!byModel) {
byModel = new Map();
map.set(provider, byModel);
}
let byKey = byModel.get(modelId);
if (!byKey) {
byKey = new Map();
byModel.set(modelId, byKey);
}
byKey.set(key, value);
}
/**
* Load all capability/custom-model tables in one uninterrupted JS turn.
* Callers must not yield between the bulk reads if they need a coherent view;
@@ -113,20 +133,14 @@ export function createModelCapabilityResolutionSnapshot(
reasoningEffortsOverrides.set(entry.provider, byModel);
}
byModel.set(entry.modelId, entry.value);
} else if (isBooleanKey(entry.key)) {
let byModel = booleanCapabilityOverrides.get(entry.provider);
if (!byModel) {
byModel = new Map();
booleanCapabilityOverrides.set(entry.provider, byModel);
}
let byKey = byModel.get(entry.modelId);
if (!byKey) {
byKey = new Map();
byModel.set(entry.modelId, byKey);
}
if (typeof entry.value === "boolean") {
byKey.set(entry.key, entry.value);
}
} else if (isBooleanKey(entry.key) && typeof entry.value === "boolean") {
setNestedBooleanOverride(
booleanCapabilityOverrides,
entry.provider,
entry.modelId,
entry.key,
entry.value
);
}
}

View File

@@ -14,6 +14,7 @@ const caps = await import("../../src/lib/modelCapabilities.ts");
const overrides = await import("../../src/lib/db/modelCapabilityOverrides.ts");
const route = await import("../../src/app/api/model-capability-overrides/route.ts");
const snapshotMod = await import("../../src/lib/modelCapabilityResolutionSnapshot.ts");
const nodes = await import("../../src/lib/db/providers/nodes.ts");
beforeEach(() => {
coreDb.resetDbInstance();
@@ -123,6 +124,34 @@ describe("model capability boolean overrides (#20127)", () => {
);
});
it("applies an override stored under a custom node id to its prefix-addressed model", async () => {
const nodeId = "openai-compatible-chat-20127-0000-4000-8000-000000000001";
await nodes.createProviderNode({
id: nodeId,
type: "openai-compatible",
prefix: "boolproxy",
name: "BoolProxy",
apiType: "chat",
baseUrl: "https://example.com/v1",
});
const res = await patchOverride("boolproxy/demo-model", "structured_output", false);
assert.equal(res.status, 200);
assert.equal(overrides.listModelCapabilityOverrides()[0]?.provider, nodeId);
const viaPrefix = { provider: "boolproxy", model: "demo-model" };
assert.equal(caps.getResolvedModelCapabilities(viaPrefix).structuredOutput, false);
const snapshot = snapshotMod.createModelCapabilityResolutionSnapshot();
assert.equal(
caps.getResolvedModelCapabilities(viaPrefix, undefined, snapshot).structuredOutput,
false
);
assert.equal(
caps.getResolvedModelCapabilities({ provider: nodeId, model: "demo-model" }).structuredOutput,
false
);
});
it("maintains parity between direct runtime resolution and snapshot bulk resolution", () => {
const target = "codex/gpt-5.6";
overrides.setModelCapabilityOverride(target, "structured_output", true);