@byok-sdk/keys 0.3.8 → 0.3.10

package/dist/pi-provider-launcher-core.d.ts

@@ -1,10 +1,13 @@
-import { type ModelProviderId, type ModelProviderProfile } from './provider-profile';
+import { type ExactProviderProfileBinding, type ModelProviderProfile, type ProviderProfileRef } from './provider-profile';
 import { type SecretStore } from './secret-store';
 export interface PiProviderLauncherOptions {
     piBin: string;
     profileDbPath: string;
-    providerId: ModelProviderId;
+    /** Carried by the `--provider` flag: the exact local profile to launch. */
+    profileRef: ProviderProfileRef;
     modelId: string;
+    expectedBinding?: ExactProviderProfileBinding;
+    validateOnly: boolean;
     sessionDir: string;
     secretServicePrefix?: string;
     macosKeychainPath?: string;

package/dist/pi-provider-projection.d.ts

@@ -1,8 +1,17 @@
 import type { ModelProviderProfile } from './provider-profile';
 export declare const PI_PROJECTED_KEY_ENV = "PI_PROVIDER_API_KEY";
 /** Keep projected providers disjoint from Pi built-ins so composition can never fall back to one. */
-export declare function piProjectionProviderId(profileProviderId: string): string;
-/** Credential-blind Pi configuration derived from one validated local profile. */
+export declare function piProjectionProviderId(profileRef: string): string;
+/**
+ * Credential-blind Pi configuration derived from one validated local profile.
+ *
+ * The projected provider is namespaced by the profile's own ref, not by its
+ * provider kind, so two independently configured endpoints of the same kind
+ * project to two distinct Pi providers instead of colliding on one. Model
+ * `input` modalities are projected from the profile's declared capabilities —
+ * declared local configuration is the only authority; nothing is inferred from
+ * the model name or base URL.
+ */
 export declare function buildPiProviderProjection(profile: ModelProviderProfile): object;
 /**
  * Validate the credential-blind RPC argv the client may delegate, then bind

package/dist/profile-store.d.ts

@@ -1,5 +1,5 @@
 import { ByokKeysError } from './errors';
-import { type ModelProviderId, type ModelProviderProfile } from './provider-profile';
+import { type ModelProviderProfile, type ProviderProfileRef } from './provider-profile';
 /**
  * Storage contract for provider profiles — everything needed to address a
  * provider except the API key, which lives in a {@link SecretStore}.
@@ -23,24 +23,24 @@ import { type ModelProviderId, type ModelProviderProfile } from './provider-prof
 export interface ProviderProfileStore {
     /** Release the underlying resource. Safe to call more than once. */
     close(): Promise<void>;
-    /** Remove `providerId`; `false` when it was not configured. */
-    delete(providerId: ModelProviderId): Promise<boolean>;
-    /** Read one provider's profile, configured or not enabled alike. */
-    get(providerId: ModelProviderId): Promise<ModelProviderProfile | undefined>;
+    /** Remove `profileRef`; `false` when it was not configured. */
+    delete(profileRef: ProviderProfileRef): Promise<boolean>;
+    /** Read one profile, configured or not enabled alike. */
+    get(profileRef: ProviderProfileRef): Promise<ModelProviderProfile | undefined>;
     /** The single enabled profile, or `undefined` when none is enabled. */
     getEnabled(): Promise<ModelProviderProfile | undefined>;
-    /** Every configured profile, ordered by provider id. */
+    /** Every configured profile, ordered by profile ref. */
     list(): Promise<ModelProviderProfile[]>;
     /** Insert or update `profile`, enforcing both invariants above. */
     save(profile: ModelProviderProfile): Promise<ModelProviderProfile>;
     /**
-     * Make `providerId` the enabled profile. Throws `PROVIDER_NOT_CONFIGURED`
+     * Make `profileRef` the enabled profile. Throws `PROVIDER_NOT_CONFIGURED`
      * when it has no profile — a fail-closed port of `providers.ts:1243-1250`.
      */
-    setEnabled(providerId: ModelProviderId): Promise<ModelProviderProfile>;
+    setEnabled(profileRef: ProviderProfileRef): Promise<ModelProviderProfile>;
 }
 /** Shared by both implementations so their error text cannot drift apart. */
-export declare function providerNotConfigured(providerId: ModelProviderId): ByokKeysError;
+export declare function providerNotConfigured(profileRef: ProviderProfileRef): ByokKeysError;
 /**
  * Profile store held in process memory: the default, and the one every test
  * that does not specifically exercise SQLite should use.
@@ -52,10 +52,10 @@ export declare function providerNotConfigured(providerId: ModelProviderId): Byok
 export declare class InMemoryProviderProfileStore implements ProviderProfileStore {
     #private;
     close(): Promise<void>;
-    delete(providerId: ModelProviderId): Promise<boolean>;
-    get(providerId: ModelProviderId): Promise<ModelProviderProfile | undefined>;
+    delete(profileRef: ProviderProfileRef): Promise<boolean>;
+    get(profileRef: ProviderProfileRef): Promise<ModelProviderProfile | undefined>;
     getEnabled(): Promise<ModelProviderProfile | undefined>;
     list(): Promise<ModelProviderProfile[]>;
     save(profile: ModelProviderProfile): Promise<ModelProviderProfile>;
-    setEnabled(providerId: ModelProviderId): Promise<ModelProviderProfile>;
+    setEnabled(profileRef: ProviderProfileRef): Promise<ModelProviderProfile>;
 }

package/dist/provider-profile.d.ts

@@ -1,10 +1,42 @@
 import { z } from 'zod';
 /**
- * Model providers this package knows how to address. Ported from
- * `aip-main-open@c6a5385` `providers.ts:30-36` (`LOCAL_MODEL_PROVIDER_IDS`).
+ * Opaque, portable identity of one locally configured provider profile.
+ *
+ * This is the profile's primary key: it is a local logical id, never a path,
+ * and several profiles may share one {@link MODEL_PROVIDER_KINDS} kind (two
+ * independent `custom` endpoints, for example). It replaces the former
+ * `MODEL_PROVIDER_IDS` primary key, which conflated instance identity with
+ * provider kind and therefore allowed exactly one profile per kind.
+ *
+ * `@byok-sdk/protocol` declares the same lexical rule for the wire form in
+ * `provider-profile-binding.ts`. The two definitions are deliberately parallel
+ * rather than shared: the release graph (`scripts/release/check-package-graph.mjs`)
+ * forbids `@byok-sdk/keys` from depending on any dispatch package, so the
+ * device-local authority cannot import the wire authority. This mirrors how
+ * `packages/protocol/src/blob.ts`'s `CONTENT_HASH_RE` restates
+ * `packages/core/src/blob.ts`'s content-hash format across the same boundary.
+ */
+export declare const PROVIDER_PROFILE_REF_PATTERN: RegExp;
+export declare const ProviderProfileRefSchema: z.ZodString;
+export type ProviderProfileRef = z.infer<typeof ProviderProfileRefSchema>;
+/**
+ * Provider kinds this package knows how to address — the surviving half of the
+ * former `MODEL_PROVIDER_IDS`. A kind says *what dialect family and vendor
+ * shape* a profile is; {@link ProviderProfileRefSchema} says *which* profile.
+ * Ported from `aip-main-open@c6a5385` `providers.ts:30-36`
+ * (`LOCAL_MODEL_PROVIDER_IDS`).
  */
-export declare const MODEL_PROVIDER_IDS: readonly ['openai', 'deepseek', 'anthropic', 'custom'];
-export type ModelProviderId = (typeof MODEL_PROVIDER_IDS)[number];
+export declare const MODEL_PROVIDER_KINDS: readonly ['openai', 'deepseek', 'anthropic', 'custom'];
+export type ModelProviderKind = (typeof MODEL_PROVIDER_KINDS)[number];
+/**
+ * Bounded model capabilities a profile may declare. A capability is explicit
+ * local configuration, never inferred from the model name or the base URL.
+ */
+export declare const PROVIDER_MODEL_CAPABILITIES: readonly ['image-input'];
+export declare const ProviderModelCapabilitySchema: z.ZodEnum<{
+    "image-input": "image-input";
+}>;
+export type ProviderModelCapability = z.infer<typeof ProviderModelCapabilitySchema>;
 /** Auth modes a provider profile can request (`providers.ts:29`). */
 export declare const PROVIDER_AUTH_MODES: readonly ['bearer', 'x_api_key', 'none'];
 export type ProviderAuthMode = (typeof PROVIDER_AUTH_MODES)[number];
@@ -34,12 +66,16 @@ export declare const ModelProviderProfileSchema: z.ZodObject<{
         x_api_key: "x_api_key";
     }>;
     base_url: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+    capabilities: z.ZodArray<z.ZodEnum<{
+        "image-input": "image-input";
+    }>>;
     created_at: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
     display_name: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
     enabled: z.ZodBoolean;
     kind: z.ZodLiteral<"model">;
     model: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
-    provider_id: z.ZodEnum<{
+    profile_ref: z.ZodString;
+    provider_kind: z.ZodEnum<{
         anthropic: "anthropic";
         custom: "custom";
         deepseek: "deepseek";
@@ -51,6 +87,23 @@ export declare const ModelProviderProfileSchema: z.ZodObject<{
 export type ModelProviderProfile = z.infer<typeof ModelProviderProfileSchema>;
 /** Pre-normalization shape callers may hand in. */
 export type ModelProviderProfileInput = z.input<typeof ModelProviderProfileSchema>;
+export interface ExactProviderProfileBinding {
+    profileRef: ProviderProfileRef;
+    profileRevision: string;
+    profileHash: string;
+    modelId: string;
+    requiredCapabilities: readonly ProviderModelCapability[];
+}
+/**
+ * Derive the credential-free wire identity from the normalized local record.
+ * `updated_at` is the persisted monotonic revision authority; the hash covers
+ * the complete normalized non-secret record with capability order
+ * canonicalized. Secret values are not accepted by this type and therefore
+ * cannot enter the digest or any mismatch message.
+ */
+export declare function exactProviderProfileBinding(profileInput: ModelProviderProfile, requiredCapabilities?: readonly ProviderModelCapability[]): ExactProviderProfileBinding;
+/** Fail closed unless every offered binding field matches local authority. */
+export declare function assertExactProviderProfileBinding(profile: ModelProviderProfile, expected: ExactProviderProfileBinding): void;
 /**
  * Parse and normalize a profile, or throw {@link ByokKeysError}. Replaces the
  * source's `normalizeProviderProfile` (`providers.ts:1489-1556`) for the model

package/dist/registry.d.ts

@@ -2,7 +2,7 @@ import { AnthropicMessagesClient } from './anthropic-client';
 import type { ProviderFetch } from './http';
 import { OpenAiCompatibleChatClient } from './openai-client';
 import type { ProviderProfileStore } from './profile-store';
-import { type ModelProviderAdapter, type ModelProviderId, type ProviderAuthMode } from './provider-profile';
+import { type ModelProviderAdapter, type ModelProviderKind, type ProviderAuthMode, type ProviderModelCapability, type ProviderProfileRef } from './provider-profile';
 import { type ModelProviderSecretName, type SecretStore } from './secret-store';
 /** A transport client for whichever dialect the resolved profile declares. */
 export type ModelProviderClient = AnthropicMessagesClient | OpenAiCompatibleChatClient;
@@ -16,11 +16,18 @@ export interface ProviderConfiguration {
     adapter: ModelProviderAdapter;
     auth_mode: ProviderAuthMode;
     base_url: string;
+    /**
+     * Bounded model capabilities this exact profile supports. Declared, never
+     * inferred: an omitted capability means the endpoint does not offer it.
+     */
+    capabilities: readonly ProviderModelCapability[];
     display_name: string;
     /** Defaults to `true`: configuring a provider makes it the default. */
     enabled?: boolean;
     model: string;
-    provider_id: ModelProviderId;
+    /** This profile's own local identity; several profiles may share one kind. */
+    profile_ref: ProviderProfileRef;
+    provider_kind: ModelProviderKind;
 }
 /**
  * The registry's outward projection of a profile.
@@ -34,12 +41,18 @@ export interface ProviderStatus {
     adapter: ModelProviderAdapter;
     auth_mode: ProviderAuthMode;
     base_url: string;
+    capabilities: readonly ProviderModelCapability[];
     created_at: string;
     display_name: string;
     enabled: boolean;
     model: string;
-    provider_id: ModelProviderId;
-    /** Whether the credential store currently holds this provider's key. */
+    profile_ref: ProviderProfileRef;
+    /** Canonical credential-free revision used by exact task admission. */
+    profile_revision: string;
+    /** SHA-256 of the normalized non-secret local record. */
+    profile_hash: string;
+    provider_kind: ModelProviderKind;
+    /** Whether the credential store currently holds this profile's key. */
     secret_configured: boolean;
     updated_at: string;
 }
@@ -86,9 +99,9 @@ export declare class ProviderRegistry {
      * authentication it cannot perform.
      */
     configure(configuration: ProviderConfiguration, secret?: string): Promise<ProviderStatus>;
-    /** Remove a provider's profile and its secret together. */
-    delete(providerId: ModelProviderId): Promise<boolean>;
-    get(providerId: ModelProviderId): Promise<ProviderStatus | undefined>;
+    /** Remove a profile and its secret together. */
+    delete(profileRef: ProviderProfileRef): Promise<boolean>;
+    get(profileRef: ProviderProfileRef): Promise<ProviderStatus | undefined>;
     list(): Promise<ProviderStatus[]>;
     /**
      * Build a client for the one enabled provider (`providers.ts:1331-1354`).
@@ -98,6 +111,6 @@ export declare class ProviderRegistry {
      * missing secret or an unusable profile is a fault, not an absence.
      */
     resolveDefaultModelProvider(): Promise<ModelProviderClient | undefined>;
-    /** Switch which configured provider is the default. */
-    setDefaultModelProvider(providerId: ModelProviderId): Promise<ProviderStatus>;
+    /** Switch which configured profile is the default. */
+    setDefaultModelProvider(profileRef: ProviderProfileRef): Promise<ProviderStatus>;
 }

package/dist/secret-store.d.ts

@@ -1,4 +1,4 @@
-import type { ModelProviderId } from './provider-profile';
+import { type ProviderProfileRef } from './provider-profile';
 /**
  * Storage contract for a single secret entry in an operating-system credential
  * store.
@@ -42,20 +42,23 @@ export interface SecretStore<TName extends string = string> {
  */
 export declare const DEFAULT_SECRET_SERVICE_PREFIX = "com.byok.keys";
 /**
- * Credential-store entry name per model provider, ported verbatim from
- * `providers.ts:1624-1632`. The names carry no vendor branding — the branding
- * lives in the service prefix — so they travel unchanged and K4 needs no
- * migration.
+ * Credential-store entry name for one provider profile.
+ *
+ * The former fixed `MODEL_PROVIDER_SECRET_NAMES` table could name exactly one
+ * entry per provider kind, so two independent `custom` endpoints would have
+ * shared — and overwritten — a single credential. The name is now derived from
+ * the profile's own {@link ProviderProfileRef}, keeping the shape
+ * `providers.ts:1624-1632` established (`model-<id>-api-key`, no vendor
+ * branding; the branding lives in the service prefix).
+ */
+export type ModelProviderSecretName = `model-${string}-api-key`;
+/**
+ * Resolve a provider profile ref to the credential-store entry holding its API
+ * key. The ref is validated here as well as by the profile schema: this
+ * function composes a storage address, so an unvalidated ref would be an
+ * address-injection surface rather than merely an invalid record.
  */
-export declare const MODEL_PROVIDER_SECRET_NAMES: {
-    readonly anthropic: 'model-anthropic-api-key';
-    readonly custom: 'model-custom-api-key';
-    readonly deepseek: 'model-deepseek-api-key';
-    readonly openai: 'model-openai-api-key';
-};
-export type ModelProviderSecretName = (typeof MODEL_PROVIDER_SECRET_NAMES)[keyof typeof MODEL_PROVIDER_SECRET_NAMES];
-/** Resolve a provider id to the credential-store entry holding its API key. */
-export declare function modelProviderSecretName(providerId: ModelProviderId): ModelProviderSecretName;
+export declare function modelProviderSecretName(profileRef: ProviderProfileRef): ModelProviderSecretName;
 /**
  * The secret-shape invariant both OS backends share. Their size ceilings differ
  * in both magnitude and unit (macOS counts 16384 characters, Windows counts

package/dist/sqlite-profile-store.d.ts

@@ -1,5 +1,5 @@
 import { type ProviderProfileStore } from './profile-store';
-import { type ModelProviderId, type ModelProviderProfile } from './provider-profile';
+import { type ModelProviderProfile, type ProviderProfileRef } from './provider-profile';
 export interface SqliteProviderProfileStoreOptions {
     /**
      * Database file path. `:memory:` exercises the SQLite code path without a
@@ -26,12 +26,12 @@ export declare class SqliteProviderProfileStore implements ProviderProfileStore
      * teardown.
      */
     close(): Promise<void>;
-    delete(providerId: ModelProviderId): Promise<boolean>;
-    get(providerId: ModelProviderId): Promise<ModelProviderProfile | undefined>;
+    delete(profileRef: ProviderProfileRef): Promise<boolean>;
+    get(profileRef: ProviderProfileRef): Promise<ModelProviderProfile | undefined>;
     getEnabled(): Promise<ModelProviderProfile | undefined>;
     list(): Promise<ModelProviderProfile[]>;
     save(profile: ModelProviderProfile): Promise<ModelProviderProfile>;
-    setEnabled(providerId: ModelProviderId): Promise<ModelProviderProfile>;
+    setEnabled(profileRef: ProviderProfileRef): Promise<ModelProviderProfile>;
 }
-/** Exported for the store's own tests to enumerate the CHECK-constrained ids. */
-export declare const SQLITE_PROFILE_PROVIDER_IDS: readonly ["openai", "deepseek", "anthropic", "custom"];
+/** Exported for the store's own tests to enumerate the CHECK-constrained kinds. */
+export declare const SQLITE_PROFILE_PROVIDER_KINDS: readonly ["openai", "deepseek", "anthropic", "custom"];

package/dist/truth-profile-store.d.ts

@@ -1,7 +1,17 @@
 import { type TenantId, type TruthStore } from '@byok-sdk/core';
 import { type ProviderProfileStore } from './profile-store';
-import { type ModelProviderId, type ModelProviderProfile } from './provider-profile';
+import { type ModelProviderProfile, type ProviderProfileRef } from './provider-profile';
 export declare const PROVIDER_PROFILE_TRUTH_RECORD_KEY = "byok-sdk.keys/model-provider-registry-v1";
+/**
+ * Upper bound on how many profiles one tenant's registry snapshot may carry.
+ *
+ * The former bound was `MODEL_PROVIDER_IDS.length`, which only held because the
+ * primary key was a four-value enum. Profile refs are open, so the CAS body
+ * needs an explicit ceiling of its own; a registry is device-local operator
+ * configuration, and 32 endpoints is far past any real local setup while
+ * keeping the single-record snapshot small.
+ */
+export declare const MAX_PROVIDER_PROFILES = 32;
 export interface TruthStoreProviderProfileStoreOptions {
     tenant: TenantId;
     truthStore: TruthStore;
@@ -18,10 +28,10 @@ export declare class TruthStoreProviderProfileStore implements ProviderProfileSt
     #private;
     constructor(options: TruthStoreProviderProfileStoreOptions);
     close(): Promise<void>;
-    delete(providerId: ModelProviderId): Promise<boolean>;
-    get(providerId: ModelProviderId): Promise<ModelProviderProfile | undefined>;
+    delete(profileRef: ProviderProfileRef): Promise<boolean>;
+    get(profileRef: ProviderProfileRef): Promise<ModelProviderProfile | undefined>;
     getEnabled(): Promise<ModelProviderProfile | undefined>;
     list(): Promise<ModelProviderProfile[]>;
     save(profile: ModelProviderProfile): Promise<ModelProviderProfile>;
-    setEnabled(providerId: ModelProviderId): Promise<ModelProviderProfile>;
+    setEnabled(profileRef: ProviderProfileRef): Promise<ModelProviderProfile>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@byok-sdk/keys",
-  "version": "0.3.8",
+  "version": "0.3.10",
   "description": "BYOK SDK key management: provider profiles, credential-backed auth headers, and direct provider transports",
   "type": "module",
   "license": "MIT",
@@ -48,7 +48,7 @@
     "clean": "rm -rf dist"
   },
   "dependencies": {
-    "@byok-sdk/core": "0.11.0",
+    "@byok-sdk/core": "0.13.0",
     "zod": "^4.4.3"
   }
 }