nolo-cli 0.1.39 → 0.1.41

package/integrations/openai/filterAndCleanMessages.ts

@@ -0,0 +1,284 @@
+// packages/integrations/openai/filterAndCleanMessages.ts
+
+export type MessagePart =
+  | { type: "text"; text: string }
+  | { type: "image_url"; image_url: { url: string; detail?: "low" | "high" | "auto" } };
+
+export interface ToolCallFunction {
+  name: string;
+  arguments: string;
+}
+
+export interface ToolCall {
+  id: string;
+  type: "function";
+  function: ToolCallFunction;
+}
+
+export interface OpenAIMessage {
+  id?: string;
+  role: "system" | "user" | "assistant" | "tool";
+  content: string | MessagePart[];
+  name?: string;
+  tool_calls?: ToolCall[];
+  tool_call_id?: string;
+}
+
+export interface InternalMessage extends Omit<Partial<OpenAIMessage>, "content"> {
+  role: OpenAIMessage["role"];
+  content?: unknown;
+  toolName?: string;
+  toolCalls?: ToolCall[];
+  toolCallId?: string;
+  toolPayload?: {
+    toolName?: string;
+    rawToolCall?: ToolCall & { id: string };
+  };
+  [key: string]: any;
+}
+
+const TOOL_CONTEXT_MAX_CHARS = 4000;
+
+const truncateText = (text: string, maxChars: number = TOOL_CONTEXT_MAX_CHARS): string => {
+  if (text.length <= maxChars) return text;
+  return `${text.slice(0, maxChars)}\n…[截断，原始长度 ${text.length} 字符]`;
+};
+
+export const isValidMessagePart = (part: any): part is MessagePart => {
+  if (!part || typeof part !== "object") return false;
+  if (part.type === "text") return typeof part.text === "string";
+  if (part.type === "image_url") {
+    const img = part.image_url;
+    return img && typeof img === "object" && typeof img.url === "string" && img.url.length > 0;
+  }
+  return false;
+};
+
+const extractContent = (msg: InternalMessage): string | MessagePart[] | null => {
+  if (msg.role === "tool") {
+    const llmContext = typeof msg.toolPayload?.llmContext === "string"
+      ? msg.toolPayload.llmContext.trim()
+      : "";
+    if (llmContext) return truncateText(llmContext);
+
+    const summary = typeof msg.toolPayload?.summary === "string"
+      ? msg.toolPayload.summary.trim()
+      : "";
+    if (summary) return truncateText(summary);
+
+    if (typeof msg.content === "string") return truncateText(msg.content);
+    if (msg.content != null) return truncateText(JSON.stringify(msg.content));
+    return null;
+  }
+
+  if (typeof msg.content === "string") return msg.content;
+  if (Array.isArray(msg.content)) {
+    const parts = msg.content.filter(isValidMessagePart);
+    return parts.length > 0 ? parts : null;
+  }
+  if (msg.content && typeof msg.content === "object" && isValidMessagePart(msg.content)) {
+    return [msg.content as MessagePart];
+  }
+  return null;
+};
+
+const extractToolCalls = (msg: InternalMessage): ToolCall[] | undefined => {
+  const calls = msg.tool_calls ?? msg.toolCalls;
+  return Array.isArray(calls) && calls.length > 0 ? calls : undefined;
+};
+
+const extractToolCallId = (msg: InternalMessage): string | undefined =>
+  msg.tool_call_id ?? msg.toolCallId ?? msg.toolPayload?.rawToolCall?.id;
+
+const extractName = (msg: InternalMessage): string | undefined => {
+  if (typeof msg.name === "string") return msg.name;
+  if (typeof msg.toolName === "string") return msg.toolName;
+  if (typeof msg.toolPayload?.toolName === "string") return msg.toolPayload.toolName;
+  return undefined;
+};
+
+const getToolName = (msg: any): string | undefined =>
+  msg?.toolName ?? msg?.toolPayload?.toolName;
+
+const parseJsonObject = (value: unknown): Record<string, any> | undefined => {
+  if (typeof value !== "string") return undefined;
+  try {
+    const parsed = JSON.parse(value);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+      ? parsed
+      : undefined;
+  } catch {
+    return undefined;
+  }
+};
+
+const getStreamParallelReturnMode = (msg: any): string | undefined =>
+  msg?.toolPayload?.input?.returnMode ?? parseJsonObject(msg?.content)?.returnMode;
+
+const isHandoffToolMessage = (msg: any): boolean => {
+  const toolName = getToolName(msg);
+  if (toolName === "runStreamingAgent") return true;
+  if (toolName !== "streamParallelAgents") return false;
+  return getStreamParallelReturnMode(msg) !== "continue";
+};
+
+const getToolMessageCallId = (msg: any): string | undefined =>
+  msg?.tool_call_id ?? msg?.toolCallId ?? msg?.toolPayload?.rawToolCall?.id;
+
+const collectHandoffToolCallIds = (msgs: any[]): Set<string> => {
+  const ids = new Set<string>();
+  for (const msg of msgs) {
+    if (msg?.role !== "tool" || !isHandoffToolMessage(msg)) continue;
+    const id = getToolMessageCallId(msg);
+    if (id) ids.add(id);
+  }
+  return ids;
+};
+
+const stripHandoffToolMessage = (msg: any): any | null =>
+  msg?.role === "tool" && isHandoffToolMessage(msg) ? null : msg;
+
+const removeToolCallsById = (calls: any[] | undefined, ids: Set<string>) =>
+  calls?.filter((call) => !ids.has(call.id));
+
+const stripHandoffToolCallsFromAssistant = (msg: any, handoffIds: Set<string>): any => {
+  if (msg?.role !== "assistant") return msg;
+
+  const calls: any[] | undefined = msg.tool_calls ?? msg.toolCalls;
+  if (!calls?.some((call) => handoffIds.has(call.id))) return msg;
+
+  const kept = removeToolCallsById(calls, handoffIds);
+  return {
+    ...msg,
+    tool_calls: kept?.length ? kept : undefined,
+    toolCalls: kept?.length ? kept : undefined,
+  };
+};
+
+export const stripHandoffToolMessages = (msgs: any[]): any[] => {
+  const handoffIds = collectHandoffToolCallIds(msgs);
+  if (handoffIds.size === 0) return msgs;
+
+  return msgs
+    .map(stripHandoffToolMessage)
+    .filter(Boolean)
+    .map((msg) => stripHandoffToolCallsFromAssistant(msg, handoffIds));
+};
+
+const toOpenAIMessage = (rawMsg: any): OpenAIMessage | null => {
+  const msg = rawMsg as InternalMessage;
+  const { role, id } = msg;
+
+  if (!role || !["system", "user", "assistant", "tool"].includes(role)) return null;
+
+  const toolCalls = extractToolCalls(msg);
+  let content = extractContent(msg);
+
+  // assistant with tool_calls 允许 content 为空
+  if (content === null) {
+    if (role === "assistant" && toolCalls) content = "";
+    else return null;
+  }
+
+  const cleaned: OpenAIMessage = { role, content };
+
+  if (id) cleaned.id = id;
+  const name = extractName(msg);
+  if (name) cleaned.name = name;
+
+  if (role === "assistant" && toolCalls) {
+    cleaned.tool_calls = toolCalls;
+  }
+
+  if (role === "tool") {
+    const toolCallId = extractToolCallId(msg);
+    if (toolCallId) cleaned.tool_call_id = toolCallId;
+    if (!cleaned.tool_call_id) {
+      console.warn("[filterAndCleanMessages] 丢弃无效 tool 消息：缺少 tool_call_id", msg);
+      return null;
+    }
+  }
+
+  return cleaned;
+};
+
+/**
+ * 清除孤立的 tool_result / assistant stub 对。
+ *
+ * 一条 tool 消息若在其前面最近的 assistant 消息的 tool_calls 中找不到对应 id，
+ * 则视为孤立——连同对应的空 assistant stub 一起丢弃。
+ */
+const removeOrphanedToolPairs = (msgs: OpenAIMessage[]): OpenAIMessage[] => {
+  const dropIndexes = new Set<number>();
+
+  // 为每条 tool 消息找到对应的 assistant 索引
+  const toolToAssistant = new Map<number, number>();
+  for (let i = 0; i < msgs.length; i++) {
+    if (msgs[i].role !== "tool") continue;
+    for (let j = i - 1; j >= 0; j--) {
+      if (msgs[j].role === "assistant") {
+        toolToAssistant.set(i, j);
+        break;
+      }
+    }
+  }
+
+  // 标记孤立的 tool 消息
+  for (let i = 0; i < msgs.length; i++) {
+    if (msgs[i].role === "tool" && !toolToAssistant.has(i)) {
+      dropIndexes.add(i);
+      console.warn("[filterAndCleanMessages] 丢弃孤立 tool 消息：缺少前置 assistant", msgs[i].tool_call_id);
+    }
+  }
+
+  for (const [toolIdx, assistantIdx] of toolToAssistant) {
+    const toolMsg = msgs[toolIdx];
+    if (!toolMsg.tool_call_id) continue;
+
+    const knownIds = new Set((msgs[assistantIdx].tool_calls ?? []).map((tc) => tc.id));
+    if (!knownIds.has(toolMsg.tool_call_id)) {
+      dropIndexes.add(toolIdx);
+      console.warn("[filterAndCleanMessages] 丢弃孤立 tool 消息:", toolMsg.tool_call_id);
+    }
+  }
+
+  // 检查 assistant stub：若其所有 tool_calls 都已被孤立且自身无文本，一并丢弃
+  for (const assistantIdx of new Set(toolToAssistant.values())) {
+    if (dropIndexes.has(assistantIdx)) continue;
+
+    const stub = msgs[assistantIdx];
+    const content = typeof stub.content === "string" ? stub.content.trim() : stub.content;
+    const isEmpty = content === "" || (Array.isArray(content) && content.length === 0);
+    if (!isEmpty) continue;
+
+    const allToolsDropped = (stub.tool_calls ?? []).every((tc) => {
+      // 找所有引用该 id 的 tool 消息，看是否全被 drop
+      return msgs.every((m, idx) =>
+        m.role !== "tool" || m.tool_call_id !== tc.id || dropIndexes.has(idx)
+      );
+    });
+
+    if (allToolsDropped) {
+      dropIndexes.add(assistantIdx);
+      console.warn("[filterAndCleanMessages] 一并丢弃孤立 assistant stub（index:", assistantIdx, ")");
+    }
+  }
+
+  if (dropIndexes.size === 0) return msgs;
+  return msgs.filter((_, idx) => !dropIndexes.has(idx));
+};
+
+/**
+ * 将内部消息数组清洗为严格的 OpenAIMessage[]。
+ *
+ * 调用顺序建议：
+ *   selectAllMsgs → buildAgentViewMessages → filterAndCleanMessages → generateRequestBody
+ */
+export const filterAndCleanMessages = (msgs: any[]): OpenAIMessage[] => {
+  if (!Array.isArray(msgs)) return [];
+
+  const flat = msgs.flat();
+  const preprocessed = stripHandoffToolMessages(flat);
+  const cleaned = preprocessed.map(toOpenAIMessage).filter((m): m is OpenAIMessage => m !== null);
+  return removeOrphanedToolPairs(cleaned);
+};

package/integrations/openai/flexTier.ts

@@ -0,0 +1,102 @@
+export type OpenAIServiceTier = "flex" | "default";
+
+type OpenAIModelProfile = {
+  upstreamModel: string;
+  defaultServiceTier?: OpenAIServiceTier;
+  preAdjustedFlexPrice?: boolean;
+};
+
+const OPENAI_MODEL_PROFILES: Record<string, OpenAIModelProfile> = {
+  "gpt-5.5": {
+    upstreamModel: "gpt-5.5",
+    defaultServiceTier: "default",
+  },
+  "gpt-5.5-flex": {
+    upstreamModel: "gpt-5.5",
+    defaultServiceTier: "flex",
+    preAdjustedFlexPrice: true,
+  },
+  "gpt-5.5-pro-flex": {
+    upstreamModel: "gpt-5.5-pro",
+    defaultServiceTier: "flex",
+    preAdjustedFlexPrice: true,
+  },
+  "gpt-5.4": {
+    upstreamModel: "gpt-5.4",
+    defaultServiceTier: "default",
+  },
+  "gpt-5.4-flex": {
+    upstreamModel: "gpt-5.4",
+    defaultServiceTier: "flex",
+    preAdjustedFlexPrice: true,
+  },
+  "gpt-5.4-pro-flex": {
+    upstreamModel: "gpt-5.4-pro",
+    defaultServiceTier: "flex",
+    preAdjustedFlexPrice: true,
+  },
+};
+
+const getOpenAIModelProfile = (model?: string | null): OpenAIModelProfile | undefined => {
+  if (!model) return undefined;
+  return OPENAI_MODEL_PROFILES[model];
+};
+
+const isExplicitFlexModel = (model?: string | null): boolean => {
+  return getOpenAIModelProfile(model)?.defaultServiceTier === "flex";
+};
+
+export const resolveOpenAIUpstreamModel = ({
+  providerName,
+  model,
+}: {
+  providerName?: string | null;
+  model?: string | null;
+}): string | undefined => {
+  if (!model) return undefined;
+  if (providerName !== "openai") return model;
+  return getOpenAIModelProfile(model)?.upstreamModel ?? model;
+};
+
+export const isOpenAIFlexPricedModel = (model?: string | null): boolean => {
+  return getOpenAIModelProfile(model)?.preAdjustedFlexPrice === true;
+};
+
+export const resolveOpenAIServiceTier = ({
+  providerName,
+  model,
+  requestedServiceTier,
+}: {
+  providerName?: string | null;
+  model?: string | null;
+  requestedServiceTier?: string | null;
+}): OpenAIServiceTier | undefined => {
+  if (providerName !== "openai" || !model) return undefined;
+  const normalizedRequestedServiceTier =
+    requestedServiceTier === "flex" || requestedServiceTier === "default"
+      ? requestedServiceTier
+      : undefined;
+
+  if (normalizedRequestedServiceTier === "flex") {
+    return isExplicitFlexModel(model) ? "flex" : undefined;
+  }
+  if (normalizedRequestedServiceTier === "default") return "default";
+  return getOpenAIModelProfile(model)?.defaultServiceTier;
+};
+
+export const resolveOpenAIRequestTarget = ({
+  providerName,
+  model,
+  requestedServiceTier,
+}: {
+  providerName?: string | null;
+  model?: string | null;
+  requestedServiceTier?: string | null;
+}): { model?: string; serviceTier?: OpenAIServiceTier } => ({
+  model: resolveOpenAIUpstreamModel({ providerName, model }),
+  serviceTier: resolveOpenAIServiceTier({
+    providerName,
+    model,
+    requestedServiceTier,
+  }),
+});

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,
+  });
+};