retrace-sdk 0.5.2 → 0.5.4

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/package.json

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