@iota-uz/sdk 0.4.24 → 0.4.25

package/dist/bichat/index.mjs

@@ -2442,6 +2442,33 @@ var ChatMachine = class {
       });
     }
   }
+  async _resumeAcceptedRunOrPoll(sessionId, runId) {
+    setRunMarker(sessionId, runId);
+    try {
+      await this._runResumeStream(sessionId, runId);
+    } catch (err) {
+      if (this.disposed) {
+        return;
+      }
+      console.warn("[ChatMachine] resumeStream failed, switching to status polling fallback:", err);
+      const getStreamStatus2 = this.dataSource.getStreamStatus;
+      const status = getStreamStatus2 ? await getStreamStatus2(sessionId).catch(() => null) : null;
+      if (!status?.active) {
+        clearRunMarker(sessionId);
+        await this._syncSessionFromServer(sessionId, true).catch(() => {
+        });
+        this._updateMessaging({ generationInProgress: false });
+        return;
+      }
+      setRunMarker(sessionId, status.runId ?? runId);
+      this._updateMessaging({
+        isStreaming: false,
+        loading: false,
+        generationInProgress: true
+      });
+      this._startPassivePolling(sessionId);
+    }
+  }
   // =====================================================================
   // Private — actions
   // =====================================================================
@@ -2560,20 +2587,28 @@ var ChatMachine = class {
         streamingContent: ""
       });
       try {
-        const compactResult = await this.dataSource.compactSessionHistory(curSessionId);
-        const summary = compactResult.summary || "";
+        const accepted = await this.dataSource.compactSessionHistory(curSessionId);
+        if (!accepted.runId) {
+          throw new Error("Async compaction run metadata is missing");
+        }
         this._updateMessaging({
-          turns: applyTurnLifecycleForPendingQuestion([createCompactedSystemTurn(curSessionId, summary)], null),
+          turns: applyTurnLifecycleForPendingQuestion(
+            [createCompactedSystemTurn(curSessionId, "Compacting conversation history...")],
+            null
+          ),
           pendingQuestion: null
         });
-        const result = await this.dataSource.fetchSession(curSessionId);
-        if (result) {
-          this._updateSession({ session: result.session });
-          this._setTurnsFromFetch(result.turns, result.pendingQuestion || null);
-        } else {
-          this._setTurnsFromFetch([], null);
+        await this._resumeAcceptedRunOrPoll(curSessionId, accepted.runId);
+        if (!this.state.messaging.generationInProgress) {
+          const result = await this.dataSource.fetchSession(curSessionId);
+          if (result) {
+            this._updateSession({ session: result.session });
+            this._setTurnsFromFetch(result.turns, result.pendingQuestion || null);
+          } else {
+            this._setTurnsFromFetch([], null);
+          }
+          this._updateMessaging({ codeOutputs: [] });
         }
-        this._updateMessaging({ codeOutputs: [] });
       } catch (err) {
         const normalized = normalizeRPCError(err, "Failed to compact session history");
         this._updateInput({ inputError: normalized.userMessage });
@@ -2738,8 +2773,6 @@ var ChatMachine = class {
       this._notifySessionsUpdated("session_created", targetSessionId);
       if (this.onSessionCreated) {
         this.onSessionCreated(targetSessionId);
-      } else {
-        this.dataSource.navigateToSession?.(targetSessionId);
       }
     }
     this._clearStreamError();
@@ -3025,9 +3058,24 @@ var ChatMachine = class {
         return;
       }
       if (result.success) {
+        this._updateMessaging({
+          pendingQuestion: null,
+          turns: applyTurnLifecycleForPendingQuestion(this.state.messaging.turns, null)
+        });
         if (result.data) {
-          this._updateSession({ session: result.data.session });
-          this._setTurnsFromFetch(result.data.turns, result.data.pendingQuestion || null);
+          await this._resumeAcceptedRunOrPoll(curSessionId, result.data.runId);
+          if (!this.state.messaging.generationInProgress) {
+            const fetchResult = await this.dataSource.fetchSession(curSessionId);
+            if (this.disposed) {
+              return;
+            }
+            if (fetchResult) {
+              this._updateSession({ session: fetchResult.session });
+              this._setTurnsFromFetch(fetchResult.turns, fetchResult.pendingQuestion || null);
+            } else {
+              this._updateSession({ error: "Failed to load updated session", errorRetryable: true });
+            }
+          }
         } else if (curSessionId !== "new") {
           const fetchResult = await this.dataSource.fetchSession(curSessionId);
           if (this.disposed) {
@@ -3071,7 +3119,9 @@ var ChatMachine = class {
           pendingQuestion: null,
           turns: applyTurnLifecycleForPendingQuestion(this.state.messaging.turns, null)
         });
-        if (curSessionId !== "new") {
+        if (result.data) {
+          await this._resumeAcceptedRunOrPoll(curSessionId, result.data.runId);
+        } else if (curSessionId !== "new") {
           const fetchResult = await this.dataSource.fetchSession(curSessionId);
           if (this.disposed) {
             return;
@@ -16880,9 +16930,10 @@ function useHttpDataSourceConfigFromApplet(options) {
       rpcEndpoint,
       streamEndpoint,
       csrfToken,
-      timeout: options?.timeout ?? 12e4
+      rpcTimeoutMs: options?.rpcTimeoutMs ?? 12e4,
+      streamConnectTimeoutMs: options?.streamConnectTimeoutMs ?? 3e4
     };
-  }, [options?.timeout]);
+  }, [options?.rpcTimeoutMs, options?.streamConnectTimeoutMs]);
 }
 var SESSION_PATH_REGEX = /\/session\/([^/]+)/;
 function useBichatRouter({
@@ -18048,7 +18099,23 @@ async function clearSessionHistory(callRPC, sessionId) {
   return callRPC("bichat.session.clear", { id: sessionId });
 }
 async function compactSessionHistory(callRPC, sessionId) {
-  return callRPC("bichat.session.compact", { id: sessionId });
+  const result = await callRPC("bichat.session.compact", { id: sessionId });
+  if (!result.accepted) {
+    throw new Error("Session compact request was not accepted");
+  }
+  if (result.operation !== "session_compact") {
+    throw new Error(`Unexpected async operation: ${result.operation}`);
+  }
+  if (!result.sessionId || !result.runId) {
+    throw new Error("Missing async run metadata");
+  }
+  return {
+    accepted: true,
+    operation: result.operation,
+    sessionId: result.sessionId,
+    runId: result.runId,
+    startedAt: result.startedAt
+  };
 }
 async function listUsers(callRPC) {
   const data = await callRPC("bichat.user.list", {});
@@ -18167,6 +18234,9 @@ var TERMINAL_TYPES = /* @__PURE__ */ new Set(["done", "error"]);
 async function* parseBichatStream(reader) {
   let yieldedTerminal = false;
   for await (const event of parseSSEStream(reader)) {
+    if (event.type === "ping") {
+      continue;
+    }
     const parsed = event;
     const inferredType = parsed.type || (parsed.content ? "content" : "error");
     const normalized = {
@@ -18504,7 +18574,7 @@ async function* sendMessage(deps, sessionId, content, attachments = [], signal,
       replaceFromMessageId: options?.replaceFromMessageID,
       attachments: streamAttachments
     };
-    const timeoutMs = deps.timeout ?? 0;
+    const timeoutMs = deps.streamConnectTimeoutMs ?? 0;
     if (timeoutMs > 0) {
       connectionTimeoutID = setTimeout(() => {
         connectionTimedOut = true;
@@ -18539,7 +18609,7 @@ async function* sendMessage(deps, sessionId, content, attachments = [], signal,
       if (err.name === "AbortError") {
         yield {
           type: "error",
-          error: connectionTimedOut ? `Stream request timed out after ${deps.timeout}ms` : "Stream cancelled"
+          error: connectionTimedOut ? `Stream request timed out after ${deps.streamConnectTimeoutMs}ms` : "Stream cancelled"
         };
       } else {
         yield {
@@ -18627,7 +18697,7 @@ async function resumeStream(deps, sessionId, runId, onChunk, signal) {
   const url = buildStreamUrl(deps, "/resume");
   const controller = new AbortController();
   let timeoutId;
-  const timeoutMs = deps.timeout;
+  const timeoutMs = deps.connectTimeoutMs;
   if (timeoutMs != null && timeoutMs > 0) {
     timeoutId = setTimeout(() => controller.abort(), timeoutMs);
   }
@@ -18644,6 +18714,10 @@ async function resumeStream(deps, sessionId, runId, onChunk, signal) {
     if (!response.ok) {
       throw new Error(`Resume stream failed: HTTP ${response.status}`);
     }
+    if (timeoutId !== void 0) {
+      clearTimeout(timeoutId);
+      timeoutId = void 0;
+    }
     if (!response.body) {
       throw new Error("Resume response body is null");
     }
@@ -18677,11 +18751,7 @@ async function submitQuestionAnswers(callRPC, sessionId, questionId, answers) {
     });
     return {
       success: true,
-      data: {
-        session: toSession(result.session),
-        turns: normalizeTurns(sanitizeConversationTurns(result.turns, sessionId)),
-        pendingQuestion: sanitizePendingQuestion(result.pendingQuestion, sessionId)
-      }
+      data: normalizeAsyncRunAccepted(result)
     };
   } catch (err) {
     return { success: false, error: err instanceof Error ? err.message : "Unknown error" };
@@ -18689,12 +18759,33 @@ async function submitQuestionAnswers(callRPC, sessionId, questionId, answers) {
 }
 async function rejectPendingQuestion(callRPC, sessionId) {
   try {
-    await callRPC("bichat.question.reject", { sessionId });
-    return { success: true };
+    const result = await callRPC("bichat.question.reject", { sessionId });
+    return { success: true, data: normalizeAsyncRunAccepted(result) };
   } catch (err) {
     return { success: false, error: err instanceof Error ? err.message : "Unknown error" };
   }
 }
+function isAsyncRunOperation(value) {
+  return value === "question_submit" || value === "question_reject" || value === "session_compact";
+}
+function normalizeAsyncRunAccepted(input) {
+  if (!input.accepted) {
+    throw new Error("Async run request was not accepted");
+  }
+  if (!isAsyncRunOperation(input.operation)) {
+    throw new Error(`Unexpected async operation: ${input.operation}`);
+  }
+  if (!input.sessionId || !input.runId) {
+    throw new Error("Missing async run metadata");
+  }
+  return {
+    accepted: true,
+    operation: input.operation,
+    sessionId: input.sessionId,
+    runId: input.runId,
+    startedAt: input.startedAt
+  };
+}
 
 // ui/src/bichat/data/ArtifactManager.ts
 async function fetchSessionArtifacts(callRPC, sessionId, options) {
@@ -18766,15 +18857,13 @@ var HttpDataSource = class {
     this.config = {
       streamEndpoint: "/stream",
       uploadEndpoint: "/api/uploads",
-      timeout: 12e4,
-      ...config
+      ...config,
+      rpcTimeoutMs: typeof config.rpcTimeoutMs === "number" ? config.rpcTimeoutMs : 12e4,
+      streamConnectTimeoutMs: typeof config.streamConnectTimeoutMs === "number" ? config.streamConnectTimeoutMs : 3e4
     };
-    if (config.navigateToSession) {
-      this.navigateToSession = config.navigateToSession;
-    }
     this.rpc = createAppletRPCClient({
       endpoint: `${this.config.baseUrl}${this.config.rpcEndpoint}`,
-      timeoutMs: this.config.timeout
+      timeoutMs: this.config.rpcTimeoutMs
     });
   }
   // -------------------------------------------------------------------------
@@ -18894,7 +18983,7 @@ var HttpDataSource = class {
         baseUrl: this.config.baseUrl,
         streamEndpoint: this.config.streamEndpoint,
         createHeaders: (h) => this.createHeaders(h),
-        timeoutMs: this.config.timeout
+        timeoutMs: this.config.rpcTimeoutMs
       },
       sessionId
     );
@@ -18905,7 +18994,7 @@ var HttpDataSource = class {
         baseUrl: this.config.baseUrl,
         streamEndpoint: this.config.streamEndpoint,
         createHeaders: (h) => this.createHeaders(h),
-        timeout: this.config.timeout
+        connectTimeoutMs: this.config.streamConnectTimeoutMs
       },
       sessionId,
       runId,
@@ -18929,7 +19018,8 @@ var HttpDataSource = class {
           callRPC: this.boundCallRPC,
           baseUrl: this.config.baseUrl,
           streamEndpoint: this.config.streamEndpoint,
-          timeout: this.config.timeout,
+          rpcTimeoutMs: this.config.rpcTimeoutMs,
+          streamConnectTimeoutMs: this.config.streamConnectTimeoutMs,
           createHeaders: (additional) => this.createHeaders(additional),
           uploadFileFn: this.boundUploadFile,
           logAttachmentLifecycle: () => {
@@ -18980,17 +19070,6 @@ var HttpDataSource = class {
   async deleteSessionArtifact(artifactId) {
     return deleteSessionArtifact(this.boundCallRPC, artifactId);
   }
-  // -------------------------------------------------------------------------
-  // Navigation (optional, deprecated)
-  // -------------------------------------------------------------------------
-  /**
-   * @deprecated Pass `onSessionCreated` to `ChatSessionProvider` instead.
-   */
-  navigateToSession(sessionId) {
-    if (typeof window !== "undefined") {
-      window.location.href = `/chat/${sessionId}`;
-    }
-  }
 };
 function createHttpDataSource(config) {
   return new HttpDataSource(config);