@slkiser/opencode-quota 4.0.0 → 4.1.0

package/dist/lib/quota-providers.js

@@ -2,7 +2,7 @@ import { isIP } from "node:net";
 import { getQuotaProviderShape } from "./provider-metadata.js";
 import { lookupCost } from "./modelsdev-pricing.js";
 import { resolvePricingKey } from "./quota-stats.js";
-export const QUOTA_PROVIDER_REMOTE_FORMATS = ["accounting-v1", "openrouter-key-v1"];
+export const QUOTA_PROVIDER_REMOTE_FORMATS = ["quota-v1", "openrouter-key-v1", "json-v1"];
 export const QUOTA_PROVIDER_MODES = ["remote-api", "local-estimate"];
 export const QUOTA_PROVIDER_WINDOW_TYPES = ["utc-day", "rolling"];
 export const QUOTA_PROVIDERS_AGGREGATE_ID = "quota-providers";
@@ -46,7 +46,7 @@ export function selectEligibleQuotaProviderDefinitions(params) {
         (definition.modelIds === undefined || definition.modelIds.includes(identity.modelId)));
 }
 const BASE_FIELDS = ["id", "providerId", "label", "mode", "modelIds"];
-const REMOTE_FIELDS = [...BASE_FIELDS, "url", "format", "apiKeyEnv"];
+const REMOTE_FIELDS = [...BASE_FIELDS, "url", "format", "apiKeyEnv", "adapter"];
 const LOCAL_FIELDS = [...BASE_FIELDS, "windows", "pricingModelMap"];
 const WINDOW_FIELDS = [
     "id",
@@ -60,6 +60,7 @@ const ID_PATTERN = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
 const PROVIDER_ID_PATTERN = /^[a-z0-9][a-z0-9._-]*$/;
 const ENV_NAME_PATTERN = /^[A-Z_][A-Z0-9_]*$/;
 const ASCII_OR_UNICODE_CONTROL_PATTERN = /\p{Cc}/u;
+const JSON_V1_STATIC_DISPLAY_FORBIDDEN_PATTERN = /[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]/u;
 const URL_WHITESPACE_OR_CONTROL_PATTERN = /[\s\p{Cc}]/u;
 const MODEL_FORBIDDEN_PATTERN = /[\s\p{Cc}#?]/u;
 const MAX_ID_LENGTH = 64;
@@ -70,6 +71,35 @@ const MAX_WINDOWS = 16;
 const MAX_ROLLING_MINUTES = 366 * 24 * 60;
 const MAX_SAFE_REQUEST_LIMIT = 1_000_000_000;
 const MAX_USD_BUDGET = 1_000_000_000;
+export const JSON_V1_MAX_MAPPINGS = 16;
+export const JSON_V1_MAX_ADAPTER_DEPTH = 8;
+export const JSON_V1_MAX_ADAPTER_OBJECTS = 128;
+export const JSON_V1_MAX_ADAPTER_PROPERTIES = 384;
+export const JSON_V1_MAX_ADAPTER_ARRAY_ELEMENTS = 640;
+export const JSON_V1_MAX_PATH_SEGMENTS = 8;
+export const JSON_V1_MAX_PATH_SEGMENT_CODE_POINTS = 64;
+export const JSON_V1_MAX_STATIC_NAME_CODE_POINTS = 80;
+export const JSON_V1_MAX_STATIC_UNIT_CODE_POINTS = 32;
+export const JSON_V1_MAX_DISPLAY_CODE_POINTS = 160;
+export const JSON_V1_MAX_NUMBER_MAGNITUDE = 1e15;
+const JSON_V1_FORBIDDEN_PATH_SEGMENTS = new Set(["__proto__", "prototype", "constructor"]);
+const JSON_V1_DIVISORS = new Set([100, 1_000, 1_000_000]);
+const JSON_V1_TIMESTAMP_ENCODINGS = new Set([
+    "iso-8601",
+    "unix-seconds",
+    "unix-milliseconds",
+]);
+const JSON_V1_RESULT_TYPES = new Set([
+    "quota",
+    "rate_limit",
+    "usage",
+    "spend",
+    "budget",
+    "balance",
+    "status",
+]);
+const JSON_V1_MIN_TIMESTAMP_MS = 0;
+const JSON_V1_MAX_TIMESTAMP_MS = 253_402_300_799_999;
 function isPlainObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -151,10 +181,16 @@ function normalizeRemoteUrl(value) {
 }
 function cloneDefinition(definition) {
     if (definition.mode === "remote-api") {
-        return {
-            ...definition,
-            ...(definition.modelIds ? { modelIds: [...definition.modelIds] } : {}),
-        };
+        return definition.format === "json-v1"
+            ? {
+                ...definition,
+                ...(definition.modelIds ? { modelIds: [...definition.modelIds] } : {}),
+                adapter: structuredClone(definition.adapter),
+            }
+            : {
+                ...definition,
+                ...(definition.modelIds ? { modelIds: [...definition.modelIds] } : {}),
+            };
     }
     return {
         ...definition,
@@ -163,6 +199,487 @@ function cloneDefinition(definition) {
         ...(definition.pricingModelMap ? { pricingModelMap: { ...definition.pricingModelMap } } : {}),
     };
 }
+function adapterIssue(issues, key, message) {
+    issues.push({ key, message });
+}
+function validateKnownAdapterFields(value, allowed, key, issues) {
+    if (Object.keys(value).some((field) => !allowed.includes(field))) {
+        adapterIssue(issues, `${key}.*`, `unknown field; allowed fields are ${allowed.join(", ")}`);
+    }
+}
+function preflightJsonV1Adapter(value, key, issues) {
+    const stack = [{ value, depth: 1 }];
+    const seen = new WeakSet();
+    let objects = 0;
+    let properties = 0;
+    let arrayElements = 0;
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (!current.value || typeof current.value !== "object")
+            continue;
+        if (seen.has(current.value)) {
+            adapterIssue(issues, key, "expected a bounded JSON object tree");
+            return false;
+        }
+        seen.add(current.value);
+        if (current.depth > JSON_V1_MAX_ADAPTER_DEPTH) {
+            adapterIssue(issues, key, `must not exceed nesting depth ${JSON_V1_MAX_ADAPTER_DEPTH}`);
+            return false;
+        }
+        if (Array.isArray(current.value)) {
+            arrayElements += current.value.length;
+            if (arrayElements > JSON_V1_MAX_ADAPTER_ARRAY_ELEMENTS) {
+                adapterIssue(issues, key, `must not exceed ${JSON_V1_MAX_ADAPTER_ARRAY_ELEMENTS} total array elements`);
+                return false;
+            }
+            for (let index = current.value.length - 1; index >= 0; index -= 1) {
+                stack.push({ value: current.value[index], depth: current.depth + 1 });
+            }
+            continue;
+        }
+        objects += 1;
+        const keys = Object.keys(current.value);
+        properties += keys.length;
+        if (objects > JSON_V1_MAX_ADAPTER_OBJECTS) {
+            adapterIssue(issues, key, `must not exceed ${JSON_V1_MAX_ADAPTER_OBJECTS} objects`);
+            return false;
+        }
+        if (properties > JSON_V1_MAX_ADAPTER_PROPERTIES) {
+            adapterIssue(issues, key, `must not exceed ${JSON_V1_MAX_ADAPTER_PROPERTIES} object properties`);
+            return false;
+        }
+        const record = current.value;
+        for (let index = keys.length - 1; index >= 0; index -= 1) {
+            stack.push({ value: record[keys[index]], depth: current.depth + 1 });
+        }
+    }
+    return true;
+}
+function normalizeJsonV1StaticText(value, maxCodePoints) {
+    if (typeof value !== "string" || JSON_V1_STATIC_DISPLAY_FORBIDDEN_PATTERN.test(value))
+        return null;
+    const normalized = value.trim();
+    const length = Array.from(normalized).length;
+    return length >= 1 && length <= maxCodePoints ? normalized : null;
+}
+function validateJsonV1Path(value, key, issues) {
+    if (!Array.isArray(value) || value.length < 1 || value.length > JSON_V1_MAX_PATH_SEGMENTS) {
+        adapterIssue(issues, key, `expected an array containing 1-${JSON_V1_MAX_PATH_SEGMENTS} path segments`);
+        return undefined;
+    }
+    const path = [];
+    for (let index = 0; index < value.length; index += 1) {
+        const segment = value[index];
+        if (typeof segment !== "string" ||
+            Array.from(segment).length < 1 ||
+            Array.from(segment).length > JSON_V1_MAX_PATH_SEGMENT_CODE_POINTS ||
+            ASCII_OR_UNICODE_CONTROL_PATTERN.test(segment) ||
+            JSON_V1_FORBIDDEN_PATH_SEGMENTS.has(segment)) {
+            adapterIssue(issues, `${key}[${index}]`, "expected a safe 1-64 code point property segment");
+            continue;
+        }
+        path.push(segment);
+    }
+    return path.length === value.length ? path : undefined;
+}
+const JSON_V1_ISO_RE = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.(\d{1,3}))?(Z|([+-])(\d{2}):(\d{2}))$/;
+function daysInMonth(year, month) {
+    if (month === 2) {
+        return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0) ? 29 : 28;
+    }
+    return [4, 6, 9, 11].includes(month) ? 30 : 31;
+}
+export function normalizeJsonV1Timestamp(value, encoding) {
+    let milliseconds;
+    if (encoding === "iso-8601") {
+        if (typeof value !== "string")
+            return null;
+        const match = JSON_V1_ISO_RE.exec(value);
+        if (!match)
+            return null;
+        const year = Number(match[1]);
+        const month = Number(match[2]);
+        const day = Number(match[3]);
+        const hour = Number(match[4]);
+        const minute = Number(match[5]);
+        const second = Number(match[6]);
+        const fraction = (match[7] ?? "").padEnd(3, "0");
+        const offsetHour = match[8] === "Z" ? 0 : Number(match[10]);
+        const offsetMinute = match[8] === "Z" ? 0 : Number(match[11]);
+        if (year < 1970 ||
+            month < 1 ||
+            month > 12 ||
+            day < 1 ||
+            day > daysInMonth(year, month) ||
+            hour > 23 ||
+            minute > 59 ||
+            second > 59 ||
+            offsetHour > 14 ||
+            offsetMinute > 59 ||
+            (offsetHour === 14 && offsetMinute !== 0)) {
+            return null;
+        }
+        const offset = match[8] === "Z"
+            ? 0
+            : (match[9] === "+" ? 1 : -1) * (offsetHour * 60 + offsetMinute) * 60_000;
+        milliseconds = Date.UTC(year, month - 1, day, hour, minute, second, Number(fraction)) - offset;
+    }
+    else {
+        if (typeof value !== "number" || !Number.isFinite(value) || !Number.isInteger(value)) {
+            return null;
+        }
+        milliseconds = encoding === "unix-seconds" ? value * 1_000 : value;
+    }
+    if (!Number.isSafeInteger(milliseconds) ||
+        milliseconds < JSON_V1_MIN_TIMESTAMP_MS ||
+        milliseconds > JSON_V1_MAX_TIMESTAMP_MS) {
+        return null;
+    }
+    return new Date(milliseconds).toISOString();
+}
+function validateJsonV1NumberSource(value, key, issues) {
+    if (!isPlainObject(value)) {
+        adapterIssue(issues, key, "expected a path or literal number source object");
+        return undefined;
+    }
+    const hasPath = hasOwnKey(value, "path");
+    const hasLiteral = hasOwnKey(value, "literal");
+    if (hasPath === hasLiteral) {
+        adapterIssue(issues, key, "expected exactly one of path or literal");
+        return undefined;
+    }
+    if (hasPath) {
+        validateKnownAdapterFields(value, ["path", "divideBy"], key, issues);
+        const path = validateJsonV1Path(value.path, `${key}.path`, issues);
+        if (hasOwnKey(value, "divideBy") &&
+            (typeof value.divideBy !== "number" || !JSON_V1_DIVISORS.has(value.divideBy))) {
+            adapterIssue(issues, `${key}.divideBy`, "expected 100, 1000, or 1000000");
+        }
+        if (path &&
+            (!hasOwnKey(value, "divideBy") ||
+                (typeof value.divideBy === "number" && JSON_V1_DIVISORS.has(value.divideBy)))) {
+            return {
+                path,
+                ...(value.divideBy !== undefined
+                    ? { divideBy: value.divideBy }
+                    : {}),
+            };
+        }
+        return undefined;
+    }
+    validateKnownAdapterFields(value, ["literal"], key, issues);
+    if (typeof value.literal !== "number" ||
+        !Number.isFinite(value.literal) ||
+        Math.abs(value.literal) > JSON_V1_MAX_NUMBER_MAGNITUDE) {
+        adapterIssue(issues, `${key}.literal`, `expected a finite number with absolute magnitude at most ${JSON_V1_MAX_NUMBER_MAGNITUDE}`);
+        return undefined;
+    }
+    return { literal: value.literal };
+}
+function validateJsonV1TextSource(value, key, issues) {
+    if (!isPlainObject(value)) {
+        adapterIssue(issues, key, "expected a path or literal text source object");
+        return undefined;
+    }
+    const hasPath = hasOwnKey(value, "path");
+    const hasLiteral = hasOwnKey(value, "literal");
+    if (hasPath === hasLiteral) {
+        adapterIssue(issues, key, "expected exactly one of path or literal");
+        return undefined;
+    }
+    validateKnownAdapterFields(value, hasPath ? ["path"] : ["literal"], key, issues);
+    if (hasPath) {
+        const path = validateJsonV1Path(value.path, `${key}.path`, issues);
+        return path ? { path } : undefined;
+    }
+    const literal = normalizeJsonV1StaticText(value.literal, JSON_V1_MAX_DISPLAY_CODE_POINTS);
+    if (!literal) {
+        adapterIssue(issues, `${key}.literal`, `expected 1-${JSON_V1_MAX_DISPLAY_CODE_POINTS} printable Unicode code points after trimming`);
+        return undefined;
+    }
+    return { literal };
+}
+function validateJsonV1TimestampSource(value, key, issues) {
+    if (!isPlainObject(value)) {
+        adapterIssue(issues, key, "expected a timestamp source object");
+        return undefined;
+    }
+    const hasPath = hasOwnKey(value, "path");
+    const hasLiteral = hasOwnKey(value, "literal");
+    if (hasPath === hasLiteral) {
+        adapterIssue(issues, key, "expected exactly one of path or literal");
+        return undefined;
+    }
+    validateKnownAdapterFields(value, hasPath ? ["path", "encoding"] : ["literal", "encoding"], key, issues);
+    const encoding = value.encoding;
+    if (typeof encoding !== "string" ||
+        !JSON_V1_TIMESTAMP_ENCODINGS.has(encoding)) {
+        adapterIssue(issues, `${key}.encoding`, 'expected "iso-8601", "unix-seconds", or "unix-milliseconds"');
+        return undefined;
+    }
+    const typedEncoding = encoding;
+    if (hasPath) {
+        const path = validateJsonV1Path(value.path, `${key}.path`, issues);
+        return path ? { path, encoding: typedEncoding } : undefined;
+    }
+    if (normalizeJsonV1Timestamp(value.literal, typedEncoding) === null) {
+        adapterIssue(issues, `${key}.literal`, "expected a valid timestamp for the selected encoding");
+        return undefined;
+    }
+    return { literal: value.literal, encoding: typedEncoding };
+}
+function literalNumber(source) {
+    return source && "literal" in source ? source.literal : undefined;
+}
+function requireLiteralNumber(source, key, issues, rule) {
+    const value = literalNumber(source);
+    if (value === undefined)
+        return;
+    if ((rule === "positive" && value <= 0) || (rule === "non-negative" && value < 0)) {
+        adapterIssue(issues, `${key}.literal`, rule === "positive"
+            ? "expected a number greater than zero"
+            : "expected a non-negative number");
+    }
+}
+function validateJsonV1Metric(value, resultType, key, issues) {
+    if (!isPlainObject(value)) {
+        adapterIssue(issues, key, "expected a tagged metric object");
+        return undefined;
+    }
+    if (typeof value.type !== "string") {
+        adapterIssue(issues, `${key}.type`, "field is required");
+        return undefined;
+    }
+    const issueStart = issues.length;
+    switch (value.type) {
+        case "percentage": {
+            validateKnownAdapterFields(value, ["type", "percentage", "meaning"], key, issues);
+            const percentage = validateJsonV1NumberSource(value.percentage, `${key}.percentage`, issues);
+            if (value.meaning !== "remaining" && value.meaning !== "used") {
+                adapterIssue(issues, `${key}.meaning`, 'expected "remaining" or "used"');
+            }
+            if (resultType && !["quota", "rate_limit", "budget"].includes(resultType)) {
+                adapterIssue(issues, `${key}.type`, "percentage is incompatible with resultType");
+            }
+            const literal = literalNumber(percentage);
+            if (literal !== undefined &&
+                ((value.meaning === "remaining" && literal > 100) ||
+                    (value.meaning === "used" && literal < 0))) {
+                adapterIssue(issues, `${key}.percentage.literal`, value.meaning === "remaining"
+                    ? "remaining percentage must not exceed 100"
+                    : "used percentage must be non-negative");
+            }
+            return issueStart === issues.length && percentage
+                ? { type: "percentage", percentage, meaning: value.meaning }
+                : undefined;
+        }
+        case "used-limit": {
+            validateKnownAdapterFields(value, ["type", "used", "limit"], key, issues);
+            const used = validateJsonV1NumberSource(value.used, `${key}.used`, issues);
+            const limit = validateJsonV1NumberSource(value.limit, `${key}.limit`, issues);
+            requireLiteralNumber(used, `${key}.used`, issues, "non-negative");
+            requireLiteralNumber(limit, `${key}.limit`, issues, "positive");
+            if (resultType && !["quota", "rate_limit"].includes(resultType)) {
+                adapterIssue(issues, `${key}.type`, "used-limit is incompatible with resultType");
+            }
+            return issueStart === issues.length && used && limit
+                ? { type: "used-limit", used, limit }
+                : undefined;
+        }
+        case "remaining-limit": {
+            validateKnownAdapterFields(value, ["type", "remaining", "limit"], key, issues);
+            const remaining = validateJsonV1NumberSource(value.remaining, `${key}.remaining`, issues);
+            const limit = validateJsonV1NumberSource(value.limit, `${key}.limit`, issues);
+            requireLiteralNumber(limit, `${key}.limit`, issues, "positive");
+            const remainingLiteral = literalNumber(remaining);
+            const limitLiteral = literalNumber(limit);
+            if (remainingLiteral !== undefined &&
+                limitLiteral !== undefined &&
+                remainingLiteral > limitLiteral) {
+                adapterIssue(issues, `${key}.remaining.literal`, "remaining must not exceed limit");
+            }
+            if (resultType && !["quota", "rate_limit"].includes(resultType)) {
+                adapterIssue(issues, `${key}.type`, "remaining-limit is incompatible with resultType");
+            }
+            return issueStart === issues.length && remaining && limit
+                ? { type: "remaining-limit", remaining, limit }
+                : undefined;
+        }
+        case "spend-budget": {
+            validateKnownAdapterFields(value, ["type", "spend", "budget"], key, issues);
+            const spend = validateJsonV1NumberSource(value.spend, `${key}.spend`, issues);
+            const budget = validateJsonV1NumberSource(value.budget, `${key}.budget`, issues);
+            requireLiteralNumber(spend, `${key}.spend`, issues, "non-negative");
+            requireLiteralNumber(budget, `${key}.budget`, issues, "positive");
+            if (resultType && resultType !== "budget") {
+                adapterIssue(issues, `${key}.type`, "spend-budget is incompatible with resultType");
+            }
+            return issueStart === issues.length && spend && budget
+                ? { type: "spend-budget", spend, budget }
+                : undefined;
+        }
+        case "remaining-budget": {
+            validateKnownAdapterFields(value, ["type", "remaining", "budget"], key, issues);
+            const remaining = validateJsonV1NumberSource(value.remaining, `${key}.remaining`, issues);
+            const budget = validateJsonV1NumberSource(value.budget, `${key}.budget`, issues);
+            requireLiteralNumber(budget, `${key}.budget`, issues, "positive");
+            const remainingLiteral = literalNumber(remaining);
+            const budgetLiteral = literalNumber(budget);
+            if (remainingLiteral !== undefined &&
+                budgetLiteral !== undefined &&
+                remainingLiteral > budgetLiteral) {
+                adapterIssue(issues, `${key}.remaining.literal`, "remaining must not exceed budget");
+            }
+            if (resultType && resultType !== "budget") {
+                adapterIssue(issues, `${key}.type`, "remaining-budget is incompatible with resultType");
+            }
+            return issueStart === issues.length && remaining && budget
+                ? { type: "remaining-budget", remaining, budget }
+                : undefined;
+        }
+        case "value": {
+            validateKnownAdapterFields(value, ["type", "valueType", "value"], key, issues);
+            const source = validateJsonV1NumberSource(value.value, `${key}.value`, issues);
+            const allowed = {
+                used: ["quota", "rate_limit", "usage"],
+                limit: ["quota", "rate_limit"],
+                remaining: ["quota", "rate_limit"],
+                balance: ["balance"],
+                spend: ["spend"],
+                budget: ["budget"],
+            };
+            if (typeof value.valueType !== "string" || !hasOwnKey(allowed, value.valueType)) {
+                adapterIssue(issues, `${key}.valueType`, 'expected "used", "limit", "remaining", "balance", "spend", or "budget"');
+            }
+            else {
+                if (!["remaining", "balance"].includes(value.valueType)) {
+                    requireLiteralNumber(source, `${key}.value`, issues, "non-negative");
+                }
+                if (resultType && !allowed[value.valueType].includes(resultType)) {
+                    adapterIssue(issues, `${key}.valueType`, "valueType is incompatible with resultType");
+                }
+            }
+            return issueStart === issues.length && source
+                ? {
+                    type: "value",
+                    valueType: value.valueType,
+                    value: source,
+                }
+                : undefined;
+        }
+        case "status": {
+            validateKnownAdapterFields(value, ["type", "value"], key, issues);
+            const source = validateJsonV1TextSource(value.value, `${key}.value`, issues);
+            if (resultType && resultType !== "status") {
+                adapterIssue(issues, `${key}.type`, "status is incompatible with resultType");
+            }
+            return issueStart === issues.length && source ? { type: "status", value: source } : undefined;
+        }
+        default:
+            adapterIssue(issues, `${key}.type`, "expected a supported tagged metric type");
+            return undefined;
+    }
+}
+function validateJsonV1Mapping(value, key, providerLabel, issues) {
+    if (!isPlainObject(value)) {
+        adapterIssue(issues, key, "expected an object");
+        return undefined;
+    }
+    const issueStart = issues.length;
+    validateKnownAdapterFields(value, ["resultType", "name", "label", "unit", "unitPosition", "resetTime", "observedTime", "metric"], key, issues);
+    for (const field of ["resultType", "name", "metric"]) {
+        if (!hasOwnKey(value, field))
+            adapterIssue(issues, `${key}.${field}`, "field is required");
+    }
+    const resultType = typeof value.resultType === "string" &&
+        JSON_V1_RESULT_TYPES.has(value.resultType)
+        ? value.resultType
+        : undefined;
+    if (hasOwnKey(value, "resultType") && !resultType) {
+        adapterIssue(issues, `${key}.resultType`, "expected a supported accounting result type");
+    }
+    const name = normalizeJsonV1StaticText(value.name, JSON_V1_MAX_STATIC_NAME_CODE_POINTS);
+    if (hasOwnKey(value, "name") && !name) {
+        adapterIssue(issues, `${key}.name`, `expected 1-${JSON_V1_MAX_STATIC_NAME_CODE_POINTS} printable Unicode code points after trimming`);
+    }
+    else if (name &&
+        Array.from(`${providerLabel} ${name}`).length > JSON_V1_MAX_DISPLAY_CODE_POINTS) {
+        adapterIssue(issues, `${key}.name`, `provider-prefixed name must not exceed ${JSON_V1_MAX_DISPLAY_CODE_POINTS} code points`);
+    }
+    const label = value.label === undefined
+        ? undefined
+        : normalizeJsonV1StaticText(value.label, JSON_V1_MAX_STATIC_NAME_CODE_POINTS);
+    if (value.label !== undefined && !label) {
+        adapterIssue(issues, `${key}.label`, `expected 1-${JSON_V1_MAX_STATIC_NAME_CODE_POINTS} printable Unicode code points after trimming`);
+    }
+    const unit = value.unit === undefined
+        ? undefined
+        : normalizeJsonV1StaticText(value.unit, JSON_V1_MAX_STATIC_UNIT_CODE_POINTS);
+    if (value.unit !== undefined && !unit) {
+        adapterIssue(issues, `${key}.unit`, `expected 1-${JSON_V1_MAX_STATIC_UNIT_CODE_POINTS} printable Unicode code points after trimming`);
+    }
+    const unitPosition = value.unitPosition === "prefix" || value.unitPosition === "suffix"
+        ? value.unitPosition
+        : undefined;
+    if (value.unitPosition !== undefined && !unitPosition) {
+        adapterIssue(issues, `${key}.unitPosition`, 'expected "prefix" or "suffix"');
+    }
+    if ((unit === undefined) !== (unitPosition === undefined)) {
+        adapterIssue(issues, `${key}.unitPosition`, "unit and unitPosition must be configured together");
+    }
+    const resetTime = value.resetTime === undefined
+        ? undefined
+        : validateJsonV1TimestampSource(value.resetTime, `${key}.resetTime`, issues);
+    const observedTime = value.observedTime === undefined
+        ? undefined
+        : validateJsonV1TimestampSource(value.observedTime, `${key}.observedTime`, issues);
+    const metric = validateJsonV1Metric(value.metric, resultType, `${key}.metric`, issues);
+    if (metric && (metric.type === "percentage" || metric.type === "status") && unit !== undefined) {
+        adapterIssue(issues, `${key}.unit`, "units are not allowed for percentage or status metrics");
+    }
+    if (issueStart !== issues.length || !resultType || !name || !metric)
+        return undefined;
+    return {
+        resultType,
+        name,
+        ...(label ? { label } : {}),
+        ...(unit ? { unit, unitPosition: unitPosition } : {}),
+        ...(resetTime ? { resetTime } : {}),
+        ...(observedTime ? { observedTime } : {}),
+        metric,
+    };
+}
+function validateJsonV1Adapter(value, key, providerLabel, issues) {
+    if (!isPlainObject(value)) {
+        adapterIssue(issues, key, "expected an object");
+        return undefined;
+    }
+    if (!preflightJsonV1Adapter(value, key, issues))
+        return undefined;
+    const issueStart = issues.length;
+    validateKnownAdapterFields(value, ["rowsPath", "mappings"], key, issues);
+    const rowsPath = value.rowsPath === undefined
+        ? undefined
+        : validateJsonV1Path(value.rowsPath, `${key}.rowsPath`, issues);
+    if (!hasOwnKey(value, "mappings")) {
+        adapterIssue(issues, `${key}.mappings`, "field is required");
+    }
+    if (!Array.isArray(value.mappings) ||
+        value.mappings.length < 1 ||
+        value.mappings.length > JSON_V1_MAX_MAPPINGS) {
+        adapterIssue(issues, `${key}.mappings`, `expected an array containing 1-${JSON_V1_MAX_MAPPINGS} mappings`);
+        return undefined;
+    }
+    const mappings = [];
+    for (let index = 0; index < value.mappings.length; index += 1) {
+        const mapping = validateJsonV1Mapping(value.mappings[index], `${key}.mappings[${index}]`, providerLabel, issues);
+        if (mapping)
+            mappings.push(mapping);
+    }
+    return issueStart === issues.length && mappings.length === value.mappings.length
+        ? { ...(rowsPath ? { rowsPath } : {}), mappings }
+        : undefined;
+}
 function validateModelIds(params) {
     if (!hasOwnKey(params.raw, "modelIds"))
         return undefined;
@@ -515,13 +1032,29 @@ export function validateQuotaProviders(value) {
             if (normalizedUrl.message) {
                 issues.push({ key: `${providerKey}.url`, message: normalizedUrl.message });
             }
-            const format = raw.format;
-            if (hasOwnKey(raw, "format") &&
-                (typeof format !== "string" ||
-                    !QUOTA_PROVIDER_REMOTE_FORMATS.includes(format))) {
+            const rawFormat = raw.format;
+            const format = rawFormat === "accounting-v1" ? "quota-v1" : rawFormat;
+            const formatValid = typeof format === "string" &&
+                QUOTA_PROVIDER_REMOTE_FORMATS.includes(format);
+            if (hasOwnKey(raw, "format") && !formatValid) {
                 issues.push({
                     key: `${providerKey}.format`,
-                    message: 'expected "accounting-v1" or "openrouter-key-v1"',
+                    message: 'expected "quota-v1", "openrouter-key-v1", or "json-v1"',
+                });
+            }
+            let adapter;
+            if (format === "json-v1") {
+                if (!hasOwnKey(raw, "adapter")) {
+                    issues.push({ key: `${providerKey}.adapter`, message: "field is required" });
+                }
+                else if (label) {
+                    adapter = validateJsonV1Adapter(raw.adapter, `${providerKey}.adapter`, label, issues);
+                }
+            }
+            else if (hasOwnKey(raw, "adapter")) {
+                issues.push({
+                    key: `${providerKey}.adapter`,
+                    message: "allowed only for json-v1 format",
                 });
             }
             const apiKeyEnv = raw.apiKeyEnv;
@@ -534,7 +1067,7 @@ export function validateQuotaProviders(value) {
                     message: "expected at most 128 characters matching ^[A-Z_][A-Z0-9_]*$",
                 });
             }
-            if (providerId && normalizedUrl.value && typeof format === "string") {
+            if (providerId && normalizedUrl.value && formatValid) {
                 const identity = JSON.stringify([providerId, normalizedUrl.value, format, apiKeyEnv ?? ""]);
                 const first = requestIdentities.get(identity);
                 if (first !== undefined) {
@@ -552,20 +1085,24 @@ export function validateQuotaProviders(value) {
                 providerId &&
                 label &&
                 normalizedUrl.value &&
-                typeof format === "string" &&
-                QUOTA_PROVIDER_REMOTE_FORMATS.includes(format)) {
+                formatValid) {
+                const common = {
+                    id,
+                    providerId,
+                    label,
+                    mode: "remote-api",
+                    url: normalizedUrl.value,
+                    ...(apiKeyEnv !== undefined ? { apiKeyEnv: apiKeyEnv } : {}),
+                    ...(modelIds ? { modelIds } : {}),
+                };
                 definitions.push({
                     index,
-                    config: {
-                        id,
-                        providerId,
-                        label,
-                        mode,
-                        url: normalizedUrl.value,
-                        format: format,
-                        ...(apiKeyEnv !== undefined ? { apiKeyEnv: apiKeyEnv } : {}),
-                        ...(modelIds ? { modelIds } : {}),
-                    },
+                    config: format === "json-v1"
+                        ? { ...common, format, adapter: adapter }
+                        : {
+                            ...common,
+                            format: format,
+                        },
                 });
             }
         }