Upload 6 files

Dockerfile

@@ -0,0 +1,12 @@
+FROM node:lts-alpine
+
+EXPOSE 3000
+ENV TZ=Europe/Moscow
+
+WORKDIR /app
+COPY . .
+
+RUN yarn config set registry https://registry.npmmirror.com/
+RUN yarn
+
+CMD ["npm", "run", "start"]

package.json

@@ -0,0 +1,22 @@
+{
+  "name": "cursor-api",
+  "version": "1.0.0",
+  "description": "cursor reverse-API",
+  "author": "zhx47",
+  "private": false,
+  "main": "index.js",
+  "url": "https://github.com/zhx47/cursor-api",
+  "license": "MIT",
+  "dependencies": {
+    "express": "4.21.1",
+    "protobufjs": "^7.4.0",
+    "uuid": "11.0.3"
+  },
+  "scripts": {
+    "format": "prettier --write \"src/**/*.js\"",
+    "start": "node src/index.js"
+  },
+  "devDependencies": {
+    "prettier": "^3.4.0"
+  }
+}

src/index.js

@@ -0,0 +1,151 @@
+const express = require('express');
+const { v4: uuidv4 } = require('uuid');
+const { stringToHex, chunkToUtf8String, getRandomIDPro } = require('./utils.js');
+const app = express();
+
+// Middleware configuration
+app.use(express.json());
+app.use(express.urlencoded({ extended: true }));
+
+app.post('/v1/chat/completions', async (req, res) => {
+  // Models starting with o1 do not support streaming output
+  if (req.body.model.startsWith('o1-') && req.body.stream) {
+    return res.status(400).json({
+      error: 'Model not supported stream',
+    });
+  }
+
+  let currentKeyIndex = 0;
+  try {
+    const { model, messages, stream = false } = req.body;
+    let authToken = req.headers.authorization?.replace('Bearer ', '');
+    // Handle comma-separated keys
+    const keys = authToken.split(',').map((key) => key.trim());
+    if (keys.length > 0) {
+      // make sure currentKeyIndex won't cross the line
+      if (currentKeyIndex >= keys.length) {
+        currentKeyIndex = 0;
+      }
+      // Use the current index to get the key
+      authToken = keys[currentKeyIndex];
+    }
+    if (authToken && authToken.includes('%3A%3A')) {
+      authToken = authToken.split('%3A%3A')[1];
+    }
+    if (!messages || !Array.isArray(messages) || messages.length === 0 || !authToken) {
+      return res.status(400).json({
+        error: 'Invalid request. Messages should be a non-empty array and authorization is required',
+      });
+    }
+
+    const hexData = await stringToHex(messages, model);
+
+    // get checksum，req header Medium passes first, the environment variable ranks second, and is randomly generated last
+    const checksum =
+      req.headers['x-cursor-checksum'] ??
+      process.env['x-cursor-checksum'] ??
+      `zo${getRandomIDPro({ dictType: 'max', size: 6 })}${getRandomIDPro({ dictType: 'max', size: 64 })}/${getRandomIDPro({ dictType: 'max', size: 64 })}`;
+
+    const response = await fetch('https://api2.cursor.sh/aiserver.v1.AiService/StreamChat', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/connect+proto',
+        authorization: `Bearer ${authToken}`,
+        'connect-accept-encoding': 'gzip,br',
+        'connect-protocol-version': '1',
+        'user-agent': 'connect-es/1.4.0',
+        'x-amzn-trace-id': `Root=${uuidv4()}`,
+        'x-cursor-checksum': checksum,
+        'x-cursor-client-version': '0.42.3',
+        'x-cursor-timezone': 'Asia/Shanghai',
+        'x-ghost-mode': 'false',
+        'x-request-id': uuidv4(),
+        Host: 'api2.cursor.sh',
+      },
+      body: hexData,
+    });
+
+    if (stream) {
+      res.setHeader('Content-Type', 'text/event-stream');
+      res.setHeader('Cache-Control', 'no-cache');
+      res.setHeader('Connection', 'keep-alive');
+
+      const responseId = `chatcmpl-${uuidv4()}`;
+
+      // Use encapsulated function processing chunk
+      for await (const chunk of response.body) {
+        const text = await chunkToUtf8String(chunk);
+
+        if (text.length > 0) {
+          res.write(
+            `data: ${JSON.stringify({
+              id: responseId,
+              object: 'chat.completion.chunk',
+              created: Math.floor(Date.now() / 1000),
+              model,
+              choices: [
+                {
+                  index: 0,
+                  delta: {
+                    content: text,
+                  },
+                },
+              ],
+            })}\n\n`,
+          );
+        }
+      }
+
+      res.write('data: [DONE]\n\n');
+      return res.end();
+    } else {
+      let text = '';
+      // Encapsulated functions are also used in non-streaming mode
+      for await (const chunk of response.body) {
+        text += await chunkToUtf8String(chunk);
+      }
+      // Further processing of the parsed string
+      text = text.replace(/^.*<\|END_USER\|>/s, '');
+      text = text.replace(/^\n[a-zA-Z]?/, '').trim();
+      // console.log(text)
+
+      return res.json({
+        id: `chatcmpl-${uuidv4()}`,
+        object: 'chat.completion',
+        created: Math.floor(Date.now() / 1000),
+        model,
+        choices: [
+          {
+            index: 0,
+            message: {
+              role: 'assistant',
+              content: text,
+            },
+            finish_reason: 'stop',
+          },
+        ],
+        usage: {
+          prompt_tokens: 0,
+          completion_tokens: 0,
+          total_tokens: 0,
+        },
+      });
+    }
+  } catch (error) {
+    console.error('Error:', error);
+    if (!res.headersSent) {
+      if (req.body.stream) {
+        res.write(`data: ${JSON.stringify({ error: 'Internal server error' })}\n\n`);
+        return res.end();
+      } else {
+        return res.status(500).json({ error: 'Internal server error' });
+      }
+    }
+  }
+});
+
+// Start the server
+const PORT = process.env.PORT || 3000;
+app.listen(PORT, () => {
+  console.log(`The server runs on the port ${PORT}`);
+});

src/message.js

@@ -0,0 +1,1918 @@
+/*eslint-disable block-scoped-var, id-length, no-control-regex, no-magic-numbers, no-prototype-builtins, no-redeclare, no-shadow, no-var, sort-vars*/
+'use strict';
+
+const $protobuf = require('protobufjs/minimal');
+
+// Common aliases
+const $Reader = $protobuf.Reader,
+  $Writer = $protobuf.Writer,
+  $util = $protobuf.util;
+
+// Exported root namespace
+const $root = $protobuf.roots['default'] || ($protobuf.roots['default'] = {});
+
+$root.ChatMessage = (function () {
+  /**
+   * Properties of a ChatMessage.
+   * @exports IChatMessage
+   * @interface IChatMessage
+   * @property {Array.<ChatMessage.IUserMessage>|null} [messages] ChatMessage messages
+   * @property {ChatMessage.IInstructions|null} [instructions] ChatMessage instructions
+   * @property {string|null} [projectPath] ChatMessage projectPath
+   * @property {ChatMessage.IModel|null} [model] ChatMessage model
+   * @property {string|null} [requestId] ChatMessage requestId
+   * @property {string|null} [summary] ChatMessage summary
+   * @property {string|null} [conversationId] ChatMessage conversationId
+   */
+
+  /**
+   * Constructs a new ChatMessage.
+   * @exports ChatMessage
+   * @classdesc Represents a ChatMessage.
+   * @implements IChatMessage
+   * @constructor
+   * @param {IChatMessage=} [properties] Properties to set
+   */
+  function ChatMessage(properties) {
+    this.messages = [];
+    if (properties) let keys = Object.keys(properties), i = 0; for (; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
+  }
+
+  /**
+   * ChatMessage messages.
+   * @member {Array.<ChatMessage.IUserMessage>} messages
+   * @memberof ChatMessage
+   * @instance
+   */
+  ChatMessage.prototype.messages = $util.emptyArray;
+
+  /**
+   * ChatMessage instructions.
+   * @member {ChatMessage.IInstructions|null|undefined} instructions
+   * @memberof ChatMessage
+   * @instance
+   */
+  ChatMessage.prototype.instructions = null;
+
+  /**
+   * ChatMessage projectPath.
+   * @member {string} projectPath
+   * @memberof ChatMessage
+   * @instance
+   */
+  ChatMessage.prototype.projectPath = '';
+
+  /**
+   * ChatMessage model.
+   * @member {ChatMessage.IModel|null|undefined} model
+   * @memberof ChatMessage
+   * @instance
+   */
+  ChatMessage.prototype.model = null;
+
+  /**
+   * ChatMessage requestId.
+   * @member {string} requestId
+   * @memberof ChatMessage
+   * @instance
+   */
+  ChatMessage.prototype.requestId = '';
+
+  /**
+   * ChatMessage summary.
+   * @member {string} summary
+   * @memberof ChatMessage
+   * @instance
+   */
+  ChatMessage.prototype.summary = '';
+
+  /**
+   * ChatMessage conversationId.
+   * @member {string} conversationId
+   * @memberof ChatMessage
+   * @instance
+   */
+  ChatMessage.prototype.conversationId = '';
+
+  /**
+   * Creates a new ChatMessage instance using the specified properties.
+   * @function create
+   * @memberof ChatMessage
+   * @static
+   * @param {IChatMessage=} [properties] Properties to set
+   * @returns {ChatMessage} ChatMessage instance
+   */
+  ChatMessage.create = function create(properties) {
+    return new ChatMessage(properties);
+  };
+
+  /**
+   * Encodes the specified ChatMessage message. Does not implicitly {@link ChatMessage.verify|verify} messages.
+   * @function encode
+   * @memberof ChatMessage
+   * @static
+   * @param {IChatMessage} message ChatMessage message or plain object to encode
+   * @param {$protobuf.Writer} [writer] Writer to encode to
+   * @returns {$protobuf.Writer} Writer
+   */
+  ChatMessage.encode = function encode(message, writer) {
+    if (!writer) writer = $Writer.create();
+    if (message.messages != null && message.messages.length)
+      for (let i = 0; i < message.messages.length; ++i) $root.ChatMessage.UserMessage.encode(message.messages[i], writer.uint32(/* id 2, wireType 2 =*/ 18).fork()).ldelim();
+    if (message.instructions != null && Object.hasOwnProperty.call(message, 'instructions'))
+      $root.ChatMessage.Instructions.encode(message.instructions, writer.uint32(/* id 4, wireType 2 =*/ 34).fork()).ldelim();
+    if (message.projectPath != null && Object.hasOwnProperty.call(message, 'projectPath')) writer.uint32(/* id 5, wireType 2 =*/ 42).string(message.projectPath);
+    if (message.model != null && Object.hasOwnProperty.call(message, 'model'))
+      $root.ChatMessage.Model.encode(message.model, writer.uint32(/* id 7, wireType 2 =*/ 58).fork()).ldelim();
+    if (message.requestId != null && Object.hasOwnProperty.call(message, 'requestId')) writer.uint32(/* id 9, wireType 2 =*/ 74).string(message.requestId);
+    if (message.summary != null && Object.hasOwnProperty.call(message, 'summary')) writer.uint32(/* id 11, wireType 2 =*/ 90).string(message.summary);
+    if (message.conversationId != null && Object.hasOwnProperty.call(message, 'conversationId')) writer.uint32(/* id 15, wireType 2 =*/ 122).string(message.conversationId);
+    return writer;
+  };
+
+  /**
+   * Encodes the specified ChatMessage message, length delimited. Does not implicitly {@link ChatMessage.verify|verify} messages.
+   * @function encodeDelimited
+   * @memberof ChatMessage
+   * @static
+   * @param {IChatMessage} message ChatMessage message or plain object to encode
+   * @param {$protobuf.Writer} [writer] Writer to encode to
+   * @returns {$protobuf.Writer} Writer
+   */
+  ChatMessage.encodeDelimited = function encodeDelimited(message, writer) {
+    return this.encode(message, writer).ldelim();
+  };
+
+  /**
+   * Decodes a ChatMessage message from the specified reader or buffer.
+   * @function decode
+   * @memberof ChatMessage
+   * @static
+   * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+   * @param {number} [length] Message length if known beforehand
+   * @returns {ChatMessage} ChatMessage
+   * @throws {Error} If the payload is not a reader or valid buffer
+   * @throws {$protobuf.util.ProtocolError} If required fields are missing
+   */
+  ChatMessage.decode = function decode(reader, length) {
+    if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
+    const end = length === undefined ? reader.len : reader.pos + length,
+      message = new $root.ChatMessage();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 2: {
+          if (!(message.messages && message.messages.length)) message.messages = [];
+          message.messages.push($root.ChatMessage.UserMessage.decode(reader, reader.uint32()));
+          break;
+        }
+        case 4: {
+          message.instructions = $root.ChatMessage.Instructions.decode(reader, reader.uint32());
+          break;
+        }
+        case 5: {
+          message.projectPath = reader.string();
+          break;
+        }
+        case 7: {
+          message.model = $root.ChatMessage.Model.decode(reader, reader.uint32());
+          break;
+        }
+        case 9: {
+          message.requestId = reader.string();
+          break;
+        }
+        case 11: {
+          message.summary = reader.string();
+          break;
+        }
+        case 15: {
+          message.conversationId = reader.string();
+          break;
+        }
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  };
+
+  /**
+   * Decodes a ChatMessage message from the specified reader or buffer, length delimited.
+   * @function decodeDelimited
+   * @memberof ChatMessage
+   * @static
+   * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+   * @returns {ChatMessage} ChatMessage
+   * @throws {Error} If the payload is not a reader or valid buffer
+   * @throws {$protobuf.util.ProtocolError} If required fields are missing
+   */
+  ChatMessage.decodeDelimited = function decodeDelimited(reader) {
+    if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+    return this.decode(reader, reader.uint32());
+  };
+
+  /**
+   * Verifies a ChatMessage message.
+   * @function verify
+   * @memberof ChatMessage
+   * @static
+   * @param {Object.<string,*>} message Plain object to verify
+   * @returns {string|null} `null` if valid, otherwise the reason why it is not
+   */
+  ChatMessage.verify = function verify(message) {
+    let error;
+    if (typeof message !== 'object' || message === null) return 'object expected';
+    if (message.messages != null && message.hasOwnProperty('messages')) {
+      if (!Array.isArray(message.messages)) return 'messages: array expected';
+      for (let i = 0; i < message.messages.length; ++i) {
+        error = $root.ChatMessage.UserMessage.verify(message.messages[i]);
+        if (error) return 'messages.' + error;
+      }
+    }
+    if (message.instructions != null && message.hasOwnProperty('instructions')) {
+      error = $root.ChatMessage.Instructions.verify(message.instructions);
+      if (error) return 'instructions.' + error;
+    }
+    if (message.projectPath != null && message.hasOwnProperty('projectPath')) if (!$util.isString(message.projectPath)) return 'projectPath: string expected';
+    if (message.model != null && message.hasOwnProperty('model')) {
+      error = $root.ChatMessage.Model.verify(message.model);
+      if (error) return 'model.' + error;
+    }
+    if (message.requestId != null && message.hasOwnProperty('requestId')) if (!$util.isString(message.requestId)) return 'requestId: string expected';
+    if (message.summary != null && message.hasOwnProperty('summary')) if (!$util.isString(message.summary)) return 'summary: string expected';
+    if (message.conversationId != null && message.hasOwnProperty('conversationId')) if (!$util.isString(message.conversationId)) return 'conversationId: string expected';
+    return null;
+  };
+
+  /**
+   * Creates a ChatMessage message from a plain object. Also converts values to their respective internal types.
+   * @function fromObject
+   * @memberof ChatMessage
+   * @static
+   * @param {Object.<string,*>} object Plain object
+   * @returns {ChatMessage} ChatMessage
+   */
+  ChatMessage.fromObject = function fromObject(object) {
+    if (object instanceof $root.ChatMessage) return object;
+    const message = new $root.ChatMessage();
+    if (object.messages) {
+      if (!Array.isArray(object.messages)) throw TypeError('.ChatMessage.messages: array expected');
+      message.messages = [];
+      for (let i = 0; i < object.messages.length; ++i) {
+        if (typeof object.messages[i] !== 'object') throw TypeError('.ChatMessage.messages: object expected');
+        message.messages[i] = $root.ChatMessage.UserMessage.fromObject(object.messages[i]);
+      }
+    }
+    if (object.instructions != null) {
+      if (typeof object.instructions !== 'object') throw TypeError('.ChatMessage.instructions: object expected');
+      message.instructions = $root.ChatMessage.Instructions.fromObject(object.instructions);
+    }
+    if (object.projectPath != null) message.projectPath = String(object.projectPath);
+    if (object.model != null) {
+      if (typeof object.model !== 'object') throw TypeError('.ChatMessage.model: object expected');
+      message.model = $root.ChatMessage.Model.fromObject(object.model);
+    }
+    if (object.requestId != null) message.requestId = String(object.requestId);
+    if (object.summary != null) message.summary = String(object.summary);
+    if (object.conversationId != null) message.conversationId = String(object.conversationId);
+    return message;
+  };
+
+  /**
+   * Creates a plain object from a ChatMessage message. Also converts values to other types if specified.
+   * @function toObject
+   * @memberof ChatMessage
+   * @static
+   * @param {ChatMessage} message ChatMessage
+   * @param {$protobuf.IConversionOptions} [options] Conversion options
+   * @returns {Object.<string,*>} Plain object
+   */
+  ChatMessage.toObject = function toObject(message, options) {
+    if (!options) options = {};
+    const object = {};
+    if (options.arrays || options.defaults) object.messages = [];
+    if (options.defaults) {
+      object.instructions = null;
+      object.projectPath = '';
+      object.model = null;
+      object.requestId = '';
+      object.summary = '';
+      object.conversationId = '';
+    }
+    if (message.messages && message.messages.length) {
+      object.messages = [];
+      for (let j = 0; j < message.messages.length; ++j) object.messages[j] = $root.ChatMessage.UserMessage.toObject(message.messages[j], options);
+    }
+    if (message.instructions != null && message.hasOwnProperty('instructions')) object.instructions = $root.ChatMessage.Instructions.toObject(message.instructions, options);
+    if (message.projectPath != null && message.hasOwnProperty('projectPath')) object.projectPath = message.projectPath;
+    if (message.model != null && message.hasOwnProperty('model')) object.model = $root.ChatMessage.Model.toObject(message.model, options);
+    if (message.requestId != null && message.hasOwnProperty('requestId')) object.requestId = message.requestId;
+    if (message.summary != null && message.hasOwnProperty('summary')) object.summary = message.summary;
+    if (message.conversationId != null && message.hasOwnProperty('conversationId')) object.conversationId = message.conversationId;
+    return object;
+  };
+
+  /**
+   * Converts this ChatMessage to JSON.
+   * @function toJSON
+   * @memberof ChatMessage
+   * @instance
+   * @returns {Object.<string,*>} JSON object
+   */
+  ChatMessage.prototype.toJSON = function toJSON() {
+    return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+  };
+
+  /**
+   * Gets the default type url for ChatMessage
+   * @function getTypeUrl
+   * @memberof ChatMessage
+   * @static
+   * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+   * @returns {string} The default type url
+   */
+  ChatMessage.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+    if (typeUrlPrefix === undefined) {
+      typeUrlPrefix = 'type.googleapis.com';
+    }
+    return typeUrlPrefix + '/ChatMessage';
+  };
+
+  ChatMessage.FileContent = (function () {
+    /**
+     * Properties of a FileContent.
+     * @memberof ChatMessage
+     * @interface IFileContent
+     * @property {string|null} [filename] FileContent filename
+     * @property {string|null} [content] FileContent content
+     * @property {ChatMessage.FileContent.IPosition|null} [position] FileContent position
+     * @property {string|null} [language] FileContent language
+     * @property {ChatMessage.FileContent.IRange|null} [range] FileContent range
+     * @property {number|null} [length] FileContent length
+     * @property {number|null} [type] FileContent type
+     * @property {number|null} [errorCode] FileContent errorCode
+     */
+
+    /**
+     * Constructs a new FileContent.
+     * @memberof ChatMessage
+     * @classdesc Represents a FileContent.
+     * @implements IFileContent
+     * @constructor
+     * @param {ChatMessage.IFileContent=} [properties] Properties to set
+     */
+    function FileContent(properties) {
+      if (properties) let keys = Object.keys(properties), i = 0; for (; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
+    }
+
+    /**
+     * FileContent filename.
+     * @member {string} filename
+     * @memberof ChatMessage.FileContent
+     * @instance
+     */
+    FileContent.prototype.filename = '';
+
+    /**
+     * FileContent content.
+     * @member {string} content
+     * @memberof ChatMessage.FileContent
+     * @instance
+     */
+    FileContent.prototype.content = '';
+
+    /**
+     * FileContent position.
+     * @member {ChatMessage.FileContent.IPosition|null|undefined} position
+     * @memberof ChatMessage.FileContent
+     * @instance
+     */
+    FileContent.prototype.position = null;
+
+    /**
+     * FileContent language.
+     * @member {string} language
+     * @memberof ChatMessage.FileContent
+     * @instance
+     */
+    FileContent.prototype.language = '';
+
+    /**
+     * FileContent range.
+     * @member {ChatMessage.FileContent.IRange|null|undefined} range
+     * @memberof ChatMessage.FileContent
+     * @instance
+     */
+    FileContent.prototype.range = null;
+
+    /**
+     * FileContent length.
+     * @member {number} length
+     * @memberof ChatMessage.FileContent
+     * @instance
+     */
+    FileContent.prototype.length = 0;
+
+    /**
+     * FileContent type.
+     * @member {number} type
+     * @memberof ChatMessage.FileContent
+     * @instance
+     */
+    FileContent.prototype.type = 0;
+
+    /**
+     * FileContent errorCode.
+     * @member {number} errorCode
+     * @memberof ChatMessage.FileContent
+     * @instance
+     */
+    FileContent.prototype.errorCode = 0;
+
+    /**
+     * Creates a new FileContent instance using the specified properties.
+     * @function create
+     * @memberof ChatMessage.FileContent
+     * @static
+     * @param {ChatMessage.IFileContent=} [properties] Properties to set
+     * @returns {ChatMessage.FileContent} FileContent instance
+     */
+    FileContent.create = function create(properties) {
+      return new FileContent(properties);
+    };
+
+    /**
+     * Encodes the specified FileContent message. Does not implicitly {@link ChatMessage.FileContent.verify|verify} messages.
+     * @function encode
+     * @memberof ChatMessage.FileContent
+     * @static
+     * @param {ChatMessage.IFileContent} message FileContent message or plain object to encode
+     * @param {$protobuf.Writer} [writer] Writer to encode to
+     * @returns {$protobuf.Writer} Writer
+     */
+    FileContent.encode = function encode(message, writer) {
+      if (!writer) writer = $Writer.create();
+      if (message.filename != null && Object.hasOwnProperty.call(message, 'filename')) writer.uint32(/* id 1, wireType 2 =*/ 10).string(message.filename);
+      if (message.content != null && Object.hasOwnProperty.call(message, 'content')) writer.uint32(/* id 2, wireType 2 =*/ 18).string(message.content);
+      if (message.position != null && Object.hasOwnProperty.call(message, 'position'))
+        $root.ChatMessage.FileContent.Position.encode(message.position, writer.uint32(/* id 3, wireType 2 =*/ 26).fork()).ldelim();
+      if (message.language != null && Object.hasOwnProperty.call(message, 'language')) writer.uint32(/* id 5, wireType 2 =*/ 42).string(message.language);
+      if (message.range != null && Object.hasOwnProperty.call(message, 'range'))
+        $root.ChatMessage.FileContent.Range.encode(message.range, writer.uint32(/* id 6, wireType 2 =*/ 50).fork()).ldelim();
+      if (message.length != null && Object.hasOwnProperty.call(message, 'length')) writer.uint32(/* id 8, wireType 0 =*/ 64).int32(message.length);
+      if (message.type != null && Object.hasOwnProperty.call(message, 'type')) writer.uint32(/* id 9, wireType 0 =*/ 72).int32(message.type);
+      if (message.errorCode != null && Object.hasOwnProperty.call(message, 'errorCode')) writer.uint32(/* id 11, wireType 0 =*/ 88).int32(message.errorCode);
+      return writer;
+    };
+
+    /**
+     * Encodes the specified FileContent message, length delimited. Does not implicitly {@link ChatMessage.FileContent.verify|verify} messages.
+     * @function encodeDelimited
+     * @memberof ChatMessage.FileContent
+     * @static
+     * @param {ChatMessage.IFileContent} message FileContent message or plain object to encode
+     * @param {$protobuf.Writer} [writer] Writer to encode to
+     * @returns {$protobuf.Writer} Writer
+     */
+    FileContent.encodeDelimited = function encodeDelimited(message, writer) {
+      return this.encode(message, writer).ldelim();
+    };
+
+    /**
+     * Decodes a FileContent message from the specified reader or buffer.
+     * @function decode
+     * @memberof ChatMessage.FileContent
+     * @static
+     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+     * @param {number} [length] Message length if known beforehand
+     * @returns {ChatMessage.FileContent} FileContent
+     * @throws {Error} If the payload is not a reader or valid buffer
+     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+     */
+    FileContent.decode = function decode(reader, length) {
+      if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
+      const end = length === undefined ? reader.len : reader.pos + length,
+        message = new $root.ChatMessage.FileContent();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            message.filename = reader.string();
+            break;
+          }
+          case 2: {
+            message.content = reader.string();
+            break;
+          }
+          case 3: {
+            message.position = $root.ChatMessage.FileContent.Position.decode(reader, reader.uint32());
+            break;
+          }
+          case 5: {
+            message.language = reader.string();
+            break;
+          }
+          case 6: {
+            message.range = $root.ChatMessage.FileContent.Range.decode(reader, reader.uint32());
+            break;
+          }
+          case 8: {
+            message.length = reader.int32();
+            break;
+          }
+          case 9: {
+            message.type = reader.int32();
+            break;
+          }
+          case 11: {
+            message.errorCode = reader.int32();
+            break;
+          }
+          default:
+            reader.skipType(tag & 7);
+            break;
+        }
+      }
+      return message;
+    };
+
+    /**
+     * Decodes a FileContent message from the specified reader or buffer, length delimited.
+     * @function decodeDelimited
+     * @memberof ChatMessage.FileContent
+     * @static
+     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+     * @returns {ChatMessage.FileContent} FileContent
+     * @throws {Error} If the payload is not a reader or valid buffer
+     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+     */
+    FileContent.decodeDelimited = function decodeDelimited(reader) {
+      if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+      return this.decode(reader, reader.uint32());
+    };
+
+    /**
+     * Verifies a FileContent message.
+     * @function verify
+     * @memberof ChatMessage.FileContent
+     * @static
+     * @param {Object.<string,*>} message Plain object to verify
+     * @returns {string|null} `null` if valid, otherwise the reason why it is not
+     */
+    FileContent.verify = function verify(message) {
+      let error;
+      if (typeof message !== 'object' || message === null) return 'object expected';
+      if (message.filename != null && message.hasOwnProperty('filename')) if (!$util.isString(message.filename)) return 'filename: string expected';
+      if (message.content != null && message.hasOwnProperty('content')) if (!$util.isString(message.content)) return 'content: string expected';
+      if (message.position != null && message.hasOwnProperty('position')) {
+        error = $root.ChatMessage.FileContent.Position.verify(message.position);
+        if (error) return 'position.' + error;
+      }
+      if (message.language != null && message.hasOwnProperty('language')) if (!$util.isString(message.language)) return 'language: string expected';
+      if (message.range != null && message.hasOwnProperty('range')) {
+        error = $root.ChatMessage.FileContent.Range.verify(message.range);
+        if (error) return 'range.' + error;
+      }
+      if (message.length != null && message.hasOwnProperty('length')) if (!$util.isInteger(message.length)) return 'length: integer expected';
+      if (message.type != null && message.hasOwnProperty('type')) if (!$util.isInteger(message.type)) return 'type: integer expected';
+      if (message.errorCode != null && message.hasOwnProperty('errorCode')) if (!$util.isInteger(message.errorCode)) return 'errorCode: integer expected';
+      return null;
+    };
+
+    /**
+     * Creates a FileContent message from a plain object. Also converts values to their respective internal types.
+     * @function fromObject
+     * @memberof ChatMessage.FileContent
+     * @static
+     * @param {Object.<string,*>} object Plain object
+     * @returns {ChatMessage.FileContent} FileContent
+     */
+    FileContent.fromObject = function fromObject(object) {
+      if (object instanceof $root.ChatMessage.FileContent) return object;
+      const message = new $root.ChatMessage.FileContent();
+      if (object.filename != null) message.filename = String(object.filename);
+      if (object.content != null) message.content = String(object.content);
+      if (object.position != null) {
+        if (typeof object.position !== 'object') throw TypeError('.ChatMessage.FileContent.position: object expected');
+        message.position = $root.ChatMessage.FileContent.Position.fromObject(object.position);
+      }
+      if (object.language != null) message.language = String(object.language);
+      if (object.range != null) {
+        if (typeof object.range !== 'object') throw TypeError('.ChatMessage.FileContent.range: object expected');
+        message.range = $root.ChatMessage.FileContent.Range.fromObject(object.range);
+      }
+      if (object.length != null) message.length = object.length | 0;
+      if (object.type != null) message.type = object.type | 0;
+      if (object.errorCode != null) message.errorCode = object.errorCode | 0;
+      return message;
+    };
+
+    /**
+     * Creates a plain object from a FileContent message. Also converts values to other types if specified.
+     * @function toObject
+     * @memberof ChatMessage.FileContent
+     * @static
+     * @param {ChatMessage.FileContent} message FileContent
+     * @param {$protobuf.IConversionOptions} [options] Conversion options
+     * @returns {Object.<string,*>} Plain object
+     */
+    FileContent.toObject = function toObject(message, options) {
+      if (!options) options = {};
+      const object = {};
+      if (options.defaults) {
+        object.filename = '';
+        object.content = '';
+        object.position = null;
+        object.language = '';
+        object.range = null;
+        object.length = 0;
+        object.type = 0;
+        object.errorCode = 0;
+      }
+      if (message.filename != null && message.hasOwnProperty('filename')) object.filename = message.filename;
+      if (message.content != null && message.hasOwnProperty('content')) object.content = message.content;
+      if (message.position != null && message.hasOwnProperty('position')) object.position = $root.ChatMessage.FileContent.Position.toObject(message.position, options);
+      if (message.language != null && message.hasOwnProperty('language')) object.language = message.language;
+      if (message.range != null && message.hasOwnProperty('range')) object.range = $root.ChatMessage.FileContent.Range.toObject(message.range, options);
+      if (message.length != null && message.hasOwnProperty('length')) object.length = message.length;
+      if (message.type != null && message.hasOwnProperty('type')) object.type = message.type;
+      if (message.errorCode != null && message.hasOwnProperty('errorCode')) object.errorCode = message.errorCode;
+      return object;
+    };
+
+    /**
+     * Converts this FileContent to JSON.
+     * @function toJSON
+     * @memberof ChatMessage.FileContent
+     * @instance
+     * @returns {Object.<string,*>} JSON object
+     */
+    FileContent.prototype.toJSON = function toJSON() {
+      return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+    };
+
+    /**
+     * Gets the default type url for FileContent
+     * @function getTypeUrl
+     * @memberof ChatMessage.FileContent
+     * @static
+     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+     * @returns {string} The default type url
+     */
+    FileContent.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+      if (typeUrlPrefix === undefined) {
+        typeUrlPrefix = 'type.googleapis.com';
+      }
+      return typeUrlPrefix + '/ChatMessage.FileContent';
+    };
+
+    FileContent.Position = (function () {
+      /**
+       * Properties of a Position.
+       * @memberof ChatMessage.FileContent
+       * @interface IPosition
+       * @property {number|null} [line] Position line
+       * @property {number|null} [column] Position column
+       */
+
+      /**
+       * Constructs a new Position.
+       * @memberof ChatMessage.FileContent
+       * @classdesc Represents a Position.
+       * @implements IPosition
+       * @constructor
+       * @param {ChatMessage.FileContent.IPosition=} [properties] Properties to set
+       */
+      function Position(properties) {
+        if (properties) let keys = Object.keys(properties), i = 0; for (; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
+      }
+
+      /**
+       * Position line.
+       * @member {number} line
+       * @memberof ChatMessage.FileContent.Position
+       * @instance
+       */
+      Position.prototype.line = 0;
+
+      /**
+       * Position column.
+       * @member {number} column
+       * @memberof ChatMessage.FileContent.Position
+       * @instance
+       */
+      Position.prototype.column = 0;
+
+      /**
+       * Creates a new Position instance using the specified properties.
+       * @function create
+       * @memberof ChatMessage.FileContent.Position
+       * @static
+       * @param {ChatMessage.FileContent.IPosition=} [properties] Properties to set
+       * @returns {ChatMessage.FileContent.Position} Position instance
+       */
+      Position.create = function create(properties) {
+        return new Position(properties);
+      };
+
+      /**
+       * Encodes the specified Position message. Does not implicitly {@link ChatMessage.FileContent.Position.verify|verify} messages.
+       * @function encode
+       * @memberof ChatMessage.FileContent.Position
+       * @static
+       * @param {ChatMessage.FileContent.IPosition} message Position message or plain object to encode
+       * @param {$protobuf.Writer} [writer] Writer to encode to
+       * @returns {$protobuf.Writer} Writer
+       */
+      Position.encode = function encode(message, writer) {
+        if (!writer) writer = $Writer.create();
+        if (message.line != null && Object.hasOwnProperty.call(message, 'line')) writer.uint32(/* id 1, wireType 0 =*/ 8).int32(message.line);
+        if (message.column != null && Object.hasOwnProperty.call(message, 'column')) writer.uint32(/* id 2, wireType 0 =*/ 16).int32(message.column);
+        return writer;
+      };
+
+      /**
+       * Encodes the specified Position message, length delimited. Does not implicitly {@link ChatMessage.FileContent.Position.verify|verify} messages.
+       * @function encodeDelimited
+       * @memberof ChatMessage.FileContent.Position
+       * @static
+       * @param {ChatMessage.FileContent.IPosition} message Position message or plain object to encode
+       * @param {$protobuf.Writer} [writer] Writer to encode to
+       * @returns {$protobuf.Writer} Writer
+       */
+      Position.encodeDelimited = function encodeDelimited(message, writer) {
+        return this.encode(message, writer).ldelim();
+      };
+
+      /**
+       * Decodes a Position message from the specified reader or buffer.
+       * @function decode
+       * @memberof ChatMessage.FileContent.Position
+       * @static
+       * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+       * @param {number} [length] Message length if known beforehand
+       * @returns {ChatMessage.FileContent.Position} Position
+       * @throws {Error} If the payload is not a reader or valid buffer
+       * @throws {$protobuf.util.ProtocolError} If required fields are missing
+       */
+      Position.decode = function decode(reader, length) {
+        if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
+        const end = length === undefined ? reader.len : reader.pos + length,
+          message = new $root.ChatMessage.FileContent.Position();
+        while (reader.pos < end) {
+          const tag = reader.uint32();
+          switch (tag >>> 3) {
+            case 1: {
+              message.line = reader.int32();
+              break;
+            }
+            case 2: {
+              message.column = reader.int32();
+              break;
+            }
+            default:
+              reader.skipType(tag & 7);
+              break;
+          }
+        }
+        return message;
+      };
+
+      /**
+       * Decodes a Position message from the specified reader or buffer, length delimited.
+       * @function decodeDelimited
+       * @memberof ChatMessage.FileContent.Position
+       * @static
+       * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+       * @returns {ChatMessage.FileContent.Position} Position
+       * @throws {Error} If the payload is not a reader or valid buffer
+       * @throws {$protobuf.util.ProtocolError} If required fields are missing
+       */
+      Position.decodeDelimited = function decodeDelimited(reader) {
+        if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+        return this.decode(reader, reader.uint32());
+      };
+
+      /**
+       * Verifies a Position message.
+       * @function verify
+       * @memberof ChatMessage.FileContent.Position
+       * @static
+       * @param {Object.<string,*>} message Plain object to verify
+       * @returns {string|null} `null` if valid, otherwise the reason why it is not
+       */
+      Position.verify = function verify(message) {
+        if (typeof message !== 'object' || message === null) return 'object expected';
+        if (message.line != null && message.hasOwnProperty('line')) if (!$util.isInteger(message.line)) return 'line: integer expected';
+        if (message.column != null && message.hasOwnProperty('column')) if (!$util.isInteger(message.column)) return 'column: integer expected';
+        return null;
+      };
+
+      /**
+       * Creates a Position message from a plain object. Also converts values to their respective internal types.
+       * @function fromObject
+       * @memberof ChatMessage.FileContent.Position
+       * @static
+       * @param {Object.<string,*>} object Plain object
+       * @returns {ChatMessage.FileContent.Position} Position
+       */
+      Position.fromObject = function fromObject(object) {
+        if (object instanceof $root.ChatMessage.FileContent.Position) return object;
+        const message = new $root.ChatMessage.FileContent.Position();
+        if (object.line != null) message.line = object.line | 0;
+        if (object.column != null) message.column = object.column | 0;
+        return message;
+      };
+
+      /**
+       * Creates a plain object from a Position message. Also converts values to other types if specified.
+       * @function toObject
+       * @memberof ChatMessage.FileContent.Position
+       * @static
+       * @param {ChatMessage.FileContent.Position} message Position
+       * @param {$protobuf.IConversionOptions} [options] Conversion options
+       * @returns {Object.<string,*>} Plain object
+       */
+      Position.toObject = function toObject(message, options) {
+        if (!options) options = {};
+        const object = {};
+        if (options.defaults) {
+          object.line = 0;
+          object.column = 0;
+        }
+        if (message.line != null && message.hasOwnProperty('line')) object.line = message.line;
+        if (message.column != null && message.hasOwnProperty('column')) object.column = message.column;
+        return object;
+      };
+
+      /**
+       * Converts this Position to JSON.
+       * @function toJSON
+       * @memberof ChatMessage.FileContent.Position
+       * @instance
+       * @returns {Object.<string,*>} JSON object
+       */
+      Position.prototype.toJSON = function toJSON() {
+        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+      };
+
+      /**
+       * Gets the default type url for Position
+       * @function getTypeUrl
+       * @memberof ChatMessage.FileContent.Position
+       * @static
+       * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+       * @returns {string} The default type url
+       */
+      Position.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+        if (typeUrlPrefix === undefined) {
+          typeUrlPrefix = 'type.googleapis.com';
+        }
+        return typeUrlPrefix + '/ChatMessage.FileContent.Position';
+      };
+
+      return Position;
+    })();
+
+    FileContent.Range = (function () {
+      /**
+       * Properties of a Range.
+       * @memberof ChatMessage.FileContent
+       * @interface IRange
+       * @property {ChatMessage.FileContent.IPosition|null} [start] Range start
+       * @property {ChatMessage.FileContent.IPosition|null} [end] Range end
+       */
+
+      /**
+       * Constructs a new Range.
+       * @memberof ChatMessage.FileContent
+       * @classdesc Represents a Range.
+       * @implements IRange
+       * @constructor
+       * @param {ChatMessage.FileContent.IRange=} [properties] Properties to set
+       */
+      function Range(properties) {
+        if (properties) let keys = Object.keys(properties), i = 0; for (; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
+      }
+
+      /**
+       * Range start.
+       * @member {ChatMessage.FileContent.IPosition|null|undefined} start
+       * @memberof ChatMessage.FileContent.Range
+       * @instance
+       */
+      Range.prototype.start = null;
+
+      /**
+       * Range end.
+       * @member {ChatMessage.FileContent.IPosition|null|undefined} end
+       * @memberof ChatMessage.FileContent.Range
+       * @instance
+       */
+      Range.prototype.end = null;
+
+      /**
+       * Creates a new Range instance using the specified properties.
+       * @function create
+       * @memberof ChatMessage.FileContent.Range
+       * @static
+       * @param {ChatMessage.FileContent.IRange=} [properties] Properties to set
+       * @returns {ChatMessage.FileContent.Range} Range instance
+       */
+      Range.create = function create(properties) {
+        return new Range(properties);
+      };
+
+      /**
+       * Encodes the specified Range message. Does not implicitly {@link ChatMessage.FileContent.Range.verify|verify} messages.
+       * @function encode
+       * @memberof ChatMessage.FileContent.Range
+       * @static
+       * @param {ChatMessage.FileContent.IRange} message Range message or plain object to encode
+       * @param {$protobuf.Writer} [writer] Writer to encode to
+       * @returns {$protobuf.Writer} Writer
+       */
+      Range.encode = function encode(message, writer) {
+        if (!writer) writer = $Writer.create();
+        if (message.start != null && Object.hasOwnProperty.call(message, 'start'))
+          $root.ChatMessage.FileContent.Position.encode(message.start, writer.uint32(/* id 1, wireType 2 =*/ 10).fork()).ldelim();
+        if (message.end != null && Object.hasOwnProperty.call(message, 'end'))
+          $root.ChatMessage.FileContent.Position.encode(message.end, writer.uint32(/* id 2, wireType 2 =*/ 18).fork()).ldelim();
+        return writer;
+      };
+
+      /**
+       * Encodes the specified Range message, length delimited. Does not implicitly {@link ChatMessage.FileContent.Range.verify|verify} messages.
+       * @function encodeDelimited
+       * @memberof ChatMessage.FileContent.Range
+       * @static
+       * @param {ChatMessage.FileContent.IRange} message Range message or plain object to encode
+       * @param {$protobuf.Writer} [writer] Writer to encode to
+       * @returns {$protobuf.Writer} Writer
+       */
+      Range.encodeDelimited = function encodeDelimited(message, writer) {
+        return this.encode(message, writer).ldelim();
+      };
+
+      /**
+       * Decodes a Range message from the specified reader or buffer.
+       * @function decode
+       * @memberof ChatMessage.FileContent.Range
+       * @static
+       * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+       * @param {number} [length] Message length if known beforehand
+       * @returns {ChatMessage.FileContent.Range} Range
+       * @throws {Error} If the payload is not a reader or valid buffer
+       * @throws {$protobuf.util.ProtocolError} If required fields are missing
+       */
+      Range.decode = function decode(reader, length) {
+        if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
+        const end = length === undefined ? reader.len : reader.pos + length,
+          message = new $root.ChatMessage.FileContent.Range();
+        while (reader.pos < end) {
+          const tag = reader.uint32();
+          switch (tag >>> 3) {
+            case 1: {
+              message.start = $root.ChatMessage.FileContent.Position.decode(reader, reader.uint32());
+              break;
+            }
+            case 2: {
+              message.end = $root.ChatMessage.FileContent.Position.decode(reader, reader.uint32());
+              break;
+            }
+            default:
+              reader.skipType(tag & 7);
+              break;
+          }
+        }
+        return message;
+      };
+
+      /**
+       * Decodes a Range message from the specified reader or buffer, length delimited.
+       * @function decodeDelimited
+       * @memberof ChatMessage.FileContent.Range
+       * @static
+       * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+       * @returns {ChatMessage.FileContent.Range} Range
+       * @throws {Error} If the payload is not a reader or valid buffer
+       * @throws {$protobuf.util.ProtocolError} If required fields are missing
+       */
+      Range.decodeDelimited = function decodeDelimited(reader) {
+        if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+        return this.decode(reader, reader.uint32());
+      };
+
+      /**
+       * Verifies a Range message.
+       * @function verify
+       * @memberof ChatMessage.FileContent.Range
+       * @static
+       * @param {Object.<string,*>} message Plain object to verify
+       * @returns {string|null} `null` if valid, otherwise the reason why it is not
+       */
+      Range.verify = function verify(message) {
+        let error;
+        if (typeof message !== 'object' || message === null) return 'object expected';
+        if (message.start != null && message.hasOwnProperty('start')) {
+          error = $root.ChatMessage.FileContent.Position.verify(message.start);
+          if (error) return 'start.' + error;
+        }
+        if (message.end != null && message.hasOwnProperty('end')) {
+          error = $root.ChatMessage.FileContent.Position.verify(message.end);
+          if (error) return 'end.' + error;
+        }
+        return null;
+      };
+
+      /**
+       * Creates a Range message from a plain object. Also converts values to their respective internal types.
+       * @function fromObject
+       * @memberof ChatMessage.FileContent.Range
+       * @static
+       * @param {Object.<string,*>} object Plain object
+       * @returns {ChatMessage.FileContent.Range} Range
+       */
+      Range.fromObject = function fromObject(object) {
+        if (object instanceof $root.ChatMessage.FileContent.Range) return object;
+        const message = new $root.ChatMessage.FileContent.Range();
+        if (object.start != null) {
+          if (typeof object.start !== 'object') throw TypeError('.ChatMessage.FileContent.Range.start: object expected');
+          message.start = $root.ChatMessage.FileContent.Position.fromObject(object.start);
+        }
+        if (object.end != null) {
+          if (typeof object.end !== 'object') throw TypeError('.ChatMessage.FileContent.Range.end: object expected');
+          message.end = $root.ChatMessage.FileContent.Position.fromObject(object.end);
+        }
+        return message;
+      };
+
+      /**
+       * Creates a plain object from a Range message. Also converts values to other types if specified.
+       * @function toObject
+       * @memberof ChatMessage.FileContent.Range
+       * @static
+       * @param {ChatMessage.FileContent.Range} message Range
+       * @param {$protobuf.IConversionOptions} [options] Conversion options
+       * @returns {Object.<string,*>} Plain object
+       */
+      Range.toObject = function toObject(message, options) {
+        if (!options) options = {};
+        const object = {};
+        if (options.defaults) {
+          object.start = null;
+          object.end = null;
+        }
+        if (message.start != null && message.hasOwnProperty('start')) object.start = $root.ChatMessage.FileContent.Position.toObject(message.start, options);
+        if (message.end != null && message.hasOwnProperty('end')) object.end = $root.ChatMessage.FileContent.Position.toObject(message.end, options);
+        return object;
+      };
+
+      /**
+       * Converts this Range to JSON.
+       * @function toJSON
+       * @memberof ChatMessage.FileContent.Range
+       * @instance
+       * @returns {Object.<string,*>} JSON object
+       */
+      Range.prototype.toJSON = function toJSON() {
+        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+      };
+
+      /**
+       * Gets the default type url for Range
+       * @function getTypeUrl
+       * @memberof ChatMessage.FileContent.Range
+       * @static
+       * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+       * @returns {string} The default type url
+       */
+      Range.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+        if (typeUrlPrefix === undefined) {
+          typeUrlPrefix = 'type.googleapis.com';
+        }
+        return typeUrlPrefix + '/ChatMessage.FileContent.Range';
+      };
+
+      return Range;
+    })();
+
+    return FileContent;
+  })();
+
+  ChatMessage.UserMessage = (function () {
+    /**
+     * Properties of a UserMessage.
+     * @memberof ChatMessage
+     * @interface IUserMessage
+     * @property {string|null} [content] UserMessage content
+     * @property {number|null} [role] UserMessage role
+     * @property {string|null} [messageId] UserMessage messageId
+     */
+
+    /**
+     * Constructs a new UserMessage.
+     * @memberof ChatMessage
+     * @classdesc Represents a UserMessage.
+     * @implements IUserMessage
+     * @constructor
+     * @param {ChatMessage.IUserMessage=} [properties] Properties to set
+     */
+    function UserMessage(properties) {
+      if (properties) let keys = Object.keys(properties), i = 0; for (; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
+    }
+
+    /**
+     * UserMessage content.
+     * @member {string} content
+     * @memberof ChatMessage.UserMessage
+     * @instance
+     */
+    UserMessage.prototype.content = '';
+
+    /**
+     * UserMessage role.
+     * @member {number} role
+     * @memberof ChatMessage.UserMessage
+     * @instance
+     */
+    UserMessage.prototype.role = 0;
+
+    /**
+     * UserMessage messageId.
+     * @member {string} messageId
+     * @memberof ChatMessage.UserMessage
+     * @instance
+     */
+    UserMessage.prototype.messageId = '';
+
+    /**
+     * Creates a new UserMessage instance using the specified properties.
+     * @function create
+     * @memberof ChatMessage.UserMessage
+     * @static
+     * @param {ChatMessage.IUserMessage=} [properties] Properties to set
+     * @returns {ChatMessage.UserMessage} UserMessage instance
+     */
+    UserMessage.create = function create(properties) {
+      return new UserMessage(properties);
+    };
+
+    /**
+     * Encodes the specified UserMessage message. Does not implicitly {@link ChatMessage.UserMessage.verify|verify} messages.
+     * @function encode
+     * @memberof ChatMessage.UserMessage
+     * @static
+     * @param {ChatMessage.IUserMessage} message UserMessage message or plain object to encode
+     * @param {$protobuf.Writer} [writer] Writer to encode to
+     * @returns {$protobuf.Writer} Writer
+     */
+    UserMessage.encode = function encode(message, writer) {
+      if (!writer) writer = $Writer.create();
+      if (message.content != null && Object.hasOwnProperty.call(message, 'content')) writer.uint32(/* id 1, wireType 2 =*/ 10).string(message.content);
+      if (message.role != null && Object.hasOwnProperty.call(message, 'role')) writer.uint32(/* id 2, wireType 0 =*/ 16).int32(message.role);
+      if (message.messageId != null && Object.hasOwnProperty.call(message, 'messageId')) writer.uint32(/* id 13, wireType 2 =*/ 106).string(message.messageId);
+      return writer;
+    };
+
+    /**
+     * Encodes the specified UserMessage message, length delimited. Does not implicitly {@link ChatMessage.UserMessage.verify|verify} messages.
+     * @function encodeDelimited
+     * @memberof ChatMessage.UserMessage
+     * @static
+     * @param {ChatMessage.IUserMessage} message UserMessage message or plain object to encode
+     * @param {$protobuf.Writer} [writer] Writer to encode to
+     * @returns {$protobuf.Writer} Writer
+     */
+    UserMessage.encodeDelimited = function encodeDelimited(message, writer) {
+      return this.encode(message, writer).ldelim();
+    };
+
+    /**
+     * Decodes a UserMessage message from the specified reader or buffer.
+     * @function decode
+     * @memberof ChatMessage.UserMessage
+     * @static
+     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+     * @param {number} [length] Message length if known beforehand
+     * @returns {ChatMessage.UserMessage} UserMessage
+     * @throws {Error} If the payload is not a reader or valid buffer
+     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+     */
+    UserMessage.decode = function decode(reader, length) {
+      if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
+      const end = length === undefined ? reader.len : reader.pos + length,
+        message = new $root.ChatMessage.UserMessage();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            message.content = reader.string();
+            break;
+          }
+          case 2: {
+            message.role = reader.int32();
+            break;
+          }
+          case 13: {
+            message.messageId = reader.string();
+            break;
+          }
+          default:
+            reader.skipType(tag & 7);
+            break;
+        }
+      }
+      return message;
+    };
+
+    /**
+     * Decodes a UserMessage message from the specified reader or buffer, length delimited.
+     * @function decodeDelimited
+     * @memberof ChatMessage.UserMessage
+     * @static
+     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+     * @returns {ChatMessage.UserMessage} UserMessage
+     * @throws {Error} If the payload is not a reader or valid buffer
+     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+     */
+    UserMessage.decodeDelimited = function decodeDelimited(reader) {
+      if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+      return this.decode(reader, reader.uint32());
+    };
+
+    /**
+     * Verifies a UserMessage message.
+     * @function verify
+     * @memberof ChatMessage.UserMessage
+     * @static
+     * @param {Object.<string,*>} message Plain object to verify
+     * @returns {string|null} `null` if valid, otherwise the reason why it is not
+     */
+    UserMessage.verify = function verify(message) {
+      if (typeof message !== 'object' || message === null) return 'object expected';
+      if (message.content != null && message.hasOwnProperty('content')) if (!$util.isString(message.content)) return 'content: string expected';
+      if (message.role != null && message.hasOwnProperty('role')) if (!$util.isInteger(message.role)) return 'role: integer expected';
+      if (message.messageId != null && message.hasOwnProperty('messageId')) if (!$util.isString(message.messageId)) return 'messageId: string expected';
+      return null;
+    };
+
+    /**
+     * Creates a UserMessage message from a plain object. Also converts values to their respective internal types.
+     * @function fromObject
+     * @memberof ChatMessage.UserMessage
+     * @static
+     * @param {Object.<string,*>} object Plain object
+     * @returns {ChatMessage.UserMessage} UserMessage
+     */
+    UserMessage.fromObject = function fromObject(object) {
+      if (object instanceof $root.ChatMessage.UserMessage) return object;
+      const message = new $root.ChatMessage.UserMessage();
+      if (object.content != null) message.content = String(object.content);
+      if (object.role != null) message.role = object.role | 0;
+      if (object.messageId != null) message.messageId = String(object.messageId);
+      return message;
+    };
+
+    /**
+     * Creates a plain object from a UserMessage message. Also converts values to other types if specified.
+     * @function toObject
+     * @memberof ChatMessage.UserMessage
+     * @static
+     * @param {ChatMessage.UserMessage} message UserMessage
+     * @param {$protobuf.IConversionOptions} [options] Conversion options
+     * @returns {Object.<string,*>} Plain object
+     */
+    UserMessage.toObject = function toObject(message, options) {
+      if (!options) options = {};
+      const object = {};
+      if (options.defaults) {
+        object.content = '';
+        object.role = 0;
+        object.messageId = '';
+      }
+      if (message.content != null && message.hasOwnProperty('content')) object.content = message.content;
+      if (message.role != null && message.hasOwnProperty('role')) object.role = message.role;
+      if (message.messageId != null && message.hasOwnProperty('messageId')) object.messageId = message.messageId;
+      return object;
+    };
+
+    /**
+     * Converts this UserMessage to JSON.
+     * @function toJSON
+     * @memberof ChatMessage.UserMessage
+     * @instance
+     * @returns {Object.<string,*>} JSON object
+     */
+    UserMessage.prototype.toJSON = function toJSON() {
+      return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+    };
+
+    /**
+     * Gets the default type url for UserMessage
+     * @function getTypeUrl
+     * @memberof ChatMessage.UserMessage
+     * @static
+     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+     * @returns {string} The default type url
+     */
+    UserMessage.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+      if (typeUrlPrefix === undefined) {
+        typeUrlPrefix = 'type.googleapis.com';
+      }
+      return typeUrlPrefix + '/ChatMessage.UserMessage';
+    };
+
+    return UserMessage;
+  })();
+
+  ChatMessage.Instructions = (function () {
+    /**
+     * Properties of an Instructions.
+     * @memberof ChatMessage
+     * @interface IInstructions
+     * @property {string|null} [instruction] Instructions instruction
+     */
+
+    /**
+     * Constructs a new Instructions.
+     * @memberof ChatMessage
+     * @classdesc Represents an Instructions.
+     * @implements IInstructions
+     * @constructor
+     * @param {ChatMessage.IInstructions=} [properties] Properties to set
+     */
+    function Instructions(properties) {
+      if (properties) let keys = Object.keys(properties), i = 0; for (; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
+    }
+
+    /**
+     * Instructions instruction.
+     * @member {string} instruction
+     * @memberof ChatMessage.Instructions
+     * @instance
+     */
+    Instructions.prototype.instruction = '';
+
+    /**
+     * Creates a new Instructions instance using the specified properties.
+     * @function create
+     * @memberof ChatMessage.Instructions
+     * @static
+     * @param {ChatMessage.IInstructions=} [properties] Properties to set
+     * @returns {ChatMessage.Instructions} Instructions instance
+     */
+    Instructions.create = function create(properties) {
+      return new Instructions(properties);
+    };
+
+    /**
+     * Encodes the specified Instructions message. Does not implicitly {@link ChatMessage.Instructions.verify|verify} messages.
+     * @function encode
+     * @memberof ChatMessage.Instructions
+     * @static
+     * @param {ChatMessage.IInstructions} message Instructions message or plain object to encode
+     * @param {$protobuf.Writer} [writer] Writer to encode to
+     * @returns {$protobuf.Writer} Writer
+     */
+    Instructions.encode = function encode(message, writer) {
+      if (!writer) writer = $Writer.create();
+      if (message.instruction != null && Object.hasOwnProperty.call(message, 'instruction')) writer.uint32(/* id 1, wireType 2 =*/ 10).string(message.instruction);
+      return writer;
+    };
+
+    /**
+     * Encodes the specified Instructions message, length delimited. Does not implicitly {@link ChatMessage.Instructions.verify|verify} messages.
+     * @function encodeDelimited
+     * @memberof ChatMessage.Instructions
+     * @static
+     * @param {ChatMessage.IInstructions} message Instructions message or plain object to encode
+     * @param {$protobuf.Writer} [writer] Writer to encode to
+     * @returns {$protobuf.Writer} Writer
+     */
+    Instructions.encodeDelimited = function encodeDelimited(message, writer) {
+      return this.encode(message, writer).ldelim();
+    };
+
+    /**
+     * Decodes an Instructions message from the specified reader or buffer.
+     * @function decode
+     * @memberof ChatMessage.Instructions
+     * @static
+     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+     * @param {number} [length] Message length if known beforehand
+     * @returns {ChatMessage.Instructions} Instructions
+     * @throws {Error} If the payload is not a reader or valid buffer
+     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+     */
+    Instructions.decode = function decode(reader, length) {
+      if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
+      const end = length === undefined ? reader.len : reader.pos + length,
+        message = new $root.ChatMessage.Instructions();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            message.instruction = reader.string();
+            break;
+          }
+          default:
+            reader.skipType(tag & 7);
+            break;
+        }
+      }
+      return message;
+    };
+
+    /**
+     * Decodes an Instructions message from the specified reader or buffer, length delimited.
+     * @function decodeDelimited
+     * @memberof ChatMessage.Instructions
+     * @static
+     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+     * @returns {ChatMessage.Instructions} Instructions
+     * @throws {Error} If the payload is not a reader or valid buffer
+     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+     */
+    Instructions.decodeDelimited = function decodeDelimited(reader) {
+      if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+      return this.decode(reader, reader.uint32());
+    };
+
+    /**
+     * Verifies an Instructions message.
+     * @function verify
+     * @memberof ChatMessage.Instructions
+     * @static
+     * @param {Object.<string,*>} message Plain object to verify
+     * @returns {string|null} `null` if valid, otherwise the reason why it is not
+     */
+    Instructions.verify = function verify(message) {
+      if (typeof message !== 'object' || message === null) return 'object expected';
+      if (message.instruction != null && message.hasOwnProperty('instruction')) if (!$util.isString(message.instruction)) return 'instruction: string expected';
+      return null;
+    };
+
+    /**
+     * Creates an Instructions message from a plain object. Also converts values to their respective internal types.
+     * @function fromObject
+     * @memberof ChatMessage.Instructions
+     * @static
+     * @param {Object.<string,*>} object Plain object
+     * @returns {ChatMessage.Instructions} Instructions
+     */
+    Instructions.fromObject = function fromObject(object) {
+      if (object instanceof $root.ChatMessage.Instructions) return object;
+      const message = new $root.ChatMessage.Instructions();
+      if (object.instruction != null) message.instruction = String(object.instruction);
+      return message;
+    };
+
+    /**
+     * Creates a plain object from an Instructions message. Also converts values to other types if specified.
+     * @function toObject
+     * @memberof ChatMessage.Instructions
+     * @static
+     * @param {ChatMessage.Instructions} message Instructions
+     * @param {$protobuf.IConversionOptions} [options] Conversion options
+     * @returns {Object.<string,*>} Plain object
+     */
+    Instructions.toObject = function toObject(message, options) {
+      if (!options) options = {};
+      const object = {};
+      if (options.defaults) object.instruction = '';
+      if (message.instruction != null && message.hasOwnProperty('instruction')) object.instruction = message.instruction;
+      return object;
+    };
+
+    /**
+     * Converts this Instructions to JSON.
+     * @function toJSON
+     * @memberof ChatMessage.Instructions
+     * @instance
+     * @returns {Object.<string,*>} JSON object
+     */
+    Instructions.prototype.toJSON = function toJSON() {
+      return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+    };
+
+    /**
+     * Gets the default type url for Instructions
+     * @function getTypeUrl
+     * @memberof ChatMessage.Instructions
+     * @static
+     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+     * @returns {string} The default type url
+     */
+    Instructions.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+      if (typeUrlPrefix === undefined) {
+        typeUrlPrefix = 'type.googleapis.com';
+      }
+      return typeUrlPrefix + '/ChatMessage.Instructions';
+    };
+
+    return Instructions;
+  })();
+
+  ChatMessage.Model = (function () {
+    /**
+     * Properties of a Model.
+     * @memberof ChatMessage
+     * @interface IModel
+     * @property {string|null} [name] Model name
+     * @property {string|null} [empty] Model empty
+     */
+
+    /**
+     * Constructs a new Model.
+     * @memberof ChatMessage
+     * @classdesc Represents a Model.
+     * @implements IModel
+     * @constructor
+     * @param {ChatMessage.IModel=} [properties] Properties to set
+     */
+    function Model(properties) {
+      if (properties) let keys = Object.keys(properties), i = 0; for (; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
+    }
+
+    /**
+     * Model name.
+     * @member {string} name
+     * @memberof ChatMessage.Model
+     * @instance
+     */
+    Model.prototype.name = '';
+
+    /**
+     * Model empty.
+     * @member {string} empty
+     * @memberof ChatMessage.Model
+     * @instance
+     */
+    Model.prototype.empty = '';
+
+    /**
+     * Creates a new Model instance using the specified properties.
+     * @function create
+     * @memberof ChatMessage.Model
+     * @static
+     * @param {ChatMessage.IModel=} [properties] Properties to set
+     * @returns {ChatMessage.Model} Model instance
+     */
+    Model.create = function create(properties) {
+      return new Model(properties);
+    };
+
+    /**
+     * Encodes the specified Model message. Does not implicitly {@link ChatMessage.Model.verify|verify} messages.
+     * @function encode
+     * @memberof ChatMessage.Model
+     * @static
+     * @param {ChatMessage.IModel} message Model message or plain object to encode
+     * @param {$protobuf.Writer} [writer] Writer to encode to
+     * @returns {$protobuf.Writer} Writer
+     */
+    Model.encode = function encode(message, writer) {
+      if (!writer) writer = $Writer.create();
+      if (message.name != null && Object.hasOwnProperty.call(message, 'name')) writer.uint32(/* id 1, wireType 2 =*/ 10).string(message.name);
+      if (message.empty != null && Object.hasOwnProperty.call(message, 'empty')) writer.uint32(/* id 4, wireType 2 =*/ 34).string(message.empty);
+      return writer;
+    };
+
+    /**
+     * Encodes the specified Model message, length delimited. Does not implicitly {@link ChatMessage.Model.verify|verify} messages.
+     * @function encodeDelimited
+     * @memberof ChatMessage.Model
+     * @static
+     * @param {ChatMessage.IModel} message Model message or plain object to encode
+     * @param {$protobuf.Writer} [writer] Writer to encode to
+     * @returns {$protobuf.Writer} Writer
+     */
+    Model.encodeDelimited = function encodeDelimited(message, writer) {
+      return this.encode(message, writer).ldelim();
+    };
+
+    /**
+     * Decodes a Model message from the specified reader or buffer.
+     * @function decode
+     * @memberof ChatMessage.Model
+     * @static
+     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+     * @param {number} [length] Message length if known beforehand
+     * @returns {ChatMessage.Model} Model
+     * @throws {Error} If the payload is not a reader or valid buffer
+     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+     */
+    Model.decode = function decode(reader, length) {
+      if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
+      const end = length === undefined ? reader.len : reader.pos + length,
+        message = new $root.ChatMessage.Model();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            message.name = reader.string();
+            break;
+          }
+          case 4: {
+            message.empty = reader.string();
+            break;
+          }
+          default:
+            reader.skipType(tag & 7);
+            break;
+        }
+      }
+      return message;
+    };
+
+    /**
+     * Decodes a Model message from the specified reader or buffer, length delimited.
+     * @function decodeDelimited
+     * @memberof ChatMessage.Model
+     * @static
+     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+     * @returns {ChatMessage.Model} Model
+     * @throws {Error} If the payload is not a reader or valid buffer
+     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+     */
+    Model.decodeDelimited = function decodeDelimited(reader) {
+      if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+      return this.decode(reader, reader.uint32());
+    };
+
+    /**
+     * Verifies a Model message.
+     * @function verify
+     * @memberof ChatMessage.Model
+     * @static
+     * @param {Object.<string,*>} message Plain object to verify
+     * @returns {string|null} `null` if valid, otherwise the reason why it is not
+     */
+    Model.verify = function verify(message) {
+      if (typeof message !== 'object' || message === null) return 'object expected';
+      if (message.name != null && message.hasOwnProperty('name')) if (!$util.isString(message.name)) return 'name: string expected';
+      if (message.empty != null && message.hasOwnProperty('empty')) if (!$util.isString(message.empty)) return 'empty: string expected';
+      return null;
+    };
+
+    /**
+     * Creates a Model message from a plain object. Also converts values to their respective internal types.
+     * @function fromObject
+     * @memberof ChatMessage.Model
+     * @static
+     * @param {Object.<string,*>} object Plain object
+     * @returns {ChatMessage.Model} Model
+     */
+    Model.fromObject = function fromObject(object) {
+      if (object instanceof $root.ChatMessage.Model) return object;
+      const message = new $root.ChatMessage.Model();
+      if (object.name != null) message.name = String(object.name);
+      if (object.empty != null) message.empty = String(object.empty);
+      return message;
+    };
+
+    /**
+     * Creates a plain object from a Model message. Also converts values to other types if specified.
+     * @function toObject
+     * @memberof ChatMessage.Model
+     * @static
+     * @param {ChatMessage.Model} message Model
+     * @param {$protobuf.IConversionOptions} [options] Conversion options
+     * @returns {Object.<string,*>} Plain object
+     */
+    Model.toObject = function toObject(message, options) {
+      if (!options) options = {};
+      const object = {};
+      if (options.defaults) {
+        object.name = '';
+        object.empty = '';
+      }
+      if (message.name != null && message.hasOwnProperty('name')) object.name = message.name;
+      if (message.empty != null && message.hasOwnProperty('empty')) object.empty = message.empty;
+      return object;
+    };
+
+    /**
+     * Converts this Model to JSON.
+     * @function toJSON
+     * @memberof ChatMessage.Model
+     * @instance
+     * @returns {Object.<string,*>} JSON object
+     */
+    Model.prototype.toJSON = function toJSON() {
+      return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+    };
+
+    /**
+     * Gets the default type url for Model
+     * @function getTypeUrl
+     * @memberof ChatMessage.Model
+     * @static
+     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+     * @returns {string} The default type url
+     */
+    Model.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+      if (typeUrlPrefix === undefined) {
+        typeUrlPrefix = 'type.googleapis.com';
+      }
+      return typeUrlPrefix + '/ChatMessage.Model';
+    };
+
+    return Model;
+  })();
+
+  return ChatMessage;
+})();
+
+$root.ResMessage = (function () {
+  /**
+   * Properties of a ResMessage.
+   * @exports IResMessage
+   * @interface IResMessage
+   * @property {string|null} [msg] ResMessage msg
+   */
+
+  /**
+   * Constructs a new ResMessage.
+   * @exports ResMessage
+   * @classdesc Represents a ResMessage.
+   * @implements IResMessage
+   * @constructor
+   * @param {IResMessage=} [properties] Properties to set
+   */
+  function ResMessage(properties) {
+    if (properties) let keys = Object.keys(properties), i = 0; for (; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
+  }
+
+  /**
+   * ResMessage msg.
+   * @member {string} msg
+   * @memberof ResMessage
+   * @instance
+   */
+  ResMessage.prototype.msg = '';
+
+  /**
+   * Creates a new ResMessage instance using the specified properties.
+   * @function create
+   * @memberof ResMessage
+   * @static
+   * @param {IResMessage=} [properties] Properties to set
+   * @returns {ResMessage} ResMessage instance
+   */
+  ResMessage.create = function create(properties) {
+    return new ResMessage(properties);
+  };
+
+  /**
+   * Encodes the specified ResMessage message. Does not implicitly {@link ResMessage.verify|verify} messages.
+   * @function encode
+   * @memberof ResMessage
+   * @static
+   * @param {IResMessage} message ResMessage message or plain object to encode
+   * @param {$protobuf.Writer} [writer] Writer to encode to
+   * @returns {$protobuf.Writer} Writer
+   */
+  ResMessage.encode = function encode(message, writer) {
+    if (!writer) writer = $Writer.create();
+    if (message.msg != null && Object.hasOwnProperty.call(message, 'msg')) writer.uint32(/* id 1, wireType 2 =*/ 10).string(message.msg);
+    return writer;
+  };
+
+  /**
+   * Encodes the specified ResMessage message, length delimited. Does not implicitly {@link ResMessage.verify|verify} messages.
+   * @function encodeDelimited
+   * @memberof ResMessage
+   * @static
+   * @param {IResMessage} message ResMessage message or plain object to encode
+   * @param {$protobuf.Writer} [writer] Writer to encode to
+   * @returns {$protobuf.Writer} Writer
+   */
+  ResMessage.encodeDelimited = function encodeDelimited(message, writer) {
+    return this.encode(message, writer).ldelim();
+  };
+
+  /**
+   * Decodes a ResMessage message from the specified reader or buffer.
+   * @function decode
+   * @memberof ResMessage
+   * @static
+   * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+   * @param {number} [length] Message length if known beforehand
+   * @returns {ResMessage} ResMessage
+   * @throws {Error} If the payload is not a reader or valid buffer
+   * @throws {$protobuf.util.ProtocolError} If required fields are missing
+   */
+  ResMessage.decode = function decode(reader, length) {
+    if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
+    const end = length === undefined ? reader.len : reader.pos + length,
+      message = new $root.ResMessage();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          message.msg = reader.string();
+          break;
+        }
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  };
+
+  /**
+   * Decodes a ResMessage message from the specified reader or buffer, length delimited.
+   * @function decodeDelimited
+   * @memberof ResMessage
+   * @static
+   * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+   * @returns {ResMessage} ResMessage
+   * @throws {Error} If the payload is not a reader or valid buffer
+   * @throws {$protobuf.util.ProtocolError} If required fields are missing
+   */
+  ResMessage.decodeDelimited = function decodeDelimited(reader) {
+    if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+    return this.decode(reader, reader.uint32());
+  };
+
+  /**
+   * Verifies a ResMessage message.
+   * @function verify
+   * @memberof ResMessage
+   * @static
+   * @param {Object.<string,*>} message Plain object to verify
+   * @returns {string|null} `null` if valid, otherwise the reason why it is not
+   */
+  ResMessage.verify = function verify(message) {
+    if (typeof message !== 'object' || message === null) return 'object expected';
+    if (message.msg != null && message.hasOwnProperty('msg')) if (!$util.isString(message.msg)) return 'msg: string expected';
+    return null;
+  };
+
+  /**
+   * Creates a ResMessage message from a plain object. Also converts values to their respective internal types.
+   * @function fromObject
+   * @memberof ResMessage
+   * @static
+   * @param {Object.<string,*>} object Plain object
+   * @returns {ResMessage} ResMessage
+   */
+  ResMessage.fromObject = function fromObject(object) {
+    if (object instanceof $root.ResMessage) return object;
+    const message = new $root.ResMessage();
+    if (object.msg != null) message.msg = String(object.msg);
+    return message;
+  };
+
+  /**
+   * Creates a plain object from a ResMessage message. Also converts values to other types if specified.
+   * @function toObject
+   * @memberof ResMessage
+   * @static
+   * @param {ResMessage} message ResMessage
+   * @param {$protobuf.IConversionOptions} [options] Conversion options
+   * @returns {Object.<string,*>} Plain object
+   */
+  ResMessage.toObject = function toObject(message, options) {
+    if (!options) options = {};
+    const object = {};
+    if (options.defaults) object.msg = '';
+    if (message.msg != null && message.hasOwnProperty('msg')) object.msg = message.msg;
+    return object;
+  };
+
+  /**
+   * Converts this ResMessage to JSON.
+   * @function toJSON
+   * @memberof ResMessage
+   * @instance
+   * @returns {Object.<string,*>} JSON object
+   */
+  ResMessage.prototype.toJSON = function toJSON() {
+    return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+  };
+
+  /**
+   * Gets the default type url for ResMessage
+   * @function getTypeUrl
+   * @memberof ResMessage
+   * @static
+   * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+   * @returns {string} The default type url
+   */
+  ResMessage.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+    if (typeUrlPrefix === undefined) {
+      typeUrlPrefix = 'type.googleapis.com';
+    }
+    return typeUrlPrefix + '/ResMessage';
+  };
+
+  return ResMessage;
+})();
+
+module.exports = $root;

src/message.proto

@@ -0,0 +1,51 @@
+syntax = "proto3";
+
+message ChatMessage {
+  message FileContent {
+    message Position {
+      int32 line = 1;
+      int32 column = 2;
+    }
+    message Range {
+      Position start = 1;
+      Position end = 2;
+    }
+
+    string filename = 1;
+    string content = 2;
+    Position position = 3;
+    string language = 5;
+    Range range = 6;
+    int32 length = 8;
+    int32 type = 9;
+    int32 error_code = 11;
+  }
+
+  message UserMessage {
+    string content = 1;
+    int32 role = 2;
+    string message_id = 13;
+  }
+
+  message Instructions {
+    string instruction = 1;
+  }
+
+  message Model {
+    string name = 1;
+    string empty = 4;
+  }
+
+  // repeated FileContent files = 1;
+  repeated UserMessage messages = 2;
+  Instructions instructions = 4;
+  string projectPath = 5;
+  Model model = 7;
+  string requestId = 9;
+  string summary = 11; // Maybe it's empty, describing what the session did, but it's not a title, and it might be used as an additional setting
+  string conversationId = 15; // Here's another one uuid
+}
+
+message ResMessage {
+  string msg = 1;
+}

src/utils.js

@@ -0,0 +1,111 @@
+const { v4: uuidv4 } = require('uuid');
+const zlib = require('zlib');
+const $root = require('./message.js');
+
+const regex = /<\|BEGIN_SYSTEM\|>.*?<\|END_SYSTEM\|>.*?<\|BEGIN_USER\|>.*?<\|END_USER\|>/s;
+
+async function stringToHex(messages, modelName) {
+  const formattedMessages = messages.map((msg) => ({
+    ...msg,
+    role: msg.role === 'user' ? 1 : 2,
+    message_id: uuidv4(),
+  }));
+
+  const message = {
+    messages: formattedMessages,
+    instructions: {
+      instruction: 'Always respond in Russian',
+    },
+    projectPath: '/path/to/project',
+    model: {
+      name: modelName,
+      empty: '',
+    },
+    requestId: uuidv4(),
+    summary: '',
+    conversationId: uuidv4(),
+  };
+  const errMsg = $root.ChatMessage.verify(message);
+  if (errMsg) throw Error(errMsg);
+
+  const messageInstance = $root.ChatMessage.create(message);
+
+  const buffer = $root.ChatMessage.encode(messageInstance).finish();
+  const hexString = (buffer.length.toString(16).padStart(10, '0') + buffer.toString('hex')).toUpperCase();
+
+  return Buffer.from(hexString, 'hex');
+}
+
+async function chunkToUtf8String(chunk) {
+  try {
+    let hex = Buffer.from(chunk).toString('hex');
+
+    let offset = 0;
+    let results = [];
+
+    while (offset < hex.length) {
+      if (offset + 10 > hex.length) break;
+
+      const dataLength = parseInt(hex.slice(offset, offset + 10), 16);
+      offset += 10;
+
+      if (offset + dataLength * 2 > hex.length) break;
+
+      const messageHex = hex.slice(offset, offset + dataLength * 2);
+      offset += dataLength * 2;
+
+      const messageBuffer = Buffer.from(messageHex, 'hex');
+      const message = $root.ResMessage.decode(messageBuffer);
+      results.push(message.msg);
+    }
+
+    if (results.length == 0) {
+      return gunzip(chunk);
+    }
+    return results.join('');
+  } catch (err) {
+    return gunzip(chunk);
+  }
+}
+
+function gunzip(chunk) {
+  return new Promise((resolve, reject) => {
+    zlib.gunzip(chunk.slice(5), (err, decompressed) => {
+      if (err) {
+        resolve('');
+      } else {
+        const text = decompressed.toString('utf-8');
+        // 这里只是尝试解析错误数据，如果是包含了全量的返回结果直接忽略
+        if (regex.test(text)) {
+          resolve('');
+        } else {
+          resolve(text);
+        }
+      }
+    });
+  });
+}
+
+function getRandomIDPro({ size, dictType, customDict }) {
+  let random = '';
+  if (!customDict) {
+    switch (dictType) {
+      case 'alphabet':
+        customDict = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
+        break;
+      case 'max':
+        customDict = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_-';
+        break;
+      default:
+        customDict = '0123456789';
+    }
+  }
+  for (; size--; ) random += customDict[(Math.random() * customDict.length) | 0];
+  return random;
+}
+
+module.exports = {
+  stringToHex,
+  chunkToUtf8String,
+  getRandomIDPro,
+};