@nextpa/chat-core 0.1.0

package/dist/core/widget-core.js

@@ -0,0 +1,160 @@
+import { WidgetApiClient } from '../services/api';
+import { logger } from '../utils/logger';
+import { ConfigManager } from './config-manager';
+import { ChatManager } from './chat-manager';
+import { ThemeManager } from './theme-manager';
+import { ConsentManager } from './consent-manager';
+import { PopoverManager } from './popover-manager';
+import { NavigationManager } from './navigation-manager';
+import { ConversationPersistence } from './conversation-persistence';
+const DEMO_RESPONSE_DELAY_MS = 300;
+export class WidgetCore {
+    apiClient;
+    configManager;
+    chatManager;
+    themeManager;
+    consentManager;
+    popoverManager;
+    navigationManager;
+    persistence;
+    isMinimized = true;
+    isConnecting = false;
+    hasError = false;
+    isLoading = true;
+    initFailed = false;
+    pageUrl;
+    pageTitle;
+    onStateChanged;
+    onConnect;
+    logPrefix;
+    source;
+    constructor(options, onStateChanged, onDocumentProviders, onConnect, logPrefix) {
+        this.onStateChanged = onStateChanged;
+        this.onConnect = onConnect;
+        this.logPrefix = logPrefix;
+        this.source = options.source;
+        this.apiClient = options.apiClient ?? new WidgetApiClient({
+            apiKey: options.apiKey,
+            baseUrl: options.baseUrl,
+            source: options.source,
+            tokenProvider: options.tokenProvider,
+        });
+        this.configManager = new ConfigManager(this.apiClient);
+        this.chatManager = new ChatManager();
+        this.themeManager = new ThemeManager();
+        this.consentManager = new ConsentManager(onStateChanged);
+        this.popoverManager = new PopoverManager(onStateChanged);
+        this.navigationManager = new NavigationManager(onStateChanged, onDocumentProviders, () => this.resolvePageHost());
+        this.persistence = new ConversationPersistence(this.apiClient, logPrefix);
+        this.chatManager.on('messageAdded', () => {
+            onStateChanged();
+            this.persistence.saveToLocalStorage(this.chatManager);
+        });
+        this.chatManager.on('messagesCleared', onStateChanged);
+    }
+    async initialize() {
+        try {
+            const config = await this.configManager.loadConfig();
+            this.themeManager.initialize(config.theme, this.onStateChanged);
+            // The chat-app is an authenticated tenant-owner surface — the
+            // operator is previewing their own assistants, so the visitor-facing
+            // terms gate is irrelevant (and has no UI here). Skip it.
+            const autoAcceptConsent = this.source === 'chat-app';
+            this.consentManager.check(config.assistantId, config.showTermsAndConditions ?? false, autoAcceptConsent);
+            this.popoverManager.initialize(config);
+            this.detectPageContext();
+            // Hydrate the conversation panel up front so the user sees their
+            // previous messages on first paint, before the lazy SignalR /
+            // WebRTC connect inside connectText/connectVoice gets around to
+            // calling loadHistory itself. Without this the panel stays empty
+            // for the duration of the connect step, which on assistant switch
+            // looks like 'the chat is gone'.
+            this.persistence.setAssistantId(config.assistantId);
+            await this.persistence.loadHistory(this.chatManager);
+            this.isLoading = false;
+            this.onStateChanged();
+            this.checkForReconnect();
+        }
+        catch (err) {
+            logger.error(`${this.logPrefix} Initialization failed:`, err);
+            this.initFailed = true;
+            this.isLoading = false;
+            this.onStateChanged();
+        }
+    }
+    toggleMinimized() {
+        this.popoverManager.dismiss();
+        this.isMinimized = !this.isMinimized;
+        this.onStateChanged();
+    }
+    setMinimized(minimized) {
+        if (this.isMinimized === minimized)
+            return;
+        this.isMinimized = minimized;
+        this.onStateChanged();
+    }
+    dismissPopover() {
+        this.popoverManager.dismiss();
+    }
+    acceptTerms(onAccepted) {
+        const config = this.configManager.getConfig();
+        if (!config)
+            return;
+        this.consentManager.accept(config.assistantId);
+        onAccepted();
+    }
+    declineTerms() {
+        this.consentManager.decline();
+        this.isMinimized = true;
+        this.onStateChanged();
+    }
+    dismissBlockedUrl() {
+        this.navigationManager.dismissBlockedUrl();
+    }
+    openBlockedUrl() {
+        this.navigationManager.openBlockedUrl();
+    }
+    requireConsentOrConnect(config) {
+        this.popoverManager.dismiss();
+        return this.consentManager.requireConsentOrProceed(config);
+    }
+    showDemoWelcome(config) {
+        setTimeout(() => {
+            this.chatManager.addAssistantMessage(config.welcomeMessage);
+        }, DEMO_RESPONSE_DELAY_MS);
+    }
+    dispose() {
+        this.themeManager.dispose();
+        this.popoverManager.dispose();
+        this.navigationManager.dispose();
+        this.chatManager.removeAllListeners();
+    }
+    detectPageContext() {
+        try {
+            const loc = globalThis.parent?.location;
+            if (loc?.href && loc.href !== 'about:blank') {
+                this.pageUrl = loc.href;
+                this.pageTitle = globalThis.parent?.document?.title ?? undefined;
+            }
+        }
+        catch { /* cross-origin iframe — expected when embedded on external sites */ }
+    }
+    resolvePageHost() {
+        if (!this.pageUrl)
+            return null;
+        try {
+            return new URL(this.pageUrl).host;
+        }
+        catch {
+            return null;
+        }
+    }
+    checkForReconnect() {
+        if (!this.navigationManager.checkForReconnect())
+            return;
+        logger.debug(`${this.logPrefix} Fast reconnect: auto-expanding and connecting after navigation fallback`);
+        this.isMinimized = false;
+        this.onStateChanged();
+        this.onConnect();
+    }
+}

package/dist/google.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/google.js

@@ -0,0 +1,12 @@
+import { registerRealtimeProvider } from './services/realtime/provider-factory';
+// Subpath entry (@nextpa/chat-core/google): importing it registers both Google
+// Live API providers as lazy loaders — VertexAI shares ~90% of the Google Dev
+// implementation, so one subpath covers both. The SDKs stay in async chunks.
+registerRealtimeProvider('google', async () => {
+    const { GoogleRealtimeProvider } = await import('./services/realtime/google');
+    return new GoogleRealtimeProvider();
+});
+registerRealtimeProvider('vertexai', async () => {
+    const { VertexAiRealtimeProvider } = await import('./services/realtime/vertexai');
+    return new VertexAiRealtimeProvider();
+});

package/dist/index.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @nextpa/chat-core — framework-neutral voice & text chat engine.
+ *
+ * PII-free, no Preact/UI coupling: realtime voice providers
+ * (OpenAI / Google / VertexAI), text + voice conversation orchestration,
+ * backend API/auth client, SignalR, audio and WebRTC handling. Consumed by
+ * both the Preact widget and the Angular chat app.
+ *
+ * The "." entry is provider-SDK-free: realtime providers register themselves
+ * via the subpath entries ("@nextpa/chat-core/openai", "@nextpa/chat-core/google")
+ * which the consuming app imports for the providers it uses.
+ */
+export { WidgetController, TextWidgetController, ConfigManager, ChatManager, ConnectionManager, TextConnectionManager, EventEmitter, type WidgetState, type WidgetControllerOptions, type WidgetEvents, type TextWidgetState, } from './core';
+export { resolveSameOriginTarget } from './core/link-target';
+export { WidgetApiClient, type WidgetApiClientOptions, type WidgetTokenProvider, type WidgetTokenRequestContext, type WidgetTokenResult, } from './services/api';
+export { WebRtcService } from './services/webrtc';
+export type { SignalRService, SignalREvents } from './services/signalr';
+export { VoiceSessionTracker } from './services/realtime/voice-session-tracker';
+export { startThinkingAudio, stopThinkingAudio } from './services/thinking-audio-pulse';
+export { PageInteractionHandler, type DocumentProvider, type ExternalExecutor, type WindowProvider, } from './services/page-interaction/page-interaction-handler';
+export { initExtensionBridge, refreshExtensionContext, } from './services/page-interaction/extension-bridge';
+export { IframeNavigationManager } from './services/page-interaction/iframe-navigation-manager';
+export { generateSelector } from './services/page-interaction/selector-generator';
+export { NEXTPA_IFRAME_NAME } from './services/page-interaction/constants';
+export { createRealtimeProvider, registerRealtimeProvider, type RealtimeProviderLoader, } from './services/realtime/provider-factory';
+export type * from './services/realtime/types';
+export type * from './types';
+export { getDemoConfig, isDemoMode, setDemoMode, DEFAULT_LOGO_DATA_URL, DEFAULT_DESIGN_TOKENS, } from './constants/defaults';
+export { MicLevelAnalyser } from './utils/mic-level-analyser';
+export { logger, type LogLevel } from './utils/logger';
+export { primeAudioOnGesture } from './utils/audio-context';
+export { detectHostLanguage } from './utils/language-detection';
+export { isGerman } from './utils/tool-status';
+export { getMessageBubbleClasses, getMinimizedWidthClasses, getPlacementClasses, } from './utils/styles';
+export { PROACTIVE_OPEN_WIDGET_EVENT, type ProactiveOpenWidgetEvent, type ProactiveOpenWidgetEventDetail, } from './utils/proactive-events';
+export { CONNECT_CHIME_VARIANTS, getActiveConnectChimeVariant, setActiveConnectChimeVariant, playConnectChimeVariant, type ConnectChimeVariantId, type ConnectChimeVariant, } from './utils/connect-chime';
+export { playMuteSound, playUnmuteSound, playEndCallSound } from './utils/ui-sounds';

package/dist/index.js

@@ -0,0 +1,40 @@
+/**
+ * @nextpa/chat-core — framework-neutral voice & text chat engine.
+ *
+ * PII-free, no Preact/UI coupling: realtime voice providers
+ * (OpenAI / Google / VertexAI), text + voice conversation orchestration,
+ * backend API/auth client, SignalR, audio and WebRTC handling. Consumed by
+ * both the Preact widget and the Angular chat app.
+ *
+ * The "." entry is provider-SDK-free: realtime providers register themselves
+ * via the subpath entries ("@nextpa/chat-core/openai", "@nextpa/chat-core/google")
+ * which the consuming app imports for the providers it uses.
+ */
+// Controllers & core managers (voice + text orchestration)
+export { WidgetController, TextWidgetController, ConfigManager, ChatManager, ConnectionManager, TextConnectionManager, EventEmitter, } from './core';
+export { resolveSameOriginTarget } from './core/link-target';
+// Backend API, SignalR, WebRTC services
+export { WidgetApiClient, } from './services/api';
+export { WebRtcService } from './services/webrtc';
+export { VoiceSessionTracker } from './services/realtime/voice-session-tracker';
+export { startThinkingAudio, stopThinkingAudio } from './services/thinking-audio-pulse';
+// Page interaction (widget DOM bridge)
+export { PageInteractionHandler, } from './services/page-interaction/page-interaction-handler';
+export { initExtensionBridge, refreshExtensionContext, } from './services/page-interaction/extension-bridge';
+export { IframeNavigationManager } from './services/page-interaction/iframe-navigation-manager';
+export { generateSelector } from './services/page-interaction/selector-generator';
+export { NEXTPA_IFRAME_NAME } from './services/page-interaction/constants';
+// Realtime provider abstraction
+export { createRealtimeProvider, registerRealtimeProvider, } from './services/realtime/provider-factory';
+// Defaults / demo config
+export { getDemoConfig, isDemoMode, setDemoMode, DEFAULT_LOGO_DATA_URL, DEFAULT_DESIGN_TOKENS, } from './constants/defaults';
+// Framework-neutral utilities
+export { MicLevelAnalyser } from './utils/mic-level-analyser';
+export { logger } from './utils/logger';
+export { primeAudioOnGesture } from './utils/audio-context';
+export { detectHostLanguage } from './utils/language-detection';
+export { isGerman } from './utils/tool-status';
+export { getMessageBubbleClasses, getMinimizedWidthClasses, getPlacementClasses, } from './utils/styles';
+export { PROACTIVE_OPEN_WIDGET_EVENT, } from './utils/proactive-events';
+export { CONNECT_CHIME_VARIANTS, getActiveConnectChimeVariant, setActiveConnectChimeVariant, playConnectChimeVariant, } from './utils/connect-chime';
+export { playMuteSound, playUnmuteSound, playEndCallSound } from './utils/ui-sounds';

package/dist/openai.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/openai.js

@@ -0,0 +1,7 @@
+import { registerRealtimeProvider } from './services/realtime/provider-factory';
+// Subpath entry (@nextpa/chat-core/openai): importing it registers the OpenAI
+// provider as a lazy loader — the SDK stays in its own async chunk.
+registerRealtimeProvider('openai', async () => {
+    const { OpenAiRealtimeProvider } = await import('./services/realtime/openai');
+    return new OpenAiRealtimeProvider();
+});

package/dist/services/api.d.ts

@@ -0,0 +1,114 @@
+import type { ToolDefinition, VoiceUsage, WidgetConfig } from '../types';
+export interface WidgetTokenRequestContext {
+    readonly baseUrl: string;
+    readonly clientId: string;
+}
+export interface WidgetTokenResult {
+    token: string;
+    expiresAt: string;
+    assistantId?: string;
+    assistantName?: string;
+}
+export type WidgetTokenProvider = (context: WidgetTokenRequestContext) => Promise<WidgetTokenResult>;
+export interface WidgetApiClientOptions {
+    apiKey?: string;
+    baseUrl?: string;
+    source?: string;
+    tokenProvider?: WidgetTokenProvider;
+}
+type ProactiveModeOptionsResponse = {
+    maxOffersPerSession: number;
+    cooldownSeconds: number;
+    longCooldownSeconds: number;
+    hardStopAfterConsecutiveDismissals: number;
+    allowedAnchorScopes: ReadonlyArray<'Element' | 'Section' | 'Page'>;
+    blockedUrlPatterns: ReadonlyArray<string>;
+    mobileBehavior: 'StandardWidget' | 'ReducedWidget' | 'ProactiveOnly';
+};
+type ProactiveModeResponse = {
+    enabled: boolean;
+    options: ProactiveModeOptionsResponse;
+};
+type TokenResponse = {
+    token: string;
+    expiresAt: string;
+    model: string;
+    provider?: string;
+    proxyUrl?: string;
+    proactiveMode?: ProactiveModeResponse;
+};
+type ConversationEntryDto = {
+    id: string;
+    role: string;
+    content: string;
+    timestamp: string;
+    feedback?: {
+        rating: number;
+    } | null;
+};
+type TokenClaims = {
+    assistantId?: string;
+    tenantId?: string;
+    userId?: string;
+};
+export declare class WidgetApiClient {
+    private static readonly CLIENT_ID_STORAGE_KEY;
+    private readonly baseUrl;
+    private readonly apiKey;
+    private readonly tokenProvider;
+    private clientId;
+    private readonly hostLanguage;
+    private bearerToken;
+    private tokenExpiresAt;
+    private tokenClaims;
+    private readonly source;
+    constructor(options: WidgetApiClientOptions);
+    private getOrCreateClientId;
+    getClientId(): string;
+    rotateClientId(): string;
+    getTokenClaims(): TokenClaims;
+    authenticate(): Promise<WidgetTokenResult>;
+    private exchangeApiKey;
+    private validateClientId;
+    private parseTokenClaims;
+    isAuthenticated(): boolean;
+    getBearerToken(): string | null;
+    getBaseUrl(): string;
+    getWidgetConfig(): Promise<WidgetConfig>;
+    generatePrompt(pageUrl?: string, pageTitle?: string): Promise<string>;
+    getEphemeralToken(): Promise<TokenResponse>;
+    getTools(): Promise<ToolDefinition[]>;
+    executeTool(name: string, jsonArguments: string, signal?: AbortSignal): Promise<string>;
+    transcribeAudio(audio: Blob, signal?: AbortSignal): Promise<string>;
+    addConversationMessage(params: {
+        role: string;
+        content: string;
+        pageUrl?: string;
+        pageTitle?: string;
+        language?: string;
+        usage?: VoiceUsage;
+        toolCalls?: Array<{
+            name: string;
+            durationMs: number;
+            succeeded: boolean;
+        }>;
+        responseLatencyMs?: number;
+        inputSource?: 'Spoken' | 'Typed';
+    }): Promise<void>;
+    startSession(): Promise<void>;
+    getConversationHistory(): Promise<ConversationEntryDto[]>;
+    submitFeedback(messageId: string, rating: number): Promise<void>;
+    submitSessionFeedback(rating: number): Promise<void>;
+    endConversationSession(userFeedback?: string, trimFarewell?: boolean): Promise<void>;
+    resetConversation(): Promise<void>;
+    startVoiceSession(sessionId: string): Promise<void>;
+    sendVoiceHeartbeat(sessionId: string): Promise<void>;
+    endVoiceSession(sessionId: string): Promise<void>;
+    sendVoiceSessionBeacon(sessionId: string): void;
+    sendChatMessage(message: string, pageUrl?: string, pageTitle?: string, isGreeting?: boolean): Promise<void>;
+    private ensureAuthenticated;
+    private requestWithApiKey;
+    private requestWithBearer;
+    private request;
+}
+export {};