nolo-cli 0.1.23 → 0.1.29

package/integrations/openai/generateOpenAIRequestBody.ts

@@ -0,0 +1,274 @@
+// 路径: /integrations/openai/generateOpenAIRequestBody.ts
+import { Agent, Message } from "../../app/types";
+
+import { isModelSupportReasoningEffort } from "../../ai/llm/reasoningModels";
+import { getUsageRequestOptions } from "../../ai/llm/usageRequestOptions";
+import {
+  isDeepInfraKimiModel,
+  isFireworksKimiModel,
+  resolveFireworksKimiModel,
+} from "../../ai/llm/kimi";
+import { Contexts } from "../../ai/types";
+import { generatePrompt } from "../../ai/agent/generatePrompt";
+import { resolveOpenAIRequestTarget } from "./flexTier";
+import { normalizeChatCompletionsBodyForProvider } from "./providerBodyCompatibility";
+
+// model 理论上不应为空（schema 已强制必填），但防御性处理 undefined
+const isClaudeModel = (model: string | undefined): boolean =>
+  !!model && (model.includes("claude") || model.includes("anthropic"));
+
+const applyClaudeCache = (content: any): any => {
+  if (typeof content === "string") {
+    return [
+      { type: "text", text: content, cache_control: { type: "ephemeral" } },
+    ];
+  }
+  if (Array.isArray(content)) {
+    // 已经是数组，给最后一个元素加上缓存标记
+    const lastIdx = content.length - 1;
+    return content.map((part, idx) => {
+      if (idx === lastIdx && typeof part === "object") {
+        return { ...part, cache_control: { type: "ephemeral" } };
+      }
+      return part;
+    });
+  }
+  return content;
+};
+
+const prependPromptMessage = (
+  messages: Message[],
+  agentConfig: Agent,
+  resolvedModel: string,
+  language: string,
+  contexts?: Contexts,
+  prependSystemPrompt = true
+): Message[] => {
+  if (!prependSystemPrompt) return messages;
+  if (!contexts && !agentConfig.prompt) return messages;
+
+  const promptContent = generatePrompt({ agentConfig, language, contexts });
+  if (!promptContent.trim()) return messages;
+
+  const content = isClaudeModel(resolvedModel)
+    ? applyClaudeCache(promptContent)
+    : promptContent;
+
+  const systemMessage: Message = { role: "system", content };
+  return [systemMessage, ...messages];
+};
+
+interface BuildRequestBodyOptions {
+  model: string;
+  messages: Message[];
+  providerName: string;
+  temperature?: number;
+  top_p?: number;
+  frequency_penalty?: number;
+  presence_penalty?: number;
+  max_tokens?: number;
+  reasoning_effort?: string;
+}
+
+const isLocalhostUrl = (url: string | undefined): boolean => {
+  if (!url?.trim()) return false;
+  try {
+    const hostname = new URL(url).hostname.toLowerCase();
+    return hostname === "127.0.0.1" || hostname === "localhost" || hostname === "::1";
+  } catch {
+    return false;
+  }
+};
+
+const shouldInjectLlamaCppThinkingToggle = (agentConfig: Agent): boolean => {
+  if (typeof agentConfig.enableThinking !== "boolean") return false;
+  if (!isLocalhostUrl(agentConfig.customProviderUrl)) return false;
+  return /qwen/i.test(agentConfig.model ?? "");
+};
+
+const shouldDisableMiMoThinking = (agentConfig: Agent): boolean => {
+  if (agentConfig.enableThinking === true) return false;
+  return (
+    /xiaomimimo\.com/i.test(agentConfig.customProviderUrl ?? "") ||
+    (agentConfig.provider ?? "").toLowerCase() === "mimo"
+  );
+};
+
+const shouldDisableKimiThinking = (
+  agentConfig: Agent,
+  providerName: string,
+  resolvedModel: string
+): boolean => {
+  if (agentConfig.enableThinking !== false) return false;
+  if (providerName === "deepinfra") return isDeepInfraKimiModel(resolvedModel);
+  if (providerName === "fireworks") return isFireworksKimiModel(resolvedModel);
+  if (providerName === "openrouter") {
+    return resolvedModel.toLowerCase() === "moonshotai/kimi-k2.6";
+  }
+  return false;
+};
+
+const normalizeChatCompletionsContent = (
+  content: Message["content"] | Record<string, unknown> | null | undefined
+): Message["content"] | null => {
+  if (typeof content === "string" || Array.isArray(content)) return content;
+  if (content == null) return null;
+  return JSON.stringify(content);
+};
+
+const sanitizeChatCompletionsMessage = (message: Message & Record<string, any>) => {
+  const sanitized: Record<string, any> = {
+    role: message.role,
+    content: normalizeChatCompletionsContent(message.content),
+  };
+
+  if (typeof message.name === "string" && message.name.trim()) {
+    sanitized.name = message.name.trim();
+  }
+
+  if (typeof message.tool_call_id === "string" && message.tool_call_id.trim()) {
+    sanitized.tool_call_id = message.tool_call_id.trim();
+  }
+
+  if (Array.isArray(message.tool_calls)) {
+    sanitized.tool_calls = message.tool_calls;
+  }
+
+  if (
+    message.role === "assistant" &&
+    typeof message.reasoning_content === "string" &&
+    message.reasoning_content
+  ) {
+    sanitized.reasoning_content = message.reasoning_content;
+  }
+
+  return sanitized;
+};
+
+const buildRequestBody = (options: BuildRequestBodyOptions): any => {
+  const {
+    model,
+    messages,
+    providerName,
+    temperature,
+    top_p,
+    frequency_penalty,
+    presence_penalty,
+    max_tokens,
+    reasoning_effort,
+  } = options;
+
+  // 只保留上游协议允许的字段，避免 UI/runtime 元数据泄漏到 chat-completions 请求体。
+  const cleanedMessages = messages.map((message) =>
+    sanitizeChatCompletionsMessage(message as Message & Record<string, any>)
+  );
+
+  const requestTarget = resolveOpenAIRequestTarget({
+    providerName,
+    model,
+  });
+  const bodyData: any = {
+    model: requestTarget.model ?? model,
+    messages: cleanedMessages,
+    stream: true,
+  };
+  const usageRequestOptions = getUsageRequestOptions(providerName, {
+    api: "chat-completions",
+  });
+  Object.assign(bodyData, usageRequestOptions);
+
+  // 推理强度（仅部分模型支持）
+  if (reasoning_effort && isModelSupportReasoningEffort(model)) {
+    bodyData.reasoning_effort = reasoning_effort;
+  }
+
+  if (requestTarget.serviceTier) {
+    bodyData.service_tier = requestTarget.serviceTier;
+  }
+
+  if (typeof temperature === "number") bodyData.temperature = temperature;
+  if (typeof top_p === "number") bodyData.top_p = top_p;
+  if (typeof frequency_penalty === "number")
+    bodyData.frequency_penalty = frequency_penalty;
+  if (typeof presence_penalty === "number")
+    bodyData.presence_penalty = presence_penalty;
+  if (typeof max_tokens === "number") bodyData.max_tokens = max_tokens;
+
+  return bodyData;
+};
+
+/**
+ * 主函数：生成完整的 OpenAI 请求体。
+ */
+export const generateOpenAIRequestBody = (
+  agentConfig: Agent,
+  providerName: string,
+  messages: Message[],
+  contexts?: Contexts,
+  stableMessages: Message[] = [],
+  prependSystemPrompt = true
+) => {
+  // 0. 解析最终 model 名：统一用 model 字段，不再有 customModelName
+  //    model 在 platform 和 custom 模式下都是同一个字段
+  const resolvedModel =
+    providerName === "fireworks"
+      ? resolveFireworksKimiModel(agentConfig.model)
+      : agentConfig.model ?? "";
+
+  // 1. 处理 stableMessages 的缓存点 (仅针对 Claude)
+  let processedStable = [...stableMessages];
+  if (isClaudeModel(resolvedModel) && processedStable.length > 0) {
+    const lastStableIdx = processedStable.length - 1;
+    processedStable[lastStableIdx] = {
+      ...processedStable[lastStableIdx],
+      content: applyClaudeCache(processedStable[lastStableIdx].content),
+    };
+  }
+
+  // 2. 合并 stable + dynamic
+  const fullMessages = [...processedStable, ...messages];
+
+  const messagesWithPrompt = prependPromptMessage(
+    fullMessages,
+    agentConfig,
+    resolvedModel,
+    typeof navigator !== "undefined" ? (navigator as any).language : "en",
+    contexts,
+    prependSystemPrompt
+  );
+
+  const requestBody = buildRequestBody({
+    model: resolvedModel,
+    messages: messagesWithPrompt,
+    providerName,
+    temperature: agentConfig.temperature,
+    top_p: agentConfig.top_p,
+    frequency_penalty: agentConfig.frequency_penalty,
+    presence_penalty: agentConfig.presence_penalty,
+    max_tokens: agentConfig.max_tokens,
+    reasoning_effort: agentConfig.reasoning_effort,
+  });
+
+  if (shouldInjectLlamaCppThinkingToggle(agentConfig)) {
+    requestBody.chat_template_kwargs = {
+      ...(requestBody.chat_template_kwargs ?? {}),
+      enable_thinking: agentConfig.enableThinking,
+    };
+  }
+
+  if (shouldDisableMiMoThinking(agentConfig)) {
+    requestBody.thinking = { type: "disabled" };
+  }
+
+  if (shouldDisableKimiThinking(agentConfig, providerName, resolvedModel)) {
+    requestBody.thinking = { type: "disabled" };
+    requestBody.reasoning_effort = "none";
+    requestBody.reasoning = { enabled: false };
+  }
+
+  return normalizeChatCompletionsBodyForProvider({
+    body: requestBody,
+    provider: providerName,
+    model: requestBody.model,
+  });
+};

package/integrations/openai/generateResponseRequestBody.ts

@@ -0,0 +1,77 @@
+// /integrations/openai/generateResponseRequestBody.ts
+import { Agent, Message } from "../../app/types";
+import { generatePrompt } from "../../ai/agent/generatePrompt";
+import { getUsageRequestOptions } from "../../ai/llm/usageRequestOptions";
+import { Contexts } from "../../ai/types";
+import { resolveOpenAIRequestTarget } from "./flexTier";
+import { convertMessagesToResponsesInput } from "./responsesHelpers";
+
+/**
+ * 生成新版 Response API 请求体
+ * Responses API (/v1/responses) 天然在流结束时返回 usage，
+ * 不需要也不支持 Chat Completions 的 stream_options.include_usage。
+ * @param agentConfig Agent 配置
+ * @param msgs 历史消息列表（数组里每项为 { role, content, name?, tool_calls?, tool_call_id? }）
+ * @param contexts 可选上下文
+ */
+export function generateResponseRequestBody(
+  agentConfig: Agent,
+  msgs: Message[],
+  contexts?: Contexts,
+  prependSystemPrompt = true
+) {
+  const language =
+    typeof navigator !== "undefined" && navigator.language
+      ? navigator.language
+      : "zh-CN";
+  const input = convertMessagesToResponsesInput(msgs);
+  const requestTarget = resolveOpenAIRequestTarget({
+    providerName: agentConfig.provider,
+    model: agentConfig.model,
+  });
+  const body: Record<string, any> = {
+    model: requestTarget.model ?? agentConfig.model,
+    input,
+    stream: true,
+    ...getUsageRequestOptions(agentConfig.provider, { api: "responses" }),
+  };
+
+  if (prependSystemPrompt) {
+    const promptContent = generatePrompt({
+      agentConfig,
+      language,
+      contexts,
+    });
+    body.instructions = promptContent;
+  }
+
+  if (requestTarget.serviceTier) {
+    body.service_tier = requestTarget.serviceTier;
+  }
+
+  // 3. 按需添加可选字段
+
+  if (agentConfig.temperature !== undefined) {
+    body.temperature = agentConfig.temperature;
+  }
+  if (agentConfig.top_p !== undefined) {
+    body.top_p = agentConfig.top_p;
+  }
+  if (agentConfig.max_tokens !== undefined) {
+    body.max_output_tokens = agentConfig.max_tokens;
+  }
+  if (agentConfig.max_tool_calls !== undefined) {
+    body.max_tool_calls = agentConfig.max_tool_calls;
+  }
+  if (agentConfig.user !== undefined) {
+    body.user = agentConfig.user;
+  }
+  if (agentConfig.include !== undefined) {
+    body.include = agentConfig.include;
+  }
+  if (agentConfig.metadata !== undefined) {
+    body.metadata = agentConfig.metadata;
+  }
+
+  return body;
+}

package/integrations/openai/models.ts

@@ -0,0 +1,271 @@
+// integrations/openai/models.ts
+import type { Model, ModelPrice } from "../../ai/llm/types";
+
+const scalePrice = (price: ModelPrice, multiplier: number): ModelPrice => ({
+  input: price.input * multiplier,
+  output: price.output * multiplier,
+  ...(typeof price.cachingWrite === "number"
+    ? { cachingWrite: price.cachingWrite * multiplier }
+    : {}),
+  ...(typeof price.cachingRead === "number"
+    ? { cachingRead: price.cachingRead * multiplier }
+    : {}),
+  ...(typeof price.inputCacheHit === "number"
+    ? { inputCacheHit: price.inputCacheHit * multiplier }
+    : {}),
+});
+
+const GPT_5_4_STANDARD_PRICE: ModelPrice = {
+  input: 2.5,
+  output: 15,
+  inputCacheHit: 0.25,
+};
+
+const GPT_5_5_STANDARD_PRICE: ModelPrice = {
+  input: 5,
+  output: 30,
+  inputCacheHit: 0.5,
+};
+
+const GPT_5_4_LONG_CONTEXT_PRICE: ModelPrice = {
+  input: 5,
+  output: 22.5,
+  inputCacheHit: 0.5,
+};
+
+const GPT_5_5_LONG_CONTEXT_PRICE: ModelPrice = {
+  input: 10,
+  output: 45,
+  inputCacheHit: 1,
+};
+
+const GPT_5_4_PRO_STANDARD_PRICE: ModelPrice = {
+  input: 30,
+  output: 180,
+  inputCacheHit: 0,
+};
+
+const GPT_5_4_PRO_LONG_CONTEXT_PRICE: ModelPrice = {
+  input: 60,
+  output: 270,
+  inputCacheHit: 0,
+};
+
+export const openAIModels: Model[] = [
+  {
+    name: "gpt-5.5",
+    displayName: "GPT-5.5 Standard",
+    endpointKey: "responses",
+    hasVision: true,
+    contextWindow: 1_047_576,
+    maxOutputTokens: 128_000,
+    supportsReasoningEffort: true,
+    price: GPT_5_5_STANDARD_PRICE,
+    pricingStrategy: {
+      type: "tiered_context",
+      tiers: [
+        {
+          minContext: 272_001,
+          price: GPT_5_5_LONG_CONTEXT_PRICE,
+        },
+      ],
+    },
+  },
+  {
+    name: "gpt-5.5-flex",
+    displayName: "GPT-5.5 Flex",
+    endpointKey: "responses",
+    hasVision: true,
+    contextWindow: 1_047_576,
+    maxOutputTokens: 128_000,
+    supportsReasoningEffort: true,
+    price: scalePrice(GPT_5_5_STANDARD_PRICE, 0.5),
+    pricingStrategy: {
+      type: "tiered_context",
+      tiers: [
+        {
+          minContext: 272_001,
+          price: scalePrice(GPT_5_5_LONG_CONTEXT_PRICE, 0.5),
+        },
+      ],
+    },
+  },
+  {
+    name: "gpt-5.5-pro",
+    displayName: "GPT-5.5 Pro",
+    endpointKey: "responses",
+    hasVision: true,
+    contextWindow: 1_047_576,
+    maxOutputTokens: 128_000,
+    supportsReasoningEffort: true,
+    price: GPT_5_4_PRO_STANDARD_PRICE,
+    pricingStrategy: {
+      type: "tiered_context",
+      tiers: [
+        {
+          minContext: 272_001,
+          price: GPT_5_4_PRO_LONG_CONTEXT_PRICE,
+        },
+      ],
+    },
+  },
+  {
+    name: "gpt-5.5-pro-flex",
+    displayName: "GPT-5.5 Pro Flex",
+    endpointKey: "responses",
+    hasVision: true,
+    contextWindow: 1_047_576,
+    maxOutputTokens: 128_000,
+    supportsReasoningEffort: true,
+    price: scalePrice(GPT_5_4_PRO_STANDARD_PRICE, 0.5),
+    pricingStrategy: {
+      type: "tiered_context",
+      tiers: [
+        {
+          minContext: 272_001,
+          price: scalePrice(GPT_5_4_PRO_LONG_CONTEXT_PRICE, 0.5),
+        },
+      ],
+    },
+  },
+  {
+    name: "gpt-image-2",
+    displayName: "GPT Image 2",
+    endpointKey: "responses",
+    hasVision: true,
+    hasImageOutput: true,
+    supportsImageOutput: true,
+    supportsTool: false,
+    contextWindow: 128_000,
+    maxOutputTokens: 32_768,
+    // OpenAI's current public pricing page does not list GPT Image 2 separately.
+    // Reuse GPT Image 1.5 pricing as a conservative placeholder until official
+    // GPT Image 2 pricing is published.
+    price: { input: 5, output: 10, inputCacheHit: 1.25 },
+    pricePerImage: 0.04 * 8,
+  },
+  {
+    name: "gpt-5.4",
+    displayName: "GPT-5.4 Standard",
+    endpointKey: "responses",
+    hasVision: true,
+    contextWindow: 1_047_576,
+    maxOutputTokens: 128_000,
+    supportsReasoningEffort: true,
+    price: GPT_5_4_STANDARD_PRICE,
+    pricingStrategy: {
+      type: "tiered_context",
+      tiers: [
+        {
+          minContext: 272_001,
+          price: GPT_5_4_LONG_CONTEXT_PRICE,
+        },
+      ],
+    },
+  },
+  {
+    name: "gpt-5.4-flex",
+    displayName: "GPT-5.4 Flex",
+    endpointKey: "responses",
+    hasVision: true,
+    contextWindow: 1_047_576,
+    maxOutputTokens: 128_000,
+    supportsReasoningEffort: true,
+    price: scalePrice(GPT_5_4_STANDARD_PRICE, 0.5),
+    pricingStrategy: {
+      type: "tiered_context",
+      tiers: [
+        {
+          minContext: 272_001,
+          price: scalePrice(GPT_5_4_LONG_CONTEXT_PRICE, 0.5),
+        },
+      ],
+    },
+  },
+  {
+    name: "gpt-5.4-mini",
+    displayName: "GPT-5.4 Mini",
+    endpointKey: "responses",
+    hasVision: true,
+    contextWindow: 400_000,
+    maxOutputTokens: 128_000,
+    supportsReasoningEffort: true,
+    price: { input: 0.75, output: 4.5, inputCacheHit: 0.075 },
+  },
+  {
+    name: "gpt-5.4-nano",
+    displayName: "GPT-5.4 Nano",
+    endpointKey: "responses",
+    hasVision: true,
+    contextWindow: 400_000,
+    maxOutputTokens: 128_000,
+    supportsReasoningEffort: true,
+    price: { input: 0.2, output: 1.25, inputCacheHit: 0.02 },
+  },
+  {
+    name: "gpt-5.4-pro",
+    displayName: "GPT-5.4 Pro",
+    endpointKey: "responses",
+    hasVision: true,
+    contextWindow: 1_047_576,
+    maxOutputTokens: 128_000,
+    supportsReasoningEffort: true,
+    price: GPT_5_4_PRO_STANDARD_PRICE,
+    pricingStrategy: {
+      type: "tiered_context",
+      tiers: [
+        {
+          minContext: 272_001,
+          price: GPT_5_4_PRO_LONG_CONTEXT_PRICE,
+        },
+      ],
+    },
+  },
+  {
+    name: "gpt-5.4-pro-flex",
+    displayName: "GPT-5.4 Pro Flex",
+    endpointKey: "responses",
+    hasVision: true,
+    contextWindow: 1_047_576,
+    maxOutputTokens: 128_000,
+    supportsReasoningEffort: true,
+    price: scalePrice(GPT_5_4_PRO_STANDARD_PRICE, 0.5),
+    pricingStrategy: {
+      type: "tiered_context",
+      tiers: [
+        {
+          minContext: 272_001,
+          price: scalePrice(GPT_5_4_PRO_LONG_CONTEXT_PRICE, 0.5),
+        },
+      ],
+    },
+  },
+  {
+    name: "gpt-5",
+    displayName: "GPT-5",
+    hasVision: true,
+    contextWindow: 400_000,
+    maxOutputTokens: 128_000,
+    supportsReasoningEffort: true,
+    price: { input: 12.5, output: 100, inputCacheHit: 1.25 },
+  },
+  {
+    name: "gpt-5-mini",
+    displayName: "GPT-5 mini",
+    hasVision: true,
+    contextWindow: 400_000,
+    maxOutputTokens: 128_000,
+    supportsReasoningEffort: true,
+    price: { input: 2.5, output: 20, inputCacheHit: 0.25 },
+  },
+  {
+    name: "o3-pro",
+    displayName: "O3 Pro",
+    hasVision: false,
+    contextWindow: 200_000,
+    maxOutputTokens: 100_000,
+    supportsReasoningEffort: true,
+    endpointKey: "responses",
+    price: { input: 200, output: 800, inputCacheHit: 0 },
+  },
+];

package/integrations/openai/providerBodyCompatibility.ts

@@ -0,0 +1,23 @@
+import { isFireworksKimiModel } from "../../ai/llm/kimi";
+
+type NormalizeChatCompletionsBodyArgs = {
+  body: Record<string, any>;
+  provider: string;
+  model: string;
+};
+
+export const normalizeChatCompletionsBodyForProvider = ({
+  body,
+  provider,
+  model,
+}: NormalizeChatCompletionsBodyArgs): Record<string, any> => {
+  const nextBody = { ...body, model };
+  const normalizedProvider = provider.trim().toLowerCase();
+
+  if (normalizedProvider === "fireworks" && isFireworksKimiModel(model)) {
+    delete nextBody.reasoning;
+    delete nextBody.reasoning_effort;
+  }
+
+  return nextBody;
+};