bitfab 0.53.1 → 0.53.2

package/dist/{chunk-MMT5MWG5.js → chunk-V3KD7B3B.js}

@@ -5,7 +5,7 @@ import {
   replayContextReady,
   runWithReplayContext,
   warnOnce
-} from "./chunk-ASMHSKFS.js";
+} from "./chunk-JZAKQDGR.js";
 
 // src/gitCommand.ts
 var EXIT_GRACE_MS = 500;
@@ -1303,4 +1303,4 @@ export {
   sleepForReplayPersistence,
   replay
 };
-//# sourceMappingURL=chunk-MMT5MWG5.js.map
+//# sourceMappingURL=chunk-V3KD7B3B.js.map

package/dist/{http-7QLUPC6F.js → http-LOZSAC23.js}

@@ -6,7 +6,7 @@ import {
   flushTraces,
   parseRetryAfterMs,
   serializePayloadBody
-} from "./chunk-ZNY2HZT3.js";
+} from "./chunk-S4UK5HNW.js";
 export {
   BitfabError,
   HttpClient,
@@ -16,4 +16,4 @@ export {
   parseRetryAfterMs,
   serializePayloadBody
 };
-//# sourceMappingURL=http-7QLUPC6F.js.map
+//# sourceMappingURL=http-LOZSAC23.js.map

package/dist/{http-2OOKOZQ3.js → http-PUEEHMKU.js}

@@ -6,7 +6,7 @@ import {
   flushTraces,
   parseRetryAfterMs,
   serializePayloadBody
-} from "./chunk-ASMHSKFS.js";
+} from "./chunk-JZAKQDGR.js";
 import "./chunk-H6LZRFMN.js";
 export {
   BitfabError,
@@ -17,4 +17,4 @@ export {
   parseRetryAfterMs,
   serializePayloadBody
 };
-//# sourceMappingURL=http-2OOKOZQ3.js.map
+//# sourceMappingURL=http-PUEEHMKU.js.map

package/dist/index.cjs

@@ -51,7 +51,7 @@ var __version__, __packageName__;
 var init_version_generated = __esm({
   "src/version.generated.ts"() {
     "use strict";
-    __version__ = "0.53.1";
+    __version__ = "0.53.2";
     __packageName__ = "bitfab";
   }
 });
@@ -6719,6 +6719,17 @@ function runWithSeedContext(ctx, fn) {
 init_serialize();
 init_simulationPlan();
 init_spanOrigin();
+
+// src/streamFinalizationError.ts
+var StreamFinalizationError = class extends Error {
+  constructor(message, output) {
+    super(message);
+    this.output = output;
+    this.name = "StreamFinalizationError";
+  }
+};
+
+// src/client.ts
 init_traceMetadata();
 
 // src/tracing.ts
@@ -6992,52 +7003,110 @@ function summarizeGenerate(result, model) {
   }
   return summary;
 }
-function accumulateStream(onComplete, model) {
+function accumulateStream(source, onComplete, model) {
+  const reader = source.getReader();
   let text = "";
   const toolCalls = [];
   let usage;
   let finishReason;
   let completed = false;
-  const complete = () => {
+  let streamFailure;
+  const complete = (failure = streamFailure) => {
     if (completed) {
       return;
     }
     completed = true;
-    const summary = {
+    let error;
+    if (failure !== void 0) {
+      try {
+        error = failure.error instanceof Error ? failure.error.message : String(
+          failure.error ?? (failure.cancelled === true ? "Stream cancelled" : "Stream failed")
+        );
+      } catch {
+        error = "Stream failed";
+      }
+    }
+    onComplete({
       text,
       toolCalls: toolCalls.length > 0 ? toolCalls : void 0,
       usage,
-      finishReason
-    };
-    if (model) {
-      summary.model = model;
-    }
-    onComplete(summary);
+      finishReason,
+      ...model !== void 0 && { model },
+      ...failure !== void 0 && { error },
+      ...failure?.cancelled === true && { cancelled: true }
+    });
   };
-  return new TransformStream({
-    transform(part, controller) {
-      try {
-        if (part?.type === "text-delta") {
-          text += part.delta ?? part.textDelta ?? "";
-        } else if (part?.type === "tool-call") {
-          toolCalls.push({
-            toolCallId: part.toolCallId,
-            toolName: part.toolName,
-            input: part.input ?? part.args
-          });
-        } else if (part?.type === "finish") {
-          usage = part.usage;
-          finishReason = part.finishReason;
-          complete();
+  return new ReadableStream(
+    {
+      start(controller) {
+        void reader.closed.then(
+          () => {
+            queueMicrotask(() => {
+              if (!completed) {
+                complete();
+                reader.releaseLock();
+                controller.close();
+              }
+            });
+          },
+          (error) => {
+            if (!completed) {
+              complete({ error });
+              controller.error(error);
+              reader.releaseLock();
+            }
+          }
+        );
+      },
+      async pull(controller) {
+        try {
+          const { done, value: part } = await reader.read();
+          if (completed) {
+            return;
+          }
+          if (done) {
+            complete();
+            reader.releaseLock();
+            controller.close();
+            return;
+          }
+          try {
+            if (part?.type === "text-delta") {
+              text += part.delta ?? part.textDelta ?? "";
+            } else if (part?.type === "tool-call") {
+              toolCalls.push({
+                toolCallId: part.toolCallId,
+                toolName: part.toolName,
+                input: part.input ?? part.args
+              });
+            } else if (part?.type === "error") {
+              streamFailure = { error: part.error };
+            } else if (part?.type === "finish") {
+              usage = part.usage;
+              finishReason = part.finishReason;
+            }
+          } catch {
+          }
+          controller.enqueue(part);
+        } catch (error) {
+          if (!completed) {
+            complete({ error });
+            reader.releaseLock();
+            controller.error(error);
+          }
+        }
+      },
+      async cancel(reason) {
+        complete({ error: reason, cancelled: true });
+        try {
+          await reader.cancel(reason);
+        } finally {
+          reader.releaseLock();
         }
-      } catch {
       }
-      controller.enqueue(part);
     },
-    flush() {
-      complete();
-    }
-  });
+    { highWaterMark: 0 }
+  );
 }
 var BitfabVercelAiHandler = class {
   constructor(config) {
@@ -7078,14 +7147,22 @@ var BitfabVercelAiHandler = class {
           // awaits the summary the accumulator resolves once the stream drains.
           {
             type: "llm",
-            finalize: () => summary,
+            finalize: async () => {
+              const output = await summary;
+              if (output.error !== void 0) {
+                throw new StreamFinalizationError(output.error, output);
+              }
+              return output;
+            },
             surface: "inherit",
             instrumentation: "vercel-ai"
           },
           async () => {
             const result = await doStream();
-            const stream = result.stream.pipeThrough(
-              accumulateStream(resolveSummary, label)
+            const stream = accumulateStream(
+              result.stream,
+              resolveSummary,
+              label
             );
             return { ...result, stream };
           }
@@ -8580,8 +8657,8 @@ var Bitfab = class {
             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)}`
+                  result: error instanceof StreamFinalizationError ? error.output : void 0,
+                  error: error instanceof StreamFinalizationError ? error.message : error instanceof Error ? `finalize failed: ${error.message}` : `finalize failed: ${String(error)}`
                 })
               )
             );