Debug code

code_engine.py

@@ -77,9 +77,21 @@ def process_codex_request(request: CodeXRequest) -> CodeXResponse:
     start_time = time.perf_counter()
 
     try:
+        print("=" * 80, flush=True)
+        print("DEBUG code_engine.process_codex_request()", flush=True)
+        print(f"DEBUG incoming session_id: {request.session_id!r}", flush=True)
+        print(f"DEBUG incoming message: {request.message!r}", flush=True)
+        print(f"DEBUG incoming language: {request.language!r}", flush=True)
+        print(f"DEBUG incoming has_code: {bool(request.code and request.code.strip())}", flush=True)
+        print(f"DEBUG incoming has_error_message: {bool(request.error_message and request.error_message.strip())}", flush=True)
+
         scope_decision = decide_scope(request)
+        print(f"DEBUG scope_decision.route: {scope_decision.route}", flush=True)
+        print(f"DEBUG scope_decision.should_continue_to_codex: {scope_decision.should_continue_to_codex}", flush=True)
+
         if not scope_decision.should_continue_to_codex:
             processing_time_ms = int((time.perf_counter() - start_time) * 1000)
+            print("DEBUG returning scope response early", flush=True)
             return build_scope_response(
                 route=scope_decision.route,
                 message=scope_decision.message,
@@ -91,6 +103,12 @@ def process_codex_request(request: CodeXRequest) -> CodeXResponse:
             session_id=request.session_id,
         )
 
+        print(f"DEBUG enriched session_id: {enriched_request.session_id!r}", flush=True)
+        print(f"DEBUG enriched message: {enriched_request.message!r}", flush=True)
+        print(f"DEBUG enriched previous_context present: {bool(enriched_request.previous_context and str(enriched_request.previous_context).strip())}", flush=True)
+        print(f"DEBUG enriched has_code: {bool(enriched_request.code and enriched_request.code.strip())}", flush=True)
+        print(f"DEBUG enriched has_error_message: {bool(enriched_request.error_message and enriched_request.error_message.strip())}", flush=True)
+
         task_type = detect_task_type(
             message=enriched_request.message,
             code=enriched_request.code,
@@ -98,12 +116,20 @@ def process_codex_request(request: CodeXRequest) -> CodeXResponse:
             mode_hint=enriched_request.mode,
         )
 
+        print(f"DEBUG detected task_type: {task_type}", flush=True)
+
         evidence_list = []
         retrieval_used = False
 
-        if should_use_retrieval(task_type, enriched_request):
+        retrieval_decision = should_use_retrieval(task_type, enriched_request)
+        print(f"DEBUG should_use_retrieval: {retrieval_decision}", flush=True)
+
+        if retrieval_decision:
             evidence_list = get_retrieved_evidence(task_type, enriched_request)
             retrieval_used = len(evidence_list) > 0
+            print(f"DEBUG retrieved evidence count: {len(evidence_list)}", flush=True)
+        else:
+            print("DEBUG retrieval skipped", flush=True)
 
         prompt = build_prompt(
             task_type=task_type,
@@ -116,8 +142,14 @@ def process_codex_request(request: CodeXRequest) -> CodeXResponse:
             evidence_list=evidence_list,
         )
 
+        print(f"DEBUG prompt length: {len(prompt)}", flush=True)
+
         model_output, model_used, used_fallback = model_client.generate(prompt)
 
+        print(f"DEBUG model_used: {model_used}", flush=True)
+        print(f"DEBUG used_fallback: {used_fallback}", flush=True)
+        print(f"DEBUG model_output preview: {str(model_output)[:300]!r}", flush=True)
+
         processing_time_ms = int((time.perf_counter() - start_time) * 1000)
 
         response = build_response(
@@ -132,7 +164,12 @@ def process_codex_request(request: CodeXRequest) -> CodeXResponse:
             sources=evidence_list,
         )
 
+        print(f"DEBUG response.task_type: {response.task_type}", flush=True)
+        print(f"DEBUG response.answer: {response.answer!r}", flush=True)
+        print(f"DEBUG response.has_code_output: {bool(response.code_output and response.code_output.strip())}", flush=True)
+
         if response.code_output and response.code_output.strip():
+            print("DEBUG saving artifact to context_manager", flush=True)
             context_manager.save_artifact(
                 session_id=enriched_request.session_id,
                 code=response.code_output,
@@ -141,12 +178,15 @@ def process_codex_request(request: CodeXRequest) -> CodeXResponse:
                 framework=enriched_request.framework,
                 last_user_goal=enriched_request.message,
             )
+        else:
+            print("DEBUG no artifact saved", flush=True)
 
         return response
 
     except Exception as e:
         processing_time_ms = int((time.perf_counter() - start_time) * 1000)
         fallback_task = request.mode if request.mode else CodeTaskType.UNKNOWN
+        print(f"DEBUG exception in process_codex_request: {e}", flush=True)
 
         return build_error_response(
             task_type=fallback_task,