@corbat-tech/coco 2.25.15 → 2.27.1

package/dist/cli/index.js

@@ -21,7 +21,7 @@ import { Logger } from 'tslog';
 import Anthropic from '@anthropic-ai/sdk';
 import { jsonrepair } from 'jsonrepair';
 import OpenAI from 'openai';
-import { GoogleGenerativeAI, FunctionCallingMode } from '@google/generative-ai';
+import { GoogleGenAI, FunctionCallingConfigMode } from '@google/genai';
 import matter from 'gray-matter';
 import { minimatch } from 'minimatch';
 import hljs from 'highlight.js/lib/core';
@@ -151,6 +151,7 @@ var init_schema = __esm({
         "codex",
         "copilot",
         "gemini",
+        "vertex",
         "kimi",
         "kimi-code",
         "lmstudio",
@@ -167,7 +168,9 @@ var init_schema = __esm({
       model: z.string().default("claude-sonnet-4-6"),
       maxTokens: z.number().min(1).max(2e5).default(8192),
       temperature: z.number().min(0).max(2).default(0),
-      timeout: z.number().min(1e3).default(12e4)
+      timeout: z.number().min(1e3).default(12e4),
+      project: z.string().optional(),
+      location: z.string().optional()
     });
     QualityConfigSchema = z.object({
       minScore: z.number().min(0).max(100).default(85),
@@ -788,8 +791,8 @@ async function requestDeviceCode(provider) {
   }
   const contentType = response.headers.get("content-type") || "";
   if (!contentType.includes("application/json")) {
-    const text13 = await response.text();
-    if (text13.includes("<!DOCTYPE") || text13.includes("<html")) {
+    const text14 = await response.text();
+    if (text14.includes("<!DOCTYPE") || text14.includes("<html")) {
       throw new Error(
         "OAuth service returned HTML instead of JSON.\n   The service may be temporarily unavailable.\n   Please use an API key instead, or try again later."
       );
@@ -2261,31 +2264,63 @@ async function hasADCCredentials() {
     return false;
   }
 }
-async function getADCAccessToken() {
+async function inspectADC() {
   try {
-    const { stdout } = await execAsync("gcloud auth application-default print-access-token", {
+    const { stdout } = await execAsync(PRINT_ACCESS_TOKEN_COMMAND, {
       timeout: 1e4
     });
     const accessToken = stdout.trim();
-    if (!accessToken) return null;
+    if (!accessToken) {
+      return {
+        status: "missing",
+        token: null,
+        message: "gcloud ADC is not configured.",
+        suggestion: `Run \`${ADC_LOGIN_COMMAND}\` manually, then retry Coco.`
+      };
+    }
     const expiresAt = Date.now() + 55 * 60 * 1e3;
     return {
-      accessToken,
-      expiresAt
+      status: "ok",
+      token: {
+        accessToken,
+        expiresAt
+      }
     };
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
+    if (message.includes("scope is required but not consented")) {
+      return {
+        status: "scope_not_consented",
+        token: null,
+        message: "gcloud ADC exists, but the required Google scope was not consented for this account.",
+        suggestion: `For Vertex AI, rerun \`gcloud auth application-default login\` manually. For Gemini API OAuth, follow Google's OAuth guide with your own OAuth client and run \`gcloud auth application-default login --client-id-file=client_secret.json --scopes='${GEMINI_OAUTH_SCOPES}'\`. Otherwise use a Gemini API key in Coco.`
+      };
+    }
     if (message.includes("not logged in") || message.includes("no application default credentials")) {
-      return null;
+      return {
+        status: "missing",
+        token: null,
+        message: "No application default credentials were found for gcloud.",
+        suggestion: `Run \`${ADC_LOGIN_COMMAND}\` manually, then retry Coco.`
+      };
     }
-    return null;
+    return {
+      status: "error",
+      token: null,
+      message,
+      suggestion: `Try \`${PRINT_ACCESS_TOKEN_COMMAND}\` in your terminal to inspect the local ADC state.`
+    };
   }
 }
+async function getADCAccessToken() {
+  const result = await inspectADC();
+  return result.token;
+}
 async function isADCConfigured() {
   const hasCredentials = await hasADCCredentials();
   if (!hasCredentials) return false;
-  const token = await getADCAccessToken();
-  return token !== null;
+  const result = await inspectADC();
+  return result.status === "ok" && result.token !== null;
 }
 async function runGcloudADCLogin() {
   try {
@@ -2313,10 +2348,16 @@ async function getCachedADCToken() {
 function clearADCCache() {
   cachedToken = null;
 }
-var execAsync, cachedToken;
+var execAsync, PRINT_ACCESS_TOKEN_COMMAND, ADC_LOGIN_COMMAND, GEMINI_OAUTH_SCOPES, cachedToken;
 var init_gcloud = __esm({
   "src/auth/gcloud.ts"() {
     execAsync = promisify(exec);
+    PRINT_ACCESS_TOKEN_COMMAND = "gcloud auth application-default print-access-token";
+    ADC_LOGIN_COMMAND = "gcloud auth application-default login";
+    GEMINI_OAUTH_SCOPES = [
+      "https://www.googleapis.com/auth/cloud-platform",
+      "https://www.googleapis.com/auth/generative-language.retriever"
+    ].join(",");
     cachedToken = null;
   }
 });
@@ -2347,6 +2388,7 @@ __export(auth_exports, {
   getValidAccessToken: () => getValidAccessToken,
   getValidCopilotToken: () => getValidCopilotToken,
   hasADCCredentials: () => hasADCCredentials,
+  inspectADC: () => inspectADC,
   isADCConfigured: () => isADCConfigured,
   isGcloudInstalled: () => isGcloudInstalled,
   isOAuthConfigured: () => isOAuthConfigured,
@@ -2461,6 +2503,8 @@ function getApiKey(provider) {
       return process.env["OPENAI_API_KEY"];
     case "gemini":
       return process.env["GEMINI_API_KEY"] ?? process.env["GOOGLE_API_KEY"];
+    case "vertex":
+      return void 0;
     case "kimi":
       return process.env["KIMI_API_KEY"] ?? process.env["MOONSHOT_API_KEY"];
     case "kimi-code":
@@ -2509,6 +2553,8 @@ function getBaseUrl(provider) {
       return "https://chatgpt.com/backend-api/codex/responses";
     case "copilot":
       return process.env["COPILOT_BASE_URL"] ?? "https://api.githubcopilot.com";
+    case "vertex":
+      return process.env["VERTEX_BASE_URL"] ?? "https://aiplatform.googleapis.com/v1";
     case "groq":
       return process.env["GROQ_BASE_URL"] ?? "https://api.groq.com/openai/v1";
     case "openrouter":
@@ -2535,6 +2581,8 @@ function getDefaultModel(provider) {
       return process.env["OPENAI_MODEL"] ?? "gpt-5.4-codex";
     case "gemini":
       return process.env["GEMINI_MODEL"] ?? "gemini-3.1-pro-preview";
+    case "vertex":
+      return process.env["VERTEX_MODEL"] ?? "gemini-2.5-pro";
     case "kimi":
       return process.env["KIMI_MODEL"] ?? "kimi-k2.5";
     case "kimi-code":
@@ -2606,7 +2654,7 @@ async function getLastUsedModel(provider) {
   }
   return void 0;
 }
-async function saveProviderPreference(provider, model) {
+async function saveProviderPreference(provider, model, options) {
   let config;
   try {
     config = await loadConfig(CONFIG_PATHS.config);
@@ -2648,6 +2696,16 @@ async function saveProviderPreference(provider, model) {
   } else {
     config.provider.model = getDefaultModel(provider);
   }
+  if (options?.project !== void 0) {
+    config.provider.project = options.project;
+  } else if (provider !== "vertex") {
+    delete config.provider.project;
+  }
+  if (options?.location !== void 0) {
+    config.provider.location = options.location;
+  } else if (provider !== "vertex") {
+    delete config.provider.location;
+  }
   await saveConfig(config, void 0, true);
   await updateEnvProvider(provider);
 }
@@ -2782,6 +2840,7 @@ var init_env = __esm({
       "codex",
       "copilot",
       "gemini",
+      "vertex",
       "kimi",
       "kimi-code",
       "lmstudio",
@@ -3311,25 +3370,25 @@ var init_anthropic = __esm({
        *
        * This heuristic analyzes the text to provide a better estimate.
        */
-      countTokens(text13) {
-        if (!text13) return 0;
+      countTokens(text14) {
+        if (!text14) return 0;
         const codePatterns = /[{}[\]();=<>!&|+\-*/]/g;
         const whitespacePattern = /\s/g;
         const wordPattern = /\b\w+\b/g;
-        const codeChars = (text13.match(codePatterns) || []).length;
-        const whitespace = (text13.match(whitespacePattern) || []).length;
-        const words = (text13.match(wordPattern) || []).length;
-        const isCodeLike = codeChars > text13.length * 0.05;
+        const codeChars = (text14.match(codePatterns) || []).length;
+        const whitespace = (text14.match(whitespacePattern) || []).length;
+        const words = (text14.match(wordPattern) || []).length;
+        const isCodeLike = codeChars > text14.length * 0.05;
         let charsPerToken;
         if (isCodeLike) {
           charsPerToken = 3.5;
-        } else if (whitespace > text13.length * 0.3) {
+        } else if (whitespace > text14.length * 0.3) {
           charsPerToken = 5;
         } else {
           charsPerToken = 4.5;
         }
         const wordBasedEstimate = words * 1.3;
-        const charBasedEstimate = text13.length / charsPerToken;
+        const charBasedEstimate = text14.length / charsPerToken;
         return Math.ceil((wordBasedEstimate + charBasedEstimate) / 2);
       }
       /**
@@ -3378,8 +3437,8 @@ var init_anthropic = __esm({
         const systemMsg = messages.find((m) => m.role === "system");
         if (!systemMsg) return void 0;
         if (typeof systemMsg.content === "string") return systemMsg.content;
-        const text13 = systemMsg.content.filter((b) => b.type === "text").map((b) => b.text).join("");
-        return text13 || void 0;
+        const text14 = systemMsg.content.filter((b) => b.type === "text").map((b) => b.text).join("");
+        return text14 || void 0;
       }
       /**
        * Convert messages to Anthropic format
@@ -3567,15 +3626,15 @@ var init_tool_call_normalizer = __esm({
         if (delta.function?.name) {
           builder.name = delta.function.name;
         }
-        const text13 = delta.function?.arguments ?? "";
-        if (!text13) return { started };
-        builder.arguments += text13;
+        const text14 = delta.function?.arguments ?? "";
+        if (!text14) return { started };
+        builder.arguments += text14;
         return {
           started,
           argumentDelta: {
             id: builder.id,
             name: builder.name,
-            text: text13
+            text: text14
           }
         };
       }
@@ -4164,23 +4223,23 @@ var init_openai = __esm({
        * For accurate counting, use the model's native tokenizer.
        * This heuristic provides a reasonable estimate without dependencies.
        */
-      countTokens(text13) {
-        if (!text13) return 0;
+      countTokens(text14) {
+        if (!text14) return 0;
         const codePatterns = /[{}[\]();=<>!&|+\-*/]/g;
         const whitespacePattern = /\s/g;
         const wordPattern = /\b\w+\b/g;
         const nonAsciiPattern = /[^\x00-\x7F]/g;
-        const codeChars = (text13.match(codePatterns) || []).length;
-        const whitespace = (text13.match(whitespacePattern) || []).length;
-        const words = (text13.match(wordPattern) || []).length;
-        const nonAscii = (text13.match(nonAsciiPattern) || []).length;
-        const isCodeLike = codeChars > text13.length * 0.05;
+        const codeChars = (text14.match(codePatterns) || []).length;
+        const whitespace = (text14.match(whitespacePattern) || []).length;
+        const words = (text14.match(wordPattern) || []).length;
+        const nonAscii = (text14.match(nonAsciiPattern) || []).length;
+        const isCodeLike = codeChars > text14.length * 0.05;
         const isLocal = this.isLocalModel();
         let charsPerToken;
         if (isLocal) {
           if (isCodeLike) {
             charsPerToken = 3.2;
-          } else if (nonAscii > text13.length * 0.1) {
+          } else if (nonAscii > text14.length * 0.1) {
             charsPerToken = 2;
           } else {
             charsPerToken = 3.5;
@@ -4188,7 +4247,7 @@ var init_openai = __esm({
         } else {
           if (isCodeLike) {
             charsPerToken = 3.3;
-          } else if (whitespace > text13.length * 0.3) {
+          } else if (whitespace > text14.length * 0.3) {
             charsPerToken = 4.5;
           } else {
             charsPerToken = 4;
@@ -4196,7 +4255,7 @@ var init_openai = __esm({
         }
         const tokensPerWord = isLocal ? 1.4 : 1.3;
         const wordBasedEstimate = words * tokensPerWord;
-        const charBasedEstimate = text13.length / charsPerToken;
+        const charBasedEstimate = text14.length / charsPerToken;
         const weight = isCodeLike ? 0.7 : 0.5;
         return Math.ceil(charBasedEstimate * weight + wordBasedEstimate * (1 - weight));
       }
@@ -4977,8 +5036,8 @@ var init_codex = __esm({
        * Count tokens in text (approximate)
        * Uses GPT-4 approximation: ~4 chars per token
        */
-      countTokens(text13) {
-        return Math.ceil(text13.length / 4);
+      countTokens(text14) {
+        return Math.ceil(text14.length / 4);
       }
       /**
        * Check if provider is available (has valid OAuth tokens)
@@ -5646,9 +5705,9 @@ var init_copilot2 = __esm({
       /**
        * Count tokens (approximate — Copilot models vary in tokenizer)
        */
-      countTokens(text13) {
-        if (!text13) return 0;
-        return Math.ceil(text13.length / 3.5);
+      countTokens(text14) {
+        if (!text14) return 0;
+        return Math.ceil(text14.length / 3.5);
       }
       /**
        * Get context window for the current model
@@ -5683,19 +5742,14 @@ var DEFAULT_MODEL5, CONTEXT_WINDOWS5, GeminiProvider;
 var init_gemini = __esm({
   "src/providers/gemini.ts"() {
     init_errors();
-    init_gcloud();
     DEFAULT_MODEL5 = "gemini-3.1-pro-preview";
     CONTEXT_WINDOWS5 = {
-      // Gemini 3.1 series (latest)
       "gemini-3.1-pro-preview": 1e6,
       "gemini-3.1-flash-lite-preview": 1e6,
-      // Gemini 3 series
       "gemini-3-flash-preview": 1e6,
-      // Gemini 2.5 series (production stable)
       "gemini-2.5-pro": 1048576,
       "gemini-2.5-flash": 1048576,
       "gemini-2.5-flash-lite": 1048576,
-      // Legacy
       "gemini-1.5-flash": 1e6,
       "gemini-1.5-pro": 2e6
     };
@@ -5704,131 +5758,56 @@ var init_gemini = __esm({
       name = "Google Gemini";
       client = null;
       config = {};
-      /**
-       * Initialize the provider
-       *
-       * Authentication priority:
-       * 1. API key passed in config (unless it's the ADC marker)
-       * 2. GEMINI_API_KEY environment variable
-       * 3. GOOGLE_API_KEY environment variable
-       * 4. Google Cloud ADC (gcloud auth application-default login)
-       */
       async initialize(config) {
         this.config = config;
-        const isADCMarker = config.apiKey === "__gcloud_adc__";
-        let apiKey = !isADCMarker && config.apiKey ? config.apiKey : process.env["GEMINI_API_KEY"] ?? process.env["GOOGLE_API_KEY"];
-        if (!apiKey || isADCMarker) {
-          try {
-            const adcToken = await getCachedADCToken();
-            if (adcToken) {
-              apiKey = adcToken.accessToken;
-              this.config.useADC = true;
-            }
-          } catch {
-          }
-        }
+        const apiKey = config.apiKey ?? process.env["GEMINI_API_KEY"] ?? process.env["GOOGLE_API_KEY"];
         if (!apiKey) {
           throw new ProviderError(
-            "Gemini API key not provided. Set GEMINI_API_KEY or run: gcloud auth application-default login",
+            "Gemini Developer API key not provided. Set GEMINI_API_KEY or GOOGLE_API_KEY.",
             { provider: this.id }
           );
         }
-        this.client = new GoogleGenerativeAI(apiKey);
-      }
-      /**
-       * Refresh ADC token if needed and reinitialize client
-       */
-      async refreshADCIfNeeded() {
-        if (!this.config.useADC) return;
-        try {
-          const adcToken = await getCachedADCToken();
-          if (adcToken) {
-            this.client = new GoogleGenerativeAI(adcToken.accessToken);
-          }
-        } catch {
-        }
+        this.client = new GoogleGenAI({ apiKey });
       }
-      /**
-       * Send a chat message
-       */
       async chat(messages, options) {
         this.ensureInitialized();
-        await this.refreshADCIfNeeded();
         try {
-          const model = this.client.getGenerativeModel({
-            model: options?.model ?? this.config.model ?? DEFAULT_MODEL5,
-            generationConfig: {
-              maxOutputTokens: options?.maxTokens ?? this.config.maxTokens ?? 8192,
-              temperature: options?.temperature ?? this.config.temperature ?? 0,
-              stopSequences: options?.stopSequences
-            },
-            systemInstruction: this.extractSystem(messages, options?.system)
+          const response = await this.client.models.generateContent({
+            model: this.getModel(options?.model),
+            contents: this.convertContents(messages),
+            config: this.buildConfig(messages, options)
           });
-          const { history, lastMessage } = this.convertMessages(messages);
-          const chat = model.startChat({ history });
-          const result = await chat.sendMessage(lastMessage);
-          return this.parseResponse(result);
+          return this.parseResponse(response, options?.model);
         } catch (error) {
           throw this.handleError(error);
         }
       }
-      /**
-       * Send a chat message with tool use
-       */
       async chatWithTools(messages, options) {
         this.ensureInitialized();
-        await this.refreshADCIfNeeded();
         try {
-          const tools = [
-            {
-              functionDeclarations: this.convertTools(options.tools)
-            }
-          ];
-          const model = this.client.getGenerativeModel({
-            model: options?.model ?? this.config.model ?? DEFAULT_MODEL5,
-            generationConfig: {
-              maxOutputTokens: options?.maxTokens ?? this.config.maxTokens ?? 8192,
-              temperature: options?.temperature ?? this.config.temperature ?? 0
-            },
-            systemInstruction: this.extractSystem(messages, options?.system),
-            tools,
-            toolConfig: {
-              functionCallingConfig: {
-                mode: this.convertToolChoice(options.toolChoice)
-              }
-            }
+          const response = await this.client.models.generateContent({
+            model: this.getModel(options.model),
+            contents: this.convertContents(messages),
+            config: this.buildConfig(messages, options, options.tools, options.toolChoice)
           });
-          const { history, lastMessage } = this.convertMessages(messages);
-          const chat = model.startChat({ history });
-          const result = await chat.sendMessage(lastMessage);
-          return this.parseResponseWithTools(result);
+          return this.parseResponseWithTools(response, options.model);
         } catch (error) {
           throw this.handleError(error);
         }
       }
-      /**
-       * Stream a chat response
-       */
       async *stream(messages, options) {
         this.ensureInitialized();
-        await this.refreshADCIfNeeded();
         try {
-          const model = this.client.getGenerativeModel({
-            model: options?.model ?? this.config.model ?? DEFAULT_MODEL5,
-            generationConfig: {
-              maxOutputTokens: options?.maxTokens ?? this.config.maxTokens ?? 8192,
-              temperature: options?.temperature ?? this.config.temperature ?? 0
-            },
-            systemInstruction: this.extractSystem(messages, options?.system)
+          const stream = await this.client.models.generateContentStream({
+            model: this.getModel(options?.model),
+            contents: this.convertContents(messages),
+            config: this.buildConfig(messages, options)
           });
-          const { history, lastMessage } = this.convertMessages(messages);
-          const chat = model.startChat({ history });
-          const result = await chat.sendMessageStream(lastMessage);
-          let streamStopReason;
-          for await (const chunk of result.stream) {
-            const text13 = chunk.text();
-            if (text13) {
-              yield { type: "text", text: text13 };
+          let streamStopReason = "end_turn";
+          for await (const chunk of stream) {
+            const text14 = chunk.text;
+            if (text14) {
+              yield { type: "text", text: text14 };
             }
             const finishReason = chunk.candidates?.[0]?.finishReason;
             if (finishReason) {
@@ -5840,116 +5819,76 @@ var init_gemini = __esm({
           throw this.handleError(error);
         }
       }
-      /**
-       * Stream a chat response with tool use
-       */
       async *streamWithTools(messages, options) {
         this.ensureInitialized();
-        await this.refreshADCIfNeeded();
         try {
-          const tools = [
-            {
-              functionDeclarations: this.convertTools(options.tools)
-            }
-          ];
-          const model = this.client.getGenerativeModel({
-            model: options?.model ?? this.config.model ?? DEFAULT_MODEL5,
-            generationConfig: {
-              maxOutputTokens: options?.maxTokens ?? this.config.maxTokens ?? 8192,
-              temperature: options?.temperature ?? this.config.temperature ?? 0
-            },
-            systemInstruction: this.extractSystem(messages, options?.system),
-            tools,
-            toolConfig: {
-              functionCallingConfig: {
-                mode: this.convertToolChoice(options.toolChoice)
-              }
-            }
+          const stream = await this.client.models.generateContentStream({
+            model: this.getModel(options.model),
+            contents: this.convertContents(messages),
+            config: this.buildConfig(messages, options, options.tools, options.toolChoice)
           });
-          const { history, lastMessage } = this.convertMessages(messages);
-          const chat = model.startChat({ history });
-          const result = await chat.sendMessageStream(lastMessage);
-          let streamStopReason;
-          let streamToolCallCounter = 0;
-          for await (const chunk of result.stream) {
-            const text13 = chunk.text();
-            if (text13) {
-              yield { type: "text", text: text13 };
+          let streamStopReason = "end_turn";
+          let fallbackToolCounter = 0;
+          const emittedToolIds = /* @__PURE__ */ new Set();
+          for await (const chunk of stream) {
+            const text14 = chunk.text;
+            if (text14) {
+              yield { type: "text", text: text14 };
+            }
+            const functionCalls = this.extractFunctionCalls(chunk);
+            for (const functionCall of functionCalls) {
+              const toolCallId = functionCall.id ?? `gemini_call_${++fallbackToolCounter}`;
+              if (emittedToolIds.has(toolCallId)) continue;
+              emittedToolIds.add(toolCallId);
+              const toolCall = {
+                id: toolCallId,
+                name: functionCall.name ?? "unknown_function",
+                input: functionCall.args ?? {}
+              };
+              yield {
+                type: "tool_use_start",
+                toolCall: {
+                  id: toolCall.id,
+                  name: toolCall.name
+                }
+              };
+              yield {
+                type: "tool_use_end",
+                toolCall
+              };
             }
             const finishReason = chunk.candidates?.[0]?.finishReason;
-            if (finishReason) {
+            if (functionCalls.length > 0) {
+              streamStopReason = "tool_use";
+            } else if (finishReason) {
               streamStopReason = this.mapFinishReason(finishReason);
             }
-            const candidate = chunk.candidates?.[0];
-            if (candidate?.content?.parts) {
-              for (const part of candidate.content.parts) {
-                if ("functionCall" in part && part.functionCall) {
-                  const funcCall = part.functionCall;
-                  streamToolCallCounter++;
-                  const toolCall = {
-                    id: `gemini_call_${streamToolCallCounter}`,
-                    name: funcCall.name,
-                    input: funcCall.args ?? {}
-                  };
-                  yield {
-                    type: "tool_use_start",
-                    toolCall: {
-                      id: toolCall.id,
-                      name: toolCall.name
-                    }
-                  };
-                  yield {
-                    type: "tool_use_end",
-                    toolCall
-                  };
-                }
-              }
-            }
           }
           yield { type: "done", stopReason: streamStopReason };
         } catch (error) {
           throw this.handleError(error);
         }
       }
-      /**
-       * Count tokens (approximate)
-       *
-       * Gemini uses a SentencePiece tokenizer. The average ratio varies:
-       * - English text: ~4 characters per token
-       * - Code: ~3.2 characters per token
-       * - Mixed content: ~3.5 characters per token
-       *
-       * Using 3.5 as the default provides a better estimate for typical
-       * coding agent workloads which mix code and natural language.
-       */
-      countTokens(text13) {
-        if (!text13) return 0;
-        return Math.ceil(text13.length / 3.5);
+      countTokens(text14) {
+        if (!text14) return 0;
+        return Math.ceil(text14.length / 3.5);
       }
-      /**
-       * Get context window size
-       */
       getContextWindow() {
         const model = this.config.model ?? DEFAULT_MODEL5;
         return CONTEXT_WINDOWS5[model] ?? 1e6;
       }
-      /**
-       * Check if provider is available
-       */
       async isAvailable() {
         if (!this.client) return false;
         try {
-          const modelName = this.config.model ?? DEFAULT_MODEL5;
-          const model = this.client.getGenerativeModel({ model: modelName });
-          await model.generateContent("hi");
+          await this.client.models.generateContent({
+            model: this.getModel(),
+            contents: "hi"
+          });
           return true;
         } catch {
           return false;
         }
       }
-      /**
-       * Ensure client is initialized
-       */
       ensureInitialized() {
         if (!this.client) {
           throw new ProviderError("Provider not initialized. Call initialize() first.", {
@@ -5957,70 +5896,62 @@ var init_gemini = __esm({
           });
         }
       }
-      /**
-       * Extract system prompt from messages array or options.
-       *
-       * convertMessages() skips system-role messages ("handled via systemInstruction"),
-       * but all callers forgot to also pass it via options.system. This helper bridges
-       * that gap — mirrors the same fix applied to AnthropicProvider.
-       */
+      getModel(model) {
+        return model ?? this.config.model ?? DEFAULT_MODEL5;
+      }
+      buildConfig(messages, options, tools, toolChoice) {
+        const config = {
+          maxOutputTokens: options?.maxTokens ?? this.config.maxTokens ?? 8192,
+          temperature: options?.temperature ?? this.config.temperature ?? 0,
+          stopSequences: options?.stopSequences,
+          systemInstruction: this.extractSystem(messages, options?.system)
+        };
+        if (tools && tools.length > 0) {
+          config.tools = [{ functionDeclarations: this.convertTools(tools) }];
+          config.toolConfig = {
+            functionCallingConfig: this.convertToolChoice(toolChoice)
+          };
+        }
+        return config;
+      }
       extractSystem(messages, optionsSystem) {
         if (optionsSystem !== void 0) return optionsSystem;
         const systemMsg = messages.find((m) => m.role === "system");
         if (!systemMsg) return void 0;
         if (typeof systemMsg.content === "string") return systemMsg.content;
-        const text13 = systemMsg.content.filter((b) => b.type === "text").map((b) => b.text).join("");
-        return text13 || void 0;
+        const text14 = systemMsg.content.filter((b) => b.type === "text").map((b) => b.text).join("");
+        return text14 || void 0;
       }
-      /**
-       * Convert messages to Gemini format
-       */
-      convertMessages(messages) {
+      convertContents(messages) {
         const toolNameByUseId = this.buildToolUseNameMap(messages);
         const conversation = messages.filter((m) => m.role !== "system");
-        const history = [];
-        let lastUserMessage = "";
-        for (let i = 0; i < conversation.length; i++) {
-          const msg = conversation[i];
-          const isLastMessage = i === conversation.length - 1;
+        const contents = [];
+        for (const msg of conversation) {
           if (msg.role === "user") {
             if (Array.isArray(msg.content) && msg.content[0]?.type === "tool_result") {
-              const functionResponses = [];
+              const parts = [];
               for (const block of msg.content) {
                 if (block.type === "tool_result") {
                   const toolResult = block;
-                  functionResponses.push({
+                  parts.push({
                     functionResponse: {
-                      // Gemini expects the function name in functionResponse.name.
-                      // Recover it from prior assistant tool_use blocks when possible.
+                      id: toolResult.tool_use_id,
                       name: toolNameByUseId.get(toolResult.tool_use_id) ?? toolResult.tool_use_id,
                       response: { result: toolResult.content }
                     }
                   });
                 }
               }
-              history.push({ role: "function", parts: functionResponses });
-              if (isLastMessage) {
-                lastUserMessage = "";
-              }
+              contents.push({ role: "user", parts });
             } else {
-              const parts = this.convertContent(msg.content);
-              if (isLastMessage) {
-                lastUserMessage = parts;
-              } else {
-                history.push({ role: "user", parts });
-              }
+              contents.push({ role: "user", parts: this.convertContent(msg.content) });
             }
           } else if (msg.role === "assistant") {
-            const parts = this.convertContent(msg.content);
-            history.push({ role: "model", parts });
+            contents.push({ role: "model", parts: this.convertContent(msg.content) });
           }
         }
-        return { history, lastMessage: lastUserMessage };
+        return contents.length > 0 ? contents : [{ role: "user", parts: [{ text: "" }] }];
       }
-      /**
-       * Build a map from tool_use IDs to function names from assistant history.
-       */
       buildToolUseNameMap(messages) {
         const map = /* @__PURE__ */ new Map();
         for (const msg of messages) {
@@ -6033,9 +5964,6 @@ var init_gemini = __esm({
         }
         return map;
       }
-      /**
-       * Convert content to Gemini parts
-       */
       convertContent(content) {
         if (typeof content === "string") {
           return [{ text: content }];
@@ -6045,27 +5973,26 @@ var init_gemini = __esm({
           if (block.type === "text") {
             parts.push({ text: block.text });
           } else if (block.type === "image") {
-            const imgBlock = block;
+            const image = block;
             parts.push({
               inlineData: {
-                data: imgBlock.source.data,
-                mimeType: imgBlock.source.media_type
+                data: image.source.data,
+                mimeType: image.source.media_type
               }
             });
           } else if (block.type === "tool_use") {
+            const toolUse = block;
             parts.push({
               functionCall: {
-                name: block.name,
-                args: block.input
+                id: toolUse.id,
+                name: toolUse.name,
+                args: toolUse.input
               }
             });
           }
         }
         return parts.length > 0 ? parts : [{ text: "" }];
       }
-      /**
-       * Convert tools to Gemini format
-       */
       convertTools(tools) {
         return tools.map((tool) => ({
           name: tool.name,
@@ -6073,72 +6000,58 @@ var init_gemini = __esm({
           parameters: tool.input_schema
         }));
       }
-      /**
-       * Convert tool choice to Gemini format
-       */
       convertToolChoice(choice) {
-        if (!choice || choice === "auto") return FunctionCallingMode.AUTO;
-        if (choice === "any") return FunctionCallingMode.ANY;
-        return FunctionCallingMode.AUTO;
+        if (!choice || choice === "auto") {
+          return { mode: FunctionCallingConfigMode.AUTO };
+        }
+        if (choice === "any") {
+          return { mode: FunctionCallingConfigMode.ANY };
+        }
+        return {
+          mode: FunctionCallingConfigMode.ANY,
+          allowedFunctionNames: [choice.name]
+        };
       }
-      /**
-       * Parse response from Gemini
-       */
-      parseResponse(result) {
-        const response = result.response;
-        const text13 = response.text();
+      extractFunctionCalls(response) {
+        if (response.functionCalls && response.functionCalls.length > 0) {
+          return response.functionCalls;
+        }
+        const candidate = response.candidates?.[0];
+        const parts = candidate?.content?.parts ?? [];
+        return parts.filter((part) => !!part.functionCall).map((part) => part.functionCall).filter(Boolean);
+      }
+      parseResponse(response, model) {
         const usage = response.usageMetadata;
         return {
           id: `gemini-${Date.now()}`,
-          content: text13,
+          content: response.text ?? "",
           stopReason: this.mapFinishReason(response.candidates?.[0]?.finishReason),
           usage: {
             inputTokens: usage?.promptTokenCount ?? 0,
             outputTokens: usage?.candidatesTokenCount ?? 0
           },
-          model: this.config.model ?? DEFAULT_MODEL5
+          model: this.getModel(model)
         };
       }
-      /**
-       * Parse response with tool calls from Gemini
-       */
-      parseResponseWithTools(result) {
-        const response = result.response;
-        const candidate = response.candidates?.[0];
+      parseResponseWithTools(response, model) {
         const usage = response.usageMetadata;
-        let textContent = "";
-        const toolCalls = [];
-        if (candidate?.content?.parts) {
-          let toolIndex = 0;
-          for (const part of candidate.content.parts) {
-            if ("text" in part && part.text) {
-              textContent += part.text;
-            }
-            if ("functionCall" in part && part.functionCall) {
-              toolIndex++;
-              toolCalls.push({
-                id: `gemini_call_${toolIndex}`,
-                name: part.functionCall.name,
-                input: part.functionCall.args ?? {}
-              });
-            }
-          }
-        }
+        const toolCalls = this.extractFunctionCalls(response).map((functionCall, index) => ({
+          id: functionCall.id ?? `gemini_call_${index + 1}`,
+          name: functionCall.name ?? "unknown_function",
+          input: functionCall.args ?? {}
+        }));
         return {
           id: `gemini-${Date.now()}`,
-          content: textContent,
-          stopReason: toolCalls.length > 0 ? "tool_use" : this.mapFinishReason(candidate?.finishReason),
+          content: response.text ?? "",
+          stopReason: toolCalls.length > 0 ? "tool_use" : this.mapFinishReason(response.candidates?.[0]?.finishReason),
           usage: {
             inputTokens: usage?.promptTokenCount ?? 0,
             outputTokens: usage?.candidatesTokenCount ?? 0
           },
-          model: this.config.model ?? DEFAULT_MODEL5,
+          model: this.getModel(model),
           toolCalls
         };
       }
-      /**
-       * Map finish reason to our format
-       */
       mapFinishReason(reason) {
         switch (reason) {
           case "STOP":
@@ -6153,9 +6066,6 @@ var init_gemini = __esm({
             return "end_turn";
         }
       }
-      /**
-       * Handle API errors
-       */
       handleError(error) {
         const message = error instanceof Error ? error.message : String(error);
         const msg = message.toLowerCase();
@@ -6176,6 +6086,436 @@ var init_gemini = __esm({
   }
 });
 
+// src/providers/vertex.ts
+function createVertexProvider(config) {
+  const provider = new VertexProvider();
+  if (config) {
+    provider.initialize(config).catch(() => {
+    });
+  }
+  return provider;
+}
+var DEFAULT_MODEL6, DEFAULT_BASE_URL, DEFAULT_LOCATION, CONTEXT_WINDOWS6, VertexProvider;
+var init_vertex = __esm({
+  "src/providers/vertex.ts"() {
+    init_errors();
+    init_gcloud();
+    init_retry();
+    DEFAULT_MODEL6 = "gemini-2.5-pro";
+    DEFAULT_BASE_URL = "https://aiplatform.googleapis.com/v1";
+    DEFAULT_LOCATION = "global";
+    CONTEXT_WINDOWS6 = {
+      "gemini-2.5-pro": 1048576,
+      "gemini-2.5-flash": 1048576,
+      "gemini-2.5-flash-lite": 1048576,
+      "gemini-2.0-flash-001": 1048576,
+      "gemini-2.0-flash-lite-001": 1048576
+    };
+    VertexProvider = class {
+      id = "vertex";
+      name = "Google Vertex AI Gemini";
+      config = {};
+      project = "";
+      location = DEFAULT_LOCATION;
+      retryConfig = DEFAULT_RETRY_CONFIG;
+      async initialize(config) {
+        this.config = config;
+        this.project = config.project ?? process.env["VERTEX_PROJECT"] ?? process.env["GOOGLE_CLOUD_PROJECT"] ?? process.env["GCLOUD_PROJECT"] ?? "";
+        this.location = config.location ?? process.env["VERTEX_LOCATION"] ?? process.env["GOOGLE_CLOUD_LOCATION"] ?? DEFAULT_LOCATION;
+        if (!this.project.trim()) {
+          throw new ProviderError(
+            "Vertex AI project not configured. Set provider.project, VERTEX_PROJECT, or GOOGLE_CLOUD_PROJECT.",
+            { provider: this.id }
+          );
+        }
+        const token = await getCachedADCToken();
+        if (!token) {
+          throw new ProviderError(
+            "Vertex AI ADC is not configured. Run `gcloud auth application-default login` manually, then retry.",
+            { provider: this.id }
+          );
+        }
+      }
+      async chat(messages, options) {
+        this.ensureInitialized();
+        return withRetry(async () => {
+          const response = await this.generateContent(messages, options);
+          return this.parseResponse(response, options?.model);
+        }, this.retryConfig);
+      }
+      async chatWithTools(messages, options) {
+        this.ensureInitialized();
+        return withRetry(async () => {
+          const response = await this.generateContent(
+            messages,
+            options,
+            options.tools,
+            options.toolChoice
+          );
+          return this.parseResponseWithTools(response, options.model);
+        }, this.retryConfig);
+      }
+      async *stream(messages, options) {
+        this.ensureInitialized();
+        const stream = await this.streamGenerateContent(messages, options);
+        let stopReason = "end_turn";
+        for await (const chunk of stream) {
+          const candidate = chunk.candidates?.[0];
+          const parts = candidate?.content?.parts ?? [];
+          for (const part of parts) {
+            if (part.text) {
+              yield { type: "text", text: part.text };
+            }
+          }
+          stopReason = this.mapFinishReason(candidate?.finishReason);
+        }
+        yield { type: "done", stopReason };
+      }
+      async *streamWithTools(messages, options) {
+        this.ensureInitialized();
+        const stream = await this.streamGenerateContent(
+          messages,
+          options,
+          options.tools,
+          options.toolChoice
+        );
+        let stopReason = "end_turn";
+        let streamToolCallCounter = 0;
+        for await (const chunk of stream) {
+          const candidate = chunk.candidates?.[0];
+          const parts = candidate?.content?.parts ?? [];
+          for (const part of parts) {
+            if (part.text) {
+              yield { type: "text", text: part.text };
+            }
+            if (part.functionCall) {
+              streamToolCallCounter++;
+              yield {
+                type: "tool_use_start",
+                toolCall: {
+                  id: `vertex_call_${streamToolCallCounter}`,
+                  name: part.functionCall.name,
+                  input: part.functionCall.args ?? {}
+                }
+              };
+              yield {
+                type: "tool_use_end",
+                toolCall: {
+                  id: `vertex_call_${streamToolCallCounter}`,
+                  name: part.functionCall.name,
+                  input: part.functionCall.args ?? {}
+                }
+              };
+            }
+          }
+          stopReason = parts.some((part) => part.functionCall) ? "tool_use" : this.mapFinishReason(candidate?.finishReason);
+        }
+        yield { type: "done", stopReason };
+      }
+      countTokens(text14) {
+        return Math.ceil(text14.length / 4);
+      }
+      getContextWindow() {
+        return CONTEXT_WINDOWS6[this.config.model ?? DEFAULT_MODEL6] ?? 1048576;
+      }
+      async isAvailable() {
+        try {
+          await this.generateContent([{ role: "user", content: "hi" }], { maxTokens: 8 });
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      ensureInitialized() {
+        if (!this.project) {
+          throw new ProviderError("Provider not initialized. Call initialize() first.", {
+            provider: this.id
+          });
+        }
+      }
+      getModel(model) {
+        return model ?? this.config.model ?? DEFAULT_MODEL6;
+      }
+      getResolvedBaseUrl() {
+        if (this.config.baseUrl && this.config.baseUrl.trim()) {
+          return this.config.baseUrl;
+        }
+        if (this.location === DEFAULT_LOCATION) {
+          return DEFAULT_BASE_URL;
+        }
+        return `https://${encodeURIComponent(this.location)}-aiplatform.googleapis.com/v1`;
+      }
+      buildEndpoint(model, stream = false) {
+        const action = stream ? "streamGenerateContent?alt=sse" : "generateContent";
+        return `${this.getResolvedBaseUrl()}/projects/${encodeURIComponent(this.project)}/locations/${encodeURIComponent(this.location)}/publishers/google/models/${encodeURIComponent(this.getModel(model))}:${action}`;
+      }
+      async getHeaders() {
+        const token = await getCachedADCToken();
+        if (!token) {
+          throw new ProviderError(
+            "Vertex AI ADC token is unavailable. Re-authenticate with gcloud and retry.",
+            { provider: this.id }
+          );
+        }
+        return {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${token.accessToken}`,
+          "x-goog-user-project": this.project
+        };
+      }
+      extractSystem(messages, optionsSystem) {
+        if (optionsSystem !== void 0) return optionsSystem;
+        const systemMsg = messages.find((m) => m.role === "system");
+        if (!systemMsg) return void 0;
+        if (typeof systemMsg.content === "string") return systemMsg.content;
+        const text14 = systemMsg.content.filter((b) => b.type === "text").map((b) => b.text).join("");
+        return text14 || void 0;
+      }
+      buildToolUseNameMap(messages) {
+        const map = /* @__PURE__ */ new Map();
+        for (const msg of messages) {
+          if (msg.role !== "assistant" || !Array.isArray(msg.content)) continue;
+          for (const block of msg.content) {
+            if (block.type === "tool_use") {
+              map.set(block.id, block.name);
+            }
+          }
+        }
+        return map;
+      }
+      convertContents(messages) {
+        const toolNameByUseId = this.buildToolUseNameMap(messages);
+        const conversation = messages.filter((m) => m.role !== "system");
+        const contents = [];
+        for (let i = 0; i < conversation.length; i++) {
+          const msg = conversation[i];
+          if (msg.role === "user") {
+            if (Array.isArray(msg.content) && msg.content[0]?.type === "tool_result") {
+              const functionResponses = [];
+              for (const block of msg.content) {
+                if (block.type === "tool_result") {
+                  const toolResult = block;
+                  functionResponses.push({
+                    functionResponse: {
+                      name: toolNameByUseId.get(toolResult.tool_use_id) ?? toolResult.tool_use_id,
+                      response: { result: toolResult.content }
+                    }
+                  });
+                }
+              }
+              contents.push({ role: "user", parts: functionResponses });
+            } else {
+              contents.push({ role: "user", parts: this.convertContent(msg.content) });
+            }
+          } else if (msg.role === "assistant") {
+            contents.push({ role: "model", parts: this.convertContent(msg.content) });
+          }
+        }
+        return contents.length > 0 ? contents : [{ role: "user", parts: [{ text: "" }] }];
+      }
+      convertContent(content) {
+        if (typeof content === "string") return [{ text: content }];
+        const parts = [];
+        for (const block of content) {
+          if (block.type === "text") {
+            parts.push({ text: block.text });
+          } else if (block.type === "image") {
+            const image = block;
+            parts.push({
+              inlineData: {
+                data: image.source.data,
+                mimeType: image.source.media_type
+              }
+            });
+          } else if (block.type === "tool_use") {
+            const toolUse = block;
+            parts.push({
+              functionCall: {
+                name: toolUse.name,
+                args: toolUse.input
+              }
+            });
+          }
+        }
+        return parts.length > 0 ? parts : [{ text: "" }];
+      }
+      convertTools(tools) {
+        return [
+          {
+            functionDeclarations: tools.map((tool) => ({
+              name: tool.name,
+              description: tool.description,
+              parameters: tool.input_schema
+            }))
+          }
+        ];
+      }
+      convertToolChoice(choice) {
+        if (!choice || choice === "auto") {
+          return { functionCallingConfig: { mode: "AUTO" } };
+        }
+        if (choice === "any") {
+          return { functionCallingConfig: { mode: "ANY" } };
+        }
+        return { functionCallingConfig: { mode: "ANY", allowedFunctionNames: [choice.name] } };
+      }
+      buildRequestBody(messages, options, tools, toolChoice) {
+        const body = {
+          contents: this.convertContents(messages),
+          generationConfig: {
+            maxOutputTokens: options?.maxTokens ?? this.config.maxTokens ?? 8192,
+            temperature: options?.temperature ?? this.config.temperature ?? 0,
+            stopSequences: options?.stopSequences
+          }
+        };
+        const systemInstruction = this.extractSystem(messages, options?.system);
+        if (systemInstruction) {
+          body["systemInstruction"] = {
+            parts: [{ text: systemInstruction }]
+          };
+        }
+        if (tools && tools.length > 0) {
+          body["tools"] = this.convertTools(tools);
+          const convertedChoice = this.convertToolChoice(toolChoice);
+          if (convertedChoice) {
+            body["toolConfig"] = convertedChoice;
+          }
+        }
+        return body;
+      }
+      async generateContent(messages, options, tools, toolChoice) {
+        const response = await fetch(this.buildEndpoint(options?.model), {
+          method: "POST",
+          headers: await this.getHeaders(),
+          body: JSON.stringify(this.buildRequestBody(messages, options, tools, toolChoice)),
+          signal: options?.signal
+        });
+        if (!response.ok) {
+          throw await this.buildHttpError(response);
+        }
+        const data = await response.json();
+        if (data.error?.message) {
+          throw new ProviderError(data.error.message, {
+            provider: this.id,
+            statusCode: data.error.code
+          });
+        }
+        return data;
+      }
+      async *streamGenerateContent(messages, options, tools, toolChoice) {
+        const response = await fetch(this.buildEndpoint(options?.model, true), {
+          method: "POST",
+          headers: await this.getHeaders(),
+          body: JSON.stringify(this.buildRequestBody(messages, options, tools, toolChoice)),
+          signal: options?.signal
+        });
+        if (!response.ok) {
+          throw await this.buildHttpError(response);
+        }
+        if (!response.body) {
+          throw new ProviderError("Vertex AI streaming response body is empty.", {
+            provider: this.id
+          });
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        while (true) {
+          const { value, done } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          while (true) {
+            const eventBoundary = buffer.indexOf("\n\n");
+            if (eventBoundary === -1) break;
+            const rawEvent = buffer.slice(0, eventBoundary);
+            buffer = buffer.slice(eventBoundary + 2);
+            const dataLines = rawEvent.split("\n").filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trim()).filter(Boolean);
+            for (const line of dataLines) {
+              if (line === "[DONE]") return;
+              yield JSON.parse(line);
+            }
+          }
+        }
+        const trailing = buffer.trim();
+        if (trailing.startsWith("data:")) {
+          const line = trailing.slice(5).trim();
+          if (line && line !== "[DONE]") {
+            yield JSON.parse(line);
+          }
+        }
+      }
+      parseResponse(response, model) {
+        const candidate = response.candidates?.[0];
+        const text14 = (candidate?.content?.parts ?? []).filter((part) => part.text).map((part) => part.text).join("");
+        return {
+          id: `vertex-${Date.now()}`,
+          content: text14,
+          stopReason: this.mapFinishReason(candidate?.finishReason),
+          usage: {
+            inputTokens: response.usageMetadata?.promptTokenCount ?? 0,
+            outputTokens: response.usageMetadata?.candidatesTokenCount ?? 0
+          },
+          model: this.getModel(model)
+        };
+      }
+      parseResponseWithTools(response, model) {
+        const candidate = response.candidates?.[0];
+        const parts = candidate?.content?.parts ?? [];
+        const toolCalls = [];
+        let textContent = "";
+        let toolIndex = 0;
+        for (const part of parts) {
+          if (part.text) {
+            textContent += part.text;
+          }
+          if (part.functionCall) {
+            toolIndex++;
+            toolCalls.push({
+              id: `vertex_call_${toolIndex}`,
+              name: part.functionCall.name,
+              input: part.functionCall.args ?? {}
+            });
+          }
+        }
+        return {
+          id: `vertex-${Date.now()}`,
+          content: textContent,
+          stopReason: toolCalls.length > 0 ? "tool_use" : this.mapFinishReason(candidate?.finishReason),
+          usage: {
+            inputTokens: response.usageMetadata?.promptTokenCount ?? 0,
+            outputTokens: response.usageMetadata?.candidatesTokenCount ?? 0
+          },
+          model: this.getModel(model),
+          toolCalls
+        };
+      }
+      mapFinishReason(reason) {
+        switch (reason) {
+          case "STOP":
+            return "end_turn";
+          case "MAX_TOKENS":
+            return "max_tokens";
+          case "SAFETY":
+          case "RECITATION":
+          case "OTHER":
+            return "stop_sequence";
+          default:
+            return "end_turn";
+        }
+      }
+      async buildHttpError(response) {
+        const body = await response.text();
+        const retryable = response.status === 429 || response.status >= 500;
+        return new ProviderError(`Vertex AI error: ${response.status} - ${body}`, {
+          provider: this.id,
+          statusCode: response.status,
+          retryable
+        });
+      }
+    };
+  }
+});
+
 // src/providers/pricing.ts
 function estimateCost(model, inputTokens, outputTokens, provider) {
   const pricing = MODEL_PRICING[model] ?? (provider ? DEFAULT_PRICING[provider] : DEFAULT_PRICING.anthropic);
@@ -6269,6 +6609,7 @@ var init_pricing = __esm({
       codex: { inputPerMillion: 0, outputPerMillion: 0, contextWindow: 128e3 },
       // ChatGPT Plus/Pro subscription
       gemini: { inputPerMillion: 0.1, outputPerMillion: 0.4, contextWindow: 1e6 },
+      vertex: { inputPerMillion: 0.1, outputPerMillion: 0.4, contextWindow: 1048576 },
       kimi: { inputPerMillion: 1.2, outputPerMillion: 1.2, contextWindow: 8192 },
       "kimi-code": { inputPerMillion: 0, outputPerMillion: 0, contextWindow: 131072 },
       // Included in subscription
@@ -6591,9 +6932,9 @@ var init_fallback = __esm({
        * @param text - Text to count tokens for
        * @returns Estimated token count
        */
-      countTokens(text13) {
+      countTokens(text14) {
         const provider = this.getCurrentProvider();
-        return provider.provider.countTokens(text13);
+        return provider.provider.countTokens(text14);
       }
       /**
        * Get context window from current provider
@@ -6809,8 +7150,8 @@ var init_resilient = __esm({
       async *streamWithTools(messages, options) {
         yield* this.streamWithPolicy(() => this.provider.streamWithTools(messages, options));
       }
-      countTokens(text13) {
-        return this.provider.countTokens(text13);
+      countTokens(text14) {
+        return this.provider.countTokens(text14);
       }
       getContextWindow() {
         return this.provider.getContextWindow();
@@ -6877,6 +7218,7 @@ __export(providers_exports, {
   OpenAIProvider: () => OpenAIProvider,
   ProviderFallback: () => ProviderFallback,
   ResilientProvider: () => ResilientProvider,
+  VertexProvider: () => VertexProvider,
   createAnthropicProvider: () => createAnthropicProvider,
   createCircuitBreaker: () => createCircuitBreaker,
   createCodexProvider: () => createCodexProvider,
@@ -6889,6 +7231,7 @@ __export(providers_exports, {
   createProviderFallback: () => createProviderFallback,
   createResilientProvider: () => createResilientProvider,
   createRetryableMethod: () => createRetryableMethod,
+  createVertexProvider: () => createVertexProvider,
   estimateCost: () => estimateCost,
   formatCost: () => formatCost,
   getDefaultProvider: () => getDefaultProvider2,
@@ -6905,6 +7248,11 @@ function normalizeProviderModel(model) {
   const trimmed = model.trim();
   return trimmed.length > 0 ? trimmed : void 0;
 }
+function normalizeOptional(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
 async function createProvider(type, config = {}) {
   let provider;
   const mergedConfig = {
@@ -6913,7 +7261,11 @@ async function createProvider(type, config = {}) {
     model: normalizeProviderModel(config.model) ?? getDefaultModel(type),
     maxTokens: config.maxTokens,
     temperature: config.temperature,
-    timeout: config.timeout
+    timeout: config.timeout,
+    project: normalizeOptional(config.project) ?? (type === "vertex" ? normalizeOptional(
+      process.env["VERTEX_PROJECT"] ?? process.env["GOOGLE_CLOUD_PROJECT"] ?? process.env["GCLOUD_PROJECT"]
+    ) : void 0),
+    location: normalizeOptional(config.location) ?? (type === "vertex" ? normalizeOptional(process.env["VERTEX_LOCATION"] ?? process.env["GOOGLE_CLOUD_LOCATION"]) : void 0)
   };
   switch (type) {
     case "anthropic":
@@ -6931,6 +7283,9 @@ async function createProvider(type, config = {}) {
     case "gemini":
       provider = new GeminiProvider();
       break;
+    case "vertex":
+      provider = new VertexProvider();
+      break;
     case "kimi":
       provider = createKimiProvider(mergedConfig);
       break;
@@ -7014,6 +7369,11 @@ function listProviders() {
       })()
     },
     { id: "gemini", name: "Google Gemini", configured: !!getApiKey("gemini") },
+    {
+      id: "vertex",
+      name: "Google Vertex AI",
+      configured: !!(process.env["VERTEX_PROJECT"] ?? process.env["GOOGLE_CLOUD_PROJECT"] ?? process.env["GCLOUD_PROJECT"])
+    },
     { id: "kimi", name: "Kimi (Moonshot API)", configured: !!getApiKey("kimi") },
     { id: "kimi-code", name: "Kimi Code (Subscription)", configured: !!getApiKey("kimi-code") },
     { id: "groq", name: "Groq", configured: !!getApiKey("groq") },
@@ -7034,6 +7394,7 @@ var init_providers = __esm({
     init_codex();
     init_copilot2();
     init_gemini();
+    init_vertex();
     init_retry();
     init_pricing();
     init_circuit_breaker();
@@ -7043,6 +7404,7 @@ var init_providers = __esm({
     init_anthropic();
     init_openai();
     init_gemini();
+    init_vertex();
     init_codex();
     init_copilot2();
     init_errors();
@@ -8102,8 +8464,8 @@ function tokenOverlap(queryTokens, targetTokens) {
   }
   return hits / queryTokens.length;
 }
-function tokenize(text13) {
-  return text13.toLowerCase().replace(/[^a-z0-9\s-]/g, " ").split(/[\s-]+/).filter((word) => word.length > 1 && !STOP_WORDS.has(word)).map(stem);
+function tokenize(text14) {
+  return text14.toLowerCase().replace(/[^a-z0-9\s-]/g, " ").split(/[\s-]+/).filter((word) => word.length > 1 && !STOP_WORDS.has(word)).map(stem);
 }
 function stem(word) {
   if (word.length < 4) return word;
@@ -9200,8 +9562,8 @@ ${tail}`
       estimateTokens(messages, provider) {
         let total = 0;
         for (const message of messages) {
-          const text13 = this.extractTextContent(message.content);
-          total += provider.countTokens(text13);
+          const text14 = this.extractTextContent(message.content);
+          total += provider.countTokens(text14);
         }
         return total;
       }
@@ -18291,15 +18653,15 @@ ${message}
           let stdoutBuffer = "";
           let stderrBuffer = "";
           subprocess.stdout?.on("data", (chunk) => {
-            const text13 = chunk.toString();
-            stdoutBuffer += text13;
-            process.stdout.write(text13);
+            const text14 = chunk.toString();
+            stdoutBuffer += text14;
+            process.stdout.write(text14);
             heartbeat.activity();
           });
           subprocess.stderr?.on("data", (chunk) => {
-            const text13 = chunk.toString();
-            stderrBuffer += text13;
-            process.stderr.write(text13);
+            const text14 = chunk.toString();
+            stderrBuffer += text14;
+            process.stderr.write(text14);
             heartbeat.activity();
           });
           const result = await subprocess;
@@ -19967,11 +20329,11 @@ async function runMergeRelease(ctx) {
   }
   const tagName = ctx.newVersion ? `v${ctx.newVersion}` : void 0;
   const mergeMsg = tagName ? `Merge PR #${ctx.prNumber} to ${ctx.profile.defaultBranch} and create release ${tagName}?` : `Merge PR #${ctx.prNumber} to ${ctx.profile.defaultBranch}?`;
-  const confirm23 = await p26.confirm({
+  const confirm22 = await p26.confirm({
     message: mergeMsg,
     initialValue: true
   });
-  if (p26.isCancel(confirm23) || !confirm23) {
+  if (p26.isCancel(confirm22) || !confirm22) {
     return {
       step: "merge-release",
       status: "skipped",
@@ -22756,22 +23118,22 @@ var init_types7 = __esm({
 });
 
 // src/cli/repl/interruptions/classifier.ts
-function matchPatterns(text13, patterns) {
+function matchPatterns(text14, patterns) {
   for (let i = 0; i < patterns.length; i++) {
-    if (patterns[i].test(text13)) {
+    if (patterns[i].test(text14)) {
       return 1 - i * 0.1;
     }
   }
   return 0;
 }
 function classifyInterruption(message) {
-  const text13 = message.text;
-  const abortConf = matchPatterns(text13, ABORT_PATTERNS);
-  const modifyConf = matchPatterns(text13, MODIFY_PATTERNS);
-  const correctConf = matchPatterns(text13, CORRECT_PATTERNS);
+  const text14 = message.text;
+  const abortConf = matchPatterns(text14, ABORT_PATTERNS);
+  const modifyConf = matchPatterns(text14, MODIFY_PATTERNS);
+  const correctConf = matchPatterns(text14, CORRECT_PATTERNS);
   if (abortConf > 0 && abortConf >= modifyConf && abortConf >= correctConf) {
     return {
-      text: text13,
+      text: text14,
       type: "abort" /* Abort */,
       confidence: Math.min(1, abortConf),
       timestamp: message.timestamp
@@ -22779,7 +23141,7 @@ function classifyInterruption(message) {
   }
   if (modifyConf > 0 && modifyConf >= correctConf) {
     return {
-      text: text13,
+      text: text14,
       type: "modify" /* Modify */,
       confidence: Math.min(1, modifyConf),
       timestamp: message.timestamp
@@ -22787,14 +23149,14 @@ function classifyInterruption(message) {
   }
   if (correctConf > 0) {
     return {
-      text: text13,
+      text: text14,
       type: "correct" /* Correct */,
       confidence: Math.min(1, correctConf),
       timestamp: message.timestamp
     };
   }
   return {
-    text: text13,
+    text: text14,
     type: "info" /* Info */,
     confidence: 0.5,
     timestamp: message.timestamp
@@ -25302,10 +25664,10 @@ function inferTargetUsers(session) {
     /(?:for|by)\s+(developers?|users?|administrators?|customers?)/gi,
     /(developers?|users?|administrators?|customers?)\s+(?:can|will|should)/gi
   ];
-  const text13 = session.requirements.map((r) => r.description).join(" ");
+  const text14 = session.requirements.map((r) => r.description).join(" ");
   for (const pattern of userPatterns) {
     let match;
-    while ((match = pattern.exec(text13)) !== null) {
+    while ((match = pattern.exec(text14)) !== null) {
       const user = match[1]?.toLowerCase();
       if (user && !users.includes(user)) {
         users.push(user);
@@ -25318,13 +25680,13 @@ function inferTargetUsers(session) {
   return users;
 }
 function inferProjectType(session) {
-  const text13 = session.initialInput.toLowerCase();
-  if (text13.includes("cli") || text13.includes("command line")) return "cli";
-  if (text13.includes("api") || text13.includes("rest") || text13.includes("graphql")) return "api";
-  if (text13.includes("web app") || text13.includes("frontend")) return "web_app";
-  if (text13.includes("library") || text13.includes("package")) return "library";
-  if (text13.includes("service") || text13.includes("daemon")) return "service";
-  if (text13.includes("full stack") || text13.includes("fullstack")) return "full_stack";
+  const text14 = session.initialInput.toLowerCase();
+  if (text14.includes("cli") || text14.includes("command line")) return "cli";
+  if (text14.includes("api") || text14.includes("rest") || text14.includes("graphql")) return "api";
+  if (text14.includes("web app") || text14.includes("frontend")) return "web_app";
+  if (text14.includes("library") || text14.includes("package")) return "library";
+  if (text14.includes("service") || text14.includes("daemon")) return "service";
+  if (text14.includes("full stack") || text14.includes("fullstack")) return "full_stack";
   return "unknown";
 }
 function assessComplexity(session) {
@@ -28991,16 +29353,13 @@ var PROVIDER_DEFINITIONS = {
     id: "gemini",
     name: "Google Gemini",
     emoji: "\u{1F535}",
-    description: "Gemini 3 and 2.5 models",
+    description: "Gemini Developer API via AI Studio API key",
     envVar: "GEMINI_API_KEY",
     apiKeyUrl: "https://aistudio.google.com/apikey",
     docsUrl: "https://ai.google.dev/gemini-api/docs",
     baseUrl: "https://generativelanguage.googleapis.com/v1beta",
     supportsCustomModels: true,
     openaiCompatible: false,
-    supportsGcloudADC: true,
-    // Supports gcloud auth application-default login
-    // NOTE: OAuth removed - Google's client ID is restricted to official apps only
     paymentType: "freemium",
     features: {
       streaming: true,
@@ -29055,6 +29414,63 @@ var PROVIDER_DEFINITIONS = {
       }
     ]
   },
+  vertex: {
+    id: "vertex",
+    name: "Google Vertex AI Gemini",
+    emoji: "\u2601\uFE0F",
+    description: "Gemini on Vertex AI with GCP project, IAM and ADC",
+    envVar: "VERTEX_PROJECT",
+    apiKeyUrl: "https://console.cloud.google.com/vertex-ai",
+    docsUrl: "https://cloud.google.com/vertex-ai/generative-ai/docs/start/quickstart",
+    baseUrl: "https://aiplatform.googleapis.com/v1",
+    supportsCustomModels: true,
+    openaiCompatible: false,
+    supportsGcloudADC: true,
+    paymentType: "api",
+    features: {
+      streaming: true,
+      functionCalling: true,
+      vision: true
+    },
+    models: [
+      {
+        id: "gemini-2.5-pro",
+        name: "Gemini 2.5 Pro",
+        description: "Recommended Vertex model for coding and complex reasoning",
+        contextWindow: 1048576,
+        maxOutputTokens: 65536,
+        recommended: true
+      },
+      {
+        id: "gemini-2.5-flash",
+        name: "Gemini 2.5 Flash",
+        description: "Faster Vertex model with 1M context",
+        contextWindow: 1048576,
+        maxOutputTokens: 65536
+      },
+      {
+        id: "gemini-2.5-flash-lite",
+        name: "Gemini 2.5 Flash-Lite",
+        description: "Lowest-cost Vertex option",
+        contextWindow: 1048576,
+        maxOutputTokens: 65536
+      },
+      {
+        id: "gemini-2.0-flash-001",
+        name: "Gemini 2.0 Flash 001",
+        description: "Broadly available Vertex model",
+        contextWindow: 1048576,
+        maxOutputTokens: 8192
+      },
+      {
+        id: "gemini-2.0-flash-lite-001",
+        name: "Gemini 2.0 Flash-Lite 001",
+        description: "Lightweight Vertex fallback",
+        contextWindow: 1048576,
+        maxOutputTokens: 8192
+      }
+    ]
+  },
   // Kimi/Moonshot - OpenAI compatible
   kimi: {
     id: "kimi",
@@ -29681,6 +30097,9 @@ function getConfiguredProviders() {
     if (p45.id === "lmstudio" || p45.id === "ollama") {
       return hasLocalProviderConfig(p45.id);
     }
+    if (p45.id === "vertex") {
+      return !!(process.env["VERTEX_PROJECT"] ?? process.env["GOOGLE_CLOUD_PROJECT"] ?? process.env["GCLOUD_PROJECT"]);
+    }
     return !!process.env[p45.envVar];
   });
 }
@@ -30032,11 +30451,11 @@ async function runRemoveServer(name, options) {
     process.exit(1);
   }
   if (!options.yes) {
-    const confirm23 = await p26.confirm({
+    const confirm22 = await p26.confirm({
       message: `Remove server '${name}'?`,
       initialValue: false
     });
-    if (p26.isCancel(confirm23) || !confirm23) {
+    if (p26.isCancel(confirm22) || !confirm22) {
       p26.outro("Cancelled");
       return;
     }
@@ -30308,10 +30727,10 @@ async function runRemove(name, options) {
     return;
   }
   if (!options.yes) {
-    const confirm23 = await p26.confirm({
+    const confirm22 = await p26.confirm({
       message: `Remove skill "${name}" from ${targetDir}?`
     });
-    if (p26.isCancel(confirm23) || !confirm23) {
+    if (p26.isCancel(confirm22) || !confirm22) {
       p26.log.info("Cancelled.");
       p26.outro("");
       return;
@@ -30816,8 +31235,8 @@ ${suggestionsHtml}
     return filePath;
   }
   // ── Private helpers ───────────────────────────────────────────────────────
-  htmlEscape(text13) {
-    return text13.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+  htmlEscape(text14) {
+    return text14.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
   }
   markdownIssue(issue) {
     const severity = issue.severity === "critical" ? "\u{1F534}" : issue.severity === "major" ? "\u{1F7E1}" : "\u{1F535}";
@@ -31339,12 +31758,12 @@ Return only JSON: { "score": <number 1-10>, "reasoning": "<brief explanation>" }
   }
   return classifyFeatureHeuristic(feature);
 }
-function extractJsonScore(text13) {
+function extractJsonScore(text14) {
   try {
-    const stripped = text13.replace(/^```(?:json)?\s*\n?/, "").replace(/\n?```\s*$/, "").trim();
+    const stripped = text14.replace(/^```(?:json)?\s*\n?/, "").replace(/\n?```\s*$/, "").trim();
     return JSON.parse(stripped);
   } catch {
-    const match = text13.match(/\{[\s\S]*?\}/);
+    const match = text14.match(/\{[\s\S]*?\}/);
     if (match) {
       try {
         return JSON.parse(match[0]);
@@ -32557,12 +32976,12 @@ function computeGlobalScore(results) {
   const total = results.reduce((sum, r) => sum + r.reviewScore, 0);
   return Math.round(total / results.length);
 }
-function extractJson(text13) {
+function extractJson(text14) {
   try {
-    const stripped = text13.replace(/^```(?:json)?\s*\n?/, "").replace(/\n?```\s*$/, "").trim();
+    const stripped = text14.replace(/^```(?:json)?\s*\n?/, "").replace(/\n?```\s*$/, "").trim();
     return JSON.parse(stripped);
   } catch {
-    const match = text13.match(/\{[\s\S]*\}/);
+    const match = text14.match(/\{[\s\S]*\}/);
     if (match) {
       try {
         return JSON.parse(match[0]);
@@ -33398,111 +33817,132 @@ async function setupGcloudADC(provider) {
     p26.log.error("gcloud CLI is not installed");
     console.log(chalk.dim("   Install it from: https://cloud.google.com/sdk/docs/install"));
     console.log();
-    const useFallback = await p26.confirm({
+    if (provider.id === "vertex") {
+      console.log(chalk.dim("   Vertex AI requires gcloud ADC plus a Google Cloud project."));
+      console.log();
+      return null;
+    }
+    const useFallback2 = await p26.confirm({
       message: "Use API key instead?",
       initialValue: true
     });
-    if (p26.isCancel(useFallback) || !useFallback) return null;
+    if (p26.isCancel(useFallback2) || !useFallback2) return null;
     showProviderInfo(provider);
-    const apiKey = await requestApiKey(provider);
-    if (!apiKey) return null;
-    const model = await selectModel(provider);
-    if (!model) return null;
-    const valid = await testConnection(provider, apiKey, model);
-    if (!valid) return null;
-    return { type: provider.id, model, apiKey };
-  }
-  const adcConfigured = await isADCConfigured();
-  if (adcConfigured) {
+    const apiKey2 = await requestApiKey(provider);
+    if (!apiKey2) return null;
+    const model2 = await selectModel(provider);
+    if (!model2) return null;
+    const valid2 = await testConnection(provider, apiKey2, model2);
+    if (!valid2) return null;
+    return { type: provider.id, model: model2, apiKey: apiKey2 };
+  }
+  let adc = await inspectADC();
+  if (adc.status === "ok" && adc.token) {
     console.log(chalk.green("   \u2713 gcloud ADC is already configured!"));
     console.log();
-    const token = await getADCAccessToken();
-    if (token) {
-      p26.log.success("Authentication verified");
-      const model = await selectModel(provider);
-      if (!model) return null;
-      return {
-        type: provider.id,
-        model,
-        apiKey: "__gcloud_adc__"
-        // Special marker for ADC
-      };
-    }
+    p26.log.success("Authentication verified");
+    const vertexSettings = provider.id === "vertex" ? await promptVertexSettings() : void 0;
+    if (provider.id === "vertex" && !vertexSettings) return null;
+    const model2 = await selectModel(provider);
+    if (!model2) return null;
+    return {
+      type: provider.id,
+      model: model2,
+      apiKey: "__gcloud_adc__",
+      project: vertexSettings?.project,
+      location: vertexSettings?.location
+    };
   }
-  console.log(chalk.dim("   To authenticate with Google Cloud, you'll need to run:"));
-  console.log();
-  console.log(chalk.cyan("   $ gcloud auth application-default login"));
+  console.log(chalk.yellow("   No reusable gcloud ADC session was found for Coco."));
   console.log();
-  console.log(chalk.dim("   This will open a browser for Google sign-in."));
-  console.log(chalk.dim("   After signing in, the credentials will be stored locally."));
-  console.log();
-  const runNow = await p26.confirm({
-    message: "Run gcloud auth now?",
+  if (adc.message) {
+    console.log(chalk.dim(`   ${adc.message}`));
+    console.log();
+  }
+  const runLoginNow = await p26.confirm({
+    message: "Authenticate with gcloud now from Coco?",
     initialValue: true
   });
-  if (p26.isCancel(runNow)) return null;
-  if (runNow) {
-    console.log();
-    console.log(chalk.dim("   Opening browser for Google sign-in..."));
-    console.log(chalk.dim("   (Complete the sign-in in your browser, then return here)"));
-    console.log();
-    const { exec: exec3 } = await import('child_process');
-    const { promisify: promisify6 } = await import('util');
-    const execAsync3 = promisify6(exec3);
-    try {
-      await execAsync3("gcloud auth application-default login", {
-        timeout: 12e4
-        // 2 minute timeout
-      });
-      const token = await getADCAccessToken();
-      if (token) {
-        console.log(chalk.green("\n   \u2713 Authentication successful!"));
-        const model = await selectModel(provider);
-        if (!model) return null;
+  if (p26.isCancel(runLoginNow)) return null;
+  if (runLoginNow) {
+    p26.log.step("Running `gcloud auth application-default login`...");
+    const loginOk = await runGcloudADCLogin();
+    if (loginOk) {
+      adc = await inspectADC();
+      if (adc.status === "ok" && adc.token) {
+        console.log(chalk.green("   \u2713 gcloud ADC is now configured."));
+        console.log();
+        p26.log.success("Authentication verified");
+        const vertexSettings = provider.id === "vertex" ? await promptVertexSettings() : void 0;
+        if (provider.id === "vertex" && !vertexSettings) return null;
+        const model2 = await selectModel(provider);
+        if (!model2) return null;
         return {
           type: provider.id,
-          model,
-          apiKey: "__gcloud_adc__"
-          // Special marker for ADC
+          model: model2,
+          apiKey: "__gcloud_adc__",
+          project: vertexSettings?.project,
+          location: vertexSettings?.location
         };
-      } else {
-        p26.log.error("Failed to verify authentication");
-        return null;
       }
-    } catch (error) {
-      const errorMsg = error instanceof Error ? error.message : String(error);
-      p26.log.error(`Authentication failed: ${errorMsg}`);
-      const useFallback = await p26.confirm({
-        message: "Use API key instead?",
-        initialValue: true
-      });
-      if (p26.isCancel(useFallback) || !useFallback) return null;
-      showProviderInfo(provider);
-      const apiKey = await requestApiKey(provider);
-      if (!apiKey) return null;
-      const model = await selectModel(provider);
-      if (!model) return null;
-      const valid = await testConnection(provider, apiKey, model);
-      if (!valid) return null;
-      return { type: provider.id, model, apiKey };
     }
-  } else {
-    console.log(chalk.dim("\n   Run this command when ready:"));
-    console.log(chalk.cyan("   $ gcloud auth application-default login\n"));
-    const useFallback = await p26.confirm({
-      message: "Use API key for now?",
-      initialValue: true
-    });
-    if (p26.isCancel(useFallback) || !useFallback) return null;
-    showProviderInfo(provider);
-    const apiKey = await requestApiKey(provider);
-    if (!apiKey) return null;
-    const model = await selectModel(provider);
-    if (!model) return null;
-    const valid = await testConnection(provider, apiKey, model);
-    if (!valid) return null;
-    return { type: provider.id, model, apiKey };
+    p26.log.error("Could not complete gcloud ADC login from Coco.");
+    console.log();
+  }
+  console.log(chalk.dim("   Check the current machine-wide ADC state with:"));
+  console.log(chalk.cyan("   $ gcloud auth application-default print-access-token"));
+  console.log();
+  console.log(chalk.dim("   If you want to authenticate manually, run in your terminal:"));
+  console.log(chalk.cyan("   $ gcloud auth application-default login"));
+  console.log();
+  if (adc.suggestion) {
+    console.log(chalk.dim(`   ${adc.suggestion}`));
+    console.log();
+  }
+  console.log(chalk.dim("   Coco will reuse the login on the next attempt if ADC is valid."));
+  console.log();
+  if (provider.id === "vertex") {
+    console.log(
+      chalk.dim("   Vertex AI does not use API keys in Coco. Configure ADC, then retry.")
+    );
+    console.log();
+    return null;
   }
+  const useFallback = await p26.confirm({
+    message: "Use API key for now?",
+    initialValue: true
+  });
+  if (p26.isCancel(useFallback) || !useFallback) return null;
+  showProviderInfo(provider);
+  const apiKey = await requestApiKey(provider);
+  if (!apiKey) return null;
+  const model = await selectModel(provider);
+  if (!model) return null;
+  const valid = await testConnection(provider, apiKey, model);
+  if (!valid) return null;
+  return { type: provider.id, model, apiKey };
+}
+async function promptVertexSettings() {
+  const projectDefault = process.env["VERTEX_PROJECT"] ?? process.env["GOOGLE_CLOUD_PROJECT"] ?? process.env["GCLOUD_PROJECT"] ?? "";
+  const locationDefault = process.env["VERTEX_LOCATION"] ?? process.env["GOOGLE_CLOUD_LOCATION"] ?? "global";
+  const project = await p26.text({
+    message: "Google Cloud project ID:",
+    placeholder: projectDefault || "my-gcp-project",
+    initialValue: projectDefault,
+    validate: (v) => !v?.trim() ? "Project ID is required for Vertex AI" : void 0
+  });
+  if (p26.isCancel(project)) return null;
+  const location = await p26.text({
+    message: "Vertex AI location:",
+    placeholder: locationDefault,
+    initialValue: locationDefault,
+    validate: (v) => !v?.trim() ? "Location is required for Vertex AI" : void 0
+  });
+  if (p26.isCancel(location)) return null;
+  return {
+    project: project.trim(),
+    location: location.trim()
+  };
 }
 var LOCAL_PROVIDER_CONFIG = {
   lmstudio: {
@@ -33996,7 +34436,7 @@ async function testConnectionQuiet(provider, apiKey, model, baseUrl) {
     return false;
   }
 }
-async function testConnection(provider, apiKey, model, baseUrl) {
+async function testConnection(provider, apiKey, model, baseUrl, vertexSettings) {
   p26.log.message("");
   const spinner18 = p26.spinner();
   spinner18.start(`Testing connection to ${provider.name}...`);
@@ -34013,7 +34453,15 @@ async function testConnection(provider, apiKey, model, baseUrl) {
     if (baseUrl) {
       process.env[`${provider.id.toUpperCase()}_BASE_URL`] = baseUrl;
     }
-    const testProvider = await createProvider(provider.id, { model });
+    if (provider.id === "vertex") {
+      if (vertexSettings?.project) ;
+      if (vertexSettings?.location) ;
+    }
+    const testProvider = await createProvider(provider.id, {
+      model,
+      project: vertexSettings?.project,
+      location: vertexSettings?.location
+    });
     if (debug) {
       p26.log.message(chalk.dim(`[Debug] Provider created: ${testProvider.id}`));
     }
@@ -34073,7 +34521,20 @@ async function saveConfiguration(result) {
     p26.log.message(
       chalk.dim("   Run `gcloud auth application-default login` to refresh credentials")
     );
-    await saveProviderPreference(result.type, result.model);
+    if (result.type === "vertex" && result.project) {
+      await saveEnvVars(
+        CONFIG_PATHS.env,
+        {
+          VERTEX_PROJECT: result.project,
+          VERTEX_LOCATION: result.location ?? "global"
+        },
+        true
+      );
+    }
+    await saveProviderPreference(result.type, result.model, {
+      project: result.project,
+      location: result.location
+    });
     return;
   }
   if (result.type === "copilot") {
@@ -34116,6 +34577,10 @@ async function saveConfiguration(result) {
     if (result.baseUrl) {
       envVarsToSave[`${provider.envVar.replace("_API_KEY", "_BASE_URL")}`] = result.baseUrl;
     }
+    if (result.type === "vertex" && result.project) {
+      envVarsToSave["VERTEX_PROJECT"] = result.project;
+      envVarsToSave["VERTEX_LOCATION"] = result.location ?? "global";
+    }
   }
   switch (saveOptions) {
     case "global":
@@ -34129,7 +34594,10 @@ async function saveConfiguration(result) {
       p26.log.message(chalk.dim("\n\u{1F4A8} Configuration active for this session only."));
       break;
   }
-  await saveProviderPreference(result.type, result.model);
+  await saveProviderPreference(result.type, result.model, {
+    project: result.project,
+    location: result.location
+  });
 }
 async function saveEnvVars(filePath, vars, createDir = false) {
   if (createDir) {
@@ -34498,6 +34966,7 @@ async function switchProvider(initialProvider, session) {
   let internalProviderId = initialProvider.id;
   let selectedAuthMethod = "apikey";
   let newApiKeyForSaving = null;
+  let vertexSettings;
   if (newProvider.id === "lmstudio" || newProvider.id === "ollama") {
     const result = newProvider.id === "ollama" ? await setupOllamaProvider() : await setupLMStudioProvider();
     if (!result) {
@@ -34514,7 +34983,8 @@ async function switchProvider(initialProvider, session) {
 `));
     return false;
   }
-  const apiKey = process.env[newProvider.envVar];
+  const supportsApiKey = newProvider.id !== "vertex" && newProvider.requiresApiKey !== false;
+  const apiKey = supportsApiKey ? process.env[newProvider.envVar] : void 0;
   const hasOAuth = supportsOAuth(newProvider.id) || newProvider.supportsOAuth;
   const hasGcloudADC = newProvider.supportsGcloudADC;
   const oauthProviderName = newProvider.id === "copilot" ? "copilot" : newProvider.id === "gemini" ? "gemini" : "openai";
@@ -34562,18 +35032,20 @@ async function switchProvider(initialProvider, session) {
         hint: "Authenticate via gcloud CLI"
       });
     }
-    if (apiKey) {
-      authOptions.push({
-        value: "apikey",
-        label: "\u{1F511} API key (configured \u2713)",
-        hint: "Use your existing API key"
-      });
-    } else {
-      authOptions.push({
-        value: "apikey",
-        label: "\u{1F511} Enter API key",
-        hint: `Get from ${newProvider.apiKeyUrl}`
-      });
+    if (supportsApiKey) {
+      if (apiKey) {
+        authOptions.push({
+          value: "apikey",
+          label: "\u{1F511} API key (configured \u2713)",
+          hint: "Use your existing API key"
+        });
+      } else {
+        authOptions.push({
+          value: "apikey",
+          label: "\u{1F511} Enter API key",
+          hint: `Get from ${newProvider.apiKeyUrl}`
+        });
+      }
     }
     if (oauthConnected || apiKey) {
       authOptions.push({
@@ -34644,6 +35116,11 @@ Using existing OAuth session...`));
         const adcResult = await setupGcloudADCForProvider();
         if (!adcResult) return false;
         selectedAuthMethod = "gcloud";
+        if (newProvider.id === "vertex") {
+          const settings = await promptVertexSettings2();
+          if (!settings) return false;
+          vertexSettings = settings;
+        }
       } else if (authChoice === "apikey") {
         if (apiKey) {
           selectedAuthMethod = "apikey";
@@ -34712,16 +35189,27 @@ Using existing API key...`));
     } else {
       console.log(chalk.yellow(`
 ${newProvider.emoji} ${newProvider.name} is not configured.`));
-      const key = await p26.password({
-        message: `Enter your ${newProvider.name} API key:`,
-        validate: (v) => !v || v.length < 10 ? "API key too short" : void 0
-      });
-      if (p26.isCancel(key)) {
-        return false;
+      if (hasGcloudADC && !supportsApiKey) {
+        const adcResult = await setupGcloudADCForProvider();
+        if (!adcResult) return false;
+        selectedAuthMethod = "gcloud";
+        if (newProvider.id === "vertex") {
+          const settings = await promptVertexSettings2();
+          if (!settings) return false;
+          vertexSettings = settings;
+        }
+      } else {
+        const key = await p26.password({
+          message: `Enter your ${newProvider.name} API key:`,
+          validate: (v) => !v || v.length < 10 ? "API key too short" : void 0
+        });
+        if (p26.isCancel(key)) {
+          return false;
+        }
+        process.env[newProvider.envVar] = key;
+        selectedAuthMethod = "apikey";
+        newApiKeyForSaving = key;
       }
-      process.env[newProvider.envVar] = key;
-      selectedAuthMethod = "apikey";
-      newApiKeyForSaving = key;
     }
   }
   const rememberedModel = await getLastUsedModel(newProvider.id);
@@ -34731,7 +35219,9 @@ ${newProvider.emoji} ${newProvider.name} is not configured.`));
   spinner18.start(`Connecting to ${newProvider.name}...`);
   try {
     const testProvider = await createProvider(internalProviderId, {
-      model: newModel
+      model: newModel,
+      project: vertexSettings?.project,
+      location: vertexSettings?.location
     });
     const available = await testProvider.isAvailable();
     if (!available) {
@@ -34744,6 +35234,13 @@ ${newProvider.emoji} ${newProvider.name} is not configured.`));
     spinner18.stop(chalk.green("Connected!"));
     session.config.provider.type = userFacingProviderId;
     session.config.provider.model = newModel;
+    if (userFacingProviderId === "vertex") {
+      session.config.provider.project = vertexSettings?.project;
+      session.config.provider.location = vertexSettings?.location;
+    } else {
+      delete session.config.provider.project;
+      delete session.config.provider.location;
+    }
     if (newApiKeyForSaving) {
       await saveConfiguration({
         type: userFacingProviderId,
@@ -34751,7 +35248,10 @@ ${newProvider.emoji} ${newProvider.name} is not configured.`));
         apiKey: newApiKeyForSaving
       });
     } else {
-      await saveProviderPreference(userFacingProviderId, newModel);
+      await saveProviderPreference(userFacingProviderId, newModel, {
+        project: vertexSettings?.project,
+        location: vertexSettings?.location
+      });
     }
     console.log(chalk.green(`
 \u2713 Switched to ${newProvider.emoji} ${newProvider.name}`));
@@ -34779,38 +35279,48 @@ async function setupGcloudADCForProvider(_provider) {
     console.log(chalk.dim("   Install it from: https://cloud.google.com/sdk/docs/install\n"));
     return false;
   }
-  const adcConfigured = await isADCConfigured();
-  if (adcConfigured) {
-    const token = await getADCAccessToken();
-    if (token) {
-      console.log(chalk.green("   \u2713 gcloud ADC is already configured!\n"));
-      return true;
-    }
+  const adc = await inspectADC();
+  if (adc.status === "ok" && adc.token) {
+    console.log(chalk.green("   \u2713 gcloud ADC is already configured!\n"));
+    return true;
   }
-  console.log(chalk.dim("\n   To authenticate, run:"));
-  console.log(chalk.cyan("   $ gcloud auth application-default login\n"));
-  const runNow = await p26.confirm({
-    message: "Run gcloud auth now?",
-    initialValue: true
-  });
-  if (p26.isCancel(runNow) || !runNow) {
-    return false;
+  console.log(chalk.yellow("\n   No reusable gcloud ADC session was found for Coco."));
+  if (adc.message) {
+    console.log(chalk.dim(`   ${adc.message}`));
   }
-  const { exec: exec3 } = await import('child_process');
-  const { promisify: promisify6 } = await import('util');
-  const execAsync3 = promisify6(exec3);
-  try {
-    await execAsync3("gcloud auth application-default login", { timeout: 12e4 });
-    const token = await getADCAccessToken();
-    if (token) {
-      console.log(chalk.green("\n   \u2713 Authentication successful!\n"));
-      return true;
-    }
-  } catch (error) {
-    p26.log.error(`Authentication failed: ${error instanceof Error ? error.message : String(error)}`);
+  console.log(chalk.dim("\n   Check the current ADC state with:"));
+  console.log(chalk.cyan("   $ gcloud auth application-default print-access-token"));
+  console.log(chalk.dim("\n   Authenticate manually in your terminal with:"));
+  console.log(chalk.cyan("   $ gcloud auth application-default login"));
+  if (adc.suggestion) {
+    console.log(chalk.dim(`
+   ${adc.suggestion}`));
   }
+  console.log();
   return false;
 }
+async function promptVertexSettings2() {
+  const projectDefault = process.env["VERTEX_PROJECT"] ?? process.env["GOOGLE_CLOUD_PROJECT"] ?? process.env["GCLOUD_PROJECT"] ?? "";
+  const locationDefault = process.env["VERTEX_LOCATION"] ?? process.env["GOOGLE_CLOUD_LOCATION"] ?? "global";
+  const project = await p26.text({
+    message: "Google Cloud project ID:",
+    placeholder: projectDefault || "my-gcp-project",
+    initialValue: projectDefault,
+    validate: (value) => !value?.trim() ? "Project ID is required for Vertex AI" : void 0
+  });
+  if (p26.isCancel(project)) return null;
+  const location = await p26.text({
+    message: "Vertex AI location:",
+    placeholder: locationDefault,
+    initialValue: locationDefault,
+    validate: (value) => !value?.trim() ? "Location is required for Vertex AI" : void 0
+  });
+  if (p26.isCancel(location)) return null;
+  return {
+    project: project.trim(),
+    location: location.trim()
+  };
+}
 
 // src/cli/repl/commands/status.ts
 init_state();
@@ -35500,11 +36010,11 @@ async function revokeTrust(session, trustStore) {
     p26.log.info("This project is not currently trusted");
     return;
   }
-  const confirm23 = await p26.confirm({
+  const confirm22 = await p26.confirm({
     message: "Revoke all access to this project?",
     initialValue: false
   });
-  if (p26.isCancel(confirm23) || !confirm23) {
+  if (p26.isCancel(confirm22) || !confirm22) {
     p26.outro("Cancelled");
     return;
   }
@@ -35621,11 +36131,11 @@ var initCommand = {
         p26.log.message(`  Description: ${description}`);
       }
       p26.log.message("");
-      const confirm23 = await p26.confirm({
+      const confirm22 = await p26.confirm({
         message: "Create project?",
         initialValue: true
       });
-      if (p26.isCancel(confirm23) || !confirm23) {
+      if (p26.isCancel(confirm22) || !confirm22) {
         p26.outro("Cancelled");
         return false;
       }
@@ -36851,11 +37361,11 @@ async function runInteractiveMode(session) {
     );
   }
   console.log();
-  const confirm23 = await p26.confirm({
+  const confirm22 = await p26.confirm({
     message: "Proceed with restoration?",
     initialValue: true
   });
-  if (p26.isCancel(confirm23) || !confirm23) {
+  if (p26.isCancel(confirm22) || !confirm22) {
     p26.outro("Cancelled");
     return false;
   }
@@ -36898,11 +37408,11 @@ async function runDirectMode(session, checkpointId) {
     console.log(`${chalk.dim("Conversation:")} ${checkpoint.conversation?.messageCount} messages`);
   }
   console.log();
-  const confirm23 = await p26.confirm({
+  const confirm22 = await p26.confirm({
     message: "Restore this checkpoint?",
     initialValue: true
   });
-  if (p26.isCancel(confirm23) || !confirm23) {
+  if (p26.isCancel(confirm22) || !confirm22) {
     p26.outro("Cancelled");
     return false;
   }
@@ -37353,11 +37863,11 @@ async function runInteractiveMode2(session) {
     return false;
   }
   displaySessionDetails(selectedSession);
-  const confirm23 = await p26.confirm({
+  const confirm22 = await p26.confirm({
     message: "Resume this session?",
     initialValue: true
   });
-  if (p26.isCancel(confirm23) || !confirm23) {
+  if (p26.isCancel(confirm22) || !confirm22) {
     p26.outro("Cancelled");
     return false;
   }
@@ -37375,11 +37885,11 @@ async function runDirectMode2(session, sessionId) {
     return false;
   }
   displaySessionDetails(targetSession);
-  const confirm23 = await p26.confirm({
+  const confirm22 = await p26.confirm({
     message: "Resume this session?",
     initialValue: true
   });
-  if (p26.isCancel(confirm23) || !confirm23) {
+  if (p26.isCancel(confirm22) || !confirm22) {
     p26.outro("Cancelled");
     return false;
   }
@@ -37668,7 +38178,7 @@ function getClipboardCommand() {
   }
   return null;
 }
-async function copyToClipboard(text13) {
+async function copyToClipboard(text14) {
   const clipboardCmd = getClipboardCommand();
   if (!clipboardCmd) {
     return false;
@@ -37689,7 +38199,7 @@ async function copyToClipboard(text13) {
             });
             xselProc.on("error", () => resolve4(false));
             xselProc.on("close", (code) => resolve4(code === 0));
-            xselProc.stdin.write(text13);
+            xselProc.stdin.write(text14);
             xselProc.stdin.end();
           } catch {
             resolve4(false);
@@ -37705,7 +38215,7 @@ async function copyToClipboard(text13) {
       });
       proc.stdin.on("error", () => {
       });
-      proc.stdin.write(text13);
+      proc.stdin.write(text14);
       proc.stdin.end();
     } catch {
       resolve4(false);
@@ -39439,9 +39949,9 @@ var UserCancelledError = class extends Error {
 var SPEC_AGENT_SYSTEM = `You are a senior technical product manager specialising in rapid MVP delivery.
 Your job is to help a developer plan a software project efficiently and honestly.
 Always respond with valid JSON only \u2014 no markdown fences, no prose outside JSON.`;
-function extractJson2(text13) {
-  const match = text13.match(/```(?:json)?\s*([\s\S]*?)```/) ?? text13.match(/(\{[\s\S]*\})/);
-  return match ? (match[1] ?? text13).trim() : text13.trim();
+function extractJson2(text14) {
+  const match = text14.match(/```(?:json)?\s*([\s\S]*?)```/) ?? text14.match(/(\{[\s\S]*\})/);
+  return match ? (match[1] ?? text14).trim() : text14.trim();
 }
 function validateBacklogSpec(raw) {
   if (!raw.sprints || raw.sprints.length === 0) {
@@ -39619,11 +40129,11 @@ Response format (JSON only, no prose):
     }
   }
   if (!options?.skipConfirmation) {
-    const confirm23 = await p26.confirm({
+    const confirm22 = await p26.confirm({
       message: "Start building with this plan?",
       initialValue: true
     });
-    if (p26.isCancel(confirm23) || !confirm23) {
+    if (p26.isCancel(confirm22) || !confirm22) {
       cancel5("Build cancelled.");
     }
   }
@@ -41181,8 +41691,8 @@ Examples:
     recursive: z.boolean().optional().default(false).describe("Delete directories recursively"),
     confirm: z.boolean().optional().describe("Must be true to confirm deletion")
   }),
-  async execute({ path: filePath, recursive, confirm: confirm23 }) {
-    if (confirm23 !== true) {
+  async execute({ path: filePath, recursive, confirm: confirm22 }) {
+    if (confirm22 !== true) {
       throw new ToolError(
         "Deletion requires explicit confirmation. Set confirm: true to proceed.",
         { tool: "delete_file" }
@@ -43082,15 +43592,15 @@ ${message}
       let stdoutBuffer = "";
       let stderrBuffer = "";
       subprocess.stdout?.on("data", (chunk) => {
-        const text13 = chunk.toString();
-        stdoutBuffer += text13;
-        process.stdout.write(text13);
+        const text14 = chunk.toString();
+        stdoutBuffer += text14;
+        process.stdout.write(text14);
         heartbeat.activity();
       });
       subprocess.stderr?.on("data", (chunk) => {
-        const text13 = chunk.toString();
-        stderrBuffer += text13;
-        process.stderr.write(text13);
+        const text14 = chunk.toString();
+        stderrBuffer += text14;
+        process.stderr.write(text14);
         heartbeat.activity();
       });
       const result = await subprocess;
@@ -43207,15 +43717,15 @@ ${message}
       let stdoutBuffer = "";
       let stderrBuffer = "";
       subprocess.stdout?.on("data", (chunk) => {
-        const text13 = chunk.toString();
-        stdoutBuffer += text13;
-        process.stdout.write(text13);
+        const text14 = chunk.toString();
+        stdoutBuffer += text14;
+        process.stdout.write(text14);
         heartbeat.activity();
       });
       subprocess.stderr?.on("data", (chunk) => {
-        const text13 = chunk.toString();
-        stderrBuffer += text13;
-        process.stderr.write(text13);
+        const text14 = chunk.toString();
+        stderrBuffer += text14;
+        process.stderr.write(text14);
         heartbeat.activity();
       });
       const result = await subprocess;
@@ -43309,15 +43819,15 @@ ${message}
       let stdoutBuffer = "";
       let stderrBuffer = "";
       subprocess.stdout?.on("data", (chunk) => {
-        const text13 = chunk.toString();
-        stdoutBuffer += text13;
-        process.stdout.write(text13);
+        const text14 = chunk.toString();
+        stdoutBuffer += text14;
+        process.stdout.write(text14);
         heartbeat.activity();
       });
       subprocess.stderr?.on("data", (chunk) => {
-        const text13 = chunk.toString();
-        stderrBuffer += text13;
-        process.stderr.write(text13);
+        const text14 = chunk.toString();
+        stderrBuffer += text14;
+        process.stderr.write(text14);
         heartbeat.activity();
       });
       const result = await subprocess;
@@ -43412,15 +43922,15 @@ ${message}
       let stdoutBuffer = "";
       let stderrBuffer = "";
       subprocess.stdout?.on("data", (chunk) => {
-        const text13 = chunk.toString();
-        stdoutBuffer += text13;
-        process.stdout.write(text13);
+        const text14 = chunk.toString();
+        stdoutBuffer += text14;
+        process.stdout.write(text14);
         heartbeat.activity();
       });
       subprocess.stderr?.on("data", (chunk) => {
-        const text13 = chunk.toString();
-        stderrBuffer += text13;
-        process.stderr.write(text13);
+        const text14 = chunk.toString();
+        stderrBuffer += text14;
+        process.stderr.write(text14);
         heartbeat.activity();
       });
       const result = await subprocess;
@@ -43516,15 +44026,15 @@ ${message}
       let stdoutBuffer = "";
       let stderrBuffer = "";
       subprocess.stdout?.on("data", (chunk) => {
-        const text13 = chunk.toString();
-        stdoutBuffer += text13;
-        process.stdout.write(text13);
+        const text14 = chunk.toString();
+        stdoutBuffer += text14;
+        process.stdout.write(text14);
         heartbeat.activity();
       });
       subprocess.stderr?.on("data", (chunk) => {
-        const text13 = chunk.toString();
-        stderrBuffer += text13;
-        process.stderr.write(text13);
+        const text14 = chunk.toString();
+        stderrBuffer += text14;
+        process.stderr.write(text14);
         heartbeat.activity();
       });
       const result = await subprocess;
@@ -43603,15 +44113,15 @@ ${message}
       let stdoutBuffer = "";
       let stderrBuffer = "";
       subprocess.stdout?.on("data", (chunk) => {
-        const text13 = chunk.toString();
-        stdoutBuffer += text13;
-        process.stdout.write(text13);
+        const text14 = chunk.toString();
+        stdoutBuffer += text14;
+        process.stdout.write(text14);
         heartbeat.activity();
       });
       subprocess.stderr?.on("data", (chunk) => {
-        const text13 = chunk.toString();
-        stderrBuffer += text13;
-        process.stderr.write(text13);
+        const text14 = chunk.toString();
+        stderrBuffer += text14;
+        process.stderr.write(text14);
         heartbeat.activity();
       });
       const result = await subprocess;
@@ -44102,16 +44612,16 @@ function htmlToMarkdown(html) {
     const prefix = "#".repeat(i);
     const regex = new RegExp(`<h${i}[^>]*>([\\s\\S]*?)<\\/h${i}>`, "gi");
     md = md.replace(regex, (_, content) => {
-      const text13 = content.replace(/<[^>]*>/g, "").trim();
-      return text13 ? `
+      const text14 = content.replace(/<[^>]*>/g, "").trim();
+      return text14 ? `
 
-${prefix} ${text13}
+${prefix} ${text14}
 
 ` : "";
     });
   }
-  md = md.replace(/<a\s+[^>]*href=["']([^"']+)["'][^>]*>([\s\S]*?)<\/a>/gi, (_, href, text13) => {
-    const cleanText = text13.replace(/<[^>]*>/g, "").trim();
+  md = md.replace(/<a\s+[^>]*href=["']([^"']+)["'][^>]*>([\s\S]*?)<\/a>/gi, (_, href, text14) => {
+    const cleanText = text14.replace(/<[^>]*>/g, "").trim();
     if (!cleanText) return "";
     if (href.startsWith("#") || href.startsWith("javascript:")) return cleanText;
     return `[${cleanText}](${href})`;
@@ -44138,8 +44648,8 @@ ${decoded.trim()}
   });
   md = md.replace(/<ul[^>]*>([\s\S]*?)<\/ul>/gi, (_, items) => {
     return "\n" + items.replace(/<li[^>]*>([\s\S]*?)<\/li>/gi, (_2, item) => {
-      const text13 = item.replace(/<[^>]*>/g, "").trim();
-      return text13 ? `- ${text13}
+      const text14 = item.replace(/<[^>]*>/g, "").trim();
+      return text14 ? `- ${text14}
 ` : "";
     }) + "\n";
   });
@@ -44147,29 +44657,29 @@ ${decoded.trim()}
     let counter = 0;
     return "\n" + items.replace(/<li[^>]*>([\s\S]*?)<\/li>/gi, (_2, item) => {
       counter++;
-      const text13 = item.replace(/<[^>]*>/g, "").trim();
-      return text13 ? `${counter}. ${text13}
+      const text14 = item.replace(/<[^>]*>/g, "").trim();
+      return text14 ? `${counter}. ${text14}
 ` : "";
     }) + "\n";
   });
   md = md.replace(/<blockquote[^>]*>([\s\S]*?)<\/blockquote>/gi, (_, content) => {
-    const text13 = content.replace(/<[^>]*>/g, "").trim();
-    return text13 ? "\n" + text13.split("\n").map((line) => `> ${line.trim()}`).join("\n") + "\n" : "";
+    const text14 = content.replace(/<[^>]*>/g, "").trim();
+    return text14 ? "\n" + text14.split("\n").map((line) => `> ${line.trim()}`).join("\n") + "\n" : "";
   });
   md = md.replace(/<p[^>]*>([\s\S]*?)<\/p>/gi, (_, content) => {
-    const text13 = content.replace(/<[^>]*>/g, "").trim();
-    return text13 ? `
+    const text14 = content.replace(/<[^>]*>/g, "").trim();
+    return text14 ? `
 
-${text13}
+${text14}
 
 ` : "";
   });
   md = md.replace(/<br\s*\/?>/gi, "\n");
   md = md.replace(
     /<(?:strong|b)[^>]*>([\s\S]*?)<\/(?:strong|b)>/gi,
-    (_, text13) => `**${text13.trim()}**`
+    (_, text14) => `**${text14.trim()}**`
   );
-  md = md.replace(/<(?:em|i)[^>]*>([\s\S]*?)<\/(?:em|i)>/gi, (_, text13) => `*${text13.trim()}*`);
+  md = md.replace(/<(?:em|i)[^>]*>([\s\S]*?)<\/(?:em|i)>/gi, (_, text14) => `*${text14.trim()}*`);
   md = md.replace(/<hr\s*\/?>/gi, "\n---\n");
   md = md.replace(/<table[^>]*>([\s\S]*?)<\/table>/gi, (_, tableContent) => {
     const rows = [];
@@ -45299,10 +45809,10 @@ function chunkContent(content, chunkSize) {
   const chunks = [];
   for (let i = 0; i < lines.length; i += chunkSize) {
     const chunkLines = lines.slice(i, Math.min(i + chunkSize, lines.length));
-    const text13 = chunkLines.join("\n").trim();
-    if (text13.length > 10) {
+    const text14 = chunkLines.join("\n").trim();
+    if (text14.length > 10) {
       chunks.push({
-        text: text13,
+        text: text14,
         startLine: i + 1,
         endLine: Math.min(i + chunkSize, lines.length)
       });
@@ -45310,8 +45820,8 @@ function chunkContent(content, chunkSize) {
   }
   return chunks;
 }
-function simpleEmbedding(text13) {
-  const words = text13.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter((w) => w.length > 1);
+function simpleEmbedding(text14) {
+  const words = text14.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter((w) => w.length > 1);
   const freq = /* @__PURE__ */ new Map();
   for (const word of words) {
     freq.set(word, (freq.get(word) ?? 0) + 1);
@@ -45337,7 +45847,7 @@ function simpleEmbedding(text13) {
 }
 var embedFn = null;
 var usingFallbackEmbedding = false;
-async function getEmbedding(text13) {
+async function getEmbedding(text14) {
   if (!embedFn) {
     try {
       const transformers = await import('@xenova/transformers');
@@ -45354,7 +45864,7 @@ async function getEmbedding(text13) {
       usingFallbackEmbedding = true;
     }
   }
-  return embedFn(text13);
+  return embedFn(text14);
 }
 async function loadIndex2(indexDir) {
   try {
@@ -45907,23 +46417,23 @@ Examples:
       const pdfData = await pdfParse.default(dataBuffer, {
         max: maxPages
       });
-      let text13 = pdfData.text;
+      let text14 = pdfData.text;
       let truncated = false;
       const totalPages = pdfData.numpages;
       if (pages) {
         const range = parsePageRange(pages, totalPages);
-        const pageTexts = text13.split(/\f/);
+        const pageTexts = text14.split(/\f/);
         if (pageTexts.length > 1) {
           const selectedPages = pageTexts.slice(range.start - 1, range.end);
-          text13 = selectedPages.join("\n\n--- Page Break ---\n\n");
+          text14 = selectedPages.join("\n\n--- Page Break ---\n\n");
         }
       }
-      if (text13.length > 5e5) {
-        text13 = text13.slice(0, 5e5);
+      if (text14.length > 5e5) {
+        text14 = text14.slice(0, 5e5);
         truncated = true;
       }
       return {
-        text: text13,
+        text: text14,
         pages: totalPages,
         metadata: {
           title: pdfData.info?.Title,
@@ -46084,7 +46594,7 @@ Examples:
         description = response.choices[0]?.message?.content ?? "No description generated";
       } else if (selectedProvider === "gemini") {
         model = "gemini-2.0-flash";
-        const { GoogleGenerativeAI: GoogleGenerativeAI2 } = await import('@google/generative-ai');
+        const { GoogleGenAI: GoogleGenAI2 } = await import('@google/genai');
         const apiKey = process.env.GOOGLE_API_KEY ?? process.env.GEMINI_API_KEY;
         if (!apiKey) {
           throw new ToolError(
@@ -46092,18 +46602,25 @@ Examples:
             { tool: "read_image" }
           );
         }
-        const genAI = new GoogleGenerativeAI2(apiKey);
-        const genModel = genAI.getGenerativeModel({ model });
-        const result = await genModel.generateContent([
-          effectivePrompt,
-          {
-            inlineData: {
-              data: base64,
-              mimeType
+        const genAI = new GoogleGenAI2({ apiKey });
+        const result = await genAI.models.generateContent({
+          model,
+          contents: [
+            {
+              role: "user",
+              parts: [
+                { text: effectivePrompt },
+                {
+                  inlineData: {
+                    data: base64,
+                    mimeType
+                  }
+                }
+              ]
             }
-          }
-        ]);
-        description = result.response.text() ?? "No description generated";
+          ]
+        });
+        description = result.text ?? "No description generated";
       } else {
         throw new ToolError(`Unsupported provider: ${selectedProvider}`, {
           tool: "read_image"
@@ -46115,7 +46632,7 @@ Examples:
         const pkgMap = {
           anthropic: "@anthropic-ai/sdk",
           openai: "openai",
-          gemini: "@google/generative-ai"
+          gemini: "@google/genai"
         };
         const pkg = pkgMap[selectedProvider] ?? selectedProvider;
         throw new ToolError(`Provider SDK not installed. Run: pnpm add ${pkg}`, {
@@ -48158,11 +48675,11 @@ var buildAppCommand = {
       return false;
     }
     if (!isAutonomous && !parsed.skipConfirmation) {
-      const confirm23 = await p26.confirm({
+      const confirm22 = await p26.confirm({
         message: `Build "${spec.projectName}" with ${spec.sprints.length} sprints?`,
         initialValue: true
       });
-      if (p26.isCancel(confirm23) || !confirm23) {
+      if (p26.isCancel(confirm22) || !confirm22) {
         p26.cancel("Build cancelled.");
         return false;
       }
@@ -49343,24 +49860,24 @@ function formatHtmlLine(line) {
   }
   return null;
 }
-function formatInlineMarkdown(text13) {
-  text13 = text13.replace(/\*\*\*(.+?)\*\*\*/g, (_, content) => chalk.bold.italic(content));
-  text13 = text13.replace(/\*\*(.+?)\*\*/g, (_, content) => chalk.bold(content));
-  text13 = text13.replace(/\*([^*]+)\*/g, (_, content) => chalk.italic(content));
-  text13 = text13.replace(/_([^_]+)_/g, (_, content) => chalk.italic(content));
-  text13 = text13.replace(/`([^`]+)`/g, (_, content) => chalk.cyan(content));
-  text13 = text13.replace(/~~(.+?)~~/g, (_, content) => chalk.strikethrough(content));
-  text13 = text13.replace(/\[([^\]]+)\]\([^)]+\)/g, (_, linkText) => chalk.blue.underline(linkText));
-  return text13;
-}
-function wrapText(text13, maxWidth) {
-  if (maxWidth <= 0) return [text13];
-  const plainText = stripAnsi(text13);
+function formatInlineMarkdown(text14) {
+  text14 = text14.replace(/\*\*\*(.+?)\*\*\*/g, (_, content) => chalk.bold.italic(content));
+  text14 = text14.replace(/\*\*(.+?)\*\*/g, (_, content) => chalk.bold(content));
+  text14 = text14.replace(/\*([^*]+)\*/g, (_, content) => chalk.italic(content));
+  text14 = text14.replace(/_([^_]+)_/g, (_, content) => chalk.italic(content));
+  text14 = text14.replace(/`([^`]+)`/g, (_, content) => chalk.cyan(content));
+  text14 = text14.replace(/~~(.+?)~~/g, (_, content) => chalk.strikethrough(content));
+  text14 = text14.replace(/\[([^\]]+)\]\([^)]+\)/g, (_, linkText) => chalk.blue.underline(linkText));
+  return text14;
+}
+function wrapText(text14, maxWidth) {
+  if (maxWidth <= 0) return [text14];
+  const plainText = stripAnsi(text14);
   if (plainText.length <= maxWidth) {
-    return [text13];
+    return [text14];
   }
   const lines = [];
-  let remaining = text13;
+  let remaining = text14;
   while (true) {
     const plain = stripAnsi(remaining);
     if (plain.length <= maxWidth) break;
@@ -49398,7 +49915,7 @@ function wrapText(text13, maxWidth) {
   if (remaining) {
     lines.push(remaining);
   }
-  return lines.length > 0 ? lines : [text13];
+  return lines.length > 0 ? lines : [text14];
 }
 function stripAnsi(str) {
   return str.replace(/\x1b\[[0-9;]*m/g, "");
@@ -49550,9 +50067,9 @@ function printEditDiff(oldStr, newStr) {
     if (lines.length === 0) return;
     const truncate4 = (s) => s.length > termWidth - 2 ? s.slice(0, termWidth - 3) + "\u2026" : s;
     for (const l of lines) {
-      const text13 = `+ ${truncate4(l)}`;
-      const pad = Math.max(0, termWidth - stripAnsi(text13).length + 2);
-      console.log("  " + diffBgAdd(text13 + " ".repeat(pad)));
+      const text14 = `+ ${truncate4(l)}`;
+      const pad = Math.max(0, termWidth - stripAnsi(text14).length + 2);
+      console.log("  " + diffBgAdd(text14 + " ".repeat(pad)));
     }
     return;
   }
@@ -50008,10 +50525,10 @@ function findNextWordBoundary(line, pos) {
   while (i < line.length && line[i] === " ") i++;
   return i;
 }
-function countVisualRows(text13, startCol, termCols) {
+function countVisualRows(text14, startCol, termCols) {
   let rows = 1;
   let col = startCol;
-  for (const char of text13) {
+  for (const char of text14) {
     if (char === "\n") {
       if (col > 0) rows++;
       col = 0;
@@ -50025,11 +50542,11 @@ function countVisualRows(text13, startCol, termCols) {
   }
   return rows;
 }
-function getCursorVisualPos(text13, cursorPos, promptLen, termCols) {
+function getCursorVisualPos(text14, cursorPos, promptLen, termCols) {
   let row = 0;
   let col = promptLen;
   for (let i = 0; i < cursorPos; i++) {
-    if (text13[i] === "\n") {
+    if (text14[i] === "\n") {
       if (col > 0) row++;
       col = 0;
     } else {
@@ -50042,14 +50559,14 @@ function getCursorVisualPos(text13, cursorPos, promptLen, termCols) {
   }
   return { row, col };
 }
-function computeWordWrap(text13, startCol, termCols) {
+function computeWordWrap(text14, startCol, termCols) {
   const passthrough = {
-    display: text13,
+    display: text14,
     toDisplayPos: (p45) => p45,
     toOrigPos: (p45) => p45
   };
-  if (!text13 || termCols <= 1) return passthrough;
-  const origToDisp = new Int32Array(text13.length + 1);
+  if (!text14 || termCols <= 1) return passthrough;
+  const origToDisp = new Int32Array(text14.length + 1);
   const dispToOrig = [];
   let display = "";
   let col = startCol;
@@ -50065,15 +50582,15 @@ function computeWordWrap(text13, startCol, termCols) {
     col = 0;
   }
   let i = 0;
-  while (i < text13.length) {
-    const ch = text13[i];
+  while (i < text14.length) {
+    const ch = text14[i];
     if (ch === "\n") {
       emitChar("\n", i++);
       continue;
     }
     if (ch !== " ") {
       let wordEnd = i;
-      while (wordEnd < text13.length && text13[wordEnd] !== " " && text13[wordEnd] !== "\n") {
+      while (wordEnd < text14.length && text14[wordEnd] !== " " && text14[wordEnd] !== "\n") {
         wordEnd++;
       }
       const wordLen = wordEnd - i;
@@ -50081,7 +50598,7 @@ function computeWordWrap(text13, startCol, termCols) {
         injectNewline();
       }
       for (let k = i; k < wordEnd; k++) {
-        emitChar(text13[k], k);
+        emitChar(text14[k], k);
         if (col >= termCols && k + 1 < wordEnd) {
           injectNewline();
         }
@@ -50093,7 +50610,7 @@ function computeWordWrap(text13, startCol, termCols) {
         col = 0;
       } else {
         let nextWordEnd = i;
-        while (nextWordEnd < text13.length && text13[nextWordEnd] !== " " && text13[nextWordEnd] !== "\n") {
+        while (nextWordEnd < text14.length && text14[nextWordEnd] !== " " && text14[nextWordEnd] !== "\n") {
           nextWordEnd++;
         }
         const nextWordLen = nextWordEnd - i;
@@ -50103,10 +50620,10 @@ function computeWordWrap(text13, startCol, termCols) {
       }
     }
   }
-  origToDisp[text13.length] = display.length;
+  origToDisp[text14.length] = display.length;
   return {
     display,
-    toDisplayPos: (origPos) => origToDisp[Math.min(origPos, text13.length)] ?? display.length,
+    toDisplayPos: (origPos) => origToDisp[Math.min(origPos, text14.length)] ?? display.length,
     toOrigPos: (displayPos) => {
       const dp = Math.max(0, Math.min(displayPos, dispToOrig.length - 1));
       for (let d = dp; d >= 0; d--) {
@@ -50239,11 +50756,11 @@ function createInputHandler(_session) {
           const item = visibleItems[itemIndex];
           const actualIndex = startIndex + itemIndex;
           const isSelected = actualIndex === selectedCompletion;
-          const text13 = `  ${item.cmd}`.padEnd(ITEM_WIDTH);
+          const text14 = `  ${item.cmd}`.padEnd(ITEM_WIDTH);
           if (isSelected) {
-            output += chalk.bgBlue.white(text13);
+            output += chalk.bgBlue.white(text14);
           } else {
-            output += chalk.cyan(text13);
+            output += chalk.cyan(text14);
           }
         }
       }
@@ -50295,8 +50812,8 @@ function createInputHandler(_session) {
     process.stdout.write("\r" + ansiEscapes.eraseDown);
     lastMenuLines = 0;
   }
-  function insertTextAtCursor(text13) {
-    const cleaned = text13.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  function insertTextAtCursor(text14) {
+    const cleaned = text14.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
     const printable = cleaned.replace(/[^\n\x20-\x7E\u00A0-\uFFFF]/g, "");
     if (printable.length === 0) return;
     currentLine = currentLine.slice(0, cursorPos) + printable + currentLine.slice(cursorPos);
@@ -51199,10 +51716,10 @@ function formatWriteFilePreview(toolCall, maxLines = 10) {
   const footer = truncated ? chalk.dim(`  \u2514\u2500 ... ${lines.length - maxLines} more lines`) : "";
   return formatted + (footer ? "\n" + footer : "");
 }
-function wrapCommandText(text13, maxWidth = 70, indent = "      ") {
-  if (text13.length <= maxWidth) return text13;
+function wrapCommandText(text14, maxWidth = 70, indent = "      ") {
+  if (text14.length <= maxWidth) return text14;
   const lines = [];
-  let remaining = text13;
+  let remaining = text14;
   while (remaining.length > maxWidth) {
     let breakAt = maxWidth;
     const spaceIdx = remaining.lastIndexOf(" ", maxWidth);
@@ -53469,14 +53986,14 @@ async function startRepl(options = {}) {
         imageCount++;
       }
     }
-    const text13 = textParts.join("\n\n").trim();
-    if (text13.length > 0) {
+    const text14 = textParts.join("\n\n").trim();
+    if (text14.length > 0) {
       if (imageCount > 0) {
-        return `${text13}
+        return `${text14}
 
 [System: The original request included ${imageCount} image(s). Use the image context already provided in this conversation.]`;
       }
-      return text13;
+      return text14;
     }
     if (imageCount > 0) {
       return `[System: Retry the previous image-based user request (${imageCount} image(s)). Use the existing image context in the conversation and do not repeat the same failed action.]`;