feat: personal ai agent framework

bot/claude/claude_ai_bot.py

@@ -1,222 +0,0 @@
-import re
-import time
-import json
-import uuid
-from curl_cffi import requests
-from bot.bot import Bot
-from bot.claude.claude_ai_session import ClaudeAiSession
-from bot.openai.open_ai_image import OpenAIImage
-from bot.session_manager import SessionManager
-from bridge.context import Context, ContextType
-from bridge.reply import Reply, ReplyType
-from common.log import logger
-from config import conf
-
-
-class ClaudeAIBot(Bot, OpenAIImage):
-    def __init__(self):
-        super().__init__()
-        self.sessions = SessionManager(ClaudeAiSession, model=conf().get("model") or "gpt-3.5-turbo")
-        self.claude_api_cookie = conf().get("claude_api_cookie")
-        self.proxy = conf().get("proxy")
-        self.con_uuid_dic = {}
-        if self.proxy:
-            self.proxies = {
-            "http": self.proxy,
-            "https": self.proxy
-        }
-        else:
-            self.proxies = None
-        self.error = ""
-        self.org_uuid = self.get_organization_id()
-
-    def generate_uuid(self):
-        random_uuid = uuid.uuid4()
-        random_uuid_str = str(random_uuid)
-        formatted_uuid = f"{random_uuid_str[0:8]}-{random_uuid_str[9:13]}-{random_uuid_str[14:18]}-{random_uuid_str[19:23]}-{random_uuid_str[24:]}"
-        return formatted_uuid
-        
-    def reply(self, query, context: Context = None) -> Reply:
-        if context.type == ContextType.TEXT:
-            return self._chat(query, context)
-        elif context.type == ContextType.IMAGE_CREATE:
-            ok, res = self.create_img(query, 0)
-            if ok:
-                reply = Reply(ReplyType.IMAGE_URL, res)
-            else:
-                reply = Reply(ReplyType.ERROR, res)
-            return reply
-        else:
-            reply = Reply(ReplyType.ERROR, "Bot不支持处理{}类型的消息".format(context.type))
-            return reply
-
-    def get_organization_id(self):
-        url = "https://claude.ai/api/organizations"
-        headers = {
-            'User-Agent':
-                'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/115.0',
-            'Accept-Language': 'en-US,en;q=0.5',
-            'Referer': 'https://claude.ai/chats',
-            'Content-Type': 'application/json',
-            'Sec-Fetch-Dest': 'empty',
-            'Sec-Fetch-Mode': 'cors',
-            'Sec-Fetch-Site': 'same-origin',
-            'Connection': 'keep-alive',
-            'Cookie': f'{self.claude_api_cookie}'
-        }
-        try:
-            response = requests.get(url, headers=headers, impersonate="chrome110", proxies =self.proxies, timeout=400)
-            res = json.loads(response.text)
-            uuid = res[0]['uuid']
-        except:
-            if "App unavailable" in response.text:
-                logger.error("IP error: The IP is not allowed to be used on Claude")
-                self.error = "ip所在地区不被claude支持"
-            elif "Invalid authorization" in response.text:
-                logger.error("Cookie error: Invalid authorization of claude, check cookie please.")
-                self.error = "无法通过claude身份验证，请检查cookie"
-            return None
-        return uuid
-
-    def conversation_share_check(self,session_id):
-        if conf().get("claude_uuid") is not None and conf().get("claude_uuid") != "":
-            con_uuid = conf().get("claude_uuid")
-            return con_uuid
-        if session_id not in self.con_uuid_dic:
-            self.con_uuid_dic[session_id] = self.generate_uuid()
-            self.create_new_chat(self.con_uuid_dic[session_id])
-        return self.con_uuid_dic[session_id]
-
-    def check_cookie(self):
-        flag = self.get_organization_id()
-        return flag
-
-    def create_new_chat(self, con_uuid):
-        """
-        新建claude对话实体
-        :param con_uuid: 对话id
-        :return:
-        """
-        url = f"https://claude.ai/api/organizations/{self.org_uuid}/chat_conversations"
-        payload = json.dumps({"uuid": con_uuid, "name": ""})
-        headers = {
-            'User-Agent':
-                'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/115.0',
-            'Accept-Language': 'en-US,en;q=0.5',
-            'Referer': 'https://claude.ai/chats',
-            'Content-Type': 'application/json',
-            'Origin': 'https://claude.ai',
-            'DNT': '1',
-            'Connection': 'keep-alive',
-            'Cookie': self.claude_api_cookie,
-            'Sec-Fetch-Dest': 'empty',
-            'Sec-Fetch-Mode': 'cors',
-            'Sec-Fetch-Site': 'same-origin',
-            'TE': 'trailers'
-        }
-        response = requests.post(url, headers=headers, data=payload, impersonate="chrome110", proxies=self.proxies, timeout=400)
-        # Returns JSON of the newly created conversation information
-        return response.json()
-        
-    def _chat(self, query, context, retry_count=0) -> Reply:
-        """
-        发起对话请求
-        :param query: 请求提示词
-        :param context: 对话上下文
-        :param retry_count: 当前递归重试次数
-        :return: 回复
-        """
-        if retry_count >= 2:
-            # exit from retry 2 times
-            logger.warn("[CLAUDEAI] failed after maximum number of retry times")
-            return Reply(ReplyType.ERROR, "请再问我一次吧")
-
-        try:
-            session_id = context["session_id"]
-            if self.org_uuid is None:
-                return Reply(ReplyType.ERROR, self.error)
-
-            session = self.sessions.session_query(query, session_id)
-            con_uuid = self.conversation_share_check(session_id)
-
-            model = conf().get("model") or "gpt-3.5-turbo"
-            # remove system message
-            if session.messages[0].get("role") == "system":
-                if model == "wenxin" or model == "claude":
-                    session.messages.pop(0)
-            logger.info(f"[CLAUDEAI] query={query}")
-
-            # do http request
-            base_url = "https://claude.ai"
-            payload = json.dumps({
-                "completion": {
-                    "prompt": f"{query}",
-                    "timezone": "Asia/Kolkata",
-                    "model": "claude-2"
-                },
-                "organization_uuid": f"{self.org_uuid}",
-                "conversation_uuid": f"{con_uuid}",
-                "text": f"{query}",
-                "attachments": []
-            })
-            headers = {
-                'User-Agent':
-                    'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/115.0',
-                'Accept': 'text/event-stream, text/event-stream',
-                'Accept-Language': 'en-US,en;q=0.5',
-                'Referer': 'https://claude.ai/chats',
-                'Content-Type': 'application/json',
-                'Origin': 'https://claude.ai',
-                'DNT': '1',
-                'Connection': 'keep-alive',
-                'Cookie': f'{self.claude_api_cookie}',
-                'Sec-Fetch-Dest': 'empty',
-                'Sec-Fetch-Mode': 'cors',
-                'Sec-Fetch-Site': 'same-origin',
-                'TE': 'trailers'
-            }
-
-            res = requests.post(base_url + "/api/append_message", headers=headers, data=payload,impersonate="chrome110",proxies= self.proxies,timeout=400)
-            if res.status_code == 200 or "pemission" in res.text:
-                # execute success
-                decoded_data = res.content.decode("utf-8")
-                decoded_data = re.sub('\n+', '\n', decoded_data).strip()
-                data_strings = decoded_data.split('\n')
-                completions = []
-                for data_string in data_strings:
-                    json_str = data_string[6:].strip()
-                    data = json.loads(json_str)
-                    if 'completion' in data:
-                        completions.append(data['completion'])
-
-                reply_content = ''.join(completions)
-
-                if "rate limi" in reply_content:
-                    logger.error("rate limit error: The conversation has reached the system speed limit and is synchronized with Cladue. Please go to the official website to check the lifting time")
-                    return Reply(ReplyType.ERROR, "对话达到系统速率限制，与cladue同步，请进入官网查看解除限制时间")
-                logger.info(f"[CLAUDE] reply={reply_content}, total_tokens=invisible")
-                self.sessions.session_reply(reply_content, session_id, 100)
-                return Reply(ReplyType.TEXT, reply_content)
-            else:
-                flag = self.check_cookie()
-                if flag == None:
-                    return Reply(ReplyType.ERROR, self.error)
-
-                response = res.json()
-                error = response.get("error")
-                logger.error(f"[CLAUDE] chat failed, status_code={res.status_code}, "
-                             f"msg={error.get('message')}, type={error.get('type')}, detail: {res.text}, uuid: {con_uuid}")
-
-                if res.status_code >= 500:
-                    # server error, need retry
-                    time.sleep(2)
-                    logger.warn(f"[CLAUDE] do retry, times={retry_count}")
-                    return self._chat(query, context, retry_count + 1)
-                return Reply(ReplyType.ERROR, "提问太快啦，请休息一下再问我吧")
-
-        except Exception as e:
-            logger.exception(e)
-            # retry
-            time.sleep(2)
-            logger.warn(f"[CLAUDE] do retry, times={retry_count}")
-            return self._chat(query, context, retry_count + 1)

bot/claude/claude_ai_session.py

@@ -1,9 +0,0 @@
-from bot.session_manager import Session
-
-
-class ClaudeAiSession(Session):
-    def __init__(self, session_id, system_prompt=None, model="claude"):
-        super().__init__(session_id, system_prompt)
-        self.model = model
-        # claude逆向不支持role prompt
-        # self.reset()

bot/claudeapi/claude_api_bot.py

@@ -1,19 +1,18 @@
 # encoding:utf-8
 
+import json
 import time
 
-import openai
-import openai.error
-import anthropic
+import requests
 
+from bot.baidu.baidu_wenxin_session import BaiduWenxinSession
 from bot.bot import Bot
 from bot.openai.open_ai_image import OpenAIImage
-from bot.baidu.baidu_wenxin_session import BaiduWenxinSession
 from bot.session_manager import SessionManager
 from bridge.context import ContextType
 from bridge.reply import Reply, ReplyType
-from common.log import logger
 from common import const
+from common.log import logger
 from config import conf
 
 user_session = dict()
@@ -23,13 +22,9 @@ user_session = dict()
 class ClaudeAPIBot(Bot, OpenAIImage):
     def __init__(self):
         super().__init__()
-        proxy = conf().get("proxy", None)
-        base_url = conf().get("open_ai_api_base", None)  # 复用"open_ai_api_base"参数作为base_url
-        self.claudeClient = anthropic.Anthropic(
-            api_key=conf().get("claude_api_key"),
-            proxies=proxy if proxy else None,
-            base_url=base_url if base_url else None
-        )
+        self.api_key = conf().get("claude_api_key")
+        self.api_base = conf().get("open_ai_api_base") or "https://api.anthropic.com/v1"
+        self.proxy = conf().get("proxy", None)
         self.sessions = SessionManager(BaiduWenxinSession, model=conf().get("model") or "text-davinci-003")
 
     def reply(self, query, context=None):
@@ -73,39 +68,104 @@ class ClaudeAPIBot(Bot, OpenAIImage):
                     reply = Reply(ReplyType.ERROR, retstring)
                 return reply
 
-    def reply_text(self, session: BaiduWenxinSession, retry_count=0):
+    def reply_text(self, session: BaiduWenxinSession, retry_count=0, tools=None):
         try:
             actual_model = self._model_mapping(conf().get("model"))
-            response = self.claudeClient.messages.create(
-                model=actual_model,
-                max_tokens=4096,
-                system=conf().get("character_desc", ""),
-                messages=session.messages
+
+            # Prepare headers
+            headers = {
+                "x-api-key": self.api_key,
+                "anthropic-version": "2023-06-01",
+                "content-type": "application/json"
+            }
+
+            # Extract system prompt if present and prepare Claude-compatible messages
+            system_prompt = conf().get("character_desc", "")
+            claude_messages = []
+
+            for msg in session.messages:
+                if msg.get("role") == "system":
+                    system_prompt = msg["content"]
+                else:
+                    claude_messages.append(msg)
+
+            # Prepare request data
+            data = {
+                "model": actual_model,
+                "messages": claude_messages,
+                "max_tokens": self._get_max_tokens(actual_model)
+            }
+
+            if system_prompt:
+                data["system"] = system_prompt
+
+            if tools:
+                data["tools"] = tools
+
+            # Make HTTP request
+            proxies = {"http": self.proxy, "https": self.proxy} if self.proxy else None
+            response = requests.post(
+                f"{self.api_base}/messages",
+                headers=headers,
+                json=data,
+                proxies=proxies
             )
-            # response = openai.Completion.create(prompt=str(session), **self.args)
-            res_content = response.content[0].text.strip().replace("<|endoftext|>", "")
-            total_tokens = response.usage.input_tokens+response.usage.output_tokens
-            completion_tokens = response.usage.output_tokens
+
+            if response.status_code != 200:
+                raise Exception(f"API request failed: {response.status_code} - {response.text}")
+
+            claude_response = response.json()
+            # Handle response content and tool calls
+            res_content = ""
+            tool_calls = []
+
+            content_blocks = claude_response.get("content", [])
+            for block in content_blocks:
+                if block.get("type") == "text":
+                    res_content += block.get("text", "")
+                elif block.get("type") == "tool_use":
+                    tool_calls.append({
+                        "id": block.get("id", ""),
+                        "name": block.get("name", ""),
+                        "arguments": block.get("input", {})
+                    })
+
+            res_content = res_content.strip().replace("<|endoftext|>", "")
+            usage = claude_response.get("usage", {})
+            total_tokens = usage.get("input_tokens", 0) + usage.get("output_tokens", 0)
+            completion_tokens = usage.get("output_tokens", 0)
+
             logger.info("[CLAUDE_API] reply={}".format(res_content))
-            return {
+            if tool_calls:
+                logger.info("[CLAUDE_API] tool_calls={}".format(tool_calls))
+
+            result = {
                 "total_tokens": total_tokens,
                 "completion_tokens": completion_tokens,
                 "content": res_content,
             }
+
+            if tool_calls:
+                result["tool_calls"] = tool_calls
+
+            return result
         except Exception as e:
             need_retry = retry_count < 2
             result = {"total_tokens": 0, "completion_tokens": 0, "content": "我现在有点累了，等会再来吧"}
-            if isinstance(e, openai.error.RateLimitError):
+
+            # Handle different types of errors
+            error_str = str(e).lower()
+            if "rate" in error_str or "limit" in error_str:
                 logger.warn("[CLAUDE_API] RateLimitError: {}".format(e))
                 result["content"] = "提问太快啦，请休息一下再问我吧"
                 if need_retry:
                     time.sleep(20)
-            elif isinstance(e, openai.error.Timeout):
+            elif "timeout" in error_str:
                 logger.warn("[CLAUDE_API] Timeout: {}".format(e))
                 result["content"] = "我没有收到你的消息"
                 if need_retry:
                     time.sleep(5)
-            elif isinstance(e, openai.error.APIConnectionError):
+            elif "connection" in error_str or "network" in error_str:
                 logger.warn("[CLAUDE_API] APIConnectionError: {}".format(e))
                 need_retry = False
                 result["content"] = "我连接不到你的网络"
@@ -116,7 +176,7 @@ class ClaudeAPIBot(Bot, OpenAIImage):
 
             if need_retry:
                 logger.warn("[CLAUDE_API] 第{}次重试".format(retry_count + 1))
-                return self.reply_text(session, retry_count + 1)
+                return self.reply_text(session, retry_count + 1, tools)
             else:
                 return result
 
@@ -130,3 +190,288 @@ class ClaudeAPIBot(Bot, OpenAIImage):
         elif model == "claude-3.5-sonnet":
             return const.CLAUDE_35_SONNET
         return model
+
+    def _get_max_tokens(self, model: str) -> int:
+        """
+        Get max_tokens for the model.
+        Reference from pi-mono:
+        - Claude 3.5/3.7: 8192
+        - Claude 3 Opus: 4096
+        - Default: 8192
+        """
+        if model and (model.startswith("claude-3-5") or model.startswith("claude-3-7")):
+            return 8192
+        elif model and model.startswith("claude-3") and "opus" in model:
+            return 4096
+        elif model and (model.startswith("claude-sonnet-4") or model.startswith("claude-opus-4")):
+            return 64000
+        return 8192
+
+    def call_with_tools(self, messages, tools=None, stream=False, **kwargs):
+        """
+        Call Claude API with tool support for agent integration
+
+        Args:
+            messages: List of messages
+            tools: List of tool definitions
+            stream: Whether to use streaming
+            **kwargs: Additional parameters
+            
+        Returns:
+            Formatted response compatible with OpenAI format or generator for streaming
+        """
+        actual_model = self._model_mapping(conf().get("model"))
+
+        # Extract system prompt from messages if present
+        system_prompt = kwargs.get("system", conf().get("character_desc", ""))
+        claude_messages = []
+
+        for msg in messages:
+            if msg.get("role") == "system":
+                system_prompt = msg["content"]
+            else:
+                claude_messages.append(msg)
+
+        request_params = {
+            "model": actual_model,
+            "max_tokens": kwargs.get("max_tokens", self._get_max_tokens(actual_model)),
+            "messages": claude_messages,
+            "stream": stream
+        }
+
+        if system_prompt:
+            request_params["system"] = system_prompt
+
+        if tools:
+            request_params["tools"] = tools
+
+        try:
+            if stream:
+                return self._handle_stream_response(request_params)
+            else:
+                return self._handle_sync_response(request_params)
+        except Exception as e:
+            logger.error(f"Claude API call error: {e}")
+            if stream:
+                # Return error generator for stream
+                def error_generator():
+                    yield {
+                        "error": True,
+                        "message": str(e),
+                        "status_code": 500
+                    }
+
+                return error_generator()
+            else:
+                # Return error response for sync
+                return {
+                    "error": True,
+                    "message": str(e),
+                    "status_code": 500
+                }
+
+    def _handle_sync_response(self, request_params):
+        """Handle synchronous Claude API response"""
+        # Prepare headers
+        headers = {
+            "x-api-key": self.api_key,
+            "anthropic-version": "2023-06-01",
+            "content-type": "application/json"
+        }
+
+        # Make HTTP request
+        proxies = {"http": self.proxy, "https": self.proxy} if self.proxy else None
+        response = requests.post(
+            f"{self.api_base}/messages",
+            headers=headers,
+            json=request_params,
+            proxies=proxies
+        )
+
+        if response.status_code != 200:
+            raise Exception(f"API request failed: {response.status_code} - {response.text}")
+
+        claude_response = response.json()
+
+        # Extract content blocks
+        text_content = ""
+        tool_calls = []
+
+        content_blocks = claude_response.get("content", [])
+        for block in content_blocks:
+            if block.get("type") == "text":
+                text_content += block.get("text", "")
+            elif block.get("type") == "tool_use":
+                tool_calls.append({
+                    "id": block.get("id", ""),
+                    "type": "function",
+                    "function": {
+                        "name": block.get("name", ""),
+                        "arguments": json.dumps(block.get("input", {}))
+                    }
+                })
+
+        # Build message in OpenAI format
+        message = {
+            "role": "assistant",
+            "content": text_content
+        }
+        if tool_calls:
+            message["tool_calls"] = tool_calls
+
+        # Format response to match OpenAI structure
+        usage = claude_response.get("usage", {})
+        formatted_response = {
+            "id": claude_response.get("id", ""),
+            "object": "chat.completion",
+            "created": int(time.time()),
+            "model": claude_response.get("model", request_params["model"]),
+            "choices": [
+                {
+                    "index": 0,
+                    "message": message,
+                    "finish_reason": claude_response.get("stop_reason", "stop")
+                }
+            ],
+            "usage": {
+                "prompt_tokens": usage.get("input_tokens", 0),
+                "completion_tokens": usage.get("output_tokens", 0),
+                "total_tokens": usage.get("input_tokens", 0) + usage.get("output_tokens", 0)
+            }
+        }
+
+        return formatted_response
+
+    def _handle_stream_response(self, request_params):
+        """Handle streaming Claude API response using HTTP requests"""
+        # Prepare headers
+        headers = {
+            "x-api-key": self.api_key,
+            "anthropic-version": "2023-06-01",
+            "content-type": "application/json"
+        }
+
+        # Add stream parameter
+        request_params["stream"] = True
+
+        # Track tool use state
+        tool_uses_map = {}  # {index: {id, name, input}}
+        current_tool_use_index = -1
+
+        try:
+            # Make streaming HTTP request
+            proxies = {"http": self.proxy, "https": self.proxy} if self.proxy else None
+            response = requests.post(
+                f"{self.api_base}/messages",
+                headers=headers,
+                json=request_params,
+                proxies=proxies,
+                stream=True
+            )
+
+            if response.status_code != 200:
+                error_text = response.text
+                try:
+                    error_data = json.loads(error_text)
+                    error_msg = error_data.get("error", {}).get("message", error_text)
+                except:
+                    error_msg = error_text or "Unknown error"
+
+                yield {
+                    "error": True,
+                    "status_code": response.status_code,
+                    "message": error_msg
+                }
+                return
+
+            # Process streaming response
+            for line in response.iter_lines():
+                if line:
+                    line = line.decode('utf-8')
+                    if line.startswith('data: '):
+                        line = line[6:]  # Remove 'data: ' prefix
+                        if line == '[DONE]':
+                            break
+                        try:
+                            event = json.loads(line)
+                            event_type = event.get("type")
+
+                            if event_type == "content_block_start":
+                                # New content block
+                                block = event.get("content_block", {})
+                                if block.get("type") == "tool_use":
+                                    current_tool_use_index = event.get("index", 0)
+                                    tool_uses_map[current_tool_use_index] = {
+                                        "id": block.get("id", ""),
+                                        "name": block.get("name", ""),
+                                        "input": ""
+                                    }
+
+                            elif event_type == "content_block_delta":
+                                delta = event.get("delta", {})
+                                delta_type = delta.get("type")
+
+                                if delta_type == "text_delta":
+                                    # Text content
+                                    content = delta.get("text", "")
+                                    yield {
+                                        "id": event.get("id", ""),
+                                        "object": "chat.completion.chunk",
+                                        "created": int(time.time()),
+                                        "model": request_params["model"],
+                                        "choices": [{
+                                            "index": 0,
+                                            "delta": {"content": content},
+                                            "finish_reason": None
+                                        }]
+                                    }
+
+                                elif delta_type == "input_json_delta":
+                                    # Tool input accumulation
+                                    if current_tool_use_index >= 0:
+                                        tool_uses_map[current_tool_use_index]["input"] += delta.get("partial_json", "")
+
+                            elif event_type == "message_delta":
+                                # Message complete - yield tool calls if any
+                                if tool_uses_map:
+                                    for idx in sorted(tool_uses_map.keys()):
+                                        tool_data = tool_uses_map[idx]
+                                        yield {
+                                            "id": event.get("id", ""),
+                                            "object": "chat.completion.chunk",
+                                            "created": int(time.time()),
+                                            "model": request_params["model"],
+                                            "choices": [{
+                                                "index": 0,
+                                                "delta": {
+                                                    "tool_calls": [{
+                                                        "index": idx,
+                                                        "id": tool_data["id"],
+                                                        "type": "function",
+                                                        "function": {
+                                                            "name": tool_data["name"],
+                                                            "arguments": tool_data["input"]
+                                                        }
+                                                    }]
+                                                },
+                                                "finish_reason": None
+                                            }]
+                                        }
+
+                        except json.JSONDecodeError:
+                            continue
+
+        except requests.RequestException as e:
+            logger.error(f"Claude streaming request error: {e}")
+            yield {
+                "error": True,
+                "message": f"Connection error: {str(e)}",
+                "status_code": 0
+            }
+        except Exception as e:
+            logger.error(f"Claude streaming error: {e}")
+            yield {
+                "error": True,
+                "message": str(e),
+                "status_code": 500
+            }