refactor(test): Remove OpenAI SDK

Author: Aculeasis

test.py

@@ -5,11 +5,16 @@
 """
 
 import asyncio
+import json
 import os
 
+import httpx
 import yaml
-from openai import AsyncOpenAI  # Use the OpenAI library
 
+MODEL =  "deepseek/deepseek-r1:free"
+STREAM = True
+MAX_TOKENS = 600
+INCLUDE_REASONING = True
 
 def load_config():
     """
@@ -36,28 +41,15 @@ def load_config():
 if os.environ.get("ACCESS_KEY"):
     ACCESS_KEY = os.environ.get("ACCESS_KEY")
 
-MODEL =  "deepseek/deepseek-r1:free"
-# MODEL = "google/gemini-2.0-pro-exp-02-05:free"
-
 
 async def test_openrouter_streaming():
     """
     Test the OpenRouter proxy with streaming mode.
     """
-    print(f"Testing OpenRouter Proxy at {PROXY_URL} with model {MODEL} in streaming mode...")
-
-    # Initialize OpenAI client with proxy URL
-    client = AsyncOpenAI(
-        base_url=PROXY_URL + "/api/v1",  # Append /api/v1 for OpenAI compatibility
-        api_key=ACCESS_KEY if ACCESS_KEY else "dummy" # Use a dummy key if no access key
-    )
-
-    headers = {
-        # Optional. Site URL for rankings on openrouter.ai.
-        "HTTP-Referer": config.get("test", {}).get("http_referer", "http://localhost"),
-        # Optional. Site title for rankings on openrouter.ai.
-        "X-Title": config.get("test", {}).get("x_title", "Local Test"),
-    }
+    print(f"Testing OpenRouter Proxy at {PROXY_URL} with model {MODEL}")
+
+    url = f"{PROXY_URL}/api/v1/chat/completions"
+    headers = {"Authorization": f"Bearer {ACCESS_KEY or 'dummy'}"}
     if not ACCESS_KEY:
         print("No valid access key found. Request may fail if server requires authentication.")
     else:
@@ -70,62 +62,61 @@ async def test_openrouter_streaming():
         "messages": [
             {"role": "user", "content": "Write a short poem about AI and humanity working together"}
         ],
-        "stream": True,  # Enable streaming
-        "max_tokens": 600
+        "stream": STREAM,
+        "max_tokens": MAX_TOKENS,
+        "include_reasoning": INCLUDE_REASONING,
     }
 
+    client = httpx.AsyncClient(timeout=httpx.Timeout(15.0, read=600.0))
+    req = client.build_request("POST", url, headers=headers, json=request_data)
+
+    print(f"\nStarting to receive data streaming: {STREAM}...\n")
+    print("-" * 50)
+
+    resp = await client.send(req, stream=STREAM)
     try:
-        # Use OpenAI's async streaming
-        stream = await client.chat.completions.create(
-            **request_data,
-            extra_headers=headers,
-            extra_body={"include_reasoning": True}
-        )
-
-        print("\nStarting to receive stream...\n")
-        print("-" * 50)
-        start_reasoning = False
-        end_reasoning = False
-
-        if request_data["stream"]:
-            async for chunk in stream:
-                if chunk.choices:
-                    content = chunk.choices[0].delta.content
-                    if content:
-                        if start_reasoning and not end_reasoning:
-                            end_reasoning = True
-                            print("</reasoning>\n")
-                        print(content, end='', flush=True)
-
-                    # Check for reasoning, if supported by the model
-                    if not end_reasoning and hasattr(chunk.choices[0].delta, 'reasoning'):
-                        reasoning = chunk.choices[0].delta.reasoning
-                        if reasoning:
-                            if not start_reasoning:
-                                print("<reasoning>")
-                                start_reasoning = True
-                            print(reasoning, end='', flush=True)
-        else:
-            if stream.choices:
-                if hasattr(stream.choices[0].message, 'reasoning'):
-                    reasoning = stream.choices[0].message.reasoning
-                    if reasoning:
-                        print("<reasoning>")
-                        print(reasoning, end='', flush=True)
+        resp.raise_for_status()
+        if STREAM:
+            reasoning_phase = False
+            async for line in resp.aiter_lines():
+                if not line.startswith("data: "):
+                    continue
+                if (line := line[6:]) == "[DONE]":
+                    break
+                data = json.loads(line)
+                if "error" in data:
+                    raise ValueError(str(data))
+                choice = data["choices"][0]["delta"]
+                if content := choice.get("content"):
+                    if reasoning_phase:
+                        reasoning_phase = False
                         print("</reasoning>\n")
-                content = stream.choices[0].message.content
-                if content:
                     print(content, end='', flush=True)
-
-        print("\n" + "-" * 50)
-        if request_data["stream"]:
-            print("\nStream completed!")
+                elif reasoning := choice.get("reasoning"):
+                    if not reasoning_phase:
+                        reasoning_phase = True
+                        print("<reasoning>")
+                    print(reasoning, end='', flush=True)
         else:
-            print("\nNon-streaming response completed!")
-
+            data = resp.json()
+            if "error" in data:
+                raise ValueError(str(data))
+            choice = data["choices"][0]["message"]
+            if reasoning := choice.get("reasoning"):
+                print(f"<reasoning>\n{reasoning}</reasoning>\n")
+            if content := choice.get("content"):
+                print(content, end='')
     except Exception as e:
         print(f"Error occurred during test: {str(e)}")
+    finally:
+        if STREAM:
+            await resp.aclose()
+    print("\n" + "-" * 50)
+    if STREAM:
+        print("\nStream completed!")
+    else:
+        print("\nNon-streaming response completed!")
 
 
 if __name__ == "__main__":
-    asyncio.run(test_openrouter_streaming())
+    asyncio.run(test_openrouter_streaming())