nolo-cli 0.1.23 → 0.1.29

package/server/handlers/chatProxyRouting.ts

@@ -0,0 +1,404 @@
+import {
+  DEEPINFRA_KIMI_FALLBACK_MODEL,
+  FIREWORKS_KIMI_CURRENT_MODEL,
+  FIREWORKS_KIMI_LATEST_MODEL,
+  KIMI_PLATFORM_FALLBACK_STATUSES,
+  OPENROUTER_KIMI_FALLBACK_MODEL,
+  isDeepInfraKimiModel,
+  isFireworksKimiModel,
+  resolveFireworksKimiModel,
+} from "../../ai/llm/kimi";
+
+export const FIREWORKS_CHAT_COMPLETIONS_URL =
+  "https://api.fireworks.ai/inference/v1/chat/completions";
+export const DEEPINFRA_CHAT_COMPLETIONS_URL =
+  "https://api.deepinfra.com/v1/openai/chat/completions";
+export const OPENROUTER_CHAT_COMPLETIONS_URL =
+  "https://openrouter.ai/api/v1/chat/completions";
+export const GOOGLE_FALLBACK_STATUSES = [404, 429, 500, 502, 503, 504];
+
+export type ChatProxyPayload = {
+  url: string;
+  KEY?: unknown;
+  agentKey?: unknown;
+  agentHydratedKey?: unknown;
+  provider: any;
+  apiSource?: unknown;
+  apiKeyHeader?: unknown;
+  body: Record<string, any>;
+  providerName: any;
+  originalModel: any;
+  model: any;
+  messages: any;
+};
+
+export type CredentialPlan = {
+  apiKey?: string;
+  isCustomApi: boolean;
+  hasExplicitKey: boolean;
+};
+
+export type UpstreamRequestSpec = {
+  url: string;
+  provider: any;
+  model: any;
+  init: RequestInit;
+};
+
+export type FallbackPlan = {
+  kimiFallbackRequest?: UpstreamRequestSpec;
+  kimiFallbackRequests?: UpstreamRequestSpec[];
+  googleFallbackRequest?: UpstreamRequestSpec;
+  routeKimiThroughOpenRouter: boolean;
+  missingKimiFallbackKey: boolean;
+  missingGoogleFallbackKey: boolean;
+};
+
+export type SelectedUpstreamRequest = {
+  url: string;
+  provider: any;
+  model: any;
+  init: RequestInit;
+  fallbackRequest?: UpstreamRequestSpec;
+  fallbackRequests?: UpstreamRequestSpec[];
+  fallbackOnStatuses?: number[];
+};
+
+export type ChatRoutingDecisionLog = {
+  provider: any;
+  providerName: any;
+  originalModel: any;
+  normalizedModel: any;
+  upstreamProvider: any;
+  upstreamModel: any;
+  upstreamUrl: string;
+  hasExplicitKey: boolean;
+  isCustomApi: boolean;
+  fallbackReason?: string;
+  fallbackProvider?: any;
+  fallbackModel?: any;
+  fallbackOnStatuses?: number[];
+};
+
+export type ChatRoutingKeyResolver = (provider: string) => string | undefined;
+
+export const toOpenRouterGoogleModelName = (modelName: string) =>
+  `google/${modelName}`;
+
+export const stripApiSourceField = <T extends Record<string, any>>(obj: T): T => {
+  if (!obj || typeof obj !== "object" || Array.isArray(obj)) return obj;
+  const { apiSource: _apiSource, ...rest } = obj;
+  return rest as T;
+};
+
+export const buildUpstreamHeaders = (
+  requestUrl: string,
+  apiKey?: string | null,
+  apiKeyHeader?: string | null
+) => {
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+  };
+  const normalizedApiKeyHeader =
+    apiKeyHeader?.trim() ||
+    (/xiaomimimo\.com/i.test(requestUrl) ? "api-key" : "");
+  if (apiKey) {
+    if (normalizedApiKeyHeader) {
+      headers[normalizedApiKeyHeader] = apiKey;
+    } else {
+      headers.Authorization = `Bearer ${apiKey}`;
+    }
+  }
+
+  if (requestUrl.includes("openrouter.ai")) {
+    headers["HTTP-Referer"] = "https://nolo.chat";
+    headers["X-Title"] = "nolo";
+  }
+
+  return headers;
+};
+
+const stripApiSourceFromMessageList = (messages: unknown[]): unknown[] => {
+  return messages.map((msg: any) => stripApiSourceField(msg));
+};
+
+export const normalizeChatProxyPayload = (payload: any): ChatProxyPayload => {
+  const { url, KEY, agentKey, agentHydratedKey, provider, apiSource, apiKeyHeader, ...rawBody } = payload;
+  const body = stripApiSourceField(rawBody as Record<string, any>);
+  if (Array.isArray(body.messages)) {
+    body.messages = stripApiSourceFromMessageList(body.messages);
+  }
+  if (Array.isArray(body.input)) {
+    body.input = stripApiSourceFromMessageList(body.input);
+  }
+
+  const providerName =
+    typeof provider === "string" ? provider.trim() : provider;
+  const originalModel = body.model;
+  const model =
+    providerName === "fireworks"
+      ? resolveFireworksKimiModel(originalModel)
+      : originalModel;
+  body.model = model;
+
+  return {
+    url,
+    KEY,
+    agentKey,
+    agentHydratedKey,
+    provider,
+    apiSource,
+    apiKeyHeader,
+    body,
+    providerName,
+    originalModel,
+    model,
+    messages: body.messages,
+  };
+};
+
+export const resolveProviderCredentials = (
+  request: Pick<
+    ChatProxyPayload,
+    "KEY" | "agentHydratedKey" | "provider" | "providerName" | "apiSource" | "body"
+  >,
+  apiKeyForProvider: ChatRoutingKeyResolver
+): CredentialPlan => {
+  const isCustomApi =
+    request.apiSource === "custom" || request.providerName === "custom";
+  const providedKey =
+    typeof request.KEY === "string" && request.KEY.trim()
+      ? request.KEY.trim()
+      : "";
+  const hasExplicitKey = !!providedKey && request.agentHydratedKey !== true;
+
+  if (providedKey) {
+    return {
+      apiKey: providedKey,
+      isCustomApi,
+      hasExplicitKey,
+    };
+  }
+
+  if (typeof request.provider === "object") {
+    request.body.provider = stripApiSourceField(
+      request.provider as Record<string, any>
+    );
+    return {
+      apiKey: apiKeyForProvider("openrouter"),
+      isCustomApi,
+      hasExplicitKey,
+    };
+  }
+
+  if (!isCustomApi) {
+    return {
+      apiKey: apiKeyForProvider(String(request.providerName)),
+      isCustomApi,
+      hasExplicitKey,
+    };
+  }
+
+  return {
+    isCustomApi,
+    hasExplicitKey,
+  };
+};
+
+export const buildFallbackRequest = (
+  url: string,
+  provider: string,
+  model: string,
+  body: Record<string, any>,
+  apiKey: string,
+  signal: AbortSignal
+): UpstreamRequestSpec => ({
+  url,
+  provider,
+  model,
+  init: {
+    method: "POST",
+    headers: buildUpstreamHeaders(url, apiKey),
+    body: JSON.stringify({
+      ...body,
+      model,
+    }),
+    signal,
+  },
+});
+
+export const buildChatFallbackPlan = (
+  request: Pick<
+    ChatProxyPayload,
+    "providerName" | "originalModel" | "model" | "body"
+  >,
+  credentials: Pick<CredentialPlan, "isCustomApi" | "hasExplicitKey">,
+  signal: AbortSignal,
+  apiKeyForProvider: ChatRoutingKeyResolver
+): FallbackPlan => {
+  const isPlatformKimiRequest =
+    ((request.providerName === "deepinfra" &&
+      isDeepInfraKimiModel(request.model)) ||
+      (request.providerName === "fireworks" &&
+        isFireworksKimiModel(request.originalModel))) &&
+    !credentials.isCustomApi &&
+    !credentials.hasExplicitKey;
+  const fireworksApiKeyForKimiFallback =
+    isPlatformKimiRequest && request.providerName !== "fireworks"
+      ? apiKeyForProvider("fireworks")
+      : null;
+  const deepInfraApiKeyForKimiFallback =
+    isPlatformKimiRequest && request.providerName !== "deepinfra"
+      ? apiKeyForProvider("deepinfra")
+      : null;
+  const openRouterApiKeyForKimiFallback = isPlatformKimiRequest
+    ? apiKeyForProvider("openrouter")
+    : null;
+  const kimiFallbackRequests = isPlatformKimiRequest
+    ? [
+        fireworksApiKeyForKimiFallback
+          ? buildFallbackRequest(
+              FIREWORKS_CHAT_COMPLETIONS_URL,
+              "fireworks",
+              FIREWORKS_KIMI_CURRENT_MODEL,
+              request.body,
+              fireworksApiKeyForKimiFallback,
+              signal
+            )
+          : undefined,
+        deepInfraApiKeyForKimiFallback
+          ? buildFallbackRequest(
+              DEEPINFRA_CHAT_COMPLETIONS_URL,
+              "deepinfra",
+              DEEPINFRA_KIMI_FALLBACK_MODEL,
+              request.body,
+              deepInfraApiKeyForKimiFallback,
+              signal
+            )
+          : undefined,
+        openRouterApiKeyForKimiFallback
+          ? buildFallbackRequest(
+              OPENROUTER_CHAT_COMPLETIONS_URL,
+              "openrouter",
+              OPENROUTER_KIMI_FALLBACK_MODEL,
+              request.body,
+              openRouterApiKeyForKimiFallback,
+              signal
+            )
+          : undefined,
+      ].filter((fallback): fallback is UpstreamRequestSpec => !!fallback)
+    : [];
+  const kimiFallbackRequest = kimiFallbackRequests[0];
+
+  const shouldUseGoogleOpenRouterFallback =
+    request.providerName === "google" &&
+    typeof request.model === "string" &&
+    !!request.model &&
+    !credentials.isCustomApi &&
+    !credentials.hasExplicitKey;
+  const openRouterApiKey = shouldUseGoogleOpenRouterFallback
+    ? apiKeyForProvider("openrouter")
+    : null;
+  const googleFallbackRequest =
+    shouldUseGoogleOpenRouterFallback && openRouterApiKey
+      ? buildFallbackRequest(
+          OPENROUTER_CHAT_COMPLETIONS_URL,
+          "openrouter",
+          toOpenRouterGoogleModelName(request.model),
+          request.body,
+          openRouterApiKey,
+          signal
+        )
+      : undefined;
+
+  return {
+    kimiFallbackRequest,
+    kimiFallbackRequests,
+    googleFallbackRequest,
+    routeKimiThroughOpenRouter: false,
+    missingKimiFallbackKey:
+      isPlatformKimiRequest && kimiFallbackRequests.length === 0,
+    missingGoogleFallbackKey:
+      shouldUseGoogleOpenRouterFallback && !openRouterApiKey,
+  };
+};
+
+export const selectUpstreamRequest = (
+  request: Pick<
+    ChatProxyPayload,
+    "url" | "providerName" | "model" | "body" | "apiKeyHeader"
+  >,
+  credentials: Pick<CredentialPlan, "apiKey">,
+  fallbackPlan: FallbackPlan,
+  signal: AbortSignal
+): SelectedUpstreamRequest => {
+  return {
+    url: request.url,
+    provider: request.providerName,
+    model: request.model,
+    init: {
+      method: "POST",
+      headers: buildUpstreamHeaders(
+        request.url,
+        credentials.apiKey,
+        typeof request.apiKeyHeader === "string"
+          ? request.apiKeyHeader
+          : undefined
+      ),
+      body: JSON.stringify(request.body),
+      signal,
+    },
+    fallbackRequest:
+      fallbackPlan.kimiFallbackRequest ?? fallbackPlan.googleFallbackRequest,
+    fallbackRequests:
+      fallbackPlan.kimiFallbackRequests &&
+      fallbackPlan.kimiFallbackRequests.length > 0
+        ? fallbackPlan.kimiFallbackRequests
+        : undefined,
+    fallbackOnStatuses:
+      request.providerName === "google"
+        ? GOOGLE_FALLBACK_STATUSES
+        : fallbackPlan.kimiFallbackRequests &&
+            fallbackPlan.kimiFallbackRequests.length > 0
+          ? KIMI_PLATFORM_FALLBACK_STATUSES
+          : undefined,
+  };
+};
+
+export const buildChatRoutingDecisionLog = (
+  request: ChatProxyPayload,
+  credentials: CredentialPlan,
+  fallbackPlan: FallbackPlan,
+  upstreamRequest: SelectedUpstreamRequest
+): ChatRoutingDecisionLog => {
+  const fallbackRequest =
+    fallbackPlan.kimiFallbackRequest ?? fallbackPlan.googleFallbackRequest;
+  const fallbackReason = fallbackPlan.routeKimiThroughOpenRouter
+    ? "kimi_openrouter_direct"
+    : fallbackPlan.kimiFallbackRequests && fallbackPlan.kimiFallbackRequests.length > 0
+      ? "kimi_platform_fallback_chain"
+      : fallbackPlan.googleFallbackRequest
+        ? "google_openrouter_status_fallback"
+        : fallbackPlan.missingKimiFallbackKey
+          ? "kimi_platform_fallback_missing_key"
+          : fallbackPlan.missingGoogleFallbackKey
+            ? "google_openrouter_missing_key"
+            : undefined;
+
+  return {
+    provider: request.provider,
+    providerName: request.providerName,
+    originalModel:
+      request.originalModel ?? FIREWORKS_KIMI_LATEST_MODEL,
+    normalizedModel: request.model,
+    upstreamProvider: upstreamRequest.provider,
+    upstreamModel: upstreamRequest.model,
+    upstreamUrl: upstreamRequest.url,
+    hasExplicitKey: credentials.hasExplicitKey,
+    isCustomApi: credentials.isCustomApi,
+    fallbackReason,
+    fallbackProvider: fallbackRequest?.provider,
+    fallbackModel: fallbackRequest?.model,
+    fallbackOnStatuses: upstreamRequest.fallbackOnStatuses,
+  };
+};

package/server/handlers/chatUpstreamRetry.ts

@@ -0,0 +1,162 @@
+type RetryLogger = {
+  warn?: (...args: any[]) => void;
+};
+
+import type { OpenAIServiceTier } from "../../integrations/openai/flexTier";
+import { isFireworksKimiModel } from "../../ai/llm/kimi";
+
+const FIREWORKS_GENTLE_RETRY_DELAY_MS = 1200;
+const FIREWORKS_GENTLE_RETRY_STATUSES = new Set([429, 503]);
+
+type UpstreamRequest = {
+  url: string;
+  init: RequestInit;
+  provider?: string;
+  model?: string;
+  serviceTier?: OpenAIServiceTier;
+};
+
+function createAbortError(reason?: unknown): Error {
+  const error = new Error(typeof reason === "string" ? reason : "Aborted");
+  error.name = "AbortError";
+  return error;
+}
+
+async function sleepWithAbort(ms: number, signal?: AbortSignal): Promise<void> {
+  if (!signal) {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+    return;
+  }
+
+  if (signal.aborted) throw createAbortError(signal.reason);
+
+  await new Promise<void>((resolve, reject) => {
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+
+    const onAbort = () => {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", onAbort);
+      reject(createAbortError(signal.reason));
+    };
+
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+export async function fetchUpstreamWithGentleRetry({
+  url,
+  init,
+  provider,
+  model,
+  log,
+  fallbackRequest,
+  fallbackRequests,
+  fallbackOnStatuses,
+  retryDelayMs = FIREWORKS_GENTLE_RETRY_DELAY_MS,
+  fetchImpl = fetch,
+}: {
+  url: string;
+  init: RequestInit;
+  provider?: string;
+  model?: string;
+  log?: RetryLogger;
+  fallbackRequest?: UpstreamRequest;
+  fallbackRequests?: UpstreamRequest[];
+  fallbackOnStatuses?: Iterable<number>;
+  retryDelayMs?: number;
+  fetchImpl?: typeof fetch;
+}): Promise<{
+  response: Response;
+  provider?: string;
+  model?: string;
+  serviceTier?: OpenAIServiceTier;
+}> {
+  const maxAttempts = provider === "fireworks" ? 2 : 1;
+  let response: Response | undefined;
+
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    response = await fetchImpl(url, init);
+    const shouldRetry =
+      provider === "fireworks" &&
+      attempt < maxAttempts &&
+      FIREWORKS_GENTLE_RETRY_STATUSES.has(response.status);
+
+    if (!shouldRetry) break;
+
+    log?.warn?.("Fireworks 上游繁忙，准备温和重试一次", {
+      provider,
+      model,
+      status: response.status,
+      retryDelayMs,
+      attempt,
+    });
+
+    await sleepWithAbort(retryDelayMs, init.signal as AbortSignal | undefined);
+  }
+
+  if (!response) {
+    throw new Error("Unexpected retry state");
+  }
+
+  const fallbackStatuses = fallbackOnStatuses
+    ? new Set(Array.from(fallbackOnStatuses))
+      : provider === "fireworks" && isFireworksKimiModel(model)
+      ? FIREWORKS_GENTLE_RETRY_STATUSES
+      : null;
+  const fallbackQueue =
+    fallbackRequests && fallbackRequests.length > 0
+      ? fallbackRequests
+      : fallbackRequest
+        ? [fallbackRequest]
+        : [];
+  const shouldFallback =
+    fallbackQueue.length > 0 &&
+    !!fallbackStatuses &&
+    fallbackStatuses.has(response.status);
+
+  if (!shouldFallback) {
+    return {
+      response,
+      provider,
+      model,
+    };
+  }
+
+  let currentProvider = provider;
+  let currentModel = model;
+  let currentStatus = response.status;
+
+  for (const nextFallback of fallbackQueue) {
+    log?.warn?.("上游请求失败，切换到 fallback provider", {
+      provider: currentProvider,
+      model: currentModel,
+      status: currentStatus,
+      fallbackProvider: nextFallback.provider,
+      fallbackModel: nextFallback.model,
+    });
+
+    const fallbackResponse = await fetchImpl(nextFallback.url, nextFallback.init);
+    if (!fallbackStatuses.has(fallbackResponse.status)) {
+      return {
+        response: fallbackResponse,
+        provider: nextFallback.provider,
+        model: nextFallback.model,
+        serviceTier: nextFallback.serviceTier,
+      };
+    }
+
+    response = fallbackResponse;
+    currentProvider = nextFallback.provider;
+    currentModel = nextFallback.model;
+    currentStatus = fallbackResponse.status;
+  }
+
+  return {
+    response,
+    provider: currentProvider,
+    model: currentModel,
+  };
+}