autotel-devtools 23.0.0 → 24.0.0

package/dist/genai/index.d.cts

@@ -1,4 +1,4 @@
-import { r as SpanData } from "../types-DHDvZnnn.cjs";
+import { r as SpanData } from "../types-B86Qkqg5.cjs";
 //#region src/widget/genai/detect.d.ts
 declare function isGenAiSpan(span: SpanData): boolean;
 //#endregion

package/dist/genai/index.d.ts

@@ -1,4 +1,4 @@
-import { r as SpanData } from "../types-DHDvZnnn.js";
+import { r as SpanData } from "../types-B86Qkqg5.js";
 //#region src/widget/genai/detect.d.ts
 declare function isGenAiSpan(span: SpanData): boolean;
 //#endregion

package/dist/{grpc-CSWjMRiB.cjs → grpc-CSW1Evnt.cjs}

@@ -1,4 +1,4 @@
-const require_http = require('./http-Cqm_MAtc.cjs');
+const require_http = require('./http-CahjEnpE.cjs');
 let _grpc_grpc_js = require("@grpc/grpc-js");
 
 //#region src/server/grpc.ts

package/dist/{grpc-CZEDUYCM.js → grpc-D1tt8UPi.js}

@@ -1,4 +1,4 @@
-import { c as decodeOtlpTraceRequest, o as decodeOtlpLogsRequest, s as decodeOtlpMetricsRequest } from "./http-Dbd9TIYU.js";
+import { c as decodeOtlpTraceRequest, o as decodeOtlpLogsRequest, s as decodeOtlpMetricsRequest } from "./http-z8UbJsqk.js";
 import { Server, ServerCredentials, status } from "@grpc/grpc-js";
 
 //#region src/server/grpc.ts

package/dist/{http-Cqm_MAtc.cjs → http-CahjEnpE.cjs}

@@ -316,6 +316,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 = require_json_fields.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 = require_json_fields.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 = require_json_fields.asString(attrs["webmcp.tool.name"]) ?? require_json_fields.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: require_json_fields.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 ??= require_json_fields.asString(attrs["session.id"]);
+		switch (span.name) {
+			case REGISTER:
+				installations.set(installationKey, true);
+				tool.observedAtRegistration = true;
+				tool.offered = true;
+				tool.descriptionLength = require_json_fields.asNumber(attrs["webmcp.tool.description.length"]);
+				tool.hasInputSchema = require_json_fields.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 = require_json_fields.asNumber(attrs["webmcp.result.bytes"]) ?? 0;
+				tool.resultBytes += bytes;
+				tool.resultSizes.push(bytes);
+				if (require_json_fields.asBoolean(attrs["webmcp.result.envelope"])) {
+					tool.envelopeCalls += 1;
+					tool.envelopeBytes += ENVELOPE_OVERHEAD_BYTES;
+				}
+				if (require_json_fields.asBoolean(attrs["webmcp.result.substituted"])) tool.substitutedCalls += 1;
+				const failed = span.status.code === "ERROR" || (require_json_fields.asBoolean(attrs["webmcp.result.error"]) ?? false) || require_json_fields.asString(attrs["error.type"]) !== void 0;
+				if (failed) tool.errors += 1;
+				tool.recentCalls.push({
+					timestamp: span.startTime,
+					durationMs: span.duration,
+					resultBytes: bytes,
+					resultType: require_json_fields.asString(attrs["webmcp.result.type"]),
+					envelope: require_json_fields.asBoolean(attrs["webmcp.result.envelope"]) ?? false,
+					substituted: require_json_fields.asBoolean(attrs["webmcp.result.substituted"]) ?? false,
+					error: failed,
+					input: require_json_fields.asString(attrs["webmcp.input"]) ?? require_json_fields.asString(attrs["gen_ai.tool.call.arguments"]),
+					result: require_json_fields.asString(attrs["webmcp.result"]) ?? require_json_fields.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;
@@ -1528,6 +1703,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
@@ -2503,11 +2714,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();
@@ -2714,6 +2929,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);
@@ -2721,6 +2974,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);
 	}
@@ -3435,6 +3691,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;
 		}
@@ -3708,6 +3970,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" });