@visual-z/xeno 0.8.4 → 0.9.1

package/src/runtime/mcp-oauth.ts

@@ -1,168 +0,0 @@
-/** OAuth is a user-owned repair operation; the SDK owns discovery, PKCE and issuer/resource binding. */
-import { randomUUID } from "node:crypto";
-import { auth, checkResourceAllowed, resourceUrlFromServerUrl, StreamableHTTPClientTransport,
-  type OAuthClientProvider, type OAuthClientInformationContext, type StoredOAuthClientInformation, type StoredOAuthTokens,
-  type OAuthClientMetadata, type OAuthDiscoveryState, type FetchLike } from "@modelcontextprotocol/client";
-import type { McpOAuthConfig } from "../core/mcp-config.ts";
-import { isJsonValue } from "../core/tool-contract.ts";
-import type { McpCredentials, McpCredentialsStore } from "../store/mcp-credentials.ts";
-import { boundedResponseBytes } from "./web-http.ts";
-
-export class McpAuthRequired extends Error { constructor() { super("MCP authentication requires an explicit login"); this.name = "McpAuthRequired"; } }
-/** The SDK warns with OAuth error_description; normalize peer errors before they can reach its console path. */
-export function safeOAuthFetch(fetcher: FetchLike): FetchLike {
-  return async (input, init) => {
-    let response: Response;
-    try { response = await fetcher(input, init); } catch { throw new McpAuthRequired(); }
-    if (response.ok) return response;
-    let code = "server_error";
-    try {
-      const value: unknown = JSON.parse(new TextDecoder().decode(await boundedResponseBytes(response, 16 * 1024)));
-      if (value && typeof value === "object" && "error" in value && typeof value.error === "string"
-        && ["invalid_request", "invalid_client", "invalid_grant", "unauthorized_client", "unsupported_grant_type", "invalid_scope", "access_denied", "server_error", "temporarily_unavailable"].includes(value.error)) code = value.error;
-    } catch { /* Unknown peer bodies contribute status only, never diagnostics containing secrets. */ }
-    return Response.json({ error: code, error_description: "OAuth request rejected" }, { status: response.status, headers: { "content-type": "application/json" } });
-  };
-}
-function savedClient(value: unknown): value is StoredOAuthClientInformation {
-  return !!value && typeof value === "object" && "client_id" in value && typeof value.client_id === "string";
-}
-function savedTokens(value: unknown): value is StoredOAuthTokens {
-  return !!value && typeof value === "object" && "access_token" in value && typeof value.access_token === "string"
-    && "token_type" in value && typeof value.token_type === "string";
-}
-/** A per-resource provider; discovery/verifier/state exist only during this owned process's login. */
-export class McpOAuthProvider implements OAuthClientProvider {
-  private readonly url: string;
-  private readonly config: McpOAuthConfig;
-  private readonly store: McpCredentialsStore;
-  private readonly env: Readonly<Record<string, string | undefined>>;
-  private credentials: McpCredentials;
-  private verifier: string | undefined;
-  private discovery: OAuthDiscoveryState | undefined;
-  private expectedState: string | undefined;
-  private redirect: ((url: URL) => void | Promise<void>) | undefined;
-  private refreshing: Promise<void> | undefined;
-  private resourceMetadataUrl: URL | undefined;
-  private challengedScope: string | undefined;
-  private constructor(url: string, config: McpOAuthConfig,
-    store: McpCredentialsStore, env: Readonly<Record<string, string | undefined>>, credentials?: McpCredentials) {
-    this.url = url; this.config = config; this.store = store; this.env = env;
-    this.credentials = credentials ?? { version: 1, serverUrl: url, redirectUrl: config.redirectUrl ?? "http://127.0.0.1:0/callback",
-      clients: {}, tokens: {}, expiresAt: {}, activeIssuer: null, ...(config.clientId ? { clientIdentity: config.clientId } : {}) };
-    if (config.redirectUrl) this.credentials.redirectUrl = config.redirectUrl;
-  }
-  static async create(url: string, config: McpOAuthConfig, store: McpCredentialsStore, env: Readonly<Record<string, string | undefined>>) {
-    return new McpOAuthProvider(url, config, store, env, await store.read(url, config.clientId));
-  }
-  get redirectUrl() { return this.credentials.redirectUrl; }
-  get clientMetadata(): OAuthClientMetadata {
-    return { client_name: "xeno", application_type: "native", redirect_uris: [this.redirectUrl], response_types: ["code"],
-      grant_types: ["authorization_code", "refresh_token"], token_endpoint_auth_method: this.config.clientSecretEnv ? "client_secret_basic" : "none",
-      ...(this.config.scope ? { scope: this.config.scope } : {}) };
-  }
-  clientInformation(ctx?: OAuthClientInformationContext): StoredOAuthClientInformation | undefined {
-    if (this.config.clientId) {
-      const secret = this.config.clientSecretEnv ? this.env[this.config.clientSecretEnv] : undefined;
-      if (this.config.clientSecretEnv && !secret) throw new McpAuthRequired();
-      return { client_id: this.config.clientId, ...(secret ? { client_secret: secret } : {}), ...(ctx ? { issuer: ctx.issuer } : {}) };
-    }
-    const value = ctx ? this.credentials.clients[ctx.issuer] : undefined;
-    return savedClient(value) ? value : undefined;
-  }
-  async saveClientInformation(info: StoredOAuthClientInformation, ctx?: OAuthClientInformationContext) {
-    const issuer = ctx?.issuer ?? info.issuer;
-    if (!issuer || !isJsonValue(info)) throw new McpAuthRequired();
-    this.credentials.clients[issuer] = info;
-    await this.store.write(this.credentials);
-  }
-  tokens(ctx?: OAuthClientInformationContext): StoredOAuthTokens | undefined {
-    const issuer = ctx?.issuer ?? this.credentials.activeIssuer, value = issuer ? this.credentials.tokens[issuer] : undefined;
-    return savedTokens(value) ? value : undefined;
-  }
-  async saveTokens(tokens: StoredOAuthTokens, ctx?: OAuthClientInformationContext) {
-    const issuer = ctx?.issuer ?? tokens.issuer;
-    if (!issuer || !isJsonValue(tokens)) throw new McpAuthRequired();
-    this.credentials.tokens[issuer] = tokens; this.credentials.activeIssuer = issuer;
-    if (tokens.expires_in !== undefined) this.credentials.expiresAt[issuer] = Date.now() + tokens.expires_in * 1_000;
-    else delete this.credentials.expiresAt[issuer];
-    await this.store.write(this.credentials);
-  }
-  state() { this.expectedState = randomUUID(); return this.expectedState; }
-  redirectToAuthorization(url: URL) {
-    if (!this.redirect) throw new McpAuthRequired();
-    return this.redirect(url);
-  }
-  saveCodeVerifier(verifier: string) { this.verifier = verifier; }
-  codeVerifier() { if (!this.verifier) throw new McpAuthRequired(); return this.verifier; }
-  saveDiscoveryState(state: OAuthDiscoveryState) { this.discovery = state; }
-  discoveryState() { return this.discovery; }
-  setChallenge(resourceMetadataUrl: URL | undefined, scope: string | undefined) {
-    this.resourceMetadataUrl = resourceMetadataUrl; this.challengedScope = scope; this.discovery = undefined;
-  }
-  private authOptions(fetcher: FetchLike) {
-    const scope = this.config.scope ?? this.challengedScope;
-    return { serverUrl: this.url, fetchFn: safeOAuthFetch(fetcher), ...(this.resourceMetadataUrl ? { resourceMetadataUrl: this.resourceMetadataUrl } : {}), ...(scope ? { scope } : {}) };
-  }
-  async validateResourceURL(serverUrl: string | URL, resource?: string) {
-    const expected = resourceUrlFromServerUrl(serverUrl);
-    if (resource && !checkResourceAllowed({ requestedResource: expected, configuredResource: resource })) throw new McpAuthRequired();
-    return expected;
-  }
-  async invalidateCredentials(scope: "all" | "client" | "tokens" | "verifier" | "discovery") {
-    if (scope === "all" || scope === "client") this.credentials.clients = {};
-    if (scope === "all" || scope === "tokens") { this.credentials.tokens = {}; this.credentials.expiresAt = {}; this.credentials.activeIssuer = null; }
-    if (scope === "all" || scope === "verifier") this.verifier = undefined;
-    if (scope === "all" || scope === "discovery") this.discovery = undefined;
-    if (scope === "all") await this.store.remove(this.url, this.config.clientId); else await this.store.write(this.credentials);
-  }
-  async token(fetcher: FetchLike): Promise<string | undefined> {
-    const issuer = this.credentials.activeIssuer, expiresAt = issuer ? this.credentials.expiresAt[issuer] : undefined;
-    // Assumed 30s skew prevents sending a token that expires while the new request is in flight.
-    if (expiresAt !== undefined && expiresAt <= Date.now() + 30_000) {
-      if (!this.refreshing) {
-        this.refreshing = (async () => {
-          if (!this.tokens()?.refresh_token) { await this.invalidateCredentials("tokens"); throw new McpAuthRequired(); }
-          try { if (await auth(this, this.authOptions(fetcher)) !== "AUTHORIZED") throw new McpAuthRequired(); }
-          catch { await this.invalidateCredentials("tokens"); throw new McpAuthRequired(); }
-        })().finally(() => { this.refreshing = undefined; });
-      }
-      await this.refreshing;
-    }
-    return this.tokens()?.access_token;
-  }
-  async login(onAuthorizationUrl: (url: URL) => void | Promise<void>, fetcher: FetchLike, signal: AbortSignal): Promise<void> {
-    if (this.redirect) throw new McpAuthRequired();
-    signal.throwIfAborted();
-    const callback = new URL(this.redirectUrl);
-    let resolveCallback: (value: URLSearchParams) => void = () => {}, rejectCallback: (error: Error) => void = () => {};
-    const received = new Promise<URLSearchParams>((resolve, reject) => { resolveCallback = resolve; rejectCallback = reject; });
-    // Reject handlers are installed before starting auth; cancellation never leaves an unhandled callback promise.
-    void received.catch(() => {});
-    const server = Bun.serve({ hostname: "127.0.0.1", port: Number(callback.port), fetch: request => {
-      const current = new URL(request.url);
-      if (current.pathname !== callback.pathname) return new Response("Not found", { status: 404 });
-      if (request.method !== "GET" || !this.expectedState || current.searchParams.get("state") !== this.expectedState) return new Response("Invalid authorization state", { status: 400 });
-      if (current.searchParams.has("error") || !current.searchParams.get("code")) {
-        rejectCallback(new McpAuthRequired()); return new Response("Authorization was not completed", { status: 400 });
-      }
-      resolveCallback(current.searchParams); return new Response("Authorization received. Return to xeno.", { headers: { "content-type": "text/plain" } });
-    } });
-    const selected = new URL(callback.pathname, server.url).href;
-    if (selected !== this.credentials.redirectUrl && !this.config.clientId) this.credentials.clients = {};
-    this.credentials.redirectUrl = selected; this.redirect = onAuthorizationUrl;
-    const onAbort = () => rejectCallback(new McpAuthRequired());
-    signal.addEventListener("abort", onAbort, { once: true });
-    try {
-      const safeFetch = safeOAuthFetch(fetcher);
-      const result = await auth(this, this.authOptions(fetcher));
-      if (result === "AUTHORIZED") return;
-      const params = await received;
-      const transport = new StreamableHTTPClientTransport(new URL(this.url), { authProvider: this, fetch: safeFetch, onInsufficientScope: "throw" });
-      try { await transport.finishAuth(params); } finally { await transport.close(); }
-    } finally {
-      signal.removeEventListener("abort", onAbort); server.stop(true); this.redirect = undefined;
-      this.expectedState = undefined; this.verifier = undefined; this.discovery = undefined;
-    }
-  }
-}

package/src/runtime/mcp-schema.ts

@@ -1,51 +0,0 @@
-/** MCP 2025-11-25 defaults to 2020-12; validation never repairs the frozen invocation. */
-import { Ajv, type ValidateFunction } from "ajv";
-import { Ajv2019 } from "ajv/dist/2019.js";
-import { Ajv2020 } from "ajv/dist/2020.js";
-import { addFormats } from "@modelcontextprotocol/client/validators/ajv";
-import type { JsonSchemaType, JsonSchemaValidator, jsonSchemaValidator } from "@modelcontextprotocol/client";
-import { NOT_STARTED, ToolFault } from "../core/tool-failure.ts";
-
-export class McpSchemaError extends Error {
-  constructor() { super("MCP schema is invalid or uses an unsupported dialect, reference, keyword or format; repair the server schema before reloading."); this.name = "McpSchemaError"; }
-}
-
-/** The official client's format package is bundled in its public validator entry; no extra dependency. */
-export class McpSchemas implements jsonSchemaValidator {
-  private readonly compiled = new Map<string, ValidateFunction>();
-  validator(schema: unknown): ValidateFunction {
-    if (!schema || typeof schema !== "object" || Array.isArray(schema)) throw new McpSchemaError();
-    const key = JSON.stringify(schema), cached = this.compiled.get(key);
-    if (cached) return cached;
-    try {
-      const dialect = (schema as Record<string, unknown>)["$schema"];
-      const options = { strictSchema: true, strictNumbers: true, strictTypes: false, strictTuples: false, strictRequired: false,
-        validateFormats: true, coerceTypes: false, useDefaults: false, removeAdditional: false, allErrors: false, logger: false as const };
-      // Strict schema rejects unknown semantics, while strict style checks are disabled:
-      // valid JSON Schema need not spell out every tuple bound or repeat inherited types.
-      const ajv = dialect === undefined || dialect === "https://json-schema.org/draft/2020-12/schema" ? new Ajv2020(options)
-        : dialect === "https://json-schema.org/draft/2019-09/schema" ? new Ajv2019(options)
-        : dialect === "http://json-schema.org/draft-07/schema#" || dialect === "http://json-schema.org/draft-07/schema" ? new Ajv(options)
-        : undefined;
-      if (!ajv) throw new McpSchemaError();
-      addFormats(ajv);
-      // MCP's header annotation is interpreted by the official transport, not a validation constraint.
-      ajv.addKeyword({ keyword: "x-mcp-header", schemaType: "string", valid: true });
-      // Ajv validates this entire JSON schema; the assertion only bridges the SDK's wider wire type.
-      const validate = ajv.compile(structuredClone(schema) as JsonSchemaType);
-      this.compiled.set(key, validate); return validate;
-    } catch { throw new McpSchemaError(); }
-  }
-  getValidator<T>(schema: JsonSchemaType): JsonSchemaValidator<T> {
-    const validate = this.validator(schema);
-    return input => validate(input) ? { valid: true, data: input as T, errorMessage: undefined }
-      : { valid: false, data: undefined, errorMessage: "MCP structured output failed the advertised schema." };
-  }
-  prepare(schema: unknown): (input: unknown) => unknown {
-    const validate = this.validator(schema);
-    return input => {
-      if (!validate(input)) throw new ToolFault("invalid_input", "MCP arguments do not satisfy the complete advertised schema. Correct the input before calling the remote tool.", NOT_STARTED);
-      return input;
-    };
-  }
-}

package/src/runtime/model-config.ts

@@ -1,232 +0,0 @@
-/** Config parsing owns provider wire vocabulary; identity/filter policy lives in core. */
-import { mergeCatalogs, modelEnabled } from "../core/catalog-merge.ts";
-import { modelKey } from "../core/session-position.ts";
-import { THINKING_LEVELS } from "../core/thinking.ts";
-import { SOURCE_PROVIDERS } from "./model-data.ts";
-import { DEFAULT_COMPAT, type ModelSpec, type Effort } from "./model.ts";
-import { isProviderApi, SDK_APIS } from "./provider-protocols.ts";
-import { providerAccess, setProviderAccess, type ProviderAccess } from "./provider-access.ts";
-
-function object(value: unknown): value is Record<string, unknown> { return value !== null && typeof value === "object" && !Array.isArray(value); }
-function own(value: Record<string, unknown>, key: string): boolean { return Object.hasOwn(value, key); }
-function positive(value: unknown): value is number { return typeof value === "number" && Number.isFinite(value) && value > 0; }
-function nonnegative(value: unknown): value is number { return typeof value === "number" && Number.isFinite(value) && value >= 0; }
-function error(path: string, message: string): never { throw new Error(`${path}: ${message}`); }
-function strings(value: unknown, path: string): string[] | undefined {
-  if (value === undefined) return undefined;
-  if (!Array.isArray(value) || !value.every(x => typeof x === "string")) error(path, "must be an array of strings");
-  return value as string[];
-}
-function stringMap(value: unknown, path: string, nullable = false): Record<string, string | null> | undefined {
-  if (value === undefined) return undefined;
-  if (!object(value) || !Object.values(value).every(x => typeof x === "string" || (nullable && x === null))) error(path, "must contain string values" + (nullable ? " or null" : ""));
-  return Object.fromEntries(Object.entries(value as Record<string, string | null>).map(([key, v]) => [key, typeof v === "string" ? configValue(v) : v]));
-}
-/** OpenCode's env reference and Pi's interpolation share one resolver. No implicit uppercase lookup. */
-function configValue(value: string): string { return value.replace(/\{env:([A-Za-z_][A-Za-z0-9_]*)\}/g, "$${$1}"); }
-const RESERVED_BODY = ["model", "modelId", "messages", "system", "systemInstruction", "system_instruction", "instructions", "input", "contents", "context", "tools", "toolConfig", "stream", "previous_response_id", "store", "conversation", "conversation_id", "sessionId", "session_id", "httpOptions", "http_options", "headers", "apiKey", "authToken", "baseUrl", "baseURL", "fetch", "abortSignal", "signal", "onPayload", "onResponse"];
-const REQUEST_OPTIONS = ["temperature", "samplingParams", "cacheRetention", "timeoutMs", "maxRetryDelayMs", "metadata"];
-
-function payloadPatch(value: unknown, path: string): Record<string, unknown> | undefined {
-  if (value === undefined) return undefined;
-  if (!object(value)) error(path, "must be an object");
-  for (const [key, child] of Object.entries(value)) {
-    if (RESERVED_BODY.includes(key)) error(`${path}.${key}`, "is owned by the log projection and request adapter");
-    if ((key === "config" || key === "options") && !object(child)) error(`${path}.${key}`, "must be an object");
-    if (object(child)) payloadPatch(child, `${path}.${key}`);
-  }
-  return value;
-}
-
-function accessPatch(raw: Record<string, unknown>, path: string, parent: ProviderAccess = {}): ProviderAccess {
-  if (raw["options"] !== undefined && !object(raw["options"])) error(`${path}.options`, "must be an object");
-  const options = object(raw["options"]) ? raw["options"] : {};
-  const apiKey = own(raw, "apiKey") ? raw["apiKey"] : options["apiKey"];
-  if (apiKey !== undefined && (typeof apiKey !== "string" || !apiKey.length)) error(`${path}.apiKey`, "must be a non-empty string; use auth: false for a keyless endpoint");
-  const auth = raw["auth"];
-  if (auth !== undefined && auth !== false && auth !== "ambient") error(`${path}.auth`, "must be false or ambient");
-  const authHeader = raw["authHeader"];
-  if (authHeader !== undefined && typeof authHeader !== "boolean" && (typeof authHeader !== "string" || !/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/.test(authHeader))) error(`${path}.authHeader`, "must be a boolean or header name");
-  const headers = stringMap(raw["headers"] ?? options["headers"] ?? raw["defaultHeaders"], `${path}.headers`, true);
-  if (headers && Object.keys(headers).some(key => !/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/.test(key))) error(`${path}.headers`, "contains an invalid header name");
-  const env = stringMap(raw["env"], `${path}.env`) as Record<string, string> | undefined;
-  if (env && Object.keys(env).some(key => !/^[A-Za-z_][A-Za-z0-9_]*$/.test(key))) error(`${path}.env`, "contains an invalid variable name");
-  const body = payloadPatch(raw["body"] ?? raw["extraBody"] ?? options["body"] ?? options["extraBody"], `${path}.body`);
-  const requestOptions = Object.fromEntries(Object.entries(options).filter(([key]) => !["apiKey", "baseURL", "baseUrl", "headers", "body", "extraBody"].includes(key)));
-  for (const key of Object.keys(requestOptions)) {
-    if (!REQUEST_OPTIONS.includes(key)) error(`${path}.options.${key}`, "is not a configurable request option; use env for native cloud settings or body for API parameters");
-  }
-  payloadPatch(requestOptions["samplingParams"], `${path}.options.samplingParams`);
-  for (const key of ["temperature", "timeoutMs", "maxRetryDelayMs"]) if (requestOptions[key] !== undefined && !nonnegative(requestOptions[key])) error(`${path}.options.${key}`, "must be a finite nonnegative number");
-  if (requestOptions["cacheRetention"] !== undefined && !["none", "short", "long"].includes(String(requestOptions["cacheRetention"]))) error(`${path}.options.cacheRetention`, "must be none, short or long");
-  stringMap(requestOptions["metadata"], `${path}.options.metadata`);
-  return { ...parent,
-    ...(typeof apiKey === "string" ? { apiKey: configValue(apiKey) } : {}),
-    ...(auth === false || auth === "ambient" ? { auth } : {}),
-    ...(typeof authHeader === "boolean" || typeof authHeader === "string" ? { authHeader } : {}),
-    ...(headers ? { headers: { ...parent.headers, ...headers } } : {}),
-    ...(env ? { env: { ...parent.env, ...env } } : {}),
-    ...(object(body) ? { body: { ...parent.body, ...body } } : {}),
-    ...(Object.keys(requestOptions).length ? { options: { ...parent.options, ...requestOptions } } : {}) };
-}
-
-function modelPatch(raw: Record<string, unknown>, base: ModelSpec | undefined, provider: string, id: string, path: string, partial: boolean): ModelSpec {
-  const options = object(raw["options"]) ? raw["options"] : {};
-  const endpoint = raw["baseUrl"] ?? raw["baseURL"] ?? options["baseURL"] ?? options["baseUrl"];
-  if (raw["npm"] !== undefined && (typeof raw["npm"] !== "string" || !SDK_APIS[raw["npm"]]) && raw["api"] === undefined) error(`${path}.npm`, "unsupported SDK; select a supported api explicitly");
-  const api = raw["api"] ?? (typeof raw["npm"] === "string" ? SDK_APIS[raw["npm"]] : undefined) ?? base?.api ?? SOURCE_PROVIDERS[provider]?.api;
-  if (!isProviderApi(api)) error(`${path}.api`, "unknown or missing protocol");
-  if (endpoint !== undefined && typeof endpoint !== "string") error(`${path}.baseUrl`, "must be a string");
-  const spec: ModelSpec = { ...(base ?? {}), provider, id, name: base?.name ?? id, api,
-    reasoning: base?.reasoning ?? false, ...(partial ? {} : { driver: "pi" }),
-    ...(typeof endpoint === "string" ? { baseUrl: configValue(endpoint) } : base?.baseUrl !== undefined ? {} : SOURCE_PROVIDERS[provider]?.baseUrl ? { baseUrl: SOURCE_PROVIDERS[provider].baseUrl } : {}) };
-  if (raw["api"] !== undefined && raw["api"] !== base?.api) { delete spec.compat; delete spec.nativeCompat; delete spec.thinkingLevelMap; }
-  if (typeof raw["name"] === "string" && raw["name"].length) spec.name = raw["name"];
-  if (own(raw, "reasoning")) { if (typeof raw["reasoning"] !== "boolean") error(`${path}.reasoning`, "must be boolean"); spec.reasoning = raw["reasoning"]; }
-  const limit = object(raw["limit"]) ? raw["limit"] : {};
-  for (const [key, value] of [["contextWindow", raw["contextWindow"] ?? limit["context"]], ["maxTokens", raw["maxTokens"] ?? limit["output"]]] as const) {
-    if (value !== undefined) { if (!positive(value)) error(`${path}.${key}`, "must be a finite positive number"); spec[key] = value; }
-  }
-  if (own(raw, "input")) {
-    if (!Array.isArray(raw["input"]) || !raw["input"].every(x => x === "text" || x === "image")) error(`${path}.input`, "must contain only text or image");
-    spec.input = raw["input"] as ("text" | "image")[];
-  }
-  if (raw["credentialEnv"] !== undefined) {
-    const names = strings(raw["credentialEnv"], `${path}.credentialEnv`)!;
-    if (names.some(name => !/^[A-Za-z_][A-Za-z0-9_]*$/.test(name))) error(`${path}.credentialEnv`, "must contain variable names");
-    spec.credentialEnv = names;
-  }
-  const price = raw["price"] ?? raw["cost"];
-  if (price !== undefined) {
-    if (!object(price) || !nonnegative(price["input"]) || !nonnegative(price["output"]) || ["cacheRead", "cacheWrite"].some(k => own(price, k) && !nonnegative(price[k]))) error(`${path}.price`, "requires finite nonnegative input/output and optional cache prices");
-    spec.price = { input: price["input"], output: price["output"],
-      ...(nonnegative(price["cacheRead"]) ? { cacheRead: price["cacheRead"] } : {}),
-      ...(nonnegative(price["cacheWrite"]) ? { cacheWrite: price["cacheWrite"] } : {}) };
-  }
-  if (raw["cache"] !== undefined) { if (raw["cache"] !== "explicit" && raw["cache"] !== "automatic") error(`${path}.cache`, "must be explicit or automatic"); spec.cache = raw["cache"]; }
-  if (raw["rates"] !== undefined) {
-    const rates = raw["rates"];
-    if (!object(rates) || !nonnegative(rates["read"]) || !nonnegative(rates["write"])) error(`${path}.rates`, "requires finite nonnegative read/write");
-    spec.rates = { read: rates["read"], write: rates["write"] };
-  }
-  if (raw["thinkingLevelMap"] !== undefined) {
-    const map = raw["thinkingLevelMap"];
-    if (!object(map) || !Object.entries(map).every(([key, value]) => (THINKING_LEVELS as readonly string[]).includes(key) && (value === null || typeof value === "string"))) error(`${path}.thinkingLevelMap`, "requires supported effort keys and string/null values");
-    spec.thinkingLevelMap = map as Partial<Record<Effort, string | null>>;
-  }
-  for (const key of ["compat", "nativeCompat", "samplingParams"] as const) {
-    const value = raw[key];
-    if (value !== undefined) {
-      if (!object(value)) error(`${path}.${key}`, "must be an object");
-      if (key === "samplingParams") payloadPatch(value, `${path}.${key}`);
-      else for (const [field, flag] of Object.entries(value)) {
-        if (/^(supports|requires)/.test(field) && typeof flag !== "boolean") error(`${path}.${key}.${field}`, "must be boolean");
-        if (field === "maxTokensField" && flag !== "max_tokens" && flag !== "max_completion_tokens") error(`${path}.${key}.${field}`, "must be max_tokens or max_completion_tokens");
-      }
-      if (key === "compat") {
-        spec.nativeCompat = { ...spec.nativeCompat, ...value };
-        spec.compat = { ...DEFAULT_COMPAT, ...base?.compat, ...value } as NonNullable<ModelSpec["compat"]>;
-      } else spec[key] = { ...spec[key], ...value };
-    }
-  }
-  if (raw["driver"] === "pi") spec.driver = "pi";
-  if (typeof raw["wireId"] === "string") spec.wireId = raw["wireId"];
-  return spec;
-}
-
-export function parseModelConfiguration(json: unknown, builtin: readonly ModelSpec[] = []): { models: ModelSpec[]; errors: string[] } {
-  let models = [...builtin];
-  const errors: string[] = [];
-  const report = (err: unknown) => errors.push(err instanceof Error ? err.message : "invalid model configuration");
-  if (!Array.isArray(json) && !object(json)) return { models, errors: ["user catalog must be an array or an object with models/providers/provider"] };
-  const root = object(json) ? json : {};
-  const rows = Array.isArray(json) ? json : root["models"];
-  if (rows !== undefined && !Array.isArray(rows)) errors.push("user catalog .models is not an array");
-  const indexed = new Map(models.map(model => [modelKey(model), model]));
-  if (Array.isArray(rows)) for (const [i, row] of rows.entries()) {
-    const path = `models[${i}]` + (object(row) && typeof row["id"] === "string" ? ` (${row["id"]})` : "");
-    try {
-      if (!object(row)) error(path, "must be an object");
-      if (typeof row["id"] !== "string" || !row["id"].length) error(path, "has no id");
-      if (typeof row["provider"] !== "string" || !row["provider"].length) error(path, "has no provider");
-      const id = row["id"], provider = row["provider"];
-      if (row["disabled"] === true || row["enabled"] === false) { indexed.delete(modelKey({ provider, id })); continue; }
-      const previous = indexed.get(modelKey({ provider, id }));
-      const model = modelPatch(row, previous, provider, id, path, true);
-      const access = accessPatch(row, path, previous ? providerAccess(previous) : {});
-      if (Object.keys(access).length) { model.driver = "pi"; setProviderAccess(model, access); }
-      indexed.set(modelKey(model), model);
-    } catch (err) {
-      report(err);
-      if (object(row) && typeof row["id"] === "string" && typeof row["provider"] === "string") {
-        const key = modelKey({ id: row["id"], provider: row["provider"] });
-        const previous = indexed.get(key);
-        if (previous) { const copy = { ...previous }; setProviderAccess(copy, { invalid: `${path}: invalid model configuration` }); indexed.set(key, copy); }
-      }
-    }
-  }
-  models = [...indexed.values()];
-  for (const groupKey of ["providers", "provider"] as const) {
-    const providers = root[groupKey];
-    if (providers === undefined) continue;
-    if (!object(providers)) { errors.push(`${groupKey}: must be an object`); continue; }
-    for (const [provider, config] of Object.entries(providers)) {
-      const path = `${groupKey}.${provider}`;
-      try {
-        if (!object(config)) error(path, "must be an object");
-        if (config["disabled"] === true || config["enabled"] === false) { models = models.filter(model => model.provider !== provider); continue; }
-        const access = accessPatch(config, path);
-        const allow = strings(config["allowlist"] ?? config["whitelist"], `${path}.allowlist`);
-        const deny = strings(config["denylist"] ?? config["blacklist"], `${path}.denylist`);
-        const peers: ModelSpec[] = [];
-        const defaults = { ...config }; delete defaults["name"];
-        for (const previous of models.filter(model => model.provider === provider)) {
-          const next = modelPatch(defaults, previous, provider, previous.id, path, false);
-          setProviderAccess(next, accessPatch(config, path, providerAccess(previous))); peers.push(next);
-        }
-        const definitions = config["models"];
-        if (definitions !== undefined && !Array.isArray(definitions) && !object(definitions)) error(`${path}.models`, "must be an array or object");
-        const additions: [string | undefined, unknown][] = Array.isArray(definitions) ? definitions.map(row => [undefined, row]) : object(definitions) ? Object.entries(definitions) : [];
-        const patches = config["modelOverrides"];
-        if (patches !== undefined && !object(patches)) error(`${path}.modelOverrides`, "must be an object");
-        const entries = [...additions.map(([id, row]) => ({ id, row, override: false })), ...Object.entries(object(patches) ? patches : {}).map(([id, row]) => ({ id, row, override: true }))];
-        for (const [index, entry] of entries.entries()) {
-          const label = `${path}.${entry.override ? "modelOverrides" : "models"}.${entry.id ?? index}`;
-          try {
-            if (!object(entry.row)) error(label, "must be an object");
-            const id = entry.id ?? entry.row["id"];
-            if (typeof id !== "string" || !id.length) error(label, "has no id");
-            if (entry.row["disabled"] === true || entry.row["enabled"] === false) { const at = peers.findIndex(model => model.id === id); if (at >= 0) peers.splice(at, 1); continue; }
-            const base = peers.find(model => model.id === id);
-            if (entry.override && !base) error(label, "cannot override an unknown model");
-            const inherited = base ?? modelPatch(defaults, undefined, provider, id, path, false);
-            const model = modelPatch(entry.row, inherited, provider, id, label, false);
-            if (entry.id && typeof entry.row["id"] === "string" && entry.row["id"] !== id) model.wireId = entry.row["id"];
-            setProviderAccess(model, accessPatch(entry.row, label, base ? providerAccess(base) : access));
-            const at = peers.findIndex(candidate => candidate.id === id);
-            if (at < 0) peers.push(model); else peers[at] = model;
-          } catch (err) {
-            report(err);
-            const id = entry.id ?? (object(entry.row) ? entry.row["id"] : undefined);
-            const at = peers.findIndex(model => model.id === id);
-            if (at >= 0) { const copy = { ...peers[at]! }; setProviderAccess(copy, { invalid: `${label}: invalid model configuration` }); peers[at] = copy; }
-          }
-        }
-        models = mergeCatalogs(models.filter(model => model.provider !== provider), peers.filter(model => modelEnabled(model.id, allow, deny)));
-      } catch (err) {
-        report(err);
-        // An invalid explicit provider config must not silently use a different credential/endpoint.
-        models = models.map(model => {
-          if (model.provider !== provider) return model;
-          const copy = { ...model }; setProviderAccess(copy, { invalid: `${path}: invalid provider configuration` }); return copy;
-        });
-      }
-    }
-  }
-  try {
-    const enabled = strings(root["enabled_providers"], "enabled_providers");
-    const disabled = strings(root["disabled_providers"], "disabled_providers");
-    models = models.filter(model => modelEnabled(model.provider, enabled, disabled));
-  } catch (err) { report(err); }
-  return { models, errors };
-}

package/src/runtime/model-data.LICENSE

@@ -1,27 +0,0 @@
-The generated model catalog contains data adapted from:
-
-Pi (https://github.com/earendil-works/pi)
-Copyright (c) 2025 Mario Zechner
-
-Models.dev (https://github.com/anomalyco/models.dev)
-Copyright (c) 2025 models.dev
-
-Both sources are distributed under the following MIT License:
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.