tentative tool call support

app/openai_handler.py

@@ -245,30 +245,61 @@ class OpenAIDirectHandler:
                                 #     print(f"DEBUG: Chunk {chunk_count} - Processed content: '{processed_content}', Reasoning: '{current_reasoning[:50]}...' if len(current_reasoning) > 50 else '{current_reasoning}'")
                                 
                                 # Send chunks for both reasoning and content as they arrive
-                                chunks_to_send = []
-                                
-                                # If we have reasoning content, send it
+                                # Kilo Code: Revised payload construction
+                                original_choice = chunk_as_dict['choices'][0]
+                                original_finish_reason = original_choice.get('finish_reason')
+                                original_usage = original_choice.get('usage')
+
                                 if current_reasoning:
-                                    reasoning_chunk_payload = chunk_as_dict.copy()
-                                    reasoning_chunk_payload['choices'][0]['delta'] = {'reasoning_content': current_reasoning}
-                                    chunks_to_send.append(reasoning_chunk_payload)
+                                    reasoning_delta = {'reasoning_content': current_reasoning}
+                                    reasoning_payload = {
+                                        "id": chunk_as_dict["id"], "object": chunk_as_dict["object"],
+                                        "created": chunk_as_dict["created"], "model": chunk_as_dict["model"],
+                                        "choices": [{"index": 0, "delta": reasoning_delta, "finish_reason": None}]
+                                    }
+                                    yielded_data_str = f"data: {json.dumps(reasoning_payload)}\n\n"
+                                    print(f"DEBUG_OPENAI_STREAM: Chunk {chunk_count} - Yielding REASONING: {yielded_data_str.strip()}")
+                                    yield yielded_data_str
                                 
-                                # If we have regular content, send it
                                 if processed_content:
-                                    content_chunk_payload = chunk_as_dict.copy()
-                                    content_chunk_payload['choices'][0]['delta'] = {'content': processed_content}
-                                    chunks_to_send.append(content_chunk_payload)
+                                    content_delta = {'content': processed_content}
+                                    # Determine if this processed_content chunk should carry the original finish_reason and usage.
+                                    # It should if the reasoning processor is NOT inside a tag after this,
+                                    # meaning this processed_content is the final part of any tagged content from original_content_from_delta.
+                                    finish_reason_for_this_content_delta = None
+                                    usage_for_this_content_delta = None
+
+                                    if original_finish_reason and not reasoning_processor.inside_tag:
+                                        finish_reason_for_this_content_delta = original_finish_reason
+                                        if original_usage:
+                                            usage_for_this_content_delta = original_usage
+                                    
+                                    content_payload = {
+                                        "id": chunk_as_dict["id"], "object": chunk_as_dict["object"],
+                                        "created": chunk_as_dict["created"], "model": chunk_as_dict["model"],
+                                        "choices": [{"index": 0, "delta": content_delta, "finish_reason": finish_reason_for_this_content_delta}]
+                                    }
+                                    if usage_for_this_content_delta:
+                                        content_payload['choices'][0]['usage'] = usage_for_this_content_delta
+                                    
+                                    yielded_data_str = f"data: {json.dumps(content_payload)}\n\n"
+                                    print(f"DEBUG_OPENAI_STREAM: Chunk {chunk_count} - Yielding CONTENT: {yielded_data_str.strip()}")
+                                    yield yielded_data_str
                                     has_sent_content = True
                                 
-                                # Send all chunks
-                                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)
+                                # If neither reasoning nor processed_content was generated from a non-empty original content,
+                                # it implies the original content might have been just a tag or something consumed entirely.
+                                # In this case, do nothing more for this path; the original chunk's other properties (like finish_reason if content was empty) are handled below.
+
+                            elif original_finish_reason: # Original delta had no content, but had a finish_reason
+                                # This case handles chunks that are purely for signaling stream end or other non-content states.
+                                yielded_data_str = f"data: {json.dumps(chunk_as_dict)}\n\n" # Yield original chunk as is
+                                print(f"DEBUG_OPENAI_STREAM: Chunk {chunk_count} - Yielding (original delta no content, but has finish_reason): {yielded_data_str.strip()}")
+                                yield yielded_data_str
+                            # If original delta had no content and no finish_reason, it's an empty delta, yield as is.
+                            elif not content and not original_finish_reason : # Kilo Code: Added this condition
                                 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
+                                print(f"DEBUG_OPENAI_STREAM: Chunk {chunk_count} - Yielding (original delta empty): {yielded_data_str.strip()}")
                                 yield yielded_data_str
                     else:
                         # Yield chunks without choices too (they might contain metadata)