koishi-plugin-chatluna-google-gemini-adapter 1.0.0-beta.1

package/README.md

@@ -0,0 +1,7 @@
+## chatluna-google-gemini-adapter
+
+## [![npm](https://img.shields.io/npm/v/koishi-plugin-chatluna-google-gemini-adapter/next)](https://www.npmjs.com/package/koishi-plugin-chatluna-google-gemini) [![npm](https://img.shields.io/npm/dm/koishi-plugin-chatluna-google-gemini-adapter)](https://www.npmjs.com/package//koishi-plugin-chatluna-google-gemini-adapter)
+
+> 为 ChatHub 提供 Google-gemini 支持的适配器
+
+[Google-gemini 适配器文档](https://chatluna.dingyi222666.top/guide/configure-model-platform/google-gemini.html)

package/lib/client.d.ts

@@ -0,0 +1,17 @@
+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 { Context } from 'koishi';
+import { Config } from '.';
+export declare class GeminiClient extends PlatformModelAndEmbeddingsClient<ClientConfig> {
+    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;
+}

package/lib/client.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeminiClient = void 0;
+const client_1 = require("koishi-plugin-chatluna/lib/llm-core/platform/client");
+const model_1 = require("koishi-plugin-chatluna/lib/llm-core/platform/model");
+const types_1 = require("koishi-plugin-chatluna/lib/llm-core/platform/types");
+const error_1 = require("koishi-plugin-chatluna/lib/utils/error");
+const requester_1 = require("./requester");
+class GeminiClient extends client_1.PlatformModelAndEmbeddingsClient {
+    _config;
+    platform = 'gemini';
+    _requester;
+    _models;
+    constructor(ctx, _config, clientConfig) {
+        super(ctx, clientConfig);
+        this._config = _config;
+        this._requester = new requester_1.GeminiRequester(clientConfig);
+    }
+    async init() {
+        await this.getModels();
+    }
+    async refreshModels() {
+        try {
+            const rawModels = await this._requester.getModels();
+            return rawModels
+                .map((model) => model.replace('models/', ''))
+                .map((model) => {
+                return {
+                    name: model,
+                    type: model.includes('embedding')
+                        ? types_1.ModelType.embeddings
+                        : types_1.ModelType.llm,
+                    functionCall: true,
+                    supportMode: ['all']
+                };
+            });
+        }
+        catch (e) {
+            throw new error_1.ChatLunaError(error_1.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 error_1.ChatLunaError(error_1.ChatLunaErrorCode.MODEL_NOT_FOUND);
+        }
+        if (info.type === types_1.ModelType.llm) {
+            return new model_1.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 model_1.ChatLunaEmbeddings({
+            client: this._requester,
+            maxRetries: this._config.maxRetries
+        });
+    }
+}
+exports.GeminiClient = GeminiClient;

package/lib/index.d.ts

@@ -0,0 +1,12 @@
+import { ChatLunaPlugin } from 'koishi-plugin-chatluna/lib/services/chat';
+import { Context, Logger, Schema } from 'koishi';
+export declare let logger: Logger;
+export declare function apply(ctx: Context, config: Config): void;
+export interface Config extends ChatLunaPlugin.Config {
+    apiKeys: [string, string][];
+    maxTokens: number;
+    temperature: number;
+}
+export declare const Config: Schema<Config>;
+export declare const inject: string[];
+export declare const name = "chatluna-gemini-adapter";

package/lib/index.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.name = exports.inject = exports.Config = exports.apply = exports.logger = void 0;
+const chat_1 = require("koishi-plugin-chatluna/lib/services/chat");
+const koishi_1 = require("koishi");
+const client_1 = require("./client");
+const logger_1 = require("koishi-plugin-chatluna/lib/utils/logger");
+function apply(ctx, config) {
+    const plugin = new chat_1.ChatLunaPlugin(ctx, config, 'gemini');
+    exports.logger = (0, logger_1.createLogger)(ctx, 'chatluna-gemini-adapter');
+    ctx.on('ready', async () => {
+        await plugin.registerToService();
+        await plugin.parseConfig((config) => {
+            return config.apiKeys.map(([apiKey, apiEndpoint]) => {
+                return {
+                    apiKey,
+                    apiEndpoint,
+                    platform: 'gemini',
+                    chatLimit: config.chatTimeLimit,
+                    timeout: config.timeout,
+                    maxRetries: config.maxRetries,
+                    concurrentMaxSize: config.chatConcurrentMaxSize
+                };
+            });
+        });
+        await plugin.registerClient((_, clientConfig) => new client_1.GeminiClient(ctx, config, clientConfig));
+        await plugin.initClients();
+    });
+}
+exports.apply = apply;
+exports.Config = koishi_1.Schema.intersect([
+    chat_1.ChatLunaPlugin.Config,
+    koishi_1.Schema.object({
+        apiKeys: koishi_1.Schema.array(koishi_1.Schema.tuple([
+            koishi_1.Schema.string()
+                .role('secret')
+                .description('Gemini 的 API Key')
+                .required(),
+            koishi_1.Schema.string()
+                .description('请求 Gemini API 的地址')
+                .default('https://generativelanguage.googleapis.com/v1beta')
+        ]))
+            .description('Gemini 的 API Key 和请求地址列表')
+            .default([['', 'https://generativelanguage.googleapis.com/v1beta']])
+    }).description('请求设置'),
+    koishi_1.Schema.object({
+        maxTokens: koishi_1.Schema.number()
+            .description('回复的最大 Token 数（16~32800，必须是16的倍数）（注意如果你目前使用的模型的最大 Token 为 8000 及以上的话才建议设置超过 512 token）')
+            .min(16)
+            .max(128000)
+            .step(16)
+            .default(1024),
+        temperature: koishi_1.Schema.percent()
+            .description('回复温度，越高越随机')
+            .min(0)
+            .max(1)
+            .step(0.1)
+            .default(0.8)
+    }).description('模型设置')
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+]);
+exports.inject = ['chatluna'];
+exports.name = 'chatluna-gemini-adapter';

package/lib/requester.d.ts

@@ -0,0 +1,16 @@
+import { EmbeddingsRequester, EmbeddingsRequestParams, ModelRequester, ModelRequestParams } from 'koishi-plugin-chatluna/lib/llm-core/platform/api';
+import { ClientConfig } from 'koishi-plugin-chatluna/lib/llm-core/platform/config';
+import { ChatGenerationChunk } from 'langchain/schema';
+export declare class GeminiRequester extends ModelRequester implements EmbeddingsRequester {
+    private _config;
+    constructor(_config: ClientConfig);
+    completionStream(params: ModelRequestParams): AsyncGenerator<ChatGenerationChunk>;
+    embeddings(params: EmbeddingsRequestParams): Promise<number[] | number[][]>;
+    getModels(): Promise<string[]>;
+    private _post;
+    private _get;
+    private _concatUrl;
+    private _buildHeaders;
+    init(): Promise<void>;
+    dispose(): Promise<void>;
+}

package/lib/requester.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeminiRequester = void 0;
+const api_1 = require("koishi-plugin-chatluna/lib/llm-core/platform/api");
+const schema_1 = require("langchain/schema");
+const error_1 = require("koishi-plugin-chatluna/lib/utils/error");
+const sse_1 = require("koishi-plugin-chatluna/lib/utils/sse");
+const utils_1 = require("./utils");
+const request_1 = require("koishi-plugin-chatluna/lib/utils/request");
+const _1 = require(".");
+const json_1 = require("@streamparser/json");
+const stream_1 = require("koishi-plugin-chatluna/lib/utils/stream");
+class GeminiRequester extends api_1.ModelRequester {
+    _config;
+    constructor(_config) {
+        super();
+        this._config = _config;
+    }
+    async *completionStream(params) {
+        try {
+            const response = await this._post(`models/${params.model}:streamGenerateContent`, {
+                contents: (0, utils_1.langchainMessageToGeminiMessage)(params.input, params.model),
+                safetySettings: [
+                    {
+                        category: 'HARM_CATEGORY_HARASSMENT',
+                        threshold: 'BLOCK_ONLY_HIGH'
+                    },
+                    {
+                        category: 'HARM_CATEGORY_HATE_SPEECH',
+                        threshold: 'BLOCK_ONLY_HIGH'
+                    },
+                    {
+                        category: 'HARM_CATEGORY_SEXUALLY_EXPLICIT',
+                        threshold: 'BLOCK_ONLY_HIGH'
+                    },
+                    {
+                        category: 'HARM_CATEGORY_DANGEROUS_CONTENT',
+                        threshold: 'BLOCK_ONLY_HIGH'
+                    }
+                ],
+                generationConfig: {
+                    stopSequences: params.stop,
+                    temperature: params.temperature,
+                    maxOutputTokens: params.model.includes('vision')
+                        ? undefined
+                        : params.maxTokens,
+                    topP: params.topP
+                }
+            }, {
+                signal: params.signal
+            });
+            let errorCount = 0;
+            const stream = new TransformStream();
+            const iterable = (0, stream_1.readableStreamToAsyncIterable)(stream.readable);
+            const jsonParser = new json_1.JSONParser();
+            const writable = stream.writable.getWriter();
+            jsonParser.onEnd = async () => {
+                await writable.write('[DONE]');
+            };
+            jsonParser.onValue = async ({ value }) => {
+                const transformValue = value;
+                if (transformValue.candidates && transformValue.candidates[0]) {
+                    const parts = transformValue.candidates[0].content
+                        .parts;
+                    if (parts.length < 1) {
+                        throw new Error(JSON.stringify(value));
+                    }
+                    const text = parts[0].text;
+                    if (text) {
+                        await writable.write(text);
+                    }
+                }
+            };
+            await (0, sse_1.sse)(response, async (rawData) => {
+                jsonParser.write(rawData);
+                return true;
+            });
+            let content = '';
+            for await (const chunk of iterable) {
+                if (chunk === '[DONE]') {
+                    return;
+                }
+                try {
+                    const messageChunk = new schema_1.AIMessageChunk(chunk);
+                    messageChunk.content = content + messageChunk.content;
+                    const generationChunk = new schema_1.ChatGenerationChunk({
+                        message: messageChunk,
+                        text: messageChunk.content
+                    });
+                    yield generationChunk;
+                    content = messageChunk.content;
+                }
+                catch (e) {
+                    if (errorCount > 5) {
+                        _1.logger.error('error with chunk', chunk);
+                        throw new error_1.ChatLunaError(error_1.ChatLunaErrorCode.API_REQUEST_FAILED, e);
+                    }
+                    else {
+                        errorCount++;
+                        continue;
+                    }
+                }
+            }
+        }
+        catch (e) {
+            if (e instanceof error_1.ChatLunaError) {
+                throw e;
+            }
+            else {
+                throw new error_1.ChatLunaError(error_1.ChatLunaErrorCode.API_REQUEST_FAILED, e);
+            }
+        }
+    }
+    async embeddings(params) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        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;
+            _1.logger.debug(e);
+            throw new error_1.ChatLunaError(error_1.ChatLunaErrorCode.API_REQUEST_FAILED, error);
+        }
+    }
+    async getModels() {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let data;
+        try {
+            const response = await this._get('models');
+            data = await response.text();
+            data = JSON.parse(data);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            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] === undefined) {
+                delete data[key];
+            }
+        }
+        const body = JSON.stringify(data);
+        // console.log('POST', requestUrl, body)
+        return (0, request_1.chatLunaFetch)(requestUrl, {
+            body,
+            headers: this._buildHeaders(),
+            method: 'POST',
+            ...params
+        });
+    }
+    _get(url) {
+        const requestUrl = this._concatUrl(url);
+        return (0, request_1.chatLunaFetch)(requestUrl, {
+            method: 'GET',
+            headers: this._buildHeaders()
+        });
+    }
+    _concatUrl(url) {
+        const apiEndPoint = this._config.apiEndpoint;
+        // match the apiEndPoint ends with '/v1' or '/v1/' using regex
+        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() { }
+}
+exports.GeminiRequester = GeminiRequester;

package/lib/types.d.ts

@@ -0,0 +1,36 @@
+export interface ChatCompletionResponseMessage {
+    role: string;
+    parts?: (ChatMessagePart | ChatUploadDataPart)[];
+}
+export type ChatMessagePart = {
+    text: string;
+};
+export type ChatUploadDataPart = {
+    inline_data: {
+        mime_type: string;
+        data?: string;
+    };
+};
+export interface ChatResponse {
+    candidates: {
+        content: ChatCompletionResponseMessage;
+        finishReason: string;
+        index: number;
+        safetyRatings: {
+            category: string;
+            probability: string;
+        }[];
+    }[];
+    promptFeedback: {
+        safetyRatings: {
+            category: string;
+            probability: string;
+        }[];
+    };
+}
+export interface CreateEmbeddingResponse {
+    embedding: {
+        values: number[];
+    };
+}
+export type ChatCompletionResponseMessageRoleEnum = 'system' | 'model' | 'user';

package/lib/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/utils.d.ts

@@ -0,0 +1,5 @@
+import { AIMessageChunk, BaseMessage, ChatMessageChunk, HumanMessageChunk, MessageType, SystemMessageChunk } from 'langchain/schema';
+import { ChatCompletionResponseMessage, ChatCompletionResponseMessageRoleEnum } from './types';
+export declare function langchainMessageToGeminiMessage(messages: BaseMessage[], model?: string): ChatCompletionResponseMessage[];
+export declare function messageTypeToGeminiRole(type: MessageType): ChatCompletionResponseMessageRoleEnum;
+export declare function convertDeltaToMessageChunk(delta: Record<string, any>, defaultRole?: ChatCompletionResponseMessageRoleEnum): HumanMessageChunk | AIMessageChunk | SystemMessageChunk | ChatMessageChunk;

package/lib/utils.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertDeltaToMessageChunk = exports.messageTypeToGeminiRole = exports.langchainMessageToGeminiMessage = void 0;
+const schema_1 = require("langchain/schema");
+function langchainMessageToGeminiMessage(messages, model) {
+    // TODO: image vision
+    const mappedMessage = messages.map((rawMessage) => {
+        const role = messageTypeToGeminiRole(rawMessage._getType());
+        const images = rawMessage.additional_kwargs.images;
+        const result = {
+            role,
+            parts: [
+                {
+                    text: rawMessage.content
+                }
+            ]
+        };
+        if (model.includes('vision') && images != null) {
+            for (const image of images) {
+                result.parts.push({
+                    inline_data: {
+                        // base64 image match type
+                        data: image,
+                        mime_type: 'image/jpeg'
+                    }
+                });
+            }
+        }
+        return result;
+    });
+    const result = [];
+    for (let i = 0; i < mappedMessage.length; i++) {
+        const message = mappedMessage[i];
+        if (message.role !== 'system') {
+            result.push(message);
+            continue;
+        }
+        /*   if (removeSystemMessage) {
+            continue
+        } */
+        result.push({
+            role: 'user',
+            parts: message.parts
+        });
+        if (mappedMessage?.[i + 1]?.role === 'model') {
+            continue;
+        }
+        result.push({
+            role: 'model',
+            parts: [{ text: 'Okay, what do I need to do?' }]
+        });
+    }
+    if (result[result.length - 1].role === 'assistant') {
+        result.push({
+            role: 'user',
+            parts: [
+                {
+                    text: 'Continue what I said to you last message. Follow these instructions.'
+                }
+            ]
+        });
+    }
+    return result;
+}
+exports.langchainMessageToGeminiMessage = langchainMessageToGeminiMessage;
+function messageTypeToGeminiRole(type) {
+    switch (type) {
+        case 'system':
+            return 'system';
+        case 'ai':
+            return 'model';
+        case 'human':
+            return 'user';
+        default:
+            throw new Error(`Unknown message type: ${type}`);
+    }
+}
+exports.messageTypeToGeminiRole = messageTypeToGeminiRole;
+function convertDeltaToMessageChunk(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+delta, defaultRole) {
+    const role = delta.role ?? defaultRole;
+    const content = delta.content ?? '';
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/naming-convention
+    let additional_kwargs;
+    if (delta.function_call) {
+        additional_kwargs = {
+            function_call: delta.function_call
+        };
+    }
+    else if (delta.tool_calls) {
+        additional_kwargs = {
+            tool_calls: delta.tool_calls
+        };
+    }
+    else {
+        additional_kwargs = {};
+    }
+    if (role === 'user') {
+        return new schema_1.HumanMessageChunk({ content });
+    }
+    else if (role === 'assistant') {
+        return new schema_1.AIMessageChunk({ content, additional_kwargs });
+    }
+    else if (role === 'system') {
+        return new schema_1.SystemMessageChunk({ content });
+    }
+    else {
+        return new schema_1.ChatMessageChunk({ content, role });
+    }
+}
+exports.convertDeltaToMessageChunk = convertDeltaToMessageChunk;

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "koishi-plugin-chatluna-google-gemini-adapter",
+  "description": "google-gemini adapter for chatluna",
+  "version": "1.0.0-beta.1",
+  "main": "lib/index.js",
+  "typings": "lib/index.d.ts",
+  "files": [
+    "lib",
+    "dist"
+  ],
+  "author": "dingyi222666 <dingyi222666@foxmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ChatLunaLab/chatluna.git",
+    "directory": "packages/google-gemini-adapter"
+  },
+  "license": "AGPL-3.0",
+  "bugs": {
+    "url": "https://github.com/ChatLunaLab/chatluna/issues"
+  },
+  "homepage": "https://github.com/ChatLunaLab/chatluna/tree/v1-dev/packages/google-gemini-adapter#readme",
+  "scripts": {
+    "build": "atsc -b"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "chatbot",
+    "koishi",
+    "plugin",
+    "service",
+    "chatgpt",
+    "gpt",
+    "google",
+    "gemini",
+    "chatluna",
+    "adapter"
+  ],
+  "dependencies": {
+    "@streamparser/json": "^0.0.19",
+    "langchain": "^0.0.186"
+  },
+  "devDependencies": {
+    "atsc": "^1.2.2",
+    "koishi": "^4.16.1"
+  },
+  "peerDependencies": {
+    "koishi": "^4.16.0",
+    "koishi-plugin-chatluna": "^1.0.0-beta.28"
+  },
+  "koishi": {
+    "description": {
+      "zh": "ChatLuna 的 Google gemini 平台适配器"
+    },
+    "service": {
+      "required": [
+        "chatluna"
+      ]
+    }
+  }
+}