Update app.py

app.py

@@ -2,1130 +2,443 @@ from flask import Flask, request, Response, jsonify
 import requests
 import json
 import uuid
+import time
 import os
-from datetime import datetime
 
 app = Flask(__name__)
 
-ONYX_API_URL = os.getenv("ONYX_API_URL", "https://cloud.onyx.app/api/chat/send-chat-message")
-ONYX_API_TOKEN = os.getenv("ONYX_SECRET", "")
+# Configuration
+ONYX_API_URL = "https://cloud.onyx.app/api/chat/send-chat-message"
+ONYX_API_TOKEN = os.environ.get("ONYX_SECRET", "<your-token-here>")
 
-if not ONYX_API_TOKEN:
-    print("WARNING: ONYX_API_TOKEN not set in HuggingFace Secrets!")
+# Store chat sessions for context
+chat_sessions = {}
 
-def stream_onyx_response(onyx_response, format_type="openai"):
-    try:
-        for line in onyx_response.iter_lines():
-            if line:
-                line = line.decode('utf-8')
-                if line.startswith('data: '):
-                    data = line[6:]
-                    if data == '[DONE]':
-                        if format_type == "openai":
-                            yield f"data: [DONE]\n\n"
-                        break
-                    try:
-                        onyx_data = json.loads(data)
-                        content = onyx_data.get("message", "")
-                        if format_type == "huggingface":
-                            hf_chunk = {"token": {"id": 0, "text": content, "logprob": 0.0, "special": False}, "generated_text": None, "details": None}
-                            yield f"data:{json.dumps(hf_chunk)}\n\n"
-                        else:
-                            openai_chunk = {"id": f"chatcmpl-{uuid.uuid4().hex[:8]}", "object": "chat.completion.chunk", "created": int(datetime.now().timestamp()), "model": onyx_data.get("model", "unknown"), "choices": [{"index": 0, "delta": {"content": content}, "finish_reason": None}]}
-                            yield f"data: {json.dumps(openai_chunk)}\n\n"
-                    except json.JSONDecodeError:
-                        continue
-        if format_type == "huggingface":
-            final_hf = {"token": {"id": 0, "text": "", "logprob": 0.0, "special": True}, "generated_text": "", "details": {"finish_reason": "stop", "generated_tokens": 0, "seed": None}}
-            yield f"data:{json.dumps(final_hf)}\n\n"
-        else:
-            final_chunk = {"id": f"chatcmpl-{uuid.uuid4().hex[:8]}", "object": "chat.completion.chunk", "created": int(datetime.now().timestamp()), "model": "unknown", "choices": [{"index": 0, "delta": {}, "finish_reason": "stop"}]}
-            yield f"data: {json.dumps(final_chunk)}\n\n"
-            yield f"data: [DONE]\n\n"
-    except Exception as e:
-        error_chunk = {"error": {"message": str(e), "type": "server_error"}}
-        yield f"data: {json.dumps(error_chunk)}\n\n"
-
-@app.route('/v1/chat/completions', methods=['POST'])
-def chat_completions():
-    try:
-        data = request.json
-        messages = data.get('messages', [])
-        model_provider = data.get('model_provider', 'openai')
-        model_id = data.get('model', 'gpt-4')
-        temperature = data.get('temperature', 1.0)
-        stream_requested = data.get('stream', False)
-        user_message = ""
-        for msg in reversed(messages):
-            if msg.get('role') == 'user':
-                user_message = msg.get('content', '')
-                break
-        onyx_payload = {"message": user_message, "llm_override": {"model_provider": model_provider, "model_version": model_id, "temperature": temperature}, "allowed_tool_ids": [], "file_descriptors": [], "deep_research": False, "origin": "api", "parent_message_id": -1, "chat_session_id": str(uuid.uuid4()), "chat_session_info": {"persona_id": 0, "description": "OpenAI API Bridge", "project_id": 0}, "stream": True, "include_citations": True}
-        headers = {"Authorization": f"Bearer {ONYX_API_TOKEN}", "Content-Type": "application/json"}
-        onyx_response = requests.post(ONYX_API_URL, json=onyx_payload, headers=headers, stream=True)
-        if onyx_response.status_code != 200:
-            return jsonify({"error": {"message": f"Onyx API error: {onyx_response.status_code}", "type": "api_error"}}), onyx_response.status_code
-        if stream_requested:
-            return Response(stream_onyx_response(onyx_response, "openai"), mimetype='text/event-stream', headers={'Cache-Control': 'no-cache', 'X-Accel-Buffering': 'no'})
-        else:
-            full_content = ""
-            for line in onyx_response.iter_lines():
-                if line:
-                    line = line.decode('utf-8')
-                    if line.startswith('data: '):
-                        data_str = line[6:]
-                        if data_str != '[DONE]':
-                            try:
-                                onyx_data = json.loads(data_str)
-                                full_content += onyx_data.get("message", "")
-                            except json.JSONDecodeError:
-                                continue
-            return jsonify({"id": f"chatcmpl-{uuid.uuid4().hex[:8]}", "object": "chat.completion", "created": int(datetime.now().timestamp()), "model": model_id, "choices": [{"index": 0, "message": {"role": "assistant", "content": full_content}, "finish_reason": "stop"}], "usage": {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0}})
-    except Exception as e:
-        return jsonify({"error": {"message": str(e), "type": "server_error"}}), 500
-
-@app.route('/generate', methods=['POST'])
-@app.route('/v1/completions', methods=['POST'])
-def hf_generate():
-    try:
-        data = request.json
-        inputs = data.get('inputs', '')
-        parameters = data.get('parameters', {})
-        model_provider = parameters.get('model_provider', 'openai')
-        model_id = parameters.get('model', 'gpt-4')
-        temperature = parameters.get('temperature', 1.0)
-        stream_requested = data.get('stream', False)
-        onyx_payload = {"message": inputs, "llm_override": {"model_provider": model_provider, "model_version": model_id, "temperature": temperature}, "allowed_tool_ids": [], "file_descriptors": [], "deep_research": False, "origin": "api", "parent_message_id": -1, "chat_session_id": str(uuid.uuid4()), "chat_session_info": {"persona_id": 0, "description": "HuggingFace API Bridge", "project_id": 0}, "stream": True, "include_citations": True}
-        headers = {"Authorization": f"Bearer {ONYX_API_TOKEN}", "Content-Type": "application/json"}
-        onyx_response = requests.post(ONYX_API_URL, json=onyx_payload, headers=headers, stream=True)
-        if onyx_response.status_code != 200:
-            return jsonify({"error": f"Onyx API error: {onyx_response.status_code}"}), onyx_response.status_code
-        if stream_requested:
-            return Response(stream_onyx_response(onyx_response, "huggingface"), mimetype='text/event-stream', headers={'Cache-Control': 'no-cache', 'X-Accel-Buffering': 'no'})
-        else:
-            full_content = ""
-            for line in onyx_response.iter_lines():
-                if line:
-                    line = line.decode('utf-8')
-                    if line.startswith('data: '):
-                        data_str = line[6:]
-                        if data_str != '[DONE]':
-                            try:
-                                onyx_data = json.loads(data_str)
-                                full_content += onyx_data.get("message", "")
-                            except json.JSONDecodeError:
-                                continue
-            return jsonify([{"generated_text": full_content}])
-    except Exception as e:
-        return jsonify({"error": str(e)}), 500
-
-@app.route('/v1/models', methods=['POST', 'GET'])
-@app.route('/models', methods=['POST', 'GET'])
-def list_models():
-    return jsonify({"object": "list", "data": [{"id": "gpt-4", "object": "model", "created": int(datetime.now().timestamp()), "owned_by": "onyx"}, {"id": "claude-3-5-sonnet", "object": "model", "created": int(datetime.now().timestamp()), "owned_by": "onyx"}]})
 
-@app.route('/health', methods=['GET'])
-@app.route('/', methods=['GET'])
-def health():
-    return jsonify({"status": "ok", "api_token_set": bool(ONYX_API_TOKEN), "endpoints": {"openai": "/v1/chat/completions", "huggingface": "/generate", "models": "/v1/models"}})
+def create_chat_session_id():
+    """Generate a new chat session UUID"""
+    return str(uuid.uuid4())
 
-if __name__ == '__main__':
-    port = int(os.getenv("PORT", 7860))
-    app.run(host="0.0.0.0", port=port)                            hf_chunk = {
-                                "token": {
-                                    "id": 0,
-                                    "text": content,
-                                    "logprob": 0.0,
-                                    "special": False
-                                },
-                                "generated_text": None,
-                                "details": None
-                            }
-                            yield f"data:{json.dumps(hf_chunk)}\n\n"
-                        else:
-                            openai_chunk = {
-                                "id": f"chatcmpl-{uuid.uuid4().hex[:8]}",
-                                "object": "chat.completion.chunk",
-                                "created": int(datetime.now().timestamp()),
-                                "model": onyx_data.get("model", "unknown"),
-                                "choices": [{
-                                    "index": 0,
-                                    "delta": {"content": content},
-                                    "finish_reason": None
-                                }]
-                            }
-                            yield f"data: {json.dumps(openai_chunk)}\n\n"
-                    except json.JSONDecodeError:
-                        continue
-        
-        if format_type == "huggingface":
-            final_hf = {
-                "token": {
-                    "id": 0,
-                    "text": "",
-                    "logprob": 0.0,
-                    "special": True
-                },
-                "generated_text": "",
-                "details": {
-                    "finish_reason": "stop",
-                    "generated_tokens": 0,
-                    "seed": None
-                }
-            }
-            yield f"data:{json.dumps(final_hf)}\n\n"
-        else:
-            final_chunk = {
-                "id": f"chatcmpl-{uuid.uuid4().hex[:8]}",
-                "object": "chat.completion.chunk",
-                "created": int(datetime.now().timestamp()),
-                "model": "unknown",
-                "choices": [{
-                    "index": 0,
-                    "delta": {},
-                    "finish_reason": "stop"
-                }]
-            }
-            yield f"data: {json.dumps(final_chunk)}\n\n"
-            yield f"data: [DONE]\n\n"
-        
-    except Exception as e:
-        error_chunk = {"error": {"message": str(e), "type": "server_error"}}
-        yield f"data: {json.dumps(error_chunk)}\n\n"
 
-@app.route('/v1/chat/completions', methods=['POST'])
-def chat_completions():
-    """OpenAI-compatible endpoint"""
-    try:
-        data = request.json
-        messages = data.get('messages', [])
-        model_provider = data.get('model_provider', 'openai')
-        model_id = data.get('model', 'gpt-4')
-        temperature = data.get('temperature', 1.0)
-        stream_requested = data.get('stream', False)
-        
-        user_message = ""
-        for msg in reversed(messages):
-            if msg.get('role') == 'user':
-                user_message = msg.get('content', '')
-                break
-        
-        onyx_payload = {
-            "message": user_message,
-            "llm_override": {
-                "model_provider": model_provider,
-                "model_version": model_id,
-                "temperature": temperature
-            },
-            "allowed_tool_ids": [],
-            "file_descriptors": [],
-            "deep_research": False,
-            "origin": "api",
-            "parent_message_id": -1,
-            "chat_session_id": str(uuid.uuid4()),
-            "chat_session_info": {
-                "persona_id": 0,
-                "description": "OpenAI API Bridge",
-                "project_id": 0
-            },
-            "stream": True,
-            "include_citations": True
-        }
-        
-        headers = {
-            "Authorization": f"Bearer {ONYX_API_TOKEN}",
-            "Content-Type": "application/json"
-        }
-        
-        onyx_response = requests.post(ONYX_API_URL, json=onyx_payload, headers=headers, stream=True)
-        
-        if onyx_response.status_code != 200:
-            return jsonify({
-                "error": {
-                    "message": f"Onyx API error: {onyx_response.status_code}",
-                    "type": "api_error"
-                }
-            }), onyx_response.status_code
-        
-        if stream_requested:
-            return Response(
-                stream_onyx_response(onyx_response, "openai"),
-                mimetype='text/event-stream',
-                headers={'Cache-Control': 'no-cache', 'X-Accel-Buffering': 'no'}
-            )
-        else:
-            full_content = ""
-            for line in onyx_response.iter_lines():
-                if line:
-                    line = line.decode('utf-8')
-                    if line.startswith('data: '):
-                        data = line[6:]
-                        if data != '[DONE]':
-                            try:
-                                onyx_data = json.loads(data)
-                                full_content += onyx_data.get("message", "")
-                            except json.JSONDecodeError:
-                                continue
-            
-            return jsonify({
-                "id": f"chatcmpl-{uuid.uuid4().hex[:8]}",
-                "object": "chat.completion",
-                "created": int(datetime.now().timestamp()),
-                "model": model_id,
-                "choices": [{
-                    "index": 0,
-                    "message": {"role": "assistant", "content": full_content},
-                    "finish_reason": "stop"
-                }],
-                "usage": {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0}
-            })
+def build_onyx_payload(messages, model_provider, model_version, temperature, chat_session_id=None):
+    """Convert OpenAI format to Onyx payload"""
     
-    except Exception as e:
-        return jsonify({"error": {"message": str(e), "type": "server_error"}}), 500
-
-@app.route('/generate', methods=['POST'])
-@app.route('/v1/completions', methods=['POST'])
-def hf_generate():
-    """HuggingFace TGI-compatible endpoint"""
-    try:
-        data = request.json
-        inputs = data.get('inputs', '')
-        parameters = data.get('parameters', {})
-        model_provider = parameters.get('model_provider', 'openai')
-        model_id = parameters.get('model', 'gpt-4')
-        temperature = parameters.get('temperature', 1.0)
-        stream_requested = data.get('stream', False)
-        
-        onyx_payload = {
-            "message": inputs,
-            "llm_override": {
-                "model_provider": model_provider,
-                "model_version": model_id,
-                "temperature": temperature
-            },
-            "allowed_tool_ids": [],
-            "file_descriptors": [],
-            "deep_research": False,
-            "origin": "api",
-            "parent_message_id": -1,
-            "chat_session_id": str(uuid.uuid4()),
-            "chat_session_info": {
-                "persona_id": 0,
-                "description": "HuggingFace API Bridge",
-                "project_id": 0
-            },
-            "stream": True,
-            "include_citations": True
-        }
-        
-        headers = {
-            "Authorization": f"Bearer {ONYX_API_TOKEN}",
-            "Content-Type": "application/json"
-        }
-        
-        onyx_response = requests.post(ONYX_API_URL, json=onyx_payload, headers=headers, stream=True)
-        
-        if onyx_response.status_code != 200:
-            return jsonify({"error": f"Onyx API error: {onyx_response.status_code}"}), onyx_response.status_code
-        
-        if stream_requested:
-            return Response(
-                stream_onyx_response(onyx_response, "huggingface"),
-                mimetype='text/event-stream',
-                headers={'Cache-Control': 'no-cache', 'X-Accel-Buffering': 'no'}
-            )
-        else:
-            full_content = ""
-            for line in onyx_response.iter_lines():
-                if line:
-                    line = line.decode('utf-8')
-                    if line.startswith('data: '):
-                        data = line[6:]
-                        if data != '[DONE]':
-                            try:
-                                onyx_data = json.loads(data)
-                                full_content += onyx_data.get("message", "")
-                            except json.JSONDecodeError:
-                                continue
-            
-            return jsonify([{"generated_text": full_content}])
+    # Extract the last user message
+    last_user_message = ""
+    for msg in reversed(messages):
+        if msg.get('role') == 'user':
+            content = msg.get('content', '')
+            if isinstance(content, list):
+                # Handle content array format (for vision models, etc.)
+                text_parts = [p.get('text', '') for p in content if p.get('type') == 'text']
+                last_user_message = ' '.join(text_parts)
+            else:
+                last_user_message = content
+            break
     
-    except Exception as e:
-        return jsonify({"error": str(e)}), 500
-
-@app.route('/v1/models', methods=['POST', 'GET'])
-@app.route('/models', methods=['POST', 'GET'])
-def list_models():
-    """List available models"""
-    return jsonify({
-        "object": "list",
-        "data": [
-            {"id": "gpt-4", "object": "model", "created": int(datetime.now().timestamp()), "owned_by": "onyx"},
-            {"id": "claude-3-5-sonnet", "object": "model", "created": int(datetime.now().timestamp()), "owned_by": "onyx"}
-        ]
-    })
+    # Build system prompt from system messages
+    system_prompt = ""
+    for msg in messages:
+        if msg.get('role') == 'system':
+            system_prompt += msg.get('content', '') + "\n"
+    
+    # Prepend system prompt to message if exists
+    full_message = last_user_message
+    if system_prompt:
+        full_message = f"[System Instructions: {system_prompt.strip()}]\n\n{last_user_message}"
+    
+    payload = {
+        "message": full_message,
+        "llm_override": {
+            "model_provider": model_provider,
+            "model_version": model_version,
+            "temperature": temperature
+        },
+        "allowed_tool_ids": [],
+        "file_descriptors": [],
+        "internal_search_filters": {
+            "source_type": [],
+            "document_set": [],
+            "tags": []
+        },
+        "deep_research": False,
+        "origin": "unset",
+        "parent_message_id": -1,
+        "chat_session_id": chat_session_id or create_chat_session_id(),
+        "chat_session_info": {
+            "persona_id": 0,
+            "description": "OpenAI Compatible API Session",
+            "project_id": 0
+        },
+        "stream": True,  # Always stream internally
+        "include_citations": False
+    }
+    
+    return payload
 
-@app.route('/health', methods=['GET'])
-@app.route('/', methods=['GET'])
-def health():
-    """Health check endpoint"""
-    return jsonify({
-        "status": "ok",
-        "api_token_set": bool(ONYX_API_TOKEN),
-        "endpoints": {
-            "openai": "/v1/chat/completions",
-            "huggingface": "/generate or /v1/completions",
-            "models": "/v1/models"
-        }
-    })
 
-if __name__ == '__main__':
-    port = int(os.getenv("PORT", 7860))
-    app.run(host="0.0.0.0", port=port)                            hf_chunk = {
-                                "token": {
-                                    "id": 0,
-                                    "text": content,
-                                    "logprob": 0.0,
-                                    "special": False
-                                },
-                                "generated_text": None,
-                                "details": None
-                            }
-                            yield f"data:{json.dumps(hf_chunk)}\n\n"
-                        else:
-                            openai_chunk = {
-                                "id": f"chatcmpl-{uuid.uuid4().hex[:8]}",
-                                "object": "chat.completion.chunk",
-                                "created": int(datetime.now().timestamp()),
-                                "model": onyx_data.get("model", "unknown"),
-                                "choices": [{
-                                    "index": 0,
-                                    "delta": {"content": content},
-                                    "finish_reason": None
-                                }]
-                            }
-                            yield f"data: {json.dumps(openai_chunk)}\n\n"
-                    except json.JSONDecodeError:
-                        continue
-        
-        if format_type == "huggingface":
-            final_hf = {
-                "token": {
-                    "id": 0,
-                    "text": "",
-                    "logprob": 0.0,
-                    "special": True
-                },
-                "generated_text": "",
-                "details": {
-                    "finish_reason": "stop",
-                    "generated_tokens": 0,
-                    "seed": None
-                }
-            }
-            yield f"data:{json.dumps(final_hf)}\n\n"
-        else:
-            final_chunk = {
-                "id": f"chatcmpl-{uuid.uuid4().hex[:8]}",
-                "object": "chat.completion.chunk",
-                "created": int(datetime.now().timestamp()),
-                "model": "unknown",
-                "choices": [{
-                    "index": 0,
-                    "delta": {},
-                    "finish_reason": "stop"
-                }]
-            }
-            yield f"data: {json.dumps(final_chunk)}\n\n"
-            yield f"data: [DONE]\n\n"
-        
-    except Exception as e:
-        error_chunk = {"error": {"message": str(e), "type": "server_error"}}
-        yield f"data: {json.dumps(error_chunk)}\n\n"
+def parse_model_string(model):
+    """
+    Parse model string in format 'provider/model_version' or 'provider:model_version'
+    Examples: 
+        - 'openai/gpt-4' -> ('openai', 'gpt-4')
+        - 'anthropic/claude-3-opus' -> ('anthropic', 'claude-3-opus')
+        - 'gpt-4' -> ('openai', 'gpt-4')  # default provider
+    """
+    if '/' in model:
+        parts = model.split('/', 1)
+        return parts[0], parts[1]
+    elif ':' in model:
+        parts = model.split(':', 1)
+        return parts[0], parts[1]
+    else:
+        # Default provider
+        return "openai", model
 
-@app.route('/v1/chat/completions', methods=['POST'])
-def chat_completions():
-    """OpenAI-compatible endpoint"""
-    try:
-        data = request.json
-        messages = data.get('messages', [])
-        model_provider = data.get('model_provider', 'openai')
-        model_id = data.get('model', 'gpt-4')
-        temperature = data.get('temperature', 1.0)
-        stream_requested = data.get('stream', False)
-        
-        user_message = ""
-        for msg in reversed(messages):
-            if msg.get('role') == 'user':
-                user_message = msg.get('content', '')
-                break
-        
-        onyx_payload = {
-            "message": user_message,
-            "llm_override": {
-                "model_provider": model_provider,
-                "model_version": model_id,
-                "temperature": temperature
-            },
-            "allowed_tool_ids": [],
-            "file_descriptors": [],
-            "deep_research": False,
-            "origin": "api",
-            "parent_message_id": -1,
-            "chat_session_id": str(uuid.uuid4()),
-            "chat_session_info": {
-                "persona_id": 0,
-                "description": "OpenAI API Bridge",
-                "project_id": 0
-            },
-            "stream": True,
-            "include_citations": True
-        }
-        
-        headers = {
-            "Authorization": f"Bearer {ONYX_API_TOKEN}",
-            "Content-Type": "application/json"
-        }
-        
-        onyx_response = requests.post(ONYX_API_URL, json=onyx_payload, headers=headers, stream=True)
-        
-        if onyx_response.status_code != 200:
-            return jsonify({
-                "error": {
-                    "message": f"Onyx API error: {onyx_response.status_code}",
-                    "type": "api_error"
-                }
-            }), onyx_response.status_code
-        
-        if stream_requested:
-            return Response(
-                stream_onyx_response(onyx_response, "openai"),
-                mimetype='text/event-stream',
-                headers={'Cache-Control': 'no-cache', 'X-Accel-Buffering': 'no'}
-            )
-        else:
-            full_content = ""
-            for line in onyx_response.iter_lines():
-                if line:
-                    line = line.decode('utf-8')
-                    if line.startswith('data: '):
-                        data = line[6:]
-                        if data != '[DONE]':
-                            try:
-                                onyx_data = json.loads(data)
-                                full_content += onyx_data.get("message", "")
-                            except json.JSONDecodeError:
-                                continue
-            
-            return jsonify({
-                "id": f"chatcmpl-{uuid.uuid4().hex[:8]}",
-                "object": "chat.completion",
-                "created": int(datetime.now().timestamp()),
-                "model": model_id,
-                "choices": [{
-                    "index": 0,
-                    "message": {"role": "assistant", "content": full_content},
-                    "finish_reason": "stop"
-                }],
-                "usage": {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0}
-            })
-    
-    except Exception as e:
-        return jsonify({"error": {"message": str(e), "type": "server_error"}}), 500
 
-@app.route('/generate', methods=['POST'])
-@app.route('/v1/completions', methods=['POST'])
-def hf_generate():
-    """HuggingFace TGI-compatible endpoint"""
+def parse_onyx_stream_chunk(chunk_text):
+    """Parse a chunk from Onyx stream and extract the text content"""
     try:
-        data = request.json
-        inputs = data.get('inputs', '')
-        parameters = data.get('parameters', {})
-        model_provider = parameters.get('model_provider', 'openai')
-        model_id = parameters.get('model', 'gpt-4')
-        temperature = parameters.get('temperature', 1.0)
-        stream_requested = data.get('stream', False)
-        
-        onyx_payload = {
-            "message": inputs,
-            "llm_override": {
-                "model_provider": model_provider,
-                "model_version": model_id,
-                "temperature": temperature
-            },
-            "allowed_tool_ids": [],
-            "file_descriptors": [],
-            "deep_research": False,
-            "origin": "api",
-            "parent_message_id": -1,
-            "chat_session_id": str(uuid.uuid4()),
-            "chat_session_info": {
-                "persona_id": 0,
-                "description": "HuggingFace API Bridge",
-                "project_id": 0
-            },
-            "stream": True,
-            "include_citations": True
-        }
-        
-        headers = {
-            "Authorization": f"Bearer {ONYX_API_TOKEN}",
-            "Content-Type": "application/json"
-        }
-        
-        onyx_response = requests.post(ONYX_API_URL, json=onyx_payload, headers=headers, stream=True)
-        
-        if onyx_response.status_code != 200:
-            return jsonify({"error": f"Onyx API error: {onyx_response.status_code}"}), onyx_response.status_code
-        
-        if stream_requested:
-            return Response(
-                stream_onyx_response(onyx_response, "huggingface"),
-                mimetype='text/event-stream',
-                headers={'Cache-Control': 'no-cache', 'X-Accel-Buffering': 'no'}
-            )
-        else:
-            full_content = ""
-            for line in onyx_response.iter_lines():
-                if line:
-                    line = line.decode('utf-8')
-                    if line.startswith('data: '):
-                        data = line[6:]
-                        if data != '[DONE]':
-                            try:
-                                onyx_data = json.loads(data)
-                                full_content += onyx_data.get("message", "")
-                            except json.JSONDecodeError:
-                                continue
+        data = json.loads(chunk_text)
+        
+        # Handle different response types from Onyx
+        if isinstance(data, dict):
+            # Check for answer/text content
+            if 'answer_piece' in data:
+                return data['answer_piece']
+            elif 'text' in data:
+                return data['text']
+            elif 'content' in data:
+                return data['content']
+            elif 'message' in data:
+                return data['message']
+            # Check for error
+            elif 'error' in data:
+                return f"[Error: {data['error']}]"
+        elif isinstance(data, str):
+            return data
             
-            return jsonify([{"generated_text": full_content}])
+    except json.JSONDecodeError:
+        # If not JSON, return as-is if it looks like content
+        if chunk_text.strip() and not chunk_text.startswith('{'):
+            return chunk_text
     
-    except Exception as e:
-        return jsonify({"error": str(e)}), 500
+    return None
+
+
+def generate_openai_stream_chunk(content, model, chunk_id, finish_reason=None):
+    """Generate an OpenAI-compatible SSE chunk"""
+    chunk = {
+        "id": chunk_id,
+        "object": "chat.completion.chunk",
+        "created": int(time.time()),
+        "model": model,
+        "choices": [{
+            "index": 0,
+            "delta": {"content": content} if content else {},
+            "finish_reason": finish_reason
+        }]
+    }
+    return f"data: {json.dumps(chunk)}\n\n"
 
-@app.route('/v1/models', methods=['POST', 'GET'])
-@app.route('/models', methods=['POST', 'GET'])
-def list_models():
-    """List available models"""
-    return jsonify({
-        "object": "list",
-        "data": [
-            {"id": "gpt-4", "object": "model", "created": int(datetime.now().timestamp()), "owned_by": "onyx"},
-            {"id": "claude-3-5-sonnet", "object": "model", "created": int(datetime.now().timestamp()), "owned_by": "onyx"}
-        ]
-    })
 
-@app.route('/health', methods=['GET'])
-@app.route('/', methods=['GET'])
-def health():
-    """Health check and documentation"""
-    space_host = request.host
+def stream_onyx_response(payload, headers, model):
+    """Stream response from Onyx API in OpenAI SSE format"""
+    chunk_id = f"chatcmpl-{uuid.uuid4().hex[:24]}"
     
-    html = f"""
-    <!DOCTYPE html>
-    <html>
-    <head>
-        <title>Onyx API Bridge</title>
-        <style>
-            body {{
-                font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
-                max-width: 900px;
-                margin: 40px auto;
-                padding: 20px;
-                background: #f5f5f5;
-            }}
-            .container {{
-                background: white;
-                padding: 30px;
-                border-radius: 8px;
-                box-shadow: 0 2px 4px rgba(0,0,0,0.1);
-            }}
-            h1 {{
-                color: #2563eb;
-                margin-bottom: 10px;
-            }}
-            .status {{
-                display: inline-block;
-                padding: 4px 12px;
-                border-radius: 12px;
-                font-size: 14px;
-                font-weight: 500;
-            }}
-            .status.ok {{
-                background: #dcfce7;
-                color: #166534;
-            }}
-            .status.error {{
-                background: #fee2e2;
-                color: #991b1b;
-            }}
-            .endpoint {{
-                background: #f9fafb;
-                padding: 15px;
-                border-radius: 6px;
-                margin: 15px 0;
-                border-left: 4px solid #2563eb;
-            }}
-            .endpoint-title {{
-                font-weight: 600;
-                color: #1f2937;
-                margin-bottom: 8px;
-            }}
-            .code-block {{
-                background: #1f2937;
-                color: #f9fafb;
-                padding: 15px;
-                border-radius: 6px;
-                margin: 10px 0;
-                position: relative;
-                overflow-x: auto;
-            }}
-            .code-block pre {{
-                margin: 0;
-                font-family: 'Monaco', 'Menlo', monospace;
-                font-size: 13px;
-                line-height: 1.5;
-            }}
-            .copy-btn {{
-                position: absolute;
-                top: 10px;
-                right: 10px;
-                background: #3b82f6;
-                color: white;
-                border: none;
-                padding: 6px 12px;
-                border-radius: 4px;
-                cursor: pointer;
-                font-size: 12px;
-                transition: background 0.2s;
-            }}
-            .copy-btn:hover {{
-                background: #2563eb;
-            }}
-            .copy-btn.copied {{
-                background: #10b981;
-            }}
-            .url {{
-                color: #2563eb;
-                word-break: break-all;
-            }}
-        </style>
-    </head>
-    <body>
-        <div class="container">
-            <h1>🚀 Onyx API Bridge</h1>
-            <p>
-                <span class="status {'ok' if ONYX_API_TOKEN else 'error'}">
-                    {'✓ API Token Set' if ONYX_API_TOKEN else '✗ API Token Missing'}
-                </span>
-            </p>
-            
-            <h2>Available Endpoints</h2>
-            
-            <div class="endpoint">
-                <div class="endpoint-title">OpenAI Compatible</div>
-                <code class="url">https://{space_host}/v1/chat/completions</code>
-            </div>
-            
-            <div class="endpoint">
-                <div class="endpoint-title">HuggingFace Compatible</div>
-                <code class="url">https://{space_host}/generate</code>
-            </div>
+    # Send initial chunk with role
+    initial_chunk = {
+        "id": chunk_id,
+        "object": "chat.completion.chunk",
+        "created": int(time.time()),
+        "model": model,
+        "choices": [{
+            "index": 0,
+            "delta": {"role": "assistant", "content": ""},
+            "finish_reason": None
+        }]
+    }
+    yield f"data: {json.dumps(initial_chunk)}\n\n"
+    
+    try:
+        with requests.post(
+            ONYX_API_URL, 
+            json=payload, 
+            headers=headers, 
+            stream=True,
+            timeout=120
+        ) as response:
             
-            <div class="endpoint">
-                <div class="endpoint-title">Models List</div>
-                <code class="url">https://{space_host}/v1/models</code>
-            </div>
+            if response.status_code != 200:
+                error_content = f"Error from Onyx API: {response.status_code} - {response.text}"
+                yield generate_openai_stream_chunk(error_content, model, chunk_id)
+                yield generate_openai_stream_chunk("", model, chunk_id, "stop")
+                yield "data: [DONE]\n\n"
+                return
             
-            <h2>Usage Examples</h2>
+            buffer = ""
+            for chunk in response.iter_content(chunk_size=None, decode_unicode=True):
+                if chunk:
+                    buffer += chunk
+                    
+                    # Process complete lines
+                    while '\n' in buffer:
+                        line, buffer = buffer.split('\n', 1)
+                        line = line.strip()
+                        
+                        if not line:
+                            continue
+                        
+                        # Handle SSE format from Onyx
+                        if line.startswith('data: '):
+                            line = line[6:]
+                        
+                        if line == '[DONE]':
+                            continue
+                        
+                        content = parse_onyx_stream_chunk(line)
+                        if content:
+                            yield generate_openai_stream_chunk(content, model, chunk_id)
             
-            <h3>OpenAI SDK</h3>
-            <div class="code-block">
-                <button class="copy-btn" onclick="copyCode(this)">Copy</button>
-                <pre>from openai import OpenAI
-
-client = OpenAI(
-    api_key="dummy",
-    base_url="https://{space_host}/v1"
-)
+            # Process any remaining buffer
+            if buffer.strip():
+                content = parse_onyx_stream_chunk(buffer.strip())
+                if content:
+                    yield generate_openai_stream_chunk(content, model, chunk_id)
+    
+    except requests.exceptions.RequestException as e:
+        error_content = f"Request error: {str(e)}"
+        yield generate_openai_stream_chunk(error_content, model, chunk_id)
+    
+    # Send final chunk
+    yield generate_openai_stream_chunk("", model, chunk_id, "stop")
+    yield "data: [DONE]\n\n"
 
-response = client.chat.completions.create(
-    model="claude-3-5-sonnet",
-    model_provider="anthropic",
-    messages=[{{"role": "user", "content": "Hello!"}}],
-    stream=True
-)
 
-for chunk in response:
-    if chunk.choices[0].delta.content:
-        print(chunk.choices[0].delta.content, end="")</pre>
-            </div>
+def collect_full_response(payload, headers, model):
+    """Collect full streaming response and return as complete OpenAI response"""
+    full_content = ""
+    
+    try:
+        with requests.post(
+            ONYX_API_URL, 
+            json=payload, 
+            headers=headers, 
+            stream=True,
+            timeout=120
+        ) as response:
             
-            <h3>HuggingFace Client</h3>
-            <div class="code-block">
-                <button class="copy-btn" onclick="copyCode(this)">Copy</button>
-                <pre>from huggingface_hub import InferenceClient
-
-client = InferenceClient(model="https://{space_host}")
-
-for token in client.text_generation(
-    "Hello!",
-    stream=True,
-    parameters={{
-        "model_provider": "anthropic",
-        "model": "claude-3-5-sonnet"
-    }}
-):
-    print(token, end="")</pre>
-            </div>
+            if response.status_code != 200:
+                return {
+                    "error": {
+                        "message": f"Error from Onyx API: {response.status_code} - {response.text}",
+                        "type": "api_error",
+                        "code": response.status_code
+                    }
+                }, response.status_code
             
-            <h3>cURL</h3>
-            <div class="code-block">
-                <button class="copy-btn" onclick="copyCode(this)">Copy</button>
-                <pre>curl -X POST https://{space_host}/v1/chat/completions \\
-  -H "Content-Type: application/json" \\
-  -d '{{
-    "model": "gpt-4",
-    "model_provider": "openai",
-    "messages": [{{"role": "user", "content": "Hello!"}}],
-    "stream": false
-  }}'</pre>
-            </div>
-        </div>
-        
-        <script>
-            function copyCode(button) {{
-                const codeBlock = button.nextElementSibling;
-                const text = codeBlock.textContent;
-                
-                navigator.clipboard.writeText(text).then(() => {{
-                    button.textContent = 'Copied!';
-                    button.classList.add('copied');
-                    setTimeout(() => {{
-                        button.textContent = 'Copy';
-                        button.classList.remove('copied');
-                    }}, 2000);
-                }});
-            }}
-        </script>
-    </body>
-    </html>
-    """
+            buffer = ""
+            for chunk in response.iter_content(chunk_size=None, decode_unicode=True):
+                if chunk:
+                    buffer += chunk
+                    
+                    while '\n' in buffer:
+                        line, buffer = buffer.split('\n', 1)
+                        line = line.strip()
+                        
+                        if not line:
+                            continue
+                        
+                        if line.startswith('data: '):
+                            line = line[6:]
+                        
+                        if line == '[DONE]':
+                            continue
+                        
+                        content = parse_onyx_stream_chunk(line)
+                        if content:
+                            full_content += content
+            
+            # Process remaining buffer
+            if buffer.strip():
+                content = parse_onyx_stream_chunk(buffer.strip())
+                if content:
+                    full_content += content
     
-    return html
-
-if __name__ == '__main__':
-    port = int(os.getenv("PORT", 7860))
-    app.run(host="0.0.0.0", port=port)                            hf_chunk = {
-                                "token": {
-                                    "id": 0,
-                                    "text": content,
-                                    "logprob": 0.0,
-                                    "special": False
-                                },
-                                "generated_text": None,
-                                "details": None
-                            }
-                            yield f"data:{json.dumps(hf_chunk)}\n\n"
-                        else:
-                            openai_chunk = {
-                                "id": f"chatcmpl-{uuid.uuid4().hex[:8]}",
-                                "object": "chat.completion.chunk",
-                                "created": int(datetime.now().timestamp()),
-                                "model": onyx_data.get("model", "unknown"),
-                                "choices": [{
-                                    "index": 0,
-                                    "delta": {"content": content},
-                                    "finish_reason": None
-                                }]
-                            }
-                            yield f"data: {json.dumps(openai_chunk)}\n\n"
-                    except json.JSONDecodeError:
-                        continue
-        
-        if format_type == "huggingface":
-            final_hf = {
-                "token": {
-                    "id": 0,
-                    "text": "",
-                    "logprob": 0.0,
-                    "special": True
-                },
-                "generated_text": "",
-                "details": {
-                    "finish_reason": "stop",
-                    "generated_tokens": 0,
-                    "seed": None
-                }
+    except requests.exceptions.RequestException as e:
+        return {
+            "error": {
+                "message": f"Request error: {str(e)}",
+                "type": "api_error",
+                "code": 500
             }
-            yield f"data:{json.dumps(final_hf)}\n\n"
-        else:
-            final_chunk = {
-                "id": f"chatcmpl-{uuid.uuid4().hex[:8]}",
-                "object": "chat.completion.chunk",
-                "created": int(datetime.now().timestamp()),
-                "model": "unknown",
-                "choices": [{
-                    "index": 0,
-                    "delta": {},
-                    "finish_reason": "stop"
-                }]
-            }
-            yield f"data: {json.dumps(final_chunk)}\n\n"
-            yield f"data: [DONE]\n\n"
-        
-    except Exception as e:
-        error_chunk = {"error": {"message": str(e), "type": "server_error"}}
-        yield f"data: {json.dumps(error_chunk)}\n\n"
-
-@app.route('/v1/chat/completions', methods=['POST'])
-def chat_completions():
-    """OpenAI-compatible endpoint"""
-    try:
-        data = request.json
-        messages = data.get('messages', [])
-        model_provider = data.get('model_provider', 'openai')
-        model_id = data.get('model', 'gpt-4')
-        temperature = data.get('temperature', 1.0)
-        stream_requested = data.get('stream', False)
-        
-        user_message = ""
-        for msg in reversed(messages):
-            if msg.get('role') == 'user':
-                user_message = msg.get('content', '')
-                break
-        
-        onyx_payload = {
-            "message": user_message,
-            "llm_override": {
-                "model_provider": model_provider,
-                "model_version": model_id,
-                "temperature": temperature
-            },
-            "allowed_tool_ids": [],
-            "file_descriptors": [],
-            "deep_research": False,
-            "origin": "api",
-            "parent_message_id": -1,
-            "chat_session_id": str(uuid.uuid4()),
-            "chat_session_info": {
-                "persona_id": 0,
-                "description": "OpenAI API Bridge",
-                "project_id": 0
+        }, 500
+    
+    # Build OpenAI-compatible response
+    response_data = {
+        "id": f"chatcmpl-{uuid.uuid4().hex[:24]}",
+        "object": "chat.completion",
+        "created": int(time.time()),
+        "model": model,
+        "choices": [{
+            "index": 0,
+            "message": {
+                "role": "assistant",
+                "content": full_content
             },
-            "stream": True,
-            "include_citations": True
+            "finish_reason": "stop"
+        }],
+        "usage": {
+            "prompt_tokens": -1,  # Not available from Onyx
+            "completion_tokens": -1,
+            "total_tokens": -1
         }
-        
-        headers = {
-            "Authorization": f"Bearer {ONYX_API_TOKEN}",
-            "Content-Type": "application/json"
-        }
-        
-        onyx_response = requests.post(ONYX_API_URL, json=onyx_payload, headers=headers, stream=True)
-        
-        if onyx_response.status_code != 200:
-            return jsonify({
-                "error": {
-                    "message": f"Onyx API error: {onyx_response.status_code}",
-                    "type": "api_error"
-                }
-            }), onyx_response.status_code
-        
-        if stream_requested:
-            return Response(
-                stream_onyx_response(onyx_response, "openai"),
-                mimetype='text/event-stream',
-                headers={'Cache-Control': 'no-cache', 'X-Accel-Buffering': 'no'}
-            )
-        else:
-            full_content = ""
-            for line in onyx_response.iter_lines():
-                if line:
-                    line = line.decode('utf-8')
-                    if line.startswith('data: '):
-                        data = line[6:]
-                        if data != '[DONE]':
-                            try:
-                                onyx_data = json.loads(data)
-                                full_content += onyx_data.get("message", "")
-                            except json.JSONDecodeError:
-                                continue
-            
-            return jsonify({
-                "id": f"chatcmpl-{uuid.uuid4().hex[:8]}",
-                "object": "chat.completion",
-                "created": int(datetime.now().timestamp()),
-                "model": model_id,
-                "choices": [{
-                    "index": 0,
-                    "message": {"role": "assistant", "content": full_content},
-                    "finish_reason": "stop"
-                }],
-                "usage": {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0}
-            })
+    }
     
-    except Exception as e:
-        return jsonify({"error": {"message": str(e), "type": "server_error"}}), 500
+    return response_data, 200
+
+
+# ============== API Routes ==============
 
-@app.route('/generate', methods=['POST'])
-@app.route('/v1/completions', methods=['POST'])
-def hf_generate():
-    """HuggingFace TGI-compatible endpoint"""
+@app.route('/v1/chat/completions', methods=['POST'])
+def chat_completions():
+    """OpenAI-compatible chat completions endpoint"""
+    
     try:
         data = request.json
-        inputs = data.get('inputs', '')
-        parameters = data.get('parameters', {})
-        model_provider = parameters.get('model_provider', 'openai')
-        model_id = parameters.get('model', 'gpt-4')
-        temperature = parameters.get('temperature', 1.0)
-        stream_requested = data.get('stream', False)
-        
-        onyx_payload = {
-            "message": inputs,
-            "llm_override": {
-                "model_provider": model_provider,
-                "model_version": model_id,
-                "temperature": temperature
-            },
-            "allowed_tool_ids": [],
-            "file_descriptors": [],
-            "deep_research": False,
-            "origin": "api",
-            "parent_message_id": -1,
-            "chat_session_id": str(uuid.uuid4()),
-            "chat_session_info": {
-                "persona_id": 0,
-                "description": "HuggingFace API Bridge",
-                "project_id": 0
-            },
-            "stream": True,
-            "include_citations": True
-        }
-        
-        headers = {
-            "Authorization": f"Bearer {ONYX_API_TOKEN}",
-            "Content-Type": "application/json"
-        }
-        
-        onyx_response = requests.post(ONYX_API_URL, json=onyx_payload, headers=headers, stream=True)
-        
-        if onyx_response.status_code != 200:
-            return jsonify({"error": f"Onyx API error: {onyx_response.status_code}"}), onyx_response.status_code
-        
-        if stream_requested:
-            return Response(
-                stream_onyx_response(onyx_response, "huggingface"),
-                mimetype='text/event-stream',
-                headers={'Cache-Control': 'no-cache', 'X-Accel-Buffering': 'no'}
-            )
-        else:
-            full_content = ""
-            for line in onyx_response.iter_lines():
-                if line:
-                    line = line.decode('utf-8')
-                    if line.startswith('data: '):
-                        data = line[6:]
-                        if data != '[DONE]':
-                            try:
-                                onyx_data = json.loads(data)
-                                full_content += onyx_data.get("message", "")
-                            except json.JSONDecodeError:
-                                continue
-            
-            return jsonify([{"generated_text": full_content}])
-    
     except Exception as e:
-        return jsonify({"error": str(e)}), 500
+        return jsonify({"error": {"message": "Invalid JSON", "type": "invalid_request_error"}}), 400
+    
+    # Extract parameters
+    model = data.get('model', 'openai/gpt-4')
+    messages = data.get('messages', [])
+    stream = data.get('stream', False)
+    temperature = data.get('temperature', 0.7)
+    
+    # Validate messages
+    if not messages:
+        return jsonify({
+            "error": {
+                "message": "messages is required",
+                "type": "invalid_request_error"
+            }
+        }), 400
+    
+    # Parse model string
+    model_provider, model_version = parse_model_string(model)
+    
+    # Build Onyx payload
+    payload = build_onyx_payload(
+        messages=messages,
+        model_provider=model_provider,
+        model_version=model_version,
+        temperature=temperature
+    )
+    
+    headers = {
+        "Authorization": f"Bearer {ONYX_API_TOKEN}",
+        "Content-Type": "application/json"
+    }
+    
+    if stream:
+        # Return streaming response
+        return Response(
+            stream_onyx_response(payload, headers, model),
+            content_type='text/event-stream',
+            headers={
+                'Cache-Control': 'no-cache',
+                'Connection': 'keep-alive',
+                'X-Accel-Buffering': 'no'
+            }
+        )
+    else:
+        # Return complete response
+        response_data, status_code = collect_full_response(payload, headers, model)
+        return jsonify(response_data), status_code
+
 
-@app.route('/v1/models', methods=['POST', 'GET'])
-@app.route('/models', methods=['POST', 'GET'])
+@app.route('/v1/models', methods=['GET'])
 def list_models():
-    """List available models"""
+    """OpenAI-compatible models listing endpoint"""
+    models = [
+        {"id": "openai/gpt-4", "object": "model", "owned_by": "openai"},
+        {"id": "openai/gpt-4-turbo", "object": "model", "owned_by": "openai"},
+        {"id": "openai/gpt-3.5-turbo", "object": "model", "owned_by": "openai"},
+        {"id": "anthropic/claude-3-opus", "object": "model", "owned_by": "anthropic"},
+        {"id": "anthropic/claude-3-sonnet", "object": "model", "owned_by": "anthropic"},
+        {"id": "anthropic/claude-3-haiku", "object": "model", "owned_by": "anthropic"},
+    ]
+    
     return jsonify({
         "object": "list",
-        "data": [
-            {"id": "gpt-4", "object": "model", "created": int(datetime.now().timestamp()), "owned_by": "onyx"},
-            {"id": "claude-3-5-sonnet", "object": "model", "created": int(datetime.now().timestamp()), "owned_by": "onyx"}
-        ]
+        "data": models
+    })
+
+
+@app.route('/v1/models/<path:model_id>', methods=['GET'])
+def get_model(model_id):
+    """OpenAI-compatible model details endpoint"""
+    return jsonify({
+        "id": model_id,
+        "object": "model",
+        "owned_by": model_id.split('/')[0] if '/' in model_id else "unknown"
     })
 
+
 @app.route('/health', methods=['GET'])
-@app.route('/', methods=['GET'])
-def health():
+def health_check():
     """Health check endpoint"""
+    return jsonify({"status": "healthy", "timestamp": int(time.time())})
+
+
+@app.route('/', methods=['GET'])
+def root():
+    """Root endpoint with API info"""
     return jsonify({
-        "status": "ok",
-        "api_token_set": bool(ONYX_API_TOKEN),
+        "name": "OpenAI-Compatible Onyx API Proxy",
+        "version": "1.0.0",
         "endpoints": {
-            "openai": "/v1/chat/completions",
-            "huggingface": "/generate or /v1/completions",
-            "models": "/v1/models"
+            "chat_completions": "/v1/chat/completions",
+            "models": "/v1/models",
+            "health": "/health"
         }
     })
 
-if __name__ == '__main__':
-    port = int(os.getenv("PORT", 7860))
-    app.run(host="0.0.0.0", port=port)        # Splits on first slash, cleans whitespace, preserves case
-        provider, version = [part.strip() for part in raw_model.split("/", 1)]
-    else:
-        provider, version = "OpenAI", raw_model.strip()
 
-    messages = data.get("messages", [])
-    user_content = messages[-1].get("content", "") if messages else ""
+# ============== Error Handlers ==============
 
-    # ONYX PAYLOAD: Uses your specific template requirements
-    onyx_payload = {
-        "message": user_content,
-        "llm_override": {
-            "model_provider": provider,
-            "model_version": version,
-            "temperature": data.get("temperature", 0.7)
-        },
-        "stream": True,  # Forced ON regardless of user input
-        "include_citations": True,
-        "deep_research": False,
-        "parent_message_id": -1,
-        "chat_session_id": "3c90c3cc-0d44-4b50-8888-8dd25736052a"
-    }
-
-    headers = {
-        "Authorization": f"Bearer {ONYX_API_KEY}",
-        "Content-Type": "application/json"
-    }
+@app.errorhandler(404)
+def not_found(e):
+    return jsonify({
+        "error": {
+            "message": "Endpoint not found",
+            "type": "invalid_request_error",
+            "code": 404
+        }
+    }), 404
 
-    def generate():
-        try:
-            with requests.post(ONYX_URL, json=onyx_payload, headers=headers, stream=True) as r:
-                if r.status_code != 200:
-                    yield f"data: {json.dumps({'error': 'Onyx API Error', 'status': r.status_code})}\n\n"
-                    return
 
-                for line in r.iter_lines():
-                    if not line:
-                        continue
-                    
-                    try:
-                        packet = json.loads(line.decode('utf-8'))
-                        # Onyx provides content in 'message_delta' packets
-                        if packet.get("type") == "message_delta":
-                            content = packet.get("delta", "")
-                            yield transform_to_openai_chunk(content, raw_model)
-                    except (json.JSONDecodeError, KeyError):
-                        continue
-                
-                # Signal stream completion
-                yield transform_to_openai_chunk(None, raw_model, finish_reason="stop")
-                yield "data: [DONE]\n\n"
-        except Exception as e:
-            yield f"data: {json.dumps({'error': str(e)})}\n\n"
+@app.errorhandler(500)
+def server_error(e):
+    return jsonify({
+        "error": {
+            "message": "Internal server error",
+            "type": "server_error",
+            "code": 500
+        }
+    }), 500
 
-    return Response(stream_with_context(generate()), mimetype='text/event-stream')
 
-@app.route('/')
-def health_check():
-    return "Onyx-OpenAI Proxy is running on HF Space (Port 7860).", 200
+# ============== Main ==============
 
 if __name__ == '__main__':
-    # Standard HF port
-    app.run(host='0.0.0.0', port=7860)
+    print("Starting OpenAI-Compatible Onyx API Proxy...")
+    print(f"Onyx API URL: {ONYX_API_URL}")
+    print("="*50)
+    
+    app.run(
+        host='0.0.0.0',
+        port=5000,
+        debug=True,
+        threaded=True
+    )