@nextpa/chat-core 0.1.0

package/dist/services/api.js

@@ -0,0 +1,336 @@
+import { logger } from '../utils/logger';
+import { detectHostLanguage } from '../utils/language-detection';
+// Dev fallback only; the host app passes the real base URL to the constructor.
+const API_BASE_URL = 'https://localhost:6101';
+export class WidgetApiClient {
+    static CLIENT_ID_STORAGE_KEY = 'nextpa_widget_client_id';
+    baseUrl;
+    apiKey;
+    tokenProvider;
+    clientId;
+    hostLanguage;
+    bearerToken = null;
+    tokenExpiresAt = null;
+    tokenClaims = {};
+    source;
+    constructor(options) {
+        if (!options.apiKey && !options.tokenProvider) {
+            throw new Error('WidgetApiClient requires an apiKey (public widget key exchange) or a custom tokenProvider.');
+        }
+        this.apiKey = options.apiKey ?? null;
+        this.baseUrl = options.baseUrl || API_BASE_URL;
+        this.clientId = this.getOrCreateClientId();
+        this.hostLanguage = detectHostLanguage();
+        this.source = options.source ?? null;
+        this.tokenProvider = options.tokenProvider ?? (() => this.exchangeApiKey());
+    }
+    getOrCreateClientId() {
+        try {
+            const stored = localStorage.getItem(WidgetApiClient.CLIENT_ID_STORAGE_KEY);
+            if (stored) {
+                logger.debug('[API] Using stored ClientId:', stored);
+                return stored;
+            }
+        }
+        catch {
+            // localStorage not available
+        }
+        const newClientId = crypto.randomUUID();
+        logger.debug('[API] Generated new ClientId:', newClientId);
+        try {
+            localStorage.setItem(WidgetApiClient.CLIENT_ID_STORAGE_KEY, newClientId);
+        }
+        catch {
+            // localStorage not available
+        }
+        return newClientId;
+    }
+    getClientId() {
+        return this.clientId;
+    }
+    // Start a brand-new conversation identity. Used on reset so the next conversation is keyed by a
+    // fresh clientId — immune to a late async write resurrecting the previous conversation's memory.
+    rotateClientId() {
+        this.clientId = crypto.randomUUID();
+        try {
+            localStorage.setItem(WidgetApiClient.CLIENT_ID_STORAGE_KEY, this.clientId);
+        }
+        catch {
+            // localStorage not available
+        }
+        logger.debug('[API] Rotated ClientId:', this.clientId);
+        return this.clientId;
+    }
+    getTokenClaims() {
+        return this.tokenClaims;
+    }
+    async authenticate() {
+        const result = await this.tokenProvider({ baseUrl: this.baseUrl, clientId: this.clientId });
+        this.bearerToken = result.token;
+        this.tokenExpiresAt = new Date(result.expiresAt);
+        this.tokenClaims = this.parseTokenClaims(result.token);
+        await this.validateClientId();
+        return result;
+    }
+    exchangeApiKey() {
+        return this.requestWithApiKey('/api/widget/authenticate', {
+            method: 'POST',
+        });
+    }
+    async validateClientId() {
+        try {
+            const response = await this.requestWithBearer('/api/widget/validate-client', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ clientId: this.clientId }),
+            });
+            if (!response.valid) {
+                logger.debug('[API] ClientId invalid for current assistant, using new:', response.clientId);
+                this.clientId = response.clientId;
+                try {
+                    localStorage.setItem(WidgetApiClient.CLIENT_ID_STORAGE_KEY, response.clientId);
+                }
+                catch {
+                    // localStorage not available
+                }
+            }
+        }
+        catch {
+            logger.debug('[API] Client validation failed, keeping current clientId');
+        }
+    }
+    parseTokenClaims(token) {
+        try {
+            const parts = token.split('.');
+            if (parts.length !== 3)
+                return {};
+            const payload = JSON.parse(atob(parts[1]));
+            return {
+                assistantId: payload.assistant_id,
+                tenantId: payload['stratara:tenant_id'],
+                userId: payload.sub,
+            };
+        }
+        catch {
+            logger.debug('[API] Failed to parse token claims');
+            return {};
+        }
+    }
+    isAuthenticated() {
+        if (!this.bearerToken || !this.tokenExpiresAt) {
+            return false;
+        }
+        return this.tokenExpiresAt.getTime() > Date.now() + 60000;
+    }
+    getBearerToken() {
+        return this.bearerToken;
+    }
+    getBaseUrl() {
+        return this.baseUrl;
+    }
+    async getWidgetConfig() {
+        await this.ensureAuthenticated();
+        return this.requestWithBearer('/api/widget/config');
+    }
+    async generatePrompt(pageUrl, pageTitle) {
+        await this.ensureAuthenticated();
+        const params = new URLSearchParams();
+        if (pageUrl)
+            params.set('pageUrl', pageUrl);
+        if (pageTitle)
+            params.set('pageTitle', pageTitle);
+        const query = params.toString();
+        const endpoint = query ? `/api/widget/prompt?${query}` : '/api/widget/prompt';
+        const response = await this.requestWithBearer(endpoint);
+        return response.prompt;
+    }
+    async getEphemeralToken() {
+        await this.ensureAuthenticated();
+        return this.requestWithBearer('/api/widget/token');
+    }
+    async getTools() {
+        await this.ensureAuthenticated();
+        return this.requestWithBearer('/api/widget/tools');
+    }
+    async executeTool(name, jsonArguments, signal) {
+        await this.ensureAuthenticated();
+        const response = await this.requestWithBearer('/api/widget/tools/execute', {
+            method: 'POST',
+            body: JSON.stringify({ name, arguments: jsonArguments }),
+            signal,
+        });
+        return response.result;
+    }
+    async transcribeAudio(audio, signal) {
+        await this.ensureAuthenticated();
+        const oggOrWebm = audio.type.includes('ogg') ? 'ogg' : 'webm';
+        const extension = audio.type.includes('mp4') ? 'mp4' : oggOrWebm;
+        const formData = new FormData();
+        formData.append('audio', audio, `dictation.${extension}`);
+        const response = await this.requestWithBearer('/api/widget/transcribe', {
+            method: 'POST',
+            body: formData,
+            signal,
+        });
+        return response.text;
+    }
+    async addConversationMessage(params) {
+        await this.ensureAuthenticated();
+        await this.requestWithBearer('/api/widget/conversation/message', {
+            method: 'POST',
+            body: JSON.stringify(params),
+        });
+    }
+    async startSession() {
+        await this.ensureAuthenticated();
+        await this.requestWithBearer('/api/widget/conversation/start-session', {
+            method: 'POST',
+        });
+    }
+    async getConversationHistory() {
+        await this.ensureAuthenticated();
+        const response = await this.requestWithBearer('/api/widget/conversation/history');
+        return response.entries;
+    }
+    async submitFeedback(messageId, rating) {
+        await this.ensureAuthenticated();
+        await this.requestWithBearer('/api/widget/conversation/feedback', {
+            method: 'POST',
+            body: JSON.stringify({ messageId, rating }),
+        });
+    }
+    async submitSessionFeedback(rating) {
+        await this.ensureAuthenticated();
+        await this.requestWithBearer('/api/widget/conversation/session-feedback', {
+            method: 'POST',
+            body: JSON.stringify({ rating }),
+        });
+    }
+    async endConversationSession(userFeedback, trimFarewell = false) {
+        await this.ensureAuthenticated();
+        await this.requestWithBearer('/api/widget/conversation/end', {
+            method: 'POST',
+            body: JSON.stringify({ userFeedback, trimFarewell }),
+        });
+    }
+    async resetConversation() {
+        await this.ensureAuthenticated();
+        await this.requestWithBearer('/api/widget/conversation/reset', {
+            method: 'POST',
+        });
+    }
+    async startVoiceSession(sessionId) {
+        await this.ensureAuthenticated();
+        await this.requestWithBearer('/api/widget/voice/start', {
+            method: 'POST',
+            body: JSON.stringify({ sessionId }),
+        });
+    }
+    async sendVoiceHeartbeat(sessionId) {
+        await this.ensureAuthenticated();
+        await this.requestWithBearer('/api/widget/voice/heartbeat', {
+            method: 'POST',
+            body: JSON.stringify({ sessionId }),
+        });
+    }
+    async endVoiceSession(sessionId) {
+        await this.ensureAuthenticated();
+        await this.requestWithBearer('/api/widget/voice/end', {
+            method: 'POST',
+            body: JSON.stringify({ sessionId }),
+        });
+    }
+    sendVoiceSessionBeacon(sessionId) {
+        const url = `${this.baseUrl}/api/widget/voice/end-beacon`;
+        // tenantId is no longer sent — the server derives it from the VoiceSession aggregate.
+        const payload = JSON.stringify({ sessionId });
+        fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: payload,
+            keepalive: true,
+        }).catch(() => {
+            const blob = new Blob([payload], { type: 'application/json' });
+            navigator.sendBeacon(url, blob);
+        });
+    }
+    async sendChatMessage(message, pageUrl, pageTitle, isGreeting = false) {
+        await this.ensureAuthenticated();
+        await this.requestWithBearer('/api/widget/chat', {
+            method: 'POST',
+            body: JSON.stringify({ message, pageUrl, pageTitle, isGreeting }),
+        });
+    }
+    async ensureAuthenticated() {
+        if (!this.isAuthenticated()) {
+            await this.authenticate();
+        }
+    }
+    async requestWithApiKey(endpoint, options = {}) {
+        const apiKey = this.apiKey;
+        if (!apiKey) {
+            throw new Error('No apiKey configured — supply an apiKey or use a custom tokenProvider.');
+        }
+        return this.request(endpoint, {
+            ...options,
+            headers: {
+                'X-Widget-Api-Key': apiKey,
+                ...(this.source ? { 'X-Widget-Source': this.source } : {}),
+                ...options.headers,
+            },
+        });
+    }
+    async requestWithBearer(endpoint, options = {}) {
+        if (!this.bearerToken) {
+            throw new Error('Not authenticated. Call authenticate() first.');
+        }
+        const headers = {
+            'Authorization': `Bearer ${this.bearerToken}`,
+            'X-Client-Id': this.clientId,
+            ...(this.hostLanguage ? { 'X-Widget-Language': this.hostLanguage } : {}),
+            ...options.headers,
+        };
+        return this.request(endpoint, {
+            ...options,
+            headers,
+        });
+    }
+    async request(endpoint, options = {}) {
+        const cleanBaseUrl = this.baseUrl.endsWith('/') ? this.baseUrl.slice(0, -1) : this.baseUrl;
+        const cleanEndpoint = endpoint.startsWith('/') ? endpoint : `/${endpoint}`;
+        const url = `${cleanBaseUrl}${cleanEndpoint}`;
+        const method = options.method || 'GET';
+        logger.debug(`[API] ${method} ${url}`);
+        const headers = {
+            ...options.headers,
+        };
+        // FormData sets its own multipart Content-Type (with boundary) — forcing
+        // application/json here would corrupt the upload.
+        if (method !== 'GET' && method !== 'HEAD' && !(options.body instanceof FormData)) {
+            headers['Content-Type'] = 'application/json';
+        }
+        try {
+            const response = await fetch(url, {
+                ...options,
+                headers,
+            });
+            logger.debug(`[API] Response: ${response.status} ${response.statusText}`);
+            if (!response.ok) {
+                const error = await response.json().catch(() => ({
+                    message: `HTTP error ${response.status}`,
+                }));
+                throw new Error(error.message);
+            }
+            const contentLength = response.headers.get('content-length');
+            const contentType = response.headers.get('content-type');
+            if (contentLength === '0' || !contentType?.includes('application/json')) {
+                return undefined;
+            }
+            return response.json();
+        }
+        catch (err) {
+            logger.error(`[API] Fetch error:`, err);
+            throw err;
+        }
+    }
+}

package/dist/services/index.d.ts

@@ -0,0 +1,3 @@
+export { WidgetApiClient } from './api';
+export { WebRtcService } from './webrtc';
+export { SignalRService, type SignalREvents } from './signalr';

package/dist/services/index.js

@@ -0,0 +1,3 @@
+export { WidgetApiClient } from './api';
+export { WebRtcService } from './webrtc';
+export { SignalRService } from './signalr';

package/dist/services/page-interaction/constants.d.ts

@@ -0,0 +1 @@
+export declare const NEXTPA_IFRAME_NAME = "nextpa-nav-iframe";

package/dist/services/page-interaction/constants.js

@@ -0,0 +1 @@
+export const NEXTPA_IFRAME_NAME = 'nextpa-nav-iframe';

package/dist/services/page-interaction/content-extractor.d.ts

@@ -0,0 +1,2 @@
+import type { PageContent } from './types';
+export declare function extractPageContent(doc?: Document, win?: Window): PageContent;

package/dist/services/page-interaction/content-extractor.js

@@ -0,0 +1,104 @@
+import { queryAllDeep } from './deep-query';
+const CONTENT_ROOT_SELECTOR = 'main, [role="main"], article';
+const SKIP_SELECTOR = 'nav, footer, aside, script, style, noscript, template, [aria-hidden="true"], [hidden]';
+const CONTENT_SELECTOR = 'h1, h2, h3, h4, h5, h6, p, li, blockquote, pre, figcaption, dt, dd, td, th, summary';
+const HEADING_TAGS = new Set(['H1', 'H2', 'H3', 'H4', 'H5', 'H6']);
+const MAX_CONTENT_LENGTH = 8000;
+const TRUNCATION_MARKER = '\n\n[content truncated]';
+const EMBEDDED_FRAME_MARKER = '[embedded content]';
+const UNREADABLE_FRAME_MARKER = '[an embedded frame from another site is on this page and cannot be read]';
+export function extractPageContent(doc = document, win = globalThis) {
+    const lines = [...collectDocumentLines(doc, win), ...collectFrameLines(doc, win)];
+    const fullText = lines.join('\n').trim();
+    const truncated = fullText.length > MAX_CONTENT_LENGTH;
+    const content = truncated
+        ? fullText.slice(0, MAX_CONTENT_LENGTH).trimEnd() + TRUNCATION_MARKER
+        : fullText;
+    return {
+        url: win.location.href,
+        title: doc.title || null,
+        content,
+        truncated,
+    };
+}
+function collectDocumentLines(doc, win) {
+    const root = doc.querySelector(CONTENT_ROOT_SELECTOR) ?? doc.body ?? doc.documentElement;
+    return root ? collectContentLines(root, win) : [];
+}
+// A frame from another site is unreadable by design, and saying so is better than the assistant
+// reporting that it cannot see what the visitor is looking at. One note is enough per page.
+function collectFrameLines(doc, win) {
+    const lines = [];
+    let unreadableNoted = false;
+    for (const frame of queryAllDeep(doc, 'iframe')) {
+        if (frame.closest(SKIP_SELECTOR))
+            continue;
+        const frameDoc = documentOf(frame);
+        if (!frameDoc) {
+            if (!unreadableNoted) {
+                lines.push(UNREADABLE_FRAME_MARKER);
+                unreadableNoted = true;
+            }
+            continue;
+        }
+        const inner = collectDocumentLines(frameDoc, frame.contentWindow ?? win);
+        if (inner.length === 0)
+            continue;
+        lines.push(EMBEDDED_FRAME_MARKER, ...inner);
+    }
+    return lines;
+}
+function documentOf(frame) {
+    try {
+        return frame.contentDocument;
+    }
+    catch {
+        return null;
+    }
+}
+function collectContentLines(root, win) {
+    const lines = [];
+    for (const element of queryAllDeep(root, CONTENT_SELECTOR)) {
+        if (element.closest(SKIP_SELECTOR))
+            continue;
+        if (hasContentAncestor(element, root))
+            continue;
+        if (isHidden(element, win))
+            continue;
+        const text = renderedText(element);
+        if (!text)
+            continue;
+        lines.push(formatLine(element, text));
+    }
+    return lines;
+}
+function hasContentAncestor(element, root) {
+    let parent = element.parentElement;
+    while (parent && parent !== root) {
+        if (parent.matches(CONTENT_SELECTOR))
+            return true;
+        parent = parent.parentElement;
+    }
+    return false;
+}
+function formatLine(element, text) {
+    if (HEADING_TAGS.has(element.tagName)) {
+        return '#'.repeat(Number(element.tagName.charAt(1))) + ' ' + text;
+    }
+    if (element.tagName === 'LI') {
+        return '- ' + text;
+    }
+    return text;
+}
+function renderedText(element) {
+    const text = element.innerText ?? element.textContent ?? '';
+    return text.replace(/\s+/g, ' ').trim();
+}
+function isHidden(element, win) {
+    if (element.hasAttribute('hidden'))
+        return true;
+    if (element.getAttribute('aria-hidden') === 'true')
+        return true;
+    const style = win.getComputedStyle(element);
+    return style.display === 'none' || style.visibility === 'hidden';
+}

package/dist/services/page-interaction/deep-query.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Like `querySelectorAll`, but descends into open shadow roots. A closed shadow root stays
+ * invisible — nothing can reach it, which is the boundary the page-interaction capability
+ * describes. Light DOM comes first, shadow content after the host it belongs to.
+ */
+export declare function queryAllDeep<T extends Element>(root: ParentNode, selector: string): T[];
+/** The single-element form, used to resolve a selector back to an element for an action. */
+export declare function querySelectorDeep<T extends Element>(root: ParentNode, selector: string): T | null;

package/dist/services/page-interaction/deep-query.js

@@ -0,0 +1,44 @@
+// The assistant's own surface. Reading it back would feed the assistant its own words, and
+// offering its own controls as page controls would let it click itself.
+const ASSISTANT_HOST_SELECTOR = 'nextpa-widget, [data-nextpa-widget]';
+/**
+ * Like `querySelectorAll`, but descends into open shadow roots. A closed shadow root stays
+ * invisible — nothing can reach it, which is the boundary the page-interaction capability
+ * describes. Light DOM comes first, shadow content after the host it belongs to.
+ */
+export function queryAllDeep(root, selector) {
+    const found = [];
+    collectDeep(root, selector, found);
+    return found;
+}
+/** The single-element form, used to resolve a selector back to an element for an action. */
+export function querySelectorDeep(root, selector) {
+    const direct = root.querySelector(selector);
+    if (direct)
+        return direct;
+    for (const shadow of shadowRootsOf(root)) {
+        const match = querySelectorDeep(shadow, selector);
+        if (match)
+            return match;
+    }
+    return null;
+}
+function collectDeep(root, selector, into) {
+    for (const element of Array.from(root.querySelectorAll(selector))) {
+        into.push(element);
+    }
+    for (const shadow of shadowRootsOf(root)) {
+        collectDeep(shadow, selector, into);
+    }
+}
+function shadowRootsOf(root) {
+    const roots = [];
+    for (const host of Array.from(root.querySelectorAll('*'))) {
+        if (!host.shadowRoot)
+            continue;
+        if (host.matches(ASSISTANT_HOST_SELECTOR))
+            continue;
+        roots.push(host.shadowRoot);
+    }
+    return roots;
+}

package/dist/services/page-interaction/dom-executor.d.ts

@@ -0,0 +1,7 @@
+import type { ActionResult } from './types';
+export declare function fillField(selector: string, value: string, doc?: Document): ActionResult;
+export declare function fillFields(fields: Record<string, string>, doc?: Document): ActionResult;
+export declare function clickElement(selector: string, doc?: Document): ActionResult;
+export declare function scrollToElement(selector: string, doc?: Document): ActionResult;
+export declare function highlightElement(selector: string, color?: string, durationMs?: number, doc?: Document): ActionResult;
+export declare function waitForElement(selector: string, timeoutMs?: number, doc?: Document): Promise<ActionResult>;