retrace-sdk 0.5.0 → 0.5.2

package/dist/index.js

@@ -9,3 +9,5 @@ export { RetraceError, RetraceAuthError, RetraceCreditsExhaustedError, RetraceCo
 export { registerResumable, handleResume } from "./resume.js";
 export { isReplaying, consumeCassetteEntry, handleReplay } from "./replay.js";
 export { setTraceContext, clearTraceContext, getTraceparent, injectTraceparent, parseTraceparent } from "./traceparent.js";
+// v0.5.0
+// trigger

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);

package/dist/resume.js

@@ -33,6 +33,10 @@ export function handleResume(command) {
                     _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

package/package.json

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