@pellux/goodvibes-tui 0.18.4

package/src/providers/anthropic-compat.ts

@@ -0,0 +1,373 @@
+import type {
+  LLMProvider,
+  ChatRequest,
+  ChatResponse,
+  ProviderRuntimeMetadata,
+  ProviderRuntimeMetadataDeps,
+} from './interface.ts';
+import { REASONING_BUDGET_MAP } from './interface.ts';
+import { ProviderError } from '@pellux/goodvibes-sdk/platform/types/errors';
+import { withRetry } from '@pellux/goodvibes-sdk/platform/utils/retry';
+import { logger } from '@pellux/goodvibes-sdk/platform/utils/logger';
+import {
+  toAnthropicTools,
+  toAnthropicMessages,
+  fromAnthropicContent,
+} from './tool-formats.ts';
+import type { AnthropicContentBlock } from './tool-formats.ts';
+import { toProviderError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+
+const ANTHROPIC_API_VERSION = '2023-06-01';
+
+interface AnthropicCompatResponseBody {
+  content: AnthropicContentBlock[];
+  stop_reason: string;
+  usage: { input_tokens: number; output_tokens: number };
+}
+
+/** Anthropic SSE event types used in streaming responses. */
+interface AnthropicCompatSSEEvent {
+  type: string;
+  index?: number;
+  delta?: {
+    type?: string;
+    text?: string;
+    thinking?: string;
+    partial_json?: string;
+    stop_reason?: string;
+  };
+  content_block?: {
+    type: string;
+    id?: string;
+    name?: string;
+    text?: string;
+    thinking?: string;
+  };
+  message?: {
+    usage?: { input_tokens: number; output_tokens: number; cache_read_input_tokens?: number; cache_creation_input_tokens?: number };
+  };
+  usage?: { input_tokens?: number; output_tokens?: number; cache_read_input_tokens?: number; cache_creation_input_tokens?: number };
+}
+
+export interface AnthropicCompatOptions {
+  /** Unique provider identifier, e.g. 'my-anthropic-proxy' */
+  name: string;
+  /** Base URL for the Anthropic Messages API, e.g. 'https://my-proxy.example.com/v1' */
+  baseURL: string;
+  /** API key sent as the x-api-key header */
+  apiKey: string;
+  /** Model ID to use when none is specified in ChatRequest */
+  defaultModel: string;
+  /** List of model IDs exposed by this provider */
+  models: string[];
+  /** Optional extra HTTP headers sent with every request */
+  defaultHeaders?: Record<string, string>;
+  /** Optional env vars or secret keys that can satisfy auth for this provider. */
+  authEnvVars?: readonly string[];
+  /** Optional service names that expose service-owned OAuth for this provider. */
+  serviceNames?: readonly string[];
+  /** Optional provider aliases exposed to runtime metadata consumers. */
+  aliases?: readonly string[];
+  /** Optional subscription-provider identity when this provider can use a stored OAuth session. */
+  subscriptionProviderId?: string;
+  /** Optional explicit stream protocol label for diagnostics. */
+  streamProtocol?: string;
+  /** Optional auth header mode. Default: x-api-key. */
+  authHeaderMode?: 'x-api-key' | 'bearer';
+  /** Optional anonymous/local access posture. */
+  allowAnonymous?: boolean;
+  anonymousConfigured?: boolean;
+  anonymousDetail?: string;
+}
+
+/**
+ * AnthropicCompatProvider — generic provider for endpoints that speak the
+ * Anthropic Messages API (SSE streaming variant). Useful for self-hosted
+ * proxies, Claude-compatible services, and any backend that mirrors the
+ * Anthropic Messages API spec.
+ *
+ * Configured via a custom provider JSON file with `"type": "anthropic-compat"`
+ * in ~/.goodvibes/tui/providers/.
+ */
+export class AnthropicCompatProvider implements LLMProvider {
+  readonly name: string;
+  readonly models: string[];
+
+  private baseURL: string;
+  private apiKey: string;
+  private defaultModel: string;
+  private defaultHeaders: Record<string, string>;
+  private readonly authEnvVars: readonly string[];
+  private readonly serviceNames: readonly string[];
+  private readonly aliases: readonly string[];
+  private readonly subscriptionProviderId?: string;
+  private readonly streamProtocol?: string;
+  private readonly authHeaderMode: 'x-api-key' | 'bearer';
+  private readonly allowAnonymous: boolean;
+  private readonly anonymousConfigured: boolean;
+  private readonly anonymousDetail?: string;
+
+  constructor(opts: AnthropicCompatOptions) {
+    this.name = opts.name;
+    this.models = opts.models;
+    this.baseURL = opts.baseURL.replace(/\/$/, ''); // strip trailing slash
+    this.apiKey = opts.apiKey;
+    this.defaultModel = opts.defaultModel;
+    this.defaultHeaders = opts.defaultHeaders ?? {};
+    this.authEnvVars = opts.authEnvVars ?? [];
+    this.serviceNames = opts.serviceNames ?? [];
+    this.aliases = opts.aliases ?? [];
+    this.subscriptionProviderId = opts.subscriptionProviderId;
+    this.streamProtocol = opts.streamProtocol;
+    this.authHeaderMode = opts.authHeaderMode ?? 'x-api-key';
+    this.allowAnonymous = opts.allowAnonymous ?? false;
+    this.anonymousConfigured = opts.anonymousConfigured ?? false;
+    this.anonymousDetail = opts.anonymousDetail;
+  }
+
+  async chat(params: ChatRequest): Promise<ChatResponse> {
+    const { messages, tools, model, maxTokens, signal, systemPrompt, onDelta, reasoningEffort } = params;
+
+    return withRetry(async () => {
+      const resolvedModel = model ?? this.defaultModel;
+
+      const body: Record<string, unknown> = {
+        model: resolvedModel,
+        max_tokens: maxTokens ?? 8192,
+        messages: toAnthropicMessages(messages),
+        stream: true,
+      };
+
+      if (systemPrompt) {
+        body['system'] = systemPrompt;
+      }
+
+      if (tools && tools.length > 0) {
+        body['tools'] = toAnthropicTools(tools);
+      }
+
+      if (reasoningEffort && reasoningEffort !== 'instant') {
+        const budget = REASONING_BUDGET_MAP[reasoningEffort];
+        if (budget !== undefined && budget > 0) {
+          body['thinking'] = { type: 'enabled', budget_tokens: budget };
+          const currentMax = (body['max_tokens'] as number) ?? 8192;
+          if (currentMax <= budget) {
+            body['max_tokens'] = budget + 4096;
+          }
+        }
+      }
+
+      const headers: Record<string, string> = {
+        'Content-Type': 'application/json',
+        'anthropic-version': ANTHROPIC_API_VERSION,
+        ...this.defaultHeaders,
+      };
+      if (this.apiKey) {
+        if (this.authHeaderMode === 'bearer') {
+          headers['Authorization'] = `Bearer ${this.apiKey}`;
+        } else {
+          headers['x-api-key'] = this.apiKey;
+        }
+      }
+
+      if (body['thinking']) {
+        headers['anthropic-beta'] = 'interleaved-thinking-2025-05-14';
+      }
+
+      let res: Response;
+      try {
+        res = await fetch(`${this.baseURL}/messages`, {
+          method: 'POST',
+          headers,
+          body: JSON.stringify(body),
+          signal,
+        });
+      } catch (err: unknown) {
+        throw toProviderError(err, {
+          provider: this.name,
+          operation: 'chat',
+          phase: 'request',
+        });
+      }
+
+      if (!res.ok) {
+        const text = await res.text().catch(() => 'unknown error');
+        throw new ProviderError(
+          `AnthropicCompat(${this.name}) API error ${res.status}: ${text}`,
+          {
+            statusCode: res.status,
+            provider: this.name,
+            operation: 'chat',
+            phase: 'request',
+          },
+        );
+      }
+
+      // Parse SSE stream
+      let responseText = '';
+      let inputTokens = 0;
+      let outputTokens = 0;
+      let cacheReadTokens = 0;
+      let cacheWriteTokens = 0;
+      let stopReason: ChatResponse['stopReason'] = 'end';
+
+      // Accumulate tool use blocks by index
+      const toolBlocks = new Map<number, { id: string; name: string; args: string }>();
+
+      const reader = res.body?.getReader();
+      if (!reader) {
+        throw new ProviderError(`AnthropicCompat(${this.name}) returned no response body.`, {
+          statusCode: 502,
+          provider: this.name,
+          operation: 'chat',
+          phase: 'response',
+        });
+      }
+
+      const decoder = new TextDecoder();
+      let buffer = '';
+
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split('\n');
+          buffer = lines.pop() ?? '';
+
+          for (const line of lines) {
+            if (!line.startsWith('data: ')) continue;
+            const data = line.slice(6).trim();
+            if (!data || data === '[DONE]') continue;
+
+            let event: AnthropicCompatSSEEvent;
+            try {
+              event = JSON.parse(data) as AnthropicCompatSSEEvent;
+            } catch {
+              logger.debug('AnthropicCompat SSE: failed to parse JSON chunk', { data });
+              continue;
+            }
+
+            if (event.type === 'content_block_start' && event.content_block?.type === 'tool_use') {
+              const idx = event.index ?? 0;
+              toolBlocks.set(idx, {
+                id: event.content_block.id ?? '',
+                name: event.content_block.name ?? '',
+                args: '',
+              });
+              if (onDelta) {
+                onDelta({ toolCalls: [{ index: idx, id: event.content_block.id, name: event.content_block.name }] });
+              }
+            } else if (event.type === 'content_block_delta') {
+              const idx = event.index ?? 0;
+              if (event.delta?.type === 'text_delta' && event.delta.text) {
+                responseText += event.delta.text;
+                if (onDelta) onDelta({ content: event.delta.text });
+              } else if (event.delta?.type === 'thinking_delta' && event.delta.thinking) {
+                if (onDelta) onDelta({ reasoning: event.delta.thinking });
+              } else if (event.delta?.type === 'input_json_delta' && event.delta.partial_json) {
+                const block = toolBlocks.get(idx);
+                if (block) block.args += event.delta.partial_json;
+                if (onDelta) {
+                  onDelta({ toolCalls: [{ index: idx, arguments: event.delta.partial_json }] });
+                }
+              }
+            } else if (event.type === 'message_delta') {
+              if (event.delta?.stop_reason === 'tool_use') stopReason = 'tool_use';
+              else if (event.delta?.stop_reason === 'max_tokens') stopReason = 'max_tokens';
+              if (event.usage?.output_tokens) outputTokens = event.usage.output_tokens;
+              if (event.usage?.cache_read_input_tokens != null) cacheReadTokens = event.usage.cache_read_input_tokens;
+              if (event.usage?.cache_creation_input_tokens != null) cacheWriteTokens = event.usage.cache_creation_input_tokens;
+            } else if (event.type === 'message_start') {
+              if (event.message?.usage) {
+                inputTokens = event.message.usage.input_tokens;
+                outputTokens = event.message.usage.output_tokens;
+                cacheReadTokens = event.message.usage.cache_read_input_tokens ?? 0;
+                cacheWriteTokens = event.message.usage.cache_creation_input_tokens ?? 0;
+              }
+            }
+          }
+        }
+      } finally {
+        reader.releaseLock();
+      }
+
+      // Assemble content blocks
+      const contentBlocks: AnthropicContentBlock[] = [];
+      if (responseText) {
+        contentBlocks.push({ type: 'text', text: responseText } as AnthropicContentBlock);
+      }
+      for (const [, block] of [...toolBlocks.entries()].sort(([a], [b]) => a - b)) {
+        let parsedInput: Record<string, unknown> = {};
+        try {
+          parsedInput = JSON.parse(block.args || '{}') as Record<string, unknown>;
+        } catch {
+          logger.debug('AnthropicCompat: failed to parse tool args JSON', { name: block.name, args: block.args });
+          parsedInput = {};
+        }
+        contentBlocks.push({
+          type: 'tool_use',
+          id: block.id,
+          name: block.name,
+          input: parsedInput,
+        } as AnthropicContentBlock);
+      }
+
+      const { text, toolCalls } = fromAnthropicContent(contentBlocks);
+
+      return {
+        content: text,
+        toolCalls,
+        usage: { inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens },
+        stopReason,
+      };
+    });
+  }
+
+  async describeRuntime(deps: ProviderRuntimeMetadataDeps): Promise<ProviderRuntimeMetadata> {
+    const { buildStandardProviderAuthRoutes } = await import('./runtime-metadata.ts');
+    const authRoutes = await buildStandardProviderAuthRoutes({
+      providerId: this.name,
+      apiKeyEnvVars: this.authEnvVars,
+      secretKeys: this.authEnvVars,
+      serviceNames: this.serviceNames,
+      ...(this.subscriptionProviderId ? { subscriptionProviderId: this.subscriptionProviderId } : {}),
+      allowAnonymous: this.allowAnonymous,
+      anonymousConfigured: this.anonymousConfigured,
+      anonymousDetail: this.anonymousDetail,
+    }, deps);
+    return {
+      auth: {
+        mode: this.allowAnonymous && !this.apiKey ? 'anonymous' : 'api-key',
+        configured: Boolean(this.apiKey) || this.anonymousConfigured,
+        detail: this.apiKey
+          ? `API key for ${this.name} is available`
+          : this.allowAnonymous
+            ? (this.anonymousDetail ?? `${this.name} can be used without a stored API key`)
+            : `API key for ${this.name} is not configured`,
+        ...(this.authEnvVars.length > 0 ? { envVars: this.authEnvVars } : {}),
+        routes: authRoutes,
+      },
+      models: {
+        defaultModel: this.defaultModel,
+        models: this.models,
+        ...(this.aliases.length > 0 ? { aliases: this.aliases } : {}),
+      },
+      usage: {
+        streaming: true,
+        toolCalling: true,
+        parallelTools: true,
+        promptCaching: true,
+        notes: ['Anthropic prompt caching and thinking controls are surfaced through the compat wrapper.'],
+      },
+      policy: {
+        local: false,
+        streamProtocol: this.streamProtocol ?? 'anthropic-sse',
+        reasoningMode: 'thinking_budget',
+        supportedReasoningEfforts: ['instant', 'low', 'medium', 'high'],
+        cacheStrategy: 'anthropic-prompt-cache',
+      },
+    };
+  }
+}

package/src/providers/anthropic-sdk-provider.ts

@@ -0,0 +1,230 @@
+import type { MessageStreamEvent } from '@anthropic-ai/sdk/resources/messages';
+import type {
+  ChatRequest,
+  ChatResponse,
+  LLMProvider,
+  ProviderRuntimeMetadata,
+  ProviderRuntimeMetadataDeps,
+} from './interface.ts';
+import { REASONING_BUDGET_MAP } from './interface.ts';
+import type { AnthropicContentBlock } from './tool-formats.ts';
+import {
+  fromAnthropicContent,
+  toAnthropicMessages,
+  toAnthropicTools,
+} from './tool-formats.ts';
+import { ProviderError } from '@pellux/goodvibes-sdk/platform/types/errors';
+import { withRetry } from '@pellux/goodvibes-sdk/platform/utils/retry';
+import { buildStandardProviderAuthRoutes } from './runtime-metadata.ts';
+import { toProviderError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+
+const DEFAULT_MAX_OUTPUT = 8192;
+
+type AnthropicStreamCapableClient = {
+  messages: {
+    stream: unknown;
+  };
+};
+
+type AnthropicMessageStream = AsyncIterable<MessageStreamEvent> & {
+  finalMessage(): Promise<{
+    content: unknown;
+    usage: {
+      input_tokens: number;
+      output_tokens: number;
+      cache_read_input_tokens?: number | null;
+      cache_creation_input_tokens?: number | null;
+    };
+  }>;
+};
+
+function normalizeAnthropicModel(model: string): string {
+  if (model.startsWith('anthropic:')) return model.slice('anthropic:'.length);
+  if (model.startsWith('anthropic/')) return model.slice('anthropic/'.length);
+  return model;
+}
+
+export interface AnthropicSdkProviderAuthConfig {
+  readonly mode: 'api-key' | 'anonymous';
+  readonly configured: boolean;
+  readonly detail: string;
+  readonly envVars?: readonly string[];
+  readonly secretKeys?: readonly string[];
+  readonly serviceNames?: readonly string[];
+  readonly allowAnonymous?: boolean;
+  readonly anonymousConfigured?: boolean;
+  readonly anonymousDetail?: string;
+}
+
+export interface AnthropicSdkProviderOptions {
+  readonly name: string;
+  readonly label: string;
+  readonly defaultModel: string;
+  readonly models: readonly string[];
+  readonly createClient: () => AnthropicStreamCapableClient;
+  readonly auth: AnthropicSdkProviderAuthConfig;
+  readonly streamProtocol: string;
+  readonly notes?: readonly string[];
+}
+
+export class AnthropicSdkProvider implements LLMProvider {
+  readonly name: string;
+  readonly models: string[];
+
+  constructor(private readonly options: AnthropicSdkProviderOptions) {
+    this.name = options.name;
+    this.models = [...options.models];
+  }
+
+  async chat(params: ChatRequest): Promise<ChatResponse> {
+    return withRetry(async () => {
+      const client = this.options.createClient();
+      const resolvedModel = normalizeAnthropicModel(params.model ?? this.options.defaultModel);
+      const body: Record<string, unknown> = {
+        model: resolvedModel,
+        max_tokens: params.maxTokens ?? DEFAULT_MAX_OUTPUT,
+        messages: toAnthropicMessages(params.messages),
+        stream: true,
+      };
+
+      if (params.systemPrompt) {
+        body['system'] = params.systemPrompt;
+      }
+
+      if (params.tools && params.tools.length > 0) {
+        body['tools'] = toAnthropicTools(params.tools);
+      }
+
+      if (params.reasoningEffort && params.reasoningEffort !== 'instant') {
+        const budget = REASONING_BUDGET_MAP[params.reasoningEffort];
+        if (typeof budget === 'number' && budget > 0) {
+          body['thinking'] = { type: 'enabled', budget_tokens: budget };
+          const currentMax = (body['max_tokens'] as number) ?? DEFAULT_MAX_OUTPUT;
+          if (currentMax <= budget) body['max_tokens'] = budget + 4096;
+        }
+      }
+
+      const toolBlocks = new Map<number, { id: string; name: string; args: string }>();
+      let responseText = '';
+      let stopReason: ChatResponse['stopReason'] = 'end';
+
+      try {
+        const streamFactory = client.messages.stream as (
+          body: Record<string, unknown>,
+          options?: { signal?: AbortSignal },
+        ) => AnthropicMessageStream;
+        const stream = streamFactory(body, params.signal ? { signal: params.signal } : undefined);
+        for await (const event of stream as AsyncIterable<MessageStreamEvent>) {
+          if (event.type === 'content_block_start' && event.content_block.type === 'tool_use') {
+            const idx = event.index ?? 0;
+            toolBlocks.set(idx, {
+              id: event.content_block.id ?? '',
+              name: event.content_block.name ?? '',
+              args: '',
+            });
+            params.onDelta?.({
+              toolCalls: [{ index: idx, id: event.content_block.id, name: event.content_block.name }],
+            });
+          } else if (event.type === 'content_block_delta') {
+            const idx = event.index ?? 0;
+            if (event.delta.type === 'text_delta' && event.delta.text) {
+              responseText += event.delta.text;
+              params.onDelta?.({ content: event.delta.text });
+            } else if (event.delta.type === 'thinking_delta' && event.delta.thinking) {
+              params.onDelta?.({ reasoning: event.delta.thinking });
+            } else if (event.delta.type === 'input_json_delta' && event.delta.partial_json) {
+              const block = toolBlocks.get(idx);
+              if (block) block.args += event.delta.partial_json;
+              params.onDelta?.({
+                toolCalls: [{ index: idx, arguments: event.delta.partial_json }],
+              });
+            }
+          } else if (event.type === 'message_delta') {
+            if (event.delta.stop_reason === 'tool_use') stopReason = 'tool_use';
+            else if (event.delta.stop_reason === 'max_tokens') stopReason = 'max_tokens';
+          }
+        }
+
+        const finalMessage = await stream.finalMessage();
+        const contentBlocks: AnthropicContentBlock[] = [];
+        if (responseText) {
+          contentBlocks.push({ type: 'text', text: responseText } as AnthropicContentBlock);
+        }
+        for (const [, block] of [...toolBlocks.entries()].sort(([a], [b]) => a - b)) {
+          let parsedInput: Record<string, unknown> = {};
+          try {
+            parsedInput = JSON.parse(block.args || '{}') as Record<string, unknown>;
+          } catch {
+            parsedInput = {};
+          }
+          contentBlocks.push({
+            type: 'tool_use',
+            id: block.id,
+            name: block.name,
+            input: parsedInput,
+          } as AnthropicContentBlock);
+        }
+
+        const parsed = contentBlocks.length > 0
+          ? fromAnthropicContent(contentBlocks)
+          : fromAnthropicContent(finalMessage.content as AnthropicContentBlock[]);
+
+        return {
+          content: parsed.text,
+          toolCalls: parsed.toolCalls,
+          usage: {
+            inputTokens: finalMessage.usage.input_tokens,
+            outputTokens: finalMessage.usage.output_tokens,
+            ...(finalMessage.usage.cache_read_input_tokens != null ? { cacheReadTokens: finalMessage.usage.cache_read_input_tokens } : {}),
+            ...(finalMessage.usage.cache_creation_input_tokens != null ? { cacheWriteTokens: finalMessage.usage.cache_creation_input_tokens } : {}),
+          },
+          stopReason,
+        };
+      } catch (error) {
+        throw toProviderError(error, {
+          provider: this.name,
+          operation: 'chat',
+          phase: 'stream',
+        });
+      }
+    });
+  }
+
+  async describeRuntime(deps: ProviderRuntimeMetadataDeps): Promise<ProviderRuntimeMetadata> {
+    const authRoutes = await buildStandardProviderAuthRoutes({
+      providerId: this.options.name,
+      apiKeyEnvVars: this.options.auth.envVars,
+      secretKeys: this.options.auth.secretKeys,
+      serviceNames: this.options.auth.serviceNames,
+      allowAnonymous: this.options.auth.allowAnonymous,
+      anonymousConfigured: this.options.auth.anonymousConfigured,
+      anonymousDetail: this.options.auth.anonymousDetail,
+    }, deps);
+    return {
+      auth: {
+        mode: this.options.auth.mode,
+        configured: this.options.auth.configured,
+        detail: this.options.auth.detail,
+        ...(this.options.auth.envVars ? { envVars: this.options.auth.envVars } : {}),
+        routes: authRoutes,
+      },
+      models: {
+        defaultModel: this.options.defaultModel,
+        models: this.models,
+      },
+      usage: {
+        streaming: true,
+        toolCalling: true,
+        parallelTools: true,
+        promptCaching: true,
+        ...(this.options.notes ? { notes: this.options.notes } : {}),
+      },
+      policy: {
+        local: false,
+        streamProtocol: this.options.streamProtocol,
+        reasoningMode: 'thinking_budget',
+        supportedReasoningEfforts: ['instant', 'low', 'medium', 'high'],
+      },
+    };
+  }
+}

package/src/providers/anthropic-vertex.ts

@@ -0,0 +1,59 @@
+import { AnthropicVertex } from '@anthropic-ai/vertex-sdk';
+import { AnthropicSdkProvider } from './anthropic-sdk-provider.ts';
+
+const VERTEX_MODELS = [
+  'claude-sonnet-4-6',
+  'claude-opus-4-6',
+  'claude-haiku-4-5',
+];
+
+function resolveVertexProjectId(): string | null {
+  return process.env['ANTHROPIC_VERTEX_PROJECT_ID']
+    ?? process.env['GOOGLE_CLOUD_PROJECT']
+    ?? process.env['GOOGLE_CLOUD_PROJECT_ID']
+    ?? null;
+}
+
+function hasVertexCredentials(): boolean {
+  return Boolean(
+    resolveVertexProjectId()
+    && (process.env['GOOGLE_APPLICATION_CREDENTIALS'] || process.env['ANTHROPIC_VERTEX_USE_GCP_METADATA'] === '1'),
+  );
+}
+
+export class AnthropicVertexProvider extends AnthropicSdkProvider {
+  constructor() {
+    const configured = hasVertexCredentials();
+    super({
+      name: 'anthropic-vertex',
+      label: 'Anthropic Vertex',
+      defaultModel: 'claude-sonnet-4-6',
+      models: VERTEX_MODELS,
+      createClient: () => new AnthropicVertex({
+        projectId: resolveVertexProjectId(),
+        region: process.env['GOOGLE_CLOUD_LOCATION'] ?? process.env['CLOUD_ML_REGION'] ?? 'global',
+      }),
+      auth: {
+        mode: configured ? 'api-key' : 'anonymous',
+        configured,
+        detail: configured
+          ? 'Google Cloud Vertex credentials are available for Anthropic Vertex.'
+          : 'Configure project ID plus GOOGLE_APPLICATION_CREDENTIALS or metadata-based auth for Anthropic Vertex.',
+        envVars: [
+          'ANTHROPIC_VERTEX_PROJECT_ID',
+          'GOOGLE_CLOUD_PROJECT',
+          'GOOGLE_CLOUD_PROJECT_ID',
+          'GOOGLE_CLOUD_LOCATION',
+          'CLOUD_ML_REGION',
+          'GOOGLE_APPLICATION_CREDENTIALS',
+          'ANTHROPIC_VERTEX_USE_GCP_METADATA',
+        ],
+        allowAnonymous: true,
+        anonymousConfigured: Boolean(resolveVertexProjectId()),
+        anonymousDetail: 'Anthropic Vertex can use Google ADC or workload identity without a stored API key.',
+      },
+      streamProtocol: 'anthropic-sdk-stream',
+      notes: ['Anthropic Vertex is backed by Google ADC / Vertex auth rather than a provider API key.'],
+    });
+  }
+}