claudish 3.4.1 → 3.5.0

package/dist/index.js

@@ -56261,6 +56261,9 @@ function getModelPricing(provider, modelName) {
     case "google":
       pricingTable = GEMINI_PRICING;
       break;
+    case "vertex":
+      pricingTable = VERTEX_PRICING;
+      break;
     case "openai":
     case "oai":
       pricingTable = OPENAI_PRICING;
@@ -56290,7 +56293,7 @@ function getModelPricing(provider, modelName) {
   }
   return pricingTable.default;
 }
-var GEMINI_PRICING, OPENAI_PRICING, MINIMAX_PRICING, KIMI_PRICING, GLM_PRICING;
+var GEMINI_PRICING, OPENAI_PRICING, MINIMAX_PRICING, KIMI_PRICING, GLM_PRICING, VERTEX_PRICING;
 var init_remote_provider_types = __esm(() => {
   GEMINI_PRICING = {
     "gemini-2.5-flash": { inputCostPer1M: 0.15, outputCostPer1M: 0.6 },
@@ -56361,6 +56364,17 @@ var init_remote_provider_types = __esm(() => {
     "glm-4-plus": { inputCostPer1M: 0.5, outputCostPer1M: 2 },
     default: { inputCostPer1M: 0.16, outputCostPer1M: 0.8, isEstimate: true }
   };
+  VERTEX_PRICING = {
+    "gemini-2.5-flash": { inputCostPer1M: 0.15, outputCostPer1M: 0.6 },
+    "gemini-2.5-flash-preview-05-20": { inputCostPer1M: 0.15, outputCostPer1M: 0.6 },
+    "gemini-2.5-pro": { inputCostPer1M: 1.25, outputCostPer1M: 10 },
+    "gemini-2.5-pro-preview-05-06": { inputCostPer1M: 1.25, outputCostPer1M: 10 },
+    "gemini-3-pro-preview": { inputCostPer1M: 2.5, outputCostPer1M: 10 },
+    "gemini-3.0-flash": { inputCostPer1M: 0.1, outputCostPer1M: 0.4 },
+    "gemini-2.0-flash": { inputCostPer1M: 0.1, outputCostPer1M: 0.4 },
+    "gemini-2.0-flash-thinking": { inputCostPer1M: 0.1, outputCostPer1M: 0.4 },
+    default: { inputCostPer1M: 0.5, outputCostPer1M: 2, isEstimate: true }
+  };
 });
 
 // ../core/dist/handlers/gemini-handler.js
@@ -57712,161 +57726,1070 @@ var init_anthropic_compat_handler = __esm(() => {
   init_remote_provider_types();
 });
 
-// ../core/dist/providers/provider-registry.js
-function getRegisteredProviders() {
-  return getProviders();
-}
-function resolveProvider(modelId) {
-  const providers = getProviders();
-  for (const provider of providers) {
-    for (const prefix of provider.prefixes) {
-      if (modelId.startsWith(prefix)) {
-        return {
-          provider,
-          modelName: modelId.slice(prefix.length)
-        };
-      }
+// ../core/dist/auth/vertex-auth.js
+import { exec as exec2 } from "node:child_process";
+import { promisify } from "node:util";
+import { existsSync as existsSync6 } from "node:fs";
+import { homedir as homedir7 } from "node:os";
+import { join as join11 } from "node:path";
+
+class VertexAuthManager {
+  cachedToken = null;
+  refreshPromise = null;
+  tokenRefreshMargin = 5 * 60 * 1000;
+  async getAccessToken() {
+    if (this.refreshPromise) {
+      log("[VertexAuth] Waiting for in-progress refresh");
+      return this.refreshPromise;
+    }
+    if (this.isTokenValid()) {
+      return this.cachedToken.token;
+    }
+    this.refreshPromise = this.doRefresh();
+    try {
+      const token = await this.refreshPromise;
+      return token;
+    } finally {
+      this.refreshPromise = null;
     }
   }
-  return null;
-}
-function isLocalProvider(modelId) {
-  if (resolveProvider(modelId) !== null) {
-    return true;
+  async refreshToken() {
+    this.cachedToken = null;
+    await this.getAccessToken();
   }
-  if (parseUrlModel(modelId) !== null) {
-    return true;
+  isTokenValid() {
+    if (!this.cachedToken)
+      return false;
+    return Date.now() < this.cachedToken.expiresAt - this.tokenRefreshMargin;
+  }
+  async doRefresh() {
+    log("[VertexAuth] Refreshing token");
+    const adcToken = await this.tryADC();
+    if (adcToken) {
+      this.cachedToken = adcToken;
+      log(`[VertexAuth] ADC token valid until ${new Date(adcToken.expiresAt).toISOString()}`);
+      return adcToken.token;
+    }
+    const saToken = await this.tryServiceAccount();
+    if (saToken) {
+      this.cachedToken = saToken;
+      log(`[VertexAuth] Service account token valid until ${new Date(saToken.expiresAt).toISOString()}`);
+      return saToken.token;
+    }
+    throw new Error(`Failed to authenticate with Vertex AI.
+
+` + `Options:
+` + `1. Run: gcloud auth application-default login
+` + `2. Set: export GOOGLE_APPLICATION_CREDENTIALS='/path/to/service-account.json'
+`);
   }
-  return false;
-}
-function parseUrlModel(modelId) {
-  if (!modelId.startsWith("http://") && !modelId.startsWith("https://")) {
-    return null;
+  async tryADC() {
+    try {
+      const adcPath = join11(homedir7(), ".config/gcloud/application_default_credentials.json");
+      if (!existsSync6(adcPath)) {
+        log("[VertexAuth] ADC credentials file not found");
+        return null;
+      }
+      const { stdout } = await execAsync("gcloud auth application-default print-access-token", {
+        timeout: 1e4
+      });
+      const token = stdout.trim();
+      if (!token) {
+        log("[VertexAuth] ADC returned empty token");
+        return null;
+      }
+      const expiresAt = Date.now() + 55 * 60 * 1000;
+      return { token, expiresAt };
+    } catch (e) {
+      log(`[VertexAuth] ADC failed: ${e.message}`);
+      return null;
+    }
   }
-  try {
-    const url2 = new URL(modelId);
-    const pathParts = url2.pathname.split("/").filter(Boolean);
-    if (pathParts.length === 0) {
+  async tryServiceAccount() {
+    const credPath = process.env.GOOGLE_APPLICATION_CREDENTIALS;
+    if (!credPath) {
       return null;
     }
-    const modelName = pathParts[pathParts.length - 1];
-    let basePath = "";
-    if (pathParts.length > 1) {
-      const prefix = pathParts.slice(0, -1).join("/");
-      if (prefix)
-        basePath = "/" + prefix;
+    if (!existsSync6(credPath)) {
+      throw new Error(`Service account file not found: ${credPath}
+
+Check GOOGLE_APPLICATION_CREDENTIALS path.`);
+    }
+    try {
+      const { stdout } = await execAsync(`gcloud auth print-access-token --credential-file-override="${credPath}"`, { timeout: 1e4 });
+      const token = stdout.trim();
+      if (!token) {
+        log("[VertexAuth] Service account returned empty token");
+        return null;
+      }
+      const expiresAt = Date.now() + 55 * 60 * 1000;
+      return { token, expiresAt };
+    } catch (e) {
+      log(`[VertexAuth] Service account auth failed: ${e.message}`);
+      return null;
     }
-    const baseUrl = `${url2.protocol}//${url2.host}${basePath}`;
-    return {
-      baseUrl,
-      modelName
-    };
-  } catch {
-    return null;
   }
 }
-function createUrlProvider(parsed) {
+function getVertexConfig() {
+  const projectId = process.env.VERTEX_PROJECT || process.env.GOOGLE_CLOUD_PROJECT;
+  if (!projectId) {
+    return null;
+  }
   return {
-    name: "custom-url",
-    baseUrl: parsed.baseUrl,
-    apiPath: "/v1/chat/completions",
-    envVar: "",
-    prefixes: [],
-    capabilities: {
-      supportsTools: true,
-      supportsVision: false,
-      supportsStreaming: true,
-      supportsJsonMode: true
-    }
+    projectId,
+    location: process.env.VERTEX_LOCATION || "us-central1"
   };
 }
-var getProviders = () => [
-  {
-    name: "ollama",
-    baseUrl: process.env.OLLAMA_HOST || process.env.OLLAMA_BASE_URL || "http://localhost:11434",
-    apiPath: "/v1/chat/completions",
-    envVar: "OLLAMA_BASE_URL",
-    prefixes: ["ollama/", "ollama:"],
-    capabilities: {
-      supportsTools: true,
-      supportsVision: false,
-      supportsStreaming: true,
-      supportsJsonMode: true
-    }
-  },
-  {
-    name: "lmstudio",
-    baseUrl: process.env.LMSTUDIO_BASE_URL || "http://localhost:1234",
-    apiPath: "/v1/chat/completions",
-    envVar: "LMSTUDIO_BASE_URL",
-    prefixes: ["lmstudio/", "lmstudio:", "mlstudio/", "mlstudio:"],
-    capabilities: {
-      supportsTools: true,
-      supportsVision: false,
-      supportsStreaming: true,
-      supportsJsonMode: true
+function validateVertexOAuthConfig() {
+  const config3 = getVertexConfig();
+  if (!config3) {
+    return `Missing VERTEX_PROJECT environment variable.
+
+` + `Set it with:
+` + `  export VERTEX_PROJECT='your-gcp-project-id'
+` + "  export VERTEX_LOCATION='us-central1'  # optional";
+  }
+  const adcPath = join11(homedir7(), ".config/gcloud/application_default_credentials.json");
+  const hasADC = existsSync6(adcPath);
+  const hasServiceAccount = !!process.env.GOOGLE_APPLICATION_CREDENTIALS;
+  if (!hasADC && !hasServiceAccount) {
+    return `No Vertex AI credentials found.
+
+` + `Options:
+` + `1. Run: gcloud auth application-default login
+` + "2. Set: export GOOGLE_APPLICATION_CREDENTIALS='/path/to/service-account.json'";
+  }
+  return null;
+}
+function buildVertexOAuthEndpoint(config3, publisher, model, streaming = true) {
+  const method = streaming ? "streamGenerateContent" : "generateContent";
+  if (publisher === "google") {
+    const sseParam = streaming ? "?alt=sse" : "";
+    return `https://${config3.location}-aiplatform.googleapis.com/v1/` + `projects/${config3.projectId}/locations/${config3.location}/` + `publishers/${publisher}/models/${model}:${method}${sseParam}`;
+  } else if (publisher === "mistralai") {
+    const mistralMethod = streaming ? "streamRawPredict" : "rawPredict";
+    return `https://${config3.location}-aiplatform.googleapis.com/v1/` + `projects/${config3.projectId}/locations/${config3.location}/` + `publishers/mistralai/models/${model}:${mistralMethod}`;
+  } else {
+    return `https://aiplatform.googleapis.com/v1/` + `projects/${config3.projectId}/locations/global/` + `endpoints/openapi/chat/completions`;
+  }
+}
+function getVertexAuthManager() {
+  if (!authManagerInstance) {
+    authManagerInstance = new VertexAuthManager;
+  }
+  return authManagerInstance;
+}
+var execAsync, authManagerInstance = null;
+var init_vertex_auth = __esm(() => {
+  init_logger();
+  execAsync = promisify(exec2);
+});
+
+// ../core/dist/handlers/vertex-oauth-handler.js
+import { writeFileSync as writeFileSync10, mkdirSync as mkdirSync8 } from "node:fs";
+import { homedir as homedir8 } from "node:os";
+import { join as join12 } from "node:path";
+function parseVertexModel(modelId) {
+  const parts = modelId.split("/");
+  if (parts.length === 1) {
+    return { publisher: "google", model: parts[0] };
+  }
+  return { publisher: parts[0], model: parts.slice(1).join("/") };
+}
+
+class VertexOAuthHandler {
+  modelName;
+  port;
+  config;
+  parsed;
+  adapterManager;
+  middlewareManager;
+  sessionTotalCost = 0;
+  sessionInputTokens = 0;
+  sessionOutputTokens = 0;
+  contextWindow = 1e6;
+  toolCallMap = new Map;
+  constructor(modelName, port) {
+    this.modelName = modelName;
+    this.port = port;
+    this.config = getVertexConfig();
+    this.parsed = parseVertexModel(modelName);
+    this.adapterManager = new AdapterManager(`vertex/${modelName}`);
+    this.middlewareManager = new MiddlewareManager;
+    if (this.parsed.publisher === "google") {
+      this.middlewareManager.register(new GeminiThoughtSignatureMiddleware);
     }
-  },
-  {
-    name: "vllm",
-    baseUrl: process.env.VLLM_BASE_URL || "http://localhost:8000",
-    apiPath: "/v1/chat/completions",
-    envVar: "VLLM_BASE_URL",
-    prefixes: ["vllm/", "vllm:"],
-    capabilities: {
-      supportsTools: true,
-      supportsVision: false,
-      supportsStreaming: true,
-      supportsJsonMode: true
+    this.middlewareManager.initialize().catch((err) => log(`[VertexOAuth:${modelName}] Middleware init error: ${err}`));
+  }
+  getPricing() {
+    return getModelPricing("vertex", this.parsed.model);
+  }
+  getApiEndpoint() {
+    return buildVertexOAuthEndpoint(this.config, this.parsed.publisher, this.parsed.model, true);
+  }
+  writeTokenFile(input, output) {
+    try {
+      const total = input + output;
+      const leftPct = this.contextWindow > 0 ? Math.max(0, Math.min(100, Math.round((this.contextWindow - total) / this.contextWindow * 100))) : 100;
+      const data = {
+        input_tokens: input,
+        output_tokens: output,
+        total_tokens: total,
+        total_cost: this.sessionTotalCost,
+        context_window: this.contextWindow,
+        context_left_percent: leftPct,
+        updated_at: Date.now()
+      };
+      const claudishDir = join12(homedir8(), ".claudish");
+      mkdirSync8(claudishDir, { recursive: true });
+      writeFileSync10(join12(claudishDir, `tokens-${this.port}.json`), JSON.stringify(data), "utf-8");
+    } catch (e) {
+      log(`[VertexOAuth] Error writing token file: ${e}`);
     }
-  },
-  {
-    name: "mlx",
-    baseUrl: process.env.MLX_BASE_URL || "http://127.0.0.1:8080",
-    apiPath: "/v1/chat/completions",
-    envVar: "MLX_BASE_URL",
-    prefixes: ["mlx/", "mlx:"],
-    capabilities: {
-      supportsTools: true,
-      supportsVision: false,
-      supportsStreaming: true,
-      supportsJsonMode: true
+  }
+  updateTokenTracking(inputTokens, outputTokens) {
+    this.sessionInputTokens = inputTokens;
+    this.sessionOutputTokens += outputTokens;
+    const pricing = this.getPricing();
+    const cost = inputTokens / 1e6 * pricing.inputCostPer1M + outputTokens / 1e6 * pricing.outputCostPer1M;
+    this.sessionTotalCost += cost;
+    this.writeTokenFile(inputTokens, this.sessionOutputTokens);
+  }
+  buildPayload(claudeRequest) {
+    if (this.parsed.publisher === "google") {
+      return this.buildGeminiPayload(claudeRequest);
+    } else if (this.parsed.publisher === "anthropic") {
+      return this.buildAnthropicPayload(claudeRequest);
+    } else if (this.parsed.publisher === "mistralai" || this.parsed.publisher === "meta") {
+      return this.buildOpenAIPayload(claudeRequest);
+    } else {
+      return this.buildOpenAIPayload(claudeRequest);
     }
   }
-];
+  buildGeminiPayload(claudeRequest) {
+    const contents = this.convertToGeminiMessages(claudeRequest);
+    const payload = {
+      contents,
+      generationConfig: {
+        temperature: claudeRequest.temperature ?? 1,
+        maxOutputTokens: claudeRequest.max_tokens
+      }
+    };
+    if (claudeRequest.system) {
+      let systemContent = Array.isArray(claudeRequest.system) ? claudeRequest.system.map((i) => i.text || i).join(`
 
-// ../core/dist/providers/remote-provider-registry.js
-function resolveRemoteProvider(modelId) {
-  const providers = getRemoteProviders();
-  for (const provider of providers) {
-    for (const prefix of provider.prefixes) {
-      if (modelId.startsWith(prefix)) {
-        return {
-          provider,
-          modelName: modelId.slice(prefix.length)
+`) : claudeRequest.system;
+      systemContent = filterIdentity(systemContent);
+      payload.systemInstruction = { parts: [{ text: systemContent }] };
+    }
+    const tools = this.convertToGeminiTools(claudeRequest);
+    if (tools) {
+      payload.tools = tools;
+    }
+    if (claudeRequest.thinking) {
+      const { budget_tokens } = claudeRequest.thinking;
+      if (this.parsed.model.includes("gemini-3")) {
+        payload.generationConfig.thinkingConfig = {
+          thinkingLevel: budget_tokens >= 16000 ? "high" : "low"
+        };
+      } else {
+        const MAX_GEMINI_BUDGET = 24576;
+        payload.generationConfig.thinkingConfig = {
+          thinkingBudget: Math.min(budget_tokens, MAX_GEMINI_BUDGET)
         };
       }
     }
+    return payload;
   }
-  return null;
-}
-function validateRemoteProviderApiKey(provider) {
-  const apiKey = process.env[provider.apiKeyEnvVar];
-  if (!apiKey) {
-    const examples = {
-      GEMINI_API_KEY: "export GEMINI_API_KEY='your-key' (get from https://aistudio.google.com/app/apikey)",
-      OPENAI_API_KEY: "export OPENAI_API_KEY='sk-...' (get from https://platform.openai.com/api-keys)",
-      OPENROUTER_API_KEY: "export OPENROUTER_API_KEY='sk-or-...' (get from https://openrouter.ai/keys)",
-      MINIMAX_API_KEY: "export MINIMAX_API_KEY='your-key' (get from https://www.minimaxi.com/)",
-      MOONSHOT_API_KEY: "export MOONSHOT_API_KEY='your-key' (get from https://platform.moonshot.cn/)",
-      ZHIPU_API_KEY: "export ZHIPU_API_KEY='your-key' (get from https://open.bigmodel.cn/)"
+  buildAnthropicPayload(claudeRequest) {
+    const payload = {
+      anthropic_version: "vertex-2023-10-16",
+      messages: claudeRequest.messages,
+      max_tokens: claudeRequest.max_tokens || 4096,
+      stream: true
     };
-    const example = examples[provider.apiKeyEnvVar] || `export ${provider.apiKeyEnvVar}='your-key'`;
-    return `Missing ${provider.apiKeyEnvVar} environment variable.
+    if (claudeRequest.system) {
+      payload.system = Array.isArray(claudeRequest.system) ? claudeRequest.system.map((i) => i.text || i).join(`
 
-Set it with:
-  ${example}`;
-  }
+`) : claudeRequest.system;
+    }
+    if (claudeRequest.temperature !== undefined) {
+      payload.temperature = claudeRequest.temperature;
+    }
+    if (claudeRequest.tools && claudeRequest.tools.length > 0) {
+      payload.tools = claudeRequest.tools;
+    }
+    return payload;
+  }
+  buildOpenAIPayload(claudeRequest) {
+    const messages = [];
+    if (claudeRequest.system) {
+      const systemContent = Array.isArray(claudeRequest.system) ? claudeRequest.system.map((i) => i.text || i).join(`
+
+`) : claudeRequest.system;
+      messages.push({ role: "system", content: filterIdentity(systemContent) });
+    }
+    if (claudeRequest.messages) {
+      for (const msg of claudeRequest.messages) {
+        if (msg.role === "user") {
+          const content = this.convertClaudeContentToOpenAI(msg.content);
+          messages.push({ role: "user", content });
+        } else if (msg.role === "assistant") {
+          const content = this.convertClaudeContentToOpenAI(msg.content);
+          messages.push({ role: "assistant", content });
+        }
+      }
+    }
+    const modelId = this.parsed.publisher === "mistralai" ? this.parsed.model : `${this.parsed.publisher}/${this.parsed.model}`;
+    const payload = {
+      model: modelId,
+      messages,
+      max_tokens: claudeRequest.max_tokens || 4096,
+      stream: true
+    };
+    if (claudeRequest.temperature !== undefined) {
+      payload.temperature = claudeRequest.temperature;
+    }
+    if (claudeRequest.tools && claudeRequest.tools.length > 0) {
+      payload.tools = claudeRequest.tools.map((tool) => ({
+        type: "function",
+        function: {
+          name: tool.name,
+          description: tool.description,
+          parameters: tool.input_schema
+        }
+      }));
+    }
+    return payload;
+  }
+  convertClaudeContentToOpenAI(content) {
+    if (typeof content === "string") {
+      return content;
+    }
+    if (Array.isArray(content)) {
+      return content.filter((block) => block.type === "text").map((block) => block.text).join(`
+`);
+    }
+    return "";
+  }
+  convertToGeminiMessages(claudeRequest) {
+    const messages = [];
+    if (claudeRequest.messages) {
+      for (const msg of claudeRequest.messages) {
+        if (msg.role === "user") {
+          const parts = this.convertUserMessageParts(msg);
+          if (parts.length > 0) {
+            messages.push({ role: "user", parts });
+          }
+        } else if (msg.role === "assistant") {
+          const parts = this.convertAssistantMessageParts(msg);
+          if (parts.length > 0) {
+            messages.push({ role: "model", parts });
+          }
+        }
+      }
+    }
+    return messages;
+  }
+  convertUserMessageParts(msg) {
+    const parts = [];
+    if (Array.isArray(msg.content)) {
+      for (const block of msg.content) {
+        if (block.type === "text") {
+          parts.push({ text: block.text });
+        } else if (block.type === "image") {
+          parts.push({
+            inlineData: {
+              mimeType: block.source.media_type,
+              data: block.source.data
+            }
+          });
+        } else if (block.type === "tool_result") {
+          const toolInfo = this.toolCallMap.get(block.tool_use_id);
+          if (toolInfo) {
+            parts.push({
+              functionResponse: {
+                name: toolInfo.name,
+                response: {
+                  content: typeof block.content === "string" ? block.content : JSON.stringify(block.content)
+                }
+              }
+            });
+          }
+        }
+      }
+    } else if (typeof msg.content === "string") {
+      parts.push({ text: msg.content });
+    }
+    return parts;
+  }
+  convertAssistantMessageParts(msg) {
+    const parts = [];
+    if (Array.isArray(msg.content)) {
+      for (const block of msg.content) {
+        if (block.type === "text") {
+          parts.push({ text: block.text });
+        } else if (block.type === "tool_use") {
+          const toolInfo = this.toolCallMap.get(block.id);
+          let thoughtSignature = toolInfo?.thoughtSignature || "skip_thought_signature_validator";
+          const functionCallPart = {
+            functionCall: {
+              name: block.name,
+              args: block.input
+            }
+          };
+          if (thoughtSignature) {
+            functionCallPart.thoughtSignature = thoughtSignature;
+          }
+          parts.push(functionCallPart);
+        }
+      }
+    } else if (typeof msg.content === "string") {
+      parts.push({ text: msg.content });
+    }
+    return parts;
+  }
+  convertToGeminiTools(claudeRequest) {
+    if (!claudeRequest.tools || claudeRequest.tools.length === 0) {
+      return;
+    }
+    const functionDeclarations = claudeRequest.tools.map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      parameters: this.sanitizeSchemaForGemini(tool.input_schema)
+    }));
+    return [{ functionDeclarations }];
+  }
+  sanitizeSchemaForGemini(schema) {
+    if (!schema || typeof schema !== "object")
+      return schema;
+    if (Array.isArray(schema))
+      return schema.map((item) => this.sanitizeSchemaForGemini(item));
+    const result = {};
+    const normalizedType = Array.isArray(schema.type) ? schema.type.filter((t) => t !== "null")[0] || "string" : schema.type || "string";
+    result.type = normalizedType;
+    if (schema.description)
+      result.description = schema.description;
+    if (Array.isArray(schema.enum))
+      result.enum = schema.enum;
+    if (Array.isArray(schema.required))
+      result.required = schema.required;
+    if (schema.properties) {
+      result.properties = {};
+      for (const [key, value] of Object.entries(schema.properties)) {
+        if (value && typeof value === "object") {
+          result.properties[key] = this.sanitizeSchemaForGemini(value);
+        }
+      }
+    }
+    if (schema.items) {
+      result.items = this.sanitizeSchemaForGemini(Array.isArray(schema.items) ? schema.items[0] : schema.items);
+    }
+    return result;
+  }
+  handleGeminiStreamingResponse(c, response) {
+    let isClosed = false;
+    let ping2 = null;
+    const encoder = new TextEncoder;
+    const decoder = new TextDecoder;
+    const toolCallMap = this.toolCallMap;
+    const modelName = this.modelName;
+    return c.body(new ReadableStream({
+      start: async (controller) => {
+        const send = (e, d) => {
+          if (!isClosed) {
+            controller.enqueue(encoder.encode(`event: ${e}
+data: ${JSON.stringify(d)}
+
+`));
+          }
+        };
+        const msgId = `msg_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+        let usage = null;
+        let finalized = false;
+        let textStarted = false;
+        let textIdx = -1;
+        let thinkingStarted = false;
+        let thinkingIdx = -1;
+        let curIdx = 0;
+        const tools = new Map;
+        let lastActivity = Date.now();
+        send("message_start", {
+          type: "message_start",
+          message: {
+            id: msgId,
+            type: "message",
+            role: "assistant",
+            content: [],
+            model: `vertex/${this.modelName}`,
+            stop_reason: null,
+            stop_sequence: null,
+            usage: { input_tokens: 100, output_tokens: 1 }
+          }
+        });
+        ping2 = setInterval(() => {
+          if (!isClosed && Date.now() - lastActivity > 1000) {
+            send("ping", { type: "ping" });
+          }
+        }, 1000);
+        const finalize = async (reason, err) => {
+          if (finalized)
+            return;
+          finalized = true;
+          if (thinkingStarted)
+            send("content_block_stop", { type: "content_block_stop", index: thinkingIdx });
+          if (textStarted)
+            send("content_block_stop", { type: "content_block_stop", index: textIdx });
+          for (const t of Array.from(tools.values())) {
+            if (t.started && !t.closed) {
+              send("content_block_stop", { type: "content_block_stop", index: t.blockIndex });
+              t.closed = true;
+            }
+          }
+          if (usage) {
+            this.updateTokenTracking(usage.promptTokenCount || 0, usage.candidatesTokenCount || 0);
+          }
+          if (reason === "error") {
+            send("error", { type: "error", error: { type: "api_error", message: err } });
+          } else {
+            const hasToolCalls = tools.size > 0;
+            send("message_delta", {
+              type: "message_delta",
+              delta: { stop_reason: hasToolCalls ? "tool_use" : "end_turn", stop_sequence: null },
+              usage: { output_tokens: usage?.candidatesTokenCount || 0 }
+            });
+            send("message_stop", { type: "message_stop" });
+          }
+          if (!isClosed) {
+            try {
+              controller.enqueue(encoder.encode(`data: [DONE]
+
+
+`));
+            } catch {}
+            controller.close();
+            isClosed = true;
+            if (ping2)
+              clearInterval(ping2);
+          }
+        };
+        try {
+          const reader = response.body.getReader();
+          let buffer = "";
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+              break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split(`
+`);
+            buffer = lines.pop() || "";
+            for (const line of lines) {
+              if (!line.trim() || !line.startsWith("data: "))
+                continue;
+              const dataStr = line.slice(6);
+              if (dataStr === "[DONE]") {
+                await finalize("done");
+                return;
+              }
+              try {
+                const chunk = JSON.parse(dataStr);
+                if (chunk.usageMetadata)
+                  usage = chunk.usageMetadata;
+                const candidate = chunk.candidates?.[0];
+                if (candidate?.content?.parts) {
+                  for (const part of candidate.content.parts) {
+                    lastActivity = Date.now();
+                    if (part.thought || part.thoughtText) {
+                      const thinkingContent = part.thought || part.thoughtText;
+                      if (!thinkingStarted) {
+                        thinkingIdx = curIdx++;
+                        send("content_block_start", {
+                          type: "content_block_start",
+                          index: thinkingIdx,
+                          content_block: { type: "thinking", thinking: "" }
+                        });
+                        thinkingStarted = true;
+                      }
+                      send("content_block_delta", {
+                        type: "content_block_delta",
+                        index: thinkingIdx,
+                        delta: { type: "thinking_delta", thinking: thinkingContent }
+                      });
+                    }
+                    if (part.text) {
+                      if (thinkingStarted) {
+                        send("content_block_stop", { type: "content_block_stop", index: thinkingIdx });
+                        thinkingStarted = false;
+                      }
+                      if (!textStarted) {
+                        textIdx = curIdx++;
+                        send("content_block_start", {
+                          type: "content_block_start",
+                          index: textIdx,
+                          content_block: { type: "text", text: "" }
+                        });
+                        textStarted = true;
+                      }
+                      send("content_block_delta", {
+                        type: "content_block_delta",
+                        index: textIdx,
+                        delta: { type: "text_delta", text: part.text }
+                      });
+                    }
+                    if (part.functionCall) {
+                      if (thinkingStarted) {
+                        send("content_block_stop", { type: "content_block_stop", index: thinkingIdx });
+                        thinkingStarted = false;
+                      }
+                      if (textStarted) {
+                        send("content_block_stop", { type: "content_block_stop", index: textIdx });
+                        textStarted = false;
+                      }
+                      const toolIdx = tools.size;
+                      const toolId = `tool_${Date.now()}_${toolIdx}`;
+                      const t = {
+                        id: toolId,
+                        name: part.functionCall.name,
+                        blockIndex: curIdx++,
+                        started: true,
+                        closed: false,
+                        arguments: JSON.stringify(part.functionCall.args || {})
+                      };
+                      tools.set(toolIdx, t);
+                      const thoughtSignature = part.thoughtSignature;
+                      toolCallMap.set(t.id, { name: t.name, thoughtSignature });
+                      send("content_block_start", {
+                        type: "content_block_start",
+                        index: t.blockIndex,
+                        content_block: { type: "tool_use", id: t.id, name: t.name }
+                      });
+                      send("content_block_delta", {
+                        type: "content_block_delta",
+                        index: t.blockIndex,
+                        delta: { type: "input_json_delta", partial_json: t.arguments }
+                      });
+                      send("content_block_stop", { type: "content_block_stop", index: t.blockIndex });
+                      t.closed = true;
+                    }
+                  }
+                }
+                if (candidate?.finishReason === "STOP" || candidate?.finishReason === "MAX_TOKENS") {
+                  await finalize("done");
+                  return;
+                }
+              } catch {}
+            }
+          }
+          await finalize("unexpected");
+        } catch (e) {
+          await finalize("error", String(e));
+        }
+      },
+      cancel() {
+        isClosed = true;
+        if (ping2)
+          clearInterval(ping2);
+      }
+    }), {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive"
+      }
+    });
+  }
+  handleAnthropicStreamingResponse(_c, response) {
+    return new Response(response.body, {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive"
+      }
+    });
+  }
+  handleOpenAIStreamingResponse(c, response) {
+    let isClosed = false;
+    let ping2 = null;
+    const encoder = new TextEncoder;
+    const decoder = new TextDecoder;
+    return c.body(new ReadableStream({
+      start: async (controller) => {
+        const send = (e, d) => {
+          if (!isClosed) {
+            controller.enqueue(encoder.encode(`event: ${e}
+data: ${JSON.stringify(d)}
+
+`));
+          }
+        };
+        const msgId = `msg_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+        let finalized = false;
+        let textStarted = false;
+        let textIdx = 0;
+        let lastActivity = Date.now();
+        send("message_start", {
+          type: "message_start",
+          message: {
+            id: msgId,
+            type: "message",
+            role: "assistant",
+            content: [],
+            model: `vertex/${this.modelName}`,
+            stop_reason: null,
+            stop_sequence: null,
+            usage: { input_tokens: 100, output_tokens: 1 }
+          }
+        });
+        ping2 = setInterval(() => {
+          if (!isClosed && Date.now() - lastActivity > 1000) {
+            send("ping", { type: "ping" });
+          }
+        }, 1000);
+        const finalize = async (reason, err) => {
+          if (finalized)
+            return;
+          finalized = true;
+          if (textStarted) {
+            send("content_block_stop", { type: "content_block_stop", index: textIdx });
+          }
+          if (reason === "error") {
+            send("error", { type: "error", error: { type: "api_error", message: err } });
+          } else {
+            send("message_delta", {
+              type: "message_delta",
+              delta: { stop_reason: "end_turn", stop_sequence: null },
+              usage: { output_tokens: 100 }
+            });
+            send("message_stop", { type: "message_stop" });
+          }
+          if (!isClosed) {
+            try {
+              controller.enqueue(encoder.encode(`data: [DONE]
+
+
+`));
+            } catch {}
+            controller.close();
+            isClosed = true;
+            if (ping2)
+              clearInterval(ping2);
+          }
+        };
+        try {
+          const reader = response.body.getReader();
+          let buffer = "";
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+              break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split(`
+`);
+            buffer = lines.pop() || "";
+            for (const line of lines) {
+              if (!line.trim() || !line.startsWith("data: "))
+                continue;
+              const dataStr = line.slice(6);
+              if (dataStr === "[DONE]") {
+                await finalize("done");
+                return;
+              }
+              try {
+                const chunk = JSON.parse(dataStr);
+                const choice = chunk.choices?.[0];
+                if (choice?.delta?.content) {
+                  lastActivity = Date.now();
+                  if (!textStarted) {
+                    send("content_block_start", {
+                      type: "content_block_start",
+                      index: textIdx,
+                      content_block: { type: "text", text: "" }
+                    });
+                    textStarted = true;
+                  }
+                  send("content_block_delta", {
+                    type: "content_block_delta",
+                    index: textIdx,
+                    delta: { type: "text_delta", text: choice.delta.content }
+                  });
+                }
+                if (choice?.finish_reason) {
+                  await finalize("done");
+                  return;
+                }
+              } catch {}
+            }
+          }
+          await finalize("done");
+        } catch (e) {
+          await finalize("error", String(e));
+        }
+      },
+      cancel() {
+        isClosed = true;
+        if (ping2)
+          clearInterval(ping2);
+      }
+    }), {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive"
+      }
+    });
+  }
+  async handle(c, payload) {
+    const { claudeRequest, droppedParams } = transformOpenAIToClaude(payload);
+    logStructured("Vertex OAuth Request", {
+      targetModel: `vertex/${this.modelName}`,
+      publisher: this.parsed.publisher,
+      model: this.parsed.model,
+      project: this.config.projectId,
+      location: this.config.location,
+      messageCount: claudeRequest.messages?.length || 0,
+      toolCount: claudeRequest.tools?.length || 0
+    });
+    const authManager = getVertexAuthManager();
+    let accessToken;
+    try {
+      accessToken = await authManager.getAccessToken();
+    } catch (e) {
+      log(`[VertexOAuth] Auth failed: ${e.message}`);
+      return c.json({
+        error: {
+          type: "authentication_error",
+          message: e.message
+        }
+      }, 401);
+    }
+    const requestPayload = this.buildPayload(claudeRequest);
+    const endpoint = this.getApiEndpoint();
+    log(`[VertexOAuth] Calling API: ${endpoint}`);
+    const controller = new AbortController;
+    const timeoutId = setTimeout(() => controller.abort(), 30000);
+    let response;
+    try {
+      response = await fetch(endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${accessToken}`
+        },
+        body: JSON.stringify(requestPayload),
+        signal: controller.signal
+      });
+    } catch (fetchError) {
+      clearTimeout(timeoutId);
+      if (fetchError.name === "AbortError") {
+        return c.json({ error: { type: "timeout_error", message: "Request timed out" } }, 504);
+      }
+      return c.json({ error: { type: "network_error", message: fetchError.message } }, 503);
+    } finally {
+      clearTimeout(timeoutId);
+    }
+    log(`[VertexOAuth] Response status: ${response.status}`);
+    if (response.status === 401) {
+      log("[VertexOAuth] Got 401, refreshing token and retrying");
+      await authManager.refreshToken();
+      const newToken = await authManager.getAccessToken();
+      response = await fetch(endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${newToken}`
+        },
+        body: JSON.stringify(requestPayload)
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        return c.json({ error: errorText }, response.status);
+      }
+    }
+    if (!response.ok) {
+      const errorText = await response.text();
+      log(`[VertexOAuth] Error: ${errorText}`);
+      return c.json({ error: errorText }, response.status);
+    }
+    if (droppedParams.length > 0) {
+      c.header("X-Dropped-Params", droppedParams.join(", "));
+    }
+    if (this.parsed.publisher === "google") {
+      return this.handleGeminiStreamingResponse(c, response);
+    } else if (this.parsed.publisher === "anthropic") {
+      return this.handleAnthropicStreamingResponse(c, response);
+    } else {
+      return this.handleOpenAIStreamingResponse(c, response);
+    }
+  }
+  async shutdown() {}
+}
+var init_vertex_oauth_handler = __esm(() => {
+  init_adapter_manager();
+  init_middleware();
+  init_transform();
+  init_logger();
+  init_openai_compat();
+  init_remote_provider_types();
+  init_vertex_auth();
+});
+
+// ../core/dist/providers/provider-registry.js
+function getRegisteredProviders() {
+  return getProviders();
+}
+function resolveProvider(modelId) {
+  const providers = getProviders();
+  for (const provider of providers) {
+    for (const prefix of provider.prefixes) {
+      if (modelId.startsWith(prefix)) {
+        return {
+          provider,
+          modelName: modelId.slice(prefix.length)
+        };
+      }
+    }
+  }
+  return null;
+}
+function isLocalProvider(modelId) {
+  if (resolveProvider(modelId) !== null) {
+    return true;
+  }
+  if (parseUrlModel(modelId) !== null) {
+    return true;
+  }
+  return false;
+}
+function parseUrlModel(modelId) {
+  if (!modelId.startsWith("http://") && !modelId.startsWith("https://")) {
+    return null;
+  }
+  try {
+    const url2 = new URL(modelId);
+    const pathParts = url2.pathname.split("/").filter(Boolean);
+    if (pathParts.length === 0) {
+      return null;
+    }
+    const modelName = pathParts[pathParts.length - 1];
+    let basePath = "";
+    if (pathParts.length > 1) {
+      const prefix = pathParts.slice(0, -1).join("/");
+      if (prefix)
+        basePath = "/" + prefix;
+    }
+    const baseUrl = `${url2.protocol}//${url2.host}${basePath}`;
+    return {
+      baseUrl,
+      modelName
+    };
+  } catch {
+    return null;
+  }
+}
+function createUrlProvider(parsed) {
+  return {
+    name: "custom-url",
+    baseUrl: parsed.baseUrl,
+    apiPath: "/v1/chat/completions",
+    envVar: "",
+    prefixes: [],
+    capabilities: {
+      supportsTools: true,
+      supportsVision: false,
+      supportsStreaming: true,
+      supportsJsonMode: true
+    }
+  };
+}
+var getProviders = () => [
+  {
+    name: "ollama",
+    baseUrl: process.env.OLLAMA_HOST || process.env.OLLAMA_BASE_URL || "http://localhost:11434",
+    apiPath: "/v1/chat/completions",
+    envVar: "OLLAMA_BASE_URL",
+    prefixes: ["ollama/", "ollama:"],
+    capabilities: {
+      supportsTools: true,
+      supportsVision: false,
+      supportsStreaming: true,
+      supportsJsonMode: true
+    }
+  },
+  {
+    name: "lmstudio",
+    baseUrl: process.env.LMSTUDIO_BASE_URL || "http://localhost:1234",
+    apiPath: "/v1/chat/completions",
+    envVar: "LMSTUDIO_BASE_URL",
+    prefixes: ["lmstudio/", "lmstudio:", "mlstudio/", "mlstudio:"],
+    capabilities: {
+      supportsTools: true,
+      supportsVision: false,
+      supportsStreaming: true,
+      supportsJsonMode: true
+    }
+  },
+  {
+    name: "vllm",
+    baseUrl: process.env.VLLM_BASE_URL || "http://localhost:8000",
+    apiPath: "/v1/chat/completions",
+    envVar: "VLLM_BASE_URL",
+    prefixes: ["vllm/", "vllm:"],
+    capabilities: {
+      supportsTools: true,
+      supportsVision: false,
+      supportsStreaming: true,
+      supportsJsonMode: true
+    }
+  },
+  {
+    name: "mlx",
+    baseUrl: process.env.MLX_BASE_URL || "http://127.0.0.1:8080",
+    apiPath: "/v1/chat/completions",
+    envVar: "MLX_BASE_URL",
+    prefixes: ["mlx/", "mlx:"],
+    capabilities: {
+      supportsTools: true,
+      supportsVision: false,
+      supportsStreaming: true,
+      supportsJsonMode: true
+    }
+  }
+];
+
+// ../core/dist/providers/remote-provider-registry.js
+function resolveRemoteProvider(modelId) {
+  const providers = getRemoteProviders();
+  for (const provider of providers) {
+    for (const prefix of provider.prefixes) {
+      if (modelId.startsWith(prefix)) {
+        return {
+          provider,
+          modelName: modelId.slice(prefix.length)
+        };
+      }
+    }
+  }
+  return null;
+}
+function validateRemoteProviderApiKey(provider) {
+  const apiKey = process.env[provider.apiKeyEnvVar];
+  if (!apiKey) {
+    const examples = {
+      GEMINI_API_KEY: "export GEMINI_API_KEY='your-key' (get from https://aistudio.google.com/app/apikey)",
+      VERTEX_API_KEY: "export VERTEX_API_KEY='your-key' (get from Google Cloud Console)",
+      OPENAI_API_KEY: "export OPENAI_API_KEY='sk-...' (get from https://platform.openai.com/api-keys)",
+      OPENROUTER_API_KEY: "export OPENROUTER_API_KEY='sk-or-...' (get from https://openrouter.ai/keys)",
+      MINIMAX_API_KEY: "export MINIMAX_API_KEY='your-key' (get from https://www.minimaxi.com/)",
+      MOONSHOT_API_KEY: "export MOONSHOT_API_KEY='your-key' (get from https://platform.moonshot.cn/)",
+      ZHIPU_API_KEY: "export ZHIPU_API_KEY='your-key' (get from https://open.bigmodel.cn/)"
+    };
+    const example = examples[provider.apiKeyEnvVar] || `export ${provider.apiKeyEnvVar}='your-key'`;
+    return `Missing ${provider.apiKeyEnvVar} environment variable.
+
+Set it with:
+  ${example}`;
+  }
   return null;
 }
 function getRegisteredRemoteProviders() {
@@ -57887,6 +58810,20 @@ var getRemoteProviders = () => [
       supportsReasoning: true
     }
   },
+  {
+    name: "vertex",
+    baseUrl: process.env.VERTEX_BASE_URL || "https://aiplatform.googleapis.com",
+    apiPath: "/v1/publishers/google/models/{model}:streamGenerateContent?alt=sse",
+    apiKeyEnvVar: "VERTEX_API_KEY",
+    prefixes: ["vertex/", "v/"],
+    capabilities: {
+      supportsTools: true,
+      supportsVision: true,
+      supportsStreaming: true,
+      supportsJsonMode: false,
+      supportsReasoning: true
+    }
+  },
   {
     name: "openai",
     baseUrl: process.env.OPENAI_BASE_URL || "https://api.openai.com",
@@ -58010,6 +58947,29 @@ async function createProxyServer(port, openrouterApiKey, model, monitorMode = fa
     if (resolved.provider.name === "openrouter") {
       return null;
     }
+    if (resolved.provider.name === "vertex") {
+      const hasApiKey = !!process.env.VERTEX_API_KEY;
+      const vertexConfig = getVertexConfig();
+      let handler2;
+      if (hasApiKey) {
+        const apiKey2 = process.env.VERTEX_API_KEY;
+        handler2 = new GeminiHandler(resolved.provider, resolved.modelName, apiKey2, port);
+        log(`[Proxy] Created Vertex AI Express handler: ${resolved.modelName}`);
+      } else if (vertexConfig) {
+        const oauthError = validateVertexOAuthConfig();
+        if (oauthError) {
+          log(`[Proxy] Vertex OAuth config error: ${oauthError}`);
+          return null;
+        }
+        handler2 = new VertexOAuthHandler(resolved.modelName, port);
+        log(`[Proxy] Created Vertex AI OAuth handler: ${resolved.modelName} (project: ${vertexConfig.projectId})`);
+      } else {
+        log(`[Proxy] Vertex AI requires either VERTEX_API_KEY or VERTEX_PROJECT`);
+        return null;
+      }
+      remoteProviderHandlers.set(targetModel, handler2);
+      return handler2;
+    }
     const apiKeyError = validateRemoteProviderApiKey(resolved.provider);
     if (apiKeyError) {
       throw new Error(apiKeyError);
@@ -58125,6 +59085,8 @@ var init_proxy_server = __esm(() => {
   init_gemini_handler();
   init_openai_handler();
   init_anthropic_compat_handler();
+  init_vertex_oauth_handler();
+  init_vertex_auth();
 });
 
 // ../core/dist/index.js
@@ -58177,15 +59139,15 @@ var init_dist11 = __esm(() => {
 });
 
 // src/model-loader.ts
-import { readFileSync as readFileSync5, existsSync as existsSync6 } from "node:fs";
-import { join as join11, dirname as dirname4 } from "node:path";
+import { readFileSync as readFileSync5, existsSync as existsSync7 } from "node:fs";
+import { join as join13, dirname as dirname4 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 function loadModelInfo2() {
   if (_cachedModelInfo2) {
     return _cachedModelInfo2;
   }
-  const jsonPath = join11(__dirname5, "../recommended-models.json");
-  if (existsSync6(jsonPath)) {
+  const jsonPath = join13(__dirname5, "../recommended-models.json");
+  if (existsSync7(jsonPath)) {
     try {
       const jsonContent = readFileSync5(jsonPath, "utf-8");
       const data = JSON.parse(jsonContent);
@@ -58217,8 +59179,8 @@ function getAvailableModels() {
   if (_cachedModelIds) {
     return _cachedModelIds;
   }
-  const jsonPath = join11(__dirname5, "../recommended-models.json");
-  if (existsSync6(jsonPath)) {
+  const jsonPath = join13(__dirname5, "../recommended-models.json");
+  if (existsSync7(jsonPath)) {
     try {
       const jsonContent = readFileSync5(jsonPath, "utf-8");
       const data = JSON.parse(jsonContent);
@@ -58280,9 +59242,9 @@ __export(exports_cli, {
   parseArgs: () => parseArgs,
   getVersion: () => getVersion
 });
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync10, existsSync as existsSync7, mkdirSync as mkdirSync8, copyFileSync } from "node:fs";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync11, existsSync as existsSync8, mkdirSync as mkdirSync9, copyFileSync } from "node:fs";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
-import { dirname as dirname5, join as join12 } from "node:path";
+import { dirname as dirname5, join as join14 } from "node:path";
 function getVersion() {
   return VERSION;
 }
@@ -58555,7 +59517,7 @@ async function fetchOllamaModels() {
 }
 async function searchAndPrintModels(query, forceUpdate) {
   let models = [];
-  if (!forceUpdate && existsSync7(ALL_MODELS_JSON_PATH2)) {
+  if (!forceUpdate && existsSync8(ALL_MODELS_JSON_PATH2)) {
     try {
       const cacheData = JSON.parse(readFileSync6(ALL_MODELS_JSON_PATH2, "utf-8"));
       const lastUpdated = new Date(cacheData.lastUpdated);
@@ -58574,7 +59536,7 @@ async function searchAndPrintModels(query, forceUpdate) {
         throw new Error(`API returned ${response.status}`);
       const data = await response.json();
       models = data.data;
-      writeFileSync10(ALL_MODELS_JSON_PATH2, JSON.stringify({
+      writeFileSync11(ALL_MODELS_JSON_PATH2, JSON.stringify({
         lastUpdated: new Date().toISOString(),
         models
       }), "utf-8");
@@ -58653,7 +59615,7 @@ Found ${results.length} matching models:
 async function printAllModels(jsonOutput, forceUpdate) {
   let models = [];
   const ollamaModels = await fetchOllamaModels();
-  if (!forceUpdate && existsSync7(ALL_MODELS_JSON_PATH2)) {
+  if (!forceUpdate && existsSync8(ALL_MODELS_JSON_PATH2)) {
     try {
       const cacheData = JSON.parse(readFileSync6(ALL_MODELS_JSON_PATH2, "utf-8"));
       const lastUpdated = new Date(cacheData.lastUpdated);
@@ -58675,7 +59637,7 @@ async function printAllModels(jsonOutput, forceUpdate) {
         throw new Error(`API returned ${response.status}`);
       const data = await response.json();
       models = data.data;
-      writeFileSync10(ALL_MODELS_JSON_PATH2, JSON.stringify({
+      writeFileSync11(ALL_MODELS_JSON_PATH2, JSON.stringify({
         lastUpdated: new Date().toISOString(),
         models
       }), "utf-8");
@@ -58785,7 +59747,7 @@ async function printAllModels(jsonOutput, forceUpdate) {
   console.log("Top models:    claudish --top-models");
 }
 function isCacheStale() {
-  if (!existsSync7(MODELS_JSON_PATH)) {
+  if (!existsSync8(MODELS_JSON_PATH)) {
     return true;
   }
   try {
@@ -58884,7 +59846,7 @@ async function updateModelsFromOpenRouter() {
       providers.add(provider);
     }
     let version2 = "1.1.5";
-    if (existsSync7(MODELS_JSON_PATH)) {
+    if (existsSync8(MODELS_JSON_PATH)) {
       try {
         const existing = JSON.parse(readFileSync6(MODELS_JSON_PATH, "utf-8"));
         version2 = existing.version || version2;
@@ -58896,7 +59858,7 @@ async function updateModelsFromOpenRouter() {
       source: "https://openrouter.ai/models?categories=programming&fmt=cards&order=top-weekly",
       models: recommendations
     };
-    writeFileSync10(MODELS_JSON_PATH, JSON.stringify(updatedData, null, 2), "utf-8");
+    writeFileSync11(MODELS_JSON_PATH, JSON.stringify(updatedData, null, 2), "utf-8");
     console.error(`✅ Updated ${recommendations.length} models (last updated: ${updatedData.lastUpdated})`);
   } catch (error46) {
     console.error(`❌ Failed to update models: ${error46 instanceof Error ? error46.message : String(error46)}`);
@@ -58933,6 +59895,7 @@ USAGE:
 MODEL ROUTING (prefix-based):
   (no prefix)      OpenRouter (default)   claudish --model openai/gpt-5.2 "task"
   g/, gemini/      Google Gemini API      claudish --model g/gemini-2.0-flash "task"
+  v/, vertex/      Vertex AI (OAuth)      claudish --model v/gemini-2.5-flash "task"
   oai/             OpenAI Direct API      claudish --model oai/gpt-4o "task"
   mmax/, mm/       MiniMax Direct API     claudish --model mmax/MiniMax-M2.1 "task"
   kimi/, moonshot/ Kimi Direct API        claudish --model kimi/kimi-k2-thinking-turbo "task"
@@ -59009,6 +59972,9 @@ ENVIRONMENT VARIABLES:
   API Keys (at least one required for cloud models):
   OPENROUTER_API_KEY              OpenRouter API key (default backend)
   GEMINI_API_KEY                  Google Gemini API key (for g/ prefix)
+  VERTEX_API_KEY                  Vertex AI Express API key (for v/ prefix)
+  VERTEX_PROJECT                  Vertex AI project ID (OAuth mode, for v/ prefix)
+  VERTEX_LOCATION                 Vertex AI region (default: us-central1)
   OPENAI_API_KEY                  OpenAI API key (for oai/ prefix)
   MINIMAX_API_KEY                 MiniMax API key (for mmax/, mm/ prefix)
   MOONSHOT_API_KEY                Kimi/Moonshot API key (for kimi/, moonshot/ prefix)
@@ -59060,6 +60026,15 @@ EXAMPLES:
   claudish --model g/gemini-2.0-flash "quick fix"
   claudish --model gemini/gemini-2.5-pro "complex analysis"
 
+  # Vertex AI (Google Cloud - supports Google + partner models)
+  # Express mode (API key):
+  VERTEX_API_KEY=... claudish --model v/gemini-2.5-flash "task"
+  # OAuth mode (gcloud auth):
+  VERTEX_PROJECT=my-project claudish --model v/gemini-2.5-flash "task"
+  # Partner models (MiniMax, Mistral on Vertex):
+  claudish --model vertex/minimaxai/minimax-m2-maas "task"
+  claudish --model vertex/mistralai/codestral-2 "write code"
+
   # Direct OpenAI API
   claudish --model oai/gpt-4o "implement feature"
   claudish --model oai/o1 "complex reasoning"
@@ -59142,7 +60117,7 @@ MORE INFO:
 }
 function printAIAgentGuide() {
   try {
-    const guidePath = join12(__dirname6, "../AI_AGENT_GUIDE.md");
+    const guidePath = join14(__dirname6, "../AI_AGENT_GUIDE.md");
     const guideContent = readFileSync6(guidePath, "utf-8");
     console.log(guideContent);
   } catch (error46) {
@@ -59159,19 +60134,19 @@ async function initializeClaudishSkill() {
   console.log(`\uD83D\uDD27 Initializing Claudish skill in current project...
 `);
   const cwd = process.cwd();
-  const claudeDir = join12(cwd, ".claude");
-  const skillsDir = join12(claudeDir, "skills");
-  const claudishSkillDir = join12(skillsDir, "claudish-usage");
-  const skillFile = join12(claudishSkillDir, "SKILL.md");
-  if (existsSync7(skillFile)) {
+  const claudeDir = join14(cwd, ".claude");
+  const skillsDir = join14(claudeDir, "skills");
+  const claudishSkillDir = join14(skillsDir, "claudish-usage");
+  const skillFile = join14(claudishSkillDir, "SKILL.md");
+  if (existsSync8(skillFile)) {
     console.log("✅ Claudish skill already installed at:");
     console.log(`   ${skillFile}
 `);
     console.log("\uD83D\uDCA1 To reinstall, delete the file and run 'claudish --init' again.");
     return;
   }
-  const sourceSkillPath = join12(__dirname6, "../skills/claudish-usage/SKILL.md");
-  if (!existsSync7(sourceSkillPath)) {
+  const sourceSkillPath = join14(__dirname6, "../skills/claudish-usage/SKILL.md");
+  if (!existsSync8(sourceSkillPath)) {
     console.error("❌ Error: Claudish skill file not found in installation.");
     console.error(`   Expected at: ${sourceSkillPath}`);
     console.error(`
@@ -59180,16 +60155,16 @@ async function initializeClaudishSkill() {
     process.exit(1);
   }
   try {
-    if (!existsSync7(claudeDir)) {
-      mkdirSync8(claudeDir, { recursive: true });
+    if (!existsSync8(claudeDir)) {
+      mkdirSync9(claudeDir, { recursive: true });
       console.log("\uD83D\uDCC1 Created .claude/ directory");
     }
-    if (!existsSync7(skillsDir)) {
-      mkdirSync8(skillsDir, { recursive: true });
+    if (!existsSync8(skillsDir)) {
+      mkdirSync9(skillsDir, { recursive: true });
       console.log("\uD83D\uDCC1 Created .claude/skills/ directory");
     }
-    if (!existsSync7(claudishSkillDir)) {
-      mkdirSync8(claudishSkillDir, { recursive: true });
+    if (!existsSync8(claudishSkillDir)) {
+      mkdirSync9(claudishSkillDir, { recursive: true });
       console.log("\uD83D\uDCC1 Created .claude/skills/claudish-usage/ directory");
     }
     copyFileSync(sourceSkillPath, skillFile);
@@ -59231,7 +60206,7 @@ function printAvailableModels() {
   let lastUpdated = "unknown";
   let models = [];
   try {
-    if (existsSync7(MODELS_JSON_PATH)) {
+    if (existsSync8(MODELS_JSON_PATH)) {
       const data = JSON.parse(readFileSync6(MODELS_JSON_PATH, "utf-8"));
       lastUpdated = data.lastUpdated || "unknown";
       models = data.models || [];
@@ -59283,7 +60258,7 @@ Force update: claudish --list-models --force-update
 `);
 }
 function printAvailableModelsJSON() {
-  const jsonPath = join12(__dirname6, "../recommended-models.json");
+  const jsonPath = join14(__dirname6, "../recommended-models.json");
   try {
     const jsonContent = readFileSync6(jsonPath, "utf-8");
     const data = JSON.parse(jsonContent);
@@ -59309,7 +60284,7 @@ function printAvailableModelsJSON() {
     console.log(JSON.stringify(output, null, 2));
   }
 }
-var __filename6, __dirname6, VERSION = "3.3.5", CACHE_MAX_AGE_DAYS3 = 2, MODELS_JSON_PATH, ALL_MODELS_JSON_PATH2;
+var __filename6, __dirname6, VERSION = "3.5.0", CACHE_MAX_AGE_DAYS3 = 2, MODELS_JSON_PATH, ALL_MODELS_JSON_PATH2;
 var init_cli = __esm(() => {
   init_dist11();
   init_model_loader2();
@@ -59317,11 +60292,11 @@ var init_cli = __esm(() => {
   __filename6 = fileURLToPath5(import.meta.url);
   __dirname6 = dirname5(__filename6);
   try {
-    const packageJson = JSON.parse(readFileSync6(join12(__dirname6, "../package.json"), "utf-8"));
+    const packageJson = JSON.parse(readFileSync6(join14(__dirname6, "../package.json"), "utf-8"));
     VERSION = packageJson.version;
   } catch {}
-  MODELS_JSON_PATH = join12(__dirname6, "../recommended-models.json");
-  ALL_MODELS_JSON_PATH2 = join12(__dirname6, "../all-models.json");
+  MODELS_JSON_PATH = join14(__dirname6, "../recommended-models.json");
+  ALL_MODELS_JSON_PATH2 = join14(__dirname6, "../all-models.json");
 });
 
 // src/update-checker.ts
@@ -59333,31 +60308,31 @@ __export(exports_update_checker, {
   checkForUpdates: () => checkForUpdates
 });
 import { execSync } from "node:child_process";
-import { existsSync as existsSync8, mkdirSync as mkdirSync9, readFileSync as readFileSync7, unlinkSync, writeFileSync as writeFileSync11 } from "node:fs";
-import { homedir as homedir7, platform, tmpdir } from "node:os";
-import { join as join13 } from "node:path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync10, readFileSync as readFileSync7, unlinkSync, writeFileSync as writeFileSync12 } from "node:fs";
+import { homedir as homedir9, platform, tmpdir } from "node:os";
+import { join as join15 } from "node:path";
 import { createInterface as createInterface2 } from "node:readline";
 function getCacheFilePath() {
   let cacheDir;
   if (isWindows) {
-    const localAppData = process.env.LOCALAPPDATA || join13(homedir7(), "AppData", "Local");
-    cacheDir = join13(localAppData, "claudish");
+    const localAppData = process.env.LOCALAPPDATA || join15(homedir9(), "AppData", "Local");
+    cacheDir = join15(localAppData, "claudish");
   } else {
-    cacheDir = join13(homedir7(), ".cache", "claudish");
+    cacheDir = join15(homedir9(), ".cache", "claudish");
   }
   try {
-    if (!existsSync8(cacheDir)) {
-      mkdirSync9(cacheDir, { recursive: true });
+    if (!existsSync9(cacheDir)) {
+      mkdirSync10(cacheDir, { recursive: true });
     }
-    return join13(cacheDir, "update-check.json");
+    return join15(cacheDir, "update-check.json");
   } catch {
-    return join13(tmpdir(), "claudish-update-check.json");
+    return join15(tmpdir(), "claudish-update-check.json");
   }
 }
 function readCache() {
   try {
     const cachePath = getCacheFilePath();
-    if (!existsSync8(cachePath)) {
+    if (!existsSync9(cachePath)) {
       return null;
     }
     const data = JSON.parse(readFileSync7(cachePath, "utf-8"));
@@ -59373,7 +60348,7 @@ function writeCache(latestVersion) {
       lastCheck: Date.now(),
       latestVersion
     };
-    writeFileSync11(cachePath, JSON.stringify(data), "utf-8");
+    writeFileSync12(cachePath, JSON.stringify(data), "utf-8");
   } catch {}
 }
 function isCacheValid(cache) {
@@ -59383,7 +60358,7 @@ function isCacheValid(cache) {
 function clearCache() {
   try {
     const cachePath = getCacheFilePath();
-    if (existsSync8(cachePath)) {
+    if (existsSync9(cachePath)) {
       unlinkSync(cachePath);
     }
   } catch {}
@@ -59649,17 +60624,17 @@ __export(exports_claude_runner, {
   checkClaudeInstalled: () => checkClaudeInstalled
 });
 import { spawn } from "node:child_process";
-import { writeFileSync as writeFileSync12, unlinkSync as unlinkSync2, mkdirSync as mkdirSync10 } from "node:fs";
+import { writeFileSync as writeFileSync13, unlinkSync as unlinkSync2, mkdirSync as mkdirSync11 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import { join as join14 } from "node:path";
+import { join as join16 } from "node:path";
 function isWindows2() {
   return process.platform === "win32";
 }
 function createStatusLineScript(tokenFilePath) {
   const homeDir = process.env.HOME || process.env.USERPROFILE || tmpdir2();
-  const claudishDir = join14(homeDir, ".claudish");
+  const claudishDir = join16(homeDir, ".claudish");
   const timestamp = Date.now();
-  const scriptPath = join14(claudishDir, `status-${timestamp}.js`);
+  const scriptPath = join16(claudishDir, `status-${timestamp}.js`);
   const escapedTokenPath = tokenFilePath.replace(/\\/g, "\\\\");
   const script = `
 const fs = require('fs');
@@ -59703,18 +60678,18 @@ process.stdin.on('end', () => {
   }
 });
 `;
-  writeFileSync12(scriptPath, script, "utf-8");
+  writeFileSync13(scriptPath, script, "utf-8");
   return scriptPath;
 }
 function createTempSettingsFile(modelDisplay, port) {
   const homeDir = process.env.HOME || process.env.USERPROFILE || tmpdir2();
-  const claudishDir = join14(homeDir, ".claudish");
+  const claudishDir = join16(homeDir, ".claudish");
   try {
-    mkdirSync10(claudishDir, { recursive: true });
+    mkdirSync11(claudishDir, { recursive: true });
   } catch {}
   const timestamp = Date.now();
-  const tempPath = join14(claudishDir, `settings-${timestamp}.json`);
-  const tokenFilePath = join14(claudishDir, `tokens-${port}.json`);
+  const tempPath = join16(claudishDir, `settings-${timestamp}.json`);
+  const tokenFilePath = join16(claudishDir, `tokens-${port}.json`);
   let statusCommand;
   if (isWindows2()) {
     const scriptPath = createStatusLineScript(tokenFilePath);
@@ -59736,7 +60711,7 @@ function createTempSettingsFile(modelDisplay, port) {
       padding: 0
     }
   };
-  writeFileSync12(tempPath, JSON.stringify(settings, null, 2), "utf-8");
+  writeFileSync13(tempPath, JSON.stringify(settings, null, 2), "utf-8");
   return tempPath;
 }
 async function runClaudeWithProxy(config3, proxyUrl) {