koishi-plugin-chatluna-google-gemini-adapter 1.0.0-beta.2 → 1.0.0-beta.20

package/lib/index.cjs

@@ -0,0 +1,653 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Config: () => Config,
+  apply: () => apply,
+  inject: () => inject,
+  logger: () => logger,
+  name: () => name
+});
+module.exports = __toCommonJS(src_exports);
+var import_chat = require("koishi-plugin-chatluna/services/chat");
+var import_koishi = require("koishi");
+
+// src/client.ts
+var import_client = require("koishi-plugin-chatluna/llm-core/platform/client");
+var import_model = require("koishi-plugin-chatluna/llm-core/platform/model");
+var import_types = require("koishi-plugin-chatluna/llm-core/platform/types");
+var import_error2 = require("koishi-plugin-chatluna/utils/error");
+
+// src/requester.ts
+var import_messages2 = require("@langchain/core/messages");
+var import_outputs = require("@langchain/core/outputs");
+var import_json = require("@streamparser/json");
+var import_api = require("koishi-plugin-chatluna/llm-core/platform/api");
+var import_error = require("koishi-plugin-chatluna/utils/error");
+var import_sse = require("koishi-plugin-chatluna/utils/sse");
+var import_stream = require("koishi-plugin-chatluna/utils/stream");
+
+// src/utils.ts
+var import_messages = require("@langchain/core/messages");
+var import_zod_to_json_schema = require("zod-to-json-schema");
+async function langchainMessageToGeminiMessage(messages, model) {
+  const mappedMessage = await Promise.all(
+    messages.map(async (rawMessage) => {
+      const role = messageTypeToGeminiRole(rawMessage._getType());
+      if (role === "function" || rawMessage.additional_kwargs?.function_call != null) {
+        return {
+          role: "function",
+          parts: [
+            {
+              functionResponse: rawMessage.additional_kwargs?.function_call != null ? void 0 : {
+                name: rawMessage.name,
+                response: {
+                  name: rawMessage.name,
+                  content: (() => {
+                    try {
+                      const result3 = JSON.parse(
+                        rawMessage.content
+                      );
+                      if (typeof result3 === "string") {
+                        return {
+                          response: result3
+                        };
+                      } else {
+                        return result3;
+                      }
+                    } catch (e) {
+                      return {
+                        response: rawMessage.content
+                      };
+                    }
+                  })()
+                }
+              },
+              functionCall: rawMessage.additional_kwargs?.function_call != null ? {
+                name: rawMessage.additional_kwargs.function_call.name,
+                args: (() => {
+                  try {
+                    const result3 = JSON.parse(
+                      rawMessage.additional_kwargs.function_call.arguments
+                    );
+                    if (typeof result3 === "string") {
+                      return {
+                        input: result3
+                      };
+                    } else {
+                      return result3;
+                    }
+                  } catch (e) {
+                    return {
+                      input: rawMessage.additional_kwargs.function_call.arguments
+                    };
+                  }
+                })()
+              } : void 0
+            }
+          ]
+        };
+      }
+      const images = rawMessage.additional_kwargs.images;
+      const result2 = {
+        role,
+        parts: [
+          {
+            text: rawMessage.content
+          }
+        ]
+      };
+      if ((model.includes("vision") || model.includes("gemini-1.5")) && images != null) {
+        for (const image of images) {
+          result2.parts.push({
+            inline_data: {
+              // base64 image match type
+              data: image.replace(/^data:image\/\w+;base64,/, ""),
+              mime_type: "image/jpeg"
+            }
+          });
+        }
+      }
+      return result2;
+    })
+  );
+  const result = [];
+  for (let i = 0; i < mappedMessage.length; i++) {
+    const message = mappedMessage[i];
+    if (message.role !== "system") {
+      result.push(message);
+      continue;
+    }
+    result.push({
+      role: "user",
+      parts: message.parts
+    });
+    if (mappedMessage?.[i + 1]?.role === "model") {
+      continue;
+    }
+    if (mappedMessage?.[i + 1]?.role === "user") {
+      result.push({
+        role: "model",
+        parts: [{ text: "Okay, what do I need to do?" }]
+      });
+    }
+  }
+  if (result[result.length - 1].role === "model") {
+    result.push({
+      role: "user",
+      parts: [
+        {
+          text: "Continue what I said to you last message. Follow these instructions."
+        }
+      ]
+    });
+  }
+  if (model.includes("vision")) {
+    const textBuffer = [];
+    const last = result.pop();
+    for (let i = 0; i < result.length; i++) {
+      const message = result[i];
+      const text = message.parts[0].text;
+      textBuffer.push(`${message.role}: ${text}`);
+    }
+    const lastParts = last.parts;
+    let lastImagesParts = lastParts.filter(
+      (part) => part.inline_data?.mime_type === "image/jpeg"
+    );
+    if (lastImagesParts.length < 1) {
+      for (let i = result.length - 1; i >= 0; i--) {
+        const message = result[i];
+        const images = message.parts.filter(
+          (part) => part.inline_data?.mime_type === "image/jpeg"
+        );
+        if (images.length > 0) {
+          lastImagesParts = images;
+          break;
+        }
+      }
+    }
+    ;
+    lastParts.filter(
+      (part) => part.text !== void 0 && part.text !== null
+    ).forEach((part) => {
+      textBuffer.push(`${last.role}: ${part.text}`);
+    });
+    return [
+      {
+        role: "user",
+        parts: [
+          {
+            text: textBuffer.join("\n")
+          },
+          ...lastImagesParts
+        ]
+      }
+    ];
+  }
+  return result;
+}
+__name(langchainMessageToGeminiMessage, "langchainMessageToGeminiMessage");
+function partAsType(part) {
+  return part;
+}
+__name(partAsType, "partAsType");
+function formatToolsToGeminiAITools(tools) {
+  if (tools.length < 1) {
+    return void 0;
+  }
+  return tools.map(formatToolToGeminiAITool);
+}
+__name(formatToolsToGeminiAITools, "formatToolsToGeminiAITools");
+function formatToolToGeminiAITool(tool) {
+  const parameters = (0, import_zod_to_json_schema.zodToJsonSchema)(tool.schema);
+  delete parameters["$schema"];
+  delete parameters["additionalProperties"];
+  return {
+    name: tool.name,
+    description: tool.description,
+    // any?
+    parameters
+  };
+}
+__name(formatToolToGeminiAITool, "formatToolToGeminiAITool");
+function messageTypeToGeminiRole(type) {
+  switch (type) {
+    case "system":
+      return "system";
+    case "ai":
+      return "model";
+    case "human":
+      return "user";
+    case "function":
+      return "function";
+    default:
+      throw new Error(`Unknown message type: ${type}`);
+  }
+}
+__name(messageTypeToGeminiRole, "messageTypeToGeminiRole");
+
+// src/requester.ts
+var GeminiRequester = class extends import_api.ModelRequester {
+  constructor(_config, _plugin) {
+    super();
+    this._config = _config;
+    this._plugin = _plugin;
+  }
+  static {
+    __name(this, "GeminiRequester");
+  }
+  async *completionStream(params) {
+    try {
+      const response = await this._post(
+        `models/${params.model}:streamGenerateContent`,
+        {
+          contents: await langchainMessageToGeminiMessage(
+            params.input,
+            params.model
+          ),
+          safetySettings: [
+            {
+              category: "HARM_CATEGORY_HARASSMENT",
+              threshold: "BLOCK_NONE"
+            },
+            {
+              category: "HARM_CATEGORY_HATE_SPEECH",
+              threshold: "BLOCK_NONE"
+            },
+            {
+              category: "HARM_CATEGORY_SEXUALLY_EXPLICIT",
+              threshold: "BLOCK_NONE"
+            },
+            {
+              category: "HARM_CATEGORY_DANGEROUS_CONTENT",
+              threshold: "BLOCK_NONE"
+            }
+          ],
+          generationConfig: {
+            stopSequences: params.stop,
+            temperature: params.temperature,
+            maxOutputTokens: params.model.includes("vision") ? void 0 : params.maxTokens,
+            topP: params.topP
+          },
+          tools: !params.model.includes("vision") && params.tools != null ? {
+            functionDeclarations: formatToolsToGeminiAITools(params.tools)
+          } : void 0
+        },
+        {
+          signal: params.signal
+        }
+      );
+      let errorCount = 0;
+      const stream = new TransformStream();
+      const iterable = (0, import_stream.readableStreamToAsyncIterable)(
+        stream.readable
+      );
+      const jsonParser = new import_json.JSONParser();
+      const writable = stream.writable.getWriter();
+      jsonParser.onEnd = async () => {
+        await writable.close();
+      };
+      jsonParser.onValue = async ({ value }) => {
+        const transformValue = value;
+        if (transformValue.candidates && transformValue.candidates[0]) {
+          const parts = transformValue.candidates[0]?.content?.parts;
+          if (parts == null || parts.length < 1) {
+            throw new Error(JSON.stringify(value));
+          }
+          for (const part of parts) {
+            await writable.write(part);
+          }
+        }
+      };
+      await (0, import_sse.sse)(
+        response,
+        async (rawData) => {
+          jsonParser.write(rawData);
+          return true;
+        },
+        0
+      );
+      let content = "";
+      let isOldVisionModel = params.model.includes("vision");
+      const functionCall = {
+        name: "",
+        args: "",
+        arguments: ""
+      };
+      for await (const chunk of iterable) {
+        const messagePart = partAsType(chunk);
+        const chatFunctionCallingPart = partAsType(chunk);
+        if (messagePart.text) {
+          if (params.tools != null) {
+            content = messagePart.text;
+          } else {
+            content += messagePart.text;
+          }
+          if (isOldVisionModel && /\s*model:\s*/.test(content)) {
+            isOldVisionModel = false;
+            content = messagePart.text.replace(/\s*model:\s*/, "");
+          }
+        }
+        const deltaFunctionCall = chatFunctionCallingPart.functionCall;
+        if (deltaFunctionCall) {
+          let args = deltaFunctionCall.args?.input ?? deltaFunctionCall.args;
+          try {
+            let parsedArgs = JSON.parse(args);
+            if (typeof parsedArgs !== "string") {
+              args = parsedArgs;
+            }
+            parsedArgs = JSON.parse(args);
+            if (typeof parsedArgs !== "string") {
+              args = parsedArgs;
+            }
+          } catch (e) {
+          }
+          functionCall.args = JSON.stringify(args);
+          functionCall.name = deltaFunctionCall.name;
+          functionCall.arguments = deltaFunctionCall.args;
+        }
+        try {
+          const messageChunk = new import_messages2.AIMessageChunk(content);
+          messageChunk.additional_kwargs = {
+            function_call: functionCall.name.length > 0 ? {
+              name: functionCall.name,
+              arguments: functionCall.args,
+              args: functionCall.arguments
+            } : void 0
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          };
+          messageChunk.content = content;
+          const generationChunk = new import_outputs.ChatGenerationChunk({
+            message: messageChunk,
+            text: messageChunk.content
+          });
+          yield generationChunk;
+          content = messageChunk.content;
+        } catch (e) {
+          if (errorCount > 5) {
+            logger.error("error with chunk", chunk);
+            throw new import_error.ChatLunaError(
+              import_error.ChatLunaErrorCode.API_REQUEST_FAILED,
+              e
+            );
+          } else {
+            errorCount++;
+            continue;
+          }
+        }
+      }
+    } catch (e) {
+      if (e instanceof import_error.ChatLunaError) {
+        throw e;
+      } else {
+        throw new import_error.ChatLunaError(import_error.ChatLunaErrorCode.API_REQUEST_FAILED, e);
+      }
+    }
+  }
+  async embeddings(params) {
+    let data;
+    if (typeof params.input === "string") {
+      params.input = [params.input];
+    }
+    try {
+      const response = await this._post(
+        `models/${params.model}:batchEmbedContents`,
+        {
+          requests: params.input.map((input) => {
+            return {
+              model: `models/${params.model}`,
+              content: {
+                parts: [
+                  {
+                    text: input
+                  }
+                ]
+              }
+            };
+          })
+        }
+      );
+      data = await response.text();
+      data = JSON.parse(data);
+      if (data.embeddings && data.embeddings.length > 0) {
+        return data.embeddings.map((embedding) => {
+          return embedding.values;
+        });
+      }
+      throw new Error(
+        "error when calling gemini embeddings, Result: " + JSON.stringify(data)
+      );
+    } catch (e) {
+      const error = new Error(
+        "error when calling gemini embeddings, Result: " + JSON.stringify(data)
+      );
+      error.stack = e.stack;
+      error.cause = e.cause;
+      logger.debug(e);
+      throw new import_error.ChatLunaError(import_error.ChatLunaErrorCode.API_REQUEST_FAILED, error);
+    }
+  }
+  async getModels() {
+    let data;
+    try {
+      const response = await this._get("models");
+      data = await response.text();
+      data = JSON.parse(data);
+      if (!data.models || !data.models.length) {
+        throw new Error(
+          "error when listing gemini models, Result:" + JSON.stringify(data)
+        );
+      }
+      return data.models.map((model) => model.name).filter(
+        (model) => model.includes("gemini") || model.includes("embedding")
+      );
+    } catch (e) {
+      const error = new Error(
+        "error when listing gemini models, Result: " + JSON.stringify(data)
+      );
+      error.stack = e.stack;
+      error.cause = e.cause;
+      throw error;
+    }
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  _post(url, data, params = {}) {
+    const requestUrl = this._concatUrl(url);
+    for (const key in data) {
+      if (data[key] === void 0) {
+        delete data[key];
+      }
+    }
+    const body = JSON.stringify(data);
+    return this._plugin.fetch(requestUrl, {
+      body,
+      headers: this._buildHeaders(),
+      method: "POST",
+      ...params
+    });
+  }
+  _get(url) {
+    const requestUrl = this._concatUrl(url);
+    return this._plugin.fetch(requestUrl, {
+      method: "GET",
+      headers: this._buildHeaders()
+    });
+  }
+  _concatUrl(url) {
+    const apiEndPoint = this._config.apiEndpoint;
+    if (apiEndPoint.endsWith("/")) {
+      return apiEndPoint + url + `?key=${this._config.apiKey}`;
+    }
+    return apiEndPoint + "/" + url + `?key=${this._config.apiKey}`;
+  }
+  _buildHeaders() {
+    return {
+      /*  Authorization: `Bearer ${this._config.apiKey}`, */
+      "Content-Type": "application/json"
+    };
+  }
+  async init() {
+  }
+  async dispose() {
+  }
+};
+
+// src/client.ts
+var GeminiClient = class extends import_client.PlatformModelAndEmbeddingsClient {
+  constructor(ctx, _config, clientConfig, plugin) {
+    super(ctx, clientConfig);
+    this._config = _config;
+    this._requester = new GeminiRequester(clientConfig, plugin);
+  }
+  static {
+    __name(this, "GeminiClient");
+  }
+  platform = "gemini";
+  _requester;
+  _models;
+  async init() {
+    await this.getModels();
+  }
+  async refreshModels() {
+    try {
+      const rawModels = await this._requester.getModels();
+      if (!rawModels.length) {
+        throw new import_error2.ChatLunaError(
+          import_error2.ChatLunaErrorCode.MODEL_INIT_ERROR,
+          new Error("No model found")
+        );
+      }
+      return rawModels.map((model) => model.replace("models/", "")).map((model) => {
+        return {
+          name: model,
+          maxTokens: ((model2) => {
+            if (model2.includes("gemini-1.5-pro")) {
+              return 1048576;
+            }
+            if (model2.includes("gemini-1.5-flash")) {
+              return 2097152;
+            }
+            if (model2.includes("gemini-1.0-pro")) {
+              return 30720;
+            }
+            return 30720;
+          })(model),
+          type: model.includes("embedding") ? import_types.ModelType.embeddings : import_types.ModelType.llm,
+          functionCall: !model.includes("vision"),
+          supportMode: ["all"]
+        };
+      });
+    } catch (e) {
+      throw new import_error2.ChatLunaError(import_error2.ChatLunaErrorCode.MODEL_INIT_ERROR, e);
+    }
+  }
+  async getModels() {
+    if (this._models) {
+      return Object.values(this._models);
+    }
+    const models = await this.refreshModels();
+    this._models = {};
+    for (const model of models) {
+      this._models[model.name] = model;
+    }
+  }
+  _createModel(model) {
+    const info = this._models[model];
+    if (info == null) {
+      throw new import_error2.ChatLunaError(import_error2.ChatLunaErrorCode.MODEL_NOT_FOUND);
+    }
+    if (info.type === import_types.ModelType.llm) {
+      return new import_model.ChatLunaChatModel({
+        modelInfo: info,
+        requester: this._requester,
+        model,
+        modelMaxContextSize: info.maxTokens,
+        maxTokens: this._config.maxTokens,
+        timeout: this._config.timeout,
+        temperature: this._config.temperature,
+        maxRetries: this._config.maxRetries,
+        llmType: "gemini"
+      });
+    }
+    return new import_model.ChatLunaEmbeddings({
+      client: this._requester,
+      model,
+      maxRetries: this._config.maxRetries
+    });
+  }
+};
+
+// src/index.ts
+var import_logger = require("koishi-plugin-chatluna/utils/logger");
+var logger;
+function apply(ctx, config) {
+  const plugin = new import_chat.ChatLunaPlugin(ctx, config, "gemini");
+  logger = (0, import_logger.createLogger)(ctx, "chatluna-gemini-adapter");
+  ctx.on("ready", async () => {
+    await plugin.registerToService();
+    await plugin.parseConfig((config2) => {
+      return config2.apiKeys.map(([apiKey, apiEndpoint]) => {
+        return {
+          apiKey,
+          apiEndpoint,
+          platform: "gemini",
+          chatLimit: config2.chatTimeLimit,
+          timeout: config2.timeout,
+          maxRetries: config2.maxRetries,
+          concurrentMaxSize: config2.chatConcurrentMaxSize
+        };
+      });
+    });
+    await plugin.registerClient(
+      (_, clientConfig) => new GeminiClient(ctx, config, clientConfig, plugin)
+    );
+    await plugin.initClients();
+  });
+}
+__name(apply, "apply");
+var Config = import_koishi.Schema.intersect([
+  import_chat.ChatLunaPlugin.Config,
+  import_koishi.Schema.object({
+    apiKeys: import_koishi.Schema.array(
+      import_koishi.Schema.tuple([
+        import_koishi.Schema.string().role("secret").description("Gemini 的 API Key").required(),
+        import_koishi.Schema.string().description("请求 Gemini API 的地址").default("https://generativelanguage.googleapis.com/v1beta")
+      ])
+    ).description("Gemini 的 API Key 和请求地址列表").default([["", "https://generativelanguage.googleapis.com/v1beta"]])
+  }).description("请求设置"),
+  import_koishi.Schema.object({
+    maxTokens: import_koishi.Schema.number().description(
+      "回复的最大 Token 数（16~2097000，必须是16的倍数）（注意如果你目前使用的模型的最大 Token 为 8000 及以上的话才建议设置超过 512 token）"
+    ).min(16).max(2097e3).step(16).default(8064),
+    temperature: import_koishi.Schema.percent().description("回复温度，越高越随机").min(0).max(1).step(0.1).default(0.8)
+  }).description("模型设置")
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+]);
+var inject = ["chatluna"];
+var name = "chatluna-google-gemini-adapter";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Config,
+  apply,
+  inject,
+  logger,
+  name
+});