retrace-sdk 0.16.8 → 0.16.10

package/dist/config.js

@@ -63,7 +63,7 @@ export function configure(opts) {
     if (config.enabled) {
         void import("./interceptors/install.js").then((m) => m.ensureInterceptorsInstalled()).catch(() => { });
     }
-    void import("./telemetry.js").then((m) => m.track("configure")).catch(() => { });
+    void import("./telemetry.js").then((m) => m.track("sdk_init", { has_api_key: !!config.apiKey, enabled: config.enabled })).catch(() => { });
     return config;
 }
 export function requireApiKey() {

package/dist/recorder.js

@@ -184,6 +184,13 @@ export class TraceRecorder {
             // lossy / capture_complete:false). Only a naturally-drained run produces a clean terminal.
             ...(opts?.terminatedEarly ? { terminated_early: true } : {}),
         });
+        // Anonymous usage analytics (fire-and-forget; never throws): record success/failure + which
+        // provider families ran. No PII, no user content.
+        try {
+            const dict = this.builder.toDict();
+            void import("./telemetry.js").then((m) => m.trackRecord(String(data.status), dict.spans ?? [], dict.metadata ?? {})).catch(() => { });
+        }
+        catch { /* never affect the user's program */ }
         // Restore the enclosing trace's fallback (e.g. the ambient init() recorder) instead of nulling.
         setActiveRecorderFallback(this.prevFallback, this.prevFallbackSink);
         this.prevFallback = null;
@@ -221,6 +228,7 @@ export class TraceRecorder {
         if (span.ended_at) {
             this.transport.send("span_ended", {
                 id: span.id,
+                trace_id: span.trace_id,
                 ended_at: span.ended_at,
                 output: span.output,
                 output_tokens: span.output_tokens,
@@ -263,6 +271,7 @@ export class TraceRecorder {
         this.builder.addSpan(span);
         this.transport.send("span_ended", {
             id: span.id,
+            trace_id: span.trace_id,
             ended_at: span.ended_at,
             output: span.output,
             output_tokens: span.output_tokens,

package/dist/resume.d.ts

@@ -17,6 +17,9 @@ export interface ResumeCommand {
     forkPointIndex?: number;
     modifiedInput: unknown;
     originalArgs?: unknown[];
+    /** Server replay-lease generation token; echoed back on the result trace so the server can reject
+     *  a superseded (stale) generation and release the correct lease. */
+    executionId?: string;
 }
 export declare function registerResumable(name: string, fn: (...args: unknown[]) => unknown): void;
 export declare function getResumable(name: string): ((...args: unknown[]) => unknown) | undefined;

package/dist/resume.js

@@ -29,6 +29,7 @@ export async function handleResume(command) {
                 _fork_id: command.forkId,
                 _fork_of: command.traceId,
                 _fork_point: command.forkPointSpanId,
+                _fork_execution_id: command.executionId,
                 _cascade_replay: true,
             },
             forkPointSpanId: command.forkPointSpanId,
@@ -63,5 +64,6 @@ export function parseResumeMessage(msg) {
         forkPointIndex: msg.data.forkPointIndex,
         modifiedInput: msg.data.modifiedInput,
         originalArgs: msg.data.originalArgs,
+        executionId: msg.data.executionId,
     };
 }

package/dist/telemetry.d.ts

@@ -1 +1,8 @@
+/** Coarse provider family from a model name (analytics only — never the key or content). */
+export declare function providerOf(model?: string | null): string;
 export declare function track(event: string, fields?: Record<string, string | number | boolean>): void;
+/** Emit record_success / record_failure with anonymous, aggregate-only fields (span count, provider
+ *  families used, whether the run was resumable / a cascade replay). Never throws. */
+export declare function trackRecord(status: string, spans: Array<{
+    model?: string | null;
+}>, metadata?: Record<string, unknown>): void;

package/dist/telemetry.js

@@ -1,26 +1,35 @@
 /**
- * Anonymous, opt-out diagnostic telemetry.
+ * Anonymous, always-on diagnostic telemetry.
  *
  * Sends NO user code, API keys, prompts, responses, or personal information — only the SDK version,
- * the runtime/OS family, an anonymous per-process id, and event/error *categories* — to the Retrace
- * API's internal log ingest (forwarded to the centralized logging platform under
- * service="sdk-typescript"). Fire-and-forget; never blocks, never throws.
+ * the runtime/OS family, an anonymous per-process id, and event/error *categories*. Events are POSTed
+ * to the Retrace API's internal ingest, which forwards them to PostHog (and the logging platform)
+ * under service="sdk-typescript" — so the SDK NEVER holds any analytics key (SDK → Retrace API →
+ * PostHog).
  *
- * Disable entirely with RETRACE_TELEMETRY=0 (also accepts false/no/off).
+ * Fire-and-forget: never blocks the user's program, never throws. Anonymous by construction (no PII,
+ * random per-process id) and intentionally NOT user-disableable.
  */
 import os from "node:os";
 import { getConfig } from "./config.js";
 // Per-process random id — anonymous, not linked to any account, user, or machine identity.
 const ANON_ID = Math.random().toString(16).slice(2, 18);
-const DISABLED = new Set(["0", "false", "no", "off"]);
 // Keep in sync with package.json version.
-const SDK_VERSION = "0.16.5";
-function enabled() {
-    return !DISABLED.has((process.env.RETRACE_TELEMETRY ?? "1").trim().toLowerCase());
+const SDK_VERSION = "0.16.9";
+/** Coarse provider family from a model name (analytics only — never the key or content). */
+export function providerOf(model) {
+    const m = (model || "").toLowerCase();
+    if (!m)
+        return "";
+    if (m.startsWith("gemini") || m.includes("google"))
+        return "google";
+    if (/^(gpt|o1|o3|o4|chatgpt|text-embedding|davinci)/.test(m))
+        return "openai";
+    if (m.includes("claude"))
+        return "anthropic";
+    return "other";
 }
 export function track(event, fields = {}) {
-    if (!enabled())
-        return;
     try {
         const base = (getConfig().baseUrl || "https://api.retraceai.tech").replace(/\/$/, "");
         const body = JSON.stringify({
@@ -49,3 +58,19 @@ export function track(event, fields = {}) {
         /* telemetry must never affect the user's program */
     }
 }
+/** Emit record_success / record_failure with anonymous, aggregate-only fields (span count, provider
+ *  families used, whether the run was resumable / a cascade replay). Never throws. */
+export function trackRecord(status, spans, metadata = {}) {
+    try {
+        const provs = Array.from(new Set(spans.map((s) => providerOf(s.model)).filter(Boolean)));
+        track(status === "completed" ? "record_success" : "record_failure", {
+            spans: spans.length,
+            providers: provs.join(",") || "none",
+            resumable: !!metadata._resumable,
+            cascade: !!metadata._cascade_replay,
+        });
+    }
+    catch {
+        /* never throw */
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "retrace-sdk",
-  "version": "0.16.8",
+  "version": "0.16.10",
   "description": "The execution replay engine for AI agents. Record, replay, fork, and share agent executions.",
   "type": "module",
   "main": "dist/index.js",
@@ -77,11 +77,11 @@
     }
   },
   "devDependencies": {
-    "@anthropic-ai/sdk": "^0.105.0",
-    "@google/genai": "^2.9.0",
+    "@anthropic-ai/sdk": "^0.111.0",
+    "@google/genai": "^2.11.0",
     "@types/node": "24.13.2",
     "@types/ws": "8.18.1",
-    "openai": "^6.44.0",
+    "openai": "^6.46.0",
     "typescript": "6.0.3"
   }
 }