autokap 1.0.6 → 1.0.8

package/dist/video-variant-state.js

@@ -0,0 +1,80 @@
+import { evaluateRequestedLanguageState, evaluateRequestedThemeState as evaluateRequestedThemeStateRich, } from './session-profile.js';
+function normalizeConfidenceScore(confidence) {
+    switch (confidence) {
+        case 'high':
+            return 1;
+        case 'medium':
+            return 0.78;
+        case 'low':
+        default:
+            return 0.58;
+    }
+}
+export function scoreLocaleSignals(signals, requestedLang) {
+    if (!requestedLang)
+        return { score: 1, reasons: [], ambiguous: false };
+    const languageState = evaluateRequestedLanguageState({
+        currentUrl: signals.url,
+        requestedLang,
+        signals,
+    });
+    if (languageState.active) {
+        return {
+            score: normalizeConfidenceScore(languageState.confidence),
+            reasons: languageState.reasons,
+            ambiguous: false,
+        };
+    }
+    if (languageState.ambiguous) {
+        return {
+            score: languageState.confidence === 'high' ? 0.45 : languageState.confidence === 'medium' ? 0.32 : 0.18,
+            reasons: languageState.reasons,
+            ambiguous: true,
+        };
+    }
+    return {
+        score: 0,
+        reasons: languageState.reasons,
+        ambiguous: false,
+    };
+}
+export function evaluateRequestedThemeState(signals, requestedTheme) {
+    const themeState = evaluateRequestedThemeStateRich({
+        requestedTheme,
+        signals,
+    });
+    return {
+        detected: themeState.detected,
+        active: themeState.active,
+        ambiguous: themeState.ambiguous,
+        reason: themeState.reasons.join('; ') || 'no_theme_signal',
+    };
+}
+export async function detectVariantStateDeterministic(browser, requestedLang, requestedTheme) {
+    const signals = await browser.capturePageSignals();
+    const languageState = evaluateRequestedLanguageState({
+        currentUrl: signals.url,
+        requestedLang,
+        signals,
+    });
+    const themeState = evaluateRequestedThemeStateRich({
+        requestedTheme,
+        signals,
+    });
+    return {
+        lang: {
+            requested: requestedLang,
+            detected: languageState.detected,
+            active: requestedLang ? languageState.active : true,
+            ambiguous: requestedLang ? languageState.ambiguous : false,
+        },
+        theme: {
+            requested: requestedTheme,
+            detected: themeState.detected,
+            active: requestedTheme ? themeState.active : true,
+            ambiguous: requestedTheme ? themeState.ambiguous : false,
+        },
+        pageSignals: signals,
+    };
+}
+//# sourceMappingURL=video-variant-state.js.map

package/dist/vision-model.d.ts

@@ -0,0 +1,17 @@
+export declare class VisionModelUnsupportedError extends Error {
+    requestedModel: string;
+    fallbackModel?: string;
+    constructor(requestedModel: string, fallbackModel?: string);
+}
+export declare function isImageInputUnsupportedError(err: unknown): boolean;
+export declare function buildVisionModelUnavailableMessage(requestedModel: string, fallbackModel?: string): string;
+export declare function callVisionCapableModel<T>(params: {
+    primaryModel: string;
+    fallbackModel?: string;
+    callModel: (model: string) => Promise<T>;
+    onFallbackActivated?: (model: string, reason: string) => void;
+}): Promise<{
+    result: T;
+    model: string;
+    fellBack: boolean;
+}>;

package/dist/vision-model.js

@@ -0,0 +1,74 @@
+export class VisionModelUnsupportedError extends Error {
+    requestedModel;
+    fallbackModel;
+    constructor(requestedModel, fallbackModel) {
+        super(buildVisionModelUnavailableMessage(requestedModel, fallbackModel));
+        this.name = 'VisionModelUnsupportedError';
+        this.requestedModel = requestedModel;
+        this.fallbackModel = fallbackModel;
+    }
+}
+function extractNestedErrorMessage(err) {
+    if (!err || typeof err !== 'object')
+        return '';
+    const errorRecord = err;
+    const directMessage = typeof errorRecord.message === 'string' ? errorRecord.message : '';
+    const nestedError = errorRecord.error;
+    const nestedMessage = nestedError && typeof nestedError === 'object' && typeof nestedError.message === 'string'
+        ? nestedError.message
+        : '';
+    if (nestedMessage && nestedMessage === directMessage)
+        return directMessage;
+    return [directMessage, nestedMessage].filter(Boolean).join(' ');
+}
+export function isImageInputUnsupportedError(err) {
+    if (!err || typeof err !== 'object')
+        return false;
+    const errorRecord = err;
+    const status = typeof errorRecord.status === 'number' ? errorRecord.status : undefined;
+    const message = extractNestedErrorMessage(err).toLowerCase();
+    if (!message)
+        return false;
+    const mentionsImageEndpoint = message.includes('no endpoints found that support image input')
+        || message.includes('no providers that support image input')
+        || (message.includes('image input') && message.includes('no') && message.includes('support'))
+        || (message.includes('image input') && message.includes('endpoint') && message.includes('no'));
+    if (!mentionsImageEndpoint)
+        return false;
+    return status === undefined || status === 400 || status === 404 || status === 422;
+}
+export function buildVisionModelUnavailableMessage(requestedModel, fallbackModel) {
+    const fallbackHint = fallbackModel && fallbackModel !== requestedModel
+        ? ` Automatic fallback to "${fallbackModel}" also failed or was unavailable.`
+        : '';
+    return `The model "${requestedModel}" has no available endpoint that supports image input.${fallbackHint} Configure a vision-capable default/fallback model or retry later if the provider is degraded.`;
+}
+export async function callVisionCapableModel(params) {
+    const { primaryModel, fallbackModel, callModel, onFallbackActivated } = params;
+    let fallbackReason = '';
+    try {
+        const result = await callModel(primaryModel);
+        return { result, model: primaryModel, fellBack: false };
+    }
+    catch (err) {
+        if (!isImageInputUnsupportedError(err)) {
+            throw err;
+        }
+        fallbackReason = extractNestedErrorMessage(err) || 'image input unsupported';
+        if (!fallbackModel || fallbackModel === primaryModel) {
+            throw new VisionModelUnsupportedError(primaryModel, fallbackModel);
+        }
+    }
+    try {
+        const result = await callModel(fallbackModel);
+        onFallbackActivated?.(fallbackModel, fallbackReason);
+        return { result, model: fallbackModel, fellBack: true };
+    }
+    catch (fallbackErr) {
+        if (isImageInputUnsupportedError(fallbackErr)) {
+            throw new VisionModelUnsupportedError(primaryModel, fallbackModel);
+        }
+        throw fallbackErr;
+    }
+}
+//# sourceMappingURL=vision-model.js.map

package/dist/web-playwright-local.d.ts

@@ -0,0 +1,126 @@
+/**
+ * Capture Agent — WebPlaywrightLocal RuntimeAdapter
+ *
+ * Thin adapter delegating to the existing Browser class from src/browser.ts.
+ * This is the first (and for now only) RuntimeAdapter implementation.
+ */
+import type { Browser } from './browser.js';
+import type { AKTree, VideoPageSignals } from './types.js';
+import type { RuntimeAdapter, ClickOptions, WaitCondition, RecordingOptions, RecordingResult } from './execution-types.js';
+import { type ResolveOptions } from './semantic-resolver.js';
+export declare class WebPlaywrightLocal implements RuntimeAdapter {
+    private browser;
+    private recordingDir?;
+    private readonly sessionStartedAt;
+    private recording;
+    private clipCursor;
+    constructor(browser: Browser, recordingDir?: string | undefined);
+    navigate(url: string): Promise<void>;
+    getCurrentUrl(): Promise<string>;
+    getAKTree(): Promise<AKTree>;
+    getPageSignals(): Promise<VideoPageSignals>;
+    click(selector: string, options?: ClickOptions): Promise<void>;
+    /**
+     * Click an element using semantic target resolution.
+     * Tries CSS selector first, falls back to Playwright semantic locators.
+     */
+    clickByTarget(opts: ResolveOptions): Promise<void>;
+    /**
+     * Type into an element using semantic target resolution.
+     */
+    typeByTarget(opts: ResolveOptions, text: string, clearFirst?: boolean): Promise<void>;
+    /**
+     * Wait for an element using semantic target resolution.
+     */
+    waitForTarget(opts: ResolveOptions, timeoutMs?: number): Promise<boolean>;
+    /**
+     * Scroll an element into view using semantic target resolution.
+     */
+    scrollIntoViewByTarget(opts: ResolveOptions): Promise<void>;
+    type(selector: string, text: string, clearFirst?: boolean): Promise<void>;
+    pressKey(key: string): Promise<void>;
+    scroll(direction: 'up' | 'down' | 'left' | 'right', amount?: number): Promise<void>;
+    scrollIntoView(selector: string): Promise<void>;
+    waitFor(condition: WaitCondition): Promise<boolean>;
+    dismissOverlays(): Promise<{
+        dismissed: boolean;
+        method: string | null;
+    }>;
+    takeScreenshot(): Promise<Buffer>;
+    takeElementScreenshot(selector: string): Promise<Buffer>;
+    takeCleanScreenshot(): Promise<Buffer>;
+    beginRecording(options: RecordingOptions): Promise<void>;
+    endRecording(): Promise<RecordingResult>;
+    setLocale(locale: string): Promise<void>;
+    setColorScheme(scheme: 'light' | 'dark'): Promise<void>;
+    reloadPage(): Promise<void>;
+    writeStorageHint(params: {
+        storage: 'localStorage' | 'sessionStorage' | 'cookie';
+        key: string;
+        value: string;
+        kind: 'locale' | 'theme';
+    }): Promise<boolean>;
+    hover(selector: string): Promise<void>;
+    hoverByTarget(opts: ResolveOptions): Promise<void>;
+    selectOption(selector: string, option: {
+        label?: string;
+        value?: string;
+        index?: number;
+    }): Promise<void>;
+    check(selector: string, checked: boolean): Promise<void>;
+    doubleClick(selector: string): Promise<void>;
+    cloneElement(opts: {
+        sourceSelector: string;
+        containerSelector: string;
+        count: number;
+        removeSource?: boolean;
+    }): Promise<{
+        clonedCount: number;
+    }>;
+    setAttribute(opts: {
+        selector: string;
+        attribute: string;
+        value: string;
+    }): Promise<void>;
+    setTextContent(opts: {
+        selector: string;
+        text: string;
+    }): Promise<void>;
+    removeElement(opts: {
+        selector: string;
+    }): Promise<{
+        removedCount: number;
+    }>;
+    setInputValue(opts: {
+        selector: string;
+        value: string;
+    }): Promise<void>;
+    clickHidden(opts: {
+        selector: string;
+    }): Promise<void>;
+    serializeDom(selector?: string): Promise<{
+        html: string;
+        assetUrls: string[];
+        viewport: {
+            width: number;
+            height: number;
+        };
+        capturedAt: string;
+    }>;
+    serializeFragment(selector: string): Promise<{
+        html: string;
+        assetUrls: string[];
+        capturedAt: string;
+    }>;
+    extractFavicon(): Promise<{
+        buffer: Buffer;
+        mimeType: string;
+    } | null>;
+    close(): Promise<void>;
+    private typeIntoLocator;
+    private seedClipCursor;
+    private moveClipCursorToViewportCenter;
+    private moveClipCursorToLocator;
+    private moveClipCursorToPoint;
+    private emitClipClickPulse;
+}