update python

app.py

@@ -301,11 +301,7 @@ def get_streaming_callback(text_placeholder, tool_placeholder):
         if not hasattr(callback_func, '_data_counter'):
             callback_func._data_counter = 0
         
-        # Initialize persistent storage for all processed data
-        if not hasattr(callback_func, '_persistent_data'):
-            callback_func._persistent_data = []
-            callback_func._persistent_data.append("🚀 **Session Started** - All data will be preserved\n")
-            callback_func._persistent_data.append("---\n")
+
         
 
         
@@ -473,9 +469,6 @@ def get_streaming_callback(text_placeholder, tool_placeholder):
                                                                 accumulated_tool.append(f"\n🚀 **Task Started**: {content}\n")
                                                         # Real-time UI update for task start
                                                         with tool_placeholder.expander("🔧 Tool Call Information", expanded=True):
-                                                            # Show data counter at the top
-                                                            st.markdown(f"**📊 Total Data Messages: {callback_func._data_counter}**")
-                                                            st.markdown("---")
                                                             st.markdown("".join(accumulated_tool))
                                                     elif "```bdd-long-task-end" in content:
                                                         # Extract task info
@@ -490,9 +483,6 @@ def get_streaming_callback(text_placeholder, tool_placeholder):
                                                                 accumulated_tool.append(f"\n✅ **Task Completed**: {content}\n")
                                                         # Real-time UI update for task completion
                                                         with tool_placeholder.expander("🔧 Tool Call Information", expanded=True):
-                                                            # Show data counter at the top
-                                                            st.markdown(f"**📊 Total Data Messages: {callback_func._data_counter}**")
-                                                            st.markdown("---")
                                                             st.markdown("".join(accumulated_tool))
                                                     elif "```bdd-resource-lookup" in content:
                                                         # Extract resource info
@@ -514,9 +504,6 @@ def get_streaming_callback(text_placeholder, tool_placeholder):
                                                                 accumulated_tool.append(f"\n📚 **Resources**: {content}\n")
                                                         # Real-time UI update for resources
                                                         with tool_placeholder.expander("🔧 Tool Call Information", expanded=True):
-                                                            # Show data counter at the top
-                                                            st.markdown(f"**📊 Total Data Messages: {callback_func._data_counter}**")
-                                                            st.markdown("---")
                                                             st.markdown("".join(accumulated_tool))
                                                     elif "```bdd-chat-agent-task" in content:
                                                         # Extract chat agent task info
@@ -589,45 +576,22 @@ def get_streaming_callback(text_placeholder, tool_placeholder):
                                                 timestamp = time.strftime("%H:%M:%S")
                                                 
                                                 # Format the data for display
-                                                data_entry = ""
                                                 if isinstance(data_content, str):
-                                                    data_entry = f"\n📡 **Data [{data_type}]** [{timestamp}]: {data_content}\n"
+                                                    accumulated_tool.append(f"\n📡 **Data [{data_type}]** [{timestamp}]: {data_content}\n")
                                                 else:
-                                                    data_entry = f"\n📡 **Data [{data_type}]** [{timestamp}]:\n```json\n{json.dumps(data_obj, indent=2)}\n```\n"
-                                                
-                                                # Add to both temporary and persistent storage
-                                                accumulated_tool.append(data_entry)
-                                                callback_func._persistent_data.append(data_entry)
+                                                    accumulated_tool.append(f"\n📡 **Data [{data_type}]** [{timestamp}]:\n```json\n{json.dumps(data_obj, indent=2)}\n```\n")
                                                 
                                                 # Immediate real-time UI update for any data: message
                                                 with tool_placeholder.expander("🔧 Tool Call Information", expanded=True):
-                                                    # Show data counter at the top
-                                                    st.markdown(f"**📊 Total Data Messages: {callback_func._data_counter}**")
-                                                    st.markdown("---")
-                                                    # Show persistent data first, then current accumulated data
-                                                    st.markdown("".join(callback_func._persistent_data))
-                                                    st.markdown("---")
-                                                    st.markdown("**🔄 Current Stream:**")
                                                     st.markdown("".join(accumulated_tool))
                                         else:
                                             # Handle non-dict data objects
                                             import time
                                             timestamp = time.strftime("%H:%M:%S")
-                                            data_entry = f"\n📡 **Raw Data** [{timestamp}]:\n```json\n{json_str}\n```\n"
-                                            
-                                            # Add to both temporary and persistent storage
-                                            accumulated_tool.append(data_entry)
-                                            callback_func._persistent_data.append(data_entry)
+                                            accumulated_tool.append(f"\n📡 **Raw Data** [{timestamp}]:\n```json\n{json_str}\n```\n")
                                             
                                             # Immediate real-time UI update
                                             with tool_placeholder.expander("🔧 Tool Call Information", expanded=True):
-                                                # Show data counter at the top
-                                                st.markdown(f"**📊 Total Data Messages: {callback_func._data_counter}**")
-                                                st.markdown("---")
-                                                # Show persistent data first, then current accumulated data
-                                                st.markdown("".join(callback_func._persistent_data))
-                                                st.markdown("---")
-                                                st.markdown("**🔄 Current Stream:**")
                                                 st.markdown("".join(accumulated_tool))
                                     except json.JSONDecodeError:
                                         # If not valid JSON, check if it's streaming text content
@@ -652,27 +616,11 @@ def get_streaming_callback(text_placeholder, tool_placeholder):
                                                 # Real-time UI update
                                                 with tool_placeholder.expander("🔧 Tool Call Information", expanded=True):
                                                     st.markdown("".join(accumulated_tool))
-                                        else:
-                                            # Handle empty or whitespace-only data
-                                            import time
-                                            timestamp = time.strftime("%H:%M:%S")
-                                            accumulated_tool.append(f"\n📡 **Empty Data** [{timestamp}]: (empty or whitespace)\n")
-                                            
-                                            # Immediate real-time UI update
-                                            with tool_placeholder.expander("🔧 Tool Call Information", expanded=True):
-                                                st.markdown("".join(accumulated_tool))
-                            except Exception as e:
+
+                            except Exception:
                                 # Fallback: treat as plain text, but only if it's meaningful
-                                import time
-                                timestamp = time.strftime("%H:%M:%S")
                                 if line.strip() and len(line.strip()) > 1:  # Only show non-trivial content
-                                    accumulated_tool.append(f"\n📝 **Info** [{timestamp}]: {line.strip()}\n")
-                                else:
-                                    accumulated_tool.append(f"\n⚠️ **Error** [{timestamp}]: {str(e)}\n")
-                                
-                                # Immediate real-time UI update for error cases
-                                with tool_placeholder.expander("🔧 Tool Call Information", expanded=True):
-                                    st.markdown("".join(accumulated_tool))
+                                    accumulated_tool.append(f"\n📝 **Info**: {line.strip()}\n")
                         elif line.startswith('ping - '):
                             # Handle ping messages directly
                             timestamp = line.split('ping - ')[-1]
@@ -682,29 +630,8 @@ def get_streaming_callback(text_placeholder, tool_placeholder):
                             with tool_placeholder.expander("🔧 Tool Call Information", expanded=True):
                                 st.markdown("".join(accumulated_tool))
                         elif line and not line.startswith(':'):
-                            # Other non-empty lines - capture any other data patterns
-                            import time
-                            timestamp = time.strftime("%H:%M:%S")
-                            
-                            # Check if this line contains any meaningful data
-                            if line.strip() and len(line.strip()) > 1:
-                                # Try to detect if it's JSON-like content
-                                if line.strip().startswith('{') or line.strip().startswith('['):
-                                    try:
-                                        # Try to parse as JSON for better formatting
-                                        import json
-                                        parsed_json = json.loads(line.strip())
-                                        accumulated_tool.append(f"\n📡 **JSON Data** [{timestamp}]:\n```json\n{json.dumps(parsed_json, indent=2)}\n```\n")
-                                    except:
-                                        # If not valid JSON, show as regular data
-                                        accumulated_tool.append(f"\n📡 **Data** [{timestamp}]: {line.strip()}\n")
-                                else:
-                                    # Regular text data
-                                    accumulated_tool.append(f"\n📝 **Info** [{timestamp}]: {line.strip()}\n")
-                                
-                                # Immediate real-time UI update for any captured data
-                                with tool_placeholder.expander("🔧 Tool Call Information", expanded=True):
-                                    st.markdown("".join(accumulated_tool))
+                            # Other non-empty lines
+                            accumulated_tool.append(f"\n📝 **Info**: {line.strip()}\n")
                 else:
                     # Regular tool response content
                     accumulated_tool.append(

config.json

@@ -8,7 +8,7 @@
   },
   "qa": {
     "transport": "sse",
-    "url": "http://10.15.56.148:8000/qa"
+    "url": "http://10.15.56.148:9230/sse"
   },
   "review_generate": {
     "transport": "sse",

runtime.txt

@@ -0,0 +1 @@
+python: 3.12