[app_chatgpt] v18 to be validate

app_chatgpt/models/__init__.py

@@ -0,0 +1,10 @@
+# -*- coding: utf-8 -*-
+
+from . import res_partner
+from . import discuss_channel
+from . import res_config_settings
+from . import ai_robot
+from . import res_partner_ai_use
+from . import res_users
+from . import mail_message
+from . import mail_thread

app_chatgpt/models/ai_robot.py

@@ -0,0 +1,381 @@
+# -*- coding: utf-8 -*-
+
+import os
+from openai import OpenAI
+from openai import AzureOpenAI
+import requests, json
+import base64
+
+from odoo import api, fields, models, modules, tools, _
+from odoo.exceptions import UserError
+
+import logging
+_logger = logging.getLogger(__name__)
+
+
+class AiRobot(models.Model):
+    _name = 'ai.robot'
+    _description = 'Ai Robot'
+    _order = 'sequence, name'
+
+    name = fields.Char(string='Name', translate=True, required=True)
+    provider = fields.Selection(string="AI Provider", selection=[('openai', 'OpenAI'), ('azure', 'Azure')],
+                                required=True, default='openai', change_default=True)
+    # update ai_robot set ai_model=set_ai_model
+    ai_model = fields.Char(string="Ai Model", required=True, default='auto', help='Customize input')
+    set_ai_model = fields.Selection(string="Quick Set Model", selection=[
+        ('gpt-3.5-turbo-0125', 'gpt-3.5-turbo-0125(Default and Latest)'),
+        ('gpt-3.5-turbo-0613', 'gpt-3.5-turbo-0613'),
+        ('gpt-3.5-turbo-0125', 'gpt-3.5-turbo-0125'),
+        ('gpt-3.5-turbo-16k-0613', 'gpt-3.5-turbo-16k-0613(Big text)'),
+        ('gpt-4o', 'GPT-4o'),
+        ('gpt-4-turbo', 'GPT-4 Turbo'),
+        ('gpt-4', 'Chatgpt 4'),
+        ('gpt-4-32k', 'Chatgpt 4 32k'),
+        ('gpt-3.5-turbo', 'Chatgpt 3.5 Turbo'),
+        ('gpt-3.5-turbo-0301', 'Chatgpt 3.5 Turbo on 20230301'),
+        ('text-davinci-003', 'Chatgpt 3 Davinci'),
+        ('code-davinci-002', 'Chatgpt 2 Code Optimized'),
+        ('text-davinci-002', 'Chatgpt 2 Davinci'),
+        ('dall-e2', 'Dall-E Image'),
+    ], default='gpt-3.5-turbo-0125',
+                                help="""
+GPT-4: Can understand Image, generate natural language or code.
+GPT-3.5: A set of models that improve on GPT-3 and can understand as well as generate natural language or code
+DALL·E: A model that can generate and edit images given a natural language prompt
+Whisper: A model that can convert audio into text
+Embeddings:	A set of models that can convert text into a numerical form
+CodexLimited: A set of models that can understand and generate code, including translating natural language to code
+Moderation: A fine-tuned model that can detect whether text may be sensitive or unsafe
+GPT-3	A set of models that can understand and generate natural language
+                             """)
+    openapi_api_key = fields.Char(string="API Key", help="Provide the API key here")
+    # begin gpt 参数
+    # 1. stop：表示聊天机器人停止生成回复的条件，可以是一段文本或者一个列表，当聊天机器人生成的回复中包含了这个条件，就会停止继续生成回复。
+    # 2. temperature：0-2，控制回复的“新颖度”，值越高，聊天机器人生成的回复越不确定和随机，值越低，聊天机器人生成的回复会更加可预测和常规化。
+    # 3. top_p：0-1，语言连贯性，与temperature有些类似，也是控制回复的“新颖度”。不同的是，top_p控制的是回复中概率最高的几个可能性的累计概率之和，值越小，生成的回复越保守，值越大，生成的回复越新颖。
+    # 4. frequency_penalty：-2~2，用于控制聊天机器人回复中出现频率过高的词汇的惩罚程度。聊天机器人会尝试避免在回复中使用频率较高的词汇，以提高回复的多样性和新颖度。
+    # 5. presence_penalty：-2~2与frequency_penalty相对，用于控制聊天机器人回复中出现频率较低的词汇的惩罚程度。聊天机器人会尝试在回复中使用频率较低的词汇，以提高回复的多样性和新颖度。
+    max_tokens = fields.Integer('Max Response', default=600,
+                                help="""
+                                Set a limit on the number of tokens per model response.
+                                The API supports a maximum of 4000 tokens shared between the prompt
+                                (including system message, examples, message history, and user query) and the model's response.
+                                One token is roughly 4 characters for typical English text.
+                                """)
+    temperature = fields.Float(string='Temperature', default=1,
+                               help="""
+                               Controls randomness. Lowering the temperature means that the model will produce
+                               more repetitive and deterministic responses.
+                               Increasing the temperature will result in more unexpected or creative responses.
+                               Try adjusting temperature or Top P but not both.
+                                    """)
+    top_p = fields.Float('Top Probabilities', default=0.6,
+                         help="""
+                         Similar to temperature, this controls randomness but uses a different method.
+                         Lowering Top P will narrow the model’s token selection to likelier tokens.
+                         Increasing Top P will let the model choose from tokens with both high and low likelihood.
+                         Try adjusting temperature or Top P but not both
+                         """)
+    # 避免使用常用词
+    frequency_penalty = fields.Float('Frequency Penalty', default=1,
+                                     help="""
+                                     Reduce the chance of repeating a token proportionally based on how often it has appeared in the text so far.
+                                     This decreases the likelihood of repeating the exact same text in a response.
+                                     """)
+    # 越大模型就趋向于生成更新的话题，惩罚已经出现过的文本
+    presence_penalty = fields.Float('Presence penalty', default=1,
+                                    help="""
+                                    Reduce the chance of repeating any token that has appeared in the text at all so far.
+                                    This increases the likelihood of introducing new topics in a response.
+                                    """)
+    # 停止回复的关键词
+    stop = fields.Char('Stop sequences',
+                       help="""
+                       Use , to separate the stop key word.
+                       Make responses stop at a desired point, such as the end of a sentence or list.
+                       Specify up to four sequences where the model will stop generating further tokens in a response.
+                       The returned text will not contain the stop sequence.
+                       """)
+    # 角色设定
+    sys_content = fields.Char('System message',
+                              help="""
+                              Give the model instructions about how it should behave and any context it should reference when generating a response.
+                              You can describe the assistant’s personality,
+                              tell it what it should and shouldn’t answer, and tell it how to format responses.
+                              There’s no token limit for this section, but it will be included with every API call,
+                              so it counts against the overall token limit.
+                              """)
+    # end gpt 参数
+    endpoint = fields.Char('End Point', default='https://api.openai.com/v1/chat/completions')
+    engine = fields.Char('Engine', help='If use Azure, Please input the Model deployment name.')
+    api_version = fields.Char('API Version', default='2022-12-01')
+    ai_timeout = fields.Integer('Timeout(seconds)', help="Connect timeout for Ai response", default=120)
+    sequence = fields.Integer('Sequence', help="Determine the display order", default=10)
+    sensitive_words = fields.Text('Sensitive Words Plus', help='Sensitive word filtering. Separate keywords with a carriage return.')
+    is_filtering = fields.Boolean('Filter Sensitive Words', default=False, help='Use base Filter in dir models/lib/sensi_words.txt')
+
+    max_send_char = fields.Integer('Max Send Char', help='Max Send Prompt Length', default=8000)
+    image_avatar = fields.Image('Avatar')
+    partner_ids = fields.One2many('res.partner', 'gpt_id', string='Partner')
+    partner_count = fields.Integer('#Partner', compute='_compute_partner_count', store=False)
+    active = fields.Boolean('Active', default=True)
+
+    def _compute_partner_count(self):
+        for rec in self:
+            rec.partner_count = len(rec.partner_ids)
+
+    def action_disconnect(self):
+        requests.delete('https://chatgpt.com/v1/disconnect')
+
+    def get_ai_pre(self, data, author_id=False, answer_id=False, param={}):
+        # hook，都正常
+        return False
+
+    def get_ai(self, data, author_id=False, answer_id=False, param={}):
+        #     通用方法
+        # author_id: 请求的 partner_id 对象
+        # answer_id: 回答的 partner_id 对象
+        # param，dict 形式的参数
+        # 调整输出为2个参数：res_post详细内容，is_ai是否ai的响应
+
+        self.ensure_one()
+        # 前置勾子，一般返回 False，有问题返回响应内容，用于处理敏感词等
+        res_pre = self.get_ai_pre(data, author_id, answer_id, param)
+        if res_pre:
+            # 有错误内容，则返回上级内容及 is_ai为假
+            return res_pre, {}, False
+        if not hasattr(self, 'get_%s' % self.provider):
+            res = _('No robot provider found')
+            return res, {}, False
+
+        res = getattr(self, 'get_%s' % self.provider)(data, author_id, answer_id, param)
+        # 后置勾子，返回处理后的内容
+        res_post, usage, is_ai = self.get_ai_post(res, author_id, answer_id,  param)
+        return res_post, usage, is_ai
+
+    def get_ai_origin(self, data, author_id=False, answer_id=False, param={}):
+        # 通用方法
+        # author_id: 请求的 partner_id 对象
+        # answer_id: 回答的 partner_id 对象
+        # param，dict 形式的参数
+        # 调整输出为2个参数：res_post详细内容，is_ai是否ai的响应
+
+        self.ensure_one()
+        # 前置勾子，一般返回 False，有问题返回响应内容，用于处理敏感词等
+        res_pre = self.get_ai_pre(data, author_id, answer_id, param)
+        if res_pre:
+            # 有错误内容，则返回上级内容及 is_ai为假
+            return res_pre, {}, False
+        if not hasattr(self, 'get_%s' % self.provider):
+            res = _('No robot provider found')
+            return res, {}, False
+
+        res = getattr(self, 'get_%s' % self.provider)(data, author_id, answer_id, param)
+        # 后置勾子，返回处理后的内容
+        res_post, usage, is_ai = self.get_ai_post(res, author_id, answer_id, param)
+        return res
+
+    def get_ai_post(self, res, author_id=False, answer_id=False, param=None):
+        # hook，高级版要替代
+        if param is None:
+            param = {}
+        if not res or not author_id or (not isinstance(res, list) and not isinstance(res, dict)):
+            return res, False, False
+        # 返回是个对象，那么就是ai
+        usage = content = data = None
+        try:
+            if self.provider == 'openai':
+                # openai 格式处理
+                usage = res['usage']
+                content = res['choices'][0]['message']['content']
+                # _logger.warning('===========Ai响应:%s' % content)
+            elif self.provider == 'azure':
+                # azure 格式
+                usage = res['usage']
+                content = res['choices'][0]['message']['content']
+            else:
+                usage = False
+                content = res
+            data = content.replace(' .', '.').strip()
+            return data, usage, True
+        except Exception as e:
+            _logger.error('==========app_chatgpt get_ai_post Error: %s' % e)
+            return res, False, False
+
+    def get_ai_system(self, content=None):
+        # 获取基础ai角色设定, role system
+        sys_content = content or self.sys_content
+        if sys_content:
+            return {"role": "system", "content": sys_content}
+        return {}
+
+    def get_ai_model_info(self):
+        self.ensure_one()
+        headers = {"Content-Type": "application/json", "Authorization": f"Bearer {self.openapi_api_key}"}
+        R_TIMEOUT = self.ai_timeout or 120
+        o_url = "https://api.openai.com/v1/models/%s" % self.ai_model
+        if self.endpoint:
+            o_url = self.endpoint.replace("/chat/completions", "") + "/models/%s" % self.ai_model
+
+        response = requests.get(o_url, headers=headers, timeout=R_TIMEOUT)
+        response.close()
+        if response:
+            res = response.json()
+            r_text = json.dumps(res, indent=2)
+        else:
+            r_text = 'No response.'
+        raise UserError(r_text)
+
+    def get_ai_list_model(self):
+        self.ensure_one()
+        headers = {"Content-Type": "application/json", "Authorization": f"Bearer {self.openapi_api_key}"}
+        R_TIMEOUT = self.ai_timeout or 120
+        o_url = "https://api.openai.com/v1/models"
+        if self.endpoint:
+            o_url = self.endpoint.replace("/chat/completions", "") + "/models"
+        response = requests.get(o_url, headers=headers, timeout=R_TIMEOUT)
+        response.close()
+        if response:
+            res = response.json()
+            r_text = json.dumps(res, indent=2)
+        else:
+            r_text = 'No response.'
+        raise UserError(r_text)
+
+    def get_openai(self, data, author_id, answer_id, param={}):
+        self.ensure_one()
+        headers = {"Content-Type": "application/json", "Authorization": f"Bearer {self.openapi_api_key}"}
+        R_TIMEOUT = self.ai_timeout or 120
+        o_url = self.endpoint or "https://api.openai.com/v1/chat/completions"
+
+        # 处理传参，传过来的优先于 robot 默认的
+        max_tokens = param.get('max_tokens') if param.get('max_tokens') else self.max_tokens
+        temperature = param.get('temperature') if param.get('temperature') else self.temperature
+        top_p = param.get('top_p') if param.get('top_p') else self.top_p
+        frequency_penalty = param.get('frequency_penalty') if param.get('frequency_penalty') else self.frequency_penalty
+        presence_penalty = param.get('presence_penalty') if param.get('presence_penalty') else self.presence_penalty
+        request_timeout = param.get('request_timeout') if param.get('request_timeout') else self.ai_timeout
+
+        if self.stop:
+            stop = self.stop.split(',')
+        else:
+            stop = ["Human:", "AI:"]
+        # 以下处理 open ai
+        if self.ai_model == 'dall-e2':
+            # todo: 处理 图像引擎，主要是返回参数到聊天中
+            # image_url = response['data'][0]['url']
+            # https://platform.openai.com/docs/guides/images/introduction
+            pdata = {
+                "prompt": data,
+                "n": 3,
+                "size": "1024x1024",
+            }
+            return '建设中'
+        else:
+            pdata = {
+                "model": self.ai_model,
+                "prompt": data,
+                "temperature": 1,
+                "max_tokens": max_tokens,
+                "top_p": 0.6,
+                "frequency_penalty": 0.1,
+                "presence_penalty": 0.1,
+                "stop": stop
+            }
+            client = OpenAI(
+                api_key=self.openapi_api_key,
+                timeout=R_TIMEOUT
+                )
+            response = client.chat.completions.create(
+                messages=data,
+                model=self.ai_model,
+            )
+            res = response.model_dump()
+            if 'choices' in res:
+                return res
+            else:
+                _logger.warning('=====================openai output data: %s' % response.json())
+
+        return _("Response Timeout, please speak again.")
+
+    def get_azure(self, data, author_id, answer_id, param={}):
+        self.ensure_one()
+        # only for azure
+        if not self.endpoint:
+            raise UserError(_("Please Set your AI robot's endpoint first."))
+
+        if not self.api_version:
+            raise UserError(_("Please Set your AI robot's API Version first."))
+
+        if self.stop:
+            stop = self.stop.split(',')
+        else:
+            stop = ["Human:", "AI:"]
+        if isinstance(data, list):
+            messages = data
+        else:
+            messages = [{"role": "user", "content": data}]
+
+        # 处理传参，传过来的优先于 robot 默认的
+        max_tokens = param.get('max_tokens') if param.get('max_tokens') else self.max_tokens
+        temperature = param.get('temperature') if param.get('temperature') else self.temperature
+        top_p = param.get('top_p') if param.get('top_p') else self.top_p
+        frequency_penalty = param.get('frequency_penalty') if param.get('frequency_penalty') else self.frequency_penalty
+        presence_penalty = param.get('presence_penalty') if param.get('presence_penalty') else self.presence_penalty
+        request_timeout= param.get('request_timeout') if param.get('request_timeout') else self.ai_timeout
+
+        # Ai角色设定，如果没设定则再处理
+        if messages[0].get('role') != 'system':
+            sys_content = self.get_ai_system(param.get('sys_content'))
+            if sys_content:
+                messages.insert(0, sys_content)
+        #         暂时不变
+
+        client = AzureOpenAI(
+            api_version=self.api_version,
+            azure_endpoint=self.endpoint,
+            api_key=self.openapi_api_key,
+            timeout=request_timeout
+        )
+        response = client.chat.completions.create(
+            model=self.engine,
+            messages=messages,
+            # 返回的回答数量
+            n=1,
+            max_tokens=max_tokens,
+            temperature=temperature,
+            top_p=top_p,
+            frequency_penalty=frequency_penalty,
+            presence_penalty=presence_penalty,
+            stop=None,
+        )
+        res = response.model_dump()
+        if 'choices' in res:
+            return res
+        else:
+            _logger.warning('=====================azure output data: %s' % response.json())
+        return _("Response Timeout, please speak again.")
+
+    @api.onchange('provider')
+    def _onchange_provider(self):
+        if self.provider == 'openai':
+            self.endpoint = 'https://api.openai.com/v1/chat/completions'
+        elif self.provider == 'azure':
+            self.endpoint = 'https://odoo.openai.azure.com'
+
+        if self.provider:
+            # 取头像
+            module_path = modules.get_module_path('app_chatgpt', display_warning=False)
+            if module_path:
+                path = modules.check_resource_path(module_path, ('static/description/src/%s.png' % self.provider))
+                if path:
+                    image_file = tools.file_open(path, 'rb')
+                    self.image_avatar = base64.b64encode(image_file.read())
+
+    @api.onchange('set_ai_model')
+    def _onchange_set_ai_model(self):
+        if self.set_ai_model:
+            self.ai_model = self.set_ai_model
+        else:
+            self.ai_model = None

app_chatgpt/models/discuss_channel.py

@@ -0,0 +1,358 @@
+# -*- coding: utf-8 -*-
+
+import openai
+import requests, json
+import datetime
+# from transformers import TextDavinciTokenizer, TextDavinciModel
+from odoo import api, fields, models, tools, _
+from odoo.exceptions import UserError
+from odoo.osv import expression
+from odoo.addons.app_common.models.base import get_ua_type
+
+import logging
+_logger = logging.getLogger(__name__)
+
+
+class Channel(models.Model):
+    _inherit = 'discuss.channel'
+
+    is_private = fields.Boolean(string="Private", default=False, help="Check to set Private, Can only use by user, not Public")
+    # 因为 channel_member_ids 不好处理，在此增加此字段
+    # 主Ai
+    ai_partner_id = fields.Many2one(comodel_name="res.partner", string="Main Ai", required=False,
+                                    domain=[('gpt_id', '!=', None), ('is_chat_private', '=', True)],
+                                    default=lambda self: self._app_get_m2o_default('ai_partner_id'),
+                                    help="Main Ai is the robot help you default.")
+    ext_ai_partner_id = fields.Many2one(comodel_name="res.partner", string="Secondary Ai",
+                                        domain=[('gpt_id', '!=', None), ('is_chat_private', '=', True)])
+    description = fields.Text('Ai Character', help="Ai would help you act as the Character set.")
+    set_max_tokens = fields.Selection([
+        ('300', 'Short'),
+        ('600', 'Standard'),
+        ('1000', 'Medium'),
+        ('2000', 'Long'),
+        ('3000', 'Overlength'),
+        ('32000', '32K'),
+    ], string='Max Response', default='600', help="越大返回内容越多，计费也越多")
+    set_chat_count = fields.Selection([
+        ('none', 'Ai Auto'),
+        ('1', '1标准'),
+        ('3', '3强关联'),
+        ('5', '5超强关联'),
+    ], string="History Count", default='1', help="0-5，设定后，会将最近n次对话发给Ai，有助于他更好的回答，但太大费用也高")
+    set_temperature = fields.Selection([
+        ('2', '天马行空'),
+        ('1.5', '创造性'),
+        ('1', '标准'),
+        ('0.6', '理性'),
+        ('0.1', '保守'),
+    ], string="Set Temperature", default='1', help="0-21，值越大越富有想像力，越小则越保守")
+    set_top_p = fields.Selection([
+        ('0.9', '严谨惯性思维'),
+        ('0.6', '标准推理'),
+        ('0.4', '跳跃性'),
+        ('0.1', '随便'),
+    ], string="Top Probabilities", default='0.6', help="0-1，值越大越倾向大众化的连贯思维")
+    # 避免使用常用词
+    set_frequency_penalty = fields.Selection([
+        ('2', '老学究-晦涩难懂'),
+        ('1.5', '学院派-较多高级词'),
+        ('1', '标准'),
+        ('0.1', '少常用词'),
+        ('-1', '通俗易懂'),
+        ('-2', '大白话'),
+    ], string='Frequency Penalty', default='1', help="-2~2，值越大越少使用常用词")
+    set_presence_penalty = fields.Selection([
+        ('2', '多样强迫症'),
+        ('1.5', '新颖化'),
+        ('1', '标准'),
+        ('0.1', '允许常规重复'),
+        ('-1', '允许较多重复'),
+        ('-2', '更多强调重复'),
+    ], string='Presence penalty', default='1', help="-2~2，值越大越少重复词")
+
+    # todo: 这里用 compute?
+    max_tokens = fields.Integer('最长响应Token', default=600, help="越大返回内容越多，计费也越多")
+    chat_count = fields.Integer(string="上下文数量", default=0, help="0~3，设定后，会将最近n次对话发给Ai，有助于他更好的回答")
+    temperature = fields.Float(string="创造性值", default=1, help="0~2，值越大越富有想像力，越小则越保守")
+    top_p = fields.Float(string="连贯性值", default=0.6, help="0~1，值越大越富有想像力，越小则越保守")
+    frequency_penalty = fields.Float('避免常用词值', default=1, help="-2~2，值越大越少使用常用词")
+    presence_penalty = fields.Float('避免重复词值', default=1, help="-2~2，值越大越少重复词")
+
+    is_current_channel = fields.Boolean('是否当前用户默认频道', compute='_compute_is_current_channel', help='是否当前用户默认微信对话频道')
+
+    def name_get(self):
+        result = []
+        for c in self:
+            pre = '[私]' if c.channel_type == 'channel' and c.is_private else ''
+            result.append((c.id, f"{pre}{c.name or ''}"))
+        return result
+
+    def get_openai_context(self, channel_id, author_id, answer_id, minutes=60, chat_count=0):
+        # 上下文处理，要处理群的方式，以及独聊的方式
+        # azure新api 处理
+        context_history = []
+        afterTime = fields.Datetime.now() - datetime.timedelta(minutes=minutes)
+        message_model = self.env['mail.message'].sudo()
+        # 处理消息： 取最新问题 + 上 chat_count=1次的交互，将之前的交互按时间顺序拼接。
+        # 注意： ai 每一次回复都有 parent_id 来处理连续性
+        # 私聊处理
+
+        # todo: 更好的处理方式
+        domain = [('res_id', '=', channel_id),
+                  ('model', '=', 'discuss.channel'),
+                  ('message_type', '!=', 'user_notification'),
+                  ('parent_id', '!=', False),
+                  ('is_ai', '=', True),
+                  ('body', '!=', '<p>%s</p>' % _('Response Timeout, please speak again.')),
+                  ('body', '!=', _('温馨提示：您发送的内容含有敏感词，请修改内容后再向我发送。'))]
+
+        if self.channel_type in ['group', 'channel']:
+            # 群聊增加时间限制，当前找所有人，不限制 author_id
+            domain = expression.AND([domain, [('date', '>=', afterTime)]])
+        else:
+            domain = expression.AND([domain, [('author_id', '=', answer_id.id)]])
+        if chat_count == 0:
+            ai_msg_list = []
+        else:
+            ai_msg_list = message_model.with_context(tz='UTC').search(domain, order="id desc", limit=chat_count)
+        for ai_msg in ai_msg_list:
+            # 判断这个 ai_msg 是不是ai发，有才 insert。 判断 user_msg 是不是 user发的，有才 insert
+            user_msg = ai_msg.parent_id.sudo()
+            if ai_msg.author_id.sudo().gpt_id and answer_id.sudo().gpt_id and ai_msg.author_id.sudo().gpt_id == answer_id.sudo().gpt_id:
+                ai_content = str(ai_msg.body).replace("<p>", "").replace("</p>", "").replace("<p>", "")
+                context_history.insert(0, {
+                    'role': 'assistant',
+                    'content': ai_content,
+                })
+            if not user_msg.author_id.gpt_id:
+                user_content = user_msg.description.replace("<p>", "").replace("</p>", "").replace('@%s' % answer_id.name, '').lstrip()
+                context_history.insert(0, {
+                    'role': 'user',
+                    'content': user_content,
+                })
+        return context_history
+
+    def get_ai_config(self, ai):
+        # 勾子，用于取ai 配置
+        return {}
+
+    def get_ai_response(self, ai, messages, channel, user_id, message):
+        author_id = message.create_uid.partner_id
+        answer_id = user_id.partner_id
+        # todo: 只有个人配置的群聊才给配置
+        param = self.get_ai_config(ai)
+        res, usage, is_ai = ai.get_ai(messages, author_id, answer_id, param)
+        if res:
+            if get_ua_type() != 'wxweb':
+                # 处理当微信语音返回时，是直接回文本信息，不需要转换回车
+                res = res.replace('\n', '<br/>')
+            new_msg = channel.with_user(user_id).message_post(body=res, message_type='comment', subtype_xmlid='mail.mt_comment', parent_id=message.id)
+            if usage:
+                if ai.provider == 'ali':
+                    prompt_tokens = usage['input_tokens']
+                    completion_tokens = usage['output_tokens']
+                    total_tokens = usage['input_tokens'] + usage['output_tokens']
+                else:
+                    prompt_tokens = usage['prompt_tokens']
+                    completion_tokens = usage['completion_tokens']
+                    total_tokens = usage['total_tokens']
+                new_msg.write({
+                    'human_prompt_tokens': prompt_tokens,
+                    'ai_completion_tokens': completion_tokens,
+                    'cost_tokens': total_tokens,
+                })
+
+    def _notify_thread(self, message, msg_vals=False, **kwargs):
+        rdata = super(Channel, self)._notify_thread(message, msg_vals=msg_vals, **kwargs)
+        # print(f'rdata:{rdata}')
+        answer_id = self.env['res.partner']
+        user_id = self.env['res.users']
+        author_id = msg_vals.get('author_id')
+        ai = self.env['ai.robot'].sudo()
+        channel = self.env['discuss.channel']
+        channel_type = self.channel_type
+        messages = []
+
+        # 不处理 一般notify，但处理欢迎
+        if '<div class="o_mail_notification' in message.body and message.body != _('<div class="o_mail_notification">joined the channel</div>'):
+            return rdata
+        if 'o_odoobot_command' in message.body:
+            return rdata
+
+        if channel_type == 'chat':
+            channel_partner_ids = self.channel_partner_ids
+            answer_id = channel_partner_ids - message.author_id
+            user_id = answer_id.mapped('user_ids').sudo().filtered(lambda r: r.gpt_id)[:1]
+            if user_id and answer_id.gpt_id:
+                gpt_policy = user_id.gpt_policy
+                gpt_wl_partners = user_id.gpt_wl_partners
+                is_allow = message.author_id.id in gpt_wl_partners.ids
+                if gpt_policy == 'all' or (gpt_policy == 'limit' and is_allow):
+                    ai = answer_id.sudo().gpt_id
+
+        elif channel_type in ['group', 'channel']:
+            # partner_ids = @ ids
+            partner_ids = list(msg_vals.get('partner_ids'))
+            if hasattr(self, 'ai_partner_id') and self.ai_partner_id:
+                # 当有主id时，使用主id
+                if self.ai_partner_id.id in partner_ids:
+                    partner_ids = [self.ai_partner_id.id]
+            if partner_ids:
+                # 常规群聊 @
+                partners = self.env['res.partner'].search([('id', 'in', partner_ids)])
+                # user_id = user, who has binded gpt robot
+                user_id = partners.mapped('user_ids').sudo().filtered(lambda r: r.gpt_id)[:1]
+            elif message.body == _('<div class="o_mail_notification">joined the channel</div>'):
+                # 欢迎的情况
+                partners = self.channel_partner_ids.sudo().filtered(lambda r: r.gpt_id)[:1]
+                user_id = partners.mapped('user_ids')[:1]
+            elif self.member_count == 2:
+                # 处理独聊频道
+                if hasattr(self, 'is_private') and not self.is_private:
+                    # 2个人的非私有频道不处理
+                    pass
+                else:
+                    partners = self.channel_partner_ids.sudo().filtered(lambda r: r.gpt_id and r != message.author_id)[:1]
+                    user_id = partners.mapped('user_ids')[:1]
+            elif not message.author_id.gpt_id:
+                # 没有@时，默认第一个robot
+                # robot = self.env.ref('app_chatgpt.chatgpt_robot')
+                # 临时用azure
+                if hasattr(self, 'ai_partner_id') and self.ai_partner_id:
+                    # 当有主id时，使用主id
+                    user_id = self.ai_partner_id.mapped('user_ids')[:1]
+                else:
+                    # 使用群里的第一个robot
+                    partners = self.channel_partner_ids.sudo().filtered(lambda r: r.gpt_id)[:1]
+                    user_id = partners.mapped('user_ids')[:1]
+            if user_id:
+                ai = user_id.sudo().gpt_id
+            #     此处理不判断，将此处逻辑迁移至 get_ai_pre， 非ai回复的直接内容注意设置为 is_ai=false
+            #     gpt_policy = user_id.gpt_policy
+            #     gpt_wl_partners = user_id.gpt_wl_partners
+            #     is_allow = message.author_id.id in gpt_wl_partners.ids
+            #     answer_id = user_id.partner_id
+            #     if gpt_policy == 'all' or (gpt_policy == 'limit' and is_allow):
+            #         ai = user_id.sudo().gpt_id
+            #     elif user_id.gpt_id and not is_allow:
+            #         # 暂时有限用户的Ai
+            #         raise UserError(_('此Ai暂时未开放，请联系管理员。'))
+        if hasattr(ai, 'is_translator') and ai.is_translator and ai.ai_model == 'translator':
+            return rdata
+        chatgpt_channel_id = self.env.ref('app_chatgpt.channel_chatgpt')
+
+        if message.body == _('<div class="o_mail_notification">joined the channel</div>'):
+            msg = _("Please warmly welcome our new partner %s and send him the best wishes.") % message.author_id.name
+        else:
+            # 不能用 preview， 如果用 : 提示词则 preview信息丢失
+            plaintext_ct = tools.html_to_inner_content(message.body)
+            msg = plaintext_ct.replace('@%s' % answer_id.name, '').lstrip()
+
+        if not msg:
+            return rdata
+
+        if self._context.get('app_ai_sync_config') and self._context.get('app_ai_sync_config') in ['sync', 'async']:
+            sync_config = self._context.get('app_ai_sync_config')
+        else:
+            sync_config = self.env['ir.config_parameter'].sudo().get_param('app_chatgpt.openai_sync_config')
+        # api_key = self.env['ir.config_parameter'].sudo().get_param('app_chatgpt.openapi_api_key')
+        # ai处理，不要自问自答
+        if ai and answer_id != message.author_id:
+            api_key = ai.openapi_api_key
+            if not api_key:
+                _logger.warning(_("ChatGPT Robot【%s】have not set open api key."))
+                return rdata
+            try:
+                openapi_context_timeout = int(self.env['ir.config_parameter'].sudo().get_param('app_chatgpt.openapi_context_timeout')) or 60
+            except:
+                openapi_context_timeout = 60
+            openai.api_key = api_key
+            # 非4版本，取0次。其它取3 次历史
+            chat_count = 3
+            if '4' in ai.ai_model or '4' in ai.name:
+                chat_count = 1
+                if hasattr(self, 'chat_count'):
+                    if self.chat_count > 0:
+                        chat_count = 1
+            else:
+                chat_count = chat_count
+
+            if author_id != answer_id.id and self.channel_type == 'chat':
+                # 私聊
+                _logger.info(f'私聊:author_id:{author_id},partner_chatgpt.id:{answer_id.id}')
+                channel = self.env[msg_vals.get('model')].browse(msg_vals.get('res_id'))
+            elif author_id != answer_id.id and msg_vals.get('model', '') == 'discuss.channel' and msg_vals.get('res_id', 0) == chatgpt_channel_id.id:
+                # todo: 公开的群聊，当前只开1个，后续更多
+                _logger.info(f'频道群聊:author_id:{author_id},partner_chatgpt.id:{answer_id.id}')
+                channel = chatgpt_channel_id
+            elif author_id != answer_id.id and msg_vals.get('model', '') == 'discuss.channel' and self.channel_type in ['group', 'channel']:
+                # 高级用户自建的话题
+                channel = self.env[msg_vals.get('model')].browse(msg_vals.get('res_id'))
+                if hasattr(channel, 'is_private') and channel.description:
+                    messages.append({"role": "system", "content": channel.description})
+
+            try:
+                c_history = self.get_openai_context(channel.id, author_id, answer_id, openapi_context_timeout, chat_count)
+                if c_history:
+                    messages += c_history
+                messages.append({"role": "user", "content": msg})
+                msg_len = sum(len(str(m)) for m in messages)
+                # 接口最大接收 8430 Token
+                if msg_len * 2 > ai.max_send_char:
+                    messages = []
+                    if hasattr(channel, 'is_private') and channel.description:
+                        messages.append({"role": "system", "content": channel.description})
+                    messages.append({"role": "user", "content": msg})
+                    msg_len = sum(len(str(m)) for m in messages)
+                    if msg_len * 2 > ai.max_send_char:
+                        new_msg = channel.with_user(user_id).message_post(body=_('您所发送的提示词已超长。'), message_type='comment',
+                                                                          subtype_xmlid='mail.mt_comment',
+                                                                          parent_id=message.id)
+
+                    # if msg_len * 2 >= 8000:
+                    # messages = [{"role": "user", "content": msg}]
+                self.get_ai_response(ai, messages, channel, user_id, message)
+                # if sync_config == 'sync':
+                #     self.get_ai_response(ai, messages, channel, user_id, message)
+                # else:
+                #     self.with_delay().get_ai_response(ai, messages, channel, user_id, message)
+            except Exception as e:
+                raise UserError(_(e))
+
+        return rdata
+
+    def _message_post_after_hook(self, message, msg_vals):
+        if message.author_id.gpt_id:
+            if msg_vals['body'] not in [_('Response Timeout, please speak again.'), _('温馨提示：您发送的内容含有敏感词，请修改内容后再向我发送。'),
+                                        _('此Ai暂时未开放，请联系管理员。'), _('您所发送的提示词已超长。')]:
+                message.is_ai = True
+        return super(Channel, self)._message_post_after_hook(message, msg_vals)
+
+    @api.model
+    def _get_my_last_cid(self):
+        # 获取当前用户最后一次进入的channel，返回该channel的id
+        # todo: 优化，每次聊天进入时就 write
+        user = self.env.user
+        msgs = self.env['mail.message'].sudo().search([
+            ('model', '=', 'discuss.channel'),
+            ('author_id', '=', user.partner_id.id),
+        ], limit=3, order='id desc')
+        c_id = 0
+        c = self
+        for m in msgs:
+            c = self.browse(m.res_id)
+            if c.is_member:
+                c_id = c.id
+                break
+        if not c_id:
+            c = self.env.ref('app_chatgpt.channel_chatgpt', raise_if_not_found=False)
+            c_id = c.id or False
+        if c and not c.is_member:
+            c.sudo().add_members([user.partner_id.id])
+        return c_id
+
+    @api.onchange('ai_partner_id')
+    def _onchange_ai_partner_id(self):
+        if self.ai_partner_id and self.ai_partner_id.image_1920:
+            self.image_128 = self.ai_partner_id.avatar_128

app_chatgpt/models/mail_message.py

@@ -0,0 +1,32 @@
+# -*- coding: utf-8 -*-
+
+from odoo import fields, models
+
+
+class Message(models.Model):
+    _inherit = "mail.message"
+
+    human_prompt_tokens = fields.Integer('Human Prompt Tokens')
+    ai_completion_tokens = fields.Integer('AI Completion Tokens')
+    cost_tokens = fields.Integer('Cost Tokens')
+    # 是否ai回复
+    is_ai = fields.Boolean('Is Ai', default=False)
+    # 得到 ai 响应后，需要特殊处理ai的
+    ai2model = fields.Char('Ai Response model')
+    ai2id = fields.Integer('Ai Response id')
+
+    def _message_add_reaction(self, content):
+        super(Message, self)._message_add_reaction(content)
+        if self.create_uid.gpt_id:
+            # 处理反馈
+            pass
+
+    def message_format(self, format_reply=True, msg_vals=None):
+        message_values = super(Message, self).message_format(format_reply=format_reply, msg_vals=msg_vals)
+        for message in message_values:
+            message_sudo = self.browse(message['id']).sudo().with_prefetch(self.ids)
+            message['human_prompt_tokens'] = message_sudo.human_prompt_tokens
+            message['ai_completion_tokens'] = message_sudo.ai_completion_tokens
+            message['cost_tokens'] = message_sudo.cost_tokens
+            message['is_ai'] = message_sudo.is_ai
+        return message_values

app_chatgpt/models/mail_thread.py

@@ -0,0 +1,7 @@
+# -*- coding: utf-8 -*-
+
+from odoo import fields, models, api, _
+
+
+class MailThread(models.AbstractModel):
+    _inherit = "mail.thread"

app_chatgpt/models/res.json

@@ -0,0 +1,21 @@
+{
+  'id': 'chatcmpl-747IRWr2Ij3HA6NVTWp4ZTnEA2grW',
+  'object': 'chat.completion',
+  'created': 1681215715,
+  'model': 'gpt-3.5-turbo-0301',
+  'usage': {
+    'prompt_tokens': 17,
+    'completion_tokens': 38,
+    'total_tokens': 55
+  },
+  'choices': [
+    {
+      'message': {
+        'role': 'assistant',
+        'content': '非常抱歉，我不太理解您在说什么。 可以提供更多背景信息或上下文吗？'
+      },
+      'finish_reason': 'stop',
+      'index': 0
+    }
+  ]
+}

app_chatgpt/models/res_config_settings.py

@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*-
+
+from odoo import fields, models
+
+
+class ResConfigSettings(models.TransientModel):
+    _inherit = "res.config.settings"
+
+    openapi_context_timeout = fields.Integer(string="Connect Timout", help="群聊中多少分钟以内的聊天信息作为上下文继续", config_parameter="app_chatgpt.openapi_context_timeout")
+    openai_sync_config = fields.Selection([
+        ('sync', 'Synchronous'),
+        ('async', 'Asynchronous')
+    ], string='Sync Config', default='sync', config_parameter="app_chatgpt.openai_sync_config")

app_chatgpt/models/res_partner.py

@@ -0,0 +1,61 @@
+# -*- coding: utf-8 -*-
+
+from odoo import fields, models, api
+from odoo.addons.mail.tools.discuss import Store
+
+
+class ResPartner(models.Model):
+    _inherit = "res.partner"
+
+    gpt_id = fields.Many2one('ai.robot', string='Bind to Ai', ondelete='set null')
+
+    is_chat_private = fields.Boolean('Allow Chat Private', default=False)
+
+    @api.model
+    def im_search(self, name, limit=20, excluded_ids=None):
+        users = self.env['res.users'].search([
+            ('id', '!=', self.env.user.id),
+            ('name', 'ilike', name),
+            ('active', '=', True),
+            ('share', '=', False),
+            ('is_chat_private', '=', True)
+        ], order='gpt_id, name, id', limit=limit)
+        # return list(users.partner_id.mail_partner_format().values())
+        return Store(users.partner_id).get_result()
+
+    def mail_partner_format(self, fields=None):
+        # TODO: remove !!!
+        # 直接覆盖原生，增加 gpt_id 字段
+        partners_format = dict()
+        if not fields:
+            fields = {'id': True, 'name': True, 'email': True, 'active': True, 'im_status': True, 'gpt_id': 0, 'user': {}}
+        for partner in self:
+            data = {}
+            if 'id' in fields:
+                data['id'] = partner.id
+            if 'name' in fields:
+                name = partner.name
+                # 英文不好分，暂时不隐名
+                # if not partner.related_user_id.gpt_id:
+                #     name = partner.name[0] + '*' * (len(partner.name) - 1)
+                data['name'] = name
+            if 'email' in fields:
+                data['email'] = partner.email
+            if 'active' in fields:
+                data['active'] = partner.active
+            if 'im_status' in fields:
+                data['im_status'] = partner.im_status
+            if 'gpt_id' in fields:
+                data['gpt_id'] = partner.gpt_id.id if partner.gpt_id else 0
+            if 'user' in fields:
+                internal_users = partner.user_ids - partner.user_ids.filtered('share')
+                main_user = internal_users[0] if len(internal_users) > 0 else partner.user_ids[0] if len(partner.user_ids) > 0 else self.env['res.users']
+                data['user'] = {
+                    "id": main_user.id,
+                    "isInternalUser": not main_user.share,
+                } if main_user else [('clear',)]
+            # if 'guest' in self.env.context or not self.env.user.has_group('base.group_erp_manager'):
+            # 完全不显示 邮箱
+            data.pop('email', None)
+            partners_format[partner] = data
+        return partners_format

app_chatgpt/models/res_partner_ai_use.py

@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+
+from odoo import fields, models
+
+
+class ResPartnerAiUse(models.Model):
+    _name = "res.partner.ai.use"
+    _description = '消费者Ai使用情况'
+
+    name = fields.Many2one('res.partner', 'Partner')
+    ai_user_id = fields.Many2one('res.users', 'Ai User', domain=[('gpt_id', '!=', False)])
+    first_ask_time = fields.Datetime('First Ask Time')
+    latest_ask_time = fields.Datetime('Latest Ask Time')
+    service_start_date = fields.Datetime('Service Start Date')
+    service_end_date = fields.Datetime('Service End Date')
+    used_number = fields.Integer('Number of Used')
+    max_number = fields.Integer('Max Number of Call')
+    human_prompt_tokens = fields.Integer('Human Prompt Tokens')
+    ai_completion_tokens = fields.Integer('AI Completion Tokens')
+    tokens_total = fields.Integer('Total Tokens')
+    token_balance = fields.Integer('Token Balance')
+    # balance = allow - total
+    token_allow = fields.Integer('Token Allow')

app_chatgpt/models/res_users.py

@@ -0,0 +1,17 @@
+# -*- coding: utf-8 -*-
+
+from odoo import fields, models
+
+
+class ResUsers(models.Model):
+    _inherit = "res.users"
+
+    # 改为在 partner中设置，用户处绑定
+    gpt_id = fields.Many2one('ai.robot', string='Bind to Ai', related='partner_id.gpt_id', inherited=True, readonly=False)
+    gpt_policy = fields.Selection([
+        ('all', 'All Users'),
+        ('limit', 'Selected Users')
+    ], string='Allowed Conversation Mode', default='all', ondelete='set default')
+    gpt_wl_partners = fields.Many2many('res.partner', 'res_partner_ai_use', 'ai_user_id', 'name', string='Allowed Partners')
+    gpt_demo_time = fields.Integer('Default Demo Time', default=0)
+    is_chat_private = fields.Boolean('Allow Chat Private', default=False, related='partner_id.is_chat_private', inherited=True, readonly=False)

app_chatgpt/models/z_model_info.json

@@ -0,0 +1,23 @@
+{
+  "id": "gpt-3.5-turbo",
+  "object": "model",
+  "created": 1677610602,
+  "owned_by": "openai",
+  "permission": [
+    {
+      "object": "model_permission",
+      "created": 1677691854,
+      "allow_create_engine": false,
+      "allow_sampling": true,
+      "allow_logprobs": true,
+      "allow_search_indices": false,
+      "allow_view": true,
+      "allow_fine_tuning": false,
+      "organization": "*",
+      "group": null,
+      "is_blocking": false
+    }
+  ],
+  "root": "gpt-3.5-turbo",
+  "parent": null
+}