Update app.py

app.py

@@ -7,48 +7,12 @@ import queue
 import threading
 import os
 
-analysis_text = """
-Stage 1: Ground-Based Spin-Up and Launch Initiation
-• Concept:
-A large, energy‑efficient, electrically powered centrifuge is built on the ground. This “spin launcher” uses renewable energy (for example, solar‐assisted electricity) to accelerate a specially designed payload assembly along a rotating arm or in a long circular tunnel.
-• Benefits:
-Because most of the kinetic energy is imparted mechanically (rather than via chemical propellant), the system drastically reduces the need for traditional, polluting rocket propellants. This stage is also relatively low‑cost because the “engine” is essentially an electromagnetic drive rather than a rocket motor.
-Stage 2: Controlled Payload Release and Orbital Injection
-• Concept:
-At a pre‑calculated high tangential velocity, the payload is released from the spin launcher. A very short, minimal‐burn liquid or electric thruster (if needed) “tunes” the trajectory so that the payload enters a stable, low‑Earth orbit.
-• Benefits:
-The primary acceleration is mechanical, so only a tiny amount of propellant is required for orbital insertion. This greatly cuts both cost and the environmental impact typically associated with rocket launches.
-Stage 3: Autonomous On-Orbit Stabilization and Despinning
-• Concept:
-Once in orbit, the payload’s onboard guidance and control systems (such as small reaction control thrusters or a yo-yo de-spin mechanism) despin and stabilize the payload. Integrated sensors and attitude-control software adjust the payload’s orientation and gently circularize the orbit.
-• Benefits:
-Autonomous stabilization minimizes additional propellant use and prepares the payload for a safe, predictable rendezvous. The controlled despinning ensures that the payload’s docking adapter remains in the proper orientation for subsequent attachment.
-Stage 4: Rendezvous and Docking with the Manned Vehicle
-• Concept:
-A separately launched or pre‑positioned manned spacecraft (or space station) maneuvers to intercept the payload. The payload is equipped with a dedicated docking adapter (for instance, a magnetic or mechanical latch system engineered for high-precision contact under low‑g conditions).
-• Benefits:
-This phase uses conventional low‑delta‑V maneuvers that are far less expensive than a full chemical orbital insertion burn. The docking system is designed to absorb minor mismatches in velocity or attitude, allowing the crew to safely “hook on” to the payload. This minimizes extra propellant usage during the rendezvous phase.
-Stage 5: Integrated Mission Operations and Continued Space Activity
-• Concept:
-Once docked, the combined system—the manned vehicle with the attached spin-delivered payload—continues its mission. The payload might provide additional resources (such as extra fuel, scientific instruments, or habitat modules) that augment the manned vehicle’s capabilities.
-• Benefits:
-With the payload permanently attached, mission operations (such as orbital adjustments, inter-station transfers, or even on-orbit assembly of larger structures) proceed with enhanced capabilities. The system’s reliance on mechanical acceleration for the bulk of the launch cut both launch costs and the environmental footprint, leaving only minor orbital maneuvers to be performed with conventional thrusters.
-Summary
-This five-stage system marries a ground-based spin acceleration concept with in-space docking and integration to achieve a “propellant-light” method for delivering payloads into orbit. By using a spin launcher to achieve high velocity on the ground (Stage 1) and minimizing onboard chemical propellant (Stage 2), the payload is inserted into orbit economically and with reduced environmental impact. On-orbit stabilization (Stage 3) prepares it for rendezvous with a manned vehicle (Stage 4), after which the combined system carries out the mission (Stage 5).
-"""
-
-summary_txt = """
-Summary
-This five-stage system marries a ground-based spin acceleration concept with in-space docking and integration to achieve a “propellant-light” method for delivering payloads into orbit. By using a spin launcher to achieve high velocity on the ground (Stage 1) and minimizing onboard chemical propellant (Stage 2), the payload is inserted into orbit economically and with reduced environmental impact. On-orbit stabilization (Stage 3) prepares it for rendezvous with a manned vehicle (Stage 4), after which the combined system carries out the mission (Stage 5).
-"""
-
 class AgentMessageQueue:
     def __init__(self):
         self.message_queue = queue.Queue()
         self.last_agent = None
 
     def add_message(self, message: Dict):
-        print(f"Adding message to queue: {message}")  # Debug print
         self.message_queue.put(message)
 
     def get_messages(self) -> List[Dict]:
@@ -57,15 +21,15 @@ class AgentMessageQueue:
             messages.append(self.message_queue.get())
         return messages
 
-class ArticleCrew:
+class SpaceSystemCrew:
     def __init__(self, api_key: str = None):
         self.api_key = api_key
         self.message_queue = AgentMessageQueue()
-        self.planner = None
-        self.writer = None
-        self.editor = None
+        self.system_architect = None
+        self.mechanical_engineer = None
+        self.aerospace_manager = None
         self.current_agent = None
-        self.final_article = None
+        self.final_design = None
 
     def initialize_agents(self, topic: str):
         if not self.api_key:
@@ -74,185 +38,87 @@ class ArticleCrew:
         os.environ["OPENAI_API_KEY"] = self.api_key
         llm = ChatOpenAI(temperature=0.7, model="gpt-4")
 
-        self.planner = Agent(
-            role="Content Planner",
-            goal=f"Plan engaging and factually accurate content on {topic}",
-            backstory="Expert content planner with focus on creating engaging outlines",
+        self.system_architect = Agent(
+            role="System Architect",
+            goal=f"Design the architecture of the {topic} space system",
+            backstory="Expert in space system design, integrating mechanical and propulsion components into a cohesive system",
             allow_delegation=False,
             verbose=True,
             llm=llm
         )
 
-        self.writer = Agent(
-            role="Content Writer",
-            goal=f"Write insightful and factually accurate piece about {topic}",
-            backstory="Expert content writer with focus on engaging articles",
+        self.mechanical_engineer = Agent(
+            role="Mechanical Engineer",
+            goal=f"Develop structural and propulsion mechanisms for {topic}",
+            backstory="Specialist in high-velocity launch systems and orbital stabilization",
             allow_delegation=False,
             verbose=True,
             llm=llm
         )
 
-        self.editor = Agent(
-            role="Editor",
-            goal="Polish and refine the article",
-            backstory="Expert editor with eye for detail and clarity",
+        self.aerospace_manager = Agent(
+            role="Aerospace Mission Manager",
+            goal=f"Ensure mission feasibility, safety, and execution for {topic}",
+            backstory="Oversees project feasibility, mission planning, and ensures integration with existing aerospace infrastructure",
             allow_delegation=False,
             verbose=True,
             llm=llm
         )
 
     def create_tasks(self, topic: str) -> List[Task]:
-        planner_task = Task(
-            description=f"""Create a detailed content plan for an article about {topic} by:
-1. Prioritizing the latest trends, key players, and noteworthy news
-2. Identifying the target audience, considering their interests and pain points
-3. Developing a detailed content outline including introduction, key points, and call to action
-4. Including SEO keywords and relevant data or sources""",
-            expected_output="A comprehensive content plan with outline, keywords, and target audience analysis",
-            agent=self.planner
+        architect_task = Task(
+            description=f"""Develop the complete architecture for the {topic} space system, including:
+            1. High-level design of the five-stage system
+            2. Identification of key components and subsystems
+            3. Integration with existing space infrastructure
+            4. Energy efficiency and sustainability considerations""",
+            expected_output="A comprehensive space system architecture plan",
+            agent=self.system_architect
         )
 
-        writer_task = Task(
-            description="""Based on the provided content plan:
-1. Use the content plan to craft a compelling blog post
-2. Incorporate SEO keywords naturally
-3. Ensure sections/subtitles are properly named in an engaging manner
-4. Create proper structure with introduction, body, and conclusion
-5. Proofread for grammatical errors""",
-            expected_output="A well-written article draft following the content plan",
-            agent=self.writer
+        mechanical_task = Task(
+            description="""Design the structural and propulsion aspects of the space system, including:
+            1. Engineering specifications for the spin-launcher mechanism
+            2. Payload stabilization and orbital insertion strategies
+            3. Material selection and thermal considerations
+            4. Fuel efficiency and mechanical reliability""",
+            expected_output="Detailed propulsion and structural design specifications",
+            agent=self.mechanical_engineer
         )
 
-        editor_task = Task(
-            description="""Review the written article by:
-1. Checking for clarity and coherence
-2. Correcting any grammatical errors and typos
-3. Ensuring consistent tone and style
-4. Verifying proper formatting and structure""",
-            expected_output="A polished, final version of the article ready for publication",
-            agent=self.editor
+        aerospace_task = Task(
+            description="""Assess the feasibility and mission execution strategies, including:
+            1. Launch site selection and environmental impact assessment
+            2. Safety protocols and risk mitigation strategies
+            3. Crew and payload rendezvous procedures
+            4. Operational procedures for space missions post-docking""",
+            expected_output="A validated mission feasibility and execution plan",
+            agent=self.aerospace_manager
         )
 
-        return [planner_task, writer_task, editor_task]
-
-    async def process_article(self, topic: str) -> Generator[List[Dict], None, None]:
-        def add_agent_messages(agent_name: str, tasks: str, emoji: str = "🤖"):
-            # Add agent header
-            self.message_queue.add_message({
-                "role": "assistant",
-                "content": agent_name,
-                "metadata": {"title": f"{emoji} {agent_name}"}
-            })
-            
-            # Add task description
-            self.message_queue.add_message({
-                "role": "assistant",
-                "content": tasks,
-                "metadata": {"title": f"📋 Task for {agent_name}"}
-            })
-
-        def setup_next_agent(current_agent: str) -> None:
-            agent_sequence = {
-                "Content Planner": ("Content Writer", """1. Use the content plan to craft a compelling blog post
-2. Incorporate SEO keywords naturally
-3. Ensure sections/subtitles are properly named in an engaging manner
-4. Create proper structure with introduction, body, and conclusion
-5. Proofread for grammatical errors"""),
-                
-                "Content Writer": ("Editor", """1. Review the article for clarity and coherence
-2. Check for grammatical errors and typos
-3. Ensure consistent tone and style
-4. Verify proper formatting and structure""")
-            }
-
-            if current_agent in agent_sequence:
-                next_agent, tasks = agent_sequence[current_agent]
-                self.current_agent = next_agent
-                add_agent_messages(next_agent, tasks)
-
-
-        def task_callback(task_output) -> None:
-            print(f"Task callback received: {task_output}")  # Debug print
-            
-            # Extract content from raw output
-            raw_output = task_output.raw
-            if "## Final Answer:" in raw_output:
-                content = raw_output.split("## Final Answer:")[1].strip()
-            else:
-                content = raw_output.strip()
-            
-            # Handle the output based on current agent
-            if self.current_agent == "Editor":
-                # Don't show editor's output with metadata
-                # Instead, show completion message and final article
-                self.message_queue.add_message({
-                    "role": "assistant",
-                    "content": "Final article is ready!",
-                    "metadata": {"title": "📝 Final Article"}
-                })
-                
-                # Convert common markdown patterns to Gradio-compatible markdown
-                formatted_content = content
-                # Ensure proper spacing for headers
-                formatted_content = formatted_content.replace("\n#", "\n\n#")
-                # Ensure proper spacing for lists
-                formatted_content = formatted_content.replace("\n-", "\n\n-")
-                formatted_content = formatted_content.replace("\n*", "\n\n*")
-                formatted_content = formatted_content.replace("\n1.", "\n\n1.")
-                # Ensure proper spacing for paragraphs
-                formatted_content = formatted_content.replace("\n\n\n", "\n\n")
-                
-                # Add the final article content without metadata
-                self.message_queue.add_message({
-                    "role": "assistant",
-                    "content": formatted_content
-                })
-            else:
-                # For other agents, show their output with metadata
-                self.message_queue.add_message({
-                    "role": "assistant",
-                    "content": content,
-                    "metadata": {"title": f"✨ Output from {self.current_agent}"}
-                })
-                # Setup next agent
-                setup_next_agent(self.current_agent)
-
-        def step_callback(output: Any) -> None:
-            print(f"Step callback received: {output}")  # Debug print
-            # We'll only use step_callback for logging purposes now
-            pass
+        return [architect_task, mechanical_task, aerospace_task]
 
+    async def process_design(self, topic: str) -> Generator[List[Dict], None, None]:
         try:
             self.initialize_agents(topic)
-            self.current_agent = "Content Planner"
+            self.current_agent = "System Architect"
 
-            # Start process
             yield [{
                 "role": "assistant",
-                "content": "Starting work on your article...",
+                "content": "Starting work on your space system design...",
                 "metadata": {"title": "🚀 Process Started"}
             }]
 
-            # Initialize first agent
-            add_agent_messages("Content Planner", 
-                """1. Prioritize the latest trends, key players, and noteworthy news
-2. Identify the target audience, considering their interests and pain points
-3. Develop a detailed content outline including introduction, key points, and call to action
-4. Include SEO keywords and relevant data or sources""")
-
             crew = Crew(
-                agents=[self.planner, self.writer, self.editor],
+                agents=[self.system_architect, self.mechanical_engineer, self.aerospace_manager],
                 tasks=self.create_tasks(topic),
-                verbose=True,
-                step_callback=step_callback,
-                task_callback=task_callback
+                verbose=True
             )
 
             def run_crew():
                 try:
                     crew.kickoff()
                 except Exception as e:
-                    print(f"Error in crew execution: {str(e)}")  # Debug print
                     self.message_queue.add_message({
                         "role": "assistant",
                         "content": f"An error occurred: {str(e)}",
@@ -265,27 +131,22 @@ class ArticleCrew:
             while thread.is_alive() or not self.message_queue.message_queue.empty():
                 messages = self.message_queue.get_messages()
                 if messages:
-                    print(f"Yielding messages: {messages}")  # Debug print
                     yield messages
                 await asyncio.sleep(0.1)
-
         except Exception as e:
-            print(f"Error in process_article: {str(e)}")  # Debug print
             yield [{
                 "role": "assistant",
                 "content": f"An error occurred: {str(e)}",
                 "metadata": {"title": "❌ Error"}
             }]
 
-# [Rest of the code remains the same]
-
 
 def create_demo():
-    article_crew = None
+    space_crew = None
 
     with gr.Blocks(theme=gr.themes.Soft()) as demo:
-        gr.Markdown("# 📝 AI Article Writing Crew")
-        
+        gr.Markdown("# 🚀 AI Space System Design Crew")
+
         openai_api_key = gr.Textbox(
             label='OpenAI API Key',
             type='password',
@@ -294,26 +155,26 @@ def create_demo():
         )
 
         chatbot = gr.Chatbot(
-            label="Writing Process",
+            label="Design Process",
             height=700,
             type="messages",
             show_label=True,
             visible=False,
             avatar_images=(None, "https://avatars.githubusercontent.com/u/170677839?v=4"),
-            render_markdown=True  # Enable markdown rendering
+            render_markdown=True
         )
 
         with gr.Row(equal_height=True):
             topic = gr.Textbox(
-                label="Article Topic",
-                placeholder="Enter topic...",
+                label="Space System Name",
+                placeholder="Enter system name...",
                 scale=4,
                 visible=False
             )
-            btn = gr.Button("Write Article", variant="primary", scale=1, visible=False)
+            btn = gr.Button("Design System", variant="primary", scale=1, visible=False)
 
         async def process_input(topic, history, api_key):
-            nonlocal article_crew
+            nonlocal space_crew
             if not api_key:
                 history = history or []
                 history.append({
@@ -324,15 +185,15 @@ def create_demo():
                 yield history
                 return
 
-            if article_crew is None:
-                article_crew = ArticleCrew(api_key=api_key)
+            if space_crew is None:
+                space_crew = SpaceSystemCrew(api_key=api_key)
 
             history = history or []
-            history.append({"role": "user", "content": f"Write an article about: {topic}"})
+            history.append({"role": "user", "content": f"Design a space system for: {topic}"})
             yield history
 
             try:
-                async for messages in article_crew.process_article(topic):
+                async for messages in space_crew.process_design(topic):
                     history.extend(messages)
                     yield history
             except Exception as e:
@@ -343,21 +204,12 @@ def create_demo():
                 })
                 yield history
 
-        def show_interface():
-            return {
-                openai_api_key: gr.Textbox(visible=False),
-                chatbot: gr.Chatbot(visible=True),
-                topic: gr.Textbox(visible=True),
-                btn: gr.Button(visible=True)
-            }
-
-        openai_api_key.submit(show_interface, None, [openai_api_key, chatbot, topic, btn])
+        openai_api_key.submit(lambda: {openai_api_key: gr.Textbox(visible=False), chatbot: gr.Chatbot(visible=True), topic: gr.Textbox(visible=True), btn: gr.Button(visible=True)}, None, [openai_api_key, chatbot, topic, btn])
         btn.click(process_input, [topic, chatbot, openai_api_key], [chatbot])
-        topic.submit(process_input, [topic, chatbot, openai_api_key], [chatbot])
 
     return demo
 
 if __name__ == "__main__":
     demo = create_demo()
     demo.queue()
-    demo.launch(debug=True)
+    demo.launch(debug=True)