@obsunified/collector 2.0.1

package/src/lib/action-identity.ts

@@ -0,0 +1,106 @@
+import type { JsonValue, StoredSpan } from "@obsunified/types";
+import {
+	ACTION_CAUSED_BY_ID_KEY,
+	ACTION_CONFIDENCE_KEY,
+	ACTION_ID_KEY,
+	ACTION_ID_RE,
+	ACTION_KIND_KEY,
+	ACTION_ROOT_ID_KEY,
+	ActionConfidence,
+	AGENT_RUN_ID_KEY,
+} from "@obsunified/types/constants";
+import { sha256Hex } from "./hash";
+
+export interface ResolvedActionIdentity {
+	actionId: string;
+	rootActionId: string;
+	causedByActionId: string | null;
+	agentRunId: string | null;
+	confidence: ActionConfidence;
+}
+
+export async function deriveActionId(
+	projectId: string,
+	traceId: string,
+	spanId: string,
+): Promise<string> {
+	const input = `${projectId}:${traceId}:${spanId}`;
+	const hash = await sha256Hex(input);
+	const hex = hash.substring(0, 32);
+	let num = BigInt(`0x${hex}`);
+	const alphabet = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+	let encoded = "";
+	for (let i = 0; i < 26; i++) {
+		const remainder = Number(num % 32n);
+		encoded = alphabet[remainder] + encoded;
+		num = num / 32n;
+	}
+	return encoded;
+}
+
+export const asValidActionId = (value: unknown): string | undefined => {
+	if (typeof value !== "string") return undefined;
+	const trimmed = value.trim();
+	return ACTION_ID_RE.test(trimmed) ? trimmed : undefined;
+};
+
+const asConfidence = (value: unknown): ActionConfidence | undefined =>
+	value === ActionConfidence.Explicit || value === ActionConfidence.Fallback
+		? value
+		: undefined;
+
+export async function resolveActionIdentity(
+	span: Pick<StoredSpan, "projectId" | "traceId" | "spanId" | "parentSpanId">,
+	attrs: Record<string, JsonValue>,
+): Promise<ResolvedActionIdentity> {
+	const explicitActionId = asValidActionId(attrs[ACTION_ID_KEY]);
+	const actionId =
+		explicitActionId ??
+		(await deriveActionId(span.projectId, span.traceId, span.spanId));
+	const confidence =
+		asConfidence(attrs[ACTION_CONFIDENCE_KEY]) ??
+		(explicitActionId ? ActionConfidence.Explicit : ActionConfidence.Fallback);
+	const actionKind =
+		typeof attrs[ACTION_KIND_KEY] === "string" ? attrs[ACTION_KIND_KEY] : null;
+
+	const rootActionId =
+		asValidActionId(attrs[ACTION_ROOT_ID_KEY]) ??
+		asValidActionId(attrs[AGENT_RUN_ID_KEY]) ??
+		asValidActionId(attrs["obs.action.agent_run_id"]) ??
+		asValidActionId(attrs["obs.agent_run.id"]) ??
+		(actionKind === "agent.run" || actionKind === "agent"
+			? actionId
+			: await deriveActionId(
+					span.projectId,
+					span.traceId,
+					span.traceId.substring(0, 16),
+				));
+
+	const explicitCausedByActionId = asValidActionId(
+		attrs[ACTION_CAUSED_BY_ID_KEY],
+	);
+	let causedByActionId: string | null;
+	if (explicitCausedByActionId) {
+		causedByActionId = explicitCausedByActionId;
+	} else if (attrs[ACTION_CAUSED_BY_ID_KEY] === null) {
+		causedByActionId = null;
+	} else {
+		causedByActionId = span.parentSpanId
+			? await deriveActionId(span.projectId, span.traceId, span.parentSpanId)
+			: null;
+	}
+
+	const agentRunId =
+		asValidActionId(attrs[AGENT_RUN_ID_KEY]) ??
+		asValidActionId(attrs["obs.action.agent_run_id"]) ??
+		asValidActionId(attrs["obs.agent_run.id"]) ??
+		(actionKind === "agent.run" || actionKind === "agent" ? actionId : null);
+
+	return {
+		actionId,
+		rootActionId,
+		causedByActionId,
+		agentRunId,
+		confidence,
+	};
+}

package/src/lib/actions-store.ts

@@ -0,0 +1,397 @@
+import type {
+	ActionRef,
+	AgentRunRef,
+	ArtifactRef,
+	EvalResultRef,
+	RetrievalEventRef,
+	ToolCallRef,
+} from "./identity-index";
+import {
+	mapAction,
+	mapAgentRun,
+	mapArtifact,
+	mapEvalResult,
+	mapRetrievalEvent,
+	mapToolCall,
+} from "./identity-index/mappers";
+import type { SqlDb } from "./sql-db";
+
+export type ActionRecord = Omit<ActionRef, "projectId"> & {
+	projectId: string;
+};
+
+export type AgentRunRecord = Omit<AgentRunRef, "projectId"> & {
+	projectId: string;
+};
+
+export type ToolCallRecord = Omit<ToolCallRef, "projectId" | "sideEffect"> & {
+	projectId: string;
+	sideEffect: boolean | number;
+};
+
+export type RetrievalEventRecord = Omit<RetrievalEventRef, "projectId"> & {
+	projectId: string;
+};
+
+export type EvalResultRecord = Omit<EvalResultRef, "projectId" | "passed"> & {
+	projectId: string;
+	passed: boolean | number;
+};
+
+export type ArtifactRecord = Omit<ArtifactRef, "projectId"> & {
+	projectId: string;
+};
+
+export class ActionStore {
+	constructor(private readonly db: SqlDb) {}
+
+	async upsertAction(action: ActionRecord): Promise<void> {
+		await this.db
+			.prepare(`
+				INSERT INTO actions (
+					id, project_id, root_action_id, caused_by_action_id, actor_type, actor_id,
+					action_kind, name, status, started_at, ended_at, duration_ms, trace_id,
+					span_id, session_id, interaction_id, user_id, agent_run_id, step_id,
+					tool_call_id, prompt_version, model_name, provider, total_cost_usd,
+					attrs_json
+				) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+				ON CONFLICT(id) DO UPDATE SET
+					project_id = excluded.project_id,
+					root_action_id = excluded.root_action_id,
+					caused_by_action_id = excluded.caused_by_action_id,
+					actor_type = excluded.actor_type,
+					actor_id = excluded.actor_id,
+					action_kind = excluded.action_kind,
+					name = excluded.name,
+					status = excluded.status,
+					started_at = excluded.started_at,
+					ended_at = excluded.ended_at,
+					duration_ms = excluded.duration_ms,
+					trace_id = excluded.trace_id,
+					span_id = excluded.span_id,
+					session_id = excluded.session_id,
+					interaction_id = excluded.interaction_id,
+					user_id = excluded.user_id,
+					agent_run_id = excluded.agent_run_id,
+					step_id = excluded.step_id,
+					tool_call_id = excluded.tool_call_id,
+					prompt_version = excluded.prompt_version,
+					model_name = excluded.model_name,
+					provider = excluded.provider,
+					total_cost_usd = excluded.total_cost_usd,
+					attrs_json = excluded.attrs_json
+			`)
+			.bind(
+				action.id,
+				action.projectId,
+				action.rootActionId,
+				action.causedByActionId,
+				action.actorType,
+				action.actorId,
+				action.actionKind,
+				action.name,
+				action.status,
+				action.startedAt,
+				action.endedAt,
+				action.durationMs,
+				action.traceId,
+				action.spanId,
+				action.sessionId,
+				action.interactionId,
+				action.userId,
+				action.agentRunId,
+				action.stepId,
+				action.toolCallId,
+				action.promptVersion,
+				action.modelName,
+				action.provider,
+				action.totalCostUsd,
+				action.attrsJson,
+			)
+			.run();
+	}
+
+	async upsertAgentRun(run: AgentRunRecord): Promise<void> {
+		await this.db
+			.prepare(`
+				INSERT INTO agent_runs (
+					id, project_id, agent_id, agent_name, agent_version, goal, outcome,
+					autonomy_level, status, error_message, total_cost_usd,
+					total_duration_ms, metadata_json
+				) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+				ON CONFLICT(id) DO UPDATE SET
+					project_id = excluded.project_id,
+					agent_id = excluded.agent_id,
+					agent_name = excluded.agent_name,
+					agent_version = excluded.agent_version,
+					goal = excluded.goal,
+					outcome = excluded.outcome,
+					autonomy_level = excluded.autonomy_level,
+					status = excluded.status,
+					error_message = excluded.error_message,
+					total_cost_usd = excluded.total_cost_usd,
+					total_duration_ms = excluded.total_duration_ms,
+					metadata_json = excluded.metadata_json
+			`)
+			.bind(
+				run.id,
+				run.projectId,
+				run.agentId,
+				run.agentName,
+				run.agentVersion,
+				run.goal,
+				run.outcome,
+				run.autonomyLevel,
+				run.status,
+				run.errorMessage,
+				run.totalCostUsd,
+				run.totalDurationMs,
+				run.metadataJson,
+			)
+			.run();
+	}
+
+	async upsertToolCall(toolCall: ToolCallRecord): Promise<void> {
+		await this.db
+			.prepare(`
+				INSERT INTO tool_calls (
+					id, action_id, project_id, tool_name, args_hash, result_hash,
+					error_type, side_effect, approval_state, args_redacted, result_redacted,
+					mcp_audit_json, mutation_before_json, mutation_after_json,
+					mutation_diff_json, mutation_artifact_id
+				) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+				ON CONFLICT(id) DO UPDATE SET
+					action_id = excluded.action_id,
+					project_id = excluded.project_id,
+					tool_name = excluded.tool_name,
+					args_hash = excluded.args_hash,
+					result_hash = excluded.result_hash,
+					error_type = excluded.error_type,
+					side_effect = excluded.side_effect,
+					approval_state = excluded.approval_state,
+					args_redacted = excluded.args_redacted,
+					result_redacted = excluded.result_redacted,
+					mcp_audit_json = excluded.mcp_audit_json,
+					mutation_before_json = excluded.mutation_before_json,
+					mutation_after_json = excluded.mutation_after_json,
+					mutation_diff_json = excluded.mutation_diff_json,
+					mutation_artifact_id = excluded.mutation_artifact_id
+			`)
+			.bind(
+				toolCall.id,
+				toolCall.actionId,
+				toolCall.projectId,
+				toolCall.toolName,
+				toolCall.argsHash,
+				toolCall.resultHash,
+				toolCall.errorType,
+				toolCall.sideEffect ? 1 : 0,
+				toolCall.approvalState,
+				toolCall.argsRedacted,
+				toolCall.resultRedacted,
+				toolCall.mcpAuditJson,
+				toolCall.mutationBeforeJson,
+				toolCall.mutationAfterJson,
+				toolCall.mutationDiffJson,
+				toolCall.mutationArtifactId,
+			)
+			.run();
+	}
+
+	async upsertRetrievalEvent(event: RetrievalEventRecord): Promise<void> {
+		await this.db
+			.prepare(`
+				INSERT INTO retrieval_events (
+					id, action_id, project_id, retriever_name, query_hash, documents_json,
+					total_results, max_relevance_score, duration_ms
+				) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+				ON CONFLICT(id) DO UPDATE SET
+					action_id = excluded.action_id,
+					project_id = excluded.project_id,
+					retriever_name = excluded.retriever_name,
+					query_hash = excluded.query_hash,
+					documents_json = excluded.documents_json,
+					total_results = excluded.total_results,
+					max_relevance_score = excluded.max_relevance_score,
+					duration_ms = excluded.duration_ms
+			`)
+			.bind(
+				event.id,
+				event.actionId,
+				event.projectId,
+				event.retrieverName,
+				event.queryHash,
+				event.documentsJson,
+				event.totalResults,
+				event.maxRelevanceScore,
+				event.durationMs,
+			)
+			.run();
+	}
+
+	async upsertEvalResult(result: EvalResultRecord): Promise<void> {
+		await this.db
+			.prepare(`
+				INSERT INTO eval_results (
+					id, action_id, project_id, evaluator_name, evaluator_version, score,
+					passed, reasoning, rubric_json
+				) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+				ON CONFLICT(id) DO UPDATE SET
+					action_id = excluded.action_id,
+					project_id = excluded.project_id,
+					evaluator_name = excluded.evaluator_name,
+					evaluator_version = excluded.evaluator_version,
+					score = excluded.score,
+					passed = excluded.passed,
+					reasoning = excluded.reasoning,
+					rubric_json = excluded.rubric_json
+			`)
+			.bind(
+				result.id,
+				result.actionId,
+				result.projectId,
+				result.evaluatorName,
+				result.evaluatorVersion,
+				result.score,
+				result.passed ? 1 : 0,
+				result.reasoning,
+				result.rubricJson,
+			)
+			.run();
+	}
+
+	async upsertArtifact(artifact: ArtifactRecord): Promise<void> {
+		await this.db
+			.prepare(`
+				INSERT INTO artifacts (
+					id, action_id, project_id, artifact_name, artifact_type, storage_ref,
+					size_bytes, sha256_hash, content_preview
+				) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+				ON CONFLICT(id) DO UPDATE SET
+					action_id = excluded.action_id,
+					project_id = excluded.project_id,
+					artifact_name = excluded.artifact_name,
+					artifact_type = excluded.artifact_type,
+					storage_ref = excluded.storage_ref,
+					size_bytes = excluded.size_bytes,
+					sha256_hash = excluded.sha256_hash,
+					content_preview = excluded.content_preview
+			`)
+			.bind(
+				artifact.id,
+				artifact.actionId,
+				artifact.projectId,
+				artifact.artifactName,
+				artifact.artifactType,
+				artifact.storageRef,
+				artifact.sizeBytes,
+				artifact.sha256Hash,
+				artifact.contentPreview,
+			)
+			.run();
+	}
+
+	async getAction(
+		projectId: string,
+		actionId: string,
+	): Promise<ActionRef | null> {
+		const row = await this.db
+			.prepare(`SELECT * FROM actions WHERE project_id = ? AND id = ? LIMIT 1`)
+			.bind(projectId, actionId)
+			.first<Parameters<typeof mapAction>[0]>();
+		return row ? mapAction(row) : null;
+	}
+
+	async listActionsByRoot(
+		projectId: string,
+		rootActionId: string,
+		limit = 100,
+	): Promise<ActionRef[]> {
+		const rows = await this.db
+			.prepare(
+				`SELECT * FROM actions
+					WHERE project_id = ? AND root_action_id = ?
+					ORDER BY started_at ASC LIMIT ?`,
+			)
+			.bind(projectId, rootActionId, limit)
+			.all<Parameters<typeof mapAction>[0]>();
+		return rows.results.map(mapAction);
+	}
+
+	async getAgentRun(
+		projectId: string,
+		agentRunId: string,
+	): Promise<AgentRunRef | null> {
+		const row = await this.db
+			.prepare(
+				`SELECT * FROM agent_runs WHERE project_id = ? AND id = ? LIMIT 1`,
+			)
+			.bind(projectId, agentRunId)
+			.first<Parameters<typeof mapAgentRun>[0]>();
+		return row ? mapAgentRun(row) : null;
+	}
+
+	async listToolCallsByAction(
+		projectId: string,
+		actionId: string,
+		limit = 100,
+	): Promise<ToolCallRef[]> {
+		const rows = await this.db
+			.prepare(
+				`SELECT * FROM tool_calls
+					WHERE project_id = ? AND action_id = ?
+					LIMIT ?`,
+			)
+			.bind(projectId, actionId, limit)
+			.all<Parameters<typeof mapToolCall>[0]>();
+		return rows.results.map(mapToolCall);
+	}
+
+	async listRetrievalEventsByAction(
+		projectId: string,
+		actionId: string,
+		limit = 100,
+	): Promise<RetrievalEventRef[]> {
+		const rows = await this.db
+			.prepare(
+				`SELECT * FROM retrieval_events
+					WHERE project_id = ? AND action_id = ?
+					LIMIT ?`,
+			)
+			.bind(projectId, actionId, limit)
+			.all<Parameters<typeof mapRetrievalEvent>[0]>();
+		return rows.results.map(mapRetrievalEvent);
+	}
+
+	async listEvalResultsByAction(
+		projectId: string,
+		actionId: string,
+		limit = 100,
+	): Promise<EvalResultRef[]> {
+		const rows = await this.db
+			.prepare(
+				`SELECT * FROM eval_results
+					WHERE project_id = ? AND action_id = ?
+					LIMIT ?`,
+			)
+			.bind(projectId, actionId, limit)
+			.all<Parameters<typeof mapEvalResult>[0]>();
+		return rows.results.map(mapEvalResult);
+	}
+
+	async listArtifactsByAction(
+		projectId: string,
+		actionId: string,
+		limit = 100,
+	): Promise<ArtifactRef[]> {
+		const rows = await this.db
+			.prepare(
+				`SELECT * FROM artifacts
+					WHERE project_id = ? AND action_id = ?
+					LIMIT ?`,
+			)
+			.bind(projectId, actionId, limit)
+			.all<Parameters<typeof mapArtifact>[0]>();
+		return rows.results.map(mapArtifact);
+	}
+}

package/src/lib/ai-pricing.ts

@@ -0,0 +1,80 @@
+/**
+ * Vendor pricing table for computing llm.cost.total_usd from token counts
+ * when a span didn't report cost directly. Conservative — only covers the
+ * models we see most often; unknown models get $0 and we log once per model.
+ *
+ * Prices are USD per 1M tokens. Keep in sync with vendor rate cards.
+ * Values as of mid-2026; when stale, bump and add a migration note.
+ */
+
+export interface ModelPricing {
+	inputPer1M: number;
+	outputPer1M: number;
+}
+
+const PRICING: Record<string, ModelPricing> = {
+	// OpenAI
+	"gpt-4o": { inputPer1M: 2.5, outputPer1M: 10 },
+	"gpt-4o-mini": { inputPer1M: 0.15, outputPer1M: 0.6 },
+	"gpt-4-turbo": { inputPer1M: 10, outputPer1M: 30 },
+	"gpt-4": { inputPer1M: 30, outputPer1M: 60 },
+	"gpt-3.5-turbo": { inputPer1M: 0.5, outputPer1M: 1.5 },
+	o1: { inputPer1M: 15, outputPer1M: 60 },
+	"o1-mini": { inputPer1M: 3, outputPer1M: 12 },
+
+	// Anthropic
+	"claude-3-5-sonnet": { inputPer1M: 3, outputPer1M: 15 },
+	"claude-3-5-haiku": { inputPer1M: 0.8, outputPer1M: 4 },
+	"claude-3-opus": { inputPer1M: 15, outputPer1M: 75 },
+	"claude-3-sonnet": { inputPer1M: 3, outputPer1M: 15 },
+	"claude-3-haiku": { inputPer1M: 0.25, outputPer1M: 1.25 },
+	"claude-opus-4": { inputPer1M: 15, outputPer1M: 75 },
+	"claude-sonnet-4": { inputPer1M: 3, outputPer1M: 15 },
+
+	// Google
+	"gemini-1.5-pro": { inputPer1M: 1.25, outputPer1M: 5 },
+	"gemini-1.5-flash": { inputPer1M: 0.075, outputPer1M: 0.3 },
+	"gemini-2.0-flash": { inputPer1M: 0.1, outputPer1M: 0.4 },
+};
+
+// Resolve a model identifier to its pricing by longest-prefix match so
+// `gpt-4o-2024-11-20` hits `gpt-4o`, `claude-3-5-sonnet-20240620` hits
+// `claude-3-5-sonnet`, etc.
+const lookupCache = new Map<string, ModelPricing | null>();
+
+export function getModelPricing(
+	model: string | null | undefined,
+): ModelPricing | null {
+	if (!model) return null;
+	const normalized = model.toLowerCase();
+	const cached = lookupCache.get(normalized);
+	if (cached !== undefined) return cached;
+
+	let best: { key: string; pricing: ModelPricing } | null = null;
+	for (const [key, pricing] of Object.entries(PRICING)) {
+		const matchesModel = normalized === key || normalized.startsWith(`${key}-`);
+		if (matchesModel && (!best || key.length > best.key.length)) {
+			best = { key, pricing };
+		}
+	}
+	const result = best?.pricing ?? null;
+	lookupCache.set(normalized, result);
+	return result;
+}
+
+/**
+ * Compute USD cost from token counts using the pricing table. Returns null
+ * when the model is unknown — caller should fall back to the cost attribute
+ * on the span (if any) rather than reporting $0.
+ */
+export function computeCost(
+	model: string | null | undefined,
+	promptTokens: number | null | undefined,
+	completionTokens: number | null | undefined,
+): number | null {
+	const pricing = getModelPricing(model);
+	if (!pricing) return null;
+	const input = ((promptTokens ?? 0) * pricing.inputPer1M) / 1_000_000;
+	const output = ((completionTokens ?? 0) * pricing.outputPer1M) / 1_000_000;
+	return input + output;
+}