Supported Claude

json_str/claude/request.json

@@ -0,0 +1,72 @@
+{
+    "model": "claude-3-5-sonnet-20240620",
+    "messages": [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "text",
+                    "text": "hi"
+                }
+            ]
+        }
+    ],
+    "temperature": 0.5,
+    "top_p": 0.7,
+    "max_tokens": 4096,
+    "stream": true,
+    "system": "You are Claude, a large language model trained by Anthropic. Use simple characters to represent mathematical symbols. Do not use LaTeX commands. Respond conversationally in English.",
+    "tools": [
+        {
+            "name": "get_search_results",
+            "description": "Search Google to enhance knowledge.",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "prompt": {
+                        "type": "string",
+                        "description": "The prompt to search."
+                    }
+                },
+                "required": [
+                    "prompt"
+                ]
+            }
+        },
+        {
+            "name": "get_url_content",
+            "description": "Get the webpage content of a URL",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "url": {
+                        "type": "string",
+                        "description": "the URL to request"
+                    }
+                },
+                "required": [
+                    "url"
+                ]
+            }
+        },
+        {
+            "name": "download_read_arxiv_pdf",
+            "description": "Get the content of the paper corresponding to the arXiv ID",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "prompt": {
+                        "type": "string",
+                        "description": "the arXiv ID of the paper"
+                    }
+                },
+                "required": [
+                    "prompt"
+                ]
+            }
+        }
+    ],
+    "tool_choice": {
+        "type": "auto"
+    }
+}

main.py

@@ -64,12 +64,12 @@ async def process_request(request: RequestModel, provider: Dict):
 
     url, headers, payload = await get_payload(request, engine, provider)
 
-    # request_info = {
-    #     "url": url,
-    #     "headers": headers,
-    #     "payload": payload
-    # }
-    # print(f"Request details: {json.dumps(request_info, indent=2, ensure_ascii=False)}")
+    request_info = {
+        "url": url,
+        "headers": headers,
+        "payload": payload
+    }
+    print(f"Request details: {json.dumps(request_info, indent=2, ensure_ascii=False)}")
 
     if request.stream:
         return StreamingResponse(fetch_response_stream(app.state.client, url, headers, payload, engine, request.model), media_type="text/event-stream")

request.py

@@ -149,8 +149,102 @@ async def get_gpt_payload(request, engine, provider):
 
     return url, headers, payload
 
+async def gpt2claude_tools_json(json_dict):
+    import copy
+    json_dict = copy.deepcopy(json_dict)
+    keys_to_change = {
+        "parameters": "input_schema",
+    }
+    for old_key, new_key in keys_to_change.items():
+        if old_key in json_dict:
+            if new_key:
+                json_dict[new_key] = json_dict.pop(old_key)
+            else:
+                json_dict.pop(old_key)
+    # if "tools" in json_dict.keys():
+    #     json_dict["tool_choice"] = {
+    #         "type": "auto"
+    #     }
+    return json_dict
+
 async def get_claude_payload(request, engine, provider):
-    pass
+    headers = {
+        "content-type": "application/json",
+        "x-api-key": f"{provider['api']}",
+        "anthropic-version": "2023-06-01",
+        "anthropic-beta": "tools-2024-05-16"
+    }
+    url = provider['base_url']
+
+    messages = []
+    for msg in request.messages:
+        if isinstance(msg.content, list):
+            content = []
+            for item in msg.content:
+                if item.type == "text":
+                    text_message = await get_text_message(msg.role, item.text, engine)
+                    content.append(text_message)
+                elif item.type == "image_url":
+                    image_message = await get_image_message(item.image_url.url, engine)
+                    content.append(image_message)
+        else:
+            content = msg.content
+            name = msg.name
+        if name:
+            messages.append({"role": msg.role, "name": name, "content": content})
+        elif msg.role != "system":
+            messages.append({"role": msg.role, "content": content})
+        elif msg.role == "system":
+            system_prompt = content
+
+    payload = {
+        "model": request.model,
+        "messages": messages,
+        "system": system_prompt,
+    }
+    # json_post = {
+    #     "model": model or self.engine,
+    #     "messages": self.conversation[convo_id] if pass_history else [{
+    #         "role": "user",
+    #         "content": prompt
+    #     }],
+    #     "temperature": kwargs.get("temperature", self.temperature),
+    #     "top_p": kwargs.get("top_p", self.top_p),
+    #     "max_tokens": model_max_tokens,
+    #     "stream": True,
+    # }
+
+    miss_fields = [
+        'model',
+        'messages',
+        'presence_penalty',
+        'frequency_penalty',
+        'n',
+        'user',
+        'include_usage',
+    ]
+
+    for field, value in request.model_dump(exclude_unset=True).items():
+        if field not in miss_fields and value is not None:
+            payload[field] = value
+
+    tools = []
+    for tool in request.tools:
+        print("tool", type(tool), tool)
+
+        json_tool = await gpt2claude_tools_json(tool.dict()["function"])
+        tools.append(json_tool)
+    payload["tools"] = tools
+        # del payload["type"]
+        # del payload["function"]
+    if "tool_choice" in payload:
+        payload["tool_choice"] = {
+            "type": "auto"
+        }
+    import json
+    print("payload", json.dumps(payload, indent=2, ensure_ascii=False))
+
+    return url, headers, payload
 
 async def get_payload(request: RequestModel, engine, provider):
     if engine == "gemini":

response.py

@@ -72,47 +72,42 @@ async def fetch_gpt_response_stream(client, url, headers, payload):
     except httpx.ConnectError as e:
         print(f"连接错误： {e}")
 
-async def fetch_claude_response_stream(client, url, headers, payload, engine, model):
+async def fetch_claude_response_stream(client, url, headers, payload, model):
     try:
         timestamp = datetime.timestamp(datetime.now())
         async with client.stream('POST', url, headers=headers, json=payload) as response:
-            buffer = ""
-            async for chunk in response.aiter_text():
-                buffer += chunk
-                while "\n" in buffer:
-                    line, buffer = buffer.split("\n", 1)
-                    # print(line)
-                    if engine == "gemini":
-                        if line and '\"text\": \"' in line:
-                            try:
-                                json_data = json.loads( "{" + line + "}")
-                                content = json_data.get('text', '')
-                                content = "\n".join(content.split("\\n"))
-                                sse_string = await generate_sse_response(timestamp, model, content)
-                                yield sse_string
-                            except json.JSONDecodeError:
-                                print(f"无法解析JSON: {line}")
-                    else:
-                        yield line + "\n"
-
-            # 处理缓冲区中剩余的内容
-            if buffer:
-                # print(buffer)
-                if engine == "gemini":
-                    if '\"text\": \"' in buffer:
-                        try:
-                            json_data = json.loads(buffer)
-                            content = json_data.get('text', '')
-                            content = "\n".join(content.split("\\n"))
+            async for chunk in response.aiter_bytes():
+                chunk_line = chunk.decode('utf-8').split("\n")
+                for chunk in chunk_line:
+                    if chunk.startswith("data:"):
+                        line = chunk[6:]
+                        # print(line)
+                        resp: dict = json.loads(line)
+                        message = resp.get("message")
+                        if message:
+                            tokens_use = resp.get("usage")
+                            if tokens_use:
+                                total_tokens = tokens_use["input_tokens"] + tokens_use["output_tokens"]
+                                # print("\n\rtotal_tokens", total_tokens)
+                        # tool_use = resp.get("content_block")
+                        # if tool_use and "tool_use" == tool_use['type']:
+                        #     # print("tool_use", tool_use)
+                        #     tools_id = tool_use["id"]
+                        #     need_function_call = True
+                        #     if "name" in tool_use:
+                        #         function_call_name = tool_use["name"]
+                        delta = resp.get("delta")
+                        # print("delta", delta)
+                        if not delta:
+                            continue
+                        if "text" in delta:
+                            content = delta["text"]
                             sse_string = await generate_sse_response(timestamp, model, content)
+                            print(sse_string)
                             yield sse_string
-                        except json.JSONDecodeError:
-                            print(f"无法解析JSON: {buffer}")
-                else:
-                    yield buffer
-
-            if engine == "gemini":
-                yield "data: [DONE]\n\n"
+                        # if "partial_json" in delta:
+                        #     function_call_content = delta["partial_json"]
+            yield "data: [DONE]\n\n"
     except httpx.ConnectError as e:
         print(f"连接错误： {e}")
 
@@ -121,12 +116,11 @@ async def fetch_response(client, url, headers, payload):
     return response.json()
 
 async def fetch_response_stream(client, url, headers, payload, engine, model):
-    print(f"Engine: {engine}")
     if engine == "gemini":
         async for chunk in fetch_gemini_response_stream(client, url, headers, payload, model):
             yield chunk
     elif engine == "claude":
-        async for chunk in fetch_claude_response_stream(client, url, headers, payload, engine, model):
+        async for chunk in fetch_claude_response_stream(client, url, headers, payload, model):
             yield chunk
     elif engine == "gpt":
         async for chunk in fetch_gpt_response_stream(client, url, headers, payload):