bitfab 0.14.0 → 0.16.0

package/dist/{chunk-RMQX546G.js → chunk-53G5GR7B.js}

@@ -1,14 +1,350 @@
 import {
   BitfabError,
-  DEFAULT_SERVICE_URL,
-  HttpClient,
   asyncStorageReady,
   createAsyncLocalStorage,
   deserializeValue,
   getReplayContext,
   isAsyncStorageInitDone,
   serializeValue
-} from "./chunk-OW2EJK7T.js";
+} from "./chunk-QT7HWOKU.js";
+
+// src/version.generated.ts
+var __version__ = "0.16.0";
+
+// src/constants.ts
+var DEFAULT_SERVICE_URL = "https://bitfab.ai";
+
+// src/http.ts
+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;
+  }
+  await Promise.race([
+    Promise.allSettled(Array.from(pendingTracePromises)),
+    new Promise((resolve) => setTimeout(resolve, timeoutMs))
+  ]);
+}
+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;
+  }
+  /**
+   * 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);
+    let body;
+    let serializationError;
+    try {
+      body = JSON.stringify(payload);
+    } catch (error) {
+      serializationError = error instanceof Error ? error.message : String(error);
+      body = JSON.stringify({
+        ...Object.fromEntries(
+          Object.entries(payload).filter(
+            ([, v]) => typeof v === "string" || typeof v === "number"
+          )
+        ),
+        rawSpan: {},
+        errors: [
+          { source: "sdk", step: "json_serialize", error: serializationError }
+        ]
+      });
+    }
+    try {
+      const response = await fetch(url, {
+        method,
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.apiKey}`
+        },
+        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 });
+  }
+  /**
+   * 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 external trace identified by sourceTraceId.
+   * Used by the detached `client.getTrace(id)` handle. Fire-and-forget;
+   * returns a tracked promise that callers may optionally await.
+   */
+  patchTrace(sourceTraceId, payload) {
+    const endpoint = `/api/sdk/externalTraces/${encodeURIComponent(sourceTraceId)}`;
+    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, codeChangeDescription, codeChangeFiles, includeDbBranchLease, experimentGroupId) {
+    const payload = { traceFunctionKey };
+    if (limit !== void 0) {
+      payload.limit = limit;
+    }
+    if (traceIds) {
+      payload.traceIds = traceIds;
+    }
+    if (codeChangeDescription !== void 0) {
+      payload.codeChangeDescription = codeChangeDescription;
+    }
+    if (codeChangeFiles !== void 0) {
+      payload.codeChangeFiles = codeChangeFiles;
+    }
+    if (includeDbBranchLease) {
+      payload.includeDbBranchLease = true;
+    }
+    if (experimentGroupId !== void 0) {
+      payload.experimentGroupId = experimentGroupId;
+    }
+    const timeout = includeDbBranchLease ? 18e4 : 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.apiKey}` },
+        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.
+   */
+  async getSpanTree(externalSpanId) {
+    const url = `${this.serviceUrl}/api/sdk/replay/spanTree/${externalSpanId}`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 3e4);
+    try {
+      const response = await fetch(url, {
+        method: "GET",
+        headers: { Authorization: `Bearer ${this.apiKey}` },
+        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, dbSnapshotRef) {
+    return this.request(
+      "/api/sdk/replay/resolveDbBranchLease",
+      { testRunId, traceId, dbSnapshotRef },
+      { timeout: 9e4 }
+    );
+  }
+  /** 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 }
+    );
+  }
+};
 
 // src/claudeAgentSdk.ts
 function nowIso() {
@@ -2162,9 +2498,18 @@ var Bitfab = class {
         spanType: options.type ?? "custom"
       };
       const sendSpan = async (params) => {
+        const replayCtx = getReplayContext();
+        const persistenceCollector = isRootSpan ? replayCtx?.pendingPersistence : void 0;
+        let resolvePersistence;
+        if (persistenceCollector) {
+          persistenceCollector.push(
+            new Promise((resolve) => {
+              resolvePersistence = resolve;
+            })
+          );
+        }
         try {
           const endedAt = (/* @__PURE__ */ new Date()).toISOString();
-          const replayCtx = getReplayContext();
           const spanPromise = self.sendWrapperSpan({
             ...baseSpanParams,
             ...params,
@@ -2179,13 +2524,17 @@ var Bitfab = class {
           if (isRootSpan) {
             const pending = pendingSpanPromises.get(traceId) ?? [];
             pending.push(spanPromise);
-            await Promise.race([
-              Promise.allSettled(pending),
-              new Promise((resolve) => setTimeout(resolve, 5e3))
-            ]);
+            if (persistenceCollector) {
+              await Promise.allSettled(pending);
+            } else {
+              await Promise.race([
+                Promise.allSettled(pending),
+                new Promise((resolve) => setTimeout(resolve, 5e3))
+              ]);
+            }
             pendingSpanPromises.delete(traceId);
             const traceState = activeTraceStates.get(traceId);
-            self.sendTraceCompletion({
+            const completionPromise = self.sendTraceCompletion({
               traceFunctionKey,
               traceId,
               startedAt: traceState?.startedAt ?? startedAt,
@@ -2198,6 +2547,9 @@ var Bitfab = class {
               dbSnapshotRef: traceState?.dbSnapshotRef
             });
             activeTraceStates.delete(traceId);
+            if (persistenceCollector) {
+              await completionPromise;
+            }
           } else {
             const pending = pendingSpanPromises.get(traceId);
             if (pending) {
@@ -2207,6 +2559,8 @@ var Bitfab = class {
             }
           }
         } catch {
+        } finally {
+          resolvePersistence?.();
         }
       };
       const replayCtxForMock = getReplayContext();
@@ -2359,7 +2713,7 @@ var Bitfab = class {
     if (params.dbSnapshotRef) {
       rawTrace.db_snapshot_ref = params.dbSnapshotRef;
     }
-    this.httpClient.sendExternalTrace({
+    return this.httpClient.sendExternalTrace({
       type: "sdk-function",
       source: "typescript-sdk-function",
       traceFunctionKey: params.traceFunctionKey,
@@ -2439,7 +2793,7 @@ var Bitfab = class {
    * @returns ReplayResult with items, testRunId, and testRunUrl
    */
   async replay(traceFunctionKey, fn, options) {
-    const { replay: doReplay } = await import("./replay-LNP2K3DN.js");
+    const { replay: doReplay } = await import("./replay-WIBKB3BK.js");
     return doReplay(
       this.httpClient,
       this.serviceUrl,
@@ -2505,6 +2859,9 @@ var BitfabFunction = class {
 };
 
 export {
+  __version__,
+  DEFAULT_SERVICE_URL,
+  flushTraces,
   BitfabClaudeAgentHandler,
   SUPPORTED_PROVIDERS,
   BitfabLangGraphCallbackHandler,
@@ -2515,4 +2872,4 @@ export {
   Bitfab,
   BitfabFunction
 };
-//# sourceMappingURL=chunk-RMQX546G.js.map
+//# sourceMappingURL=chunk-53G5GR7B.js.map