@iota-uz/sdk 0.4.17 → 0.4.19

package/dist/bichat/index.cjs

@@ -1518,6 +1518,10 @@ var ChatMachine = class {
   }
   /** Sets turns from fetch, preserving pending user-only turns if server hasn't caught up. */
   _setTurnsFromFetch(fetchedTurns) {
+    if (!Array.isArray(fetchedTurns)) {
+      console.warn("[ChatMachine] Ignoring malformed turns payload from fetchSession");
+      return;
+    }
     const prev = this.state.messaging.turns;
     const hasPendingUserOnly = prev.length > 0 && !prev[prev.length - 1].assistantTurn;
     if (hasPendingUserOnly && (!fetchedTurns || fetchedTurns.length === 0)) {
@@ -1907,6 +1911,7 @@ var ChatMachine = class {
     const curSessionId = this.state.session.currentSessionId;
     const curPendingQuestion = this.state.messaging.pendingQuestion;
     if (!curSessionId || !curPendingQuestion) return;
+    const previousTurns = this.state.messaging.turns;
     this._updateMessaging({ loading: true });
     this._updateSession({ error: null, errorRetryable: false });
     const previousPendingQuestion = curPendingQuestion;
@@ -1924,19 +1929,28 @@ var ChatMachine = class {
             const fetchResult = await this.dataSource.fetchSession(curSessionId);
             if (this.disposed) return;
             if (fetchResult) {
-              this._updateMessaging({
-                turns: fetchResult.turns,
-                pendingQuestion: fetchResult.pendingQuestion || null
-              });
+              this._updateSession({ session: fetchResult.session });
+              this._updateMessaging({ pendingQuestion: fetchResult.pendingQuestion || null });
+              const hasMalformedRefresh = previousTurns.length > 0 && Array.isArray(fetchResult.turns) && fetchResult.turns.length === 0;
+              if (hasMalformedRefresh) {
+                console.warn("[ChatMachine] Preserving previous turns due to empty post-HITL refetch payload", {
+                  sessionId: curSessionId,
+                  previousTurnCount: previousTurns.length
+                });
+                this._updateSession({
+                  error: "Failed to fully refresh session. Showing last known messages.",
+                  errorRetryable: true
+                });
+              } else {
+                this._setTurnsFromFetch(fetchResult.turns);
+              }
             } else {
-              this._updateMessaging({ pendingQuestion: previousPendingQuestion });
-              this._updateSession({ error: "Failed to load updated session", errorRetryable: false });
+              this._updateSession({ error: "Failed to load updated session", errorRetryable: true });
             }
           } catch (fetchErr) {
             if (this.disposed) return;
-            this._updateMessaging({ pendingQuestion: previousPendingQuestion });
             const normalized = normalizeRPCError(fetchErr, "Failed to load updated session");
-            this._updateSession({ error: normalized.userMessage, errorRetryable: normalized.retryable });
+            this._updateSession({ error: normalized.userMessage, errorRetryable: true });
           }
         }
       } else {
@@ -3296,7 +3310,7 @@ function InlineQuestionForm({ pendingQuestion }) {
   const [currentStep, setCurrentStep] = React.useState(0);
   const [answers, setAnswers] = React.useState({});
   const [otherTexts, setOtherTexts] = React.useState({});
-  const questions = pendingQuestion.questions;
+  const questions = Array.isArray(pendingQuestion.questions) ? pendingQuestion.questions : [];
   const currentQuestion = questions[currentStep];
   const isLastStep = currentStep === questions.length - 1;
   const isFirstStep = currentStep === 0;
@@ -3390,9 +3404,31 @@ function InlineQuestionForm({ pendingQuestion }) {
     e.preventDefault();
     handleNext();
   };
-  if (!currentQuestion) return null;
+  if (!currentQuestion) {
+    return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "animate-slide-up rounded-2xl border border-amber-200 dark:border-amber-700/50 bg-gradient-to-b from-amber-50/70 to-white dark:from-amber-950/20 dark:to-gray-900/80 shadow-sm overflow-hidden p-4", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-sm font-medium text-gray-800 dark:text-gray-200", children: t("BiChat.Error.SomethingWentWrong") }),
+      /* @__PURE__ */ jsxRuntime.jsx("p", { className: "mt-1 text-xs text-gray-500 dark:text-gray-400", children: t("BiChat.Error.UnexpectedError") }),
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: "mt-3", children: /* @__PURE__ */ jsxRuntime.jsxs(
+        "button",
+        {
+          type: "button",
+          onClick: handleRejectPendingQuestion,
+          disabled: loading,
+          className: "cursor-pointer inline-flex items-center gap-1.5 px-3 py-1.5 text-sm rounded-lg bg-gray-100 dark:bg-gray-800 text-gray-700 dark:text-gray-300 hover:bg-gray-200 dark:hover:bg-gray-700 disabled:opacity-40",
+          children: [
+            /* @__PURE__ */ jsxRuntime.jsx(react.X, { size: 14, weight: "bold" }),
+            t("BiChat.InlineQuestion.Dismiss")
+          ]
+        }
+      ) })
+    ] });
+  }
   const isMultiSelect = currentQuestion.type === "MULTIPLE_CHOICE";
-  const options = currentQuestion.options || [];
+  const options = (currentQuestion.options || []).filter((option) => Boolean(option && typeof option.label === "string")).map((option, index) => ({
+    id: option.id || `${currentQuestion.id}-option-${index}`,
+    label: option.label,
+    value: option.value || option.label
+  }));
   const isOtherSelected = currentAnswer?.customText !== void 0;
   const canProceed = isCurrentAnswerValid();
   return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "animate-slide-up rounded-2xl border border-gray-200 dark:border-gray-700/50 bg-gradient-to-b from-primary-50/80 to-white dark:from-primary-950/30 dark:to-gray-900/80 shadow-sm overflow-hidden", children: /* @__PURE__ */ jsxRuntime.jsxs("form", { onSubmit: handleSubmit, children: [
@@ -4306,7 +4342,8 @@ function TurnBubble({
     userTurn: classNames?.userTurn ?? defaultClassNames3.userTurn,
     assistantTurn: classNames?.assistantTurn ?? defaultClassNames3.assistantTurn
   };
-  const isSystemSummaryTurn = turn.userTurn.content.trim() === "" && turn.assistantTurn?.role === "system";
+  const userContent = typeof turn.userTurn?.content === "string" ? turn.userTurn.content : "";
+  const isSystemSummaryTurn = userContent.trim() === "" && turn.assistantTurn?.role === "system";
   return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: classes.root, "data-turn-id": turn.id, children: [
     !isSystemSummaryTurn && /* @__PURE__ */ jsxRuntime.jsx("div", { className: classes.userTurn, children: renderUserTurn ? renderUserTurn(turn) : /* @__PURE__ */ jsxRuntime.jsx(
       UserTurnView,
@@ -8084,12 +8121,63 @@ function DefaultErrorContent({
     ] })
   ] });
 }
+function StaticEmergencyErrorContent({
+  error,
+  onReset
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex flex-col items-center justify-center p-8 text-center min-h-[200px]", children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "relative flex flex-col items-center", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "relative mb-5", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: "absolute inset-0 rounded-full bg-red-100 scale-150 blur-md" }),
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: "relative flex items-center justify-center w-14 h-14 rounded-full bg-red-50 border border-red-200/60", children: /* @__PURE__ */ jsxRuntime.jsx(react.WarningCircle, { size: 28, className: "text-red-500", weight: "fill" }) })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx("h2", { className: "text-lg font-semibold text-gray-900 mb-1.5", children: "Something went wrong" }),
+    /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-sm text-gray-500 mb-5 max-w-md leading-relaxed", children: error?.message || "An unexpected UI error occurred." }),
+    onReset && /* @__PURE__ */ jsxRuntime.jsxs(
+      "button",
+      {
+        type: "button",
+        onClick: onReset,
+        className: "flex items-center gap-2 px-5 py-2.5 bg-red-600 hover:bg-red-700 active:bg-red-800 text-white rounded-lg transition-colors shadow-sm text-sm font-medium",
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx(react.ArrowClockwise, { size: 16, weight: "bold" }),
+          "Try again"
+        ]
+      }
+    )
+  ] }) });
+}
+var FallbackGuard = class extends React.Component {
+  constructor(props) {
+    super(props);
+    this.state = { fallbackFailed: false };
+  }
+  static getDerivedStateFromError() {
+    return { fallbackFailed: true };
+  }
+  componentDidCatch(error, errorInfo) {
+    this.props.onFallbackError?.(error, errorInfo);
+  }
+  render() {
+    if (this.state.fallbackFailed) {
+      return /* @__PURE__ */ jsxRuntime.jsx(StaticEmergencyErrorContent, { error: this.props.primaryError, onReset: this.props.onReset });
+    }
+    return this.props.renderFallback();
+  }
+};
 var ErrorBoundary = class extends React.Component {
   constructor(props) {
     super(props);
     this.handleReset = () => {
       this.setState({ hasError: false, error: null });
     };
+    this.handleFallbackError = (error, errorInfo) => {
+      console.error("React Error Boundary fallback crashed:", {
+        primaryError: this.state.error,
+        fallbackError: error,
+        errorInfo
+      });
+      this.props.onError?.(error, errorInfo);
+    };
     this.state = { hasError: false, error: null };
   }
   static getDerivedStateFromError(error) {
@@ -8101,13 +8189,24 @@ var ErrorBoundary = class extends React.Component {
   }
   render() {
     if (this.state.hasError) {
-      if (this.props.fallback) {
-        if (typeof this.props.fallback === "function") {
-          return this.props.fallback(this.state.error, this.handleReset);
-        }
-        return this.props.fallback;
-      }
-      return /* @__PURE__ */ jsxRuntime.jsx(DefaultErrorContent, { error: this.state.error, onReset: this.handleReset });
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        FallbackGuard,
+        {
+          primaryError: this.state.error,
+          onReset: this.handleReset,
+          onFallbackError: this.handleFallbackError,
+          renderFallback: () => {
+            if (this.props.fallback) {
+              if (typeof this.props.fallback === "function") {
+                return this.props.fallback(this.state.error, this.handleReset);
+              }
+              return this.props.fallback;
+            }
+            return /* @__PURE__ */ jsxRuntime.jsx(DefaultErrorContent, { error: this.state.error, onReset: this.handleReset });
+          }
+        },
+        `${this.state.error?.name ?? "Error"}:${this.state.error?.message ?? ""}`
+      );
     }
     return this.props.children;
   }
@@ -12066,6 +12165,7 @@ function toSessionArtifact(artifact) {
     id: artifact.id,
     sessionId: artifact.sessionId,
     messageId: artifact.messageId,
+    uploadId: artifact.uploadId,
     type: artifact.type,
     name: artifact.name,
     description: artifact.description,
@@ -12076,21 +12176,272 @@ function toSessionArtifact(artifact) {
     createdAt: artifact.createdAt
   };
 }
-function toPendingQuestion(rpc) {
-  if (!rpc) return null;
-  const questions = (rpc.questions || []).map((q) => ({
-    id: q.id,
-    text: q.text,
-    type: q.type,
-    options: (q.options || []).map((o) => ({
-      id: o.id,
-      label: o.label,
-      value: o.label
-    }))
-  }));
+function warnMalformedSessionPayload(message, details) {
+  console.warn(`[BiChat] ${message}`, details || {});
+}
+function readString(value, fallback = "") {
+  return typeof value === "string" ? value : fallback;
+}
+function readNonEmptyString(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function readFiniteNumber(value, fallback = 0) {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function readOptionalFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function normalizeQuestionType(rawType) {
+  const normalized = readString(rawType).trim().toUpperCase().replace(/[\s-]+/g, "_");
+  return normalized === "MULTIPLE_CHOICE" ? "MULTIPLE_CHOICE" : "SINGLE_CHOICE";
+}
+function normalizeMessageRole(rawRole) {
+  const normalized = readString(rawRole).trim().toLowerCase();
+  if (normalized === "user" /* User */) return "user" /* User */;
+  if (normalized === "system" /* System */) return "system" /* System */;
+  if (normalized === "tool" /* Tool */) return "tool" /* Tool */;
+  return "assistant" /* Assistant */;
+}
+function sanitizeAttachment(rawAttachment, turnId, index) {
+  if (!isRecord(rawAttachment)) {
+    warnMalformedSessionPayload("Dropped malformed attachment entry", { turnId, index });
+    return null;
+  }
+  const filename = readString(rawAttachment.filename, "attachment");
+  const mimeType = readString(rawAttachment.mimeType, "application/octet-stream");
+  const id = readNonEmptyString(rawAttachment.id) || void 0;
+  const clientKey = readNonEmptyString(rawAttachment.clientKey) || id || `${turnId}-attachment-${index}`;
+  return {
+    id,
+    clientKey,
+    filename,
+    mimeType,
+    sizeBytes: readFiniteNumber(rawAttachment.sizeBytes),
+    uploadId: readOptionalFiniteNumber(rawAttachment.uploadId),
+    base64Data: readNonEmptyString(rawAttachment.base64Data) || void 0,
+    url: readNonEmptyString(rawAttachment.url) || void 0,
+    preview: readNonEmptyString(rawAttachment.preview) || void 0
+  };
+}
+function sanitizeUserAttachments(rawAttachments, turnId) {
+  if (!Array.isArray(rawAttachments)) return [];
+  const result = [];
+  for (let i = 0; i < rawAttachments.length; i++) {
+    const sanitized = sanitizeAttachment(rawAttachments[i], turnId, i);
+    if (sanitized) result.push(sanitized);
+  }
+  return result;
+}
+function sanitizeAssistantArtifacts(rawArtifacts, turnId) {
+  if (!Array.isArray(rawArtifacts)) return [];
+  const artifacts = [];
+  for (let i = 0; i < rawArtifacts.length; i++) {
+    const raw = rawArtifacts[i];
+    if (!isRecord(raw)) {
+      warnMalformedSessionPayload("Dropped malformed assistant artifact", { turnId, index: i });
+      continue;
+    }
+    const type = readString(raw.type).toLowerCase();
+    if (type !== "excel" && type !== "pdf") {
+      continue;
+    }
+    const url = readNonEmptyString(raw.url);
+    if (!url) {
+      warnMalformedSessionPayload("Dropped assistant artifact without url", { turnId, index: i });
+      continue;
+    }
+    artifacts.push({
+      type,
+      filename: readString(raw.filename, "download"),
+      url,
+      sizeReadable: readNonEmptyString(raw.sizeReadable) || void 0,
+      rowCount: typeof raw.rowCount === "number" && Number.isFinite(raw.rowCount) ? raw.rowCount : void 0,
+      description: readNonEmptyString(raw.description) || void 0
+    });
+  }
+  return artifacts;
+}
+function sanitizeAssistantTurn(rawAssistantTurn, fallbackCreatedAt, turnId) {
+  if (rawAssistantTurn == null) return void 0;
+  if (!isRecord(rawAssistantTurn)) {
+    warnMalformedSessionPayload("Dropped malformed assistant turn payload", { turnId });
+    return void 0;
+  }
+  const assistantID = readNonEmptyString(rawAssistantTurn.id);
+  if (!assistantID) {
+    warnMalformedSessionPayload("Dropped assistant turn without id", { turnId });
+    return void 0;
+  }
+  const citations = Array.isArray(rawAssistantTurn.citations) ? rawAssistantTurn.citations.filter((item) => isRecord(item)).map((item, index) => ({
+    id: readString(item.id, `${assistantID}-citation-${index}`),
+    type: readString(item.type),
+    title: readString(item.title),
+    url: readString(item.url),
+    startIndex: readFiniteNumber(item.startIndex),
+    endIndex: readFiniteNumber(item.endIndex),
+    excerpt: readNonEmptyString(item.excerpt) || void 0
+  })) : [];
+  const toolCalls = Array.isArray(rawAssistantTurn.toolCalls) ? rawAssistantTurn.toolCalls.filter((item) => isRecord(item)).map((item, index) => ({
+    id: readString(item.id, `${assistantID}-tool-${index}`),
+    name: readString(item.name),
+    arguments: readString(item.arguments),
+    result: readNonEmptyString(item.result) || void 0,
+    error: readNonEmptyString(item.error) || void 0,
+    durationMs: readFiniteNumber(item.durationMs)
+  })) : [];
+  const codeOutputs = Array.isArray(rawAssistantTurn.codeOutputs) ? rawAssistantTurn.codeOutputs.filter((item) => isRecord(item)).map((item) => ({
+    type: (() => {
+      const normalizedType = readString(item.type, "text").toLowerCase();
+      if (normalizedType === "image" || normalizedType === "error") return normalizedType;
+      return "text";
+    })(),
+    content: readString(item.content),
+    filename: readNonEmptyString(item.filename) || void 0,
+    mimeType: readNonEmptyString(item.mimeType) || void 0,
+    sizeBytes: readOptionalFiniteNumber(item.sizeBytes)
+  })) : [];
+  const debugTrace = isRecord(rawAssistantTurn.debug) ? {
+    generationMs: readOptionalFiniteNumber(rawAssistantTurn.debug.generationMs),
+    usage: isRecord(rawAssistantTurn.debug.usage) ? {
+      promptTokens: readFiniteNumber(rawAssistantTurn.debug.usage.promptTokens),
+      completionTokens: readFiniteNumber(rawAssistantTurn.debug.usage.completionTokens),
+      totalTokens: readFiniteNumber(rawAssistantTurn.debug.usage.totalTokens),
+      cachedTokens: readOptionalFiniteNumber(rawAssistantTurn.debug.usage.cachedTokens),
+      cost: readOptionalFiniteNumber(rawAssistantTurn.debug.usage.cost)
+    } : void 0,
+    tools: Array.isArray(rawAssistantTurn.debug.tools) ? rawAssistantTurn.debug.tools.filter((tool) => isRecord(tool)).map((tool) => ({
+      callId: readNonEmptyString(tool.callId) || void 0,
+      name: readString(tool.name),
+      arguments: readNonEmptyString(tool.arguments) || void 0,
+      result: readNonEmptyString(tool.result) || void 0,
+      error: readNonEmptyString(tool.error) || void 0,
+      durationMs: readOptionalFiniteNumber(tool.durationMs)
+    })) : []
+  } : void 0;
+  return {
+    id: assistantID,
+    role: normalizeMessageRole(rawAssistantTurn.role),
+    content: readString(rawAssistantTurn.content),
+    explanation: readNonEmptyString(rawAssistantTurn.explanation) || void 0,
+    citations,
+    toolCalls,
+    chartData: void 0,
+    artifacts: sanitizeAssistantArtifacts(rawAssistantTurn.artifacts, turnId),
+    codeOutputs,
+    debug: debugTrace,
+    createdAt: readString(rawAssistantTurn.createdAt, fallbackCreatedAt)
+  };
+}
+function sanitizeConversationTurn(rawTurn, index, fallbackSessionID) {
+  if (!isRecord(rawTurn)) {
+    warnMalformedSessionPayload("Dropped malformed turn payload (not an object)", { index });
+    return null;
+  }
+  if (!isRecord(rawTurn.userTurn)) {
+    warnMalformedSessionPayload("Dropped malformed turn payload (missing user turn)", { index });
+    return null;
+  }
+  const userTurnID = readNonEmptyString(rawTurn.userTurn.id);
+  if (!userTurnID) {
+    warnMalformedSessionPayload("Dropped malformed turn payload (missing user turn id)", { index });
+    return null;
+  }
+  const turnID = readString(rawTurn.id, userTurnID);
+  const createdAt = readString(
+    rawTurn.createdAt,
+    readString(rawTurn.userTurn.createdAt, (/* @__PURE__ */ new Date()).toISOString())
+  );
   return {
-    id: rpc.checkpointId,
-    turnId: rpc.turnId || "",
+    id: turnID,
+    sessionId: readString(rawTurn.sessionId, fallbackSessionID),
+    userTurn: {
+      id: userTurnID,
+      content: readString(rawTurn.userTurn.content),
+      attachments: sanitizeUserAttachments(rawTurn.userTurn.attachments, turnID),
+      createdAt: readString(rawTurn.userTurn.createdAt, createdAt)
+    },
+    assistantTurn: sanitizeAssistantTurn(rawTurn.assistantTurn, createdAt, turnID),
+    createdAt
+  };
+}
+function sanitizeConversationTurns(rawTurns, sessionID) {
+  if (!Array.isArray(rawTurns)) {
+    warnMalformedSessionPayload("Session payload contained non-array turns field", { sessionID });
+    return [];
+  }
+  const turns = [];
+  let dropped = 0;
+  for (let i = 0; i < rawTurns.length; i++) {
+    const sanitizedTurn = sanitizeConversationTurn(rawTurns[i], i, sessionID);
+    if (sanitizedTurn) {
+      turns.push(sanitizedTurn);
+    } else {
+      dropped++;
+    }
+  }
+  if (dropped > 0) {
+    warnMalformedSessionPayload("Dropped malformed turns from session payload", {
+      sessionID,
+      dropped,
+      total: rawTurns.length
+    });
+  }
+  return turns;
+}
+function sanitizePendingQuestion(rawPendingQuestion, sessionID) {
+  if (!rawPendingQuestion) return null;
+  const checkpointID = readNonEmptyString(rawPendingQuestion.checkpointId);
+  if (!checkpointID) {
+    warnMalformedSessionPayload("Dropped malformed pendingQuestion without checkpointId", { sessionID });
+    return null;
+  }
+  if (!Array.isArray(rawPendingQuestion.questions)) {
+    warnMalformedSessionPayload("Pending question had non-array questions payload", {
+      sessionID,
+      checkpointID
+    });
+  }
+  const questions = Array.isArray(rawPendingQuestion.questions) ? rawPendingQuestion.questions.filter((question) => {
+    if (!question || !isRecord(question)) {
+      warnMalformedSessionPayload("Dropped malformed question from pendingQuestion", {
+        sessionID,
+        checkpointID
+      });
+      return false;
+    }
+    return true;
+  }).map((question, index) => {
+    const questionID = readString(question.id, `${checkpointID}-q-${index}`);
+    const options = Array.isArray(question.options) ? question.options.filter((option) => {
+      if (!option || !isRecord(option)) {
+        warnMalformedSessionPayload("Dropped malformed pendingQuestion option", {
+          sessionID,
+          checkpointID,
+          questionID
+        });
+        return false;
+      }
+      return true;
+    }).map((option, optionIndex) => {
+      const label = readString(option.label);
+      return {
+        id: readString(option.id, `${questionID}-opt-${optionIndex}`),
+        label,
+        value: label
+      };
+    }) : [];
+    return {
+      id: questionID,
+      text: readString(question.text),
+      type: normalizeQuestionType(question.type),
+      options
+    };
+  }) : [];
+  return {
+    id: checkpointID,
+    turnId: readString(rawPendingQuestion.turnId),
     questions,
     status: "PENDING"
   };
@@ -12286,6 +12637,7 @@ var HttpDataSource = class {
     this.abortController = null;
     this.config = {
       streamEndpoint: "/stream",
+      uploadEndpoint: "/api/uploads",
       timeout: 12e4,
       ...config
     };
@@ -12321,6 +12673,83 @@ var HttpDataSource = class {
     }
     return headers;
   }
+  createUploadHeaders(additionalHeaders) {
+    const headers = new Headers({
+      ...this.config.headers,
+      ...additionalHeaders
+    });
+    const csrfToken = this.getCSRFToken();
+    if (csrfToken) {
+      headers.set("X-CSRF-Token", csrfToken);
+    }
+    headers.delete("Content-Type");
+    return headers;
+  }
+  async uploadFile(file) {
+    const formData = new FormData();
+    formData.append("file", file);
+    const response = await fetch(`${this.config.baseUrl}${this.config.uploadEndpoint}`, {
+      method: "POST",
+      headers: this.createUploadHeaders(),
+      body: formData
+    });
+    let payload = null;
+    try {
+      payload = await response.json();
+    } catch {
+      payload = null;
+    }
+    if (!response.ok) {
+      const errorMessage = isRecord(payload) && typeof payload.error === "string" ? payload.error : `Upload failed: HTTP ${response.status}`;
+      throw new Error(errorMessage);
+    }
+    if (!isRecord(payload) || typeof payload.id !== "number" || payload.id <= 0) {
+      throw new Error("Upload failed: invalid response payload");
+    }
+    return {
+      id: payload.id,
+      url: typeof payload.url === "string" ? payload.url : "",
+      path: typeof payload.path === "string" ? payload.path : "",
+      name: typeof payload.name === "string" ? payload.name : file.name,
+      mimetype: typeof payload.mimetype === "string" ? payload.mimetype : file.type,
+      size: typeof payload.size === "number" && Number.isFinite(payload.size) ? payload.size : file.size
+    };
+  }
+  async attachmentToFile(attachment) {
+    if (attachment.base64Data && attachment.base64Data.trim().length > 0) {
+      const base64Data = attachment.base64Data.trim();
+      const dataUrl = base64Data.startsWith("data:") ? base64Data : `data:${attachment.mimeType || "application/octet-stream"};base64,${base64Data}`;
+      const blob = await fetch(dataUrl).then((response) => response.blob());
+      return new File([blob], attachment.filename, {
+        type: attachment.mimeType || blob.type || "application/octet-stream"
+      });
+    }
+    if (attachment.url) {
+      const response = await fetch(attachment.url);
+      if (!response.ok) {
+        throw new Error(`Failed to read attachment source: HTTP ${response.status}`);
+      }
+      const blob = await response.blob();
+      return new File([blob], attachment.filename, {
+        type: attachment.mimeType || blob.type || "application/octet-stream"
+      });
+    }
+    throw new Error(`Attachment "${attachment.filename}" has no uploadable data`);
+  }
+  async ensureAttachmentUpload(attachment) {
+    if (typeof attachment.uploadId === "number" && attachment.uploadId > 0) {
+      return {
+        id: attachment.uploadId,
+        url: attachment.url || "",
+        path: "",
+        name: attachment.filename,
+        mimetype: attachment.mimeType,
+        size: attachment.sizeBytes
+      };
+    }
+    const file = await this.attachmentToFile(attachment);
+    return this.uploadFile(file);
+  }
   async callRPC(method, params) {
     return this.rpc.callTyped(method, params);
   }
@@ -12343,11 +12772,22 @@ var HttpDataSource = class {
           return { artifacts: [], hasMore: false, nextOffset: 0 };
         })
       ]);
-      const turns = attachArtifactsToTurns(normalizeTurns(data.turns), artifactsData.artifacts || []);
+      const sanitizedTurns = sanitizeConversationTurns(data.turns, id);
+      const turns = attachArtifactsToTurns(
+        normalizeTurns(sanitizedTurns),
+        artifactsData.artifacts || []
+      );
+      const pendingQuestion = sanitizePendingQuestion(data.pendingQuestion, id);
+      if (data.pendingQuestion && pendingQuestion && pendingQuestion.questions.length === 0) {
+        warnMalformedSessionPayload("Pending question normalized to zero renderable questions", {
+          sessionID: id,
+          checkpointID: pendingQuestion.id
+        });
+      }
       return {
         session: toSession(data.session),
         turns,
-        pendingQuestion: toPendingQuestion(data.pendingQuestion)
+        pendingQuestion
       };
     } catch (err) {
       if (isSessionNotFoundError(err)) {
@@ -12379,27 +12819,12 @@ var HttpDataSource = class {
       return { artifacts: [] };
     }
     validateFileCount(0, files.length, 10);
-    const attachments = [];
-    for (const file of files) {
-      validateAttachmentFile(file);
-      const base64Data = await convertToBase64(file);
-      attachments.push({
-        clientKey: crypto.randomUUID(),
-        filename: file.name,
-        mimeType: file.type,
-        sizeBytes: file.size,
-        base64Data
-      });
-    }
+    files.forEach((file) => validateAttachmentFile(file));
+    const uploads = await Promise.all(files.map((file) => this.uploadFile(file)));
     const data = await this.callRPC("bichat.session.uploadArtifacts", {
       sessionId,
-      attachments: attachments.map((a) => ({
-        id: "",
-        // Backend will assign ID
-        filename: a.filename,
-        mimeType: a.mimeType,
-        sizeBytes: a.sizeBytes,
-        base64Data: a.base64Data
+      attachments: uploads.map((upload) => ({
+        uploadId: upload.id
       }))
     });
     return {
@@ -12430,22 +12855,21 @@ var HttpDataSource = class {
       signal.addEventListener("abort", onExternalAbort);
     }
     const url = `${this.config.baseUrl}${this.config.streamEndpoint}`;
-    const payload = {
-      sessionId,
-      content,
-      debugMode: options?.debugMode ?? false,
-      replaceFromMessageId: options?.replaceFromMessageID,
-      attachments: attachments.map((a) => ({
-        filename: a.filename,
-        mimeType: a.mimeType,
-        sizeBytes: a.sizeBytes,
-        base64Data: a.base64Data,
-        url: a.url
-      }))
-    };
     let connectionTimeoutID;
     let connectionTimedOut = false;
     try {
+      const uploads = await Promise.all(
+        attachments.map((attachment) => this.ensureAttachmentUpload(attachment))
+      );
+      const payload = {
+        sessionId,
+        content,
+        debugMode: options?.debugMode ?? false,
+        replaceFromMessageId: options?.replaceFromMessageID,
+        attachments: uploads.map((upload) => ({
+          uploadId: upload.id
+        }))
+      };
       const timeoutMs = this.config.timeout ?? 0;
       if (timeoutMs > 0) {
         connectionTimeoutID = setTimeout(() => {