Upload app/api/main.py with huggingface_hub

app/api/main.py

@@ -13,6 +13,18 @@ from ..agents.peer_learning_agent import PeerLearningAgent
 from ..agents.hand_gesture_agent import HandGestureAgent, GestureSignalMapper
 from datetime import datetime
 import uuid
+import asyncio
+
+
+def run_async(coro):
+    """Run async coroutine in sync context"""
+    try:
+        loop = asyncio.get_running_loop()
+        # If already in async context, create new event loop
+        return asyncio.run(coro)
+    except RuntimeError:
+        # No running loop, safe to use asyncio.run
+        return asyncio.run(coro)
 
 api = Blueprint('api', __name__)
 
@@ -37,7 +49,7 @@ def start_session():
     subtopic = data.get('subtopic', '')
     
     orchestrator = get_orchestrator(user_id)
-    session = orchestrator.start_session(topic, subtopic)
+    session = run_async(orchestrator.start_session(topic, subtopic))
     
     return jsonify({
         'session_id': session.session_id,
@@ -65,14 +77,17 @@ def update_session():
     captured_doubt = data.get('captured_doubt')
     
     orchestrator = get_orchestrator(user_id)
-    orchestrator.update_session(behavioral_data, captured_doubt)
+    run_async(orchestrator.update_session(behavioral_data, captured_doubt))
+    
+    confusion_score = 0
+    if orchestrator.state.current_session and orchestrator.state.current_session.behavioral_signals:
+        signals = orchestrator.state.current_session.behavioral_signals[-5:]
+        confusion_score = orchestrator.behavioral_agent.calculate_confusion_score(signals)
     
     return jsonify({
         'status': 'updated',
-        'active_predictions': orchestrator.state.active_predictions[-3:],
-        'confusion_level': orchestrator.behavioral_agent.calculate_confusion_score(
-            orchestrator.state.current_session.behavioral_signals[-5:]
-        ) if orchestrator.state.current_session else 0
+        'active_predictions': [p.predicted_doubt for p in orchestrator.state.active_predictions[-3:]],
+        'confusion_level': confusion_score
     })
 
 
@@ -238,7 +253,7 @@ def get_due_reviews():
     topic = request.args.get('topic')
     
     agent = RecallAgent(user_id)
-    recalls = agent.get_due_recalls(topic)
+    recalls = run_async(agent.get_due_recalls(topic))
     
     return jsonify({
         'due_count': len(recalls),
@@ -265,7 +280,7 @@ def complete_review():
     quality = data.get('quality', 3)
     
     agent = RecallAgent(user_id)
-    result = agent.complete_review(card_id, quality)
+    result = run_async(agent.complete_review(card_id, quality))
     
     if result:
         return jsonify({
@@ -273,7 +288,7 @@ def complete_review():
             'quality': result.quality,
             'xp_earned': result.xp_earned,
             'next_interval': result.new_interval,
-            'next_review': result.next_review.isoformat()
+            'next_review': result.next_review.isoformat() if hasattr(result, 'next_review') else None
         })
     
     return jsonify({'error': 'Card not found'}), 404
@@ -300,16 +315,16 @@ def get_peer_insights():
     topic = request.args.get('topic', 'General')
     
     agent = PeerLearningAgent('anonymous')
-    insights = agent.get_peer_insights(topic)
+    insights = run_async(agent.get_peer_insights(topic))
     
     return jsonify({
         'insights': [
             {
-                'type': i.insight_type,
-                'content': i.content,
-                'related_topics': i.related_topics,
-                'confidence': i.confidence,
-                'peer_count': i.peer_count
+                'type': i.insight_type if hasattr(i, 'insight_type') else 'general',
+                'content': i.content if hasattr(i, 'content') else str(i),
+                'related_topics': i.related_topics if hasattr(i, 'related_topics') else [],
+                'confidence': i.confidence if hasattr(i, 'confidence') else 0.5,
+                'peer_count': i.peer_count if hasattr(i, 'peer_count') else 1
             }
             for i in insights
         ]
@@ -323,16 +338,16 @@ def get_peer_doubts():
     limit = int(request.args.get('limit', 10))
     
     agent = PeerLearningAgent('anonymous')
-    doubts = agent.get_peer_doubts(topic, limit)
+    doubts = run_async(agent.get_peer_doubts(topic, limit))
     
     return jsonify({
         'doubts': [
             {
-                'id': d.doubt_id,
-                'content': d.content,
-                'resolved': d.resolved,
-                'upvotes': d.upvotes,
-                'similarity': d.similarity_score
+                'id': d.doubt_id if hasattr(d, 'doubt_id') else str(d),
+                'content': d.content if hasattr(d, 'content') else str(d),
+                'resolved': d.resolved if hasattr(d, 'resolved') else False,
+                'upvotes': d.upvotes if hasattr(d, 'upvotes') else 0,
+                'similarity': d.similarity_score if hasattr(d, 'similarity_score') else 0.5
             }
             for d in doubts
         ]
@@ -343,10 +358,10 @@ def get_peer_doubts():
 def get_trending():
     """Get trending topics"""
     agent = PeerLearningAgent('anonymous')
-    trending = agent.get_trending_topics()
+    trending = run_async(agent.get_trending_topics())
     
     return jsonify({
-        'trending': trending
+        'trending': trending if isinstance(trending, list) else []
     })
 
 
@@ -617,16 +632,16 @@ def llm_query():
         models=models
     )
     
-    responses = orchestrator.query_parallel(request_obj)
+    responses = run_async(orchestrator.query_parallel(request_obj))
     
     return jsonify({
         'responses': [
             {
-                'provider': r.provider.value,
-                'content': r.content,
-                'success': r.success,
-                'error': r.error,
-                'latency_ms': r.latency_ms
+                'provider': r.provider.value if hasattr(r, 'provider') else 'unknown',
+                'content': r.content if hasattr(r, 'content') else str(r),
+                'success': r.success if hasattr(r, 'success') else True,
+                'error': r.error if hasattr(r, 'error') else None,
+                'latency_ms': r.latency_ms if hasattr(r, 'latency_ms') else 0
             }
             for r in responses
         ],