@retrivora-ai/rag-engine 2.2.6 → 2.2.8

package/src/components/ChatWidget.tsx

@@ -4,6 +4,7 @@ import { ChatWindow } from './ChatWindow';
 import { useConfig } from './ConfigProvider';
 import { ChatWidgetProps } from '../types';
 import { SDK_VERSION } from '../version';
+import { LicenseValidator } from '../core/LicenseValidator';
 
 const DEFAULT_DIMENSIONS = { width: 380, height: 600 };
 
@@ -45,8 +46,8 @@ const GEMINI_STYLES = `
   }
 `;
 
-export function ChatWidget({ position = 'bottom-right', onAddToCart, apiUrl, retrivoraApiBase, headers }: ChatWidgetProps) {
-  const { ui } = useConfig();
+export function ChatWidget({ position = 'bottom-right', onAddToCart, apiUrl, retrivoraApiBase, licenseKey: licenseKeyProp, headers }: ChatWidgetProps) {
+  const { ui, projectId } = useConfig();
   const [isOpen, setIsOpen] = useState(false);
   const [hasUnread, setHasUnread] = useState(false);
   const [dimensions, setDimensions] = useState(DEFAULT_DIMENSIONS);
@@ -71,44 +72,37 @@ export function ChatWidget({ position = 'bottom-right', onAddToCart, apiUrl, ret
   const handleOpen = async () => {
     setIsValidating(true);
     try {
-      const base = retrivoraApiBase || '/api/retrivora';
-      const configUrl = `${base.replace(/\/$/, '')}/config?sdkVersion=${SDK_VERSION}`;
-      const res = await fetch(configUrl, {
-        method: 'GET',
-        cache: 'no-store',
-        headers: {
-          'Content-Type': 'application/json',
-          'x-sdk-version': SDK_VERSION,
-          ...(headers || {})
-        },
-      });
-
-      if (!res.ok) {
-        const data = await res.json().catch(() => ({}));
-        if (res.status === 426 || data.code === 'SDK_VERSION_OUTDATED') {
-          const msg = data.error || 'Your Retrivora SDK package version is outdated. Please update your package to the latest version to continue.';
-          setWidgetError(msg);
-          setIsOpen(false); // DO NOT OPEN CHAT WIDGET
-          return;
+      const getHeader = (name: string) => {
+        if (!headers) return undefined;
+        const target = name.toLowerCase();
+        for (const [k, v] of Object.entries(headers)) {
+          if (k.toLowerCase() === target) return v;
         }
-        if (
-          res.status === 403 ||
-          res.status === 401 ||
-          (typeof data.error === 'string' && data.error.toLowerCase().includes('license'))
-        ) {
-          const msg = (typeof data.error === 'string' ? data.error : data.error?.message) || 'Your Retrivora license is no longer valid. Please contact your administrator or obtain a valid license key.';
-          setWidgetError(msg);
-          setIsOpen(false); // DO NOT OPEN CHAT WIDGET
-          return;
-        }
-      }
+        return undefined;
+      };
+
+      const resolvedLicenseKey =
+        licenseKeyProp ||
+        getHeader('x-license-key') ||
+        getHeader('authorization')?.replace(/^Bearer\s+/i, '') ||
+        (typeof process !== 'undefined'
+          ? (process.env.NEXT_PUBLIC_RETRIVORA_LICENSE_KEY || process.env.RETRIVORA_LICENSE_KEY)
+          : '') ||
+        '';
+
+      await LicenseValidator.getInstance().validate({
+        licenseKey: resolvedLicenseKey,
+        projectId,
+        retrivoraApiBase,
+        headers,
+      });
 
       setWidgetError(null);
       setIsOpen(true);
       setHasUnread(false);
-    } catch {
-      // Fallback
-      setIsOpen(true);
+    } catch (err: any) {
+      setWidgetError(err?.message || 'Access denied.');
+      setIsOpen(false); // DO NOT OPEN CHAT WIDGET
     } finally {
       setIsValidating(false);
     }
@@ -190,6 +184,7 @@ export function ChatWidget({ position = 'bottom-right', onAddToCart, apiUrl, ret
           onAddToCart={onAddToCart}
           apiUrl={apiUrl}
           retrivoraApiBase={retrivoraApiBase}
+          licenseKey={licenseKeyProp}
           headers={headers}
         />
         {/* Pointer (Tail) */}

package/src/components/ChatWindow.tsx

@@ -23,6 +23,7 @@ import { useRagChat } from '../hooks/useRagChat';
 import { BORDER_RADIUS_MAP, CHAT_SUGGESTIONS } from '../config/uiConstants';
 import { ChatWindowProps } from '../types';
 import { SDK_VERSION } from '../version';
+import { LicenseValidator } from '../core/LicenseValidator';
 
 interface SpeechRecognitionEvent {
   resultIndex: number;
@@ -67,6 +68,7 @@ export function ChatWindow({
   onAddToCart,
   apiUrl,
   retrivoraApiBase,
+  licenseKey: licenseKeyProp,
   headers
 }: ChatWindowProps) {
   const { ui, projectId } = useConfig();
@@ -80,6 +82,7 @@ export function ChatWindow({
     namespace: projectId,
     apiUrl,
     retrivoraApiBase,
+    licenseKey: licenseKeyProp,
     headers,
   });
 
@@ -97,48 +100,49 @@ export function ChatWindow({
     let isMounted = true;
     async function validateSessionLicense() {
       try {
-        const base = retrivoraApiBase || '/api/retrivora';
-        const configUrl = `${base.replace(/\/$/, '')}/config?sdkVersion=${SDK_VERSION}`;
-        const res = await fetch(configUrl, {
-          method: 'GET',
-          cache: 'no-store',
-          headers: {
-            'Content-Type': 'application/json',
-            'x-sdk-version': SDK_VERSION,
-            ...(headers || {})
-          },
+        const getHeader = (name: string) => {
+          if (!headers) return undefined;
+          const target = name.toLowerCase();
+          for (const [k, v] of Object.entries(headers)) {
+            if (k.toLowerCase() === target) return v;
+          }
+          return undefined;
+        };
+
+        const resolvedLicenseKey =
+          licenseKeyProp ||
+          getHeader('x-license-key') ||
+          getHeader('authorization')?.replace(/^Bearer\s+/i, '') ||
+          (typeof process !== 'undefined'
+            ? (process.env.NEXT_PUBLIC_RETRIVORA_LICENSE_KEY || process.env.RETRIVORA_LICENSE_KEY)
+            : '') ||
+          '';
+
+        await LicenseValidator.getInstance().validate({
+          licenseKey: resolvedLicenseKey,
+          projectId,
+          retrivoraApiBase,
+          headers,
         });
 
-        if (!res.ok) {
-          const data = await res.json().catch(() => ({}));
-          if (res.status === 426 || data.code === 'SDK_VERSION_OUTDATED') {
-            if (isMounted) {
-              setVersionError(data.error || 'Your Retrivora SDK package is outdated. Please update your package to the latest version to continue.');
-            }
-          } else if (
-            res.status === 403 ||
-            res.status === 401 ||
-            (typeof data.error === 'string' && data.error.toLowerCase().includes('license'))
-          ) {
-            if (isMounted) {
-              const errMsg = typeof data.error === 'string' ? data.error : data.error?.message || 'Your Retrivora license is no longer valid. Please contact your administrator or obtain a valid license key.';
-              setLicenseError(errMsg);
-            }
-          }
-        } else {
-          if (isMounted) {
-            setLicenseError(null);
-            setVersionError(null);
+        if (isMounted) {
+          setLicenseError(null);
+          setVersionError(null);
+        }
+      } catch (err: any) {
+        if (isMounted) {
+          if (err?.code === 'SDK_VERSION_UNSUPPORTED') {
+            setVersionError(err?.message || 'SDK version unsupported.');
+          } else {
+            setLicenseError(err?.message || 'License validation failed.');
           }
         }
-      } catch {
-        // Non-blocking fallback
       }
     }
 
     validateSessionLicense();
     return () => { isMounted = false; };
-  }, [retrivoraApiBase, headers]);
+  }, [retrivoraApiBase, headers, projectId]);
 
   // Initialize SpeechRecognition
   useEffect(() => {

package/src/core/LicenseValidator.ts

@@ -0,0 +1,198 @@
+import { SDK_VERSION } from '../version';
+import { SDKVersionUnsupportedError, LicenseValidationError } from '../exceptions';
+import { LicenseVerifier } from './LicenseVerifier';
+
+export interface LicenseValidationRequest {
+  licenseKey: string;
+  projectId?: string;
+  sdkVersion?: string;
+  sdk?: string;
+  platform?: string;
+  retrivoraApiBase?: string;
+  headers?: Record<string, string>;
+}
+
+export interface LicenseValidationResponse {
+  valid: boolean;
+  licenseStatus: 'ACTIVE' | 'SUSPENDED' | 'TERMINATED' | 'EXPIRED' | 'REVOKED';
+  minimumSupportedVersion: string;
+  latestVersion: string;
+  forceUpgrade: boolean;
+  expiresAt: string | null;
+  message: string;
+}
+
+interface CachedSuccessValidation {
+  response: LicenseValidationResponse;
+  timestamp: number;
+}
+
+export class LicenseValidator {
+  private static instance: LicenseValidator;
+  private cache: Map<string, CachedSuccessValidation> = new Map();
+  private static readonly SUCCESS_CACHE_TTL_MS = 5 * 60 * 1000; // 5-minute TTL for successful validation only
+
+  private constructor() {}
+
+  public static getInstance(): LicenseValidator {
+    if (!LicenseValidator.instance) {
+      LicenseValidator.instance = new LicenseValidator();
+    }
+    return LicenseValidator.instance;
+  }
+
+  /**
+   * Invalidate local validation cache for a license key
+   */
+  public purgeCache(licenseKey?: string): void {
+    if (licenseKey) {
+      this.cache.delete(licenseKey);
+    } else {
+      this.cache.clear();
+    }
+  }
+
+  /**
+   * Validate license status and SDK version against Retrivora License Service
+   */
+  public async validate(request: LicenseValidationRequest): Promise<LicenseValidationResponse> {
+    const {
+      licenseKey,
+      projectId,
+      sdkVersion = SDK_VERSION,
+      sdk = '@retrivora-ai/rag-engine',
+      platform = typeof window !== 'undefined' ? 'browser' : 'node',
+      retrivoraApiBase,
+      headers: customHeaders,
+    } = request;
+
+    const getHeader = (name: string): string | undefined => {
+      if (!customHeaders) return undefined;
+      const target = name.toLowerCase();
+      for (const [k, v] of Object.entries(customHeaders)) {
+        if (k.toLowerCase() === target) return v;
+      }
+      return undefined;
+    };
+
+    const effectiveLicenseKey =
+      licenseKey ||
+      getHeader('x-license-key') ||
+      getHeader('authorization')?.replace(/^Bearer\s+/i, '') ||
+      (typeof process !== 'undefined'
+        ? (process.env.NEXT_PUBLIC_RETRIVORA_LICENSE_KEY || process.env.RETRIVORA_LICENSE_KEY)
+        : '') ||
+      '';
+
+    if (!effectiveLicenseKey) {
+      this.purgeCache(effectiveLicenseKey);
+      throw new LicenseValidationError('Missing RETRIVORA_LICENSE_KEY in request.');
+    }
+
+    // 1. Check successful 5-minute cache
+    const cached = this.cache.get(effectiveLicenseKey);
+    if (cached) {
+      const isFresh = Date.now() - cached.timestamp < LicenseValidator.SUCCESS_CACHE_TTL_MS;
+      if (isFresh && cached.response.valid && cached.response.licenseStatus === 'ACTIVE' && !cached.response.forceUpgrade) {
+        return cached.response;
+      } else {
+        this.cache.delete(effectiveLicenseKey);
+      }
+    }
+
+    // 2. Fetch live validation from Retrivora backend API
+    const base = retrivoraApiBase || (typeof process !== 'undefined' ? process.env.NEXT_PUBLIC_RETRIVORA_API_BASE || process.env.RETRIVORA_API_BASE : '') || '/api/retrivora';
+    const validateUrl = `${base.replace(/\/$/, '')}/v1/license/validate`;
+
+    let res: Response | null = null;
+    try {
+      res = await fetch(validateUrl, {
+        method: 'POST',
+        cache: 'no-store',
+        headers: {
+          'Content-Type': 'application/json',
+          'x-license-key': effectiveLicenseKey,
+          'x-sdk-version': sdkVersion,
+          ...(customHeaders || {}),
+        },
+        body: JSON.stringify({
+          licenseKey,
+          projectId,
+          sdkVersion,
+          sdk,
+          platform,
+        }),
+      });
+    } catch (err: any) {
+      // Fallback: If network error occurs, verify locally via RSA LicenseVerifier
+      try {
+        const payload = LicenseVerifier.verify(licenseKey, projectId || 'my-rag-app');
+        const fallbackResp: LicenseValidationResponse = {
+          valid: true,
+          licenseStatus: 'ACTIVE',
+          minimumSupportedVersion: '2.1.0',
+          latestVersion: SDK_VERSION,
+          forceUpgrade: false,
+          expiresAt: payload.expiresAt ? new Date(payload.expiresAt * 1000).toISOString() : null,
+          message: 'Local license verification active.',
+        };
+        this.cache.set(licenseKey, { response: fallbackResp, timestamp: Date.now() });
+        return fallbackResp;
+      } catch {
+        this.purgeCache(licenseKey);
+        throw new LicenseValidationError(`License validation request failed: ${err?.message || 'Network error'}`);
+      }
+    }
+
+    if (res && !res.ok) {
+      // Attempt local verification fallback if API route returned 404 or non-OK response
+      try {
+        const payload = LicenseVerifier.verify(licenseKey, projectId || 'my-rag-app');
+        const fallbackResp: LicenseValidationResponse = {
+          valid: true,
+          licenseStatus: 'ACTIVE',
+          minimumSupportedVersion: '2.1.0',
+          latestVersion: SDK_VERSION,
+          forceUpgrade: false,
+          expiresAt: payload.expiresAt ? new Date(payload.expiresAt * 1000).toISOString() : null,
+          message: 'Local license verification active.',
+        };
+        this.cache.set(licenseKey, { response: fallbackResp, timestamp: Date.now() });
+        return fallbackResp;
+      } catch { /* proceed to parse error response */ }
+    }
+
+    const data: LicenseValidationResponse = await res!.json().catch(() => ({
+      valid: false,
+      licenseStatus: 'REVOKED' as const,
+      minimumSupportedVersion: '2.1.0',
+      latestVersion: SDK_VERSION,
+      forceUpgrade: false,
+      expiresAt: null,
+      message: 'Failed to parse license validation response.',
+    }));
+
+    // 3. Negative validation responses immediately purge any existing cache
+    if (!res.ok || !data.valid || data.licenseStatus !== 'ACTIVE' || data.forceUpgrade) {
+      this.purgeCache(licenseKey);
+
+      if (data.forceUpgrade || res.status === 426) {
+        throw new SDKVersionUnsupportedError(
+          data.message || `This SDK version (${sdkVersion}) is no longer supported. Upgrade to version ${data.latestVersion || '2.2.6'} or later.`,
+          data
+        );
+      }
+
+      const errMsg = data.message || `License validation failed with status: ${data.licenseStatus}. Access denied.`;
+      throw new LicenseValidationError(errMsg, data);
+    }
+
+    // 4. Cache SUCCESSFUL validation only (TTL = 5 minutes)
+    this.cache.set(licenseKey, {
+      response: data,
+      timestamp: Date.now(),
+    });
+
+    return data;
+  }
+}

package/src/exceptions/index.ts

@@ -8,7 +8,9 @@ export type RetrivoraErrorCode =
   | 'RETRIEVAL_FAILED'
   | 'RATE_LIMITED'
   | 'CONFIGURATION_ERROR'
-  | 'AUTHENTICATION_ERROR';
+  | 'AUTHENTICATION_ERROR'
+  | 'SDK_VERSION_UNSUPPORTED'
+  | 'LICENSE_VALIDATION_ERROR';
 
 export class RetrivoraError extends Error {
   readonly code: RetrivoraErrorCode;
@@ -58,6 +60,18 @@ export class AuthenticationException extends RetrivoraError {
   }
 }
 
+export class SDKVersionUnsupportedError extends RetrivoraError {
+  constructor(message = 'This SDK version is no longer supported.', details?: unknown) {
+    super(message, 'SDK_VERSION_UNSUPPORTED', details);
+  }
+}
+
+export class LicenseValidationError extends RetrivoraError {
+  constructor(message = 'License validation failed.', details?: unknown) {
+    super(message, 'LICENSE_VALIDATION_ERROR', details);
+  }
+}
+
 /**
  * Wraps any unknown error into an appropriate RetrivoraError subclass.
  */
@@ -80,14 +94,20 @@ export function wrapError(
     return new RateLimitException(message, err);
   }
 
-  // 2. Authentication Recognition
+  // 2. Authentication / License Recognition
   if (
     status === 401 ||
     status === 403 ||
-    /unauthorized|auth|api[- ]?key/i.test(message) ||
-    code === 'INVALID_API_KEY'
+    /unauthorized|auth|license|revoked|terminated|api[- ]?key/i.test(message) ||
+    code === 'INVALID_API_KEY' ||
+    code === 'LICENSE_DELETED' ||
+    code === 'LICENSE_INACTIVE'
   ) {
-    return new AuthenticationException(message, err);
+    const isLicenseError = /403|license|revoked|terminated/i.test(message) || status === 403;
+    const cleanMsg = isLicenseError
+      ? 'Your Retrivora license key has been terminated, suspended, or revoked. Access denied.'
+      : message;
+    return new AuthenticationException(cleanMsg, err);
   }
 
   // Fallback Mapping based on defaultCode

package/src/handlers/index.ts

@@ -5,6 +5,8 @@ import { ChatMessage, ChatResponse } from '../types';
 import { DocumentParser } from '../utils/DocumentParser';
 import { UITransformer } from '../utils/UITransformer';
 import { DatabaseStorage, HistoryMessage } from '../core/DatabaseStorage';
+import { LicenseVerifier } from '../core/LicenseVerifier';
+import { SDK_VERSION } from '../version';
 
 export interface HandlerOptions {
   onAuthorize?: (req: NextRequest) => boolean | Promise<boolean> | Response | Promise<Response>;
@@ -147,8 +149,6 @@ function getOrCreatePlugin(configOrPlugin: Partial<RagConfig> | VectorPlugin | u
 
 // ─── Telemetry Reporter Helper ───────────────────────────────────────────────
 
-import { SDK_VERSION } from '../version';
-
 /**
  * Asynchronously sends telemetry payload to telemetryUrl when telemetry is enabled
  * or when a licenseKey is set. Non-blocking.
@@ -492,8 +492,18 @@ export function createStreamHandler(
           }
         } catch (streamError) {
           if (isActive) {
-            const errorMessage =
+            let errorMessage =
               streamError instanceof Error ? streamError.message : String(streamError);
+
+            if (
+              errorMessage.includes('403') ||
+              errorMessage.toLowerCase().includes('license') ||
+              errorMessage.toLowerCase().includes('revoked') ||
+              errorMessage.toLowerCase().includes('terminated')
+            ) {
+              errorMessage = 'Your Retrivora license key has been terminated, suspended, or revoked. Access denied.';
+            }
+
             console.error('[createStreamHandler] Stream error:', streamError);
             reportTelemetry(req, plugin, 'QUERY_GENERATION', 'error', errorMessage);
             try {
@@ -586,6 +596,64 @@ export function createHealthHandler(
   };
 }
 
+/**
+ * createLicenseHandler — factory for the license validation endpoint (/v1/license/validate).
+ */
+export function createLicenseHandler(
+  configOrPlugin?: Partial<RagConfig> | VectorPlugin,
+  options?: HandlerOptions
+) {
+  const plugin = getOrCreatePlugin(configOrPlugin);
+  const onAuthorize = options?.onAuthorize;
+
+  return async function POST(req: NextRequest) {
+    if (req) {
+      const authResult = await checkAuth(req, onAuthorize);
+      if (authResult) return authResult as any;
+    }
+
+    try {
+      const body = await req.json().catch(() => ({}));
+      const config = plugin.getConfig();
+      const licenseKey =
+        req.headers.get('x-license-key') ||
+        body?.licenseKey ||
+        req.headers.get('authorization')?.replace(/^Bearer\s+/i, '') ||
+        config.licenseKey ||
+        process.env.RETRIVORA_LICENSE_KEY ||
+        process.env.NEXT_PUBLIC_RETRIVORA_LICENSE_KEY ||
+        '';
+
+      const projectId = body?.projectId || config.projectId || 'my-rag-app';
+
+      const payload = LicenseVerifier.verify(licenseKey, projectId);
+
+      return NextResponse.json({
+        valid: true,
+        licenseStatus: 'ACTIVE',
+        minimumSupportedVersion: '2.1.0',
+        latestVersion: SDK_VERSION,
+        forceUpgrade: false,
+        expiresAt: payload.expiresAt ? new Date(payload.expiresAt * 1000).toISOString() : null,
+        message: 'License key is active and valid.',
+      });
+    } catch (err: any) {
+      return NextResponse.json(
+        {
+          valid: false,
+          licenseStatus: 'REVOKED',
+          minimumSupportedVersion: '2.1.0',
+          latestVersion: SDK_VERSION,
+          forceUpgrade: false,
+          expiresAt: null,
+          message: err?.message || 'License validation failed.',
+        },
+        { status: 400 }
+      );
+    }
+  };
+}
+
 /**
  * createUploadHandler — factory for the file upload ingestion endpoint.
  */
@@ -922,6 +990,7 @@ export function createRagHandler(
   const historyHandler = createHistoryHandler(plugin, { onAuthorize });
   const feedbackHandler = createFeedbackHandler(plugin, { onAuthorize });
   const sessionsHandler = createSessionsHandler(plugin, { onAuthorize });
+  const licenseHandler = createLicenseHandler(plugin, { onAuthorize });
 
   async function routePostRequest(req: any, segment: string) {
     switch (segment) {
@@ -940,6 +1009,9 @@ export function createRagHandler(
         return historyHandler(req);
       case 'feedback':
         return feedbackHandler(req);
+      case 'license/validate':
+      case 'v1/license/validate':
+        return licenseHandler(req);
       default:
         return NextResponse.json({ error: `Not Found: POST segment "${segment}" not supported.` }, { status: 404 });
     }
@@ -973,6 +1045,7 @@ export function createRagHandler(
     try {
       const url = new URL(req.url);
       const pathname = url.pathname;
+      if (pathname.includes('/license/validate')) return 'v1/license/validate';
       if (pathname.endsWith('/upload')) return 'upload';
       if (pathname.endsWith('/chat') || pathname.endsWith('/chat-sync')) return 'chat';
       if (pathname.endsWith('/health')) return 'health';

package/src/hooks/useRagChat.ts

@@ -129,8 +129,27 @@ export function useRagChat(
           userMessageId: userMsgId,
         });
 
-        const fetchHeaders = {
+        const getHeader = (headersObj: Record<string, string> | undefined, name: string) => {
+          if (!headersObj) return undefined;
+          const target = name.toLowerCase();
+          for (const [k, v] of Object.entries(headersObj)) {
+            if (k.toLowerCase() === target) return v;
+          }
+          return undefined;
+        };
+
+        const resolvedLicenseKey =
+          options.licenseKey ||
+          getHeader(options.headers, 'x-license-key') ||
+          getHeader(options.headers, 'authorization')?.replace(/^Bearer\s+/i, '') ||
+          (typeof process !== 'undefined'
+            ? (process.env.NEXT_PUBLIC_RETRIVORA_LICENSE_KEY || process.env.RETRIVORA_LICENSE_KEY)
+            : '') ||
+          '';
+
+        const fetchHeaders: Record<string, string> = {
           'Content-Type': 'application/json',
+          ...(resolvedLicenseKey ? { 'x-license-key': resolvedLicenseKey } : {}),
           ...(options.headers || {})
         };
 
@@ -292,7 +311,15 @@ export function useRagChat(
           console.log('[useRagChat] Streaming stopped by user.');
           return;
         }
-        const msg = err instanceof Error ? err.message : 'Something went wrong. Please try again.';
+        let msg = err instanceof Error ? err.message : 'Something went wrong. Please try again.';
+        if (
+          msg.includes('403') ||
+          msg.toLowerCase().includes('license') ||
+          msg.toLowerCase().includes('revoked') ||
+          msg.toLowerCase().includes('terminated')
+        ) {
+          msg = 'Your Retrivora license key has been terminated, suspended, or revoked. Access denied.';
+        }
         setError(msg);
         onError?.(msg);
       } finally {

package/src/index.ts

@@ -63,6 +63,8 @@ export type { ILLMProvider, EmbedOptions } from './llm/ILLMProvider';
 export type { Chunk, ChunkOptions } from './rag/DocumentChunker';
 export type { Retrivora } from './core/Retrivora';
 export type { RetrivoraErrorCode } from './exceptions';
+export { LicenseValidator } from './core/LicenseValidator';
+export type { LicenseValidationRequest, LicenseValidationResponse } from './core/LicenseValidator';
 export {
   RetrivoraError,
   ProviderNotFoundException,
@@ -71,6 +73,8 @@ export {
   RateLimitException,
   ConfigurationException,
   AuthenticationException,
+  SDKVersionUnsupportedError,
+  LicenseValidationError,
 } from './exceptions';
 export type {
   VectorMatch,

package/src/server.ts

@@ -90,6 +90,10 @@ export {
   sseErrorFrame,
 } from './handlers';
 
+// ── License Validator ─────────────────────────────────────────
+export { LicenseValidator } from './core/LicenseValidator';
+export type { LicenseValidationRequest, LicenseValidationResponse } from './core/LicenseValidator';
+
 // ── Exceptions ────────────────────────────────────────────────
 export type { RetrivoraErrorCode } from './exceptions';
 export {
@@ -100,6 +104,8 @@ export {
   RateLimitException,
   ConfigurationException,
   AuthenticationException,
+  SDKVersionUnsupportedError,
+  LicenseValidationError,
   wrapError,
 } from './exceptions';
 

package/src/types/chat.ts

@@ -57,6 +57,8 @@ export interface UseRagChatOptions {
   onError?: (error: string) => void;
   /** Optional custom headers to send with the chat request */
   headers?: Record<string, string>;
+  /** Optional Retrivora license key override */
+  licenseKey?: string;
   /** Session ID for history and feedback tracking (default: 'default') */
   sessionId?: string;
 }