open-swarm 0.1.1745019858__tar.gz → 0.1.1745020084__tar.gz

{open_swarm-0.1.1745019858 → open_swarm-0.1.1745020084}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: open-swarm
-Version: 0.1.1745019858
+Version: 0.1.1745020084
 Summary: Open Swarm: Orchestrating AI Agent Swarms with Django
 Project-URL: Homepage, https://github.com/yourusername/open-swarm
 Project-URL: Documentation, https://github.com/yourusername/open-swarm/blob/main/README.md

{open_swarm-0.1.1745019858 → open_swarm-0.1.1745020084}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "open-swarm"
-version = "0.1.1745019858"
+version = "0.1.1745020084"
 description = "Open Swarm: Orchestrating AI Agent Swarms with Django"
 readme = "README.md"
 requires-python = ">=3.10"

{open_swarm-0.1.1745019858 → open_swarm-0.1.1745020084}/src/swarm/blueprints/chatbot/blueprint_chatbot.py

@@ -19,6 +19,12 @@ if not os.environ.get("SWARM_DEBUG"):
 else:
     logging.basicConfig(level=logging.DEBUG)
 
+# Set logging to WARNING by default unless SWARM_DEBUG=1
+if not os.environ.get("SWARM_DEBUG"):
+    logging.basicConfig(level=logging.WARNING)
+else:
+    logging.basicConfig(level=logging.DEBUG)
+
 # Ensure src is in path for BlueprintBase import
 project_root = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..'))
 src_path = os.path.join(project_root, 'src')
@@ -180,50 +186,47 @@ You are a helpful and friendly chatbot. Respond directly to the user's input in
         logger.debug("Chatbot agent created.")
         return chatbot_agent
 
-    def render_prompt(self, template_name: str, context: dict) -> str:
-        return f"User request: {context.get('user_request', '')}\nHistory: {context.get('history', '')}\nAvailable tools: {', '.join(context.get('available_tools', []))}"
-
     async def run(self, messages: List[Dict[str, Any]], **kwargs) -> Any:
         """Main execution entry point for the Chatbot blueprint."""
         logger.info("ChatbotBlueprint run method called.")
-        last_user_message = next((m['content'] for m in reversed(messages) if m['role'] == 'user'), None)
-        if not last_user_message:
-            yield {"messages": [{"role": "assistant", "content": "I need a user message to proceed."}]}
-            return
-        prompt_context = {
-            "user_request": last_user_message,
-            "history": messages[:-1],
-            "available_tools": ["chat"]
-        }
-        rendered_prompt = self.render_prompt("chatbot_prompt.j2", prompt_context)
-        yield {
-            "messages": [
-                {
-                    "role": "assistant",
-                    "content": f"[Chatbot LLM] Would respond to: {rendered_prompt}"
-                }
-            ]
-        }
-        return
+        instruction = messages[-1].get("content", "") if messages else ""
+        async for chunk in self._run_non_interactive(instruction, **kwargs):
+            yield chunk
+        logger.info("ChatbotBlueprint run method finished.")
+
+    async def _run_non_interactive(self, instruction: str, **kwargs) -> Any:
+        mcp_servers = kwargs.get("mcp_servers", [])
+        agent = self.create_starting_agent(mcp_servers=mcp_servers)
+        from agents import Runner
+        import os
+        model_name = os.getenv("LITELLM_MODEL") or os.getenv("DEFAULT_LLM") or "gpt-3.5-turbo"
+        try:
+            result = await Runner.run(agent, instruction)
+            yield {"messages": [{"role": "assistant", "content": getattr(result, 'final_output', str(result))}]}
+        except Exception as e:
+            logger.error(f"Error during non-interactive run: {e}", exc_info=True)
+            yield {"messages": [{"role": "assistant", "content": f"An error occurred: {e}"}]}
 
 # Standard Python entry point
 if __name__ == "__main__":
+    import sys
     import asyncio
-    import json
-    parser = argparse.ArgumentParser(description='Chatbot Blueprint Runner')
-    parser.add_argument('instruction', nargs=argparse.REMAINDER, help='Instruction for Chatbot to process (all args after -- are joined as the prompt)')
-    args = parser.parse_args()
-    instruction_args = args.instruction
-    if instruction_args and instruction_args[0] == '--':
-        instruction_args = instruction_args[1:]
-    instruction = ' '.join(instruction_args).strip() if instruction_args else None
-    if instruction:
-        blueprint = ChatbotBlueprint(blueprint_id="chatbot")
-        async def runner():
-            async for chunk in blueprint._run_non_interactive(instruction):
-                msg = chunk["messages"][0]["content"]
-                if not msg.startswith("An error occurred:"):
-                    print(msg)
-        asyncio.run(runner())
+    # --- AUTO-PYTHONPATH PATCH FOR AGENTS ---
+    import os
+    project_root = os.path.abspath(os.path.join(os.path.dirname(__file__), '../../../..'))
+    src_path = os.path.join(project_root, 'src')
+    if src_path not in sys.path:
+        sys.path.insert(0, src_path)
+    if '--instruction' in sys.argv:
+        instruction = sys.argv[sys.argv.index('--instruction') + 1]
     else:
         print("Interactive mode not supported in this script.")
+        sys.exit(1)
+
+    blueprint = ChatbotBlueprint(blueprint_id="chatbot")
+    async def runner():
+        async for chunk in blueprint._run_non_interactive(instruction):
+            msg = chunk["messages"][0]["content"]
+            if not msg.startswith("An error occurred:"):
+                print(msg)
+    asyncio.run(runner())

{open_swarm-0.1.1745019858 → open_swarm-0.1.1745020084}/src/swarm/blueprints/digitalbutlers/blueprint_digitalbutlers.py

@@ -123,16 +123,8 @@ SPINNER_STATES = ['Generating.', 'Generating..', 'Generating...', 'Running...']
 
 # --- Define the Blueprint ---
 class DigitalButlersBlueprint(BlueprintBase):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        class DummyLLM:
-            def chat_completion_stream(self, messages, **_):
-                class DummyStream:
-                    def __aiter__(self): return self
-                    async def __anext__(self):
-                        raise StopAsyncIteration
-                return DummyStream()
-        self.llm = DummyLLM()
+    def __init__(self, blueprint_id: str, config_path: Optional[Path] = None, **kwargs):
+        super().__init__(blueprint_id, config_path=config_path, **kwargs)
 
     """Blueprint for private web search and home automation using a team of digital butlers."""
     metadata: ClassVar[Dict[str, Any]] = {
@@ -258,97 +250,28 @@ class DigitalButlersBlueprint(BlueprintBase):
         logger.debug("Digital Butlers team created: Jeeves (Coordinator), Mycroft (Search), Gutenberg (Home).")
         return jeeves_agent # Jeeves is the entry point
 
-    def render_prompt(self, template_name: str, context: dict) -> str:
-        return f"User request: {context.get('user_request', '')}\nHistory: {context.get('history', '')}\nAvailable tools: {', '.join(context.get('available_tools', []))}"
-
-    async def _original_run(self, messages: list) -> object:
-        last_user_message = next((m['content'] for m in reversed(messages) if m['role'] == 'user'), None)
-        if not last_user_message:
-            yield {"messages": [{"role": "assistant", "content": "I need a user message to proceed."}]}
-            return
-        prompt_context = {
-            "user_request": last_user_message,
-            "history": messages[:-1],
-            "available_tools": ["digital_butler"]
-        }
-        rendered_prompt = self.render_prompt("digitalbutlers_prompt.j2", prompt_context)
-        yield {
-            "messages": [
-                {
-                    "role": "assistant",
-                    "content": f"[DigitalButlers LLM] Would respond to: {rendered_prompt}"
-                }
-            ]
-        }
-        return
-
-    async def run(self, messages):
-        last_result = None
-        async for result in self._original_run(messages):
-            last_result = result
-            yield result
-        if last_result is not None:
-            await self.reflect_and_learn(messages, last_result)
-
-    async def reflect_and_learn(self, messages, result):
-        log = {
-            'task': messages,
-            'result': result,
-            'reflection': 'Success' if self.success_criteria(result) else 'Needs improvement',
-            'alternatives': self.consider_alternatives(messages, result),
-            'swarm_lessons': self.query_swarm_knowledge(messages)
-        }
-        self.write_to_swarm_log(log)
-
-    def success_criteria(self, result):
-        if not result or (isinstance(result, dict) and 'error' in result):
-            return False
-        if isinstance(result, list) and result and 'error' in result[0].get('messages', [{}])[0].get('content', '').lower():
-            return False
-        return True
-
-    def consider_alternatives(self, messages, result):
-        alternatives = []
-        if not self.success_criteria(result):
-            alternatives.append('Delegate to a different butler.')
-            alternatives.append('Try a simpler or more robust plan.')
-        else:
-            alternatives.append('Parallelize tasks for efficiency.')
-        return alternatives
-
-    def query_swarm_knowledge(self, messages):
-        import json, os
-        path = os.path.join(os.path.dirname(__file__), '../../../swarm_knowledge.json')
-        if not os.path.exists(path):
-            return []
-        with open(path, 'r') as f:
-            knowledge = json.load(f)
-        task_str = json.dumps(messages)
-        return [entry for entry in knowledge if entry.get('task_str') == task_str]
-
-    def write_to_swarm_log(self, log):
-        import json, os, time
-        from filelock import FileLock, Timeout
-        path = os.path.join(os.path.dirname(__file__), '../../../swarm_log.json')
-        lock_path = path + '.lock'
-        log['task_str'] = json.dumps(log['task'])
-        for attempt in range(10):
-            try:
-                with FileLock(lock_path, timeout=5):
-                    if os.path.exists(path):
-                        with open(path, 'r') as f:
-                            try:
-                                logs = json.load(f)
-                            except json.JSONDecodeError:
-                                logs = []
-                    else:
-                        logs = []
-                    logs.append(log)
-                    with open(path, 'w') as f:
-                        json.dump(logs, f, indent=2)
-                break
-            except Timeout:
-                time.sleep(0.2 * (attempt + 1))
+    async def run(self, messages: List[Dict[str, Any]], **kwargs) -> Any:
+        """Main execution entry point for the DigitalButlers blueprint."""
+        logger.info("DigitalButlersBlueprint run method called.")
+        instruction = messages[-1].get("content", "") if messages else ""
+        async for chunk in self._run_non_interactive(instruction, **kwargs):
+            yield chunk
+        logger.info("DigitalButlersBlueprint run method finished.")
+
+    async def _run_non_interactive(self, instruction: str, **kwargs) -> Any:
+        logger.info(f"Running DigitalButlers non-interactively with instruction: '{instruction[:100]}...'")
+        mcp_servers = kwargs.get("mcp_servers", [])
+        agent = self.create_starting_agent(mcp_servers=mcp_servers)
+        # Use Runner.run as a classmethod for portability
+        from agents import Runner
+        import os
+        model_name = os.getenv("LITELLM_MODEL") or os.getenv("DEFAULT_LLM") or "gpt-3.5-turbo"
+        try:
+            for chunk in Runner.run(agent, instruction):
+                yield chunk
+        except Exception as e:
+            logger.error(f"Error during non-interactive run: {e}", exc_info=True)
+            yield {"messages": [{"role": "assistant", "content": f"An error occurred: {e}"}]}
 
 # Standard Python entry point
 if __name__ == "__main__":

{open_swarm-0.1.1745019858 → open_swarm-0.1.1745020084}/src/swarm/blueprints/divine_code/blueprint_divine_code.py

@@ -164,14 +164,6 @@ execute_shell_command_tool = PatchedFunctionTool(execute_shell_command, 'execute
 class DivineOpsBlueprint(BlueprintBase):
     def __init__(self, blueprint_id: str, config_path: Optional[Path] = None, **kwargs):
         super().__init__(blueprint_id, config_path=config_path, **kwargs)
-        class DummyLLM:
-            def chat_completion_stream(self, messages, **_):
-                class DummyStream:
-                    def __aiter__(self): return self
-                    async def __anext__(self):
-                        raise StopAsyncIteration
-                return DummyStream()
-        self.llm = DummyLLM()
         # Use serious style for DivineOps
         self.ux = BlueprintUX(style="serious")
 
@@ -289,39 +281,13 @@ class DivineOpsBlueprint(BlueprintBase):
         logger.debug("Divine Ops Team (Zeus & Pantheon) created successfully. Zeus is starting agent.")
         return zeus_agent
 
-    def render_prompt(self, template_name: str, context: dict) -> str:
-        return f"User request: {context.get('user_request', '')}\nHistory: {context.get('history', '')}\nAvailable tools: {', '.join(context.get('available_tools', []))}"
-
     async def run(self, messages: List[Dict[str, Any]], **kwargs) -> Any:
         """Main execution entry point for the DivineOps blueprint."""
         logger.info("DivineOpsBlueprint run method called.")
-        last_user_message = next((m['content'] for m in reversed(messages) if m['role'] == 'user'), None)
-        if not last_user_message:
-            yield {"messages": [{"role": "assistant", "content": self.ux.box("Error", "I need a user message to proceed.")}]}
-            return
-        prompt_context = {
-            "user_request": last_user_message,
-            "history": messages[:-1],
-            "available_tools": ["divine_code"]
-        }
-        rendered_prompt = self.render_prompt("divine_code_prompt.j2", prompt_context)
-        import asyncio
-        for i in range(4):
-            yield {"messages": [{"role": "assistant", "content": self.ux.box("DivineOps", self.ux.spinner(i), summary="Preparing to process", params=prompt_context["user_request"])}]}
-            await asyncio.sleep(0.2)
-        yield {"messages": [{"role": "assistant", "content": self.ux.box("DivineOps", self.ux.spinner(0, taking_long=True), summary="Still working", params=prompt_context["user_request"])}]}
-        # Simulate code vs semantic search distinction
-        code_results = ["def divine(): ...", "def ops(): ..."]
-        semantic_results = ["This function orchestrates SDLC.", "This function demonstrates self-healing."]
-        yield {"messages": [{"role": "assistant", "content": self.ux.box(
-            "DivineOps Results",
-            self.ux.code_vs_semantic("code", code_results) + "\n" + self.ux.code_vs_semantic("semantic", semantic_results),
-            summary=self.ux.summary("Analyzed codebase", 4, prompt_context["user_request"]),
-            result_count=4,
-            params=prompt_context["user_request"]
-        )}]}
-        logger.info("DivineOpsBlueprint run finished.")
-        return
+        instruction = messages[-1].get("content", "") if messages else ""
+        async for chunk in self._run_non_interactive(instruction, **kwargs):
+            yield chunk
+        logger.info("DivineOpsBlueprint run method finished.")
 
     async def _run_non_interactive(self, instruction: str, **kwargs) -> Any:
         logger.info(f"Running DivineOps non-interactively with instruction: '{instruction[:100]}...'")

{open_swarm-0.1.1745019858 → open_swarm-0.1.1745020084}/src/swarm/blueprints/family_ties/blueprint_family_ties.py

@@ -55,16 +55,8 @@ brian_instructions = (
 
 # --- Define the Blueprint ---
 class FamilyTiesBlueprint(BlueprintBase):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        class DummyLLM:
-            def chat_completion_stream(self, messages, **_):
-                class DummyStream:
-                    def __aiter__(self): return self
-                    async def __anext__(self):
-                        raise StopAsyncIteration
-                return DummyStream()
-        self.llm = DummyLLM()
+    def __init__(self, blueprint_id: str, config_path: Optional[Path] = None, **kwargs):
+        super().__init__(blueprint_id, config_path=config_path, **kwargs)
 
     """Manages WordPress content with a Peter/Brian agent team using the `server-wp-mcp` server."""
     metadata: ClassVar[Dict[str, Any]] = {
@@ -161,29 +153,13 @@ class FamilyTiesBlueprint(BlueprintBase):
         logger.debug("Agents created: PeterGrifton (Coordinator), BrianGrifton (WordPress Manager).")
         return peter_agent # Peter is the entry point
 
-    def render_prompt(self, template_name: str, context: dict) -> str:
-        return f"User request: {context.get('user_request', '')}\nHistory: {context.get('history', '')}\nAvailable tools: {', '.join(context.get('available_tools', []))}"
-
-    async def run(self, messages: list) -> object:
-        last_user_message = next((m['content'] for m in reversed(messages) if m['role'] == 'user'), None)
-        if not last_user_message:
-            yield {"messages": [{"role": "assistant", "content": "I need a user message to proceed."}]}
-            return
-        prompt_context = {
-            "user_request": last_user_message,
-            "history": messages[:-1],
-            "available_tools": ["family_ties"]
-        }
-        rendered_prompt = self.render_prompt("family_ties_prompt.j2", prompt_context)
-        yield {
-            "messages": [
-                {
-                    "role": "assistant",
-                    "content": f"[FamilyTies LLM] Would respond to: {rendered_prompt}"
-                }
-            ]
-        }
-        return
+    async def run(self, messages: List[Dict[str, Any]], **kwargs) -> Any:
+        """Main execution entry point for the FamilyTies blueprint."""
+        logger.info("FamilyTiesBlueprint run method called.")
+        instruction = messages[-1].get("content", "") if messages else ""
+        async for chunk in self._run_non_interactive(instruction, **kwargs):
+            yield chunk
+        logger.info("FamilyTiesBlueprint run method finished.")
 
     async def _run_non_interactive(self, instruction: str, **kwargs) -> Any:
         logger.info(f"Running FamilyTies non-interactively with instruction: '{instruction[:100]}...'")

{open_swarm-0.1.1745019858 → open_swarm-0.1.1745020084}/src/swarm/blueprints/omniplex/blueprint_omniplex.py

@@ -231,26 +231,26 @@ class OmniplexBlueprint(BlueprintBase):
         logger.info(f"Omniplex Coordinator created with tools for: {[t.name for t in team_tools]}")
         return coordinator_agent
 
-    async def run(self, messages: list) -> object:
-        last_user_message = next((m['content'] for m in reversed(messages) if m['role'] == 'user'), None)
-        if not last_user_message:
-            yield {"messages": [{"role": "assistant", "content": "I need a user message to proceed."}]}
-            return
-        prompt_context = {
-            "user_request": last_user_message,
-            "history": messages[:-1],
-            "available_tools": ["omniplex"]
-        }
-        rendered_prompt = self.render_prompt("omniplex_prompt.j2", prompt_context)
-        yield {
-            "messages": [
-                {
-                    "role": "assistant",
-                    "content": f"[Omniplex LLM] Would respond to: {rendered_prompt}"
-                }
-            ]
-        }
-        return
+    async def run(self, messages: List[Dict[str, Any]], **kwargs) -> Any:
+        """Main execution entry point for the Omniplex blueprint."""
+        logger.info("OmniplexBlueprint run method called.")
+        instruction = messages[-1].get("content", "") if messages else ""
+        async for chunk in self._run_non_interactive(instruction, **kwargs):
+            yield chunk
+        logger.info("OmniplexBlueprint run method finished.")
+
+    async def _run_non_interactive(self, instruction: str, **kwargs) -> Any:
+        logger.info(f"Running OmniplexBlueprint non-interactively with instruction: '{instruction[:100]}...'")
+        mcp_servers = kwargs.get("mcp_servers", [])
+        agent = self.create_starting_agent(mcp_servers=mcp_servers)
+        from agents import Runner
+        model_name = os.getenv("LITELLM_MODEL") or os.getenv("DEFAULT_LLM") or "gpt-3.5-turbo"
+        try:
+            for chunk in Runner.run(agent, instruction):
+                yield chunk
+        except Exception as e:
+            logger.error(f"Error during non-interactive run: {e}", exc_info=True)
+            yield {"messages": [{"role": "assistant", "content": f"An error occurred: {e}"}]}
 
 # Standard Python entry point
 if __name__ == "__main__":

{open_swarm-0.1.1745019858 → open_swarm-0.1.1745020084}/src/swarm/blueprints/rue_code/blueprint_rue_code.py

@@ -265,20 +265,6 @@ class RueCodeBlueprint(BlueprintBase):
             params=prompt_context["user_request"]
         )}]}
         logger.info("RueCodeBlueprint run finished.")
-        return
-
-    def create_starting_agent(self, mcp_servers):
-        read_file_tool = PatchedFunctionTool(read_file_fileops, 'read_file')
-        write_file_tool = PatchedFunctionTool(write_file_fileops, 'write_file')
-        list_files_tool = PatchedFunctionTool(list_files_fileops, 'list_files')
-        execute_shell_command_tool = PatchedFunctionTool(execute_shell_command_fileops, 'execute_shell_command')
-        rue_agent = self.make_agent(
-            name="RueCodeAgent",
-            instructions="You are RueCodeAgent. You can use fileops tools (read_file, write_file, list_files, execute_shell_command) for any file or shell tasks.",
-            tools=[read_file_tool, write_file_tool, list_files_tool, execute_shell_command_tool],
-            mcp_servers=mcp_servers
-        )
-        return rue_agent
 
 if __name__ == "__main__":
     import asyncio

{open_swarm-0.1.1745019858 → open_swarm-0.1.1745020084}/src/swarm/blueprints/suggestion/blueprint_suggestion.py

@@ -138,8 +138,11 @@ class SuggestionBlueprint(BlueprintBase):
         model_name = profile_data.get("model")
         if not model_name: raise ValueError(f"Missing 'model' in profile '{profile_name}'.")
         if provider != "openai": raise ValueError(f"Unsupported provider: {provider}")
+        # Remove redundant client instantiation; rely on framework-level default client
+        # All blueprints now use the default client set at framework init
         logger.debug(f"Instantiating OpenAIChatCompletionsModel(model='{model_name}') for '{profile_name}'.")
         try:
+            # Ensure the model selected supports structured output (most recent OpenAI do)
             model_instance = OpenAIChatCompletionsModel(model=model_name)
             self._model_instance_cache[profile_name] = model_instance
             return model_instance
@@ -168,97 +171,27 @@ class SuggestionBlueprint(BlueprintBase):
         logger.debug("SuggestionAgent created with output_type enforcement.")
         return suggestion_agent
 
-    def render_prompt(self, template_name: str, context: dict) -> str:
-        return f"User request: {context.get('user_request', '')}\nHistory: {context.get('history', '')}\nAvailable tools: {', '.join(context.get('available_tools', []))}"
-
-    async def _original_run(self, messages: list) -> object:
-        last_user_message = next((m['content'] for m in reversed(messages) if m['role'] == 'user'), None)
-        if not last_user_message:
-            yield {"messages": [{"role": "assistant", "content": "I need a user message to proceed."}]}
-            return
-        prompt_context = {
-            "user_request": last_user_message,
-            "history": messages[:-1],
-            "available_tools": ["suggest"]
-        }
-        rendered_prompt = self.render_prompt("suggestion_prompt.j2", prompt_context)
-        yield {
-            "messages": [
-                {
-                    "role": "assistant",
-                    "content": f"[Suggestion LLM] Would respond to: {rendered_prompt}"
-                }
-            ]
-        }
-        return
-
-    async def run(self, messages):
-        last_result = None
-        async for result in self._original_run(messages):
-            last_result = result
-            yield result
-        if last_result is not None:
-            await self.reflect_and_learn(messages, last_result)
-
-    async def reflect_and_learn(self, messages, result):
-        log = {
-            'task': messages,
-            'result': result,
-            'reflection': 'Success' if self.success_criteria(result) else 'Needs improvement',
-            'alternatives': self.consider_alternatives(messages, result),
-            'swarm_lessons': self.query_swarm_knowledge(messages)
-        }
-        self.write_to_swarm_log(log)
-
-    def success_criteria(self, result):
-        if not result or (isinstance(result, dict) and 'error' in result):
-            return False
-        if isinstance(result, list) and result and 'error' in result[0].get('messages', [{}])[0].get('content', '').lower():
-            return False
-        return True
-
-    def consider_alternatives(self, messages, result):
-        alternatives = []
-        if not self.success_criteria(result):
-            alternatives.append('Try a different suggestion agent.')
-            alternatives.append('Fallback to a simpler suggestion.')
-        else:
-            alternatives.append('Expand suggestions with more context.')
-        return alternatives
-
-    def query_swarm_knowledge(self, messages):
-        import json, os
-        path = os.path.join(os.path.dirname(__file__), '../../../swarm_knowledge.json')
-        if not os.path.exists(path):
-            return []
-        with open(path, 'r') as f:
-            knowledge = json.load(f)
-        task_str = json.dumps(messages)
-        return [entry for entry in knowledge if entry.get('task_str') == task_str]
-
-    def write_to_swarm_log(self, log):
-        import json, os, time
-        from filelock import FileLock, Timeout
-        path = os.path.join(os.path.dirname(__file__), '../../../swarm_log.json')
-        lock_path = path + '.lock'
-        log['task_str'] = json.dumps(log['task'])
-        for attempt in range(10):
-            try:
-                with FileLock(lock_path, timeout=5):
-                    if os.path.exists(path):
-                        with open(path, 'r') as f:
-                            try:
-                                logs = json.load(f)
-                            except json.JSONDecodeError:
-                                logs = []
-                    else:
-                        logs = []
-                    logs.append(log)
-                    with open(path, 'w') as f:
-                        json.dump(logs, f, indent=2)
-                break
-            except Timeout:
-                time.sleep(0.2 * (attempt + 1))
+    async def run(self, messages: List[Dict[str, Any]], **kwargs) -> Any:
+        """Main execution entry point for the Suggestion blueprint."""
+        logger.info("SuggestionBlueprint run method called.")
+        instruction = messages[-1].get("content", "") if messages else ""
+        async for chunk in self._run_non_interactive(instruction, **kwargs):
+            yield chunk
+        logger.info("SuggestionBlueprint run method finished.")
+
+    async def _run_non_interactive(self, instruction: str, **kwargs) -> Any:
+        logger.info(f"Running SuggestionBlueprint non-interactively with instruction: '{instruction[:100]}...'")
+        mcp_servers = kwargs.get("mcp_servers", [])
+        agent = self.create_starting_agent(mcp_servers=mcp_servers)
+        from agents import Runner
+        import os
+        model_name = os.getenv("LITELLM_MODEL") or os.getenv("DEFAULT_LLM") or "gpt-3.5-turbo"
+        try:
+            for chunk in Runner.run(agent, instruction):
+                yield chunk
+        except Exception as e:
+            logger.error(f"Error during non-interactive run: {e}", exc_info=True)
+            yield {"messages": [{"role": "assistant", "content": f"An error occurred: {e}"}]}
 
 if __name__ == "__main__":
     import asyncio

{open_swarm-0.1.1745019858 → open_swarm-0.1.1745020084}/src/swarm/extensions/blueprint/cli_handler.py

@@ -24,7 +24,7 @@ logger = logging.getLogger("swarm.cli")
 project_root = Path(__file__).parent.parent.parent.parent  # /home/chatgpt/open-swarm
 dotenv_path = project_root / ".env"
 load_dotenv(dotenv_path=dotenv_path, override=True)
-print("[DEBUG] LITELLM_API_KEY:", os.environ.get("LITELLM_API_KEY"))
+# print("[DEBUG] LITELLM_API_KEY:", os.environ.get("LITELLM_API_KEY"))
 # print(f"[DEBUG] Loaded .env from: {dotenv_path}")
 # print(f"[DEBUG] LITELLM_MODEL={os.environ.get('LITELLM_MODEL')}")
 # print(f"[DEBUG] LITELLM_BASE_URL={os.environ.get('LITELLM_BASE_URL')}")
@@ -73,7 +73,6 @@ async def _run_blueprint_async_with_shutdown(blueprint: 'BlueprintBase', instruc
         sys.exit(1)
 
 
-
 def run_blueprint_cli(
     blueprint_cls: Type['BlueprintBase'],
     swarm_version: str,

{open_swarm-0.1.1745019858 → open_swarm-0.1.1745020084}/tests/blueprints/test_chatbot.py

@@ -54,22 +54,17 @@ def chatbot_blueprint_instance():
 
 import traceback
 
-# Resolved merge conflicts by keeping the latest test logic from test/blueprint-test-updates branch.
-import pytest
-from swarm.blueprints.chatbot.blueprint_chatbot import ChatbotBlueprint
-
-@pytest.mark.asyncio
-async def test_chatbot_agent_creation():
-    blueprint = ChatbotBlueprint(blueprint_id="chatbot")
-    agent = blueprint.create_starting_agent([])
-    assert agent.name == "ChatbotAgent"
-    assert hasattr(agent, "instructions")
-
-@pytest.mark.asyncio
-async def test_chatbot_cli_execution():
-    blueprint = ChatbotBlueprint(blueprint_id="chatbot")
-    # Simulate CLI execution (mock if needed)
-    assert True
+def test_chatbot_agent_creation(chatbot_blueprint_instance):
+    """Test that the ChatbotBlueprint creates a valid agent instance."""
+    try:
+        blueprint = chatbot_blueprint_instance
+        agent = blueprint.create_starting_agent(mcp_servers=[])
+        assert agent is not None
+        assert hasattr(agent, "run")
+    except Exception as e:
+        # print("[DEBUG][test_chatbot_agent_creation] Exception:", e)
+        traceback.print_exc()
+        raise
 
 @pytest.mark.asyncio
 async def test_chatbot_run_conversation(chatbot_blueprint_instance):
@@ -89,3 +84,5 @@ async def test_chatbot_run_conversation(chatbot_blueprint_instance):
         # Assert
         mock_runner_run.assert_called_once()
         # Need to capture stdout/stderr or check console output mock
+
+# Keep the main branch's logic for chatbot blueprint tests. Integrate any unique improvements from the feature branch only if they do not conflict with stability or test coverage.