@oxvo/ai-live-assist 7.3.0

package/cjs/client.d.ts

@@ -0,0 +1,53 @@
+import type { AssistMode, BootstrapConfig, ConsentScope, LaunchResult, ExperienceMode } from './types.js';
+export declare class RuntimeClientError extends Error {
+    readonly code: string;
+    readonly retryable: boolean;
+    readonly retryAfterMs: number | null;
+    readonly status: number;
+    constructor(code: string, message: string, retryable: boolean, retryAfterMs: number | null, status: number);
+}
+type LaunchInput = {
+    siteKey: string;
+    configRevision: number;
+    path: string;
+    tabId: string;
+    mode: AssistMode;
+    anonymousId: string;
+    replay?: {
+        sessionId: string;
+        tabId: string;
+    };
+    disclosureChecksum: string;
+    scopes: ConsentScope[];
+    locale: string;
+    microphone: boolean;
+    reducedMotion: boolean;
+    protocolVersion: 1 | 2;
+    experienceMode: ExperienceMode;
+    fallbackIntent?: "standard_assist" | "human_handoff";
+    lowPower: boolean;
+};
+export declare const idempotencyKey: (prefix: string) => string;
+export declare class RuntimeClient {
+    private readonly clientVersion;
+    readonly baseUrl: string;
+    constructor(runtimeUrl: string, clientVersion: string);
+    bootstrap(siteKey: string, path: string, anonymousId: string, signal: AbortSignal): Promise<BootstrapConfig>;
+    launch(input: LaunchInput, signal: AbortSignal): Promise<LaunchResult>;
+    resume(sessionId: string, credential: string, path: string, protocolVersion: 1 | 2, signal: AbortSignal): Promise<LaunchResult>;
+    offer(result: LaunchResult, offerSdp: string, signal: AbortSignal): Promise<{
+        answerSdp: string;
+        fencingToken: number;
+    }>;
+    end(result: LaunchResult, fencingToken: number, signal?: AbortSignal): Promise<void>;
+    pauseOrResume(result: LaunchResult, fencingToken: number, operation: 'pause' | 'resume', signal?: AbortSignal): Promise<void>;
+    feedback(result: LaunchResult, payload: {
+        rating: number | null;
+        outcome: 'resolved' | 'partially_resolved' | 'not_resolved' | 'handoff';
+    }, signal?: AbortSignal): Promise<void>;
+    private postEmpty;
+    private postJson;
+    private parseJson;
+    private throwResponse;
+}
+export {};

package/cjs/client.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuntimeClient = exports.idempotencyKey = exports.RuntimeClientError = void 0;
+class RuntimeClientError extends Error {
+    constructor(code, message, retryable, retryAfterMs, status) {
+        super(message);
+        this.code = code;
+        this.retryable = retryable;
+        this.retryAfterMs = retryAfterMs;
+        this.status = status;
+        this.name = 'RuntimeClientError';
+    }
+}
+exports.RuntimeClientError = RuntimeClientError;
+const requestId = () => `req_${crypto.randomUUID()}`;
+const idempotencyKey = (prefix) => `${prefix}_${crypto.randomUUID()}`;
+exports.idempotencyKey = idempotencyKey;
+class RuntimeClient {
+    constructor(runtimeUrl, clientVersion) {
+        this.clientVersion = clientVersion;
+        const url = new URL(runtimeUrl, window.location.href);
+        if (!['http:', 'https:'].includes(url.protocol)) {
+            throw new Error('AI Live Assist runtime URL must use HTTP or HTTPS.');
+        }
+        this.baseUrl = url.origin + url.pathname.replace(/\/$/, '');
+    }
+    async bootstrap(siteKey, path, anonymousId, signal) {
+        const url = new URL(`${this.baseUrl}/ai-live-assist/v1/public/bootstrap`);
+        url.searchParams.set('siteKey', siteKey);
+        url.searchParams.set('path', path);
+        const response = await fetch(url, {
+            method: 'GET',
+            mode: 'cors',
+            credentials: 'omit',
+            cache: 'no-store',
+            headers: {
+                Accept: 'application/json',
+                'X-Oxvo-Ai-Client-Version': this.clientVersion,
+                'X-Oxvo-Ai-Visitor-Id': anonymousId,
+                'X-Request-Id': requestId(),
+            },
+            signal,
+        });
+        return this.parseJson(response);
+    }
+    async launch(input, signal) {
+        const shared = {
+            clientVersion: this.clientVersion,
+            siteKey: input.siteKey,
+            configRevision: input.configRevision,
+            path: input.path,
+            tabId: input.tabId,
+            mode: input.mode,
+            visitor: { anonymousId: input.anonymousId },
+            ...(input.replay ? { replay: input.replay } : {}),
+            consent: {
+                disclosureChecksum: input.disclosureChecksum,
+                scopes: input.scopes,
+                locale: input.locale,
+            },
+        };
+        const body = input.protocolVersion === 2
+            ? {
+                schemaVersion: 2,
+                protocolVersion: 2,
+                experienceMode: input.experienceMode,
+                ...(input.fallbackIntent
+                    ? { fallbackIntent: input.fallbackIntent }
+                    : {}),
+                ...shared,
+                capabilitySummary: {
+                    microphone: input.microphone,
+                    webrtc: typeof RTCPeerConnection !== 'undefined',
+                    audioPlayback: typeof HTMLAudioElement !== 'undefined',
+                    webAudio: typeof AudioContext !== 'undefined' ||
+                        typeof window
+                            .webkitAudioContext !== 'undefined',
+                    svgOverlay: typeof SVGElement !== 'undefined',
+                    visualViewport: typeof window.visualViewport !== 'undefined',
+                    reducedMotion: input.reducedMotion,
+                    lowPower: input.lowPower,
+                },
+            }
+            : {
+                schemaVersion: 1,
+                protocolVersion: 1,
+                ...shared,
+                capabilitySummary: {
+                    microphone: input.microphone,
+                    webrtc: typeof RTCPeerConnection !== 'undefined',
+                    reducedMotion: input.reducedMotion,
+                },
+            };
+        return this.postJson('/ai-live-assist/v1/public/launch', body, {
+            'Idempotency-Key': (0, exports.idempotencyKey)('launch'),
+        }, signal);
+    }
+    async resume(sessionId, credential, path, protocolVersion, signal) {
+        return this.postJson(`/ai-live-assist/v1/public/sessions/${encodeURIComponent(sessionId)}/resume`, {
+            schemaVersion: protocolVersion,
+            protocolVersion,
+            path,
+            reason: 'navigation',
+        }, { Authorization: `Bearer ${credential}` }, signal);
+    }
+    async offer(result, offerSdp, signal) {
+        const response = await fetch(result.realtimeOfferUrl, {
+            method: 'POST',
+            mode: 'cors',
+            credentials: 'omit',
+            cache: 'no-store',
+            headers: {
+                Accept: 'application/sdp',
+                Authorization: `Bearer ${result.launchCredential}`,
+                'Content-Type': 'application/sdp',
+                'Idempotency-Key': (0, exports.idempotencyKey)('offer'),
+                'X-Oxvo-Ai-Client-Version': this.clientVersion,
+                'X-Request-Id': requestId(),
+            },
+            body: offerSdp,
+            signal,
+        });
+        if (!response.ok)
+            await this.throwResponse(response);
+        const fencingToken = Number(response.headers.get('X-Oxvo-Fencing-Token'));
+        if (!Number.isSafeInteger(fencingToken) || fencingToken < 1) {
+            throw new RuntimeClientError('PROTOCOL_INVALID', 'The runtime returned an invalid control lease.', false, null, 502);
+        }
+        return { answerSdp: await response.text(), fencingToken };
+    }
+    async end(result, fencingToken, signal) {
+        await this.postEmpty(`/ai-live-assist/v1/public/sessions/${encodeURIComponent(result.sessionId)}/end`, result.controlCredential, fencingToken, result.protocolVersion, signal);
+    }
+    async pauseOrResume(result, fencingToken, operation, signal) {
+        await this.postEmpty(`/ai-live-assist/v1/public/sessions/${encodeURIComponent(result.sessionId)}/${operation}`, result.controlCredential, fencingToken, result.protocolVersion, signal);
+    }
+    async feedback(result, payload, signal) {
+        await this.postJson(`/ai-live-assist/v1/public/sessions/${encodeURIComponent(result.sessionId)}/feedback`, payload, {
+            Authorization: `Bearer ${result.feedbackCredential}`,
+        }, signal);
+    }
+    async postEmpty(path, credential, fencingToken, protocolVersion, signal) {
+        await this.postJson(path, {
+            schemaVersion: protocolVersion,
+            protocolVersion,
+            fencingToken,
+        }, { Authorization: `Bearer ${credential}` }, signal);
+    }
+    async postJson(path, body, extraHeaders, signal) {
+        const response = await fetch(`${this.baseUrl}${path}`, {
+            method: 'POST',
+            mode: 'cors',
+            credentials: 'omit',
+            cache: 'no-store',
+            headers: {
+                Accept: 'application/json',
+                'Content-Type': 'application/json',
+                'X-Oxvo-Ai-Client-Version': this.clientVersion,
+                'X-Request-Id': requestId(),
+                ...extraHeaders,
+            },
+            body: JSON.stringify(body),
+            ...(signal ? { signal } : {}),
+        });
+        if (response.status === 204)
+            return undefined;
+        return this.parseJson(response);
+    }
+    async parseJson(response) {
+        if (!response.ok)
+            await this.throwResponse(response);
+        try {
+            return (await response.json());
+        }
+        catch {
+            throw new RuntimeClientError('PROTOCOL_INVALID', 'The runtime returned an invalid response.', false, null, response.status);
+        }
+    }
+    async throwResponse(response) {
+        let error = {};
+        try {
+            const body = (await response.json());
+            error = body.error ?? {};
+        }
+        catch {
+            // Keep the public fallback generic; response bodies may come from a proxy.
+        }
+        throw new RuntimeClientError(typeof error.code === 'string' ? error.code : 'RUNTIME_UNAVAILABLE', typeof error.message === 'string'
+            ? error.message
+            : 'AI Live Assist is temporarily unavailable.', error.retryable === true, typeof error.retryAfterMs === 'number' ? error.retryAfterMs : null, response.status);
+    }
+}
+exports.RuntimeClient = RuntimeClient;

package/cjs/context.d.ts

@@ -0,0 +1,58 @@
+import type { ActionExecutionResult, ActionGrant, PageContextSnapshot, PresentationTarget, VisualContextCapture } from './types.js';
+type SelectorRegionRule = {
+    digest: string;
+    selector: string;
+};
+type ContextCallbacks = {
+    onSnapshot: (snapshot: PageContextSnapshot) => void | Promise<void>;
+    onNavigation: (pageId: string, revision: number, url: string) => void | Promise<void>;
+    onHighlight: (element: Element | null, status: 'focus' | 'success' | 'failure') => void;
+};
+export declare class PageContextCollector {
+    private readonly callbacks;
+    private readonly selectorRegionRules;
+    private readonly policyVersion;
+    private pageId;
+    private revision;
+    private running;
+    private mutationObserver;
+    private captureTimer;
+    private targetIds;
+    private textIds;
+    private optionIds;
+    private targets;
+    private originalPushState;
+    private originalReplaceState;
+    private executingActionId;
+    private pendingNavigation;
+    private pendingCapture;
+    private deferredNavigation;
+    private recentSelection;
+    constructor(callbacks: ContextCallbacks, selectorRegionRules?: SelectorRegionRule[], policyVersion?: number);
+    get currentRevision(): number;
+    get currentPageId(): string;
+    presentationTarget(targetId: string, revision: number): PresentationTarget | null;
+    start(): void;
+    stop(): void;
+    captureAndPublish(): Promise<PageContextSnapshot>;
+    capture(): PageContextSnapshot;
+    captureVisualContext(): VisualContextCapture | null;
+    execute(grant: ActionGrant): Promise<ActionExecutionResult>;
+    completeActionExecution(actionId: string): Promise<string | null>;
+    private click;
+    private type;
+    private select;
+    private submit;
+    private safeState;
+    private actionApplied;
+    private clippedGeometry;
+    private scheduleCapture;
+    private handleSelectionChange;
+    private handleControlStateChange;
+    private readSafeSelection;
+    private handleNavigation;
+    private installNavigationHooks;
+    private restoreNavigationHooks;
+    private reducedMotion;
+}
+export {};