@oh-my-pi/pi-ai 16.1.13 → 16.1.14

package/src/registry/oauth/minimax-code.ts

@@ -13,8 +13,7 @@
  * China: https://api.minimaxi.com/v1
  */
 
-import { validateOpenAICompatibleApiKey } from "../api-key-validation";
-import type { OAuthController } from "./types";
+import { createApiKeyLogin } from "../api-key-login";
 
 const AUTH_URL_INTL = "https://platform.minimax.io/subscribe/token-plan";
 const AUTH_URL_CN = "https://platform.minimaxi.com/subscribe/token-plan";
@@ -22,61 +21,33 @@ const API_BASE_URL_INTL = "https://api.minimax.io/v1";
 const API_BASE_URL_CN = "https://api.minimaxi.com/v1";
 const VALIDATION_MODEL = "MiniMax-M3";
 
+function createMiniMaxLogin(authUrl: string, baseUrl: string, provider: string) {
+	return createApiKeyLogin({
+		providerLabel: "MiniMax Token Plan",
+		authUrl,
+		instructions: "Subscribe to Token Plan and copy your API key",
+		promptMessage: "Paste your MiniMax Token Plan API key",
+		placeholder: "sk-...",
+		validation: {
+			kind: "chat-completions",
+			provider,
+			baseUrl,
+			model: VALIDATION_MODEL,
+		},
+	});
+}
+
 /**
  * Login to MiniMax Token Plan (international).
  *
  * Opens browser to subscription page, prompts user to paste their API key.
  * Returns the API key directly (not OAuthCredentials - this isn't OAuth).
  */
-export async function loginMiniMaxCode(options: OAuthController): Promise<string> {
-	return loginMiniMaxCodeWithBaseUrl(options, AUTH_URL_INTL, API_BASE_URL_INTL, "MiniMax Token Plan");
-}
-
-async function loginMiniMaxCodeWithBaseUrl(
-	options: OAuthController,
-	authUrl: string,
-	baseUrl: string,
-	providerName: string,
-): Promise<string> {
-	const fetchImpl = options.fetch ?? fetch;
-	if (!options.onPrompt) {
-		throw new Error("MiniMax Token Plan login requires onPrompt callback");
-	}
-	// Open browser to subscription page
-	options.onAuth?.({
-		url: authUrl,
-		instructions: "Subscribe to Token Plan and copy your API key",
-	});
-	// Prompt user to paste their API key
-	const apiKey = await options.onPrompt({
-		message: "Paste your MiniMax Token Plan API key",
-		placeholder: "sk-...",
-	});
-	if (options.signal?.aborted) {
-		throw new Error("Login cancelled");
-	}
-	const trimmed = apiKey.trim();
-	if (!trimmed) {
-		throw new Error("API key is required");
-	}
-
-	options.onProgress?.("Validating API key...");
-	await validateOpenAICompatibleApiKey({
-		provider: providerName,
-		apiKey: trimmed,
-		baseUrl,
-		model: VALIDATION_MODEL,
-		signal: options.signal,
-		fetch: fetchImpl,
-	});
-	return trimmed;
-}
+export const loginMiniMaxCode = createMiniMaxLogin(AUTH_URL_INTL, API_BASE_URL_INTL, "MiniMax Token Plan");
 
 /**
  * Login to MiniMax Token Plan (China).
  *
  * Same flow as international but uses China endpoint.
  */
-export async function loginMiniMaxCodeCn(options: OAuthController): Promise<string> {
-	return loginMiniMaxCodeWithBaseUrl(options, AUTH_URL_CN, API_BASE_URL_CN, "MiniMax Token Plan (China)");
-}
+export const loginMiniMaxCodeCn = createMiniMaxLogin(AUTH_URL_CN, API_BASE_URL_CN, "MiniMax Token Plan (China)");

package/src/registry/qianfan.ts

@@ -1,46 +1,24 @@
-import { validateOpenAICompatibleApiKey } from "./api-key-validation";
-import type { OAuthController, OAuthLoginCallbacks } from "./oauth/types";
+import { createApiKeyLogin } from "./api-key-login";
+import type { OAuthLoginCallbacks } from "./oauth/types";
 import type { ProviderDefinition } from "./types";
 
 const AUTH_URL = "https://console.bce.baidu.com/qianfan/ais/console/apiKey";
 const API_BASE_URL = "https://qianfan.baidubce.com/v2";
 const VALIDATION_MODEL = "deepseek-v3.2";
 
-export async function loginQianfan(options: OAuthController): Promise<string> {
-	if (!options.onPrompt) {
-		throw new Error("Qianfan login requires onPrompt callback");
-	}
-
-	options.onAuth?.({
-		url: AUTH_URL,
-		instructions: "Copy your Qianfan API key from the console",
-	});
-
-	const apiKey = await options.onPrompt({
-		message: "Paste your Qianfan API key",
-		placeholder: "bce-v3/ALTAK-...",
-	});
-
-	if (options.signal?.aborted) {
-		throw new Error("Login cancelled");
-	}
-
-	const trimmed = apiKey.trim();
-	if (!trimmed) {
-		throw new Error("API key is required");
-	}
-
-	options.onProgress?.("Validating API key...");
-	await validateOpenAICompatibleApiKey({
+export const loginQianfan = createApiKeyLogin({
+	providerLabel: "Qianfan",
+	authUrl: AUTH_URL,
+	instructions: "Copy your Qianfan API key from the console",
+	promptMessage: "Paste your Qianfan API key",
+	placeholder: "bce-v3/ALTAK-...",
+	validation: {
+		kind: "chat-completions",
 		provider: "qianfan",
-		apiKey: trimmed,
 		baseUrl: API_BASE_URL,
 		model: VALIDATION_MODEL,
-		signal: options.signal,
-	});
-
-	return trimmed;
-}
+	},
+});
 
 export const qianfanProvider = {
 	id: "qianfan",

package/src/registry/registry.ts

@@ -44,6 +44,7 @@ import { parallelProvider } from "./parallel";
 import { perplexityProvider } from "./perplexity";
 import { qianfanProvider } from "./qianfan";
 import { qwenPortalProvider } from "./qwen-portal";
+import { sakanaProvider } from "./sakana";
 import { syntheticProvider } from "./synthetic";
 import { tavilyProvider } from "./tavily";
 import { togetherProvider } from "./together";
@@ -90,6 +91,7 @@ const ALL = [
 	zhipuCodingPlanProvider,
 	umansProvider,
 	qwenPortalProvider,
+	sakanaProvider,
 	minimaxCodeProvider,
 	minimaxCodeCnProvider,
 	xiaomiProvider,

package/src/registry/sakana.ts

@@ -0,0 +1,22 @@
+import { createApiKeyLogin } from "./api-key-login";
+import type { OAuthLoginCallbacks } from "./oauth/types";
+import type { ProviderDefinition } from "./types";
+
+export const loginSakana = createApiKeyLogin({
+	providerLabel: "Sakana AI",
+	authUrl: "https://console.sakana.ai/api-keys",
+	instructions: "Copy your API key from the Sakana AI console",
+	promptMessage: "Paste your Sakana AI API key",
+	placeholder: "sk-...",
+	validation: {
+		kind: "models-endpoint",
+		provider: "Sakana AI",
+		modelsUrl: "https://api.sakana.ai/v1/models",
+	},
+});
+
+export const sakanaProvider = {
+	id: "sakana",
+	name: "Sakana AI",
+	login: (cb: OAuthLoginCallbacks) => loginSakana(cb),
+} as const satisfies ProviderDefinition;

package/src/registry/venice.ts

@@ -1,5 +1,5 @@
-import { validateOpenAICompatibleApiKey } from "./api-key-validation";
-import type { OAuthController, OAuthLoginCallbacks } from "./oauth/types";
+import { createApiKeyLogin } from "./api-key-login";
+import type { OAuthLoginCallbacks } from "./oauth/types";
 import type { ProviderDefinition } from "./types";
 
 const AUTH_URL = "https://venice.ai/settings/api";
@@ -12,41 +12,19 @@ const VALIDATION_MODEL = "qwen3-4b";
  * Opens browser to API keys page, prompts user to paste their API key.
  * Returns the API key directly (not OAuthCredentials - this isn't OAuth).
  */
-export async function loginVenice(options: OAuthController): Promise<string> {
-	if (!options.onPrompt) {
-		throw new Error("Venice login requires onPrompt callback");
-	}
-
-	options.onAuth?.({
-		url: AUTH_URL,
-		instructions: "Copy your API key from the Venice dashboard",
-	});
-
-	const apiKey = await options.onPrompt({
-		message: "Paste your Venice API key",
-		placeholder: "vapi_...",
-	});
-
-	if (options.signal?.aborted) {
-		throw new Error("Login cancelled");
-	}
-
-	const trimmed = apiKey.trim();
-	if (!trimmed) {
-		throw new Error("API key is required");
-	}
-
-	options.onProgress?.("Validating API key...");
-	await validateOpenAICompatibleApiKey({
+export const loginVenice = createApiKeyLogin({
+	providerLabel: "Venice",
+	authUrl: AUTH_URL,
+	instructions: "Copy your API key from the Venice dashboard",
+	promptMessage: "Paste your Venice API key",
+	placeholder: "vapi_...",
+	validation: {
+		kind: "chat-completions",
 		provider: "Venice",
-		apiKey: trimmed,
 		baseUrl: API_BASE_URL,
 		model: VALIDATION_MODEL,
-		signal: options.signal,
-	});
-
-	return trimmed;
-}
+	},
+});
 
 export const veniceProvider = {
 	id: "venice",

package/src/registry/zai.ts

@@ -1,45 +1,24 @@
-import { validateOpenAICompatibleApiKey } from "./api-key-validation";
-import type { OAuthController, OAuthLoginCallbacks } from "./oauth/types";
+import { createApiKeyLogin } from "./api-key-login";
+import type { OAuthLoginCallbacks } from "./oauth/types";
 import type { ProviderDefinition } from "./types";
 
 const AUTH_URL = "https://z.ai/manage-apikey/apikey-list";
 const API_BASE_URL = "https://api.z.ai/api/coding/paas/v4";
 const VALIDATION_MODEL = "glm-5.2";
 
-export async function loginZai(options: OAuthController): Promise<string> {
-	if (!options.onPrompt) {
-		throw new Error("Z.AI login requires onPrompt callback");
-	}
-
-	options.onAuth?.({
-		url: AUTH_URL,
-		instructions: "Copy your API key from the dashboard",
-	});
-
-	const apiKey = await options.onPrompt({
-		message: "Paste your Z.AI API key",
-		placeholder: "sk-...",
-	});
-
-	if (options.signal?.aborted) {
-		throw new Error("Login cancelled");
-	}
-
-	const trimmed = apiKey.trim();
-	if (!trimmed) {
-		throw new Error("API key is required");
-	}
-
-	options.onProgress?.("Validating API key...");
-	await validateOpenAICompatibleApiKey({
+export const loginZai = createApiKeyLogin({
+	providerLabel: "Z.AI",
+	authUrl: AUTH_URL,
+	instructions: "Copy your API key from the dashboard",
+	promptMessage: "Paste your Z.AI API key",
+	placeholder: "sk-...",
+	validation: {
+		kind: "chat-completions",
 		provider: "Z.AI",
-		apiKey: trimmed,
 		baseUrl: API_BASE_URL,
 		model: VALIDATION_MODEL,
-		signal: options.signal,
-	});
-	return trimmed;
-}
+	},
+});
 
 export const zaiProvider = {
 	id: "zai",

package/src/registry/zhipu-coding-plan.ts

@@ -1,45 +1,24 @@
-import { validateOpenAICompatibleApiKey } from "./api-key-validation";
-import type { OAuthController, OAuthLoginCallbacks } from "./oauth/types";
+import { createApiKeyLogin } from "./api-key-login";
+import type { OAuthLoginCallbacks } from "./oauth/types";
 import type { ProviderDefinition } from "./types";
 
 const AUTH_URL = "https://bigmodel.cn/coding-plan/personal/overview";
 const API_BASE_URL = "https://open.bigmodel.cn/api/coding/paas/v4";
 const VALIDATION_MODEL = "glm-5.1";
 
-export async function loginZhipuCodingPlan(options: OAuthController): Promise<string> {
-	if (!options.onPrompt) {
-		throw new Error("Zhipu Coding Plan login requires onPrompt callback");
-	}
-
-	options.onAuth?.({
-		url: AUTH_URL,
-		instructions: "Copy your API key from the Coding Plan dashboard",
-	});
-
-	const apiKey = await options.onPrompt({
-		message: "Paste your Zhipu API key",
-		placeholder: "<id>.<secret>",
-	});
-
-	if (options.signal?.aborted) {
-		throw new Error("Login cancelled");
-	}
-
-	const trimmed = apiKey.trim();
-	if (!trimmed) {
-		throw new Error("API key is required");
-	}
-
-	options.onProgress?.("Validating API key...");
-	await validateOpenAICompatibleApiKey({
+export const loginZhipuCodingPlan = createApiKeyLogin({
+	providerLabel: "Zhipu Coding Plan",
+	authUrl: AUTH_URL,
+	instructions: "Copy your API key from the Coding Plan dashboard",
+	promptMessage: "Paste your Zhipu API key",
+	placeholder: "<id>.<secret>",
+	validation: {
+		kind: "chat-completions",
 		provider: "Zhipu",
-		apiKey: trimmed,
 		baseUrl: API_BASE_URL,
 		model: VALIDATION_MODEL,
-		signal: options.signal,
-	});
-	return trimmed;
-}
+	},
+});
 
 export const zhipuCodingPlanProvider = {
 	id: "zhipu-coding-plan",

package/src/stream.ts

@@ -64,6 +64,7 @@ import type {
 	ToolChoice,
 } from "./types";
 import { AssistantMessageEventStream } from "./utils/event-stream";
+import { wrapFetchForProxy } from "./utils/proxy";
 import { withRequestDebugFetch } from "./utils/request-debug";
 import { withGeminiThinkingLoopGuard } from "./utils/thinking-loop";
 
@@ -237,9 +238,12 @@ function streamDispatch<TApi extends Api>(
 	context: Context,
 	options?: OptionsForApi<TApi>,
 ): AssistantMessageEventStream {
-	const requestOptions = withRequestDebugFetch(options as StreamOptions | undefined) as
-		| OptionsForApi<TApi>
-		| undefined;
+	const baseOptions = (options || {}) as StreamOptions;
+	const debugOptions = withRequestDebugFetch(baseOptions);
+	const requestOptions = {
+		...debugOptions,
+		fetch: wrapFetchForProxy(debugOptions.fetch ?? (globalThis.fetch as FetchImpl), model.provider),
+	} as OptionsForApi<TApi>;
 
 	// Check custom API registry first (extension-provided APIs like "vertex-claude-api")
 	const customApiProvider = getCustomApi(model.api);
@@ -248,12 +252,12 @@ function streamDispatch<TApi extends Api>(
 	}
 
 	if (isGitLabDuoModel(model)) {
-		const apiKey = (requestOptions as StreamOptions | undefined)?.apiKey || getEnvApiKey(model.provider);
+		const apiKey = requestOptions.apiKey || getEnvApiKey(model.provider);
 		if (!apiKey) {
 			throw new Error(`No API key for provider: ${model.provider}`);
 		}
 		return streamGitLabDuo(model, context, {
-			...(requestOptions as SimpleStreamOptions | undefined),
+			...(requestOptions as SimpleStreamOptions),
 			apiKey,
 		});
 	}
@@ -263,14 +267,10 @@ function streamDispatch<TApi extends Api>(
 		return streamGoogleVertex(model as Model<"google-vertex">, context, requestOptions as GoogleVertexOptions);
 	} else if (model.api === "bedrock-converse-stream") {
 		// Bedrock doesn't have any API keys instead it sources credentials from standard AWS env variables or from given AWS profile.
-		return streamBedrock(
-			model as Model<"bedrock-converse-stream">,
-			context,
-			(requestOptions || {}) as BedrockOptions,
-		);
+		return streamBedrock(model as Model<"bedrock-converse-stream">, context, requestOptions as BedrockOptions);
 	}
 
-	const apiKey = requestOptions?.apiKey || getEnvApiKey(model.provider);
+	const apiKey = requestOptions.apiKey || getEnvApiKey(model.provider);
 	if (!apiKey) {
 		throw new Error(`No API key for provider: ${model.provider}`);
 	}
@@ -278,7 +278,7 @@ function streamDispatch<TApi extends Api>(
 		? {
 				...requestOptions,
 				apiKey: "vertex-adc",
-				fetch: createVertexAuthenticatedFetch(requestOptions as StreamOptions | undefined),
+				fetch: createVertexAuthenticatedFetch(requestOptions),
 			}
 		: { ...requestOptions, apiKey };
 
@@ -410,7 +410,12 @@ export function streamSimple<TApi extends Api>(
 	context: Context,
 	options?: SimpleStreamOptions,
 ): AssistantMessageEventStream {
-	const requestOptions = withRequestDebugFetch(options);
+	const baseOptions = (options || {}) as SimpleStreamOptions;
+	const debugOptions = withRequestDebugFetch(baseOptions);
+	const requestOptions = {
+		...debugOptions,
+		fetch: wrapFetchForProxy(debugOptions.fetch ?? (globalThis.fetch as FetchImpl), model.provider),
+	} as SimpleStreamOptions;
 	const apiKeyResolver = isApiKeyResolver(requestOptions?.apiKey) ? requestOptions.apiKey : undefined;
 	if (apiKeyResolver) {
 		const outer = new AssistantMessageEventStream();

package/src/utils/deterministic-id.ts

@@ -0,0 +1,20 @@
+/**
+ * A UUID-shaped string: five hex groups in the canonical 8-4-4-4-12 layout.
+ *
+ * NOT a spec-compliant RFC 4122 UUID — the version/variant nibbles are left as
+ * raw hash output — but the shape passes everywhere a UUID string is expected.
+ */
+export type DeterministicUuid = `${string}-${string}-${string}-${string}-${string}`;
+
+/**
+ * Format the leading 128 bits of `seed`'s SHA-256 digest as a v4-shape UUID
+ * (8-4-4-4-12 hex groups).
+ *
+ * Deterministic: identical seeds always map to the same id, so callers get
+ * stable ids across requests / conversation turns (reusing message-blob ids,
+ * keying prompt caches) without persisting a seed→id mapping.
+ */
+export function deterministicUuid(seed: string): DeterministicUuid {
+	const hex = new Bun.CryptoHasher("sha256").update(seed).digest("hex");
+	return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
+}