happy-imou-cloud 2.1.1 → 2.1.2

package/dist/{runGemini-CcWGezMt.cjs → runGemini-6Dwyk_Km.cjs}

@@ -3,10 +3,10 @@
 var ink = require('ink');
 var React = require('react');
 var node_crypto = require('node:crypto');
-var api = require('./api-DId_j3C2.cjs');
-var registerKillSessionHandler = require('./registerKillSessionHandler-Dg_iRBPm.cjs');
-var index = require('./index-CuuYSKiv.cjs');
-var BaseReasoningProcessor = require('./BaseReasoningProcessor-CBMK-8Gi.cjs');
+var api = require('./api-DZimmN4C.cjs');
+var registerKillSessionHandler = require('./registerKillSessionHandler-BapPCRmp.cjs');
+var index = require('./index-Cuvs0lFS.cjs');
+var BaseReasoningProcessor = require('./BaseReasoningProcessor-CzvqwxuY.cjs');
 require('cross-spawn');
 require('@agentclientprotocol/sdk');
 require('ps-list');
@@ -17,7 +17,7 @@ require('node:child_process');
 require('node:readline');
 require('tweetnacl');
 require('axios');
-require('./persistence-Dzr6sFwD.cjs');
+require('./persistence-C8-MtdQK.cjs');
 require('open');
 require('chalk');
 require('fs');
@@ -432,6 +432,116 @@ class ConversationHistory extends registerKillSessionHandler.ConversationHistory
   }
 }
 
+const GEMINI_PERMISSION_MODES = [
+  "default",
+  "read-only",
+  "safe-yolo",
+  "yolo"
+];
+function isGeminiPermissionMode(value) {
+  return typeof value === "string" && GEMINI_PERMISSION_MODES.includes(value);
+}
+function hasMetaOverride(message, key) {
+  return Object.prototype.hasOwnProperty.call(message.meta ?? {}, key);
+}
+function resolveGeminiQueuedMessage(message, currentState) {
+  const previousState = { ...currentState };
+  const currentPermissionMode = isGeminiPermissionMode(currentState.permissionMode) ? currentState.permissionMode : void 0;
+  let permissionMode = currentPermissionMode;
+  let invalidPermissionMode = null;
+  if (hasMetaOverride(message, "permissionMode")) {
+    if (isGeminiPermissionMode(message.meta?.permissionMode)) {
+      permissionMode = message.meta.permissionMode;
+    } else if (message.meta?.permissionMode) {
+      invalidPermissionMode = String(message.meta.permissionMode);
+    }
+  }
+  const hasModelOverride = hasMetaOverride(message, "model");
+  const model = hasModelOverride ? message.meta?.model || void 0 : currentState.model;
+  const originalUserMessage = message.content.text;
+  let queuedText = originalUserMessage;
+  const isFirstMessage = currentState.isFirstMessage ?? true;
+  let nextIsFirstMessage = isFirstMessage;
+  if (isFirstMessage && message.meta?.appendSystemPrompt) {
+    queuedText = `${message.meta.appendSystemPrompt}
+
+${originalUserMessage}`;
+    nextIsFirstMessage = false;
+  }
+  const nextState = {
+    permissionMode: permissionMode ?? "default",
+    model,
+    isFirstMessage: nextIsFirstMessage
+  };
+  return {
+    previousState,
+    nextState,
+    invalidPermissionMode,
+    hasModelOverride,
+    queuedMessage: {
+      text: queuedText,
+      mode: {
+        permissionMode: nextState.permissionMode ?? "default",
+        model,
+        originalUserMessage
+      }
+    }
+  };
+}
+function bindGeminiUserMessageQueue(opts) {
+  let currentState = { ...opts.initialState };
+  opts.session.onUserMessage((message) => {
+    const happyOrgResult = opts.happyOrg ? registerKillSessionHandler.resolveHappyOrgQueuedTurn({
+      metadata: opts.happyOrg.getMetadata(),
+      message
+    }) : {
+      nextMetadata: null,
+      queuedTurn: null,
+      blocked: false,
+      statusMessage: void 0
+    };
+    if (opts.happyOrg && happyOrgResult.nextMetadata) {
+      opts.happyOrg.updateMetadata(() => happyOrgResult.nextMetadata);
+    }
+    if (happyOrgResult.blocked) {
+      if (happyOrgResult.statusMessage) {
+        opts.happyOrg?.emitStatusMessage(happyOrgResult.statusMessage);
+      }
+      api.logger.debugLargeJson("[gemini] User message blocked by Happy Org runtime:", message);
+      return;
+    }
+    const resolution = resolveGeminiQueuedMessage(message, currentState);
+    currentState = resolution.nextState;
+    resolution.queuedMessage.mode.happyOrg = happyOrgResult.queuedTurn;
+    opts.onResolvedMessage?.(resolution);
+    opts.messageQueue.push(resolution.queuedMessage.text, resolution.queuedMessage.mode);
+    api.logger.debugLargeJson("[gemini] User message queued:", message);
+  });
+}
+
+function normalizeGeminiBackendError(error) {
+  if (typeof error === "string") {
+    return error.trim() || "Gemini runtime exited unexpectedly";
+  }
+  if (error instanceof Error) {
+    return error.message.trim() || "Gemini runtime exited unexpectedly";
+  }
+  if (typeof error === "object" && error !== null) {
+    const record = error;
+    const fields = [record.message, record.details, record.detail, record.stderr].map((value) => typeof value === "string" ? value.trim() : "").filter(Boolean);
+    if (fields.length > 0) {
+      return fields.join("\n");
+    }
+    try {
+      const serialized = JSON.stringify(record);
+      if (serialized && serialized !== "{}") {
+        return serialized;
+      }
+    } catch {
+    }
+  }
+  return "Gemini runtime exited unexpectedly";
+}
 async function runGemini(opts) {
   const sessionTag = node_crypto.randomUUID();
   api.connectionState.setBackend("Gemini");
@@ -513,67 +623,21 @@ async function runGemini(opts) {
   await registerKillSessionHandler.syncControlledByUserState(session, false);
   const messageQueue = new registerKillSessionHandler.MessageQueue2((mode) => registerKillSessionHandler.hashObject({
     permissionMode: mode.permissionMode,
-    model: mode.model
+    model: mode.model,
+    happyOrg: mode.happyOrg ? {
+      taskId: mode.happyOrg.context.taskId,
+      organizationId: mode.happyOrg.context.organizationId,
+      memberAgentId: mode.happyOrg.context.memberAgentId,
+      supervisorAgentId: mode.happyOrg.context.supervisorAgentId,
+      reopenContext: mode.happyOrg.reopenContext ?? null
+    } : null
   }));
   const conversationHistory = new ConversationHistory({ maxMessages: 20, maxCharacters: 5e4 });
-  let currentPermissionMode = void 0;
-  let currentModel = void 0;
-  session.onUserMessage((message) => {
-    let messagePermissionMode = currentPermissionMode;
-    if (message.meta?.permissionMode) {
-      const validModes = ["default", "read-only", "safe-yolo", "yolo"];
-      if (validModes.includes(message.meta.permissionMode)) {
-        messagePermissionMode = message.meta.permissionMode;
-        currentPermissionMode = messagePermissionMode;
-        updatePermissionMode(messagePermissionMode);
-        api.logger.debug(`[Gemini] Permission mode updated from user message to: ${currentPermissionMode}`);
-      } else {
-        api.logger.debug(`[Gemini] Invalid permission mode received: ${message.meta.permissionMode}`);
-      }
-    } else {
-      api.logger.debug(`[Gemini] User message received with no permission mode override, using current: ${currentPermissionMode ?? "default (effective)"}`);
-    }
-    if (currentPermissionMode === void 0) {
-      currentPermissionMode = "default";
-      updatePermissionMode("default");
-    }
-    let messageModel = currentModel;
-    if (message.meta?.hasOwnProperty("model")) {
-      if (message.meta.model === null) {
-        messageModel = void 0;
-        currentModel = void 0;
-      } else if (message.meta.model) {
-        const previousModel = currentModel;
-        messageModel = message.meta.model;
-        currentModel = messageModel;
-        if (previousModel !== messageModel) {
-          updateDisplayedModel(messageModel, true);
-          messageBuffer.addMessage(`Model changed to: ${messageModel}`, "system");
-          api.logger.debug(`[Gemini] Model changed from ${previousModel} to ${messageModel}`);
-        }
-      }
-    }
-    const originalUserMessage = message.content.text;
-    let fullPrompt = originalUserMessage;
-    if (isFirstMessage && message.meta?.appendSystemPrompt) {
-      fullPrompt = message.meta.appendSystemPrompt + "\n\n" + originalUserMessage;
-      isFirstMessage = false;
-    }
-    const mode = {
-      permissionMode: messagePermissionMode || "default",
-      model: messageModel,
-      originalUserMessage
-      // Store original message separately
-    };
-    messageQueue.push(fullPrompt, mode);
-    conversationHistory.addUserMessage(originalUserMessage);
-  });
   let thinking = false;
   session.keepAlive(thinking, "remote");
   const keepAliveInterval = setInterval(() => {
     session.keepAlive(thinking, "remote");
   }, 2e3);
-  let isFirstMessage = true;
   const sendReady = () => {
     session.sendSessionEvent({ type: "ready" });
     try {
@@ -606,12 +670,22 @@ async function runGemini(opts) {
   let shouldExit = false;
   let runtimeHandle = null;
   let unsubscribeRuntimeMessages = null;
+  let handleQueuedUserMessage = null;
+  let emitGeminiStatusMessage = null;
+  let turnAbortedSent = false;
+  let turnInFlight = false;
+  let shouldInjectHistoryOnNextSession = false;
+  let currentModeHash = null;
+  let unexpectedRuntimeStopRecovery = null;
   async function handleAbort() {
     api.logger.debug("[Gemini] Abort requested - stopping current task");
-    session.sendAgentMessage("gemini", {
-      type: "turn_aborted",
-      id: node_crypto.randomUUID()
-    });
+    if (!turnAbortedSent) {
+      session.sendAgentMessage("gemini", {
+        type: "turn_aborted",
+        id: node_crypto.randomUUID()
+      });
+      turnAbortedSent = true;
+    }
     reasoningProcessor.abort();
     diffProcessor.reset();
     try {
@@ -672,6 +746,10 @@ async function runGemini(opts) {
       api.logger.debug(`[gemini] Model unchanged, skipping update message`);
     }
   };
+  emitGeminiStatusMessage = (message) => {
+    messageBuffer.addMessage(message, "status");
+    session.sendSessionEvent({ type: "message", message });
+  };
   if (hasTTY) {
     console.clear();
     const DisplayComponent = () => {
@@ -712,10 +790,56 @@ async function runGemini(opts) {
   const updatePermissionMode = (mode) => {
     permissionHandler.setPermissionMode(mode);
   };
+  handleQueuedUserMessage = ({ previousState, nextState, invalidPermissionMode, hasModelOverride }) => {
+    if (invalidPermissionMode) {
+      api.logger.debug(`[Gemini] Invalid permission mode received: ${invalidPermissionMode}`);
+    } else if (nextState.permissionMode) {
+      api.logger.debug(`[Gemini] Permission mode resolved to: ${nextState.permissionMode}`);
+    }
+    updatePermissionMode(nextState.permissionMode ?? "default");
+    if (hasModelOverride && nextState.model && previousState.model !== nextState.model) {
+      updateDisplayedModel(nextState.model, true);
+      messageBuffer.addMessage(`Model changed to: ${nextState.model}`, "system");
+      api.logger.debug(`[Gemini] Model changed from ${previousState.model} to ${nextState.model}`);
+    }
+  };
+  bindGeminiUserMessageQueue({
+    session,
+    messageQueue,
+    initialState: {},
+    happyOrg: {
+      getMetadata: () => session.getMetadataSnapshot?.() ?? metadata,
+      updateMetadata: (handler) => session.updateMetadata(handler),
+      emitStatusMessage: (message) => {
+        emitGeminiStatusMessage?.(message);
+      }
+    },
+    onResolvedMessage: (resolution) => {
+      handleQueuedUserMessage?.(resolution);
+    }
+  });
+  const emitTurnReport = (report) => {
+    session.sendAgentMessage("gemini", {
+      type: "turn-report",
+      id: node_crypto.randomUUID(),
+      report
+    });
+  };
   let accumulatedResponse = "";
   let isResponseInProgress = false;
   let hadToolCallInTurn = false;
   let taskStartedSent = false;
+  const resetTurnState = () => {
+    reasoningProcessor.abort();
+    diffProcessor.reset();
+    accumulatedResponse = "";
+    isResponseInProgress = false;
+    hadToolCallInTurn = false;
+    taskStartedSent = false;
+    turnAbortedSent = false;
+    thinking = false;
+    session.keepAlive(thinking, "remote");
+  };
   const disposeRuntimeHandle = async () => {
     if (!runtimeHandle) {
       return;
@@ -730,6 +854,37 @@ async function runGemini(opts) {
       api.logger.debug("[Gemini] Error disposing runtime session:", error);
     }
   };
+  const queueHistoryInjectionForRestart = (reason) => {
+    messageBuffer.addMessage("\u2550".repeat(40), "status");
+    if (conversationHistory.hasHistory()) {
+      shouldInjectHistoryOnNextSession = true;
+      const message = `${reason} Preserving ${conversationHistory.size()} earlier messages of context.`;
+      emitGeminiStatusMessage?.(message);
+      api.logger.debug(`[Gemini] Will inject conversation history after restart: ${conversationHistory.getSummary()}`);
+      return;
+    }
+    emitGeminiStatusMessage?.(reason);
+  };
+  const recoverUnexpectedRuntimeStop = async (detail) => {
+    if (shouldExit || messageQueue.isClosed() || unexpectedRuntimeStopRecovery) {
+      return;
+    }
+    const errorMessage = normalizeGeminiBackendError(detail);
+    unexpectedRuntimeStopRecovery = (async () => {
+      queueHistoryInjectionForRestart(
+        `Gemini runtime stopped unexpectedly (${errorMessage}). Starting a new Gemini session on the next message...`
+      );
+      await disposeRuntimeHandle();
+      currentModeHash = null;
+      permissionHandler.reset();
+      resetTurnState();
+    })();
+    try {
+      await unexpectedRuntimeStopRecovery;
+    } finally {
+      unexpectedRuntimeStopRecovery = null;
+    }
+  };
   function setupGeminiMessageHandler(activeRuntimeHandle) {
     const forwardAgentMessage = (agentMessage) => {
       registerKillSessionHandler.forwardAgentMessageToProviderSession(agentMessage, {
@@ -759,10 +914,13 @@ async function runGemini(opts) {
           api.logger.debug(`[gemini] Status changed: ${msg.status}${statusDetail ? ` - ${statusDetail}` : ""}`);
           if (msg.status === "error") {
             api.logger.debug(`[gemini] \u26A0\uFE0F Error status received: ${statusDetail || "Unknown error"}`);
-            session.sendAgentMessage("gemini", {
-              type: "turn_aborted",
-              id: node_crypto.randomUUID()
-            });
+            if (!turnAbortedSent) {
+              session.sendAgentMessage("gemini", {
+                type: "turn_aborted",
+                id: node_crypto.randomUUID()
+              });
+              turnAbortedSent = true;
+            }
           }
           if (msg.status === "running") {
             thinking = true;
@@ -777,6 +935,9 @@ async function runGemini(opts) {
             messageBuffer.addMessage("Thinking...", "system");
           } else if (msg.status === "idle" || msg.status === "stopped") {
             reasoningProcessor.complete();
+            if (msg.status === "stopped" && !turnInFlight) {
+              void recoverUnexpectedRuntimeStop(msg.detail);
+            }
           } else if (msg.status === "error") {
             thinking = false;
             session.keepAlive(thinking, "remote");
@@ -936,7 +1097,6 @@ Guide: https://goo.gle/gemini-cli-auth-docs#workspace-gca`;
     };
   }
   try {
-    let currentModeHash = null;
     let pending = null;
     while (!shouldExit) {
       let message = pending;
@@ -959,19 +1119,11 @@ Guide: https://goo.gle/gemini-cli-auth-docs#workspace-gca`;
       if (!message) {
         break;
       }
-      let injectHistoryContext = false;
       if (runtimeHandle && currentModeHash && message.hash !== currentModeHash) {
         api.logger.debug("[Gemini] Mode changed \u2013 restarting Gemini session");
-        messageBuffer.addMessage("\u2550".repeat(40), "status");
-        if (conversationHistory.hasHistory()) {
-          messageBuffer.addMessage(`Switching model (preserving ${conversationHistory.size()} messages of context)...`, "status");
-          injectHistoryContext = true;
-          api.logger.debug(`[Gemini] Will inject conversation history: ${conversationHistory.getSummary()}`);
-        } else {
-          messageBuffer.addMessage("Starting new Gemini session (mode changed)...", "status");
-        }
+        queueHistoryInjectionForRestart("Starting new Gemini session (execution settings changed)...");
         permissionHandler.reset();
-        reasoningProcessor.abort();
+        resetTurnState();
         await disposeRuntimeHandle();
         const launchedRuntime = await launchGeminiRuntimeHandle(message.mode);
         const actualModel = launchedRuntime.model;
@@ -987,7 +1139,9 @@ Guide: https://goo.gle/gemini-cli-auth-docs#workspace-gca`;
       const userMessageToShow = message.mode?.originalUserMessage || message.message;
       messageBuffer.addMessage(userMessageToShow, "user");
       isProcessingMessage = true;
+      let turnStatus = "task_complete";
       try {
+        turnInFlight = true;
         let activeHandle = runtimeHandle;
         if (!activeHandle) {
           const launchedRuntime = await launchGeminiRuntimeHandle(message.mode);
@@ -1007,12 +1161,17 @@ Guide: https://goo.gle/gemini-cli-auth-docs#workspace-gca`;
         isResponseInProgress = false;
         hadToolCallInTurn = false;
         taskStartedSent = false;
+        turnAbortedSent = false;
         let promptToSend = message.message;
-        if (injectHistoryContext && conversationHistory.hasHistory()) {
+        if (shouldInjectHistoryOnNextSession && conversationHistory.hasHistory()) {
           const historyContext = conversationHistory.getContextForNewSession();
           promptToSend = historyContext + promptToSend;
           api.logger.debug(`[gemini] Injected conversation history context (${historyContext.length} chars)`);
         }
+        if (message.mode.happyOrg) {
+          promptToSend = registerKillSessionHandler.buildHappyOrgTurnPrompt(promptToSend, message.mode.happyOrg);
+        }
+        conversationHistory.addUserMessage(userMessageToShow);
         api.logger.debug(`[gemini] Sending prompt to Gemini (length: ${promptToSend.length}): ${promptToSend.substring(0, 100)}...`);
         api.logger.debug(`[gemini] Full prompt: ${promptToSend}`);
         const MAX_RETRIES = 3;
@@ -1022,8 +1181,9 @@ Guide: https://goo.gle/gemini-cli-auth-docs#workspace-gca`;
           try {
             await activeHandle.sendPrompt(promptToSend);
             api.logger.debug("[gemini] Prompt sent successfully");
-            await registerKillSessionHandler.waitForResponseCompleteWithAbort(activeHandle.backend, abortController.signal, 12e4);
+            await registerKillSessionHandler.waitForResponseCompleteWithAbort(activeHandle.backend, abortController.signal, 10 * 6e4);
             api.logger.debug("[gemini] Response complete");
+            shouldInjectHistoryOnNextSession = false;
             break;
           } catch (promptError) {
             lastError = promptError;
@@ -1061,6 +1221,14 @@ Guide: https://goo.gle/gemini-cli-auth-docs#workspace-gca`;
       } catch (error) {
         api.logger.debug("[gemini] Error in gemini session:", error);
         const isAbortError = error instanceof Error && error.name === "AbortError";
+        turnStatus = "turn_aborted";
+        if (!turnAbortedSent) {
+          session.sendAgentMessage("gemini", {
+            type: "turn_aborted",
+            id: node_crypto.randomUUID()
+          });
+          turnAbortedSent = true;
+        }
         if (isAbortError) {
           messageBuffer.addMessage("Aborted by user", "status");
           session.sendSessionEvent({ type: "message", message: "Aborted by user" });
@@ -1073,8 +1241,8 @@ Guide: https://goo.gle/gemini-cli-auth-docs#workspace-gca`;
             const errorMessage = errObj.message || errObj.error?.message || "";
             const errorString = String(error);
             if (errorCode === 404 || errorDetails.includes("notFound") || errorDetails.includes("404") || errorMessage.includes("not found") || errorMessage.includes("404")) {
-              const currentModel2 = displayedModel || "gemini-2.5-pro";
-              errorMsg = `Model "${currentModel2}" not found. Available models: gemini-2.5-pro, gemini-2.5-flash, gemini-2.5-flash-lite`;
+              const currentModel = displayedModel || "gemini-2.5-pro";
+              errorMsg = `Model "${currentModel}" not found. Available models: gemini-2.5-pro, gemini-2.5-flash, gemini-2.5-flash-lite`;
             } else if (errorCode === -32603 || errorDetails.includes("empty response") || errorDetails.includes("Model stream ended")) {
               errorMsg = "Gemini API returned empty response after retries. This is a temporary issue - please try again.";
             } else if (errorCode === 429 || errorDetails.includes("429") || errorMessage.includes("429") || errorString.includes("429") || errorDetails.includes("rateLimitExceeded") || errorDetails.includes("RESOURCE_EXHAUSTED") || errorMessage.includes("Rate limit exceeded") || errorMessage.includes("Resource exhausted") || errorString.includes("rateLimitExceeded") || errorString.includes("RESOURCE_EXHAUSTED")) {
@@ -1107,9 +1275,26 @@ Guide: https://goo.gle/gemini-cli-auth-docs#workspace-gca`;
           });
         }
       } finally {
+        turnInFlight = false;
         permissionHandler.reset();
         reasoningProcessor.abort();
         diffProcessor.reset();
+        const finalizedTurn = registerKillSessionHandler.finalizeHappyOrgTurn({
+          metadata: session.getMetadataSnapshot?.() ?? null,
+          queuedTurn: message.mode.happyOrg,
+          responseText: accumulatedResponse,
+          turnStatus
+        });
+        if (finalizedTurn.nextMetadata && typeof session.updateMetadata === "function") {
+          session.updateMetadata(() => finalizedTurn.nextMetadata);
+        }
+        if (finalizedTurn.report) {
+          emitTurnReport(finalizedTurn.report);
+        }
+        if (finalizedTurn.terminateMessage) {
+          emitGeminiStatusMessage?.(finalizedTurn.terminateMessage);
+        }
+        accumulatedResponse = finalizedTurn.cleanedText;
         if (accumulatedResponse.trim()) {
           const { text: messageText, options } = parseOptionsFromText(accumulatedResponse);
           conversationHistory.addAssistantMessage(messageText);