@versini/sassysaint-common 4.12.0 → 4.13.0

package/dist/index.d.ts

@@ -22,7 +22,9 @@ declare const ALL_PROVIDERS: readonly ["OpenAI", "Anthropic", "Google"];
  * List of available models TODAY.
  */
 declare const MODEL_GPT5 = "gpt-5";
-declare const MODEL_GPT4_MINI = "gpt-4.1-nano";
+declare const MODEL_GPT5_MINI = "gpt-5-mini";
+declare const MODEL_GPT5_NANO = "gpt-5-nano";
+declare const MODEL_GPT4_NANO = "gpt-4.1-nano";
 declare const MODEL_CLAUDE_HAIKU = "claude-haiku-4-5-20251001";
 declare const MODEL_CLAUDE_SONNET = "claude-sonnet-4-5-20250929";
 declare const MODEL_GEMINI_FLASH = "gemini-2.5-flash";
@@ -33,22 +35,21 @@ declare const MODEL_DEV = "mistralai/mistral-small-3.2-24b-instruct:free";
 declare const MODEL_MEMORY_INFERENCE = "gpt-4o-mini";
 declare const MODEL_EMBEDDING_TEXT = "text-embedding-3-small";
 /**
- * Maps model constants to user-friendly display names.
- * Used by client UI to show readable model names in plan descriptions and
- * settings.
+ * Maps model constants to user-friendly display names. Used by client UI to
+ * show readable model names in plan descriptions and settings.
  */
 declare const MODEL_DISPLAY_NAMES: Record<string, string>;
 /**
- * List of all models available TODAY.
- * This is used by the client to display the list of models.
+ * List of all models available TODAY. This is used by the client to display the
+ * list of models.
  */
-declare const ALL_MODELS: readonly ["gpt-5", "gpt-4.1-nano", "claude-haiku-4-5-20251001", "claude-sonnet-4-5-20250929", "gemini-2.5-flash", "gemini-2.5-pro"];
+declare const ALL_MODELS: readonly ["gpt-5", "gpt-5-mini", "gpt-5-nano", "claude-haiku-4-5-20251001", "claude-sonnet-4-5-20250929", "gemini-2.5-flash", "gemini-2.5-pro"];
 declare const ALL_REASONING_MODELS: string[];
 /**
  * List of models available according to the providers.
  */
 declare const MODELS_PER_PROVIDER: {
-    readonly OpenAI: readonly ["gpt-4.1-nano", "gpt-5"];
+    readonly OpenAI: readonly ["gpt-4.1-nano", "gpt-5", "gpt-5-mini", "gpt-5-nano"];
     readonly Anthropic: readonly ["claude-haiku-4-5-20251001", "claude-sonnet-4-5-20250929"];
     readonly Google: readonly ["gemini-2.5-flash", "gemini-2.5-pro"];
     readonly Perplexity: readonly ["sonar", "sonar-pro"];
@@ -64,38 +65,22 @@ declare const PROVIDER_ROLE_MAP: {
     Google: string[];
     Perplexity: string[];
 };
+/**
+ * Mapping of AI providers to their approximate model name prefixes. This
+ * enables provider identification from model names even when exact model
+ * versions change over time.
+ */
+declare const APPROXIMATE_MODELS_PER_PROVIDER: {
+    readonly Anthropic: readonly ["claude-sonnet-4", "claude-3"];
+    readonly OpenAI: readonly ["gpt-", "o3", "o4"];
+    readonly Google: readonly ["gemini"];
+    readonly Perplexity: readonly ["sonar"];
+};
 /**
  * Header string for Diggidy Chat Id. Used to identify the chat in the server
  * when there is a client abort.
  */
 declare const DIGGIDY_CHAT_ID_HEADER = "x-diggidy-chat-id";
-/**
- * This function finds the provider associated with a given model name. It
- * checks the model name against a list of approximate models for each provider.
- *
- * @param modelName - The model name to check.
- * @returns The provider associated with the model name or null if not found.
- *
- */
-declare const findProvider: (modelName: string) => null | typeof PROVIDER_ANTHROPIC | typeof PROVIDER_OPENAI | typeof PROVIDER_GOOGLE;
-/**
- * Derives the list of available providers from a given list of models.
- * This allows the client to automatically filter provider options based on
- * which models are available in a user's plan.
- *
- * @param models - Array of model names (e.g., from allowedModels in policies).
- * @returns Array of provider names that have at least one model available.
- *
- * @example
- * // If plan only has GPT and Claude models:
- * getProvidersFromModels([MODEL_GPT4_MINI, MODEL_CLAUDE_HAIKU])
- * // returns: [PROVIDER_OPENAI, PROVIDER_ANTHROPIC]
- *
- * // If Gemini models are removed from plan:
- * getProvidersFromModels([MODEL_GPT4_MINI, MODEL_CLAUDE_HAIKU])
- * // Google provider will not be in the result
- */
-declare const getProvidersFromModels: (models: string[]) => Array<typeof PROVIDER_OPENAI | typeof PROVIDER_ANTHROPIC | typeof PROVIDER_GOOGLE>;
 /**
  * Sort capabilities are shared across client and server.
  */
@@ -105,261 +90,12 @@ declare const SORT_BY_TOKEN_USAGE = "tokenUsage";
  * Name of the application.
  */
 declare const APPLICATION_NAME = "Diggidy";
-
-/**
- * TypeScript interfaces for Server-Mediated Encryption.
- */
-/**
- * RSA key pair stored in memory for the current session.
- */
-interface ClientCryptoKeyPair {
-    publicKey: CryptoKey;
-    privateKey: CryptoKey;
-}
-/**
- * Serializable format for public key exchange with server.
- */
-interface SerializablePublicKey {
-    /**
-     * Public key in JSON Web Key format.
-     */
-    jwk: JsonWebKey;
-    /**
-     * Key type identifier.
-     */
-    kty: "RSA";
-    /**
-     * Algorithm identifier.
-     */
-    alg: "RSA-OAEP-256";
-}
-/**
- * Response from server's key exchange mutation.
- */
-interface KeyExchangeResponse {
-    /**
-     * Server's public key in JWK format.
-     */
-    serverPublicKey: string;
-    /**
-     * Server's key identifier for rotation tracking.
-     */
-    keyId: string;
-    /**
-     * List of supported encryption algorithms.
-     */
-    supportedAlgorithms: string[];
-}
-/**
- * Client crypto session state stored in memory.
- */
-interface CryptoSession {
-    /**
-     * Client's RSA key pair.
-     */
-    clientKeyPair: ClientCryptoKeyPair;
-    /**
-     * Server's public key for encryption.
-     */
-    serverPublicKey: CryptoKey;
-    /**
-     * Unique device/session identifier.
-     */
-    deviceId: string;
-    /**
-     * Server's key identifier.
-     */
-    serverKeyId: string;
-    /**
-     * When this session was established.
-     */
-    establishedAt: Date;
-}
-/**
- * Encrypted message format for transport.
- */
-interface EncryptedMessage {
-    /**
-     * Base64-encoded encrypted data.
-     */
-    data: string;
-    /**
-     * Algorithm used for encryption.
-     */
-    algorithm: "RSA-OAEP";
-    /**
-     * Key ID used for encryption.
-     */
-    keyId: string;
-}
-/**
- * Parameters for RSA key generation.
- */
-interface RSAKeyGenParams {
-    /**
-     * RSA modulus length in bits.
-     */
-    modulusLength: 2048 | 4096;
-    /**
-     * Public exponent.
-     */
-    publicExponent: Uint8Array;
-    /**
-     * Hash algorithm for OAEP.
-     */
-    hash: "SHA-256";
-}
-/**
- * Error types for crypto operations.
- */
-declare class CryptoError extends Error {
-    readonly code: "KEY_GENERATION_FAILED" | "ENCRYPTION_FAILED" | "DECRYPTION_FAILED" | "KEY_IMPORT_FAILED" | "INVALID_KEY_FORMAT";
-    readonly originalError?: Error | undefined;
-    constructor(message: string, code: "KEY_GENERATION_FAILED" | "ENCRYPTION_FAILED" | "DECRYPTION_FAILED" | "KEY_IMPORT_FAILED" | "INVALID_KEY_FORMAT", originalError?: Error | undefined);
-}
-/**
- * Configuration options for crypto operations.
- */
-interface CryptoConfig {
-    /**
-     * RSA key size in bits.
-     */
-    keySize: 2048 | 4096;
-    /**
-     * Enable debug logging.
-     */
-    debug: boolean;
-}
-/**
- * Default crypto configuration.
- */
-declare const DEFAULT_CRYPTO_CONFIG: CryptoConfig;
-
-/**
- * Generate a new RSA key pair for the current session.
- */
-declare function generateClientKeyPair(config?: Partial<CryptoConfig>): Promise<ClientCryptoKeyPair>;
-/**
- * Export public key to serializable format for server exchange.
- */
-declare function exportPublicKey(publicKey: CryptoKey): Promise<SerializablePublicKey>;
-/**
- * Import server's public key from JWK format.
- */
-declare function importServerPublicKey(serverPublicKeyJWK: string): Promise<CryptoKey>;
-/**
- * Encrypt message for transmission to server.
- */
-declare function encryptForServer(message: string, serverPublicKey: CryptoKey, serverKeyId: string): Promise<EncryptedMessage>;
-/**
- * Decrypt message received from server.
- */
-declare function decryptFromServer(encryptedMessage: EncryptedMessage, clientPrivateKey: CryptoKey): Promise<string>;
-/**
- * Create a complete crypto session with key exchange.
- */
-declare function establishCryptoSession(keyExchangeResponse: KeyExchangeResponse, clientKeyPair: ClientCryptoKeyPair, deviceId: string): Promise<CryptoSession>;
-/**
- * Validate that a crypto session is still valid.
- */
-declare function isCryptoSessionValid(session: CryptoSession): boolean;
-
-/**
- * Utility functions for crypto operations.
- */
-/**
- * Generate a unique device ID for this session.
- */
-declare function generateDeviceId(): string;
-/**
- * Check if the current environment supports Web Crypto API.
- */
-declare function isWebCryptoSupported(): boolean;
-/**
- * Validate that we're in a secure context (required for Web Crypto API).
- */
-declare function isSecureContext(): boolean;
-/**
- * Check if encryption is available in the current environment.
- */
-declare function canUseEncryption(): boolean;
-/**
- * Convert ArrayBuffer to base64 string.
- */
-declare function arrayBufferToBase64(buffer: ArrayBuffer): string;
-/**
- * Convert base64 string to ArrayBuffer.
- */
-declare function base64ToArrayBuffer(base64: string): ArrayBuffer;
-/**
- * Safely stringify JSON with error handling.
- */
-declare function safeStringify(obj: unknown): string;
-/**
- * Safely parse JSON with error handling.
- */
-declare function safeParse<T = unknown>(json: string): T | null;
-/**
- * Debug logger for crypto operations (only in development).
- *
- * ⚠️ SECURITY WARNING: Never log sensitive data such as:
- * - Private or public key objects
- * - Encrypted or decrypted data
- * - Raw cryptographic material
- * - Device IDs or session identifiers
- *
- * Only log non-sensitive metadata like algorithms, key sizes, operation status,
- * etc.
- *
- */
-declare function debugLog(message: string, ...args: unknown[]): void;
-
-type index_ClientCryptoKeyPair = ClientCryptoKeyPair;
-type index_CryptoConfig = CryptoConfig;
-type index_CryptoError = CryptoError;
-declare const index_CryptoError: typeof CryptoError;
-type index_CryptoSession = CryptoSession;
-declare const index_DEFAULT_CRYPTO_CONFIG: typeof DEFAULT_CRYPTO_CONFIG;
-type index_EncryptedMessage = EncryptedMessage;
-type index_KeyExchangeResponse = KeyExchangeResponse;
-type index_RSAKeyGenParams = RSAKeyGenParams;
-type index_SerializablePublicKey = SerializablePublicKey;
-declare const index_arrayBufferToBase64: typeof arrayBufferToBase64;
-declare const index_base64ToArrayBuffer: typeof base64ToArrayBuffer;
-declare const index_canUseEncryption: typeof canUseEncryption;
-declare const index_debugLog: typeof debugLog;
-declare const index_decryptFromServer: typeof decryptFromServer;
-declare const index_encryptForServer: typeof encryptForServer;
-declare const index_establishCryptoSession: typeof establishCryptoSession;
-declare const index_exportPublicKey: typeof exportPublicKey;
-declare const index_generateClientKeyPair: typeof generateClientKeyPair;
-declare const index_generateDeviceId: typeof generateDeviceId;
-declare const index_importServerPublicKey: typeof importServerPublicKey;
-declare const index_isCryptoSessionValid: typeof isCryptoSessionValid;
-declare const index_isSecureContext: typeof isSecureContext;
-declare const index_isWebCryptoSupported: typeof isWebCryptoSupported;
-declare const index_safeParse: typeof safeParse;
-declare const index_safeStringify: typeof safeStringify;
-declare namespace index {
-  export { type index_ClientCryptoKeyPair as ClientCryptoKeyPair, type index_CryptoConfig as CryptoConfig, index_CryptoError as CryptoError, type index_CryptoSession as CryptoSession, index_DEFAULT_CRYPTO_CONFIG as DEFAULT_CRYPTO_CONFIG, type index_EncryptedMessage as EncryptedMessage, type index_KeyExchangeResponse as KeyExchangeResponse, type index_RSAKeyGenParams as RSAKeyGenParams, type index_SerializablePublicKey as SerializablePublicKey, index_arrayBufferToBase64 as arrayBufferToBase64, index_base64ToArrayBuffer as base64ToArrayBuffer, index_canUseEncryption as canUseEncryption, index_debugLog as debugLog, index_decryptFromServer as decryptFromServer, index_encryptForServer as encryptForServer, index_establishCryptoSession as establishCryptoSession, index_exportPublicKey as exportPublicKey, index_generateClientKeyPair as generateClientKeyPair, index_generateDeviceId as generateDeviceId, index_importServerPublicKey as importServerPublicKey, index_isCryptoSessionValid as isCryptoSessionValid, index_isSecureContext as isSecureContext, index_isWebCryptoSupported as isWebCryptoSupported, index_safeParse as safeParse, index_safeStringify as safeStringify };
-}
-
 /**
  * List of all plans available.
  */
 declare const PLAN_BASIC = "sassy:basic";
 declare const PLAN_PLUS = "sassy:plus";
 declare const PLAN_PREMIUM = "sassy:advanced";
-/**
- * List of grants available (coarse grain). This is to be used by client with
- * the isGranted() helper to check for feature availability via JWT
- * capabilities.
- */
-declare const POLICY_GRANTS: {
-    PLAN_BASIC: string;
-    PLAN_PLUS: string;
-    PLAN_PREMIUM: string;
-};
 /**
  * Capability constants (single source of truth for string ids).
  * NOTE: these map 1:1 to tool names in ALL_TOOLS from @sassysaint/tools
@@ -384,28 +120,206 @@ declare const CAPABILITIES: {
         readonly CODEINTERPRETER: "addon:codeinterpreter";
     };
 };
+
+/**
+ * Identifies the AI provider associated with a given model name by matching
+ * against known model prefixes. This function provides backward compatibility
+ * for older model naming schemes while correctly identifying the provider.
+ *
+ * The function iterates through approximate model prefixes for each provider
+ * and returns the first matching provider. This approach handles cases where
+ * model version numbers change but the provider remains the same.
+ *
+ * @param modelName - The full model name to identify (e.g.,
+ *   "claude-3-5-sonnet-20241022").
+ * @returns The provider constant (PROVIDER_ANTHROPIC, PROVIDER_OPENAI, or
+ *   PROVIDER_GOOGLE) if a match is found, or null if no provider matches.
+ *
+ * @example
+ * ```ts
+ * findProvider("claude-3-5-sonnet-latest"); // Returns PROVIDER_ANTHROPIC
+ * findProvider("gpt-4-turbo"); // Returns PROVIDER_OPENAI
+ * findProvider("gemini-1.5-pro"); // Returns PROVIDER_GOOGLE
+ * findProvider("unknown-model"); // Returns null
+ * ```
+ *
+ */
+declare const findProvider: (modelName: string) => null | typeof PROVIDER_ANTHROPIC | typeof PROVIDER_OPENAI | typeof PROVIDER_GOOGLE;
+/**
+ * Derives the list of available AI providers from a given array of model names.
+ * This function enables automatic filtering of provider options in the UI based
+ * on which models are available in a user's subscription plan.
+ *
+ * The function cross-references each model against the MODELS_PER_PROVIDER
+ * mapping to determine which providers should be available. Results are
+ * returned in a consistent order matching ALL_PROVIDERS to ensure UI stability.
+ *
+ * @param models - Array of model names available to the user (e.g., from
+ *   allowedModels in policy configuration).
+ * @returns Array of provider constants (PROVIDER_OPENAI, PROVIDER_ANTHROPIC,
+ *   PROVIDER_GOOGLE) that have at least one available model. Returns empty
+ *   array if no models are provided.
+ *
+ * @example
+ * ```ts
+ * // User's plan includes GPT and Claude models:
+ * getProvidersFromModels([MODEL_GPT4_NANO, MODEL_CLAUDE_HAIKU]);
+ * // Returns: [PROVIDER_OPENAI, PROVIDER_ANTHROPIC]
+ *
+ * // Gemini models removed from plan:
+ * getProvidersFromModels([MODEL_GPT4_NANO, MODEL_CLAUDE_HAIKU]);
+ * // Returns: [PROVIDER_OPENAI, PROVIDER_ANTHROPIC]
+ * // (PROVIDER_GOOGLE is excluded)
+ *
+ * // Empty models array:
+ * getProvidersFromModels([]);
+ * // Returns: []
+ * ```
+ *
+ */
+declare const getProvidersFromModels: (models: string[]) => Array<typeof PROVIDER_OPENAI | typeof PROVIDER_ANTHROPIC | typeof PROVIDER_GOOGLE>;
 /**
- * Capability entitlement helper (client/server shared).
+ * Input type for capability checks. Can be a single capability string or an
+ * array of capability strings for checking multiple capabilities at once.
  */
 type CapabilityInput = string | readonly string[];
+/**
+ * Configuration options for the isEntitled function to control how capability
+ * checks are evaluated.
+ */
 interface IsEntitledOptions {
     /**
-     * Allow entitlement if ANY capability matches (OR). Default false = require
-     * ALL.
+     * When true, grants entitlement if ANY of the required capabilities match
+     * (logical OR). When false (default), requires ALL capabilities to match
+     * (logical AND).
      */
     any?: boolean;
     /**
-     * Pre-supplied Set; if absent we'll build one from `capabilities`.
+     * Pre-computed capability Set for performance optimization. If provided, skips
+     * building a new Set from the capabilities array.
      */
     set?: Set<string>;
 }
+/**
+ * Represents the shape of an entitlement state object, used for checking
+ * capability loading status. This interface is intentionally flexible to work
+ * with various entitlement state implementations across client and server.
+ */
 interface EntitlementStateLike {
+    /**
+     * Array of capability strings granted to the user.
+     */
     capabilities?: string[];
+    /**
+     * Version number of the entitlement state for cache invalidation.
+     */
     version?: number;
+    /**
+     * Current status of the entitlement (e.g., "active", "expired").
+     */
     status?: string;
 }
+/**
+ * Checks whether an entitlement state object has been successfully loaded and
+ * contains valid capability data. This function verifies the state is defined
+ * and has a capabilities array (even if empty).
+ *
+ * Use this function before performing capability checks to ensure the
+ * entitlement data is available and initialized properly.
+ *
+ * @param state - The entitlement state object to check, which may be null or
+ *   undefined during initial loading.
+ * @returns True if the state is loaded and contains a capabilities array,
+ *   false otherwise.
+ *
+ * @example
+ * ```ts
+ * const entitlementState = await fetchEntitlements();
+ * if (isEntitlementLoaded(entitlementState)) {
+ *   // Safe to check capabilities
+ *   const hasFeature = isEntitled(entitlementState.capabilities, "premium");
+ * }
+ * ```
+ *
+ */
 declare function isEntitlementLoaded(state: EntitlementStateLike | null | undefined): boolean;
+/**
+ * Converts an array of capability strings into a Set for efficient lookup
+ * operations. Returns null if the input is null, undefined, or not an array.
+ *
+ * Using a Set for capability checks provides O(1) lookup performance compared
+ * to O(n) for array includes, which is beneficial when checking multiple
+ * capabilities or performing frequent checks.
+ *
+ * @param capabilities - Array of capability strings to convert, or null/
+ *   undefined.
+ * @returns A Set containing the capability strings, or null if input is
+ *   invalid.
+ *
+ * @example
+ * ```ts
+ * const caps = ["read:posts", "write:posts", "admin"];
+ * const capSet = toCapabilitySet(caps);
+ * // capSet.has("read:posts") is now O(1) instead of O(n)
+ *
+ * toCapabilitySet(null); // Returns null
+ * toCapabilitySet(undefined); // Returns null
+ * ```
+ *
+ */
 declare function toCapabilitySet(capabilities: string[] | undefined | null): Set<string> | null;
+/**
+ * Checks whether a user has the required capability or capabilities based on
+ * their entitlement. This function is used throughout the application to
+ * control access to features based on subscription plans or permission levels.
+ *
+ * The function supports multiple modes of operation:
+ * - Single capability check: Pass a string to check one capability
+ * - Multiple capability check (AND): Pass an array to require ALL capabilities
+ * - Multiple capability check (OR): Pass an array with options.any=true to
+ *   require ANY capability
+ * - Performance optimization: Pass a pre-computed Set via options.set
+ *
+ * An empty requirements array or empty string always returns true, treating it
+ * as "no specific entitlement required".
+ *
+ * @param capabilitiesOrSet - User's capabilities as an array, a Set, or null/
+ *   undefined if not loaded.
+ * @param required - The capability or capabilities to check. Can be a single
+ *   string or an array of strings.
+ * @param options - Optional configuration for the check behavior (any mode, pre-
+ *   computed Set).
+ * @returns True if the user has the required capability/capabilities according
+ *   to the specified logic, false otherwise.
+ *
+ * @example
+ * ```ts
+ * const userCaps = ["read:posts", "write:posts"];
+ *
+ * // Single capability check:
+ * isEntitled(userCaps, "read:posts"); // true
+ * isEntitled(userCaps, "admin"); // false
+ *
+ * // Multiple capabilities (AND - all required):
+ * isEntitled(userCaps, ["read:posts", "write:posts"]); // true
+ * isEntitled(userCaps, ["read:posts", "admin"]); // false
+ *
+ * // Multiple capabilities (OR - any required):
+ * isEntitled(userCaps, ["admin", "read:posts"], { any: true }); // true
+ * isEntitled(userCaps, ["admin", "super:user"], { any: true }); // false
+ *
+ * // Performance optimization with pre-computed Set:
+ * const capSet = toCapabilitySet(userCaps);
+ * isEntitled(capSet, "read:posts"); // true (faster lookup)
+ *
+ * // Edge cases:
+ * isEntitled(userCaps, ""); // true (no requirement)
+ * isEntitled(userCaps, []); // true (no requirement)
+ * isEntitled(null, "read:posts"); // false (no capabilities)
+ * isEntitled([], "read:posts"); // false (empty capabilities)
+ * ```
+ *
+ */
 declare function isEntitled(capabilitiesOrSet: string[] | Set<string> | null | undefined, required: CapabilityInput, options?: IsEntitledOptions): boolean;
 
-export { ALL_MODELS, ALL_PROVIDERS, ALL_REASONING_MODELS, APPLICATION_NAME, CAPABILITIES, type CapabilityInput, DEFAULT_PROVIDER, DIGGIDY_CHAT_ID_HEADER, type EntitlementStateLike, type IsEntitledOptions, MODELS_PER_PROVIDER, MODEL_CLAUDE_HAIKU, MODEL_CLAUDE_SONNET, MODEL_DEV, MODEL_DISPLAY_NAMES, MODEL_EMBEDDING_TEXT, MODEL_GEMINI_FLASH, MODEL_GEMINI_PRO, MODEL_GPT4_MINI, MODEL_GPT5, MODEL_MEMORY_INFERENCE, MODEL_SONAR, MODEL_SONAR_PRO, PLAN_BASIC, PLAN_PLUS, PLAN_PREMIUM, POLICY_GRANTS, PROVIDER_ANTHROPIC, PROVIDER_GOOGLE, PROVIDER_MEMORY, PROVIDER_MISTRAL, PROVIDER_OPENAI, PROVIDER_PERPLEXITY, PROVIDER_ROLE_MAP, PROVIDER_SUMMARY, ROLE_ASSISTANT, ROLE_HIDDEN, ROLE_INTERNAL, ROLE_SYSTEM, ROLE_USER, SORT_BY_TIMESTAMP, SORT_BY_TOKEN_USAGE, index as crypto, findProvider, getProvidersFromModels, isEntitled, isEntitlementLoaded, toCapabilitySet };
+export { ALL_MODELS, ALL_PROVIDERS, ALL_REASONING_MODELS, APPLICATION_NAME, APPROXIMATE_MODELS_PER_PROVIDER, CAPABILITIES, type CapabilityInput, DEFAULT_PROVIDER, DIGGIDY_CHAT_ID_HEADER, type EntitlementStateLike, type IsEntitledOptions, MODELS_PER_PROVIDER, MODEL_CLAUDE_HAIKU, MODEL_CLAUDE_SONNET, MODEL_DEV, MODEL_DISPLAY_NAMES, MODEL_EMBEDDING_TEXT, MODEL_GEMINI_FLASH, MODEL_GEMINI_PRO, MODEL_GPT4_NANO, MODEL_GPT5, MODEL_GPT5_MINI, MODEL_GPT5_NANO, MODEL_MEMORY_INFERENCE, MODEL_SONAR, MODEL_SONAR_PRO, PLAN_BASIC, PLAN_PLUS, PLAN_PREMIUM, PROVIDER_ANTHROPIC, PROVIDER_GOOGLE, PROVIDER_MEMORY, PROVIDER_MISTRAL, PROVIDER_OPENAI, PROVIDER_PERPLEXITY, PROVIDER_ROLE_MAP, PROVIDER_SUMMARY, ROLE_ASSISTANT, ROLE_HIDDEN, ROLE_INTERNAL, ROLE_SYSTEM, ROLE_USER, SORT_BY_TIMESTAMP, SORT_BY_TOKEN_USAGE, findProvider, getProvidersFromModels, isEntitled, isEntitlementLoaded, toCapabilitySet };

package/dist/index.js

@@ -1,274 +1,62 @@
-const L = "system", a = "user", i = "assistant", ne = "hidden", re = "data", c = "OpenAI", y = "Anthropic", d = "Google", M = "Summary", T = "Memory", O = "Perplexity", oe = "Mistral", se = c, m = [
-  c,
-  y,
-  d
-], u = "gpt-5", p = "gpt-4.1-nano", f = "claude-haiku-4-5-20251001", A = "claude-sonnet-4-5-20250929", _ = "gemini-2.5-flash", l = "gemini-2.5-pro", R = "sonar", P = "sonar-pro", ae = "mistralai/mistral-small-3.2-24b-instruct:free", ie = "gpt-4o-mini", ce = "text-embedding-3-small", Ee = {
-  [u]: "GPT-5",
-  [p]: "GPT-4.1 Nano",
-  [f]: "Claude Haiku 4.5",
-  [A]: "Claude Sonnet 4.5",
-  [_]: "Gemini 2.5 Flash",
-  [l]: "Gemini 2.5 Pro",
-  [R]: "Sonar",
-  [P]: "Sonar Pro"
-}, ye = [
-  u,
-  p,
-  f,
-  A,
+const l = "system", E = "user", e = "assistant", X = "hidden", Y = "data", O = "OpenAI", _ = "Anthropic", c = "Google", d = "Summary", g = "Memory", M = "Perplexity", v = "Mistral", b = O, m = [
+  O,
   _,
-  l
-], de = [
-  u,
+  c
+], A = "gpt-5", R = "gpt-5-mini", r = "gpt-5-nano", T = "gpt-4.1-nano", I = "claude-haiku-4-5-20251001", i = "claude-sonnet-4-5-20250929", D = "gemini-2.5-flash", a = "gemini-2.5-pro", S = "sonar", N = "sonar-pro", B = "mistralai/mistral-small-3.2-24b-instruct:free", F = "gpt-4o-mini", W = "text-embedding-3-small", x = {
+  [A]: "GPT-5",
+  [R]: "GPT-5 Mini",
+  [r]: "GPT-5 Nano",
+  [T]: "GPT-4.1 Nano",
+  [I]: "Claude Haiku 4.5",
+  [i]: "Claude Sonnet 4.5",
+  [D]: "Gemini 2.5 Flash",
+  [a]: "Gemini 2.5 Pro",
+  [S]: "Sonar",
+  [N]: "Sonar Pro"
+}, k = [
   A,
-  l
-], w = "claude-sonnet-4", h = "claude-3", b = "gpt-", N = "o3", C = "o4", v = "gemini", U = "sonar", K = {
-  [y]: [
-    w,
-    h
+  R,
+  r,
+  I,
+  i,
+  D,
+  a
+], j = [
+  A,
+  R,
+  r,
+  i,
+  a
+], u = {
+  [O]: [
+    T,
+    A,
+    R,
+    r
   ],
-  [c]: [
-    b,
-    N,
-    C
+  [_]: [I, i],
+  [c]: [D, a],
+  [M]: [S, N]
+}, w = {
+  [O]: [l, E, e],
+  [_]: [E, e],
+  [d]: [E, e],
+  [g]: [E, e],
+  [c]: [E, e],
+  [M]: [E, e]
+}, G = "claude-sonnet-4", f = "claude-3", p = "gpt-", y = "o3", h = "o4", C = "gemini", U = "sonar", H = {
+  [_]: [
+    G,
+    f
   ],
-  [d]: [v],
-  [O]: [U]
-}, G = {
-  [c]: [p, u],
-  [y]: [f, A],
-  [d]: [_, l],
-  [O]: [R, P]
-}, ue = {
-  [c]: [L, a, i],
-  [y]: [a, i],
-  [M]: [a, i],
-  [T]: [a, i],
-  [d]: [a, i],
-  [O]: [a, i]
-}, Ae = "x-diggidy-chat-id", le = (n) => {
-  for (const [e, r] of Object.entries(
-    K
-  ))
-    if (r.some((t) => n.startsWith(t)))
-      return e;
-  return null;
-}, Oe = (n) => {
-  if (!n || n.length === 0)
-    return [];
-  const e = /* @__PURE__ */ new Set();
-  for (const r of n)
-    for (const [t, E] of Object.entries(
-      G
-    ))
-      E.includes(r) && (t === c || t === y || t === d) && e.add(t);
-  return m.filter((r) => e.has(r));
-}, pe = "timestamp", fe = "tokenUsage", _e = "Diggidy";
-class s extends Error {
-  constructor(e, r, t) {
-    super(e), this.code = r, this.originalError = t, this.name = "CryptoError";
-  }
-}
-const S = {
-  keySize: 4096,
-  debug: !1
-};
-async function k(n = {}) {
-  const e = { ...S, ...n };
-  try {
-    const r = {
-      modulusLength: e.keySize,
-      publicExponent: new Uint8Array([1, 0, 1]),
-      // 65537
-      hash: "SHA-256"
-    }, t = await crypto.subtle.generateKey(
-      {
-        name: "RSA-OAEP",
-        ...r
-      },
-      !0,
-      // extractable for public key export
-      ["encrypt", "decrypt"]
-    );
-    return e.debug && console.info("🔐 Generated RSA key pair:", {
-      keySize: e.keySize,
-      algorithm: "RSA-OAEP",
-      hash: "SHA-256",
-      publicKeyType: t.publicKey.type,
-      privateKeyType: t.privateKey.type,
-      publicKeyUsages: t.publicKey.usages,
-      privateKeyUsages: t.privateKey.usages
-    }), {
-      publicKey: t.publicKey,
-      privateKey: t.privateKey
-    };
-  } catch (r) {
-    throw new s(
-      `Failed to generate RSA key pair: ${r instanceof Error ? r.message : "Unknown error"}`,
-      "KEY_GENERATION_FAILED",
-      r instanceof Error ? r : void 0
-    );
-  }
-}
-async function F(n) {
-  try {
-    return {
-      jwk: await crypto.subtle.exportKey("jwk", n),
-      kty: "RSA",
-      alg: "RSA-OAEP-256"
-    };
-  } catch (e) {
-    throw new s(
-      `Failed to export public key: ${e instanceof Error ? e.message : "Unknown error"}`,
-      "KEY_IMPORT_FAILED",
-      e instanceof Error ? e : void 0
-    );
-  }
-}
-async function I(n) {
-  try {
-    const e = JSON.parse(n);
-    return await crypto.subtle.importKey(
-      "jwk",
-      e,
-      {
-        name: "RSA-OAEP",
-        hash: "SHA-256"
-      },
-      !1,
-      // not extractable
-      ["encrypt"]
-    );
-  } catch (e) {
-    throw new s(
-      `Failed to import server public key: ${e instanceof Error ? e.message : "Unknown error"}`,
-      "KEY_IMPORT_FAILED",
-      e instanceof Error ? e : void 0
-    );
-  }
-}
-async function Y(n, e, r) {
-  try {
-    const E = new TextEncoder().encode(n), o = await crypto.subtle.encrypt(
-      {
-        name: "RSA-OAEP"
-      },
-      e,
-      E
-    );
-    return {
-      data: btoa(
-        String.fromCharCode(...new Uint8Array(o))
-      ),
-      algorithm: "RSA-OAEP",
-      keyId: r
-    };
-  } catch (t) {
-    throw new s(
-      `Failed to encrypt message for server: ${t instanceof Error ? t.message : "Unknown error"}`,
-      "ENCRYPTION_FAILED",
-      t instanceof Error ? t : void 0
-    );
-  }
-}
-async function V(n, e) {
-  try {
-    const r = Uint8Array.from(
-      atob(n.data),
-      (o) => o.charCodeAt(0)
-    ), t = await crypto.subtle.decrypt(
-      {
-        name: "RSA-OAEP"
-      },
-      e,
-      r
-    );
-    return new TextDecoder().decode(t);
-  } catch (r) {
-    throw new s(
-      `Failed to decrypt message from server: ${r instanceof Error ? r.message : "Unknown error"}`,
-      "DECRYPTION_FAILED",
-      r instanceof Error ? r : void 0
-    );
-  }
-}
-async function H(n, e, r) {
-  try {
-    const t = await I(
-      n.serverPublicKey
-    );
-    return {
-      clientKeyPair: e,
-      serverPublicKey: t,
-      deviceId: r,
-      serverKeyId: n.keyId,
-      establishedAt: /* @__PURE__ */ new Date()
-    };
-  } catch (t) {
-    throw new s(
-      `Failed to establish crypto session: ${t instanceof Error ? t.message : "Unknown error"}`,
-      "KEY_IMPORT_FAILED",
-      t instanceof Error ? t : void 0
-    );
-  }
-}
-function x(n) {
-  return !(!n || !n.clientKeyPair || !n.serverPublicKey);
-}
-function B() {
-  const n = Date.now().toString(36), e = new Uint8Array(8);
-  if (typeof window < "u" && window.crypto?.getRandomValues)
-    window.crypto.getRandomValues(e);
-  else
-    for (let t = 0; t < e.length; t++)
-      e[t] = Math.floor(Math.random() * 256);
-  const r = Array.from(e).map((t) => t.toString(36)).join("");
-  return `device_${n}_${r}`;
-}
-function D() {
-  return typeof window < "u" && typeof window.crypto < "u" && typeof window.crypto.subtle < "u";
-}
-function g() {
-  return typeof window < "u" && (window.isSecureContext || window.location.protocol === "https:");
-}
-function X() {
-  return D() && g();
-}
-function j(n) {
-  const e = new Uint8Array(n);
-  let r = "";
-  for (let t = 0; t < e.byteLength; t++)
-    r += String.fromCharCode(e[t]);
-  return btoa(r);
-}
-function $(n) {
-  const e = atob(n), r = new Uint8Array(e.length);
-  for (let t = 0; t < e.length; t++)
-    r[t] = e.charCodeAt(t);
-  return r.buffer;
-}
-function z(n) {
-  try {
-    return JSON.stringify(n);
-  } catch {
-    return String(n);
-  }
-}
-function W(n) {
-  try {
-    return JSON.parse(n);
-  } catch {
-    return null;
-  }
-}
-function J(n, ...e) {
-  typeof process < "u" && process.env && process.env.NODE_ENV === "development" && console.info(`🔐 [Crypto] ${n}`, ...e);
-}
-const Re = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ __proto__: null, CryptoError: s, DEFAULT_CRYPTO_CONFIG: S, arrayBufferToBase64: j, base64ToArrayBuffer: $, canUseEncryption: X, debugLog: J, decryptFromServer: V, encryptForServer: Y, establishCryptoSession: H, exportPublicKey: F, generateClientKeyPair: k, generateDeviceId: B, importServerPublicKey: I, isCryptoSessionValid: x, isSecureContext: g, isWebCryptoSupported: D, safeParse: W, safeStringify: z }, Symbol.toStringTag, { value: "Module" })), Z = "sassy:basic", Q = "sassy:plus", q = "sassy:advanced", Pe = {
-  PLAN_BASIC: Z,
-  PLAN_PLUS: Q,
-  PLAN_PREMIUM: q
-}, Se = {
+  [O]: [
+    p,
+    y,
+    h
+  ],
+  [c]: [C],
+  [M]: [U]
+}, z = "x-diggidy-chat-id", K = "timestamp", Z = "tokenUsage", J = "Diggidy", Q = "sassy:basic", $ = "sassy:plus", q = "sassy:advanced", tt = {
   TOOL: {
     DATETIME: "getDateTime",
     IMAGES: "getImages",
@@ -286,63 +74,81 @@ const Re = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
     REASONING: "addon:reasoning",
     CODEINTERPRETER: "addon:codeinterpreter"
   }
+}, nt = (t) => {
+  for (const [n, s] of Object.entries(
+    H
+  ))
+    if (s.some((o) => t.startsWith(o)))
+      return n;
+  return null;
+}, ot = (t) => {
+  if (!t || t.length === 0)
+    return [];
+  const n = /* @__PURE__ */ new Set();
+  for (const s of t)
+    for (const [o, L] of Object.entries(
+      u
+    ))
+      L.includes(s) && (o === O || o === _ || o === c) && n.add(o);
+  return m.filter((s) => n.has(s));
 };
-function Ie(n) {
-  return !!n && Array.isArray(n.capabilities) && n.capabilities.length >= 0;
+function st(t) {
+  return !!t && Array.isArray(t.capabilities) && t.capabilities.length >= 0;
 }
-function ee(n) {
-  return n ? new Set(n) : null;
+function V(t) {
+  return t ? new Set(t) : null;
 }
-function De(n, e, r) {
-  if (!e || Array.isArray(e) && e.length === 0)
+function Et(t, n, s) {
+  if (!n || Array.isArray(n) && n.length === 0)
     return !0;
-  const t = n instanceof Set ? n : ee(n);
-  return !t || t.size === 0 ? !1 : typeof e == "string" ? t.has(e) : r?.any === !0 ? e.some((o) => t.has(o)) : e.every((o) => t.has(o));
+  const o = t instanceof Set ? t : V(t);
+  return !o || o.size === 0 ? !1 : typeof n == "string" ? o.has(n) : s?.any === !0 ? n.some((P) => o.has(P)) : n.every((P) => o.has(P));
 }
 export {
-  ye as ALL_MODELS,
+  k as ALL_MODELS,
   m as ALL_PROVIDERS,
-  de as ALL_REASONING_MODELS,
-  _e as APPLICATION_NAME,
-  Se as CAPABILITIES,
-  se as DEFAULT_PROVIDER,
-  Ae as DIGGIDY_CHAT_ID_HEADER,
-  G as MODELS_PER_PROVIDER,
-  f as MODEL_CLAUDE_HAIKU,
-  A as MODEL_CLAUDE_SONNET,
-  ae as MODEL_DEV,
-  Ee as MODEL_DISPLAY_NAMES,
-  ce as MODEL_EMBEDDING_TEXT,
-  _ as MODEL_GEMINI_FLASH,
-  l as MODEL_GEMINI_PRO,
-  p as MODEL_GPT4_MINI,
-  u as MODEL_GPT5,
-  ie as MODEL_MEMORY_INFERENCE,
-  R as MODEL_SONAR,
-  P as MODEL_SONAR_PRO,
-  Z as PLAN_BASIC,
-  Q as PLAN_PLUS,
+  j as ALL_REASONING_MODELS,
+  J as APPLICATION_NAME,
+  H as APPROXIMATE_MODELS_PER_PROVIDER,
+  tt as CAPABILITIES,
+  b as DEFAULT_PROVIDER,
+  z as DIGGIDY_CHAT_ID_HEADER,
+  u as MODELS_PER_PROVIDER,
+  I as MODEL_CLAUDE_HAIKU,
+  i as MODEL_CLAUDE_SONNET,
+  B as MODEL_DEV,
+  x as MODEL_DISPLAY_NAMES,
+  W as MODEL_EMBEDDING_TEXT,
+  D as MODEL_GEMINI_FLASH,
+  a as MODEL_GEMINI_PRO,
+  T as MODEL_GPT4_NANO,
+  A as MODEL_GPT5,
+  R as MODEL_GPT5_MINI,
+  r as MODEL_GPT5_NANO,
+  F as MODEL_MEMORY_INFERENCE,
+  S as MODEL_SONAR,
+  N as MODEL_SONAR_PRO,
+  Q as PLAN_BASIC,
+  $ as PLAN_PLUS,
   q as PLAN_PREMIUM,
-  Pe as POLICY_GRANTS,
-  y as PROVIDER_ANTHROPIC,
-  d as PROVIDER_GOOGLE,
-  T as PROVIDER_MEMORY,
-  oe as PROVIDER_MISTRAL,
-  c as PROVIDER_OPENAI,
-  O as PROVIDER_PERPLEXITY,
-  ue as PROVIDER_ROLE_MAP,
-  M as PROVIDER_SUMMARY,
-  i as ROLE_ASSISTANT,
-  ne as ROLE_HIDDEN,
-  re as ROLE_INTERNAL,
-  L as ROLE_SYSTEM,
-  a as ROLE_USER,
-  pe as SORT_BY_TIMESTAMP,
-  fe as SORT_BY_TOKEN_USAGE,
-  Re as crypto,
-  le as findProvider,
-  Oe as getProvidersFromModels,
-  De as isEntitled,
-  Ie as isEntitlementLoaded,
-  ee as toCapabilitySet
+  _ as PROVIDER_ANTHROPIC,
+  c as PROVIDER_GOOGLE,
+  g as PROVIDER_MEMORY,
+  v as PROVIDER_MISTRAL,
+  O as PROVIDER_OPENAI,
+  M as PROVIDER_PERPLEXITY,
+  w as PROVIDER_ROLE_MAP,
+  d as PROVIDER_SUMMARY,
+  e as ROLE_ASSISTANT,
+  X as ROLE_HIDDEN,
+  Y as ROLE_INTERNAL,
+  l as ROLE_SYSTEM,
+  E as ROLE_USER,
+  K as SORT_BY_TIMESTAMP,
+  Z as SORT_BY_TOKEN_USAGE,
+  nt as findProvider,
+  ot as getProvidersFromModels,
+  Et as isEntitled,
+  st as isEntitlementLoaded,
+  V as toCapabilitySet
 };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@versini/sassysaint-common",
-	"version": "4.12.0",
+	"version": "4.13.0",
 	"license": "MIT",
 	"author": "Arno Versini",
 	"publishConfig": {
@@ -32,5 +32,5 @@
 		"test:watch": "vitest",
 		"watch": "npm-run-all dev"
 	},
-	"gitHead": "f7d78abb7a4c8517ab533addf1bfa6cd244439dc"
+	"gitHead": "89572beafadc51e691166d4334c4ce4d1002f682"
 }