@gakr-gakr/anthropic-vertex-provider 0.1.0

package/api.ts

@@ -0,0 +1,74 @@
+import type { StreamFn } from "@earendil-works/pi-agent-core";
+import type { AnthropicVertexStreamDeps } from "./stream-runtime.js";
+
+export {
+  ANTHROPIC_VERTEX_DEFAULT_MODEL_ID,
+  buildAnthropicVertexProvider,
+} from "./provider-catalog.js";
+export {
+  hasAnthropicVertexAvailableAuth,
+  hasAnthropicVertexCredentials,
+  resolveAnthropicVertexClientRegion,
+  resolveAnthropicVertexConfigApiKey,
+  resolveAnthropicVertexProjectId,
+  resolveAnthropicVertexRegion,
+  resolveAnthropicVertexRegionFromBaseUrl,
+} from "./region.js";
+import { buildAnthropicVertexProvider } from "./provider-catalog.js";
+import { hasAnthropicVertexAvailableAuth } from "./region.js";
+
+export function mergeImplicitAnthropicVertexProvider(params: {
+  existing?: ReturnType<typeof buildAnthropicVertexProvider>;
+  implicit: ReturnType<typeof buildAnthropicVertexProvider>;
+}) {
+  const { existing, implicit } = params;
+  if (!existing) {
+    return implicit;
+  }
+  return {
+    ...implicit,
+    ...existing,
+    models:
+      Array.isArray(existing.models) && existing.models.length > 0
+        ? existing.models
+        : implicit.models,
+  };
+}
+
+export function resolveImplicitAnthropicVertexProvider(params?: { env?: NodeJS.ProcessEnv }) {
+  const env = params?.env ?? process.env;
+  if (!hasAnthropicVertexAvailableAuth(env)) {
+    return null;
+  }
+
+  return buildAnthropicVertexProvider({ env });
+}
+
+export function createAnthropicVertexStreamFn(
+  projectId: string | undefined,
+  region: string,
+  baseURL?: string,
+  deps?: AnthropicVertexStreamDeps,
+): StreamFn {
+  const streamFnPromise = import("./stream-runtime.js").then((runtime) =>
+    runtime.createAnthropicVertexStreamFn(projectId, region, baseURL, deps),
+  );
+  return async (model, context, options) => {
+    const streamFn = await streamFnPromise;
+    return streamFn(model, context, options);
+  };
+}
+
+export function createAnthropicVertexStreamFnForModel(
+  model: { baseUrl?: string },
+  env: NodeJS.ProcessEnv = process.env,
+  deps?: AnthropicVertexStreamDeps,
+): StreamFn {
+  const streamFnPromise = import("./stream-runtime.js").then((runtime) =>
+    runtime.createAnthropicVertexStreamFnForModel(model, env, deps),
+  );
+  return async (...args) => {
+    const streamFn = await streamFnPromise;
+    return streamFn(...args);
+  };
+}

package/autobot.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/index.ts

@@ -0,0 +1,60 @@
+import { definePluginEntry } from "autobot/plugin-sdk/plugin-entry";
+import { readConfiguredProviderCatalogEntries } from "autobot/plugin-sdk/provider-catalog-shared";
+import { NATIVE_ANTHROPIC_REPLAY_HOOKS } from "autobot/plugin-sdk/provider-model-shared";
+import {
+  hasAnthropicVertexAvailableAuth,
+  mergeImplicitAnthropicVertexProvider,
+  resolveAnthropicVertexConfigApiKey,
+  resolveImplicitAnthropicVertexProvider,
+} from "./api.js";
+
+const PROVIDER_ID = "anthropic-vertex";
+const GCP_VERTEX_CREDENTIALS_MARKER = "gcp-vertex-credentials";
+
+export 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 undefined;
+        }
+        return {
+          apiKey: GCP_VERTEX_CREDENTIALS_MARKER,
+          source: "gcp-vertex-credentials (ADC)",
+          mode: "api-key",
+        };
+      },
+      augmentModelCatalog: ({ config }) =>
+        readConfiguredProviderCatalogEntries({
+          config,
+          providerId: PROVIDER_ID,
+        }),
+    });
+  },
+});

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@gakr-gakr/anthropic-vertex-provider",
+  "version": "0.1.0",
+  "description": "AutoBot Anthropic Vertex provider plugin",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/autobot/autobot"
+  },
+  "type": "module",
+  "dependencies": {
+    "@anthropic-ai/vertex-sdk": "0.16.0",
+    "@earendil-works/pi-agent-core": "0.75.1",
+    "@earendil-works/pi-ai": "0.75.1"
+  },
+  "devDependencies": {
+    "@gakr-gakr/plugin-sdk": "workspace:*"
+  },
+  "autobot": {
+    "extensions": [
+      "./index.ts"
+    ],
+    "install": {
+      "npmSpec": "@gakr-gakr/anthropic-vertex-provider",
+      "defaultChoice": "npm",
+      "minHostVersion": ">=2026.5.12-beta.1"
+    },
+    "compat": {
+      "pluginApi": ">=2026.5.19"
+    },
+    "build": {
+      "autobotVersion": "2026.5.19",
+      "bundledDist": false
+    },
+    "release": {
+      "publishToClawHub": true,
+      "publishToNpm": true
+    }
+  }
+}

package/provider-catalog.ts

@@ -0,0 +1,66 @@
+import type {
+  ModelDefinitionConfig,
+  ModelProviderConfig,
+} from "autobot/plugin-sdk/provider-model-shared";
+import { normalizeLowercaseStringOrEmpty } from "autobot/plugin-sdk/string-coerce-runtime";
+import { resolveAnthropicVertexRegion } from "./region.js";
+export const ANTHROPIC_VERTEX_DEFAULT_MODEL_ID = "claude-sonnet-4-6";
+const ANTHROPIC_VERTEX_DEFAULT_CONTEXT_WINDOW = 1_000_000;
+const GCP_VERTEX_CREDENTIALS_MARKER = "gcp-vertex-credentials";
+
+function buildAnthropicVertexModel(params: {
+  id: string;
+  name: string;
+  reasoning: boolean;
+  input: ModelDefinitionConfig["input"];
+  cost: ModelDefinitionConfig["cost"];
+  maxTokens: number;
+}): ModelDefinitionConfig {
+  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(): ModelDefinitionConfig[] {
+  return [
+    buildAnthropicVertexModel({
+      id: "claude-opus-4-6",
+      name: "Claude Opus 4.6",
+      reasoning: true,
+      input: ["text", "image"],
+      cost: { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 },
+      maxTokens: 128000,
+    }),
+    buildAnthropicVertexModel({
+      id: ANTHROPIC_VERTEX_DEFAULT_MODEL_ID,
+      name: "Claude Sonnet 4.6",
+      reasoning: true,
+      input: ["text", "image"],
+      cost: { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+      maxTokens: 128000,
+    }),
+  ];
+}
+
+export function buildAnthropicVertexProvider(params?: {
+  env?: NodeJS.ProcessEnv;
+}): ModelProviderConfig {
+  const region = resolveAnthropicVertexRegion(params?.env);
+  const baseUrl =
+    normalizeLowercaseStringOrEmpty(region) === "global"
+      ? "https://aiplatform.googleapis.com"
+      : `https://${region}-aiplatform.googleapis.com`;
+
+  return {
+    baseUrl,
+    api: "anthropic-messages",
+    apiKey: GCP_VERTEX_CREDENTIALS_MARKER,
+    models: buildAnthropicVertexCatalog(),
+  };
+}

package/provider-discovery.ts

@@ -0,0 +1,92 @@
+import type { ProviderCatalogContext } from "autobot/plugin-sdk/provider-catalog-shared";
+import type { ModelProviderConfig } from "autobot/plugin-sdk/provider-model-shared";
+import { buildAnthropicVertexProvider } from "./provider-catalog.js";
+import { hasAnthropicVertexAvailableAuth, resolveAnthropicVertexConfigApiKey } from "./region.js";
+
+const PROVIDER_ID = "anthropic-vertex";
+const GCP_VERTEX_CREDENTIALS_MARKER = "gcp-vertex-credentials";
+
+type AnthropicVertexProviderPlugin = {
+  id: string;
+  label: string;
+  docsPath: string;
+  auth: [];
+  catalog: {
+    order: "simple";
+    run: (ctx: ProviderCatalogContext) => ReturnType<typeof runAnthropicVertexCatalog>;
+  };
+  resolveConfigApiKey: (params: { env: NodeJS.ProcessEnv }) => string | undefined;
+  resolveSyntheticAuth: () =>
+    | {
+        apiKey: string;
+        source: string;
+        mode: "api-key";
+      }
+    | undefined;
+};
+
+function mergeImplicitAnthropicVertexProvider(params: {
+  existing?: ModelProviderConfig;
+  implicit: ModelProviderConfig;
+}) {
+  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?: { env?: NodeJS.ProcessEnv }) {
+  const env = params?.env ?? process.env;
+  if (!hasAnthropicVertexAvailableAuth(env)) {
+    return null;
+  }
+
+  return buildAnthropicVertexProvider({ env });
+}
+
+async function runAnthropicVertexCatalog(ctx: ProviderCatalogContext) {
+  const implicit = resolveImplicitAnthropicVertexProvider({
+    env: ctx.env,
+  });
+  if (!implicit) {
+    return null;
+  }
+  return {
+    provider: mergeImplicitAnthropicVertexProvider({
+      existing: ctx.config.models?.providers?.[PROVIDER_ID],
+      implicit,
+    }),
+  };
+}
+
+export const anthropicVertexProviderDiscovery: AnthropicVertexProviderPlugin = {
+  id: PROVIDER_ID,
+  label: "Anthropic Vertex",
+  docsPath: "/providers/models",
+  auth: [],
+  catalog: {
+    order: "simple",
+    run: runAnthropicVertexCatalog,
+  },
+  resolveConfigApiKey: ({ env }) => resolveAnthropicVertexConfigApiKey(env),
+  resolveSyntheticAuth: () => {
+    if (!hasAnthropicVertexAvailableAuth()) {
+      return undefined;
+    }
+    return {
+      apiKey: GCP_VERTEX_CREDENTIALS_MARKER,
+      source: "gcp-vertex-credentials (ADC)",
+      mode: "api-key",
+    };
+  },
+};
+
+export default anthropicVertexProviderDiscovery;

package/region.ts

@@ -0,0 +1,145 @@
+import { readFileSync } from "node:fs";
+import { homedir, platform } from "node:os";
+import { join } from "node:path";
+import { resolveProviderEndpoint } from "autobot/plugin-sdk/provider-http";
+import { normalizeLowercaseStringOrEmpty } from "autobot/plugin-sdk/string-coerce-runtime";
+
+const ANTHROPIC_VERTEX_DEFAULT_REGION = "global";
+const ANTHROPIC_VERTEX_REGION_RE = /^[a-z0-9-]+$/;
+const GCP_VERTEX_CREDENTIALS_MARKER = "gcp-vertex-credentials";
+
+type AdcProjectFile = {
+  project_id?: unknown;
+  quota_project_id?: unknown;
+};
+
+function normalizeOptionalSecretInput(value: unknown): string | undefined {
+  if (typeof value !== "string") {
+    return undefined;
+  }
+  const trimmed = value.trim();
+  return trimmed || undefined;
+}
+
+export function resolveAnthropicVertexRegion(env: NodeJS.ProcessEnv = process.env): string {
+  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;
+}
+
+export function resolveAnthropicVertexProjectId(
+  env: NodeJS.ProcessEnv = process.env,
+): string | undefined {
+  return (
+    normalizeOptionalSecretInput(env.ANTHROPIC_VERTEX_PROJECT_ID) ||
+    normalizeOptionalSecretInput(env.GOOGLE_CLOUD_PROJECT) ||
+    normalizeOptionalSecretInput(env.GOOGLE_CLOUD_PROJECT_ID) ||
+    resolveAnthropicVertexProjectIdFromAdc(env)
+  );
+}
+
+export function resolveAnthropicVertexRegionFromBaseUrl(baseUrl?: string): string | undefined {
+  const endpoint = resolveProviderEndpoint(baseUrl);
+  return endpoint.endpointClass === "google-vertex" ? endpoint.googleVertexRegion : undefined;
+}
+
+export function resolveAnthropicVertexClientRegion(params?: {
+  baseUrl?: string;
+  env?: NodeJS.ProcessEnv;
+}): string {
+  return (
+    resolveAnthropicVertexRegionFromBaseUrl(params?.baseUrl) ||
+    resolveAnthropicVertexRegion(params?.env)
+  );
+}
+
+function hasAnthropicVertexMetadataServerAdc(env: NodeJS.ProcessEnv = process.env): boolean {
+  const explicitMetadataOptIn = normalizeOptionalSecretInput(env.ANTHROPIC_VERTEX_USE_GCP_METADATA);
+  return (
+    explicitMetadataOptIn === "1" ||
+    normalizeLowercaseStringOrEmpty(explicitMetadataOptIn) === "true"
+  );
+}
+
+function resolveAnthropicVertexHomeDir(env: NodeJS.ProcessEnv = process.env): string {
+  return (
+    normalizeOptionalSecretInput(env.HOME) ||
+    normalizeOptionalSecretInput(env.USERPROFILE) ||
+    homedir()
+  );
+}
+
+function resolveAnthropicVertexDefaultAdcPath(env: NodeJS.ProcessEnv = process.env): string {
+  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: NodeJS.ProcessEnv = process.env,
+): string | undefined {
+  const explicit = normalizeOptionalSecretInput(env.GOOGLE_APPLICATION_CREDENTIALS);
+  if (explicit) {
+    return explicit;
+  }
+  return resolveAnthropicVertexDefaultAdcPath(env);
+}
+
+function canReadAnthropicVertexAdc(env: NodeJS.ProcessEnv = process.env): boolean {
+  const credentialsPath = resolveAnthropicVertexAdcCredentialsPathCandidate(env);
+  if (!credentialsPath) {
+    return false;
+  }
+  try {
+    readFileSync(credentialsPath, "utf8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function resolveAnthropicVertexProjectIdFromAdc(
+  env: NodeJS.ProcessEnv = process.env,
+): string | undefined {
+  const credentialsPath = resolveAnthropicVertexAdcCredentialsPathCandidate(env);
+  if (!credentialsPath) {
+    return undefined;
+  }
+  try {
+    const parsed = JSON.parse(readFileSync(credentialsPath, "utf8")) as AdcProjectFile;
+    return (
+      normalizeOptionalSecretInput(parsed.project_id) ||
+      normalizeOptionalSecretInput(parsed.quota_project_id)
+    );
+  } catch {
+    return undefined;
+  }
+}
+
+export function hasAnthropicVertexCredentials(env: NodeJS.ProcessEnv = process.env): boolean {
+  return hasAnthropicVertexMetadataServerAdc(env) || canReadAnthropicVertexAdc(env);
+}
+
+export function hasAnthropicVertexAvailableAuth(env: NodeJS.ProcessEnv = process.env): boolean {
+  return hasAnthropicVertexCredentials(env);
+}
+
+export function resolveAnthropicVertexConfigApiKey(
+  env: NodeJS.ProcessEnv = process.env,
+): string | undefined {
+  return hasAnthropicVertexAvailableAuth(env) ? GCP_VERTEX_CREDENTIALS_MARKER : undefined;
+}

package/setup-api.ts

@@ -0,0 +1,16 @@
+import { definePluginEntry } from "autobot/plugin-sdk/plugin-entry";
+import { resolveAnthropicVertexConfigApiKey } from "./region.js";
+
+export 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),
+    });
+  },
+});

package/stream-runtime.ts

@@ -0,0 +1,221 @@
+import { AnthropicVertex as AnthropicVertexSdk } from "@anthropic-ai/vertex-sdk";
+import type { StreamFn } from "@earendil-works/pi-agent-core";
+import {
+  streamAnthropic as streamAnthropicDefault,
+  type AnthropicOptions,
+  type Model,
+} from "@earendil-works/pi-ai";
+import {
+  applyAnthropicPayloadPolicyToParams,
+  resolveAnthropicPayloadPolicy,
+} from "autobot/plugin-sdk/provider-stream-shared";
+import { resolveAnthropicVertexClientRegion, resolveAnthropicVertexProjectId } from "./region.js";
+
+type AnthropicVertexEffort = NonNullable<AnthropicOptions["effort"]>;
+type AnthropicVertexAdaptiveEffort = AnthropicVertexEffort | "xhigh";
+type AnthropicVertexClientOptions = {
+  baseURL?: string;
+  projectId?: string;
+  region: string;
+};
+
+export type AnthropicVertexStreamDeps = {
+  AnthropicVertex: new (options: AnthropicVertexClientOptions) => unknown;
+  streamAnthropic: typeof streamAnthropicDefault;
+};
+
+const defaultAnthropicVertexStreamDeps: AnthropicVertexStreamDeps = {
+  AnthropicVertex: AnthropicVertexSdk as AnthropicVertexStreamDeps["AnthropicVertex"],
+  streamAnthropic: streamAnthropicDefault,
+};
+
+function isClaudeOpus47Model(modelId: string): boolean {
+  return modelId.includes("opus-4-7") || modelId.includes("opus-4.7");
+}
+
+function isClaudeOpus46Model(modelId: string): boolean {
+  return modelId.includes("opus-4-6") || modelId.includes("opus-4.6");
+}
+
+function supportsAdaptiveThinking(modelId: string): boolean {
+  return (
+    isClaudeOpus47Model(modelId) ||
+    isClaudeOpus46Model(modelId) ||
+    modelId.includes("sonnet-4-6") ||
+    modelId.includes("sonnet-4.6")
+  );
+}
+
+function mapAnthropicAdaptiveEffort(
+  reasoning: string,
+  modelId: string,
+): AnthropicVertexAdaptiveEffort {
+  const effortMap: Record<string, AnthropicVertexAdaptiveEffort> = {
+    minimal: "low",
+    low: "low",
+    medium: "medium",
+    high: "high",
+    xhigh: isClaudeOpus47Model(modelId) ? "xhigh" : isClaudeOpus46Model(modelId) ? "max" : "high",
+  };
+  return effortMap[reasoning] ?? "high";
+}
+
+function resolveAnthropicVertexMaxTokens(params: {
+  modelMaxTokens: number | undefined;
+  requestedMaxTokens: number | undefined;
+}): number | undefined {
+  const modelMax =
+    typeof params.modelMaxTokens === "number" &&
+    Number.isFinite(params.modelMaxTokens) &&
+    params.modelMaxTokens > 0
+      ? Math.floor(params.modelMaxTokens)
+      : undefined;
+  const requested =
+    typeof params.requestedMaxTokens === "number" &&
+    Number.isFinite(params.requestedMaxTokens) &&
+    params.requestedMaxTokens > 0
+      ? Math.floor(params.requestedMaxTokens)
+      : undefined;
+
+  if (modelMax !== undefined && requested !== undefined) {
+    return Math.min(requested, modelMax);
+  }
+  return requested ?? modelMax;
+}
+
+function createAnthropicVertexOnPayload(params: {
+  model: { api: string; baseUrl?: string; provider: string };
+  cacheRetention: AnthropicOptions["cacheRetention"] | undefined;
+  onPayload: AnthropicOptions["onPayload"] | undefined;
+}): NonNullable<AnthropicOptions["onPayload"]> {
+  const policy = resolveAnthropicPayloadPolicy({
+    provider: params.model.provider,
+    api: params.model.api,
+    baseUrl: params.model.baseUrl,
+    cacheRetention: params.cacheRetention,
+    enableCacheControl: true,
+  });
+
+  function applyPolicy(payload: unknown): unknown {
+    if (payload && typeof payload === "object" && !Array.isArray(payload)) {
+      applyAnthropicPayloadPolicyToParams(payload as Record<string, unknown>, policy);
+    }
+    return payload;
+  }
+
+  return async (payload, model) => {
+    const shapedPayload = applyPolicy(payload);
+    const nextPayload = await params.onPayload?.(shapedPayload, model);
+    if (nextPayload === undefined || 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.
+ */
+export function createAnthropicVertexStreamFn(
+  projectId: string | undefined,
+  region: string,
+  baseURL?: string,
+  deps: AnthropicVertexStreamDeps = defaultAnthropicVertexStreamDeps,
+): StreamFn {
+  const client = new deps.AnthropicVertex({
+    region,
+    ...(baseURL ? { baseURL } : {}),
+    ...(projectId ? { projectId } : {}),
+  });
+
+  return (model, context, options) => {
+    const transportModel = model as Model<"anthropic-messages"> & {
+      api: string;
+      baseUrl?: string;
+      provider: string;
+    };
+    const maxTokens = resolveAnthropicVertexMaxTokens({
+      modelMaxTokens: transportModel.maxTokens,
+      requestedMaxTokens: options?.maxTokens,
+    });
+    const opts: AnthropicOptions = {
+      client: client as AnthropicOptions["client"],
+      temperature: options?.temperature,
+      ...(maxTokens !== undefined ? { 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,
+        ) as AnthropicVertexEffort;
+      } else {
+        opts.thinkingEnabled = true;
+        const budgets = options.thinkingBudgets;
+        opts.thinkingBudgetTokens =
+          (budgets && options.reasoning in budgets
+            ? budgets[options.reasoning as keyof typeof budgets]
+            : undefined) ?? 10000;
+      }
+    } else {
+      opts.thinkingEnabled = false;
+    }
+
+    return deps.streamAnthropic(transportModel, context, opts);
+  };
+}
+
+function resolveAnthropicVertexSdkBaseUrl(baseUrl?: string): string | undefined {
+  const trimmed = baseUrl?.trim();
+  if (!trimmed) {
+    return undefined;
+  }
+
+  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;
+  }
+}
+
+export function createAnthropicVertexStreamFnForModel(
+  model: { baseUrl?: string },
+  env: NodeJS.ProcessEnv = process.env,
+  deps?: AnthropicVertexStreamDeps,
+): StreamFn {
+  return createAnthropicVertexStreamFn(
+    resolveAnthropicVertexProjectId(env),
+    resolveAnthropicVertexClientRegion({
+      baseUrl: model.baseUrl,
+      env,
+    }),
+    resolveAnthropicVertexSdkBaseUrl(model.baseUrl),
+    deps,
+  );
+}

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "extends": "../tsconfig.package-boundary.base.json",
+  "compilerOptions": {
+    "rootDir": "."
+  },
+  "include": ["./*.ts", "./src/**/*.ts"],
+  "exclude": [
+    "./**/*.test.ts",
+    "./dist/**",
+    "./node_modules/**",
+    "./src/test-support/**",
+    "./src/**/*test-helpers.ts",
+    "./src/**/*test-harness.ts",
+    "./src/**/*test-support.ts"
+  ]
+}