@iota-uz/sdk 0.4.34 → 0.4.36

package/dist/bichat/index.cjs

@@ -3015,7 +3015,10 @@ var ChatMachine = class {
       )
     });
     const normalized = normalizeRPCError(err, "Failed to send message");
-    this._updateInput({ inputError: normalized.userMessage });
+    this._updateInput({
+      message: content,
+      inputError: normalized.userMessage
+    });
     this._updateMessaging({
       streamError: normalized.userMessage,
       streamErrorRetryable: normalized.retryable
@@ -12689,7 +12692,9 @@ function ModelSelector() {
   }, [currentModel, models, setModel]);
   React.useEffect(() => {
     const handler = (e) => {
-      if ((e.metaKey || e.ctrlKey) && e.shiftKey && e.key === "m") {
+      const isModifierPressed = e.metaKey || e.ctrlKey;
+      const isShortcutKey = e.code === "KeyM" || e.key.toLowerCase() === "m";
+      if (isModifierPressed && e.shiftKey && !e.altKey && isShortcutKey) {
         e.preventDefault();
         rotateModel();
       }
@@ -17065,6 +17070,140 @@ function useStreaming2(options = {}) {
     reset
   };
 }
+var TERMINAL = /* @__PURE__ */ new Set([
+  "completed",
+  "cancelled",
+  "failed"
+]);
+function useActiveRuns(dataSource, options = {}) {
+  const [runs, setRuns] = React.useState({});
+  const [ready, setReady] = React.useState(false);
+  const onErrorRef = React.useRef(options.onError);
+  onErrorRef.current = options.onError;
+  const enabled = options.enabled ?? true;
+  const retainTerminalMs = options.retainTerminalMs ?? 0;
+  const emptyStateTimeoutMs = options.emptyStateTimeoutMs ?? 250;
+  React.useEffect(() => {
+    if (!enabled) {
+      return;
+    }
+    if (!dataSource.subscribeActiveRuns) {
+      return;
+    }
+    const controller = new AbortController();
+    let stagingTimer;
+    const staging = {};
+    let sawSnapshotRow = false;
+    const pendingTerminalTimers = /* @__PURE__ */ new Map();
+    const flushSnapshot = () => {
+      setRuns((prev) => ({ ...prev, ...staging }));
+      setReady(true);
+      stagingTimer = void 0;
+    };
+    const subscription = dataSource.subscribeActiveRuns({
+      signal: controller.signal,
+      onError: (evt) => onErrorRef.current?.(evt),
+      onEvent: (evt) => {
+        if (evt.event === "snapshot") {
+          sawSnapshotRow = true;
+          const pending2 = pendingTerminalTimers.get(evt.sessionId);
+          if (pending2 !== void 0) {
+            clearTimeout(pending2);
+            pendingTerminalTimers.delete(evt.sessionId);
+          }
+          staging[evt.sessionId] = {
+            runId: evt.runId,
+            status: evt.status,
+            updatedAt: evt.updatedAt
+          };
+          if (stagingTimer === void 0) {
+            stagingTimer = setTimeout(flushSnapshot, 16);
+          }
+          return;
+        }
+        if (TERMINAL.has(evt.status)) {
+          if (retainTerminalMs <= 0) {
+            setRuns((prev) => {
+              if (!(evt.sessionId in prev)) {
+                return prev;
+              }
+              const next = { ...prev };
+              delete next[evt.sessionId];
+              return next;
+            });
+            return;
+          }
+          setRuns((prev) => ({
+            ...prev,
+            [evt.sessionId]: {
+              runId: evt.runId,
+              status: evt.status,
+              updatedAt: evt.updatedAt
+            }
+          }));
+          const existing = pendingTerminalTimers.get(evt.sessionId);
+          if (existing !== void 0) {
+            clearTimeout(existing);
+          }
+          const handle = setTimeout(() => {
+            pendingTerminalTimers.delete(evt.sessionId);
+            setRuns((prev) => {
+              if (!(evt.sessionId in prev)) {
+                return prev;
+              }
+              const next = { ...prev };
+              delete next[evt.sessionId];
+              return next;
+            });
+          }, retainTerminalMs);
+          pendingTerminalTimers.set(evt.sessionId, handle);
+          return;
+        }
+        const pending = pendingTerminalTimers.get(evt.sessionId);
+        if (pending !== void 0) {
+          clearTimeout(pending);
+          pendingTerminalTimers.delete(evt.sessionId);
+        }
+        setRuns((prev) => ({
+          ...prev,
+          [evt.sessionId]: {
+            runId: evt.runId,
+            status: evt.status,
+            updatedAt: evt.updatedAt
+          }
+        }));
+      }
+    });
+    subscription?.catch((err) => {
+      if (controller.signal.aborted) {
+        return;
+      }
+      const surface = err instanceof Event ? err : new Event("error");
+      onErrorRef.current?.(surface);
+    });
+    const readyTimeout = setTimeout(() => {
+      if (!sawSnapshotRow) {
+        setReady(true);
+      }
+    }, emptyStateTimeoutMs);
+    return () => {
+      controller.abort();
+      if (stagingTimer !== void 0) {
+        clearTimeout(stagingTimer);
+      }
+      clearTimeout(readyTimeout);
+      for (const handle of pendingTerminalTimers.values()) {
+        clearTimeout(handle);
+      }
+      pendingTerminalTimers.clear();
+    };
+  }, [dataSource, enabled, retainTerminalMs, emptyStateTimeoutMs]);
+  const status = React.useCallback(
+    (sessionId) => runs[sessionId]?.status,
+    [runs]
+  );
+  return { runs, ready, status };
+}
 
 // ui/src/bichat/index.ts
 init_useTranslation();
@@ -19134,6 +19273,8 @@ function toStreamEvent(chunk) {
       return chunk.sessionId ? { type: "user_message", sessionId: chunk.sessionId } : null;
     case "interrupt":
       return chunk.interrupt ? { type: "interrupt", interrupt: chunk.interrupt, sessionId: chunk.sessionId } : null;
+    case "text_block_end":
+      return { type: "text_block_end", seq: chunk.textBlockSeq ?? 0 };
     case "done":
       return { type: "done", sessionId: chunk.sessionId, generationMs: chunk.generationMs };
     case "error":
@@ -19143,6 +19284,90 @@ function toStreamEvent(chunk) {
   }
 }
 
+// ui/src/bichat/utils/eventNames.ts
+var STREAM_EVENT_TYPES = [
+  "chunk",
+  "content",
+  "thinking",
+  "tool_start",
+  "tool_end",
+  "text_block_end",
+  "snapshot",
+  "interrupt",
+  "citation",
+  "usage",
+  "ping",
+  "stream_started",
+  "done",
+  "cancelled",
+  "error",
+  "failed"
+];
+var TERMINAL_STREAM_EVENT_TYPES = [
+  "done",
+  "cancelled",
+  "error",
+  "failed"
+];
+function isTerminalEvent(name) {
+  return TERMINAL_STREAM_EVENT_TYPES.includes(name);
+}
+
+// ui/src/bichat/data/openManagedEventSource.ts
+function openManagedEventSource(opts) {
+  const graceMs = opts.connectGraceMs ?? 500;
+  return new Promise((resolve, reject) => {
+    const startedAt = Date.now();
+    const es = new EventSource(opts.url, {
+      withCredentials: opts.withCredentials ?? true
+    });
+    let settled = false;
+    let sawEvent = false;
+    const settle = (err) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      es.close();
+      if (err) {
+        reject(err);
+      } else {
+        resolve();
+      }
+    };
+    if (opts.signal) {
+      if (opts.signal.aborted) {
+        settle();
+        return;
+      }
+      opts.signal.addEventListener("abort", () => settle(), { once: true });
+    }
+    const forward = (name) => (evt) => {
+      sawEvent = true;
+      let parsed;
+      try {
+        parsed = JSON.parse(evt.data);
+      } catch {
+        parsed = { __unparseable: true, raw: String(evt.data) };
+      }
+      try {
+        opts.onMessage(name, parsed);
+      } catch {
+      }
+    };
+    for (const name of opts.events) {
+      es.addEventListener(name, forward(name));
+    }
+    es.onerror = (evt) => {
+      opts.onError?.(evt);
+      if (graceMs > 0 && !sawEvent && Date.now() - startedAt < graceMs) {
+        const err = opts.onConnectError ? opts.onConnectError(evt) : new Error("EventSource failed to connect before first event");
+        settle(err);
+      }
+    };
+  });
+}
+
 // ui/src/bichat/data/AttachmentUploader.ts
 init_chartSpec();
 var MIME_TO_EXTENSION = {
@@ -19397,6 +19622,26 @@ async function ensureAttachmentUpload(attachment, context, uploadFileFn) {
 }
 
 // ui/src/bichat/data/MessageTransport.ts
+var RunEventsConnectError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.name = "RunEventsConnectError";
+    this.cause = cause;
+  }
+};
+function generateRequestId() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  const bytes = new Uint8Array(16);
+  for (let i = 0; i < bytes.length; i++) {
+    bytes[i] = Math.floor(Math.random() * 256);
+  }
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
 async function* sendMessage(deps, sessionId, content, attachments = [], signal, options) {
   const abortController = new AbortController();
   let onExternalAbort;
@@ -19424,12 +19669,14 @@ async function* sendMessage(deps, sessionId, content, attachments = [], signal,
       sessionId,
       attachmentCount: streamAttachments.length
     });
+    const requestId = options?.requestId ?? generateRequestId();
     const payload = {
       sessionId,
       content,
       debugMode: options?.debugMode ?? false,
       replaceFromMessageId: options?.replaceFromMessageID,
-      attachments: streamAttachments
+      attachments: streamAttachments,
+      requestId
     };
     if (options?.reasoningEffort) {
       payload.reasoningEffort = options.reasoningEffort;
@@ -19470,10 +19717,14 @@ async function* sendMessage(deps, sessionId, content, attachments = [], signal,
   } catch (err) {
     if (err instanceof Error) {
       if (err.name === "AbortError") {
-        yield {
-          type: "error",
-          error: connectionTimedOut ? `Stream request timed out after ${deps.streamConnectTimeoutMs}ms` : "Stream cancelled"
-        };
+        if (connectionTimedOut) {
+          yield {
+            type: "error",
+            error: `Stream request timed out after ${deps.streamConnectTimeoutMs}ms`
+          };
+        } else {
+          throw err;
+        }
       } else {
         yield {
           type: "error",
@@ -19597,6 +19848,67 @@ async function resumeStream(deps, sessionId, runId, onChunk, signal) {
     }
   }
 }
+function subscribeRunEvents(deps, sessionId, runId, options) {
+  const base = buildStreamUrl(deps, "/events");
+  const qs = new URLSearchParams({ sessionId, runId });
+  const url = `${base}?${qs.toString()}`;
+  const withCursor = options.lastEventId ? `${url}&${new URLSearchParams({ lastEventId: options.lastEventId }).toString()}` : url;
+  const settleController = new AbortController();
+  if (options.signal) {
+    if (options.signal.aborted) {
+      settleController.abort();
+    } else {
+      options.signal.addEventListener("abort", () => settleController.abort(), {
+        once: true
+      });
+    }
+  }
+  return openManagedEventSource({
+    url: withCursor,
+    events: STREAM_EVENT_TYPES,
+    withCredentials: true,
+    signal: settleController.signal,
+    onError: options.onError,
+    onConnectError: (evt) => new RunEventsConnectError(
+      "EventSource failed to connect before first event",
+      evt
+    ),
+    onMessage: (name, data) => {
+      if (typeof data === "object" && data !== null && data.__unparseable) {
+        options.onChunk({
+          type: "error",
+          error: `Failed to parse event: ${data.raw}`
+        });
+        return;
+      }
+      const parsed = data;
+      if (!parsed.type) {
+        parsed.type = name;
+      }
+      options.onChunk(parsed);
+      if (isTerminalEvent(name) || isTerminalEvent(String(parsed.type))) {
+        settleController.abort();
+      }
+    }
+  });
+}
+function subscribeActiveRuns(deps, options) {
+  const url = buildStreamUrl(deps, "/active-runs");
+  return openManagedEventSource({
+    url,
+    events: ["snapshot", "update"],
+    withCredentials: true,
+    signal: options.signal,
+    onError: options.onError,
+    onMessage: (name, data) => {
+      if (typeof data !== "object" || data === null || data.__unparseable) {
+        return;
+      }
+      const body = data;
+      options.onEvent({ event: name, ...body });
+    }
+  });
+}
 async function submitQuestionAnswers(callRPC, sessionId, questionId, answers) {
   try {
     const flatAnswers = {};
@@ -19865,6 +20177,39 @@ var HttpDataSource = class {
       signal
     );
   }
+  /**
+   * Open a native EventSource against GET /stream/events for the given
+   * run. Used by components that want browser-native auto-reconnect
+   * with Last-Event-ID (tab close, wifi drop, device switch). Prefer
+   * over resumeStream when tailing an already-running generation that
+   * another tab started.
+   */
+  subscribeRunEvents(sessionId, runId, options) {
+    return subscribeRunEvents(
+      {
+        baseUrl: this.config.baseUrl,
+        streamEndpoint: this.config.streamEndpoint
+      },
+      sessionId,
+      runId,
+      options
+    );
+  }
+  /**
+   * Subscribe to the per-tenant active-run fan-out
+   * (GET /stream/active-runs). Never resolves until the caller aborts
+   * via the signal; use from a top-level component (sidebar container)
+   * that mounts for the lifetime of the chat app.
+   */
+  subscribeActiveRuns(options) {
+    return subscribeActiveRuns(
+      {
+        baseUrl: this.config.baseUrl,
+        streamEndpoint: this.config.streamEndpoint
+      },
+      options
+    );
+  }
   async *sendMessage(sessionId, content, attachments = [], signal, options) {
     this.abortController = new AbortController();
     let onExternalAbort;
@@ -19938,6 +20283,50 @@ function createHttpDataSource(config) {
   return new HttpDataSource(config);
 }
 
+// ui/src/bichat/utils/textBlocks.ts
+function splitIntoTextBlocks(content, offsets) {
+  if (!content) {
+    return [];
+  }
+  if (!offsets || offsets.length === 0) {
+    return [{ seq: 0, content }];
+  }
+  const sanitized = [...offsets].map((n) => Math.max(0, Math.min(Math.floor(n), content.length))).sort((a, b) => a - b);
+  const blocks = [];
+  let cursor = 0;
+  for (let i = 0; i < sanitized.length; i++) {
+    const end = sanitized[i];
+    if (end <= cursor) {
+      continue;
+    }
+    const slice = content.slice(cursor, end);
+    if (slice) {
+      blocks.push({ seq: blocks.length, content: slice });
+    }
+    cursor = end;
+  }
+  if (cursor < content.length) {
+    blocks.push({ seq: blocks.length, content: content.slice(cursor) });
+  }
+  return blocks;
+}
+function readTextBlockOffsets(partialMetadata) {
+  if (!partialMetadata) {
+    return [];
+  }
+  const raw = partialMetadata["text_block_offsets"];
+  if (!Array.isArray(raw)) {
+    return [];
+  }
+  const out = [];
+  for (const entry of raw) {
+    if (typeof entry === "number" && Number.isFinite(entry) && entry >= 0) {
+      out.push(Math.floor(entry));
+    }
+  }
+  return out;
+}
+
 exports.ATTACHMENT_ACCEPT_ATTRIBUTE = ATTACHMENT_ACCEPT_ATTRIBUTE;
 exports.ActionButton = ActionButton;
 exports.ActivityTrace = ActivityTrace;
@@ -19989,6 +20378,8 @@ exports.QuestionForm = QuestionForm;
 exports.QuestionStep = QuestionStep;
 exports.RateLimiter = RateLimiter;
 exports.RetryActionArea = RetryActionArea;
+exports.RunEventsConnectError = RunEventsConnectError;
+exports.STREAM_EVENT_TYPES = STREAM_EVENT_TYPES;
 exports.ScreenReaderAnnouncer = ScreenReaderAnnouncer;
 exports.ScrollToBottomButton = ScrollToBottomButton;
 exports.SearchInput = MemoizedSearchInput;
@@ -20010,6 +20401,7 @@ exports.SourcesPanel = SourcesPanel;
 exports.StreamError = StreamError;
 exports.StreamingCursor = StreamingCursor;
 exports.SystemMessage = SystemMessage;
+exports.TERMINAL_STREAM_EVENT_TYPES = TERMINAL_STREAM_EVENT_TYPES;
 exports.TabbedChartGroup = TabbedChartGroup;
 exports.TabbedTableGroup = TabbedTableGroup;
 exports.ThemeProvider = ThemeProvider;
@@ -20047,6 +20439,7 @@ exports.groupSteps = groupSteps;
 exports.hasPermission = hasPermission;
 exports.isImageMimeType = isImageMimeType;
 exports.isPermissionDeniedError = isPermissionDeniedError;
+exports.isTerminalEvent = isTerminalEvent;
 exports.lightTheme = lightTheme;
 exports.listItemVariants = listItemVariants;
 exports.messageContainerVariants = messageContainerVariants;
@@ -20054,12 +20447,15 @@ exports.messageVariants = messageVariants;
 exports.parseBichatStream = parseBichatStream;
 exports.parseBichatStreamEvents = parseBichatStreamEvents;
 exports.parseSSEStream = parseSSEStream;
+exports.readTextBlockOffsets = readTextBlockOffsets;
 exports.scaleFadeVariants = scaleFadeVariants;
 exports.sessionItemVariants = sessionItemVariants;
+exports.splitIntoTextBlocks = splitIntoTextBlocks;
 exports.staggerContainerVariants = staggerContainerVariants;
 exports.toErrorDisplay = toErrorDisplay;
 exports.typingDotVariants = typingDotVariants;
 exports.useActionButtonContext = useActionButtonContext;
+exports.useActiveRuns = useActiveRuns;
 exports.useAttachments = useAttachments;
 exports.useAutoScroll = useAutoScroll;
 exports.useAvatarContext = useAvatarContext;