@listo-ai/mcp-observability 0.2.0

package/dist/index.js

@@ -0,0 +1,790 @@
+import { createHash, randomUUID } from 'node:crypto';
+export class InMemorySink {
+    events = [];
+    limit;
+    constructor(options) {
+        this.limit = options?.limit ?? 2000;
+    }
+    emit(event) {
+        this.events.push(event);
+        if (this.events.length > this.limit) {
+            this.events.shift();
+        }
+    }
+    getEvents() {
+        return [...this.events];
+    }
+    getMetrics() {
+        const httpEvents = this.events.filter((event) => event.type === 'http_request');
+        const mcpEvents = this.events.filter((event) => event.type === 'mcp_request');
+        const sessionEvents = this.events.filter((event) => event.type === 'mcp_session');
+        const uiEvents = this.events.filter((event) => event.type === 'ui_event');
+        const businessEvents = this.events.filter((event) => event.type === 'business_event');
+        return {
+            totals: {
+                events: this.events.length,
+                http: httpEvents.length,
+                mcp: mcpEvents.length,
+                sessions: sessionEvents.length,
+                ui: uiEvents.length,
+                business: businessEvents.length,
+            },
+            http: {
+                overall: summarizeLatency(httpEvents),
+                byRoute: summarizeBy(httpEvents, (event) => event.route),
+            },
+            mcp: {
+                byKind: summarizeBy(mcpEvents, (event) => event.requestKind),
+                tools: summarizeBy(mcpEvents.filter((event) => event.requestKind === 'CallTool'), (event) => event.toolName ?? 'unknown'),
+            },
+            sessions: summarizeSessionEvents(sessionEvents),
+            ui: summarizeUiEvents(uiEvents),
+            business: summarizeBusinessEvents(businessEvents),
+            analytics: computeAnalytics({ uiEvents, businessEvents }),
+        };
+    }
+}
+export function createConsoleSink(options) {
+    const logSuccess = options?.logSuccess ?? false;
+    return {
+        emit(event) {
+            if (event.type === 'http_request') {
+                if (event.status === 'ok' && !logSuccess)
+                    return;
+                const label = `${event.method} ${event.route}`;
+                const message = `[telemetry] ${label} status=${event.status} code=${event.statusCode} latency=${event.latencyMs.toFixed(1)}ms`;
+                (event.status === 'error' ? console.error : console.info)(event.error ? `${message} error=${event.error}` : message);
+                return;
+            }
+            if (event.type === 'mcp_request') {
+                if (event.status === 'ok' && !logSuccess)
+                    return;
+                const label = `${event.requestKind}${event.toolName ? `:${event.toolName}` : ''}`;
+                const message = `[telemetry] ${label} status=${event.status} latency=${event.latencyMs.toFixed(1)}ms`;
+                (event.status === 'error' ? console.error : console.info)(event.error ? `${message} error=${event.error}` : message);
+                return;
+            }
+            if (event.type === 'mcp_session' || event.type === 'business_event') {
+                console.info('[telemetry]', event);
+            }
+        },
+    };
+}
+export function combineSinks(...sinks) {
+    return {
+        emit(event) {
+            sinks.forEach((sink) => {
+                try {
+                    const result = sink.emit(event);
+                    if (result && typeof result.then === 'function') {
+                        result.catch((error) => {
+                            console.error('Telemetry sink failed', error);
+                        });
+                    }
+                }
+                catch (error) {
+                    console.error('Telemetry sink threw', error);
+                }
+            });
+        },
+    };
+}
+export class McpObservability {
+    serviceName;
+    serviceVersion;
+    environment;
+    sinks;
+    sampleRate;
+    redactKeys;
+    capturePayloads;
+    tenantResolver;
+    constructor(options) {
+        this.serviceName = options.serviceName;
+        this.serviceVersion = options.serviceVersion;
+        this.environment = options.environment;
+        this.sinks = options.sinks?.length
+            ? options.sinks
+            : [createConsoleSink({ logSuccess: false })];
+        this.sampleRate = clampSampleRate(options.sampleRate);
+        this.redactKeys = new Set((options.redactKeys ?? [
+            'authorization',
+            'apikey',
+            'password',
+            'token',
+            'secret',
+        ]).map((key) => key.toLowerCase()));
+        this.capturePayloads = options.capturePayloads ?? false;
+        this.tenantResolver = options.tenantResolver;
+    }
+    recordUiEvent(event) {
+        const enriched = {
+            ...event,
+            type: 'ui_event',
+            timestamp: Date.now(),
+            service: this.serviceName,
+            serviceVersion: this.serviceVersion,
+            environment: this.environment,
+        };
+        this.safeEmit(enriched);
+    }
+    async trackHttpRequest(req, res, handler) {
+        const start = performance.now();
+        const requestId = randomUUID();
+        const defaultRoute = normalizePath(req.url);
+        const path = defaultRoute;
+        const context = {
+            route: defaultRoute,
+            tenantId: this.tenantResolver?.(req),
+        };
+        let recorded = false;
+        const finalize = (error) => {
+            if (recorded)
+                return;
+            recorded = true;
+            const latencyMs = performance.now() - start;
+            const statusCode = res.statusCode || (error ? 500 : 200);
+            const status = error || statusCode >= 500 ? 'error' : 'ok';
+            const event = {
+                type: 'http_request',
+                timestamp: Date.now(),
+                service: this.serviceName,
+                serviceVersion: this.serviceVersion,
+                environment: this.environment,
+                requestId,
+                method: req.method ?? 'UNKNOWN',
+                path,
+                route: context.route,
+                statusCode,
+                status,
+                latencyMs,
+                tenantId: context.tenantId || undefined,
+                error: error ? toErrorMessage(error) : undefined,
+            };
+            this.safeEmit(event);
+        };
+        res.once('finish', () => finalize());
+        try {
+            await handler({
+                setRoute: (route) => {
+                    context.route = route || context.route;
+                },
+                setTenant: (tenantId) => {
+                    context.tenantId = tenantId ?? undefined;
+                },
+            });
+        }
+        catch (error) {
+            finalize(error);
+            throw error;
+        }
+    }
+    wrapMcpHandler(requestKind, handler, context) {
+        return async (request) => {
+            const metadata = context?.(request) ?? {};
+            const requestId = metadata.requestId ?? randomUUID();
+            const start = performance.now();
+            try {
+                const result = await handler(request);
+                const sanitizedArgs = metadata.args
+                    ? this.sanitizePayload(metadata.args)
+                    : undefined;
+                const sanitizedResult = metadata.resultPreview
+                    ? this.sanitizePayload(metadata.resultPreview(result))
+                    : undefined;
+                this.safeEmit({
+                    ...this.baseMcpFields(),
+                    type: 'mcp_request',
+                    timestamp: Date.now(),
+                    requestId,
+                    requestKind,
+                    toolName: metadata.toolName,
+                    resourceUri: metadata.resourceUri,
+                    status: 'ok',
+                    latencyMs: performance.now() - start,
+                    tenantId: metadata.tenantId,
+                    sessionId: metadata.sessionId,
+                    locale: metadata.locale,
+                    userAgent: metadata.userAgent,
+                    conversationId: metadata.conversationId,
+                    argsHash: sanitizedArgs ? hashPayload(sanitizedArgs) : undefined,
+                    inputBytes: estimateSize(metadata.args),
+                    outputBytes: estimateSize(result),
+                    samplePayload: this.capturePayloads ? sanitizedArgs : undefined,
+                    argsPreview: sanitizedArgs
+                        ? truncatePreview(sanitizedArgs)
+                        : undefined,
+                    resultPreview: sanitizedResult
+                        ? truncatePreview(sanitizedResult)
+                        : undefined,
+                    resultHash: sanitizedResult
+                        ? hashPayload(sanitizedResult)
+                        : undefined,
+                    userQueryHash: metadata.userQuery
+                        ? hashPayload(this.sanitizePayload(metadata.userQuery))
+                        : undefined,
+                    userQueryPreview: metadata.userQuery
+                        ? truncateString(metadata.userQuery, 240)
+                        : undefined,
+                });
+                return result;
+            }
+            catch (error) {
+                const sanitizedArgs = metadata.args
+                    ? this.sanitizePayload(metadata.args)
+                    : undefined;
+                this.safeEmit({
+                    ...this.baseMcpFields(),
+                    type: 'mcp_request',
+                    timestamp: Date.now(),
+                    requestId,
+                    requestKind,
+                    toolName: metadata.toolName,
+                    resourceUri: metadata.resourceUri,
+                    status: 'error',
+                    latencyMs: performance.now() - start,
+                    tenantId: metadata.tenantId,
+                    sessionId: metadata.sessionId,
+                    locale: metadata.locale,
+                    userAgent: metadata.userAgent,
+                    conversationId: metadata.conversationId,
+                    argsHash: sanitizedArgs ? hashPayload(sanitizedArgs) : undefined,
+                    inputBytes: estimateSize(metadata.args),
+                    error: toErrorMessage(error),
+                });
+                throw error;
+            }
+        };
+    }
+    recordSession(event) {
+        const enriched = {
+            ...event,
+            timestamp: Date.now(),
+            service: this.serviceName,
+            serviceVersion: this.serviceVersion,
+            environment: this.environment,
+        };
+        this.safeEmit(enriched);
+    }
+    recordBusinessEvent(name, properties, status) {
+        const event = {
+            type: 'business_event',
+            timestamp: Date.now(),
+            service: this.serviceName,
+            serviceVersion: this.serviceVersion,
+            environment: this.environment,
+            name,
+            properties,
+            status,
+        };
+        this.safeEmit(event);
+    }
+    baseMcpFields() {
+        return {
+            service: this.serviceName,
+            serviceVersion: this.serviceVersion,
+            environment: this.environment,
+        };
+    }
+    sanitizePayload(payload, depth = 0) {
+        if (payload === null || payload === undefined)
+            return payload;
+        if (depth > 6)
+            return '[truncated]';
+        if (Array.isArray(payload)) {
+            return payload
+                .slice(0, 20)
+                .map((item) => this.sanitizePayload(item, depth + 1));
+        }
+        if (typeof payload !== 'object')
+            return payload;
+        const output = {};
+        for (const [key, value] of Object.entries(payload)) {
+            if (this.redactKeys.has(key.toLowerCase())) {
+                output[key] = '[redacted]';
+            }
+            else {
+                output[key] = this.sanitizePayload(value, depth + 1);
+            }
+        }
+        return output;
+    }
+    safeEmit(event) {
+        if (!shouldSample(event, this.sampleRate))
+            return;
+        for (const sink of this.sinks) {
+            try {
+                const result = sink.emit(event);
+                if (result && typeof result.then === 'function') {
+                    result.catch((error) => {
+                        console.error('Telemetry sink failed', error);
+                    });
+                }
+            }
+            catch (error) {
+                console.error('Telemetry sink threw', error);
+            }
+        }
+    }
+}
+export function createMcpObservability(options) {
+    return new McpObservability(options);
+}
+function hashPayload(payload) {
+    try {
+        const json = JSON.stringify(payload);
+        if (!json)
+            return undefined;
+        return createHash('sha256').update(json).digest('hex');
+    }
+    catch {
+        return undefined;
+    }
+}
+function estimateSize(payload) {
+    try {
+        const json = JSON.stringify(payload);
+        return json ? Buffer.byteLength(json, 'utf8') : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function toErrorMessage(error) {
+    if (error instanceof Error)
+        return error.message;
+    return typeof error === 'string' ? error : JSON.stringify(error);
+}
+function normalizePath(path) {
+    if (!path)
+        return '/';
+    const withoutQuery = path.split('?')[0];
+    return withoutQuery || '/';
+}
+function clampSampleRate(sampleRate) {
+    if (sampleRate === undefined || Number.isNaN(sampleRate))
+        return 1;
+    return Math.min(1, Math.max(0, sampleRate));
+}
+function shouldSample(event, sampleRate) {
+    if ('status' in event && event.status === 'error')
+        return true;
+    if (event.type === 'mcp_session')
+        return true;
+    if (sampleRate >= 1)
+        return true;
+    return Math.random() < sampleRate;
+}
+function percentile(values, p) {
+    if (!values.length)
+        return null;
+    const sorted = [...values].sort((a, b) => a - b);
+    const index = Math.min(sorted.length - 1, Math.max(0, Math.floor((sorted.length - 1) * p)));
+    return sorted[index];
+}
+function summarizeLatency(events) {
+    if (!events.length) {
+        return { count: 0, errors: 0 };
+    }
+    const latencies = events.map((event) => event.latencyMs);
+    const errors = events.filter((event) => event.status === 'error').length;
+    const totalLatency = latencies.reduce((sum, value) => sum + value, 0);
+    return {
+        count: events.length,
+        errors,
+        avgMs: totalLatency / latencies.length,
+        p50: percentile(latencies, 0.5),
+        p95: percentile(latencies, 0.95),
+        p99: percentile(latencies, 0.99),
+    };
+}
+function summarizeBy(events, keyFn) {
+    const groups = {};
+    for (const event of events) {
+        const key = keyFn(event) || 'unknown';
+        if (!groups[key])
+            groups[key] = [];
+        groups[key].push(event);
+    }
+    const summaries = {};
+    for (const [key, group] of Object.entries(groups)) {
+        summaries[key] = summarizeLatency(group);
+    }
+    return summaries;
+}
+function summarizeSessionEvents(events) {
+    const counts = { open: 0, close: 0 };
+    for (const event of events) {
+        counts[event.action] += 1;
+    }
+    return counts;
+}
+function summarizeUiEvents(events) {
+    const byName = {};
+    const byAction = {};
+    const byWidget = {};
+    for (const event of events) {
+        const nameKey = event.name || 'unknown';
+        const actionKey = event.action || 'unspecified';
+        const widgetKey = event.widgetId || 'unknown';
+        byName[nameKey] = (byName[nameKey] ?? 0) + 1;
+        byAction[actionKey] = (byAction[actionKey] ?? 0) + 1;
+        byWidget[widgetKey] = (byWidget[widgetKey] ?? 0) + 1;
+    }
+    return { byName, byAction, byWidget, total: events.length };
+}
+function summarizeBusinessEvents(events) {
+    const byName = {};
+    for (const event of events) {
+        const key = event.name || 'unknown';
+        if (!byName[key]) {
+            byName[key] = { count: 0, ok: 0, error: 0 };
+        }
+        byName[key].count += 1;
+        if (event.status === 'error')
+            byName[key].error += 1;
+        if (event.status === 'ok')
+            byName[key].ok += 1;
+    }
+    return { byName };
+}
+function truncateString(value, max = 240) {
+    if (value.length <= max)
+        return value;
+    return `${value.slice(0, max)}…`;
+}
+function truncatePreview(value) {
+    if (Array.isArray(value)) {
+        // Truncate individual string elements but keep all array items
+        return value.map((item) => typeof item === 'string' ? truncateString(item) : item);
+    }
+    if (value && typeof value === 'object') {
+        // Keep all object entries but truncate string values
+        const result = {};
+        for (const [key, val] of Object.entries(value)) {
+            result[key] = typeof val === 'string' ? truncateString(val) : val;
+        }
+        return result;
+    }
+    if (typeof value === 'string')
+        return truncateString(value);
+    return value;
+}
+function incMap(map, rawKey, delta = 1) {
+    const key = rawKey.trim();
+    if (!key)
+        return;
+    map.set(key, (map.get(key) ?? 0) + delta);
+}
+function asString(value) {
+    if (typeof value === 'string')
+        return value;
+    if (typeof value === 'number' || typeof value === 'boolean')
+        return String(value);
+    return undefined;
+}
+function asObject(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    return value;
+}
+function asStringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .map((v) => asString(v))
+        .filter((v) => typeof v === 'string' && v.trim().length > 0);
+}
+function tokenize(input, stopWords) {
+    const sanitized = input
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, ' ')
+        .trim();
+    if (!sanitized)
+        return [];
+    return sanitized
+        .split(/\s+/)
+        .map((token) => token.trim())
+        .filter((token) => token.length >= 3)
+        .filter((token) => !stopWords.has(token));
+}
+function topEntries(map, limit = 10) {
+    return Array.from(map.entries())
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, limit)
+        .map(([value, count]) => ({ value, count }));
+}
+function topHotelEntries(map, limit = 10) {
+    return Array.from(map.entries())
+        .sort((a, b) => b[1].count - a[1].count)
+        .slice(0, limit)
+        .map(([id, meta]) => ({ id, name: meta.name, count: meta.count }));
+}
+function computeAnalytics(options) {
+    const queryCounts = new Map();
+    const keywordCounts = new Map();
+    const minRatingCounts = new Map();
+    const cityCounts = new Map();
+    const countryCounts = new Map();
+    const hotelViewCounts = new Map();
+    const bookingClickCounts = new Map();
+    const websiteClickCounts = new Map();
+    const searchPriceCounts = new Map();
+    const searchStyleCounts = new Map();
+    const searchNeighborhoodCounts = new Map();
+    const searchLimitCounts = new Map();
+    const viewedPriceCounts = new Map();
+    const viewedStyleCounts = new Map();
+    const viewedCategoryCounts = new Map();
+    const viewedNeighborhoodCounts = new Map();
+    const stopWords = new Set([
+        'a',
+        'an',
+        'and',
+        'are',
+        'as',
+        'at',
+        'be',
+        'but',
+        'by',
+        'for',
+        'from',
+        'has',
+        'have',
+        'hotel',
+        'hotels',
+        'i',
+        'in',
+        'is',
+        'it',
+        'of',
+        'on',
+        'or',
+        'the',
+        'to',
+        'with',
+    ]);
+    const recordQuery = (query) => {
+        const normalized = query.trim();
+        if (!normalized)
+            return;
+        incMap(queryCounts, normalized);
+        tokenize(normalized, stopWords).forEach((token) => incMap(keywordCounts, token));
+    };
+    const recordMinRating = (value) => {
+        const str = asString(value);
+        if (!str)
+            return;
+        incMap(minRatingCounts, str);
+    };
+    const recordCityCountry = (city, country) => {
+        if (city)
+            incMap(cityCounts, city);
+        if (country)
+            incMap(countryCounts, country);
+    };
+    const recordHotelView = (hotelId, name) => {
+        if (!hotelId)
+            return;
+        const existing = hotelViewCounts.get(hotelId) ?? {
+            count: 0,
+            name: undefined,
+        };
+        hotelViewCounts.set(hotelId, {
+            count: existing.count + 1,
+            name: existing.name ?? (name || undefined),
+        });
+    };
+    const recordHotelClick = (map, hotelId, name) => {
+        if (!hotelId)
+            return;
+        const existing = map.get(hotelId) ?? { count: 0, name: undefined };
+        map.set(hotelId, {
+            count: existing.count + 1,
+            name: existing.name ?? (name || undefined),
+        });
+    };
+    const recordList = (map, values) => {
+        const list = asStringArray(values);
+        list.forEach((value) => incMap(map, value));
+    };
+    // Business events (tool-level signals)
+    for (const event of options.businessEvents) {
+        if (event.name === 'hotel_search') {
+            const q = asString(event.properties?.q);
+            if (q)
+                recordQuery(q);
+            recordMinRating(event.properties?.minRating ?? event.properties?.min_rating);
+            recordCityCountry(asString(event.properties?.city), asString(event.properties?.country));
+            recordList(searchPriceCounts, event.properties?.priceLevels);
+            recordList(searchStyleCounts, event.properties?.styles);
+            recordList(searchNeighborhoodCounts, event.properties?.neighborhoods);
+            const limit = asString(event.properties?.limit);
+            if (limit)
+                incMap(searchLimitCounts, limit);
+        }
+        if (event.name === 'hotel_details') {
+            const hotelId = asString(event.properties?.id);
+            const name = asString(event.properties?.name);
+            recordHotelView(hotelId, name);
+            recordCityCountry(asString(event.properties?.city), asString(event.properties?.country));
+            const priceLevel = asString(event.properties?.priceLevel);
+            if (priceLevel)
+                incMap(viewedPriceCounts, priceLevel);
+            recordList(viewedStyleCounts, event.properties?.styles);
+            recordList(viewedCategoryCounts, event.properties?.categories);
+            recordList(viewedNeighborhoodCounts, event.properties?.neighborhoods);
+        }
+    }
+    // UI events (engagement/CTR)
+    for (const event of options.uiEvents) {
+        if (event.name === 'search_results_rendered') {
+            const filters = asObject(event.properties?.rawFilters) ??
+                asObject(event.properties?.filters);
+            const q = asString(filters?.q ?? filters?.query);
+            if (q)
+                recordQuery(q);
+            recordMinRating(filters?.minRating ?? filters?.min_rating);
+            recordList(searchPriceCounts, filters?.priceLevels ?? filters?.price_levels);
+            recordList(searchStyleCounts, filters?.styles);
+            recordList(searchNeighborhoodCounts, filters?.neighborhoods);
+            const limit = asString(filters?.limit);
+            if (limit)
+                incMap(searchLimitCounts, limit);
+        }
+        if (event.name === 'hotel_detail_viewed') {
+            const props = asObject(event.properties);
+            recordHotelView(asString(props?.hotelId), asString(props?.hotelName));
+            recordCityCountry(asString(props?.city), asString(props?.country));
+            const priceLevel = asString(props?.priceLevel);
+            if (priceLevel)
+                incMap(viewedPriceCounts, priceLevel);
+            recordList(viewedStyleCounts, props?.styles);
+            recordList(viewedCategoryCounts, props?.categories);
+            recordList(viewedNeighborhoodCounts, props?.neighborhoods);
+        }
+        if (event.name === 'hotel_selected') {
+            const props = asObject(event.properties);
+            recordHotelView(asString(props?.hotelId), asString(props?.hotelName));
+        }
+        if (event.name === 'booking_cta_click') {
+            const props = asObject(event.properties);
+            const hotelId = asString(props?.hotelId);
+            recordHotelClick(bookingClickCounts, hotelId, asString(props?.hotelName));
+        }
+        if (event.name === 'website_click') {
+            const props = asObject(event.properties);
+            const hotelId = asString(props?.hotelId);
+            recordHotelClick(websiteClickCounts, hotelId, asString(props?.hotelName));
+        }
+    }
+    const impressions = options.uiEvents.filter((e) => e.name === 'widget_impression').length;
+    const clicks = options.uiEvents.filter((e) => e.name === 'widget_click').length;
+    const detailViews = options.uiEvents.filter((e) => e.name === 'hotel_detail_viewed').length;
+    const bookingClicks = Array.from(bookingClickCounts.values()).reduce((acc, entry) => acc + (entry.count || 0), 0);
+    const websiteClicks = Array.from(websiteClickCounts.values()).reduce((acc, entry) => acc + (entry.count || 0), 0);
+    // Backfill missing names from any known hotel views (older clients may omit hotelName).
+    for (const [hotelId, meta] of bookingClickCounts.entries()) {
+        if (!meta.name) {
+            const known = hotelViewCounts.get(hotelId)?.name;
+            if (known)
+                bookingClickCounts.set(hotelId, { ...meta, name: known });
+        }
+    }
+    for (const [hotelId, meta] of websiteClickCounts.entries()) {
+        if (!meta.name) {
+            const known = hotelViewCounts.get(hotelId)?.name;
+            if (known)
+                websiteClickCounts.set(hotelId, { ...meta, name: known });
+        }
+    }
+    const ctrFromImpressions = impressions ? bookingClicks / impressions : null;
+    const ctrFromDetails = detailViews ? bookingClicks / detailViews : null;
+    const topBookingCtr = Array.from(bookingClickCounts.entries())
+        .map(([hotelId, meta]) => {
+        const clicks = meta.count || 0;
+        const views = hotelViewCounts.get(hotelId)?.count ?? 0;
+        const name = meta.name ?? hotelViewCounts.get(hotelId)?.name;
+        return {
+            id: hotelId,
+            name,
+            clicks,
+            views,
+            ctr: views ? clicks / views : null,
+        };
+    })
+        .filter((row) => row.ctr !== null && row.views >= 2)
+        .sort((a, b) => (b.ctr ?? 0) - (a.ctr ?? 0))
+        .slice(0, 8);
+    const sessionsAll = new Set();
+    const sessionsFromImpressions = new Set();
+    const sessionsBooking = new Set();
+    const sessionsWebsite = new Set();
+    let unknownSessionUiEvents = 0;
+    for (const event of options.uiEvents) {
+        const sid = event.sessionId;
+        if (!sid) {
+            unknownSessionUiEvents += 1;
+            continue;
+        }
+        sessionsAll.add(sid);
+        if (event.name === 'widget_impression')
+            sessionsFromImpressions.add(sid);
+        if (event.name === 'booking_cta_click')
+            sessionsBooking.add(sid);
+        if (event.name === 'website_click')
+            sessionsWebsite.add(sid);
+    }
+    const totalSessions = sessionsFromImpressions.size > 0
+        ? sessionsFromImpressions.size
+        : sessionsAll.size;
+    const convertedSessions = new Set([
+        ...Array.from(sessionsBooking),
+        ...Array.from(sessionsWebsite),
+    ]).size;
+    return {
+        search: {
+            topQueries: topEntries(queryCounts, 12),
+            topKeywords: topEntries(keywordCounts, 18),
+            minRatings: topEntries(minRatingCounts, 8),
+            priceLevels: topEntries(searchPriceCounts, 10),
+            neighborhoods: topEntries(searchNeighborhoodCounts, 10),
+            styles: topEntries(searchStyleCounts, 10),
+            limits: topEntries(searchLimitCounts, 8),
+        },
+        geo: {
+            topCities: topEntries(cityCounts, 12),
+            topCountries: topEntries(countryCounts, 12),
+        },
+        hotels: {
+            topViewed: topHotelEntries(hotelViewCounts, 12),
+            topBookingClicks: topHotelEntries(bookingClickCounts, 12),
+            topBookingCtr,
+            topWebsiteClicks: topHotelEntries(websiteClickCounts, 12),
+            viewedPriceLevels: topEntries(viewedPriceCounts, 10),
+            viewedStyles: topEntries(viewedStyleCounts, 10),
+            viewedCategories: topEntries(viewedCategoryCounts, 10),
+            viewedNeighborhoods: topEntries(viewedNeighborhoodCounts, 10),
+        },
+        ctr: {
+            impressions,
+            clicks,
+            detailViews,
+            bookingClicks,
+            websiteClicks,
+            bookingPerImpression: ctrFromImpressions,
+            bookingPerDetailView: ctrFromDetails,
+        },
+        sessions: {
+            total: totalSessions,
+            converted: convertedSessions,
+            booking: sessionsBooking.size,
+            website: sessionsWebsite.size,
+            conversionRate: totalSessions ? convertedSessions / totalSessions : null,
+            unknownSessionUiEvents,
+        },
+    };
+}
+export { RemoteSink, createRemoteSink, } from './remote-sink.js';
+export { createMcpObservabilityEasy, } from './easy-setup.js';
+export { createTelemetryRouter, expressTelemetry } from './endpoints.js';
+//# sourceMappingURL=index.js.map