autokap 1.0.6 → 1.0.8

package/dist/clip-postprocess.d.ts

@@ -0,0 +1,42 @@
+import type { ClipOptions } from './types.js';
+/**
+ * Resolve the system ffmpeg binary path. Throws if not found.
+ */
+export declare function ensureFfmpegAvailable(): Promise<string>;
+/**
+ * Convert a WebM recording to an optimized GIF using a 2-pass palette approach.
+ * Pass 1: generate an optimal palette. Pass 2: encode with that palette.
+ */
+export declare function convertToGif(webmPath: string, outputPath: string, opts?: {
+    fps?: number;
+    maxWidth?: number;
+    loop?: boolean;
+}): Promise<void>;
+/**
+ * Convert a WebM recording to an MP4 with web-optimized settings.
+ */
+export declare function convertToMp4(webmPath: string, outputPath: string): Promise<void>;
+/**
+ * Extract the first frame of a WebM as a PNG thumbnail.
+ */
+export declare function extractThumbnail(webmPath: string, outputPath: string): Promise<void>;
+/**
+ * Trim a recording: skip dead frames at the start and cap duration.
+ */
+export declare function trimRecording(inputPath: string, outputPath: string, startSec?: number, maxDurationSec?: number): Promise<void>;
+/**
+ * Get the duration of a media file in milliseconds.
+ */
+export declare function getMediaDurationMs(filePath: string): Promise<number>;
+export interface ClipPostProcessResult {
+    gifPath?: string;
+    mp4Path?: string;
+    thumbnailPath?: string;
+    durationMs: number;
+    fileSizeBytes?: number;
+}
+/**
+ * Full post-processing pipeline for a single clip recording:
+ * trim → GIF and/or MP4 → thumbnail → measure.
+ */
+export declare function postProcessClipRecording(webmPath: string, outputDir: string, clipId: string, options?: ClipOptions): Promise<ClipPostProcessResult>;

package/dist/clip-postprocess.js

@@ -0,0 +1,201 @@
+import { execFile } from 'node:child_process';
+import { rm, stat } from 'node:fs/promises';
+import path from 'node:path';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+// ── Default values ──────────────────────────────────────────────────
+const DEFAULT_GIF_FPS = 15;
+const DEFAULT_GIF_MAX_WIDTH = 800;
+const DEFAULT_MAX_DURATION_SEC = 8;
+const DEFAULT_TRIM_START_SEC = 0.3;
+// ── ffmpeg detection ────────────────────────────────────────────────
+const cachedBinaryPaths = {};
+async function ensureBinaryAvailable(binaryName) {
+    const cached = cachedBinaryPaths[binaryName];
+    if (cached)
+        return cached;
+    const resolver = process.platform === 'win32' ? 'where' : 'which';
+    const { stdout } = await execFileAsync(resolver, [binaryName]);
+    const resolvedPath = stdout
+        .split(/\r?\n/)
+        .map(line => line.trim())
+        .find(Boolean);
+    if (!resolvedPath) {
+        throw new Error(`${binaryName} not found`);
+    }
+    cachedBinaryPaths[binaryName] = resolvedPath;
+    return resolvedPath;
+}
+/**
+ * Resolve the system ffmpeg binary path. Throws if not found.
+ */
+export async function ensureFfmpegAvailable() {
+    try {
+        return await ensureBinaryAvailable('ffmpeg');
+    }
+    catch {
+        throw new Error('ffmpeg is required for clip post-processing but was not found on your system. ' +
+            'Install it via: brew install ffmpeg (macOS), apt install ffmpeg (Linux), or choco install ffmpeg (Windows).');
+    }
+}
+// ── Conversion functions ────────────────────────────────────────────
+/**
+ * Convert a WebM recording to an optimized GIF using a 2-pass palette approach.
+ * Pass 1: generate an optimal palette. Pass 2: encode with that palette.
+ */
+export async function convertToGif(webmPath, outputPath, opts = {}) {
+    const ffmpeg = await ensureFfmpegAvailable();
+    const fps = opts.fps ?? DEFAULT_GIF_FPS;
+    const maxWidth = opts.maxWidth ?? DEFAULT_GIF_MAX_WIDTH;
+    const loopFlag = (opts.loop ?? true) ? '0' : '-1';
+    const paletteDir = path.dirname(outputPath);
+    const palettePath = path.join(paletteDir, `_palette_${Date.now()}.png`);
+    const scaleFilter = `fps=${fps},scale=${maxWidth}:-1:flags=lanczos`;
+    // Pass 1: Generate palette
+    await execFileAsync(ffmpeg, [
+        '-i', webmPath,
+        '-vf', `${scaleFilter},palettegen=stats_mode=diff`,
+        '-y', palettePath,
+    ]);
+    // Pass 2: Encode GIF with palette
+    try {
+        await execFileAsync(ffmpeg, [
+            '-i', webmPath,
+            '-i', palettePath,
+            '-lavfi', `${scaleFilter}[x];[x][1:v]paletteuse=dither=bayer:bayer_scale=3`,
+            '-loop', loopFlag,
+            '-y', outputPath,
+        ]);
+    }
+    finally {
+        // Clean up palette file
+        try {
+            await stat(palettePath);
+            await rm(palettePath, { force: true });
+        }
+        catch { /* ignore */ }
+    }
+}
+/**
+ * Convert a WebM recording to an MP4 with web-optimized settings.
+ */
+export async function convertToMp4(webmPath, outputPath) {
+    const ffmpeg = await ensureFfmpegAvailable();
+    await execFileAsync(ffmpeg, [
+        '-i', webmPath,
+        '-c:v', 'libx264',
+        '-preset', 'slow',
+        '-crf', '22',
+        '-pix_fmt', 'yuv420p',
+        '-movflags', '+faststart',
+        '-an',
+        '-y', outputPath,
+    ]);
+}
+/**
+ * Extract the first frame of a WebM as a PNG thumbnail.
+ */
+export async function extractThumbnail(webmPath, outputPath) {
+    const ffmpeg = await ensureFfmpegAvailable();
+    await execFileAsync(ffmpeg, [
+        '-i', webmPath,
+        '-frames:v', '1',
+        '-y', outputPath,
+    ]);
+}
+/**
+ * Trim a recording: skip dead frames at the start and cap duration.
+ */
+export async function trimRecording(inputPath, outputPath, startSec = DEFAULT_TRIM_START_SEC, maxDurationSec = DEFAULT_MAX_DURATION_SEC) {
+    const ffmpeg = await ensureFfmpegAvailable();
+    await execFileAsync(ffmpeg, [
+        '-ss', String(startSec),
+        '-i', inputPath,
+        '-t', String(maxDurationSec),
+        '-c', 'copy',
+        '-y', outputPath,
+    ]);
+}
+/**
+ * Get the duration of a media file in milliseconds.
+ */
+export async function getMediaDurationMs(filePath) {
+    const ffprobe = await ensureBinaryAvailable('ffprobe');
+    const { stdout } = await execFileAsync(ffprobe, [
+        '-v', 'error',
+        '-show_entries', 'format=duration',
+        '-of', 'default=noprint_wrappers=1:nokey=1',
+        filePath,
+    ]);
+    return Math.round(parseFloat(stdout.trim()) * 1000);
+}
+/**
+ * Freeze the last frame of a video for `durationSec` additional seconds.
+ * Uses ffmpeg's tpad filter to hold the final frame in place.
+ */
+async function freezeLastFrame(inputPath, outputPath, durationSec) {
+    const ffmpeg = await ensureFfmpegAvailable();
+    const stopDurationMs = Math.round(durationSec * 1000);
+    await execFileAsync(ffmpeg, [
+        '-i', inputPath,
+        '-vf', `tpad=stop_mode=clone:stop_duration=${stopDurationMs}ms`,
+        '-c:v', 'libvpx-vp9',
+        '-crf', '30',
+        '-b:v', '0',
+        '-an',
+        '-y', outputPath,
+    ]);
+}
+/**
+ * Full post-processing pipeline for a single clip recording:
+ * trim → GIF and/or MP4 → thumbnail → measure.
+ */
+export async function postProcessClipRecording(webmPath, outputDir, clipId, options = {}) {
+    const maxDuration = options.maxDurationSec ?? DEFAULT_MAX_DURATION_SEC;
+    // Step 1: Trim the recording — cut the setup phase (page load, overlay dismiss)
+    const trimStart = options.trimStartSec ?? DEFAULT_TRIM_START_SEC;
+    const trimmedPath = path.join(outputDir, `${clipId}_trimmed.webm`);
+    await trimRecording(webmPath, trimmedPath, trimStart, maxDuration);
+    // Step 1b: Optionally freeze the last frame for a pause before looping
+    const holdSec = Math.min(Math.max(options.holdLastFrameSec ?? 0, 0), 10);
+    let sourcePath = trimmedPath;
+    if (holdSec > 0) {
+        const paddedPath = path.join(outputDir, `${clipId}_padded.webm`);
+        await freezeLastFrame(trimmedPath, paddedPath, holdSec);
+        sourcePath = paddedPath;
+    }
+    const durationMs = await getMediaDurationMs(sourcePath);
+    const result = { durationMs };
+    // Step 2: Always persist both a GIF and an MP4.
+    // The GIF remains useful for delivery and embeds, while the MP4 is the
+    // high-fidelity source for Studio playback and downstream re-renders.
+    const gifPath = path.join(outputDir, `${clipId}.gif`);
+    await convertToGif(sourcePath, gifPath, {
+        fps: options.gifFps,
+        maxWidth: options.gifMaxWidth,
+        loop: options.loop,
+    });
+    result.gifPath = gifPath;
+    const gifStat = await stat(gifPath);
+    result.fileSizeBytes = gifStat.size;
+    const mp4Path = path.join(outputDir, `${clipId}.mp4`);
+    await convertToMp4(sourcePath, mp4Path);
+    result.mp4Path = mp4Path;
+    // Step 3: Extract thumbnail
+    const thumbnailPath = path.join(outputDir, `${clipId}_thumb.png`);
+    await extractThumbnail(sourcePath, thumbnailPath);
+    result.thumbnailPath = thumbnailPath;
+    // Clean up intermediate files
+    try {
+        await rm(trimmedPath, { force: true });
+    }
+    catch { /* ignore */ }
+    if (sourcePath !== trimmedPath) {
+        try {
+            await rm(sourcePath, { force: true });
+        }
+        catch { /* ignore */ }
+    }
+    return result;
+}
+//# sourceMappingURL=clip-postprocess.js.map

package/dist/cookie-dismiss.d.ts

@@ -1,4 +1,6 @@
 import type { Page } from 'playwright';
+export declare function getCaptureHideCSS(): string;
+export declare function ensureCaptureHideStyles(page: Page): Promise<void>;
 export declare function dismissCookiesAndWidgets(page: Page): Promise<{
     dismissed: boolean;
     method: string | null;

package/dist/cookie-dismiss.js

@@ -82,6 +82,51 @@ const HIDE_SELECTORS = [
     '[id*="cookieBanner"]', '[id*="cookieConsent"]',
     '[class*="gdpr"]', '[id*="gdpr"]',
 ];
+// Dev-only chrome that should never appear in captures
+const DEV_TOOL_SELECTORS = [
+    // Next.js dev indicator / devtools
+    'nextjs-portal',
+    '#__next-build-watcher',
+    '[data-next-badge-root]',
+    // Astro dev toolbar
+    'astro-dev-toolbar',
+    // Vite overlays
+    'vite-error-overlay',
+    'vite-plugin-checker-error-overlay',
+    // Nuxt devtools
+    'nuxt-devtools',
+    'nuxt-devtools-frame',
+    '#nuxt-devtools-anchor',
+    '#nuxt-devtools-container',
+];
+const CAPTURE_HIDE_STYLE_ID = 'autokap-capture-hide-style';
+export function getCaptureHideCSS() {
+    return [...HIDE_SELECTORS, ...DEV_TOOL_SELECTORS].map(selector => `${selector} { display: none !important; visibility: hidden !important; pointer-events: none !important; }`).join('\n');
+}
+export async function ensureCaptureHideStyles(page) {
+    try {
+        await page.evaluate(({ styleId, css }) => {
+            const parent = document.head ?? document.documentElement;
+            if (!parent)
+                return;
+            let style = document.getElementById(styleId);
+            if (!style) {
+                style = document.createElement('style');
+                style.id = styleId;
+                parent.appendChild(style);
+            }
+            if (style.textContent !== css) {
+                style.textContent = css;
+            }
+        }, {
+            styleId: CAPTURE_HIDE_STYLE_ID,
+            css: getCaptureHideCSS(),
+        });
+    }
+    catch {
+        // Page might have navigated away
+    }
+}
 export async function dismissCookiesAndWidgets(page) {
     // Strategy 1: Click known CMP buttons
     for (const selector of CMP_SELECTORS) {
@@ -91,7 +136,7 @@ export async function dismissCookiesAndWidgets(page) {
                 await button.click({ timeout: 2000 });
                 logger.info(`Cookie dismissed via CMP selector: ${selector}`);
                 await page.waitForTimeout(500);
-                await injectHideCSS(page);
+                await ensureCaptureHideStyles(page);
                 return { dismissed: true, method: `cmp:${selector}` };
             }
         }
@@ -148,7 +193,7 @@ export async function dismissCookiesAndWidgets(page) {
         if (dismissed) {
             logger.info(`Cookie dismissed via text match: "${dismissed}"`);
             await page.waitForTimeout(500);
-            await injectHideCSS(page);
+            await ensureCaptureHideStyles(page);
             return { dismissed: true, method: `text:${dismissed}` };
         }
     }
@@ -156,17 +201,7 @@ export async function dismissCookiesAndWidgets(page) {
         // Text-based search failed
     }
     // Strategy 3: Always inject CSS to hide known overlays and widgets
-    await injectHideCSS(page);
+    await ensureCaptureHideStyles(page);
     return { dismissed: false, method: null };
 }
-async function injectHideCSS(page) {
-    try {
-        await page.addStyleTag({
-            content: HIDE_SELECTORS.map(s => `${s} { display: none !important; visibility: hidden !important; pointer-events: none !important; }`).join('\n'),
-        });
-    }
-    catch {
-        // Page might have navigated away
-    }
-}
 //# sourceMappingURL=cookie-dismiss.js.map

package/dist/cost-logging.d.ts

@@ -0,0 +1,35 @@
+import type { SupabaseClient } from '@supabase/supabase-js';
+import type { StepUsage } from './types.js';
+export interface CostLogContext {
+    runId: string;
+    userId: string;
+    projectId?: string;
+    presetId?: string;
+    lang?: string;
+    theme?: string;
+    captureType?: 'fullpage' | 'element' | 'video';
+    elementName?: string;
+    targetId?: string;
+    captureId?: string | null;
+    viewportWidth?: number | null;
+    viewportHeight?: number | null;
+}
+export declare function insertCostLogs(supabase: SupabaseClient, ctx: CostLogContext, steps: StepUsage[]): Promise<string[]>;
+export declare function updateCostLogCaptureContext(supabase: SupabaseClient, costLogIds: string[], params: {
+    captureId?: string | null;
+    targetId?: string | null;
+    viewportWidth?: number | null;
+    viewportHeight?: number | null;
+}): Promise<void>;
+/**
+ * Retry resolution for previously failed cost logs.
+ * Designed to be called by a reconciliation cron job.
+ */
+export declare function reconcileUnresolvedCosts(supabase: SupabaseClient, apiKey: string): Promise<{
+    retried: number;
+    resolved: number;
+}>;
+export declare function resolveAllCosts(supabase: SupabaseClient, entries: Array<{
+    costLogId: string;
+    generationId: string | null;
+}>, apiKey: string, serviceClient?: SupabaseClient): Promise<void>;

package/dist/cost-logging.js

@@ -0,0 +1,242 @@
+function isFiniteInteger(value) {
+    return typeof value === 'number' && Number.isInteger(value);
+}
+function normalizeUsageForCostLog(step, index) {
+    const normalizedStepNumber = isFiniteInteger(step.stepNumber) && step.stepNumber >= 0
+        ? step.stepNumber
+        : index + 1;
+    const normalizedStepType = typeof step.stepType === 'string' && step.stepType.trim().length > 0
+        ? step.stepType
+        : 'agent_iteration';
+    const normalizedModelRequested = typeof step.modelRequested === 'string' && step.modelRequested.trim().length > 0
+        ? step.modelRequested
+        : step.modelUsed ?? 'unknown';
+    const normalizedImagesInPrompt = typeof step.imagesInPrompt === 'number' && Number.isFinite(step.imagesInPrompt)
+        ? step.imagesInPrompt
+        : 0;
+    if (normalizedStepNumber !== step.stepNumber
+        || normalizedStepType !== step.stepType
+        || normalizedModelRequested !== step.modelRequested
+        || normalizedImagesInPrompt !== step.imagesInPrompt) {
+        console.warn('Normalizing invalid cost log usage entry:', JSON.stringify({
+            stepNumber: step.stepNumber ?? null,
+            stepType: step.stepType ?? null,
+            modelRequested: step.modelRequested ?? null,
+            modelUsed: step.modelUsed ?? null,
+            fallbackStepNumber: normalizedStepNumber,
+        }));
+    }
+    return {
+        ...step,
+        stepNumber: normalizedStepNumber,
+        stepType: normalizedStepType,
+        modelRequested: normalizedModelRequested,
+        imagesInPrompt: normalizedImagesInPrompt,
+    };
+}
+export async function insertCostLogs(supabase, ctx, steps) {
+    if (steps.length === 0)
+        return [];
+    const rows = steps.map((rawStep, index) => {
+        const step = normalizeUsageForCostLog(rawStep, index);
+        return {
+            id: crypto.randomUUID(),
+            run_id: ctx.runId,
+            user_id: ctx.userId,
+            project_id: ctx.projectId ?? null,
+            preset_id: ctx.presetId ?? null,
+            capture_id: ctx.captureId ?? null,
+            step_number: step.stepNumber,
+            step_type: step.stepType,
+            model_requested: step.modelRequested,
+            model_used: step.modelUsed,
+            generation_id: step.generationId,
+            prompt_tokens: step.promptTokens,
+            completion_tokens: step.completionTokens,
+            total_tokens: step.totalTokens,
+            cost_resolved: false,
+            images_in_prompt: step.imagesInPrompt,
+            lang: ctx.lang ?? null,
+            theme: ctx.theme ?? null,
+            capture_type: ctx.captureType ?? null,
+            element_name: ctx.elementName ?? null,
+            target_id: ctx.targetId ?? null,
+            viewport_width: ctx.viewportWidth ?? null,
+            viewport_height: ctx.viewportHeight ?? null,
+            system_prompt_chars: step.systemPromptChars ?? null,
+            tool_schema_chars: step.toolSchemaChars ?? null,
+            user_payload_chars: step.userPayloadChars ?? null,
+            accessibility_chars: step.accessibilityChars ?? null,
+            interactive_element_count: step.interactiveElementCount ?? null,
+            action_history_count: step.actionHistoryCount ?? null,
+            elements_chars: step.elementsChars ?? null,
+            session_summary_chars: step.sessionSummaryChars ?? null,
+            selector_memory_chars: step.selectorMemoryChars ?? null,
+            agent_context_chars: step.agentContextChars ?? null,
+            profile_validation_status: step.profileValidationStatus ?? null,
+            session_profile_source: step.sessionProfileSource ?? null,
+            repair_path_used: step.repairPathUsed ?? null,
+            evaluator_used: step.evaluatorUsed ?? false,
+            cache_read_tokens: step.cacheReadTokens ?? null,
+            cache_write_tokens: step.cacheWriteTokens ?? null,
+            session_profile_reused: step.sessionProfileReused ?? false,
+            action_replay_used: step.actionReplayUsed ?? false,
+        };
+    });
+    try {
+        const { error } = await supabase.from('cost_logs').insert(rows);
+        if (error) {
+            console.error('Failed to insert cost logs:', error.message);
+            return [];
+        }
+        return rows.map((row) => row.id);
+    }
+    catch (error) {
+        console.error('Failed to insert cost logs:', error.message);
+        return [];
+    }
+}
+export async function updateCostLogCaptureContext(supabase, costLogIds, params) {
+    if (costLogIds.length === 0)
+        return;
+    try {
+        const { error } = await supabase
+            .from('cost_logs')
+            .update({
+            capture_id: params.captureId ?? null,
+            target_id: params.targetId ?? null,
+            viewport_width: params.viewportWidth ?? null,
+            viewport_height: params.viewportHeight ?? null,
+        })
+            .in('id', costLogIds);
+        if (error) {
+            console.error('Failed to update cost log capture context:', error.message);
+        }
+    }
+    catch (error) {
+        console.error('Failed to update cost log capture context:', error.message);
+    }
+}
+async function resolveCost(updateClient, generationId, costLogId, apiKey) {
+    const delays = [10_000, 20_000, 40_000, 80_000, 160_000];
+    for (let attempt = 0; attempt < delays.length; attempt += 1) {
+        await new Promise((resolve) => setTimeout(resolve, delays[attempt]));
+        // Track resolution attempt (best-effort)
+        try {
+            await updateClient
+                .from('cost_logs')
+                .update({
+                resolution_attempts: attempt + 1,
+                last_resolution_attempt_at: new Date().toISOString(),
+                cost_resolution_status: 'pending',
+            })
+                .eq('id', costLogId);
+        }
+        catch { /* best-effort tracking */ }
+        try {
+            const response = await fetch(`https://openrouter.ai/api/v1/generation?id=${generationId}`, { headers: { Authorization: `Bearer ${apiKey}` } });
+            if (response.status === 404 && attempt < delays.length - 1) {
+                continue;
+            }
+            if (!response.ok) {
+                console.error(`OpenRouter generation lookup failed (${generationId}): HTTP ${response.status}`);
+                if (attempt === delays.length - 1) {
+                    await markCostResolutionFailed(updateClient, costLogId, `HTTP ${response.status}`);
+                }
+                continue;
+            }
+            const generation = await response.json();
+            const totalCost = generation.data?.total_cost ?? null;
+            if (totalCost == null) {
+                console.warn(`OpenRouter returned no total_cost for generation ${generationId}`);
+                if (attempt === delays.length - 1) {
+                    await markCostResolutionFailed(updateClient, costLogId, 'no total_cost in response');
+                }
+                continue;
+            }
+            const { error } = await updateClient
+                .from('cost_logs')
+                .update({
+                cost_usd: totalCost,
+                cost_resolved: true,
+                resolved_at: new Date().toISOString(),
+                cost_resolution_status: 'resolved',
+            })
+                .eq('id', costLogId);
+            if (error) {
+                console.error(`cost_logs update failed for row ${costLogId}:`, error.message);
+            }
+            return;
+        }
+        catch (error) {
+            if (attempt === delays.length - 1) {
+                console.error(`Cost resolution failed for ${generationId}:`, error.message);
+                await markCostResolutionFailed(updateClient, costLogId, error.message);
+            }
+        }
+    }
+}
+async function markCostResolutionFailed(updateClient, costLogId, reason) {
+    try {
+        await updateClient
+            .from('cost_logs')
+            .update({ cost_resolution_status: 'failed' })
+            .eq('id', costLogId);
+        console.error(`Cost resolution marked as failed for ${costLogId}: ${reason}`);
+    }
+    catch {
+        // best-effort — don't fail the caller
+    }
+}
+/**
+ * Retry resolution for previously failed cost logs.
+ * Designed to be called by a reconciliation cron job.
+ */
+export async function reconcileUnresolvedCosts(supabase, apiKey) {
+    const sevenDaysAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString();
+    const { data: failedLogs, error } = await supabase
+        .from('cost_logs')
+        .select('id, generation_id')
+        .eq('cost_resolution_status', 'failed')
+        .gt('created_at', sevenDaysAgo)
+        .not('generation_id', 'is', null)
+        .limit(100);
+    if (error || !failedLogs?.length) {
+        return { retried: 0, resolved: 0 };
+    }
+    let resolved = 0;
+    for (const log of failedLogs) {
+        try {
+            const response = await fetch(`https://openrouter.ai/api/v1/generation?id=${log.generation_id}`, { headers: { Authorization: `Bearer ${apiKey}` } });
+            if (!response.ok)
+                continue;
+            const generation = await response.json();
+            const totalCost = generation.data?.total_cost ?? null;
+            if (totalCost == null)
+                continue;
+            await supabase
+                .from('cost_logs')
+                .update({
+                cost_usd: totalCost,
+                cost_resolved: true,
+                resolved_at: new Date().toISOString(),
+                cost_resolution_status: 'resolved',
+            })
+                .eq('id', log.id);
+            resolved += 1;
+        }
+        catch {
+            // skip this entry, will be retried next run
+        }
+    }
+    return { retried: failedLogs.length, resolved };
+}
+export function resolveAllCosts(supabase, entries, apiKey, serviceClient) {
+    const toResolve = entries.filter((entry) => entry.generationId != null);
+    if (toResolve.length === 0) {
+        return Promise.resolve();
+    }
+    const updateClient = serviceClient ?? supabase;
+    return Promise.allSettled(toResolve.map((entry) => resolveCost(updateClient, entry.generationId, entry.costLogId, apiKey))).then(() => undefined);
+}
+//# sourceMappingURL=cost-logging.js.map

package/dist/cost-resolution-monitor.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Cost resolution monitoring — exposes metrics for alerting
+ * when the failure rate of OpenRouter cost lookups exceeds thresholds.
+ */
+import type { SupabaseClient } from '@supabase/supabase-js';
+export interface CostResolutionStats {
+    /** Number of cost logs with status 'failed' in the last hour. */
+    failedLastHour: number;
+    /** Total cost logs created in the last hour. */
+    totalLastHour: number;
+    /** Failure rate as a percentage (0-100). */
+    failureRate: number;
+    /** Number of cost logs still pending (older than 5 minutes). */
+    stalePending: number;
+}
+export declare function getCostResolutionStats(supabase: SupabaseClient): Promise<CostResolutionStats>;

package/dist/cost-resolution-monitor.js

@@ -0,0 +1,34 @@
+/**
+ * Cost resolution monitoring — exposes metrics for alerting
+ * when the failure rate of OpenRouter cost lookups exceeds thresholds.
+ */
+export async function getCostResolutionStats(supabase) {
+    const oneHourAgo = new Date(Date.now() - 60 * 60 * 1000).toISOString();
+    const fiveMinutesAgo = new Date(Date.now() - 5 * 60 * 1000).toISOString();
+    const [failedResult, totalResult, staleResult] = await Promise.all([
+        supabase
+            .from('cost_logs')
+            .select('*', { count: 'exact', head: true })
+            .eq('cost_resolution_status', 'failed')
+            .gt('created_at', oneHourAgo),
+        supabase
+            .from('cost_logs')
+            .select('*', { count: 'exact', head: true })
+            .gt('created_at', oneHourAgo)
+            .not('generation_id', 'is', null),
+        supabase
+            .from('cost_logs')
+            .select('*', { count: 'exact', head: true })
+            .eq('cost_resolution_status', 'pending')
+            .lt('created_at', fiveMinutesAgo)
+            .not('generation_id', 'is', null),
+    ]);
+    const failedLastHour = failedResult.count ?? 0;
+    const totalLastHour = totalResult.count ?? 0;
+    const stalePending = staleResult.count ?? 0;
+    const failureRate = totalLastHour > 0
+        ? Math.round((failedLastHour / totalLastHour) * 10000) / 100
+        : 0;
+    return { failedLastHour, totalLastHour, failureRate, stalePending };
+}
+//# sourceMappingURL=cost-resolution-monitor.js.map

package/dist/credential-templates.d.ts

@@ -0,0 +1,5 @@
+import type { LoginCredentials } from "./types.js";
+export declare function resolveCredentialTemplates(value: string | undefined, credentials?: LoginCredentials): string | undefined;
+export declare function ensureNoCredentialTemplate(field: string, value: string | undefined): void;
+export declare function sanitizeCredentialParams(params: Record<string, unknown>, credentials?: LoginCredentials): Record<string, unknown>;
+export declare function resolveActionCredentialArgs(action: string, args: Record<string, unknown>, credentials?: LoginCredentials): Record<string, unknown>;