Repo: https://github.com/PhialsBasement/Chain-of-Recursive-Thoughts
Community: https://discord.gg/openfreeai
"""
return html_content
# Health check endpoint
@app.get("/health")
async def health_check():
"""Health check endpoint"""
return {"status": "healthy", "timestamp": datetime.now().isoformat()}
@app.post("/api/initialize", response_model=InitResponse)
async def initialize_chat(config: ChatConfig):
"""Initialize a new chat session using the environment API key"""
try:
# Generate a session ID
session_id = f"session_{datetime.now().strftime('%Y%m%d%H%M%S')}_{uuid.uuid4().hex[:8]}"
# If the environment variable is missing, raise an error (or warning)
if not API_KEY:
raise HTTPException(status_code=400, detail="The OPENROUTE_API environment variable is not set.")
# Initialize the chat instance
chat = EnhancedRecursiveThinkingChat(
api_key=API_KEY,
model=config.model,
temperature=config.temperature
)
chat_instances[session_id] = {
"chat": chat,
"created_at": datetime.now().isoformat(),
"model": config.model
}
return {"session_id": session_id, "status": "initialized"}
except Exception as e:
logger.error(f"Error initializing chat: {str(e)}")
raise HTTPException(status_code=500, detail=f"Failed to initialize chat: {str(e)}")
@app.post("/api/send_message")
async def send_message(request: MessageRequest):
"""Send a message and get a response with the thinking process"""
try:
if request.session_id not in chat_instances:
raise HTTPException(status_code=404, detail="Session not found")
chat = chat_instances[request.session_id]["chat"]
# Override class parameters if provided
original_thinking_fn = chat._determine_thinking_rounds
original_alternatives_fn = chat._generate_alternatives
original_temperature = getattr(chat, "temperature", 0.7)
if request.thinking_rounds is not None:
# Override the thinking rounds determination
chat._determine_thinking_rounds = lambda _: request.thinking_rounds
if request.alternatives_per_round is not None:
def modified_generate_alternatives(base_response, prompt, num_alternatives=3):
return original_alternatives_fn(base_response, prompt, request.alternatives_per_round)
chat._generate_alternatives = modified_generate_alternatives
# Override temperature if provided
if request.temperature is not None:
setattr(chat, "temperature", request.temperature)
# Process the message
logger.info(f"Processing message for session {request.session_id}")
start_time = datetime.now()
result = chat.think_and_respond(request.message, verbose=True)
processing_time = (datetime.now() - start_time).total_seconds()
logger.info(f"Message processed in {processing_time:.2f} seconds")
# Restore original functions and parameters
chat._determine_thinking_rounds = original_thinking_fn
chat._generate_alternatives = original_alternatives_fn
if request.temperature is not None:
setattr(chat, "temperature", original_temperature)
return {
"session_id": request.session_id,
"response": result["response"],
"thinking_rounds": result["thinking_rounds"],
"thinking_history": result["thinking_history"],
"processing_time": processing_time
}
except Exception as e:
logger.error(f"Error processing message: {str(e)}")
raise HTTPException(status_code=500, detail=f"Failed to process message: {str(e)}")
@app.post("/api/save")
async def save_conversation(request: SaveRequest):
"""Save the conversation or the full thinking log"""
try:
if request.session_id not in chat_instances:
raise HTTPException(status_code=404, detail="Session not found")
chat = chat_instances[request.session_id]["chat"]
# Generate default filename if not provided
filename = request.filename
if filename is None:
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
log_type = "full_log" if request.full_log else "conversation"
filename = f"recthink_{log_type}_{timestamp}.json"
# Make sure the output directory exists
os.makedirs("logs", exist_ok=True)
file_path = os.path.join("logs", filename)
if request.full_log:
chat.save_full_log(file_path)
else:
chat.save_conversation(file_path)
return {"status": "saved", "filename": filename, "path": file_path}
except Exception as e:
logger.error(f"Error saving conversation: {str(e)}")
raise HTTPException(status_code=500, detail=f"Failed to save conversation: {str(e)}")
@app.get("/api/sessions", response_model=SessionResponse)
async def list_sessions():
"""List all active chat sessions"""
sessions = []
for session_id, session_data in chat_instances.items():
chat = session_data["chat"]
message_count = len(chat.conversation_history) // 2 # Each message-response pair counts as 2
sessions.append(SessionInfo(
session_id=session_id,
message_count=message_count,
created_at=session_data["created_at"],
model=session_data["model"]
))
return {"sessions": sessions}
@app.get("/api/sessions/{session_id}")
async def get_session(session_id: str):
"""Get details for a specific chat session"""
if session_id not in chat_instances:
raise HTTPException(status_code=404, detail="Session not found")
session_data = chat_instances[session_id]
chat = session_data["chat"]
# Extract conversation history
conversation = []
for i in range(0, len(chat.conversation_history), 2):
if i+1 < len(chat.conversation_history):
conversation.append({
"user": chat.conversation_history[i],
"assistant": chat.conversation_history[i+1]
})
return {
"session_id": session_id,
"created_at": session_data["created_at"],
"model": session_data["model"],
"message_count": len(conversation),
"conversation": conversation
}
@app.delete("/api/sessions/{session_id}")
async def delete_session(session_id: str):
"""Delete a chat session"""
if session_id not in chat_instances:
raise HTTPException(status_code=404, detail="Session not found")
del chat_instances[session_id]
return {"status": "deleted", "session_id": session_id}
# WebSocket connection manager
class ConnectionManager:
def __init__(self):
self.active_connections: Dict[str, WebSocket] = {}
async def connect(self, session_id: str, websocket: WebSocket):
await websocket.accept()
self.active_connections[session_id] = websocket
def disconnect(self, session_id: str):
if session_id in self.active_connections:
del self.active_connections[session_id]
async def send_json(self, session_id: str, data: dict):
if session_id in self.active_connections:
await self.active_connections[session_id].send_json(data)
manager = ConnectionManager()
# WebSocket for streaming the thinking process
@app.websocket("/ws/{session_id}")
async def websocket_endpoint(websocket: WebSocket, session_id: str):
try:
await manager.connect(session_id, websocket)
if session_id not in chat_instances:
await websocket.send_json({"error": "Session not found"})
await websocket.close()
return
chat = chat_instances[session_id]["chat"]
# Set up a custom callback to stream the thinking process
original_call_api = chat._call_api
async def stream_callback(chunk):
await manager.send_json(session_id, {"type": "chunk", "content": chunk})
# Override the _call_api method to also send updates via WebSocket
def ws_call_api(messages, temperature=0.7, stream=True):
result = original_call_api(messages, temperature, stream)
# Send the chunk via WebSocket if we're streaming
if stream:
asyncio.create_task(stream_callback(result))
return result
# Replace the method temporarily
chat._call_api = ws_call_api
# Wait for messages from the client
while True:
data = await websocket.receive_text()
message_data = json.loads(data)
if message_data["type"] == "message":
# Process the message
start_time = datetime.now()
try:
# Get parameters if they exist
thinking_rounds = message_data.get("thinking_rounds", None)
alternatives_per_round = message_data.get("alternatives_per_round", None)
temperature = message_data.get("temperature", None)
# Override if needed
original_thinking_fn = chat._determine_thinking_rounds
original_alternatives_fn = chat._generate_alternatives
original_temperature = getattr(chat, "temperature", 0.7)
if thinking_rounds is not None:
chat._determine_thinking_rounds = lambda _: thinking_rounds
if alternatives_per_round is not None:
def modified_generate_alternatives(base_response, prompt, num_alternatives=3):
return original_alternatives_fn(base_response, prompt, alternatives_per_round)
chat._generate_alternatives = modified_generate_alternatives
if temperature is not None:
setattr(chat, "temperature", temperature)
# Send a status message that we've started processing
await manager.send_json(session_id, {
"type": "status",
"status": "processing",
"message": "Starting recursive thinking process..."
})
# Process the message
result = chat.think_and_respond(message_data["content"], verbose=True)
processing_time = (datetime.now() - start_time).total_seconds()
# Restore original functions
chat._determine_thinking_rounds = original_thinking_fn
chat._generate_alternatives = original_alternatives_fn
if temperature is not None:
setattr(chat, "temperature", original_temperature)
# Send the final result
await manager.send_json(session_id, {
"type": "final",
"response": result["response"],
"thinking_rounds": result["thinking_rounds"],
"thinking_history": result["thinking_history"],
"processing_time": processing_time
})
except Exception as e:
error_msg = str(e)
logger.error(f"Error in WebSocket message processing: {error_msg}")
await manager.send_json(session_id, {
"type": "error",
"error": error_msg
})
except WebSocketDisconnect:
logger.info(f"WebSocket disconnected: {session_id}")
manager.disconnect(session_id)
except Exception as e:
error_msg = str(e)
logger.error(f"WebSocket error: {error_msg}")
try:
await websocket.send_json({"type": "error", "error": error_msg})
except:
pass
finally:
# Restore the original method if needed
if 'chat' in locals() and 'original_call_api' in locals():
chat._call_api = original_call_api
# Make sure to disconnect
manager.disconnect(session_id)
# Use port 7860 for Hugging Face Spaces
if __name__ == "__main__":
port = 7860
print(f"Starting server on port {port}")
uvicorn.run("app:app", host="0.0.0.0", port=port)