bitfab 0.57.6 → 0.57.8

package/dist/{chunk-ICL6RSND.js → chunk-2E7Q52KB.js}

@@ -17,7 +17,7 @@ import {
   serializeValue,
   toJsonSafe,
   toJsonSafeReport
-} from "./chunk-GT4IDECP.js";
+} from "./chunk-CPVOJHEH.js";
 import {
   BitfabError,
   CONTENT_OFF_KEY,
@@ -37,7 +37,7 @@ import {
   retireTraceMetadata,
   traceIdOf,
   warnOnce
-} from "./chunk-UTBA3ASY.js";
+} from "./chunk-HKRCT4OE.js";
 import {
   __privateAdd,
   __privateGet,
@@ -296,6 +296,11 @@ var BitfabClaudeAgentHandler = class {
     }
     this.runToSpan.set(spanId, spanInfo);
     this.httpClient.traceCompletion.start(spanInfo.traceId, spanInfo.spanId);
+    this.httpClient.reserveFrameworkSpan(
+      spanInfo.traceId,
+      spanInfo.spanId,
+      spanInfo.parentId
+    );
     return spanInfo;
   }
   completeSpan(spanId, output, error, extraContexts) {
@@ -575,6 +580,11 @@ var BitfabClaudeAgentHandler = class {
       this.conversationHistory.push(...this.pendingMessages);
       this.pendingMessages = [];
       this.currentLlmSpanId = randomUuid();
+      this.httpClient.reserveFrameworkSpan(
+        this.ensureTrace(),
+        this.currentLlmSpanId,
+        this.getParentId()
+      );
       this.currentLlmMessageId = messageId ?? null;
       this.currentLlmContent = [];
       this.currentLlmModel = inner.model ?? null;
@@ -1815,6 +1825,11 @@ var BitfabLangGraphCallbackHandler = class {
     this.runToSpan.set(runId, spanInfo);
     if (spanInfo.hidden !== true) {
       this.httpClient.traceCompletion.start(spanInfo.traceId, spanInfo.spanId);
+      this.httpClient.reserveFrameworkSpan(
+        spanInfo.traceId,
+        spanInfo.spanId,
+        spanInfo.parentId
+      );
     }
     if (isRootInvocation) {
       this.sendTraceStart(spanInfo);
@@ -3331,8 +3346,14 @@ var BitfabOpenAITracingProcessor = class {
   async onSpanStart(span) {
     if (span.spanId !== void 0 && span.traceId !== null && span.traceId !== void 0) {
       this.startedSpans.set(span.spanId, span.traceId);
-      const traceId = this.activeSpanMappings[span.traceId]?.traceId ?? span.traceId;
+      const mapping = this.activeSpanMappings[span.traceId];
+      const traceId = mapping?.traceId ?? span.traceId;
       this.httpClient.traceCompletion.start(traceId, span.spanId);
+      this.httpClient.reserveFrameworkSpan(
+        traceId,
+        span.spanId,
+        span.parentId ?? mapping?.spanId
+      );
     }
   }
   /**
@@ -3718,22 +3739,68 @@ var BitfabVercelAiHandler = class {
 };
 
 // src/client.ts
+var TRUNCATION_LIMIT_ORDER = [
+  "max_depth",
+  "max_spans",
+  "max_captured_subtree_spans"
+];
 var activeTraceStates = /* @__PURE__ */ new Map();
-function fitsTraceSpanBudget(payload) {
-  if (!recordedByFramework(payload)) {
-    return true;
+var REFUSED_FRAMEWORK_SPAN_TRACES_RETAINED = 1024;
+var refusedFrameworkSpans = /* @__PURE__ */ new Map();
+function frameworkSpanRefused(traceId, spanId) {
+  return refusedFrameworkSpans.get(traceId)?.has(spanId) === true;
+}
+function refuseFrameworkSpan(traceId, spanId) {
+  const refused = refusedFrameworkSpans.get(traceId);
+  if (refused !== void 0) {
+    refused.add(spanId);
+    return;
   }
-  const traceId = traceIdOf(payload);
-  const spanBudget = traceId === void 0 ? void 0 : activeTraceStates.get(traceId)?.spanBudget;
-  if (spanBudget === void 0) {
-    return true;
+  refusedFrameworkSpans.set(traceId, /* @__PURE__ */ new Set([spanId]));
+  while (refusedFrameworkSpans.size > REFUSED_FRAMEWORK_SPAN_TRACES_RETAINED) {
+    const oldest = refusedFrameworkSpans.keys().next();
+    if (oldest.done) {
+      return;
+    }
+    refusedFrameworkSpans.delete(oldest.value);
+  }
+}
+function reserveFrameworkSpan(traceId, spanId, parentSpanId) {
+  const spanBudget = activeTraceStates.get(traceId)?.spanBudget;
+  const parentRefused = parentSpanId !== null && frameworkSpanRefused(traceId, parentSpanId);
+  if (!parentRefused && (spanBudget === void 0 || spanBudget.spansUsed < spanBudget.maxSpans)) {
+    if (spanBudget !== void 0) {
+      spanBudget.spansUsed += 1;
+    }
+    return;
   }
-  if (spanBudget.spansUsed >= spanBudget.maxSpans) {
-    spanBudget.truncate();
+  refuseFrameworkSpan(traceId, spanId);
+  spanBudget?.truncate("max_spans");
+}
+function isRefusedFrameworkSpan(payload) {
+  if (!recordedByFramework(payload)) {
     return false;
   }
-  spanBudget.spansUsed += 1;
-  return true;
+  const rawSpan = payload.rawSpan;
+  const spanId = rawSpan?.id;
+  if (typeof spanId !== "string") {
+    return false;
+  }
+  const traceIds = [payload.sourceTraceId, traceIdOf(payload)];
+  return traceIds.some(
+    (traceId) => typeof traceId === "string" && frameworkSpanRefused(traceId, spanId)
+  );
+}
+function truncationMetadata(truncation) {
+  if (truncation === void 0 || truncation.limits.size === 0) {
+    return void 0;
+  }
+  return {
+    "bitfab.truncated_by": TRUNCATION_LIMIT_ORDER.filter(
+      (limit) => truncation.limits.has(limit)
+    ).join(","),
+    "bitfab.dropped_spans": truncation.droppedSpans
+  };
 }
 function rootTraceFunctionKeyOfTrace(traceId, fallback) {
   return activeTraceStates.get(traceId)?.traceFunctionKey ?? fallback;
@@ -4113,9 +4180,8 @@ function readBooleanEnv(name) {
   return void 0;
 }
 var DEFAULT_AUTO_TRACE_MAX_DEPTH = 30;
-var DEFAULT_AUTO_TRACE_MAX_SPANS = 2048;
-var DEFAULT_AUTO_TRACE_MAX_CAPTURED_SUBTREE_SPANS = 512;
-var AUTO_TRACE_PROTOCOL = "ts-auto-v1";
+var DEFAULT_AUTO_TRACE_MAX_SPANS = 1e4;
+var DEFAULT_AUTO_TRACE_MAX_CAPTURED_SUBTREE_SPANS = 500;
 function spanOwnerName(receiver) {
   if (typeof receiver === "function") {
     return receiver.name !== "" ? receiver.name : void 0;
@@ -4181,7 +4247,8 @@ var Bitfab = class {
       this.httpClient,
       config.simulationPlan ?? true
     );
-    this.httpClient.externalSpanTransform = (payload, submit) => this.applySimulationPlan(payload, submit);
+    this.httpClient.externalSpanTransform = (payload, submit, drop) => this.applySimulationPlan(payload, submit, drop);
+    this.httpClient.frameworkSpanStart = reserveFrameworkSpan;
     this.httpClient.externalTraceTransform = (payload, submit) => this.simulationPlan.sendTrace(payload, submit);
     this.httpClient.releaseHeldExternalSpans = (timeoutMs) => this.simulationPlan.release(timeoutMs);
     this.httpClient.stopSimulationPlan = () => this.simulationPlan.stop();
@@ -4377,35 +4444,31 @@ var Bitfab = class {
       function(...args) {
         self.simulationPlan.refresh();
         let capturedSubtreeCount = 0;
-        let truncated = false;
-        const warnTruncated = () => {
-          if (!truncated) {
-            truncated = true;
-            getCurrentTrace().setMetadata({
-              bitfabAutoTrace: {
-                protocol: AUTO_TRACE_PROTOCOL,
-                truncated: true,
-                maxDepth,
-                maxSpans,
-                maxCapturedSubtreeSpans
-              }
-            });
-          }
+        const rootSpanStack = getSpanStack();
+        const rootSpan = rootSpanStack[rootSpanStack.length - 1];
+        const rootTraceState = rootSpan === void 0 ? void 0 : activeTraceStates.get(rootSpan.traceId);
+        const truncation = rootTraceState?.truncation ?? {
+          limits: /* @__PURE__ */ new Set(),
+          droppedSpans: 0
+        };
+        const truncate = (limit) => {
+          truncation.limits.add(limit);
+          truncation.droppedSpans += 1;
           warnOnce(
             `auto-trace-truncated:${traceFunctionKey}`,
             `"${traceFunctionKey}" hit an automatic subtree capture limit (maxDepth=${maxDepth}, maxCapturedSubtreeSpans=${maxCapturedSubtreeSpans}, maxSpans=${maxSpans}); its trace is incomplete. Raise the limits, declare the calls you need with node(), or narrow the subtree with exclude.`
           );
         };
-        const rootSpanStack = getSpanStack();
         const spanBudget = {
           spansUsed: 1,
           maxSpans,
-          truncate: () => runWithSpanStack(rootSpanStack, warnTruncated)
+          truncate
         };
-        const rootSpan = rootSpanStack[rootSpanStack.length - 1];
-        const rootTraceState = rootSpan === void 0 ? void 0 : activeTraceStates.get(rootSpan.traceId);
-        if (rootTraceState !== void 0 && rootTraceState.spanBudget === void 0) {
-          rootTraceState.spanBudget = spanBudget;
+        if (rootTraceState !== void 0) {
+          rootTraceState.truncation = truncation;
+          if (rootTraceState.spanBudget === void 0) {
+            rootTraceState.spanBudget = spanBudget;
+          }
         }
         const spanStackOf = (entry) => entry.spanStack;
         const openChild = (entry, childOptions, inputs, isAsync, invokeFn) => {
@@ -4445,15 +4508,16 @@ var Bitfab = class {
             rootTraceFunctionKeyOfEntry(entry),
             spanName
           );
-          if (entry.depth < maxDepth && spanBudget.spansUsed < maxSpans && (!countsTowardCapturedSubtree || capturedSubtreeCount < maxCapturedSubtreeSpans)) {
-            spanBudget.spansUsed += 1;
-            if (countsTowardCapturedSubtree) {
-              capturedSubtreeCount += 1;
-            }
-            return true;
+          const refusedBy = entry.depth >= maxDepth ? "max_depth" : spanBudget.spansUsed >= maxSpans ? "max_spans" : countsTowardCapturedSubtree && capturedSubtreeCount >= maxCapturedSubtreeSpans ? "max_captured_subtree_spans" : void 0;
+          if (refusedBy !== void 0) {
+            truncate(refusedBy);
+            return false;
+          }
+          spanBudget.spansUsed += 1;
+          if (countsTowardCapturedSubtree) {
+            capturedSubtreeCount += 1;
           }
-          runWithSpanStack(spanStackOf(entry), warnTruncated);
-          return false;
+          return true;
         };
         const autoTraceContext = {
           traceFunctionKey,
@@ -4580,11 +4644,17 @@ var Bitfab = class {
     Object.defineProperty(autoTraceRoot, "_bitfabWrappedFn", { value: fn });
     return autoTraceRoot;
   }
-  applySimulationPlan(payload, submit) {
-    if (!fitsTraceSpanBudget(payload)) {
+  applySimulationPlan(payload, submit, drop) {
+    if (isRefusedFrameworkSpan(payload)) {
+      drop();
       return;
     }
-    this.simulationPlan.send(payload, rootTraceFunctionKeyOf(payload), submit);
+    this.simulationPlan.send(
+      payload,
+      rootTraceFunctionKeyOf(payload),
+      submit,
+      drop
+    );
   }
   /**
    * Flush and permanently close this client's tracing resources: its pending
@@ -5253,6 +5323,9 @@ var Bitfab = class {
           registeredTraceId = traceId;
         }
         self.httpClient.traceCompletion.start(traceId, spanId);
+        if (isFrameworkInstrumentation(options.instrumentation)) {
+          reserveFrameworkSpan(traceId, spanId, parentSpanId);
+        }
         startedSpan = { traceId, spanId };
         const functionName = fn.name !== "" ? fn.name : void 0;
         const rootTraceFunctionKey = rootTraceFunctionKeyOfTrace(
@@ -5297,6 +5370,10 @@ var Bitfab = class {
             }
             if (isRootSpan) {
               const traceState = activeTraceStates.get(traceId);
+              const truncated = truncationMetadata(traceState?.truncation);
+              if (truncated !== void 0) {
+                recordCallerTraceMetadata(traceId, truncated);
+              }
               self.sendTraceCompletion({
                 traceFunctionKey,
                 traceId,
@@ -5849,7 +5926,7 @@ var Bitfab = class {
         ...params.captureContent && params.contexts && params.contexts.length > 0 && {
           contexts: params.contexts
         },
-        ...params.captureContent && params.prompt !== void 0 && { prompt: params.prompt },
+        ...buildsContent && params.prompt !== void 0 && { prompt: params.prompt },
         ...contentOff && { [CONTENT_OFF_KEY]: true }
       }
     };
@@ -6016,7 +6093,7 @@ var Bitfab = class {
       await runWithSeedContext({ traceId }, async () => target(...args));
     } finally {
       try {
-        const { flushTraces: flushTraces2 } = await import("./http-EYKH2EPD.js");
+        const { flushTraces: flushTraces2 } = await import("./http-2EGLRQUQ.js");
         await flushTraces2(3e4);
       } finally {
         unrecorded = activeTraceStates.delete(traceId);
@@ -6075,7 +6152,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-W2KNVMMJ.js");
+    const { replay: doReplay } = await import("./replay-BWUZ2NDQ.js");
     return doReplay(
       this.httpClient,
       this.serviceUrl,
@@ -6395,7 +6472,7 @@ async function seedFromRegistry(registry, pipeline, cases, options = {}) {
       sessionId: seedCase.sessionId
     })
   );
-  const { flushTraces: flushTraces2 } = await import("./http-EYKH2EPD.js");
+  const { flushTraces: flushTraces2 } = await import("./http-2EGLRQUQ.js");
   await flushTraces2(3e4);
   return { pipeline, traceFunctionKey, traceIds };
 }
@@ -6434,4 +6511,4 @@ export {
   reseedFromRegistry,
   seedFromRegistry
 };
-//# sourceMappingURL=chunk-ICL6RSND.js.map
+//# sourceMappingURL=chunk-2E7Q52KB.js.map