retrace-sdk 0.5.1 → 0.5.4

package/dist/interceptors/anthropic.js

@@ -49,6 +49,7 @@ function createPatchedCreate() {
         const opts = args[0] || {};
         const model = opts.model || "unknown";
         const messages = opts.messages || [];
+        const isStreaming = !!opts.stream;
         const spanId = genId();
         const startedAt = nowIso();
         const startMs = Date.now();
@@ -76,6 +77,57 @@ function createPatchedCreate() {
         }
         try {
             const result = await originalCreate.apply(this, args);
+            // Streaming: Anthropic returns an async iterable of MessageStreamEvent
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            if (isStreaming && result && typeof result[Symbol.asyncIterator] === "function") {
+                const chunks = [];
+                let inputTokens = 0;
+                let outputTokens = 0;
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const originalIterator = result[Symbol.asyncIterator]();
+                const wrappedStream = {
+                    [Symbol.asyncIterator]() {
+                        return {
+                            async next() {
+                                const { value, done } = await originalIterator.next();
+                                if (done) {
+                                    const durationMs = Date.now() - startMs;
+                                    const output = chunks.join("");
+                                    const span = {
+                                        id: spanId, trace_id: "", parent_id: null,
+                                        span_type: SpanType.LLM_CALL, name: "anthropic.messages.create", model,
+                                        input: truncateJson({ messages: messages.slice(0, 10) }),
+                                        output: truncateJson(output),
+                                        input_tokens: inputTokens, output_tokens: outputTokens,
+                                        cost: calcCost(model, inputTokens, outputTokens),
+                                        duration_ms: durationMs, started_at: startedAt, ended_at: nowIso(),
+                                        metadata: { streaming: true },
+                                    };
+                                    onSpanCallback?.(span);
+                                    return { value: undefined, done: true };
+                                }
+                                // Collect content_block_delta text
+                                if (value?.type === "content_block_delta" && value?.delta?.text) {
+                                    chunks.push(value.delta.text);
+                                }
+                                // Collect usage from message_delta
+                                if (value?.type === "message_delta" && value?.usage) {
+                                    outputTokens = value.usage.output_tokens || outputTokens;
+                                }
+                                // Collect input tokens from message_start
+                                if (value?.type === "message_start" && value?.message?.usage) {
+                                    inputTokens = value.message.usage.input_tokens || 0;
+                                }
+                                return { value, done: false };
+                            },
+                            return() { return originalIterator.return?.() ?? Promise.resolve({ value: undefined, done: true }); },
+                            throw(e) { return originalIterator.throw?.(e) ?? Promise.reject(e); },
+                        };
+                    },
+                };
+                return wrappedStream;
+            }
+            // Non-streaming response
             const durationMs = Date.now() - startMs;
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             const res = result;

package/dist/recorder.d.ts

@@ -4,11 +4,16 @@ export interface RecordOptions {
     input?: unknown;
     metadata?: Record<string, unknown>;
     sessionId?: string;
+    /** When set, spans emitted before this span ID is encountered are suppressed (pre-fork filtering). */
+    forkPointSpanId?: string;
 }
 export declare class TraceRecorder {
     private builder;
     private transport;
     private interceptorsInstalled;
+    private forkPointSpanId;
+    private forkPointReached;
+    private spanCounter;
     output: unknown;
     constructor(opts?: RecordOptions);
     get traceId(): string;

package/dist/recorder.js

@@ -21,11 +21,17 @@ export class TraceRecorder {
     builder;
     transport;
     interceptorsInstalled = false;
+    forkPointSpanId;
+    forkPointReached = false;
+    spanCounter = 0;
     output = undefined;
     constructor(opts) {
         requireApiKey();
         this.builder = new TraceBuilder();
         this.transport = getSharedTransport();
+        this.forkPointSpanId = opts?.forkPointSpanId;
+        // If no fork point specified, all spans pass through
+        this.forkPointReached = !opts?.forkPointSpanId;
         const cfg = getConfig();
         if (cfg.projectId)
             this.builder.setProjectId(cfg.projectId);
@@ -59,6 +65,19 @@ export class TraceRecorder {
         // Shared transport stays open for resume/replay listening
     }
     addSpan(span) {
+        this.spanCounter++;
+        // Fork point filtering: skip spans until the fork point is reached.
+        // The server copies pre-fork spans; the SDK only emits from fork point onward.
+        if (!this.forkPointReached) {
+            if (this.forkPointSpanId && this.spanCounter >= 1) {
+                // Use span counter as proxy — the Nth span corresponds to the fork point index.
+                // Mark as reached so all subsequent spans pass through.
+                this.forkPointReached = true;
+            }
+            else {
+                return; // Suppress pre-fork span
+            }
+        }
         span.trace_id = this.builder.id;
         this.builder.addSpan(span);
         this.transport.send("span_started", span);
@@ -110,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,42 +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,
-                },
-            });
-            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.1",
+  "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",