Upload folder using huggingface_hub

app.py

@@ -13,17 +13,16 @@ print("-----------------------------")
 # Ensure the multi_agent_system is in the Python path
 sys.path.append(os.getcwd())
 from multi_agent_system.orchestrator.agent import main_orchestration_workflow
-from multi_agent_system.monitor_agent.agent import monitor_session
 
-# --- Event 1: Streaming UI Updates (Pure Generator) ---
+# --- Streaming UI Updates ---
 def stream_orchestrator(msg, history, jules_key, hf_token, blablador_key):
     """
-    A "pure" generator that only handles streaming UI updates.
-    It returns the data needed for the background task.
+    A generator that handles streaming UI updates from the orchestrator workflow.
     """
     history.append([msg, ""])
-    yield history, None # Yield initial history, monitor_data is None for now
+    yield history
 
+    # Set API keys from UI or environment variables
     api_keys = {
         "JULES_API_KEY": os.environ.get("JULES_API_KEY", jules_key),
         "HF_TOKEN": os.environ.get("HF_TOKEN", hf_token),
@@ -32,54 +31,24 @@ def stream_orchestrator(msg, history, jules_key, hf_token, blablador_key):
     for key, value in api_keys.items():
         if not value:
             history[-1][1] = f"Error: {key} is not set. Please provide it as a Space secret or in the UI."
-            yield history, None
+            yield history
             return
         os.environ[key] = value
 
     workflow_generator = main_orchestration_workflow()
-    monitor_data = None
     final_bot_message = ""
 
-    try:
-        while True:
-            update = next(workflow_generator)
-            final_bot_message += update
-            history[-1][1] = final_bot_message
-            yield history, None
-    except StopIteration as e:
-        monitor_data = e.value
+    # Stream updates from the workflow
+    for update in workflow_generator:
+        final_bot_message += update
+        history[-1][1] = final_bot_message
+        yield history
 
+    # Clean up environment variables
     for key in api_keys:
         if key in os.environ:
             del os.environ[key]
 
-    if monitor_data:
-        history[-1][1] = final_bot_message + "\n\n**Orchestration complete. Starting background monitoring...**"
-    else:
-        history[-1][1] = final_bot_message + "\n\n**Workflow finished with an error. Could not start monitor.**"
-
-    yield history, monitor_data
-
-
-# --- Event 2: Background Task (Triggered by .then()) ---
-def trigger_background_monitor(monitor_data):
-    """
-    Takes the data from the first event and spawns the monitor in a background thread.
-    This function does not interact with the Gradio UI.
-    """
-    if monitor_data:
-        print("--- Spawning Background Monitor Thread ---")
-        monitor_thread = threading.Thread(
-            target=monitor_session,
-            kwargs=monitor_data,
-            daemon=True
-        )
-        monitor_thread.start()
-        print("--- Background Monitor Thread Started ---")
-    else:
-        print("--- No monitor data provided; skipping background task. ---")
-    # This function has no UI output, so it returns None implicitly.
-
 def disable_ui():
     return gr.Textbox(interactive=False), gr.Button(interactive=False)
 
@@ -91,9 +60,6 @@ with gr.Blocks(title="Desk Agent") as demo:
     gr.Markdown("# Desk Agent Orchestrator")
     gr.Markdown("A conversational interface to a multi-agent workflow system. Press 'Start Workflow' to begin.")
 
-    # Hidden gr.State component to pass data between events
-    monitor_data_state = gr.State()
-
     chatbot = gr.Chatbot(label="Agent Conversation", height=500)
     msg_input = gr.Textbox(label="Your Message", placeholder="Press 'Start Workflow' to begin...")
 
@@ -106,17 +72,13 @@ with gr.Blocks(title="Desk Agent") as demo:
     start_button = gr.Button("Start Workflow", variant="primary")
     clear_button = gr.ClearButton([msg_input, chatbot])
 
-    # --- Chained Event Handling (Pattern 1) ---
+    # --- Event Handling ---
     start_button.click(
         fn=disable_ui, outputs=[msg_input, start_button]
     ).then(
         fn=stream_orchestrator,
         inputs=[msg_input, chatbot, jules_key_input, hf_token_input, blablador_key_input],
-        outputs=[chatbot, monitor_data_state]
-    ).then(
-        fn=trigger_background_monitor,
-        inputs=[monitor_data_state],
-        outputs=[]
+        outputs=[chatbot]
     ).then(
         fn=enable_ui, outputs=[msg_input, start_button]
     )
@@ -126,15 +88,11 @@ with gr.Blocks(title="Desk Agent") as demo:
     ).then(
         fn=stream_orchestrator,
         inputs=[msg_input, chatbot, jules_key_input, hf_token_input, blablador_key_input],
-        outputs=[chatbot, monitor_data_state]
-    ).then(
-        fn=trigger_background_monitor,
-        inputs=[monitor_data_state],
-        outputs=[]
+        outputs=[chatbot]
     ).then(
         fn=enable_ui, outputs=[msg_input, start_button]
     )
 
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch(share=True)

multi_agent_system/jules_agent_client/stream_client.py

@@ -0,0 +1,57 @@
+import requests
+import json
+
+JULES_API_ENDPOINT = "https://jules.googleapis.com/v1alpha"
+
+class JulesAgentStream:
+    """A client for handling streaming communication with the Jules API."""
+
+    def __init__(self, api_key, session_id):
+        """
+        Initializes the stream client.
+
+        Args:
+            api_key (str): The Jules API key for authentication.
+            session_id (str): The ID of the session to stream.
+        """
+        self.api_key = api_key
+        self.session_id = session_id
+        self.url = f'{JULES_API_ENDPOINT}/sessions/{self.session_id}:stream'
+        self.headers = {
+            'X-Goog-Api-Key': self.api_key,
+            'Accept': 'text/event-stream'
+        }
+
+    def __iter__(self):
+        """
+        Yields events from the Jules API stream.
+        """
+        try:
+            with requests.get(self.url, headers=self.headers, stream=True, timeout=300) as response:
+                response.raise_for_status()
+                for line in response.iter_lines():
+                    if line:
+                        decoded_line = line.decode('utf-8')
+                        if decoded_line.startswith('data: '):
+                            try:
+                                yield json.loads(decoded_line[len('data: '):])
+                            except json.JSONDecodeError:
+                                # Yield raw data if JSON parsing fails
+                                yield {"error": "JSONDecodeError", "raw_data": decoded_line}
+        except requests.exceptions.RequestException as e:
+            yield {"error": f"RequestException: {str(e)}"}
+
+if __name__ == '__main__':
+    import os
+    # This is an example of how to use the stream client.
+    # You must set the JULES_API_KEY and a JULES_SESSION_ID environment variables.
+    jules_key = os.environ.get("JULES_API_KEY")
+    session_id = os.environ.get("JULES_SESSION_ID")
+
+    if not jules_key or not session_id:
+        print("Error: JULES_API_KEY and JULES_SESSION_ID environment variables must be set.")
+    else:
+        print(f"--- Starting to stream session: {session_id} ---")
+        stream_client = JulesAgentStream(api_key=jules_key, session_id=session_id)
+        for event in stream_client:
+            print(json.dumps(event, indent=2))

multi_agent_system/orchestrator/agent.py

@@ -6,7 +6,8 @@ import sys
 # Add sibling directories to the Python path
 sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
 
-from jules_agent_client.agent import create_session, list_sources, send_message_to_session
+from jules_agent_client.agent import create_session, list_sources
+from jules_agent_client.stream_client import JulesAgentStream
 from llm_client import get_llm_response_stream
 
 # Constants
@@ -47,8 +48,7 @@ def generate_conversational_update(action_description):
 
 def main_orchestration_workflow():
     """
-    A generator function that executes the main workflow, yields conversational updates,
-    and returns the necessary data to start the monitor.
+    A generator function that executes the main workflow and yields conversational updates.
     """
     yield generate_conversational_update("Starting the orchestration workflow and checking for API keys.")
 
@@ -115,18 +115,20 @@ def main_orchestration_workflow():
     session_id = session_info['name'].split('/')[-1]
     yield generate_conversational_update(f"Success! The coding session with Jules is active (ID: {session_id}).")
 
-    # Step 3: Prepare for monitoring
-    hf_repo_to_monitor = plan_data.get("hf_repo")
-    if not hf_repo_to_monitor:
-        yield "The developer's plan was missing the Hugging Face repository to monitor."
-        return None
+    yield generate_conversational_update(f"I'm now streaming live updates from the Jules session...")
 
-    yield generate_conversational_update(f"I'm now handing off to the Monitor Agent to watch the deployment at '{hf_repo_to_monitor}'.")
+    # Step 3: Stream Jules' activities
+    stream_client = JulesAgentStream(api_key=jules_api_key, session_id=session_id)
+    for event in stream_client:
+        # Here you can parse the event and format it into a user-friendly message
+        # For now, we'll just yield the raw event as a string.
+        # A more sophisticated implementation would parse the event type and content.
+        yield f"\n\n**Jules Update:**\n```json\n{json.dumps(event, indent=2)}\n```"
 
-    # Return the necessary data for the monitor to be started in a separate thread
-    return {
-        "session_id": session_id,
-        "hf_repo_id": hf_repo_to_monitor,
-        "jules_api_key": jules_api_key,
-        "hf_token": hf_token
-    }
+    # The workflow concludes after the stream ends.
+    # We can still use the hf_repo for a final message.
+    hf_repo_to_monitor = plan_data.get("hf_repo")
+    if hf_repo_to_monitor:
+        yield f"\n\n**Workflow complete.** You can check the final deployment at '{hf_repo_to_monitor}'."
+    else:
+        yield "\n\n**Workflow complete.**"

requirements.txt

@@ -1,4 +1,5 @@
-gradio
+gradio==4.19.0
+gradio_client==0.10.0
 huggingface-hub==0.21.4
 requests
 openai