bitfab 0.53.0 → 0.53.2

package/dist/{chunk-CBRO6BP7.js → chunk-S4UK5HNW.js}

@@ -94,7 +94,7 @@ function encodeRequestBody(body) {
 }
 
 // src/version.generated.ts
-var __version__ = "0.53.0";
+var __version__ = "0.53.2";
 var __packageName__ = "bitfab";
 
 // src/errors.ts
@@ -415,6 +415,32 @@ function encodePayloadBody(payload) {
   }
 }
 
+// src/spanOrigin.ts
+var FRAMEWORK_INSTRUMENTATIONS = [
+  "openai-agents",
+  "langgraph",
+  "claude-agent-sdk",
+  "vercel-ai"
+];
+var FRAMEWORK_INSTRUMENTATION_SET = new Set(
+  FRAMEWORK_INSTRUMENTATIONS
+);
+
+// src/unrefTimer.ts
+function unrefTimer(timer) {
+  const handle = timer;
+  if (typeof handle.unref === "function") {
+    handle.unref();
+  }
+}
+
+// src/simulationPlan.ts
+var SIMULATION_PLAN_READ_TIMEOUT_MS = 5e3;
+var ROOT_TRACE_FUNCTION_KEY_FIELD = "rootTraceFunctionKey";
+function planWaitSliceMs(timeoutMs) {
+  return Math.min(SIMULATION_PLAN_READ_TIMEOUT_MS, Math.max(timeoutMs, 0) / 2);
+}
+
 // src/traceMetadata.ts
 var activeRecords = /* @__PURE__ */ new Map();
 var completedRecords = /* @__PURE__ */ new Map();
@@ -486,14 +512,6 @@ var DeliveryError = class extends Error {
   }
 };
 
-// src/unrefTimer.ts
-function unrefTimer(timer) {
-  const handle = timer;
-  if (typeof handle.unref === "function") {
-    handle.unref();
-  }
-}
-
 // src/otel.ts
 var OPERATION_ATTRIBUTE = "bitfab.operation";
 var PAYLOAD_ATTRIBUTE = "bitfab.payload";
@@ -1116,6 +1134,18 @@ var RETRYABLE_STATUSES = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
 var EXIT_FLUSH_TIMEOUT_MS = 5e3;
 var DEFAULT_LIFECYCLE_TIMEOUT_MS2 = 3e4;
 var pendingTracePromises = /* @__PURE__ */ new Set();
+var liveHttpClients = /* @__PURE__ */ new Set();
+async function releaseHeldExternalSpans(timeoutMs) {
+  const deadline = Date.now() + Math.max(timeoutMs, 0);
+  for (const client of [...liveHttpClients]) {
+    await client.releaseHeldExternalSpans?.(Math.max(0, deadline - Date.now()));
+  }
+}
+function stopSimulationPlans() {
+  for (const client of [...liveHttpClients]) {
+    client.stopSimulationPlan?.();
+  }
+}
 function awaitOnExit(promise) {
   pendingTracePromises.add(promise);
   void promise.finally(() => {
@@ -1126,7 +1156,10 @@ function awaitOnExit(promise) {
 }
 async function flushTraces(timeoutMs = 5e3) {
   const deadline = Date.now() + Math.max(timeoutMs, 0);
-  const requestsFlushed = await awaitPendingRequests(timeoutMs);
+  await releaseHeldExternalSpans(planWaitSliceMs(timeoutMs));
+  const requestsFlushed = await awaitPendingRequests(
+    Math.max(0, deadline - Date.now())
+  );
   const transportsFlushed = await flushTraceTransports(
     Math.max(0, deadline - Date.now())
   );
@@ -1163,12 +1196,27 @@ if (typeof process !== "undefined" && process.versions != null && process.versio
       return;
     }
     isFlushing = true;
-    void Promise.allSettled([
-      ...Array.from(pendingTracePromises).map((p) => p.catch(() => {
-      })),
-      shutdownTraceTransports(EXIT_FLUSH_TIMEOUT_MS).catch(() => false)
-    ]).then(() => {
+    const planWaitMs = SIMULATION_PLAN_READ_TIMEOUT_MS;
+    const stopFlushing = () => {
       isFlushing = false;
+    };
+    const deadline = setTimeout(
+      stopFlushing,
+      EXIT_FLUSH_TIMEOUT_MS + planWaitMs
+    );
+    unrefTimer(deadline);
+    void releaseHeldExternalSpans(planWaitMs).catch(() => {
+    }).then(() => {
+      stopSimulationPlans();
+    }).then(
+      () => Promise.allSettled([
+        ...Array.from(pendingTracePromises).map((p) => p.catch(() => {
+        })),
+        shutdownTraceTransports(EXIT_FLUSH_TIMEOUT_MS).catch(() => false)
+      ])
+    ).then(() => {
+      clearTimeout(deadline);
+      stopFlushing();
     });
   });
 }
@@ -1262,6 +1310,21 @@ function sourceTraceIdOf(payload) {
   return typeof id === "string" ? id : void 0;
 }
 var carrierSeq = 0;
+function describeError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function warnDroppedExternalSpan(error) {
+  warnOnce(
+    "external-span-dropped",
+    `a span was dropped because the send step failed: ${describeError(error)}`
+  );
+}
+function warnDroppedExternalTrace(error) {
+  warnOnce(
+    "external-trace-dropped",
+    `a trace was dropped because the send step failed: ${describeError(error)}`
+  );
+}
 var HttpClient = class {
   constructor(config) {
     // Only traces a caller asked about are tracked, so ordinary tracing stores
@@ -1276,6 +1339,7 @@ var HttpClient = class {
     this.apiKey = config.apiKey;
     this.serviceUrl = config.serviceUrl;
     this.timeout = config.timeout ?? 12e4;
+    liveHttpClients.add(this);
   }
   /**
    * Resolve the API key at the moment it is needed (request time), invoking
@@ -1473,9 +1537,14 @@ var HttpClient = class {
    * attributing its timeout here would fail a client whose own work succeeded.
    */
   async settleDeferredWork(timeoutMs = DEFAULT_LIFECYCLE_TIMEOUT_MS2) {
+    const deadline = Date.now() + Math.max(timeoutMs, 0);
+    await this.releaseHeldExternalSpans?.(planWaitSliceMs(timeoutMs));
     await replayContextReady.catch(() => {
     });
-    return waitForPromises(Array.from(this.deferredWork), timeoutMs);
+    return waitForPromises(
+      Array.from(this.deferredWork),
+      Math.max(0, deadline - Date.now())
+    );
   }
   /**
    * Wait for spans queued by this client to be delivered, within one deadline.
@@ -1483,7 +1552,9 @@ var HttpClient = class {
    */
   async waitForPendingRequests(timeoutMs = DEFAULT_LIFECYCLE_TIMEOUT_MS2) {
     const deadline = Date.now() + Math.max(timeoutMs, 0);
-    const settled = await this.settleDeferredWork(timeoutMs);
+    const settled = await this.settleDeferredWork(
+      Math.max(0, deadline - Date.now())
+    );
     const flushed = await this.traceTransport?.flush(Math.max(0, deadline - Date.now())) ?? true;
     return settled && flushed;
   }
@@ -1498,6 +1569,13 @@ var HttpClient = class {
     }
     const deadline = Date.now() + Math.max(timeoutMs, 0);
     this.closing = (async () => {
+      await this.releaseHeldExternalSpans?.(planWaitSliceMs(timeoutMs));
+      this.stopSimulationPlan?.();
+      this.externalSpanTransform = void 0;
+      this.externalTraceTransform = void 0;
+      this.releaseHeldExternalSpans = void 0;
+      this.stopSimulationPlan = void 0;
+      liveHttpClients.delete(this);
       const settled = await this.settleDeferredWork(
         Math.max(0, deadline - Date.now())
       );
@@ -1609,6 +1687,13 @@ var HttpClient = class {
       protocol
     });
   }
+  async getSimulationPlan() {
+    return this.get(
+      "/api/sdk/sim-plan",
+      SIMULATION_PLAN_READ_TIMEOUT_MS,
+      { Connection: "close" }
+    );
+  }
   async getTraceSpan(traceId, lookup) {
     const searchParams = new URLSearchParams();
     if (lookup.id !== void 0) {
@@ -1625,14 +1710,18 @@ var HttpClient = class {
    * GET a JSON endpoint on the service with the client's API key. Throws a
    * `BitfabError` carrying the status text for any non-2xx response.
    */
-  async get(endpoint) {
+  async get(endpoint, timeoutMs, extraHeaders) {
     const url = `${this.serviceUrl}${endpoint}`;
+    const timeout = timeoutMs ?? this.timeout;
     const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
     try {
       const response = await fetch(url, {
         method: "GET",
-        headers: { Authorization: `Bearer ${this.resolveApiKey() ?? ""}` },
+        headers: {
+          Authorization: `Bearer ${this.resolveApiKey() ?? ""}`,
+          ...extraHeaders
+        },
         signal: controller.signal
       });
       if (!response.ok) {
@@ -1651,7 +1740,7 @@ var HttpClient = class {
       }
       if (error instanceof Error) {
         if (error.name === "AbortError") {
-          throw new BitfabError(`Request timed out after ${this.timeout}ms`);
+          throw new BitfabError(`Request timed out after ${timeout}ms`);
         }
         throw new BitfabError(error.message);
       }
@@ -1678,16 +1767,27 @@ var HttpClient = class {
       carrierMeta("internal_trace", body, void 0)
     );
   }
-  /**
-   * Queue an external span (from withSpan wrapper or OpenAI tracing) onto this
-   * client's batching transport. Fire-and-forget: the transport owns delivery,
-   * so callers await `flushTraces()` or `close()` rather than a per-span
-   * promise.
-   */
   sendExternalSpan(payload) {
+    const gate = this.externalSpanTransform;
+    if (gate === void 0) {
+      this.submitExternalSpan(payload);
+      return;
+    }
+    try {
+      gate(payload, (ready) => this.submitExternalSpan(ready));
+    } catch (error) {
+      warnDroppedExternalSpan(error);
+    }
+  }
+  submitExternalSpan(payload) {
+    const body = {
+      ...payload,
+      sdkVersion: __version__
+    };
+    delete body[ROOT_TRACE_FUNCTION_KEY_FIELD];
     this.getTraceTransport()?.submit(
       "external_span",
-      { ...payload, sdkVersion: __version__ },
+      body,
       this.recordedMeta("external_span", payload, carrierRef(payload))
     );
   }
@@ -1699,6 +1799,18 @@ var HttpClient = class {
    */
   sendExternalTrace(rawPayload) {
     const payload = mergeCallerMetadataIntoTracePayload(rawPayload);
+    const gate = this.externalTraceTransform;
+    if (gate === void 0) {
+      this.submitExternalTrace(payload);
+      return;
+    }
+    try {
+      gate(payload, (ready) => this.submitExternalTrace(ready));
+    } catch (error) {
+      warnDroppedExternalTrace(error);
+    }
+  }
+  submitExternalTrace(payload) {
     this.getTraceTransport()?.submit(
       "external_trace",
       {
@@ -1943,4 +2055,4 @@ export {
   parseRetryAfterMs,
   HttpClient
 };
-//# sourceMappingURL=chunk-CBRO6BP7.js.map
+//# sourceMappingURL=chunk-S4UK5HNW.js.map