autotel-agents 0.1.0

package/dist/index.js

@@ -0,0 +1,676 @@
+//#region src/attrs.ts
+function str(attrs, ...keys) {
+	for (const key of keys) {
+		const value = attrs[key];
+		if (typeof value === "string" && value.length > 0) return value;
+		if (typeof value === "number" || typeof value === "boolean") return String(value);
+	}
+}
+function num(attrs, ...keys) {
+	for (const key of keys) {
+		const value = attrs[key];
+		if (typeof value === "number" && Number.isFinite(value)) return value;
+		if (typeof value === "string") {
+			const parsed = Number(value);
+			if (Number.isFinite(parsed) && value.trim() !== "") return parsed;
+		}
+	}
+}
+function bool(attrs, ...keys) {
+	for (const key of keys) {
+		const value = attrs[key];
+		if (typeof value === "boolean") return value;
+		if (typeof value === "string") {
+			if (value === "true") return true;
+			if (value === "false") return false;
+		}
+	}
+}
+
+//#endregion
+//#region src/cost.ts
+/**
+* Fallback cost estimation. Reported cost (`cost_usd` on `api_request`) always
+* wins — Claude Code computes it cache-accurately. This table is ONLY used when
+* an agent reports tokens but not cost (e.g. a future agent, or a misconfigured
+* run). Estimated values are badged `estimated` in the UI.
+*
+* Prices are USD per 1,000,000 tokens. Matched by substring so model ids like
+* `claude-sonnet-4-6` or `claude-3-5-sonnet-20241022` resolve to a family rate.
+* Keep deliberately small — this is a safety net, not a billing source.
+*/
+const PRICES = [
+	[
+		"claude-opus-4",
+		15,
+		75
+	],
+	[
+		"claude-sonnet-4",
+		3,
+		15
+	],
+	[
+		"claude-haiku-4",
+		.8,
+		4
+	],
+	[
+		"claude-3-5-sonnet",
+		3,
+		15
+	],
+	[
+		"claude-3-5-haiku",
+		.8,
+		4
+	],
+	[
+		"claude-3-opus",
+		15,
+		75
+	],
+	[
+		"claude-3-haiku",
+		.25,
+		1.25
+	],
+	[
+		"opus",
+		15,
+		75
+	],
+	[
+		"sonnet",
+		3,
+		15
+	],
+	[
+		"haiku",
+		.8,
+		4
+	]
+];
+function estimateCostUsd(model, inputTokens, outputTokens) {
+	if (!model) return void 0;
+	const lower = model.toLowerCase();
+	const row = PRICES.find(([match]) => lower.includes(match));
+	if (!row) return void 0;
+	const [, inputRate, outputRate] = row;
+	return (inputTokens ?? 0) / 1e6 * inputRate + (outputTokens ?? 0) / 1e6 * outputRate;
+}
+
+//#endregion
+//#region src/identity.ts
+function mergeAttrs(...sources) {
+	return Object.assign({}, ...sources);
+}
+/** Pull the common identity attributes shared by every signal in a session. */
+function readIdentity(attrs) {
+	return {
+		user: str(attrs, "user.id", "user.account_uuid", "user.email"),
+		organization: str(attrs, "organization.id"),
+		terminal: str(attrs, "terminal.type"),
+		appVersion: str(attrs, "app.version"),
+		model: str(attrs, "model")
+	};
+}
+
+//#endregion
+//#region src/mcp.ts
+const MCP_PREFIX = "mcp__";
+function parseToolName(name) {
+	if (!name.startsWith(MCP_PREFIX)) return {
+		name,
+		isMcp: false
+	};
+	const rest = name.slice(5);
+	const sep = rest.indexOf("__");
+	if (sep === -1) return {
+		name,
+		isMcp: true,
+		mcpServer: rest || void 0
+	};
+	const server = rest.slice(0, sep);
+	const tool = rest.slice(sep + 2);
+	return {
+		name,
+		isMcp: true,
+		mcpServer: server || void 0,
+		mcpTool: tool || void 0
+	};
+}
+function isMcpTool(name) {
+	return name.startsWith(MCP_PREFIX);
+}
+
+//#endregion
+//#region src/tool-taxonomy.ts
+/**
+* Tool taxonomy. Claude Code reports every action the model takes as a tool
+* call (`tool_name` on `tool_result` / `tool_decision`), so the *kind* of work
+* an agent is doing is derivable from the name:
+*
+*   - sub-agents are the `Task` tool
+*   - skills are the `Skill` tool
+*   - MCP tools are `mcp__<server>__<tool>`
+*   - the rest are built-in file / shell / search / web / todo tools
+*
+* CC's native telemetry does NOT include tool *arguments*, so the specific
+* sub-agent type or skill name usually isn't present — we read them defensively
+* in case a future agent version (or another agent) adds them, and otherwise
+* fall back to the category count.
+*/
+const TOOL_CATEGORIES = [
+	"file",
+	"shell",
+	"search",
+	"web",
+	"todo",
+	"subagent",
+	"skill",
+	"mcp",
+	"other"
+];
+const BUILTIN = {
+	read: "file",
+	edit: "file",
+	write: "file",
+	multiedit: "file",
+	notebookedit: "file",
+	bash: "shell",
+	bashoutput: "shell",
+	killshell: "shell",
+	killbash: "shell",
+	grep: "search",
+	glob: "search",
+	ls: "search",
+	webfetch: "web",
+	websearch: "web",
+	todowrite: "todo",
+	task: "subagent",
+	agent: "subagent",
+	skill: "skill"
+};
+function classifyTool(name) {
+	if (isMcpTool(name)) return "mcp";
+	return BUILTIN[name.toLowerCase()] ?? "other";
+}
+/** Sub-agent type, when the agent happens to emit it (defensive — often absent). */
+function readSubAgentType(attributes) {
+	return str(attributes, "subagent_type", "agent_type", "subagent.type");
+}
+/** Skill name, when present (defensive — often absent). */
+function readSkillName(attributes) {
+	return str(attributes, "skill", "skill_name", "skill.name");
+}
+
+//#endregion
+//#region src/adapters/prefix-adapter.ts
+/**
+* Factory for "Claude-Code-shaped" agents. Claude Code, opencode and (soon)
+* Codex emit the *same* instrument and event names under different prefixes and
+* instrumentation scopes — opencode literally mirrors Claude Code's contract
+* with an `opencode.` prefix. So one parameterized adapter covers them all, and
+* a new agent is `createPrefixAdapter({ kind, prefix, scopeHint })`.
+*/
+const EVENT_SUFFIXES = {
+	user_prompt: "user_prompt",
+	api_request: "api_request",
+	api_error: "api_error",
+	tool_result: "tool_result",
+	tool_decision: "tool_decision"
+};
+/** Compose a full ToolRef: MCP split + category + (defensive) sub-agent/skill id. */
+function buildToolRef(name, attrs) {
+	const category = classifyTool(name);
+	const ref = {
+		...parseToolName(name),
+		category
+	};
+	if (category === "subagent") {
+		const subAgentType = readSubAgentType(attrs);
+		if (subAgentType) ref.subAgentType = subAgentType;
+	} else if (category === "skill") {
+		const skillName = readSkillName(attrs);
+		if (skillName) ref.skillName = skillName;
+	}
+	return ref;
+}
+const METRIC_SUFFIXES = {
+	"lines_of_code.count": "lines_of_code",
+	"commit.count": "commit",
+	"pull_request.count": "pull_request",
+	"active_time.total": "active_time"
+};
+function createPrefixAdapter(config) {
+	const { kind, prefix, scopeHint, serviceHint } = config;
+	const scopeMatches = (scopeName) => typeof scopeName === "string" && scopeName.includes(scopeHint);
+	const serviceMatches = (resource) => {
+		const service = str(resource, "service.name");
+		return service !== void 0 && service.includes(serviceHint);
+	};
+	/** Suffix after the agent prefix, e.g. `"claude_code.api_request"` → `"api_request"`. */
+	const suffixOf = (name) => name.startsWith(prefix) ? name.slice(prefix.length) : name;
+	return {
+		kind,
+		matchesMetric(record) {
+			return record.name.startsWith(prefix) || scopeMatches(record.scope?.name) || serviceMatches(record.resource);
+		},
+		matchesEvent(record) {
+			return record.eventName.startsWith(prefix) || scopeMatches(record.scope?.name) || serviceMatches(record.resource);
+		},
+		normalizeEvent(record) {
+			const attrs = mergeAttrs(record.resource, record.attributes);
+			const rawName = suffixOf(record.eventName) || str(attrs, "event.name") || record.eventName;
+			const type = EVENT_SUFFIXES[rawName] ?? "other";
+			const sessionId = str(attrs, "session.id");
+			if (!sessionId) return null;
+			const event = {
+				id: `${sessionId}:0`,
+				sessionId,
+				agent: kind,
+				type,
+				rawEventName: rawName,
+				timestamp: record.timestamp,
+				model: str(attrs, "model"),
+				attributes: record.attributes
+			};
+			switch (type) {
+				case "api_request": {
+					event.inputTokens = num(attrs, "input_tokens");
+					event.outputTokens = num(attrs, "output_tokens");
+					event.cacheReadTokens = num(attrs, "cache_read_tokens");
+					event.cacheCreationTokens = num(attrs, "cache_creation_tokens");
+					event.durationMs = num(attrs, "duration_ms");
+					const reported = num(attrs, "cost_usd", "cost");
+					if (reported === void 0) {
+						const estimated = estimateCostUsd(event.model, event.inputTokens, event.outputTokens);
+						if (estimated !== void 0) {
+							event.costUsd = estimated;
+							event.costSource = "estimated";
+						}
+					} else {
+						event.costUsd = reported;
+						event.costSource = "reported";
+					}
+					break;
+				}
+				case "api_error":
+					event.errorMessage = str(attrs, "error", "error.message", "message");
+					event.statusCode = num(attrs, "status_code", "http.status_code");
+					event.durationMs = num(attrs, "duration_ms");
+					break;
+				case "tool_result": {
+					const toolName = str(attrs, "tool_name", "name", "tool");
+					if (toolName) event.tool = buildToolRef(toolName, attrs);
+					event.success = bool(attrs, "success");
+					event.durationMs = num(attrs, "duration_ms");
+					const decision = str(attrs, "decision");
+					if (decision === "accept" || decision === "reject") event.decision = decision;
+					break;
+				}
+				case "tool_decision": {
+					const toolName = str(attrs, "tool_name", "name", "tool");
+					if (toolName) event.tool = buildToolRef(toolName, attrs);
+					const decision = str(attrs, "decision");
+					if (decision === "accept" || decision === "reject") event.decision = decision;
+					break;
+				}
+				case "user_prompt": {
+					event.promptLength = num(attrs, "prompt_length", "prompt.length");
+					const text = str(attrs, "prompt");
+					if (text) event.promptText = text;
+					break;
+				}
+				default: break;
+			}
+			return event;
+		},
+		normalizeMetric(record) {
+			const kindOfMetric = METRIC_SUFFIXES[suffixOf(record.name)] ?? "other";
+			return record.dataPoints.map((point) => {
+				const attrs = mergeAttrs(record.resource, point.attributes);
+				return {
+					agent: kind,
+					sessionId: str(attrs, "session.id"),
+					identity: readIdentity(attrs),
+					kind: kindOfMetric,
+					value: point.value,
+					temporality: record.temporality,
+					timestamp: point.timestamp,
+					attributes: point.attributes
+				};
+			});
+		}
+	};
+}
+
+//#endregion
+//#region src/adapters/claude-code.ts
+/**
+* Claude Code: metrics/events prefixed `claude_code.*`, emitted under the
+* `com.anthropic.claude_code` instrumentation scope.
+* Contract: https://code.claude.com/docs/en/monitoring-usage
+*/
+const claudeCodeAdapter = createPrefixAdapter({
+	kind: "claude-code",
+	prefix: "claude_code.",
+	scopeHint: "claude_code",
+	serviceHint: "claude-code"
+});
+
+//#endregion
+//#region src/adapters/opencode.ts
+/**
+* opencode: the opencode-plugin-otel project mirrors Claude Code's exact
+* instrument and event names under an `opencode.*` prefix and the `com.opencode`
+* scope. Same shape → same factory.
+*/
+const opencodeAdapter = createPrefixAdapter({
+	kind: "opencode",
+	prefix: "opencode.",
+	scopeHint: "opencode",
+	serviceHint: "opencode"
+});
+
+//#endregion
+//#region src/adapters/registry.ts
+/**
+* Ordered adapter registry. First match claims the record. Claude Code is most
+* specific (dedicated scope), so it leads. Add Codex here when its contract
+* lands — one line, no other changes.
+*/
+const adapters = [claudeCodeAdapter, opencodeAdapter];
+function detectAdapterForMetric(record) {
+	return adapters.find((adapter) => adapter.matchesMetric(record));
+}
+function detectAdapterForEvent(record) {
+	return adapters.find((adapter) => adapter.matchesEvent(record));
+}
+/** True if any adapter recognizes this metric — used for zero-config "agent detected" toasts. */
+function isAgentMetric(record) {
+	return detectAdapterForMetric(record) !== void 0;
+}
+/** True if any adapter recognizes this log event. */
+function isAgentEvent(record) {
+	return detectAdapterForEvent(record) !== void 0;
+}
+
+//#endregion
+//#region src/reduce.ts
+/**
+* Session reducers. These are PURE (no I/O, no node:*) but stateful over a
+* caller-owned `Map`, so the devtools server can keep one canonical store and
+* broadcast finished `AgentSession` objects to the widget.
+*
+* Invariants:
+*  - Rollups are kept forever; the raw `timeline` is ring-buffered (`timelineLimit`).
+*  - Cost/token totals come from `api_request` EVENTS only. `token.usage` and
+*    `cost.usage` METRICS are recognized but deliberately not summed, so the two
+*    representations of the same fact never double-count.
+*/
+const DEFAULT_TIMELINE_LIMIT = 500;
+function emptyToolCategories() {
+	const out = {};
+	for (const category of TOOL_CATEGORIES) out[category] = 0;
+	return out;
+}
+function emptyRollup() {
+	return {
+		costUsd: 0,
+		costReportedUsd: 0,
+		costEstimatedUsd: 0,
+		inputTokens: 0,
+		outputTokens: 0,
+		cacheReadTokens: 0,
+		cacheCreationTokens: 0,
+		apiRequests: 0,
+		apiErrors: 0,
+		prompts: 0,
+		toolCalls: 0,
+		accepted: 0,
+		rejected: 0,
+		linesAdded: 0,
+		linesRemoved: 0,
+		commits: 0,
+		pullRequests: 0,
+		activeTimeSeconds: 0,
+		models: {},
+		tools: {},
+		toolCategories: emptyToolCategories(),
+		subAgents: {},
+		skills: {}
+	};
+}
+function createSession(id, agent, timestamp) {
+	return {
+		id,
+		agent,
+		firstSeen: timestamp,
+		lastSeen: timestamp,
+		eventCount: 0,
+		metricState: {},
+		rollup: emptyRollup(),
+		timeline: []
+	};
+}
+function getOrCreate(store, id, agent, timestamp) {
+	let session = store.get(id);
+	if (!session) {
+		session = createSession(id, agent, timestamp);
+		store.set(id, session);
+	}
+	return session;
+}
+function applyIdentity(session, identity) {
+	if (!session.user && identity.user) session.user = identity.user;
+	if (!session.organization && identity.organization) session.organization = identity.organization;
+	if (!session.terminal && identity.terminal) session.terminal = identity.terminal;
+	if (!session.appVersion && identity.appVersion) session.appVersion = identity.appVersion;
+}
+function touch(session, timestamp) {
+	if (timestamp < session.firstSeen) session.firstSeen = timestamp;
+	if (timestamp > session.lastSeen) session.lastSeen = timestamp;
+}
+function bumpTool(rollup, event) {
+	const ref = event.tool;
+	const existing = rollup.tools[ref.name] ?? {
+		name: ref.name,
+		category: ref.category,
+		isMcp: ref.isMcp,
+		mcpServer: ref.mcpServer,
+		count: 0,
+		accepted: 0,
+		rejected: 0,
+		failures: 0,
+		totalDurationMs: 0
+	};
+	rollup.tools[ref.name] = existing;
+	return existing;
+}
+/** Count a tool against its category and (for sub-agents/skills) its named bucket. */
+function tallyToolKind(rollup, event) {
+	const ref = event.tool;
+	if (!ref) return;
+	rollup.toolCategories[ref.category] += 1;
+	if (ref.category === "subagent") {
+		const key = ref.subAgentType ?? "subagent";
+		rollup.subAgents[key] = (rollup.subAgents[key] ?? 0) + 1;
+	} else if (ref.category === "skill") {
+		const key = ref.skillName ?? "skill";
+		rollup.skills[key] = (rollup.skills[key] ?? 0) + 1;
+	}
+}
+/** Fold a normalized event into a session rollup + timeline. Returns the session. */
+function foldEvent(session, event, timelineLimit = 500) {
+	session.eventCount += 1;
+	event.id = `${session.id}:${session.eventCount}`;
+	touch(session, event.timestamp);
+	const { rollup } = session;
+	switch (event.type) {
+		case "api_request":
+			rollup.apiRequests += 1;
+			rollup.inputTokens += event.inputTokens ?? 0;
+			rollup.outputTokens += event.outputTokens ?? 0;
+			rollup.cacheReadTokens += event.cacheReadTokens ?? 0;
+			rollup.cacheCreationTokens += event.cacheCreationTokens ?? 0;
+			if (event.costUsd !== void 0) {
+				rollup.costUsd += event.costUsd;
+				if (event.costSource === "estimated") rollup.costEstimatedUsd += event.costUsd;
+				else rollup.costReportedUsd += event.costUsd;
+			}
+			if (event.model) rollup.models[event.model] = (rollup.models[event.model] ?? 0) + 1;
+			break;
+		case "api_error":
+			rollup.apiErrors += 1;
+			break;
+		case "user_prompt":
+			rollup.prompts += 1;
+			break;
+		case "tool_result":
+			rollup.toolCalls += 1;
+			if (event.tool) {
+				const usage = bumpTool(rollup, event);
+				usage.count += 1;
+				usage.totalDurationMs += event.durationMs ?? 0;
+				if (event.success === false) usage.failures += 1;
+				tallyToolKind(rollup, event);
+			}
+			break;
+		case "tool_decision":
+			if (event.decision === "accept") rollup.accepted += 1;
+			if (event.decision === "reject") rollup.rejected += 1;
+			if (event.tool) {
+				const usage = bumpTool(rollup, event);
+				if (event.decision === "accept") usage.accepted += 1;
+				if (event.decision === "reject") usage.rejected += 1;
+			}
+			break;
+		default: break;
+	}
+	session.timeline.push(event);
+	if (session.timeline.length > timelineLimit) session.timeline.splice(0, session.timeline.length - timelineLimit);
+	return session;
+}
+/**
+* The amount to add to a running total for one metric data point.
+*
+* `delta` points already carry the per-interval change, so they're added as-is.
+* `cumulative` points carry an absolute running total per series, so we add the
+* difference from the last value we saw for that series — otherwise re-exporting
+* `lines_of_code.count = 42` every interval would inflate the total without end.
+* A drop (counter reset / new process) is treated as a fresh delta.
+*/
+function counterDelta(session, seriesKey, signal) {
+	if (signal.temporality !== "cumulative") return signal.value;
+	const last = session.metricState[seriesKey] ?? 0;
+	session.metricState[seriesKey] = signal.value;
+	return signal.value >= last ? signal.value - last : signal.value;
+}
+/** Stable per-series key: a cumulative counter is one series per attribute set. */
+function seriesKey(signal) {
+	const attrs = Object.entries(signal.attributes).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${k}=${String(v)}`).join(",");
+	return `${signal.kind}|${attrs}`;
+}
+/** Fold a metric-only signal (lines, commits, PRs, active time) into the rollup. */
+function foldMetricSignal(session, signal) {
+	touch(session, signal.timestamp);
+	applyIdentity(session, signal.identity);
+	const { rollup } = session;
+	const value = counterDelta(session, seriesKey(signal), signal);
+	switch (signal.kind) {
+		case "lines_of_code": {
+			const type = String(signal.attributes["type"] ?? "").toLowerCase();
+			if (type.includes("remov") || type.includes("delet")) rollup.linesRemoved += value;
+			else rollup.linesAdded += value;
+			break;
+		}
+		case "commit":
+			rollup.commits += value;
+			break;
+		case "pull_request":
+			rollup.pullRequests += value;
+			break;
+		case "active_time":
+			rollup.activeTimeSeconds += value;
+			break;
+		default: break;
+	}
+}
+/**
+* Ingest a decoded OTLP log record. No-op (returns null) if no adapter claims it
+* or the record lacks a session id.
+*/
+function ingestEventRecord(store, record, options = {}) {
+	const adapter = detectAdapterForEvent(record);
+	if (!adapter) return null;
+	const event = adapter.normalizeEvent(record);
+	if (!event) return null;
+	const session = getOrCreate(store, event.sessionId, adapter.kind, event.timestamp);
+	applyIdentity(session, readIdentity(mergeAttrs(record.resource, record.attributes)));
+	return foldEvent(session, event, options.timelineLimit ?? 500);
+}
+/** Ingest a decoded OTLP metric. Returns sessions touched (may be several). */
+function ingestMetricRecord(store, record) {
+	const adapter = detectAdapterForMetric(record);
+	if (!adapter) return [];
+	const touched = /* @__PURE__ */ new Map();
+	for (const signal of adapter.normalizeMetric(record)) {
+		if (!signal.sessionId) continue;
+		const session = getOrCreate(store, signal.sessionId, adapter.kind, signal.timestamp);
+		foldMetricSignal(session, signal);
+		touched.set(session.id, session);
+	}
+	return [...touched.values()];
+}
+/** Batch-ingest decoded OTLP log records. */
+function ingestAgentEvents(store, records, options = {}) {
+	for (const record of records) ingestEventRecord(store, record, options);
+}
+/** Batch-ingest decoded OTLP metric records. */
+function ingestAgentMetrics(store, records) {
+	for (const record of records) ingestMetricRecord(store, record);
+}
+function summarizeSessions(sessions) {
+	const agg = {
+		sessions: 0,
+		costUsd: 0,
+		inputTokens: 0,
+		outputTokens: 0,
+		apiRequests: 0,
+		apiErrors: 0,
+		accepted: 0,
+		rejected: 0,
+		models: {},
+		tools: {},
+		toolCategories: emptyToolCategories(),
+		mcpServers: {},
+		subAgents: {},
+		skills: {}
+	};
+	for (const session of sessions) {
+		agg.sessions += 1;
+		const { rollup } = session;
+		agg.costUsd += rollup.costUsd;
+		agg.inputTokens += rollup.inputTokens;
+		agg.outputTokens += rollup.outputTokens;
+		agg.apiRequests += rollup.apiRequests;
+		agg.apiErrors += rollup.apiErrors;
+		agg.accepted += rollup.accepted;
+		agg.rejected += rollup.rejected;
+		for (const [model, count] of Object.entries(rollup.models)) agg.models[model] = (agg.models[model] ?? 0) + count;
+		for (const usage of Object.values(rollup.tools)) {
+			agg.tools[usage.name] = (agg.tools[usage.name] ?? 0) + usage.count;
+			if (usage.isMcp && usage.mcpServer) agg.mcpServers[usage.mcpServer] = (agg.mcpServers[usage.mcpServer] ?? 0) + usage.count;
+		}
+		for (const category of TOOL_CATEGORIES) agg.toolCategories[category] += rollup.toolCategories[category];
+		for (const [type, count] of Object.entries(rollup.subAgents)) agg.subAgents[type] = (agg.subAgents[type] ?? 0) + count;
+		for (const [name, count] of Object.entries(rollup.skills)) agg.skills[name] = (agg.skills[name] ?? 0) + count;
+	}
+	return agg;
+}
+
+//#endregion
+export { DEFAULT_TIMELINE_LIMIT, TOOL_CATEGORIES, adapters, classifyTool, claudeCodeAdapter, createPrefixAdapter, detectAdapterForEvent, detectAdapterForMetric, estimateCostUsd, foldEvent, foldMetricSignal, ingestAgentEvents, ingestAgentMetrics, ingestEventRecord, ingestMetricRecord, isAgentEvent, isAgentMetric, isMcpTool, mergeAttrs, opencodeAdapter, parseToolName, readIdentity, readSkillName, readSubAgentType, summarizeSessions };
+//# sourceMappingURL=index.js.map