@byok-sdk/keys 0.3.9 → 0.4.0

package/dist/index.js

@@ -1,7 +1,7 @@
 import { z } from 'zod';
+import { createHash } from 'crypto';
 import { spawn } from 'child_process';
 import path, { dirname } from 'path';
-import { createHash } from 'crypto';
 import { mkdirSync, existsSync, chmodSync } from 'fs';
 import { createRequire } from 'module';
 import { isCoreConflictError, contentHash } from '@byok-sdk/core';
@@ -47,6 +47,7 @@ var BYOK_KEYS_ERROR_CODES = {
   PROVIDER_SECRET_MISSING: "PROVIDER_SECRET_MISSING",
   PROVIDER_SECRET_NOT_ALLOWED: "PROVIDER_SECRET_NOT_ALLOWED",
   PROVIDER_SECRET_ROLLBACK_FAILED: "PROVIDER_SECRET_ROLLBACK_FAILED",
+  PROVIDER_STORE_SCHEMA_STALE: "PROVIDER_STORE_SCHEMA_STALE",
   PROVIDER_STORE_UNAVAILABLE: "PROVIDER_STORE_UNAVAILABLE",
   PROVIDER_TRUTH_INVALID: "PROVIDER_TRUTH_INVALID",
   PROVIDER_URL_INVALID: "PROVIDER_URL_INVALID",
@@ -56,6 +57,89 @@ var BYOK_KEYS_ERROR_CODES = {
   SECRET_VALUE_INVALID: "SECRET_VALUE_INVALID"
 };
 
+// src/provider-catalog.ts
+function openAiCompatible(display_name, base_url, api_key_env) {
+  return {
+    display_name,
+    base_url,
+    adapter: "openai_compatible",
+    auth_mode: "bearer",
+    api_key_env
+  };
+}
+function anthropicMessages(display_name, base_url, api_key_env) {
+  return {
+    display_name,
+    base_url,
+    adapter: "anthropic",
+    auth_mode: "x_api_key",
+    api_key_env
+  };
+}
+var MODEL_PROVIDER_VENDORS = {
+  "ant-ling": openAiCompatible("Ant Ling", "https://api.ant-ling.com/v1", "ANT_LING_API_KEY"),
+  baseten: openAiCompatible("Baseten", "https://inference.baseten.co/v1", "BASETEN_API_KEY"),
+  cerebras: openAiCompatible("Cerebras", "https://api.cerebras.ai/v1", "CEREBRAS_API_KEY"),
+  deepseek: openAiCompatible("DeepSeek", "https://api.deepseek.com", "DEEPSEEK_API_KEY"),
+  groq: openAiCompatible("Groq", "https://api.groq.com/openai/v1", "GROQ_API_KEY"),
+  huggingface: openAiCompatible("Hugging Face", "https://router.huggingface.co/v1", "HF_TOKEN"),
+  moonshotai: openAiCompatible("Moonshot AI", "https://api.moonshot.ai/v1", "MOONSHOT_API_KEY"),
+  "moonshotai-cn": openAiCompatible("Moonshot AI CN", "https://api.moonshot.cn/v1", "MOONSHOT_API_KEY"),
+  nvidia: openAiCompatible("NVIDIA", "https://integrate.api.nvidia.com/v1", "NVIDIA_API_KEY"),
+  openai: openAiCompatible("OpenAI", "https://api.openai.com/v1", "OPENAI_API_KEY"),
+  openrouter: openAiCompatible("OpenRouter", "https://openrouter.ai/api/v1", "OPENROUTER_API_KEY"),
+  "qwen-token-plan": openAiCompatible(
+    "Qwen Token Plan",
+    "https://token-plan.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1",
+    "QWEN_TOKEN_PLAN_API_KEY"
+  ),
+  "qwen-token-plan-cn": openAiCompatible(
+    "Qwen Token Plan CN",
+    "https://token-plan.cn-beijing.maas.aliyuncs.com/compatible-mode/v1",
+    "QWEN_TOKEN_PLAN_CN_API_KEY"
+  ),
+  together: openAiCompatible("Together", "https://api.together.ai/v1", "TOGETHER_API_KEY"),
+  xai: openAiCompatible("xAI", "https://api.x.ai/v1", "XAI_API_KEY"),
+  xiaomi: openAiCompatible("Xiaomi", "https://api.xiaomimimo.com/v1", "XIAOMI_API_KEY"),
+  "xiaomi-token-plan-ams": openAiCompatible(
+    "Xiaomi Token Plan AMS",
+    "https://token-plan-ams.xiaomimimo.com/v1",
+    "XIAOMI_TOKEN_PLAN_AMS_API_KEY"
+  ),
+  "xiaomi-token-plan-cn": openAiCompatible(
+    "Xiaomi Token Plan CN",
+    "https://token-plan-cn.xiaomimimo.com/v1",
+    "XIAOMI_TOKEN_PLAN_CN_API_KEY"
+  ),
+  "xiaomi-token-plan-sgp": openAiCompatible(
+    "Xiaomi Token Plan SGP",
+    "https://token-plan-sgp.xiaomimimo.com/v1",
+    "XIAOMI_TOKEN_PLAN_SGP_API_KEY"
+  ),
+  zai: openAiCompatible("Z.AI", "https://api.z.ai/api/coding/paas/v4", "ZAI_API_KEY"),
+  "zai-coding-cn": openAiCompatible(
+    "Z.AI Coding CN",
+    "https://open.bigmodel.cn/api/coding/paas/v4",
+    "ZAI_CODING_CN_API_KEY"
+  ),
+  anthropic: anthropicMessages("Anthropic", "https://api.anthropic.com/v1", "ANTHROPIC_API_KEY"),
+  fireworks: anthropicMessages("Fireworks", "https://api.fireworks.ai/inference/v1", "FIREWORKS_API_KEY"),
+  "kimi-coding": anthropicMessages("Kimi For Coding", "https://api.kimi.com/coding/v1", "KIMI_API_KEY"),
+  minimax: anthropicMessages("MiniMax", "https://api.minimax.io/anthropic/v1", "MINIMAX_API_KEY"),
+  "minimax-cn": anthropicMessages("MiniMax CN", "https://api.minimaxi.com/anthropic/v1", "MINIMAX_CN_API_KEY"),
+  "vercel-ai-gateway": anthropicMessages(
+    "Vercel AI Gateway",
+    "https://ai-gateway.vercel.sh/v1",
+    "AI_GATEWAY_API_KEY"
+  )
+};
+var MODEL_PROVIDER_VENDOR_IDS = Object.keys(
+  MODEL_PROVIDER_VENDORS
+);
+function modelProviderVendor(kind) {
+  return Object.hasOwn(MODEL_PROVIDER_VENDORS, kind) ? MODEL_PROVIDER_VENDORS[kind] : void 0;
+}
+
 // src/url.ts
 function normalizeProviderUrl(value) {
   let url;
@@ -99,12 +183,17 @@ function isPrivateNetworkLiteral(hostname) {
 }
 
 // src/provider-profile.ts
-var MODEL_PROVIDER_IDS = [
-  "openai",
-  "deepseek",
-  "anthropic",
+var PROVIDER_PROFILE_REF_PATTERN = /^[a-z0-9]+(?:[-_][a-z0-9]+)*$/u;
+var ProviderProfileRefSchema = z.string().min(1).max(64).regex(
+  PROVIDER_PROFILE_REF_PATTERN,
+  "provider profile refs must be lowercase portable identifiers"
+);
+var MODEL_PROVIDER_KINDS = [
+  ...MODEL_PROVIDER_VENDOR_IDS,
   "custom"
 ];
+var PROVIDER_MODEL_CAPABILITIES = ["image-input"];
+var ProviderModelCapabilitySchema = z.enum(PROVIDER_MODEL_CAPABILITIES);
 var PROVIDER_AUTH_MODES = ["bearer", "x_api_key", "none"];
 var MODEL_PROVIDER_ADAPTERS = ["openai_compatible", "anthropic"];
 function boundedString(field, maximumLength) {
@@ -144,14 +233,23 @@ var ModelProviderProfileSchema = z.object({
   adapter: z.enum(MODEL_PROVIDER_ADAPTERS),
   auth_mode: z.enum(PROVIDER_AUTH_MODES),
   base_url: providerBaseUrl,
+  capabilities: z.array(ProviderModelCapabilitySchema).max(8),
   created_at: isoTimestamp("created_at"),
   display_name: boundedString("display_name", 100),
   enabled: z.boolean(),
   kind: z.literal("model"),
   model: boundedString("model", 160),
-  provider_id: z.enum(MODEL_PROVIDER_IDS),
+  profile_ref: ProviderProfileRefSchema,
+  provider_kind: z.enum(MODEL_PROVIDER_KINDS),
   updated_at: isoTimestamp("updated_at")
 }).superRefine((profile, ctx) => {
+  if (new Set(profile.capabilities).size !== profile.capabilities.length) {
+    ctx.addIssue({
+      code: "custom",
+      message: "Provider capabilities cannot repeat",
+      path: ["capabilities"]
+    });
+  }
   if (profile.adapter === "anthropic" && profile.auth_mode !== "x_api_key") {
     ctx.addIssue({
       code: "custom",
@@ -166,6 +264,14 @@ var ModelProviderProfileSchema = z.object({
       path: ["auth_mode"]
     });
   }
+  const vendor = modelProviderVendor(profile.provider_kind);
+  if (vendor !== void 0 && vendor.adapter !== profile.adapter) {
+    ctx.addIssue({
+      code: "custom",
+      message: `Provider kind ${profile.provider_kind} speaks the ${vendor.adapter} adapter`,
+      path: ["adapter"]
+    });
+  }
   if (Date.parse(profile.updated_at) < Date.parse(profile.created_at)) {
     ctx.addIssue({
       code: "custom",
@@ -174,6 +280,47 @@ var ModelProviderProfileSchema = z.object({
     });
   }
 });
+function exactProviderProfileBinding(profileInput, requiredCapabilities = profileInput.capabilities) {
+  const profile = parseModelProviderProfile(profileInput);
+  const revision = Date.parse(profile.updated_at);
+  if (!Number.isSafeInteger(revision) || revision < 0) {
+    throw new ByokKeysError(
+      "PROVIDER_PROFILE_INVALID",
+      "Provider updated_at cannot be represented as a canonical revision"
+    );
+  }
+  const normalizedCapabilities = [...profile.capabilities].sort();
+  const canonical = JSON.stringify({
+    adapter: profile.adapter,
+    auth_mode: profile.auth_mode,
+    base_url: profile.base_url,
+    capabilities: normalizedCapabilities,
+    kind: profile.kind,
+    model: profile.model,
+    profile_ref: profile.profile_ref,
+    provider_kind: profile.provider_kind
+  });
+  return {
+    profileRef: profile.profile_ref,
+    profileRevision: String(revision),
+    profileHash: `sha256:${createHash("sha256").update(canonical).digest("hex")}`,
+    modelId: profile.model,
+    requiredCapabilities: [...requiredCapabilities]
+  };
+}
+function assertExactProviderProfileBinding(profile, expected) {
+  if (new Set(expected.requiredCapabilities).size !== expected.requiredCapabilities.length) {
+    throw new Error("provider profile required capabilities must be unique");
+  }
+  const actual = exactProviderProfileBinding(profile, expected.requiredCapabilities);
+  if (actual.profileRef !== expected.profileRef) throw new Error("provider profile ref mismatch");
+  if (actual.profileRevision !== expected.profileRevision) throw new Error("provider profile revision mismatch");
+  if (actual.profileHash !== expected.profileHash) throw new Error("provider profile hash mismatch");
+  if (actual.modelId !== expected.modelId) throw new Error("provider profile model mismatch");
+  const supported = new Set(profile.capabilities);
+  const unsupported = expected.requiredCapabilities.find((capability) => !supported.has(capability));
+  if (unsupported !== void 0) throw new Error(`provider profile does not support required capability ${unsupported}`);
+}
 function parseModelProviderProfile(value) {
   const result = ModelProviderProfileSchema.safeParse(value);
   if (result.success) return result.data;
@@ -527,14 +674,16 @@ function assertSecretNamespace(value) {
 
 // src/secret-store.ts
 var DEFAULT_SECRET_SERVICE_PREFIX = "com.byok.keys";
-var MODEL_PROVIDER_SECRET_NAMES = {
-  anthropic: "model-anthropic-api-key",
-  custom: "model-custom-api-key",
-  deepseek: "model-deepseek-api-key",
-  openai: "model-openai-api-key"
-};
-function modelProviderSecretName(providerId) {
-  return MODEL_PROVIDER_SECRET_NAMES[providerId];
+function modelProviderSecretName(profileRef) {
+  const parsed = ProviderProfileRefSchema.safeParse(profileRef);
+  if (!parsed.success) {
+    throw new ByokKeysError(
+      "PROVIDER_PROFILE_INVALID",
+      "Provider profile ref must be a lowercase portable identifier",
+      { cause: parsed.error }
+    );
+  }
+  return assertSecretName(`model-${parsed.data}-api-key`);
 }
 function assertSharedSecretValue(secret) {
   if (secret.length === 0 || /[\u0000\r\n]/u.test(secret)) {
@@ -1143,10 +1292,10 @@ function normalizeSecretScope(scope) {
 }
 
 // src/profile-store.ts
-function providerNotConfigured(providerId) {
+function providerNotConfigured(profileRef) {
   return new ByokKeysError(
     "PROVIDER_NOT_CONFIGURED",
-    `${providerId} model provider is not configured`
+    `${profileRef} model provider is not configured`
   );
 }
 var InMemoryProviderProfileStore = class {
@@ -1154,38 +1303,38 @@ var InMemoryProviderProfileStore = class {
   async close() {
     this.#profiles.clear();
   }
-  async delete(providerId) {
-    return this.#profiles.delete(providerId);
+  async delete(profileRef) {
+    return this.#profiles.delete(profileRef);
   }
-  async get(providerId) {
-    return this.#profiles.get(providerId);
+  async get(profileRef) {
+    return this.#profiles.get(profileRef);
   }
   async getEnabled() {
     return [...this.#profiles.values()].find((profile) => profile.enabled);
   }
   async list() {
     return [...this.#profiles.values()].sort(
-      (left, right) => left.provider_id.localeCompare(right.provider_id)
+      (left, right) => left.profile_ref.localeCompare(right.profile_ref)
     );
   }
   async save(profile) {
     const validated = parseModelProviderProfile({
       ...profile,
-      created_at: this.#profiles.get(profile.provider_id)?.created_at ?? profile.created_at
+      created_at: this.#profiles.get(profile.profile_ref)?.created_at ?? profile.created_at
     });
     if (validated.enabled) {
-      for (const [providerId, existing] of this.#profiles) {
-        if (providerId !== validated.provider_id && existing.enabled) {
-          this.#profiles.set(providerId, { ...existing, enabled: false });
+      for (const [profileRef, existing] of this.#profiles) {
+        if (profileRef !== validated.profile_ref && existing.enabled) {
+          this.#profiles.set(profileRef, { ...existing, enabled: false });
         }
       }
     }
-    this.#profiles.set(validated.provider_id, validated);
+    this.#profiles.set(validated.profile_ref, validated);
     return validated;
   }
-  async setEnabled(providerId) {
-    const existing = this.#profiles.get(providerId);
-    if (existing === void 0) throw providerNotConfigured(providerId);
+  async setEnabled(profileRef) {
+    const existing = this.#profiles.get(profileRef);
+    if (existing === void 0) throw providerNotConfigured(profileRef);
     return this.save({ ...existing, enabled: true });
   }
 };
@@ -1261,20 +1410,40 @@ function secureSqliteFilePermissions(databasePath) {
 }
 
 // src/sqlite-profile-store.ts
+function sqlList(values) {
+  return values.map((value) => `'${value}'`).join(", ");
+}
 var SCHEMA = `
 CREATE TABLE IF NOT EXISTS provider_profile (
-  provider_id  TEXT PRIMARY KEY CHECK (provider_id IN ('openai', 'deepseek', 'anthropic', 'custom')),
-  kind         TEXT NOT NULL CHECK (kind = 'model'),
-  adapter      TEXT NOT NULL CHECK (adapter IN ('openai_compatible', 'anthropic')),
-  display_name TEXT NOT NULL,
-  base_url     TEXT NOT NULL,
-  auth_mode    TEXT NOT NULL CHECK (auth_mode IN ('bearer', 'x_api_key', 'none')),
-  model        TEXT NOT NULL,
-  enabled      INTEGER NOT NULL CHECK (enabled IN (0, 1)),
-  created_at   TEXT NOT NULL,
-  updated_at   TEXT NOT NULL
+  profile_ref   TEXT PRIMARY KEY,
+  provider_kind TEXT NOT NULL CHECK (provider_kind IN (${sqlList(MODEL_PROVIDER_KINDS)})),
+  kind          TEXT NOT NULL CHECK (kind = 'model'),
+  adapter       TEXT NOT NULL CHECK (adapter IN (${sqlList(MODEL_PROVIDER_ADAPTERS)})),
+  display_name  TEXT NOT NULL,
+  base_url      TEXT NOT NULL,
+  auth_mode     TEXT NOT NULL CHECK (auth_mode IN (${sqlList(PROVIDER_AUTH_MODES)})),
+  model         TEXT NOT NULL,
+  capabilities  TEXT NOT NULL,
+  enabled       INTEGER NOT NULL CHECK (enabled IN (0, 1)),
+  created_at    TEXT NOT NULL,
+  updated_at    TEXT NOT NULL
 );
 `;
+function normalizeTableDdl(sql) {
+  return sql.replace(/\bIF\s+NOT\s+EXISTS\b/giu, "").replace(/\s+/gu, " ").trim().replace(/;$/u, "").trim();
+}
+function assertProviderProfileSchemaIsCurrent(database, path2) {
+  const row = database.prepare(
+    "SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'provider_profile'"
+  ).get();
+  const stored = row?.sql;
+  if (typeof stored !== "string") return;
+  if (normalizeTableDdl(stored) === normalizeTableDdl(SCHEMA)) return;
+  throw new ByokKeysError(
+    "PROVIDER_STORE_SCHEMA_STALE",
+    `Provider profile store at ${path2} was created by a different @byok-sdk/keys schema; recreate the store file to continue`
+  );
+}
 var ENABLED_INDEX = `
 CREATE UNIQUE INDEX IF NOT EXISTS provider_profile_one_enabled
 ON provider_profile(kind)
@@ -1291,6 +1460,7 @@ var SqliteProviderProfileStore = class {
       try {
         this.#database.exec(SCHEMA);
         this.#database.exec(ENABLED_INDEX);
+        assertProviderProfileSchemaIsCurrent(this.#database, options.path);
         secureSqliteFilePermissions(options.path);
       } catch (error) {
         closeSqliteDatabaseAfterInitializationFailure(
@@ -1299,6 +1469,16 @@ var SqliteProviderProfileStore = class {
           "SqliteProviderProfileStore initialization failed and its native handle could not be closed"
         );
       }
+    } else {
+      try {
+        assertProviderProfileSchemaIsCurrent(this.#database, options.path);
+      } catch (error) {
+        closeSqliteDatabaseAfterInitializationFailure(
+          this.#database,
+          error,
+          "SqliteProviderProfileStore read-only schema check failed and its native handle could not be closed"
+        );
+      }
     }
   }
   /**
@@ -1312,12 +1492,12 @@ var SqliteProviderProfileStore = class {
     this.#closed = true;
     this.#database.close();
   }
-  async delete(providerId) {
-    const result = this.#database.prepare("DELETE FROM provider_profile WHERE provider_id = ?").run(providerId);
+  async delete(profileRef) {
+    const result = this.#database.prepare("DELETE FROM provider_profile WHERE profile_ref = ?").run(profileRef);
     return Number(result.changes) === 1;
   }
-  async get(providerId) {
-    const row = this.#database.prepare("SELECT * FROM provider_profile WHERE provider_id = ?").get(providerId);
+  async get(profileRef) {
+    const row = this.#database.prepare("SELECT * FROM provider_profile WHERE profile_ref = ?").get(profileRef);
     return row === void 0 ? void 0 : parseRow(row);
   }
   async getEnabled() {
@@ -1325,11 +1505,11 @@ var SqliteProviderProfileStore = class {
     return row === void 0 ? void 0 : parseRow(row);
   }
   async list() {
-    const rows = this.#database.prepare("SELECT * FROM provider_profile ORDER BY provider_id ASC").all();
+    const rows = this.#database.prepare("SELECT * FROM provider_profile ORDER BY profile_ref ASC").all();
     return rows.map(parseRow);
   }
   async save(profile) {
-    const existing = await this.get(profile.provider_id);
+    const existing = await this.get(profile.profile_ref);
     const validated = parseModelProviderProfile({
       ...profile,
       created_at: existing?.created_at ?? profile.created_at
@@ -1337,40 +1517,44 @@ var SqliteProviderProfileStore = class {
     this.#transaction(() => {
       if (validated.enabled) {
         this.#database.prepare(
-          "UPDATE provider_profile SET enabled = 0 WHERE provider_id <> ?"
-        ).run(validated.provider_id);
+          "UPDATE provider_profile SET enabled = 0 WHERE profile_ref <> ?"
+        ).run(validated.profile_ref);
       }
       this.#database.prepare(
         `INSERT INTO provider_profile (
-             provider_id, kind, adapter, display_name, base_url,
-             auth_mode, model, enabled, created_at, updated_at
-           ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-           ON CONFLICT(provider_id) DO UPDATE SET
+             profile_ref, provider_kind, kind, adapter, display_name, base_url,
+             auth_mode, model, capabilities, enabled, created_at, updated_at
+           ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+           ON CONFLICT(profile_ref) DO UPDATE SET
+             provider_kind = excluded.provider_kind,
              adapter = excluded.adapter,
              display_name = excluded.display_name,
              base_url = excluded.base_url,
              auth_mode = excluded.auth_mode,
              model = excluded.model,
+             capabilities = excluded.capabilities,
              enabled = excluded.enabled,
              updated_at = excluded.updated_at`
       ).run(
-        validated.provider_id,
+        validated.profile_ref,
+        validated.provider_kind,
         validated.kind,
         validated.adapter,
         validated.display_name,
         validated.base_url,
         validated.auth_mode,
         validated.model,
+        JSON.stringify(validated.capabilities),
         validated.enabled ? 1 : 0,
         validated.created_at,
         validated.updated_at
       );
     });
-    return await this.get(validated.provider_id);
+    return await this.get(validated.profile_ref);
   }
-  async setEnabled(providerId) {
-    const existing = await this.get(providerId);
-    if (existing === void 0) throw providerNotConfigured(providerId);
+  async setEnabled(profileRef) {
+    const existing = await this.get(profileRef);
+    if (existing === void 0) throw providerNotConfigured(profileRef);
     return this.save({ ...existing, enabled: true });
   }
   /** `BEGIN IMMEDIATE` / `COMMIT` / `ROLLBACK`, per `providers.ts:1252-1263`. */
@@ -1386,8 +1570,19 @@ var SqliteProviderProfileStore = class {
   }
 };
 function parseRow(row) {
+  let capabilities;
+  try {
+    capabilities = JSON.parse(row.capabilities);
+  } catch (cause) {
+    throw new ByokKeysError(
+      "PROVIDER_PROFILE_INVALID",
+      "Provider profile capabilities column is not valid JSON",
+      { cause }
+    );
+  }
   return parseModelProviderProfile({
     ...row,
+    capabilities,
     enabled: row.enabled === 1
   });
 }
@@ -1396,14 +1591,17 @@ var PROFILE_KEYS = [
   "adapter",
   "auth_mode",
   "base_url",
+  "capabilities",
   "created_at",
   "display_name",
   "enabled",
   "kind",
   "model",
-  "provider_id",
+  "profile_ref",
+  "provider_kind",
   "updated_at"
 ];
+var MAX_PROVIDER_PROFILES = 32;
 var TruthStoreProviderProfileStore = class {
   #tenant;
   #truth;
@@ -1413,20 +1611,20 @@ var TruthStoreProviderProfileStore = class {
   }
   async close() {
   }
-  async delete(providerId) {
+  async delete(profileRef) {
     const current = await this.#load();
-    if (!current.profiles.some((profile) => profile.provider_id === providerId)) {
+    if (!current.profiles.some((profile) => profile.profile_ref === profileRef)) {
       return false;
     }
     await this.#write(
-      current.profiles.filter((profile) => profile.provider_id !== providerId),
+      current.profiles.filter((profile) => profile.profile_ref !== profileRef),
       current.rev
     );
     return true;
   }
-  async get(providerId) {
+  async get(profileRef) {
     return (await this.#load()).profiles.find(
-      (profile) => profile.provider_id === providerId
+      (profile) => profile.profile_ref === profileRef
     );
   }
   async getEnabled() {
@@ -1438,28 +1636,28 @@ var TruthStoreProviderProfileStore = class {
   async save(profile) {
     const current = await this.#load();
     const existing = current.profiles.find(
-      (candidate) => candidate.provider_id === profile.provider_id
+      (candidate) => candidate.profile_ref === profile.profile_ref
     );
     const validated = parseModelProviderProfile({
       ...profile,
       created_at: existing?.created_at ?? profile.created_at
     });
-    const next = current.profiles.filter((candidate) => candidate.provider_id !== validated.provider_id).map(
+    const next = current.profiles.filter((candidate) => candidate.profile_ref !== validated.profile_ref).map(
       (candidate) => validated.enabled && candidate.enabled ? { ...candidate, enabled: false } : candidate
     );
     next.push(validated);
     await this.#write(next, current.rev);
     return validated;
   }
-  async setEnabled(providerId) {
+  async setEnabled(profileRef) {
     const current = await this.#load();
     const selected = current.profiles.find(
-      (profile) => profile.provider_id === providerId
+      (profile) => profile.profile_ref === profileRef
     );
-    if (selected === void 0) throw providerNotConfigured(providerId);
+    if (selected === void 0) throw providerNotConfigured(profileRef);
     const next = current.profiles.map((profile) => ({
       ...profile,
-      enabled: profile.provider_id === providerId
+      enabled: profile.profile_ref === profileRef
     }));
     await this.#write(next, current.rev);
     return { ...selected, enabled: true };
@@ -1505,7 +1703,7 @@ var TruthStoreProviderProfileStore = class {
   }
 };
 function encodeRegistry(profiles) {
-  const normalized = profiles.map((profile) => parseModelProviderProfile(profile)).sort((left, right) => left.provider_id.localeCompare(right.provider_id));
+  const normalized = profiles.map((profile) => parseModelProviderProfile(profile)).sort((left, right) => left.profile_ref.localeCompare(right.profile_ref));
   assertRegistryInvariants(normalized);
   const snapshot = {
     schema_version: 1,
@@ -1513,12 +1711,14 @@ function encodeRegistry(profiles) {
       adapter: profile.adapter,
       auth_mode: profile.auth_mode,
       base_url: profile.base_url,
+      capabilities: profile.capabilities,
       created_at: profile.created_at,
       display_name: profile.display_name,
       enabled: profile.enabled,
       kind: profile.kind,
       model: profile.model,
-      provider_id: profile.provider_id,
+      profile_ref: profile.profile_ref,
+      provider_kind: profile.provider_kind,
       updated_at: profile.updated_at
     }))
   };
@@ -1550,7 +1750,7 @@ function decodeRegistryRecord(record, tenant) {
   if (raw.schema_version !== 1 || !Array.isArray(raw.profiles)) {
     throw invalidTruth("Provider profile TruthStore body has an unsupported schema");
   }
-  if (raw.profiles.length > MODEL_PROVIDER_IDS.length) {
+  if (raw.profiles.length > MAX_PROVIDER_PROFILES) {
     throw invalidTruth("Provider profile TruthStore body exceeds the provider registry bound");
   }
   let profiles;
@@ -1577,10 +1777,10 @@ function assertRegistryInvariants(profiles) {
   const seen = /* @__PURE__ */ new Set();
   let enabled = 0;
   for (const profile of profiles) {
-    if (seen.has(profile.provider_id)) {
-      throw invalidTruth(`Provider profile ${profile.provider_id} appears more than once`);
+    if (seen.has(profile.profile_ref)) {
+      throw invalidTruth(`Provider profile ${profile.profile_ref} appears more than once`);
     }
-    seen.add(profile.provider_id);
+    seen.add(profile.profile_ref);
     if (profile.enabled) enabled += 1;
   }
   if (enabled > 1) {
@@ -1630,16 +1830,23 @@ var ProviderRegistry = class {
    * authentication it cannot perform.
    */
   async configure(configuration, secret) {
-    const timestamp = this.#now().toISOString();
-    const previous = await this.#profiles.get(configuration.provider_id);
+    const previous = await this.#profiles.get(configuration.profile_ref);
+    const observedNow = this.#now().getTime();
+    const previousRevision = previous === void 0 ? void 0 : Date.parse(previous.updated_at);
+    const revision = previousRevision === void 0 ? observedNow : Math.max(observedNow, previousRevision + 1);
+    if (!Number.isSafeInteger(revision) || revision < 0) {
+      throw new ByokKeysError("PROVIDER_PROFILE_INVALID", "Provider clock cannot produce a monotonic profile revision");
+    }
+    const timestamp = new Date(revision).toISOString();
     const profile = parseModelProviderProfile({
       ...configuration,
+      capabilities: [...configuration.capabilities],
       created_at: previous?.created_at ?? timestamp,
       enabled: configuration.enabled ?? true,
       kind: "model",
       updated_at: timestamp
     });
-    const secretName = modelProviderSecretName(configuration.provider_id);
+    const secretName = modelProviderSecretName(configuration.profile_ref);
     let previousSecret;
     let secretWritten = false;
     if (configuration.auth_mode === "none" && secret !== void 0) {
@@ -1691,14 +1898,14 @@ var ProviderRegistry = class {
     }
     return this.#status(saved);
   }
-  /** Remove a provider's profile and its secret together. */
-  async delete(providerId) {
-    const removed = await this.#profiles.delete(providerId);
-    await this.#secrets.delete(modelProviderSecretName(providerId));
+  /** Remove a profile and its secret together. */
+  async delete(profileRef) {
+    const removed = await this.#profiles.delete(profileRef);
+    await this.#secrets.delete(modelProviderSecretName(profileRef));
     return removed;
   }
-  async get(providerId) {
-    const profile = await this.#profiles.get(providerId);
+  async get(profileRef) {
+    const profile = await this.#profiles.get(profileRef);
     return profile === void 0 ? void 0 : this.#status(profile);
   }
   async list() {
@@ -1717,27 +1924,32 @@ var ProviderRegistry = class {
     const profile = await this.#profiles.getEnabled();
     if (profile === void 0) return void 0;
     const secret = await this.#secrets.get(
-      modelProviderSecretName(profile.provider_id)
+      modelProviderSecretName(profile.profile_ref)
     );
     const options = { fetchImpl: this.#fetch, profile, secret };
     return profile.adapter === "anthropic" ? new AnthropicMessagesClient(options) : new OpenAiCompatibleChatClient(options);
   }
-  /** Switch which configured provider is the default. */
-  async setDefaultModelProvider(providerId) {
-    return this.#status(await this.#profiles.setEnabled(providerId));
+  /** Switch which configured profile is the default. */
+  async setDefaultModelProvider(profileRef) {
+    return this.#status(await this.#profiles.setEnabled(profileRef));
   }
   async #status(profile) {
+    const binding = exactProviderProfileBinding(profile, []);
     return {
       adapter: profile.adapter,
       auth_mode: profile.auth_mode,
       base_url: profile.base_url,
+      capabilities: profile.capabilities,
       created_at: profile.created_at,
       display_name: profile.display_name,
       enabled: profile.enabled,
       model: profile.model,
-      provider_id: profile.provider_id,
+      profile_ref: profile.profile_ref,
+      profile_revision: binding.profileRevision,
+      profile_hash: binding.profileHash,
+      provider_kind: profile.provider_kind,
       secret_configured: await this.#secrets.has(
-        modelProviderSecretName(profile.provider_id)
+        modelProviderSecretName(profile.profile_ref)
       ),
       updated_at: profile.updated_at
     };
@@ -1746,11 +1958,11 @@ var ProviderRegistry = class {
 
 // src/pi-provider-projection.ts
 var PI_PROJECTED_KEY_ENV = "PI_PROVIDER_API_KEY";
-function piProjectionProviderId(profileProviderId) {
-  return `byok-sdk-${profileProviderId}`;
+function piProjectionProviderId(profileRef) {
+  return `byok-sdk-${profileRef}`;
 }
 function buildPiProviderProjection(profile) {
-  const projectedProviderId = piProjectionProviderId(profile.provider_id);
+  const projectedProviderId = piProjectionProviderId(profile.profile_ref);
   return {
     providers: {
       [projectedProviderId]: {
@@ -1761,7 +1973,11 @@ function buildPiProviderProjection(profile) {
         models: [
           {
             id: profile.model,
-            name: profile.display_name
+            name: profile.display_name,
+            input: [
+              "text",
+              ...profile.capabilities.includes("image-input") ? ["image"] : []
+            ]
           }
         ]
       }
@@ -1769,6 +1985,6 @@ function buildPiProviderProjection(profile) {
   };
 }
 
-export { AnthropicMessagesClient, BYOK_KEYS_ERROR_CODES, ByokKeysError, DEFAULT_KEYCHAIN_SECRET_STORAGE_PREFIX, DEFAULT_SECRET_ENVELOPE_PREFIX, DEFAULT_SECRET_SERVICE_PREFIX, EnvelopeScopedSecretStore, InMemoryProviderProfileStore, InMemorySecretStore, MODEL_PROVIDER_ADAPTERS, MODEL_PROVIDER_IDS, MODEL_PROVIDER_SECRET_NAMES, MacOsKeychainSecretStore, ModelProviderProfileSchema, OpenAiCompatibleChatClient, PI_PROJECTED_KEY_ENV, PROVIDER_AUTH_MODES, PROVIDER_PROFILE_TRUTH_RECORD_KEY, PROVIDER_RESPONSE_MAX_BYTES, PROVIDER_TIMEOUT_MS, ProviderRegistry, SECRET_NAMESPACE_PATTERN, SECRET_NAME_PATTERN, SqliteProviderProfileStore, TruthStoreProviderProfileStore, WindowsCredentialManagerSecretStore, anthropicMessageText, assertLiveModelResponse, assertSecretName, assertSecretNamespace, assertSharedSecretValue, buildPiProviderProjection, chatCompletionText, classifyModelProviderHttpError, decodeStrictBase64Utf8, fetchWithProviderGuards, isLoopbackHost, isLoopbackProviderUrl, isPrivateNetworkLiteral, isSqliteAvailable, loadSqliteModule, modelApiUrl, modelMessageText, modelProviderSecretName, normalizeProviderUrl, objectValue, openSqliteDatabase, parseBoundedJsonResponse, parseModelProviderProfile, providerHeaders, readModelProviderResponse, requiredProviderSecret, runCommand, scopeSecretStore, secretScopeId, secureSqliteFilePermissions };
+export { AnthropicMessagesClient, BYOK_KEYS_ERROR_CODES, ByokKeysError, DEFAULT_KEYCHAIN_SECRET_STORAGE_PREFIX, DEFAULT_SECRET_ENVELOPE_PREFIX, DEFAULT_SECRET_SERVICE_PREFIX, EnvelopeScopedSecretStore, InMemoryProviderProfileStore, InMemorySecretStore, MODEL_PROVIDER_ADAPTERS, MODEL_PROVIDER_KINDS, MODEL_PROVIDER_VENDORS, MODEL_PROVIDER_VENDOR_IDS, MacOsKeychainSecretStore, ModelProviderProfileSchema, OpenAiCompatibleChatClient, PI_PROJECTED_KEY_ENV, PROVIDER_AUTH_MODES, PROVIDER_MODEL_CAPABILITIES, PROVIDER_PROFILE_TRUTH_RECORD_KEY, PROVIDER_RESPONSE_MAX_BYTES, PROVIDER_TIMEOUT_MS, ProviderModelCapabilitySchema, ProviderProfileRefSchema, ProviderRegistry, SECRET_NAMESPACE_PATTERN, SECRET_NAME_PATTERN, SqliteProviderProfileStore, TruthStoreProviderProfileStore, WindowsCredentialManagerSecretStore, anthropicMessageText, assertExactProviderProfileBinding, assertLiveModelResponse, assertSecretName, assertSecretNamespace, assertSharedSecretValue, buildPiProviderProjection, chatCompletionText, classifyModelProviderHttpError, decodeStrictBase64Utf8, exactProviderProfileBinding, fetchWithProviderGuards, isLoopbackHost, isLoopbackProviderUrl, isPrivateNetworkLiteral, isSqliteAvailable, loadSqliteModule, modelApiUrl, modelMessageText, modelProviderSecretName, modelProviderVendor, normalizeProviderUrl, objectValue, openSqliteDatabase, parseBoundedJsonResponse, parseModelProviderProfile, providerHeaders, readModelProviderResponse, requiredProviderSecret, runCommand, scopeSecretStore, secretScopeId, secureSqliteFilePermissions };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map