happy-imou-cloud 2.1.49 → 2.1.51

package/dist/{runGemini-C0NT8MHK.cjs → runGemini-Bn3lFhz6.cjs}

@@ -3,10 +3,13 @@
 var ink = require('ink');
 var React = require('react');
 var node_crypto = require('node:crypto');
-var persistence = require('./api-D7nAeZi7.cjs');
-var registerKillSessionHandler = require('./registerKillSessionHandler-CfCya6si.cjs');
-var index = require('./index-xa1kwZoj.cjs');
-var BaseReasoningProcessor = require('./BaseReasoningProcessor-Dn9NcoHz.cjs');
+var persistence = require('./types-CttABk32.cjs');
+var ConversationHistory$1 = require('./ConversationHistory-Bl2doTA-.cjs');
+var sessionControl = require('./sessionControl-flKnQrx0.cjs');
+var index = require('./index-B_JYgMUS.cjs');
+var AcpBackend = require('./AcpBackend-XPiTd6ph.cjs');
+var config = require('./config-CFL0Gkqt.cjs');
+var BaseReasoningProcessor = require('./BaseReasoningProcessor-BD9tiwep.cjs');
 require('cross-spawn');
 require('@agentclientprotocol/sdk');
 require('ps-list');
@@ -15,6 +18,7 @@ require('node:path');
 require('node:os');
 require('node:child_process');
 require('node:readline');
+var bootstrapManagedProviderSession = require('./bootstrapManagedProviderSession-Bln-TwyB.cjs');
 require('tweetnacl');
 require('axios');
 require('open');
@@ -29,7 +33,7 @@ require('socket.io-client');
 require('fs/promises');
 require('crypto');
 require('expo-server-sdk');
-require('./types-DVk3crez.cjs');
+require('./RuntimeShell-D_Te12wq.cjs');
 require('os');
 require('qrcode-terminal');
 require('node:module');
@@ -40,6 +44,276 @@ require('http');
 require('util');
 require('node:url');
 
+const GEMINI_TIMEOUTS = {
+  /** Gemini CLI can be slow on first start (downloading models, etc.) */
+  init: 12e4,
+  /** Gemini ACP can swallow an initialize request sent too early after spawn */
+  initDelay: 2500,
+  /** Standard tool call timeout */
+  toolCall: 10 * 6e4,
+  /** Investigation tools (codebase_investigator) can run for a long time */
+  investigation: 30 * 6e4,
+  /** Think tools are usually quick */
+  think: 2 * 6e4,
+  /** Idle detection after last message chunk */
+  idle: 500
+};
+const GEMINI_TOOL_PATTERNS = [
+  {
+    name: "save_memory",
+    patterns: ["save_memory", "save-memory"],
+    inputFields: ["memory", "content"]
+  },
+  {
+    name: "think",
+    patterns: ["think"],
+    inputFields: ["thought", "thinking"]
+  }
+];
+const AVAILABLE_MODELS = [
+  "gemini-2.5-pro",
+  "gemini-2.5-flash",
+  "gemini-2.5-flash-lite"
+];
+class GeminiTransport {
+  agentName = "gemini";
+  getTimeoutProfile() {
+    return index.resolveAcpSessionPreferences({ agentName: this.agentName }).timeoutProfile;
+  }
+  /**
+   * Gemini CLI needs 2 minutes for first start (model download, warm-up)
+   */
+  getInitTimeout() {
+    return index.scaleAcpTimeoutMs(GEMINI_TIMEOUTS.init, "init", this.getTimeoutProfile());
+  }
+  getInitDelayMs() {
+    return GEMINI_TIMEOUTS.initDelay;
+  }
+  /**
+   * Filter Gemini CLI debug output from stdout.
+   *
+   * Gemini CLI outputs various debug info (experiments, flags, etc.) to stdout
+   * that breaks ACP JSON-RPC parsing. We only keep valid JSON lines.
+   */
+  filterStdoutLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      return null;
+    }
+    if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) {
+      return null;
+    }
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (typeof parsed !== "object" || parsed === null) {
+        return null;
+      }
+      return line;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Handle Gemini CLI stderr output.
+   *
+   * Detects:
+   * - Rate limit errors (429) - logged but not shown (CLI handles retries)
+   * - Model not found (404) - emit error with available models
+   * - Other errors during investigation - logged for debugging
+   */
+  handleStderr(text, context) {
+    const trimmed = text.trim();
+    if (!trimmed) {
+      return { message: null, suppress: true };
+    }
+    if (trimmed.includes("status 429") || trimmed.includes('code":429') || trimmed.includes("rateLimitExceeded") || trimmed.includes("RESOURCE_EXHAUSTED")) {
+      return {
+        message: null,
+        suppress: false
+        // Log for debugging but don't show to user
+      };
+    }
+    if (trimmed.includes("status 404") || trimmed.includes('code":404')) {
+      const errorMessage = {
+        type: "status",
+        status: "error",
+        detail: `Model not found. Available models: ${AVAILABLE_MODELS.join(", ")}`
+      };
+      return { message: errorMessage };
+    }
+    if (context.hasActiveInvestigation) {
+      const hasError = trimmed.includes("timeout") || trimmed.includes("Timeout") || trimmed.includes("failed") || trimmed.includes("Failed") || trimmed.includes("error") || trimmed.includes("Error");
+      if (hasError) {
+        return { message: null, suppress: false };
+      }
+    }
+    return { message: null };
+  }
+  /**
+   * Gemini-specific tool patterns
+   */
+  getToolPatterns() {
+    return GEMINI_TOOL_PATTERNS;
+  }
+  /**
+   * Check if tool is an investigation tool (needs longer timeout)
+   */
+  isInvestigationTool(toolCallId, toolKind) {
+    const lowerId = toolCallId.toLowerCase();
+    return lowerId.includes("codebase_investigator") || lowerId.includes("investigator") || typeof toolKind === "string" && toolKind.includes("investigator");
+  }
+  /**
+   * Get timeout for a tool call
+   */
+  getToolCallTimeout(toolCallId, toolKind) {
+    if (this.isInvestigationTool(toolCallId, toolKind)) {
+      return index.scaleAcpTimeoutMs(GEMINI_TIMEOUTS.investigation, "investigation", this.getTimeoutProfile());
+    }
+    if (toolKind === "think") {
+      return index.scaleAcpTimeoutMs(GEMINI_TIMEOUTS.think, "think", this.getTimeoutProfile());
+    }
+    return index.scaleAcpTimeoutMs(GEMINI_TIMEOUTS.toolCall, "tool", this.getTimeoutProfile());
+  }
+  /**
+   * Get idle detection timeout
+   */
+  getIdleTimeout() {
+    return GEMINI_TIMEOUTS.idle;
+  }
+  /**
+   * Extract tool name from toolCallId using Gemini patterns.
+   *
+   * Tool IDs often contain the tool name as a prefix (e.g., "save_memory-1765385846663" -> "save_memory")
+   */
+  extractToolNameFromId(toolCallId) {
+    const lowerId = toolCallId.toLowerCase();
+    for (const toolPattern of GEMINI_TOOL_PATTERNS) {
+      for (const pattern of toolPattern.patterns) {
+        if (lowerId.includes(pattern.toLowerCase())) {
+          return toolPattern.name;
+        }
+      }
+    }
+    return null;
+  }
+  /**
+   * Check if input is effectively empty
+   */
+  isEmptyInput(input) {
+    if (!input) return true;
+    if (Array.isArray(input)) return input.length === 0;
+    if (typeof input === "object") return Object.keys(input).length === 0;
+    return false;
+  }
+  /**
+   * Determine the real tool name from various sources.
+   *
+   * When Gemini sends "other" or "Unknown tool", tries to determine the real name from:
+   * 1. toolCallId patterns (most reliable - tool name often embedded in ID)
+   * 2. Input field signatures (specific fields indicate specific tools)
+   * 3. Empty input default (some tools like think have empty input)
+   *
+   * Context-based heuristics were removed as they were fragile and the above
+   * methods cover all known cases.
+   */
+  determineToolName(toolName, toolCallId, input, _context) {
+    if (toolName !== "other" && toolName !== "Unknown tool") {
+      return toolName;
+    }
+    const idToolName = this.extractToolNameFromId(toolCallId);
+    if (idToolName) {
+      return idToolName;
+    }
+    if (input && typeof input === "object" && !Array.isArray(input)) {
+      const inputKeys = Object.keys(input);
+      for (const toolPattern of GEMINI_TOOL_PATTERNS) {
+        if (toolPattern.inputFields) {
+          const hasMatchingField = toolPattern.inputFields.some(
+            (field) => inputKeys.some((key) => key.toLowerCase() === field.toLowerCase())
+          );
+          if (hasMatchingField) {
+            return toolPattern.name;
+          }
+        }
+      }
+    }
+    if (this.isEmptyInput(input) && toolName === "other") {
+      const defaultTool = GEMINI_TOOL_PATTERNS.find((p) => p.emptyInputDefault);
+      if (defaultTool) {
+        return defaultTool.name;
+      }
+    }
+    if (toolName === "other" || toolName === "Unknown tool") {
+      const inputKeys = input && typeof input === "object" ? Object.keys(input) : [];
+      persistence.logger.debug(
+        `[GeminiTransport] Unknown tool pattern - toolCallId: "${toolCallId}", toolName: "${toolName}", inputKeys: [${inputKeys.join(", ")}]. Consider adding a new pattern to GEMINI_TOOL_PATTERNS if this tool appears frequently.`
+      );
+    }
+    return toolName;
+  }
+}
+const geminiTransport = new GeminiTransport();
+
+function createGeminiBackend(options) {
+  const localConfig = config.readGeminiLocalConfig();
+  let apiKey = options.cloudToken || localConfig.token || process.env[config.GEMINI_API_KEY_ENV] || process.env[config.GOOGLE_API_KEY_ENV] || options.apiKey;
+  if (!apiKey) {
+    persistence.logger.warn(`[Gemini] No API key found. Run 'happy connect gemini' to authenticate via Google OAuth, or set ${config.GEMINI_API_KEY_ENV} environment variable.`);
+  }
+  const geminiCommand = "gemini";
+  const model = config.determineGeminiModel(options.model, localConfig);
+  const geminiArgs = ["--experimental-acp"];
+  let googleCloudProject = null;
+  if (localConfig.googleCloudProject) {
+    const storedEmail = localConfig.googleCloudProjectEmail;
+    const currentEmail = options.currentUserEmail;
+    if (!storedEmail || storedEmail === currentEmail) {
+      googleCloudProject = localConfig.googleCloudProject;
+      persistence.logger.debug(`[Gemini] Using Google Cloud Project: ${googleCloudProject}${storedEmail ? ` (for ${storedEmail})` : " (global)"}`);
+    } else {
+      persistence.logger.debug(`[Gemini] Skipping stored Google Cloud Project (stored for ${storedEmail}, current user is ${currentEmail || "unknown"})`);
+    }
+  }
+  const backendOptions = {
+    agentName: "gemini",
+    cwd: options.cwd,
+    command: geminiCommand,
+    args: geminiArgs,
+    env: {
+      ...options.env,
+      ...apiKey ? { [config.GEMINI_API_KEY_ENV]: apiKey, [config.GOOGLE_API_KEY_ENV]: apiKey } : {},
+      // Pass model via env var - gemini CLI reads GEMINI_MODEL automatically
+      [config.GEMINI_MODEL_ENV]: model,
+      // Pass Google Cloud Project for Workspace accounts
+      ...googleCloudProject ? {
+        GOOGLE_CLOUD_PROJECT: googleCloudProject,
+        GOOGLE_CLOUD_PROJECT_ID: googleCloudProject
+      } : {},
+      // Suppress debug output from gemini CLI to avoid stdout pollution
+      NODE_ENV: "production",
+      DEBUG: ""
+    },
+    mcpServers: options.mcpServers,
+    permissionHandler: options.permissionHandler,
+    transportHandler: geminiTransport
+  };
+  const modelSource = config.getGeminiModelSource(options.model, localConfig);
+  persistence.logger.debug("[Gemini] Creating ACP SDK backend with options:", {
+    cwd: backendOptions.cwd,
+    command: backendOptions.command,
+    args: backendOptions.args,
+    hasApiKey: !!apiKey,
+    model,
+    modelSource,
+    mcpServerCount: options.mcpServers ? Object.keys(options.mcpServers).length : 0
+  });
+  return {
+    backend: new AcpBackend.AcpBackend(backendOptions),
+    model,
+    modelSource
+  };
+}
+
 const GeminiDisplay = ({ messageBuffer, logPath, currentModel, onExit }) => {
   const [messages, setMessages] = React.useState([]);
   const [confirmationMode, setConfirmationMode] = React.useState(false);
@@ -183,7 +457,7 @@ const GeminiDisplay = ({ messageBuffer, logPath, currentModel, onExit }) => {
   ));
 };
 
-class GeminiPermissionHandler extends registerKillSessionHandler.BasePermissionHandler {
+class GeminiPermissionHandler extends sessionControl.BasePermissionHandler {
   currentPermissionMode = "default";
   constructor(session) {
     super(session);
@@ -420,7 +694,7 @@ function formatOptionsXml(options) {
   return "\n<options>\n" + options.map((opt) => `    <option>${opt}</option>`).join("\n") + "\n</options>";
 }
 
-class ConversationHistory extends registerKillSessionHandler.ConversationHistory {
+class ConversationHistory extends ConversationHistory$1.ConversationHistory {
   currentModel;
   setCurrentModel(model) {
     this.currentModel = model;
@@ -489,7 +763,7 @@ ${originalUserMessage}`;
 function bindGeminiUserMessageQueue(opts) {
   let currentState = { ...opts.initialState };
   opts.session.onUserMessage((message) => {
-    const happyOrgResult = opts.happyOrg ? registerKillSessionHandler.resolveHappyOrgQueuedTurn({
+    const happyOrgResult = opts.happyOrg ? sessionControl.resolveHappyOrgQueuedTurn({
       metadata: opts.happyOrg.getMetadata(),
       message,
       sessionId: opts.happyOrg.getSessionId?.() ?? null
@@ -547,12 +821,12 @@ async function runGemini(opts) {
   const api = await persistence.ApiClient.create(opts.credentials);
   let machineId;
   try {
-    machineId = await registerKillSessionHandler.ensureManagedProviderMachine({
+    machineId = await sessionControl.ensureManagedProviderMachine({
       api,
       missingMachineIdMessage: "[START] No machine ID found in settings, which is unexpected since authAndSetupMachineIfNeeded should have created it. Please report this issue on https://github.com/slopus/happy-cli/issues"
     });
   } catch (error) {
-    if (error instanceof registerKillSessionHandler.MissingMachineIdError) {
+    if (error instanceof sessionControl.MissingMachineIdError) {
       console.error(error.message);
       process.exit(1);
     }
@@ -600,7 +874,7 @@ async function runGemini(opts) {
       pendingSessionSwap = null;
     }
   };
-  const { metadata, session: initialSession, reconnectionHandle } = await BaseReasoningProcessor.bootstrapManagedProviderSession({
+  const { metadata, session: initialSession, reconnectionHandle } = await bootstrapManagedProviderSession.bootstrapManagedProviderSession({
     api,
     sessionTag,
     flavor: "gemini",
@@ -618,12 +892,12 @@ async function runGemini(opts) {
         }
         bindSessionTranscriptHistory?.(newSession);
       }
-      void registerKillSessionHandler.syncControlledByUserState(newSession, false);
+      void sessionControl.syncControlledByUserState(newSession, false);
     }
   });
   session = initialSession;
-  await registerKillSessionHandler.syncControlledByUserState(session, false);
-  const messageQueue = new registerKillSessionHandler.MessageQueue2((mode) => persistence.hashObject({
+  await sessionControl.syncControlledByUserState(session, false);
+  const messageQueue = new sessionControl.MessageQueue2((mode) => persistence.hashObject({
     permissionMode: mode.permissionMode,
     model: mode.model,
     happyOrg: mode.happyOrg ? {
@@ -652,7 +926,7 @@ async function runGemini(opts) {
       return;
     }
     try {
-      const notification = registerKillSessionHandler.buildReadyPushNotification({
+      const notification = ConversationHistory$1.buildReadyPushNotification({
         providerLabel: "Gemini",
         metadata: session.getMetadataSnapshot?.() ?? null,
         sessionId: session.sessionId
@@ -740,10 +1014,10 @@ async function runGemini(opts) {
     }
   };
   session.rpcHandlerManager.registerHandler("abort", handleAbort);
-  registerKillSessionHandler.registerKillSessionHandler(session.rpcHandlerManager, handleKillSession);
+  sessionControl.registerKillSessionHandler(session.rpcHandlerManager, handleKillSession);
   const hasTTY = process.stdout.isTTY && process.stdin.isTTY;
-  const messageBuffer = new registerKillSessionHandler.MessageBuffer({ enabled: hasTTY });
-  const renderSessionTranscript = registerKillSessionHandler.createSessionTranscriptInkRenderer({ messageBuffer });
+  const messageBuffer = new ConversationHistory$1.MessageBuffer({ enabled: hasTTY });
+  const renderSessionTranscript = ConversationHistory$1.createSessionTranscriptInkRenderer({ messageBuffer });
   let inkInstance = null;
   bindSessionTranscriptHistory = (nextSession) => {
     if (typeof nextSession.onSessionMessage !== "function") {
@@ -757,9 +1031,9 @@ async function runGemini(opts) {
     });
   };
   bindSessionTranscriptHistory(session);
-  let displayedModel = index.getInitialGeminiModel();
-  const localConfig = index.readGeminiLocalConfig();
-  persistence.logger.debug(`[gemini] Initial model setup: env[GEMINI_MODEL_ENV]=${process.env[index.GEMINI_MODEL_ENV] || "not set"}, localConfig=${localConfig.model || "not set"}, displayedModel=${displayedModel}`);
+  let displayedModel = config.getInitialGeminiModel();
+  const localConfig = config.readGeminiLocalConfig();
+  persistence.logger.debug(`[gemini] Initial model setup: env[GEMINI_MODEL_ENV]=${process.env[config.GEMINI_MODEL_ENV] || "not set"}, localConfig=${localConfig.model || "not set"}, displayedModel=${displayedModel}`);
   const updateDisplayedModel = (model, saveToConfig = false) => {
     if (model === void 0) {
       persistence.logger.debug(`[gemini] updateDisplayedModel called with undefined, skipping update`);
@@ -769,7 +1043,7 @@ async function runGemini(opts) {
     displayedModel = model;
     persistence.logger.debug(`[gemini] updateDisplayedModel called: oldModel=${oldModel}, newModel=${model}, saveToConfig=${saveToConfig}`);
     if (saveToConfig) {
-      index.saveGeminiModelToConfig(model);
+      config.saveGeminiModelToConfig(model);
     }
     if (hasTTY && oldModel !== model) {
       persistence.logger.debug(`[gemini] Adding model update message to buffer: [MODEL:${model}]`);
@@ -972,7 +1246,7 @@ async function runGemini(opts) {
   };
   function setupGeminiMessageHandler(activeRuntimeHandle) {
     const forwardAgentMessage = (agentMessage) => {
-      registerKillSessionHandler.forwardAgentMessageToProviderSession(agentMessage, {
+      sessionControl.forwardAgentMessageToProviderSession(agentMessage, {
         provider: "gemini",
         send: (body) => session.sendAgentMessage("gemini", body)
       });
@@ -1065,7 +1339,7 @@ Guide: https://goo.gle/gemini-cli-auth-docs#workspace-gca`;
           forwardAgentMessage(msg);
           break;
         case "tool-result":
-          const isError = registerKillSessionHandler.inferToolResultError(msg.result);
+          const isError = sessionControl.inferToolResultError(msg.result);
           const resultText = typeof msg.result === "string" ? msg.result.substring(0, 200) : JSON.stringify(msg.result).substring(0, 200);
           const truncatedResult = resultText + (typeof msg.result === "string" && msg.result.length > 200 ? "..." : "");
           const resultSize = typeof msg.result === "string" ? msg.result.length : JSON.stringify(msg.result).length;
@@ -1091,12 +1365,12 @@ Guide: https://goo.gle/gemini-cli-auth-docs#workspace-gca`;
           forwardAgentMessage(msg);
           break;
         case "terminal-output": {
-          const terminalOutput = registerKillSessionHandler.renderTerminalOutputPreview(msg.data);
+          const terminalOutput = sessionControl.renderTerminalOutputPreview(msg.data);
           if (!terminalOutput) {
             break;
           }
           messageBuffer.addMessage(terminalOutput, "result");
-          const forwardedOutput = registerKillSessionHandler.prepareTerminalOutputForForwarding(msg.data);
+          const forwardedOutput = sessionControl.prepareTerminalOutputForForwarding(msg.data);
           if (forwardedOutput) {
             forwardAgentMessage({
               ...msg,
@@ -1107,8 +1381,8 @@ Guide: https://goo.gle/gemini-cli-auth-docs#workspace-gca`;
         }
         case "permission-request":
           try {
-            const permissionRequest = registerKillSessionHandler.extractPermissionRequestPushContext(msg);
-            const notification = registerKillSessionHandler.buildPermissionPushNotification({
+            const permissionRequest = ConversationHistory$1.extractPermissionRequestPushContext(msg);
+            const notification = ConversationHistory$1.buildPermissionPushNotification({
               providerLabel: "Gemini",
               metadata: session.getMetadataSnapshot?.() ?? null,
               sessionId: session.sessionId,
@@ -1185,11 +1459,11 @@ Guide: https://goo.gle/gemini-cli-auth-docs#workspace-gca`;
     const modelToUse = mode.model === void 0 ? void 0 : mode.model || null;
     let backendResult;
     updatePermissionMode(mode.permissionMode);
-    const { session: nextRuntimeHandle, factoryResult } = await registerKillSessionHandler.launchRuntimeHandleWithFactoryResult({
+    const { session: nextRuntimeHandle, factoryResult } = await ConversationHistory$1.launchRuntimeHandleWithFactoryResult({
       provider: "gemini",
       cwd: process.cwd(),
       createBackendResult: (opts2) => {
-        const createdBackendResult = index.createGeminiBackend({
+        const createdBackendResult = createGeminiBackend({
           ...opts2,
           mcpServers: {},
           permissionHandler,
@@ -1294,7 +1568,7 @@ Guide: https://goo.gle/gemini-cli-auth-docs#workspace-gca`;
           persistence.logger.debug(`[gemini] Injected conversation history context (${historyContext.length} chars)`);
         }
         if (message.mode.happyOrg) {
-          promptToSend = registerKillSessionHandler.buildHappyOrgTurnPrompt(promptToSend, message.mode.happyOrg);
+          promptToSend = sessionControl.buildHappyOrgTurnPrompt(promptToSend, message.mode.happyOrg);
         }
         conversationHistory.addUserMessage(userMessageToShow);
         persistence.logger.debug(`[gemini] Sending prompt to Gemini (length: ${promptToSend.length}): ${promptToSend.substring(0, 100)}...`);
@@ -1306,7 +1580,7 @@ Guide: https://goo.gle/gemini-cli-auth-docs#workspace-gca`;
           try {
             await activeHandle.sendPrompt(promptToSend);
             persistence.logger.debug("[gemini] Prompt sent successfully");
-            await registerKillSessionHandler.waitForResponseCompleteWithAbort(activeHandle.backend, abortController.signal);
+            await sessionControl.waitForResponseCompleteWithAbort(activeHandle.backend, abortController.signal);
             persistence.logger.debug("[gemini] Response complete");
             shouldInjectHistoryOnNextSession = false;
             break;
@@ -1404,7 +1678,7 @@ Guide: https://goo.gle/gemini-cli-auth-docs#workspace-gca`;
         permissionHandler.reset();
         reasoningProcessor.abort();
         diffProcessor.reset();
-        const finalizedTurn = await registerKillSessionHandler.finalizeHappyOrgTurnWithBusinessAck({
+        const finalizedTurn = await sessionControl.finalizeHappyOrgTurnWithBusinessAck({
           metadata: session.getMetadataSnapshot?.() ?? null,
           queuedTurn: message.mode.happyOrg,
           responseText: accumulatedResponse,
@@ -1446,7 +1720,7 @@ Guide: https://goo.gle/gemini-cli-auth-docs#workspace-gca`;
           session.sendAgentMessage("gemini", messagePayload);
           if (!shouldExit) {
             try {
-              const notification = registerKillSessionHandler.buildTurnResultPushNotification({
+              const notification = ConversationHistory$1.buildTurnResultPushNotification({
                 providerLabel: "Gemini",
                 metadata: finalizedTurn.nextMetadata ?? session.getMetadataSnapshot?.() ?? null,
                 sessionId: session.sessionId,
@@ -1469,7 +1743,7 @@ Guide: https://goo.gle/gemini-cli-auth-docs#workspace-gca`;
           isResponseInProgress = false;
         } else if (!shouldExit && finalizedTurn.report) {
           try {
-            const notification = registerKillSessionHandler.buildTurnResultPushNotification({
+            const notification = ConversationHistory$1.buildTurnResultPushNotification({
               providerLabel: "Gemini",
               metadata: finalizedTurn.nextMetadata ?? session.getMetadataSnapshot?.() ?? null,
               sessionId: session.sessionId,