Updated app.py

app.py

@@ -636,20 +636,344 @@ def test_onyx_connection():
     return jsonify(results)
 
 
+# ============== Anthropic Messages API ==============
+
+def build_anthropic_payload_from_messages(messages, system_prompt, model_provider, model_version, temperature, chat_session_id, parent_message_id=None, stream=True, tools=None):
+    """Convert Anthropic Messages API format to Onyx payload"""
+    
+    # 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):
+                text_parts = [p.get('text', '') for p in content if p.get('type') == 'text']
+                last_user_message = ' '.join(text_parts)
+            elif isinstance(content, str):
+                last_user_message = content
+            break
+    
+    # Build full message with system prompt
+    full_message = last_user_message
+    if system_prompt:
+        if isinstance(system_prompt, list):
+            sys_text = ' '.join([s.get('text', '') for s in system_prompt if s.get('type') == 'text'])
+        else:
+            sys_text = system_prompt
+        full_message = f"[System: {sys_text}]\n\n{last_user_message}"
+    
+    # If tools are provided, inject them into the prompt context
+    if tools:
+        tools_desc = "\n\n[Available Tools:\n"
+        for tool in tools:
+            name = tool.get('name', '')
+            desc = tool.get('description', '')
+            input_schema = json.dumps(tool.get('input_schema', {}), indent=2)
+            tools_desc += f"- {name}: {desc}\n  Input Schema: {input_schema}\n"
+        tools_desc += "]\n\n"
+        full_message = tools_desc + full_message
+    
+    payload = {
+        "message": full_message,
+        "chat_session_id": chat_session_id,
+        "parent_message_id": parent_message_id if parent_message_id else None,
+        "stream": stream,
+        "llm_override": {
+            "model_provider": model_provider,
+            "model_version": model_version,
+            "temperature": temperature
+        },
+        "file_descriptors": [],
+        "include_citations": False
+    }
+    
+    return payload
+
+
+def generate_anthropic_stream_events(payload, model, session_key):
+    """Stream response from Onyx in Anthropic Messages SSE format"""
+    
+    msg_id = f"msg_{uuid.uuid4().hex[:24]}"
+    final_message_id = None
+    
+    endpoints = [
+        f"{ONYX_BASE_URL}/api/chat/send-chat-message",
+        f"{ONYX_BASE_URL}/api/chat/send-message",
+    ]
+    
+    # message_start event
+    msg_start = {
+        "type": "message_start",
+        "message": {
+            "id": msg_id,
+            "type": "message",
+            "role": "assistant",
+            "content": [],
+            "model": model,
+            "stop_reason": None,
+            "stop_sequence": None,
+            "usage": {"input_tokens": 0, "output_tokens": 0}
+        }
+    }
+    yield f"event: message_start\ndata: {json.dumps(msg_start)}\n\n"
+    
+    # content_block_start
+    yield f"event: content_block_start\ndata: {json.dumps({'type': 'content_block_start', 'index': 0, 'content_block': {'type': 'text', 'text': ''}})}\n\n"
+    
+    # Ping
+    yield f"event: ping\ndata: {json.dumps({'type': 'ping'})}\n\n"
+    
+    last_msg_id = None
+    
+    for url in endpoints:
+        try:
+            with requests.post(url, json=payload, headers=get_headers(), stream=True, timeout=120) as response:
+                if response.status_code != 200:
+                    continue
+                
+                buffer = ""
+                for chunk in response.iter_content(decode_unicode=True):
+                    if not chunk:
+                        continue
+                    buffer += chunk
+                    
+                    while '\n' in buffer:
+                        line, buffer = buffer.split('\n', 1)
+                        line = line.strip()
+                        
+                        if not line or line == "[DONE]":
+                            continue
+                        if line.startswith("data: "):
+                            line = line[6:]
+                        
+                        content, m_id, packet_type = parse_onyx_stream_chunk(line)
+                        
+                        if m_id:
+                            last_msg_id = m_id
+                        
+                        if content and packet_type in ['content', 'legacy', 'raw']:
+                            delta_event = {
+                                "type": "content_block_delta",
+                                "index": 0,
+                                "delta": {"type": "text_delta", "text": content}
+                            }
+                            yield f"event: content_block_delta\ndata: {json.dumps(delta_event)}\n\n"
+                        
+                        if packet_type == "stop":
+                            final_message_id = last_msg_id
+                            break
+                
+                break
+        except Exception as e:
+            print(f"Anthropic stream error: {e}")
+            continue
+    
+    # Update session
+    if final_message_id and session_key in chat_sessions_cache:
+        chat_sessions_cache[session_key]["parent_message_id"] = final_message_id
+    
+    # content_block_stop
+    yield f"event: content_block_stop\ndata: {json.dumps({'type': 'content_block_stop', 'index': 0})}\n\n"
+    
+    # message_delta (stop reason)
+    msg_delta = {
+        "type": "message_delta",
+        "delta": {"stop_reason": "end_turn", "stop_sequence": None},
+        "usage": {"output_tokens": 0}
+    }
+    yield f"event: message_delta\ndata: {json.dumps(msg_delta)}\n\n"
+    
+    # message_stop
+    yield f"event: message_stop\ndata: {json.dumps({'type': 'message_stop'})}\n\n"
+
+
+def collect_anthropic_full_response(payload, model, session_key):
+    """Collect full response and return in Anthropic Messages format"""
+    
+    full_content = ""
+    last_message_id = None
+    
+    endpoints = [
+        f"{ONYX_BASE_URL}/api/chat/send-chat-message",
+        f"{ONYX_BASE_URL}/api/chat/send-message",
+    ]
+    
+    for url in endpoints:
+        try:
+            is_streaming_request = payload.get('stream', False)
+            
+            with requests.post(url, json=payload, headers=get_headers(), stream=is_streaming_request, timeout=120) as response:
+                if response.status_code == 404:
+                    continue
+                
+                if response.status_code != 200:
+                    return {
+                        "type": "error",
+                        "error": {
+                            "type": "api_error",
+                            "message": f"Onyx API error {response.status_code}: {response.text}"
+                        }
+                    }, response.status_code
+                
+                if not is_streaming_request:
+                    try:
+                        data = response.json()
+                        full_content = data.get('answer') or data.get('message') or data.get('content') or ""
+                        msg_id = data.get('message_id')
+                        if session_key in chat_sessions_cache and msg_id:
+                            chat_sessions_cache[session_key]['parent_message_id'] = msg_id
+                        break
+                    except json.JSONDecodeError:
+                        full_content = response.text
+                        break
+                else:
+                    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, msg_id, packet_type = parse_onyx_stream_chunk(line)
+                                if msg_id:
+                                    last_message_id = msg_id
+                                if packet_type == 'stop':
+                                    break
+                                if content and packet_type in ['content', 'legacy', 'raw', 'error']:
+                                    full_content += content
+                    
+                    if session_key in chat_sessions_cache and last_message_id:
+                        chat_sessions_cache[session_key]['parent_message_id'] = last_message_id
+                    break
+                    
+        except requests.exceptions.RequestException as e:
+            print(f"Anthropic request error: {e}")
+            continue
+    
+    if not full_content:
+        return {
+            "type": "error",
+            "error": {
+                "type": "api_error",
+                "message": "No response from Onyx API"
+            }
+        }, 500
+    
+    response_data = {
+        "id": f"msg_{uuid.uuid4().hex[:24]}",
+        "type": "message",
+        "role": "assistant",
+        "content": [{"type": "text", "text": full_content}],
+        "model": model,
+        "stop_reason": "end_turn",
+        "stop_sequence": None,
+        "usage": {
+            "input_tokens": 0,
+            "output_tokens": 0
+        }
+    }
+    
+    return response_data, 200
+
+
+@app.route('/v1/messages', methods=['POST'])
+def anthropic_messages():
+    """Anthropic Messages API compatible endpoint — used by Claude Code"""
+    
+    try:
+        data = request.json
+        print(f"[Anthropic] Received request: {json.dumps(data, indent=2)[:500]}")
+    except Exception as e:
+        return jsonify({
+            "type": "error",
+            "error": {"type": "invalid_request_error", "message": f"Invalid JSON: {e}"}
+        }), 400
+    
+    # Extract Anthropic parameters
+    model = data.get('model', 'claude-opus-4-6')
+    messages = data.get('messages', [])
+    system_prompt = data.get('system', '')
+    stream = data.get('stream', False)
+    temperature = data.get('temperature', 0.7)
+    max_tokens = data.get('max_tokens', 4096)
+    tools = data.get('tools', None)
+    
+    session_key = f"anthropic_{model}"
+    
+    if not messages:
+        return jsonify({
+            "type": "error",
+            "error": {"type": "invalid_request_error", "message": "messages is required"}
+        }), 400
+    
+    # Parse model — Anthropic sends bare model names like 'claude-opus-4-6'
+    # We need to add 'anthropic/' prefix if not present
+    if '/' not in model:
+        full_model = f"anthropic/{model}"
+    else:
+        full_model = model
+    
+    model_provider, model_version = parse_model_string(full_model)
+    model_provider = normalize_provider_name(model_provider)
+    print(f"[Anthropic] Provider: {model_provider}, Version: {model_version}")
+    
+    # Get or create session
+    session_info = get_or_create_session(session_key)
+    if not session_info:
+        return jsonify({
+            "type": "error",
+            "error": {"type": "api_error", "message": "Failed to create chat session"}
+        }), 500
+    
+    # Build Onyx payload
+    payload = build_anthropic_payload_from_messages(
+        messages=messages,
+        system_prompt=system_prompt,
+        model_provider=model_provider,
+        model_version=model_version,
+        temperature=temperature,
+        chat_session_id=session_info['session_id'],
+        parent_message_id=session_info.get('parent_message_id'),
+        stream=stream,
+        tools=tools
+    )
+    
+    if stream:
+        return Response(
+            generate_anthropic_stream_events(payload, model, session_key),
+            content_type='text/event-stream',
+            headers={
+                'Cache-Control': 'no-cache',
+                'Connection': 'keep-alive',
+                'X-Accel-Buffering': 'no'
+            }
+        )
+    else:
+        response_data, status_code = collect_anthropic_full_response(payload, model, session_key)
+        return jsonify(response_data), status_code
+
+
 @app.route('/', methods=['GET'])
 def root():
     """Root endpoint with API info"""
     return jsonify({
-        "name": "OpenAI-Compatible",
-        "version": "1.0.0",
+        "name": "OpenAI + Anthropic",
+        "version": "2.0.0",
         "endpoints": {
-            "chat_completions": "/v1/chat/completions",
+            "chat_completions": "/v1/chat/completions (OpenAI format)",
+            "messages": "/v1/messages (Anthropic format)",
             "models": "/v1/models",
             "sessions": "/v1/sessions",
             "health": "/health",
-            "debug": ""
+            "debug": "/debug"
         },
-        "model_format": "provider/model_version (e.g., openai/gpt-4)"
+        "model_format": "provider/model_version (e.g., openai/gpt-4, anthropic/claude-opus-4-6)"
     })