@chatluna/v1-shared-adapter 1.0.31 → 1.0.33

package/lib/client.d.ts

@@ -1,5 +1,5 @@
 import { ModelInfo } from 'koishi-plugin-chatluna/llm-core/platform/types';
-export type OpenAIReasoningEffort = 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
+export type OpenAIReasoningEffort = 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'max' | 'xhigh';
 export declare const reasoningEffortModelSuffixes: readonly ["non-thinking", "minimal-thinking", "low-thinking", "medium-thinking", "high-thinking", "xhigh-thinking", "thinking"];
 export declare function expandReasoningEffortModelVariants(model: string, suffixes?: readonly string[]): string[];
 export declare function parseOpenAIModelNameWithReasoningEffort(modelName: string): {
@@ -9,5 +9,6 @@ export declare function parseOpenAIModelNameWithReasoningEffort(modelName: strin
 export declare function normalizeOpenAIModelName(modelName: string): string;
 export declare function isEmbeddingModel(modelName: string): boolean;
 export declare function isNonLLMModel(modelName: string): boolean;
+export declare function isImageGenerationModel(modelName: string): boolean;
 export declare function getModelMaxContextSize(info: ModelInfo): number;
 export declare function supportImageInput(modelName: string): boolean;

package/lib/index.cjs

@@ -21,6 +21,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   buildChatCompletionParams: () => buildChatCompletionParams,
+  buildResponseParams: () => buildResponseParams,
   completion: () => completion,
   completionStream: () => completionStream,
   convertDeltaToMessageChunk: () => convertDeltaToMessageChunk,
@@ -33,20 +34,33 @@ __export(index_exports, {
   fetchImageUrl: () => fetchImageUrl,
   formatToolToOpenAITool: () => formatToolToOpenAITool,
   formatToolsToOpenAITools: () => formatToolsToOpenAITools,
+  formatToolsToResponseTools: () => formatToolsToResponseTools,
   getModelMaxContextSize: () => getModelMaxContextSize,
   getModels: () => getModels,
   isEmbeddingModel: () => isEmbeddingModel,
+  isImageGenerationModel: () => isImageGenerationModel,
   isNonLLMModel: () => isNonLLMModel,
   langchainMessageToOpenAIMessage: () => langchainMessageToOpenAIMessage,
+  langchainMessageToResponseInput: () => langchainMessageToResponseInput,
   messageTypeToOpenAIRole: () => messageTypeToOpenAIRole,
   normalizeOpenAIModelName: () => normalizeOpenAIModelName,
+  openAIResponseUsageToUsageMetadata: () => openAIResponseUsageToUsageMetadata,
   openAIUsageToUsageMetadata: () => openAIUsageToUsageMetadata,
   parseOpenAIModelNameWithReasoningEffort: () => parseOpenAIModelNameWithReasoningEffort,
   processInterleavedThinkMessages: () => processInterleavedThinkMessages,
   processResponse: () => processResponse,
+  processResponseApiResponse: () => processResponseApiResponse,
+  processResponseApiStream: () => processResponseApiStream,
   processStreamResponse: () => processStreamResponse,
   reasoningEffortModelSuffixes: () => reasoningEffortModelSuffixes,
   removeAdditionalProperties: () => removeAdditionalProperties,
+  responseApiCompletion: () => responseApiCompletion,
+  responseApiCompletionStream: () => responseApiCompletionStream,
+  responseInputContent: () => responseInputContent,
+  responseOutputImageItems: () => responseOutputImageItems,
+  responseOutputText: () => responseOutputText,
+  responseOutputToolCalls: () => responseOutputToolCalls,
+  responseToChatGeneration: () => responseToChatGeneration,
   supportImageInput: () => supportImageInput,
   transformSystemMessages: () => transformSystemMessages
 });
@@ -71,7 +85,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];
@@ -109,6 +123,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) {
@@ -127,6 +145,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,
@@ -143,7 +162,7 @@ function getModelMaxContextSize(info) {
       return modelMaxContextSizeTable[key];
     }
   }
-  return (0, import_count_tokens.getModelContextSize)("o1-mini");
+  return 2e5;
 }
 __name(getModelMaxContextSize, "getModelMaxContextSize");
 function createGlobMatcher(pattern) {
@@ -162,6 +181,7 @@ var imageModelMatchers = [
   "gemini",
   "qwen-vl",
   "omni",
+  "gemma",
   "qwen*-omni",
   "qwen-omni",
   "qwen*-vl",
@@ -176,7 +196,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();
@@ -197,11 +218,13 @@ var import_types = require("@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 {
@@ -225,6 +248,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;
@@ -712,6 +873,37 @@ async function buildChatCompletionParams(params, plugin, enableGoogleSearch, sup
   return (0, import_object.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 (0, import_object.deepAssign)({}, base, params.overrideRequestParams ?? {});
+}
+__name(buildResponseParams, "buildResponseParams");
 async function* processStreamResponse(requestContext, iterator) {
   let defaultRole = "assistant";
   let errorCount = 0;
@@ -881,6 +1073,190 @@ async function processResponse(requestContext, response) {
   }
 }
 __name(processResponse, "processResponse");
+async function responseToChatGeneration(response, imageProvider) {
+  if (response.error) {
+    throw new import_error.ChatLunaError(
+      import_error.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 import_messages2.AIMessageChunk({
+    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 import_outputs.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 import_error.ChatLunaError(
+      import_error.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 import_error.ChatLunaError) throw e;
+    throw new import_error.ChatLunaError(
+      import_error.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 import_outputs.ChatGenerationChunk({
+          message: new import_messages2.AIMessageChunk(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 import_outputs.ChatGenerationChunk({
+          message: new import_messages2.AIMessageChunk({
+            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 import_outputs.ChatGenerationChunk({
+            message: new import_messages2.AIMessageChunk({
+              content: images.map((image) => ({
+                type: "image_url",
+                image_url: image
+              }))
+            }),
+            text: ""
+          });
+        }
+        if (!sentConversation) {
+          sentConversation = true;
+          yield new import_outputs.ChatGenerationChunk({
+            message: new import_messages2.AIMessageChunk({
+              content: "",
+              additional_kwargs: {
+                conversation: data.response.conversation
+              }
+            }),
+            text: ""
+          });
+        }
+        if (usageMetadata) {
+          yield new import_outputs.ChatGenerationChunk({
+            generationInfo: {
+              usage_metadata: usageMetadata
+            },
+            message: new import_messages2.AIMessageChunk({
+              content: "",
+              usage_metadata: usageMetadata
+            }),
+            text: ""
+          });
+        }
+        continue;
+      }
+      if (data.type === "response.failed" || data.type === "response.incomplete" || data.type === "response.error") {
+        throw new import_error.ChatLunaError(
+          import_error.ChatLunaErrorCode.API_REQUEST_FAILED,
+          new Error(chunk)
+        );
+      }
+    } catch (e) {
+      if (e instanceof import_error.ChatLunaError) throw e;
+      if (errorCount > 5) {
+        requestContext.modelRequester.logger.error(
+          "error with responses chunk",
+          chunk
+        );
+        throw new import_error.ChatLunaError(import_error.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(
@@ -949,6 +1325,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,
+      (0, import_sse.sseIterable)(response),
+      imageProvider
+    );
+  } catch (e) {
+    if (requestContext.ctx.chatluna.currentConfig.isLog) {
+      await (0, import_logger.trackLogToLocal)(
+        "Request",
+        JSON.stringify(request),
+        requestContext.ctx.logger("")
+      );
+    }
+    if (e instanceof import_error.ChatLunaError) throw e;
+    throw new import_error.ChatLunaError(import_error.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 (0, import_logger.trackLogToLocal)(
+        "Request",
+        JSON.stringify(request),
+        requestContext.ctx.logger("")
+      );
+    }
+    if (e instanceof import_error.ChatLunaError) throw e;
+    throw new import_error.ChatLunaError(import_error.ChatLunaErrorCode.API_REQUEST_FAILED, e);
+  }
+}
+__name(responseApiCompletion, "responseApiCompletion");
 async function createEmbeddings(requestContext, params, embeddingUrl = "embeddings") {
   const { modelRequester } = requestContext;
   let data;
@@ -1026,6 +1460,7 @@ __name(createRequestContext, "createRequestContext");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   buildChatCompletionParams,
+  buildResponseParams,
   completion,
   completionStream,
   convertDeltaToMessageChunk,
@@ -1038,20 +1473,33 @@ __name(createRequestContext, "createRequestContext");
   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
 });