koishi-plugin-chatluna-google-gemini-adapter 1.0.0-beta.13 → 1.0.0-beta.15

package/lib/index.mjs

@@ -0,0 +1,624 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/index.ts
+import { ChatLunaPlugin } from "koishi-plugin-chatluna/services/chat";
+import { Schema } from "koishi";
+
+// src/client.ts
+import { PlatformModelAndEmbeddingsClient } from "koishi-plugin-chatluna/llm-core/platform/client";
+import {
+  ChatLunaChatModel,
+  ChatLunaEmbeddings
+} from "koishi-plugin-chatluna/llm-core/platform/model";
+import {
+  ModelType
+} from "koishi-plugin-chatluna/llm-core/platform/types";
+import {
+  ChatLunaError as ChatLunaError2,
+  ChatLunaErrorCode as ChatLunaErrorCode2
+} from "koishi-plugin-chatluna/utils/error";
+
+// src/requester.ts
+import { AIMessageChunk as AIMessageChunk2 } from "@langchain/core/messages";
+import { ChatGenerationChunk } from "@langchain/core/outputs";
+import { JSONParser } from "@streamparser/json";
+import {
+  ModelRequester
+} from "koishi-plugin-chatluna/llm-core/platform/api";
+import {
+  ChatLunaError,
+  ChatLunaErrorCode
+} from "koishi-plugin-chatluna/utils/error";
+import { chatLunaFetch } from "koishi-plugin-chatluna/utils/request";
+import { sse } from "koishi-plugin-chatluna/utils/sse";
+import { readableStreamToAsyncIterable } from "koishi-plugin-chatluna/utils/stream";
+
+// src/utils.ts
+import {
+  AIMessageChunk,
+  ChatMessageChunk,
+  HumanMessageChunk,
+  SystemMessageChunk
+} from "@langchain/core/messages";
+import { zodToJsonSchema } from "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 = 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 ModelRequester {
+  constructor(_config) {
+    super();
+    this._config = _config;
+  }
+  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 = readableStreamToAsyncIterable(
+        stream.readable
+      );
+      const jsonParser = new 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 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 AIMessageChunk2(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 ChatGenerationChunk({
+            message: messageChunk,
+            text: messageChunk.content
+          });
+          yield generationChunk;
+          content = messageChunk.content;
+        } catch (e) {
+          if (errorCount > 5) {
+            logger.error("error with chunk", chunk);
+            throw new ChatLunaError(
+              ChatLunaErrorCode.API_REQUEST_FAILED,
+              e
+            );
+          } else {
+            errorCount++;
+            continue;
+          }
+        }
+      }
+    } catch (e) {
+      if (e instanceof ChatLunaError) {
+        throw e;
+      } else {
+        throw new ChatLunaError(ChatLunaErrorCode.API_REQUEST_FAILED, e);
+      }
+    }
+  }
+  async embeddings(params) {
+    let data;
+    try {
+      const response = await this._post(
+        `models/${params.model}:embedContent`,
+        {
+          model: `models/${params.model}`,
+          content: {
+            parts: [
+              {
+                text: params.input
+              }
+            ]
+          }
+        }
+      );
+      data = await response.text();
+      data = JSON.parse(data);
+      if (data.embedding && data.embedding.values?.length > 0) {
+        return data.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 ChatLunaError(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 chatLunaFetch(requestUrl, {
+      body,
+      headers: this._buildHeaders(),
+      method: "POST",
+      ...params
+    });
+  }
+  _get(url) {
+    const requestUrl = this._concatUrl(url);
+    return chatLunaFetch(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 PlatformModelAndEmbeddingsClient {
+  constructor(ctx, _config, clientConfig) {
+    super(ctx, clientConfig);
+    this._config = _config;
+    this._requester = new GeminiRequester(clientConfig);
+  }
+  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 ChatLunaError2(
+          ChatLunaErrorCode2.MODEL_INIT_ERROR,
+          new Error("No model found")
+        );
+      }
+      return rawModels.map((model) => model.replace("models/", "")).map((model) => {
+        return {
+          name: model,
+          maxTokens: model.includes("vision") ? 12288 : 30720,
+          type: model.includes("embedding") ? ModelType.embeddings : ModelType.llm,
+          functionCall: !model.includes("vision"),
+          supportMode: ["all"]
+        };
+      });
+    } catch (e) {
+      throw new ChatLunaError2(ChatLunaErrorCode2.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 ChatLunaError2(ChatLunaErrorCode2.MODEL_NOT_FOUND);
+    }
+    if (info.type === ModelType.llm) {
+      return new ChatLunaChatModel({
+        modelInfo: info,
+        requester: this._requester,
+        model,
+        maxTokens: this._config.maxTokens,
+        timeout: this._config.timeout,
+        temperature: this._config.temperature,
+        maxRetries: this._config.maxRetries,
+        llmType: "gemini"
+      });
+    }
+    return new ChatLunaEmbeddings({
+      client: this._requester,
+      model,
+      maxRetries: this._config.maxRetries
+    });
+  }
+};
+
+// src/index.ts
+import { createLogger } from "koishi-plugin-chatluna/utils/logger";
+var logger;
+function apply(ctx, config) {
+  const plugin = new ChatLunaPlugin(ctx, config, "gemini");
+  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)
+    );
+    await plugin.initClients();
+  });
+}
+__name(apply, "apply");
+var Config = Schema.intersect([
+  ChatLunaPlugin.Config,
+  Schema.object({
+    apiKeys: Schema.array(
+      Schema.tuple([
+        Schema.string().role("secret").description("Gemini 的 API Key").required(),
+        Schema.string().description("请求 Gemini API 的地址").default("https://generativelanguage.googleapis.com/v1beta")
+      ])
+    ).description("Gemini 的 API Key 和请求地址列表").default([["", "https://generativelanguage.googleapis.com/v1beta"]])
+  }).description("请求设置"),
+  Schema.object({
+    maxTokens: Schema.number().description(
+      "回复的最大 Token 数（16~32800，必须是16的倍数）（注意如果你目前使用的模型的最大 Token 为 8000 及以上的话才建议设置超过 512 token）"
+    ).min(16).max(128e3).step(16).default(1024),
+    temperature: 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";
+export {
+  Config,
+  apply,
+  inject,
+  logger,
+  name
+};

package/package.json

@@ -1,13 +1,23 @@
 {
   "name": "koishi-plugin-chatluna-google-gemini-adapter",
   "description": "google-gemini adapter for chatluna",
-  "version": "1.0.0-beta.13",
-  "main": "lib/index.js",
+  "version": "1.0.0-beta.15",
+  "main": "lib/index.cjs",
+  "module": "lib/index.mjs",
   "typings": "lib/index.d.ts",
   "files": [
     "lib",
     "dist"
   ],
+  "exports": {
+    ".": {
+      "import": "./lib/index.mjs",
+      "require": "./lib/index.cjs",
+      "types": "./lib/index.d.ts"
+    },
+    "./package.json": "./package.json"
+  },
+  "type": "module",
   "author": "dingyi222666 <dingyi222666@foxmail.com>",
   "repository": {
     "type": "git",
@@ -38,18 +48,18 @@
     "adapter"
   ],
   "dependencies": {
-    "@langchain/core": "^0.2.5",
+    "@langchain/core": "^0.2.8",
     "@streamparser/json": "^0.0.21",
     "zod": "^3.24.0-canary.20240523T174819",
-    "zod-to-json-schema": "^3.23.0"
+    "zod-to-json-schema": "^3.23.1"
   },
   "devDependencies": {
-    "atsc": "^2.0.1",
-    "koishi": "^4.17.7"
+    "atsc": "^2.1.0",
+    "koishi": "^4.17.9"
   },
   "peerDependencies": {
-    "koishi": "^4.17.0",
-    "koishi-plugin-chatluna": "^1.0.0-beta.51"
+    "koishi": "^4.17.9",
+    "koishi-plugin-chatluna": "^1.0.0-beta.54"
   },
   "koishi": {
     "description": {

package/lib/client.d.ts

@@ -1,17 +0,0 @@
-import { Context } from 'koishi';
-import { PlatformModelAndEmbeddingsClient } from 'koishi-plugin-chatluna/lib/llm-core/platform/client';
-import { ClientConfig } from 'koishi-plugin-chatluna/lib/llm-core/platform/config';
-import { ChatHubBaseEmbeddings, ChatLunaChatModel } from 'koishi-plugin-chatluna/lib/llm-core/platform/model';
-import { ModelInfo } from 'koishi-plugin-chatluna/lib/llm-core/platform/types';
-import { Config } from '.';
-export declare class GeminiClient extends PlatformModelAndEmbeddingsClient {
-    private _config;
-    platform: string;
-    private _requester;
-    private _models;
-    constructor(ctx: Context, _config: Config, clientConfig: ClientConfig);
-    init(): Promise<void>;
-    refreshModels(): Promise<ModelInfo[]>;
-    getModels(): Promise<ModelInfo[]>;
-    protected _createModel(model: string): ChatLunaChatModel | ChatHubBaseEmbeddings;
-}