bitfab 0.57.6 → 0.57.7

package/dist/{http-U3V6WNLO.js → http-AFLRC33F.js}

@@ -6,7 +6,7 @@ import {
   flushTraces,
   parseRetryAfterMs,
   serializePayloadBody
-} from "./chunk-EC7EZXDV.js";
+} from "./chunk-NRUFN7RZ.js";
 export {
   BitfabError,
   HttpClient,
@@ -16,4 +16,4 @@ export {
   parseRetryAfterMs,
   serializePayloadBody
 };
-//# sourceMappingURL=http-U3V6WNLO.js.map
+//# sourceMappingURL=http-AFLRC33F.js.map

package/dist/{http-EYKH2EPD.js → http-ODKUB6M4.js}

@@ -6,7 +6,7 @@ import {
   flushTraces,
   parseRetryAfterMs,
   serializePayloadBody
-} from "./chunk-UTBA3ASY.js";
+} from "./chunk-P4R3NY2U.js";
 import "./chunk-VCRFFCLY.js";
 export {
   BitfabError,
@@ -17,4 +17,4 @@ export {
   parseRetryAfterMs,
   serializePayloadBody
 };
-//# sourceMappingURL=http-EYKH2EPD.js.map
+//# sourceMappingURL=http-ODKUB6M4.js.map

package/dist/index.cjs

@@ -51,7 +51,7 @@ var __version__, __packageName__;
 var init_version_generated = __esm({
   "src/version.generated.ts"() {
     "use strict";
-    __version__ = "0.57.6";
+    __version__ = "0.57.7";
     __packageName__ = "bitfab";
   }
 });
@@ -1064,7 +1064,13 @@ var init_simulationPlan = __esm({
     DISABLE_SIMULATION_PLAN_ENV = "BITFAB_DISABLE_SIM_PLAN";
     ROOT_TRACE_FUNCTION_KEY_FIELD = "rootTraceFunctionKey";
     CONTENT_OFF_KEY = "content_off_by_simulation_plan";
-    CONTENT_KEYS = ["input", "input_meta", "output", "output_meta"];
+    CONTENT_KEYS = [
+      "input",
+      "input_meta",
+      "output",
+      "output_meta",
+      "prompt"
+    ];
     SimulationPlan = class {
       constructor(source, enabled = true) {
         this.source = source;
@@ -1183,13 +1189,13 @@ var init_simulationPlan = __esm({
         }
         return this.loaded;
       }
-      send(payload, traceFunctionKey, submit) {
+      send(payload, traceFunctionKey, submit, drop) {
         this.refresh();
         if (this.disabled() || traceFunctionKey === void 0 || spanNameOf(payload) === void 0 || recordedByFramework(payload)) {
           submit(payload);
           return;
         }
-        const entry = { payload, traceFunctionKey, submit };
+        const entry = { payload, traceFunctionKey, submit, drop };
         if (this.holdingForFirstRead()) {
           this.hold(entry);
           return;
@@ -1243,6 +1249,7 @@ var init_simulationPlan = __esm({
         try {
           entry.submit(this.payloadToSend(entry));
         } catch (error) {
+          entry.drop?.();
           warnOnce(
             "sim-plan-held-span-dropped",
             `a span held for the sim plan was dropped when released: ${error instanceof Error ? error.message : String(error)}`
@@ -2573,23 +2580,21 @@ var init_http = __esm({
         }
         const deadline = Date.now() + Math.max(timeoutMs, 0);
         this.closing = (async () => {
-          const released = await this.releaseHeldExternalSpans?.(
-            planWaitSliceMs(timeoutMs)
+          liveHttpClients.delete(this);
+          const settled2 = await this.settleDeferredWork(
+            Math.max(0, deadline - Date.now())
           );
           this.stopSimulationPlan?.();
+          this.closed = true;
           this.externalSpanTransform = void 0;
           this.externalTraceTransform = void 0;
+          this.frameworkSpanStart = void 0;
           this.releaseHeldExternalSpans = void 0;
           this.stopSimulationPlan = void 0;
-          liveHttpClients.delete(this);
-          const settled2 = await this.settleDeferredWork(
-            Math.max(0, deadline - Date.now())
-          );
-          this.closed = true;
           const transport = this.traceTransport;
           this.traceTransport = void 0;
           const shutdownOk = await transport?.shutdown(Math.max(0, deadline - Date.now())) ?? true;
-          return released !== false && settled2 && shutdownOk;
+          return settled2 && shutdownOk;
         })();
         return this.closing;
       }
@@ -2690,8 +2695,7 @@ var init_http = __esm({
       async getSimulationPlan() {
         return this.get(
           "/api/sdk/sim-plan",
-          SIMULATION_PLAN_READ_TIMEOUT_MS,
-          { Connection: "close" }
+          SIMULATION_PLAN_READ_TIMEOUT_MS
         );
       }
       async getTraceSpan(traceId, lookup) {
@@ -2767,19 +2771,35 @@ var init_http = __esm({
           carrierMeta("internal_trace", body, void 0)
         );
       }
+      reserveFrameworkSpan(traceId, spanId, parentSpanId) {
+        try {
+          this.frameworkSpanStart?.(traceId, spanId, parentSpanId ?? null);
+        } catch (error) {
+          warnOnce(
+            "framework-span-reservation-failed",
+            `a framework span could not be counted toward its trace's span limit: ${describeError(error)}`
+          );
+        }
+      }
       sendExternalSpan(payload) {
         const ref2 = carrierRef(payload);
         if (ref2?.spanId !== void 0) {
           this.traceCompletion.record(ref2.traceId, ref2.spanId);
         }
+        const drop = () => {
+          if (ref2?.spanId !== void 0) {
+            this.traceCompletion.abort(ref2.traceId, ref2.spanId);
+          }
+        };
         const gate = this.externalSpanTransform;
         if (gate === void 0) {
           this.submitExternalSpan(payload);
           return;
         }
         try {
-          gate(payload, (ready) => this.submitExternalSpan(ready));
+          gate(payload, (ready) => this.submitExternalSpan(ready), drop);
         } catch (error) {
+          drop();
           warnDroppedExternalSpan(error);
         }
       }
@@ -4665,6 +4685,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) {
@@ -4944,6 +4969,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;
@@ -6354,6 +6384,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);
@@ -7899,8 +7934,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
+      );
     }
   }
   /**
@@ -8287,22 +8328,68 @@ var BitfabVercelAiHandler = class {
 
 // src/client.ts
 init_warnOnce();
+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);
   }
-  if (spanBudget.spansUsed >= spanBudget.maxSpans) {
-    spanBudget.truncate();
+}
+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;
+  }
+  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;
@@ -8684,7 +8771,6 @@ function readBooleanEnv(name) {
 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";
 function spanOwnerName(receiver) {
   if (typeof receiver === "function") {
     return receiver.name !== "" ? receiver.name : void 0;
@@ -8750,7 +8836,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();
@@ -8946,35 +9033,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) => {
@@ -9014,15 +9097,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;
           }
-          runWithSpanStack(spanStackOf(entry), warnTruncated);
-          return false;
+          spanBudget.spansUsed += 1;
+          if (countsTowardCapturedSubtree) {
+            capturedSubtreeCount += 1;
+          }
+          return true;
         };
         const autoTraceContext = {
           traceFunctionKey,
@@ -9149,11 +9233,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
@@ -9822,6 +9912,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(
@@ -9866,6 +9959,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,
@@ -10418,7 +10515,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 }
       }
     };