nolo-cli 0.97.6 → 0.97.8

package/{chunk-BS7YHAQP.js → chunk-UWVGKNAL.js}

@@ -14,10 +14,10 @@ import {
 } from "./chunk-AGGIDPCZ.js";
 import {
   runLlm
-} from "./chunk-2LM7XUCX.js";
+} from "./chunk-SPCBJGFO.js";
 import {
   cleanupCliSessionForDialog
-} from "./chunk-ELIMCKNX.js";
+} from "./chunk-PCF3QU5Q.js";
 import {
   getActiveDialogAgentId,
   getDialogAgentIds,
@@ -48,7 +48,7 @@ import {
 } from "./chunk-YDH3FDFQ.js";
 import {
   fetchMessages
-} from "./chunk-V4UYSDTH.js";
+} from "./chunk-ADBZWMFB.js";
 import {
   nolotusId
 } from "./chunk-A4SQRTZ6.js";
@@ -64,7 +64,7 @@ import {
   getModelInfo,
   normalizeUsage,
   resolveAutoExecutionProfile
-} from "./chunk-JNXHAQPJ.js";
+} from "./chunk-LDCAFLXD.js";
 import {
   COMPACTION_SUMMARY_SYSTEM_PROMPT,
   buildCompactionMetricsFromPlan,
@@ -75,7 +75,7 @@ import {
   normalizeAssistantContentBuffer,
   planCompression,
   serializeMessageContent
-} from "./chunk-WS2VEVHS.js";
+} from "./chunk-7MMSLEPA.js";
 import {
   asRecordOrEmpty
 } from "./chunk-KX6YBIHG.js";
@@ -85,7 +85,7 @@ import {
   remove,
   selectById,
   write
-} from "./chunk-NVRC52JS.js";
+} from "./chunk-4FFUDT6D.js";
 import {
   findModelConfig,
   getModelConfig
@@ -111,9 +111,11 @@ import {
   scheduleDeleteReplication
 } from "./chunk-UJXNKP5V.js";
 import {
+  getRecordTimestamp,
+  getTombstoneTimestamp,
   isTombstoneRecord,
   shouldReplaceWithNextRecord
-} from "./chunk-GBRG75BQ.js";
+} from "./chunk-D2MDMY2M.js";
 import {
   builtinAgentCatalogEntryById,
   builtinRuntimeFallbackEntries,
@@ -335,7 +337,31 @@ function resolveInitMsgsHasMoreOlder(input) {
 var isValidMessage = (msg) => !!msg && typeof msg === "object" && typeof msg.id === "string";
 
 // packages/chat/messages/fetchConvMsgs.ts
-var FETCH_TIMEOUT = 5e3;
+var FETCH_BUDGETS = {
+  connectMs: 15e3,
+  stallMs: 1e4,
+  totalMs: 12e4
+};
+var now = () => typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+var readJsonBody = async (response, onChunk) => {
+  const body = response.body;
+  if (!body) {
+    return await response.json();
+  }
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let text = "";
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    if (value && value.byteLength > 0) {
+      text += decoder.decode(value, { stream: true });
+      onChunk(value.byteLength);
+    }
+  }
+  text += decoder.decode();
+  return JSON.parse(text);
+};
 var fetchConvMsgs = async (server, token, {
   dialogId,
   dialogKey,
@@ -344,9 +370,45 @@ var fetchConvMsgs = async (server, token, {
 }, options = {}) => {
   const { signal: externalSignal } = options;
   const controller = new AbortController();
-  const timeoutId = setTimeout(() => controller.abort(), FETCH_TIMEOUT);
+  const startedAt = now();
+  let phase = "connect";
+  let receivedBytes = 0;
+  let receivedChunks = 0;
+  let watchdogCause = null;
+  let connectTimer;
+  let stallTimer;
+  const clearConnectTimer = () => {
+    if (connectTimer !== void 0) {
+      clearTimeout(connectTimer);
+      connectTimer = void 0;
+    }
+  };
+  const clearStallTimer = () => {
+    if (stallTimer !== void 0) {
+      clearTimeout(stallTimer);
+      stallTimer = void 0;
+    }
+  };
+  const armStallTimer = () => {
+    clearStallTimer();
+    stallTimer = setTimeout(() => {
+      watchdogCause = "stall-timeout";
+      controller.abort();
+    }, FETCH_BUDGETS.stallMs);
+  };
+  const totalTimer = setTimeout(() => {
+    watchdogCause = "total-timeout";
+    controller.abort();
+  }, FETCH_BUDGETS.totalMs);
+  connectTimer = setTimeout(() => {
+    watchdogCause = "connect-timeout";
+    controller.abort();
+  }, FETCH_BUDGETS.connectMs);
   const onExternalAbort = () => controller.abort();
   externalSignal?.addEventListener("abort", onExternalAbort);
+  if (externalSignal?.aborted) {
+    controller.abort();
+  }
   try {
     const response = await fetch(`${server}/rpc/getConvMsgs`, {
       method: "POST",
@@ -362,22 +424,36 @@ var fetchConvMsgs = async (server, token, {
       }),
       signal: controller.signal
     });
-    clearTimeout(timeoutId);
-    externalSignal?.removeEventListener("abort", onExternalAbort);
+    phase = "body";
+    clearConnectTimer();
+    armStallTimer();
     if (!response.ok) {
       console.error(`fetchConvMsgs: Failed ${response.status} from ${server}`);
       return [];
     }
-    const data = await response.json();
+    const data = await readJsonBody(response, (byteLength) => {
+      receivedBytes += byteLength;
+      receivedChunks += 1;
+      armStallTimer();
+    });
     return Array.isArray(data) ? data : [];
   } catch (error) {
-    clearTimeout(timeoutId);
-    externalSignal?.removeEventListener("abort", onExternalAbort);
     if (externalSignal?.aborted) {
       throw error;
     }
+    if (watchdogCause !== null) {
+      console.error(
+        `fetchConvMsgs: Error fetching from ${server}: ${watchdogCause} elapsedMs=${Math.round(now() - startedAt)} phase=${phase} receivedBytes=${receivedBytes} chunks=${receivedChunks} \u2014 internal watchdog abort, returning [] (NOT evidence of an empty history)`
+      );
+      return [];
+    }
     console.error(`fetchConvMsgs: Error fetching from ${server}:`, error);
     return [];
+  } finally {
+    clearConnectTimer();
+    clearStallTimer();
+    clearTimeout(totalTimer);
+    externalSignal?.removeEventListener("abort", onExternalAbort);
   }
 };
 
@@ -393,6 +469,25 @@ function swallowNonAbortError(promise, fallback, signal) {
 }
 
 // packages/chat/messages/fetchAndCacheMessages.ts
+var sortByCreatedAtDesc = (a3, b2) => {
+  const aCreated = a3 && typeof a3 === "object" && "createdAt" in a3 ? a3.createdAt : void 0;
+  const bCreated = b2 && typeof b2 === "object" && "createdAt" in b2 ? b2.createdAt : void 0;
+  const tA = new Date(aCreated || 0).getTime();
+  const tB = new Date(bCreated || 0).getTime();
+  return tB - tA;
+};
+var mergeVisibleRecords = (seed, incoming) => {
+  const byId = /* @__PURE__ */ new Map();
+  const put = (m3) => {
+    if (!m3 || !m3.id) return;
+    const existing = byId.get(m3.id);
+    if (existing && !shouldReplaceWithNextRecord(m3, existing)) return;
+    byId.set(m3.id, m3);
+  };
+  seed.forEach(put);
+  incoming.forEach(put);
+  return Array.from(byId.values()).filter((message) => !isTombstoneRecord(message)).sort(sortByCreatedAtDesc);
+};
 var fetchAndCacheMessagesLocalFirst = async ({
   db,
   dialogId,
@@ -411,24 +506,21 @@ var fetchAndCacheMessagesLocalFirst = async ({
     throwOnError: false,
     includeDeleted: true
   }).catch(() => []);
-  const remotePromise = (async () => {
-    if (!token || remoteServers.length === 0) return [];
-    const results = await Promise.all(
-      remoteServers.map(
-        (server) => swallowNonAbortError(
-          fetchConvMsgs(
-            server,
-            token,
-            { dialogId, dialogKey, limit, beforeKey },
-            { signal }
-          ),
-          [],
-          void 0
-        )
-      )
-    );
-    return results.flat();
-  })();
+  const serverPromises = token && remoteServers.length > 0 ? remoteServers.map(
+    (server) => swallowNonAbortError(
+      fetchConvMsgs(
+        server,
+        token,
+        { dialogId, dialogKey, limit, beforeKey },
+        { signal }
+      ),
+      [],
+      void 0
+    )
+  ) : [];
+  const remotePromise = Promise.all(serverPromises).then(
+    (results) => results.flat()
+  );
   let localSettledAt = null;
   const localTimingPromise = localPromise.then((value) => {
     localSettledAt = typeof performance !== "undefined" ? performance.now() : Date.now();
@@ -437,6 +529,30 @@ var fetchAndCacheMessagesLocalFirst = async ({
   const localMsgs = await localTimingPromise;
   const localMs = localSettledAt !== null ? Math.round(localSettledAt - startedAt) : null;
   const earlyReturned = localMsgs.length > 0;
+  const partialPromise = (async () => {
+    if (!token || remoteServers.length < 2) return [];
+    const primaryServerPromise = serverPromises[0];
+    if (!primaryServerPromise) return [];
+    try {
+      const [seedLocal, primaryMsgs] = await Promise.all([
+        localTimingPromise,
+        primaryServerPromise
+      ]);
+      if (signal?.aborted) return [];
+      if (!primaryMsgs || primaryMsgs.length === 0) return [];
+      const freshLocal = await fetchMessages(db, dialogId, {
+        limit,
+        beforeKey,
+        throwOnError: false,
+        includeDeleted: true
+      }).catch(() => []);
+      if (signal?.aborted) return [];
+      return mergeVisibleRecords(freshLocal, primaryMsgs);
+    } catch {
+      return [];
+    }
+  })();
+  const finalTombstonesById = /* @__PURE__ */ new Map();
   const remotePromiseWithMerge = (async () => {
     let remoteSettledAt = null;
     const remoteMsgs = await remotePromise.then((value) => {
@@ -461,6 +577,9 @@ var fetchAndCacheMessagesLocalFirst = async ({
     localMsgs.forEach((m3) => put(m3));
     freshLocalMsgs.forEach((m3) => put(m3));
     remoteMsgs.forEach((m3) => put(m3, true));
+    for (const [recordId, record] of uniqueMap) {
+      if (isTombstoneRecord(record)) finalTombstonesById.set(recordId, record);
+    }
     if (changedMessagesToCache.size > 0) {
       try {
         const ops = Array.from(changedMessagesToCache.values()).map((msg) => {
@@ -495,25 +614,23 @@ var fetchAndCacheMessagesLocalFirst = async ({
       hasToken: !!token,
       earlyReturned
     });
-    return Array.from(uniqueMap.values()).filter((message) => !isTombstoneRecord(message)).sort((a3, b2) => {
-      const aCreated = a3 && typeof a3 === "object" && "createdAt" in a3 ? a3.createdAt : void 0;
-      const bCreated = b2 && typeof b2 === "object" && "createdAt" in b2 ? b2.createdAt : void 0;
-      const tA = new Date(aCreated || 0).getTime();
-      const tB = new Date(bCreated || 0).getTime();
-      return tB - tA;
-    });
+    return Array.from(uniqueMap.values()).filter((message) => !isTombstoneRecord(message)).sort(sortByCreatedAtDesc);
   })();
   if (!earlyReturned) {
     const mergedMessages = await remotePromiseWithMerge;
     return {
       localMessages: mergedMessages,
       remotePromise: Promise.resolve(mergedMessages),
+      partialPromise,
+      finalTombstonesById,
       earlyReturned: false
     };
   }
   return {
     localMessages: localMsgs,
     remotePromise: remotePromiseWithMerge,
+    partialPromise,
+    finalTombstonesById,
     earlyReturned: true
   };
 };
@@ -9834,9 +9951,21 @@ var messageSlice = createSliceWithThunks({
       }, thunkApi) => {
         const { db } = thunkApi.extra;
         const { getState, signal, dispatch } = thunkApi;
+        const myInitRequestId = thunkApi.requestId;
+        if (getMessageSession(dialogId).currentInitMsgsRequestId !== myInitRequestId) {
+          patchMessageSession(dialogId, {
+            currentInitMsgsRequestId: myInitRequestId
+          });
+        }
         const state = getState();
         const { currentToken: token, remoteServers } = getRuntimeServerContext(state);
-        const { localMessages, remotePromise, earlyReturned } = await fetchAndCacheMessagesLocalFirst({
+        const {
+          localMessages,
+          remotePromise,
+          partialPromise,
+          finalTombstonesById,
+          earlyReturned
+        } = await fetchAndCacheMessagesLocalFirst({
           db,
           dialogId,
           dialogKey,
@@ -9854,11 +9983,72 @@ var messageSlice = createSliceWithThunks({
               isLoadingInitial: false
             })
           );
+          const publishedIds = new Set(
+            validLocalMessages.map((message) => message.id)
+          );
+          const backgroundAllowed = () => {
+            if (signal?.aborted) return false;
+            return getMessageSession(dialogId).currentInitMsgsRequestId === myInitRequestId;
+          };
+          let reconcileApplied = false;
+          const currentEntities = () => {
+            const rootState = getState();
+            const sliceState = rootState?.message ?? rootState;
+            try {
+              return getMessageDialogState(sliceState, dialogId)?.msgs?.entities ?? {};
+            } catch {
+              return {};
+            }
+          };
+          if (partialPromise) {
+            partialPromise.then((partialMessages) => {
+              if (reconcileApplied || !backgroundAllowed()) return;
+              const validPartial = partialMessages.filter(isValidMessage);
+              if (validPartial.length === 0) return;
+              const entities = currentEntities();
+              const additions = validPartial.filter(
+                (message) => !entities[message.id]
+              );
+              if (additions.length === 0) return;
+              additions.forEach((message) => publishedIds.add(message.id));
+              dispatch(
+                messageActions.setMessages({
+                  dialogId,
+                  messages: additions
+                })
+              );
+            }).catch((err) => {
+              console.error("[initMsgs] early source view failed:", err);
+            });
+          }
           remotePromise.then((finalMessages2) => {
+            if (!backgroundAllowed()) return;
+            reconcileApplied = true;
+            const validFinalMessages = finalMessages2.filter(isValidMessage);
+            const finalIds = new Set(
+              validFinalMessages.map((message) => message.id)
+            );
+            const entities = currentEntities();
+            const removedIds = [...publishedIds].filter((id) => {
+              if (finalIds.has(id)) return false;
+              const tombstone = finalTombstonesById?.get?.(id);
+              if (!tombstone) return false;
+              const current = entities[id];
+              if (!current) return false;
+              return shouldReplaceWithNextRecord(tombstone, current) && getTombstoneTimestamp(tombstone) >= getRecordTimestamp(current);
+            });
+            if (removedIds.length > 0) {
+              dispatch(
+                messageActions.removeMessagesByIds({
+                  dialogId,
+                  ids: removedIds
+                })
+              );
+            }
             dispatch(
               messageActions.setMessages({
                 dialogId,
-                messages: finalMessages2.filter(isValidMessage)
+                messages: validFinalMessages
               })
             );
           }).catch((err) => {
@@ -9900,7 +10090,6 @@ var messageSlice = createSliceWithThunks({
           }
           const limit = action2.meta.arg.limit;
           patchMessageSession(dialogId, {
-            currentInitMsgsRequestId: void 0,
             isLoadingInitial: false,
             hasMoreOlder: resolveInitMsgsHasMoreOlder({
               limit,
@@ -9931,13 +10120,11 @@ var messageSlice = createSliceWithThunks({
           }
           if (action2.meta?.aborted) {
             patchMessageSession(dialogId, {
-              currentInitMsgsRequestId: void 0,
               isLoadingInitial: false
             });
             return;
           }
           patchMessageSession(dialogId, {
-            currentInitMsgsRequestId: void 0,
             isLoadingInitial: false,
             error: action2.error instanceof Error ? action2.error : new Error(String(action2.error))
           });
@@ -10332,7 +10519,7 @@ var messageSlice = createSliceWithThunks({
             runtimeOptions: args.runtimeOptions
           });
           if (agentKeyToUse) {
-            const { streamAgentChatTurn } = await import("./agentSlice-V2EDVUXC.js");
+            const { streamAgentChatTurn } = await import("./agentSlice-6ON6SBOW.js");
             await dispatch(
               streamAgentChatTurn({
                 agentKey: agentKeyToUse,
@@ -13015,7 +13202,7 @@ var deleteOwnedDialogAttachments = async (args) => {
     metadataReadFailures
   });
   if (!plan.deleteCandidates.length) return plan;
-  const { deleteFileAction } = await import("./deleteFile-HG4BF3CS.js");
+  const { deleteFileAction } = await import("./deleteFile-AJ2EZMHT.js");
   for (const candidate of plan.deleteCandidates) {
     if (candidate.fileDbKey) {
       await deleteFileAction(candidate.fileDbKey, args.thunkApi);
@@ -13077,7 +13264,7 @@ var deleteDialogThunk = async (payload, thunkApi) => {
   }
   if (isCurrentDialog) {
     await thunkApi.dispatch(resetMsgs());
-    const { clearPendingAttachments: clearPendingAttachments2 } = await import("./dialogSlice-M7ZWTW5D.js");
+    const { clearPendingAttachments: clearPendingAttachments2 } = await import("./dialogSlice-34DUPW5Z.js");
     dispatch(clearPendingAttachments2());
   }
   return { dialogKey, isCurrentDialog, attachmentPlan };
@@ -13085,39 +13272,39 @@ var deleteDialogThunk = async (payload, thunkApi) => {
 
 // packages/chat/dialog/dialogSlice.ts
 var runCreateDialogAction = async (args, thunkApi) => {
-  const { createDialogAction } = await import("./createDialogAction-L3WMTD5Z.js");
+  const { createDialogAction } = await import("./createDialogAction-YWNYTXXK.js");
   return createDialogAction(args, thunkApi);
 };
 var runCreateAgentAutomationAction = async (args, thunkApi) => {
-  const { createAgentAutomationAction } = await import("./createAgentAutomationAction-OW4WEVHP.js");
+  const { createAgentAutomationAction } = await import("./createAgentAutomationAction-W42UXDBD.js");
   return createAgentAutomationAction(args, thunkApi);
 };
 var runUpdateDialogTitleAction = async (args, thunkApi) => {
-  const { updateDialogTitleAction } = await import("./updateDialogTitleAction-GBUSLAQR.js");
+  const { updateDialogTitleAction } = await import("./updateDialogTitleAction-Z7OREKH3.js");
   return updateDialogTitleAction(args, thunkApi);
 };
 var runAddDialogAgentAction = async (args, thunkApi) => {
-  const { addDialogAgentAction } = await import("./addDialogAgentAction-6SGG37BF.js");
+  const { addDialogAgentAction } = await import("./addDialogAgentAction-IODCR6TB.js");
   return addDialogAgentAction(args, thunkApi);
 };
 var runRemoveDialogAgentAction = async (args, thunkApi) => {
-  const { removeDialogAgentAction } = await import("./removeDialogAgentAction-CT5HGRZH.js");
+  const { removeDialogAgentAction } = await import("./removeDialogAgentAction-46XQV5Q7.js");
   return removeDialogAgentAction(args, thunkApi);
 };
 var runSetPrimaryDialogAgentAction = async (args, thunkApi) => {
-  const { setPrimaryDialogAgentAction } = await import("./setPrimaryDialogAgentAction-MHWOGXP3.js");
+  const { setPrimaryDialogAgentAction } = await import("./setPrimaryDialogAgentAction-UHHV2QZW.js");
   return setPrimaryDialogAgentAction(args, thunkApi);
 };
 var runSwitchDialogAgentAction = async (args, thunkApi) => {
-  const { switchDialogAgentAction } = await import("./switchDialogAgentAction-JHA4JEYA.js");
+  const { switchDialogAgentAction } = await import("./switchDialogAgentAction-A2TMVGAE.js");
   return switchDialogAgentAction(args, thunkApi);
 };
 var runSetDialogExtraReferencesAction = async (args, thunkApi) => {
-  const { setDialogExtraReferencesAction } = await import("./setDialogExtraReferencesAction-JOENKFTX.js");
+  const { setDialogExtraReferencesAction } = await import("./setDialogExtraReferencesAction-J4V5ADQF.js");
   return setDialogExtraReferencesAction(args, thunkApi);
 };
 var runHandleSendMessageAction = async (args, thunkApi) => {
-  const { handleSendMessageAction } = await import("./handleSendMessageAction-KMPC6UD4.js");
+  const { handleSendMessageAction } = await import("./handleSendMessageAction-5XCHOMQH.js");
   return handleSendMessageAction(args, thunkApi);
 };
 function clearDialogState() {
@@ -13130,7 +13317,7 @@ var createPageAndAddReference = createAsyncThunk(
   async (payload, { dispatch, getState, rejectWithValue }) => {
     const { slateData, jsonData, title, type, fileId, groupId, dialogKey } = payload;
     try {
-      const { createDocState } = await import("./docStore-IX7ASJUP.js");
+      const { createDocState } = await import("./docStore-FAQ6XUUA.js");
       const pageKey = await createDocState(
         { slateData, title },
         { dispatch, getState }

package/{chunk-CV366NXM.js → chunk-V5OWQOJZ.js}

@@ -28,11 +28,11 @@ import {
   stablePromptCacheKey,
   toOpenAiCompatibleMessages,
   toResponsesTools
-} from "./chunk-PUOC4YRO.js";
+} from "./chunk-M7VLQGQP.js";
 import {
   isMeaningfulChatCompletionOutput,
   isMeaningfulResponsesOutput
-} from "./chunk-WS2VEVHS.js";
+} from "./chunk-7MMSLEPA.js";
 import {
   clipCompactText
 } from "./chunk-5MMAK75Q.js";
@@ -463,6 +463,12 @@ async function resolvePlatformChatProviderConfig(args) {
   };
 }
 function buildPlatformChatCompletionRequest(args) {
+  if (!args.providerConfig.authToken?.trim()) {
+    throw Object.assign(
+      new Error("desktop platform provider failed: AUTH_NO_TOKEN"),
+      { code: "AUTH_NO_TOKEN", authCode: "AUTH_NO_TOKEN", stage: "provider" }
+    );
+  }
   const usesResponsesApi = isResponsesEndpoint(args.providerConfig.endpoint);
   const requestOptions = usesResponsesApi ? toResponsesRequestOptions(args.providerConfig.requestOptions) : args.providerConfig.requestOptions;
   const shouldStripReasoning = shouldStripReasoningContentForOutbound(

package/{chunk-3PELUSVV.js → chunk-WZLHDC7H.js}

@@ -1,9 +1,9 @@
 import {
   clearCliLocalRuntimePreparedAgentCache
-} from "./chunk-QNTL2KFU.js";
+} from "./chunk-XEALKKFF.js";
 import {
   getReadableCliDb
-} from "./chunk-EMQZSES6.js";
+} from "./chunk-LOCNXNOU.js";
 import {
   buildCreatedAgentRecord,
   buildUpdatedAgentRecord,

package/{chunk-LYKHXIQC.js → chunk-X5YVT5HS.js}

@@ -1,9 +1,9 @@
 import {
   toolRegistry
-} from "./chunk-ZGNDLCYH.js";
+} from "./chunk-TQE6BVFT.js";
 import {
   runtime_default
-} from "./chunk-BS7YHAQP.js";
+} from "./chunk-UWVGKNAL.js";
 import {
   canonicalizeToolNames
 } from "./chunk-XUWRURDF.js";