retrace-sdk 0.5.2 → 0.6.0

package/README.md

@@ -111,6 +111,12 @@ configure({ apiKey: "rt_live_...", sampleRate: 0.1 }); // Record 10% of traces
 
 - **Fixed** — OpenAI interceptor no longer creates dummy client instance to find prototype
 
+### 0.6.0
+
+- **Token ID capture** — Stores output token IDs + logprobs from OpenAI responses (enables speculative decoding during replay)
+- **SpanData extended** — New `token_ids` and `logprobs` fields on SpanData interface
+- **Shared schema** — SpanInputSchema updated with `token_ids` and `logprobs` optional arrays
+
 ### 0.2.1
 
 - **Offline buffer** — stores up to 1000 messages when WebSocket disconnects, flushes on reconnect

package/dist/interceptors/openai.js

@@ -188,6 +188,12 @@ function createPatchedCreate() {
             const inputTokens = res?.usage?.prompt_tokens || 0;
             const outputTokens = res?.usage?.completion_tokens || 0;
             const output = res?.choices?.[0]?.message?.content || "";
+            // Extract token IDs and logprobs if available (requires logprobs: true in request)
+            const choiceLogprobs = res?.choices?.[0]?.logprobs?.content;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const tokenIds = choiceLogprobs?.map((t) => t.token_id ?? t.top_logprobs?.[0]?.token_id).filter(Boolean);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const logprobValues = choiceLogprobs?.map((t) => t.logprob).filter((v) => v !== undefined);
             const span = {
                 id: spanId, trace_id: "", parent_id: null,
                 span_type: SpanType.LLM_CALL, name: "openai.chat.completions.create", model,
@@ -196,6 +202,8 @@ function createPatchedCreate() {
                 input_tokens: inputTokens, output_tokens: outputTokens,
                 cost: calcCost(model, inputTokens, outputTokens),
                 duration_ms: durationMs, started_at: startedAt, ended_at: nowIso(),
+                ...(tokenIds?.length ? { token_ids: tokenIds } : {}),
+                ...(logprobValues?.length ? { logprobs: logprobValues } : {}),
                 ...(Object.keys(spanMetadata).length ? { metadata: spanMetadata } : {}),
             };
             onSpanCallback?.(span);

package/dist/recorder.js

@@ -129,16 +129,18 @@ export class TraceRecorder {
 export function record(opts) {
     const cfg = getConfig();
     if (!cfg.enabled || !shouldSample(cfg.sampleRate, cfg.sampleSeed, opts?.name)) {
-        // Return a typed no-op stub (preserves type safety unlike Proxy)
-        return {
-            get traceId() { return ""; },
-            output: undefined,
-            start() { return this; },
-            end() { },
-            addSpan() { },
-            startSpan(name) { const { SpanBuilder } = require("./trace.js"); return new SpanBuilder(name, "llm_call"); },
-            endSpan() { },
-        };
+        // Return a properly-typed no-op recorder that satisfies the TraceRecorder interface
+        const noop = Object.create(TraceRecorder.prototype);
+        Object.defineProperties(noop, {
+            traceId: { get: () => "" },
+            output: { value: undefined, writable: true },
+        });
+        noop.start = () => noop;
+        noop.end = () => { };
+        noop.addSpan = () => { };
+        noop.startSpan = (name) => new SpanBuilder(name, "llm_call");
+        noop.endSpan = () => { };
+        return noop;
     }
     return new TraceRecorder(opts);
 }

package/dist/resume.d.ts

@@ -17,7 +17,7 @@ export interface ResumeCommand {
 }
 export declare function registerResumable(name: string, fn: (...args: unknown[]) => unknown): void;
 export declare function getResumable(name: string): ((...args: unknown[]) => unknown) | undefined;
-export declare function handleResume(command: ResumeCommand): boolean;
+export declare function handleResume(command: ResumeCommand): Promise<boolean>;
 export declare function parseResumeMessage(msg: {
     type: string;
     data?: Record<string, unknown>;

package/dist/resume.js

@@ -15,46 +15,41 @@ export function registerResumable(name, fn) {
 export function getResumable(name) {
     return resumableFunctions.get(name);
 }
-export function handleResume(command) {
+export async function handleResume(command) {
     const fn = getResumable(command.traceName);
     if (!fn)
         return false;
-    // Re-execute async in background
-    (async () => {
-        try {
-            const { TraceRecorder } = await import("./recorder.js");
-            const { TraceStatus } = await import("./trace.js");
-            const recorder = new TraceRecorder({
-                name: `Fork: ${command.traceName}`,
-                input: command.modifiedInput,
-                metadata: {
-                    _fork_id: command.forkId,
-                    _fork_of: command.traceId,
-                    _fork_point: command.forkPointSpanId,
-                    _cascade_replay: true,
-                },
-                // Signal the recorder to skip spans until the fork point is reached.
-                // Pre-fork spans are copied server-side; the SDK only needs to emit
-                // spans from the fork point onward.
-                forkPointSpanId: command.forkPointSpanId,
-            });
-            recorder.start(`Fork: ${command.traceName}`, command.modifiedInput);
-            // Determine args for re-execution
-            let args = command.originalArgs || [];
-            if (typeof command.modifiedInput === "string") {
-                args = [command.modifiedInput, ...args.slice(1)];
-            }
-            else if (typeof command.modifiedInput === "object" && !Array.isArray(command.modifiedInput)) {
-                args = [command.modifiedInput];
-            }
-            const result = await Promise.resolve(fn(...args));
-            recorder.end(result, TraceStatus.COMPLETED);
+    try {
+        const { TraceRecorder } = await import("./recorder.js");
+        const { TraceStatus } = await import("./trace.js");
+        const recorder = new TraceRecorder({
+            name: `Fork: ${command.traceName}`,
+            input: command.modifiedInput,
+            metadata: {
+                _fork_id: command.forkId,
+                _fork_of: command.traceId,
+                _fork_point: command.forkPointSpanId,
+                _cascade_replay: true,
+            },
+            forkPointSpanId: command.forkPointSpanId,
+        });
+        recorder.start(`Fork: ${command.traceName}`, command.modifiedInput);
+        // Determine args for re-execution
+        let args = command.originalArgs || [];
+        if (typeof command.modifiedInput === "string") {
+            args = [command.modifiedInput, ...args.slice(1)];
         }
-        catch (err) {
-            console.error("[retrace] Cascade replay failed:", err);
+        else if (typeof command.modifiedInput === "object" && !Array.isArray(command.modifiedInput)) {
+            args = [command.modifiedInput];
         }
-    })().catch((err) => console.error("[retrace] Replay IIFE unhandled:", err));
-    return true;
+        const result = await Promise.resolve(fn(...args));
+        recorder.end(result, TraceStatus.COMPLETED);
+        return true;
+    }
+    catch (err) {
+        console.error("[retrace] Cascade replay failed:", err);
+        return false;
+    }
 }
 export function parseResumeMessage(msg) {
     if (msg.type !== "resume" || !msg.data)

package/dist/trace.d.ts

@@ -30,6 +30,8 @@ export interface SpanData {
     started_at: string;
     ended_at?: string;
     error?: string;
+    token_ids?: number[];
+    logprobs?: number[];
 }
 export interface TraceData {
     id: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "retrace-sdk",
-  "version": "0.5.2",
+  "version": "0.6.0",
   "description": "The execution replay engine for AI agents. Record, replay, fork, and share agent executions.",
   "type": "module",
   "main": "dist/index.js",