@oh-my-pi/pi-ai 9.1.0 → 9.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-ai",
-	"version": "9.1.0",
+	"version": "9.2.0",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -63,7 +63,7 @@
 		"@connectrpc/connect-node": "^2.1.1",
 		"@google/genai": "^1.38.0",
 		"@mistralai/mistralai": "^1.13.0",
-		"@oh-my-pi/pi-utils": "9.1.0",
+		"@oh-my-pi/pi-utils": "9.2.0",
 		"@sinclair/typebox": "^0.34.48",
 		"@smithy/node-http-handler": "^4.4.8",
 		"ajv": "^8.17.1",

package/src/index.ts

@@ -8,6 +8,7 @@ export * from "./providers/google";
 export * from "./providers/google-gemini-cli";
 export * from "./providers/google-gemini-cli-usage";
 export * from "./providers/google-vertex";
+export * from "./providers/kimi";
 export * from "./providers/openai-completions";
 export * from "./providers/openai-responses";
 export * from "./stream";

package/src/providers/anthropic.ts

@@ -424,9 +424,7 @@ export function buildAnthropicHeaders(options: AnthropicHeaderOptions): Record<s
 		"X-App": "cli",
 	};
 
-	if (oauthToken || !isAnthropicBaseUrl(options.baseUrl)) {
-		headers.Authorization = `Bearer ${options.apiKey}`;
-	} else {
+	if (!oauthToken) {
 		headers["X-Api-Key"] = options.apiKey;
 	}
 
@@ -466,11 +464,19 @@ function createClient(
 		defaultHeaders: defaultHeadersBase,
 	};
 
-	if (oauthToken || !isAnthropicBaseUrl(model.baseUrl)) {
+	if (isAnthropicBaseUrl(model.baseUrl)) {
+		// For Anthropic API, let SDK handle auth
+		if (oauthToken) {
+			clientOptions.apiKey = null;
+			clientOptions.authToken = apiKey;
+		} else {
+			clientOptions.apiKey = apiKey;
+		}
+	} else {
+		// For non-Anthropic URLs (e.g., Kimi), use authToken
+		// The SDK will add Authorization: Bearer header, which is what we want
 		clientOptions.apiKey = null;
 		clientOptions.authToken = apiKey;
-	} else {
-		clientOptions.apiKey = apiKey;
 	}
 
 	const client = new Anthropic(clientOptions);

package/src/providers/kimi.ts

@@ -0,0 +1,147 @@
+/**
+ * Kimi Code provider - wraps OpenAI or Anthropic API based on format setting.
+ *
+ * Kimi offers both OpenAI-compatible and Anthropic-compatible APIs:
+ * - OpenAI: https://api.kimi.com/coding/v1/chat/completions
+ * - Anthropic: https://api.kimi.com/coding/v1/messages
+ *
+ * The Anthropic API is generally more stable and recommended.
+ * Note: Kimi calculates TPM rate limits based on max_tokens, not actual output.
+ */
+
+import type { Api, Context, Model, SimpleStreamOptions } from "../types";
+import { AssistantMessageEventStream } from "../utils/event-stream";
+import { getKimiCommonHeaders } from "../utils/oauth/kimi";
+import { streamAnthropic } from "./anthropic";
+import { streamOpenAICompletions } from "./openai-completions";
+
+export type KimiApiFormat = "openai" | "anthropic";
+
+// Note: Anthropic SDK appends /v1/messages, so base URL should not include /v1
+const KIMI_ANTHROPIC_BASE_URL = "https://api.kimi.com/coding";
+
+// Default thinking budgets for Anthropic format (matches stream.ts)
+const DEFAULT_THINKING_BUDGETS = {
+	minimal: 1024,
+	low: 4096,
+	medium: 8192,
+	high: 16384,
+	xhigh: 32768,
+} as const;
+
+export interface KimiOptions extends SimpleStreamOptions {
+	/** API format: "openai" or "anthropic". Default: "anthropic" */
+	format?: KimiApiFormat;
+}
+
+/**
+ * Stream from Kimi Code, routing to either OpenAI or Anthropic API based on format.
+ * Returns synchronously like other providers - async header fetching happens internally.
+ */
+export function streamKimi(
+	model: Model<"openai-completions">,
+	context: Context,
+	options?: KimiOptions,
+): AssistantMessageEventStream {
+	const stream = new AssistantMessageEventStream();
+	const format = options?.format ?? "anthropic";
+
+	// Async IIFE to handle header fetching and stream piping
+	(async () => {
+		try {
+			const kimiHeaders = await getKimiCommonHeaders();
+			const mergedHeaders = { ...kimiHeaders, ...options?.headers };
+
+			if (format === "anthropic") {
+				// Create a synthetic Anthropic model pointing to Kimi's endpoint
+				const anthropicModel: Model<"anthropic-messages"> = {
+					id: model.id,
+					name: model.name,
+					api: "anthropic-messages",
+					provider: model.provider,
+					baseUrl: KIMI_ANTHROPIC_BASE_URL,
+					headers: mergedHeaders,
+					contextWindow: model.contextWindow,
+					maxTokens: model.maxTokens,
+					reasoning: model.reasoning,
+					input: model.input,
+					cost: model.cost,
+				};
+
+				// Calculate thinking budget from reasoning level
+				const reasoning = options?.reasoning;
+				const thinkingEnabled = !!reasoning && model.reasoning;
+				const thinkingBudget = reasoning
+					? (options?.thinkingBudgets?.[reasoning] ?? DEFAULT_THINKING_BUDGETS[reasoning])
+					: undefined;
+
+				const innerStream = streamAnthropic(anthropicModel, context, {
+					apiKey: options?.apiKey,
+					temperature: options?.temperature,
+					maxTokens: options?.maxTokens ?? Math.min(model.maxTokens, 32000),
+					signal: options?.signal,
+					headers: mergedHeaders,
+					sessionId: options?.sessionId,
+					onPayload: options?.onPayload,
+					thinkingEnabled,
+					thinkingBudgetTokens: thinkingBudget,
+				});
+
+				for await (const event of innerStream) {
+					stream.push(event);
+				}
+			} else {
+				// OpenAI format - use original model with Kimi headers
+				const innerStream = streamOpenAICompletions(model, context, {
+					apiKey: options?.apiKey,
+					temperature: options?.temperature,
+					maxTokens: options?.maxTokens ?? model.maxTokens,
+					signal: options?.signal,
+					headers: mergedHeaders,
+					sessionId: options?.sessionId,
+					onPayload: options?.onPayload,
+					reasoningEffort: options?.reasoning,
+				});
+
+				for await (const event of innerStream) {
+					stream.push(event);
+				}
+			}
+		} catch (err) {
+			stream.push({
+				type: "error",
+				reason: "error",
+				error: createErrorMessage(model, err),
+			});
+		}
+	})();
+
+	return stream;
+}
+
+function createErrorMessage(model: Model<Api>, err: unknown) {
+	return {
+		role: "assistant" as const,
+		content: [{ type: "text" as const, text: err instanceof Error ? err.message : String(err) }],
+		api: model.api,
+		provider: model.provider,
+		model: model.id,
+		usage: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			totalTokens: 0,
+			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+		},
+		stopReason: "error" as const,
+		timestamp: Date.now(),
+	};
+}
+
+/**
+ * Check if a model is a Kimi Code model.
+ */
+export function isKimiModel(model: Model<Api>): boolean {
+	return model.provider === "kimi-code";
+}

package/src/providers/openai-completions.ts

@@ -397,6 +397,12 @@ function buildParams(model: Model<"openai-completions">, context: Context, optio
 	const messages = convertMessages(model, context, compat);
 	maybeAddOpenRouterAnthropicCacheControl(model, messages);
 
+	// Kimi (including via OpenRouter) calculates TPM rate limits based on max_tokens, not actual output.
+	// Always send max_tokens to avoid their high default causing rate limit issues.
+	// Note: Direct kimi-code provider is handled by the dedicated Kimi provider in kimi.ts.
+	const isKimi = model.id.includes("moonshotai/kimi");
+	const effectiveMaxTokens = options?.maxTokens ?? (isKimi ? model.maxTokens : undefined);
+
 	const params: OpenAI.Chat.Completions.ChatCompletionCreateParamsStreaming = {
 		model: model.id,
 		messages,
@@ -411,11 +417,11 @@ function buildParams(model: Model<"openai-completions">, context: Context, optio
 		params.store = false;
 	}
 
-	if (options?.maxTokens) {
+	if (effectiveMaxTokens) {
 		if (compat.maxTokensField === "max_tokens") {
-			(params as any).max_tokens = options.maxTokens;
+			(params as any).max_tokens = effectiveMaxTokens;
 		} else {
-			params.max_completion_tokens = options.maxTokens;
+			params.max_completion_tokens = effectiveMaxTokens;
 		}
 	}
 

package/src/stream.ts

@@ -13,6 +13,7 @@ import {
 	streamGoogleGeminiCli,
 } from "./providers/google-gemini-cli";
 import { type GoogleVertexOptions, streamGoogleVertex } from "./providers/google-vertex";
+import { isKimiModel, streamKimi } from "./providers/kimi";
 import { streamOpenAICodexResponses } from "./providers/openai-codex-responses";
 import { type OpenAICompletionsOptions, streamOpenAICompletions } from "./providers/openai-completions";
 import { streamOpenAIResponses } from "./providers/openai-responses";
@@ -212,6 +213,16 @@ export function streamSimple<TApi extends Api>(
 		throw new Error(`No API key for provider: ${model.provider}`);
 	}
 
+	// Kimi Code - route to dedicated handler that wraps OpenAI or Anthropic API
+	if (isKimiModel(model)) {
+		// Pass raw SimpleStreamOptions - streamKimi handles mapping internally
+		return streamKimi(model as Model<"openai-completions">, context, {
+			...options,
+			apiKey,
+			format: options?.kimiApiFormat ?? "anthropic",
+		});
+	}
+
 	const providerOptions = mapOptionsForApi(model, options, apiKey);
 	return stream(model, context, providerOptions);
 }

package/src/types.ts

@@ -141,6 +141,8 @@ export interface SimpleStreamOptions extends StreamOptions {
 	cursorOnToolResult?: CursorToolResultHandler;
 	/** Optional tool choice override for compatible providers */
 	toolChoice?: ToolChoice;
+	/** API format for Kimi Code provider: "openai" or "anthropic" (default: "anthropic") */
+	kimiApiFormat?: "openai" | "anthropic";
 }
 
 // Generic StreamFunction with typed options