@oh-my-pi/pi-ai 18.2.5 → 18.2.7

package/src/providers/anthropic-compaction.ts

@@ -0,0 +1,54 @@
+import { isOfficialAnthropicApiUrl } from "@oh-my-pi/pi-catalog/compat/anthropic";
+import type { Model } from "../types";
+import type { AnthropicMessagesClientLike } from "./anthropic-client";
+import { normalizeAnthropicBaseUrl, resolveDirectAnthropicBaseUrl } from "./anthropic-state";
+
+function isCompactionCapableModel(model: Model<"anthropic-messages">): boolean {
+	return (
+		model.compat.supportsServerCompaction === true &&
+		model.compat.supportsContextManagement !== false &&
+		model.remoteCompaction?.enabled !== false
+	);
+}
+
+/** Whether the model's effective first-party route is the official Anthropic API. */
+export function resolvesToOfficialAnthropicEndpoint(model: Model<"anthropic-messages">): boolean {
+	const baseUrl =
+		model.provider === "anthropic" ? resolveDirectAnthropicBaseUrl(model) : normalizeAnthropicBaseUrl(model.baseUrl);
+	return isOfficialAnthropicApiUrl(baseUrl);
+}
+
+/** Whether the model and effective endpoint support Anthropic native compaction. */
+export function supportsAnthropicCompaction(model: Model<"anthropic-messages">, effectiveBaseUrl?: string): boolean {
+	if (!isCompactionCapableModel(model)) return false;
+	if (model.remoteCompaction?.enabled === true) return true;
+	if (
+		model.transport === "pi-native" &&
+		model.compat.firstPartyProvider === true &&
+		(effectiveBaseUrl === undefined || effectiveBaseUrl === normalizeAnthropicBaseUrl(model.baseUrl))
+	) {
+		return true;
+	}
+	return (
+		model.compat.firstPartyProvider === true &&
+		(effectiveBaseUrl === undefined
+			? resolvesToOfficialAnthropicEndpoint(model)
+			: isOfficialAnthropicApiUrl(effectiveBaseUrl))
+	);
+}
+
+/** Read a caller-owned client's endpoint for request and compaction routing. */
+export function injectedClientBaseUrl(client: AnthropicMessagesClientLike): string | undefined {
+	const candidate = "baseURL" in client ? client.baseURL : undefined;
+	return typeof candidate === "string" && candidate.length > 0 ? candidate : undefined;
+}
+
+/** Whether a caller-owned Anthropic client targets a compaction-capable endpoint. */
+export function supportsAnthropicCompactionOnClient(
+	model: Model<"anthropic-messages">,
+	client: AnthropicMessagesClientLike,
+): boolean {
+	const baseUrl = injectedClientBaseUrl(client);
+	if (baseUrl !== undefined) return supportsAnthropicCompaction(model, baseUrl);
+	return isCompactionCapableModel(model) && model.remoteCompaction?.enabled === true;
+}

package/src/providers/anthropic-identity.ts

@@ -0,0 +1,136 @@
+import * as nodeCrypto from "node:crypto";
+import { getInstallId } from "@oh-my-pi/pi-utils";
+import { claudeToolPrefix } from "./claude-code-fingerprint";
+
+const CLAUDE_CLOAKING_USER_ID_REGEX =
+	/^user_[0-9a-fA-F]{64}_account_[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}_session_[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+
+/** Whether a metadata id uses Claude Code's legacy cloaking shape. */
+export function isClaudeCloakingUserId(userId: string): boolean {
+	return CLAUDE_CLOAKING_USER_ID_REGEX.test(userId);
+}
+
+function isClaudeJsonUserId(userId: string): boolean {
+	if (userId.length === 0 || userId[0] !== "{") return false;
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(userId);
+	} catch {
+		return false;
+	}
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed) || !("session_id" in parsed)) return false;
+	return typeof parsed.session_id === "string" && parsed.session_id.length > 0;
+}
+
+/** Extract a stable session id from a supported Anthropic metadata user id. */
+export function extractClaudeMetadataSessionId(userId: unknown): string | undefined {
+	if (typeof userId !== "string") return undefined;
+	if (isClaudeCloakingUserId(userId)) {
+		return userId.slice(userId.lastIndexOf("_session_") + "_session_".length);
+	}
+	if (userId.length === 0 || userId[0] !== "{") return undefined;
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(userId);
+	} catch {
+		return undefined;
+	}
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed) || !("session_id" in parsed)) return undefined;
+	const sessionId = parsed.session_id;
+	return typeof sessionId === "string" && sessionId.length > 0 ? sessionId : undefined;
+}
+
+/** Generate a legacy Claude Code cloaking metadata id. */
+export function generateClaudeCloakingUserId(): string {
+	const userHash = nodeCrypto.randomBytes(32).toString("hex");
+	const accountId = nodeCrypto.randomUUID().toLowerCase();
+	const sessionId = nodeCrypto.randomUUID().toLowerCase();
+	return `user_${userHash}_account_${accountId}_session_${sessionId}`;
+}
+
+const CLAUDE_DEVICE_ID_INSTALL_HASH_DOMAIN = "omp-claude-device-id-v1:";
+const CLAUDE_DEVICE_ID_ACCOUNT_HASH_DOMAIN = "omp-claude-device-id-v2";
+
+/** Derive the stable Claude device id for an installation and optional account. */
+export function deriveClaudeDeviceId(installId: string, accountId?: string): string {
+	const hash = nodeCrypto.createHash("sha256");
+	if (accountId && accountId.length > 0) {
+		return hash
+			.update(CLAUDE_DEVICE_ID_ACCOUNT_HASH_DOMAIN)
+			.update("\0")
+			.update(installId)
+			.update("\0")
+			.update(accountId)
+			.digest("hex");
+	}
+	return hash.update(CLAUDE_DEVICE_ID_INSTALL_HASH_DOMAIN).update(installId).digest("hex");
+}
+
+/** Read a non-empty string from provider metadata. */
+export function readAnthropicMetadataString(
+	metadata: Record<string, unknown> | undefined,
+	key: string,
+): string | undefined {
+	const value = metadata?.[key];
+	return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+/** Resolve the account id aliases accepted in Anthropic request metadata. */
+export function readAnthropicMetadataAccountId(metadata: Record<string, unknown> | undefined): string | undefined {
+	return (
+		readAnthropicMetadataString(metadata, "account_uuid") ??
+		readAnthropicMetadataString(metadata, "accountId") ??
+		readAnthropicMetadataString(metadata, "account_id")
+	);
+}
+
+function deriveClaudeDeviceIdFromInstallId(accountId?: string): string {
+	return deriveClaudeDeviceId(getInstallId(), accountId);
+}
+
+function generateClaudeJsonUserId(sessionId?: string, accountId?: string): string {
+	const userId: Record<string, string> = {
+		device_id: deriveClaudeDeviceIdFromInstallId(accountId),
+		session_id: sessionId ?? nodeCrypto.randomUUID().toLowerCase(),
+	};
+	if (accountId && accountId.length > 0) userId.account_uuid = accountId;
+	return JSON.stringify(userId);
+}
+
+/** Resolve the provider-facing metadata user id for API-key or OAuth requests. */
+export function resolveAnthropicMetadataUserId(
+	userId: unknown,
+	isOAuthToken: boolean,
+	sessionId?: string,
+	accountId?: string,
+): string | undefined {
+	if (typeof userId === "string") {
+		if (!isOAuthToken || isClaudeCloakingUserId(userId) || isClaudeJsonUserId(userId)) {
+			return userId;
+		}
+	}
+
+	if (!isOAuthToken) return undefined;
+	return generateClaudeJsonUserId(sessionId, accountId);
+}
+
+const ANTHROPIC_BUILTIN_TOOL_NAMES: Record<string, true> = {
+	web_search: true,
+	code_execution: true,
+	text_editor: true,
+	computer: true,
+};
+
+/** Apply Claude Code's wire-only tool prefix. */
+export const applyClaudeToolPrefix = (name: string): string => {
+	if (!claudeToolPrefix) return name;
+	if (Object.hasOwn(ANTHROPIC_BUILTIN_TOOL_NAMES, name.toLowerCase())) return name;
+	return `${claudeToolPrefix}${name}`;
+};
+
+/** Remove one Claude Code wire-only tool prefix. */
+export const stripClaudeToolPrefix = (name: string): string => {
+	if (!claudeToolPrefix) return name;
+	if (!name.toLowerCase().startsWith(claudeToolPrefix.toLowerCase())) return name;
+	return name.slice(claudeToolPrefix.length);
+};

package/src/providers/anthropic-state.ts

@@ -0,0 +1,55 @@
+import { isOfficialAnthropicApiUrl } from "@oh-my-pi/pi-catalog/compat/anthropic";
+import { $env } from "@oh-my-pi/pi-utils";
+import type { Api, Model, ProviderSessionState } from "../types";
+import { isFoundryEnabled } from "../utils/foundry";
+
+/** Root key for Anthropic's per-session provider state. */
+export const ANTHROPIC_PROVIDER_SESSION_STATE_KEY = "anthropic-messages";
+
+/** Normalize an Anthropic base URL to its origin path without `/v1`. */
+export function normalizeAnthropicBaseUrl(baseUrl?: string): string | undefined {
+	const trimmed = baseUrl?.trim();
+	if (!trimmed) return undefined;
+	const withoutTrailingSlashes = trimmed.replace(/\/+$/, "");
+	return withoutTrailingSlashes.endsWith("/v1") ? withoutTrailingSlashes.slice(0, -3) : withoutTrailingSlashes;
+}
+
+/** Resolve the endpoint for a first-party Anthropic model without loading its provider implementation. */
+export function resolveDirectAnthropicBaseUrl(model: Model<Api>): string {
+	if (isFoundryEnabled()) {
+		const foundryBaseUrl = normalizeAnthropicBaseUrl($env.FOUNDRY_BASE_URL);
+		if (foundryBaseUrl) return foundryBaseUrl;
+	}
+	const configured = normalizeAnthropicBaseUrl(model.baseUrl);
+	if (configured && !isOfficialAnthropicApiUrl(configured)) return configured;
+	return normalizeAnthropicBaseUrl($env.ANTHROPIC_BASE_URL) ?? configured ?? "https://api.anthropic.com";
+}
+
+/** Build the endpoint-and-model-scoped Anthropic session-state key. */
+export function anthropicProviderSessionStateKey(baseUrl: string, modelId: string): string {
+	return `${ANTHROPIC_PROVIDER_SESSION_STATE_KEY}:${baseUrl}\u0000${modelId}`;
+}
+
+/** Re-arm fast mode across materialized Anthropic session-state entries. */
+export function clearAnthropicFastModeFallback(
+	providerSessionState: Map<string, ProviderSessionState> | undefined,
+): void {
+	if (!providerSessionState) return;
+	const prefix = `${ANTHROPIC_PROVIDER_SESSION_STATE_KEY}:`;
+	for (const [key, value] of providerSessionState) {
+		if (key !== ANTHROPIC_PROVIDER_SESSION_STATE_KEY && !key.startsWith(prefix)) continue;
+		Object.assign(value, { fastModeDisabled: false });
+	}
+}
+
+/** Inspect the direct model's fast-mode fallback without materializing state. */
+export function isAnthropicFastModeFallbackDisabled(
+	providerSessionState: Map<string, ProviderSessionState> | undefined,
+	model: Model<Api>,
+): boolean {
+	if (!providerSessionState || model.provider !== "anthropic" || model.api !== "anthropic-messages") return false;
+	const baseUrl = resolveDirectAnthropicBaseUrl(model);
+	const key = anthropicProviderSessionStateKey(baseUrl, model.id);
+	const state = providerSessionState.get(key);
+	return state !== undefined && "fastModeDisabled" in state && state.fastModeDisabled === true;
+}