@oh-my-pi/pi-ai 18.2.6 → 18.2.8

package/src/judgment/types.ts

@@ -115,14 +115,17 @@ export class JudgmentParseError extends Error {
 	}
 }
 
-/** Zero-cost usage for a request whose backend reports only token counts. */
-export function tokenUsage(input: number, output: number): Usage {
+/**
+ * Usage from a backend that reports token counts and, optionally, one billed
+ * USD amount. Judgment pricing is input-only, so the amount lands on `input`.
+ */
+export function tokenUsage(input: number, output: number, cost = 0): Usage {
 	return {
 		input,
 		output,
 		cacheRead: 0,
 		cacheWrite: 0,
 		totalTokens: input + output,
-		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+		cost: { input: cost, output: 0, cacheRead: 0, cacheWrite: 0, total: cost },
 	};
 }

package/src/judgment/typesafe.ts

@@ -1,16 +1,20 @@
 /**
  * TypeSafe System One client: the native {@link Judge} backend.
  *
- * Forwards a {@link JudgmentRequest} verbatim to `POST /v1/systemone` and maps
- * the typed answers back. Credentials flow through {@link withAuth}, so a
- * stored key rotates on 401/403 exactly like chat providers; transient
- * 429/5xx responses retry with bounded, `retry-after`-aware backoff.
+ * Forwards a {@link JudgmentRequest} verbatim to the judgment route of its
+ * API ({@link JUDGMENT_ROUTES}) and maps the typed answers back. TypeSafe's
+ * own `POST /v1/systemone` and OpenRouter's `POST /api/alpha/decisions` share
+ * the request and answer wire shape, so one client serves both. Credentials
+ * flow through {@link withAuth}, so a stored key rotates on 401/403 exactly
+ * like chat providers; transient 429/5xx responses retry with bounded,
+ * `retry-after`-aware backoff.
  *
  * Environment (mirrors the official SDK): `TYPESAFE_API_KEY` is resolved by
  * the auth registry (`rules/auth/typesafe.kdl`), `TYPESAFE_BASE_URL`
  * overrides the API root, `TYPESAFE_DEFAULT_MODEL` the model.
  */
-import type { FetchImpl } from "@oh-my-pi/pi-catalog/types";
+import { TYPESAFE_DEFAULT_BASE_URL } from "@oh-my-pi/pi-catalog/discovery";
+import type { Api, FetchImpl } from "@oh-my-pi/pi-catalog/types";
 import { $env } from "@oh-my-pi/pi-utils";
 import { type ApiKey, withAuth } from "../auth-retry";
 import * as AIError from "../error";
@@ -26,9 +30,22 @@ import {
 } from "./types";
 
 export const TYPESAFE_PROVIDER = "typesafe";
-export const TYPESAFE_DEFAULT_BASE_URL = "https://api.typesafe.ai";
 export const TYPESAFE_DEFAULT_MODEL = "jev-latest";
 
+/** Judgment `POST` path under a model's base URL, per System One–compatible API. */
+export const JUDGMENT_ROUTES = {
+	typesafe: "/v1/systemone",
+	"openrouter-decisions": "/decisions",
+} as const satisfies Partial<Record<Api, string>>;
+
+/** APIs {@link TypeSafeJudge} can serve. */
+export type JudgmentApi = keyof typeof JUDGMENT_ROUTES;
+
+/** Whether a catalog API answers System One judgments natively. */
+export function isJudgmentApi(api: Api): api is JudgmentApi {
+	return Object.hasOwn(JUDGMENT_ROUTES, api);
+}
+
 /** `TYPESAFE_BASE_URL` when set, else the public API root; trailing slashes stripped. */
 export function typesafeBaseUrl(): string {
 	return ($env.TYPESAFE_BASE_URL?.trim() || TYPESAFE_DEFAULT_BASE_URL).replace(/\/+$/, "");
@@ -41,10 +58,16 @@ export function typesafeModel(): string {
 
 export interface TypeSafeJudgeOptions {
 	apiKey: ApiKey;
+	/** Wire route; defaults to TypeSafe's own API. */
+	api?: JudgmentApi;
+	/** Catalog provider reported on results; defaults to {@link TYPESAFE_PROVIDER}. */
+	provider?: string;
 	/** Defaults to {@link typesafeBaseUrl}. */
 	baseUrl?: string;
 	/** Defaults to {@link typesafeModel}. */
 	model?: string;
+	/** Static headers attached to judgment requests (e.g. proxy routing, gateway auth). */
+	headers?: Record<string, string>;
 	fetch?: FetchImpl;
 	/** Per-attempt timeout; defaults to {@link DEFAULT_TIMEOUT_MS}. */
 	timeoutMs?: number;
@@ -60,17 +83,11 @@ const MAX_ATTEMPTS = 3;
 const BACKOFF_BASE_MS = 500;
 const BACKOFF_MAX_MS = 5_000;
 
-/** Wire shape of `GET /v1/models`. */
-export interface TypeSafeModelCard {
-	name: string;
-	description: string;
-	release_date: string;
-}
-
 interface SystemOneResponse {
 	model: string;
 	answers: Record<string, Answer>;
-	usage: { input_tokens: number; output_tokens: number };
+	/** OpenRouter adds the billed `cost` in USD; TypeSafe reports tokens only. */
+	usage: { input_tokens: number; output_tokens: number; cost?: number };
 }
 
 /** Server hint wins (capped); otherwise exponential backoff from {@link BACKOFF_BASE_MS}. */
@@ -82,75 +99,68 @@ function backoffMs(attempt: number, headers: Headers | undefined): number {
 
 export class TypeSafeJudge implements Judge {
 	readonly label: string;
+	readonly api: JudgmentApi;
+	readonly provider: string;
 	readonly model: string;
 	readonly baseUrl: string;
 	readonly #apiKey: ApiKey;
+	readonly #headers: Record<string, string> | undefined;
 	readonly #fetch: FetchImpl;
 	readonly #timeoutMs: number;
 
 	constructor(options: TypeSafeJudgeOptions) {
 		this.#apiKey = options.apiKey;
+		this.api = options.api ?? TYPESAFE_PROVIDER;
+		this.provider = options.provider ?? TYPESAFE_PROVIDER;
 		this.baseUrl = (options.baseUrl ?? typesafeBaseUrl()).replace(/\/+$/, "");
 		this.model = options.model ?? typesafeModel();
+		this.#headers = options.headers;
 		this.#fetch = options.fetch ?? fetch;
 		this.#timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-		this.label = `${TYPESAFE_PROVIDER}/${this.model}`;
+		this.label = `${this.provider}/${this.model}`;
 	}
 
 	async judge<Q extends Questions>(request: JudgmentRequest<Q>, options?: JudgeOptions): Promise<JudgmentResult<Q>> {
 		const body = JSON.stringify({ state: request.state, model: this.model, questions: request.questions });
-		const response = await this.#request<SystemOneResponse>("POST", "/v1/systemone", body, options?.signal);
+		const signal = options?.signal;
+		const response = await withAuth(
+			this.#apiKey,
+			key => this.#attempt<SystemOneResponse>(JUDGMENT_ROUTES[this.api], body, key, signal),
+			{ signal },
+		);
 		for (const id in request.questions) {
 			const answer = response.answers[id];
 			if (answer === undefined || answer.type !== request.questions[id].type) {
 				throw new AIError.ProviderResponseError(
-					`TypeSafe response is missing a "${request.questions[id].type}" answer for question "${id}"`,
-					{ provider: TYPESAFE_PROVIDER, kind: "envelope" },
+					`${this.label} response is missing a "${request.questions[id].type}" answer for question "${id}"`,
+					{ provider: this.provider, kind: "envelope" },
 				);
 			}
 		}
 		return {
-			api: TYPESAFE_PROVIDER,
-			provider: TYPESAFE_PROVIDER,
+			api: this.api,
+			provider: this.provider,
 			model: response.model,
 			answers: response.answers as JudgmentResult<Q>["answers"],
-			usage: tokenUsage(response.usage.input_tokens, response.usage.output_tokens),
+			usage: tokenUsage(response.usage.input_tokens, response.usage.output_tokens, response.usage.cost),
 		};
 	}
 
-	/** Models available to the account (`GET /v1/models`); also the login validation probe. */
-	async listModels(signal?: AbortSignal): Promise<TypeSafeModelCard[]> {
-		const response = await this.#request<{ models: TypeSafeModelCard[] }>("GET", "/v1/models", undefined, signal);
-		if (!Array.isArray(response.models)) {
-			throw new AIError.ProviderResponseError("TypeSafe /v1/models response is missing `models`", {
-				provider: TYPESAFE_PROVIDER,
-				kind: "envelope",
-			});
-		}
-		return response.models;
-	}
-
-	async #request<T>(method: "GET" | "POST", path: string, body: string | undefined, signal?: AbortSignal): Promise<T> {
-		return withAuth(this.#apiKey, key => this.#attempt<T>(method, path, body, key, signal), { signal });
-	}
-
-	async #attempt<T>(
-		method: "GET" | "POST",
-		path: string,
-		body: string | undefined,
-		key: string,
-		signal: AbortSignal | undefined,
-	): Promise<T> {
+	async #attempt<T>(path: string, body: string, key: string, signal: AbortSignal | undefined): Promise<T> {
 		const url = `${this.baseUrl}${path}`;
-		const headers: Record<string, string> = { Authorization: `Bearer ${key}`, Accept: "application/json" };
-		if (body !== undefined) headers["Content-Type"] = "application/json";
+		const headers: Record<string, string> = {
+			...this.#headers,
+			Authorization: `Bearer ${key}`,
+			Accept: "application/json",
+			"Content-Type": "application/json",
+		};
 		for (let attempt = 0; ; attempt++) {
 			signal?.throwIfAborted();
 			const timeout = AbortSignal.timeout(this.#timeoutMs);
 			let response: Response;
 			try {
 				response = await this.#fetch(url, {
-					method,
+					method: "POST",
 					headers,
 					body,
 					signal: signal ? AbortSignal.any([signal, timeout]) : timeout,
@@ -162,7 +172,7 @@ export class TypeSafeJudge implements Judge {
 			}
 			if (response.ok) return (await response.json()) as T;
 			const text = await response.text();
-			const error = new TypeSafeApiError(`TypeSafe API error (${response.status}): ${text}`, response.status, {
+			const error = new TypeSafeApiError(`${this.label} API error (${response.status}): ${text}`, response.status, {
 				headers: response.headers,
 			});
 			const transient = response.status === 408 || response.status === 429 || response.status >= 500;

package/src/provider-session-state.ts

@@ -38,7 +38,7 @@
  *   very turn that rotated; it stays on its existing session-close path.
  */
 
-import { clearAnthropicFastModeFallback } from "./providers/anthropic";
+import { clearAnthropicFastModeFallback } from "./providers/anthropic-state";
 import { resetOpenAIResponsesAccountScopedState } from "./providers/openai-responses";
 import type { ProviderSessionState } from "./types";
 

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;
+}