@openclaw/anthropic-vertex-provider 2026.6.5 → 2026.6.6-beta.2

package/dist/index.js

@@ -1,4 +1,5 @@
 import { hasAnthropicVertexAvailableAuth, resolveAnthropicVertexConfigApiKey } from "./region.js";
+import { normalizeAnthropicVertexResolvedModel } from "./provider-catalog.js";
 import { mergeImplicitAnthropicVertexProvider, resolveImplicitAnthropicVertexProvider } from "./api.js";
 import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
 import { readConfiguredProviderCatalogEntries } from "openclaw/plugin-sdk/provider-catalog-shared";
@@ -34,7 +35,8 @@ var anthropic_vertex_default = definePluginEntry({
 			},
 			resolveConfigApiKey: ({ env }) => resolveAnthropicVertexConfigApiKey(env),
 			...NATIVE_ANTHROPIC_REPLAY_HOOKS,
-			resolveThinkingProfile: ({ modelId }) => resolveClaudeThinkingProfile(modelId),
+			normalizeResolvedModel: ({ modelId, model }) => normalizeAnthropicVertexResolvedModel(modelId, model),
+			resolveThinkingProfile: ({ modelId, params }) => resolveClaudeThinkingProfile(modelId, params, { includeNativeMax: true }),
 			resolveSyntheticAuth: () => {
 				if (!hasAnthropicVertexAvailableAuth()) return;
 				return {

package/dist/provider-catalog.js

@@ -1,9 +1,11 @@
 import { resolveAnthropicVertexRegion } from "./region.js";
+import { resolveClaudeFable5ModelIdentity } from "openclaw/plugin-sdk/provider-model-shared";
 import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/anthropic-vertex/provider-catalog.ts
 /** Default Anthropic Vertex model used for implicit provider catalogs. */
 const ANTHROPIC_VERTEX_DEFAULT_MODEL_ID = "claude-sonnet-4-6";
 const ANTHROPIC_VERTEX_DEFAULT_CONTEXT_WINDOW = 1e6;
+const ANTHROPIC_VERTEX_FABLE_MAX_TOKENS = 128e3;
 const GCP_VERTEX_CREDENTIALS_MARKER = "gcp-vertex-credentials";
 function buildAnthropicVertexModel(params) {
 	return {
@@ -19,6 +21,25 @@ function buildAnthropicVertexModel(params) {
 }
 function buildAnthropicVertexCatalog() {
 	return [
+		buildAnthropicVertexModel({
+			id: "claude-fable-5",
+			name: "Claude Fable 5",
+			reasoning: true,
+			input: ["text", "image"],
+			cost: {
+				input: 10,
+				output: 50,
+				cacheRead: 1,
+				cacheWrite: 12.5
+			},
+			maxTokens: ANTHROPIC_VERTEX_FABLE_MAX_TOKENS,
+			thinkingLevelMap: {
+				off: "low",
+				minimal: "low",
+				xhigh: "xhigh",
+				max: "max"
+			}
+		}),
 		buildAnthropicVertexModel({
 			id: "claude-opus-4-8",
 			name: "Claude Opus 4.8",
@@ -47,7 +68,11 @@ function buildAnthropicVertexCatalog() {
 				cacheRead: .5,
 				cacheWrite: 6.25
 			},
-			maxTokens: 128e3
+			maxTokens: 128e3,
+			thinkingLevelMap: {
+				xhigh: null,
+				max: "max"
+			}
 		}),
 		buildAnthropicVertexModel({
 			id: ANTHROPIC_VERTEX_DEFAULT_MODEL_ID,
@@ -60,10 +85,39 @@ function buildAnthropicVertexCatalog() {
 				cacheRead: .3,
 				cacheWrite: 3.75
 			},
-			maxTokens: 128e3
+			maxTokens: 128e3,
+			thinkingLevelMap: {
+				xhigh: null,
+				max: "max"
+			}
 		})
 	];
 }
+/** Restore required Fable metadata after explicit catalog models replace the implicit row. */
+function normalizeAnthropicVertexResolvedModel(modelId, model) {
+	if (!resolveClaudeFable5ModelIdentity({
+		id: modelId,
+		params: model.params
+	})) return;
+	const input = model.input.includes("image") ? model.input : [...model.input, "image"];
+	const thinkingLevelMap = {
+		off: "low",
+		minimal: "low",
+		xhigh: "xhigh",
+		max: "max",
+		...model.thinkingLevelMap
+	};
+	if (model.reasoning && input === model.input && model.contextWindow === ANTHROPIC_VERTEX_DEFAULT_CONTEXT_WINDOW && model.contextTokens === ANTHROPIC_VERTEX_DEFAULT_CONTEXT_WINDOW && (model.maxTokens ?? 0) >= ANTHROPIC_VERTEX_FABLE_MAX_TOKENS && model.thinkingLevelMap?.off === "low" && model.thinkingLevelMap.minimal === "low" && model.thinkingLevelMap.xhigh === "xhigh" && model.thinkingLevelMap.max === "max") return;
+	return {
+		...model,
+		reasoning: true,
+		input,
+		contextWindow: ANTHROPIC_VERTEX_DEFAULT_CONTEXT_WINDOW,
+		contextTokens: ANTHROPIC_VERTEX_DEFAULT_CONTEXT_WINDOW,
+		maxTokens: Math.max(model.maxTokens ?? 0, ANTHROPIC_VERTEX_FABLE_MAX_TOKENS),
+		thinkingLevelMap
+	};
+}
 /** Build the implicit Anthropic Vertex provider config for the current env. */
 function buildAnthropicVertexProvider(params) {
 	const region = resolveAnthropicVertexRegion(params?.env);
@@ -75,4 +129,4 @@ function buildAnthropicVertexProvider(params) {
 	};
 }
 //#endregion
-export { ANTHROPIC_VERTEX_DEFAULT_MODEL_ID, buildAnthropicVertexProvider };
+export { ANTHROPIC_VERTEX_DEFAULT_MODEL_ID, buildAnthropicVertexProvider, normalizeAnthropicVertexResolvedModel };

package/dist/provider-policy-api.js

@@ -7,7 +7,7 @@ import { resolveClaudeThinkingProfile } from "openclaw/plugin-sdk/provider-model
 /** Resolve Anthropic Vertex thinking profile for a provider/model pair. */
 function resolveThinkingProfile(params) {
 	if (params.provider.trim().toLowerCase() !== "anthropic-vertex") return null;
-	return resolveClaudeThinkingProfile(params.modelId);
+	return resolveClaudeThinkingProfile(params.modelId, params.params, { includeNativeMax: true });
 }
 //#endregion
 export { resolveThinkingProfile };

package/dist/stream-runtime.js

@@ -1,6 +1,7 @@
 import { resolveAnthropicVertexClientRegion, resolveAnthropicVertexProjectId } from "./region.js";
+import { resolveClaudeFable5ModelIdentity, resolveClaudeModelIdentity, supportsClaudeAdaptiveThinking, supportsClaudeNativeMaxEffort, supportsClaudeNativeXhighEffort } from "openclaw/plugin-sdk/provider-model-shared";
 import { AnthropicVertex } from "@anthropic-ai/vertex-sdk";
-import { stream } from "openclaw/plugin-sdk/llm";
+import { clampThinkingLevel, stream } from "openclaw/plugin-sdk/llm";
 import { applyAnthropicPayloadPolicyToParams, resolveAnthropicPayloadPolicy } from "openclaw/plugin-sdk/provider-stream-shared";
 //#region extensions/anthropic-vertex/stream-runtime.ts
 /**
@@ -12,23 +13,33 @@ const defaultAnthropicVertexStreamDeps = {
 	streamAnthropic: stream
 };
 function isClaudeOpus47OrNewerModel(modelId) {
-	return modelId.includes("opus-4-8") || modelId.includes("opus-4.8") || modelId.includes("opus-4-7") || modelId.includes("opus-4.7");
+	return supportsClaudeNativeXhighEffort({ id: modelId });
 }
-function isClaudeOpus46Model(modelId) {
-	return modelId.includes("opus-4-6") || modelId.includes("opus-4.6");
+function isClaudeFable5Model(modelId) {
+	return resolveClaudeFable5ModelIdentity({ id: modelId }) !== void 0;
+}
+function isClaudeMythos5Model(modelId) {
+	return /(?:^|-)claude-mythos-5(?=$|[^a-z0-9])/.test(resolveClaudeModelIdentity({ id: modelId }));
 }
 function supportsAdaptiveThinking(modelId) {
-	return isClaudeOpus47OrNewerModel(modelId) || isClaudeOpus46Model(modelId) || modelId.includes("sonnet-4-6") || modelId.includes("sonnet-4.6");
+	return supportsClaudeAdaptiveThinking({ id: modelId }) || isClaudeMythos5Model(modelId);
 }
-function mapAnthropicAdaptiveEffort(reasoning, modelId) {
+function mapAnthropicAdaptiveEffort(reasoning, model, modelId) {
+	const resolvedReasoning = clampThinkingLevel(typeof model.params?.canonicalModelId === "string" ? {
+		...model,
+		reasoning: true
+	} : model, reasoning);
+	const mapped = model.thinkingLevelMap?.[resolvedReasoning];
+	if (typeof mapped === "string") return mapped;
 	return {
+		off: "low",
 		minimal: "low",
 		low: "low",
 		medium: "medium",
 		high: "high",
-		xhigh: isClaudeOpus47OrNewerModel(modelId) ? "xhigh" : isClaudeOpus46Model(modelId) ? "max" : "high",
-		max: isClaudeOpus47OrNewerModel(modelId) ? "max" : "high"
-	}[reasoning] ?? "high";
+		xhigh: isClaudeFable5Model(modelId) ? "xhigh" : isClaudeOpus47OrNewerModel(modelId) || isClaudeMythos5Model(modelId) ? "xhigh" : "high",
+		max: supportsClaudeNativeMaxEffort({ id: modelId }) || isClaudeMythos5Model(modelId) ? "max" : "high"
+	}[resolvedReasoning] ?? "high";
 }
 function resolveAnthropicVertexMaxTokens(params) {
 	const modelMax = typeof params.modelMaxTokens === "number" && Number.isFinite(params.modelMaxTokens) && params.modelMaxTokens > 0 ? Math.floor(params.modelMaxTokens) : void 0;
@@ -73,7 +84,11 @@ function createAnthropicVertexStreamFn(projectId, region, baseURL, deps = defaul
 			modelMaxTokens: transportModel.maxTokens,
 			requestedMaxTokens: options?.maxTokens
 		});
-		const temperature = isClaudeOpus47OrNewerModel(model.id) ? void 0 : options?.temperature;
+		const contractModelId = resolveClaudeModelIdentity(model);
+		const fable5 = isClaudeFable5Model(contractModelId);
+		const mandatoryAdaptiveThinking = fable5 || isClaudeMythos5Model(contractModelId);
+		const reasoning = options?.reasoning ?? (mandatoryAdaptiveThinking ? "high" : void 0);
+		const temperature = mandatoryAdaptiveThinking || Boolean(reasoning && supportsAdaptiveThinking(contractModelId)) || isClaudeOpus47OrNewerModel(contractModelId) || isClaudeMythos5Model(contractModelId) ? void 0 : options?.temperature;
 		const opts = {
 			client,
 			...temperature !== void 0 ? { temperature } : {},
@@ -90,15 +105,18 @@ function createAnthropicVertexStreamFn(projectId, region, baseURL, deps = defaul
 			maxRetryDelayMs: options?.maxRetryDelayMs,
 			metadata: options?.metadata
 		};
-		if (options?.reasoning) if (supportsAdaptiveThinking(model.id)) {
+		if (reasoning) if (supportsAdaptiveThinking(contractModelId)) {
 			opts.thinkingEnabled = true;
-			opts.effort = mapAnthropicAdaptiveEffort(options.reasoning, model.id);
+			opts.effort = mapAnthropicAdaptiveEffort(reasoning, transportModel, contractModelId);
 		} else {
 			opts.thinkingEnabled = true;
-			const budgets = options.thinkingBudgets;
-			opts.thinkingBudgetTokens = (budgets && options.reasoning in budgets ? budgets[options.reasoning] : void 0) ?? 1e4;
+			const budgets = options?.thinkingBudgets;
+			opts.thinkingBudgetTokens = (budgets && reasoning in budgets ? budgets[reasoning] : void 0) ?? 1e4;
 		}
-		else opts.thinkingEnabled = false;
+		else if (fable5) {
+			opts.thinkingEnabled = true;
+			opts.effort = "high";
+		} else opts.thinkingEnabled = false;
 		return deps.streamAnthropic(transportModel, context, opts);
 	};
 }

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@openclaw/anthropic-vertex-provider",
-  "version": "2026.6.5",
+  "version": "2026.6.6-beta.2",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@openclaw/anthropic-vertex-provider",
-      "version": "2026.6.5",
+      "version": "2026.6.6-beta.2",
       "dependencies": {
         "@anthropic-ai/vertex-sdk": "0.16.1"
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/anthropic-vertex-provider",
-  "version": "2026.6.5",
+  "version": "2026.6.6-beta.2",
   "description": "OpenClaw Anthropic Vertex provider plugin for Claude models on Google Vertex AI.",
   "repository": {
     "type": "git",
@@ -20,10 +20,10 @@
       "minHostVersion": ">=2026.5.12-beta.1"
     },
     "compat": {
-      "pluginApi": ">=2026.6.5"
+      "pluginApi": ">=2026.6.6-beta.2"
     },
     "build": {
-      "openclawVersion": "2026.6.5",
+      "openclawVersion": "2026.6.6-beta.2",
       "bundledDist": false
     },
     "release": {
@@ -41,7 +41,7 @@
     "README.md"
   ],
   "peerDependencies": {
-    "openclaw": ">=2026.6.5"
+    "openclaw": ">=2026.6.6-beta.2"
   },
   "peerDependenciesMeta": {
     "openclaw": {