ChatGPT智能问答AI使用指南

1. 前言

人工智能研究公司 OpenAI 于2022年11月正式推出 ChatGPT，这是一种基于对话的人工智能聊天机器人模型，它能够理解自然语言并以自然语言的方式做出回应。

ChatGPT 基于 GPT-3.5 模型微调而成，以语言服务模型 InstructGPT 为基础，通过人类回馈增强学习训练模型 RLHF，不过数据设置略有不同。它以对话方式进行交互，既能够做到回答问题，也能承认错误、质疑不正确的前提以及拒绝不恰当的请求，能以更贴近一般人的对话方式与使用者互动。

大约七年前，马斯克和OpenAI现任CEO萨姆·奥特曼及其他投资者共同创立了这个公司。2018年，由于一些分歧，马斯克离开了公司。近日，已成为推特新老板的马斯克发推“认可”了他曾经投资的这个项目。他说：“ChatGPT好得吓人。伴随危险，我们离强大的人工智能不远了。”

这几天许多用户都展示了与 ChatGPT 对话的有趣内容，各种问题轻松应答，给出的答案不仅条理清晰，还会引用例子支撑观点。让它帮忙写程序，不仅提供了可用的代码，更是把实现思路也一并写了出来。不过它用2021年之前的数据训练的，所以2022年之后的事情它不知道，回答仍然有一些错误。

2. 注册OpenAI账号

2.1 前提条件

2.1.1 准备境外代理

注册OpenAI和使用ChatGPT都需要境外代理，如果你对科学上网还不了解，可以先看我的另一篇博客：使用SSR或Trojan-Go科学上网 (opens new window)

2.1.2 准备境外手机号验证

必须使用境外真实手机号进行验证，中国大陆及港澳台的手机号不可用，境外的虚拟手机号也不可用。如果没有境外真实手机号，可以找付费接码平台解决，免费的就不要想了，能白嫖的早就被别人白嫖过了，别人绑定过你就不能再绑定了。

Step1：注册短信接码平台账号并充值

可是使用毛子的付费接码平台：https://sms-activate.org/cn (opens new window)

• 注册过程：注册过程没啥好说的，需要注意的一点是，我一开始使用Gmail注册，但邮箱的确认链接是无效的，后来换成163邮箱，就好使了。
• 充值过程：接码费用一次为 10.5 卢布，大约1.2 RMB。支持使用支付宝，充值0.2美刀（约合1.5RMB）就足够用了，这个网站会按照卢布进行计费。

Step2：购买OpenAI接码服务

在左侧的搜索框里搜索“OpenAI”服务，国家选择印度（买之前查看一下OpenAI当前还支持哪些国家注册），买入接码服务。

2.2 注册步骤

2.2.1 注册账号

这里需要提前把境外代理打开，且 IP 不是香港，最好是美国、新加坡等，不然会提示不能在当前国家服务。

• 打开 https://openai.com/api/ (opens new window) 页面点击“注册”按钮并进行注册即可，没有什么需要特别注意的。

2.2.2 绑定境外手机号

注册完账号之后，需要绑定境外手机号才行，这里使用2.1.2节的接码平台绑定境外手机号。

• 注意需要切换一下国家区号，这里的区号默认是你代理的。

绑定成功之后，就可以进入到ChatGPT的主页面啦。

3. ChatGPT的基本使用

网页版直接在输入框里输入问题即可，下面是一些例子。

[1] 用简单的术语解释量子计算

[2] 如何实现中华民族伟大复兴

[3] 根据 Midjourney 的格式，用英文给我一段生成猫窝的 text prompt

[4] 介绍一下MQTT协议

[5] 用python帮我写一段冒泡排序的代码

这里生成的代码经过格式调整后是可以正确执行的：

def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        for j in range(0, n-i-1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]

arr = [64, 34, 25, 12, 22, 11, 90]
bubble_sort(arr)

print("排序后的数组:")
for i in range(len(arr)):
    print("%d" %arr[i])
    
>>> 输出内容
排序后的数组:
11
12
22
25
34
64
90

[6] 帮我写一篇MES软件的技术路线说明书

[7] 作一首关于雪的诗

[8] 你可以取代Google搜索引擎吗

4. 使用PyChatGPT调用ChatGPT

4.1 PyChatGPT项目简介

PyChatGPT：基于 TLS 的 ChatGPT API，具有自动指令牌重生成、代理支持等功能。

• 项目地址：https://github.com/rawandahmad698/PyChatGPT (opens new window)

具备以下特性：代理支持、无需浏览器自动登录、自动抓取Access Token、绕过登录验证码（如果您随后尝试登录，系统将提示您解决验证码问题）、将访问令牌保存到文件中，因此您无需再次登录、过期时自动刷新访问令牌、使用 colorama 为输出着色、智能对话跟踪。

4.2 使用PyChatGPT项目

该项目处于快速更新状态，代码变更比较快， 以下使用示例采用的是2022.12.6版本的。

注：2022.12.11，OpenAI 添加了额外的 Cloudflare 保护措施，使访问非官方 API 变得更加困难（2022.12.6版本的已经不可用），原作者说会对这个项目持续更新，大家去用最新版的吧。

Step1：安装项目依赖

$ pip install -r requirements.txt

Step1：在config.json文件里填写你的OpenAI账号信息

{
  "email": "[email protected]",
  "password": "your_password"
}

Step2：修改main.py代码设置代理

代码里有两处需要设置代理的地方，我这里使用的是ClashX，默认端口号7890，改成自己实际的即可。

# open_ai_auth = Auth.OpenAIAuth(email_address=email, password=password)
open_ai_auth = Auth.OpenAIAuth(email_address=email, password=password, use_proxy=True, proxy="http://127.0.0.1:7890")

注：如果未设置代理，可能会导致出现IndexError: list index out of range的错误，详见此 Issues (opens new window)

Step3：执行main.py文件，将程序运行起来，可以与之交互性问答。

5. 使用ChatGPT官方API

ChatGPT官方API大约是2023年1月26日开始内测的，当前OpenAI官网上也没有任何接口介绍和文档，这对于开发和调用来说不怎么方便。但是，比较好的地方在于内测过程中调用是免费的，没有次数限制。此外，API接口调用不需要梯子或代理。

注：ChatGPT官方API只是在内测过程中调用免费，后续肯定是会收费的，一直白嫖想都不要想。

5.1 申请ChatGPT API密钥

登录账号，点击Create new secret key按钮即可创建，生成的密钥要保存好且不要泄露。

申请地址：https://platform.openai.com/account/api-keys (opens new window)

5.2 Python调用ChatGPT官方API

以下是在2023.2.11使用ChatGPT官方API的示例，后续若参数及返回参数发生变更，请自行查阅最新的官方API文档（若是出了的话）及相关资料。

依赖安装：

$ pip install openai

调用示例：

# -*- coding: utf-8 -*-

import openai

openai.api_key = "your_api_key"
response = openai.Completion.create(
  model="text-davinci-003",
  prompt="解释一下量子力学",
  temperature=0.7,
  max_tokens=2048,
  top_p=1,
  frequency_penalty=0,
  presence_penalty=0
)
print(response)
print(response["choices"][0]["text"])

GPT3模型调用方式如下，输入主要有7个参数：

• model：模型名称，text-davinci-003
• prompt：问题或待补全内容，例如“解释一下量子力学”。
• temperature：控制结果随机性，0.0表示结果固定，随机性大可以设置为0.9。
• max_tokens：最大返回字数（包括问题和答案），通常汉字占两个token。假设设置成100，如果prompt问题中有40个汉字，那么返回结果中最多包括10个汉字。
• top_p：设置为1即可。
• frequency_penalty：设置为0即可。
• presence_penalty：设置为0即可。

返回值：

{
  "choices": [
    {
      "finish_reason": "stop",
      "index": 0,
      "logprobs": null,
      "text": "\n\n\u91cf\u5b50\u529b\u5b66\u662f\u7269\u7406\u5b66\u7684\u4e00\u4e2a\u5206\u652f\uff0c\u5b83\u7814\u7a76\u7c92\u5b50\u5728\u5fae\u89c2\u5c3a\u5ea6\u4e0a\u7684\u884c\u4e3a\u3002\u91cf\u5b50\u529b\u5b66\u63cf\u8ff0\u7269\u8d28\u7684\u57fa\u672c\u7c92\u5b50\uff0c\u5982\u7535\u5b50\uff0c\u8d28\u5b50\uff0c\u4e2d\u5b50\u548c\u539f\u5b50\u7684\u884c\u4e3a\uff0c\u4ee5\u53ca\u5b83\u4eec\u4e4b\u95f4\u7684\u76f8\u4e92\u4f5c\u7528\u3002\u5b83\u91c7\u7528\u7ecf\u5178\u529b\u5b66\u7684\u6982\u5ff5\uff0c\u5982\u529b\uff0c\u52a8\u80fd\u548c\u52a8\u91cf\uff0c\u4f46\u4e5f\u63d0\u51fa\u4e86\u65b0\u7684\u6982\u5ff5\uff0c\u5982\u91cf\u5b50\u72b6\u6001\uff0c\u6ce2\u51fd\u6570\u548c\u91cf\u5b50\u5e72\u6d89\u3002\u91cf\u5b50\u529b\u5b66\u901a\u8fc7\u89e3\u51b3\u65b9\u7a0b\u6765\u63cf\u8ff0\u7c92\u5b50\u7684\u6027\u8d28\uff0c\u5176\u4e2d\u5305\u62ec\u6ce2\u52a8\u65b9\u7a0b\uff0cSchr\u00f6dinger\u65b9\u7a0b\uff0cHeisenberg\u4e0d\u786e\u5b9a\u6027\u539f\u7406\u548cPauli\u7981\u6b62\u5b9a\u5f8b\u3002"
    }
  ],
  "created": 1676122039,
  "id": "cmpl-6ikCNyZzoOPscevgIBZ0RaPHONdzz",
  "model": "text-davinci-003",
  "object": "text_completion",
  "usage": {
    "completion_tokens": 338,
    "prompt_tokens": 15,
    "total_tokens": 353
  }
}

量子力学是物理学的一个分支，它研究粒子在微观尺度上的行为。量子力学描述物质的基本粒子，如电子，质子，中子和原子的行为，以及它们之间的相互作用。它采用经典力学的概念，如力，动能和动量，但也提出了新的概念，如量子状态，波函数和量子干涉。量子力学通过解决方程来描述粒子的性质，其中包括波动方程，Schrödinger方程，Heisenberg不确定性原理和Pauli禁止定律。

注意事项：

[1] ChatGPT API允许的最大token数量为4097，即max_tokens最大设置为4097减去prompt问题的token数量。

[2] 输入参数可以增加stream，即是否采用控制流的方式输出。如果steam取值为True时，那么返回结果是一个Python generator，需要通过迭代获取结果，读取结果的结束字段为“<|im_end|>”。

# -*- coding: utf-8 -*-

import openai

openai.api_key = "your_api_key"
response = openai.Completion.create(
  model="text-davinci-003",
  prompt="解释一下量子力学",
  temperature=0.7,
  max_tokens=2048,
  stream=True,
  top_p=1,
  frequency_penalty=0,
  presence_penalty=0
)

print(response)
res = ''
for r in response:
    res += r["choices"][0]["text"]
res = res.replace('<|im_end|>', '')
print(res)

返回值：

<generator object EngineAPIResource.create.<locals>.<genexpr> at 0x122ff6a50>

量子力学是研究物质的微观结构的物理学理论。它用来描述物质的基本粒子，即原子、分子、离子等，及其组成物质的相互作用，以及物质在微观尺度上的性质。量子力学的思想是由普朗克和爱因斯坦在20世纪初提出的，它被认为是20世纪物理学的里程碑。量子力学的思想主要是由量子概念引出，即物质不是连续的物体，而是由粒子构成的。量子力学将物理系统的属性描述为“波函数”，即粒子的状态可以用量子概率的方式表示。量子力学的研究已经在原子物理、分子物理、物质的结构和性质、粒子物理、原子核物理等领域取得了显著成果。

5.3 将ChatGPT通过快捷指令接入Siri

可以通过快捷指令的方式将ChatGPT接入Siri。

• Step1：注册ChatGPT账户，获取API Key并复制：https://platform.openai.com/account/api-keys (opens new window)
• Step2：用Safari打开链接，一键安装Siri同学快捷方式：https://www.icloud.com/shortcuts/ca5272477171422296098fb726dd16f8 (opens new window)
• Step3：打开快捷指令找到Siri同学，点击三个小点，在第一个文本框把文字内容删除，并粘贴刚刚复制好的API Key
• Step4：可以使用该快捷指令使用ChatGPT了（第一次使用会提示请求连接OpenAI的API，选择允许即可）

5.4 将ChatGPT接入划词翻译浏览器插件

基于 ChatGPT API 的划词翻译浏览器插件和跨平台桌面端应用。它的使用也非常简单，下载插件 / 应用之后，填入你的 OpenAI API Key 就能使用。

特性：1）支持 55 种语言的相互翻译、润色和总结功能。2）支持实时翻译、润色和总结，以最快的速度响应用户。3）支持自定义翻译文本。4）支持一键复制。5）全平台（Windows + macOS + Linux）支持。

• 项目地址：https://github.com/yetone/openai-translator (opens new window)
• Chrome应用商店在线安装：https://chrome.google.com/webstore/detail/openai-translator/ogjibjphoadhljaoicdnjnmgokohngcc (opens new window)

6. 将ChatGPT接入Telegram Bot

6.1 申请自己的 Telegram Bot

6.1.1 申请 Telegram Bot

找 BotFather 官方机器人申请自己的 Telegram Bot，需要记录下：BotName、TOKEN、CHATID等信息。

• Step1：在Telegram中添加BotFather这个账号，然后依次发送/start，/newbot，按照提示即可创建一个新的机器人。记下来给你生成的token。
• Step2：搜索刚刚创建的机器人的名字，并给它发送一条消息。（注意：需要先与机器人之间创建会话，机器人才能下发消息，否则机器人无法主动发送消息）
• Step3：在Telegram中搜索userinfobot，并给它发送一条消息，它会返回给你chatid，将它也记下来。

6.1.2 修改 Telegram Bot 头像

还是找 BotFather 官方机器人，先发送/setuserpic，它会让你选择为哪个Bot修改，选择完之后发送头像图片给它即可。

注：头像以图片的形式发送，不要以文件的形式发送（发送时点上那个压缩图片即为图片的形式发送）

6.2 将ChatGPT接入Telegram Bot的开源项目

6.2.1 相关开源项目

将ChatGPT接入Telegram Bot的开源项目有很多，以下是我认为比较好的两个：

• https://github.com/TBXark/ChatGPT-Telegram-Workers (opens new window)（JS开发的，可通过Cloudflare Workers免服务器部署，交互按钮是中文的）
• https://github.com/karfly/chatgpt_telegram_bot (opens new window)（Python开发的，可通过Docker部署，交互按钮是英文的）

以下我采用了Cloudflare Workers免服务器部署ChatGPT-Telegram-Workers项目的方式。

• 需要提前准备好：ChatGPT API密钥、Telegram Bot的Token和CHATID

6.2.2 部署Workers

Step1：打开 Cloudflare Workers (opens new window) 注册账号

Step2：点击右上角的 Create a Service

Step3：进入新建的workers, 选择Quick Edit, 将 index.js (opens new window) 代码复制到编辑器中，保存

// src/env.js
var ENV_VALUE_TYPE = {
  API_KEY: "string"
};
var ENV = {
  // OpenAI API Key
  API_KEY: null,
  // OpenAI的模型名称
  CHAT_MODEL: "gpt-3.5-turbo",
  // 允许访问的Telegram Token， 设置时以逗号分隔
  TELEGRAM_AVAILABLE_TOKENS: [],
  // 允许访问的Telegram Token 对应的Bot Name， 设置时以逗号分隔
  TELEGRAM_BOT_NAME: [],
  // 允许所有人使用
  I_AM_A_GENEROUS_PERSON: false,
  // 白名单
  CHAT_WHITE_LIST: [],
  // 群组白名单
  CHAT_GROUP_WHITE_LIST: [],
  // 群组机器人开关
  GROUP_CHAT_BOT_ENABLE: true,
  // 群组机器人共享模式,关闭后，一个群组只有一个会话和配置。开启的话群组的每个人都有自己的会话上下文
  GROUP_CHAT_BOT_SHARE_MODE: false,
  // 为了避免4096字符限制，将消息删减
  AUTO_TRIM_HISTORY: true,
  // 最大历史记录长度
  MAX_HISTORY_LENGTH: 20,
  // 全局默认初始化消息
  SYSTEM_INIT_MESSAGE: "\u4F60\u662F\u4E00\u4E2A\u5F97\u529B\u7684\u52A9\u624B",
  // 全局默认初始化消息角色
  SYSTEM_INIT_MESSAGE_ROLE: "system",
  // 是否开启使用统计
  ENABLE_USAGE_STATISTICS: false,
  // 隐藏部分命令按钮
  HIDE_COMMAND_BUTTONS: [],
  // 检查更新的分支
  UPDATE_BRANCH: "master",
  // 当前版本
  BUILD_TIMESTAMP: 1678546663,
  // 当前版本 commit id
  BUILD_VERSION: "94c81f1",
  // DEBUG 专用
  // 调试模式
  DEBUG_MODE: false,
  // 开发模式
  DEV_MODE: false,
  // Inline keyboard: 实验性功能请勿开启
  INLINE_KEYBOARD_ENABLE: [],
  TELEGRAM_API_DOMAIN: "https://api.telegram.org",
  OPENAI_API_DOMAIN: "https://api.openai.com"
};
var CONST = {
  PASSWORD_KEY: "chat_history_password",
  GROUP_TYPES: ["group", "supergroup"]
};
var DATABASE = null;
function initEnv(env) {
  DATABASE = env.DATABASE;
  for (const key in ENV) {
    if (env[key]) {
      switch (ENV_VALUE_TYPE[key] || typeof ENV[key]) {
        case "number":
          ENV[key] = parseInt(env[key]) || ENV[key];
          break;
        case "boolean":
          ENV[key] = (env[key] || "false") === "true";
          break;
        case "string":
          ENV[key] = env[key];
          break;
        case "object":
          if (Array.isArray(ENV[key])) {
            ENV[key] = env[key].split(",");
          } else {
            try {
              ENV[key] = JSON.parse(env[key]);
            } catch (e) {
              console.error(e);
            }
          }
          break;
        default:
          ENV[key] = env[key];
          break;
      }
    }
  }
  {
    if (env.TELEGRAM_TOKEN && !ENV.TELEGRAM_AVAILABLE_TOKENS.includes(env.TELEGRAM_TOKEN)) {
      if (env.BOT_NAME && ENV.TELEGRAM_AVAILABLE_TOKENS.length === ENV.TELEGRAM_BOT_NAME.length) {
        ENV.TELEGRAM_BOT_NAME.push(env.BOT_NAME);
      }
      ENV.TELEGRAM_AVAILABLE_TOKENS.push(env.TELEGRAM_TOKEN);
    }
  }
}

// src/context.js
var USER_CONFIG = {
  // 系统初始化消息
  SYSTEM_INIT_MESSAGE: ENV.SYSTEM_INIT_MESSAGE,
  // OpenAI API 额外参数
  OPENAI_API_EXTRA_PARAMS: {}
};
var USER_DEFINE = {
  // 自定义角色
  ROLE: {}
};
var CURRENT_CHAT_CONTEXT = {
  chat_id: null,
  reply_to_message_id: null,
  // 如果是群组，这个值为消息ID，否则为null
  parse_mode: "Markdown"
};
var SHARE_CONTEXT = {
  currentBotId: null,
  // 当前机器人 ID
  currentBotToken: null,
  // 当前机器人 Token
  currentBotName: null,
  // 当前机器人名称: xxx_bot
  chatHistoryKey: null,
  // history:chat_id:bot_id:(from_id)
  configStoreKey: null,
  // user_config:chat_id:bot_id:(from_id)
  groupAdminKey: null,
  // group_admin:group_id
  usageKey: null,
  // usage:bot_id
  chatType: null,
  // 会话场景, private/group/supergroup 等, 来源 message.chat.type
  chatId: null,
  // 会话 id, private 场景为发言人 id, group/supergroup 场景为群组 id
  speakerId: null
  // 发言人 id
};
function initChatContext(chatId, replyToMessageId) {
  CURRENT_CHAT_CONTEXT.chat_id = chatId;
  CURRENT_CHAT_CONTEXT.reply_to_message_id = replyToMessageId;
  if (replyToMessageId) {
    CURRENT_CHAT_CONTEXT.allow_sending_without_reply = true;
  }
}
async function initUserConfig(storeKey) {
  try {
    const userConfig = JSON.parse(await DATABASE.get(storeKey));
    for (const key in userConfig) {
      if (key === "USER_DEFINE" && typeof USER_DEFINE === typeof userConfig[key]) {
        initUserDefine(userConfig[key]);
      } else {
        if (USER_CONFIG.hasOwnProperty(key) && typeof USER_CONFIG[key] === typeof userConfig[key]) {
          USER_CONFIG[key] = userConfig[key];
        }
      }
    }
  } catch (e) {
    console.error(e);
  }
}
function initUserDefine(userDefine) {
  for (const key in userDefine) {
    if (USER_DEFINE.hasOwnProperty(key) && typeof USER_DEFINE[key] === typeof userDefine[key]) {
      USER_DEFINE[key] = userDefine[key];
    }
  }
}
function initTelegramContext(request) {
  const { pathname } = new URL(request.url);
  const token = pathname.match(
    /^\/telegram\/(\d+:[A-Za-z0-9_-]{35})\/webhook/
  )[1];
  const telegramIndex = ENV.TELEGRAM_AVAILABLE_TOKENS.indexOf(token);
  if (telegramIndex === -1) {
    throw new Error("Token not allowed");
  }
  SHARE_CONTEXT.currentBotToken = token;
  SHARE_CONTEXT.currentBotId = token.split(":")[0];
  if (ENV.TELEGRAM_BOT_NAME.length > telegramIndex) {
    SHARE_CONTEXT.currentBotName = ENV.TELEGRAM_BOT_NAME[telegramIndex];
  }
}
async function initShareContext(message) {
  SHARE_CONTEXT.usageKey = `usage:${SHARE_CONTEXT.currentBotId}`;
  const id = message?.chat?.id;
  if (id === void 0 || id === null) {
    throw new Error("Chat id not found");
  }
  const botId = SHARE_CONTEXT.currentBotId;
  let historyKey = `history:${id}`;
  let configStoreKey = `user_config:${id}`;
  let groupAdminKey = null;
  if (botId) {
    historyKey += `:${botId}`;
    configStoreKey += `:${botId}`;
  }
  if (CONST.GROUP_TYPES.includes(message.chat?.type)) {
    if (!ENV.GROUP_CHAT_BOT_SHARE_MODE && message.from.id) {
      historyKey += `:${message.from.id}`;
      configStoreKey += `:${message.from.id}`;
    }
    groupAdminKey = `group_admin:${id}`;
  }
  SHARE_CONTEXT.chatHistoryKey = historyKey;
  SHARE_CONTEXT.configStoreKey = configStoreKey;
  SHARE_CONTEXT.groupAdminKey = groupAdminKey;
  SHARE_CONTEXT.chatType = message.chat?.type;
  SHARE_CONTEXT.chatId = message.chat.id;
  SHARE_CONTEXT.speakerId = message.from.id || message.chat.id;
}
async function initContext(message) {
  console.log(ENV);
  const chatId = message?.chat?.id;
  const replyId = CONST.GROUP_TYPES.includes(message.chat?.type) ? message.message_id : null;
  initChatContext(chatId, replyId);
  console.log(CURRENT_CHAT_CONTEXT);
  await initShareContext(message);
  console.log(SHARE_CONTEXT);
  await initUserConfig(SHARE_CONTEXT.configStoreKey);
  console.log(USER_CONFIG);
}

// src/telegram.js
async function sendMessage(message, token, context) {
  return await fetch(
    `${ENV.TELEGRAM_API_DOMAIN}/bot${token}/sendMessage`,
    {
      method: "POST",
      headers: {
        "Content-Type": "application/json"
      },
      body: JSON.stringify({
        ...context,
        text: message
      })
    }
  );
}
async function sendMessageToTelegram(message, token, context) {
  console.log("\u53D1\u9001\u6D88\u606F:\n", message);
  const botToken = token || SHARE_CONTEXT.currentBotToken;
  const chatContext = context || CURRENT_CHAT_CONTEXT;
  if (message.length <= 4096) {
    return await sendMessage(message, botToken, chatContext);
  }
  console.log("\u6D88\u606F\u5C06\u5206\u6BB5\u53D1\u9001");
  const limit = 4e3;
  chatContext.parse_mode = "HTML";
  for (let i = 0; i < message.length; i += limit) {
    const msg = message.slice(i, i + limit);
    await sendMessage(`<pre>
${msg}
</pre>`, botToken, chatContext);
  }
  return new Response("MESSAGE BATCH SEND", { status: 200 });
}
async function sendPhotoToTelegram(url, token, context) {
  const chatContext = Object.assign(context || CURRENT_CHAT_CONTEXT, { parse_mode: null });
  return await fetch(
    `${ENV.TELEGRAM_API_DOMAIN}/bot${token || SHARE_CONTEXT.currentBotToken}/sendPhoto`,
    {
      method: "POST",
      headers: {
        "Content-Type": "application/json"
      },
      body: JSON.stringify({
        ...chatContext,
        photo: url
      })
    }
  );
}
async function sendChatActionToTelegram(action, token) {
  return await fetch(
    `${ENV.TELEGRAM_API_DOMAIN}/bot${token || SHARE_CONTEXT.currentBotToken}/sendChatAction`,
    {
      method: "POST",
      headers: {
        "Content-Type": "application/json"
      },
      body: JSON.stringify({
        chat_id: CURRENT_CHAT_CONTEXT.chat_id,
        action
      })
    }
  ).then((res) => res.json());
}
async function bindTelegramWebHook(token, url) {
  return await fetch(
    `${ENV.TELEGRAM_API_DOMAIN}/bot${token}/setWebhook`,
    {
      method: "POST",
      headers: {
        "Content-Type": "application/json"
      },
      body: JSON.stringify({
        url
      })
    }
  ).then((res) => res.json());
}
async function getChatRole(id) {
  let groupAdmin;
  try {
    groupAdmin = JSON.parse(await DATABASE.get(SHARE_CONTEXT.groupAdminKey));
  } catch (e) {
    console.error(e);
    return e.message;
  }
  if (!groupAdmin || !Array.isArray(groupAdmin) || groupAdmin.length === 0) {
    const administers = await getChatAdminister(CURRENT_CHAT_CONTEXT.chat_id);
    if (administers == null) {
      return null;
    }
    groupAdmin = administers;
    await DATABASE.put(
      SHARE_CONTEXT.groupAdminKey,
      JSON.stringify(groupAdmin),
      { expiration: parseInt(Date.now() / 1e3) + 120 }
    );
  }
  for (let i = 0; i < groupAdmin.length; i++) {
    const user = groupAdmin[i];
    if (user.user.id === id) {
      return user.status;
    }
  }
  return "member";
}
async function getChatAdminister(chatId, token) {
  try {
    const resp = await fetch(
      `${ENV.TELEGRAM_API_DOMAIN}/bot${token || SHARE_CONTEXT.currentBotToken}/getChatAdministrators`,
      {
        method: "POST",
        headers: {
          "Content-Type": "application/json"
        },
        body: JSON.stringify({ chat_id: chatId })
      }
    ).then((res) => res.json());
    if (resp.ok) {
      return resp.result;
    }
  } catch (e) {
    console.error(e);
    return null;
  }
}
async function getBot(token) {
  const resp = await fetch(
    `${ENV.TELEGRAM_API_DOMAIN}/bot${token}/getMe`,
    {
      method: "POST",
      headers: {
        "Content-Type": "application/json"
      }
    }
  ).then((res) => res.json());
  if (resp.ok) {
    return {
      ok: true,
      info: {
        name: resp.result.first_name,
        bot_name: resp.result.username,
        can_join_groups: resp.result.can_join_groups,
        can_read_all_group_messages: resp.result.can_read_all_group_messages
      }
    };
  } else {
    return resp;
  }
}

// src/openai.js
async function requestCompletionsFromChatGPT(message, history) {
  const body = {
    model: ENV.CHAT_MODEL,
    ...USER_CONFIG.OPENAI_API_EXTRA_PARAMS,
    messages: [...history || [], { role: "user", content: message }]
  };
  const resp = await fetch(`${ENV.OPENAI_API_DOMAIN}/v1/chat/completions`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "Authorization": `Bearer ${ENV.API_KEY}`
    },
    body: JSON.stringify(body)
  }).then((res) => res.json());
  if (resp.error?.message) {
    throw new Error(`OpenAI API \u9519\u8BEF
> ${resp.error.message}`);
  }
  setTimeout(() => updateBotUsage(resp.usage).catch(console.error), 0);
  return resp.choices[0].message.content;
}
async function requestImageFromOpenAI(prompt) {
  const body = {
    prompt,
    n: 1,
    size: "512x512"
  };
  const resp = await fetch(`${ENV.OPENAI_API_DOMAIN}/v1/images/generations`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "Authorization": `Bearer ${ENV.API_KEY}`
    },
    body: JSON.stringify(body)
  }).then((res) => res.json());
  if (resp.error?.message) {
    throw new Error(`OpenAI API \u9519\u8BEF
> ${resp.error.message}`);
  }
  return resp.data[0].url;
}
async function updateBotUsage(usage) {
  if (!ENV.ENABLE_USAGE_STATISTICS) {
    return;
  }
  let dbValue = JSON.parse(await DATABASE.get(SHARE_CONTEXT.usageKey));
  if (!dbValue) {
    dbValue = {
      tokens: {
        total: 0,
        chats: {}
      }
    };
  }
  dbValue.tokens.total += usage.total_tokens;
  if (!dbValue.tokens.chats[SHARE_CONTEXT.chatId]) {
    dbValue.tokens.chats[SHARE_CONTEXT.chatId] = usage.total_tokens;
  } else {
    dbValue.tokens.chats[SHARE_CONTEXT.chatId] += usage.total_tokens;
  }
  await DATABASE.put(SHARE_CONTEXT.usageKey, JSON.stringify(dbValue));
}

// src/utils.js
function randomString(length) {
  const chars = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
  let result = "";
  for (let i = length; i > 0; --i)
    result += chars[Math.floor(Math.random() * chars.length)];
  return result;
}
async function historyPassword() {
  let password = await DATABASE.get(CONST.PASSWORD_KEY);
  if (password === null) {
    password = randomString(32);
    await DATABASE.put(CONST.PASSWORD_KEY, password);
  }
  return password;
}
function renderHTML(body) {
  return `
<html>  
  <head>
    <title>ChatGPT-Telegram-Workers</title>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <meta name="description" content="ChatGPT-Telegram-Workers">
    <meta name="author" content="TBXark">
    <style>
      body {
        font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol";
        font-size: 1rem;
        font-weight: 400;
        line-height: 1.5;
        color: #212529;
        text-align: left;
        background-color: #fff;
      }
      h1 {
        margin-top: 0;
        margin-bottom: 0.5rem;
      }
      p {
        margin-top: 0;
        margin-bottom: 1rem;
      }
      a {
        color: #007bff;
        text-decoration: none;
        background-color: transparent;
      }
      a:hover {
        color: #0056b3;
        text-decoration: underline;
      }
      strong {
        font-weight: bolder;
      }
    </style>
  </head>
  <body>
    ${body}
  </body>
</html>
  `;
}
function errorToString(e) {
  return JSON.stringify({
    message: e.message,
    stack: e.stack
  });
}
function mergeConfig(config, key, value) {
  switch (typeof config[key]) {
    case "number":
      config[key] = Number(value);
      break;
    case "boolean":
      config[key] = value === "true";
      break;
    case "string":
      config[key] = value;
      break;
    case "object":
      const object = JSON.parse(value);
      if (typeof object === "object") {
        config[key] = object;
        break;
      }
      throw new Error("\u4E0D\u652F\u6301\u7684\u914D\u7F6E\u9879\u6216\u6570\u636E\u7C7B\u578B\u9519\u8BEF");
    default:
      throw new Error("\u4E0D\u652F\u6301\u7684\u914D\u7F6E\u9879\u6216\u6570\u636E\u7C7B\u578B\u9519\u8BEF");
  }
}

// src/command.js
var commandAuthCheck = {
  default: function() {
    if (CONST.GROUP_TYPES.includes(SHARE_CONTEXT.chatType)) {
      return ["administrator", "creator"];
    }
    return false;
  },
  shareModeGroup: function() {
    if (CONST.GROUP_TYPES.includes(SHARE_CONTEXT.chatType)) {
      if (!ENV.GROUP_CHAT_BOT_SHARE_MODE) {
        return false;
      }
      return ["administrator", "creator"];
    }
    return false;
  }
};
var commandHandlers = {
  "/help": {
    help: "\u83B7\u53D6\u547D\u4EE4\u5E2E\u52A9",
    scopes: ["all_private_chats", "all_chat_administrators"],
    fn: commandGetHelp
  },
  "/new": {
    help: "\u53D1\u8D77\u65B0\u7684\u5BF9\u8BDD",
    scopes: ["all_private_chats", "all_group_chats", "all_chat_administrators"],
    fn: commandCreateNewChatContext,
    needAuth: commandAuthCheck.shareModeGroup
  },
  "/start": {
    help: "\u83B7\u53D6\u4F60\u7684ID, \u5E76\u53D1\u8D77\u65B0\u7684\u5BF9\u8BDD",
    scopes: ["all_private_chats", "all_chat_administrators"],
    fn: commandCreateNewChatContext,
    needAuth: commandAuthCheck.default
  },
  "/img": {
    help: "\u751F\u6210\u4E00\u5F20\u56FE\u7247, \u547D\u4EE4\u5B8C\u6574\u683C\u5F0F\u4E3A `/img \u56FE\u7247\u63CF\u8FF0`, \u4F8B\u5982`/img \u6708\u5149\u4E0B\u7684\u6C99\u6EE9`",
    scopes: ["all_private_chats", "all_chat_administrators"],
    fn: commandGenerateImg,
    needAuth: commandAuthCheck.shareModeGroup
  },
  "/version": {
    help: "\u83B7\u53D6\u5F53\u524D\u7248\u672C\u53F7, \u5224\u65AD\u662F\u5426\u9700\u8981\u66F4\u65B0",
    scopes: ["all_private_chats", "all_chat_administrators"],
    fn: commandFetchUpdate,
    needAuth: commandAuthCheck.default
  },
  "/setenv": {
    help: "\u8BBE\u7F6E\u7528\u6237\u914D\u7F6E\uFF0C\u547D\u4EE4\u5B8C\u6574\u683C\u5F0F\u4E3A /setenv KEY=VALUE",
    scopes: [],
    fn: commandUpdateUserConfig,
    needAuth: commandAuthCheck.shareModeGroup
  },
  "/usage": {
    help: "\u83B7\u53D6\u5F53\u524D\u673A\u5668\u4EBA\u7684\u7528\u91CF\u7EDF\u8BA1",
    scopes: ["all_private_chats", "all_chat_administrators"],
    fn: commandUsage,
    needAuth: commandAuthCheck.default
  },
  "/system": {
    help: "\u67E5\u770B\u5F53\u524D\u4E00\u4E9B\u7CFB\u7EDF\u4FE1\u606F",
    scopes: ["all_private_chats", "all_chat_administrators"],
    fn: commandSystem,
    needAuth: commandAuthCheck.default
  },
  "/role": {
    help: "\u8BBE\u7F6E\u9884\u8BBE\u7684\u8EAB\u4EFD",
    scopes: ["all_private_chats"],
    fn: commandUpdateRole,
    needAuth: commandAuthCheck.shareModeGroup
  }
};
async function commandUpdateRole(message, command, subcommand) {
  if (subcommand === "show") {
    const size = Object.getOwnPropertyNames(USER_DEFINE.ROLE).length;
    if (size === 0) {
      return sendMessageToTelegram("\u8FD8\u672A\u5B9A\u4E49\u4EFB\u4F55\u89D2\u8272");
    }
    let showMsg = `\u5F53\u524D\u5DF2\u5B9A\u4E49\u7684\u89D2\u8272\u5982\u4E0B(${size}):
`;
    for (const role2 in USER_DEFINE.ROLE) {
      if (USER_DEFINE.ROLE.hasOwnProperty(role2)) {
        showMsg += `~${role2}:
<pre>`;
        showMsg += JSON.stringify(USER_DEFINE.ROLE[role2]) + "\n";
        showMsg += "</pre>";
      }
    }
    CURRENT_CHAT_CONTEXT.parse_mode = "HTML";
    return sendMessageToTelegram(showMsg);
  }
  const helpMsg = "\u683C\u5F0F\u9519\u8BEF: \u547D\u4EE4\u5B8C\u6574\u683C\u5F0F\u4E3A `/role \u64CD\u4F5C`\n\u5F53\u524D\u652F\u6301\u4EE5\u4E0B`\u64CD\u4F5C`:\n`/role show` \u663E\u793A\u5F53\u524D\u5B9A\u4E49\u7684\u89D2\u8272.\n`/role \u89D2\u8272\u540D del` \u5220\u9664\u6307\u5B9A\u540D\u79F0\u7684\u89D2\u8272.\n`/role \u89D2\u8272\u540D KEY=VALUE` \u8BBE\u7F6E\u6307\u5B9A\u89D2\u8272\u7684\u914D\u7F6E.\n \u76EE\u524D\u4EE5\u4E0B\u8BBE\u7F6E\u9879:\n  `SYSTEM_INIT_MESSAGE`:\u521D\u59CB\u5316\u6D88\u606F\n  `OPENAI_API_EXTRA_PARAMS`:OpenAI API \u989D\u5916\u53C2\u6570\uFF0C\u5FC5\u987B\u4E3AJSON";
  const kv = subcommand.indexOf(" ");
  if (kv === -1) {
    return sendMessageToTelegram(helpMsg);
  }
  const role = subcommand.slice(0, kv);
  const settings = subcommand.slice(kv + 1).trim();
  const skv = settings.indexOf("=");
  if (skv === -1) {
    if (settings === "del") {
      try {
        if (USER_DEFINE.ROLE[role]) {
          delete USER_DEFINE.ROLE[role];
          await DATABASE.put(
            SHARE_CONTEXT.configStoreKey,
            JSON.stringify(Object.assign(USER_CONFIG, { USER_DEFINE }))
          );
          return sendMessageToTelegram("\u5220\u9664\u89D2\u8272\u6210\u529F");
        }
      } catch (e) {
        return sendMessageToTelegram(`\u5220\u9664\u89D2\u8272\u9519\u8BEF: \`${e.message}\``);
      }
    }
    return sendMessageToTelegram(helpMsg);
  }
  const key = settings.slice(0, skv);
  const value = settings.slice(skv + 1);
  if (!USER_DEFINE.ROLE[role]) {
    USER_DEFINE.ROLE[role] = {
      // 系统初始化消息
      SYSTEM_INIT_MESSAGE: ENV.SYSTEM_INIT_MESSAGE,
      // OpenAI API 额外参数
      OPENAI_API_EXTRA_PARAMS: {}
    };
  }
  try {
    mergeConfig(USER_DEFINE.ROLE[role], key, value);
    await DATABASE.put(
      SHARE_CONTEXT.configStoreKey,
      JSON.stringify(Object.assign(USER_CONFIG, { USER_DEFINE }))
    );
    return sendMessageToTelegram("\u66F4\u65B0\u914D\u7F6E\u6210\u529F");
  } catch (e) {
    return sendMessageToTelegram(`\u914D\u7F6E\u9879\u683C\u5F0F\u9519\u8BEF: \`${e.message}\``);
  }
}
async function commandGenerateImg(message, command, subcommand) {
  if (subcommand === "") {
    return sendMessageToTelegram("\u8BF7\u8F93\u5165\u56FE\u7247\u63CF\u8FF0\u3002\u547D\u4EE4\u5B8C\u6574\u683C\u5F0F\u4E3A `/img \u72F8\u82B1\u732B`");
  }
  try {
    setTimeout(() => sendChatActionToTelegram("upload_photo").catch(console.error), 0);
    const imgUrl = await requestImageFromOpenAI(subcommand);
    try {
      return sendPhotoToTelegram(imgUrl);
    } catch (e) {
      return sendMessageToTelegram(`\u56FE\u7247:
${imgUrl}`);
    }
  } catch (e) {
    return sendMessageToTelegram(`ERROR:IMG: ${e.message}`);
  }
}
async function commandGetHelp(message, command, subcommand) {
  const helpMsg = "\u5F53\u524D\u652F\u6301\u4EE5\u4E0B\u547D\u4EE4:\n" + Object.keys(commandHandlers).map((key) => `${key}\uFF1A${commandHandlers[key].help}`).join("\n");
  return sendMessageToTelegram(helpMsg);
}
async function commandCreateNewChatContext(message, command, subcommand) {
  try {
    await DATABASE.delete(SHARE_CONTEXT.chatHistoryKey);
    if (command === "/new") {
      return sendMessageToTelegram("\u65B0\u7684\u5BF9\u8BDD\u5DF2\u7ECF\u5F00\u59CB");
    } else {
      if (SHARE_CONTEXT.chatType === "private") {
        return sendMessageToTelegram(
          `\u65B0\u7684\u5BF9\u8BDD\u5DF2\u7ECF\u5F00\u59CB\uFF0C\u4F60\u7684ID(${CURRENT_CHAT_CONTEXT.chat_id})`
        );
      } else {
        return sendMessageToTelegram(
          `\u65B0\u7684\u5BF9\u8BDD\u5DF2\u7ECF\u5F00\u59CB\uFF0C\u7FA4\u7EC4ID(${CURRENT_CHAT_CONTEXT.chat_id})`
        );
      }
    }
  } catch (e) {
    return sendMessageToTelegram(`ERROR: ${e.message}`);
  }
}
async function commandUpdateUserConfig(message, command, subcommand) {
  const kv = subcommand.indexOf("=");
  if (kv === -1) {
    return sendMessageToTelegram(
      "\u914D\u7F6E\u9879\u683C\u5F0F\u9519\u8BEF: \u547D\u4EE4\u5B8C\u6574\u683C\u5F0F\u4E3A /setenv KEY=VALUE"
    );
  }
  const key = subcommand.slice(0, kv);
  const value = subcommand.slice(kv + 1);
  try {
    mergeConfig(USER_CONFIG, key, value);
    await DATABASE.put(
      SHARE_CONTEXT.configStoreKey,
      JSON.stringify(USER_CONFIG)
    );
    return sendMessageToTelegram("\u66F4\u65B0\u914D\u7F6E\u6210\u529F");
  } catch (e) {
    return sendMessageToTelegram(`\u914D\u7F6E\u9879\u683C\u5F0F\u9519\u8BEF: ${e.message}`);
  }
}
async function commandFetchUpdate(message, command, subcommand) {
  const config = {
    headers: {
      "User-Agent": "TBXark/ChatGPT-Telegram-Workers"
    }
  };
  const current = {
    ts: ENV.BUILD_TIMESTAMP,
    sha: ENV.BUILD_VERSION
  };
  const ts = `https://raw.githubusercontent.com/TBXark/ChatGPT-Telegram-Workers/${ENV.UPDATE_BRANCH}/dist/timestamp`;
  const info = `https://raw.githubusercontent.com/TBXark/ChatGPT-Telegram-Workers/${ENV.UPDATE_BRANCH}/dist/buildinfo.json`;
  let online = await fetch(info, config).then((r) => r.json()).catch(() => null);
  if (!online) {
    online = await fetch(ts).then((r) => r.text()).then((ts2) => ({ ts: Number(ts2.trim()), sha: "unknown" })).catch(() => ({ ts: 0, sha: "unknown" }));
  }
  if (current.ts < online.ts) {
    return sendMessageToTelegram(
      ` \u53D1\u73B0\u65B0\u7248\u672C\uFF0C\u5F53\u524D\u7248\u672C: ${JSON.stringify(current)}\uFF0C\u6700\u65B0\u7248\u672C: ${JSON.stringify(online)}`
    );
  } else {
    return sendMessageToTelegram(`\u5F53\u524D\u5DF2\u7ECF\u662F\u6700\u65B0\u7248\u672C, \u5F53\u524D\u7248\u672C: ${JSON.stringify(current)}`);
  }
}
async function commandUsage() {
  if (!ENV.ENABLE_USAGE_STATISTICS) {
    return sendMessageToTelegram("\u5F53\u524D\u673A\u5668\u4EBA\u672A\u5F00\u542F\u7528\u91CF\u7EDF\u8BA1");
  }
  const usage = JSON.parse(await DATABASE.get(SHARE_CONTEXT.usageKey));
  let text = "\u{1F4CA} \u5F53\u524D\u673A\u5668\u4EBA\u7528\u91CF\n\nTokens:\n";
  if (usage?.tokens) {
    const { tokens } = usage;
    const sortedChats = Object.keys(tokens.chats || {}).sort((a, b) => tokens.chats[b] - tokens.chats[a]);
    text += `- \u603B\u7528\u91CF\uFF1A${tokens.total || 0} tokens
- \u5404\u804A\u5929\u7528\u91CF\uFF1A`;
    for (let i = 0; i < Math.min(sortedChats.length, 30); i++) {
      text += `
  - ${sortedChats[i]}: ${tokens.chats[sortedChats[i]]} tokens`;
    }
    if (sortedChats.length === 0) {
      text += "0 tokens";
    } else if (sortedChats.length > 30) {
      text += "\n  ...";
    }
  } else {
    text += "- \u6682\u65E0\u7528\u91CF";
  }
  return sendMessageToTelegram(text);
}
async function commandSystem(message) {
  let msg = "\u5F53\u524D\u7CFB\u7EDF\u4FE1\u606F\u5982\u4E0B:\n";
  msg += "OpenAI\u6A21\u578B:" + ENV.CHAT_MODEL + "\n";
  if (ENV.DEBUG_MODE) {
    msg += "<pre>";
    msg += `USER_CONFIG: 
${JSON.stringify(USER_CONFIG, null, 2)}
`;
    if (ENV.DEV_MODE) {
      const shareCtx = { ...SHARE_CONTEXT };
      shareCtx.currentBotToken = "ENPYPTED";
      msg += `CHAT_CONTEXT: 
${JSON.stringify(CURRENT_CHAT_CONTEXT, null, 2)}
`;
      msg += `SHARE_CONTEXT: 
${JSON.stringify(shareCtx, null, 2)}
`;
    }
    msg += "</pre>";
  }
  CURRENT_CHAT_CONTEXT.parse_mode = "HTML";
  return sendMessageToTelegram(msg);
}
async function commandEcho(message) {
  let msg = "<pre>";
  msg += JSON.stringify({ message }, null, 2);
  msg += "</pre>";
  CURRENT_CHAT_CONTEXT.parse_mode = "HTML";
  return sendMessageToTelegram(msg);
}
async function handleCommandMessage(message) {
  if (ENV.DEV_MODE) {
    commandHandlers["/echo"] = {
      help: "[DEBUG ONLY]\u56DE\u663E\u6D88\u606F",
      scopes: ["all_private_chats", "all_chat_administrators"],
      fn: commandEcho,
      needAuth: commandAuthCheck.default
    };
  }
  for (const key in commandHandlers) {
    if (message.text === key || message.text.startsWith(key + " ")) {
      const command = commandHandlers[key];
      try {
        if (command.needAuth) {
          const roleList = command.needAuth();
          if (roleList) {
            const chatRole = await getChatRole(SHARE_CONTEXT.speakerId);
            if (chatRole === null) {
              return sendMessageToTelegram("\u8EAB\u4EFD\u6743\u9650\u9A8C\u8BC1\u5931\u8D25");
            }
            if (!roleList.includes(chatRole)) {
              return sendMessageToTelegram(`\u6743\u9650\u4E0D\u8DB3,\u9700\u8981${roleList.join(",")},\u5F53\u524D:${chatRole}`);
            }
          }
        }
      } catch (e) {
        return sendMessageToTelegram(`\u8EAB\u4EFD\u9A8C\u8BC1\u51FA\u9519:` + e.message);
      }
      const subcommand = message.text.substring(key.length).trim();
      try {
        return await command.fn(message, key, subcommand);
      } catch (e) {
        return sendMessageToTelegram(`\u547D\u4EE4\u6267\u884C\u9519\u8BEF: ${e.message}`);
      }
    }
  }
  return null;
}
async function bindCommandForTelegram(token) {
  const scopeCommandMap = {
    all_private_chats: [],
    all_group_chats: [],
    all_chat_administrators: []
  };
  for (const key in commandHandlers) {
    if (ENV.HIDE_COMMAND_BUTTONS.includes(key)) {
      continue;
    }
    if (commandHandlers.hasOwnProperty(key) && commandHandlers[key].scopes) {
      for (const scope of commandHandlers[key].scopes) {
        if (!scopeCommandMap[scope]) {
          scopeCommandMap[scope] = [];
        }
        scopeCommandMap[scope].push(key);
      }
    }
  }
  const result = {};
  for (const scope in scopeCommandMap) {
    result[scope] = await fetch(
      `https://api.telegram.org/bot${token}/setMyCommands`,
      {
        method: "POST",
        headers: {
          "Content-Type": "application/json"
        },
        body: JSON.stringify({
          commands: scopeCommandMap[scope].map((command) => ({
            command,
            description: commandHandlers[command].help
          })),
          scope: {
            type: scope
          }
        })
      }
    ).then((res) => res.json());
  }
  return { ok: true, result };
}
function commandsDocument() {
  return Object.keys(commandHandlers).map((key) => {
    const command = commandHandlers[key];
    return {
      command: key,
      description: command.help
    };
  });
}

// src/message.js
var MAX_TOKEN_LENGTH = 2048;
async function msgInitChatContext(message) {
  try {
    await initContext(message);
  } catch (e) {
    return new Response(errorToString(e), { status: 200 });
  }
  return null;
}
async function msgSaveLastMessage(message) {
  if (ENV.DEBUG_MODE) {
    const lastMessageKey = `last_message:${SHARE_CONTEXT.chatHistoryKey}`;
    await DATABASE.put(lastMessageKey, JSON.stringify(message));
  }
  return null;
}
async function msgCheckEnvIsReady(message) {
  if (!ENV.API_KEY) {
    return sendMessageToTelegram("OpenAI API Key \u672A\u8BBE\u7F6E");
  }
  if (!DATABASE) {
    return sendMessageToTelegram("DATABASE \u672A\u8BBE\u7F6E");
  }
  return null;
}
async function msgFilterWhiteList(message) {
  if (ENV.I_AM_A_GENEROUS_PERSON) {
    return null;
  }
  if (SHARE_CONTEXT.chatType === "private") {
    if (!ENV.CHAT_WHITE_LIST.includes(`${CURRENT_CHAT_CONTEXT.chat_id}`)) {
      return sendMessageToTelegram(
        `\u4F60\u6CA1\u6709\u6743\u9650\u4F7F\u7528\u8FD9\u4E2A\u547D\u4EE4, \u8BF7\u8BF7\u8054\u7CFB\u7BA1\u7406\u5458\u6DFB\u52A0\u4F60\u7684ID(${CURRENT_CHAT_CONTEXT.chat_id})\u5230\u767D\u540D\u5355`
      );
    }
    return null;
  }
  if (CONST.GROUP_TYPES.includes(SHARE_CONTEXT.chatType)) {
    if (!ENV.GROUP_CHAT_BOT_ENABLE) {
      return new Response("ID SUPPORT", { status: 401 });
    }
    if (!ENV.CHAT_GROUP_WHITE_LIST.includes(`${CURRENT_CHAT_CONTEXT.chat_id}`)) {
      return sendMessageToTelegram(
        `\u8BE5\u7FA4\u672A\u5F00\u542F\u804A\u5929\u6743\u9650, \u8BF7\u8BF7\u8054\u7CFB\u7BA1\u7406\u5458\u6DFB\u52A0\u7FA4ID(${CURRENT_CHAT_CONTEXT.chat_id})\u5230\u767D\u540D\u5355`
      );
    }
    return null;
  }
  return sendMessageToTelegram(
    `\u6682\u4E0D\u652F\u6301\u8BE5\u7C7B\u578B(${SHARE_CONTEXT.chatType})\u7684\u804A\u5929`
  );
}
async function msgFilterNonTextMessage(message) {
  if (!message.text) {
    return sendMessageToTelegram("\u6682\u4E0D\u652F\u6301\u975E\u6587\u672C\u683C\u5F0F\u6D88\u606F");
  }
  return null;
}
async function msgHandleGroupMessage(message) {
  if (!message.text) {
    return new Response("NON TEXT MESSAGE", { status: 200 });
  }
  const botName = SHARE_CONTEXT.currentBotName;
  if (botName) {
    let mentioned = false;
    if (message.reply_to_message) {
      if (message.reply_to_message.from.username === botName) {
        mentioned = true;
      }
    }
    if (message.entities) {
      let content = "";
      let offset = 0;
      message.entities.forEach((entity) => {
        switch (entity.type) {
          case "bot_command":
            if (!mentioned) {
              const mention = message.text.substring(
                entity.offset,
                entity.offset + entity.length
              );
              if (mention.endsWith(botName)) {
                mentioned = true;
              }
              const cmd = mention.replaceAll("@" + botName, "").replaceAll(botName).trim();
              content += cmd;
              offset = entity.offset + entity.length;
            }
            break;
          case "mention":
          case "text_mention":
            if (!mentioned) {
              const mention = message.text.substring(
                entity.offset,
                entity.offset + entity.length
              );
              if (mention === botName || mention === "@" + botName) {
                mentioned = true;
              }
            }
            content += message.text.substring(offset, entity.offset);
            offset = entity.offset + entity.length;
            break;
        }
      });
      content += message.text.substring(offset, message.text.length);
      message.text = content.trim();
    }
    if (!mentioned) {
      return new Response("NOT MENTIONED", { status: 200 });
    } else {
      return null;
    }
  }
  return new Response("NOT SET BOTNAME", { status: 200 });
  ;
}
async function msgHandleCommand(message) {
  return await handleCommandMessage(message);
}
async function msgHandleRole(message) {
  if (!message.text.startsWith("~")) {
    return null;
  }
  message.text = message.text.slice(1);
  const kv = message.text.indexOf(" ");
  if (kv === -1) {
    return null;
  }
  const role = message.text.slice(0, kv);
  const msg = message.text.slice(kv + 1).trim();
  if (USER_DEFINE.ROLE.hasOwnProperty(role)) {
    SHARE_CONTEXT.ROLE = role;
    message.text = msg;
    const roleConfig = USER_DEFINE.ROLE[role];
    for (const key in roleConfig) {
      if (USER_CONFIG.hasOwnProperty(key) && typeof USER_CONFIG[key] === typeof roleConfig[key]) {
        USER_CONFIG[key] = roleConfig[key];
      }
    }
  }
}
async function msgChatWithOpenAI(message) {
  try {
    console.log("\u63D0\u95EE\u6D88\u606F:" + message.text || "");
    const historyDisable = ENV.AUTO_TRIM_HISTORY && ENV.MAX_HISTORY_LENGTH <= 0;
    setTimeout(() => sendChatActionToTelegram("typing").catch(console.error), 0);
    const historyKey = SHARE_CONTEXT.chatHistoryKey;
    let { real: history, fake: fakeHistory, original } = await loadHistory(historyKey);
    history = JSON.parse(JSON.stringify(history));
    history.map((item) => {
      item.cosplay = void 0;
    });
    const answer = await requestCompletionsFromChatGPT(message.text, fakeHistory || history);
    if (!historyDisable) {
      original.push({ role: "user", content: message.text || "", cosplay: SHARE_CONTEXT.ROLE || "" });
      original.push({ role: "assistant", content: answer, cosplay: SHARE_CONTEXT.ROLE || "" });
      await DATABASE.put(historyKey, JSON.stringify(original)).catch(console.error);
    }
    return sendMessageToTelegram(answer);
  } catch (e) {
    return sendMessageToTelegram(`ERROR:CHAT: ${e.message}`);
  }
}
async function msgProcessByChatType(message) {
  const handlerMap = {
    "private": [
      msgFilterWhiteList,
      msgFilterNonTextMessage,
      msgHandleCommand,
      msgHandleRole
    ],
    "group": [
      msgHandleGroupMessage,
      msgFilterWhiteList,
      msgHandleCommand,
      msgHandleRole
    ],
    "supergroup": [
      msgHandleGroupMessage,
      msgFilterWhiteList,
      msgHandleCommand,
      msgHandleRole
    ]
  };
  if (!handlerMap.hasOwnProperty(SHARE_CONTEXT.chatType)) {
    return sendMessageToTelegram(
      `\u6682\u4E0D\u652F\u6301\u8BE5\u7C7B\u578B(${SHARE_CONTEXT.chatType})\u7684\u804A\u5929`
    );
  }
  const handlers = handlerMap[SHARE_CONTEXT.chatType];
  for (const handler of handlers) {
    try {
      const result = await handler(message);
      if (result && result instanceof Response) {
        return result;
      }
    } catch (e) {
      console.error(e);
      return sendMessageToTelegram(
        `\u5904\u7406(${SHARE_CONTEXT.chatType})\u7684\u804A\u5929\u6D88\u606F\u51FA\u9519`
      );
    }
  }
  return null;
}
async function loadMessage(request) {
  const raw = await request.json();
  console.log(JSON.stringify(raw));
  if (ENV.DEV_MODE) {
    setTimeout(() => {
      DATABASE.put(`log:${(/* @__PURE__ */ new Date()).toISOString()}`, JSON.stringify(raw), { expirationTtl: 600 }).catch(console.error);
    });
  }
  if (raw.message) {
    return raw.message;
  } else if (raw.callback_query && raw.callback_query.message) {
    return null;
  } else {
    throw new Error("Invalid message");
  }
}
async function loadHistory(key) {
  const initMessage = { role: "system", content: USER_CONFIG.SYSTEM_INIT_MESSAGE };
  const historyDisable = ENV.AUTO_TRIM_HISTORY && ENV.MAX_HISTORY_LENGTH <= 0;
  if (historyDisable) {
    return { real: [initMessage], original: [initMessage] };
  }
  let history = [];
  try {
    history = JSON.parse(await DATABASE.get(key));
  } catch (e) {
    console.error(e);
  }
  if (!history || !Array.isArray(history) || history.length === 0) {
    history = [];
  }
  const original = history;
  if (SHARE_CONTEXT.ROLE) {
    history = history.filter((chat) => SHARE_CONTEXT.ROLE === chat.cosplay);
  }
  if (ENV.AUTO_TRIM_HISTORY && ENV.MAX_HISTORY_LENGTH > 0) {
    if (history.length > ENV.MAX_HISTORY_LENGTH) {
      history = history.splice(history.length - ENV.MAX_HISTORY_LENGTH);
    }
    let tokenLength = Array.from(initMessage.content).length;
    for (let i = history.length - 1; i >= 0; i--) {
      const historyItem = history[i];
      let length = 0;
      if (historyItem.content) {
        length = Array.from(historyItem.content).length;
      } else {
        historyItem.content = "";
      }
      tokenLength += length;
      if (tokenLength > MAX_TOKEN_LENGTH) {
        history = history.splice(i + 1);
        break;
      }
    }
  }
  switch (history.length > 0 ? history[0].role : "") {
    case "assistant":
    case "system":
      history[0] = initMessage;
      break;
    default:
      history.unshift(initMessage);
  }
  if (ENV.SYSTEM_INIT_MESSAGE_ROLE !== "system" && history.length > 0 && history[0].role === "system") {
    const fake = [
      ...history
    ];
    fake[0] = {
      ...fake[0],
      role: ENV.SYSTEM_INIT_MESSAGE_ROLE
    };
    return { real: history, fake, original };
  }
  return { real: history, original };
}
async function handleMessage(request) {
  initTelegramContext(request);
  const message = await loadMessage(request);
  const handlers = [
    msgInitChatContext,
    // 初始化聊天上下文: 生成chat_id, reply_to_message_id(群组消息), SHARE_CONTEXT
    msgSaveLastMessage,
    // 保存最后一条消息
    msgCheckEnvIsReady,
    // 检查环境是否准备好: API_KEY, DATABASE
    msgProcessByChatType,
    // 根据类型对消息进一步处理
    msgChatWithOpenAI
    // 与OpenAI聊天
  ];
  for (const handler of handlers) {
    try {
      const result = await handler(message);
      if (result && result instanceof Response) {
        return result;
      }
    } catch (e) {
      console.error(e);
      return new Response(errorToString(e), { status: 500 });
    }
  }
  return null;
}

// src/router.js
var helpLink = "https://github.com/TBXark/ChatGPT-Telegram-Workers/blob/master/DEPLOY.md";
var issueLink = "https://github.com/TBXark/ChatGPT-Telegram-Workers/issues";
var initLink = "./init";
var footer = `
<br/>
<p>For more information, please visit <a href="${helpLink}">${helpLink}</a></p>
<p>If you have any questions, please visit <a href="${issueLink}">${issueLink}</a></p>
`;
function buildKeyNotFoundHTML(key) {
  return `<p style="color: red">Please set the <strong>${key}</strong> environment variable in Cloudflare Workers.</p> `;
}
async function bindWebHookAction(request) {
  const result = [];
  const domain = new URL(request.url).host;
  for (const token of ENV.TELEGRAM_AVAILABLE_TOKENS) {
    const url = `https://${domain}/telegram/${token.trim()}/webhook`;
    const id = token.split(":")[0];
    result[id] = {
      webhook: await bindTelegramWebHook(token, url).catch((e) => errorToString(e)),
      command: await bindCommandForTelegram(token).catch((e) => errorToString(e))
    };
  }
  const HTML = renderHTML(`
    <h1>ChatGPT-Telegram-Workers</h1>
    <h2>${domain}</h2>
    ${ENV.TELEGRAM_AVAILABLE_TOKENS.length === 0 ? buildKeyNotFoundHTML("TELEGRAM_AVAILABLE_TOKENS") : ""}
    ${Object.keys(result).map((id) => `
        <br/>
        <h4>Bot ID: ${id}</h4>
        <p style="color: ${result[id].webhook.ok ? "green" : "red"}">Webhook: ${JSON.stringify(result[id].webhook)}</p>
        <p style="color: ${result[id].command.ok ? "green" : "red"}">Command: ${JSON.stringify(result[id].command)}</p>
        `).join("")}
      ${footer}
    `);
  return new Response(HTML, { status: 200, headers: { "Content-Type": "text/html" } });
}
async function loadChatHistory(request) {
  const password = await historyPassword();
  const { pathname } = new URL(request.url);
  const historyKey = pathname.match(/^\/telegram\/(.+)\/history/)[1];
  const params = new URL(request.url).searchParams;
  const passwordParam = params.get("password");
  if (passwordParam !== password) {
    return new Response("Password Error", { status: 401 });
  }
  const history = await DATABASE.get(historyKey).then((res) => JSON.parse(res));
  const HTML = renderHTML(`
        <div id="history" style="width: 100%; height: 100%; overflow: auto; padding: 10px;">
            ${history.map((item) => `
                <div style="margin-bottom: 10px;">
                    <hp style="font-size: 16px; color: #999; margin-bottom: 5px;">${item.role}:</hp>
                    <p style="font-size: 12px; color: #333;">${item.content}</p>
                </div>
            `).join("")}
        </div>
  `);
  return new Response(HTML, { status: 200, headers: { "Content-Type": "text/html" } });
}
async function telegramWebhook(request) {
  const resp = await handleMessage(request);
  return resp || new Response("NOT HANDLED", { status: 200 });
}
async function defaultIndexAction() {
  const HTML = renderHTML(`
    <h1>ChatGPT-Telegram-Workers</h1>
    <br/>
    <p>Deployed Successfully!</p>
    <p> Version (ts:${ENV.BUILD_TIMESTAMP},sha:${ENV.BUILD_VERSION})</p>
    <br/>
    <p>You must <strong><a href="${initLink}"> >>>>> click here <<<<< </a></strong> to bind the webhook.</p>
    <br/>
    ${ENV.API_KEY ? "" : buildKeyNotFoundHTML("API_KEY")}
    <p>After binding the webhook, you can use the following commands to control the bot:</p>
    ${commandsDocument().map((item) => `<p><strong>${item.command}</strong> - ${item.description}</p>`).join("")}
    <br/>
    <p>You can get bot information by visiting the following URL:</p>
    <p><strong>/telegram/:token/bot</strong> - Get bot information</p>
    ${footer}
  `);
  return new Response(HTML, { status: 200, headers: { "Content-Type": "text/html" } });
}
async function loadBotInfo() {
  const result = [];
  for (const token of ENV.TELEGRAM_AVAILABLE_TOKENS) {
    const id = token.split(":")[0];
    result[id] = await getBot(token);
  }
  const HTML = renderHTML(`
    <h1>ChatGPT-Telegram-Workers</h1>
    <br/>
    <h4>Environment About Bot</h4>
    <p><strong>GROUP_CHAT_BOT_ENABLE:</strong> ${ENV.GROUP_CHAT_BOT_ENABLE}</p>
    <p><strong>GROUP_CHAT_BOT_SHARE_MODE:</strong> ${ENV.GROUP_CHAT_BOT_SHARE_MODE}</p>
    <p><strong>TELEGRAM_BOT_NAME:</strong> ${ENV.TELEGRAM_BOT_NAME.join(",")}</p>
    ${Object.keys(result).map((id) => `
            <br/>
            <h4>Bot ID: ${id}</h4>
            <p style="color: ${result[id].ok ? "green" : "red"}">${JSON.stringify(result[id])}</p>
            `).join("")}
    ${footer}
  `);
  return new Response(HTML, { status: 200, headers: { "Content-Type": "text/html" } });
}
async function handleRequest(request) {
  const { pathname } = new URL(request.url);
  if (pathname === `/`) {
    return defaultIndexAction();
  }
  if (pathname.startsWith(`/init`)) {
    return bindWebHookAction(request);
  }
  if (pathname.startsWith(`/telegram`) && pathname.endsWith(`/history`)) {
    return loadChatHistory(request);
  }
  if (pathname.startsWith(`/telegram`) && pathname.endsWith(`/webhook`)) {
    try {
      const resp = await telegramWebhook(request);
      if (resp.status === 200) {
        return resp;
      } else {
        return new Response(resp.body, { status: 200, headers: {
          "Original-Status": resp.status,
          ...resp.headers
        } });
      }
    } catch (e) {
      console.error(e);
      return new Response(errorToString(e), { status: 200 });
    }
  }
  if (pathname.startsWith(`/telegram`) && pathname.endsWith(`/bot`)) {
    return loadBotInfo(request);
  }
  return null;
}

// main.js
var main_default = {
  async fetch(request, env) {
    try {
      initEnv(env);
      const resp = await handleRequest(request);
      return resp || new Response("NOTFOUND", { status: 404 });
    } catch (e) {
      console.error(e);
      return new Response(errorToString(e), { status: 500 });
    }
  }
};
export {
  main_default as default
};

6.2.3 配置环境变量

打开 Cloudflare Workers (opens new window) 点击你的Workers,点击右上角的 Setting -> Variables

• API_KEY：设置成 OpenAI API Key
• TELEGRAM_AVAILABLE_TOKENS：设置成 Telegram Bot Token
• WORKERS_DOMAIN：设置成你的Workers域名，例如workers_name.username.workers.dev, 可以在workers详情页的Preview找到
• CHAT_WHITE_LIST：设置成允许访问的 telegram bot 的chatid，例如123456789,987654321

6.2.4 绑定KV数据

Step1：在首页——Workers——KV处，点击右上角的 Create a Namespace, 这里名字随便取。

Step2：打开 Cloudflare Workers (opens new window) 点击你的Workers

• 点击右上角的 Setting -> Variables
• 在 KV Namespace Bindings 中点击 Edit variables
• 点击 Add variable
• 设置名字为DATABASE，并选择刚刚创建的KV数据

6.2.5 初始化并开始聊天

初始化：浏览器打开 https://workers_name.username.workers.dev/init 地址，即可自动绑定telegram的webhook和设定所有指令。

开始聊天：打开我们的 telegram bot，输入/new命令，即可开始聊天。

7. ChatGPT的其他衍生工具

7.1 使用ChatGPT的Chrome插件

项目描述：一个浏览器扩展，可以在 Google 搜索结果的旁边显示 ChatGPT 回答的结果。

项目地址：https://github.com/wong2/chat-gpt-google-extension (opens new window)

Chrome插件商店地址：https://chrome.google.com/webstore/detail/chatgpt-for-google/jgjaeacdkonaoafenlfkkkmbaopkbilf (opens new window)

7.2 使用ChatGPT对PDF文档进行解读

项目描述：基于ChatGPT的一个应用，上传PDF文档即可让它替你学习，然后你可以直接问它相关问题。ChatPDF的原理是先对上传的PDF进行分析，为文件中每个段落创建语义索引。当用户提出一个问题后，工具就会把关联语段发送给ChatGPT，然后让它结合问题进行解读。

体验地址：https://www.chatpdf.com (opens new window)（可免费体验，该项目没有开源）

8. 参考资料

[1] OpenAI 推出超神 ChatGPT 注册攻略来了 from 稀土掘金 (opens new window)

[2] 2022最新国外短信接码平台汇总 from Extrabux (opens new window)

[3] 用于 OpenAI 与 ChatGPT API 交互的轻量级包，使用反向工程的官方 API from Github (opens new window)

[4] 基于 TLS 的 ChatGPT API，具有自动令牌重新生成、对话跟踪、代理支持等功能 from Github (opens new window)

[5] ChatGPT: Optimizing Language Models for Dialogue from OpenAI官网 (opens new window)

[6] 非官方 ChatGPT API 的 Node.js 客户端 from Github (opens new window)

[7] 显示 ChatGPT 响应和 Google 搜索结果的浏览器扩展 from Github (opens new window)

[8] ChatGPT官方API可以抢先体验了 from CSDN (opens new window)

[9] 如何创建ChatGPT API密钥？操作路径和教程 from 云东方 (opens new window)

[10] 不再是人工智障！一分钟学会如何把ChatGPT接入Siri from Bilibili (opens new window)

[11] ChatGPT-Telegram-Workers部署流程 from Github (opens new window)