autotel-devtools 23.0.0 → 24.0.0

package/dist/{http-Dbd9TIYU.js → http-z8UbJsqk.js}

@@ -1,5 +1,5 @@
 import { i as encodeTraces } from "./wire-2Rmfg6IT.js";
-import { i as asString, o as stringAttr, t as asObject } from "./json-fields-CPjKZ2WH.js";
+import { i as asString, n as asBoolean, o as stringAttr, r as asNumber, t as asObject } from "./json-fields-CPjKZ2WH.js";
 import { t as pickRoot } from "./trace-root-EHnvuA7f.js";
 import { a as compileWhere, t as parse } from "./parse-D_RmPPQs.js";
 import { t as getResourceName } from "./resource-utils-B4UVvfnH.js";
@@ -287,6 +287,181 @@ var ErrorAggregator = class {
 	}
 };
 
+//#endregion
+//#region src/server/webmcp-aggregator.ts
+/** Span names this fold consumes. Everything else in the trace is ignored. */
+const INSTALL = "webmcp.install";
+const REGISTER = "webmcp.tool.register";
+const EXECUTE = "webmcp.tool.execute";
+const WITHDRAW = "webmcp.tool.withdraw";
+/** How many recent executions a tool carries. Enough to see a pattern, not a log. */
+const RECENT_CALLS = 5;
+/**
+* `{"content":[{"type":"text","text":` + `}]}` and the quoting around it.
+*
+* Chrome does not unwrap the MCP envelope, so an enveloped result spends these
+* bytes of the agent's context on structure carrying no information. Measured
+* rather than derived: 45 bytes wrapped versus 13 plain for the same text.
+*/
+const ENVELOPE_OVERHEAD_BYTES = 32;
+const median = (values) => {
+	if (values.length === 0) return 0;
+	const sorted = [...values].sort((a, b) => a - b);
+	const mid = Math.floor(sorted.length / 2);
+	return sorted.length % 2 === 0 ? Math.round((sorted[mid - 1] + sorted[mid]) / 2) : sorted[mid];
+};
+const csv = (value) => {
+	const raw = asString(value);
+	if (!raw) return [];
+	return raw.split(",").map((part) => part.trim()).filter(Boolean);
+};
+/**
+* Spans with no installation id — emitted by an `autotel-webmcp` older than the
+* lifecycle release. Grouping them under one key per service keeps them
+* readable as a single legacy installation rather than scattering one
+* installation per tool.
+*/
+const UNKNOWN_INSTALLATION = "unknown";
+const isWebMcpSpan = (span) => span.name === INSTALL || span.name === REGISTER || span.name === EXECUTE || span.name === WITHDRAW;
+function foldWebMcpTools(traces, activityWindow) {
+	const tools = /* @__PURE__ */ new Map();
+	/** Installations seen, and whether each one ever registered anything. */
+	const installations = /* @__PURE__ */ new Map();
+	const latestInstallation = /* @__PURE__ */ new Map();
+	const spans = traces.flatMap((trace) => trace.spans.map((span) => ({
+		span,
+		service: trace.service
+	}))).sort((a, b) => a.span.startTime - b.span.startTime);
+	for (const { span, service } of spans) {
+		if (!isWebMcpSpan(span)) continue;
+		if (activityWindow && span.startTime > activityWindow.end) continue;
+		const attrs = span.attributes ?? {};
+		const installationId = asString(attrs["webmcp.installation.id"]) ?? UNKNOWN_INSTALLATION;
+		const installationKey = `${service}${installationId}`;
+		if (!installations.has(installationKey)) installations.set(installationKey, false);
+		if (span.name === INSTALL) {
+			latestInstallation.set(service, installationId);
+			continue;
+		}
+		const name = asString(attrs["webmcp.tool.name"]) ?? asString(attrs["gen_ai.tool.name"]);
+		if (!name) continue;
+		const key = `${service}${installationId}${name}`;
+		let tool = tools.get(key);
+		if (!tool) {
+			tool = {
+				name,
+				installationId,
+				service,
+				sessionId: asString(attrs["session.id"]),
+				observedAtRegistration: false,
+				offered: false,
+				firstSeen: span.startTime,
+				lastSeen: span.startTime,
+				annotationsSent: [],
+				annotationsDropped: [],
+				calls: 0,
+				errors: 0,
+				envelopeCalls: 0,
+				envelopeBytes: 0,
+				substitutedCalls: 0,
+				resultBytes: 0,
+				medianResultBytes: 0,
+				resultSizes: [],
+				recentCalls: [],
+				traceId: span.traceId,
+				spanId: span.spanId
+			};
+			tools.set(key, tool);
+		}
+		tool.firstSeen = Math.min(tool.firstSeen, span.startTime);
+		tool.lastSeen = Math.max(tool.lastSeen, span.startTime);
+		tool.sessionId ??= asString(attrs["session.id"]);
+		switch (span.name) {
+			case REGISTER:
+				installations.set(installationKey, true);
+				tool.observedAtRegistration = true;
+				tool.offered = true;
+				tool.descriptionLength = asNumber(attrs["webmcp.tool.description.length"]);
+				tool.hasInputSchema = asBoolean(attrs["webmcp.tool.has_input_schema"]);
+				tool.annotationsSent = csv(attrs["webmcp.annotations.sent"]);
+				tool.annotationsDropped = csv(attrs["webmcp.annotations.dropped"]);
+				tool.traceId = span.traceId;
+				tool.spanId = span.spanId;
+				break;
+			case WITHDRAW:
+				tool.offered = false;
+				break;
+			case EXECUTE: {
+				if (activityWindow && span.startTime < activityWindow.start) break;
+				tool.calls += 1;
+				const bytes = asNumber(attrs["webmcp.result.bytes"]) ?? 0;
+				tool.resultBytes += bytes;
+				tool.resultSizes.push(bytes);
+				if (asBoolean(attrs["webmcp.result.envelope"])) {
+					tool.envelopeCalls += 1;
+					tool.envelopeBytes += ENVELOPE_OVERHEAD_BYTES;
+				}
+				if (asBoolean(attrs["webmcp.result.substituted"])) tool.substitutedCalls += 1;
+				const failed = span.status.code === "ERROR" || (asBoolean(attrs["webmcp.result.error"]) ?? false) || asString(attrs["error.type"]) !== void 0;
+				if (failed) tool.errors += 1;
+				tool.recentCalls.push({
+					timestamp: span.startTime,
+					durationMs: span.duration,
+					resultBytes: bytes,
+					resultType: asString(attrs["webmcp.result.type"]),
+					envelope: asBoolean(attrs["webmcp.result.envelope"]) ?? false,
+					substituted: asBoolean(attrs["webmcp.result.substituted"]) ?? false,
+					error: failed,
+					input: asString(attrs["webmcp.input"]) ?? asString(attrs["gen_ai.tool.call.arguments"]),
+					result: asString(attrs["webmcp.result"]) ?? asString(attrs["gen_ai.tool.call.result"]),
+					traceId: span.traceId,
+					spanId: span.spanId
+				});
+				break;
+			}
+		}
+	}
+	const list = [...tools.values()].map((tool) => {
+		const { resultSizes, ...rest } = tool;
+		return {
+			...rest,
+			offered: rest.offered && (latestInstallation.get(rest.service) ?? rest.installationId) === rest.installationId,
+			medianResultBytes: median(resultSizes),
+			recentCalls: [...tool.recentCalls].sort((a, b) => b.timestamp - a.timestamp).slice(0, RECENT_CALLS)
+		};
+	});
+	list.sort((a, b) => Number(b.offered) - Number(a.offered) || b.calls - a.calls || a.name.localeCompare(b.name));
+	return {
+		tools: list,
+		summary: summarize(list, installations)
+	};
+}
+function summarize(tools, installations) {
+	const summary = {
+		installations: installations.size,
+		emptyInstallations: [...installations.values()].filter((saw) => !saw).length,
+		toolsOffered: 0,
+		toolsWithdrawn: 0,
+		calls: 0,
+		errors: 0,
+		resultBytes: 0,
+		envelopeBytes: 0,
+		toolsWithDroppedAnnotations: 0,
+		toolsWithoutInputSchema: 0
+	};
+	for (const tool of tools) {
+		if (tool.offered) summary.toolsOffered += 1;
+		else summary.toolsWithdrawn += 1;
+		summary.calls += tool.calls;
+		summary.errors += tool.errors;
+		summary.resultBytes += tool.resultBytes;
+		summary.envelopeBytes += tool.envelopeBytes;
+		if (tool.annotationsDropped.length > 0) summary.toolsWithDroppedAnnotations += 1;
+		if (tool.observedAtRegistration && tool.hasInputSchema === false) summary.toolsWithoutInputSchema += 1;
+	}
+	return summary;
+}
+
 //#endregion
 //#region src/server/telemetry-limits.ts
 const defaultLimit = 100;
@@ -1499,6 +1674,42 @@ var DevtoolsStore = class {
          LIMIT ?`).all(Math.max(1, Math.min(limit, 500)));
 		return [.../* @__PURE__ */ new Set([...Object.keys(schema.columns), ...rows.map((row) => row.key)])];
 	}
+	/**
+	* Values of one attribute paired with another on the same entity.
+	*
+	* `searchAttributes` matches on value text, which cannot answer "what arms
+	* does this experiment have". Pairing two keys across the same span can, and
+	* that is what turns a pair of cohorts into something the viewer offers
+	* rather than something the reader has to type.
+	*
+	* Rows arrive grouped by `key`, each group's values commonest first, so a
+	* caller can build the groups in one pass and take the two commonest as a
+	* default pair.
+	*
+	* The join runs over `attribute_occurrences`, not the `attribute_values`
+	* dictionary: occurrences are deleted with their span, so retention prunes
+	* them, and they carry the entity a value was seen on, so an arm is only
+	* offered for the experiment it actually ran under. The dictionary can do
+	* neither — it counts values for the lifetime of the database and forgets
+	* which span each came from, which would offer arms belonging to a different
+	* experiment and experiments whose spans are long gone.
+	*/
+	pairedAttributeValues(signal, key, pairedKey, limit = 200) {
+		return this.db.prepare(`
+      SELECT a.value_json AS value_json, b.value_json AS paired_json, count(*) AS count
+      FROM attribute_occurrences a
+      JOIN attribute_occurrences b
+        ON b.signal = a.signal AND b.entity_id = a.entity_id AND b.key = ?
+      WHERE a.signal = ? AND a.key = ?
+      GROUP BY a.value_json, b.value_json
+      ORDER BY value_json ASC, count DESC, paired_json ASC
+      LIMIT ?
+    `).all(pairedKey, signal, key, Math.max(1, Math.min(limit, 500))).map((row) => ({
+			value: JSON.parse(row.value_json),
+			paired: JSON.parse(row.paired_json),
+			count: Number(row.count)
+		}));
+	}
 	searchAttributes(signal, value, limit = 50) {
 		return this.db.prepare(`
       SELECT key, value_json, seen_count
@@ -2474,11 +2685,15 @@ var DevtoolsServer = class {
 				this.log(`Client disconnected (${this.clients.size} total)`);
 			});
 		});
-		if (!options.server) this.httpServer.listen(this._port, () => {
-			const addr = this.httpServer.address();
-			if (addr && typeof addr === "object") this._port = addr.port;
-			this.log(`WebSocket server listening on port ${this._port}`);
-		});
+		if (!options.server) {
+			const listening = () => {
+				const addr = this.httpServer.address();
+				if (addr && typeof addr === "object") this._port = addr.port;
+				this.log(`WebSocket server listening on port ${this._port}`);
+			};
+			if (options.host == null) this.httpServer.listen(this._port, listening);
+			else this.httpServer.listen(this._port, options.host, listening);
+		}
 	}
 	get port() {
 		const addr = this.httpServer.address();
@@ -2685,6 +2900,44 @@ var DevtoolsServer = class {
 		} while (cursor);
 		return { errors: aggregator.getErrorGroups() };
 	}
+	/**
+	* Fold WebMCP lifecycle history through the window end into the tool surface
+	* an agent is offered, while counting executions only inside the window.
+	*
+	* Drains every page rather than folding the first one: an inventory built
+	* from a page of results does not fail, it *under-reports* — "2 tools dropped
+	* annotations" when the answer is 6 — and gets more wrong the more traffic
+	* there is, which is backwards for an observability answer.
+	*
+	* The span-name filter is composed here rather than accepted from the client:
+	* this endpoint answers one question, and a caller-supplied predicate could
+	* only narrow it into a wrong answer.
+	*/
+	queryWebMcp(args) {
+		const traces = [];
+		const seenCursors = /* @__PURE__ */ new Set();
+		let cursor;
+		do {
+			const result = this.store.queryTraces({
+				query: "name ^ \"webmcp.\"",
+				window: args.window ? {
+					start: 0,
+					end: args.window.end
+				} : void 0,
+				limit: args.limit,
+				cursor
+			});
+			if (result.errors) return {
+				webmcp: foldWebMcpTools([]),
+				errors_parse: result.errors
+			};
+			traces.push(...result.traces);
+			cursor = result.nextCursor ?? void 0;
+			if (cursor && seenCursors.has(cursor)) break;
+			if (cursor) seenCursors.add(cursor);
+		} while (cursor);
+		return { webmcp: foldWebMcpTools(traces, args.window) };
+	}
 	/** Run a log query against the durable store. */
 	queryLogs(args) {
 		return this.store.queryLogs(args);
@@ -2692,6 +2945,9 @@ var DevtoolsServer = class {
 	listQueryFields(signal) {
 		return this.store.listQueryFields(signal);
 	}
+	pairedAttributeValues(signal, key, pairedKey, limit) {
+		return this.store.pairedAttributeValues(signal, key, pairedKey, limit);
+	}
 	searchAttributes(signal, value, limit) {
 		return this.store.searchAttributes(signal, value, limit);
 	}
@@ -3406,6 +3662,12 @@ function attachDevtoolsRoutes(httpServer, devtools, options = {}) {
 			}
 			const params = new URL(url, "http://localhost").searchParams;
 			const signal = params.get("signal") === "logs" ? "logs" : "traces";
+			const key = params.get("key");
+			const pair = params.get("pair");
+			if (key !== null && pair !== null) {
+				sendJson(res, 200, { pairs: devtools.pairedAttributeValues(signal, key, pair) });
+				return;
+			}
 			sendJson(res, 200, { attributes: devtools.searchAttributes(signal, params.get("value") ?? "") });
 			return;
 		}
@@ -3679,6 +3941,30 @@ function attachDevtoolsRoutes(httpServer, devtools, options = {}) {
 			}
 			return;
 		}
+		if (req.method === "POST" && url === "/api/query/webmcp") {
+			if (!allowSensitiveRequest(req.headers, loopbackOnly)) {
+				sendJson(res, 403, { error: "Forbidden" });
+				return;
+			}
+			try {
+				const body = await readJsonBody(req);
+				const result = devtools.queryWebMcp({
+					window: body.window,
+					limit: body.limit
+				});
+				if (result.errors_parse) {
+					sendJson(res, 400, { errors: result.errors_parse });
+					return;
+				}
+				sendJson(res, 200, { webmcp: result.webmcp });
+			} catch (e) {
+				sendJson(res, 400, {
+					error: "Invalid query request",
+					message: e instanceof Error ? e.message : String(e)
+				});
+			}
+			return;
+		}
 		if (req.method === "GET" && url === "/api/metrics") {
 			if (!allowSensitiveRequest(req.headers, loopbackOnly)) {
 				sendJson(res, 403, { error: "Forbidden" });

package/dist/index.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_http = require('./http-Cqm_MAtc.cjs');
+const require_http = require('./http-CahjEnpE.cjs');
 const require_listen = require('./listen-l09RRHht.cjs');
 const require_server_exporter = require('./server/exporter.cjs');
 const require_server_log_exporter = require('./server/log-exporter.cjs');

package/dist/index.d.cts

@@ -1,9 +1,9 @@
-import { n as SpanAttributes, t as AttributeValue } from "./types-DHDvZnnn.cjs";
-import { a as SpanData, i as LogData, n as ErrorGroup, o as TraceData, t as DevtoolsData } from "./types-B0tjwFqj.cjs";
-import { n as DevtoolsServer, t as DevtoolsSpanExporter } from "./exporter-C4uKgo7l.cjs";
+import { n as SpanAttributes, t as AttributeValue } from "./types-B86Qkqg5.cjs";
+import { a as SpanData, i as LogData, n as ErrorGroup, o as TraceData, t as DevtoolsData } from "./types-C-ORUrT2.cjs";
+import { n as DevtoolsServer, t as DevtoolsSpanExporter } from "./exporter-AkgWRDpc.cjs";
 import { DevtoolsLogExporter } from "./server/log-exporter.cjs";
 import { DevtoolsRemoteExporter } from "./server/remote-exporter.cjs";
-import { t as ErrorAggregator } from "./error-aggregator-DSwUvgFF.cjs";
+import { t as ErrorAggregator } from "./error-aggregator-C0at0wzF.cjs";
 import { Server } from "node:http";
 //#region src/index.d.ts
 interface CreateDevtoolsOptions {

package/dist/index.d.ts

@@ -1,9 +1,9 @@
-import { n as SpanAttributes, t as AttributeValue } from "./types-DHDvZnnn.js";
-import { a as SpanData, i as LogData, n as ErrorGroup, o as TraceData, t as DevtoolsData } from "./types-DM8y4A9Z.js";
-import { n as DevtoolsServer, t as DevtoolsSpanExporter } from "./exporter-BrEcnzoT.js";
+import { n as SpanAttributes, t as AttributeValue } from "./types-B86Qkqg5.js";
+import { a as SpanData, i as LogData, n as ErrorGroup, o as TraceData, t as DevtoolsData } from "./types-BhbHVeiy.js";
+import { n as DevtoolsServer, t as DevtoolsSpanExporter } from "./exporter-yo7lLDIs.js";
 import { DevtoolsLogExporter } from "./server/log-exporter.js";
 import { DevtoolsRemoteExporter } from "./server/remote-exporter.js";
-import { t as ErrorAggregator } from "./error-aggregator-B52JI8jL.js";
+import { t as ErrorAggregator } from "./error-aggregator-C25_JiVI.js";
 import { Server } from "node:http";
 //#region src/index.d.ts
 interface CreateDevtoolsOptions {

package/dist/index.js

@@ -1,4 +1,4 @@
-import { C as ErrorAggregator, g as hostHeaderIsLoopback, l as DevtoolsServer, r as resolveSourceRoot, t as attachDevtoolsRoutes } from "./http-Dbd9TIYU.js";
+import { C as ErrorAggregator, g as hostHeaderIsLoopback, l as DevtoolsServer, r as resolveSourceRoot, t as attachDevtoolsRoutes } from "./http-z8UbJsqk.js";
 import { t as listenLoopbackDualStack } from "./listen-D-lLgfro.js";
 import { DevtoolsSpanExporter } from "./server/exporter.js";
 import { DevtoolsLogExporter } from "./server/log-exporter.js";

package/dist/server/exporter.d.cts

@@ -1,2 +1,2 @@
-import { t as DevtoolsSpanExporter } from "../exporter-C4uKgo7l.cjs";
+import { t as DevtoolsSpanExporter } from "../exporter-AkgWRDpc.cjs";
 export { DevtoolsSpanExporter };

package/dist/server/exporter.d.ts

@@ -1,2 +1,2 @@
-import { t as DevtoolsSpanExporter } from "../exporter-BrEcnzoT.js";
+import { t as DevtoolsSpanExporter } from "../exporter-yo7lLDIs.js";
 export { DevtoolsSpanExporter };

package/dist/server/index.cjs

@@ -1,9 +1,9 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_http = require('../http-Cqm_MAtc.cjs');
+const require_http = require('../http-CahjEnpE.cjs');
 const require_server_exporter = require('./exporter.cjs');
 const require_server_log_exporter = require('./log-exporter.cjs');
 const require_server_remote_exporter = require('./remote-exporter.cjs');
-const require_grpc = require('../grpc-CSWjMRiB.cjs');
+const require_grpc = require('../grpc-CSW1Evnt.cjs');
 
 exports.DEVTOOLS_IDENTITY = require_http.DEVTOOLS_IDENTITY;
 exports.DevtoolsLogExporter = require_server_log_exporter.DevtoolsLogExporter;

package/dist/server/index.d.cts

@@ -1,9 +1,9 @@
-import "../types-DHDvZnnn.cjs";
-import { a as SpanData, i as LogData, n as ErrorGroup, o as TraceData, r as ErrorOccurrence, t as DevtoolsData } from "../types-B0tjwFqj.cjs";
-import { a as DevtoolsStoreOptions, c as QueryLogsArgs, d as QueryTracesArgs, f as QueryTracesResult, i as DevtoolsStore, l as QueryLogsResult, m as TimeWindow, n as DevtoolsServer, o as MetricCatalogEntry, p as SPAN_SCHEMA, r as DevtoolsServerOptions, s as MetricSeries, t as DevtoolsSpanExporter, u as QueryMetricSeriesArgs } from "../exporter-C4uKgo7l.cjs";
+import "../types-B86Qkqg5.cjs";
+import { a as SpanData, i as LogData, n as ErrorGroup, o as TraceData, r as ErrorOccurrence, t as DevtoolsData } from "../types-C-ORUrT2.cjs";
+import { a as DevtoolsStoreOptions, c as QueryLogsArgs, d as QueryTracesArgs, f as QueryTracesResult, i as DevtoolsStore, l as QueryLogsResult, m as TimeWindow, n as DevtoolsServer, o as MetricCatalogEntry, p as SPAN_SCHEMA, r as DevtoolsServerOptions, s as MetricSeries, t as DevtoolsSpanExporter, u as QueryMetricSeriesArgs } from "../exporter-AkgWRDpc.cjs";
 import { DevtoolsLogExporter } from "./log-exporter.cjs";
 import { DevtoolsRemoteExporter, DevtoolsRemoteExporterOptions } from "./remote-exporter.cjs";
-import { t as ErrorAggregator } from "../error-aggregator-DSwUvgFF.cjs";
+import { t as ErrorAggregator } from "../error-aggregator-C0at0wzF.cjs";
 import { AgentRawEvent, OtelMetricRecord } from "autotel-agents";
 import { Server } from "node:http";
 //#region src/server/http.d.ts

package/dist/server/index.d.ts

@@ -1,9 +1,9 @@
-import "../types-DHDvZnnn.js";
-import { a as SpanData, i as LogData, n as ErrorGroup, o as TraceData, r as ErrorOccurrence, t as DevtoolsData } from "../types-DM8y4A9Z.js";
-import { a as DevtoolsStoreOptions, c as QueryLogsArgs, d as QueryTracesArgs, f as QueryTracesResult, i as DevtoolsStore, l as QueryLogsResult, m as TimeWindow, n as DevtoolsServer, o as MetricCatalogEntry, p as SPAN_SCHEMA, r as DevtoolsServerOptions, s as MetricSeries, t as DevtoolsSpanExporter, u as QueryMetricSeriesArgs } from "../exporter-BrEcnzoT.js";
+import "../types-B86Qkqg5.js";
+import { a as SpanData, i as LogData, n as ErrorGroup, o as TraceData, r as ErrorOccurrence, t as DevtoolsData } from "../types-BhbHVeiy.js";
+import { a as DevtoolsStoreOptions, c as QueryLogsArgs, d as QueryTracesArgs, f as QueryTracesResult, i as DevtoolsStore, l as QueryLogsResult, m as TimeWindow, n as DevtoolsServer, o as MetricCatalogEntry, p as SPAN_SCHEMA, r as DevtoolsServerOptions, s as MetricSeries, t as DevtoolsSpanExporter, u as QueryMetricSeriesArgs } from "../exporter-yo7lLDIs.js";
 import { DevtoolsLogExporter } from "./log-exporter.js";
 import { DevtoolsRemoteExporter, DevtoolsRemoteExporterOptions } from "./remote-exporter.js";
-import { t as ErrorAggregator } from "../error-aggregator-B52JI8jL.js";
+import { t as ErrorAggregator } from "../error-aggregator-C25_JiVI.js";
 import { Server } from "node:http";
 import { AgentRawEvent, OtelMetricRecord } from "autotel-agents";
 //#region src/server/http.d.ts

package/dist/server/index.js

@@ -1,7 +1,7 @@
-import { C as ErrorAggregator, S as resolveTelemetryLimits, _ as isLoopbackHostname, a as probePortHolder, b as appendWithLimit, c as decodeOtlpTraceRequest, d as parseOtlpLogs, f as parseOtlpTraces, g as hostHeaderIsLoopback, h as allowSensitiveRequest, i as DEVTOOLS_IDENTITY, l as DevtoolsServer, m as SPAN_SCHEMA, n as createDevtoolsHttpServer, o as decodeOtlpLogsRequest, p as DevtoolsStore, s as decodeOtlpMetricsRequest, t as attachDevtoolsRoutes, u as isProtobufContentType, v as originIsLoopback, x as applyTelemetryLimits, y as appendManyWithLimit } from "../http-Dbd9TIYU.js";
+import { C as ErrorAggregator, S as resolveTelemetryLimits, _ as isLoopbackHostname, a as probePortHolder, b as appendWithLimit, c as decodeOtlpTraceRequest, d as parseOtlpLogs, f as parseOtlpTraces, g as hostHeaderIsLoopback, h as allowSensitiveRequest, i as DEVTOOLS_IDENTITY, l as DevtoolsServer, m as SPAN_SCHEMA, n as createDevtoolsHttpServer, o as decodeOtlpLogsRequest, p as DevtoolsStore, s as decodeOtlpMetricsRequest, t as attachDevtoolsRoutes, u as isProtobufContentType, v as originIsLoopback, x as applyTelemetryLimits, y as appendManyWithLimit } from "../http-z8UbJsqk.js";
 import { DevtoolsSpanExporter } from "./exporter.js";
 import { DevtoolsLogExporter } from "./log-exporter.js";
 import { DevtoolsRemoteExporter } from "./remote-exporter.js";
-import { t as startOtlpGrpcReceiver } from "../grpc-CZEDUYCM.js";
+import { t as startOtlpGrpcReceiver } from "../grpc-D1tt8UPi.js";
 
 export { DEVTOOLS_IDENTITY, DevtoolsLogExporter, DevtoolsRemoteExporter, DevtoolsServer, DevtoolsSpanExporter, DevtoolsStore, ErrorAggregator, SPAN_SCHEMA, allowSensitiveRequest, appendManyWithLimit, appendWithLimit, applyTelemetryLimits, attachDevtoolsRoutes, createDevtoolsHttpServer, decodeOtlpLogsRequest, decodeOtlpMetricsRequest, decodeOtlpTraceRequest, hostHeaderIsLoopback, isLoopbackHostname, isProtobufContentType, originIsLoopback, parseOtlpLogs, parseOtlpTraces, probePortHolder, resolveTelemetryLimits, startOtlpGrpcReceiver };

package/dist/types-B86Qkqg5.d.cts

@@ -0,0 +1,120 @@
+import { AgentSession } from "autotel-agents";
+//#region src/widget/types.d.ts
+/**
+ * What a span attribute holds once it has crossed OTLP. The widget is
+ * browser-safe and does not depend on the OTel API package, so the value type
+ * is named here rather than imported.
+ */
+type AttributeValue = string | number | boolean | null | undefined | Uint8Array | Array<AttributeValue> | {
+  [key: string]: AttributeValue;
+};
+/**
+ * A span's attribute bag as the devtools receives it. Wider than OpenTelemetry's
+ * own `Attributes` on purpose: OTLP's kvlist and array values decode to nested
+ * maps and lists, and the devtools displays whatever actually arrived.
+ */
+type SpanAttributes = Record<string, AttributeValue>;
+interface SpanData {
+  traceId: string;
+  spanId: string;
+  parentSpanId?: string;
+  name: string;
+  kind: 'INTERNAL' | 'SERVER' | 'CLIENT' | 'PRODUCER' | 'CONSUMER';
+  startTime: number;
+  endTime: number;
+  duration: number;
+  attributes: SpanAttributes;
+  status: {
+    code: 'OK' | 'ERROR' | 'UNSET';
+    message?: string;
+  };
+  events?: Array<{
+    name: string;
+    timestamp: number;
+    attributes?: SpanAttributes;
+  }>;
+  links?: Array<{
+    traceId: string;
+    spanId: string;
+    attributes?: SpanAttributes;
+  }>;
+  scope?: {
+    name?: string;
+    version?: string;
+  };
+}
+/**
+ * The WebMCP tool surface, as folded by `server/webmcp-aggregator`.
+ *
+ * A tool is not a span: it is a name whose lifecycle spans a registration, any
+ * number of executions and possibly a withdrawal, and it is only meaningful
+ * within the installation (page load) that registered it.
+ */
+interface WebMcpCall {
+  timestamp: number;
+  durationMs: number;
+  resultBytes: number;
+  resultType?: string;
+  envelope: boolean;
+  substituted: boolean;
+  error: boolean;
+  /** Present only when the app opted into payload capture. Render masked. */
+  input?: string;
+  /** The exact string the agent received. Present only with payload capture. */
+  result?: string;
+  traceId: string;
+  spanId: string;
+}
+interface WebMcpTool {
+  name: string;
+  /** Installation (page load) this record belongs to. */
+  installationId: string;
+  service: string;
+  sessionId?: string;
+  /** False when the tool was only ever seen executing — see the module note. */
+  observedAtRegistration: boolean;
+  /** True while the tool is offered: registered, and not since withdrawn. */
+  offered: boolean;
+  firstSeen: number;
+  lastSeen: number;
+  descriptionLength?: number;
+  hasInputSchema?: boolean;
+  annotationsSent: string[];
+  /** Annotations the browser discarded. Available nowhere else. */
+  annotationsDropped: string[];
+  calls: number;
+  errors: number;
+  /** Executions whose result was an unwrapped MCP `{ content: [...] }` envelope. */
+  envelopeCalls: number;
+  /** Of `resultBytes`, the part that is envelope wrapper rather than content. */
+  envelopeBytes: number;
+  /** Executions where the browser replaced an empty result with its own text. */
+  substitutedCalls: number;
+  /** UTF-8 bytes of result the agent has paid for across every call. */
+  resultBytes: number;
+  medianResultBytes: number;
+  /** The last few executions, newest first. Bounded — this is not a call log. */
+  recentCalls: WebMcpCall[];
+  traceId?: string;
+  spanId?: string;
+}
+interface WebMcpSummary {
+  installations: number;
+  /** Installations that registered nothing — the "instrumented too late" signature. */
+  emptyInstallations: number;
+  toolsOffered: number;
+  toolsWithdrawn: number;
+  calls: number;
+  errors: number;
+  resultBytes: number;
+  /** Bytes that are envelope wrapper rather than content. See `envelopeOverhead`. */
+  envelopeBytes: number;
+  toolsWithDroppedAnnotations: number;
+  toolsWithoutInputSchema: number;
+}
+interface WebMcpInventory {
+  tools: WebMcpTool[];
+  summary: WebMcpSummary;
+}
+//#endregion
+export { WebMcpInventory as i, SpanAttributes as n, SpanData as r, AttributeValue as t };