open-swarm 0.1.1745019957__py3-none-any.whl → 0.1.1745020084__py3-none-any.whl

{open_swarm-0.1.1745019957.dist-info → open_swarm-0.1.1745020084.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: open-swarm
-Version: 0.1.1745019957
+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.1745019957.dist-info → open_swarm-0.1.1745020084.dist-info}/RECORD

@@ -21,10 +21,10 @@ swarm/blueprints/codey/CODEY.md,sha256=JxGcR0INH0dLk_q4ua1D0YdvX99szyESsbbs4dIy5
 swarm/blueprints/codey/README.md,sha256=n2Sz1yg1FZp6ATV4W4rmgIYeQFFzlJ_APhCY1j6UR7o,3545
 swarm/blueprints/codey/blueprint_codey.py,sha256=otjn46MVsmIvHTbE6aHFPwFfcV3kNY_j2vdnt1xCKAo,17205
 swarm/blueprints/codey/instructions.md,sha256=XMvJngQ23vl7xJQx-Sp5UIME2-JQyyxeZFFtIuOtTOI,1209
-swarm/blueprints/digitalbutlers/blueprint_digitalbutlers.py,sha256=sYjbkD7esHrttiRAhd5vqx1_DCtCSHFsMgEXqStsSsc,19088
+swarm/blueprints/digitalbutlers/blueprint_digitalbutlers.py,sha256=frnC-09hrUkg2bTPBFtj_WdQkGGNE1s4Ru35Ec4ag4M,16270
 swarm/blueprints/divine_code/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 swarm/blueprints/divine_code/apps.py,sha256=k615JHdfOuo_GwfVbC7ah8X9OblkAL2XWm9aLBjmMyY,306
-swarm/blueprints/divine_code/blueprint_divine_code.py,sha256=YuJ5nThBkWLYN5ty3SiLAJaCs05wiCXHkFiNARUgLiA,21601
+swarm/blueprints/divine_code/blueprint_divine_code.py,sha256=I2WM69x-ILeBUtQn0C5emdumw8Lx2N0mIgjwMMVhDow,19546
 swarm/blueprints/django_chat/apps.py,sha256=rn1Eu11c4zZ6DYZeFb6AkCDMoM_dcQTzeNwW-IxXpCI,200
 swarm/blueprints/django_chat/blueprint_django_chat.py,sha256=LY_SOnNpColj1xXw1d6fpyflBF8CZzPqL5IYLRnzSqI,5582
 swarm/blueprints/django_chat/urls.py,sha256=TTTF3pgymvCYbuxpwi4WRBPv8ftQNH4pEoURT8sEVAg,147
@@ -32,7 +32,7 @@ swarm/blueprints/django_chat/views.py,sha256=MUKjXXjXsq8jMZtAb4RR9g2mEYrwFemN6Bq
 swarm/blueprints/django_chat/templates/django_chat/django_chat_webpage.html,sha256=wAEOI4Wg0JJ8drXaOcr2Pel6lW3JSHmyIpbocLS5tI8,1649
 swarm/blueprints/echocraft/blueprint_echocraft.py,sha256=9XNyuMZIBrm9kpnv1aq_W3h-9Zr2dVdzchI2uFXslg0,10988
 swarm/blueprints/family_ties/apps.py,sha256=EjV7AxDNsLM4gsLr_qMEiLAVbERuo1ZsdU9vPtOEYAY,287
-swarm/blueprints/family_ties/blueprint_family_ties.py,sha256=co1rujjvRcDk5qHl94wMpHSQjx7tLxED0RMWJ_lWKC4,10629
+swarm/blueprints/family_ties/blueprint_family_ties.py,sha256=AkYz9_O7QSBhoZAG1jaFlTXEouL1eUfa0y6hw9MqSro,9762
 swarm/blueprints/family_ties/models.py,sha256=C3_okdVVYuu9xOpoKRsaLoGrM2775cS_cU4UKYAkJ9s,903
 swarm/blueprints/family_ties/serializers.py,sha256=kH3T6OgXjF534bO3gfAUr6GpXZ5Jx0BQkK58nvuEcqA,325
 swarm/blueprints/family_ties/settings.py,sha256=5zcVsq7ny3GLWcJnOplZW4fMFNtyC3ba0ZOESRD2gh4,425
@@ -45,10 +45,10 @@ swarm/blueprints/messenger/templates/messenger/messenger.html,sha256=izuFtFn40Gm
 swarm/blueprints/mission_improbable/blueprint_mission_improbable.py,sha256=fAc672c3XYFwGwrdpDELO3V9k5dqBfyRH7_S7Urmo48,15034
 swarm/blueprints/monkai_magic/blueprint_monkai_magic.py,sha256=9eE3pf14OjgOPKNapJF8b9OYyK5_AEVZ4UJMRrBeOek,16009
 swarm/blueprints/nebula_shellz/blueprint_nebula_shellz.py,sha256=1xT6yYhl-sOSODd0E0hSKxtBlNoQe6sPf30d-S9fI6U,11709
-swarm/blueprints/omniplex/blueprint_omniplex.py,sha256=iBsSO_CF10kWMkGWfpJ2Aa7d2m60JpQGfMfrDWmFktY,13267
+swarm/blueprints/omniplex/blueprint_omniplex.py,sha256=ESJyKPhz01rw2l3AP5zbDreLUbzhJtwewopmr_WRVNM,13644
 swarm/blueprints/rue_code/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-swarm/blueprints/rue_code/blueprint_rue_code.py,sha256=4k0mm4i8w-jVSGAV-q2a_KgpPX9M05MyXkX4Li2hwFg,14092
-swarm/blueprints/suggestion/blueprint_suggestion.py,sha256=M8pDakR_XBF3P73jgUQxFFIswM2JsC_OkPR_XWh9mrM,13210
+swarm/blueprints/rue_code/blueprint_rue_code.py,sha256=odxqvAIzSESlm9eecZNz-JBsjeoRpFgCZs-7tG1ZkLQ,13273
+swarm/blueprints/suggestion/blueprint_suggestion.py,sha256=Qm5YbP19SETFtXc-gTsmGUh71US7huUyKZKqtRv-Qeg,10846
 swarm/blueprints/unapologetic_press/blueprint_unapologetic_press.py,sha256=lIq6oGQlVtI8sxCq9DKmpLaHpHv-8_NJ5XHB7TEL_dg,22399
 swarm/blueprints/whiskeytango_foxtrot/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 swarm/blueprints/whiskeytango_foxtrot/apps.py,sha256=V1QKvyb2Vz-EtDNhhNe4tw2W9LYhNDuiaIq_fAU4ilw,334
@@ -271,8 +271,8 @@ swarm/views/message_views.py,sha256=sDUnXyqKXC8WwIIMAlWf00s2_a2T9c75Na5FvYMJwBM,
 swarm/views/model_views.py,sha256=aAbU4AZmrOTaPeKMWtoKK7FPYHdaN3Zbx55JfKzYTRY,2937
 swarm/views/utils.py,sha256=8Usc0g0L0NPegNAyY20tJBNBy-JLwODf4VmxV0yUtpw,3627
 swarm/views/web_views.py,sha256=T1CKe-Nyv1C8aDt6QFTGWo_dkH7ojWAvS_QW9mZnZp0,7371
-open_swarm-0.1.1745019957.dist-info/METADATA,sha256=3KsTmrhfQC5EfIMULXc4grReT6v3OqPjlMeXqvuJK2Q,23332
-open_swarm-0.1.1745019957.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-open_swarm-0.1.1745019957.dist-info/entry_points.txt,sha256=fo28d0_zJrytRsh8QqkdlWQT_9lyAwYUx1WuSTDI3HM,177
-open_swarm-0.1.1745019957.dist-info/licenses/LICENSE,sha256=BU9bwRlnOt_JDIb6OT55Q4leLZx9RArDLTFnlDIrBEI,1062
-open_swarm-0.1.1745019957.dist-info/RECORD,,
+open_swarm-0.1.1745020084.dist-info/METADATA,sha256=XtGM3TNBR59a6A3ZK5YOorScI-RtFeNMJxY7L1xMSXk,23332
+open_swarm-0.1.1745020084.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+open_swarm-0.1.1745020084.dist-info/entry_points.txt,sha256=fo28d0_zJrytRsh8QqkdlWQT_9lyAwYUx1WuSTDI3HM,177
+open_swarm-0.1.1745020084.dist-info/licenses/LICENSE,sha256=BU9bwRlnOt_JDIb6OT55Q4leLZx9RArDLTFnlDIrBEI,1062
+open_swarm-0.1.1745020084.dist-info/RECORD,,

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__":

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]}...'")

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]}...'")

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__":

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

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