open-managed-agents 0.1.0

package/dist/src/control-plane/models/auth-storage-backend.js

@@ -0,0 +1,238 @@
+import { constants } from "node:fs";
+import { chmodSync, closeSync, existsSync, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync, } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { randomUUID } from "node:crypto";
+import lockfile from "proper-lockfile";
+const DEFAULT_AUTH_JSON = "{}";
+const FILE_MODE = 0o600;
+const DIR_MODE = 0o700;
+const DEFAULT_STALE_MS = 30_000;
+export class OmaAuthStorageBackend {
+    authPath;
+    staleMs;
+    syncRetryAttempts;
+    syncRetryDelayMs;
+    asyncRetries;
+    beforeRename;
+    constructor(authPath, options = {}) {
+        this.authPath = resolve(authPath);
+        this.staleMs = options.staleMs ?? DEFAULT_STALE_MS;
+        this.syncRetryAttempts = options.syncRetryAttempts ?? 50;
+        this.syncRetryDelayMs = options.syncRetryDelayMs ?? 20;
+        this.asyncRetries = options.asyncRetries ?? 10;
+        this.beforeRename = options.beforeRename;
+    }
+    withLock(fn) {
+        this.prepareStorage();
+        let release;
+        try {
+            release = this.acquireLockSync();
+            this.assertSafeAuthFile();
+            const current = readFileSync(this.authPath, "utf8");
+            const { result, next } = fn(current);
+            if (next !== undefined) {
+                this.atomicWrite(next);
+            }
+            return result;
+        }
+        finally {
+            release?.();
+        }
+    }
+    async withLockAsync(fn) {
+        this.prepareStorage();
+        let release;
+        let compromised;
+        const throwIfCompromised = () => {
+            if (compromised) {
+                throw compromised;
+            }
+        };
+        try {
+            release = await lockfile.lock(this.authPath, {
+                realpath: false,
+                stale: this.staleMs,
+                retries: {
+                    retries: this.asyncRetries,
+                    factor: 2,
+                    minTimeout: 25,
+                    maxTimeout: 250,
+                    randomize: true,
+                },
+                onCompromised: (error) => {
+                    compromised = error;
+                },
+            });
+            throwIfCompromised();
+            this.assertSafeAuthFile();
+            const current = readFileSync(this.authPath, "utf8");
+            const { result, next } = await fn(current);
+            throwIfCompromised();
+            if (next !== undefined) {
+                this.atomicWrite(next);
+            }
+            throwIfCompromised();
+            return result;
+        }
+        finally {
+            if (release) {
+                try {
+                    await release();
+                }
+                catch {
+                    if (!compromised) {
+                        throw new Error("Failed to release auth storage lock");
+                    }
+                }
+            }
+        }
+    }
+    prepareStorage() {
+        const dir = dirname(this.authPath);
+        mkdirSync(dir, { recursive: true, mode: DIR_MODE });
+        this.assertSafeDirectory(dir);
+        if (!existsSync(this.authPath)) {
+            this.createInitialFile();
+        }
+        this.assertSafeAuthFile();
+    }
+    createInitialFile() {
+        try {
+            const fd = openSync(this.authPath, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY | noFollowFlag(), FILE_MODE);
+            try {
+                writeFileSync(fd, DEFAULT_AUTH_JSON, "utf8");
+                fsyncSync(fd);
+            }
+            finally {
+                closeSync(fd);
+            }
+            chmodSync(this.authPath, FILE_MODE);
+            this.fsyncParent();
+        }
+        catch (error) {
+            if (isNodeError(error) && error.code === "EEXIST") {
+                return;
+            }
+            throw error;
+        }
+    }
+    acquireLockSync() {
+        let lastError;
+        for (let attempt = 1; attempt <= this.syncRetryAttempts; attempt += 1) {
+            try {
+                return lockfile.lockSync(this.authPath, {
+                    realpath: false,
+                    stale: this.staleMs,
+                });
+            }
+            catch (error) {
+                if (!isNodeError(error) || error.code !== "ELOCKED" || attempt === this.syncRetryAttempts) {
+                    throw error;
+                }
+                lastError = error;
+                sleepSync(this.syncRetryDelayMs);
+            }
+        }
+        throw lastError ?? new Error("Failed to acquire auth storage lock");
+    }
+    atomicWrite(content) {
+        const dir = dirname(this.authPath);
+        const temp = resolve(dir, `.${basenameForTemp(this.authPath)}.${process.pid}.${randomUUID()}.tmp`);
+        let fd;
+        try {
+            fd = openSync(temp, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY | noFollowFlag(), FILE_MODE);
+            writeFileSync(fd, content, "utf8");
+            fsyncSync(fd);
+            closeSync(fd);
+            fd = undefined;
+            chmodSync(temp, FILE_MODE);
+            this.beforeRename?.();
+            renameSync(temp, this.authPath);
+            chmodSync(this.authPath, FILE_MODE);
+            this.assertSafeAuthFile();
+            this.fsyncParent();
+        }
+        catch (error) {
+            if (fd !== undefined) {
+                closeSync(fd);
+            }
+            try {
+                unlinkSync(temp);
+            }
+            catch {
+                // Best effort cleanup; failing here would hide the original error.
+            }
+            throw error;
+        }
+    }
+    assertSafeDirectory(path) {
+        const lst = lstatSync(path);
+        if (lst.isSymbolicLink()) {
+            throw new Error(`Refusing to use symlinked auth directory: ${path}`);
+        }
+        const st = statSync(path);
+        if (!st.isDirectory()) {
+            throw new Error(`Auth storage parent is not a directory: ${path}`);
+        }
+        assertOwned(path, st.uid, "auth directory");
+        const mode = st.mode & 0o777;
+        if (mode !== DIR_MODE) {
+            throw new Error(`Refusing unsafe auth directory permissions ${formatMode(mode)} for ${path}; expected 0700`);
+        }
+    }
+    assertSafeAuthFile() {
+        const lst = lstatSync(this.authPath);
+        if (lst.isSymbolicLink()) {
+            throw new Error(`Refusing to use symlinked auth file: ${this.authPath}`);
+        }
+        const st = statSync(this.authPath);
+        if (!st.isFile()) {
+            throw new Error(`Auth storage path is not a regular file: ${this.authPath}`);
+        }
+        assertOwned(this.authPath, st.uid, "auth file");
+        const mode = st.mode & 0o777;
+        if (mode !== FILE_MODE) {
+            throw new Error(`Refusing unsafe auth file permissions ${formatMode(mode)} for ${this.authPath}; expected 0600`);
+        }
+    }
+    fsyncParent() {
+        const fd = openSync(dirname(this.authPath), constants.O_RDONLY);
+        try {
+            fsyncSync(fd);
+        }
+        finally {
+            closeSync(fd);
+        }
+    }
+}
+export function createOmaAuthStorageBackend(authPath, options) {
+    return new OmaAuthStorageBackend(authPath, options);
+}
+function noFollowFlag() {
+    return typeof constants.O_NOFOLLOW === "number" ? constants.O_NOFOLLOW : 0;
+}
+function sleepSync(delayMs) {
+    const start = Date.now();
+    while (Date.now() - start < delayMs) {
+        // Busy wait preserves Pi's synchronous backend contract.
+    }
+}
+function basenameForTemp(path) {
+    const index = path.lastIndexOf("/");
+    return index >= 0 ? path.slice(index + 1) : path;
+}
+function assertOwned(path, uid, label) {
+    if (typeof process.getuid !== "function") {
+        return;
+    }
+    const currentUid = process.getuid();
+    if (uid !== currentUid) {
+        throw new Error(`Refusing ${label} not owned by current user: ${path}`);
+    }
+}
+function formatMode(mode) {
+    return `0${mode.toString(8).padStart(3, "0")}`;
+}
+function isNodeError(error) {
+    return error instanceof Error && "code" in error;
+}

package/dist/src/control-plane/models/catalog.js

@@ -0,0 +1,78 @@
+import { AuthStorage, ModelRegistry, } from "@earendil-works/pi-coding-agent";
+import { scanModelConfigSecurity } from "./config-security.js";
+export const PINNED_PI_MODEL_RUNTIME_VERSION = "0.80.6";
+export function createPiModelCatalog(config) {
+    return createCatalog(config, AuthStorage.fromStorage(config.authBackend));
+}
+/**
+ * Read-only catalog construction for diagnostics. The caller supplies an
+ * already-read credential snapshot, so Pi never opens, locks, or creates an
+ * auth file. Runtime code must continue to use createPiModelCatalog().
+ */
+export function createReadOnlyPiModelCatalog(config, authData = {}) {
+    return createCatalog(config, AuthStorage.inMemory(authData));
+}
+function createCatalog(config, authStorage) {
+    const allowedProviders = new Set(config.allowedProviders);
+    if (allowedProviders.size !== config.allowedProviders.length) {
+        throw new Error("OMA_MODEL_PROVIDERS must not contain duplicate providers");
+    }
+    if (!allowedProviders.has(config.defaultModel.provider)) {
+        throw new Error(`Default model provider ${config.defaultModel.provider} is not enabled on this deployment`);
+    }
+    const securityReport = scanModelConfigSecurity({
+        modelsPath: config.modelsPath,
+        authPath: config.authPath,
+        allowedProviders,
+        allowCommands: config.allowModelAuthCommands,
+    });
+    const authErrors = authStorage.drainErrors();
+    if (authErrors.length > 0) {
+        throw new Error(`Failed to load model auth storage: ${authErrors.map((error) => error.message).join("; ")}`);
+    }
+    const modelRegistry = ModelRegistry.create(authStorage, config.modelsPath);
+    const registryError = modelRegistry.getError();
+    if (registryError !== undefined) {
+        throw new Error(registryError);
+    }
+    for (const provider of allowedProviders) {
+        if (!modelRegistry.getAll().some((model) => model.provider === provider)) {
+            throw new Error(`Model provider ${provider} is not available in the Pi model registry`);
+        }
+    }
+    if (!modelRegistry.find(config.defaultModel.provider, config.defaultModel.id)) {
+        throw new Error(`Default model ${config.defaultModel.provider}/${config.defaultModel.id} is not available on this deployment`);
+    }
+    return {
+        defaultModel: { ...config.defaultModel },
+        allowedProviders,
+        authStorage,
+        modelRegistry,
+        securityReport,
+        resolve(ref) {
+            if (!allowedProviders.has(ref.provider))
+                return undefined;
+            return modelRegistry.find(ref.provider, ref.id);
+        },
+        list(options = {}) {
+            const models = options.availableOnly ? modelRegistry.getAvailable() : modelRegistry.getAll();
+            return models.filter((model) => {
+                if (!allowedProviders.has(model.provider))
+                    return false;
+                return options.provider === undefined || model.provider === options.provider;
+            });
+        },
+        hasConfiguredAuth(model) {
+            // Deliberately model-scoped: provider status can report env credentials as
+            // configured:false in Pi 0.80.6 while the resolved model is usable.
+            return modelRegistry.hasConfiguredAuth(model);
+        },
+        providerAuthMetadata(provider) {
+            const status = modelRegistry.getProviderAuthStatus(provider);
+            return {
+                ...(status.source === undefined ? {} : { source: status.source }),
+                ...(status.label === undefined ? {} : { label: status.label }),
+            };
+        },
+    };
+}

package/dist/src/control-plane/models/config-security.js

@@ -0,0 +1,376 @@
+import { existsSync, lstatSync, readFileSync, statSync, } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { isIP } from "node:net";
+export const SUPPORTED_PI_MODEL_APIS = [
+    "anthropic-messages",
+    "openai-completions",
+    "openai-responses",
+    "azure-openai-responses",
+    "openai-codex-responses",
+    "mistral-conversations",
+    "google-generative-ai",
+    "google-vertex",
+    "bedrock-converse-stream",
+];
+export function scanModelConfigSecurity(options) {
+    const warnings = [];
+    if (options.modelsPath) {
+        scanPathSafety(options.modelsPath, "models.json");
+        if (existsSync(options.modelsPath)) {
+            scanModelsJson(options.modelsPath, options, warnings);
+        }
+    }
+    if (options.authPath) {
+        scanPathSafety(options.authPath, "auth.json");
+        if (existsSync(options.authPath)) {
+            scanAuthJson(options.authPath, options.allowCommands === true);
+        }
+    }
+    return { warnings };
+}
+export function parseJsoncObject(text, label) {
+    const parsed = JSON.parse(stripJsonComments(text));
+    if (!isPlainObject(parsed)) {
+        throw new Error(`${label} must contain a JSON object`);
+    }
+    return parsed;
+}
+function scanModelsJson(path, options, warnings) {
+    const root = parseJsoncObject(readFileSync(path, "utf8"), "models.json");
+    assertOnlyKeys(root, ["providers"], "models.json");
+    const providers = requiredObject(root.providers, "models.json.providers");
+    for (const [provider, rawProviderConfig] of Object.entries(providers)) {
+        if (!options.allowedProviders.has(provider)) {
+            throw new Error(`Model provider ${provider} is not enabled on this deployment`);
+        }
+        const providerConfig = requiredObject(rawProviderConfig, `models.json.providers.${provider}`);
+        assertOnlyKeys(providerConfig, ["name", "baseUrl", "apiKey", "api", "headers", "compat", "authHeader", "models", "modelOverrides"], `models.json.providers.${provider}`);
+        const providerBaseUrl = scanOptionalUrl(providerConfig.baseUrl, `models.json.providers.${provider}.baseUrl`);
+        scanOptionalApi(providerConfig.api, `models.json.providers.${provider}.api`);
+        scanOptionalConfigValue(providerConfig.apiKey, `models.json.providers.${provider}.apiKey`, options.allowCommands === true);
+        maybeWarnLiteralCredential(warnings, providerConfig.apiKey, `models.json.providers.${provider}.apiKey`, providerBaseUrl);
+        scanHeaders(providerConfig.headers, `models.json.providers.${provider}.headers`, options.allowCommands === true, warnings);
+        scanCompat(providerConfig.compat, `models.json.providers.${provider}.compat`);
+        if (providerConfig.models !== undefined) {
+            if (!Array.isArray(providerConfig.models)) {
+                throw new Error(`models.json.providers.${provider}.models must be an array`);
+            }
+            for (const [index, rawModel] of providerConfig.models.entries()) {
+                const modelPath = `models.json.providers.${provider}.models[${index}]`;
+                const model = requiredObject(rawModel, modelPath);
+                assertOnlyKeys(model, ["id", "name", "api", "baseUrl", "reasoning", "thinkingLevelMap", "input", "cost", "contextWindow", "maxTokens", "headers", "compat"], modelPath);
+                scanOptionalApi(model.api, `${modelPath}.api`);
+                scanOptionalUrl(model.baseUrl, `${modelPath}.baseUrl`);
+                scanHeaders(model.headers, `${modelPath}.headers`, options.allowCommands === true, warnings);
+                scanThinkingLevelMap(model.thinkingLevelMap, `${modelPath}.thinkingLevelMap`);
+                scanCost(model.cost, `${modelPath}.cost`, false);
+                scanCompat(model.compat, `${modelPath}.compat`);
+            }
+        }
+        if (providerConfig.modelOverrides !== undefined) {
+            const overrides = requiredObject(providerConfig.modelOverrides, `models.json.providers.${provider}.modelOverrides`);
+            for (const [modelId, rawOverride] of Object.entries(overrides)) {
+                const overridePath = `models.json.providers.${provider}.modelOverrides.${modelId}`;
+                const override = requiredObject(rawOverride, overridePath);
+                assertOnlyKeys(override, ["name", "reasoning", "thinkingLevelMap", "input", "cost", "contextWindow", "maxTokens", "headers", "compat"], overridePath);
+                scanHeaders(override.headers, `${overridePath}.headers`, options.allowCommands === true, warnings);
+                scanThinkingLevelMap(override.thinkingLevelMap, `${overridePath}.thinkingLevelMap`);
+                scanCost(override.cost, `${overridePath}.cost`, true);
+                scanCompat(override.compat, `${overridePath}.compat`);
+            }
+        }
+    }
+}
+function scanAuthJson(path, allowCommands) {
+    const auth = parseJsoncObject(readFileSync(path, "utf8"), "auth.json");
+    for (const [provider, rawCredential] of Object.entries(auth)) {
+        const credential = requiredObject(rawCredential, `auth.json.${provider}`);
+        if (credential.type === "api_key") {
+            scanOptionalConfigValue(credential.key, `auth.json.${provider}.key`, allowCommands);
+        }
+    }
+}
+function scanPathSafety(path, label) {
+    const resolved = resolve(path);
+    const parent = dirname(resolved);
+    if (existsSync(parent)) {
+        const parentStat = lstatSync(parent);
+        if (parentStat.isSymbolicLink()) {
+            throw new Error(`${label} parent directory must not be a symlink: ${parent}`);
+        }
+        if ((parentStat.mode & 0o022) !== 0) {
+            throw new Error(`${label} parent directory must not be group/world writable: ${parent}`);
+        }
+    }
+    if (!existsSync(resolved))
+        return;
+    const lst = lstatSync(resolved);
+    if (lst.isSymbolicLink()) {
+        throw new Error(`${label} must not be a symlink: ${resolved}`);
+    }
+    const st = statSync(resolved);
+    if (!st.isFile()) {
+        throw new Error(`${label} must be a regular file: ${resolved}`);
+    }
+    if ((st.mode & 0o022) !== 0) {
+        throw new Error(`${label} must not be group/world writable: ${resolved}`);
+    }
+}
+function stripJsonComments(text) {
+    let out = "";
+    let inString = false;
+    let escaped = false;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        const next = text[i + 1];
+        if (inString) {
+            out += ch;
+            if (escaped) {
+                escaped = false;
+            }
+            else if (ch === "\\") {
+                escaped = true;
+            }
+            else if (ch === "\"") {
+                inString = false;
+            }
+            continue;
+        }
+        if (ch === "\"") {
+            inString = true;
+            out += ch;
+            continue;
+        }
+        if (ch === "/" && next === "/") {
+            out += "  ";
+            i += 1;
+            while (i + 1 < text.length && text[i + 1] !== "\n" && text[i + 1] !== "\r") {
+                out += " ";
+                i += 1;
+            }
+            continue;
+        }
+        if (ch === "/" && next === "*") {
+            out += "  ";
+            i += 1;
+            while (i + 1 < text.length && !(text[i + 1] === "*" && text[i + 2] === "/")) {
+                out += text[i + 1] === "\n" || text[i + 1] === "\r" ? text[i + 1] : " ";
+                i += 1;
+            }
+            if (i + 2 < text.length) {
+                out += "  ";
+                i += 2;
+            }
+            continue;
+        }
+        out += ch;
+    }
+    return out;
+}
+function scanOptionalApi(value, path) {
+    if (value === undefined)
+        return;
+    if (typeof value !== "string")
+        throw new Error(`${path} must be a string`);
+    if (!SUPPORTED_PI_MODEL_APIS.includes(value)) {
+        throw new Error(`${path} uses unsupported Pi model adapter ${JSON.stringify(value)}`);
+    }
+}
+function scanOptionalUrl(value, path) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string" || value.trim() === "")
+        throw new Error(`${path} must be a non-empty string`);
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw new Error(`${path} must be a valid URL`);
+    }
+    if (url.username || url.password) {
+        throw new Error(`${path} must not contain username/password userinfo`);
+    }
+    if (url.protocol === "https:")
+        return url;
+    if (url.protocol === "http:" && isLoopbackHost(url.hostname))
+        return url;
+    throw new Error(`${path} must be https, or http only for syntactic loopback hosts`);
+}
+function isLoopbackHost(hostname) {
+    const normalized = hostname.toLowerCase();
+    if (normalized === "localhost" || normalized === "[::1]" || normalized === "::1")
+        return true;
+    if (isIP(normalized) === 4) {
+        const [first] = normalized.split(".");
+        return first === "127";
+    }
+    return false;
+}
+function scanOptionalConfigValue(value, path, allowCommands) {
+    if (value === undefined)
+        return;
+    if (typeof value !== "string" || value.trim() === "")
+        throw new Error(`${path} must be a non-empty string`);
+    if (value.startsWith("!") && !allowCommands) {
+        throw new Error(`${path} uses command-backed auth; set OMA_ALLOW_MODEL_AUTH_COMMANDS=true to allow it`);
+    }
+}
+function maybeWarnLiteralCredential(warnings, value, path, baseUrl) {
+    if (typeof value !== "string")
+        return;
+    if (value.startsWith("$") || value.startsWith("!") || value === "")
+        return;
+    if (value === "oma-local-keyless" && baseUrl?.protocol === "http:" && isLoopbackHost(baseUrl.hostname))
+        return;
+    warnings.push(`${path} contains a literal credential; prefer auth.json or environment interpolation`);
+}
+function scanHeaders(value, path, allowCommands, warnings) {
+    if (value === undefined)
+        return;
+    const headers = requiredObject(value, path);
+    for (const [name, headerValue] of Object.entries(headers)) {
+        scanOptionalConfigValue(headerValue, `${path}.${name}`, allowCommands);
+        if (typeof headerValue === "string" &&
+            !headerValue.startsWith("$") &&
+            !headerValue.startsWith("!") &&
+            /authorization|api[-_]?key|token|secret/i.test(name)) {
+            warnings.push(`${path}.${name} contains a literal credential-like header; prefer auth.json or environment interpolation`);
+        }
+    }
+}
+function scanThinkingLevelMap(value, path) {
+    if (value === undefined)
+        return;
+    const map = requiredObject(value, path);
+    assertOnlyKeys(map, ["off", "minimal", "low", "medium", "high", "xhigh", "max"], path);
+    for (const [key, item] of Object.entries(map)) {
+        if (item !== null && typeof item !== "string")
+            throw new Error(`${path}.${key} must be a string or null`);
+    }
+}
+function scanCost(value, path, partial) {
+    if (value === undefined)
+        return;
+    const cost = requiredObject(value, path);
+    assertOnlyKeys(cost, ["input", "output", "cacheRead", "cacheWrite", "tiers"], path);
+    for (const key of ["input", "output", "cacheRead", "cacheWrite"]) {
+        if (cost[key] !== undefined && typeof cost[key] !== "number")
+            throw new Error(`${path}.${key} must be a number`);
+        if (!partial && cost[key] === undefined && cost.tiers === undefined) {
+            // Pi still owns full semantic validation; this only prevents odd non-numeric values.
+        }
+    }
+    if (cost.tiers !== undefined) {
+        if (!Array.isArray(cost.tiers))
+            throw new Error(`${path}.tiers must be an array`);
+        for (const [index, rawTier] of cost.tiers.entries()) {
+            const tierPath = `${path}.tiers[${index}]`;
+            const tier = requiredObject(rawTier, tierPath);
+            assertOnlyKeys(tier, ["inputTokensAbove", "input", "output", "cacheRead", "cacheWrite"], tierPath);
+            for (const key of ["inputTokensAbove", "input", "output", "cacheRead", "cacheWrite"]) {
+                if (typeof tier[key] !== "number")
+                    throw new Error(`${tierPath}.${key} must be a number`);
+            }
+        }
+    }
+}
+function scanCompat(value, path) {
+    if (value === undefined)
+        return;
+    const compat = requiredObject(value, path);
+    assertOnlyKeys(compat, [
+        "supportsStore",
+        "supportsDeveloperRole",
+        "supportsReasoningEffort",
+        "supportsUsageInStreaming",
+        "maxTokensField",
+        "requiresToolResultName",
+        "requiresAssistantAfterToolResult",
+        "requiresThinkingAsText",
+        "requiresReasoningContentOnAssistantMessages",
+        "thinkingFormat",
+        "chatTemplateKwargs",
+        "cacheControlFormat",
+        "openRouterRouting",
+        "vercelGatewayRouting",
+        "supportsStrictMode",
+        "supportsLongCacheRetention",
+        "sendSessionIdHeader",
+        "supportsEagerToolInputStreaming",
+        "sendSessionAffinityHeaders",
+        "supportsCacheControlOnTools",
+        "forceAdaptiveThinking",
+    ], path);
+    if (compat.openRouterRouting !== undefined)
+        scanOpenRouterRouting(compat.openRouterRouting, `${path}.openRouterRouting`);
+    if (compat.vercelGatewayRouting !== undefined)
+        scanVercelGatewayRouting(compat.vercelGatewayRouting, `${path}.vercelGatewayRouting`);
+    if (compat.chatTemplateKwargs !== undefined)
+        scanChatTemplateKwargs(compat.chatTemplateKwargs, `${path}.chatTemplateKwargs`);
+}
+function scanOpenRouterRouting(value, path) {
+    const routing = requiredObject(value, path);
+    assertOnlyKeys(routing, [
+        "allow_fallbacks",
+        "require_parameters",
+        "data_collection",
+        "zdr",
+        "enforce_distillable_text",
+        "order",
+        "only",
+        "ignore",
+        "quantizations",
+        "sort",
+        "max_price",
+        "preferred_min_throughput",
+        "preferred_max_latency",
+    ], path);
+    if (routing.sort !== undefined && isPlainObject(routing.sort)) {
+        assertOnlyKeys(routing.sort, ["by", "partition"], `${path}.sort`);
+    }
+    if (routing.max_price !== undefined) {
+        assertOnlyKeys(requiredObject(routing.max_price, `${path}.max_price`), ["prompt", "completion", "image", "audio", "request"], `${path}.max_price`);
+    }
+    for (const key of ["preferred_min_throughput", "preferred_max_latency"]) {
+        const item = routing[key];
+        if (isPlainObject(item))
+            assertOnlyKeys(item, ["p50", "p75", "p90", "p99"], `${path}.${key}`);
+    }
+}
+function scanVercelGatewayRouting(value, path) {
+    assertOnlyKeys(requiredObject(value, path), ["only", "order"], path);
+}
+function scanChatTemplateKwargs(value, path) {
+    const kwargs = requiredObject(value, path);
+    for (const [key, rawValue] of Object.entries(kwargs)) {
+        if (isPlainObject(rawValue)) {
+            assertOnlyKeys(rawValue, ["$var", "omitWhenOff"], `${path}.${key}`);
+            if (rawValue.$var !== "thinking.enabled" && rawValue.$var !== "thinking.effort") {
+                throw new Error(`${path}.${key}.$var must reference a supported Pi variable`);
+            }
+        }
+        else if (rawValue !== null &&
+            typeof rawValue !== "string" &&
+            typeof rawValue !== "number" &&
+            typeof rawValue !== "boolean") {
+            throw new Error(`${path}.${key} must be a scalar or variable object`);
+        }
+    }
+}
+function assertOnlyKeys(value, allowed, path) {
+    const allowedSet = new Set(allowed);
+    for (const key of Object.keys(value)) {
+        if (!allowedSet.has(key)) {
+            throw new Error(`${path}.${key} is not supported by OMA's Pi model security profile`);
+        }
+    }
+}
+function requiredObject(value, path) {
+    if (!isPlainObject(value))
+        throw new Error(`${path} must be an object`);
+    return value;
+}
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}