@nuanu-ai/agentbrowse 0.2.7 → 0.2.8

package/dist/runtime-state.js

@@ -0,0 +1,629 @@
+import { resolveCachedSecretCatalogForHost } from './secrets/catalog-applicability.js';
+import { protectedBindingKey } from './secrets/protected-bindings.js';
+import { inferAcceptancePolicyFromFacts, inferAllowedActionsFromFacts, inferAvailabilityFromFacts, inferControlFamilyFromFacts, } from './control-semantics.js';
+export function locatorCandidateKey(candidate) {
+    return [
+        candidate.strategy,
+        candidate.name ?? '',
+        candidate.value,
+        candidate.attribute ?? '',
+        candidate.scope ?? '',
+    ].join(':');
+}
+function inferLegacyActionMethod(descriptor) {
+    const kind = (descriptor.kind ?? '').toLowerCase();
+    if (['click', 'fill', 'type', 'select', 'press'].includes(kind)) {
+        return kind;
+    }
+    const stagehandAction = descriptor.stagehandAction;
+    if (stagehandAction &&
+        typeof stagehandAction === 'object' &&
+        !Array.isArray(stagehandAction) &&
+        typeof stagehandAction.method === 'string') {
+        return (stagehandAction.method ?? '').toLowerCase();
+    }
+    return '';
+}
+function inferAllowedActions(descriptor) {
+    const legacyMethod = inferLegacyActionMethod(descriptor);
+    return inferAllowedActionsFromFacts({
+        kind: descriptor.kind,
+        role: descriptor.semantics?.role,
+        label: descriptor.label,
+        displayLabel: descriptor.displayLabel,
+        placeholder: descriptor.placeholder,
+        inputName: descriptor.inputName,
+        inputType: descriptor.inputType,
+        autocomplete: descriptor.autocomplete,
+        states: descriptor.semantics?.states,
+        structure: descriptor.structure,
+        legacyMethod,
+    });
+}
+function inferControlFamily(descriptor, allowedActions) {
+    return inferControlFamilyFromFacts({
+        kind: descriptor.kind,
+        role: descriptor.semantics?.role,
+        label: descriptor.label,
+        displayLabel: descriptor.displayLabel,
+        placeholder: descriptor.placeholder,
+        inputName: descriptor.inputName,
+        inputType: descriptor.inputType,
+        autocomplete: descriptor.autocomplete,
+        states: descriptor.semantics?.states,
+        structure: descriptor.structure,
+        legacyMethod: inferLegacyActionMethod(descriptor),
+    }, allowedActions);
+}
+function inferAcceptancePolicy(descriptor, allowedActions) {
+    return inferAcceptancePolicyFromFacts({
+        kind: descriptor.kind,
+        role: descriptor.semantics?.role,
+        label: descriptor.label,
+        displayLabel: descriptor.displayLabel,
+        placeholder: descriptor.placeholder,
+        inputName: descriptor.inputName,
+        inputType: descriptor.inputType,
+        autocomplete: descriptor.autocomplete,
+        states: descriptor.semantics?.states,
+        structure: descriptor.structure,
+        legacyMethod: inferLegacyActionMethod(descriptor),
+    }, allowedActions);
+}
+function inferAvailability(descriptor) {
+    if (descriptor.availability?.state) {
+        return descriptor.availability;
+    }
+    const allowedActions = descriptor.allowedActions ? [...descriptor.allowedActions] : inferAllowedActions(descriptor);
+    const controlFamily = descriptor.controlFamily ?? inferControlFamily(descriptor, allowedActions);
+    const acceptancePolicy = descriptor.acceptancePolicy ?? inferAcceptancePolicy(descriptor, allowedActions);
+    return inferAvailabilityFromFacts(descriptor.semantics?.states, descriptor.context?.hintText, {
+        readonlyInteractive: controlFamily === 'select' ||
+            controlFamily === 'datepicker' ||
+            acceptancePolicy === 'selection' ||
+            acceptancePolicy === 'date-selection',
+    });
+}
+function normalizeTargetDescriptor(descriptor, ref) {
+    const allowedActions = descriptor.allowedActions ? [...descriptor.allowedActions] : inferAllowedActions(descriptor);
+    return {
+        ...descriptor,
+        ref,
+        capability: descriptor.capability ?? 'actionable',
+        lifecycle: descriptor.lifecycle ?? 'live',
+        availability: inferAvailability(descriptor),
+        allowedActions,
+        controlFamily: descriptor.controlFamily ?? inferControlFamily(descriptor, allowedActions),
+        acceptancePolicy: descriptor.acceptancePolicy ?? inferAcceptancePolicy(descriptor, allowedActions),
+    };
+}
+function targetIdentity(descriptor) {
+    const frameKey = descriptor.framePath?.join('>') ??
+        (descriptor.frameUrl?.trim() ? `url:${descriptor.frameUrl.trim()}` : 'top');
+    const pageKey = descriptor.pageSignature ?? descriptor.pageRef;
+    const familyKey = descriptor.controlFamily ?? '';
+    const surfaceKey = descriptor.surfaceRef ?? '';
+    const structureKey = descriptor.structure
+        ? [
+            descriptor.structure.family ?? '',
+            descriptor.structure.variant ?? '',
+            descriptor.structure.row ?? '',
+            descriptor.structure.column ?? '',
+            descriptor.structure.zone ?? '',
+            descriptor.structure.cellLabel ?? '',
+        ].join(':')
+        : '';
+    const locatorKey = descriptor.locatorCandidates
+        .map((candidate) => locatorCandidateKey(candidate))
+        .join('|');
+    const domKey = descriptor.domSignature?.trim();
+    if (domKey && locatorKey) {
+        return `${pageKey}|${frameKey}|family|${familyKey}|surface|${surfaceKey}|structure|${structureKey}|dom|${domKey}|locator|${locatorKey}`;
+    }
+    if (domKey) {
+        return `${pageKey}|${frameKey}|family|${familyKey}|surface|${surfaceKey}|structure|${structureKey}|dom|${domKey}`;
+    }
+    if (locatorKey) {
+        return `${pageKey}|${frameKey}|family|${familyKey}|surface|${surfaceKey}|structure|${structureKey}|locator|${locatorKey}`;
+    }
+    return `${pageKey}|${frameKey}|family|${familyKey}|surface|${surfaceKey}|structure|${structureKey}|fallback|${descriptor.kind ?? ''}|${descriptor.label ?? ''}`;
+}
+function inferSurfaceAvailability(descriptor) {
+    return descriptor.availability?.state ? descriptor.availability : { state: 'available' };
+}
+function normalizeSurfaceDescriptor(descriptor, ref) {
+    return {
+        ...descriptor,
+        ref,
+        lifecycle: descriptor.lifecycle ?? 'live',
+        availability: inferSurfaceAvailability(descriptor),
+    };
+}
+function surfaceIdentity(descriptor) {
+    if (descriptor.surfaceId) {
+        return descriptor.surfaceId;
+    }
+    const frameKey = descriptor.framePath?.join('>') ??
+        (descriptor.frameUrl?.trim() ? `url:${descriptor.frameUrl.trim()}` : 'top');
+    const pageKey = descriptor.pageSignature ?? descriptor.pageRef;
+    const locatorKey = descriptor.locatorCandidates
+        .map((candidate) => locatorCandidateKey(candidate))
+        .join('|');
+    if (locatorKey) {
+        return `${pageKey}|${frameKey}|surface-locator|${locatorKey}`;
+    }
+    return `${pageKey}|${frameKey}|surface-fallback|${descriptor.kind ?? ''}|${descriptor.label ?? ''}`;
+}
+function syncTargetCounter(runtime, ref) {
+    const match = /^t(\d+)$/.exec(ref);
+    if (!match)
+        return;
+    const nextTarget = Number(match[1]) + 1;
+    if (Number.isFinite(nextTarget)) {
+        runtime.counters.nextTarget = Math.max(runtime.counters.nextTarget, nextTarget);
+    }
+}
+function syncFillCounter(runtime, ref) {
+    const match = /^f(\d+)$/.exec(ref);
+    if (!match)
+        return;
+    const nextFill = Number(match[1]) + 1;
+    if (Number.isFinite(nextFill)) {
+        runtime.counters.nextFill = Math.max(runtime.counters.nextFill, nextFill);
+    }
+}
+function syncSurfaceCounter(runtime, ref) {
+    const match = /^s(\d+)$/.exec(ref);
+    if (!match)
+        return;
+    const nextSurface = Number(match[1]) + 1;
+    if (Number.isFinite(nextSurface)) {
+        runtime.counters.nextSurface = Math.max(runtime.counters.nextSurface, nextSurface);
+    }
+}
+export function createRuntimeState(initialPage = {}) {
+    const pageRef = initialPage.pageRef ?? 'p0';
+    const now = new Date().toISOString();
+    return {
+        version: 1,
+        currentPageRef: pageRef,
+        pages: {
+            [pageRef]: {
+                pageRef,
+                createdAt: now,
+                updatedAt: now,
+                url: initialPage.url,
+                title: initialPage.title,
+                openerPageRef: initialPage.openerPageRef,
+            },
+        },
+        surfaces: {},
+        targets: {},
+        secretCatalogByHost: {},
+        fillableForms: {},
+        secretIntentSnapshots: {},
+        protectedExposureByPage: {},
+        counters: {
+            nextPage: pageRef === 'p0' ? 1 : 0,
+            nextSurface: 1,
+            nextTarget: 1,
+            nextFill: 1,
+        },
+        metrics: {
+            stagehandCalls: 0,
+            deterministicActions: 0,
+            fallbackActions: 0,
+            successfulActions: 0,
+            failedActions: 0,
+            totalActionDurationMs: 0,
+            successRate: 0,
+            averageActionDurationMs: 0,
+        },
+    };
+}
+export function ensureRuntimeState(session) {
+    if (!session.runtime) {
+        session.runtime = createRuntimeState();
+    }
+    session.runtime.surfaces ??= {};
+    session.runtime.secretCatalogByHost ??= {};
+    session.runtime.fillableForms ??= {};
+    session.runtime.secretIntentSnapshots ??= {};
+    session.runtime.protectedExposureByPage ??= {};
+    session.runtime.counters.nextPage ??= 1;
+    session.runtime.counters.nextSurface ??= 1;
+    session.runtime.counters.nextTarget ??= 1;
+    session.runtime.counters.nextFill ??= 1;
+    for (const pageRef of Object.keys(session.runtime.pages ?? {})) {
+        const match = /^p(\d+)$/.exec(pageRef);
+        if (!match) {
+            continue;
+        }
+        const nextPage = Number(match[1]) + 1;
+        if (Number.isFinite(nextPage)) {
+            session.runtime.counters.nextPage = Math.max(session.runtime.counters.nextPage, nextPage);
+        }
+    }
+    for (const surfaceRef of Object.keys(session.runtime.surfaces ?? {})) {
+        syncSurfaceCounter(session.runtime, surfaceRef);
+    }
+    for (const targetRef of Object.keys(session.runtime.targets ?? {})) {
+        syncTargetCounter(session.runtime, targetRef);
+    }
+    for (const fillRef of Object.keys(session.runtime.fillableForms ?? {})) {
+        syncFillCounter(session.runtime, fillRef);
+    }
+    return session.runtime;
+}
+export function registerPage(session, page = {}) {
+    const runtime = ensureRuntimeState(session);
+    const pageRef = page.pageRef ?? `p${runtime.counters.nextPage++}`;
+    const now = new Date().toISOString();
+    const existing = runtime.pages[pageRef];
+    const nextPage = {
+        pageRef,
+        createdAt: existing?.createdAt ?? now,
+        updatedAt: now,
+        url: page.url ?? existing?.url,
+        title: page.title ?? existing?.title,
+        targetId: page.targetId ?? existing?.targetId,
+        openerPageRef: page.openerPageRef ?? existing?.openerPageRef,
+    };
+    runtime.pages[pageRef] = nextPage;
+    if (page.makeCurrent !== false) {
+        runtime.currentPageRef = pageRef;
+    }
+    return nextPage;
+}
+export function updatePage(session, pageRef, patch) {
+    const runtime = ensureRuntimeState(session);
+    const current = runtime.pages[pageRef];
+    if (!current) {
+        throw new Error(`unknown_page_ref: ${pageRef}`);
+    }
+    const nextPage = {
+        ...current,
+        ...patch,
+        updatedAt: new Date().toISOString(),
+    };
+    runtime.pages[pageRef] = nextPage;
+    return nextPage;
+}
+export function setCurrentPage(session, pageRef) {
+    const runtime = ensureRuntimeState(session);
+    if (!runtime.pages[pageRef]) {
+        throw new Error(`unknown_page_ref: ${pageRef}`);
+    }
+    runtime.currentPageRef = pageRef;
+}
+export function createTargetRef(session) {
+    const runtime = ensureRuntimeState(session);
+    return `t${runtime.counters.nextTarget++}`;
+}
+export function createFillRef(session) {
+    const runtime = ensureRuntimeState(session);
+    return `f${runtime.counters.nextFill++}`;
+}
+export function createSurfaceRef(session) {
+    const runtime = ensureRuntimeState(session);
+    return `s${runtime.counters.nextSurface++}`;
+}
+export function saveSurfaces(session, descriptors) {
+    const runtime = ensureRuntimeState(session);
+    return descriptors.map((descriptor) => {
+        const ref = descriptor.ref ?? createSurfaceRef(session);
+        const surface = normalizeSurfaceDescriptor(descriptor, ref);
+        runtime.surfaces[ref] = surface;
+        syncSurfaceCounter(runtime, ref);
+        return surface;
+    });
+}
+export function replaceSurfacesForPage(session, pageRef, descriptors, options = {}) {
+    const runtime = ensureRuntimeState(session);
+    const existingEntries = Object.entries(runtime.surfaces).filter(([, surface]) => surface.pageRef === pageRef);
+    const preserveExistingOnEmpty = options.preserveExistingOnEmpty !== false;
+    const preserveExisting = options.preserveExisting !== false;
+    if (descriptors.length === 0 && preserveExistingOnEmpty) {
+        return existingEntries.map(([, surface]) => surface);
+    }
+    const reusableRefs = new Map();
+    for (const [ref, surface] of existingEntries) {
+        const identity = surfaceIdentity(surface);
+        const refs = reusableRefs.get(identity) ?? [];
+        refs.push(ref);
+        reusableRefs.set(identity, refs);
+    }
+    const nextSurfaces = [];
+    const reusedRefs = new Set();
+    for (const descriptor of descriptors) {
+        const normalizedDescriptor = normalizeSurfaceDescriptor({
+            ...descriptor,
+            pageRef,
+        }, descriptor.ref ?? '__identity__');
+        const identity = surfaceIdentity(normalizedDescriptor);
+        const matchedRef = reusableRefs.get(identity)?.shift();
+        const ref = descriptor.ref ?? matchedRef ?? createSurfaceRef(session);
+        const surface = normalizeSurfaceDescriptor(descriptor, ref);
+        runtime.surfaces[ref] = surface;
+        syncSurfaceCounter(runtime, ref);
+        reusedRefs.add(ref);
+        nextSurfaces.push(surface);
+    }
+    if (!preserveExisting) {
+        for (const [ref] of existingEntries) {
+            if (!reusedRefs.has(ref)) {
+                delete runtime.surfaces[ref];
+            }
+        }
+    }
+    return nextSurfaces;
+}
+export function saveTargets(session, descriptors) {
+    const runtime = ensureRuntimeState(session);
+    return descriptors.map((descriptor) => {
+        const ref = descriptor.ref ?? createTargetRef(session);
+        const target = normalizeTargetDescriptor(descriptor, ref);
+        runtime.targets[ref] = target;
+        syncTargetCounter(runtime, ref);
+        return target;
+    });
+}
+export function replaceTargetsForPage(session, pageRef, descriptors, options = {}) {
+    const runtime = ensureRuntimeState(session);
+    const existingEntries = Object.entries(runtime.targets).filter(([, target]) => target.pageRef === pageRef);
+    const preserveExistingOnEmpty = options.preserveExistingOnEmpty !== false;
+    const preserveExisting = options.preserveExisting !== false;
+    if (descriptors.length === 0 && preserveExistingOnEmpty) {
+        return existingEntries.map(([, target]) => target);
+    }
+    function pushReusableRef(map, identity, ref) {
+        const refs = map.get(identity) ?? [];
+        refs.push(ref);
+        map.set(identity, refs);
+    }
+    function takeReusableRef(map, identity, consumedRefs) {
+        const refs = map.get(identity);
+        while (refs && refs.length > 0) {
+            const candidate = refs.shift();
+            if (candidate && !consumedRefs.has(candidate)) {
+                return candidate;
+            }
+        }
+        return undefined;
+    }
+    const reusableRefs = new Map();
+    for (const [ref, target] of existingEntries) {
+        pushReusableRef(reusableRefs, targetIdentity(target), ref);
+    }
+    const nextTargets = [];
+    const reusedRefs = new Set();
+    for (const descriptor of descriptors) {
+        const normalizedDescriptor = normalizeTargetDescriptor({
+            ...descriptor,
+            pageRef,
+        }, descriptor.ref ?? '__identity__');
+        const identity = targetIdentity(normalizedDescriptor);
+        const matchedRef = takeReusableRef(reusableRefs, identity, reusedRefs);
+        const ref = descriptor.ref ?? matchedRef ?? createTargetRef(session);
+        const target = normalizeTargetDescriptor(descriptor, ref);
+        runtime.targets[ref] = target;
+        syncTargetCounter(runtime, ref);
+        reusedRefs.add(ref);
+        nextTargets.push(target);
+    }
+    if (!preserveExisting) {
+        for (const [ref] of existingEntries) {
+            if (!reusedRefs.has(ref)) {
+                delete runtime.targets[ref];
+            }
+        }
+    }
+    return nextTargets;
+}
+export function getTarget(session, targetRef) {
+    const runtime = ensureRuntimeState(session);
+    return runtime.targets[targetRef] ?? null;
+}
+export function getSurface(session, surfaceRef) {
+    const runtime = ensureRuntimeState(session);
+    return runtime.surfaces[surfaceRef] ?? null;
+}
+export function saveSecretCatalog(session, snapshot) {
+    const runtime = ensureRuntimeState(session);
+    runtime.secretCatalogByHost[snapshot.host] = snapshot;
+    return snapshot;
+}
+export function getSecretCatalog(session, host) {
+    const runtime = ensureRuntimeState(session);
+    return resolveCachedSecretCatalogForHost(host, Object.values(runtime.secretCatalogByHost));
+}
+export function saveFillableForms(session, forms) {
+    const runtime = ensureRuntimeState(session);
+    for (const form of forms) {
+        runtime.fillableForms[form.fillRef] = form;
+        syncFillCounter(runtime, form.fillRef);
+    }
+    return forms.map((form) => runtime.fillableForms[form.fillRef]);
+}
+function fillableFormIdentity(form) {
+    const fieldsKey = [...form.fields].map((field) => protectedBindingKey(field)).sort().join('|');
+    return [form.pageRef, form.scopeRef ?? '', form.purpose, fieldsKey].join('||');
+}
+export function replaceFillableFormsForPage(session, pageRef, forms, options = {}) {
+    const runtime = ensureRuntimeState(session);
+    const existingEntries = Object.entries(runtime.fillableForms).filter(([, form]) => form.pageRef === pageRef);
+    const preserveExistingOnEmpty = options.preserveExistingOnEmpty !== false;
+    if (forms.length === 0 && preserveExistingOnEmpty) {
+        return existingEntries.map(([, form]) => form);
+    }
+    const reusableRefs = new Map();
+    for (const [fillRef, form] of existingEntries) {
+        const identity = fillableFormIdentity(form);
+        const refs = reusableRefs.get(identity) ?? [];
+        refs.push(fillRef);
+        reusableRefs.set(identity, refs);
+    }
+    const reusedRefs = new Set();
+    const nextForms = [];
+    for (const form of forms) {
+        const identity = fillableFormIdentity(form);
+        const matchedRef = (reusableRefs.get(identity) ?? []).find((ref) => !reusedRefs.has(ref));
+        const fillRef = matchedRef ?? createFillRef(session);
+        runtime.fillableForms[fillRef] = {
+            ...form,
+            fillRef,
+        };
+        syncFillCounter(runtime, fillRef);
+        reusedRefs.add(fillRef);
+        nextForms.push(runtime.fillableForms[fillRef]);
+    }
+    for (const [fillRef] of existingEntries) {
+        if (!reusedRefs.has(fillRef)) {
+            delete runtime.fillableForms[fillRef];
+        }
+    }
+    return nextForms;
+}
+export function getFillableForm(session, fillRef) {
+    const runtime = ensureRuntimeState(session);
+    return runtime.fillableForms[fillRef] ?? null;
+}
+export function saveSecretIntentSnapshot(session, snapshot) {
+    const runtime = ensureRuntimeState(session);
+    runtime.secretIntentSnapshots[snapshot.intentId] = snapshot;
+    return snapshot;
+}
+export function getSecretIntentSnapshot(session, intentId) {
+    const runtime = ensureRuntimeState(session);
+    return runtime.secretIntentSnapshots[intentId] ?? null;
+}
+export function saveProtectedExposure(session, exposure) {
+    const runtime = ensureRuntimeState(session);
+    const exposures = runtime.protectedExposureByPage ?? (runtime.protectedExposureByPage = {});
+    exposures[exposure.pageRef] = exposure;
+    return exposures[exposure.pageRef];
+}
+export function getProtectedExposure(session, pageRef) {
+    const runtime = ensureRuntimeState(session);
+    return runtime.protectedExposureByPage?.[pageRef] ?? null;
+}
+export function clearProtectedExposure(session, pageRef) {
+    const runtime = ensureRuntimeState(session);
+    if (!pageRef) {
+        runtime.protectedExposureByPage = {};
+        return;
+    }
+    const exposures = runtime.protectedExposureByPage ?? (runtime.protectedExposureByPage = {});
+    delete exposures[pageRef];
+}
+export function updateSurface(session, surfaceRef, patch) {
+    const runtime = ensureRuntimeState(session);
+    const current = runtime.surfaces[surfaceRef];
+    if (!current) {
+        return null;
+    }
+    const next = normalizeSurfaceDescriptor({
+        ...current,
+        ...patch,
+        availability: patch.availability ?? current.availability,
+    }, surfaceRef);
+    runtime.surfaces[surfaceRef] = next;
+    return next;
+}
+export function markSurfaceLifecycle(session, surfaceRef, lifecycle, reason) {
+    return updateSurface(session, surfaceRef, {
+        lifecycle,
+        lifecycleReason: reason,
+    });
+}
+export function setSurfaceAvailability(session, surfaceRef, state, reason) {
+    return updateSurface(session, surfaceRef, {
+        availability: {
+            state,
+            reason,
+        },
+    });
+}
+export function deleteTarget(session, targetRef) {
+    const runtime = ensureRuntimeState(session);
+    delete runtime.targets[targetRef];
+}
+export function updateTarget(session, targetRef, patch) {
+    const runtime = ensureRuntimeState(session);
+    const current = runtime.targets[targetRef];
+    if (!current) {
+        return null;
+    }
+    const next = normalizeTargetDescriptor({
+        ...current,
+        ...patch,
+        availability: patch.availability ?? current.availability,
+        allowedActions: patch.allowedActions ?? current.allowedActions,
+    }, targetRef);
+    runtime.targets[targetRef] = next;
+    return next;
+}
+export function markTargetLifecycle(session, targetRef, lifecycle, reason) {
+    return updateTarget(session, targetRef, {
+        lifecycle,
+        lifecycleReason: reason,
+    });
+}
+export function setTargetAvailability(session, targetRef, state, reason) {
+    return updateTarget(session, targetRef, {
+        availability: {
+            state,
+            reason,
+        },
+    });
+}
+export function listTargets(session) {
+    return Object.values(ensureRuntimeState(session).targets);
+}
+export function listSurfaces(session) {
+    return Object.values(ensureRuntimeState(session).surfaces);
+}
+export function clearTargets(session, pageRef) {
+    const runtime = ensureRuntimeState(session);
+    if (!pageRef) {
+        runtime.surfaces = {};
+        runtime.targets = {};
+        runtime.fillableForms = {};
+        return;
+    }
+    for (const [surfaceRef, surface] of Object.entries(runtime.surfaces)) {
+        if (surface.pageRef === pageRef) {
+            delete runtime.surfaces[surfaceRef];
+        }
+    }
+    for (const [targetRef, target] of Object.entries(runtime.targets)) {
+        if (target.pageRef === pageRef) {
+            delete runtime.targets[targetRef];
+        }
+    }
+    for (const [fillRef, form] of Object.entries(runtime.fillableForms)) {
+        if (form.pageRef === pageRef) {
+            delete runtime.fillableForms[fillRef];
+        }
+    }
+}
+export function incrementMetric(session, metric, by = 1) {
+    const runtime = ensureRuntimeState(session);
+    runtime.metrics[metric] += by;
+    return runtime.metrics[metric];
+}
+export function recordActionResult(session, success, durationMs) {
+    const runtime = ensureRuntimeState(session);
+    if (success) {
+        runtime.metrics.successfulActions += 1;
+    }
+    else {
+        runtime.metrics.failedActions += 1;
+    }
+    runtime.metrics.totalActionDurationMs += Math.max(0, durationMs);
+    const attempts = runtime.metrics.successfulActions + runtime.metrics.failedActions;
+    runtime.metrics.successRate = attempts === 0 ? 0 : runtime.metrics.successfulActions / attempts;
+    runtime.metrics.averageActionDurationMs =
+        attempts === 0 ? 0 : runtime.metrics.totalActionDurationMs / attempts;
+    return runtime.metrics;
+}

package/dist/secrets/backend.d.ts

@@ -0,0 +1,32 @@
+import type { SecretCatalogSnapshot, SecretIntentSnapshot, StoredSecretFieldKey, StoredSecretKind } from './types.js';
+export interface CreateSecretIntentInput {
+    fillRef: string;
+    storedSecretRef: string;
+    host: string;
+    pageRef: string;
+    scopeRef?: string;
+    purpose: string;
+    secretKind: StoredSecretKind;
+    requestedFieldKeys: StoredSecretFieldKey[];
+}
+export interface CreateSecretIntentResult {
+    intent: SecretIntentSnapshot;
+    reused: boolean;
+}
+export interface SecretIntentPollResult {
+    snapshot: SecretIntentSnapshot;
+    deliveredValues?: Partial<Record<StoredSecretFieldKey, string>>;
+}
+export declare class SecretBackendDisabledError extends Error {
+    constructor(message?: string);
+}
+export interface SecretBackend {
+    kind: 'mock' | 'agentpay_api';
+    resolveCatalogHost(urlOrHost: string): string;
+    syncSecretCatalog(urlOrHost: string): Promise<SecretCatalogSnapshot>;
+    createOrReuseSecretIntent(input: CreateSecretIntentInput): Promise<CreateSecretIntentResult>;
+    getSecretIntent(intentId: string): Promise<SecretIntentPollResult | null>;
+}
+export declare function isMockSecretBackendEnabled(): boolean;
+export declare function getSecretBackend(): SecretBackend;
+//# sourceMappingURL=backend.d.ts.map

package/dist/secrets/backend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backend.d.ts","sourceRoot":"","sources":["../../src/secrets/backend.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EACV,qBAAqB,EACrB,oBAAoB,EACpB,oBAAoB,EACpB,gBAAgB,EAEjB,MAAM,YAAY,CAAC;AAqCpB,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,MAAM,CAAC;IAChB,eAAe,EAAE,MAAM,CAAC;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,gBAAgB,CAAC;IAC7B,kBAAkB,EAAE,oBAAoB,EAAE,CAAC;CAC5C;AAED,MAAM,WAAW,wBAAwB;IACvC,MAAM,EAAE,oBAAoB,CAAC;IAC7B,MAAM,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,oBAAoB,CAAC;IAC/B,eAAe,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,oBAAoB,EAAE,MAAM,CAAC,CAAC,CAAC;CACjE;AAWD,qBAAa,0BAA2B,SAAQ,KAAK;gBACvC,OAAO,SAA4D;CAIhF;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,GAAG,cAAc,CAAC;IAC9B,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAAC;IAC9C,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAAC;IACrE,yBAAyB,CAAC,KAAK,EAAE,uBAAuB,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAAC;IAC7F,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,sBAAsB,GAAG,IAAI,CAAC,CAAC;CAC3E;AAyKD,wBAAgB,0BAA0B,IAAI,OAAO,CAEpD;AAED,wBAAgB,gBAAgB,IAAI,aAAa,CAYhD"}