@bitfab/sdk 0.36.4 → 0.36.6

package/dist/index.cjs

@@ -42,7 +42,7 @@ var __version__;
 var init_version_generated = __esm({
   "src/version.generated.ts"() {
     "use strict";
-    __version__ = "0.36.4";
+    __version__ = "0.36.6";
   }
 });
 
@@ -2384,12 +2384,13 @@ function sleep(ms) {
     unrefTimer(timer);
   });
 }
-async function mapWithConcurrency2(tasks, maxConcurrency, onSettled) {
+async function mapWithConcurrency2(tasks, maxConcurrency, onSettled, onStarted) {
   const results = new Array(tasks.length);
   let nextIndex = 0;
   async function worker() {
     while (nextIndex < tasks.length) {
       const index = nextIndex++;
+      onStarted?.(index);
       const result = await tasks[index]();
       results[index] = result;
       onSettled?.(result, index);
@@ -2476,13 +2477,15 @@ async function replay(httpClient, serviceUrl, traceFunctionKey, fn, options, reg
     )
   );
   const total = tasks.length;
+  const onItemFinish = options?.onItemFinish ?? options?.onProgress;
   let completed = 0;
+  let started = 0;
   let succeeded = 0;
   let errored = 0;
   const resultItems = await mapWithConcurrency2(
     tasks,
     maxConcurrency,
-    options?.onProgress ? (item) => {
+    (item) => {
       completed += 1;
       if (item.error === null) {
         succeeded += 1;
@@ -2490,18 +2493,17 @@ async function replay(httpClient, serviceUrl, traceFunctionKey, fn, options, reg
         errored += 1;
       }
       try {
-        options?.onProgress?.({
+        onItemFinish?.({
           testRunId,
           completed,
           total,
           succeeded,
           errored,
           item: {
-            // The server replay trace id isn't known until completeReplay
-            // runs (below), so it can't be reported mid-run and we never
-            // emit the client-side placeholder. originalTraceId (the
-            // historical trace) is known now and is what a UI keys on to
-            // identify what just settled.
+            // The server replay trace id isn't known until completeReplay runs
+            // (below), so it can't be reported mid-run and we never emit the
+            // client-side placeholder. originalTraceId (the historical trace)
+            // is known now and is what a UI keys on to identify what settled.
             traceId: null,
             originalTraceId: item.originalTraceId ?? null,
             originalSpanId: item.originalSpanId ?? null,
@@ -2522,6 +2524,30 @@ async function replay(httpClient, serviceUrl, traceFunctionKey, fn, options, reg
         });
       } catch {
       }
+    },
+    options?.onItemStart ? (index) => {
+      started += 1;
+      const serverItem = serverItems[index];
+      const originalTraceId = serverItem.originalTraceId ?? serverItem.sourceTraceId;
+      const originalSpanId = serverItem.originalSpanId ?? serverItem.sourceSpanId;
+      try {
+        options.onItemStart?.({
+          type: "started",
+          testRunId,
+          started,
+          completed,
+          total,
+          succeeded,
+          errored,
+          item: {
+            originalTraceId,
+            originalSpanId,
+            sourceTraceId: originalTraceId,
+            sourceSpanId: originalSpanId
+          }
+        });
+      } catch {
+      }
     } : void 0
   );
   await preserveReplayFailure(
@@ -2584,17 +2610,19 @@ async function replay(httpClient, serviceUrl, traceFunctionKey, fn, options, reg
     testRunUrl: fullTestRunUrl
   };
   await writeReplayResultFile(result);
-  try {
-    options?.onProgress?.({
-      type: "complete",
-      testRunId,
-      completed: total,
-      total,
-      succeeded,
-      errored,
-      result
-    });
-  } catch {
+  if (!options?.onItemFinish) {
+    try {
+      options?.onProgress?.({
+        type: "complete",
+        testRunId,
+        completed: total,
+        total,
+        succeeded,
+        errored,
+        result
+      });
+    } catch {
+    }
   }
   return result;
 }
@@ -5768,7 +5796,7 @@ var Bitfab = class {
           }
         };
         executeWithContext = () => {
-          const result = fn(...args);
+          const result = fn.apply(this, args);
           if (result instanceof Promise) {
             return result.then((resolvedResult) => {
               recordSpan(resolvedResult);
@@ -5798,7 +5826,7 @@ var Bitfab = class {
           `withSpan-setup:${traceFunctionKey}`,
           `tracing setup failed for "${traceFunctionKey}"; running it untraced. The function still runs and returns normally; no span is recorded.`
         );
-        return fn(...args);
+        return fn.apply(this, args);
       }
       return runWithSpanStack(newStack, executeWithContext);
     };
@@ -5807,6 +5835,40 @@ var Bitfab = class {
     });
     return wrappedFn;
   }
+  /**
+   * Create a standard ECMAScript method decorator that records each invocation
+   * as a span.
+   *
+   * It supports instance, static, and private methods; use
+   * {@link Bitfab.withSpan} for standalone functions, class fields, and
+   * accessors.
+   *
+   * @example
+   * ```typescript
+   * const bitfab = new Bitfab({ apiKey: process.env.BITFAB_API_KEY });
+   *
+   * class OrderService {
+   *   @bitfab.span("order-processing", { type: "agent" })
+   *   async process(orderId: string) {
+   *     return { orderId };
+   *   }
+   * }
+   * ```
+   *
+   * @param traceFunctionKey - A string identifier for grouping spans
+   * @param options - Span configuration applied to the decorated method
+   * @returns A standard ECMAScript method decorator
+   */
+  span(traceFunctionKey, options = {}) {
+    return (originalMethod, context) => {
+      if (context.kind !== "method") {
+        throw new BitfabError(
+          `Bitfab span decorators can only decorate methods; ${String(context.name)} is a ${context.kind}`
+        );
+      }
+      return this.withSpan(traceFunctionKey, options, originalMethod);
+    };
+  }
   /**
    * Get a detached handle to a previously-created trace, looked up by the
    * canonical Bitfab trace ID.
@@ -6083,6 +6145,27 @@ var BitfabFunction = class {
     const fn = typeof optionsOrFn === "function" ? optionsOrFn : maybeFn;
     return this.client.withSpan(this.traceFunctionKey, options, fn);
   }
+  /**
+   * Create a standard ECMAScript method decorator bound to this function key.
+   *
+   * @example
+   * ```typescript
+   * const orders = client.getFunction("order-processing");
+   *
+   * class OrderService {
+   *   @orders.span({ type: "agent" })
+   *   async process(orderId: string) {
+   *     return { orderId };
+   *   }
+   * }
+   * ```
+   *
+   * @param options - Span configuration applied to the decorated method
+   * @returns A standard ECMAScript method decorator
+   */
+  span(options = {}) {
+    return this.client.span(this.traceFunctionKey, options);
+  }
   /**
    * Get a Vercel AI SDK language-model middleware bound to this function's key.
    *