@iota-uz/sdk 0.4.39 → 0.4.41

package/dist/bichat/index.cjs

@@ -1181,6 +1181,15 @@ var RateLimiter = class {
   }
 };
 
+// ui/src/bichat/types/index.ts
+var MessageRole = /* @__PURE__ */ ((MessageRole2) => {
+  MessageRole2["User"] = "user";
+  MessageRole2["Assistant"] = "assistant";
+  MessageRole2["System"] = "system";
+  MessageRole2["Tool"] = "tool";
+  return MessageRole2;
+})(MessageRole || {});
+
 // ui/src/applet-devtools/enabled.ts
 function shouldEnableAppletDevtools() {
   if (typeof window === "undefined") {
@@ -1722,15 +1731,6 @@ function getSessionDebugUsage(turns) {
   };
 }
 
-// ui/src/bichat/types/index.ts
-var MessageRole = /* @__PURE__ */ ((MessageRole2) => {
-  MessageRole2["User"] = "user";
-  MessageRole2["Assistant"] = "assistant";
-  MessageRole2["System"] = "system";
-  MessageRole2["Tool"] = "tool";
-  return MessageRole2;
-})(MessageRole || {});
-
 // ui/src/bichat/context/chatHelpers.ts
 var ARTIFACT_TOOL_NAMES = /* @__PURE__ */ new Set([
   "code_interpreter",
@@ -2541,6 +2541,25 @@ var ChatMachine = class {
       return;
     }
     const prev = this.state.messaging.turns;
+    const localPartialTurn = prev.slice().reverse().find((turn) => turn.assistantTurn?.id.startsWith("assistant-partial-"));
+    if (localPartialTurn) {
+      if (fetchedTurns.length === 0) {
+        fetchedTurns = prev;
+      } else {
+        const correspondingIndex = fetchedTurns.findIndex(
+          (turn, index) => turn.userTurn.id === localPartialTurn.userTurn.id || index === fetchedTurns.length - 1 && turn.userTurn.content === localPartialTurn.userTurn.content
+        );
+        if (correspondingIndex >= 0) {
+          if (!fetchedTurns[correspondingIndex].assistantTurn) {
+            fetchedTurns = fetchedTurns.map(
+              (turn, index) => index === correspondingIndex ? { ...turn, assistantTurn: localPartialTurn.assistantTurn } : turn
+            );
+          }
+        } else {
+          fetchedTurns = [...fetchedTurns, localPartialTurn];
+        }
+      }
+    }
     const hasPendingUserOnly = prev.length > 0 && !prev[prev.length - 1].assistantTurn;
     const patch = {};
     const effectivePendingQuestion = pendingQuestion === void 0 ? this.state.messaging.pendingQuestion : pendingQuestion;
@@ -2646,8 +2665,9 @@ var ChatMachine = class {
     this.abortController = controller;
     const epoch = this.viewEpoch;
     this._updateMessaging({ isStreaming: true });
+    let accumulatedContent = "";
     try {
-      let accumulatedContent = "";
+      let terminalError = null;
       await this.dataSource.resumeStream(
         sessionId,
         runId,
@@ -2667,13 +2687,27 @@ var ChatMachine = class {
             this._handleToolStart(chunk.tool);
           } else if (chunk.type === "tool_end" && chunk.tool) {
             this._handleToolEnd(chunk.tool);
-          } else if (chunk.type === "done" || chunk.type === "error") {
+          } else if (chunk.type === "error") {
+            terminalError = new Error(chunk.error || "Stream error");
           }
         },
         controller.signal
       );
+      if (terminalError) {
+        throw terminalError;
+      }
       clearRunMarker(sessionId);
       await this._syncSessionFromServer(sessionId, true, epoch);
+    } catch (err) {
+      if (this._isCurrentEpoch(epoch) && !(err instanceof Error && err.name === "AbortError")) {
+        this._preservePartialAssistant(accumulatedContent);
+        const normalized = normalizeRPCError(err, "Failed to resume stream");
+        this._updateMessaging({
+          streamError: normalized.userMessage,
+          streamErrorRetryable: normalized.retryable
+        });
+      }
+      throw err;
     } finally {
       if (this.abortController === controller) {
         this.abortController = null;
@@ -2956,7 +2990,8 @@ var ChatMachine = class {
       model,
       tempTurnId,
       controller,
-      epoch
+      epoch,
+      onContent
     } = params;
     let accumulatedContent = "";
     let createdSessionId;
@@ -2986,6 +3021,7 @@ var ChatMachine = class {
       }
       if ((chunk.type === "chunk" || chunk.type === "content") && chunk.content) {
         accumulatedContent += chunk.content;
+        onContent(accumulatedContent);
         this._updateMessaging({ streamingContent: accumulatedContent });
       } else if (chunk.type === "thinking" && chunk.content) {
         this._handleThinkingChunk(chunk.content);
@@ -3071,7 +3107,7 @@ var ChatMachine = class {
     this._clearStreamError();
     this.lastSendAttempt = null;
   }
-  _handleSendError(err, content, tempTurn, epoch) {
+  _handleSendError(err, content, tempTurn, epoch, partialAssistantContent) {
     if (!this._isCurrentEpoch(epoch)) {
       return false;
     }
@@ -3101,13 +3137,52 @@ var ChatMachine = class {
       };
     }
     this._updateInput({ message: "", inputError: null });
+    const turns = this._preservePartialAssistant(
+      partialAssistantContent,
+      tempTurn.id
+    );
     this._updateMessaging({
+      turns,
       streamError: normalized.userMessage,
       streamErrorRetryable: normalized.retryable
     });
     console.error("Send message error:", err);
     return false;
   }
+  _preservePartialAssistant(content, targetTurnId) {
+    if (content.trim() === "") {
+      return this.state.messaging.turns;
+    }
+    let targetIndex = targetTurnId ? this.state.messaging.turns.findIndex((turn) => turn.id === targetTurnId) : -1;
+    if (!targetTurnId) {
+      for (let i = this.state.messaging.turns.length - 1; i >= 0; i--) {
+        if (!this.state.messaging.turns[i].assistantTurn) {
+          targetIndex = i;
+          break;
+        }
+      }
+    }
+    if (targetIndex < 0) {
+      return this.state.messaging.turns;
+    }
+    const turns = this.state.messaging.turns.map(
+      (turn, index) => index === targetIndex ? {
+        ...turn,
+        assistantTurn: {
+          id: generateTempId("assistant-partial"),
+          role: "assistant" /* Assistant */,
+          content,
+          citations: [],
+          artifacts: [],
+          codeOutputs: [],
+          lifecycle: "complete",
+          createdAt: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      } : turn
+    );
+    this._updateMessaging({ turns });
+    return turns;
+  }
   // ── Send message ────────────────────────────────────────────────────────
   /**
    * Public entry point (no options). Calls _sendMessageCore internally.
@@ -3176,6 +3251,7 @@ var ChatMachine = class {
     const prevTurns = this.state.messaging.turns;
     this._insertOptimisticTurn(prevTurns, tempTurn, replaceFromMessageID);
     let shouldDrainQueue = true;
+    let partialAssistantContent = "";
     try {
       const { activeSessionId, shouldNavigateAfter } = await this._resolveSendSession(curSessionId, curDebugMode);
       this.sendingSessionId = activeSessionId || null;
@@ -3191,7 +3267,10 @@ var ChatMachine = class {
         model: this.state.session.model,
         tempTurnId: tempTurn.id,
         controller,
-        epoch
+        epoch,
+        onContent: (streamedContent) => {
+          partialAssistantContent = streamedContent;
+        }
       });
       if (!this._isCurrentEpoch(epoch)) {
       } else if (stopped) {
@@ -3204,8 +3283,10 @@ var ChatMachine = class {
         this._clearStreamError();
         const syncId = createdSessionId || activeSessionId;
         if (syncId && syncId !== "new") {
-          await this._syncSessionFromServer(syncId, true, epoch).catch(() => {
-          });
+          await this._syncSessionFromServer(syncId, true, epoch).catch(
+            () => {
+            }
+          );
         }
       } else {
         await this._ensureSessionSyncAfterStream(
@@ -3218,7 +3299,13 @@ var ChatMachine = class {
         this._finalizeSuccessfulSend(targetSessionId, shouldNavigateAfter);
       }
     } catch (err) {
-      shouldDrainQueue = this._handleSendError(err, content, tempTurn, epoch);
+      shouldDrainQueue = this._handleSendError(
+        err,
+        content,
+        tempTurn,
+        epoch,
+        partialAssistantContent
+      );
     } finally {
       if (this._isCurrentEpoch(epoch)) {
         this._updateMessaging({