@openclaw/anthropic-vertex-provider 2026.5.12-beta.7

package/dist/api.js

@@ -0,0 +1,31 @@
+import { hasAnthropicVertexAvailableAuth, hasAnthropicVertexCredentials, resolveAnthropicVertexClientRegion, resolveAnthropicVertexConfigApiKey, resolveAnthropicVertexProjectId, resolveAnthropicVertexRegion, resolveAnthropicVertexRegionFromBaseUrl } from "./region.js";
+import { ANTHROPIC_VERTEX_DEFAULT_MODEL_ID, buildAnthropicVertexProvider } from "./provider-catalog.js";
+//#region extensions/anthropic-vertex/api.ts
+function mergeImplicitAnthropicVertexProvider(params) {
+	const { existing, implicit } = params;
+	if (!existing) return implicit;
+	return {
+		...implicit,
+		...existing,
+		models: Array.isArray(existing.models) && existing.models.length > 0 ? existing.models : implicit.models
+	};
+}
+function resolveImplicitAnthropicVertexProvider(params) {
+	const env = params?.env ?? process.env;
+	if (!hasAnthropicVertexAvailableAuth(env)) return null;
+	return buildAnthropicVertexProvider({ env });
+}
+function createAnthropicVertexStreamFn(projectId, region, baseURL, deps) {
+	const streamFnPromise = import("./stream-runtime.js").then((runtime) => runtime.createAnthropicVertexStreamFn(projectId, region, baseURL, deps));
+	return async (model, context, options) => {
+		return (await streamFnPromise)(model, context, options);
+	};
+}
+function createAnthropicVertexStreamFnForModel(model, env = process.env, deps) {
+	const streamFnPromise = import("./stream-runtime.js").then((runtime) => runtime.createAnthropicVertexStreamFnForModel(model, env, deps));
+	return async (...args) => {
+		return (await streamFnPromise)(...args);
+	};
+}
+//#endregion
+export { ANTHROPIC_VERTEX_DEFAULT_MODEL_ID, buildAnthropicVertexProvider, createAnthropicVertexStreamFn, createAnthropicVertexStreamFnForModel, hasAnthropicVertexAvailableAuth, hasAnthropicVertexCredentials, mergeImplicitAnthropicVertexProvider, resolveAnthropicVertexClientRegion, resolveAnthropicVertexConfigApiKey, resolveAnthropicVertexProjectId, resolveAnthropicVertexRegion, resolveAnthropicVertexRegionFromBaseUrl, resolveImplicitAnthropicVertexProvider };

package/dist/index.js

@@ -0,0 +1,48 @@
+import { hasAnthropicVertexAvailableAuth, resolveAnthropicVertexConfigApiKey } from "./region.js";
+import { mergeImplicitAnthropicVertexProvider, resolveImplicitAnthropicVertexProvider } from "./api.js";
+import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
+import { readConfiguredProviderCatalogEntries } from "openclaw/plugin-sdk/provider-catalog-shared";
+import { NATIVE_ANTHROPIC_REPLAY_HOOKS } from "openclaw/plugin-sdk/provider-model-shared";
+//#region extensions/anthropic-vertex/index.ts
+const PROVIDER_ID = "anthropic-vertex";
+const GCP_VERTEX_CREDENTIALS_MARKER = "gcp-vertex-credentials";
+var anthropic_vertex_default = definePluginEntry({
+	id: PROVIDER_ID,
+	name: "Anthropic Vertex Provider",
+	description: "Bundled Anthropic Vertex provider plugin",
+	register(api) {
+		api.registerProvider({
+			id: PROVIDER_ID,
+			label: "Anthropic Vertex",
+			docsPath: "/providers/models",
+			auth: [],
+			catalog: {
+				order: "simple",
+				run: async (ctx) => {
+					const implicit = resolveImplicitAnthropicVertexProvider({ env: ctx.env });
+					if (!implicit) return null;
+					return { provider: mergeImplicitAnthropicVertexProvider({
+						existing: ctx.config.models?.providers?.[PROVIDER_ID],
+						implicit
+					}) };
+				}
+			},
+			resolveConfigApiKey: ({ env }) => resolveAnthropicVertexConfigApiKey(env),
+			...NATIVE_ANTHROPIC_REPLAY_HOOKS,
+			resolveSyntheticAuth: () => {
+				if (!hasAnthropicVertexAvailableAuth()) return;
+				return {
+					apiKey: GCP_VERTEX_CREDENTIALS_MARKER,
+					source: "gcp-vertex-credentials (ADC)",
+					mode: "api-key"
+				};
+			},
+			augmentModelCatalog: ({ config }) => readConfiguredProviderCatalogEntries({
+				config,
+				providerId: PROVIDER_ID
+			})
+		});
+	}
+});
+//#endregion
+export { anthropic_vertex_default as default };

package/dist/provider-catalog.js

@@ -0,0 +1,55 @@
+import { resolveAnthropicVertexRegion } from "./region.js";
+import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/anthropic-vertex/provider-catalog.ts
+const ANTHROPIC_VERTEX_DEFAULT_MODEL_ID = "claude-sonnet-4-6";
+const ANTHROPIC_VERTEX_DEFAULT_CONTEXT_WINDOW = 1e6;
+const GCP_VERTEX_CREDENTIALS_MARKER = "gcp-vertex-credentials";
+function buildAnthropicVertexModel(params) {
+	return {
+		id: params.id,
+		name: params.name,
+		reasoning: params.reasoning,
+		input: params.input,
+		cost: params.cost,
+		contextWindow: ANTHROPIC_VERTEX_DEFAULT_CONTEXT_WINDOW,
+		maxTokens: params.maxTokens
+	};
+}
+function buildAnthropicVertexCatalog() {
+	return [buildAnthropicVertexModel({
+		id: "claude-opus-4-6",
+		name: "Claude Opus 4.6",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 5,
+			output: 25,
+			cacheRead: .5,
+			cacheWrite: 6.25
+		},
+		maxTokens: 128e3
+	}), buildAnthropicVertexModel({
+		id: ANTHROPIC_VERTEX_DEFAULT_MODEL_ID,
+		name: "Claude Sonnet 4.6",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 3,
+			output: 15,
+			cacheRead: .3,
+			cacheWrite: 3.75
+		},
+		maxTokens: 128e3
+	})];
+}
+function buildAnthropicVertexProvider(params) {
+	const region = resolveAnthropicVertexRegion(params?.env);
+	return {
+		baseUrl: normalizeLowercaseStringOrEmpty(region) === "global" ? "https://aiplatform.googleapis.com" : `https://${region}-aiplatform.googleapis.com`,
+		api: "anthropic-messages",
+		apiKey: GCP_VERTEX_CREDENTIALS_MARKER,
+		models: buildAnthropicVertexCatalog()
+	};
+}
+//#endregion
+export { ANTHROPIC_VERTEX_DEFAULT_MODEL_ID, buildAnthropicVertexProvider };

package/dist/provider-discovery.js

@@ -0,0 +1,48 @@
+import { hasAnthropicVertexAvailableAuth, resolveAnthropicVertexConfigApiKey } from "./region.js";
+import { buildAnthropicVertexProvider } from "./provider-catalog.js";
+//#region extensions/anthropic-vertex/provider-discovery.ts
+const PROVIDER_ID = "anthropic-vertex";
+const GCP_VERTEX_CREDENTIALS_MARKER = "gcp-vertex-credentials";
+function mergeImplicitAnthropicVertexProvider(params) {
+	const { existing, implicit } = params;
+	if (!existing) return implicit;
+	return {
+		...implicit,
+		...existing,
+		models: Array.isArray(existing.models) && existing.models.length > 0 ? existing.models : implicit.models
+	};
+}
+function resolveImplicitAnthropicVertexProvider(params) {
+	const env = params?.env ?? process.env;
+	if (!hasAnthropicVertexAvailableAuth(env)) return null;
+	return buildAnthropicVertexProvider({ env });
+}
+async function runAnthropicVertexCatalog(ctx) {
+	const implicit = resolveImplicitAnthropicVertexProvider({ env: ctx.env });
+	if (!implicit) return null;
+	return { provider: mergeImplicitAnthropicVertexProvider({
+		existing: ctx.config.models?.providers?.[PROVIDER_ID],
+		implicit
+	}) };
+}
+const anthropicVertexProviderDiscovery = {
+	id: PROVIDER_ID,
+	label: "Anthropic Vertex",
+	docsPath: "/providers/models",
+	auth: [],
+	catalog: {
+		order: "simple",
+		run: runAnthropicVertexCatalog
+	},
+	resolveConfigApiKey: ({ env }) => resolveAnthropicVertexConfigApiKey(env),
+	resolveSyntheticAuth: () => {
+		if (!hasAnthropicVertexAvailableAuth()) return;
+		return {
+			apiKey: GCP_VERTEX_CREDENTIALS_MARKER,
+			source: "gcp-vertex-credentials (ADC)",
+			mode: "api-key"
+		};
+	}
+};
+//#endregion
+export { anthropicVertexProviderDiscovery, anthropicVertexProviderDiscovery as default };

package/dist/region.js

@@ -0,0 +1,73 @@
+import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { readFileSync } from "node:fs";
+import { homedir, platform } from "node:os";
+import { join } from "node:path";
+import { resolveProviderEndpoint } from "openclaw/plugin-sdk/provider-http";
+//#region extensions/anthropic-vertex/region.ts
+const ANTHROPIC_VERTEX_DEFAULT_REGION = "global";
+const ANTHROPIC_VERTEX_REGION_RE = /^[a-z0-9-]+$/;
+const GCP_VERTEX_CREDENTIALS_MARKER = "gcp-vertex-credentials";
+function normalizeOptionalSecretInput(value) {
+	if (typeof value !== "string") return;
+	return value.trim() || void 0;
+}
+function resolveAnthropicVertexRegion(env = process.env) {
+	const region = normalizeOptionalSecretInput(env.GOOGLE_CLOUD_LOCATION) || normalizeOptionalSecretInput(env.CLOUD_ML_REGION);
+	return region && ANTHROPIC_VERTEX_REGION_RE.test(region) ? region : ANTHROPIC_VERTEX_DEFAULT_REGION;
+}
+function resolveAnthropicVertexProjectId(env = process.env) {
+	return normalizeOptionalSecretInput(env.ANTHROPIC_VERTEX_PROJECT_ID) || normalizeOptionalSecretInput(env.GOOGLE_CLOUD_PROJECT) || normalizeOptionalSecretInput(env.GOOGLE_CLOUD_PROJECT_ID) || resolveAnthropicVertexProjectIdFromAdc(env);
+}
+function resolveAnthropicVertexRegionFromBaseUrl(baseUrl) {
+	const endpoint = resolveProviderEndpoint(baseUrl);
+	return endpoint.endpointClass === "google-vertex" ? endpoint.googleVertexRegion : void 0;
+}
+function resolveAnthropicVertexClientRegion(params) {
+	return resolveAnthropicVertexRegionFromBaseUrl(params?.baseUrl) || resolveAnthropicVertexRegion(params?.env);
+}
+function hasAnthropicVertexMetadataServerAdc(env = process.env) {
+	const explicitMetadataOptIn = normalizeOptionalSecretInput(env.ANTHROPIC_VERTEX_USE_GCP_METADATA);
+	return explicitMetadataOptIn === "1" || normalizeLowercaseStringOrEmpty(explicitMetadataOptIn) === "true";
+}
+function resolveAnthropicVertexHomeDir(env = process.env) {
+	return normalizeOptionalSecretInput(env.HOME) || normalizeOptionalSecretInput(env.USERPROFILE) || homedir();
+}
+function resolveAnthropicVertexDefaultAdcPath(env = process.env) {
+	return platform() === "win32" ? join(normalizeOptionalSecretInput(env.APPDATA) ?? join(resolveAnthropicVertexHomeDir(env), "AppData", "Roaming"), "gcloud", "application_default_credentials.json") : join(resolveAnthropicVertexHomeDir(env), ".config", "gcloud", "application_default_credentials.json");
+}
+function resolveAnthropicVertexAdcCredentialsPathCandidate(env = process.env) {
+	const explicit = normalizeOptionalSecretInput(env.GOOGLE_APPLICATION_CREDENTIALS);
+	if (explicit) return explicit;
+	return resolveAnthropicVertexDefaultAdcPath(env);
+}
+function canReadAnthropicVertexAdc(env = process.env) {
+	const credentialsPath = resolveAnthropicVertexAdcCredentialsPathCandidate(env);
+	if (!credentialsPath) return false;
+	try {
+		readFileSync(credentialsPath, "utf8");
+		return true;
+	} catch {
+		return false;
+	}
+}
+function resolveAnthropicVertexProjectIdFromAdc(env = process.env) {
+	const credentialsPath = resolveAnthropicVertexAdcCredentialsPathCandidate(env);
+	if (!credentialsPath) return;
+	try {
+		const parsed = JSON.parse(readFileSync(credentialsPath, "utf8"));
+		return normalizeOptionalSecretInput(parsed.project_id) || normalizeOptionalSecretInput(parsed.quota_project_id);
+	} catch {
+		return;
+	}
+}
+function hasAnthropicVertexCredentials(env = process.env) {
+	return hasAnthropicVertexMetadataServerAdc(env) || canReadAnthropicVertexAdc(env);
+}
+function hasAnthropicVertexAvailableAuth(env = process.env) {
+	return hasAnthropicVertexCredentials(env);
+}
+function resolveAnthropicVertexConfigApiKey(env = process.env) {
+	return hasAnthropicVertexAvailableAuth(env) ? GCP_VERTEX_CREDENTIALS_MARKER : void 0;
+}
+//#endregion
+export { hasAnthropicVertexAvailableAuth, hasAnthropicVertexCredentials, resolveAnthropicVertexClientRegion, resolveAnthropicVertexConfigApiKey, resolveAnthropicVertexProjectId, resolveAnthropicVertexRegion, resolveAnthropicVertexRegionFromBaseUrl };

package/dist/setup-api.js

@@ -0,0 +1,18 @@
+import { resolveAnthropicVertexConfigApiKey } from "./region.js";
+import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
+//#region extensions/anthropic-vertex/setup-api.ts
+var setup_api_default = definePluginEntry({
+	id: "anthropic-vertex",
+	name: "Anthropic Vertex Setup",
+	description: "Lightweight Anthropic Vertex setup hooks",
+	register(api) {
+		api.registerProvider({
+			id: "anthropic-vertex",
+			label: "Anthropic Vertex",
+			auth: [],
+			resolveConfigApiKey: ({ env }) => resolveAnthropicVertexConfigApiKey(env)
+		});
+	}
+});
+//#endregion
+export { setup_api_default as default };

package/dist/stream-runtime.js

@@ -0,0 +1,125 @@
+import { resolveAnthropicVertexClientRegion, resolveAnthropicVertexProjectId } from "./region.js";
+import { AnthropicVertex } from "@anthropic-ai/vertex-sdk";
+import { streamAnthropic } from "@earendil-works/pi-ai";
+import { applyAnthropicPayloadPolicyToParams, resolveAnthropicPayloadPolicy } from "openclaw/plugin-sdk/provider-stream-shared";
+//#region extensions/anthropic-vertex/stream-runtime.ts
+const defaultAnthropicVertexStreamDeps = {
+	AnthropicVertex,
+	streamAnthropic
+};
+function isClaudeOpus47Model(modelId) {
+	return modelId.includes("opus-4-7") || modelId.includes("opus-4.7");
+}
+function isClaudeOpus46Model(modelId) {
+	return modelId.includes("opus-4-6") || modelId.includes("opus-4.6");
+}
+function supportsAdaptiveThinking(modelId) {
+	return isClaudeOpus47Model(modelId) || isClaudeOpus46Model(modelId) || modelId.includes("sonnet-4-6") || modelId.includes("sonnet-4.6");
+}
+function mapAnthropicAdaptiveEffort(reasoning, modelId) {
+	return {
+		minimal: "low",
+		low: "low",
+		medium: "medium",
+		high: "high",
+		xhigh: isClaudeOpus47Model(modelId) ? "xhigh" : isClaudeOpus46Model(modelId) ? "max" : "high"
+	}[reasoning] ?? "high";
+}
+function resolveAnthropicVertexMaxTokens(params) {
+	const modelMax = typeof params.modelMaxTokens === "number" && Number.isFinite(params.modelMaxTokens) && params.modelMaxTokens > 0 ? Math.floor(params.modelMaxTokens) : void 0;
+	const requested = typeof params.requestedMaxTokens === "number" && Number.isFinite(params.requestedMaxTokens) && params.requestedMaxTokens > 0 ? Math.floor(params.requestedMaxTokens) : void 0;
+	if (modelMax !== void 0 && requested !== void 0) return Math.min(requested, modelMax);
+	return requested ?? modelMax;
+}
+function createAnthropicVertexOnPayload(params) {
+	const policy = resolveAnthropicPayloadPolicy({
+		provider: params.model.provider,
+		api: params.model.api,
+		baseUrl: params.model.baseUrl,
+		cacheRetention: params.cacheRetention,
+		enableCacheControl: true
+	});
+	function applyPolicy(payload) {
+		if (payload && typeof payload === "object" && !Array.isArray(payload)) applyAnthropicPayloadPolicyToParams(payload, policy);
+		return payload;
+	}
+	return async (payload, model) => {
+		const shapedPayload = applyPolicy(payload);
+		const nextPayload = await params.onPayload?.(shapedPayload, model);
+		if (nextPayload === void 0 || nextPayload === shapedPayload) return shapedPayload;
+		return applyPolicy(nextPayload);
+	};
+}
+/**
+* Create a StreamFn that routes through pi-ai's `streamAnthropic` with an
+* injected `AnthropicVertex` client.  All streaming, message conversion, and
+* event handling is handled by pi-ai — we only supply the GCP-authenticated
+* client and map SimpleStreamOptions → AnthropicOptions.
+*/
+function createAnthropicVertexStreamFn(projectId, region, baseURL, deps = defaultAnthropicVertexStreamDeps) {
+	const client = new deps.AnthropicVertex({
+		region,
+		...baseURL ? { baseURL } : {},
+		...projectId ? { projectId } : {}
+	});
+	return (model, context, options) => {
+		const transportModel = model;
+		const maxTokens = resolveAnthropicVertexMaxTokens({
+			modelMaxTokens: transportModel.maxTokens,
+			requestedMaxTokens: options?.maxTokens
+		});
+		const opts = {
+			client,
+			temperature: options?.temperature,
+			...maxTokens !== void 0 ? { maxTokens } : {},
+			signal: options?.signal,
+			cacheRetention: options?.cacheRetention,
+			sessionId: options?.sessionId,
+			headers: options?.headers,
+			onPayload: createAnthropicVertexOnPayload({
+				model: transportModel,
+				cacheRetention: options?.cacheRetention,
+				onPayload: options?.onPayload
+			}),
+			maxRetryDelayMs: options?.maxRetryDelayMs,
+			metadata: options?.metadata
+		};
+		if (options?.reasoning) if (supportsAdaptiveThinking(model.id)) {
+			opts.thinkingEnabled = true;
+			opts.effort = mapAnthropicAdaptiveEffort(options.reasoning, model.id);
+		} else {
+			opts.thinkingEnabled = true;
+			const budgets = options.thinkingBudgets;
+			opts.thinkingBudgetTokens = (budgets && options.reasoning in budgets ? budgets[options.reasoning] : void 0) ?? 1e4;
+		}
+		else opts.thinkingEnabled = false;
+		return deps.streamAnthropic(transportModel, context, opts);
+	};
+}
+function resolveAnthropicVertexSdkBaseUrl(baseUrl) {
+	const trimmed = baseUrl?.trim();
+	if (!trimmed) return;
+	try {
+		const url = new URL(trimmed);
+		const normalizedPath = url.pathname.replace(/\/+$/, "");
+		if (!normalizedPath || normalizedPath === "") {
+			url.pathname = "/v1";
+			return url.toString().replace(/\/$/, "");
+		}
+		if (!normalizedPath.endsWith("/v1")) {
+			url.pathname = `${normalizedPath}/v1`;
+			return url.toString().replace(/\/$/, "");
+		}
+		return trimmed;
+	} catch {
+		return trimmed;
+	}
+}
+function createAnthropicVertexStreamFnForModel(model, env = process.env, deps) {
+	return createAnthropicVertexStreamFn(resolveAnthropicVertexProjectId(env), resolveAnthropicVertexClientRegion({
+		baseUrl: model.baseUrl,
+		env
+	}), resolveAnthropicVertexSdkBaseUrl(model.baseUrl), deps);
+}
+//#endregion
+export { createAnthropicVertexStreamFn, createAnthropicVertexStreamFnForModel };

package/openclaw.plugin.json

@@ -0,0 +1,16 @@
+{
+  "id": "anthropic-vertex",
+  "activation": {
+    "onStartup": false
+  },
+  "enabledByDefault": true,
+  "providers": ["anthropic-vertex"],
+  "providerCatalogEntry": "./provider-discovery.ts",
+  "syntheticAuthRefs": ["anthropic-vertex"],
+  "nonSecretAuthMarkers": ["gcp-vertex-credentials"],
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {}
+  }
+}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@openclaw/anthropic-vertex-provider",
+  "version": "2026.5.12-beta.7",
+  "description": "OpenClaw Anthropic Vertex provider plugin",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/openclaw/openclaw"
+  },
+  "type": "module",
+  "dependencies": {
+    "@anthropic-ai/vertex-sdk": "0.16.0",
+    "@earendil-works/pi-agent-core": "0.74.0",
+    "@earendil-works/pi-ai": "0.74.0"
+  },
+  "devDependencies": {
+    "@openclaw/plugin-sdk": "workspace:*"
+  },
+  "openclaw": {
+    "extensions": [
+      "./index.ts"
+    ],
+    "install": {
+      "npmSpec": "@openclaw/anthropic-vertex-provider",
+      "defaultChoice": "npm",
+      "minHostVersion": ">=2026.5.12-beta.6"
+    },
+    "compat": {
+      "pluginApi": ">=2026.5.12-beta.7"
+    },
+    "build": {
+      "openclawVersion": "2026.5.12-beta.7",
+      "bundledDist": false
+    },
+    "release": {
+      "publishToClawHub": true,
+      "publishToNpm": true
+    },
+    "runtimeExtensions": [
+      "./dist/index.js"
+    ]
+  },
+  "files": [
+    "dist/**",
+    "openclaw.plugin.json"
+  ],
+  "peerDependencies": {
+    "openclaw": ">=2026.5.12-beta.7"
+  },
+  "peerDependenciesMeta": {
+    "openclaw": {
+      "optional": true
+    }
+  }
+}