@chatluna/v1-shared-adapter 1.0.32 → 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) {
@@ -178,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();
@@ -229,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;
@@ -716,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;
@@ -885,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(
@@ -953,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;
@@ -1030,6 +1460,7 @@ __name(createRequestContext, "createRequestContext");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   buildChatCompletionParams,
+  buildResponseParams,
   completion,
   completionStream,
   convertDeltaToMessageChunk,
@@ -1042,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
 });

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) {
@@ -127,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();
@@ -192,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;
@@ -679,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;
@@ -848,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(
@@ -916,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;
@@ -992,6 +1408,7 @@ function createRequestContext(ctx, config, pluginConfig, plugin, modelRequester)
 __name(createRequestContext, "createRequestContext");
 export {
   buildChatCompletionParams,
+  buildResponseParams,
   completion,
   completionStream,
   convertDeltaToMessageChunk,
@@ -1004,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>;

package/lib/types.d.ts

@@ -34,6 +34,175 @@ export interface ChatCompletionUsage {
     prompt_tokens_details?: ChatCompletionPromptTokensDetails;
     completion_tokens_details?: ChatCompletionCompletionTokensDetails;
 }
+export interface ResponseUsage {
+    input_tokens: number;
+    output_tokens: number;
+    total_tokens: number;
+    input_tokens_details?: {
+        cached_tokens?: number;
+    };
+    output_tokens_details?: {
+        reasoning_tokens?: number;
+    };
+}
+export type ResponseInputContent = {
+    type: 'input_text';
+    text: string;
+} | {
+    type: 'input_image';
+    image_url: string;
+    detail?: 'low' | 'high' | 'auto' | 'original';
+} | {
+    type: 'input_file';
+    file_url?: string;
+    file_data?: string;
+    file_id?: string;
+    filename?: string;
+};
+export type ResponseInputItem = {
+    type: 'message';
+    role: 'system' | 'developer' | 'user' | 'assistant';
+    content: string | ResponseInputContent[];
+} | {
+    type: 'function_call';
+    call_id: string;
+    name: string;
+    arguments: string;
+    status?: 'completed' | 'in_progress' | 'incomplete';
+} | {
+    type: 'function_call_output';
+    call_id: string;
+    output: string | ResponseInputContent[];
+};
+export type ResponseBuiltinToolName = 'web_search' | 'web_search_preview' | 'image_generation' | 'code_interpreter' | 'file_search';
+export type ResponseBuiltinTool = {
+    type: 'web_search' | 'web_search_2025_08_26';
+    filters?: {
+        allowed_domains?: string[] | null;
+    } | null;
+    search_context_size?: 'low' | 'medium' | 'high';
+    user_location?: {
+        city?: string | null;
+        country?: string | null;
+        region?: string | null;
+        timezone?: string | null;
+        type?: 'approximate';
+    } | null;
+} | {
+    type: 'web_search_preview' | 'web_search_preview_2025_03_11';
+    search_content_types?: ('text' | 'image')[];
+    search_context_size?: 'low' | 'medium' | 'high';
+    user_location?: {
+        type: 'approximate';
+        city?: string | null;
+        country?: string | null;
+        region?: string | null;
+        timezone?: string | null;
+    } | null;
+} | {
+    type: 'image_generation';
+    action?: 'generate' | 'edit' | 'auto';
+    background?: 'transparent' | 'opaque' | 'auto';
+    input_fidelity?: 'high' | 'low' | null;
+    input_image_mask?: {
+        file_id?: string;
+        image_url?: string;
+    };
+    model?: string;
+    moderation?: 'auto' | 'low';
+    output_compression?: number;
+    output_format?: 'png' | 'webp' | 'jpeg';
+    partial_images?: number;
+    quality?: 'low' | 'medium' | 'high' | 'auto';
+    size?: '1024x1024' | '1024x1536' | '1536x1024' | 'auto';
+} | {
+    type: 'code_interpreter';
+    container: string | {
+        type: 'auto';
+        file_ids?: string[];
+        memory_limit?: '1g' | '4g' | '16g' | '64g' | null;
+    };
+} | {
+    type: 'file_search';
+    vector_store_ids: string[];
+    filters?: Record<string, unknown> | null;
+    max_num_results?: number;
+    ranking_options?: {
+        ranker?: 'auto' | 'default-2024-11-15';
+        score_threshold?: number;
+        hybrid_search?: {
+            embedding_weight: number;
+            text_weight: number;
+        };
+    };
+};
+export type ResponseTool = {
+    type: 'function';
+    name: string;
+    description?: string;
+    parameters?: {
+        [key: string]: any;
+    };
+    strict?: boolean;
+} | ResponseBuiltinTool;
+export interface ResponseObject {
+    id: string;
+    object: 'response';
+    output_text?: string;
+    output?: ResponseOutputItem[];
+    usage?: ResponseUsage;
+    error?: {
+        message?: string;
+    } | null;
+    conversation?: {
+        id: string;
+    } | null;
+}
+export type ResponseOutputItem = {
+    type: 'message';
+    role?: string;
+    content?: ResponseOutputContent[];
+} | {
+    type: 'function_call';
+    id?: string;
+    call_id: string;
+    name: string;
+    arguments: string;
+    status?: string;
+} | {
+    type: 'image_generation_call';
+    id?: string;
+    result?: string | null;
+    output_format?: 'png' | 'jpeg' | 'webp';
+    status?: string;
+} | {
+    type: string;
+    [key: string]: unknown;
+};
+export type ResponseOutputContent = {
+    type: 'output_text';
+    text: string;
+} | {
+    type: 'refusal';
+    refusal: string;
+} | {
+    type: string;
+    [key: string]: unknown;
+};
+export interface ResponseStreamEvent {
+    type: string;
+    sequence_number?: number;
+    item_id?: string;
+    output_index?: number;
+    content_index?: number;
+    delta?: string;
+    text?: string;
+    name?: string;
+    arguments?: string;
+    item?: ResponseOutputItem;
+    response?: ResponseObject;
+    partial_image_b64?: string;
+}
 export interface ChatCompletionTextPart {
     type: 'text';
     text: string;

package/lib/utils.d.ts

@@ -1,7 +1,7 @@
 import { AIMessageChunk, BaseMessage, ChatMessageChunk, FunctionMessageChunk, HumanMessageChunk, MessageContentComplex, MessageContentImageUrl, MessageType, SystemMessageChunk, ToolMessageChunk, type UsageMetadata } from '@langchain/core/messages';
 import { StructuredTool } from '@langchain/core/tools';
 import { JsonSchema7Type } from 'zod-to-json-schema';
-import { ChatCompletionResponseMessage, ChatCompletionResponseMessageRoleEnum, ChatCompletionTool, ChatCompletionUsage } from './types';
+import { ChatCompletionResponseMessage, ChatCompletionResponseMessageRoleEnum, ChatCompletionTool, ChatCompletionUsage, type ResponseBuiltinTool, ResponseInputContent, ResponseInputItem, ResponseObject, ResponseTool, ResponseUsage } from './types';
 import { ChatLunaPlugin } from 'koishi-plugin-chatluna/services/chat';
 export declare function createUsageMetadata(data: {
     inputTokens: number;
@@ -16,6 +16,26 @@ export declare function createUsageMetadata(data: {
     reasoningTokens?: number;
 }): UsageMetadata;
 export declare function openAIUsageToUsageMetadata(usage: ChatCompletionUsage): UsageMetadata;
+export declare function openAIResponseUsageToUsageMetadata(usage: ResponseUsage): UsageMetadata;
+export declare function langchainMessageToResponseInput(messages: BaseMessage[], plugin: ChatLunaPlugin, model?: string, supportImageInputType?: boolean): Promise<ResponseInputItem[]>;
+export declare function responseInputContent(content: ChatCompletionResponseMessage['content']): string | ResponseInputContent[];
+export declare function formatToolsToResponseTools(tools: StructuredTool[], includeGoogleSearch: boolean, builtinTools?: ResponseBuiltinTool[]): ResponseTool[] | undefined;
+export declare function responseOutputText(response: ResponseObject): string;
+export declare function responseOutputToolCalls(response: ResponseObject): {
+    type: "function_call";
+    id?: string;
+    call_id: string;
+    name: string;
+    arguments: string;
+    status?: string;
+}[];
+export declare function responseOutputImageItems(response: ResponseObject): {
+    type: "image_generation_call";
+    id?: string;
+    result?: string | null;
+    output_format?: "png" | "jpeg" | "webp";
+    status?: string;
+}[];
 export declare function langchainMessageToOpenAIMessage(messages: BaseMessage[], plugin: ChatLunaPlugin, model?: string, supportImageInputType?: boolean, removeSystemMessage?: boolean): Promise<ChatCompletionResponseMessage[]>;
 export declare function processInterleavedThinkMessages(convertedMessages: ChatCompletionResponseMessage[], originalMessages: BaseMessage[]): ChatCompletionResponseMessage[];
 export declare function transformSystemMessages(messages: ChatCompletionResponseMessage[]): ChatCompletionResponseMessage[];
@@ -51,6 +71,6 @@ export declare function messageTypeToOpenAIRole(type: MessageType): ChatCompleti
 export declare function formatToolsToOpenAITools(tools: StructuredTool[], includeGoogleSearch: boolean): ChatCompletionTool[];
 export declare function formatToolToOpenAITool(tool: StructuredTool): ChatCompletionTool;
 export declare function removeAdditionalProperties(schema: JsonSchema7Type): JsonSchema7Type;
-export declare function convertMessageToMessageChunk(message: ChatCompletionResponseMessage): AIMessageChunk | HumanMessageChunk | SystemMessageChunk | FunctionMessageChunk | ToolMessageChunk | ChatMessageChunk;
-export declare function convertDeltaToMessageChunk(delta: Record<string, any>, defaultRole?: ChatCompletionResponseMessageRoleEnum): AIMessageChunk | HumanMessageChunk | SystemMessageChunk | FunctionMessageChunk | ToolMessageChunk | ChatMessageChunk;
+export declare function convertMessageToMessageChunk(message: ChatCompletionResponseMessage): HumanMessageChunk | AIMessageChunk | SystemMessageChunk | FunctionMessageChunk | ToolMessageChunk | ChatMessageChunk;
+export declare function convertDeltaToMessageChunk(delta: Record<string, any>, defaultRole?: ChatCompletionResponseMessageRoleEnum): HumanMessageChunk | AIMessageChunk | SystemMessageChunk | FunctionMessageChunk | ToolMessageChunk | ChatMessageChunk;
 export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@chatluna/v1-shared-adapter",
   "description": "chatluna shared adapter",
-  "version": "1.0.32",
+  "version": "1.0.33",
   "main": "lib/index.cjs",
   "module": "lib/index.mjs",
   "typings": "lib/index.d.ts",
@@ -70,6 +70,6 @@
   },
   "peerDependencies": {
     "koishi": "^4.18.9",
-    "koishi-plugin-chatluna": "^1.4.0-alpha.0"
+    "koishi-plugin-chatluna": "^1.4.0-alpha.8"
   }
 }