modular code apsssjjjadfdr

api.py

@@ -1,48 +1,229 @@
-import asyncio
+import os
 import httpx
-from openai import AsyncOpenAI
-from anthropic import AsyncAnthropic
-from google.generativeai import GenerativeModel
-
-async def ask_openai(query, history):
-    client = AsyncOpenAI(api_key="your_openai_api_key")
-    messages = [{"role": "user", "content": query}]
-    for h in history:
-        messages.append({"role": "user", "content": h.get("user", "")})
-        if h.get("openai"):
-            messages.append({"role": "assistant", "content": h["openai"]})
-    stream = await client.chat.completions.create(
-        model="gpt-4o-mini", messages=messages, stream=True
-    )
-    async for chunk in stream:
-        if chunk.choices[0].delta.content:
-            yield chunk.choices[0].delta.content
-
-async def ask_anthropic(query, history):
-    client = AsyncAnthropic(api_key="your_anthropic_api_key")
-    messages = [{"role": "user", "content": query}]
-    for h in history:
-        messages.append({"role": "user", "content": h.get("user", "")})
-        if h.get("anthropic"):
-            messages.append({"role": "assistant", "content": h["anthropic"]})
-    stream = await client.messages.create(
-        model="claude-3-5-sonnet-20241022", max_tokens=1024, messages=messages, stream=True
-    )
-    async for chunk in stream:
-        if chunk.content and chunk.content[0].text:
-            yield chunk.content[0].text
-
-async def ask_gemini(query, history):
-    client = GenerativeModel("gemini-1.5-flash", api_key="your_gemini_api_key")
+import json
+import traceback
+from typing import AsyncGenerator, List, Dict
+from config import logger
+
+async def ask_openai(query: str, history: List[Dict[str, str]]) -> AsyncGenerator[str, None]:
+    openai_api_key = os.getenv("OPENAI_API_KEY")
+    if not openai_api_key:
+        logger.error("OpenAI API key not provided")
+        yield "Error: OpenAI API key not provided."
+        return
+
+    # Build message history with user and assistant roles
+    messages = []
+    for msg in history:
+        messages.append({"role": "user", "content": msg["user"]})
+        if msg["bot"]:
+            messages.append({"role": "assistant", "content": msg["bot"]})
+    messages.append({"role": "user", "content": query})
+
+    headers = {
+        "Authorization": f"Bearer {openai_api_key}",
+        "Content-Type": "application/json"
+    }
+
+    payload = {
+        "model": "gpt-3.5-turbo",
+        "messages": messages,
+        "stream": True
+    }
+
+    try:
+        async with httpx.AsyncClient() as client:
+            async with client.stream("POST", "https://api.openai.com/v1/chat/completions", headers=headers, json=payload) as response:
+                response.raise_for_status()
+                buffer = ""
+                async for chunk in response.aiter_text():
+                    if chunk:
+                        buffer += chunk
+                        while "\n" in buffer:
+                            line, buffer = buffer.split("\n", 1)
+                            if line.startswith("data: "):
+                                data = line[6:]
+                                if data == "[DONE]":
+                                    break
+                                if not data.strip():
+                                    continue
+                                try:
+                                    json_data = json.loads(data)
+                                    if "choices" in json_data and json_data["choices"]:
+                                        delta = json_data["choices"][0].get("delta", {})
+                                        if "content" in delta and delta["content"] is not None:
+                                            logger.info(f"OpenAI yielding chunk: {delta['content']}")
+                                            yield delta["content"]
+                                except json.JSONDecodeError as e:
+                                    logger.error(f"Error parsing OpenAI stream chunk: {str(e)} - Data: {data}")
+                                    yield f"Error parsing stream: {str(e)}"
+                                except Exception as e:
+                                    logger.error(f"Unexpected error in OpenAI stream: {str(e)} - Data: {data}")
+                                    yield f"Error in stream: {str(e)}"
+
+    except httpx.HTTPStatusError as e:
+        response_text = await e.response.aread()
+        logger.error(f"OpenAI HTTP Status Error: {e.response.status_code}, {response_text}")
+        yield f"Error: OpenAI HTTP Status Error: {e.response.status_code}, {response_text.decode('utf-8')}"
+    except Exception as e:
+        logger.error(f"OpenAI Error: {str(e)}")
+        yield f"Error: OpenAI Error: {str(e)}"
+
+async def ask_anthropic(query: str, history: List[Dict[str, str]]) -> AsyncGenerator[str, None]:
+    anthropic_api_key = os.getenv("ANTHROPIC_API_KEY")
+    if not anthropic_api_key:
+        logger.error("Anthropic API key not provided")
+        yield "Error: Anthropic API key not provided."
+        return
+
+    messages = []
+    for msg in history:
+        messages.append({"role": "user", "content": msg["user"]})
+        if msg["bot"]:
+            messages.append({"role": "assistant", "content": msg["bot"]})
+    messages.append({"role": "user", "content": query})
+
+    headers = {
+        "x-api-key": anthropic_api_key,
+        "anthropic-version": "2023-06-01",
+        "Content-Type": "application/json"
+    }
+
+    payload = {
+        "model": "claude-3-5-sonnet-20241022",
+        "max_tokens": 1024,
+        "messages": messages,
+        "stream": True
+    }
+
+    try:
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            logger.info(f"Sending Anthropic streaming request: {payload}")
+            async with client.stream("POST", "https://api.anthropic.com/v1/messages", headers=headers, json=payload) as response:
+                response.raise_for_status()
+                buffer = ""
+                async for chunk in response.aiter_text():
+                    if chunk:
+                        buffer += chunk
+                        while "\n" in buffer:
+                            line, buffer = buffer.split("\n", 1)
+                            if line.startswith("data: "):
+                                data = line[6:]
+                                if data.strip() == "[DONE]":
+                                    break
+                                if not data.strip():
+                                    continue
+                                try:
+                                    json_data = json.loads(data)
+                                    if json_data.get("type") == "content_block_delta" and "delta" in json_data and "text" in json_data["delta"]:
+                                        logger.info(f"Anthropic yielding chunk: {json_data['delta']['text']}")
+                                        yield json_data["delta"]["text"]
+                                    elif json_data.get("type") == "message_start" or json_data.get("type") == "message_delta":
+                                        continue
+                                except json.JSONDecodeError as e:
+                                    logger.error(f"Error parsing Anthropic stream chunk: {str(e)} - Data: {data}")
+                                    yield f"Error parsing stream: {str(e)}"
+                                except Exception as e:
+                                    logger.error(f"Unexpected error in Anthropic stream: {str(e)} - Data: {data}")
+                                    yield f"Error in stream: {str(e)}"
+
+    except httpx.HTTPStatusError as e:
+        response_text = await e.response.aread()
+        logger.error(f"Anthropic HTTP Status Error: {e.response.status_code}, {response_text.decode('utf-8')}")
+        yield f"Error: Anthropic HTTP Status Error: {e.response.status_code}, {response_text.decode('utf-8')}"
+    except Exception as e:
+        logger.error(f"Anthropic Error: {str(e)}\nStack trace: {traceback.format_exc()}")
+        yield f"Error: Anthropic Error: {str(e)}"
+
+async def ask_gemini(query: str, history: List[Dict[str, str]]) -> AsyncGenerator[str, None]:
+    gemini_api_key = os.getenv("GEMINI_API_KEY")
+    if not gemini_api_key:
+        logger.error("Gemini API key not provided")
+        yield "Error: Gemini API key not provided."
+        return
+
     history_text = ""
-    for h in history:
-        user_msg = h.get("user", "")
-        if user_msg:
-            history_text += f"User: {user_msg}\n"
-            if h.get("gemini"):
-                history_text += f"Assistant: {h['gemini']}\n"
-    full_prompt = history_text + f"User: {query}\n"
-    stream = client.generate_content(full_prompt, stream=True)
-    async for chunk in stream:
-        if chunk.text:
-            yield chunk.text
+    for msg in history:
+        history_text += f"User: {msg['user']}\nAssistant: {msg['bot']}\n" if msg['bot'] else f"User: {msg['user']}\n"
+    full_query = history_text + f"User: {query}\n"
+
+    headers = {
+        "Content-Type": "application/json"
+    }
+
+    payload = {
+        "contents": [{"parts": [{"text": full_query}]}]
+    }
+
+    try:
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            logger.info(f"Sending Gemini streaming request: {payload}")
+            async with client.stream(
+                "POST",
+                f"https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:streamGenerateContent?key={gemini_api_key}",
+                headers=headers,
+                json=payload
+            ) as response:
+                response.raise_for_status()
+                buffer = ""
+                async for chunk in response.aiter_text():
+                    if chunk:
+                        buffer += chunk
+                        logger.info(f"Gemini stream chunk: {chunk}")
+                        while buffer.strip():
+                            try:
+                                json_data = json.loads(buffer)
+                                logger.info(f"Parsed Gemini JSON: {json_data}")
+                                buffer = ""
+                                objects = json_data if isinstance(json_data, list) else [json_data]
+                                for obj in objects:
+                                    if isinstance(obj, dict) and "candidates" in obj and obj["candidates"]:
+                                        content = obj["candidates"][0].get("content", {})
+                                        if "parts" in content and content["parts"]:
+                                            text = content["parts"][0].get("text", "")
+                                            if text:
+                                                logger.info(f"Gemini yielding chunk: {text}")
+                                                yield text
+                                break
+                            except json.JSONDecodeError:
+                                brace_count = 0
+                                split_index = -1
+                                for i, char in enumerate(buffer):
+                                    if char == '{':
+                                        brace_count += 1
+                                    elif char == '}':
+                                        brace_count -= 1
+                                        if brace_count == 0:
+                                            split_index = i + 1
+                                if split_index > 0:
+                                    try:
+                                        json_str = buffer[:split_index]
+                                        json_data = json.loads(json_str)
+                                        logger.info(f"Parsed Gemini JSON: {json_data}")
+                                        buffer = buffer[split_index:].lstrip(',')
+                                        objects = json_data if isinstance(json_data, list) else [json_data]
+                                        for obj in objects:
+                                            if isinstance(obj, dict) and "candidates" in obj and obj["candidates"]:
+                                                content = obj["candidates"][0].get("content", {})
+                                                if "parts" in content and content["parts"]:
+                                                    text = content["parts"][0].get("text", "")
+                                                    if text:
+                                                        logger.info(f"Gemini yielding chunk: {text}")
+                                                        yield text
+                                        continue
+                                    except json.JSONDecodeError:
+                                        pass
+                                break
+                            except Exception as e:
+                                logger.error(f"Unexpected error in Gemini stream: {str(e)} - Buffer: {buffer}")
+                                yield f"Error in stream: {str(e)}"
+                                buffer = ""
+                                break
+
+    except httpx.HTTPStatusError as e:
+        response_text = await e.response.aread()
+        logger.error(f"Gemini HTTP Status Error: {e.response.status_code}, {response_text.decode('utf-8')}")
+        yield f"Error: Gemini HTTP Status Error: {e.response.status_code}, {response_text.decode('utf-8')}"
+    except Exception as e:
+        logger.error(f"Gemini Error: {str(e)}\nStack trace: {traceback.format_exc()}")
+        yield f"Error: Gemini Error: {str(e)}"