fix: recognize google-vertex-anthropic as Claude provider (#1700)

src/hooks/anthropic-effort/hook.ts

@@ -7,7 +7,7 @@ function normalizeModelID(modelID: string): string {
 }
 
 function isClaudeProvider(providerID: string, modelID: string): boolean {
-  if (["anthropic", "opencode"].includes(providerID)) return true
+  if (["anthropic", "google-vertex-anthropic", "opencode"].includes(providerID)) return true
   if (providerID === "github-copilot" && modelID.toLowerCase().includes("claude")) return true
   return false
 }

src/hooks/anthropic-effort/index.test.ts

@@ -88,6 +88,21 @@ describe("createAnthropicEffortHook", () => {
       expect(output.options.effort).toBe("max")
     })
 
+    it("should inject effort max for google-vertex-anthropic provider", async () => {
+      //#given google-vertex-anthropic provider with claude-opus-4-6
+      const hook = createAnthropicEffortHook()
+      const { input, output } = createMockParams({
+        providerID: "google-vertex-anthropic",
+        modelID: "claude-opus-4-6",
+      })
+
+      //#when chat.params hook is called
+      await hook["chat.params"](input, output)
+
+      //#then effort should be injected
+      expect(output.options.effort).toBe("max")
+    })
+
     it("should handle normalized model ID with dots (opus-4.6)", async () => {
       //#given model ID with dots instead of hyphens
       const hook = createAnthropicEffortHook()

src/hooks/context-window-monitor.test.ts

@@ -113,6 +113,42 @@ describe("context-window-monitor", () => {
     expect(ctx.client.session.messages).not.toHaveBeenCalled()
   })
 
+  it("should append context reminder for google-vertex-anthropic provider", async () => {
+    //#given cached usage for google-vertex-anthropic above threshold
+    const hook = createContextWindowMonitorHook(ctx as never)
+    const sessionID = "ses_vertex_anthropic_high_usage"
+
+    await hook.event({
+      event: {
+        type: "message.updated",
+        properties: {
+          info: {
+            role: "assistant",
+            sessionID,
+            providerID: "google-vertex-anthropic",
+            finish: true,
+            tokens: {
+              input: 150000,
+              output: 1000,
+              reasoning: 0,
+              cache: { read: 10000, write: 0 },
+            },
+          },
+        },
+      },
+    })
+
+    //#when tool.execute.after runs
+    const output = { title: "", output: "original", metadata: null }
+    await hook["tool.execute.after"](
+      { tool: "bash", sessionID, callID: "call_1" },
+      output
+    )
+
+    //#then context reminder should be appended
+    expect(output.output).toContain("context remaining")
+  })
+
   // #given session is deleted
   // #when session.deleted event fires
   // #then cached data should be cleaned up

src/hooks/context-window-monitor.ts

@@ -27,6 +27,10 @@ interface CachedTokenState {
   tokens: TokenInfo
 }
 
+function isAnthropicProvider(providerID: string): boolean {
+  return providerID === "anthropic" || providerID === "google-vertex-anthropic"
+}
+
 export function createContextWindowMonitorHook(_ctx: PluginInput) {
   const remindedSessions = new Set<string>()
   const tokenCache = new Map<string, CachedTokenState>()
@@ -42,7 +46,7 @@ export function createContextWindowMonitorHook(_ctx: PluginInput) {
     const cached = tokenCache.get(sessionID)
     if (!cached) return
 
-    if (cached.providerID !== "anthropic") return
+    if (!isAnthropicProvider(cached.providerID)) return
 
     const lastTokens = cached.tokens
     const totalInputTokens = (lastTokens?.input ?? 0) + (lastTokens?.cache?.read ?? 0)

src/hooks/preemptive-compaction.test.ts

@@ -123,6 +123,43 @@ describe("preemptive-compaction", () => {
     expect(ctx.client.session.summarize).toHaveBeenCalled()
   })
 
+  it("should trigger compaction for google-vertex-anthropic provider", async () => {
+    //#given google-vertex-anthropic usage above threshold
+    const hook = createPreemptiveCompactionHook(ctx as never)
+    const sessionID = "ses_vertex_anthropic_high"
+
+    await hook.event({
+      event: {
+        type: "message.updated",
+        properties: {
+          info: {
+            role: "assistant",
+            sessionID,
+            providerID: "google-vertex-anthropic",
+            modelID: "claude-sonnet-4-5",
+            finish: true,
+            tokens: {
+              input: 170000,
+              output: 1000,
+              reasoning: 0,
+              cache: { read: 10000, write: 0 },
+            },
+          },
+        },
+      },
+    })
+
+    //#when tool.execute.after runs
+    const output = { title: "", output: "test", metadata: null }
+    await hook["tool.execute.after"](
+      { tool: "bash", sessionID, callID: "call_1" },
+      output
+    )
+
+    //#then summarize should be triggered
+    expect(ctx.client.session.summarize).toHaveBeenCalled()
+  })
+
   // #given session deleted
   // #then cache should be cleaned up
   it("should clean up cache on session.deleted", async () => {

src/hooks/preemptive-compaction.ts

@@ -23,6 +23,10 @@ interface CachedCompactionState {
   tokens: TokenInfo
 }
 
+function isAnthropicProvider(providerID: string): boolean {
+  return providerID === "anthropic" || providerID === "google-vertex-anthropic"
+}
+
 type PluginInput = {
   client: {
     session: {
@@ -55,7 +59,7 @@ export function createPreemptiveCompactionHook(ctx: PluginInput) {
     if (!cached) return
 
     const actualLimit =
-      cached.providerID === "anthropic"
+      isAnthropicProvider(cached.providerID)
         ? ANTHROPIC_ACTUAL_LIMIT
         : DEFAULT_ACTUAL_LIMIT
 

src/hooks/think-mode/index.test.ts

@@ -214,6 +214,27 @@ describe("createThinkModeHook integration", () => {
       expect(message.thinking).toBeDefined()
     })
 
+    it("should work for direct google-vertex-anthropic provider", async () => {
+      //#given direct google-vertex-anthropic provider
+      const hook = createThinkModeHook()
+      const input = createMockInput(
+        "google-vertex-anthropic",
+        "claude-opus-4-6",
+        "think deeply"
+      )
+
+      //#when the chat.params hook is called
+      await hook["chat.params"](input, sessionID)
+
+      //#then should upgrade model and inject Claude thinking config
+      const message = input.message as MessageWithInjectedProps
+      expect(input.message.model?.modelID).toBe("claude-opus-4-6-high")
+      expect(message.thinking).toBeDefined()
+      expect((message.thinking as Record<string, unknown>)?.budgetTokens).toBe(
+        64000
+      )
+    })
+
     it("should still work for direct google provider", async () => {
       // given direct google provider
       const hook = createThinkModeHook()

src/hooks/think-mode/switcher.test.ts

@@ -266,6 +266,24 @@ describe("think-mode switcher", () => {
       expect((config?.thinking as Record<string, unknown>)?.type).toBe("enabled")
     })
 
+    it("should work for direct google-vertex-anthropic provider", () => {
+      //#given direct google-vertex-anthropic provider
+      const config = getThinkingConfig(
+        "google-vertex-anthropic",
+        "claude-opus-4-6"
+      )
+
+      //#when thinking config is resolved
+
+      //#then it should return anthropic-style thinking config
+      expect(config).not.toBeNull()
+      expect(config?.thinking).toBeDefined()
+      expect((config?.thinking as Record<string, unknown>)?.type).toBe("enabled")
+      expect((config?.thinking as Record<string, unknown>)?.budgetTokens).toBe(
+        64000
+      )
+    })
+
     it("should still work for direct google provider", () => {
       // given direct google provider
       const config = getThinkingConfig("google", "gemini-3-pro")
@@ -314,6 +332,17 @@ describe("think-mode switcher", () => {
       expect(config.maxTokens).toBe(128000)
     })
 
+    it("should have correct structure for google-vertex-anthropic", () => {
+      //#given google-vertex-anthropic config entry
+      const config = THINKING_CONFIGS["google-vertex-anthropic"]
+
+      //#when structure is validated
+
+      //#then it should match anthropic style structure
+      expect(config.thinking).toBeDefined()
+      expect(config.maxTokens).toBe(128000)
+    })
+
     it("should have correct structure for google", () => {
       const config = THINKING_CONFIGS.google
       expect(config.providerOptions).toBeDefined()

src/hooks/think-mode/switcher.ts

@@ -121,6 +121,13 @@ export const THINKING_CONFIGS = {
     },
     maxTokens: 128000,
   },
+  "google-vertex-anthropic": {
+    thinking: {
+      type: "enabled",
+      budgetTokens: 64000,
+    },
+    maxTokens: 128000,
+  },
   "amazon-bedrock": {
     reasoningConfig: {
       type: "enabled",
@@ -164,6 +171,7 @@ export const THINKING_CONFIGS = {
 
 const THINKING_CAPABLE_MODELS = {
   anthropic: ["claude-sonnet-4", "claude-opus-4", "claude-3"],
+  "google-vertex-anthropic": ["claude-sonnet-4", "claude-opus-4", "claude-3"],
   "amazon-bedrock": ["claude", "anthropic"],
   google: ["gemini-2", "gemini-3"],
   "google-vertex": ["gemini-2", "gemini-3"],