Release v0.0.2: ClaudeAgent, Genesis Docker, Logging, and Direct Movement Velocity Support Updates

# Release v0.0.2: ClaudeAgent, Genesis Docker, Logging, and Direct Movement Velocity Support Updates

### Version Updates
- pyproject.toml: 0.0.1 -> 0.0.2

### ClaudeAgent
- Implemented Claude Agent with input query streaming and system query support. Image support WIP.
- Added skills/tool calling capabilities with thinking model integration
- Introduced `run_observable_query()` helper method in base LLMAgent
- Enhanced web interface integration for input queries
- Improved handling of Pydantic generic classes in observable query
- Streamlined text streaming for Agents using FastAPIServer
- Fixed system query handling and initialization

### Robot Control & Skills Framework
- Re-implemented direct movement velocity controls in ROSControl
- Added new Robot skill for `move_vel()` functionality

### Logging & Infrastructure
- Standardized logging system with `DIMOS_LOG_LEVEL` environment variable
- Fixed debug message handling and logger configuration
- Cleaned up terminal output and removed redundant logging
- Added standardized test file headers

### Docker & Simulation
- Added support for Genesis simulator alongside Isaac
- Created separate folders for simulation docker files
- Updated Docker configurations for both simulators
- Changed web server interface address from localhost to 0.0.0.0

Former-commit-id: fc601ac

Author: spomichter

default.env

@@ -1,4 +1,5 @@
 OPENAI_API_KEY=
+ANTHROPIC_API_KEY=
 ROBOT_IP=
 CONN_TYPE=webrtc
 WEBRTC_SERVER_HOST=0.0.0.0

dimos/agents/agent.py

@@ -58,7 +58,7 @@
 load_dotenv()
 
 # Initialize logger for the agent module
-logger = setup_logger("dimos.agents", level=logging.DEBUG)
+logger = setup_logger("dimos.agents")
 
 # Constants
 _TOKEN_BUDGET_PARTS = 4  # Number of parts to divide token budget
@@ -91,15 +91,13 @@ def __init__(self,
         self.agent_memory = agent_memory or AgentSemanticMemory()
         self.disposables = CompositeDisposable()
         self.pool_scheduler = pool_scheduler if pool_scheduler else get_scheduler()
-        self.logger = setup_logger(
-            f"dimos.agents.{self.agent_type}.{self.dev_name}")
 
     def dispose_all(self):
         """Disposes of all active subscriptions managed by this agent."""
         if self.disposables:
             self.disposables.dispose()
         else:
-            self.logger.info("No disposables to dispose.")
+            logger.info("No disposables to dispose.")
 
 
 # endregion Agent Base Class
@@ -207,8 +205,8 @@ def _get_rag_context(self) -> Tuple[str, str]:
             for (doc, score) in results)
         condensed_results = " | ".join(
             f"{doc.page_content}" for (doc, _) in results)
-        self.logger.info(f"Agent Memory Query Results:\n{formatted_results}")
-        self.logger.info("=== Results End ===")
+        logger.info(f"Agent Memory Query Results:\n{formatted_results}")
+        logger.info("=== Results End ===")
         return formatted_results, condensed_results
 
     def _build_prompt(self, base64_image: Optional[str],
@@ -284,21 +282,21 @@ def _tooling_callback(message, messages, response_message,
                 name = tool_call.function.name
                 args = json.loads(tool_call.function.arguments)
                 result = skills.call_function(name, **args)
-                self.logger.info(f"Function Call Results: {result}")
+                logger.info(f"Function Call Results: {result}")
                 new_messages.append({
                     "role": "tool",
                     "tool_call_id": tool_call.id,
                     "content": str(result),
                     "name": name
                 })
             if has_called_tools:
-                self.logger.info("Sending Another Query.")
+                logger.info("Sending Another Query.")
                 messages.append(response_message)
                 messages.extend(new_messages)
                 # Delegate to sending the query again.
                 return self._send_query(messages)
             else:
-                self.logger.info("No Need for Another Query.")
+                logger.info("No Need for Another Query.")
                 return None
 
         if response_message.tool_calls is not None:
@@ -330,10 +328,10 @@ def _observable_query(self,
             messages = self._build_prompt(base64_image, dimensions,
                                           override_token_limit,
                                           condensed_results)
-            # self.logger.debug(f"Sending Query: {messages}")
-            self.logger.info("Sending Query.")
+            # logger.debug(f"Sending Query: {messages}")
+            logger.info("Sending Query.")
             response_message = self._send_query(messages)
-            self.logger.info(f"Received Response: {response_message}")
+            logger.info(f"Received Response: {response_message}")
             if response_message is None:
                 raise Exception("Response message does not exist.")
 
@@ -358,7 +356,7 @@ def _observable_query(self,
                 self.response_subject.on_next(final_msg)
             observer.on_completed()
         except Exception as e:
-            self.logger.error(f"Query failed in {self.dev_name}: {e}")
+            logger.error(f"Query failed in {self.dev_name}: {e}")
             observer.on_error(e)
             self.response_subject.on_error(e)
 
@@ -393,7 +391,7 @@ def _log_response_to_file(self, response, output_dir: str = None):
                 log_path = os.path.join(output_dir, 'memory.txt')
                 with open(log_path, 'a') as file:
                     file.write(f"{self.dev_name}: {response}\n")
-                self.logger.info(f"LLM Response [{self.dev_name}]: {response}")
+                logger.info(f"LLM Response [{self.dev_name}]: {response}")
 
     def subscribe_to_image_processing(
             self, frame_observable: Observable) -> Disposable:
@@ -487,8 +485,8 @@ def process_if_free(frame):
         disposable = observable.subscribe(
             on_next=lambda response: self._log_response_to_file(
                 response, self.output_dir),
-            on_error=lambda e: self.logger.error(f"Error encountered: {e}"),
-            on_completed=lambda: self.logger.info(
+            on_error=lambda e: logger.error(f"Error encountered: {e}"),
+            on_completed=lambda: logger.info(
                 f"Stream processing completed for {self.dev_name}"))
         self.disposables.add(disposable)
         return disposable
@@ -529,13 +527,13 @@ def _process_query(query) -> Observable:
         is_processing = [False]
 
         def process_if_free(query):
-            self.logger.info(f"Processing Query: {query}")
+            logger.info(f"Processing Query: {query}")
             if not self.process_all_inputs and is_processing[0]:
                 # Drop query if a request is already in progress and process_all_inputs is False
                 return empty()
             else:
                 is_processing[0] = True
-                self.logger.info("Processing Query.")
+                logger.info("Processing Query.")
                 return _process_query(query).pipe(
                     MyOps.print_emission(id='B', **print_emission_args),
                     RxOps.observe_on(self.pool_scheduler),
@@ -557,9 +555,9 @@ def process_if_free(query):
         disposable = observable.subscribe(
             on_next=lambda response: self._log_response_to_file(
                 response, self.output_dir),
-            on_error=lambda e: self.logger.error(
+            on_error=lambda e: logger.error(
                 f"Error processing query for {self.dev_name}: {e}"),
-            on_completed=lambda: self.logger.info(
+            on_completed=lambda: logger.info(
                 f"Stream processing completed for {self.dev_name}"))
         self.disposables.add(disposable)
         return disposable
@@ -575,6 +573,22 @@ def get_response_observable(self) -> Observable:
             RxOps.subscribe_on(self.pool_scheduler),
             RxOps.share())
 
+    def run_observable_query(self, query_text: str) -> Observable:
+        """Creates an observable that processes a one-off text query to Agent and emits the response.
+        
+        This method provides a simple way to send a text query and get an observable
+        stream of the response. It's designed for one-off queries rather than
+        continuous processing of input streams. Useful for testing and development.
+        
+        Args:
+            query_text (str): The query text to process.
+            
+        Returns:
+            Observable: An observable that emits the response as a string.
+        """
+        return create(lambda observer, _: self._observable_query(
+            observer, incoming_query=query_text)) 
+
     def dispose_all(self):
         """Disposes of all active subscriptions managed by this agent."""
         super().dispose_all()
@@ -697,15 +711,15 @@ def __init__(self,
             )
 
         if self.input_video_stream is not None:
-            self.logger.info("Subscribing to input video stream...")
+            logger.info("Subscribing to input video stream...")
             self.disposables.add(
                 self.subscribe_to_image_processing(self.input_video_stream))
         if self.input_query_stream is not None:
-            self.logger.info("Subscribing to input query stream...")
+            logger.info("Subscribing to input query stream...")
             self.disposables.add(
                 self.subscribe_to_query_processing(self.input_query_stream))
 
-        self.logger.info("OpenAI Agent Initialized.")
+        logger.info("OpenAI Agent Initialized.")
 
     def _add_context_to_memory(self):
         """Adds initial context to the agent's memory."""
@@ -765,17 +779,17 @@ def _send_query(self, messages: list) -> Any:
 
             response_message = response.choices[0].message
             if response_message is None:
-                self.logger.error("Response message does not exist.")
+                logger.error("Response message does not exist.")
                 raise Exception("Response message does not exist.")
             return response_message
         except ConnectionError as ce:
-            self.logger.error(f"Connection error with API: {ce}")
+            logger.error(f"Connection error with API: {ce}")
             raise
         except ValueError as ve:
-            self.logger.error(f"Invalid parameters: {ve}")
+            logger.error(f"Invalid parameters: {ve}")
             raise
         except Exception as e:
-            self.logger.error(f"Unexpected error in API call: {e}")
+            logger.error(f"Unexpected error in API call: {e}")
             raise
 
     def stream_query(self, query_text: str) -> Observable:
@@ -795,4 +809,4 @@ def stream_query(self, query_text: str) -> Observable:
             observer, incoming_query=query_text))
 
 
-# endregion OpenAIAgent Subclass (OpenAI-Specific Implementation)
+# endregion OpenAIAgent Subclass (OpenAI-Specific Implementation)