@byok-sdk/keys 0.1.0

package/dist/index.js

@@ -0,0 +1,1462 @@
+import { z } from 'zod';
+import { spawn } from 'child_process';
+import { createHash } from 'crypto';
+import { mkdirSync, existsSync, chmodSync } from 'fs';
+import { createRequire } from 'module';
+import { dirname } from 'path';
+
+// src/errors.ts
+var ByokKeysError = class extends Error {
+  code;
+  httpStatus;
+  constructor(code, message, options) {
+    super(message, options);
+    this.name = "ByokKeysError";
+    this.code = code;
+    this.httpStatus = options?.httpStatus;
+  }
+};
+var BYOK_KEYS_ERROR_CODES = {
+  CREDENTIAL_MANAGER_DELETE_FAILED: "CREDENTIAL_MANAGER_DELETE_FAILED",
+  CREDENTIAL_MANAGER_READ_FAILED: "CREDENTIAL_MANAGER_READ_FAILED",
+  CREDENTIAL_MANAGER_SECRET_INVALID: "CREDENTIAL_MANAGER_SECRET_INVALID",
+  CREDENTIAL_MANAGER_UNAVAILABLE: "CREDENTIAL_MANAGER_UNAVAILABLE",
+  CREDENTIAL_MANAGER_WRITE_FAILED: "CREDENTIAL_MANAGER_WRITE_FAILED",
+  KEYCHAIN_ARGUMENT_INVALID: "KEYCHAIN_ARGUMENT_INVALID",
+  KEYCHAIN_DELETE_FAILED: "KEYCHAIN_DELETE_FAILED",
+  KEYCHAIN_READ_FAILED: "KEYCHAIN_READ_FAILED",
+  KEYCHAIN_SECRET_DECODE_FAILED: "KEYCHAIN_SECRET_DECODE_FAILED",
+  KEYCHAIN_SECRET_INVALID: "KEYCHAIN_SECRET_INVALID",
+  KEYCHAIN_UNAVAILABLE: "KEYCHAIN_UNAVAILABLE",
+  KEYCHAIN_WRITE_FAILED: "KEYCHAIN_WRITE_FAILED",
+  LOCAL_ACCOUNT_SCOPE_INVALID: "LOCAL_ACCOUNT_SCOPE_INVALID",
+  MODEL_PROVIDER_AUTH_FAILED: "MODEL_PROVIDER_AUTH_FAILED",
+  MODEL_PROVIDER_BALANCE_INSUFFICIENT: "MODEL_PROVIDER_BALANCE_INSUFFICIENT",
+  MODEL_PROVIDER_HTTP_ERROR: "MODEL_PROVIDER_HTTP_ERROR",
+  MODEL_PROVIDER_MODEL_NOT_FOUND: "MODEL_PROVIDER_MODEL_NOT_FOUND",
+  MODEL_PROVIDER_RATE_LIMITED: "MODEL_PROVIDER_RATE_LIMITED",
+  MODEL_RESPONSE_INVALID: "MODEL_RESPONSE_INVALID",
+  PROVIDER_NOT_CONFIGURED: "PROVIDER_NOT_CONFIGURED",
+  PROVIDER_PROFILE_INVALID: "PROVIDER_PROFILE_INVALID",
+  PROVIDER_REQUEST_TIMEOUT: "PROVIDER_REQUEST_TIMEOUT",
+  PROVIDER_RESPONSE_INVALID: "PROVIDER_RESPONSE_INVALID",
+  PROVIDER_RESPONSE_TOO_LARGE: "PROVIDER_RESPONSE_TOO_LARGE",
+  PROVIDER_SECRET_EMPTY: "PROVIDER_SECRET_EMPTY",
+  PROVIDER_SECRET_MISSING: "PROVIDER_SECRET_MISSING",
+  PROVIDER_SECRET_NOT_ALLOWED: "PROVIDER_SECRET_NOT_ALLOWED",
+  PROVIDER_STORE_UNAVAILABLE: "PROVIDER_STORE_UNAVAILABLE",
+  PROVIDER_URL_INVALID: "PROVIDER_URL_INVALID",
+  SECRET_ENVELOPE_INVALID: "SECRET_ENVELOPE_INVALID",
+  SECRET_NAME_INVALID: "SECRET_NAME_INVALID",
+  SECRET_NAMESPACE_INVALID: "SECRET_NAMESPACE_INVALID",
+  SECRET_VALUE_INVALID: "SECRET_VALUE_INVALID"
+};
+
+// src/url.ts
+function normalizeProviderUrl(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new ByokKeysError(
+      "PROVIDER_URL_INVALID",
+      "Provider base URL must be absolute"
+    );
+  }
+  if (url.username || url.password || url.hash || url.search || url.protocol !== "https:" && !(url.protocol === "http:" && isLoopbackHost(url.hostname))) {
+    throw new ByokKeysError(
+      "PROVIDER_URL_INVALID",
+      "Provider URL requires HTTPS; HTTP is allowed only for localhost"
+    );
+  }
+  if (isPrivateNetworkLiteral(url.hostname) && !isLoopbackHost(url.hostname)) {
+    throw new ByokKeysError(
+      "PROVIDER_URL_INVALID",
+      "Private-network provider IPs are not allowed"
+    );
+  }
+  return url.toString().replace(/\/$/u, "");
+}
+function isLoopbackProviderUrl(value) {
+  return isLoopbackHost(new URL(value).hostname);
+}
+function isLoopbackHost(hostname) {
+  const value = hostname.toLowerCase().replace(/^\[|\]$/gu, "");
+  return value === "localhost" || value === "127.0.0.1" || value === "::1";
+}
+function isPrivateNetworkLiteral(hostname) {
+  const value = hostname.toLowerCase().replace(/^\[|\]$/gu, "");
+  if (value.includes(":")) return true;
+  const parts = value.split(".").map(Number);
+  if (parts.length !== 4 || parts.some((part) => !Number.isInteger(part) || part < 0 || part > 255)) {
+    return false;
+  }
+  return parts[0] === 10 || parts[0] === 127 || parts[0] === 169 && parts[1] === 254 || parts[0] === 172 && (parts[1] ?? 0) >= 16 && (parts[1] ?? 0) <= 31 || parts[0] === 192 && parts[1] === 168;
+}
+
+// src/provider-profile.ts
+var MODEL_PROVIDER_IDS = [
+  "openai",
+  "deepseek",
+  "anthropic",
+  "custom"
+];
+var PROVIDER_AUTH_MODES = ["bearer", "x_api_key", "none"];
+var MODEL_PROVIDER_ADAPTERS = ["openai_compatible", "anthropic"];
+function boundedString(field, maximumLength) {
+  return z.string().superRefine((value, ctx) => {
+    if (value.trim().length === 0 || value.length > maximumLength || /[\u0000\r\n]/u.test(value)) {
+      ctx.addIssue({
+        code: "custom",
+        message: `Provider ${field} is invalid`
+      });
+    }
+  }).transform((value) => value.trim());
+}
+function isoTimestamp(field) {
+  return boundedString(field, 64).superRefine((value, ctx) => {
+    if (!Number.isFinite(Date.parse(value))) {
+      ctx.addIssue({
+        code: "custom",
+        message: `Provider ${field} must be an ISO timestamp`
+      });
+    }
+  });
+}
+var providerBaseUrl = z.string().superRefine((value, ctx) => {
+  try {
+    normalizeProviderUrl(value);
+  } catch (error) {
+    ctx.addIssue({
+      code: "custom",
+      message: error instanceof Error ? error.message : "Provider base URL is invalid",
+      params: {
+        byokCode: error instanceof ByokKeysError ? error.code : "PROVIDER_URL_INVALID"
+      }
+    });
+  }
+}).transform((value) => normalizeProviderUrl(value));
+var ModelProviderProfileSchema = z.object({
+  adapter: z.enum(MODEL_PROVIDER_ADAPTERS),
+  auth_mode: z.enum(PROVIDER_AUTH_MODES),
+  base_url: providerBaseUrl,
+  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),
+  updated_at: isoTimestamp("updated_at")
+}).superRefine((profile, ctx) => {
+  if (profile.adapter === "anthropic" && profile.auth_mode !== "x_api_key") {
+    ctx.addIssue({
+      code: "custom",
+      message: "Anthropic requires x_api_key authentication",
+      path: ["auth_mode"]
+    });
+  }
+  if (profile.adapter === "openai_compatible" && profile.auth_mode === "x_api_key") {
+    ctx.addIssue({
+      code: "custom",
+      message: "OpenAI-compatible providers support bearer or no authentication",
+      path: ["auth_mode"]
+    });
+  }
+  if (Date.parse(profile.updated_at) < Date.parse(profile.created_at)) {
+    ctx.addIssue({
+      code: "custom",
+      message: "Provider updated_at cannot precede created_at",
+      path: ["updated_at"]
+    });
+  }
+});
+function parseModelProviderProfile(value) {
+  const result = ModelProviderProfileSchema.safeParse(value);
+  if (result.success) return result.data;
+  const issue = result.error.issues[0];
+  const params = issue?.params;
+  throw new ByokKeysError(
+    params?.byokCode ?? "PROVIDER_PROFILE_INVALID",
+    issue?.message ?? "Provider profile is invalid",
+    { cause: result.error }
+  );
+}
+
+// src/headers.ts
+function requiredProviderSecret(profile, secret) {
+  if ((profile.auth_mode === "bearer" || profile.auth_mode === "x_api_key") && !secret) {
+    throw new ByokKeysError(
+      "PROVIDER_SECRET_MISSING",
+      `${profile.kind} provider requires a secret in the operating-system credential store`
+    );
+  }
+  return secret;
+}
+function providerHeaders(profile, secret) {
+  return {
+    accept: "application/json",
+    "content-type": "application/json",
+    ...profile.auth_mode === "bearer" ? { authorization: `Bearer ${requiredProviderSecret(profile, secret)}` } : {},
+    ...profile.auth_mode === "x_api_key" ? {
+      "anthropic-version": "2023-06-01",
+      "x-api-key": requiredProviderSecret(profile, secret)
+    } : {}
+  };
+}
+
+// src/http.ts
+var PROVIDER_RESPONSE_MAX_BYTES = 2 * 1024 * 1024;
+var PROVIDER_TIMEOUT_MS = 15e3;
+async function fetchWithProviderGuards(fetchImpl, url, init, signal) {
+  normalizeProviderUrl(url);
+  const controller = new AbortController();
+  const onAbort = () => controller.abort(signal.reason);
+  signal.addEventListener("abort", onAbort, { once: true });
+  if (signal.aborted) onAbort();
+  const timeout = setTimeout(
+    () => controller.abort("provider_timeout"),
+    PROVIDER_TIMEOUT_MS
+  );
+  try {
+    return await fetchImpl(url, { ...init, signal: controller.signal });
+  } catch (error) {
+    if (!signal.aborted && controller.signal.aborted && controller.signal.reason === "provider_timeout") {
+      throw new ByokKeysError(
+        "PROVIDER_REQUEST_TIMEOUT",
+        "Provider request timed out"
+      );
+    }
+    throw error;
+  } finally {
+    clearTimeout(timeout);
+    signal.removeEventListener("abort", onAbort);
+  }
+}
+async function parseBoundedJsonResponse(response) {
+  const contentLength = Number(response.headers.get("content-length"));
+  if (Number.isFinite(contentLength) && contentLength > PROVIDER_RESPONSE_MAX_BYTES) {
+    throw new ByokKeysError(
+      "PROVIDER_RESPONSE_TOO_LARGE",
+      "Provider response exceeds the local safety limit"
+    );
+  }
+  const text = await response.text();
+  if (new TextEncoder().encode(text).byteLength > PROVIDER_RESPONSE_MAX_BYTES) {
+    throw new ByokKeysError(
+      "PROVIDER_RESPONSE_TOO_LARGE",
+      "Provider response exceeds the local safety limit"
+    );
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new ByokKeysError(
+      "PROVIDER_RESPONSE_INVALID",
+      "Provider returned invalid JSON"
+    );
+  }
+}
+async function readModelProviderResponse(response) {
+  let payload;
+  try {
+    payload = await parseBoundedJsonResponse(response);
+  } catch (error) {
+    if (!response.ok && error instanceof ByokKeysError && error.code === "PROVIDER_RESPONSE_INVALID") {
+      throw modelProviderHttpError(response.status, void 0);
+    }
+    throw error;
+  }
+  if (!response.ok) {
+    throw modelProviderHttpError(response.status, payload);
+  }
+  return payload;
+}
+function modelProviderHttpError(status, payload) {
+  return new ByokKeysError(
+    classifyModelProviderHttpError(status, payload),
+    `Model provider request failed with HTTP ${status}`,
+    { httpStatus: status }
+  );
+}
+function classifyModelProviderHttpError(status, payload) {
+  const detail = safeProviderErrorText(payload);
+  if (status === 402 || /(?:insufficient[_ -]?(?:quota|balance|credit)|quota[_ -]?exceeded|billing|payment required|余额不足|额度不足|欠费|充值)/iu.test(
+    detail
+  )) {
+    return "MODEL_PROVIDER_BALANCE_INSUFFICIENT";
+  }
+  if (status === 401 || status === 403 || /(?:invalid[_ -]?api[_ -]?key|authentication|unauthori[sz]ed|forbidden|鉴权失败|密钥无效|令牌无效)/iu.test(
+    detail
+  )) {
+    return "MODEL_PROVIDER_AUTH_FAILED";
+  }
+  if (status === 404 || /(?:model[_ -]?not[_ -]?found|model does not exist|unknown model|模型不存在|无权访问模型)/iu.test(
+    detail
+  )) {
+    return "MODEL_PROVIDER_MODEL_NOT_FOUND";
+  }
+  if (status === 429) return "MODEL_PROVIDER_RATE_LIMITED";
+  return "MODEL_PROVIDER_HTTP_ERROR";
+}
+function safeProviderErrorText(payload) {
+  try {
+    return JSON.stringify(payload ?? "").slice(0, 8e3).toLowerCase();
+  } catch {
+    return "";
+  }
+}
+function modelApiUrl(baseUrl, suffix) {
+  const normalized = normalizeProviderUrl(baseUrl);
+  if (normalized.endsWith(`/${suffix}`)) return normalized;
+  return `${normalized}/${suffix}`;
+}
+function modelMessageText(value) {
+  if (typeof value === "string") return value;
+  if (Array.isArray(value)) {
+    return value.map(objectValue).filter(
+      (item) => item !== void 0 && typeof item.text === "string"
+    ).map((item) => item.text).join("");
+  }
+  throw new ByokKeysError(
+    "MODEL_RESPONSE_INVALID",
+    "Model response did not contain text"
+  );
+}
+function objectValue(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function assertLiveModelResponse(value) {
+  if (value.trim().length === 0) {
+    throw new ByokKeysError(
+      "MODEL_RESPONSE_INVALID",
+      "Model provider returned an empty completion during connection validation"
+    );
+  }
+}
+
+// src/openai-client.ts
+var OpenAiCompatibleChatClient = class {
+  model;
+  /** False only when the provider is loopback, i.e. no data leaves the machine. */
+  remoteDataTransfer;
+  #fetch;
+  #profile;
+  #secret;
+  constructor(options) {
+    this.#fetch = options.fetchImpl ?? ((input, init) => fetch(input, init));
+    this.#profile = parseModelProviderProfile(options.profile);
+    this.#secret = requiredProviderSecret(this.#profile, options.secret);
+    this.model = this.#profile.model;
+    this.remoteDataTransfer = !isLoopbackProviderUrl(this.#profile.base_url);
+  }
+  /** POST `<base_url>/chat/completions`; returns the parsed response object. */
+  async createChatCompletion(request, signal = new AbortController().signal) {
+    const response = await fetchWithProviderGuards(
+      this.#fetch,
+      modelApiUrl(this.#profile.base_url, "chat/completions"),
+      {
+        body: JSON.stringify({ ...request, model: this.#profile.model }),
+        headers: providerHeaders(this.#profile, this.#secret),
+        method: "POST",
+        redirect: "error"
+      },
+      signal
+    );
+    const payload = objectValue(await readModelProviderResponse(response));
+    if (payload === void 0) {
+      throw new ByokKeysError(
+        "MODEL_RESPONSE_INVALID",
+        "Model provider returned an invalid response"
+      );
+    }
+    return payload;
+  }
+  /**
+   * Round-trip the configured key against the provider
+   * (`providers.ts:797-828`). An empty completion fails, so a provider that
+   * accepts anything cannot be mistaken for a working configuration.
+   */
+  async testConnection(signal = new AbortController().signal) {
+    const payload = await this.createChatCompletion(
+      {
+        max_tokens: 32,
+        messages: [
+          {
+            content: 'Return one JSON object with exactly this shape: {"ok":true}.',
+            role: "user"
+          }
+        ],
+        response_format: { type: "json_object" },
+        temperature: 0
+      },
+      signal
+    );
+    assertLiveModelResponse(chatCompletionText(payload));
+  }
+};
+function chatCompletionText(payload) {
+  const choices = Array.isArray(payload.choices) ? payload.choices : [];
+  const message = objectValue(objectValue(choices[0])?.message);
+  return modelMessageText(message?.content);
+}
+
+// src/anthropic-client.ts
+var AnthropicMessagesClient = class {
+  model;
+  /** False only when the provider is loopback, i.e. no data leaves the machine. */
+  remoteDataTransfer;
+  #fetch;
+  #profile;
+  #secret;
+  constructor(options) {
+    this.#fetch = options.fetchImpl ?? ((input, init) => fetch(input, init));
+    this.#profile = parseModelProviderProfile(options.profile);
+    if (this.#profile.adapter !== "anthropic") {
+      throw new ByokKeysError(
+        "PROVIDER_PROFILE_INVALID",
+        "Anthropic provider requires the anthropic adapter"
+      );
+    }
+    this.#secret = requiredProviderSecret(
+      this.#profile,
+      options.secret
+    );
+    this.model = this.#profile.model;
+    this.remoteDataTransfer = !isLoopbackProviderUrl(this.#profile.base_url);
+  }
+  /** POST `<base_url>/messages`; returns the parsed response object. */
+  async createMessage(request, signal = new AbortController().signal) {
+    const response = await fetchWithProviderGuards(
+      this.#fetch,
+      modelApiUrl(this.#profile.base_url, "messages"),
+      {
+        body: JSON.stringify({ ...request, model: this.#profile.model }),
+        headers: providerHeaders(this.#profile, this.#secret),
+        method: "POST",
+        redirect: "error"
+      },
+      signal
+    );
+    const payload = objectValue(await readModelProviderResponse(response));
+    if (payload === void 0) {
+      throw new ByokKeysError(
+        "MODEL_RESPONSE_INVALID",
+        "Anthropic provider returned an invalid response"
+      );
+    }
+    return payload;
+  }
+  /** Round-trip the configured key against the provider (`providers.ts:1037-1054`). */
+  async testConnection(signal = new AbortController().signal) {
+    const payload = await this.createMessage(
+      {
+        max_tokens: 32,
+        messages: [
+          {
+            content: 'Return one JSON object with exactly this shape: {"ok":true}.',
+            role: "user"
+          }
+        ],
+        temperature: 0
+      },
+      signal
+    );
+    assertLiveModelResponse(anthropicMessageText(payload));
+  }
+};
+function anthropicMessageText(payload) {
+  return modelMessageText(payload.content);
+}
+async function runCommand(executable, args, stdin) {
+  return new Promise((resolveResult) => {
+    const child = spawn(executable, args, {
+      env: process.env,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.on("error", () => {
+      resolveResult({
+        exitCode: 127,
+        stderr: "command unavailable",
+        stdout: ""
+      });
+    });
+    child.on("close", (code) => {
+      resolveResult({ exitCode: code ?? 1, stderr, stdout });
+    });
+    if (stdin === void 0) child.stdin.end();
+    else child.stdin.end(stdin);
+  });
+}
+
+// src/secret-name.ts
+var SECRET_NAME_PATTERN = /^[a-z0-9][a-z0-9_-]{2,95}$/u;
+var SECRET_NAMESPACE_PATTERN = /^[a-z0-9][a-z0-9_-]{7,95}$/u;
+function assertSecretName(name) {
+  if (!SECRET_NAME_PATTERN.test(name)) {
+    throw new ByokKeysError(
+      "SECRET_NAME_INVALID",
+      "Secret name must be 3 to 96 characters of [a-z0-9_-] starting with a letter or digit"
+    );
+  }
+  return name;
+}
+function assertSecretNamespace(value) {
+  const normalized = value.trim();
+  if (!SECRET_NAMESPACE_PATTERN.test(normalized)) {
+    throw new ByokKeysError(
+      "SECRET_NAMESPACE_INVALID",
+      "Secret namespace must be 8 to 96 characters of [a-z0-9_-] starting with a letter or digit"
+    );
+  }
+  return normalized;
+}
+
+// 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 assertSharedSecretValue(secret) {
+  if (secret.length === 0 || /[\u0000\r\n]/u.test(secret)) {
+    throw new ByokKeysError(
+      "SECRET_VALUE_INVALID",
+      "Secret must be a non-empty string without null or newline characters"
+    );
+  }
+}
+function decodeStrictBase64Utf8(encoded) {
+  if (encoded.length % 4 !== 0) return void 0;
+  if (!/^[A-Za-z0-9+/]*={0,2}$/u.test(encoded)) return void 0;
+  const bytes = Buffer.from(encoded, "base64");
+  if (bytes.toString("base64") !== encoded) return void 0;
+  const text = bytes.toString("utf8");
+  if (!Buffer.from(text, "utf8").equals(bytes)) return void 0;
+  return text;
+}
+var InMemorySecretStore = class _InMemorySecretStore {
+  providerLabel = "in-memory";
+  #entries;
+  #servicePrefix;
+  constructor(options = {}) {
+    this.#entries = options.entries ?? /* @__PURE__ */ new Map();
+    this.#servicePrefix = options.servicePrefix ?? DEFAULT_SECRET_SERVICE_PREFIX;
+  }
+  available() {
+    return Promise.resolve(true);
+  }
+  async delete(name) {
+    return this.#entries.delete(this.#service(name));
+  }
+  async get(name) {
+    return this.#entries.get(this.#service(name));
+  }
+  async has(name) {
+    return await this.get(name) !== void 0;
+  }
+  scope(namespace) {
+    return new _InMemorySecretStore({
+      entries: this.#entries,
+      servicePrefix: `${this.#servicePrefix}.scope.${assertSecretNamespace(namespace)}`
+    });
+  }
+  async set(name, secret) {
+    const service = this.#service(name);
+    assertSharedSecretValue(secret);
+    this.#entries.set(service, secret);
+  }
+  #service(name) {
+    return `${this.#servicePrefix}.${assertSecretName(name)}`;
+  }
+};
+
+// src/macos-keychain.ts
+var DEFAULT_KEYCHAIN_SECRET_STORAGE_PREFIX = "byok-b64-v1:";
+var SECURITY_ITEM_NOT_FOUND = 44;
+var MacOsKeychainSecretStore = class _MacOsKeychainSecretStore {
+  providerLabel = "macOS Keychain";
+  #account;
+  #allowUnprefixedRead;
+  #commandRunner;
+  #platform;
+  #servicePrefix;
+  #storagePrefix;
+  constructor(options = {}) {
+    this.#account = options.account ?? "local-device";
+    this.#allowUnprefixedRead = options.allowUnprefixedRead ?? false;
+    this.#commandRunner = options.commandRunner ?? runCommand;
+    this.#platform = options.platform ?? process.platform;
+    this.#servicePrefix = options.servicePrefix ?? DEFAULT_SECRET_SERVICE_PREFIX;
+    this.#storagePrefix = options.storagePrefix ?? DEFAULT_KEYCHAIN_SECRET_STORAGE_PREFIX;
+  }
+  async available() {
+    if (this.#platform !== "darwin") return false;
+    const result = await this.#commandRunner("/usr/bin/security", [
+      "default-keychain",
+      "-d",
+      "user"
+    ]);
+    return result.exitCode === 0;
+  }
+  async delete(name) {
+    const service = this.#service(name);
+    this.#assertMacOs();
+    const result = await this.#commandRunner("/usr/bin/security", [
+      "delete-generic-password",
+      "-a",
+      this.#account,
+      "-s",
+      service
+    ]);
+    if (result.exitCode === SECURITY_ITEM_NOT_FOUND) return false;
+    if (result.exitCode !== 0) {
+      throw new ByokKeysError(
+        "KEYCHAIN_DELETE_FAILED",
+        "macOS Keychain could not delete the requested secret"
+      );
+    }
+    return true;
+  }
+  async get(name) {
+    const service = this.#service(name);
+    this.#assertMacOs();
+    const result = await this.#commandRunner("/usr/bin/security", [
+      "find-generic-password",
+      "-a",
+      this.#account,
+      "-s",
+      service,
+      "-w"
+    ]);
+    if (result.exitCode === SECURITY_ITEM_NOT_FOUND) return void 0;
+    if (result.exitCode !== 0) {
+      throw new ByokKeysError(
+        "KEYCHAIN_READ_FAILED",
+        "macOS Keychain could not read the requested secret"
+      );
+    }
+    return this.#decode(result.stdout.replace(/\r?\n$/u, ""));
+  }
+  async has(name) {
+    return await this.get(name) !== void 0;
+  }
+  scope(namespace) {
+    return new _MacOsKeychainSecretStore({
+      account: this.#account,
+      allowUnprefixedRead: this.#allowUnprefixedRead,
+      commandRunner: this.#commandRunner,
+      platform: this.#platform,
+      servicePrefix: `${this.#servicePrefix}.scope.${assertSecretNamespace(namespace)}`,
+      storagePrefix: this.#storagePrefix
+    });
+  }
+  async set(name, secret) {
+    const service = this.#service(name);
+    this.#assertMacOs();
+    if (secret.length === 0 || secret.length > 16384 || /[\u0000\r\n]/u.test(secret)) {
+      throw new ByokKeysError(
+        "KEYCHAIN_SECRET_INVALID",
+        "Secret must contain 1 to 16384 non-newline characters"
+      );
+    }
+    const storedSecret = `${this.#storagePrefix}${Buffer.from(secret, "utf8").toString("base64")}`;
+    const command = [
+      "add-generic-password",
+      "-U",
+      "-a",
+      quoteSecurityInteractiveArgument(this.#account),
+      "-s",
+      quoteSecurityInteractiveArgument(service),
+      "-w",
+      quoteSecurityInteractiveArgument(storedSecret)
+    ].join(" ");
+    const result = await this.#commandRunner(
+      "/usr/bin/security",
+      ["-i"],
+      `${command}
+`
+    );
+    if (result.exitCode !== 0) {
+      throw new ByokKeysError(
+        "KEYCHAIN_WRITE_FAILED",
+        "macOS Keychain could not store the requested secret"
+      );
+    }
+  }
+  #assertMacOs() {
+    if (this.#platform !== "darwin") {
+      throw new ByokKeysError(
+        "KEYCHAIN_UNAVAILABLE",
+        "macOS Keychain is required; plaintext fallback is disabled"
+      );
+    }
+  }
+  /**
+   * Fail-closed inverse of the storage encoding. The error message never
+   * echoes the undecodable value — it may still be somebody's live credential.
+   */
+  #decode(storedSecret) {
+    if (!storedSecret.startsWith(this.#storagePrefix)) {
+      if (this.#allowUnprefixedRead) return storedSecret;
+      throw new ByokKeysError(
+        "KEYCHAIN_SECRET_DECODE_FAILED",
+        "macOS Keychain returned a value without this store's storage prefix"
+      );
+    }
+    const decoded = decodeStrictBase64Utf8(
+      storedSecret.slice(this.#storagePrefix.length)
+    );
+    if (decoded === void 0 || decoded.length === 0) {
+      throw new ByokKeysError(
+        "KEYCHAIN_SECRET_DECODE_FAILED",
+        "macOS Keychain returned a secret that is not valid base64-encoded UTF-8"
+      );
+    }
+    return decoded;
+  }
+  #service(name) {
+    return `${this.#servicePrefix}.${assertSecretName(name)}`;
+  }
+};
+function quoteSecurityInteractiveArgument(value) {
+  if (/[\u0000\r\n]/u.test(value)) {
+    throw new ByokKeysError(
+      "KEYCHAIN_ARGUMENT_INVALID",
+      "macOS Keychain arguments cannot contain null or newline characters"
+    );
+  }
+  return `"${value.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
+}
+
+// src/windows-credential-manager.ts
+var CREDENTIAL_NOT_FOUND = 44;
+var WINDOWS_CREDENTIAL_MANAGER_SCRIPT_BASE64 = Buffer.from(
+  String.raw`
+Add-Type -TypeDefinition @"
+using System;
+using System.ComponentModel;
+using System.Runtime.InteropServices;
+using System.Runtime.InteropServices.ComTypes;
+
+namespace Byok {
+  public static class CredentialManager {
+    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+    private struct Credential {
+      public UInt32 Flags;
+      public UInt32 Type;
+      [MarshalAs(UnmanagedType.LPWStr)] public string TargetName;
+      [MarshalAs(UnmanagedType.LPWStr)] public string Comment;
+      public FILETIME LastWritten;
+      public UInt32 CredentialBlobSize;
+      public IntPtr CredentialBlob;
+      public UInt32 Persist;
+      public UInt32 AttributeCount;
+      public IntPtr Attributes;
+      [MarshalAs(UnmanagedType.LPWStr)] public string TargetAlias;
+      [MarshalAs(UnmanagedType.LPWStr)] public string UserName;
+    }
+
+    [DllImport("Advapi32.dll", EntryPoint = "CredWriteW", CharSet = CharSet.Unicode, SetLastError = true)]
+    private static extern bool CredWrite([In] ref Credential credential, UInt32 flags);
+
+    [DllImport("Advapi32.dll", EntryPoint = "CredReadW", CharSet = CharSet.Unicode, SetLastError = true)]
+    private static extern bool CredRead(string target, UInt32 type, UInt32 flags, out IntPtr credential);
+
+    [DllImport("Advapi32.dll", EntryPoint = "CredDeleteW", CharSet = CharSet.Unicode, SetLastError = true)]
+    private static extern bool CredDelete(string target, UInt32 type, UInt32 flags);
+
+    [DllImport("Advapi32.dll", SetLastError = false)]
+    private static extern void CredFree(IntPtr buffer);
+
+    public static void Write(string target, string username, byte[] secret) {
+      IntPtr blob = IntPtr.Zero;
+      try {
+        blob = Marshal.AllocHGlobal(secret.Length);
+        Marshal.Copy(secret, 0, blob, secret.Length);
+        Credential credential = new Credential {
+          Type = 1,
+          TargetName = target,
+          CredentialBlobSize = (UInt32)secret.Length,
+          CredentialBlob = blob,
+          Persist = 2,
+          UserName = username
+        };
+        if (!CredWrite(ref credential, 0)) {
+          throw new Win32Exception(Marshal.GetLastWin32Error());
+        }
+      } finally {
+        if (blob != IntPtr.Zero) {
+          Marshal.Copy(new byte[secret.Length], 0, blob, secret.Length);
+          Marshal.FreeHGlobal(blob);
+        }
+      }
+    }
+
+    public static byte[] Read(string target) {
+      IntPtr pointer;
+      if (!CredRead(target, 1, 0, out pointer)) {
+        int error = Marshal.GetLastWin32Error();
+        if (error == 1168) return null;
+        throw new Win32Exception(error);
+      }
+      try {
+        Credential credential = (Credential)Marshal.PtrToStructure(pointer, typeof(Credential));
+        byte[] secret = new byte[credential.CredentialBlobSize];
+        if (secret.Length > 0) Marshal.Copy(credential.CredentialBlob, secret, 0, secret.Length);
+        return secret;
+      } finally {
+        CredFree(pointer);
+      }
+    }
+
+    public static bool Delete(string target) {
+      if (CredDelete(target, 1, 0)) return true;
+      int error = Marshal.GetLastWin32Error();
+      if (error == 1168) return false;
+      throw new Win32Exception(error);
+    }
+  }
+}
+"@
+
+try {
+  $request = ([Console]::In.ReadToEnd() | ConvertFrom-Json)
+  if ($request.operation -eq "set") {
+    [Byok.CredentialManager]::Write(
+      [string]$request.target,
+      [string]$request.username,
+      [Convert]::FromBase64String([string]$request.secret_base64)
+    )
+    exit 0
+  }
+  if ($request.operation -eq "get") {
+    $secret = [Byok.CredentialManager]::Read([string]$request.target)
+    if ($null -eq $secret) { exit 44 }
+    [Console]::Out.Write([Convert]::ToBase64String($secret))
+    exit 0
+  }
+  if ($request.operation -eq "delete") {
+    if ([Byok.CredentialManager]::Delete([string]$request.target)) { exit 0 }
+    exit 44
+  }
+  exit 2
+} catch {
+  [Console]::Error.Write("credential operation failed")
+  exit 1
+}
+`,
+  "utf16le"
+).toString("base64");
+var WindowsCredentialManagerSecretStore = class _WindowsCredentialManagerSecretStore {
+  providerLabel = "Windows Credential Manager";
+  #account;
+  #commandRunner;
+  #platform;
+  #servicePrefix;
+  constructor(options = {}) {
+    this.#account = options.account ?? "local-device";
+    this.#commandRunner = options.commandRunner ?? runCommand;
+    this.#platform = options.platform ?? process.platform;
+    this.#servicePrefix = options.servicePrefix ?? DEFAULT_SECRET_SERVICE_PREFIX;
+  }
+  async available() {
+    if (this.#platform !== "win32") return false;
+    const result = await this.#commandRunner("powershell.exe", [
+      "-NoLogo",
+      "-NoProfile",
+      "-NonInteractive",
+      "-Command",
+      "$PSVersionTable.PSVersion.Major"
+    ]);
+    return result.exitCode === 0;
+  }
+  /**
+   * Delete, then read back. The source verifies rather than trusting the
+   * delete's exit code (`index.ts:651-679`): a credential that survives a
+   * "successful" delete is a security failure, so it is reported as one instead
+   * of being returned as `true`.
+   */
+  async delete(name) {
+    const target = this.#service(name);
+    this.#assertWindows();
+    const result = await this.#invoke({
+      operation: "delete",
+      target,
+      username: this.#account
+    });
+    if (result.exitCode === CREDENTIAL_NOT_FOUND) return false;
+    if (result.exitCode !== 0) {
+      throw new ByokKeysError(
+        "CREDENTIAL_MANAGER_DELETE_FAILED",
+        "Windows Credential Manager could not delete the requested secret"
+      );
+    }
+    const verification = await this.#invoke({
+      operation: "get",
+      target,
+      username: this.#account
+    });
+    if (verification.exitCode === CREDENTIAL_NOT_FOUND) return true;
+    if (verification.exitCode !== 0) {
+      throw new ByokKeysError(
+        "CREDENTIAL_MANAGER_DELETE_FAILED",
+        "Windows Credential Manager could not verify secret deletion"
+      );
+    }
+    throw new ByokKeysError(
+      "CREDENTIAL_MANAGER_DELETE_FAILED",
+      "Windows Credential Manager reported deletion but the secret remains"
+    );
+  }
+  async get(name) {
+    const target = this.#service(name);
+    this.#assertWindows();
+    const result = await this.#invoke({
+      operation: "get",
+      target,
+      username: this.#account
+    });
+    if (result.exitCode === CREDENTIAL_NOT_FOUND) return void 0;
+    if (result.exitCode !== 0) {
+      throw new ByokKeysError(
+        "CREDENTIAL_MANAGER_READ_FAILED",
+        "Windows Credential Manager could not read the requested secret"
+      );
+    }
+    const secret = decodeStrictBase64Utf8(result.stdout.trim());
+    if (secret === void 0 || secret.length === 0) {
+      throw new ByokKeysError(
+        "CREDENTIAL_MANAGER_READ_FAILED",
+        "Windows Credential Manager returned an invalid secret"
+      );
+    }
+    return secret;
+  }
+  async has(name) {
+    return await this.get(name) !== void 0;
+  }
+  scope(namespace) {
+    return new _WindowsCredentialManagerSecretStore({
+      account: this.#account,
+      commandRunner: this.#commandRunner,
+      platform: this.#platform,
+      servicePrefix: `${this.#servicePrefix}.scope.${assertSecretNamespace(namespace)}`
+    });
+  }
+  async set(name, secret) {
+    const target = this.#service(name);
+    this.#assertWindows();
+    assertWindowsCredentialSecret(secret);
+    const result = await this.#invoke({
+      operation: "set",
+      secret_base64: Buffer.from(secret, "utf8").toString("base64"),
+      target,
+      username: this.#account
+    });
+    if (result.exitCode !== 0) {
+      throw new ByokKeysError(
+        "CREDENTIAL_MANAGER_WRITE_FAILED",
+        "Windows Credential Manager could not store the requested secret"
+      );
+    }
+  }
+  #assertWindows() {
+    if (this.#platform !== "win32") {
+      throw new ByokKeysError(
+        "CREDENTIAL_MANAGER_UNAVAILABLE",
+        "Windows Credential Manager is required; plaintext fallback is disabled"
+      );
+    }
+  }
+  async #invoke(request) {
+    return this.#commandRunner(
+      "powershell.exe",
+      [
+        "-NoLogo",
+        "-NoProfile",
+        "-NonInteractive",
+        "-EncodedCommand",
+        WINDOWS_CREDENTIAL_MANAGER_SCRIPT_BASE64
+      ],
+      JSON.stringify(request)
+    );
+  }
+  #service(name) {
+    return `${this.#servicePrefix}.${assertSecretName(name)}`;
+  }
+};
+function assertWindowsCredentialSecret(secret) {
+  const bytes = Buffer.byteLength(secret, "utf8");
+  if (secret.length === 0 || bytes > 2560 || /[\u0000\r\n]/u.test(secret)) {
+    throw new ByokKeysError(
+      "CREDENTIAL_MANAGER_SECRET_INVALID",
+      "Secret must contain 1 to 2560 UTF-8 bytes without newline characters"
+    );
+  }
+}
+var DEFAULT_SECRET_ENVELOPE_PREFIX = "byok-scoped-secrets-v1:";
+function secretScopeId(scope) {
+  const normalized = normalizeSecretScope(scope);
+  return `acct_${createHash("sha256").update(`${normalized.account_id}
+${normalized.workspace_id}`, "utf8").digest("hex")}`;
+}
+function scopeSecretStore(store, scope) {
+  return store.scope(secretScopeId(scope));
+}
+var EnvelopeScopedSecretStore = class _EnvelopeScopedSecretStore {
+  providerLabel;
+  #envelopePrefix;
+  #scopeId;
+  #store;
+  constructor(store, scopeId, options = {}) {
+    this.#store = store;
+    this.#scopeId = assertScopeSlotKey(scopeId);
+    this.#envelopePrefix = options.envelopePrefix ?? DEFAULT_SECRET_ENVELOPE_PREFIX;
+    this.providerLabel = store.providerLabel;
+  }
+  available() {
+    return this.#store.available();
+  }
+  async delete(name) {
+    const envelope = await this.#readEnvelope(name);
+    if (envelope === void 0 || !Object.hasOwn(envelope, this.#scopeId)) {
+      return false;
+    }
+    delete envelope[this.#scopeId];
+    if (Object.keys(envelope).length === 0) return this.#store.delete(name);
+    await this.#store.set(name, this.#serialize(envelope));
+    return true;
+  }
+  async get(name) {
+    return (await this.#readEnvelope(name))?.[this.#scopeId];
+  }
+  async has(name) {
+    return await this.get(name) !== void 0;
+  }
+  scope(namespace) {
+    return new _EnvelopeScopedSecretStore(
+      this.#store,
+      `${this.#scopeId}.${assertSecretNamespace(namespace)}`,
+      { envelopePrefix: this.#envelopePrefix }
+    );
+  }
+  async set(name, secret) {
+    assertSharedSecretValue(secret);
+    const envelope = await this.#readEnvelope(name) ?? /* @__PURE__ */ Object.create(null);
+    envelope[this.#scopeId] = secret;
+    await this.#store.set(name, this.#serialize(envelope));
+  }
+  /**
+   * `undefined` means the entry is absent; a malformed entry throws.
+   *
+   * The returned map has a null prototype. A slot key is attacker-adjacent
+   * data — `constructor` is a legal namespace (`toString` and `__proto__` are
+   * rejected by the pattern, but this defense does not depend on the pattern's
+   * shape) — so a plain object would answer `envelope[scopeId]` from
+   * `Object.prototype` and hand a Function back as a scope's secret.
+   */
+  async #readEnvelope(name) {
+    const stored = await this.#store.get(assertSecretName(name));
+    if (stored === void 0) return void 0;
+    if (!stored.startsWith(this.#envelopePrefix)) throw envelopeInvalid();
+    const decoded = decodeBase64Url(stored.slice(this.#envelopePrefix.length));
+    if (decoded === void 0) throw envelopeInvalid();
+    let parsed;
+    try {
+      parsed = JSON.parse(decoded);
+    } catch {
+      throw envelopeInvalid();
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed) || Object.values(parsed).some((value) => typeof value !== "string")) {
+      throw envelopeInvalid();
+    }
+    return Object.assign(
+      /* @__PURE__ */ Object.create(null),
+      parsed
+    );
+  }
+  #serialize(value) {
+    return `${this.#envelopePrefix}${Buffer.from(
+      JSON.stringify(value),
+      "utf8"
+    ).toString("base64url")}`;
+  }
+};
+function assertScopeSlotKey(value) {
+  return value.trim().split(".").map((segment) => assertSecretNamespace(segment)).join(".");
+}
+function envelopeInvalid() {
+  return new ByokKeysError(
+    "SECRET_ENVELOPE_INVALID",
+    "The stored value is not a well-formed scoped-secret envelope"
+  );
+}
+function decodeBase64Url(encoded) {
+  if (!/^[A-Za-z0-9_-]*$/u.test(encoded)) return void 0;
+  const bytes = Buffer.from(encoded, "base64url");
+  if (bytes.toString("base64url") !== encoded) return void 0;
+  const text = bytes.toString("utf8");
+  if (!Buffer.from(text, "utf8").equals(bytes)) return void 0;
+  return text;
+}
+function normalizeSecretScope(scope) {
+  const accountId = scope.account_id.trim();
+  const workspaceId = scope.workspace_id.trim();
+  if (!accountId || !workspaceId || accountId.length > 160 || workspaceId.length > 160 || /[\u0000\r\n]/u.test(accountId) || /[\u0000\r\n]/u.test(workspaceId)) {
+    throw new ByokKeysError(
+      "LOCAL_ACCOUNT_SCOPE_INVALID",
+      "The local account data scope is invalid"
+    );
+  }
+  return { account_id: accountId, workspace_id: workspaceId };
+}
+
+// src/profile-store.ts
+function providerNotConfigured(providerId) {
+  return new ByokKeysError(
+    "PROVIDER_NOT_CONFIGURED",
+    `${providerId} model provider is not configured`
+  );
+}
+var InMemoryProviderProfileStore = class {
+  #profiles = /* @__PURE__ */ new Map();
+  close() {
+    this.#profiles.clear();
+  }
+  delete(providerId) {
+    return this.#profiles.delete(providerId);
+  }
+  get(providerId) {
+    return this.#profiles.get(providerId);
+  }
+  getEnabled() {
+    return this.list().find((profile) => profile.enabled);
+  }
+  list() {
+    return [...this.#profiles.values()].sort(
+      (left, right) => left.provider_id.localeCompare(right.provider_id)
+    );
+  }
+  save(profile) {
+    const validated = parseModelProviderProfile({
+      ...profile,
+      created_at: this.#profiles.get(profile.provider_id)?.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 });
+        }
+      }
+    }
+    this.#profiles.set(validated.provider_id, validated);
+    return validated;
+  }
+  setEnabled(providerId) {
+    const existing = this.#profiles.get(providerId);
+    if (existing === void 0) throw providerNotConfigured(providerId);
+    return this.save({ ...existing, enabled: true });
+  }
+};
+var SECURE_DIR_MODE = 448;
+var SECURE_FILE_MODE = 384;
+var DEFAULT_BUSY_TIMEOUT_MS = 5e3;
+function loadSqliteModule() {
+  try {
+    return createRequire(import.meta.url)("node:sqlite");
+  } catch (error) {
+    throw new ByokKeysError(
+      "PROVIDER_STORE_UNAVAILABLE",
+      "node:sqlite is unavailable in this Node.js runtime. SqliteProviderProfileStore requires Node.js 22.5+ with the built-in `node:sqlite` module (no native dependency is used or allowed here). Upgrade Node.js, or use InMemoryProviderProfileStore instead.",
+      { cause: error }
+    );
+  }
+}
+function isSqliteAvailable() {
+  try {
+    loadSqliteModule();
+    return true;
+  } catch {
+    return false;
+  }
+}
+function openSqliteDatabase(path, options) {
+  const { DatabaseSync } = loadSqliteModule();
+  if (path !== ":memory:") {
+    mkdirSync(dirname(path), { mode: SECURE_DIR_MODE, recursive: true });
+  }
+  const database = new DatabaseSync(path, {
+    timeout: DEFAULT_BUSY_TIMEOUT_MS,
+    ...options
+  });
+  if (path !== ":memory:") {
+    database.exec("PRAGMA journal_mode = WAL");
+    database.exec("PRAGMA synchronous = FULL");
+  }
+  return database;
+}
+function secureSqliteFilePermissions(databasePath) {
+  if (databasePath === ":memory:") return;
+  for (const candidate of [
+    databasePath,
+    `${databasePath}-wal`,
+    `${databasePath}-shm`
+  ]) {
+    if (existsSync(candidate)) {
+      chmodSync(candidate, SECURE_FILE_MODE);
+    }
+  }
+}
+
+// src/sqlite-profile-store.ts
+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
+);
+`;
+var ENABLED_INDEX = `
+CREATE UNIQUE INDEX IF NOT EXISTS provider_profile_one_enabled
+ON provider_profile(kind)
+WHERE enabled = 1;
+`;
+var SqliteProviderProfileStore = class {
+  #database;
+  #closed = false;
+  constructor(options) {
+    this.#database = openSqliteDatabase(options.path);
+    this.#database.exec(SCHEMA);
+    this.#database.exec(ENABLED_INDEX);
+    secureSqliteFilePermissions(options.path);
+  }
+  /**
+   * Idempotent, as {@link ProviderProfileStore.close} requires: `node:sqlite`
+   * throws "database is not open" on a second `close()`, and a store is
+   * routinely closed both by the code that finished with it and by a test's
+   * teardown.
+   */
+  close() {
+    if (this.#closed) return;
+    this.#closed = true;
+    this.#database.close();
+  }
+  delete(providerId) {
+    const result = this.#database.prepare("DELETE FROM provider_profile WHERE provider_id = ?").run(providerId);
+    return Number(result.changes) === 1;
+  }
+  get(providerId) {
+    const row = this.#database.prepare("SELECT * FROM provider_profile WHERE provider_id = ?").get(providerId);
+    return row === void 0 ? void 0 : parseRow(row);
+  }
+  getEnabled() {
+    const row = this.#database.prepare("SELECT * FROM provider_profile WHERE enabled = 1").get();
+    return row === void 0 ? void 0 : parseRow(row);
+  }
+  list() {
+    const rows = this.#database.prepare("SELECT * FROM provider_profile ORDER BY provider_id ASC").all();
+    return rows.map(parseRow);
+  }
+  save(profile) {
+    const validated = parseModelProviderProfile({
+      ...profile,
+      created_at: this.get(profile.provider_id)?.created_at ?? profile.created_at
+    });
+    this.#transaction(() => {
+      if (validated.enabled) {
+        this.#database.prepare(
+          "UPDATE provider_profile SET enabled = 0 WHERE provider_id <> ?"
+        ).run(validated.provider_id);
+      }
+      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
+             adapter = excluded.adapter,
+             display_name = excluded.display_name,
+             base_url = excluded.base_url,
+             auth_mode = excluded.auth_mode,
+             model = excluded.model,
+             enabled = excluded.enabled,
+             updated_at = excluded.updated_at`
+      ).run(
+        validated.provider_id,
+        validated.kind,
+        validated.adapter,
+        validated.display_name,
+        validated.base_url,
+        validated.auth_mode,
+        validated.model,
+        validated.enabled ? 1 : 0,
+        validated.created_at,
+        validated.updated_at
+      );
+    });
+    return this.get(validated.provider_id);
+  }
+  setEnabled(providerId) {
+    const existing = this.get(providerId);
+    if (existing === void 0) throw providerNotConfigured(providerId);
+    return this.save({ ...existing, enabled: true });
+  }
+  /** `BEGIN IMMEDIATE` / `COMMIT` / `ROLLBACK`, per `providers.ts:1252-1263`. */
+  #transaction(body) {
+    this.#database.exec("BEGIN IMMEDIATE");
+    try {
+      body();
+      this.#database.exec("COMMIT");
+    } catch (error) {
+      this.#database.exec("ROLLBACK");
+      throw error;
+    }
+  }
+};
+function parseRow(row) {
+  return parseModelProviderProfile({
+    ...row,
+    enabled: row.enabled === 1
+  });
+}
+
+// src/registry.ts
+var ProviderRegistry = class {
+  #fetch;
+  #now;
+  #profiles;
+  #secrets;
+  constructor(options) {
+    this.#fetch = options.fetchImpl;
+    this.#now = options.now ?? (() => /* @__PURE__ */ new Date());
+    this.#profiles = options.profileStore;
+    this.#secrets = options.secretStore;
+  }
+  close() {
+    this.#profiles.close();
+  }
+  /**
+   * Persist a provider's profile and, when supplied, its secret
+   * (`providers.ts:1180-1229`).
+   *
+   * Order matters and is the source's: write the secret first, then require
+   * that an authenticating profile actually has one, and only then save the
+   * profile. A profile is therefore never persisted in a state that claims
+   * authentication it cannot perform.
+   */
+  async configure(configuration, secret) {
+    const timestamp = this.#now().toISOString();
+    const previous = this.#profiles.get(configuration.provider_id);
+    const profile = {
+      ...configuration,
+      created_at: previous?.created_at ?? timestamp,
+      enabled: configuration.enabled ?? true,
+      kind: "model",
+      updated_at: timestamp
+    };
+    const secretName = modelProviderSecretName(configuration.provider_id);
+    if (configuration.auth_mode === "none" && secret !== void 0) {
+      throw new ByokKeysError(
+        "PROVIDER_SECRET_NOT_ALLOWED",
+        "A provider without authentication cannot accept a secret"
+      );
+    }
+    if (secret !== void 0) {
+      if (secret.length === 0) {
+        throw new ByokKeysError(
+          "PROVIDER_SECRET_EMPTY",
+          "Provider secret cannot be empty"
+        );
+      }
+      await this.#secrets.set(secretName, secret);
+    }
+    if (configuration.auth_mode !== "none" && !await this.#secrets.has(secretName)) {
+      throw new ByokKeysError(
+        "PROVIDER_SECRET_MISSING",
+        "Provider authentication requires a secret in the operating-system credential store"
+      );
+    }
+    const saved = this.#profiles.save(profile);
+    if (saved.auth_mode === "none") {
+      await this.#secrets.delete(secretName);
+    }
+    return this.#status(saved);
+  }
+  /** Remove a provider's profile and its secret together. */
+  async delete(providerId) {
+    const removed = this.#profiles.delete(providerId);
+    await this.#secrets.delete(modelProviderSecretName(providerId));
+    return removed;
+  }
+  async get(providerId) {
+    const profile = this.#profiles.get(providerId);
+    return profile === void 0 ? void 0 : this.#status(profile);
+  }
+  async list() {
+    return Promise.all(
+      this.#profiles.list().map((profile) => this.#status(profile))
+    );
+  }
+  /**
+   * Build a client for the one enabled provider (`providers.ts:1331-1354`).
+   *
+   * `undefined` means "nothing is configured", which is a legitimate state a
+   * caller must handle. A configured-but-broken provider throws instead — a
+   * missing secret or an unusable profile is a fault, not an absence.
+   */
+  async resolveDefaultModelProvider() {
+    const profile = this.#profiles.getEnabled();
+    if (profile === void 0) return void 0;
+    const secret = await this.#secrets.get(
+      modelProviderSecretName(profile.provider_id)
+    );
+    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(this.#profiles.setEnabled(providerId));
+  }
+  async #status(profile) {
+    return {
+      adapter: profile.adapter,
+      auth_mode: profile.auth_mode,
+      base_url: profile.base_url,
+      created_at: profile.created_at,
+      display_name: profile.display_name,
+      enabled: profile.enabled,
+      model: profile.model,
+      provider_id: profile.provider_id,
+      secret_configured: await this.#secrets.has(
+        modelProviderSecretName(profile.provider_id)
+      ),
+      updated_at: profile.updated_at
+    };
+  }
+};
+
+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, PROVIDER_AUTH_MODES, PROVIDER_RESPONSE_MAX_BYTES, PROVIDER_TIMEOUT_MS, ProviderRegistry, SECRET_NAMESPACE_PATTERN, SECRET_NAME_PATTERN, SqliteProviderProfileStore, WindowsCredentialManagerSecretStore, anthropicMessageText, assertLiveModelResponse, assertSecretName, assertSecretNamespace, assertSharedSecretValue, chatCompletionText, classifyModelProviderHttpError, decodeStrictBase64Utf8, fetchWithProviderGuards, isLoopbackHost, isLoopbackProviderUrl, isPrivateNetworkLiteral, isSqliteAvailable, loadSqliteModule, modelApiUrl, modelMessageText, modelProviderSecretName, normalizeProviderUrl, objectValue, openSqliteDatabase, parseBoundedJsonResponse, parseModelProviderProfile, providerHeaders, readModelProviderResponse, requiredProviderSecret, runCommand, scopeSecretStore, secretScopeId, secureSqliteFilePermissions };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map