@oxvo/ai-live-assist 7.3.4 → 7.4.23

package/cjs/messages.js

@@ -7,10 +7,19 @@ exports.defaultMessages = {
     disclosure: "You are interacting with an AI assistant.",
     requiredConsent: "I understand that I am interacting with an AI assistant.",
     consentAgreement: "I agree to use AI Guide.",
+    pageAssistanceTitle: "Allow AI Guide to help on this page?",
+    pageAssistanceAlways: "Remember this choice for this site",
+    pageAssistanceAgreement: "By allowing, you agree to the ",
+    pageAssistanceAgreementConnector: " and ",
+    pageAssistanceAgreementTerminator: ".",
+    pageAssistanceAppliesTo: "Applies to {target}.",
+    pageAssistanceAllow: "Allow",
+    pageAssistanceNotNow: "Not now",
+    pageAssistanceRevoke: "Revoke always allow",
     legalDetails: "Terms and privacy",
     legalTitle: "AI Guide terms and privacy",
     legalClose: "Close details",
-    termsOfService: "Terms of service",
+    termsOfService: "Terms of Service",
     microphoneConsent: "Send microphone audio to the AI provider for this session.",
     pageConsent: "Share a limited, sanitized description of this page.",
     controlConsent: "Allow approved low-risk page actions within this site.",
@@ -23,6 +32,8 @@ exports.defaultMessages = {
     pauseVisual: "Pause visual sharing",
     resumeVisual: "Resume visual sharing",
     handoffConsent: "Share a short conversation summary if I request a human.",
+    handoffContextShare: "Share with support",
+    handoffContextNotNow: "Not now",
     retentionConsent: "Retain a redacted transcript under this site’s policy.",
     startText: "Start with text",
     startVoice: "Start with voice",
@@ -33,14 +44,18 @@ exports.defaultMessages = {
     ready: "Ready",
     paused: "AI actions are paused. You remain in control.",
     reconnecting: "Reconnecting securely",
+    ending: "Ending session…",
+    handoffEnding: "Finishing the support connection…",
+    endRetry: "The session could not finish ending. Select End session to try again.",
     end: "End session",
     restart: "Start a new session",
     close: "Close",
     minimize: "Minimize",
-    maximize: "Expand conversation",
+    maximize: "Chat",
     activeCall: "AI Guide is still active",
     movePanel: "Move AI Guide",
     mute: "Mute",
+    muted: "Muted",
     unmute: "Unmute",
     interrupt: "Stop AI response",
     usePushToTalk: "Use push to talk",
@@ -54,9 +69,16 @@ exports.defaultMessages = {
     captionsOn: "Hide live captions",
     captionsOff: "Show live captions",
     textOnly: "Switch to text only",
+    modeSwitch: "Conversation mode",
+    chatMode: "Chat",
+    voiceMode: "Voice",
+    stopVoice: "Stop voice",
     send: "Send",
     messagePlaceholder: "Type a message",
     requestHuman: "Request human support",
+    support: "Support",
+    supportReply: "New reply from Support",
+    viewSupport: "View reply",
     continueWithFullAssist: "Continue with Full Assist",
     requestHumanFallback: "Request human support",
     approve: "Approve",
@@ -65,6 +87,7 @@ exports.defaultMessages = {
     actionRunning: "Applying the approved action",
     actionVerified: "Action completed and verified",
     actionFailed: "The action could not be verified",
+    actionVerificationExpired: "I couldn’t confirm whether the action completed after reconnecting. Please ask me to try again.",
     limitReached: "This session reached its configured limit.",
     ended: "This AI Guide session has ended.",
     idleEnded: "This session ended after no visitor activity.",
@@ -80,7 +103,7 @@ exports.defaultMessages = {
     visitorCooldown: "Please wait before starting another AI Guide session.",
     visitorAlreadyActive: "An AI Guide session is already active for this visitor.",
     safetyBoundary: "Payment details, passwords, and verification codes are always handled by you. You can pause actions or end this session at any time.",
-    privacyPolicy: "Privacy policy",
+    privacyPolicy: "Privacy Policy",
     moreControls: "More controls",
     emptyConversation: "Messages and live captions appear here.",
     audioPaused: "Audio playback is paused. Select the panel to continue.",

package/cjs/messengerLoader.d.ts

@@ -0,0 +1,3 @@
+import type { MessengerWebWidgetDescriptor } from "./types.js";
+export declare const normalizeMessengerWebWidgetDescriptor: (value: MessengerWebWidgetDescriptor | undefined) => MessengerWebWidgetDescriptor | null;
+export declare const loadMessengerWebWidget: (descriptorInput: MessengerWebWidgetDescriptor, timeoutMs: number) => Promise<void>;

package/cjs/messengerLoader.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadMessengerWebWidget = exports.normalizeMessengerWebWidgetDescriptor = void 0;
+const MESSENGER_SCRIPT_MARKER = "data-oxvo-ai-messenger-companion";
+const MESSENGER_SCRIPT_STATE = "data-oxvo-ai-messenger-state";
+const MAX_URL_LENGTH = 2048;
+const MAX_WEBSITE_TOKEN_LENGTH = 512;
+const MAX_BIGINT_STRING = "9223372036854775807";
+const positiveBigintString = (value) => {
+    if (typeof value !== "string" || !/^[1-9]\d{0,18}$/.test(value)) {
+        return null;
+    }
+    return value.length < MAX_BIGINT_STRING.length || value <= MAX_BIGINT_STRING
+        ? value
+        : null;
+};
+const httpUrl = (value, stripTrailingSlash = false) => {
+    if (typeof value !== "string" || value.length === 0 || value.length > MAX_URL_LENGTH) {
+        return null;
+    }
+    try {
+        const url = new URL(value, window.location.href);
+        if (!["http:", "https:"].includes(url.protocol) ||
+            url.username.length > 0 ||
+            url.password.length > 0) {
+            return null;
+        }
+        return stripTrailingSlash ? url.href.replace(/\/$/, "") : url.href;
+    }
+    catch {
+        return null;
+    }
+};
+const normalizeMessengerWebWidgetDescriptor = (value) => {
+    if (!value || typeof value !== "object")
+        return null;
+    const inboxId = positiveBigintString(value.inboxId);
+    const baseUrl = httpUrl(value.baseUrl, true);
+    const sdkUrl = httpUrl(value.sdkUrl);
+    const websiteToken = typeof value.websiteToken === "string" ? value.websiteToken.trim() : "";
+    if (!inboxId ||
+        !baseUrl ||
+        !sdkUrl ||
+        websiteToken.length === 0 ||
+        websiteToken.length > MAX_WEBSITE_TOKEN_LENGTH ||
+        /[\s\u0000-\u001f\u007f]/.test(websiteToken)) {
+        return null;
+    }
+    return { inboxId, baseUrl, sdkUrl, websiteToken };
+};
+exports.normalizeMessengerWebWidgetDescriptor = normalizeMessengerWebWidgetDescriptor;
+const scriptMatches = (script, descriptor) => script.src === descriptor.sdkUrl &&
+    script.dataset.oxvoInboxId === descriptor.inboxId &&
+    script.dataset.oxvoBaseUrl === descriptor.baseUrl &&
+    script.dataset.oxvoWebsiteToken === descriptor.websiteToken;
+const restoreSettingsAfterLoad = (settingsWindow, hiddenSettings, previousSettings) => {
+    if (settingsWindow.oxvoSettings !== hiddenSettings)
+        return;
+    if (previousSettings)
+        settingsWindow.oxvoSettings = previousSettings;
+    else
+        Reflect.deleteProperty(settingsWindow, "oxvoSettings");
+};
+const loadMessengerWebWidget = (descriptorInput, timeoutMs) => {
+    const descriptor = (0, exports.normalizeMessengerWebWidgetDescriptor)(descriptorInput);
+    if (!descriptor)
+        return Promise.reject(new Error("Invalid Messenger descriptor."));
+    const settingsWindow = window;
+    if (settingsWindow.oxvo)
+        return Promise.resolve();
+    const existing = document.querySelector(`script[${MESSENGER_SCRIPT_MARKER}="true"]`);
+    if (existing && !scriptMatches(existing, descriptor)) {
+        return Promise.reject(new Error("A different Messenger companion is already loading."));
+    }
+    if (existing?.getAttribute(MESSENGER_SCRIPT_STATE) === "error") {
+        return Promise.reject(new Error("Messenger failed to load."));
+    }
+    const script = existing ?? document.createElement("script");
+    const ownsScript = !existing;
+    if (!existing) {
+        script.async = true;
+        script.src = descriptor.sdkUrl;
+        script.setAttribute(MESSENGER_SCRIPT_MARKER, "true");
+        script.setAttribute(MESSENGER_SCRIPT_STATE, "loading");
+        script.dataset.oxvoInboxId = descriptor.inboxId;
+        script.dataset.oxvoBaseUrl = descriptor.baseUrl;
+        script.dataset.oxvoWebsiteToken = descriptor.websiteToken;
+    }
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const previousSettings = settingsWindow.oxvoSettings;
+        const hiddenSettings = {
+            ...(previousSettings ?? {}),
+            launcherVisible: false,
+        };
+        settingsWindow.oxvoSettings = hiddenSettings;
+        const finish = (error, preserveLateLoadGuard = false) => {
+            if (settled)
+                return;
+            settled = true;
+            window.clearTimeout(timeout);
+            if (!preserveLateLoadGuard) {
+                script.removeEventListener("load", loaded);
+                script.removeEventListener("error", failed);
+            }
+            if (error)
+                reject(error);
+            else
+                resolve();
+        };
+        const loaded = () => {
+            const messenger = settingsWindow.oxvo;
+            try {
+                messenger?.close?.();
+                messenger?.hideLauncher?.();
+            }
+            finally {
+                restoreSettingsAfterLoad(settingsWindow, hiddenSettings, previousSettings);
+            }
+            if (settled)
+                return;
+            if (!messenger) {
+                script.setAttribute(MESSENGER_SCRIPT_STATE, "error");
+                if (ownsScript)
+                    script.remove();
+                finish(new Error("Messenger SDK did not initialize."));
+                return;
+            }
+            script.setAttribute(MESSENGER_SCRIPT_STATE, "loaded");
+            finish();
+        };
+        const failed = () => {
+            if (settled)
+                return;
+            script.setAttribute(MESSENGER_SCRIPT_STATE, "error");
+            if (ownsScript)
+                script.remove();
+            restoreSettingsAfterLoad(settingsWindow, hiddenSettings, previousSettings);
+            finish(new Error("Messenger failed to load."));
+        };
+        script.addEventListener("load", loaded, { once: true });
+        script.addEventListener("error", failed, { once: true });
+        const timeout = window.setTimeout(() => {
+            script.setAttribute(MESSENGER_SCRIPT_STATE, "error");
+            if (ownsScript)
+                script.remove();
+            restoreSettingsAfterLoad(settingsWindow, hiddenSettings, previousSettings);
+            finish(new Error("Messenger did not become available in time."), true);
+        }, Math.max(1, timeoutMs));
+        if (!existing)
+            document.head.append(script);
+        else if (script.getAttribute(MESSENGER_SCRIPT_STATE) === "loaded")
+            loaded();
+    });
+};
+exports.loadMessengerWebWidget = loadMessengerWebWidget;

package/cjs/pageAssistancePreference.d.ts

@@ -0,0 +1,78 @@
+export declare const MAX_PAGE_ASSISTANCE_PREFERENCE_TTL_MS: number;
+export declare const MAX_PAGE_ASSISTANCE_RECOVERY_TTL_MS: number;
+export type PageAssistancePreferenceBinding = Readonly<{
+    origin: string;
+    siteKey: string;
+    visitorDigest: string;
+    schemaVersion: number;
+    configRevision: number;
+    policyVersion: number;
+    capability: "browser_control";
+}>;
+export type PageAssistanceReceipt = Readonly<{
+    receipt: string;
+    expiresAt: string;
+}>;
+export type PageAssistancePreferenceOptions = Readonly<{
+    storage?: Storage | null;
+    eventTarget?: Window | null;
+    now?: () => number;
+}>;
+export type PageAssistanceRecoveryDecision = "allow_session" | "allow_persistent";
+export type PageAssistanceRecoveryInput = Readonly<{
+    sessionId: string;
+    tabId: string;
+    bindingGeneration: string;
+    requestId: string;
+    proposalChecksum: string;
+    authorityEpoch: number;
+    decision: PageAssistanceRecoveryDecision;
+    persistentReceipt: string | null;
+    configRevision: number;
+    policyVersion: number;
+    expiresAt: number;
+}>;
+export type PageAssistanceRecoveryReceipt = PageAssistanceRecoveryInput & Readonly<{
+    submissionDigest: string;
+}>;
+export type PageAssistanceRecoveryOptions = Readonly<{
+    storage?: Storage | null;
+    now?: () => number;
+    subtle?: DigestProvider;
+}>;
+type PreferenceListener = (value: PageAssistanceReceipt | null, previous: PageAssistanceReceipt | null) => void;
+type DigestProvider = Pick<SubtleCrypto, "digest">;
+export declare const digestPageAssistanceVisitor: (visitorId: string, subtle?: DigestProvider | undefined) => Promise<string | null>;
+export declare class PageAssistanceRecoveryStore {
+    private readonly key;
+    private readonly storage;
+    private readonly now;
+    private readonly subtle;
+    constructor(siteKey: string, options?: PageAssistanceRecoveryOptions);
+    remember(value: PageAssistanceRecoveryInput, isCurrent: () => boolean): Promise<PageAssistanceRecoveryReceipt | null>;
+    storedRecordPresent(): boolean | null;
+    read(): Promise<PageAssistanceRecoveryReceipt | null>;
+    consume(submissionDigest: string): boolean;
+    private clearIfUnchanged;
+    clear(): void;
+}
+export declare class PageAssistancePreferenceStore {
+    private readonly binding;
+    private readonly key;
+    private readonly storage;
+    private readonly eventTarget;
+    private readonly now;
+    private readonly listeners;
+    private lastKnownReceipt;
+    private destroyed;
+    constructor(binding: PageAssistancePreferenceBinding, options?: PageAssistancePreferenceOptions);
+    read(): PageAssistanceReceipt | null;
+    remember(value: PageAssistanceReceipt): boolean;
+    clear(): void;
+    subscribe(listener: PreferenceListener): () => void;
+    destroy(): void;
+    private parse;
+    private notify;
+    private onStorage;
+}
+export {};