@chatluna/v1-shared-adapter 1.0.31 → 1.0.33

package/lib/index.mjs

@@ -20,7 +20,7 @@ function parseOpenAIModelNameWithReasoningEffort(modelName) {
   let model = modelName;
   let reasoningEffort;
   const explicitMatch = model.match(
-    /-(none|minimal|low|medium|high|xhigh|tiny)-thinking$/
+    /-(none|minimal|low|medium|high|max|xhigh|tiny)-thinking$/
   );
   if (explicitMatch?.[1]) {
     const level = explicitMatch[1];
@@ -58,6 +58,10 @@ function isNonLLMModel(modelName) {
   );
 }
 __name(isNonLLMModel, "isNonLLMModel");
+function isImageGenerationModel(modelName) {
+  return isNonLLMModel(modelName) && ["dall-e", "image"].some((keyword) => modelName.includes(keyword));
+}
+__name(isImageGenerationModel, "isImageGenerationModel");
 function getModelMaxContextSize(info) {
   const maxTokens = info.maxTokens;
   if (maxTokens != null) {
@@ -76,6 +80,7 @@ function getModelMaxContextSize(info) {
     "gemini-2.0-pro": 2097152,
     "gemini-2.5": 2097152,
     "gemini-3.0-pro": 1097152,
+    "gemini-3.1-pro": 1097152,
     "gemini-2.0": 2097152,
     deepseek: 128e3,
     "llama3.1": 128e3,
@@ -92,7 +97,7 @@ function getModelMaxContextSize(info) {
       return modelMaxContextSizeTable[key];
     }
   }
-  return getModelContextSize("o1-mini");
+  return 2e5;
 }
 __name(getModelMaxContextSize, "getModelMaxContextSize");
 function createGlobMatcher(pattern) {
@@ -111,6 +116,7 @@ var imageModelMatchers = [
   "gemini",
   "qwen-vl",
   "omni",
+  "gemma",
   "qwen*-omni",
   "qwen-omni",
   "qwen*-vl",
@@ -125,7 +131,8 @@ var imageModelMatchers = [
   "glm-*v",
   "kimi-k2.5",
   "step3",
-  "grok-4"
+  "grok-4",
+  "mimo-v2.5*"
 ].map((pattern) => createGlobMatcher(pattern));
 function supportImageInput(modelName) {
   const lowerModel = normalizeOpenAIModelName(modelName).toLowerCase();
@@ -160,11 +167,13 @@ import { isZodSchemaV3 } from "@langchain/core/utils/types";
 function createUsageMetadata(data) {
   const inputTokenDetails = {
     ...data.inputAudioTokens != null ? { audio: data.inputAudioTokens } : {},
+    ...data.inputImageTokens != null ? { image: data.inputImageTokens } : {},
     ...data.cacheReadTokens != null ? { cache_read: data.cacheReadTokens } : {},
     ...data.cacheCreationTokens != null ? { cache_creation: data.cacheCreationTokens } : {}
   };
   const outputTokenDetails = {
     ...data.outputAudioTokens != null ? { audio: data.outputAudioTokens } : {},
+    ...data.outputImageTokens != null ? { image: data.outputImageTokens } : {},
     ...data.reasoningTokens != null ? { reasoning: data.reasoningTokens } : {}
   };
   return {
@@ -188,6 +197,144 @@ function openAIUsageToUsageMetadata(usage) {
   });
 }
 __name(openAIUsageToUsageMetadata, "openAIUsageToUsageMetadata");
+function openAIResponseUsageToUsageMetadata(usage) {
+  return createUsageMetadata({
+    inputTokens: usage.input_tokens,
+    outputTokens: usage.output_tokens,
+    totalTokens: usage.total_tokens,
+    cacheReadTokens: usage.input_tokens_details?.cached_tokens,
+    reasoningTokens: usage.output_tokens_details?.reasoning_tokens
+  });
+}
+__name(openAIResponseUsageToUsageMetadata, "openAIResponseUsageToUsageMetadata");
+async function langchainMessageToResponseInput(messages, plugin, model, supportImageInputType) {
+  const chatMessages = await langchainMessageToOpenAIMessage(
+    messages,
+    plugin,
+    model,
+    supportImageInputType
+  );
+  const result = [];
+  for (const msg of chatMessages) {
+    if (msg.role === "tool") {
+      result.push({
+        type: "function_call_output",
+        call_id: msg.tool_call_id,
+        output: responseInputContent(msg.content)
+      });
+      continue;
+    }
+    if (msg.role === "function") {
+      result.push({
+        type: "message",
+        role: "user",
+        content: responseInputContent(msg.content)
+      });
+      continue;
+    }
+    if (msg.content != null && msg.content !== "") {
+      result.push({
+        type: "message",
+        role: msg.role === "system" || msg.role === "assistant" || msg.role === "user" ? msg.role : "user",
+        content: responseInputContent(msg.content)
+      });
+    }
+    if (msg.role !== "assistant" || !Array.isArray(msg.tool_calls)) {
+      continue;
+    }
+    result.push(
+      ...msg.tool_calls.map((toolCall) => ({
+        type: "function_call",
+        call_id: toolCall.id,
+        name: toolCall.function.name,
+        arguments: toolCall.function.arguments,
+        status: "completed"
+      }))
+    );
+  }
+  return result;
+}
+__name(langchainMessageToResponseInput, "langchainMessageToResponseInput");
+function responseInputContent(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.map((part) => {
+    if (part.type === "text") {
+      const text = part.text;
+      return {
+        type: "input_text",
+        text
+      };
+    }
+    if (part.type === "image_url") {
+      const raw = part.image_url;
+      const imageUrl = typeof raw === "string" ? raw : raw.url;
+      const detail = typeof raw === "string" ? void 0 : raw.detail;
+      return {
+        type: "input_image",
+        image_url: imageUrl,
+        detail: detail ?? "auto"
+      };
+    }
+    if (part.type === "file_url") {
+      const raw = part["file_url"];
+      return {
+        type: "input_file",
+        file_url: typeof raw === "string" ? raw : raw.url,
+        filename: typeof raw === "string" ? void 0 : raw.filename
+      };
+    }
+    return void 0;
+  }).filter((part) => part != null);
+}
+__name(responseInputContent, "responseInputContent");
+function formatToolsToResponseTools(tools, includeGoogleSearch, builtinTools = []) {
+  const result = (formatToolsToOpenAITools(tools, includeGoogleSearch) ?? []).map((tool) => {
+    if (tool.function.name === "googleSearch") {
+      return {
+        type: "web_search"
+      };
+    }
+    return {
+      type: "function",
+      name: tool.function.name,
+      description: tool.function.description,
+      parameters: tool.function.parameters
+    };
+  });
+  for (const tool of builtinTools) {
+    if (result.some((item) => item.type === tool.type)) continue;
+    result.push(tool);
+  }
+  return result.length ? result : void 0;
+}
+__name(formatToolsToResponseTools, "formatToolsToResponseTools");
+function responseOutputText(response) {
+  if ((response.output_text?.length ?? 0) > 0) return response.output_text;
+  return (response.output ?? []).flatMap((item) => {
+    if (item.type !== "message") return [];
+    return (item.content ?? []).map(
+      (part) => {
+        if (part.type === "output_text") return part.text;
+        if (part.type === "refusal") return part.refusal;
+        return "";
+      }
+    );
+  }).join("");
+}
+__name(responseOutputText, "responseOutputText");
+function responseOutputToolCalls(response) {
+  return (response.output ?? []).filter(
+    (item) => item.type === "function_call"
+  );
+}
+__name(responseOutputToolCalls, "responseOutputToolCalls");
+function responseOutputImageItems(response) {
+  return (response.output ?? []).filter((item) => item.type === "image_generation_call" && item.result).map(
+    (item) => item
+  );
+}
+__name(responseOutputImageItems, "responseOutputImageItems");
 async function langchainMessageToOpenAIMessage(messages, plugin, model, supportImageInputType, removeSystemMessage) {
   const result = [];
   const normalizedModel = model ? normalizeOpenAIModelName(model) : model;
@@ -675,6 +822,37 @@ async function buildChatCompletionParams(params, plugin, enableGoogleSearch, sup
   return deepAssign({}, base, params.overrideRequestParams ?? {});
 }
 __name(buildChatCompletionParams, "buildChatCompletionParams");
+async function buildResponseParams(params, plugin, opts = {}, supportImageInput2) {
+  const parsedModel = parseOpenAIModelNameWithReasoningEffort(params.model);
+  const normalizedModel = parsedModel.model;
+  const base = {
+    model: normalizedModel,
+    input: await langchainMessageToResponseInput(
+      params.input,
+      plugin,
+      normalizedModel,
+      supportImageInput2
+    ),
+    tools: opts.googleSearch || (opts.builtinTools?.length ?? 0) > 0 || params.tools != null ? formatToolsToResponseTools(
+      params.tools ?? [],
+      opts.googleSearch ?? false,
+      opts.builtinTools
+    ) : void 0,
+    max_output_tokens: normalizedModel.includes("vision") ? void 0 : params.maxTokens,
+    temperature: params.temperature === 0 ? void 0 : params.temperature,
+    top_p: params.topP,
+    prompt_cache_key: params.id,
+    reasoning: parsedModel.reasoningEffort == null || parsedModel.reasoningEffort === "none" ? void 0 : { effort: parsedModel.reasoningEffort },
+    stream: true,
+    stream_options: {
+      include_obfuscation: false
+    },
+    store: false,
+    parallel_tool_calls: true
+  };
+  return deepAssign({}, base, params.overrideRequestParams ?? {});
+}
+__name(buildResponseParams, "buildResponseParams");
 async function* processStreamResponse(requestContext, iterator) {
   let defaultRole = "assistant";
   let errorCount = 0;
@@ -844,6 +1022,190 @@ async function processResponse(requestContext, response) {
   }
 }
 __name(processResponse, "processResponse");
+async function responseToChatGeneration(response, imageProvider) {
+  if (response.error) {
+    throw new ChatLunaError(
+      ChatLunaErrorCode.API_REQUEST_FAILED,
+      new Error(response.error.message ?? JSON.stringify(response.error))
+    );
+  }
+  const text = responseOutputText(response);
+  const toolCalls = responseOutputToolCalls(response);
+  const images = imageProvider ? await Promise.all(
+    responseOutputImageItems(response).map(
+      (item) => imageProvider(item)
+    )
+  ) : [];
+  const usageMetadata = response.usage ? openAIResponseUsageToUsageMetadata(response.usage) : void 0;
+  const message = new AIMessageChunk2({
+    content: images.length > 0 ? [
+      ...text.length > 0 ? [{ type: "text", text }] : [],
+      ...images.map((image) => ({
+        type: "image_url",
+        image_url: image
+      }))
+    ] : text,
+    tool_call_chunks: toolCalls.map((call, index) => ({
+      name: call.name,
+      args: call.arguments,
+      id: call.call_id,
+      index
+    })),
+    usage_metadata: usageMetadata,
+    additional_kwargs: {
+      conversation: response.conversation
+    }
+  });
+  return new ChatGenerationChunk({
+    generationInfo: usageMetadata == null ? void 0 : {
+      usage_metadata: usageMetadata
+    },
+    message,
+    text
+  });
+}
+__name(responseToChatGeneration, "responseToChatGeneration");
+async function processResponseApiResponse(response, imageProvider) {
+  if (response.status !== 200) {
+    throw new ChatLunaError(
+      ChatLunaErrorCode.API_REQUEST_FAILED,
+      new Error(
+        "Error when calling responses, Status: " + response.status + " " + response.statusText + ", Response: " + await response.text()
+      )
+    );
+  }
+  const responseText = await response.text();
+  try {
+    return await responseToChatGeneration(
+      JSON.parse(responseText),
+      imageProvider
+    );
+  } catch (e) {
+    if (e instanceof ChatLunaError) throw e;
+    throw new ChatLunaError(
+      ChatLunaErrorCode.API_REQUEST_FAILED,
+      new Error(
+        "Error when calling responses, Error: " + e + ", Response: " + responseText
+      )
+    );
+  }
+}
+__name(processResponseApiResponse, "processResponseApiResponse");
+async function* processResponseApiStream(requestContext, iterator, imageProvider) {
+  const args = /* @__PURE__ */ new Map();
+  const calls = /* @__PURE__ */ new Map();
+  let errorCount = 0;
+  let sentConversation = false;
+  for await (const event of iterator) {
+    const chunk = event.data;
+    if (chunk === "[DONE]") break;
+    if (chunk === "" || chunk == null || chunk === "undefined") continue;
+    try {
+      const data = JSON.parse(chunk);
+      if (data.type === "response.output_text.delta" && data.delta) {
+        yield new ChatGenerationChunk({
+          message: new AIMessageChunk2(data.delta),
+          text: data.delta
+        });
+        continue;
+      }
+      if (data.type === "response.output_item.added" && data.item?.type === "function_call") {
+        const item = data.item;
+        calls.set(data.output_index ?? calls.size, {
+          name: item.name,
+          callId: item.call_id,
+          itemId: item.id
+        });
+        continue;
+      }
+      if (data.type === "response.function_call_arguments.delta") {
+        const index = data.output_index ?? 0;
+        args.set(index, (args.get(index) ?? "") + (data.delta ?? ""));
+        continue;
+      }
+      if (data.type === "response.function_call_arguments.done") {
+        const index = data.output_index ?? 0;
+        const call = calls.get(index);
+        yield new ChatGenerationChunk({
+          message: new AIMessageChunk2({
+            content: "",
+            tool_call_chunks: [
+              {
+                name: data.name ?? call?.name,
+                args: data.arguments ?? args.get(index) ?? "",
+                id: call?.callId ?? data.item_id,
+                index
+              }
+            ]
+          }),
+          text: ""
+        });
+        continue;
+      }
+      if (data.type === "response.completed" && data.response) {
+        const usageMetadata = data.response.usage ? openAIResponseUsageToUsageMetadata(data.response.usage) : void 0;
+        const images = imageProvider ? await Promise.all(
+          responseOutputImageItems(data.response).map(
+            (item) => imageProvider(item)
+          )
+        ) : [];
+        if (images.length > 0) {
+          yield new ChatGenerationChunk({
+            message: new AIMessageChunk2({
+              content: images.map((image) => ({
+                type: "image_url",
+                image_url: image
+              }))
+            }),
+            text: ""
+          });
+        }
+        if (!sentConversation) {
+          sentConversation = true;
+          yield new ChatGenerationChunk({
+            message: new AIMessageChunk2({
+              content: "",
+              additional_kwargs: {
+                conversation: data.response.conversation
+              }
+            }),
+            text: ""
+          });
+        }
+        if (usageMetadata) {
+          yield new ChatGenerationChunk({
+            generationInfo: {
+              usage_metadata: usageMetadata
+            },
+            message: new AIMessageChunk2({
+              content: "",
+              usage_metadata: usageMetadata
+            }),
+            text: ""
+          });
+        }
+        continue;
+      }
+      if (data.type === "response.failed" || data.type === "response.incomplete" || data.type === "response.error") {
+        throw new ChatLunaError(
+          ChatLunaErrorCode.API_REQUEST_FAILED,
+          new Error(chunk)
+        );
+      }
+    } catch (e) {
+      if (e instanceof ChatLunaError) throw e;
+      if (errorCount > 5) {
+        requestContext.modelRequester.logger.error(
+          "error with responses chunk",
+          chunk
+        );
+        throw new ChatLunaError(ChatLunaErrorCode.API_REQUEST_FAILED, e);
+      }
+      errorCount++;
+    }
+  }
+}
+__name(processResponseApiStream, "processResponseApiStream");
 async function* completionStream(requestContext, params, completionUrl = "chat/completions", enableGoogleSearch, supportImageInput2) {
   const { modelRequester } = requestContext;
   const chatCompletionParams = await buildChatCompletionParams(
@@ -912,6 +1274,64 @@ async function completion(requestContext, params, completionUrl = "chat/completi
   }
 }
 __name(completion, "completion");
+async function* responseApiCompletionStream(requestContext, params, opts = {}, supportImageInput2, imageProvider) {
+  const { modelRequester } = requestContext;
+  const request = await buildResponseParams(
+    params,
+    requestContext.plugin,
+    opts,
+    supportImageInput2 ?? true
+  );
+  try {
+    const response = await modelRequester.post("responses", request, {
+      signal: params.signal
+    });
+    yield* processResponseApiStream(
+      requestContext,
+      sseIterable(response),
+      imageProvider
+    );
+  } catch (e) {
+    if (requestContext.ctx.chatluna.currentConfig.isLog) {
+      await trackLogToLocal(
+        "Request",
+        JSON.stringify(request),
+        requestContext.ctx.logger("")
+      );
+    }
+    if (e instanceof ChatLunaError) throw e;
+    throw new ChatLunaError(ChatLunaErrorCode.API_REQUEST_FAILED, e);
+  }
+}
+__name(responseApiCompletionStream, "responseApiCompletionStream");
+async function responseApiCompletion(requestContext, params, opts = {}, supportImageInput2, imageProvider) {
+  const { modelRequester } = requestContext;
+  const request = await buildResponseParams(
+    params,
+    requestContext.plugin,
+    opts,
+    supportImageInput2 ?? true
+  );
+  delete request.stream;
+  delete request.stream_options;
+  try {
+    const response = await modelRequester.post("responses", request, {
+      signal: params.signal
+    });
+    return await processResponseApiResponse(response, imageProvider);
+  } catch (e) {
+    if (requestContext.ctx.chatluna.currentConfig.isLog) {
+      await trackLogToLocal(
+        "Request",
+        JSON.stringify(request),
+        requestContext.ctx.logger("")
+      );
+    }
+    if (e instanceof ChatLunaError) throw e;
+    throw new ChatLunaError(ChatLunaErrorCode.API_REQUEST_FAILED, e);
+  }
+}
+__name(responseApiCompletion, "responseApiCompletion");
 async function createEmbeddings(requestContext, params, embeddingUrl = "embeddings") {
   const { modelRequester } = requestContext;
   let data;
@@ -988,6 +1408,7 @@ function createRequestContext(ctx, config, pluginConfig, plugin, modelRequester)
 __name(createRequestContext, "createRequestContext");
 export {
   buildChatCompletionParams,
+  buildResponseParams,
   completion,
   completionStream,
   convertDeltaToMessageChunk,
@@ -1000,20 +1421,33 @@ export {
   fetchImageUrl,
   formatToolToOpenAITool,
   formatToolsToOpenAITools,
+  formatToolsToResponseTools,
   getModelMaxContextSize,
   getModels,
   isEmbeddingModel,
+  isImageGenerationModel,
   isNonLLMModel,
   langchainMessageToOpenAIMessage,
+  langchainMessageToResponseInput,
   messageTypeToOpenAIRole,
   normalizeOpenAIModelName,
+  openAIResponseUsageToUsageMetadata,
   openAIUsageToUsageMetadata,
   parseOpenAIModelNameWithReasoningEffort,
   processInterleavedThinkMessages,
   processResponse,
+  processResponseApiResponse,
+  processResponseApiStream,
   processStreamResponse,
   reasoningEffortModelSuffixes,
   removeAdditionalProperties,
+  responseApiCompletion,
+  responseApiCompletionStream,
+  responseInputContent,
+  responseOutputImageItems,
+  responseOutputText,
+  responseOutputToolCalls,
+  responseToChatGeneration,
   supportImageInput,
   transformSystemMessages
 };

package/lib/requester.d.ts

@@ -2,6 +2,7 @@ import { ChatGenerationChunk } from '@langchain/core/outputs';
 import { EmbeddingsRequestParams, ModelRequester, ModelRequestParams } from 'koishi-plugin-chatluna/llm-core/platform/api';
 import { ClientConfig } from 'koishi-plugin-chatluna/llm-core/platform/config';
 import { SSEEvent } from 'koishi-plugin-chatluna/utils/sse';
+import { type ResponseBuiltinTool, ResponseObject, ResponseOutputItem } from './types';
 import { ChatLunaPlugin } from 'koishi-plugin-chatluna/services/chat';
 import { Context } from 'koishi';
 import { Response } from 'undici/types/fetch';
@@ -13,6 +14,13 @@ interface RequestContext<T extends ClientConfig = ClientConfig, R extends ChatLu
     plugin: ChatLunaPlugin;
     modelRequester: ModelRequester<T, R>;
 }
+export type ResponseImageProvider = (item: Extract<ResponseOutputItem, {
+    type: 'image_generation_call';
+}>) => Promise<string>;
+export interface ResponseToolOptions {
+    googleSearch?: boolean;
+    builtinTools?: ResponseBuiltinTool[];
+}
 export declare function buildChatCompletionParams(params: ModelRequestParams, plugin: ChatLunaPlugin, enableGoogleSearch: boolean, supportImageInput?: boolean): Promise<{
     model: string;
     messages: import("./types").ChatCompletionResponseMessage[];
@@ -37,10 +45,33 @@ export declare function buildChatCompletionParams(params: ModelRequestParams, pl
         include_usage: boolean;
     };
 } & Record<string, any>>;
+export declare function buildResponseParams(params: ModelRequestParams, plugin: ChatLunaPlugin, opts?: ResponseToolOptions, supportImageInput?: boolean): Promise<{
+    model: string;
+    input: import("./types").ResponseInputItem[];
+    tools: import("./types").ResponseTool[];
+    max_output_tokens: number;
+    temperature: number;
+    top_p: number;
+    prompt_cache_key: string;
+    reasoning: {
+        effort: "minimal" | "low" | "medium" | "high" | "max" | "xhigh";
+    };
+    stream: boolean;
+    stream_options: {
+        include_obfuscation: boolean;
+    };
+    store: boolean;
+    parallel_tool_calls: boolean;
+} & Record<string, any>>;
 export declare function processStreamResponse<T extends ClientConfig, R extends ChatLunaPlugin.Config>(requestContext: RequestContext<T, R>, iterator: AsyncGenerator<SSEEvent, string, unknown>): AsyncGenerator<ChatGenerationChunk, void, unknown>;
 export declare function processResponse<T extends ClientConfig, R extends ChatLunaPlugin.Config>(requestContext: RequestContext<T, R>, response: Response): Promise<ChatGenerationChunk>;
+export declare function responseToChatGeneration(response: ResponseObject, imageProvider?: ResponseImageProvider): Promise<ChatGenerationChunk>;
+export declare function processResponseApiResponse(response: Response, imageProvider?: ResponseImageProvider): Promise<ChatGenerationChunk>;
+export declare function processResponseApiStream<T extends ClientConfig, R extends ChatLunaPlugin.Config>(requestContext: RequestContext<T, R>, iterator: AsyncGenerator<SSEEvent, string, unknown>, imageProvider?: ResponseImageProvider): AsyncGenerator<ChatGenerationChunk, void, unknown>;
 export declare function completionStream<T extends ClientConfig, R extends ChatLunaPlugin.Config>(requestContext: RequestContext<T, R>, params: ModelRequestParams, completionUrl?: string, enableGoogleSearch?: boolean, supportImageInput?: boolean): AsyncGenerator<ChatGenerationChunk>;
 export declare function completion<T extends ClientConfig, R extends ChatLunaPlugin.Config>(requestContext: RequestContext<T, R>, params: ModelRequestParams, completionUrl?: string, enableGoogleSearch?: boolean, supportImageInput?: boolean): Promise<ChatGenerationChunk>;
+export declare function responseApiCompletionStream<T extends ClientConfig, R extends ChatLunaPlugin.Config>(requestContext: RequestContext<T, R>, params: ModelRequestParams, opts?: ResponseToolOptions, supportImageInput?: boolean, imageProvider?: ResponseImageProvider): AsyncGenerator<ChatGenerationChunk>;
+export declare function responseApiCompletion<T extends ClientConfig, R extends ChatLunaPlugin.Config>(requestContext: RequestContext<T, R>, params: ModelRequestParams, opts?: ResponseToolOptions, supportImageInput?: boolean, imageProvider?: ResponseImageProvider): Promise<ChatGenerationChunk>;
 export declare function createEmbeddings<T extends ClientConfig, R extends ChatLunaPlugin.Config>(requestContext: RequestContext<T, R>, params: EmbeddingsRequestParams, embeddingUrl?: string): Promise<number[] | number[][]>;
 export declare function getModels<T extends ClientConfig, R extends ChatLunaPlugin.Config>(requestContext: RequestContext<T, R>, config?: RunnableConfig): Promise<string[]>;
 export declare function createRequestContext<T extends ClientConfig, R extends ChatLunaPlugin.Config>(ctx: Context, config: T, pluginConfig: R, plugin: ChatLunaPlugin, modelRequester: ModelRequester<T, R>): RequestContext<T, R>;