Create main.py

main.py

@@ -0,0 +1,678 @@
+import json
+from flask import Flask, request, jsonify, Response, stream_with_context
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional
+import time
+import uuid
+from curl_cffi.requests import Session
+
+
+
+
+
+
+
+M3 = [
+  {
+    "tag": "@cf",
+    "model": "meta/llama-3.1-70b-instruct",
+    "max_tokens" : 8192
+  },
+
+  {
+    "tag": "@cf",
+    "model": "qwen/qwen2.5-coder-32b-instruct",
+    "max_tokens" : 8192
+  },
+  {
+    "tag": "@cf",
+    "model": "deepseek-ai/deepseek-r1-distill-qwen-32b",
+    "max_tokens" : 40960
+    # ok
+
+  },
+  {
+    "tag": "@cf",
+    "model": "meta/llama-4-scout-17b-16e-instruct",
+    "max_tokens" : 40960
+    # ok
+
+  },
+  {
+    "tag": "@cf",
+    "model": "google/gemma-3-12b-it",
+    "max_tokens" : 40960
+    # ok
+
+  },
+  {
+    "tag": "@cf",
+    "model": "mistralai/mistral-small-3.1-24b-instruct",
+    "max_tokens" : 40960
+    # ok
+
+  },
+  {
+    "tag": "@cf",
+    "model": "meta/llama-3.3-70b-instruct-fp8-fast",
+    "max_tokens" : 8192
+  },
+  {
+    "tag": "@cf",
+    "model": "meta/llama-3.2-3b-instruct",
+    "max_tokens" : 40960
+    # ok
+
+  },
+  {
+    "tag": "@cf",
+    "model": "meta/llama-3.2-1b-instruct",
+    "max_tokens" : 40960
+    # ok
+  },
+  {
+    "tag": "@hf",
+    "model": "meta-llama/meta-llama-3-8b-instruct",
+    "max_tokens" : 4391
+  },
+  {
+    "tag": "@cf",
+    "model": "meta/llama-3-8b-instruct",
+    "max_tokens" : 4391
+  },
+  {
+    "tag": "@cf",
+    "model": "meta/llama-2-7b-chat-int8",
+    "max_tokens" : 4391
+  },
+  {
+    "tag": "@cf",
+    "model": "meta/llama-2-7b-chat-fp16",
+    "max_tokens" : None
+  },
+  {
+    "tag": "@cf",
+    "model": "meta/llama-3-8b-instruct-awq",
+    "max_tokens" : 4391
+  },
+  {
+    "tag": "@hf",
+    "model": "meta-llama/meta-llama-3-8b-instruct",
+    "max_tokens" : 4391
+  },
+  {
+    "tag": "@cf",
+    "model": "meta/llama-3-8b-instruct",
+    "max_tokens" : 4391
+  },
+  {
+    "tag": "@cf",
+    "model": "meta/llama-2-7b-chat-int8",
+    "max_tokens" : 4391
+  },
+  {
+    "tag": "@cf",
+    "model": "meta/llama-3-8b-instruct-awq",
+    "max_tokens" : 4391
+  },
+  {
+    "tag": "@hf",
+    "model": "google/gemma-7b-it",
+    "max_tokens" : None
+  },
+  {
+    "tag": "@cf",
+    "model": "google/gemma-2b-it-lora",
+    "max_tokens" : 4391
+  },
+  {
+    "tag": "@hf",
+    "model": "mistral/mistral-7b-instruct-v0.2",
+    "max_tokens" : 8192
+  },
+  {
+    "tag": "@cf",
+    "model": "mistral/mistral-7b-instruct-v0.2-lora",
+    "max_tokens" : 8192
+  }
+]
+
+def FREEGPT(
+        RQ : Any,
+        messages : List[Dict],
+        model : str = "deepseek-ai/deepseek-r1-distill-qwen-32b",
+        max_token : int = 40960,
+        stream : bool = True,
+        timeout: Optional[float] = None
+):
+    md = next((item["tag"] + "/" + item["model"] for item in MODELS if item["model"] == model), "@cf/meta/llama-3.2-1b-instruct")
+
+    URL = f"https://llmchat.in/inference/stream?model={md}"
+
+    
+    headers = {
+        "Accept": "text/event-stream,*/*",
+        "Content-Type": "application/json",
+        "Origin": "https://llmchat.in",
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36",
+        "Cache-Control": "no-cache",
+        "Accept-Encoding": "identity",
+        "cf-ray" : "9cba9edd9f909aaf-SIN",
+
+    }
+
+
+    payload = {
+    "messages": messages,
+    "stream": stream,
+    **({"max_tokens": max_token} if max_token is not None else {}),
+    **({"max_tokens": next((item["max_tokens"] for item in MODELS if item["model"] == model and item["max_tokens"] is not None), None)} if next((True for item in MODELS if item["model"] == model and item["max_tokens"] is not None), None) else {})
+}
+
+
+    # print(payload)
+
+    try:
+        RESP = RQ.post(url=URL,json=payload , headers=headers , timeout=timeout,stream=stream)
+        print(RESP.status_code)
+    except:
+         return
+    if RESP.status_code == 200:
+        for raw in RESP.iter_lines():
+            if not raw:
+                continue
+
+            try:
+                line = raw.decode("utf-8", errors="replace").strip()
+            except Exception:
+                line = raw.decode("latin-1", errors="replace").strip()
+
+            if line.startswith("data:"):
+                    data_json = line.split('data: ')[1]
+            try:
+                data = json.loads(data_json)
+            except:
+                continue
+
+            try:
+                yield data["response"]
+            except: pass
+        
+    else:
+        print(RESP.status_code)
+
+
+
+
+
+
+M2 = ["qwen3-4b-thinking-2507"]
+
+
+def QWEN(
+        RQ : Any,
+        messages : List[Dict],
+        model : str = "NONE",
+        max_token : int = 40960,
+        stream : bool = True,
+        timeout: Optional[float] = None
+):
+
+    def GEN(RQ:any,messages:list,timeout:int=None):
+        API_URL = "https://teichai-qwen3-4b-thinking-2507-claude-4-5-opus.hf.space/api/chat"
+
+        payload = {
+            "messages":messages,
+            "searchEnabled":False
+            }
+        
+        headers = {"Accept": "*/*","Content-Type": "application/json","Origin": "https://teichai-qwen3-4b-thinking-2507-claude-4-5-opus.hf.space","Referer": "https://teichai-qwen3-4b-thinking-2507-claude-4-5-opus.hf.space/","User-Agent": "python-requests/2.x"}
+
+        c = t()
+        RESPO = RQ.post(API_URL, headers=headers, json=payload, stream=stream, timeout=timeout)
+        print(c-t())
+        # print(RESPO)
+        buffer_lines = []
+        for raw in RESPO.iter_lines():
+            if raw is None:
+                continue
+            try:
+                line = raw.decode("utf-8", errors="replace").strip()
+            except Exception:
+                line = raw.decode("latin-1", errors="replace").strip()
+
+            if line == "":
+                if not buffer_lines:
+                    continue
+                data_text = "".join(buffer_lines)
+                buffer_lines = []
+                if data_text == "[DONE]":
+                    break
+                try:
+                    obj = json.loads(data_text)
+                    try:
+                        yield obj                        
+                    except:
+                        pass
+                except json.JSONDecodeError:
+                    pass
+                continue
+
+            if line.startswith("data:"):
+                buffer_lines.append(line[len("data:"):].lstrip())
+
+    RES = False
+    for i in GEN(RQ=RQ,messages=messages,timeout=timeout):    
+        if i["type"]=="reasoning":
+            if not RES:
+                RES = True
+                yield "<think>\n"
+            yield i["content"]
+
+        else:
+            if  RES:
+                RES = False
+                yield "\n</think>\n\n"
+            try:
+                yield i["content"]
+            except:
+                pass
+
+
+
+
+
+
+
+class CONV:
+
+    def __init__(self, default_system: str = ""):
+        self.default_system = default_system
+
+    @staticmethod
+    def _make_id() -> str:
+        return uuid.uuid4().hex[:20]
+
+    def alpaca_to_msg(
+        self,
+        alpaca_obj: Dict[str, Any],
+        insert_system: bool = True,
+        system_override: Optional[str] = None,
+        skip_empty: bool = True,
+    ) -> Tuple[List[Dict[str, str]], float]:
+
+        t0 = time.perf_counter()
+
+        out: List[Dict[str, str]] = []
+        sys_text = system_override if system_override is not None else self.default_system
+        if insert_system and sys_text is not None:
+            out.append({"role": "system", "content": sys_text})
+
+        msgs = alpaca_obj
+        append = out.append  # micro-optimization
+        for m in msgs:
+            role = (m.get("role") or "").strip().lower()
+            if role not in ("user", "assistant", "system"):
+                role = "user"
+
+            parts = m.get("parts") or []
+            # gather textual parts quickly
+            texts: List[str] = []
+            for p in parts:  # iterate in order
+                # only include parts with type == "text" and non-empty text
+                if isinstance(p, dict) and p.get("type") == "text":
+                    txt = p.get("text", "")
+                    if isinstance(txt, str) and txt:
+                        # keep as-is except trim trailing spaces/newlines
+                        texts.append(txt.rstrip())
+
+            if not texts and skip_empty:
+                continue
+
+            if texts:
+                content = "\n\n".join(texts)
+                append({"role": role, "content": content})
+            else:
+                # if not skipping empty, include empty content to preserve role
+                append({"role": role, "content": ""})
+
+        elapsed = time.perf_counter() - t0
+        return out, elapsed
+
+    def msg_to_alpaca(
+        self,
+        msg_list: List[Dict[str, Any]],
+        include_step_start: bool = True,
+        assistant_state_done: bool = True,
+        preserve_ids: bool = False,
+        skip_empty_text_parts: bool = False,
+    ) -> Tuple[Dict[str, List[Dict[str, Any]]], float]:
+
+        t0 = time.perf_counter()
+
+        out_messages: List[Dict[str, Any]] = []
+        append = out_messages.append
+
+        for entry in msg_list:
+            # allow both dicts and fallback strings
+            if not isinstance(entry, dict):
+                role = "user"
+                content = str(entry)
+                entry_id = None
+            else:
+                role = (entry.get("role") or "user").strip().lower()
+                content = entry.get("content", "")
+                entry_id = entry.get("id") if preserve_ids else None
+
+            if role not in ("user", "assistant"):
+                role = "user"
+
+            parts: List[Dict[str, Any]] = []
+            if role == "assistant" and include_step_start:
+                parts.append({"type": "step-start"})
+
+            # Only add the text part if it's non-empty (or skip_empty_text_parts False)
+            if isinstance(content, str):
+                if not skip_empty_text_parts or content.strip() != "":
+                    text_part: Dict[str, Any] = {"type": "text", "text": content}
+                    if role == "assistant" and assistant_state_done:
+                        text_part["state"] = "done"
+                    parts.append(text_part)
+
+            # Build message object
+            msg_obj: Dict[str, Any] = {
+                "id": entry_id if (entry_id is not None and isinstance(entry_id, str) and entry_id != "") else self._make_id(),
+                "role": role,
+                "parts": parts,
+                "metadata": {"custom": {}},
+            }
+
+            append(msg_obj)
+
+        elapsed = time.perf_counter() - t0
+        return out_messages, elapsed
+
+
+    
+
+
+
+MODELS=[
+    "zai-org/glm-4.6",
+    "openai/gpt-5-nano-2025-08-07",
+    "deepseek-ai/deepseek-v3.2-thinking",
+    "nvidia/nvidia-nemotron-3-nano-30b-a3b",
+    "nvidia/nvidia-nemotron-3-nano-30b-a3b-thinking",
+    "openai/gpt-5-mini-2025-08-07",
+    "qwen/qwen3-vl-235b-a22b-thinking",
+    "qwen/qwen3-vl-235b-a22b-instruct",
+    "perplexity/sonar",
+    "moonshotai/kimi-k2.5",
+    "anthropic/claude-haiku-4-5-20251001",      #-----depcriating model
+    "google/gemini-2.5-flash-lite",
+    "moonshotai/kimi-k2-thinking"
+    "mistralai/devstral-2-123b-instruct-2512" #good mordal
+    "mistralai/mistral-large-3-675b-instruct-2512",
+    "openai/gpt-oss-safeguard-20b",
+    "openai/gpt-oss-120b"
+    
+]
+
+
+def Adarsh_Personal(
+        RQ : Any,
+        messages : List[Dict],
+        model : str = "deepseek-ai/deepseek-r1-distill-qwen-32b",
+        max_token : int = 40960,
+        stream : bool = True,
+        timeout: Optional[float] = None
+):
+    
+    RES=False
+    URL = "https://hadadxyz-ai.hf.space/api/mz1a85y5n80zy5127hgsba5f3a9c2d1Np0x300vcgduqxb7ep084fygd016c9a2d16fa8b3c41gut432pvjctr75hhspjae25d6f7a8b9c0d1e2pjf43v16f3a4b5c6dd7e8fba2bdx9a0b6dv1c2d7e2b4c9f83d6a4f1bb6c152f9pe3c7a88qv5d91f3c2b765g134bp9a41ne4yx4b3vda8w074"
+
+
+    NEW_MSGS , S = CONV().msg_to_alpaca(messages, include_step_start=True, assistant_state_done=True)
+
+    # print(NEW_MSGS)
+
+    payload = {
+    "tools": {},
+    "modelId": model,
+    "sessionId": "sess_7ef524b9_mlfe4ped",
+    "clientId": "7ef524b98a963b507ec9f4000fdea38c-mlfe4pea",
+    "requestId": "req_7ef524b9_mlfg1cpq_jjxb7p",
+    "clientIp": "122.161.52.54",
+    "realIp": "122.161.52.54",
+    "forwardedFor": "122.161.52.54",
+    "userAgent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36",
+    "id": "DEFAULT_THREAD_ID",
+    "messages": NEW_MSGS,
+    "trigger": "submit-message",
+    "metadata": {}
+    }
+
+    headers = {
+    "Accept": "text/event-stream, */*",
+    "Content-Type": "application/json",
+    "Origin": "https://hadadxyz-ai.hf.space",
+    "User-Agent": payload["userAgent"],
+    "Cache-Control": "no-cache",
+    "Accept-Encoding": "identity",
+    "x-turnstile-token": "mlfe5357-zq9depfzhpb-e18cbvzrpid",
+    "x-turnstile-verified": "true",
+    }
+
+
+    RESP = RQ.post(URL, json=payload, headers=headers, stream=stream, timeout=timeout)
+
+    if RESP.status_code == 200:
+        for raw in RESP.iter_lines():
+            if not raw:
+                continue
+
+            try:
+                line = raw.decode("utf-8", errors="replace").strip()
+            except Exception:
+                line = raw.decode("latin-1", errors="replace").strip()
+
+            if line.startswith("data:"):
+                    data_json = line.split('data: ')[1]
+            try:
+                data = json.loads(data_json)
+            except:
+                continue
+            try:
+                 if data['type']=="reasoning-delta":
+                    if not RES:
+                        RES = True
+                        yield "<think>\n"
+                    try:
+                        yield data["delta"]
+                    except:
+                        pass
+            except :
+                pass     
+            try:
+                if data["type"]=="text-delta":
+                    if  RES:
+                        RES = False
+                        yield "\n</think>\n"
+
+                    try:
+                        yield data["delta"]
+                    except:
+                        pass                   
+            except:
+                 pass
+            
+import uuid
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# ---------------------------------------------------------------------
+# App & Session
+# ---------------------------------------------------------------------
+
+app = Flask(__name__)
+RQ = Session(impersonate="chrome110")
+
+
+# ---------------------------------------------------------------------
+# Config
+# ---------------------------------------------------------------------
+
+class Config:
+    DEFAULT_PROVIDER = "1"
+    DEFAULT_MODEL = "llama-3.3-70b-versatile"
+    DEFAULT_MAX_TOKENS = 512
+    DEFAULT_TEMPERATURE = 0.7
+    TIMEOUT = 30.0
+    STREAM = True
+
+
+PROVIDERS: Dict[str, Dict[str, Any]] = {
+    "1": {"func": Adarsh_Personal, "models": M1},
+    "2": {"func": QWEN, "models": M2},
+    "3": {"func": FREEGPT, "models": M3},
+}
+
+
+# ---------------------------------------------------------------------
+# Request Schema
+# ---------------------------------------------------------------------
+
+@dataclass(slots=True)
+class ChatRequest:
+    api_key: str
+    messages: List[Dict[str, Any]]
+    model: str
+    provider: str
+    max_tokens: int
+    temperature: float
+    stream: bool
+
+    @classmethod
+    def from_dict(cls, payload: Dict[str, Any]) -> "ChatRequest":
+        api_key = payload.get("api_key") or payload.get("key") or payload.get("apikey")
+        messages = payload.get("messages") or payload.get("message") or payload.get("msgs") or []
+        model = payload.get("model") or payload.get("model_name") or Config.DEFAULT_MODEL
+        provider = str(payload.get("provider", Config.DEFAULT_PROVIDER))
+
+        if isinstance(messages, dict):
+            messages = [messages]
+
+        return cls(
+            api_key=api_key,
+            messages=messages,
+            model=model,
+            provider=provider,
+            max_tokens=int(payload.get("max_tokens", Config.DEFAULT_MAX_TOKENS)),
+            temperature=float(payload.get("temperature", Config.DEFAULT_TEMPERATURE)),
+            stream=bool(payload.get("stream", Config.STREAM)),
+        )
+
+
+# ---------------------------------------------------------------------
+# Streaming Generator
+# ---------------------------------------------------------------------
+
+def stream_chat(req: ChatRequest):
+    provider = PROVIDERS.get(req.provider)
+
+    if not provider:
+        yield json.dumps({"error": "Invalid provider"}) + "\n"
+        return
+
+    try:
+        for chunk in provider["func"](
+            RQ,
+            req.messages,
+            req.model,
+            req.max_tokens,
+            req.stream,
+            Config.TIMEOUT,
+        ):
+            if not chunk:
+                continue
+            yield f"data: {json.dumps({'response': chunk})}\n\n"
+
+        yield "data: [DONE]\n\n"
+
+    except Exception as e:
+        yield f"data: {json.dumps({'error': str(e)})}\n\n"
+
+
+# ---------------------------------------------------------------------
+# Routes
+# ---------------------------------------------------------------------
+
+@app.route("/gen", methods=["POST"])
+def generate():
+    payload = request.get_json(silent=True)
+    if not payload:
+        return jsonify({"error": "Invalid JSON body"}), 400
+
+    req = ChatRequest.from_dict(payload)
+
+    if not req.api_key or not req.messages:
+        return jsonify({"error": "api_key and messages are required"}), 400
+
+    if req.stream:
+        return Response(
+            stream_with_context(stream_chat(req)),
+            content_type="text/event-stream",
+            headers={
+                "Cache-Control": "no-cache",
+                "X-Accel-Buffering": "no",
+            },
+        )
+
+    # Non-stream fallback
+    final = []
+    for part in stream_chat(req):
+        if part.startswith("data:"):
+            data = json.loads(part[6:])
+            if "response" in data:
+                final.append(data["response"])
+
+    return jsonify({"response": "".join(final)})
+
+
+@app.route("/info", methods=["GET"])
+def info():
+    return jsonify({
+        "providers": {
+            "1": M1,
+            "2": M2,
+            "3": M3,
+        }
+    })
+
+
+# ---------------------------------------------------------------------
+# Run
+# ---------------------------------------------------------------------
+
+if __name__ == "__main__":
+    app.run(host="0.0.0.0", port=5550, threaded=True)