@bitfab/sdk 0.36.1 → 0.36.3

package/dist/{chunk-HD4DRDRE.js → chunk-4CTDZMG5.js}

@@ -16,7 +16,7 @@ import {
   toJsonSafe,
   toJsonSafeReport,
   warnOnce
-} from "./chunk-6ZBZBR5K.js";
+} from "./chunk-M2GISXGV.js";
 
 // src/processorPayload.ts
 var SERIALIZATION_DEGRADED_STEP = "serialization_degraded";
@@ -3337,7 +3337,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-ZR4KIZIB.js");
+    const { replay: doReplay } = await import("./replay-ZH25RPKH.js");
     return doReplay(
       this.httpClient,
       this.serviceUrl,
@@ -3554,4 +3554,4 @@ export {
   BitfabFunction,
   finalizers
 };
-//# sourceMappingURL=chunk-HD4DRDRE.js.map
+//# sourceMappingURL=chunk-4CTDZMG5.js.map

package/dist/{chunk-6ZBZBR5K.js → chunk-M2GISXGV.js}

@@ -278,7 +278,7 @@ function encodeRequestBody(body) {
 }
 
 // src/version.generated.ts
-var __version__ = "0.36.1";
+var __version__ = "0.36.3";
 
 // src/constants.ts
 var DEFAULT_SERVICE_URL = "https://bitfab.ai";
@@ -1598,9 +1598,11 @@ var HttpClient = class {
   /**
    * Fetch an external span by ID.
    * Blocking GET request.
+   * The replay view limits rawData to input/output serialization fields.
    */
-  async getExternalSpan(spanId) {
-    const url = `${this.serviceUrl}/api/sdk/externalSpans/${spanId}`;
+  async getExternalSpan(spanId, options) {
+    const query = options?.view === "replay" ? "?view=replay" : "";
+    const url = `${this.serviceUrl}/api/sdk/externalSpans/${spanId}${query}`;
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), 3e4);
     try {
@@ -1638,9 +1640,18 @@ var HttpClient = class {
    * 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"`.
+   * Pass `includeRootOutput: false` when the root was already fetched.
    */
   async getSpanTree(externalSpanId, options) {
-    const query = options?.includeOutputs === false ? "?includeOutputs=false" : "";
+    const searchParams = new URLSearchParams();
+    if (options?.includeOutputs === false) {
+      searchParams.set("includeOutputs", "false");
+    }
+    if (options?.includeRootOutput === false) {
+      searchParams.set("includeRootOutput", "false");
+    }
+    const encodedQuery = searchParams.toString();
+    const query = encodedQuery ? `?${encodedQuery}` : "";
     const url = `${this.serviceUrl}/api/sdk/replay/spanTree/${externalSpanId}${query}`;
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), 3e4);
@@ -1921,11 +1932,78 @@ function reportReplayProgress(progress) {
     return;
   }
   try {
-    stderr.write(`${BITFAB_PROGRESS_PREFIX}${JSON.stringify(progress)}
-`);
+    stderr.write(
+      `${BITFAB_PROGRESS_PREFIX}${JSON.stringify(progress, replayJsonReplacer)}
+`
+    );
   } catch {
   }
 }
+var ReplayError = class extends BitfabError {
+  constructor(message, items, testRunId, testRunUrl, cause) {
+    super(message, testRunUrl);
+    this.items = items;
+    this.testRunId = testRunId;
+    this.testRunUrl = testRunUrl;
+    this.cause = cause;
+    this.name = "ReplayError";
+  }
+};
+var DbBranchReplayError = class extends BitfabError {
+  constructor(code, message, originalTraceId, cause) {
+    super(message);
+    this.code = code;
+    this.originalTraceId = originalTraceId;
+    this.cause = cause;
+    this.name = "DbBranchReplayError";
+  }
+};
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function replayItemErrorMessage(error) {
+  if (error instanceof DbBranchReplayError) {
+    return `Replay requested a database branch for trace ${error.originalTraceId} but it could not be resolved (${error.code}): ${error.message}. The function was not run, because replaying it against the live database would produce a result that looks valid but did not use the historical data you asked for.`;
+  }
+  return errorMessage(error);
+}
+function replayJsonReplacer(_key, value) {
+  if (value instanceof Error) {
+    const serialized = {
+      name: value.name,
+      message: value.message,
+      stack: value.stack
+    };
+    if (value instanceof DbBranchReplayError) {
+      serialized.code = value.code;
+      serialized.originalTraceId = value.originalTraceId;
+      if (value.cause !== void 0) {
+        serialized.cause = value.cause;
+      }
+    }
+    return serialized;
+  }
+  return value;
+}
+function serializeReplayResult(result) {
+  return JSON.stringify(result, replayJsonReplacer, 2);
+}
+async function preserveReplayFailure(operation, items, testRunId, testRunUrl) {
+  try {
+    return await operation();
+  } catch (cause) {
+    if (cause instanceof ReplayError) {
+      throw cause;
+    }
+    throw new ReplayError(
+      errorMessage(cause),
+      items,
+      testRunId,
+      testRunUrl,
+      cause
+    );
+  }
+}
 function deserializeInputs(spanData) {
   const inputMeta = spanData.input_meta;
   const rawInput = spanData.input;
@@ -1983,25 +2061,41 @@ async function processItem(httpClient, serverItem, fn, testRunId, mockStrategy,
   let originalOutput;
   let result;
   let error = null;
+  let traceError = null;
+  let replayError = null;
   const originalTraceId = serverItem.originalTraceId ?? serverItem.sourceTraceId;
   const originalSpanId = serverItem.originalSpanId ?? serverItem.sourceSpanId;
   try {
     if (includeDbBranchLease && !lease && !leaseError) {
-      const resolved = await httpClient.resolveDbBranchLease(
-        testRunId,
-        originalTraceId,
-        dbBranchSettings
-      );
+      let resolved;
+      try {
+        resolved = await httpClient.resolveDbBranchLease(
+          testRunId,
+          originalTraceId,
+          dbBranchSettings
+        );
+      } catch (cause) {
+        throw new DbBranchReplayError(
+          "lease_request_failed",
+          `Bitfab could not request the database branch: ${errorMessage(cause)}`,
+          originalTraceId,
+          cause
+        );
+      }
       lease = resolved.lease ?? void 0;
       leaseError = resolved.leaseError ?? void 0;
       dbSnapshotRef = resolved.dbSnapshotRef ?? dbSnapshotRef;
     }
     if (leaseError) {
-      throw new BitfabError(
-        `Replay requested a database branch for trace ${originalTraceId} but it could not be resolved (${leaseError.code}): ${leaseError.message}. The function was not run, because replaying it against the live database would produce a result that looks valid but did not use the historical data you asked for.`
+      throw new DbBranchReplayError(
+        leaseError.code,
+        leaseError.message,
+        originalTraceId
       );
     }
-    const span = await httpClient.getExternalSpan(originalSpanId);
+    const span = await httpClient.getExternalSpan(originalSpanId, {
+      view: "replay"
+    });
     const spanData = span.rawData?.span_data ?? {};
     inputs = deserializeInputs(spanData);
     originalOutput = deserializeOutput(spanData);
@@ -2021,7 +2115,8 @@ async function processItem(httpClient, serverItem, fn, testRunId, mockStrategy,
     if (needTree) {
       try {
         const treeResponse = await httpClient.getSpanTree(originalSpanId, {
-          includeOutputs
+          includeOutputs,
+          includeRootOutput: false
         });
         if (treeResponse.root) {
           mockTree = buildMockTree(treeResponse.root);
@@ -2043,7 +2138,7 @@ async function processItem(httpClient, serverItem, fn, testRunId, mockStrategy,
     const fetchSpanOutput = mockTree && !includeOutputs ? (externalSpanId) => {
       let pending = outputCache.get(externalSpanId);
       if (!pending) {
-        pending = httpClient.getExternalSpan(externalSpanId).then(
+        pending = httpClient.getExternalSpan(externalSpanId, { view: "replay" }).then(
           (s) => deserializeOutput(
             s.rawData?.span_data ?? {}
           )
@@ -2052,25 +2147,31 @@ async function processItem(httpClient, serverItem, fn, testRunId, mockStrategy,
       }
       return pending;
     } : void 0;
-    const maybePromise = runWithReplayContext(
-      {
-        testRunId,
-        traceId: replayedTraceId,
-        inputSourceSpanId: span.id,
-        inputSourceTraceId: span.externalTraceId,
-        sourceBitfabTraceId: originalTraceId,
-        mockTree,
-        callCounters: mockTree ? /* @__PURE__ */ new Map() : void 0,
-        mockStrategy,
-        mockOverrides: hasOverrides ? resolvedOverrides : void 0,
-        fetchSpanOutput,
-        dbBranchLease: lease
-      },
-      () => fn(...inputs)
-    );
-    result = maybePromise instanceof Promise ? await maybePromise : maybePromise;
+    try {
+      const maybePromise = runWithReplayContext(
+        {
+          testRunId,
+          traceId: replayedTraceId,
+          inputSourceSpanId: span.id,
+          inputSourceTraceId: span.externalTraceId,
+          sourceBitfabTraceId: originalTraceId,
+          mockTree,
+          callCounters: mockTree ? /* @__PURE__ */ new Map() : void 0,
+          mockStrategy,
+          mockOverrides: hasOverrides ? resolvedOverrides : void 0,
+          fetchSpanOutput,
+          dbBranchLease: lease
+        },
+        () => fn(...inputs)
+      );
+      result = maybePromise instanceof Promise ? await maybePromise : maybePromise;
+    } catch (e) {
+      traceError = e;
+      error = errorMessage(e);
+    }
   } catch (e) {
-    error = e instanceof Error ? e.message : String(e);
+    replayError = e;
+    error = replayItemErrorMessage(e);
   } finally {
     if (lease) {
       try {
@@ -2099,6 +2200,8 @@ async function processItem(httpClient, serverItem, fn, testRunId, mockStrategy,
     result,
     originalOutput,
     error,
+    traceError,
+    replayError,
     durationMs: serverItem.durationMs ?? null,
     // Filled in by replay() from the complete-replay response once the
     // replay traces are persisted and their spans aggregated server-side.
@@ -2223,6 +2326,7 @@ async function replay(httpClient, serviceUrl, traceFunctionKey, fn, options, reg
   );
   const mockStrategy = options?.mock ?? "marked";
   const maxConcurrency = options?.maxConcurrency ?? 10;
+  const fullTestRunUrl = `${serviceUrl}${testRunUrl}`;
   const resolvedOverrides = [
     ...normalizeMockOverrides(options?.mockOverride),
     ...registeredOverrides
@@ -2279,6 +2383,8 @@ async function replay(httpClient, serviceUrl, traceFunctionKey, fn, options, reg
             result: item.result,
             originalOutput: item.originalOutput,
             error: item.error,
+            traceError: item.traceError,
+            replayError: item.replayError,
             durationMs: item.durationMs,
             tokens: item.tokens,
             model: item.model,
@@ -2289,8 +2395,18 @@ async function replay(httpClient, serviceUrl, traceFunctionKey, fn, options, reg
       }
     } : void 0
   );
-  await waitForReplayPersistence(httpClient, testRunId, replayedTraceIds);
-  const completeResult = await httpClient.completeReplay(testRunId);
+  await preserveReplayFailure(
+    () => waitForReplayPersistence(httpClient, testRunId, replayedTraceIds),
+    resultItems,
+    testRunId,
+    fullTestRunUrl
+  );
+  const completeResult = await preserveReplayFailure(
+    () => httpClient.completeReplay(testRunId),
+    resultItems,
+    testRunId,
+    fullTestRunUrl
+  );
   const serverTraceIds = completeResult.traceIds;
   const replayTokens = completeResult.tokens;
   if (serverTraceIds !== void 0) {
@@ -2313,9 +2429,16 @@ async function replay(httpClient, serviceUrl, traceFunctionKey, fn, options, reg
     }
     if (completedCount > 0 && missing.length === completedCount) {
       const serverCount = completeResult.traceCount !== void 0 ? ` The server persisted ${completeResult.traceCount} trace(s) for this run.` : "";
-      throw new BitfabError(
+      const cause = new BitfabError(
         `Replay completed but the server has no persisted trace for any of the ${completedCount} completed item(s) (testRunId ${testRunId}).${serverCount} Trace uploads were awaited, so either the uploads failed (check for "Bitfab: Failed to create" errors above) or the replayed function is not wrapped with withSpan.`
       );
+      throw new ReplayError(
+        cause.message,
+        resultItems,
+        testRunId,
+        fullTestRunUrl,
+        cause
+      );
     }
     if (missing.length > 0) {
       try {
@@ -2329,7 +2452,7 @@ async function replay(httpClient, serviceUrl, traceFunctionKey, fn, options, reg
   const result = {
     items: resultItems,
     testRunId,
-    testRunUrl: `${serviceUrl}${testRunUrl}`
+    testRunUrl: fullTestRunUrl
   };
   await writeReplayResultFile(result);
   try {
@@ -2357,7 +2480,7 @@ async function writeReplayResultFile(result) {
       import("fs/promises")
     ]);
     await mkdir(dirname(resultPath), { recursive: true });
-    await writeFile(resultPath, `${JSON.stringify(result, null, 2)}
+    await writeFile(resultPath, `${serializeReplayResult(result)}
 `);
   } catch (err) {
     try {
@@ -2393,6 +2516,9 @@ export {
   resolveMockValue,
   BITFAB_PROGRESS_PREFIX,
   reportReplayProgress,
+  ReplayError,
+  DbBranchReplayError,
+  serializeReplayResult,
   replay
 };
-//# sourceMappingURL=chunk-6ZBZBR5K.js.map
+//# sourceMappingURL=chunk-M2GISXGV.js.map