tentative tool call support

app/openai_handler.py

@@ -233,10 +233,12 @@ class OpenAIDirectHandler:
                                 del delta['extra_content']
                             
                             content = delta.get('content', '')
+                            print(f"DEBUG_OPENAI_STREAM: Chunk {chunk_count} - Original delta content: '{content}'") # Kilo Code Added Log
                             if content:
                                 # print(f"DEBUG: Chunk {chunk_count} - Raw content: '{content}'")
                                 # Use the processor to extract reasoning
                                 processed_content, current_reasoning = reasoning_processor.process_chunk(content)
+                                print(f"DEBUG_OPENAI_STREAM: Chunk {chunk_count} - Processed by StreamingProcessor: processed_content='{processed_content}', current_reasoning='{current_reasoning}'") # Kilo Code Added Log
                                 
                                 # Debug logging for processing results
                                 # if processed_content or current_reasoning:
@@ -247,23 +249,27 @@ class OpenAIDirectHandler:
                                 
                                 # If we have reasoning content, send it
                                 if current_reasoning:
-                                    reasoning_chunk = chunk_as_dict.copy()
-                                    reasoning_chunk['choices'][0]['delta'] = {'reasoning_content': current_reasoning}
-                                    chunks_to_send.append(reasoning_chunk)
+                                    reasoning_chunk_payload = chunk_as_dict.copy()
+                                    reasoning_chunk_payload['choices'][0]['delta'] = {'reasoning_content': current_reasoning}
+                                    chunks_to_send.append(reasoning_chunk_payload)
                                 
                                 # If we have regular content, send it
                                 if processed_content:
-                                    content_chunk = chunk_as_dict.copy()
-                                    content_chunk['choices'][0]['delta'] = {'content': processed_content}
-                                    chunks_to_send.append(content_chunk)
+                                    content_chunk_payload = chunk_as_dict.copy()
+                                    content_chunk_payload['choices'][0]['delta'] = {'content': processed_content}
+                                    chunks_to_send.append(content_chunk_payload)
                                     has_sent_content = True
                                 
                                 # Send all chunks
-                                for chunk_to_send in chunks_to_send:
-                                    yield f"data: {json.dumps(chunk_to_send)}\n\n"
+                                for chunk_to_send_payload in chunks_to_send:
+                                    yielded_data_str = f"data: {json.dumps(chunk_to_send_payload)}\n\n"
+                                    print(f"DEBUG_OPENAI_STREAM: Chunk {chunk_count} - Yielding from process_chunk: {yielded_data_str.strip()}") # Kilo Code Added Log
+                                    yield yielded_data_str
                             else:
                                 # Still yield the chunk even if no content (could have other delta fields)
-                                yield f"data: {json.dumps(chunk_as_dict)}\n\n"
+                                yielded_data_str = f"data: {json.dumps(chunk_as_dict)}\n\n"
+                                print(f"DEBUG_OPENAI_STREAM: Chunk {chunk_count} - Yielding (original delta no content): {yielded_data_str.strip()}") # Kilo Code Added Log
+                                yield yielded_data_str
                     else:
                         # Yield chunks without choices too (they might contain metadata)
                         yield f"data: {json.dumps(chunk_as_dict)}\n\n"
@@ -285,43 +291,52 @@ class OpenAIDirectHandler:
             
             # Flush any remaining buffered content
             remaining_content, remaining_reasoning = reasoning_processor.flush_remaining()
+            print(f"DEBUG_OPENAI_STREAM: Flushed from StreamingProcessor: remaining_content='{remaining_content}', remaining_reasoning='{remaining_reasoning}'") # Kilo Code Added Log
             
             # Send any remaining reasoning first
             if remaining_reasoning:
                 # print(f"DEBUG: Flushing remaining reasoning: '{remaining_reasoning[:50]}...' if len(remaining_reasoning) > 50 else '{remaining_reasoning}'")
-                reasoning_chunk = {
-                    "id": f"chatcmpl-{int(time.time())}",
+                reasoning_flush_payload = {
+                    "id": f"chatcmpl-flush-{int(time.time())}", # Kilo Code: Changed ID for clarity
                     "object": "chat.completion.chunk",
                     "created": int(time.time()),
                     "model": request.model,
                     "choices": [{"index": 0, "delta": {"reasoning_content": remaining_reasoning}, "finish_reason": None}]
                 }
-                yield f"data: {json.dumps(reasoning_chunk)}\n\n"
+                yielded_data_str = f"data: {json.dumps(reasoning_flush_payload)}\n\n"
+                print(f"DEBUG_OPENAI_STREAM: Yielding from flush (reasoning): {yielded_data_str.strip()}") # Kilo Code Added Log
+                yield yielded_data_str
             
             # Send any remaining content
             if remaining_content:
                 # print(f"DEBUG: Flushing remaining content: '{remaining_content}'")
-                final_chunk = {
-                    "id": f"chatcmpl-{int(time.time())}",
+                content_flush_payload = {
+                    "id": f"chatcmpl-flush-{int(time.time())}", # Kilo Code: Changed ID for clarity
                     "object": "chat.completion.chunk",
                     "created": int(time.time()),
                     "model": request.model,
                     "choices": [{"index": 0, "delta": {"content": remaining_content}, "finish_reason": None}]
                 }
-                yield f"data: {json.dumps(final_chunk)}\n\n"
+                yielded_data_str = f"data: {json.dumps(content_flush_payload)}\n\n"
+                print(f"DEBUG_OPENAI_STREAM: Yielding from flush (content): {yielded_data_str.strip()}") # Kilo Code Added Log
+                yield yielded_data_str
                 has_sent_content = True
             
             # Always send a finish reason chunk
-            finish_chunk = {
+            finish_payload = {
                 "id": f"chatcmpl-{int(time.time())}",
                 "object": "chat.completion.chunk",
                 "created": int(time.time()),
                 "model": request.model,
                 "choices": [{"index": 0, "delta": {}, "finish_reason": "stop"}]
             }
-            yield f"data: {json.dumps(finish_chunk)}\n\n"
+            yielded_data_str = f"data: {json.dumps(finish_payload)}\n\n"
+            print(f"DEBUG_OPENAI_STREAM: Yielding finish chunk: {yielded_data_str.strip()}") # Kilo Code Added Log
+            yield yielded_data_str
             
-            yield "data: [DONE]\n\n"
+            yielded_data_str = "data: [DONE]\n\n"
+            print(f"DEBUG_OPENAI_STREAM: Yielding DONE: {yielded_data_str.strip()}") # Kilo Code Added Log
+            yield yielded_data_str
             
         except Exception as stream_error:
             error_msg = str(stream_error)