@bitfab/sdk 0.33.7 → 0.34.0

package/dist/{chunk-DZJ5K75J.js → chunk-ESKBRHVG.js}

@@ -1,5 +1,7 @@
 import {
   BitfabError,
+  DEFAULT_SERVICE_URL,
+  HttpClient,
   __privateAdd,
   __privateGet,
   __privateSet,
@@ -14,513 +16,7 @@ import {
   toJsonSafe,
   toJsonSafeReport,
   warnOnce
-} from "./chunk-DPV6PBWE.js";
-
-// src/version.generated.ts
-var __version__ = "0.33.7";
-
-// src/constants.ts
-var DEFAULT_SERVICE_URL = "https://bitfab.ai";
-
-// src/unrefTimer.ts
-function unrefTimer(timer) {
-  const handle = timer;
-  if (typeof handle.unref === "function") {
-    handle.unref();
-  }
-}
-
-// src/http.ts
-var REPLAY_DB_BRANCH_REQUEST_TIMEOUT_MS = 3e5;
-function serializePayloadBody(payload) {
-  try {
-    return { body: JSON.stringify(payload), dropped: [] };
-  } catch {
-    const dropped = [];
-    const sanitize = (value, seen) => {
-      const t = typeof value;
-      if (value === null || t === "string" || t === "number" || t === "boolean") {
-        return value;
-      }
-      if (t === "bigint") {
-        dropped.push("BigInt");
-        return "<unserializable: BigInt>";
-      }
-      if (t === "function") {
-        const name = value.name || "Function";
-        dropped.push(name);
-        return `<unserializable: ${name}>`;
-      }
-      if (t === "symbol") {
-        dropped.push("Symbol");
-        return "<unserializable: Symbol>";
-      }
-      if (t !== "object") {
-        return void 0;
-      }
-      const obj = value;
-      const className = obj.constructor?.name || "object";
-      if (seen.has(obj)) {
-        dropped.push(className);
-        return `<cycle: ${className}>`;
-      }
-      seen.add(obj);
-      let result;
-      if (Array.isArray(obj)) {
-        result = obj.map((item) => sanitize(item, seen));
-      } else if (typeof obj.toJSON === "function") {
-        try {
-          result = sanitize(obj.toJSON(), seen);
-        } catch {
-          dropped.push(className);
-          result = `<unserializable: ${className}>`;
-        }
-      } else {
-        try {
-          const out = {};
-          for (const [k, v] of Object.entries(obj)) {
-            out[k] = sanitize(v, seen);
-          }
-          result = out;
-        } catch {
-          warnOnce(
-            "payload:field-getter-threw",
-            "a value with a throwing getter/proxy could not be serialized into a span payload; it was replaced with a placeholder. The span still ships with its other fields intact."
-          );
-          dropped.push(className);
-          result = `<unserializable: ${className}>`;
-        }
-      }
-      seen.delete(obj);
-      return result;
-    };
-    let sanitized;
-    try {
-      sanitized = sanitize(payload, /* @__PURE__ */ new WeakSet());
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      return {
-        body: JSON.stringify({ error: `payload_serialize_failed: ${message}` }),
-        dropped
-      };
-    }
-    if (dropped.length > 0 && typeof sanitized === "object" && sanitized !== null && !Array.isArray(sanitized)) {
-      const obj = sanitized;
-      const existing = Array.isArray(obj.errors) ? obj.errors : [];
-      obj.errors = [
-        ...existing,
-        {
-          source: "sdk",
-          step: "json_serialize",
-          error: `stubbed non-serializable value(s): ${[
-            ...new Set(dropped)
-          ].join(", ")}`
-        }
-      ];
-    }
-    return { body: JSON.stringify(sanitized), dropped };
-  }
-}
-var pendingTracePromises = /* @__PURE__ */ new Set();
-function awaitOnExit(promise) {
-  pendingTracePromises.add(promise);
-  void promise.finally(() => {
-    pendingTracePromises.delete(promise);
-  }).catch(() => {
-  });
-  return promise;
-}
-async function flushTraces(timeoutMs = 5e3) {
-  if (pendingTracePromises.size === 0) {
-    return;
-  }
-  let timer;
-  try {
-    await Promise.race([
-      Promise.allSettled(Array.from(pendingTracePromises)),
-      new Promise((resolve) => {
-        timer = setTimeout(resolve, timeoutMs);
-        unrefTimer(timer);
-      })
-    ]);
-  } finally {
-    if (timer) {
-      clearTimeout(timer);
-    }
-  }
-}
-if (typeof process !== "undefined" && process.versions != null && process.versions.node != null) {
-  let isFlushing = false;
-  process.on("beforeExit", () => {
-    if (pendingTracePromises.size > 0 && !isFlushing) {
-      isFlushing = true;
-      Promise.allSettled(
-        Array.from(pendingTracePromises).map(
-          (p) => p.catch(() => {
-          })
-        )
-      ).then(() => {
-        isFlushing = false;
-      }).catch(() => {
-        isFlushing = false;
-      });
-    }
-  });
-}
-var HttpClient = class {
-  constructor(config) {
-    this.apiKey = config.apiKey;
-    this.serviceUrl = config.serviceUrl;
-    this.timeout = config.timeout ?? 12e4;
-  }
-  /**
-   * Resolve the API key at the moment it is needed (request time), invoking
-   * the function form if one was supplied. Never read at construction.
-   */
-  resolveApiKey() {
-    return typeof this.apiKey === "function" ? this.apiKey() : this.apiKey;
-  }
-  /**
-   * Make an HTTP request to the Bitfab API. Defaults to POST; pass
-   * `options.method` to use a different verb (e.g. "PATCH").
-   *
-   * @param endpoint - The API endpoint (without base URL)
-   * @param payload - The request body
-   * @param options - Optional request options
-   * @returns The parsed JSON response
-   * @throws {BitfabError} If the request fails
-   */
-  async request(endpoint, payload, options) {
-    const url = `${this.serviceUrl}${endpoint}`;
-    const timeout = options?.timeout ?? this.timeout;
-    const method = options?.method ?? "POST";
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), timeout);
-    const { body, dropped } = serializePayloadBody(payload);
-    if (dropped.length > 0) {
-      try {
-        console.warn(
-          `Bitfab: request body to ${endpoint} held ${dropped.length} non-serializable value(s) (${[...new Set(dropped)].join(", ")}); they were stubbed so the span still sends, but the trace may be incomplete or not replayable. Capture a JSON-safe projection of this input to make it replayable.`
-        );
-      } catch {
-      }
-    }
-    try {
-      const response = await fetch(url, {
-        method,
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${this.resolveApiKey() ?? ""}`
-        },
-        body,
-        signal: controller.signal
-      });
-      if (!response.ok) {
-        const errorText = await response.text();
-        throw new BitfabError(
-          `HTTP ${response.status}: ${errorText.slice(0, 500)}`
-        );
-      }
-      const result = await response.json();
-      if (result.error) {
-        if (result.url) {
-          throw new BitfabError(
-            `${result.error} Configure it at: ${this.serviceUrl}${result.url}`,
-            result.url
-          );
-        }
-        throw new BitfabError(result.error);
-      }
-      return result;
-    } catch (error) {
-      if (error instanceof BitfabError) {
-        throw error;
-      }
-      if (error instanceof Error) {
-        if (error.name === "AbortError") {
-          throw new BitfabError(`Request timed out after ${timeout}ms`);
-        }
-        throw new BitfabError(error.message);
-      }
-      throw new BitfabError("Unknown error occurred");
-    } finally {
-      clearTimeout(timeoutId);
-    }
-  }
-  /**
-   * Look up a function by name.
-   * Blocks until complete - needed for function execution.
-   */
-  async lookupFunction(name) {
-    return this.request("/api/sdk/functions/lookup", { name });
-  }
-  async getTraceSpan(traceId, lookup) {
-    const searchParams = new URLSearchParams();
-    if (lookup.id !== void 0) {
-      searchParams.set("id", lookup.id);
-    } else {
-      searchParams.set("name", lookup.name);
-      searchParams.set("occurrence", String(lookup.occurrence ?? "last"));
-    }
-    const endpoint = `/api/sdk/traces/${encodeURIComponent(traceId)}/span?${searchParams.toString()}`;
-    const response = await this.get(endpoint);
-    return response.span;
-  }
-  async get(endpoint) {
-    const url = `${this.serviceUrl}${endpoint}`;
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
-    try {
-      const response = await fetch(url, {
-        method: "GET",
-        headers: { Authorization: `Bearer ${this.resolveApiKey() ?? ""}` },
-        signal: controller.signal
-      });
-      if (!response.ok) {
-        const errorText = await response.text();
-        throw new BitfabError(
-          `HTTP ${response.status}: ${errorText.slice(0, 500)}`
-        );
-      }
-      return await response.json();
-    } catch (error) {
-      if (error instanceof BitfabError) {
-        throw error;
-      }
-      if (error instanceof Error) {
-        if (error.name === "AbortError") {
-          throw new BitfabError(`Request timed out after ${this.timeout}ms`);
-        }
-        throw new BitfabError(error.message);
-      }
-      throw new BitfabError("Unknown error occurred");
-    } finally {
-      clearTimeout(timeoutId);
-    }
-  }
-  /**
-   * Send an internal trace (from BAML execution).
-   * Fire-and-forget with awaitOnExit - doesn't block the caller.
-   */
-  sendInternalTrace(functionId, payload) {
-    void awaitOnExit(
-      this.request(`/api/sdk/functions/${functionId}/traces`, {
-        ...payload,
-        sdkVersion: __version__
-      })
-    ).catch((error) => {
-      try {
-        console.error("Bitfab: Failed to create trace:", error);
-      } catch {
-      }
-    });
-  }
-  /**
-   * Send an external span (from withSpan wrapper or OpenAI tracing).
-   * Fire-and-forget with awaitOnExit - doesn't block the caller.
-   * Returns the tracked promise so callers can optionally await it.
-   */
-  sendExternalSpan(payload) {
-    return awaitOnExit(
-      this.request("/api/sdk/externalSpans", {
-        ...payload,
-        sdkVersion: __version__
-      })
-    ).catch((error) => {
-      try {
-        console.error("Bitfab: Failed to create external span:", error);
-      } catch {
-      }
-    });
-  }
-  /**
-   * Send an external trace (from OpenAI tracing).
-   * Fire-and-forget with awaitOnExit - doesn't block the caller.
-   * Returns the tracked promise so callers can optionally await it
-   * (the replay path does, so trace completions are persisted before
-   * `completeReplay` builds the trace-ID mapping).
-   */
-  sendExternalTrace(payload) {
-    return awaitOnExit(
-      this.request("/api/sdk/externalTraces", {
-        ...payload,
-        sdkVersion: __version__
-      })
-    ).catch((error) => {
-      try {
-        console.error("Bitfab: Failed to create external trace:", error);
-      } catch {
-      }
-    });
-  }
-  /**
-   * Partial update of an existing trace identified by its Bitfab trace ID.
-   * Used by the detached `client.getTrace(id)` handle. Fire-and-forget;
-   * returns a tracked promise that callers may optionally await.
-   */
-  patchTrace(traceId, payload) {
-    const endpoint = `/api/sdk/traces/${encodeURIComponent(traceId)}`;
-    return awaitOnExit(
-      this.request(endpoint, payload, { method: "PATCH" })
-    ).catch((error) => {
-      try {
-        console.error("Bitfab: Failed to patch trace:", error);
-      } catch {
-      }
-    });
-  }
-  /**
-   * Start a replay session by fetching historical traces.
-   * Blocking call - creates a test run and returns lightweight item references.
-   */
-  async startReplay(traceFunctionKey, limit, traceIds, name, codeChangeDescription, codeChangeFiles, includeDbBranchLease, experimentGroupId, datasetId, graderIds, dbBranchSettings) {
-    const payload = { traceFunctionKey };
-    if (limit !== void 0) {
-      payload.limit = limit;
-    }
-    if (traceIds) {
-      payload.traceIds = traceIds;
-    }
-    if (name !== void 0) {
-      payload.name = name;
-    }
-    if (codeChangeDescription !== void 0) {
-      payload.codeChangeDescription = codeChangeDescription;
-    }
-    if (codeChangeFiles !== void 0) {
-      payload.codeChangeFiles = codeChangeFiles;
-    }
-    if (includeDbBranchLease) {
-      payload.includeDbBranchLease = true;
-      payload.lazyDbBranchLease = true;
-    }
-    if (experimentGroupId !== void 0) {
-      payload.experimentGroupId = experimentGroupId;
-    }
-    if (datasetId !== void 0) {
-      payload.datasetId = datasetId;
-    }
-    if (graderIds !== void 0) {
-      payload.graderIds = graderIds;
-    }
-    if (dbBranchSettings !== void 0) {
-      payload.dbBranchSettings = dbBranchSettings;
-    }
-    const timeout = includeDbBranchLease ? REPLAY_DB_BRANCH_REQUEST_TIMEOUT_MS : 3e4;
-    return this.request("/api/sdk/replay/start", payload, {
-      timeout
-    });
-  }
-  /**
-   * Fetch an external span by ID.
-   * Blocking GET request.
-   */
-  async getExternalSpan(spanId) {
-    const url = `${this.serviceUrl}/api/sdk/externalSpans/${spanId}`;
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), 3e4);
-    try {
-      const response = await fetch(url, {
-        method: "GET",
-        headers: { Authorization: `Bearer ${this.resolveApiKey() ?? ""}` },
-        signal: controller.signal
-      });
-      if (!response.ok) {
-        const errorText = await response.text();
-        throw new BitfabError(
-          `HTTP ${response.status}: ${errorText.slice(0, 500)}`
-        );
-      }
-      return await response.json();
-    } catch (error) {
-      if (error instanceof BitfabError) {
-        throw error;
-      }
-      if (error instanceof Error) {
-        if (error.name === "AbortError") {
-          throw new BitfabError("Request timed out after 30000ms");
-        }
-        throw new BitfabError(error.message);
-      }
-      throw new BitfabError("Unknown error occurred");
-    } finally {
-      clearTimeout(timeoutId);
-    }
-  }
-  /**
-   * Fetch the span tree for a root span.
-   * Blocking GET request.
-   *
-   * Pass `includeOutputs: false` for a payload-free tree (structure +
-   * `externalSpanId` only), so recorded outputs are fetched lazily per mocked
-   * span instead of all up front. Omit it (default eager) for `mock: "all"`.
-   */
-  async getSpanTree(externalSpanId, options) {
-    const query = options?.includeOutputs === false ? "?includeOutputs=false" : "";
-    const url = `${this.serviceUrl}/api/sdk/replay/spanTree/${externalSpanId}${query}`;
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), 3e4);
-    try {
-      const response = await fetch(url, {
-        method: "GET",
-        headers: { Authorization: `Bearer ${this.resolveApiKey() ?? ""}` },
-        signal: controller.signal
-      });
-      if (!response.ok) {
-        const errorText = await response.text();
-        throw new BitfabError(
-          `HTTP ${response.status}: ${errorText.slice(0, 500)}`
-        );
-      }
-      return await response.json();
-    } catch (error) {
-      if (error instanceof BitfabError) {
-        throw error;
-      }
-      if (error instanceof Error) {
-        if (error.name === "AbortError") {
-          throw new BitfabError("Request timed out after 30000ms");
-        }
-        throw new BitfabError(error.message);
-      }
-      throw new BitfabError("Unknown error occurred");
-    } finally {
-      clearTimeout(timeoutId);
-    }
-  }
-  /**
-   * Mark a replay test run as completed.
-   * Blocking call.
-   */
-  async completeReplay(testRunId) {
-    return this.request(
-      "/api/sdk/replay/complete",
-      { testRunId },
-      { timeout: 3e4 }
-    );
-  }
-  /**
-   * Ask the server to materialize a per-trace DB branch lease from a
-   * captured `dbSnapshotRef`. Blocking - the resolver creates a Neon
-   * snapshot + preview branch and polls operations to readiness, which
-   * can take seconds.
-   */
-  async resolveDbBranchLease(testRunId, traceId, dbBranchSettings) {
-    return this.request(
-      "/api/sdk/replay/resolveDbBranchLease",
-      { testRunId, traceId, dbBranchSettings },
-      { timeout: REPLAY_DB_BRANCH_REQUEST_TIMEOUT_MS }
-    );
-  }
-  /** Release a previously-resolved DB branch by deleting its Neon branch. Idempotent server-side. */
-  async releaseDbBranchLease(neonBranchId) {
-    await this.request(
-      "/api/sdk/replay/releaseDbBranchLease",
-      { neonBranchId },
-      { timeout: 3e4 }
-    );
-  }
-};
+} from "./chunk-4J36FZ4K.js";
 
 // src/processorPayload.ts
 var SERIALIZATION_DEGRADED_STEP = "serialization_degraded";
@@ -641,7 +137,8 @@ var BitfabClaudeAgentHandler = class {
     // its root. The prompt is not present anywhere in the message stream, so it
     // must be handed in explicitly.
     this.hasRootInput = false;
-    this.httpClient = new HttpClient({
+    this.ownsHttpClient = config._httpClient === void 0;
+    this.httpClient = config._httpClient ?? new HttpClient({
       apiKey: config.apiKey,
       serviceUrl: config.serviceUrl ?? DEFAULT_SERVICE_URL,
       timeout: config.timeout ?? 1e4
@@ -654,6 +151,14 @@ var BitfabClaudeAgentHandler = class {
     this.subagentStartHook = this.subagentStartHook.bind(this);
     this.subagentStopHook = this.subagentStopHook.bind(this);
   }
+  /**
+   * Flush and release the span transport this handler started. A no-op when
+   * the handler borrowed a `Bitfab` client's HTTP client: that client's
+   * `close()` owns the worker's lifetime.
+   */
+  async close(timeoutMs) {
+    return this.ownsHttpClient ? this.httpClient.close(timeoutMs) : true;
+  }
   // ── trace lifecycle ──────────────────────────────────────────
   ensureTrace() {
     if (this.traceId !== null) {
@@ -1659,7 +1164,8 @@ var BitfabLangGraphCallbackHandler = class {
     this.ignoreCustomEvent = true;
     this.runToSpan = /* @__PURE__ */ new Map();
     this.invocations = /* @__PURE__ */ new Map();
-    this.httpClient = new HttpClient({
+    this.ownsHttpClient = config._httpClient === void 0;
+    this.httpClient = config._httpClient ?? new HttpClient({
       apiKey: config.apiKey,
       serviceUrl: config.serviceUrl ?? DEFAULT_SERVICE_URL,
       timeout: config.timeout ?? 1e4
@@ -1667,6 +1173,14 @@ var BitfabLangGraphCallbackHandler = class {
     this.traceFunctionKey = config.traceFunctionKey;
     this.getActiveSpanContext = config.getActiveSpanContext ?? null;
   }
+  /**
+   * Flush and release the span transport this handler started. A no-op when
+   * the handler borrowed a `Bitfab` client's HTTP client: that client's
+   * `close()` owns the worker's lifetime.
+   */
+  async close(timeoutMs) {
+    return this.ownsHttpClient ? this.httpClient.close(timeoutMs) : true;
+  }
   // ── lifecycle helpers ──────────────────────────────────────────
   startSpan(runId, parentRunId, name, spanType, inputData, metadata, tags) {
     const parentSpan = parentRunId ? this.runToSpan.get(parentRunId) : void 0;
@@ -2138,7 +1652,8 @@ var BitfabOpenAITracingProcessor = class {
     this.activeTraces = {};
     this.activeSpanMappings = {};
     this.canonicalTraceIds = {};
-    this.httpClient = new HttpClient({
+    this.ownsHttpClient = config._httpClient === void 0;
+    this.httpClient = config._httpClient ?? new HttpClient({
       apiKey: config.apiKey,
       serviceUrl: config.serviceUrl ?? DEFAULT_SERVICE_URL,
       timeout: config.timeout ?? 1e4
@@ -2154,6 +1669,14 @@ var BitfabOpenAITracingProcessor = class {
     this.canonicalTraceIds[sourceTraceId] = created;
     return created;
   }
+  /**
+   * Flush and release the span transport this processor started. A no-op when
+   * the processor borrowed a `Bitfab` client's HTTP client: that client's
+   * `close()` owns the worker's lifetime.
+   */
+  async close(timeoutMs) {
+    return this.ownsHttpClient ? this.httpClient.close(timeoutMs) : true;
+  }
   /**
    * Called when a trace is started.
    * If there's an active withSpan context, the trace ID is remapped to the
@@ -2208,14 +1731,16 @@ var BitfabOpenAITracingProcessor = class {
    * Called when a trace is being flushed.
    */
   async forceFlush() {
+    await this.httpClient.waitForPendingRequests();
   }
   /**
    * Called when the trace processor is shutting down.
    */
-  async shutdown(_timeout) {
+  async shutdown(timeout) {
     this.activeTraces = {};
     this.activeSpanMappings = {};
     this.canonicalTraceIds = {};
+    await this.close(timeout);
   }
   /**
    * Send trace to Bitfab API (fire-and-forget).
@@ -2481,7 +2006,6 @@ var BitfabVercelAiHandler = class {
 
 // src/client.ts
 var activeTraceStates = /* @__PURE__ */ new Map();
-var pendingSpanPromises = /* @__PURE__ */ new Map();
 var asyncLocalStorage = null;
 var SPAN_CONTEXT_STORAGE_SYMBOL = /* @__PURE__ */ Symbol.for("bitfab.spanContextStorage");
 var initializeAsyncContext = () => {
@@ -2837,6 +2361,23 @@ var Bitfab = class {
       timeout: this.timeout
     });
   }
+  /**
+   * Flush and permanently close this client's tracing resources: its pending
+   * requests and the single span-transport worker shared by its decorators and
+   * framework handlers.
+   *
+   * Resolves `false` when delivery failed or the deadline expired. Long-lived
+   * processes never need this (the transport batches in the background and the
+   * exit hook drains it); scripts and tests that want a hard guarantee should
+   * await it.
+   *
+   * Deliberately not a `Symbol.asyncDispose` method: the SDK targets runtimes
+   * where that symbol may be absent, and a computed key on a missing symbol
+   * throws at class-definition time, taking the whole SDK down on load.
+   */
+  close(timeoutMs) {
+    return this.httpClient.close(timeoutMs);
+  }
   /**
    * Resolve the API key lazily, the first time a span actually needs it.
    *
@@ -2986,7 +2527,8 @@ var Bitfab = class {
       getActiveSpanContext: () => {
         const stack = getSpanStack();
         return stack[stack.length - 1] ?? null;
-      }
+      },
+      _httpClient: this.httpClient
     });
   }
   /**
@@ -3046,7 +2588,8 @@ var Bitfab = class {
       getActiveSpanContext: () => {
         const stack = getSpanStack();
         return stack[stack.length - 1] ?? null;
-      }
+      },
+      _httpClient: this.httpClient
     });
   }
   /**
@@ -3098,7 +2641,8 @@ var Bitfab = class {
       getActiveSpanContext: () => {
         const stack = getSpanStack();
         return stack[stack.length - 1] ?? null;
-      }
+      },
+      _httpClient: this.httpClient
     });
   }
   /**
@@ -3351,7 +2895,6 @@ var Bitfab = class {
             },
             dbSnapshotRef
           });
-          pendingSpanPromises.set(traceId, []);
           registeredTraceId = traceId;
         }
         const functionName = fn.name !== "" ? fn.name : void 0;
@@ -3366,57 +2909,29 @@ var Bitfab = class {
           startedAt,
           spanType: options.type ?? "custom"
         };
-        const sendSpan = async (params, spanOpts) => {
+        const sendSpan = async (params) => {
           const replayCtx = getReplayContext();
-          const persistenceCollector = isRootSpan ? replayCtx?.pendingPersistence : void 0;
-          let resolvePersistence;
-          if (persistenceCollector && !spanOpts?.skipPersistenceRegistration) {
-            persistenceCollector.push(
-              new Promise((resolve) => {
-                resolvePersistence = resolve;
-              })
-            );
-          }
           try {
             const endedAt = (/* @__PURE__ */ new Date()).toISOString();
             const traceDropped = activeTraceStates.get(traceId)?.dropped === true;
-            const spanPromise = traceDropped ? Promise.resolve() : self.sendWrapperSpan({
-              ...baseSpanParams,
-              ...params,
-              contexts: newContext.contexts,
-              prompt: newContext.prompt,
-              endedAt,
-              ...replayCtx?.testRunId && {
-                testRunId: replayCtx.testRunId
-              },
-              ...replayCtx?.inputSourceSpanId && {
-                inputSourceSpanId: replayCtx.inputSourceSpanId
-              }
-            });
-            if (isRootSpan) {
-              const pending = pendingSpanPromises.get(traceId) ?? [];
-              pending.push(spanPromise);
-              if (persistenceCollector) {
-                await Promise.allSettled(pending);
-              } else {
-                let raceTimer;
-                try {
-                  await Promise.race([
-                    Promise.allSettled(pending),
-                    new Promise((resolve) => {
-                      raceTimer = setTimeout(resolve, 5e3);
-                      unrefTimer(raceTimer);
-                    })
-                  ]);
-                } finally {
-                  if (raceTimer) {
-                    clearTimeout(raceTimer);
-                  }
+            if (!traceDropped) {
+              self.sendWrapperSpan({
+                ...baseSpanParams,
+                ...params,
+                contexts: newContext.contexts,
+                prompt: newContext.prompt,
+                endedAt,
+                ...replayCtx?.testRunId && {
+                  testRunId: replayCtx.testRunId
+                },
+                ...replayCtx?.inputSourceSpanId && {
+                  inputSourceSpanId: replayCtx.inputSourceSpanId
                 }
-              }
-              pendingSpanPromises.delete(traceId);
+              });
+            }
+            if (isRootSpan) {
               const traceState = activeTraceStates.get(traceId);
-              const completionPromise = self.sendTraceCompletion({
+              self.sendTraceCompletion({
                 traceFunctionKey,
                 traceId,
                 startedAt: traceState?.startedAt ?? startedAt,
@@ -3442,20 +2957,8 @@ var Bitfab = class {
                 }
               });
               activeTraceStates.delete(traceId);
-              if (persistenceCollector) {
-                await completionPromise;
-              }
-            } else {
-              const pending = pendingSpanPromises.get(traceId);
-              if (pending) {
-                pending.push(spanPromise);
-              } else {
-                pendingSpanPromises.set(traceId, [spanPromise]);
-              }
             }
           } catch {
-          } finally {
-            resolvePersistence?.();
           }
         };
         const replayCtxForMock = getReplayContext();
@@ -3539,30 +3042,14 @@ var Bitfab = class {
         }
         const recordSpan = (result) => {
           if (options.finalize) {
-            const replayCtx = getReplayContext();
-            const persistenceCollector = isRootSpan ? replayCtx?.pendingPersistence : void 0;
-            let resolvePersistence;
-            if (persistenceCollector) {
-              persistenceCollector.push(
-                new Promise((resolve) => {
-                  resolvePersistence = resolve;
-                })
-              );
-            }
-            void Promise.resolve().then(() => options.finalize(result)).then(
-              (output) => sendSpan(
-                { result: output },
-                { skipPersistenceRegistration: true }
-              )
-            ).catch(
-              (error) => sendSpan(
-                {
+            void self.httpClient.trackDeferred(
+              Promise.resolve().then(() => options.finalize(result)).then((output) => sendSpan({ result: output })).catch(
+                (error) => sendSpan({
                   result: void 0,
                   error: error instanceof Error ? `finalize failed: ${error.message}` : `finalize failed: ${String(error)}`
-                },
-                { skipPersistenceRegistration: true }
+                })
               )
-            ).finally(() => resolvePersistence?.());
+            );
           } else {
             void sendSpan({ result });
           }
@@ -3590,7 +3077,6 @@ var Bitfab = class {
       } catch (setupError) {
         if (registeredTraceId) {
           activeTraceStates.delete(registeredTraceId);
-          pendingSpanPromises.delete(registeredTraceId);
         }
         if (getReplayContext()) {
           throw setupError;
@@ -3713,7 +3199,7 @@ var Bitfab = class {
   /**
    * Send trace completion when a root span ends.
    * Internal method to record trace completion with end time.
-   * Fire-and-forget - sends to externalTraces endpoint via httpClient.
+   * Queued on the client's span transport; delivery is the transport's job.
    */
   sendTraceCompletion(params) {
     const rawTrace = {
@@ -3749,7 +3235,7 @@ var Bitfab = class {
         accessed: params.dbSnapshotUsage.accessed
       };
     }
-    return this.httpClient.sendExternalTrace({
+    this.httpClient.sendExternalTrace({
       id: params.traceId,
       type: "sdk-function",
       source: "typescript-sdk-function",
@@ -3764,7 +3250,7 @@ var Bitfab = class {
   /**
    * Send a wrapper span from function execution.
    * Internal method to record spans when using withSpan.
-   * Fire-and-forget - sends to externalSpans endpoint via httpClient.
+   * Queued on the client's span transport; delivery is the transport's job.
    */
   sendWrapperSpan(params) {
     const serializedInputs = serializeValue(params.inputs);
@@ -3805,7 +3291,7 @@ var Bitfab = class {
     if (params.inputSourceSpanId) {
       externalSpan.input_source_span_id = params.inputSourceSpanId;
     }
-    return this.httpClient.sendExternalSpan({
+    this.httpClient.sendExternalSpan({
       id: params.spanId,
       traceId: params.traceId,
       type: "sdk-function",
@@ -3839,7 +3325,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-SRQI4QMY.js");
+    const { replay: doReplay } = await import("./replay-QFNYP7EY.js");
     return doReplay(
       this.httpClient,
       this.serviceUrl,
@@ -4043,9 +3529,6 @@ var finalizers = {
 };
 
 export {
-  __version__,
-  DEFAULT_SERVICE_URL,
-  flushTraces,
   BitfabClaudeAgentHandler,
   SUPPORTED_PROVIDERS,
   BitfabLangGraphCallbackHandler,
@@ -4059,4 +3542,4 @@ export {
   BitfabFunction,
   finalizers
 };
-//# sourceMappingURL=chunk-DZJ5K75J.js.map
+//# sourceMappingURL=chunk-ESKBRHVG.js.map