@f5-sales-demo/pi-ai 19.51.2

package/src/usage/zai.ts

@@ -0,0 +1,247 @@
+import type {
+	UsageAmount,
+	UsageFetchContext,
+	UsageFetchParams,
+	UsageLimit,
+	UsageProvider,
+	UsageReport,
+	UsageStatus,
+	UsageWindow,
+} from "../usage";
+import { isRecord, toNumber } from "../utils";
+
+const DEFAULT_ENDPOINT = "https://api.z.ai";
+const QUOTA_PATH = "/api/monitor/usage/quota/limit";
+const MODEL_USAGE_PATH = "/api/monitor/usage/model-usage";
+const SEVEN_DAYS_MS = 7 * 24 * 60 * 60 * 1000;
+
+function normalizeZaiBaseUrl(baseUrl?: string): string {
+	if (!baseUrl?.trim()) return DEFAULT_ENDPOINT;
+	try {
+		return new URL(baseUrl.trim()).origin;
+	} catch {
+		return DEFAULT_ENDPOINT;
+	}
+}
+
+interface ZaiUsageLimitItem {
+	type?: string;
+	usage?: number;
+	currentValue?: number;
+	percentage?: number;
+	remaining?: number;
+	nextResetTime?: number;
+}
+
+interface ZaiQuotaPayload {
+	success?: boolean;
+	code?: number;
+	msg?: string;
+	data?: {
+		limits?: ZaiUsageLimitItem[];
+	};
+}
+
+function parseMillis(value: unknown): number | undefined {
+	const parsed = toNumber(value);
+	if (parsed === undefined) return undefined;
+	return parsed > 1_000_000_000_000 ? parsed : parsed * 1000;
+}
+
+function parseLimitItem(value: unknown): ZaiUsageLimitItem | null {
+	if (!isRecord(value)) return null;
+	const type = typeof value.type === "string" ? value.type : undefined;
+	if (!type) return null;
+	return {
+		type,
+		usage: toNumber(value.usage),
+		currentValue: toNumber(value.currentValue),
+		percentage: toNumber(value.percentage),
+		remaining: toNumber(value.remaining),
+		nextResetTime: parseMillis(value.nextResetTime),
+	};
+}
+
+function buildUsageAmount(args: {
+	used: number | undefined;
+	limit: number | undefined;
+	remaining: number | undefined;
+	unit: UsageAmount["unit"];
+	percentage?: number;
+}): UsageAmount {
+	const usedFraction =
+		args.percentage !== undefined
+			? Math.min(Math.max(args.percentage / 100, 0), 1)
+			: args.used !== undefined && args.limit !== undefined && args.limit > 0
+				? Math.min(args.used / args.limit, 1)
+				: undefined;
+	const remainingFraction = usedFraction !== undefined ? Math.max(1 - usedFraction, 0) : undefined;
+	return {
+		used: args.used,
+		limit: args.limit,
+		remaining: args.remaining,
+		usedFraction,
+		remainingFraction,
+		unit: args.unit,
+	};
+}
+
+function getUsageStatus(usedFraction: number | undefined): UsageStatus | undefined {
+	if (usedFraction === undefined) return undefined;
+	if (usedFraction >= 1) return "exhausted";
+	if (usedFraction >= 0.9) return "warning";
+	return "ok";
+}
+
+function formatDate(value: Date): string {
+	const pad = (input: number) => String(input).padStart(2, "0");
+	return `${value.getFullYear()}-${pad(value.getMonth() + 1)}-${pad(value.getDate())}+${pad(value.getHours())}:${pad(
+		value.getMinutes(),
+	)}:${pad(value.getSeconds())}`;
+}
+
+function buildModelUsageUrl(baseUrl: string, now: Date): string {
+	const start = new Date(now.getTime() - SEVEN_DAYS_MS);
+	const startTime = formatDate(start);
+	const endTime = formatDate(now);
+	return `${baseUrl}${MODEL_USAGE_PATH}?startTime=${encodeURIComponent(startTime)}&endTime=${encodeURIComponent(endTime)}`;
+}
+
+async function fetchZaiUsage(params: UsageFetchParams, ctx: UsageFetchContext): Promise<UsageReport | null> {
+	if (params.provider !== "zai") return null;
+	const credential = params.credential;
+	if (credential.type !== "api_key" || !credential.apiKey) return null;
+
+	const baseUrl = normalizeZaiBaseUrl(params.baseUrl);
+	const url = `${baseUrl}${QUOTA_PATH}`;
+	const headers: Record<string, string> = {
+		Authorization: credential.apiKey,
+		"Content-Type": "application/json",
+		"User-Agent": "OpenCode-Status-Plugin/1.0",
+	};
+
+	let payload: ZaiQuotaPayload | null = null;
+	try {
+		const response = await ctx.fetch(url, {
+			headers,
+			signal: params.signal,
+		});
+		if (!response.ok) {
+			ctx.logger?.warn("ZAI usage fetch failed", { status: response.status, statusText: response.statusText });
+			return null;
+		}
+		payload = (await response.json()) as ZaiQuotaPayload;
+	} catch (error) {
+		ctx.logger?.warn("ZAI usage fetch error", { error: String(error) });
+		return null;
+	}
+
+	if (!payload) return null;
+	if (payload.success !== true) {
+		ctx.logger?.warn("ZAI usage response invalid", { code: payload.code, message: payload.msg });
+		return null;
+	}
+
+	const limitsPayload = Array.isArray(payload.data?.limits) ? payload.data?.limits : [];
+	const limits: UsageLimit[] = [];
+
+	for (const rawLimit of limitsPayload) {
+		const parsed = parseLimitItem(rawLimit);
+		if (!parsed) continue;
+		if (parsed.type === "TOKENS_LIMIT") {
+			const amount = buildUsageAmount({
+				used: parsed.currentValue,
+				limit: parsed.usage,
+				remaining: parsed.remaining,
+				percentage: parsed.percentage,
+				unit: "tokens",
+			});
+			const window: UsageWindow = {
+				id: "quota",
+				label: "Quota",
+				durationMs: SEVEN_DAYS_MS,
+				resetsAt: parsed.nextResetTime,
+			};
+			limits.push({
+				id: "zai:tokens",
+				label: "ZAI Token Quota",
+				scope: {
+					provider: params.provider,
+					windowId: window?.id ?? "quota",
+					shared: true,
+				},
+				window,
+				amount,
+				status: getUsageStatus(amount.usedFraction),
+			});
+		}
+		if (parsed.type === "TIME_LIMIT") {
+			const window: UsageWindow = {
+				id: "quota",
+				label: "Quota",
+				durationMs: SEVEN_DAYS_MS,
+				resetsAt: parsed.nextResetTime,
+			};
+			const amount = buildUsageAmount({
+				used: parsed.currentValue,
+				limit: parsed.usage,
+				remaining: parsed.remaining,
+				percentage: parsed.percentage,
+				unit: "requests",
+			});
+			limits.push({
+				id: "zai:requests",
+				label: "ZAI Request Quota",
+				scope: {
+					provider: params.provider,
+					windowId: "quota",
+					shared: true,
+				},
+				window,
+				amount,
+				status: getUsageStatus(amount.usedFraction),
+			});
+		}
+	}
+
+	if (limits.length === 0) return null;
+
+	const report: UsageReport = {
+		provider: params.provider,
+		fetchedAt: Date.now(),
+		limits,
+		metadata: {
+			endpoint: url,
+			accountId: credential.accountId,
+			email: credential.email,
+		},
+		raw: payload,
+	};
+
+	const modelUsageUrl = buildModelUsageUrl(baseUrl, new Date());
+	try {
+		const response = await ctx.fetch(modelUsageUrl, {
+			headers,
+			signal: params.signal,
+		});
+		if (response.ok) {
+			const modelUsagePayload = (await response.json()) as unknown;
+			if (isRecord(modelUsagePayload)) {
+				report.metadata = {
+					...report.metadata,
+					modelUsage: modelUsagePayload,
+				};
+			}
+		}
+	} catch (error) {
+		ctx.logger?.debug("ZAI model usage fetch failed", { error: String(error) });
+	}
+
+	return report;
+}
+
+export const zaiUsageProvider: UsageProvider = {
+	id: "zai",
+	fetchUsage: fetchZaiUsage,
+	supports: params => params.provider === "zai" && params.credential.type === "api_key",
+};

package/src/usage.ts

@@ -0,0 +1,130 @@
+/**
+ * Usage reporting types for provider quota/limit endpoints.
+ *
+ * Provides a normalized schema to represent multiple limit windows, model tiers,
+ * and shared quotas across providers.
+ */
+import type { Provider } from "./types";
+
+export type UsageUnit = "percent" | "tokens" | "requests" | "usd" | "minutes" | "bytes" | "unknown";
+
+export type UsageStatus = "ok" | "warning" | "exhausted" | "unknown";
+
+/** Time window for a limit (e.g. 5h, 7d, monthly). */
+export interface UsageWindow {
+	/** Stable identifier (e.g. "5h", "7d", "monthly"). */
+	id: string;
+	/** Human label (e.g. "5 Hour", "7 Day"). */
+	label: string;
+	/** Window duration in milliseconds, when known. */
+	durationMs?: number;
+	/** Absolute reset timestamp in milliseconds since epoch. */
+	resetsAt?: number;
+}
+
+/** Quantitative usage data. */
+export interface UsageAmount {
+	/** Amount used in the given unit. */
+	used?: number;
+	/** Maximum limit in the given unit. */
+	limit?: number;
+	/** Remaining amount in the given unit. */
+	remaining?: number;
+	/** Fraction used (0..1). */
+	usedFraction?: number;
+	/** Fraction remaining (0..1). */
+	remainingFraction?: number;
+	/** Unit for the amounts (percent, tokens, etc.). */
+	unit: UsageUnit;
+}
+
+/** Scope metadata describing what the limit applies to. */
+export interface UsageScope {
+	provider: Provider;
+	accountId?: string;
+	projectId?: string;
+	orgId?: string;
+	modelId?: string;
+	tier?: string;
+	windowId?: string;
+	shared?: boolean;
+}
+
+/** Normalized limit entry for a single window or quota bucket. */
+export interface UsageLimit {
+	/** Stable identifier for this limit entry. */
+	id: string;
+	/** Human label for display. */
+	label: string;
+	scope: UsageScope;
+	window?: UsageWindow;
+	amount: UsageAmount;
+	status?: UsageStatus;
+	notes?: string[];
+}
+
+/** Aggregated usage report for a provider. */
+export interface UsageReport {
+	provider: Provider;
+	fetchedAt: number;
+	limits: UsageLimit[];
+	metadata?: Record<string, unknown>;
+	raw?: unknown;
+}
+
+/** Optional logger for usage fetchers. */
+export interface UsageLogger {
+	debug(message: string, meta?: Record<string, unknown>): void;
+	warn(message: string, meta?: Record<string, unknown>): void;
+}
+
+/** Credential bundle for usage endpoints. */
+export interface UsageCredential {
+	type: "api_key" | "oauth";
+	apiKey?: string;
+	accessToken?: string;
+	refreshToken?: string;
+	expiresAt?: number;
+	accountId?: string;
+	projectId?: string;
+	email?: string;
+	enterpriseUrl?: string;
+	metadata?: Record<string, unknown>;
+}
+
+/** Parameters provided to a usage fetcher. */
+export interface UsageFetchParams {
+	provider: Provider;
+	credential: UsageCredential;
+	baseUrl?: string;
+	signal?: AbortSignal;
+}
+
+/** Shared runtime utilities for fetchers. */
+export interface UsageFetchContext {
+	fetch: typeof fetch;
+	logger?: UsageLogger;
+}
+
+/** Provider implementation for fetching usage information. */
+export interface UsageProvider {
+	id: Provider;
+	fetchUsage(params: UsageFetchParams, ctx: UsageFetchContext): Promise<UsageReport | null>;
+	supports?(params: UsageFetchParams): boolean;
+}
+
+/** Strategy for usage-based credential ranking. Providers implement this to opt into smart credential selection. */
+export interface CredentialRankingStrategy {
+	/** Extract the primary (short) and secondary (long) window limits from a usage report. */
+	findWindowLimits(report: UsageReport): {
+		primary?: UsageLimit;
+		secondary?: UsageLimit;
+	};
+	/** Fallback window durations (ms) when limits don't specify durationMs. */
+	windowDefaults: {
+		primaryMs: number;
+		secondaryMs: number;
+	};
+	/** Optional: priority boost for specific credential states (e.g., fresh 5h ticker start). */
+	hasPriorityBoost?(primary: UsageLimit | undefined): boolean;
+}

package/src/utils/abort.ts

@@ -0,0 +1,36 @@
+export interface AbortSourceTracker {
+	requestAbortController: AbortController;
+	requestSignal: AbortSignal;
+	abortLocally(reason: Error): Error;
+	getLocalAbortReason(): Error | undefined;
+	wasCallerAbort(): boolean;
+}
+
+/**
+ * Tracks whether a merged request signal was aborted by the caller or by provider-local logic.
+ */
+export function createAbortSourceTracker(callerSignal?: AbortSignal): AbortSourceTracker {
+	const requestAbortController = new AbortController();
+	const requestSignal = callerSignal
+		? AbortSignal.any([callerSignal, requestAbortController.signal])
+		: requestAbortController.signal;
+	let localAbortReason: Error | undefined;
+
+	return {
+		requestAbortController,
+		requestSignal,
+		abortLocally(reason) {
+			localAbortReason = reason;
+			requestAbortController.abort(reason);
+			return reason;
+		},
+		getLocalAbortReason() {
+			if (!localAbortReason) return undefined;
+			return requestSignal.reason === localAbortReason ? localAbortReason : undefined;
+		},
+		wasCallerAbort() {
+			if (!callerSignal?.aborted) return false;
+			return requestSignal.reason !== localAbortReason;
+		},
+	};
+}

package/src/utils/anthropic-auth.ts

@@ -0,0 +1,293 @@
+/**
+ * Anthropic Authentication
+ *
+ * 7-tier auth resolution:
+ *   1. ANTHROPIC_SEARCH_API_KEY / ANTHROPIC_SEARCH_BASE_URL env vars
+ *   2. ANTHROPIC_FOUNDRY_API_KEY override when Foundry mode is enabled
+ *   3. OAuth credentials in ~/.xcsh/agent/agent.db (with expiry check)
+ *   4. API key credentials in ~/.xcsh/agent/agent.db
+ *   5. Generic Anthropic fallback (ANTHROPIC_API_KEY / ANTHROPIC_BASE_URL)
+ *   6. Anthropic provider credentials from models.yml
+ *   7. LiteLLM passthrough (LITELLM_BASE_URL / LITELLM_API_KEY)
+ */
+import { $env, getAgentDbPath, readProviderFromModelsYml } from "@f5xc-salesdemos/pi-utils";
+import { type AuthCredential, AuthCredentialStore } from "../auth-storage";
+import {
+	buildAnthropicHeaders as buildProviderAnthropicHeaders,
+	normalizeAnthropicBaseUrl,
+} from "../providers/anthropic";
+import { getEnvApiKey } from "../stream";
+
+/** Auth configuration for Anthropic */
+export interface AnthropicAuthConfig {
+	apiKey: string;
+	baseUrl: string;
+	isOAuth: boolean;
+}
+
+/** OAuth credential for Anthropic API access */
+export interface AnthropicOAuthCredential {
+	type: "oauth";
+	access: string;
+	refresh?: string;
+	/** Expiry timestamp in milliseconds */
+	expires: number;
+}
+
+const DEFAULT_BASE_URL = "https://api.anthropic.com";
+
+function isFoundryEnabled(): boolean {
+	const value = $env.CLAUDE_CODE_USE_FOUNDRY;
+	if (!value) return false;
+	const normalized = value.trim().toLowerCase();
+	return normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on";
+}
+
+function normalizeBaseUrl(baseUrl: string | undefined): string | undefined {
+	const trimmed = baseUrl?.trim();
+	return trimmed ? trimmed.replace(/\/+$/, "") : undefined;
+}
+function resolveAnthropicBaseUrlFromEnv(): string | undefined {
+	if (isFoundryEnabled()) {
+		const foundryBaseUrl = normalizeBaseUrl($env.FOUNDRY_BASE_URL);
+		if (foundryBaseUrl) return foundryBaseUrl;
+	}
+	const anthropicBaseUrl = normalizeBaseUrl($env.ANTHROPIC_BASE_URL);
+	return anthropicBaseUrl || undefined;
+}
+
+/**
+ * Checks if a token is an OAuth token by looking for sk-ant-oat prefix.
+ * @param apiKey - The API key to check
+ * @returns True if the token is an OAuth token
+ */
+export function isOAuthToken(apiKey: string): boolean {
+	return apiKey.includes("sk-ant-oat");
+}
+
+/**
+ * Converts a generic AuthCredential to AnthropicOAuthCredential if it's a valid OAuth entry.
+ * @param credential - The credential to convert
+ * @returns The converted OAuth credential, or null if not a valid OAuth type
+ */
+function toAnthropicOAuthCredential(credential: AuthCredential): AnthropicOAuthCredential | null {
+	if (credential.type !== "oauth") return null;
+	if (typeof credential.access !== "string" || typeof credential.expires !== "number") return null;
+	return {
+		type: "oauth",
+		access: credential.access,
+		refresh: credential.refresh,
+		expires: credential.expires,
+	};
+}
+
+/**
+ * Reads Anthropic OAuth credentials from an AuthCredentialStore.
+ * @param store - Credential store to read from (creates AuthCredentialStore if not provided)
+ * @returns Array of valid Anthropic OAuth credentials
+ */
+async function readAnthropicOAuthCredentials(store?: AuthCredentialStore): Promise<AnthropicOAuthCredential[]> {
+	const ownsStore = !store;
+	const effectiveStore = store ?? (await AuthCredentialStore.open(getAgentDbPath()));
+	try {
+		const records = effectiveStore.listAuthCredentials("anthropic");
+		const credentials: AnthropicOAuthCredential[] = [];
+		for (const record of records) {
+			const mapped = toAnthropicOAuthCredential(record.credential);
+			if (mapped) {
+				credentials.push(mapped);
+			}
+		}
+
+		return credentials;
+	} finally {
+		if (ownsStore) {
+			effectiveStore.close();
+		}
+	}
+}
+
+/**
+ * Resolves Anthropic provider credentials from models.yml (written by LiteLLM auto-config).
+ * Skips shell-backed secrets, which this tier cannot resolve.
+ * @returns AnthropicAuthConfig or null if unavailable
+ */
+function readAnthropicAuthFromModelsYml(): AnthropicAuthConfig | null {
+	const block = readProviderFromModelsYml("anthropic");
+	if (!block?.baseUrl || !block.apiKey) return null;
+
+	let apiKey: string | undefined;
+	switch (block.apiKey.kind) {
+		case "envVar":
+			apiKey = process.env[block.apiKey.name];
+			break;
+		case "literal":
+			apiKey = block.apiKey.value;
+			break;
+		case "shellSecret":
+			return null;
+	}
+
+	if (!apiKey) return null;
+	return { apiKey, baseUrl: block.baseUrl, isOAuth: false };
+}
+
+/**
+ * Strips known suffixes (`/` repeats, `/anthropic`, `/api/v1`, `/v1`) from a
+ * LiteLLM base URL until no further suffix matches. Handles inputs like
+ * `https://proxy/api/v1/anthropic` in any order.
+ *
+ * Exported for contract testing — see packages/ai/test/litellm-url-normalization.test.ts.
+ */
+export function normalizeLitellmBase(url: string): string {
+	const suffixes = [/\/+$/, /\/anthropic$/, /\/api\/v\d+$/, /\/v\d+$/];
+	let prev: string;
+	let current = url;
+	do {
+		prev = current;
+		for (const re of suffixes) current = current.replace(re, "");
+	} while (current !== prev);
+	return current;
+}
+
+/**
+ * Finds Anthropic auth config using priority:
+ *   1. ANTHROPIC_SEARCH_API_KEY / ANTHROPIC_SEARCH_BASE_URL
+ *   2. ANTHROPIC_FOUNDRY_API_KEY override when Foundry mode is enabled
+ *   3. OAuth in agent.db (with 5-minute expiry buffer)
+ *   4. API key in agent.db
+ *   5. ANTHROPIC_API_KEY / ANTHROPIC_BASE_URL fallback
+ *   6. Anthropic provider credentials from models.yml
+ *   7. LiteLLM passthrough (LITELLM_BASE_URL / LITELLM_API_KEY)
+ * @param store - Optional credential store (creates one from default db path if not provided)
+ * @returns The first valid auth configuration found, or null if none available
+ */
+export async function findAnthropicAuth(store?: AuthCredentialStore): Promise<AnthropicAuthConfig | null> {
+	// 1. Explicit search-specific env vars
+	const searchApiKey = $env.ANTHROPIC_SEARCH_API_KEY;
+	const searchBaseUrl = $env.ANTHROPIC_SEARCH_BASE_URL;
+	if (searchApiKey) {
+		return {
+			apiKey: searchApiKey,
+			baseUrl: searchBaseUrl ?? DEFAULT_BASE_URL,
+			isOAuth: isOAuthToken(searchApiKey),
+		};
+	}
+
+	// 2. Foundry explicit env override
+	const foundryApiKey = isFoundryEnabled() ? $env.ANTHROPIC_FOUNDRY_API_KEY?.trim() : undefined;
+	if (foundryApiKey) {
+		return {
+			apiKey: foundryApiKey,
+			baseUrl: resolveAnthropicBaseUrlFromEnv() ?? DEFAULT_BASE_URL,
+			isOAuth: isOAuthToken(foundryApiKey),
+		};
+	}
+
+	// Tiers 3-4 use the credential store; wrapped in try/catch so DB
+	// failures (missing file, corruption, locking) never prevent the
+	// env-var fallback tiers from running.
+	let storeError: unknown;
+	try {
+		const ownsStore = !store;
+		const effectiveStore = store ?? (await AuthCredentialStore.open(getAgentDbPath()));
+		try {
+			// 3. OAuth credentials in agent.db (with 5-minute expiry buffer)
+			const expiryBuffer = 5 * 60 * 1000; // 5 minutes
+			const now = Date.now();
+			const credentials = await readAnthropicOAuthCredentials(effectiveStore);
+			for (const credential of credentials) {
+				if (!credential.access) continue;
+				if (credential.expires > now + expiryBuffer) {
+					return {
+						apiKey: credential.access,
+						baseUrl: DEFAULT_BASE_URL,
+						isOAuth: true,
+					};
+				}
+			}
+
+			// 4. API key credentials in agent.db
+			const storedApiKey = effectiveStore.getApiKey("anthropic");
+			if (storedApiKey) {
+				return {
+					apiKey: storedApiKey,
+					baseUrl: resolveAnthropicBaseUrlFromEnv() ?? DEFAULT_BASE_URL,
+					isOAuth: isOAuthToken(storedApiKey),
+				};
+			}
+		} finally {
+			if (ownsStore) {
+				effectiveStore.close();
+			}
+		}
+	} catch (err) {
+		// DB unavailable — fall through to env-var tiers, but preserve the
+		// error so it can be surfaced if no later tier succeeds.
+		storeError = err;
+	}
+
+	// 5. Generic ANTHROPIC_API_KEY fallback
+	const apiKey = getEnvApiKey("anthropic");
+	const baseUrl = resolveAnthropicBaseUrlFromEnv();
+	if (apiKey) {
+		return {
+			apiKey,
+			baseUrl: baseUrl ?? DEFAULT_BASE_URL,
+			isOAuth: isOAuthToken(apiKey),
+		};
+	}
+
+	// 6. Anthropic provider credentials from models.yml
+	try {
+		const modelsYmlAuth = readAnthropicAuthFromModelsYml();
+		if (modelsYmlAuth) return modelsYmlAuth;
+	} catch {
+		/* Best-effort — don't block env-var fallback */
+	}
+
+	// 7. Derive from litellm passthrough credentials
+	const litellmBaseUrl = $env.LITELLM_BASE_URL;
+	const litellmApiKey = $env.LITELLM_API_KEY;
+	if (litellmBaseUrl && litellmApiKey) {
+		return {
+			apiKey: litellmApiKey,
+			baseUrl: `${normalizeLitellmBase(litellmBaseUrl)}/anthropic`,
+			isOAuth: false,
+		};
+	}
+
+	// No auth tier succeeded. If the credential store threw, surface
+	// that error so a broken DB isn't silently hidden as "unconfigured".
+	if (storeError) {
+		throw storeError;
+	}
+
+	return null;
+}
+
+/**
+ * Builds HTTP headers for Anthropic API requests (search variant).
+ * @param auth - The authentication configuration
+ * @returns Headers object ready for use in fetch requests
+ */
+export function buildAnthropicSearchHeaders(auth: AnthropicAuthConfig): Record<string, string> {
+	return buildProviderAnthropicHeaders({
+		apiKey: auth.apiKey,
+		baseUrl: auth.baseUrl,
+		isOAuth: auth.isOAuth,
+		extraBetas: ["web-search-2025-03-05"],
+		stream: false,
+	});
+}
+
+/**
+ * Builds the full API URL for Anthropic messages endpoint.
+ * @param auth - The authentication configuration
+ * @returns The complete API URL with beta query parameter
+ */
+export function buildAnthropicUrl(auth: AnthropicAuthConfig): string {
+	const normalizedBaseUrl = normalizeAnthropicBaseUrl(auth.baseUrl);
+	const base = `${normalizedBaseUrl}/v1/messages`;
+	return `${base}?beta=true`;
+}