nolo-cli 0.1.39 → 0.1.41

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 * 8,
+  output: 15 * 8,
+  inputCacheHit: 0.25 * 8,
+};
+
+const GPT_5_5_STANDARD_PRICE: ModelPrice = {
+  input: 5 * 8,
+  output: 30 * 8,
+  inputCacheHit: 0.5 * 8,
+};
+
+const GPT_5_4_LONG_CONTEXT_PRICE: ModelPrice = {
+  input: 5 * 8,
+  output: 22.5 * 8,
+  inputCacheHit: 0.5 * 8,
+};
+
+const GPT_5_5_LONG_CONTEXT_PRICE: ModelPrice = {
+  input: 10 * 8,
+  output: 45 * 8,
+  inputCacheHit: 1 * 8,
+};
+
+const GPT_5_4_PRO_STANDARD_PRICE: ModelPrice = {
+  input: 30 * 8,
+  output: 180 * 8,
+  inputCacheHit: 0,
+};
+
+const GPT_5_4_PRO_LONG_CONTEXT_PRICE: ModelPrice = {
+  input: 60 * 8,
+  output: 270 * 8,
+  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 * 8, output: 10 * 8, inputCacheHit: 1.25 * 8 },
+    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 * 8, output: 4.5 * 8, inputCacheHit: 0.075 * 8 },
+  },
+  {
+    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 * 8, output: 1.25 * 8, inputCacheHit: 0.02 * 8 },
+  },
+  {
+    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: 1.25 * 8, output: 10 * 8, inputCacheHit: 0.125 * 8 },
+  },
+  {
+    name: "gpt-5-mini",
+    displayName: "GPT-5 mini",
+    hasVision: true,
+    contextWindow: 400_000,
+    maxOutputTokens: 128_000,
+    supportsReasoningEffort: true,
+    price: { input: 0.25 * 8, output: 2 * 8, inputCacheHit: 0.025 * 8 },
+  },
+  {
+    name: "o3-pro",
+    displayName: "O3 Pro",
+    hasVision: false,
+    contextWindow: 200_000,
+    maxOutputTokens: 100_000,
+    supportsReasoningEffort: true,
+    endpointKey: "responses",
+    price: { input: 20 * 7, output: 80 * 7, 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;
+};

package/integrations/openai/responsesHelpers.ts

@@ -0,0 +1,297 @@
+import type { Message } from "../../app/types";
+
+type MessageContentPart =
+  | { type: "text"; text: string }
+  | { type: "image_url"; image_url: { url: string; detail?: "low" | "high" | "auto" } };
+
+type ToolCall = {
+  id: string;
+  type: "function";
+  function: { name: string; arguments: string };
+};
+
+type ResponseInputTextPart =
+  | { type: "input_text"; text: string }
+  | { type: "output_text"; text: string };
+type ResponseInputImagePart = {
+  type: "input_image";
+  image_url: string;
+  detail?: "low" | "high" | "auto";
+};
+
+type ResponseInputMessage = {
+  type: "message";
+  role: "system" | "developer" | "user" | "assistant";
+  content: Array<ResponseInputTextPart | ResponseInputImagePart>;
+};
+
+type ResponseFunctionCall = {
+  type: "function_call";
+  call_id: string;
+  name: string;
+  arguments: string;
+};
+
+type ResponseFunctionCallOutput = {
+  type: "function_call_output";
+  call_id: string;
+  output: string;
+};
+
+export type ResponseInputItem =
+  | ResponseInputMessage
+  | ResponseFunctionCall
+  | ResponseFunctionCallOutput;
+
+export type AssistantToolCall = ToolCall;
+
+const RESPONSES_TOP_LEVEL_SCHEMA_KEYS = ["anyOf", "oneOf", "allOf", "enum", "not"] as const;
+
+const sanitizeResponsesParameters = (parameters: any): any => {
+  if (!parameters || typeof parameters !== "object" || Array.isArray(parameters)) {
+    return parameters;
+  }
+
+  const next = { ...parameters };
+  for (const key of RESPONSES_TOP_LEVEL_SCHEMA_KEYS) {
+    delete next[key];
+  }
+  return next;
+};
+
+const appendTextPart = (
+  parts: Array<ResponseInputTextPart | ResponseInputImagePart>,
+  text: string,
+  role: "system" | "developer" | "user" | "assistant"
+) => {
+  if (!text) return;
+  const last = parts.at(-1);
+  const textType = role === "assistant" ? "output_text" : "input_text";
+  if (last?.type === textType) {
+    last.text += text;
+    return;
+  }
+  parts.push({ type: textType, text });
+};
+
+const normalizeMessageParts = (
+  content: Message["content"],
+  role: "system" | "developer" | "user" | "assistant"
+): Array<ResponseInputTextPart | ResponseInputImagePart> => {
+  if (typeof content === "string") {
+    if (!content) return [];
+    return [
+      {
+        type: role === "assistant" ? "output_text" : "input_text",
+        text: content,
+      },
+    ];
+  }
+
+  const parts: Array<ResponseInputTextPart | ResponseInputImagePart> = [];
+  for (const part of content ?? []) {
+    const typedPart = part as MessageContentPart;
+    if (typedPart?.type === "text" && typeof typedPart.text === "string") {
+      appendTextPart(parts, typedPart.text, role);
+      continue;
+    }
+
+    if (
+      typedPart?.type === "image_url" &&
+      typeof typedPart.image_url?.url === "string" &&
+      typedPart.image_url.url
+    ) {
+      if (role === "assistant") continue;
+      parts.push({
+        type: "input_image",
+        image_url: typedPart.image_url.url,
+        detail: typedPart.image_url.detail,
+      });
+    }
+  }
+
+  return parts;
+};
+
+const normalizeToolOutput = (content: Message["content"]): string => {
+  if (typeof content === "string") return content;
+  return JSON.stringify(content ?? "");
+};
+
+export const toResponsesTools = (tools: any[] | undefined): any[] | undefined => {
+  if (!Array.isArray(tools) || tools.length === 0) return undefined;
+
+  return tools
+    .map((tool) => {
+      const fn = tool?.function;
+      if (!fn?.name) return null;
+      return {
+        type: "function",
+        name: fn.name,
+        description: fn.description,
+        parameters: sanitizeResponsesParameters(fn.parameters),
+        strict: fn.strict,
+      };
+    })
+    .filter(Boolean);
+};
+
+export const convertMessagesToResponsesInput = (
+  messages: Array<Pick<Message, "role" | "content" | "tool_calls" | "tool_call_id">>
+): ResponseInputItem[] => {
+  const input: ResponseInputItem[] = [];
+
+  for (const message of messages) {
+    if (!message?.role) continue;
+
+    if (message.role === "tool") {
+      if (!message.tool_call_id) continue;
+      input.push({
+        type: "function_call_output",
+        call_id: message.tool_call_id,
+        output: normalizeToolOutput(message.content),
+      });
+      continue;
+    }
+
+    const role = message.role as ResponseInputMessage["role"];
+    const contentParts = normalizeMessageParts(message.content, role);
+    if (contentParts.length > 0) {
+      input.push({
+        type: "message",
+        role,
+        content: contentParts,
+      });
+    }
+
+    if (role === "assistant" && Array.isArray(message.content)) {
+      const replayImages = message.content
+        .map((part) => part as MessageContentPart)
+        .filter(
+          (part) =>
+            part?.type === "image_url" &&
+            typeof part.image_url?.url === "string" &&
+            part.image_url.url
+        )
+        .map((part) => ({
+          type: "input_image" as const,
+          image_url: part.image_url.url,
+          detail: part.image_url.detail,
+        }));
+
+      if (replayImages.length > 0) {
+        input.push({
+          type: "message",
+          role: "user",
+          content: replayImages,
+        });
+      }
+    }
+
+    if (role === "assistant" && Array.isArray(message.tool_calls)) {
+      for (const toolCall of message.tool_calls as ToolCall[]) {
+        if (!toolCall?.id || !toolCall.function?.name) continue;
+        input.push({
+          type: "function_call",
+          call_id: toolCall.id,
+          name: toolCall.function.name,
+          arguments:
+            typeof toolCall.function.arguments === "string"
+              ? toolCall.function.arguments
+              : JSON.stringify(toolCall.function.arguments ?? {}),
+        });
+      }
+    }
+  }
+
+  return input;
+};
+
+export const extractTextFromResponseOutput = (response: any): string => {
+  const parts: string[] = [];
+  for (const item of response?.output ?? []) {
+    if (item?.type !== "message") continue;
+    for (const content of item.content ?? []) {
+      if (content?.type === "output_text" && typeof content.text === "string") {
+        parts.push(content.text);
+      }
+    }
+  }
+  return parts.join("");
+};
+
+const toDataUrl = (base64Data: string, mimeType?: string | null): string => {
+  const normalizedMimeType =
+    typeof mimeType === "string" && mimeType.trim()
+      ? mimeType.trim()
+      : "image/png";
+  return `data:${normalizedMimeType};base64,${base64Data}`;
+};
+
+export const extractImagePartsFromResponseOutput = (
+  response: any
+): Array<{ type: "image_url"; image_url: { url: string } }> => {
+  const images: Array<{ type: "image_url"; image_url: { url: string } }> = [];
+
+  for (const item of response?.output ?? []) {
+    if (item?.type === "image_generation_call") {
+      if (typeof item.result === "string" && item.result.trim()) {
+        images.push({
+          type: "image_url",
+          image_url: {
+            url: toDataUrl(
+              item.result.trim(),
+              typeof item.output_format === "string" && item.output_format.trim()
+                ? `image/${item.output_format.trim()}`
+                : undefined
+            ),
+          },
+        });
+      }
+      continue;
+    }
+
+    if (item?.type !== "message") continue;
+    for (const content of item.content ?? []) {
+      if (
+        content?.type === "output_image" &&
+        typeof content.result === "string" &&
+        content.result.trim()
+      ) {
+        images.push({
+          type: "image_url",
+          image_url: {
+            url: toDataUrl(
+              content.result.trim(),
+              content.mime_type ?? content.mimeType ?? null
+            ),
+          },
+        });
+      }
+    }
+  }
+
+  return images;
+};
+
+export const extractToolCallsFromResponseOutput = (
+  response: any
+): AssistantToolCall[] => {
+  const calls: AssistantToolCall[] = [];
+  for (const item of response?.output ?? []) {
+    if (item?.type !== "function_call") continue;
+    if (!item.call_id || !item.name) continue;
+    calls.push({
+      id: item.call_id,
+      type: "function",
+      function: {
+        name: item.name,
+        arguments:
+          typeof item.arguments === "string"
+            ? item.arguments
+            : JSON.stringify(item.arguments ?? {}),
+      },
+    });
+  }
+  return calls;
+};