Update response_formatter.py

response_formatter.py

@@ -1,158 +1,127 @@
-from typing import Dict, Optional, Tuple, List, Any, Set
-import re
-import xml.etree.ElementTree as ET
-from datetime import datetime
-import json
-import logging
+export class LogicController {
+    constructor() {
+        this.storage = {
+            xmlBuffer: '',
+            isFirstMessage: true,
+            toolOutputs: new Map()
+        };
+        
+        this.eventDispatcher = new EventTarget();
+    }
 
-# Setup logger
-logger = logging.getLogger(__name__)
-logger.setLevel(logging.INFO)
+    processStreamData(chunk) {
+        try {
+            const rawData = chunk.data || chunk;
+            console.log('Raw chunk received:', rawData);
 
-# Create console handler if needed
-if not logger.handlers:
-    ch = logging.StreamHandler()
-    ch.setLevel(logging.INFO)
-    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
-    ch.setFormatter(formatter)
-    logger.addHandler(ch)
+            if (typeof rawData === 'string' && rawData.includes('<agent_response>')) {
+                this.storage.xmlBuffer += rawData;
+                
+                // Process complete messages
+                while (this.storage.xmlBuffer.includes('<agent_response>')) {
+                    const startTag = '<agent_response>';
+                    const endTag = '</agent_response>';
+                    
+                    const startIndex = this.storage.xmlBuffer.indexOf(startTag);
+                    const endIndex = this.storage.xmlBuffer.indexOf(endTag);
+                    
+                    if (startIndex === -1 || endIndex === -1) break;
 
-class StreamingFormatter:
-    def __init__(self):
-        self.processed_events = set()
-        self.current_tool_outputs = []
-        self.current_citations = []
-        self.current_metadata = {}
-        self.current_message_id = None
-        self.current_message_buffer = ""
+                    // Extract complete message
+                    const completeMessage = this.storage.xmlBuffer.slice(
+                        startIndex,
+                        endIndex + endTag.length
+                    );
 
-    def reset(self):
-        """Reset the formatter state"""
-        self.processed_events.clear()
-        self.current_tool_outputs.clear()
-        self.current_citations.clear()
-        self.current_metadata.clear()
-        self.current_message_id = None
-        self.current_message_buffer = ""
+                    // Process message content
+                    this.processMessage(completeMessage);
 
-    def append_to_buffer(self, text: str):
-        """Append text to the current message buffer"""
-        self.current_message_buffer += text
+                    // Remove processed message
+                    this.storage.xmlBuffer = this.storage.xmlBuffer.slice(
+                        endIndex + endTag.length
+                    );
+                }
+            }
+        } catch (error) {
+            console.error('Error processing stream data:', error);
+        }
+    }
 
-    def get_and_clear_buffer(self) -> str:
-        """Get the current buffer content and clear it"""
-        content = self.current_message_buffer
-        self.current_message_buffer = ""
-        return content
+    processMessage(xmlMessage) {
+        try {
+            // Parse message content
+            const messageMatch = xmlMessage.match(/<message>(.*?)<\/message>/s);
+            const thoughtMatch = xmlMessage.match(/<thought>(.*?)<\/thought>/s);
+            const toolOutputsMatch = xmlMessage.match(/<tool_outputs>(.*?)<\/tool_outputs>/s);
+            
+            // Handle regular message
+            if (messageMatch?.[1]) {
+                this.dispatchUpdate('chatwindow', {
+                    message: messageMatch[1].trim(),
+                    replace: false,
+                    format: true
+                });
+            }
 
-class ToolType:
-    DUCKDUCKGO = "duckduckgo_search"
-    REDDIT_NEWS = "reddit_x_gnews_newswire_crunchbase"
-    PUBMED = "pubmed_search"
-    CENSUS = "get_census_data"
-    HEATMAP = "heatmap_code"
-    MERMAID = "mermaid_diagram"
-    WISQARS = "wisqars"
-    WONDER = "wonder"
-    NCHS = "nchs"
-    ONESTEP = "onestep"
-    DQS = "dqs_nhis_adult_summary_health_statistics"
+            // Handle thought content
+            if (thoughtMatch?.[1]) {
+                this.dispatchUpdate('chatwindow', {
+                    message: thoughtMatch[1].trim(),
+                    replace: false,
+                    format: true,
+                    isThought: true
+                });
+            }
 
-class ResponseFormatter:
-    _instance = None
-    
-    def __new__(cls):
-        if cls._instance is None:
-            cls._instance = super(ResponseFormatter, cls).__new__(cls)
-            cls._instance.streaming_state = StreamingFormatter()
-            cls._instance.logger = logger
-        return cls._instance
+            // Handle tool outputs
+            if (toolOutputsMatch?.[1]) {
+                this.processToolOutputs(toolOutputsMatch[1]);
+            }
 
-    def format_thought(
-        self,
-        thought: str,
-        observation: str,
-        tool_outputs: List[Dict] = None,
-        event_id: str = None,
-        message_id: str = None
-    ) -> Optional[Tuple[str, str]]:
-        """Format thought and tool outputs as XML"""
-        root = ET.Element("agent_response")
-        
-        if thought:
-            thought_elem = ET.SubElement(root, "thought")
-            thought_elem.text = thought
-            
-        if observation:
-            obs_elem = ET.SubElement(root, "observation")
-            obs_elem.text = observation
-            
-        if tool_outputs:
-            tools_elem = ET.SubElement(root, "tool_outputs")
-            for output in tool_outputs:
-                tool_elem = ET.SubElement(tools_elem, "tool_output")
-                tool_elem.attrib["type"] = output.get("type", "")
-                tool_elem.text = output.get("content", "")
-        
-        xml_output = ET.tostring(root, encoding='unicode')
-        return thought, xml_output
+        } catch (error) {
+            console.error('Error processing message:', error);
+        }
+    }
 
-    def format_message(
-        self,
-        message: str,
-        event_id: str = None,
-        message_id: str = None
-    ) -> Optional[Tuple[str, str]]:
-        """Format message as XML for frontend"""
-        if not message:
-            return None
-            
-        root = ET.Element("agent_response")
-        msg_elem = ET.SubElement(root, "message")
-        msg_elem.text = message
-        
-        xml_output = ET.tostring(root, encoding='unicode')
-        return message, xml_output
+    processToolOutputs(toolOutputsXml) {
+        try {
+            const parser = new DOMParser();
+            const doc = parser.parseFromString(toolOutputsXml, 'text/xml');
+            const outputs = doc.getElementsByTagName('tool_output');
 
-    def format_error(
-        self,
-        error: str,
-        event_id: str = None,
-        message_id: str = None
-    ) -> Optional[Tuple[str, str]]:
-        """Format error message for both terminal and XML output"""
-        # Skip if already processed
-        if event_id and event_id in self.streaming_state.processed_events:
-            return None
-            
-        # Handle message state
-        if message_id != self.streaming_state.current_message_id:
-            self.streaming_state.reset()
-            self.streaming_state.current_message_id = message_id
-            
-        # Skip empty errors
-        if not error:
-            return None
-            
-        # Terminal format
-        terminal_output = f"Error: {error}"
+            Array.from(outputs).forEach(output => {
+                const type = output.getAttribute('type');
+                const content = output.textContent;
 
-        # XML format
-        root = ET.Element("agent_response")
-        error_elem = ET.SubElement(root, "error")
-        error_elem.text = error
-        
-        xml_output = ET.tostring(root, encoding='unicode')
-        
-        # Track processed event
-        if event_id:
-            self.streaming_state.processed_events.add(event_id)
-        
-        return terminal_output, xml_output
+                // Store tool output
+                const outputId = `${type}-${Date.now()}`;
+                this.storage.toolOutputs.set(outputId, {
+                    type,
+                    content,
+                    timestamp: Date.now()
+                });
+
+                // Dispatch tool-specific update
+                this.dispatchUpdate('maincontent', {
+                    observationWidget: {
+                        id: outputId,
+                        type,
+                        tool: type,
+                        observation: content
+                    }
+                });
+            });
+
+        } catch (error) {
+            console.error('Error processing tool outputs:', error);
+        }
+    }
 
-    @staticmethod
-    def _clean_markdown(text: str) -> str:
-        """Clean markdown formatting from text"""
-        text = re.sub(r'```.*?```', '', text, flags=re.DOTALL)
-        text = re.sub(r'[*_`#]', '', text)
-        return re.sub(r'\n{3,}', '\n\n', text.strip())
+    dispatchUpdate(component, data) {
+        console.log('Dispatching update:', component, data);
+        const event = new CustomEvent('componentUpdate', {
+            detail: { component, data }
+        });
+        this.eventDispatcher.dispatchEvent(event);
+    }
+}