@oh-my-pi/pi-ai 3.20.0 → 3.34.0

package/src/models.ts

@@ -12,34 +12,28 @@ for (const [provider, models] of Object.entries(MODELS)) {
 	modelRegistry.set(provider, providerModels);
 }
 
-type ProviderModels = typeof MODELS;
-type ProviderWithModels = keyof ProviderModels;
-
 type ModelApi<
-	TProvider extends ProviderWithModels,
-	TModelId extends keyof ProviderModels[TProvider],
-> = ProviderModels[TProvider][TModelId] extends { api: infer TApi } ? (TApi extends Api ? TApi : never) : never;
+	TProvider extends KnownProvider,
+	TModelId extends keyof (typeof MODELS)[TProvider],
+> = (typeof MODELS)[TProvider][TModelId] extends { api: infer TApi } ? (TApi extends Api ? TApi : never) : never;
 
-export function getModel<TProvider extends ProviderWithModels, TModelId extends keyof ProviderModels[TProvider]>(
+export function getModel<TProvider extends KnownProvider, TModelId extends keyof (typeof MODELS)[TProvider]>(
 	provider: TProvider,
 	modelId: TModelId,
-): Model<ModelApi<TProvider, TModelId>>;
-export function getModel(provider: KnownProvider, modelId: string): Model<Api> | undefined;
-export function getModel(provider: KnownProvider, modelId: string): Model<Api> | undefined {
-	return modelRegistry.get(provider)?.get(modelId as string) as Model<Api> | undefined;
+): Model<ModelApi<TProvider, TModelId>> {
+	const providerModels = modelRegistry.get(provider);
+	return providerModels?.get(modelId as string) as Model<ModelApi<TProvider, TModelId>>;
 }
 
 export function getProviders(): KnownProvider[] {
 	return Array.from(modelRegistry.keys()) as KnownProvider[];
 }
 
-export function getModels<TProvider extends ProviderWithModels>(
+export function getModels<TProvider extends KnownProvider>(
 	provider: TProvider,
-): Model<ModelApi<TProvider, keyof ProviderModels[TProvider]>>[];
-export function getModels(provider: KnownProvider): Model<Api>[];
-export function getModels(provider: KnownProvider): Model<Api>[] {
+): Model<ModelApi<TProvider, keyof (typeof MODELS)[TProvider]>>[] {
 	const models = modelRegistry.get(provider);
-	return models ? (Array.from(models.values()) as Model<Api>[]) : [];
+	return models ? (Array.from(models.values()) as Model<ModelApi<TProvider, keyof (typeof MODELS)[TProvider]>>[]) : [];
 }
 
 export function calculateCost<TApi extends Api>(model: Model<TApi>, usage: Usage): Usage["cost"] {
@@ -56,7 +50,7 @@ const XHIGH_MODELS = new Set(["gpt-5.1-codex-max", "gpt-5.2", "gpt-5.2-codex"]);
 
 /**
  * Check if a model supports xhigh thinking level.
- * Currently only certain OpenAI models support this.
+ * Currently only certain OpenAI Codex models support this.
  */
 export function supportsXhigh<TApi extends Api>(model: Model<TApi>): boolean {
 	return XHIGH_MODELS.has(model.id);

package/src/providers/anthropic.ts

@@ -3,7 +3,7 @@ import type {
 	ContentBlockParam,
 	MessageCreateParamsStreaming,
 	MessageParam,
-} from "@anthropic-ai/sdk/resources/messages.js";
+} from "@anthropic-ai/sdk/resources/messages";
 import { calculateCost } from "../models";
 import { getEnvApiKey } from "../stream";
 import type {
@@ -28,6 +28,16 @@ import { sanitizeSurrogates } from "../utils/sanitize-unicode";
 
 import { transformMessages } from "./transorm-messages";
 
+// Stealth mode: Mimic Claude Code's tool naming exactly
+const claudeCodeVersion = "2.1.2";
+
+// Prefix all tool names to avoid collisions with Claude Code's built-in tools
+const toolNamePrefix = "cli_";
+
+const toClaudeCodeName = (name: string) => toolNamePrefix + name;
+const fromClaudeCodeName = (name: string) =>
+	name.startsWith(toolNamePrefix) ? name.slice(toolNamePrefix.length) : name;
+
 /**
  * Convert content blocks to Anthropic API format
  */
@@ -157,7 +167,7 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 						const block: Block = {
 							type: "toolCall",
 							id: event.content_block.id,
-							name: event.content_block.name,
+							name: isOAuthToken ? fromClaudeCodeName(event.content_block.name) : event.content_block.name,
 							arguments: event.content_block.input as Record<string, any>,
 							partialJson: "",
 							index: event.index,
@@ -278,23 +288,68 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 	return stream;
 };
 
+function isOAuthToken(apiKey: string): boolean {
+	return apiKey.includes("sk-ant-oat");
+}
+
+// Build deduplicated beta header string
+function buildBetaHeader(baseBetas: string[], extraBetas: string[]): string {
+	const seen = new Set<string>();
+	const result: string[] = [];
+	for (const beta of [...baseBetas, ...extraBetas]) {
+		const trimmed = beta.trim();
+		if (trimmed && !seen.has(trimmed)) {
+			seen.add(trimmed);
+			result.push(trimmed);
+		}
+	}
+	return result.join(",");
+}
+
 function createClient(
 	model: Model<"anthropic-messages">,
 	apiKey: string,
 	interleavedThinking: boolean,
 ): { client: Anthropic; isOAuthToken: boolean } {
-	const betaFeatures = ["fine-grained-tool-streaming-2025-05-14"];
-	if (interleavedThinking) {
-		betaFeatures.push("interleaved-thinking-2025-05-14");
+	const oauthToken = isOAuthToken(apiKey);
+
+	// Base betas required for Claude Code compatibility
+	const baseBetas = oauthToken
+		? [
+				"claude-code-20250219",
+				"oauth-2025-04-20",
+				"interleaved-thinking-2025-05-14",
+				"fine-grained-tool-streaming-2025-05-14",
+			]
+		: ["fine-grained-tool-streaming-2025-05-14"];
+
+	// Add interleaved thinking if requested (and not already in base)
+	const extraBetas: string[] = [];
+	if (interleavedThinking && !oauthToken) {
+		extraBetas.push("interleaved-thinking-2025-05-14");
+	}
+
+	// Include any betas from model headers
+	const modelBeta = model.headers?.["anthropic-beta"];
+	if (modelBeta) {
+		extraBetas.push(...modelBeta.split(","));
 	}
 
-	if (apiKey.includes("sk-ant-oat")) {
+	const betaHeader = buildBetaHeader(baseBetas, extraBetas);
+
+	if (oauthToken) {
+		// Stealth mode: Mimic Claude Code's headers exactly
 		const defaultHeaders = {
 			accept: "application/json",
 			"anthropic-dangerous-direct-browser-access": "true",
-			"anthropic-beta": `oauth-2025-04-20,${betaFeatures.join(",")}`,
+			"anthropic-beta": betaHeader,
+			"user-agent": `claude-cli/${claudeCodeVersion} (external, cli)`,
+			"x-app": "cli",
 			...(model.headers || {}),
 		};
+		// Don't duplicate anthropic-beta from model.headers
+		delete (defaultHeaders as Record<string, string>)["anthropic-beta"];
+		(defaultHeaders as Record<string, string>)["anthropic-beta"] = betaHeader;
 
 		const client = new Anthropic({
 			apiKey: null,
@@ -305,23 +360,25 @@ function createClient(
 		});
 
 		return { client, isOAuthToken: true };
-	} else {
-		const defaultHeaders = {
-			accept: "application/json",
-			"anthropic-dangerous-direct-browser-access": "true",
-			"anthropic-beta": betaFeatures.join(","),
-			...(model.headers || {}),
-		};
+	}
 
-		const client = new Anthropic({
-			apiKey,
-			baseURL: model.baseUrl,
-			dangerouslyAllowBrowser: true,
-			defaultHeaders,
-		});
+	const defaultHeaders = {
+		accept: "application/json",
+		"anthropic-dangerous-direct-browser-access": "true",
+		"anthropic-beta": betaHeader,
+		...(model.headers || {}),
+	};
+	// Ensure our beta header takes precedence
+	(defaultHeaders as Record<string, string>)["anthropic-beta"] = betaHeader;
+
+	const client = new Anthropic({
+		apiKey,
+		baseURL: model.baseUrl,
+		dangerouslyAllowBrowser: true,
+		defaultHeaders,
+	});
 
-		return { client, isOAuthToken: false };
-	}
+	return { client, isOAuthToken: false };
 }
 
 function buildParams(
@@ -332,7 +389,7 @@ function buildParams(
 ): MessageCreateParamsStreaming {
 	const params: MessageCreateParamsStreaming = {
 		model: model.id,
-		messages: convertMessages(context.messages, model),
+		messages: convertMessages(context.messages, model, isOAuthToken),
 		max_tokens: options?.maxTokens || (model.maxTokens / 3) | 0,
 		stream: true,
 	};
@@ -375,7 +432,7 @@ function buildParams(
 	}
 
 	if (context.tools) {
-		params.tools = convertTools(context.tools);
+		params.tools = convertTools(context.tools, isOAuthToken);
 	}
 
 	if (options?.thinkingEnabled && model.reasoning) {
@@ -388,6 +445,9 @@ function buildParams(
 	if (options?.toolChoice) {
 		if (typeof options.toolChoice === "string") {
 			params.tool_choice = { type: options.toolChoice };
+		} else if (isOAuthToken && options.toolChoice.name) {
+			// Prefix tool name in tool_choice for OAuth mode
+			params.tool_choice = { ...options.toolChoice, name: toClaudeCodeName(options.toolChoice.name) };
 		} else {
 			params.tool_choice = options.toolChoice;
 		}
@@ -402,7 +462,11 @@ function sanitizeToolCallId(id: string): string {
 	return id.replace(/[^a-zA-Z0-9_-]/g, "_");
 }
 
-function convertMessages(messages: Message[], model: Model<"anthropic-messages">): MessageParam[] {
+function convertMessages(
+	messages: Message[],
+	model: Model<"anthropic-messages">,
+	isOAuthToken: boolean,
+): MessageParam[] {
 	const params: MessageParam[] = [];
 
 	// Transform messages for cross-provider compatibility
@@ -481,7 +545,7 @@ function convertMessages(messages: Message[], model: Model<"anthropic-messages">
 					blocks.push({
 						type: "tool_use",
 						id: sanitizeToolCallId(block.id),
-						name: block.name,
+						name: isOAuthToken ? toClaudeCodeName(block.name) : block.name,
 						input: block.arguments,
 					});
 				}
@@ -547,14 +611,14 @@ function convertMessages(messages: Message[], model: Model<"anthropic-messages">
 	return params;
 }
 
-function convertTools(tools: Tool[]): Anthropic.Messages.Tool[] {
+function convertTools(tools: Tool[], isOAuthToken: boolean): Anthropic.Messages.Tool[] {
 	if (!tools) return [];
 
 	return tools.map((tool) => {
 		const jsonSchema = tool.parameters as any; // TypeBox already generates JSON Schema
 
 		return {
-			name: tool.name,
+			name: isOAuthToken ? toClaudeCodeName(tool.name) : tool.name,
 			description: tool.description,
 			input_schema: {
 				type: "object" as const,