bitfab 0.52.6 → 0.53.1

package/dist/{chunk-P26KVTI5.js → chunk-ZCOZHNAA.js}

@@ -19,19 +19,23 @@ import {
   serializeValue,
   toJsonSafe,
   toJsonSafeReport
-} from "./chunk-DRTHTSHO.js";
+} from "./chunk-MMT5MWG5.js";
 import {
   BitfabError,
   DEFAULT_SERVICE_URL,
   HttpClient,
   MixedTracingError,
+  PolicyRefresh,
+  ROOT_TRACE_FUNCTION_KEY_FIELD,
+  SimulationPlan,
   callerTraceMetadata,
   getReplayContext,
+  makeSpanOrigin,
   readEnv,
   recordCallerTraceMetadata,
   retireTraceMetadata,
   warnOnce
-} from "./chunk-NXC6NYIY.js";
+} from "./chunk-ASMHSKFS.js";
 import {
   __privateAdd,
   __privateGet,
@@ -340,6 +344,7 @@ var BitfabClaudeAgentHandler = class {
       trace_id: spanInfo.traceId,
       started_at: spanInfo.startedAt,
       ended_at: spanInfo.endedAt ?? nowIso(),
+      span_origin: makeSpanOrigin("claude-agent-sdk"),
       span_data: spanData
     };
     if (spanInfo.parentId !== null) {
@@ -1825,6 +1830,7 @@ var BitfabLangGraphCallbackHandler = class {
       trace_id: spanInfo.traceId,
       started_at: spanInfo.startedAt,
       ended_at: spanInfo.endedAt ?? nowIso2(),
+      span_origin: makeSpanOrigin("langgraph"),
       span_data: spanData
     };
     if (spanInfo.parentId !== null) {
@@ -2284,7 +2290,8 @@ var BitfabLangGraphIntegration = class {
                 captureWhen: "nested",
                 mockOnReplay: shouldMock,
                 finalize: finalizeToolResult,
-                surface: "inherit"
+                surface: "inherit",
+                instrumentation: "langgraph"
               },
               async (_args) => await originalInvoke(input, ...rest)
             );
@@ -2327,7 +2334,12 @@ var BitfabLangGraphIntegration = class {
   wrapInvoke(fn) {
     return this.client.withSpan(
       this.traceFunctionKey,
-      { name: this.traceFunctionKey, type: "agent", surface: "inherit" },
+      {
+        name: this.traceFunctionKey,
+        type: "agent",
+        surface: "inherit",
+        instrumentation: "langgraph"
+      },
       fn
     );
   }
@@ -2380,7 +2392,8 @@ var BitfabOpenAIAgentHandler = class {
     const options_ = {
       type: "agent",
       finalize,
-      surface: "inherit"
+      surface: "inherit",
+      instrumentation: "openai-agents"
     };
     const traced = this.withSpanFn(
       this.traceFunctionKey,
@@ -2671,6 +2684,7 @@ var BitfabOpenAITracingProcessor = class {
    * Build span payload for the external spans API.
    */
   buildSpanPayload(serializedSpan, errors) {
+    serializedSpan.span_origin = makeSpanOrigin("openai-agents");
     const payload = {
       id: randomUuid(),
       type: "openai",
@@ -2800,7 +2814,8 @@ var BitfabVercelAiHandler = class {
           {
             type: "llm",
             finalize: (result) => summarizeGenerate(result ?? {}, label),
-            surface: "inherit"
+            surface: "inherit",
+            instrumentation: "vercel-ai"
           },
           () => doGenerate()
         );
@@ -2818,7 +2833,12 @@ var BitfabVercelAiHandler = class {
           // The wrapped fn returns immediately with the live stream, so the span
           // output cannot be read from the return value. `finalize` instead
           // awaits the summary the accumulator resolves once the stream drains.
-          { type: "llm", finalize: () => summary, surface: "inherit" },
+          {
+            type: "llm",
+            finalize: () => summary,
+            surface: "inherit",
+            instrumentation: "vercel-ai"
+          },
           async () => {
             const result = await doStream();
             const stream = result.stream.pipeThrough(
@@ -2835,6 +2855,19 @@ var BitfabVercelAiHandler = class {
 
 // src/client.ts
 var activeTraceStates = /* @__PURE__ */ new Map();
+function rootTraceFunctionKeyOf(payload) {
+  const captured = payload[ROOT_TRACE_FUNCTION_KEY_FIELD];
+  if (typeof captured === "string") {
+    return captured;
+  }
+  const traceId = payload.traceId;
+  const live = typeof traceId === "string" ? activeTraceStates.get(traceId)?.traceFunctionKey : void 0;
+  if (typeof live === "string") {
+    return live;
+  }
+  const own = payload.traceFunctionKey;
+  return typeof own === "string" ? own : void 0;
+}
 var asyncLocalStorage = null;
 var SPAN_CONTEXT_STORAGE_SYMBOL = /* @__PURE__ */ Symbol.for("bitfab.spanContextStorage");
 var initializeAsyncContext = () => {
@@ -3177,6 +3210,26 @@ var DEFAULT_AUTO_TRACE_MAX_SPANS = 500;
 var AUTO_TRACE_PROTOCOL = "ts-auto-v1";
 var AUTO_TRACE_POLICY_REFRESH_MS = 6e4;
 var AUTO_TRACE_POLICY_RETRY_MS = 1e4;
+function spanOwnerName(receiver) {
+  if (typeof receiver === "function") {
+    return receiver.name !== "" ? receiver.name : void 0;
+  }
+  if (typeof receiver !== "object" || receiver === null) {
+    return void 0;
+  }
+  const owner = receiver.constructor;
+  if (typeof owner !== "function" || owner === Object || owner.name === "") {
+    return void 0;
+  }
+  return owner.name;
+}
+function qualifiedSpanName(receiver, functionName) {
+  if (functionName === void 0) {
+    return void 0;
+  }
+  const owner = spanOwnerName(receiver);
+  return owner === void 0 ? functionName : `${owner}.${functionName}`;
+}
 function autoTraceLimit(value, fallback) {
   return value !== void 0 && Number.isFinite(value) && value >= 0 ? Math.floor(value) : fallback;
 }
@@ -3219,6 +3272,14 @@ var Bitfab = class {
       serviceUrl: this.serviceUrl,
       timeout: this.timeout
     });
+    this.simulationPlan = new SimulationPlan(
+      this.httpClient,
+      config.simulationPlan ?? true
+    );
+    this.httpClient.externalSpanTransform = (payload, submit) => this.applySimulationPlan(payload, submit);
+    this.httpClient.externalTraceTransform = (payload, submit) => this.simulationPlan.sendTrace(payload, submit);
+    this.httpClient.releaseHeldExternalSpans = (timeoutMs) => this.simulationPlan.release(timeoutMs);
+    this.httpClient.stopSimulationPlan = () => this.simulationPlan.stop();
     this.datasets = new DatasetsClient(this.httpClient);
     this.traces = new TracesClient(this.httpClient);
     this.labels = new LabelsClient(this.httpClient);
@@ -3369,6 +3430,7 @@ var Bitfab = class {
   }
   createAutoTraceRoot(traceFunctionKey, name, options, fn) {
     const self = this;
+    self.simulationPlan.refresh();
     const maxDepth = autoTraceLimit(
       options.maxDepth,
       DEFAULT_AUTO_TRACE_MAX_DEPTH
@@ -3379,12 +3441,14 @@ var Bitfab = class {
     );
     const excluded = new Set(options.exclude ?? []);
     const includeWrappers = options.includeWrappers ?? false;
+    const rootNameFor = (receiver) => options.name ?? (fn.name !== "" ? qualifiedSpanName(receiver, name) ?? name : name);
     const rootOptions = {
-      name: options.name ?? name,
+      name: options.name,
+      nameFor: rootNameFor,
       type: options.type ?? "custom",
-      surface: "opt-out"
+      surface: "opt-out",
+      instrumentation: "trace"
     };
-    const rootName = options.name ?? name;
     const buildTracedRoot = (spanOptions) => this.withSpan(
       traceFunctionKey,
       spanOptions,
@@ -3394,6 +3458,7 @@ var Bitfab = class {
           traceFunctionKey
         );
         self.refreshAutoTraceCapturePolicy(traceFunctionKey);
+        self.simulationPlan.refresh();
         let spansUsed = 0;
         let truncated = false;
         const warnTruncated = () => {
@@ -3470,6 +3535,7 @@ var Bitfab = class {
               type: nodeConfiguration?.type ?? "function",
               captureWhen: "nested",
               surface: "opt-out",
+              instrumentation: "trace",
               functionId: definition.id,
               captureContent: nodeConfiguration !== void 0 || capturePolicy === void 0 || capturePolicy.has(definition.id),
               autoTraceDefinition: definition,
@@ -3501,6 +3567,7 @@ var Bitfab = class {
               type: "function",
               captureWhen: "nested",
               surface: "opt-out",
+              instrumentation: "trace",
               captureContent: true,
               ...link !== void 0 && { nestedTrace: link }
             };
@@ -3524,6 +3591,7 @@ var Bitfab = class {
         return tracedRoot.apply(this, args);
       }
       const link = getReplayContext() || inSeedScope() ? void 0 : { traceFunctionKey };
+      const rootName = rootNameFor(this);
       return invokeThroughAutoTraceEntries(
         enclosing,
         (entry, next) => entry.context.invokeNestedRoot(
@@ -3565,38 +3633,36 @@ var Bitfab = class {
     Object.defineProperty(autoTraceRoot, "_bitfabWrappedFn", { value: fn });
     return autoTraceRoot;
   }
+  applySimulationPlan(payload, submit) {
+    this.simulationPlan.send(payload, rootTraceFunctionKeyOf(payload), submit);
+  }
   refreshAutoTraceCapturePolicy(traceFunctionKey) {
-    const now = Date.now();
-    const state = this.autoTracePolicyRefreshes.get(traceFunctionKey) ?? {
-      refreshAfter: 0
-    };
-    if (state.inFlight || now < state.refreshAfter) {
-      return;
-    }
-    const request = this.httpClient.getAutoTracePolicy(
-      traceFunctionKey,
-      AUTO_TRACE_PROTOCOL
-    ).then((policy) => {
-      if (policy.protocol !== AUTO_TRACE_PROTOCOL) {
-        state.refreshAfter = Date.now() + AUTO_TRACE_POLICY_RETRY_MS;
-        return;
-      }
-      const functionIds = Array.isArray(policy.functionIds) ? policy.functionIds.filter(
-        (id) => typeof id === "string" && id.startsWith(`${AUTO_TRACE_PROTOCOL}:`)
-      ).slice(0, DEFAULT_AUTO_TRACE_MAX_SPANS) : [];
-      __setBitfabAutoTraceCapturePolicy(
-        this,
-        traceFunctionKey,
-        policy.revision === null ? void 0 : functionIds
-      );
-      state.refreshAfter = Date.now() + AUTO_TRACE_POLICY_REFRESH_MS;
-    }).catch(() => {
-      state.refreshAfter = Date.now() + AUTO_TRACE_POLICY_RETRY_MS;
-    }).finally(() => {
-      state.inFlight = void 0;
-    });
-    state.inFlight = request;
+    const state = this.autoTracePolicyRefreshes.get(traceFunctionKey) ?? new PolicyRefresh();
     this.autoTracePolicyRefreshes.set(traceFunctionKey, state);
+    state.run(
+      () => this.httpClient.getAutoTracePolicy(
+        traceFunctionKey,
+        AUTO_TRACE_PROTOCOL
+      ),
+      (policy) => {
+        if (policy.protocol !== AUTO_TRACE_PROTOCOL) {
+          state.hold(AUTO_TRACE_POLICY_RETRY_MS);
+          return;
+        }
+        const functionIds = Array.isArray(policy.functionIds) ? policy.functionIds.filter(
+          (id) => typeof id === "string" && id.startsWith(`${AUTO_TRACE_PROTOCOL}:`)
+        ).slice(0, DEFAULT_AUTO_TRACE_MAX_SPANS) : [];
+        __setBitfabAutoTraceCapturePolicy(
+          this,
+          traceFunctionKey,
+          policy.revision === null ? void 0 : functionIds
+        );
+        state.hold(AUTO_TRACE_POLICY_REFRESH_MS);
+      },
+      () => {
+        state.hold(AUTO_TRACE_POLICY_RETRY_MS);
+      }
+    );
   }
   /**
    * Flush and permanently close this client's tracing resources: its pending
@@ -4080,6 +4146,7 @@ var Bitfab = class {
    * @returns A wrapped function with the same signature that creates spans for inputs and outputs
    */
   withSpan(traceFunctionKey, optionsOrFn, maybeFn) {
+    this.simulationPlan.refresh();
     const options = typeof optionsOrFn === "function" ? {} : optionsOrFn;
     const fn = typeof optionsOrFn === "function" ? optionsOrFn : maybeFn;
     const self = this;
@@ -4171,8 +4238,10 @@ var Bitfab = class {
         const testRunId = replayCtxAtStart?.testRunId ?? options.testRunId;
         if (isRootSpan && !activeTraceStates.has(traceId)) {
           const dbSnapshotRef = buildSnapshotRef(self.dbSnapshot, startedAt);
+          self.simulationPlan.refresh();
           activeTraceStates.set(traceId, {
             traceId,
+            traceFunctionKey,
             startedAt,
             contexts: [],
             ...testRunId !== void 0 && { testRunId },
@@ -4187,16 +4256,19 @@ var Bitfab = class {
           registeredTraceId = traceId;
         }
         const functionName = fn.name !== "" ? fn.name : void 0;
+        const rootTraceFunctionKey = activeTraceStates.get(traceId)?.traceFunctionKey ?? traceFunctionKey;
         const baseSpanParams = {
           traceFunctionKey,
+          rootTraceFunctionKey,
           functionName,
-          spanName: options.name ?? functionName ?? traceFunctionKey,
+          spanName: options.name ?? options.nameFor?.(this) ?? qualifiedSpanName(this, functionName) ?? traceFunctionKey,
           traceId,
           spanId,
           parentSpanId,
           inputs,
           startedAt,
           spanType: options.type ?? "custom",
+          instrumentation: options.instrumentation ?? "span",
           functionId: options.functionId,
           captureContent: options.captureContent ?? true,
           autoTraceDefinition: options.autoTraceDefinition,
@@ -4612,6 +4684,7 @@ var Bitfab = class {
    * @returns A BitfabFunction instance for wrapping functions
    */
   getFunction(traceFunctionKey) {
+    this.simulationPlan.refresh();
     return new BitfabFunction(this, traceFunctionKey);
   }
   /**
@@ -4699,6 +4772,7 @@ var Bitfab = class {
       trace_id: params.traceId,
       started_at: params.startedAt,
       ended_at: params.endedAt,
+      span_origin: makeSpanOrigin(params.instrumentation),
       span_data: {
         name: params.spanName,
         type: params.spanType,
@@ -4759,6 +4833,9 @@ var Bitfab = class {
       source: "typescript-sdk-function",
       sourceTraceId: params.traceId,
       traceFunctionKey: params.traceFunctionKey,
+      ...params.rootTraceFunctionKey !== void 0 && {
+        [ROOT_TRACE_FUNCTION_KEY_FIELD]: params.rootTraceFunctionKey
+      },
       rawSpan: externalSpan,
       ...params.testRunId && { testRunId: params.testRunId },
       ...params.mocked && { mocked: true },
@@ -4827,6 +4904,7 @@ var Bitfab = class {
     }
     activeTraceStates.set(traceId, {
       traceId,
+      traceFunctionKey,
       startedAt,
       contexts: [],
       ingestionType: "seeded",
@@ -4836,6 +4914,7 @@ var Bitfab = class {
     try {
       this.sendWrapperSpan({
         traceFunctionKey,
+        rootTraceFunctionKey: traceFunctionKey,
         spanName: options.spanName ?? traceFunctionKey,
         traceId,
         spanId: randomUuid(),
@@ -4845,6 +4924,7 @@ var Bitfab = class {
         startedAt,
         endedAt: startedAt,
         spanType: options.spanType ?? "agent",
+        instrumentation: "span",
         captureContent: true
       });
       this.sendTraceCompletion({
@@ -4890,6 +4970,7 @@ var Bitfab = class {
     }
     activeTraceStates.set(traceId, {
       traceId,
+      traceFunctionKey,
       startedAt: nowIsoTimestamp(),
       contexts: [],
       ingestionType: "seeded",
@@ -4902,7 +4983,7 @@ var Bitfab = class {
       await runWithSeedContext({ traceId }, async () => target(...args));
     } finally {
       try {
-        const { flushTraces: flushTraces2 } = await import("./http-MGES3ZVX.js");
+        const { flushTraces: flushTraces2 } = await import("./http-2OOKOZQ3.js");
         await flushTraces2(3e4);
       } finally {
         unrecorded = activeTraceStates.delete(traceId);
@@ -4961,7 +5042,7 @@ var Bitfab = class {
         `Function is wrapped with trace function key '${wrappedKey}' but replay was called with '${traceFunctionKey}'. Pass matching keys, or pass the unwrapped function to replay it under the explicit key.`
       );
     }
-    const { replay: doReplay } = await import("./replay-5XES2LBL.js");
+    const { replay: doReplay } = await import("./replay-KJKIGXRH.js");
     return doReplay(
       this.httpClient,
       this.serviceUrl,
@@ -5245,7 +5326,7 @@ async function seedFromRegistry(registry, pipeline, cases, options = {}) {
       sessionId: seedCase.sessionId
     })
   );
-  const { flushTraces: flushTraces2 } = await import("./http-MGES3ZVX.js");
+  const { flushTraces: flushTraces2 } = await import("./http-2OOKOZQ3.js");
   await flushTraces2(3e4);
   return { pipeline, traceFunctionKey, traceIds };
 }
@@ -5282,4 +5363,4 @@ export {
   reseedFromRegistry,
   seedFromRegistry
 };
-//# sourceMappingURL=chunk-P26KVTI5.js.map
+//# sourceMappingURL=chunk-ZCOZHNAA.js.map