@yagni-app/code 1.0.6 → 1.0.7

package/dist/extension/telemetry/tracker.d.ts

@@ -0,0 +1,131 @@
+/**
+ * Session telemetry tracker: turns pi's lifecycle into spans, metrics, and
+ * log events. Pure with respect to pi — `register.ts` feeds it events, tests
+ * feed it directly — and it only ever talks to the OTel API (tracer, meter,
+ * logger), never to exporters.
+ *
+ * Shape (Claude Code parity, prefix `yagni_code`):
+ *
+ *   spans    yagni_code.interaction ─┬─ yagni_code.turn ─┬─ yagni_code.llm_request
+ *                                    │                   └─ yagni_code.tool
+ *   metrics  session.count, token.usage, cost.usage, lines_of_code.count,
+ *            commit.count, pull_request.count, code_edit_tool.decision,
+ *            active_time.total
+ *   events   user_prompt, assistant_response, api_request, api_error,
+ *            tool_result, tool_decision, permission_mode_changed
+ *
+ * Metadata only. Prompt text, model output, tool arguments, and tool results
+ * never become attributes — only their lengths.
+ */
+import { type Attributes, type Meter, type Tracer } from "@opentelemetry/api";
+import { type Logger } from "@opentelemetry/api-logs";
+import { type Decision, type DecisionSource } from "./attrs.js";
+import type { TelemetryConfig } from "./config.js";
+/** pi's assistant-message usage block (loose: providers differ in what they fill). */
+export interface UsageLike {
+    input?: number;
+    output?: number;
+    cacheRead?: number;
+    cacheWrite?: number;
+    cost?: number | {
+        total?: number;
+    };
+}
+export interface AssistantMessageLike {
+    model?: string;
+    responseModel?: string;
+    responseId?: string;
+    usage?: UsageLike;
+    stopReason?: string;
+    errorMessage?: string;
+    content?: unknown;
+}
+export interface ToolDecisionInput {
+    toolName: string;
+    toolCallId?: string;
+    decision: Decision;
+    source: DecisionSource;
+    /** For edit/write tools: the target path, so `language` can be derived. */
+    filePath?: string;
+}
+export interface TrackerDeps {
+    tracer: Tracer;
+    meter: Meter;
+    logger: Logger;
+    config: TelemetryConfig;
+    now?: () => number;
+}
+/** Idle cutoff for user active time: gaps longer than this are not "active". */
+export declare const USER_ACTIVE_IDLE_CUTOFF_MS: number;
+export declare class SessionTelemetry {
+    private readonly tracer;
+    private readonly meter;
+    private readonly logger;
+    private readonly config;
+    private readonly now;
+    private sessionId;
+    private sessionCounted;
+    private eventSequence;
+    private interactionSequence;
+    private interaction;
+    private turn;
+    private llm;
+    private readonly tools;
+    /** Decision recorded per tool call before it executes (feeds tool_result). */
+    private readonly decisions;
+    /** When the agent last went idle — the start of the user's active window. */
+    private idleSince;
+    private readonly counters;
+    constructor(deps: TrackerDeps);
+    /** Attributes every metric and event carries (Claude Code's standard set). */
+    standardAttributes(): Attributes;
+    /** Attributes every span carries: session identity in both vocabularies. */
+    private spanAttributes;
+    private counter;
+    private add;
+    emitEvent(name: string, attrs: Attributes): void;
+    sessionStart(sessionId: string | undefined): void;
+    getSessionId(): string | undefined;
+    interactionStart(prompt: string | undefined): void;
+    interactionEnd(): void;
+    turnStart(turnIndex: number | undefined): void;
+    turnEnd(): void;
+    private parentCtx;
+    llmStart(model: string | undefined): void;
+    llmResponseHeaders(status: number | undefined, headers: Record<string, string> | undefined): void;
+    /**
+     * The assistant message ended: attach usage, emit api_request / api_error
+     * plus the token and cost counters, and close the LLM span. Opens a span
+     * first when pi delivered the message without a before_provider_request
+     * (e.g. a replayed or synthetic message) so nothing is lost.
+     */
+    assistantMessageEnd(message: AssistantMessageLike): void;
+    llmEnd(error: Error | undefined): void;
+    toolDecision(input: ToolDecisionInput): void;
+    toolStart(toolCallId: string, toolName: string, args: unknown): void;
+    toolEnd(toolCallId: string, outcome: {
+        isError: boolean;
+        resultBytes: number;
+        errorType?: string;
+    }): void;
+    /** Lines added/removed by an edit or write, from pi's tool_result details. */
+    linesOfCode(added: number, removed: number): void;
+    /** A successful bash command: count commits and PR creations. */
+    bashSucceeded(command: string | undefined): void;
+    permissionModeChanged(fromMode: string, toMode: string): void;
+    /** Close everything still open so no span is lost at exit. */
+    close(): void;
+}
+/** Cap on the exported error excerpt (characters, one line). */
+export declare const ERROR_EXCERPT_CHARS = 120;
+/** First line of a provider error, capped, never the full body. */
+export declare function errorExcerpt(message: string | undefined): string;
+export declare function byteLength(v: unknown): number;
+/** Count +/- lines in a unified patch, ignoring file headers. */
+export declare function countPatchLines(patch: string | undefined): {
+    added: number;
+    removed: number;
+};
+/** Line count of freshly written content (a write tool call). */
+export declare function countContentLines(content: unknown): number;
+//# sourceMappingURL=tracker.d.ts.map

package/dist/extension/telemetry/tracker.js

@@ -0,0 +1,551 @@
+/**
+ * Session telemetry tracker: turns pi's lifecycle into spans, metrics, and
+ * log events. Pure with respect to pi — `register.ts` feeds it events, tests
+ * feed it directly — and it only ever talks to the OTel API (tracer, meter,
+ * logger), never to exporters.
+ *
+ * Shape (Claude Code parity, prefix `yagni_code`):
+ *
+ *   spans    yagni_code.interaction ─┬─ yagni_code.turn ─┬─ yagni_code.llm_request
+ *                                    │                   └─ yagni_code.tool
+ *   metrics  session.count, token.usage, cost.usage, lines_of_code.count,
+ *            commit.count, pull_request.count, code_edit_tool.decision,
+ *            active_time.total
+ *   events   user_prompt, assistant_response, api_request, api_error,
+ *            tool_result, tool_decision, permission_mode_changed
+ *
+ * Metadata only. Prompt text, model output, tool arguments, and tool results
+ * never become attributes — only their lengths.
+ */
+import { randomUUID } from "node:crypto";
+import { context as otelContext, SpanStatusCode, trace, } from "@opentelemetry/api";
+import { SeverityNumber } from "@opentelemetry/api-logs";
+import { ATTR_APP_ENTRYPOINT, ATTR_APP_VERSION, ATTR_ERROR_TYPE, ATTR_GEN_AI_AGENT_NAME, ATTR_GEN_AI_CACHE_CREATION_TOKENS_LEGACY, ATTR_GEN_AI_CACHE_READ_TOKENS, ATTR_GEN_AI_CACHE_READ_TOKENS_LEGACY, ATTR_GEN_AI_CACHE_WRITE_TOKENS, ATTR_GEN_AI_CONVERSATION_ID, ATTR_GEN_AI_COST_ESTIMATED_TOTAL, ATTR_GEN_AI_FINISH_REASONS, ATTR_GEN_AI_INPUT_TOKENS, ATTR_GEN_AI_OPERATION_NAME, ATTR_GEN_AI_OUTPUT_TOKENS, ATTR_GEN_AI_TOTAL_TOKENS, ATTR_GEN_AI_PROVIDER_NAME, ATTR_GEN_AI_REQUEST_MODEL, ATTR_GEN_AI_RESPONSE_ID, ATTR_GEN_AI_RESPONSE_MODEL, ATTR_GEN_AI_SYSTEM, ATTR_GEN_AI_TOOL_CALL_ID, ATTR_GEN_AI_TOOL_NAME, ATTR_GEN_AI_TOOL_TYPE, ATTR_HTTP_STATUS_CODE, ATTR_ORGANIZATION_ID, ATTR_SESSION_ID, ATTR_TERMINAL_TYPE, ATTR_USER_EMAIL, EVENT_API_ERROR, EVENT_API_REQUEST, EVENT_ASSISTANT_RESPONSE, EVENT_PERMISSION_MODE_CHANGED, EVENT_TOOL_DECISION, EVENT_TOOL_RESULT, EVENT_USER_PROMPT, GEN_AI_PROVIDER, languageFromPath, METRIC_ACTIVE_TIME, METRIC_CODE_EDIT_DECISION, METRIC_COMMIT_COUNT, METRIC_COST_USAGE, METRIC_LINES_OF_CODE, METRIC_PULL_REQUEST_COUNT, METRIC_SESSION_COUNT, METRIC_TOKEN_USAGE, PREFIX, SPAN_INTERACTION, SPAN_LLM_REQUEST, SPAN_TOOL, SPAN_TURN, } from "./attrs.js";
+/** Idle cutoff for user active time: gaps longer than this are not "active". */
+export const USER_ACTIVE_IDLE_CUTOFF_MS = 5 * 60 * 1000;
+const EDIT_TOOLS = new Set(["edit", "write", "multi_edit", "notebook_edit"]);
+const GIT_COMMIT_RE = /(?:^|[;&|]\s*)git\s+(?:-C\s+\S+\s+)?(?:[a-z-]+=\S+\s+)*commit\b/;
+const GH_PR_CREATE_RE = /(?:^|[;&|]\s*)gh\s+pr\s+create\b/;
+export class SessionTelemetry {
+    tracer;
+    meter;
+    logger;
+    config;
+    now;
+    sessionId;
+    sessionCounted = false;
+    eventSequence = 0;
+    interactionSequence = 0;
+    interaction = null;
+    turn = null;
+    llm = null;
+    tools = new Map();
+    /** Decision recorded per tool call before it executes (feeds tool_result). */
+    decisions = new Map();
+    /** When the agent last went idle — the start of the user's active window. */
+    idleSince;
+    counters = {};
+    constructor(deps) {
+        this.tracer = deps.tracer;
+        this.meter = deps.meter;
+        this.logger = deps.logger;
+        this.config = deps.config;
+        this.now = deps.now ?? (() => Date.now());
+    }
+    // ── Standard attributes ─────────────────────────────────────────────────
+    /** Attributes every metric and event carries (Claude Code's standard set). */
+    standardAttributes() {
+        const id = this.config.identity;
+        const attrs = {};
+        if (this.config.includeSessionId && this.sessionId)
+            attrs[ATTR_SESSION_ID] = this.sessionId;
+        if (this.config.includeVersion && id.appVersion)
+            attrs[ATTR_APP_VERSION] = id.appVersion;
+        if (this.config.includeEntrypoint)
+            attrs[ATTR_APP_ENTRYPOINT] = id.entrypoint;
+        if (id.organizationId)
+            attrs[ATTR_ORGANIZATION_ID] = id.organizationId;
+        if (this.config.includeAccountId && id.userEmail)
+            attrs[ATTR_USER_EMAIL] = id.userEmail;
+        if (id.terminalType)
+            attrs[ATTR_TERMINAL_TYPE] = id.terminalType;
+        if (this.config.includeResourceAttributes)
+            Object.assign(attrs, this.config.resourceAttributes);
+        return attrs;
+    }
+    /** Attributes every span carries: session identity in both vocabularies. */
+    spanAttributes() {
+        const attrs = {
+            [ATTR_GEN_AI_PROVIDER_NAME]: GEN_AI_PROVIDER,
+            [ATTR_GEN_AI_SYSTEM]: GEN_AI_PROVIDER,
+            [ATTR_GEN_AI_AGENT_NAME]: this.config.serviceName,
+        };
+        if (this.sessionId) {
+            attrs[ATTR_SESSION_ID] = this.sessionId;
+            attrs[ATTR_GEN_AI_CONVERSATION_ID] = this.sessionId;
+        }
+        const id = this.config.identity;
+        if (id.organizationId)
+            attrs[ATTR_ORGANIZATION_ID] = id.organizationId;
+        // Same gate as the metrics/events attribute set: an admin who turned
+        // account identity off gets it off on spans too.
+        if (this.config.includeAccountId && id.userEmail)
+            attrs[ATTR_USER_EMAIL] = id.userEmail;
+        if (id.appVersion)
+            attrs[ATTR_APP_VERSION] = id.appVersion;
+        return attrs;
+    }
+    // ── Instruments ─────────────────────────────────────────────────────────
+    counter(name, unit, description) {
+        let c = this.counters[name];
+        if (!c) {
+            c = this.meter.createCounter(name, { unit, description });
+            this.counters[name] = c;
+        }
+        return c;
+    }
+    add(name, unit, description, value, attrs = {}) {
+        if (!Number.isFinite(value) || value === 0)
+            return;
+        try {
+            this.counter(name, unit, description).add(value, { ...this.standardAttributes(), ...attrs });
+        }
+        catch {
+            // Metrics are best-effort.
+        }
+    }
+    // ── Events ──────────────────────────────────────────────────────────────
+    emitEvent(name, attrs) {
+        this.eventSequence += 1;
+        const record = {
+            ...this.standardAttributes(),
+            "event.name": name,
+            "event.timestamp": new Date(this.now()).toISOString(),
+            "event.sequence": this.eventSequence,
+            ...(this.interaction ? { "prompt.id": this.interaction.promptId } : {}),
+            ...attrs,
+        };
+        try {
+            this.logger.emit({
+                eventName: `${PREFIX}.${name}`,
+                severityNumber: SeverityNumber.INFO,
+                severityText: "INFO",
+                body: `${PREFIX}.${name}`,
+                attributes: record,
+            });
+        }
+        catch {
+            // Logs are best-effort.
+        }
+    }
+    // ── Session ─────────────────────────────────────────────────────────────
+    sessionStart(sessionId) {
+        if (sessionId)
+            this.sessionId = sessionId;
+        if (!this.sessionCounted) {
+            this.sessionCounted = true;
+            this.add(METRIC_SESSION_COUNT, "1", "Count of CLI sessions started", 1);
+        }
+        this.idleSince = this.now();
+    }
+    getSessionId() {
+        return this.sessionId;
+    }
+    // ── Interaction (one user prompt) ───────────────────────────────────────
+    interactionStart(prompt) {
+        if (this.interaction)
+            this.interactionEnd();
+        const now = this.now();
+        // User active time: the window since the agent last went idle, unless the
+        // user walked away (idle cutoff).
+        if (this.idleSince !== undefined) {
+            const gap = now - this.idleSince;
+            if (gap > 0 && gap <= USER_ACTIVE_IDLE_CUTOFF_MS) {
+                this.add(METRIC_ACTIVE_TIME, "s", "Total active time in seconds", gap / 1000, { type: "user" });
+            }
+            this.idleSince = undefined;
+        }
+        this.interactionSequence += 1;
+        const promptId = randomUUID();
+        const promptLength = typeof prompt === "string" ? prompt.length : 0;
+        // `invoke_agent` is the semconv operation for the root of an agent run.
+        // Without it Datadog files the trace as a generic workflow, flags an
+        // instrumentation issue on the span, and leaves it out of per-agent views.
+        const span = this.tracer.startSpan(SPAN_INTERACTION, {
+            attributes: {
+                ...this.spanAttributes(),
+                [ATTR_GEN_AI_OPERATION_NAME]: "invoke_agent",
+                user_prompt_length: promptLength,
+                "interaction.sequence": this.interactionSequence,
+                "prompt.id": promptId,
+            },
+        });
+        const ctx = trace.setSpan(otelContext.active(), span);
+        this.interaction = { span, ctx, startedAt: now, promptId };
+        this.emitEvent(EVENT_USER_PROMPT, { prompt_length: promptLength });
+    }
+    interactionEnd() {
+        if (!this.interaction)
+            return;
+        const now = this.now();
+        // Close stragglers: pi guarantees agent_end after its children, but an
+        // abort can leave a turn or tool open.
+        if (this.llm)
+            this.llmEnd(undefined);
+        for (const [id] of this.tools)
+            this.toolEnd(id, { isError: false, resultBytes: 0 });
+        if (this.turn)
+            this.turnEnd();
+        const elapsed = now - this.interaction.startedAt;
+        this.interaction.span.setAttribute("interaction.duration_ms", Math.max(0, Math.round(elapsed)));
+        this.interaction.span.end();
+        this.interaction = null;
+        this.decisions.clear();
+        this.add(METRIC_ACTIVE_TIME, "s", "Total active time in seconds", Math.max(0, elapsed) / 1000, { type: "cli" });
+        this.idleSince = now;
+    }
+    // ── Turn ────────────────────────────────────────────────────────────────
+    turnStart(turnIndex) {
+        if (!this.interaction)
+            return;
+        if (this.turn)
+            this.turnEnd();
+        const span = this.tracer.startSpan(SPAN_TURN, { attributes: { ...this.spanAttributes(), ...(typeof turnIndex === "number" ? { "turn.index": turnIndex } : {}) } }, this.interaction.ctx);
+        this.turn = { span, ctx: trace.setSpan(this.interaction.ctx, span), startedAt: this.now() };
+    }
+    turnEnd() {
+        if (!this.turn)
+            return;
+        this.turn.span.end();
+        this.turn = null;
+    }
+    // ── LLM request ─────────────────────────────────────────────────────────
+    parentCtx() {
+        return this.turn?.ctx ?? this.interaction?.ctx ?? otelContext.active();
+    }
+    llmStart(model) {
+        if (this.llm)
+            this.llmEnd(undefined);
+        const parent = this.parentCtx();
+        const clientRequestId = randomUUID();
+        const attrs = {
+            ...this.spanAttributes(),
+            [ATTR_GEN_AI_OPERATION_NAME]: "chat",
+            client_request_id: clientRequestId,
+            "llm_request.context": this.interaction ? "interaction" : "standalone",
+        };
+        if (model) {
+            attrs[ATTR_GEN_AI_REQUEST_MODEL] = model;
+            attrs.model = model;
+        }
+        const span = this.tracer.startSpan(SPAN_LLM_REQUEST, { attributes: attrs }, parent);
+        this.llm = {
+            span,
+            ctx: trace.setSpan(parent, span),
+            startedAt: this.now(),
+            clientRequestId,
+            ...(model ? { requestModel: model } : {}),
+        };
+    }
+    llmResponseHeaders(status, headers) {
+        if (!this.llm)
+            return;
+        if (typeof status === "number") {
+            this.llm.status = status;
+            this.llm.span.setAttribute(ATTR_HTTP_STATUS_CODE, status);
+        }
+        const h = headers ?? {};
+        const requestId = h["x-request-id"] ?? h["request-id"] ?? h["anthropic-request-id"] ?? h["openai-response-id"];
+        if (typeof requestId === "string" && requestId) {
+            this.llm.requestId = requestId;
+            this.llm.span.setAttribute(ATTR_GEN_AI_RESPONSE_ID, requestId);
+            this.llm.span.setAttribute("request_id", requestId);
+        }
+    }
+    /**
+     * The assistant message ended: attach usage, emit api_request / api_error
+     * plus the token and cost counters, and close the LLM span. Opens a span
+     * first when pi delivered the message without a before_provider_request
+     * (e.g. a replayed or synthetic message) so nothing is lost.
+     */
+    assistantMessageEnd(message) {
+        if (!this.llm)
+            this.llmStart(message.model);
+        const slot = this.llm;
+        const now = this.now();
+        const durationMs = Math.max(0, Math.round(now - slot.startedAt));
+        const model = message.responseModel ?? message.model ?? slot.requestModel ?? "unknown";
+        const usage = message.usage ?? {};
+        const input = num(usage.input);
+        const output = num(usage.output);
+        const cacheRead = num(usage.cacheRead);
+        const cacheCreation = num(usage.cacheWrite);
+        // Claude Code always reports cost_usd (0 when it has nothing), so the flat
+        // attribute and the counter keep that shape. The vendor cost attribute is
+        // different: a 0 there renders as "$0" in cost views, so it is only set
+        // when pi actually priced the request.
+        const costKnown = typeof usage.cost === "number" || typeof usage.cost?.total === "number";
+        const cost = typeof usage.cost === "number" ? usage.cost : num(usage.cost?.total);
+        const stop = message.stopReason ?? "stop";
+        const isError = stop === "error";
+        const requestId = message.responseId ?? slot.requestId;
+        // pi's `input` excludes cached tokens (Anthropic semantics). The semconv
+        // `gen_ai.usage.input_tokens` includes them, with the cache counters as
+        // subsets; see attrs.ts. The flat Claude Code attributes below stay disjoint.
+        const inclusiveInput = input + cacheRead + cacheCreation;
+        const span = slot.span;
+        if (message.model)
+            span.setAttribute(ATTR_GEN_AI_REQUEST_MODEL, message.model);
+        span.setAttribute(ATTR_GEN_AI_RESPONSE_MODEL, model);
+        span.setAttribute("model", model);
+        span.setAttribute(ATTR_GEN_AI_INPUT_TOKENS, inclusiveInput);
+        span.setAttribute(ATTR_GEN_AI_OUTPUT_TOKENS, output);
+        span.setAttribute(ATTR_GEN_AI_TOTAL_TOKENS, inclusiveInput + output);
+        span.setAttribute(ATTR_GEN_AI_CACHE_READ_TOKENS, cacheRead);
+        span.setAttribute(ATTR_GEN_AI_CACHE_WRITE_TOKENS, cacheCreation);
+        span.setAttribute(ATTR_GEN_AI_CACHE_READ_TOKENS_LEGACY, cacheRead);
+        span.setAttribute(ATTR_GEN_AI_CACHE_CREATION_TOKENS_LEGACY, cacheCreation);
+        // Datadog ingests this attribute in nanodollars (its `ml_obs.span.llm.total.cost`
+        // unit); sending dollars renders a $0.012 call as 1.2e-9 cents. Verified against
+        // a live span on 2026-09-02. `cost_usd` below stays in dollars.
+        if (costKnown)
+            span.setAttribute(ATTR_GEN_AI_COST_ESTIMATED_TOTAL, Math.round(cost * 1_000_000_000));
+        span.setAttribute("input_tokens", input);
+        span.setAttribute("output_tokens", output);
+        span.setAttribute("cache_read_tokens", cacheRead);
+        span.setAttribute("cache_creation_tokens", cacheCreation);
+        span.setAttribute("cost_usd", cost);
+        span.setAttribute("duration_ms", durationMs);
+        span.setAttribute("stop_reason", stop);
+        span.setAttribute(ATTR_GEN_AI_FINISH_REASONS, [stop]);
+        span.setAttribute("success", isError ? "false" : "true");
+        span.setAttribute("response.has_tool_call", hasToolCall(message.content) ? "true" : "false");
+        if (requestId) {
+            span.setAttribute(ATTR_GEN_AI_RESPONSE_ID, requestId);
+            span.setAttribute("request_id", requestId);
+        }
+        const base = {
+            model,
+            duration_ms: durationMs,
+            client_request_id: slot.clientRequestId,
+            ...(requestId ? { request_id: requestId } : {}),
+        };
+        if (isError) {
+            // A short, single-line excerpt only: a provider error body can echo
+            // request content, and the contract is metadata-only. The status code
+            // and the leading words are what a dashboard needs.
+            const error = errorExcerpt(message.errorMessage);
+            span.setAttribute(ATTR_ERROR_TYPE, "api_error");
+            span.setAttribute("error", error);
+            span.setStatus({ code: SpanStatusCode.ERROR, message: error });
+            this.emitEvent(EVENT_API_ERROR, {
+                ...base,
+                error,
+                attempt: 1,
+                ...(typeof slot.status === "number" ? { status_code: String(slot.status) } : {}),
+            });
+        }
+        else {
+            this.emitEvent(EVENT_API_REQUEST, {
+                ...base,
+                cost_usd: cost,
+                cost_usd_micros: Math.round(cost * 1_000_000),
+                input_tokens: input,
+                output_tokens: output,
+                cache_read_tokens: cacheRead,
+                cache_creation_tokens: cacheCreation,
+            });
+            this.emitEvent(EVENT_ASSISTANT_RESPONSE, {
+                model,
+                response_length: responseLength(message.content),
+                ...(requestId ? { request_id: requestId } : {}),
+            });
+        }
+        const tokenAttrs = (type) => ({ type, model });
+        this.add(METRIC_TOKEN_USAGE, "{token}", "Number of tokens used", input, tokenAttrs("input"));
+        this.add(METRIC_TOKEN_USAGE, "{token}", "Number of tokens used", output, tokenAttrs("output"));
+        this.add(METRIC_TOKEN_USAGE, "{token}", "Number of tokens used", cacheRead, tokenAttrs("cacheRead"));
+        this.add(METRIC_TOKEN_USAGE, "{token}", "Number of tokens used", cacheCreation, tokenAttrs("cacheCreation"));
+        this.add(METRIC_COST_USAGE, "USD", "Cost of the session", cost, { model });
+        this.llmEnd(undefined);
+    }
+    llmEnd(error) {
+        if (!this.llm)
+            return;
+        if (error) {
+            this.llm.span.setAttribute(ATTR_ERROR_TYPE, error.name || "Error");
+            this.llm.span.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
+        }
+        this.llm.span.end();
+        this.llm = null;
+    }
+    // ── Tools ───────────────────────────────────────────────────────────────
+    toolDecision(input) {
+        const toolSource = input.toolName.startsWith("mcp__") ? "mcp" : "builtin";
+        // Only accepted calls go on to execute (and read this back in toolEnd);
+        // a rejected call never reaches tool_execution_end, so storing it would
+        // only leak.
+        if (input.toolCallId && input.decision === "accept") {
+            this.decisions.set(input.toolCallId, { decision: input.decision, source: input.source });
+        }
+        this.emitEvent(EVENT_TOOL_DECISION, {
+            tool_name: input.toolName,
+            ...(input.toolCallId ? { tool_use_id: input.toolCallId } : {}),
+            decision: input.decision,
+            source: input.source,
+            tool_source: toolSource,
+        });
+        if (EDIT_TOOLS.has(input.toolName)) {
+            const language = languageFromPath(input.filePath);
+            this.add(METRIC_CODE_EDIT_DECISION, "1", "Count of code editing tool permission decisions", 1, {
+                tool_name: input.toolName,
+                decision: input.decision,
+                source: input.source,
+                ...(language ? { language } : {}),
+            });
+        }
+    }
+    toolStart(toolCallId, toolName, args) {
+        if (this.tools.has(toolCallId))
+            return;
+        const parent = this.parentCtx();
+        const inputBytes = byteLength(args);
+        const attrs = {
+            ...this.spanAttributes(),
+            tool_name: toolName,
+            tool_use_id: toolCallId,
+            [ATTR_GEN_AI_TOOL_NAME]: toolName,
+            [ATTR_GEN_AI_TOOL_CALL_ID]: toolCallId,
+            [ATTR_GEN_AI_TOOL_TYPE]: toolName.startsWith("mcp__") ? "extension" : "function",
+            [ATTR_GEN_AI_OPERATION_NAME]: "execute_tool",
+            tool_input_size_bytes: inputBytes,
+        };
+        const span = this.tracer.startSpan(SPAN_TOOL, { attributes: attrs }, parent);
+        this.tools.set(toolCallId, { span, ctx: trace.setSpan(parent, span), startedAt: this.now(), name: toolName, inputBytes });
+    }
+    toolEnd(toolCallId, outcome) {
+        const slot = this.tools.get(toolCallId);
+        if (!slot)
+            return;
+        const durationMs = Math.max(0, Math.round(this.now() - slot.startedAt));
+        slot.span.setAttribute("duration_ms", durationMs);
+        slot.span.setAttribute("success", outcome.isError ? "false" : "true");
+        slot.span.setAttribute("tool_result_size_bytes", outcome.resultBytes);
+        if (outcome.isError) {
+            slot.span.setAttribute(ATTR_ERROR_TYPE, outcome.errorType ?? "tool_error");
+            slot.span.setStatus({ code: SpanStatusCode.ERROR });
+        }
+        slot.span.end();
+        this.tools.delete(toolCallId);
+        const decision = this.decisions.get(toolCallId);
+        this.decisions.delete(toolCallId);
+        this.emitEvent(EVENT_TOOL_RESULT, {
+            tool_name: slot.name,
+            tool_use_id: toolCallId,
+            success: outcome.isError ? "false" : "true",
+            duration_ms: durationMs,
+            tool_input_size_bytes: slot.inputBytes,
+            tool_result_size_bytes: outcome.resultBytes,
+            decision_type: "accept",
+            decision_source: decision?.source ?? "config",
+            ...(outcome.isError ? { error_type: outcome.errorType ?? "tool_error" } : {}),
+        });
+    }
+    /** Lines added/removed by an edit or write, from pi's tool_result details. */
+    linesOfCode(added, removed) {
+        this.add(METRIC_LINES_OF_CODE, "1", "Count of lines of code modified", added, { type: "added" });
+        this.add(METRIC_LINES_OF_CODE, "1", "Count of lines of code modified", removed, { type: "removed" });
+    }
+    /** A successful bash command: count commits and PR creations. */
+    bashSucceeded(command) {
+        if (typeof command !== "string")
+            return;
+        if (GIT_COMMIT_RE.test(command))
+            this.add(METRIC_COMMIT_COUNT, "1", "Count of git commits created", 1);
+        if (GH_PR_CREATE_RE.test(command))
+            this.add(METRIC_PULL_REQUEST_COUNT, "1", "Count of pull requests created", 1);
+    }
+    // ── Mode ────────────────────────────────────────────────────────────────
+    permissionModeChanged(fromMode, toMode) {
+        this.emitEvent(EVENT_PERMISSION_MODE_CHANGED, { from_mode: fromMode, to_mode: toMode });
+    }
+    // ── Shutdown ────────────────────────────────────────────────────────────
+    /** Close everything still open so no span is lost at exit. */
+    close() {
+        this.interactionEnd();
+        if (this.llm)
+            this.llmEnd(undefined);
+        for (const [id] of this.tools)
+            this.toolEnd(id, { isError: false, resultBytes: 0 });
+        if (this.turn)
+            this.turnEnd();
+    }
+}
+/** Cap on the exported error excerpt (characters, one line). */
+export const ERROR_EXCERPT_CHARS = 120;
+/** First line of a provider error, capped, never the full body. */
+export function errorExcerpt(message) {
+    const firstLine = (message ?? "").split(/\r?\n/, 1)[0]?.trim() ?? "";
+    if (!firstLine)
+        return "LLM request failed";
+    return firstLine.length > ERROR_EXCERPT_CHARS ? `${firstLine.slice(0, ERROR_EXCERPT_CHARS)}…` : firstLine;
+}
+function num(v) {
+    return typeof v === "number" && Number.isFinite(v) && v > 0 ? v : 0;
+}
+function hasToolCall(content) {
+    if (!Array.isArray(content))
+        return false;
+    return content.some((p) => p && typeof p === "object" && p.type === "toolCall");
+}
+function responseLength(content) {
+    if (typeof content === "string")
+        return content.length;
+    if (!Array.isArray(content))
+        return 0;
+    let n = 0;
+    for (const p of content) {
+        if (p && typeof p === "object" && p.type === "text") {
+            const t = p.text;
+            if (typeof t === "string")
+                n += t.length;
+        }
+    }
+    return n;
+}
+export function byteLength(v) {
+    if (v === undefined || v === null)
+        return 0;
+    if (typeof v === "string")
+        return Buffer.byteLength(v, "utf8");
+    try {
+        return Buffer.byteLength(JSON.stringify(v) ?? "", "utf8");
+    }
+    catch {
+        return 0;
+    }
+}
+/** Count +/- lines in a unified patch, ignoring file headers. */
+export function countPatchLines(patch) {
+    let added = 0;
+    let removed = 0;
+    if (typeof patch !== "string")
+        return { added, removed };
+    for (const line of patch.split("\n")) {
+        if (line.startsWith("+++") || line.startsWith("---"))
+            continue;
+        if (line.startsWith("+"))
+            added += 1;
+        else if (line.startsWith("-"))
+            removed += 1;
+    }
+    return { added, removed };
+}
+/** Line count of freshly written content (a write tool call). */
+export function countContentLines(content) {
+    if (typeof content !== "string" || content.length === 0)
+        return 0;
+    const n = content.split("\n").length;
+    return content.endsWith("\n") ? n - 1 : n;
+}
+//# sourceMappingURL=tracker.js.map