happy-imou-cloud 2.1.49 → 2.1.51

package/dist/{runGemini-DcwNsudA.mjs → runGemini-BNm4vYKA.mjs}

@@ -1,10 +1,13 @@
 import { useStdout, useInput, Box, Text, render } from 'ink';
 import React, { useState, useRef, useEffect, useCallback } from 'react';
 import { randomUUID } from 'node:crypto';
-import { l as logger, b as connectionState, A as ApiClient, h as hashObject, d as AssistantMessageStream } from './api-DnqaNvyV.mjs';
-import { B as BasePermissionHandler, C as ConversationHistory$1, r as resolveHappyOrgQueuedTurn, e as ensureManagedProviderMachine, M as MissingMachineIdError, s as syncControlledByUserState, b as MessageQueue2, c as registerKillSessionHandler, d as MessageBuffer, f as buildHappyOrgTurnPrompt, w as waitForResponseCompleteWithAbort, h as finalizeHappyOrgTurnWithBusinessAck, i as buildTurnResultPushNotification, j as buildReadyPushNotification, l as launchRuntimeHandleWithFactoryResult, k as extractPermissionRequestPushContext, m as buildPermissionPushNotification, n as renderTerminalOutputPreview, p as prepareTerminalOutputForForwarding, o as inferToolResultError, q as forwardAgentMessageToProviderSession, t as createSessionTranscriptInkRenderer } from './registerKillSessionHandler-DLDg2EES.mjs';
-import { g as getInitialGeminiModel, r as readGeminiLocalConfig, G as GEMINI_MODEL_ENV, b as closeProviderSession, s as saveGeminiModelToConfig, d as createGeminiBackend, e as stopCaffeinate } from './index-7Z93BoVn.mjs';
-import { B as BaseReasoningProcessor, b as bootstrapManagedProviderSession } from './BaseReasoningProcessor-CAVeOdyo.mjs';
+import { l as logger, b as connectionState, A as ApiClient, h as hashObject, d as AssistantMessageStream } from './types-B5vtxa38.mjs';
+import { C as ConversationHistory$1, M as MessageBuffer, b as buildTurnResultPushNotification, a as buildReadyPushNotification, l as launchRuntimeHandleWithFactoryResult, e as extractPermissionRequestPushContext, c as buildPermissionPushNotification, d as createSessionTranscriptInkRenderer } from './ConversationHistory-CI5bBfuA.mjs';
+import { B as BasePermissionHandler, c as resolveHappyOrgQueuedTurn, e as ensureManagedProviderMachine, M as MissingMachineIdError, s as syncControlledByUserState, b as MessageQueue2, r as registerKillSessionHandler, d as buildHappyOrgTurnPrompt, w as waitForResponseCompleteWithAbort, f as finalizeHappyOrgTurnWithBusinessAck, i as renderTerminalOutputPreview, p as prepareTerminalOutputForForwarding, j as inferToolResultError, h as forwardAgentMessageToProviderSession } from './sessionControl-1bT_7OI6.mjs';
+import { f as resolveAcpSessionPreferences, n as scaleAcpTimeoutMs, b as closeProviderSession, s as stopCaffeinate } from './index-CX-F_fuk.mjs';
+import { A as AcpBackend } from './AcpBackend-CqO3D07V.mjs';
+import { r as readGeminiLocalConfig, G as GEMINI_API_KEY_ENV, a as GOOGLE_API_KEY_ENV, d as determineGeminiModel, g as getGeminiModelSource, b as GEMINI_MODEL_ENV, c as getInitialGeminiModel, s as saveGeminiModelToConfig } from './config-ChSPe7p9.mjs';
+import { B as BaseReasoningProcessor } from './BaseReasoningProcessor-CjlayL2f.mjs';
 import 'cross-spawn';
 import '@agentclientprotocol/sdk';
 import 'ps-list';
@@ -13,6 +16,7 @@ import 'node:path';
 import 'node:os';
 import 'node:child_process';
 import 'node:readline';
+import { b as bootstrapManagedProviderSession } from './bootstrapManagedProviderSession-D2Z6YU3n.mjs';
 import 'tweetnacl';
 import 'axios';
 import 'open';
@@ -27,7 +31,7 @@ import 'socket.io-client';
 import 'fs/promises';
 import 'crypto';
 import 'expo-server-sdk';
-import './types-CiliQpqS.mjs';
+import './RuntimeShell-BDt42io_.mjs';
 import 'os';
 import 'qrcode-terminal';
 import 'node:module';
@@ -38,6 +42,276 @@ import 'http';
 import 'util';
 import '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 resolveAcpSessionPreferences({ agentName: this.agentName }).timeoutProfile;
+  }
+  /**
+   * Gemini CLI needs 2 minutes for first start (model download, warm-up)
+   */
+  getInitTimeout() {
+    return 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 scaleAcpTimeoutMs(GEMINI_TIMEOUTS.investigation, "investigation", this.getTimeoutProfile());
+    }
+    if (toolKind === "think") {
+      return scaleAcpTimeoutMs(GEMINI_TIMEOUTS.think, "think", this.getTimeoutProfile());
+    }
+    return 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) : [];
+      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 = readGeminiLocalConfig();
+  let apiKey = options.cloudToken || localConfig.token || process.env[GEMINI_API_KEY_ENV] || process.env[GOOGLE_API_KEY_ENV] || options.apiKey;
+  if (!apiKey) {
+    logger.warn(`[Gemini] No API key found. Run 'happy connect gemini' to authenticate via Google OAuth, or set ${GEMINI_API_KEY_ENV} environment variable.`);
+  }
+  const geminiCommand = "gemini";
+  const model = 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;
+      logger.debug(`[Gemini] Using Google Cloud Project: ${googleCloudProject}${storedEmail ? ` (for ${storedEmail})` : " (global)"}`);
+    } else {
+      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 ? { [GEMINI_API_KEY_ENV]: apiKey, [GOOGLE_API_KEY_ENV]: apiKey } : {},
+      // Pass model via env var - gemini CLI reads GEMINI_MODEL automatically
+      [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 = getGeminiModelSource(options.model, localConfig);
+  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(backendOptions),
+    model,
+    modelSource
+  };
+}
+
 const GeminiDisplay = ({ messageBuffer, logPath, currentModel, onExit }) => {
   const [messages, setMessages] = useState([]);
   const [confirmationMode, setConfirmationMode] = useState(false);