nolo-cli 0.1.13 → 0.1.14

package/ai/llm/generateRequestBody.ts

@@ -0,0 +1,165 @@
+// ai/llm/generateRequestBody.ts
+import { Agent, Message } from "app/types";
+import { generateOpenAIRequestBody } from "integrations/openai/generateOpenAIRequestBody";
+import { generateResponseRequestBody } from "integrations/openai/generateResponseRequestBody";
+
+import { isResponseAPIModel } from "./isResponseAPIModel";
+import { Contexts } from "../types";
+import { getModelConfig } from "./providers";
+import type { Model } from "./types";
+
+export interface GenerateRequestBodyArgs {
+  agentConfig: Agent;
+  messages: Message[]; // 动态历史消息/本轮新增
+  userInput: string; // 本次用户输入
+  contexts?: Contexts; // 可选上下文
+  stableMessages?: Message[]; // 稳定的、已截断的历史快照（用于缓存）
+  prependSystemPrompt?: boolean;
+}
+
+const IMAGE_OUTPUT_EXECUTION_PROMPT = [
+  "When the conversation already includes an input image and the user asks to change any visual attribute such as hairstyle, glasses, outfit, makeup, background, composition, or style, default to returning the edited image in this turn.",
+  "When the user asks you to generate, edit, redraw, or return an image, you must return the image in this turn.",
+  "Do not answer with only a textual description.",
+  "Do not claim that you uploaded, attached, or sent an image unless the response actually includes image output.",
+  "Only return text without an image when the user explicitly asks for analysis, recommendations, or explanation without generating an image.",
+].join(" ");
+
+type ImageOutputSettings = {
+  shouldEnableImage: boolean;
+  modelConfig: Model | null;
+};
+
+const getImageOutputSettings = (
+  agentConfig: Agent,
+  provider: string
+): ImageOutputSettings => {
+  const modelName = agentConfig.model;
+  if (!modelName) {
+    return { shouldEnableImage: false, modelConfig: null };
+  }
+
+  try {
+    const modelConfig = getModelConfig(provider as any, modelName);
+    const hasImageOutput = !!modelConfig.hasImageOutput;
+    const isExplicitlyDisabled = agentConfig.imageConfig?.enabled === false;
+    return {
+      shouldEnableImage: hasImageOutput && !isExplicitlyDisabled,
+      modelConfig,
+    };
+  } catch {
+    return { shouldEnableImage: false, modelConfig: null };
+  }
+};
+
+const withImageOutputPromptGuard = (
+  agentConfig: Agent,
+  shouldEnableImage: boolean
+): Agent => {
+  if (!shouldEnableImage) return agentConfig;
+
+  const basePrompt = typeof agentConfig.prompt === "string" ? agentConfig.prompt.trim() : "";
+  if (basePrompt.includes(IMAGE_OUTPUT_EXECUTION_PROMPT)) {
+    return agentConfig;
+  }
+
+  return {
+    ...agentConfig,
+    prompt: basePrompt
+      ? `${basePrompt}\n\n${IMAGE_OUTPUT_EXECUTION_PROMPT}`
+      : IMAGE_OUTPUT_EXECUTION_PROMPT,
+  };
+};
+
+/**
+ * 根据模型元数据 + Agent 配置，为 chat/completions 请求体注入
+ * - modalities: ["image", "text"]
+ * - image_config: { aspect_ratio, image_size }
+ */
+const applyImageConfigIfNeeded = (
+  body: any,
+  agentConfig: Agent,
+  provider: string
+): any => {
+  const { shouldEnableImage, modelConfig } = getImageOutputSettings(
+    agentConfig,
+    provider
+  );
+  const agentImageCfg = agentConfig.imageConfig;
+
+  if (!shouldEnableImage || !modelConfig) {
+    return body;
+  }
+
+  // 1) 处理 modalities
+  // 优先级：Agent.forceModalities > Model.defaultModalities > requiresImageModalities ? ["image","text"] : 不强制
+  const modalities: Array<"text" | "image"> | undefined =
+    agentImageCfg?.forceModalities ??
+    modelConfig.defaultModalities ??
+    (modelConfig.requiresImageModalities
+      ? (["image", "text"] as Array<"text" | "image">)
+      : undefined);
+
+  if (modalities && !body.modalities) {
+    body.modalities = modalities;
+  }
+
+  // 2) 处理 image_config（仅在模型声明 supportsImageConfig 时生效）
+  if (!modelConfig.supportsImageConfig) {
+    return body;
+  }
+
+  const aspectRatio = agentImageCfg?.aspectRatio;
+  const imageSize = agentImageCfg?.imageSize;
+
+  if (!aspectRatio && !imageSize) {
+    // Agent 未指定任何 image_config 参数，则沿用模型默认
+    return body;
+  }
+
+  body.image_config = {
+    ...(body.image_config ?? {}),
+    ...(aspectRatio ? { aspect_ratio: aspectRatio } : {}),
+    ...(imageSize ? { image_size: imageSize } : {}),
+  };
+
+  return body;
+};
+
+export const generateRequestBody = ({
+  agentConfig,
+  messages,
+  contexts,
+  stableMessages,
+  prependSystemPrompt = true,
+}: GenerateRequestBodyArgs) => {
+  const provider = (agentConfig.provider || "").toLowerCase();
+  const imageSettings = getImageOutputSettings(agentConfig, provider);
+  const agentConfigForRequest = withImageOutputPromptGuard(
+    agentConfig,
+    imageSettings.shouldEnableImage
+  );
+
+  // 1) Response API 走新版 /v1/responses（目前主要是 OpenAI）
+  if (isResponseAPIModel(agentConfigForRequest)) {
+    return generateResponseRequestBody(
+      agentConfigForRequest,
+      [...(stableMessages ?? []), ...messages],
+      contexts,
+      prependSystemPrompt
+    );
+  }
+
+  // 2) 其余走老版 chat/completions
+  const baseBody = generateOpenAIRequestBody(
+    agentConfigForRequest,
+    provider,
+    messages,
+    contexts,
+    stableMessages,
+    prependSystemPrompt
+  );
+
+  // 在基础请求体上注入图像相关配置（如果模型 + Agent 都支持/需要）
+  return applyImageConfigIfNeeded(baseBody, agentConfigForRequest, provider);
+};

package/ai/llm/getModelContextWindow.ts

@@ -0,0 +1,84 @@
+// ai/llm/getModelContextWindow.ts
+
+/**
+ * 获取指定模型的 Context Window 大小。
+ * 
+ * 复用 ALL_MODELS 数据源，保持与模型选择器的一致性。
+ */
+
+import { ALL_MODELS, type ModelWithProvider } from "./models";
+
+// 默认 Context Window（用于未知模型）
+const DEFAULT_CONTEXT_WINDOW = 128000;
+
+// 缓存模型映射表
+let modelMap: Map<string, ModelWithProvider> | null = null;
+
+const getModelMap = (): Map<string, ModelWithProvider> => {
+    if (!modelMap) {
+        modelMap = new Map();
+        for (const model of ALL_MODELS) {
+            modelMap.set(model.name, model);
+            // 也按 displayName 索引（如果有）
+            if (model.displayName) {
+                modelMap.set(model.displayName.toLowerCase(), model);
+            }
+        }
+    }
+    return modelMap;
+};
+
+/**
+ * 根据模型名称获取 Context Window 大小
+ * @param modelName 模型名称（如 "gpt-4o", "claude-3-5-sonnet"）
+ * @returns Context Window 大小（tokens）
+ */
+export const getModelContextWindow = (modelName: string): number => {
+  if (!modelName) return DEFAULT_CONTEXT_WINDOW;
+
+  const map = getModelMap();
+  const model =
+    map.get(modelName) ||
+    map.get(modelName.toLowerCase());
+
+    if (model?.contextWindow) {
+        return typeof model.contextWindow === "number"
+            ? model.contextWindow
+            : DEFAULT_CONTEXT_WINDOW;
+    }
+
+    return DEFAULT_CONTEXT_WINDOW;
+};
+
+/**
+ * 获取模型的完整信息
+ */
+export const getModelInfo = (modelName: string): ModelWithProvider | null => {
+  if (!modelName) return null;
+
+  const map = getModelMap();
+  return (
+    map.get(modelName) ||
+    map.get(modelName.toLowerCase()) ||
+    null
+  );
+};
+
+/**
+ * 获取模型的 Max Output Tokens
+ */
+export const getModelMaxOutputTokens = (modelName: string): number => {
+    const model = getModelInfo(modelName);
+    if (model?.maxOutputTokens && typeof model.maxOutputTokens === "number") {
+        return model.maxOutputTokens;
+    }
+    return 4096; // 保守默认值
+};
+
+/**
+ * 获取模型是否支持视觉
+ */
+export const getModelHasVision = (modelName: string): boolean => {
+    const model = getModelInfo(modelName);
+    return model?.hasVision ?? false;
+};

package/ai/llm/getNoloKey.ts

@@ -0,0 +1,37 @@
+import { availableProviderOptions } from "./providers";
+
+const firstConfiguredKey = (...keys: Array<string | undefined>) =>
+  keys.find((key) => key?.trim())?.trim();
+
+export const getNoloKey = (
+  provider: (typeof availableProviderOptions)[number] | "deepinfra"
+) => {
+  switch (provider) {
+    case "anthropic":
+      return process.env.ANTHROPIC_API_KEY;
+    case "google":
+      return process.env.GOOGLE_API_KEY;
+    case "deepseek":
+      return process.env.DEEPSEEK_API_KEY;
+    case "openrouter":
+      return process.env.OPENROUTER_API_KEY;
+    case "fireworks":
+      return process.env.FIREWORKS_API_KEY;
+    case "openai":
+      return firstConfiguredKey(
+        process.env.OPENAI_KEY,
+        process.env.OPENAI_API_KEY
+      );
+    case "mistral":
+      return process.env.MISTRAL_KEY;
+    case "deepinfra":
+      return process.env.DEEPINFRA_API_KEY;
+    case "mimo":
+      return process.env.MIMO_API_KEY || process.env.OPENCODE_API_KEY;
+
+    // case "xai":
+    //   return process.env.XAI_API_KEY;
+    default:
+      return null;
+  }
+};

package/ai/llm/getPricing.ts

@@ -0,0 +1,232 @@
+import type { Agent } from "app/types";
+import { getModelConfig } from "ai/llm/providers";
+import {
+  isOpenAIFlexPricedModel,
+  resolveOpenAIServiceTier,
+} from "integrations/openai/flexTier";
+import { getPublicImageAgentDefaultProfile } from "ai/agent/utils/publicImageAgentMode";
+import { getApproxPricePerImage } from "./imagePricing";
+
+interface ModelPricing {
+  inputPrice: number;
+  inputCacheHitPrice: number;
+  outputPrice: number;
+}
+
+interface Prices {
+  cybotInput: number;
+  cybotOutput: number;
+  serverInput: number;
+  serverOutput: number;
+}
+
+const MAX_OUTPUT_TOKENS = 8192; // 单次返回最大 token 数
+
+export const getModelPricing = (
+  provider: string,
+  modelName: string,
+  requestedServiceTier?: string
+): ModelPricing | null => {
+  let model;
+  try {
+    model = getModelConfig(provider as any, modelName);
+  } catch {
+    return null;
+  }
+
+  if (!model?.price) return null;
+
+  return getModelPricingForModel(provider, modelName, model, requestedServiceTier);
+};
+
+export const getModelPricingForModel = (
+  provider: string,
+  modelName: string,
+  model: { price?: { input: number; inputCacheHit?: number; output: number } | null },
+  requestedServiceTier?: string
+): ModelPricing | null => {
+  if (!model.price) return null;
+  const normalizedRequestedServiceTier =
+    requestedServiceTier === "flex" || requestedServiceTier === "default"
+      ? requestedServiceTier
+      : undefined;
+  const shouldApplyFlexDiscount =
+    provider === "openai" &&
+    (normalizedRequestedServiceTier === "flex" ||
+      resolveOpenAIServiceTier({
+        providerName: provider,
+        model: modelName,
+      }) === "flex") &&
+    !isOpenAIFlexPricedModel(modelName);
+  const priceMultiplier = shouldApplyFlexDiscount ? 0.5 : 1;
+
+  return {
+    inputPrice: model.price.input * priceMultiplier,
+    inputCacheHitPrice:
+      typeof model.price.inputCacheHit === "number"
+        ? model.price.inputCacheHit * priceMultiplier
+        : 0,
+    outputPrice: model.price.output * priceMultiplier,
+  };
+};
+
+export const getPrices = (config: any, serverPrices: any): Prices => ({
+  cybotInput: Number(config?.inputPrice ?? 0),
+  cybotOutput: Number(config?.outputPrice ?? 0),
+  serverInput: Number(serverPrices?.inputPrice ?? 0),
+  serverOutput: Number(serverPrices?.outputPrice ?? 0),
+});
+
+/**
+ * 计算最终价格：
+ * - 从所有价格中取「每百万 tokens 价格」的最大值
+ * - 再换算成单 token 价格
+ * - 再乘以最大输出 token 数
+ */
+export const getFinalPrice = (prices: Prices): number => {
+  // 1. 取出所有价格字段
+  const rawValues = Object.values(prices);
+
+  // 2. 过滤出合法数字（去掉 NaN、Infinity、null/undefined 等）
+  const validValues = rawValues.filter(
+    (value) => typeof value === "number" && Number.isFinite(value)
+  );
+
+  // 3. 没有合法值时返回 0，避免 Math.max(...[]) 抛错
+  if (validValues.length === 0) {
+    return 0;
+  }
+
+  // 4. 找到每百万 token 的最高单价
+  const maxPricePerMillion = Math.max(...validValues);
+
+  // 5. 换算成单 token 价格
+  const maxPricePerToken = maxPricePerMillion / 1_000_000;
+
+  // 6. 计算 8192 个 token 的费用
+  return maxPricePerToken * MAX_OUTPUT_TOKENS;
+};
+
+/**
+ * 每次对话估算的典型 token 用量（输入含历史上下文，输出为单次回复）
+ * 仅用于 UI 展示的估算，并非计费依据。
+ */
+const TYPICAL_INPUT_TOKENS = 500;
+const TYPICAL_OUTPUT_TOKENS = 300;
+
+export type AgentPriceHint =
+  | {
+      type: "per_image";
+      amount: number;
+      labelKey?: "defaultImageProfileEstimate";
+      profileLabel?: string;
+    }
+  | { type: "per_turn"; amount: number };
+
+export interface CompactTurnPriceDisplay {
+  amountText: string;
+  unitCount: number;
+}
+
+const trimTrailingZeros = (value: string): string => {
+  if (!value.includes(".")) return value;
+  return value.replace(/\.?0+$/, "");
+};
+
+/**
+ * 根据 agent 配置返回用户可读的价格提示：
+ * - 图像 agent（imageConfig.enabled）：从 model config 查 pricePerImage，以每张为单位
+ * - 文字 agent：用典型 token 用量估算每次对话费用
+ * - 无价格信息则返回 null
+ */
+export const getAgentPriceHint = (
+  agent: Pick<
+    Agent,
+    | "inputPrice"
+    | "outputPrice"
+    | "model"
+    | "imageModel"
+    | "provider"
+    | "imageConfig"
+    | "imageWorkflow"
+  >
+): AgentPriceHint | null => {
+  const imagePriceModel = agent.imageModel ?? agent.model;
+
+  if (agent.imageConfig?.enabled && agent.provider && imagePriceModel) {
+    try {
+      const model = getModelConfig(agent.provider as any, imagePriceModel);
+      const mode = agent.imageWorkflow;
+      
+      if (mode === "generate") {
+        // For generator agents, always use the default profile price
+        const defaultProfile = getPublicImageAgentDefaultProfile("generate");
+        const pricePerImage = getApproxPricePerImage(model, "1K");
+        if (typeof pricePerImage === "number") {
+          return {
+            type: "per_image",
+            amount: pricePerImage,
+            labelKey: "defaultImageProfileEstimate",
+            profileLabel: `${defaultProfile.quality} · ${defaultProfile.size}`,
+          };
+        }
+      } else {
+        const pricePerImage = getApproxPricePerImage(
+          model,
+          agent.imageConfig?.imageSize
+        );
+        if (typeof pricePerImage === "number") {
+          return { type: "per_image", amount: pricePerImage };
+        }
+      }
+    } catch {
+      // Fall through to token-based pricing or null.
+    }
+  }
+
+  const inputPrice = agent.inputPrice ?? 0;
+  const outputPrice = agent.outputPrice ?? 0;
+  if (inputPrice === 0 && outputPrice === 0) return null;
+
+  const amount =
+    (inputPrice * TYPICAL_INPUT_TOKENS + outputPrice * TYPICAL_OUTPUT_TOKENS) /
+    1_000_000;
+  return { type: "per_turn", amount };
+};
+
+/** 将金额格式化为用户可读字符串（2 位有效数字，不使用科学计数法）*/
+export const formatPriceAmount = (amount: number): string => {
+  if (amount >= 0.1) return amount.toFixed(2);
+  if (amount >= 0.01) return amount.toFixed(3);
+  if (amount >= 0.001) return amount.toFixed(4);
+  if (amount >= 0.0001) return amount.toFixed(5);
+  return amount.toFixed(6);
+};
+
+export const formatCompactTurnPrice = (
+  amount: number
+): CompactTurnPriceDisplay => {
+  if (amount <= 0) {
+    return { amountText: "0", unitCount: 1 };
+  }
+
+  if (amount >= 0.01) {
+    return {
+      amountText: trimTrailingZeros(formatPriceAmount(amount)),
+      unitCount: 1,
+    };
+  }
+
+  const perHundred = amount * 100;
+  if (perHundred >= 0.01) {
+    return {
+      amountText: trimTrailingZeros(formatPriceAmount(perHundred)),
+      unitCount: 100,
+    };
+  }
+
+  return {
+    amountText: trimTrailingZeros(formatPriceAmount(amount * 1000)),
+    unitCount: 1000,
+  };
+};

package/ai/llm/hooks/useModelPricing.ts

@@ -0,0 +1,75 @@
+import { useState, useEffect, useRef } from "react";
+import { getModelsByProvider, getProviderByModelName } from "ai/llm/providers";
+import type { Model, ModelPrice } from "ai/llm/types";
+
+type ModelWithLegacyPricing = Partial<Model> & {
+  pricing?: ModelPrice | null;
+};
+
+export const resolveModelPrice = (
+  model?: ModelWithLegacyPricing | null
+): ModelPrice => {
+  const price = model?.price ?? model?.pricing;
+  return {
+    input: typeof price?.input === "number" ? price.input : 0,
+    output: typeof price?.output === "number" ? price.output : 0,
+    cachingWrite: price?.cachingWrite,
+    cachingRead: price?.cachingRead,
+    inputCacheHit: price?.inputCacheHit,
+  };
+};
+
+const useModelPricing = (
+  provider: string,
+  modelName: string,
+  setValue?: (name: string, value: number) => void
+) => {
+  const [models, setModels] = useState<Model[]>([]);
+  const [inputPrice, setInputPrice] = useState<number>(0);
+  const [outputPrice, setOutputPrice] = useState<number>(0);
+  const setValueRef = useRef(setValue);
+
+  useEffect(() => {
+    setValueRef.current = setValue;
+  }, [setValue]);
+
+  useEffect(() => {
+    // 若 provider 为空，从模型名反查（防止 provider 漏传导致定价缺失）
+    const resolvedProvider = provider || getProviderByModelName(modelName);
+    if (!resolvedProvider) return;
+    setModels(getModelsByProvider(resolvedProvider));
+  }, [provider, modelName]);
+
+  useEffect(() => {
+    const selectedModel = models.find((model) => model.name === modelName);
+    if (selectedModel) {
+      const price = resolveModelPrice(selectedModel as ModelWithLegacyPricing);
+      setInputPrice((current) => current === price.input ? current : price.input);
+      setOutputPrice((current) => current === price.output ? current : price.output);
+
+      if (setValueRef.current) {
+        setValueRef.current("inputPrice", price.input);
+        setValueRef.current("outputPrice", price.output);
+      }
+    }
+  }, [models, modelName]);
+
+  const updateInputPrice = (value: number) => {
+    setInputPrice(value);
+    if (setValue) setValue("inputPrice", value);
+  };
+
+  const updateOutputPrice = (value: number) => {
+    setOutputPrice(value);
+    if (setValue) setValue("outputPrice", value);
+  };
+
+  return {
+    inputPrice,
+    outputPrice,
+    setInputPrice: updateInputPrice,
+    setOutputPrice: updateOutputPrice,
+  };
+};
+
+export default useModelPricing;

package/ai/llm/imagePricing.ts

@@ -0,0 +1,66 @@
+import type { Agent } from "app/types";
+import { findModelConfig } from "./providers";
+import type { Model } from "./types";
+
+export type ImageSizeKey = "1K" | "2K" | "4K";
+
+type ImagePricingModel = Pick<
+  Model,
+  "pricePerImage" | "imageTokenPricePerMillion" | "imageOutputTokenEstimateBySize"
+>;
+
+const DEFAULT_IMAGE_SIZE: ImageSizeKey = "1K";
+
+export const getApproxPricePerImage = (
+  model: ImagePricingModel | null | undefined,
+  requestedSize?: ImageSizeKey
+): number | undefined => {
+  if (!model) return undefined;
+
+  if (typeof model.pricePerImage === "number") {
+    return model.pricePerImage;
+  }
+
+  if (typeof model.imageTokenPricePerMillion !== "number") {
+    return undefined;
+  }
+
+  const tokenEstimates = model.imageOutputTokenEstimateBySize;
+  if (!tokenEstimates) return undefined;
+
+  const resolvedSize =
+    requestedSize && typeof tokenEstimates[requestedSize] === "number"
+      ? requestedSize
+      : DEFAULT_IMAGE_SIZE;
+  const outputTokens = tokenEstimates[resolvedSize];
+
+  if (typeof outputTokens !== "number") {
+    return undefined;
+  }
+
+  return (model.imageTokenPricePerMillion * outputTokens) / 1_000_000;
+};
+
+const OPENAI_IMAGE_FALLBACK_MODEL = "gpt-image-2";
+
+export const getApproxAgentPricePerImage = (
+  agent: Pick<Agent, "provider" | "model" | "imageConfig">
+): number | undefined => {
+  if (!agent.imageConfig?.enabled || !agent.provider || !agent.model) {
+    return undefined;
+  }
+
+  const requestedSize = agent.imageConfig.imageSize as ImageSizeKey | undefined;
+  const directModel = findModelConfig(agent.provider, agent.model);
+  const directPrice = getApproxPricePerImage(directModel, requestedSize);
+  if (typeof directPrice === "number") {
+    return directPrice;
+  }
+
+  if (String(agent.provider).toLowerCase() !== "openai") {
+    return undefined;
+  }
+
+  const fallbackModel = findModelConfig("openai", OPENAI_IMAGE_FALLBACK_MODEL);
+  return getApproxPricePerImage(fallbackModel, requestedSize);
+};

package/ai/llm/isResponseAPIModel.ts

@@ -0,0 +1,13 @@
+import { getModelConfig } from "./providers";
+
+export const isResponseAPIModel = (agentConfig) => {
+  if (agentConfig.provider !== "openai") return false;
+  if (agentConfig.endpointKey === "responses") return true;
+  if (!agentConfig.model) return false;
+
+  try {
+    return getModelConfig("openai", agentConfig.model).endpointKey === "responses";
+  } catch {
+    return false;
+  }
+};

package/ai/llm/kimi.ts

@@ -0,0 +1,18 @@
+export const FIREWORKS_KIMI_LATEST_MODEL = "accounts/fireworks/models/kimi-latest";
+export const FIREWORKS_KIMI_CURRENT_MODEL = "accounts/fireworks/models/kimi-k2p6";
+export const OPENROUTER_KIMI_FALLBACK_MODEL = "moonshotai/kimi-k2.6";
+
+export const isFireworksKimiModel = (model?: string | null): boolean =>
+  model === FIREWORKS_KIMI_LATEST_MODEL || model === FIREWORKS_KIMI_CURRENT_MODEL;
+
+export const resolveFireworksKimiModel = (model?: string | null): string => {
+  if (model === FIREWORKS_KIMI_LATEST_MODEL) {
+    return FIREWORKS_KIMI_CURRENT_MODEL;
+  }
+  return model ?? "";
+};
+
+export const shouldHideKimiAliasFromPricing = (
+  provider?: string | null,
+  model?: string | null
+): boolean => provider === "fireworks" && model === FIREWORKS_KIMI_LATEST_MODEL;