Update apis/chat_api.py

apis/chat_api.py

@@ -6,11 +6,13 @@ import json
 
 from fastapi import FastAPI
 from fastapi import Request
+from fastapi import Body
 from fastapi.encoders import jsonable_encoder
 from fastapi.responses import JSONResponse, StreamingResponse
 import uuid
 import time
 import re
+import requests
 try:
     import langid
 except Exception:
@@ -196,6 +198,36 @@ class ChatAPIApp:
             self.app.post(
                 prefix + "/translate/stream/raw",
                 summary="stream translated text (plain text body; set ?to_language=am)",
+                openapi_extra={
+                    "requestBody": {
+                        "required": True,
+                        "content": {
+                            "text/plain": {
+                                "schema": {"type": "string", "example": "selam, endet neh?"},
+                                "examples": {
+                                    "AmharicRomanized": {
+                                        "summary": "Romanized Amharic",
+                                        "value": "selam, endet neh?"
+                                    },
+                                    "Paragraph": {
+                                        "summary": "Multiline plain text",
+                                        "value": "The Ethiopian Alphasyllabary: A Look at Amharic and Tigrinya\nThe writing systems for Amharic and Tigrinya are beautiful and complex examples of an alphasyllabary."
+                                    }
+                                }
+                            }
+                        }
+                    }
+                },
+                responses={
+                    200: {
+                        "description": "SSE stream",
+                        "content": {
+                            "text/event-stream": {
+                                "schema": {"type": "string", "example": "data: {\\\"choices\\\":[{\\\"delta\\\":{\\\"content\\\":\\\"...\\\"}}]}\\n\\n"}
+                            }
+                        }
+                    }
+                },
             )(self.translate_stream_raw)
 
             self.app.post(
@@ -203,6 +235,12 @@ class ChatAPIApp:
                 summary="stream translated text from OpenAI-style chat payload",
             )(self.translate_chat_stream)
 
+            # Proxy an OpenAI-style SSE stream via Pollinations, pre/post translating
+            self.app.post(
+                prefix + "/translate/chat/proxy/stream",
+                summary="proxy OpenAI-style chat stream via Pollinations with translation",
+            )(self.translate_chat_proxy_stream)
+
     def translate_stream(self, item: TranslateCompletionsPostItem):
         f = open('apis/lang_name.json', "r")
         available_langs = json.loads(f.read())
@@ -264,15 +302,126 @@ class ChatAPIApp:
 
         return StreamingResponse(event_generator(), media_type="text/event-stream")
 
-    async def translate_stream_raw(self, request: Request, to_language: str = "am"):
-        body_bytes = await request.body()
-        input_text = body_bytes.decode("utf-8", errors="ignore")
+    async def translate_stream_raw(self, request: Request, to_language: str = "am", text: str = Body(default=None, media_type="text/plain")):
+        # Prefer explicit text/plain body if provided, else use raw bytes
+        if text is not None:
+            input_text = text
+        else:
+            body_bytes = await request.body()
+            input_text = body_bytes.decode("utf-8", errors="ignore")
         payload = self.TranslateCompletionsPostItem(
             to_language=to_language,
             input_text=input_text,
         )
         return self.translate_stream(payload)
 
+    class ChatProxyStreamItem(BaseModel):
+        model: str = Field(default="gpt-4.1", description="Pollinations model name")
+        stream: bool = Field(default=True)
+        to_language: str = Field(default="am")
+        from_language: str | None = Field(default=None)
+        messages: list[dict] = Field(default_factory=list)
+        api_url: str | None = Field(default=None, description="Override Pollinations API URL")
+
+    def translate_chat_proxy_stream(self, item: ChatProxyStreamItem):
+        api_url = item.api_url or "https://text.pollinations.ai/openai"
+        # Find last user message
+        user_text = ""
+        for msg in reversed(item.messages or []):
+            if msg.get("role") == "user":
+                user_text = msg.get("content", "")
+                break
+
+        # Pre-translate user input to English for LLM
+        detected_src, _ = self._detect_language_advanced(user_text)
+        pre_text = self._preprocess_text_for_translation(user_text, detected_src)
+        try:
+            llm_input_en = GoogleTranslator(source='auto', target='en').translate(pre_text)
+        except Exception:
+            llm_input_en = user_text
+
+        # Build messages with replaced last user message
+        proxied_messages = list(item.messages or [])
+        for i in range(len(proxied_messages) - 1, -1, -1):
+            if proxied_messages[i].get("role") == "user":
+                proxied_messages[i] = {**proxied_messages[i], "content": llm_input_en}
+                break
+
+        req_headers = {
+            "Content-Type": "application/json",
+            "Accept": "text/event-stream",
+        }
+        req_body = {
+            "model": item.model,
+            "messages": proxied_messages,
+            "stream": True,
+        }
+
+        # Make streaming request to Pollinations
+        try:
+            resp = requests.post(api_url, headers=req_headers, json=req_body, stream=True, timeout=60)
+            resp.raise_for_status()
+        except Exception as e:
+            def err_gen():
+                chunk = {
+                    "id": f"proxy-{uuid.uuid4()}",
+                    "object": "chat.completion.chunk",
+                    "choices": [{"index": 0, "delta": {"content": ""}, "finish_reason": "error"}],
+                    "error": str(e),
+                }
+                yield f"data: {json.dumps(chunk, ensure_ascii=False)}\n\n"
+                yield "data: [DONE]\n\n"
+            return StreamingResponse(err_gen(), media_type="text/event-stream")
+
+        stream_id = f"proxy-{uuid.uuid4()}"
+
+        def gen():
+            buffer = ""
+            for line in resp.iter_lines():
+                if not line:
+                    continue
+                try:
+                    s = line.decode("utf-8")
+                except Exception:
+                    continue
+                s = s.strip()
+                if not s.startswith("data:"):
+                    continue
+                data = s[len("data:"):].strip()
+                if data == "[DONE]":
+                    # Flush remaining buffer
+                    if buffer:
+                        try:
+                            translated = GoogleTranslator(source='en', target=item.to_language).translate(buffer)
+                        except Exception:
+                            translated = buffer
+                        chunk = {"id": stream_id, "object": "chat.completion.chunk", "choices": [{"index": 0, "delta": {"content": translated}, "finish_reason": None}]}
+                        yield f"data: {json.dumps(chunk, ensure_ascii=False)}\n\n"
+                        buffer = ""
+                    yield "data: [DONE]\n\n"
+                    break
+                # Parse JSON
+                try:
+                    obj = json.loads(data)
+                    piece = obj.get("choices", [{}])[0].get("delta", {}).get("content")
+                except Exception:
+                    piece = None
+                if piece:
+                    buffer += piece
+                    # Translate and flush on sentence boundary or buffer size
+                    if any(piece.endswith(x) for x in [".", "!", "?", "\n"]) or len(buffer) > 120:
+                        try:
+                            translated = GoogleTranslator(source='en', target=item.to_language).translate(buffer)
+                        except Exception:
+                            translated = buffer
+                        chunk = {"id": stream_id, "object": "chat.completion.chunk", "choices": [{"index": 0, "delta": {"content": translated}, "finish_reason": None}]}
+                        yield f"data: {json.dumps(chunk, ensure_ascii=False)}\n\n"
+                        buffer = ""
+            # Safety end
+            yield "data: [DONE]\n\n"
+
+        return StreamingResponse(gen(), media_type="text/event-stream")
+
     def translate_chat_stream(self, item: ChatTranslateStreamItem):
         # Extract latest user content
         input_text = None