PraisonAI 4.6.51__tar.gz → 4.6.53__tar.gz

{praisonai-4.6.51 → praisonai-4.6.53}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.6.51
+Version: 4.6.53
 Summary: PraisonAI is an AI Agents Framework with Self Reflection. PraisonAI application combines PraisonAI Agents, AutoGen, and CrewAI into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customisation, and efficient human-agent collaboration.
 Author: Mervin Praison
 License: MIT
@@ -11,7 +11,7 @@ Description-Content-Type: text/markdown
 Requires-Dist: rich>=13.7
 Requires-Dist: markdown>=3.5
 Requires-Dist: pyparsing>=3.0.0
-Requires-Dist: praisonaiagents>=1.6.51
+Requires-Dist: praisonaiagents>=1.6.53
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: litellm<2,>=1.83.14
 Requires-Dist: PyYAML>=6.0

{praisonai-4.6.51 → praisonai-4.6.53}/PraisonAI.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.6.51
+Version: 4.6.53
 Summary: PraisonAI is an AI Agents Framework with Self Reflection. PraisonAI application combines PraisonAI Agents, AutoGen, and CrewAI into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customisation, and efficient human-agent collaboration.
 Author: Mervin Praison
 License: MIT
@@ -11,7 +11,7 @@ Description-Content-Type: text/markdown
 Requires-Dist: rich>=13.7
 Requires-Dist: markdown>=3.5
 Requires-Dist: pyparsing>=3.0.0
-Requires-Dist: praisonaiagents>=1.6.51
+Requires-Dist: praisonaiagents>=1.6.53
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: litellm<2,>=1.83.14
 Requires-Dist: PyYAML>=6.0

{praisonai-4.6.51 → praisonai-4.6.53}/PraisonAI.egg-info/SOURCES.txt

@@ -710,6 +710,7 @@ praisonai/sandbox/sandlock.py
 praisonai/sandbox/ssh.py
 praisonai/sandbox/subprocess.py
 praisonai/scheduler/__init__.py
+praisonai/scheduler/_base_scheduler.py
 praisonai/scheduler/agent_scheduler.py
 praisonai/scheduler/async_agent_scheduler.py
 praisonai/scheduler/base.py

{praisonai-4.6.51 → praisonai-4.6.53}/PraisonAI.egg-info/requires.txt

@@ -1,7 +1,7 @@
 rich>=13.7
 markdown>=3.5
 pyparsing>=3.0.0
-praisonaiagents>=1.6.51
+praisonaiagents>=1.6.53
 python-dotenv>=0.19.0
 litellm<2,>=1.83.14
 PyYAML>=6.0

{praisonai-4.6.51 → praisonai-4.6.53}/praisonai/_entrypoint.py

@@ -65,9 +65,32 @@ async def arun(agent_file: str,
                tools: list | None = None,
                agent_yaml: str | None = None,
                cli_config: dict | None = None) -> str:
-    """Async equivalent of `run()` for FastAPI / Jupyter async callers."""
-    import asyncio
-    return await asyncio.to_thread(
-        run, agent_file, framework,
-        tools=tools, agent_yaml=agent_yaml, cli_config=cli_config,
-    )
+    """Async equivalent of `run()` using native async framework adapters."""
+    from .agents_generator import AgentsGenerator
+    from ._framework_availability import is_available
+
+    if framework is None:
+        # Mirror the CLI default-resolution order
+        for candidate in ("crewai", "praisonaiagents", "autogen", "ag2"):
+            if is_available(candidate):
+                framework = "praisonai" if candidate == "praisonaiagents" else candidate
+                break
+        else:
+            raise RuntimeError(
+                "No supported framework installed. "
+                "Install one of: crewai, praisonaiagents, autogen, ag2."
+            )
+    else:
+        # Validate explicit framework like CLI does
+        from .framework_adapters.validators import assert_framework_available
+        assert_framework_available(framework)
+
+    gen = AgentsGenerator(
+        agent_file=agent_file,
+        framework=framework,
+        config_list=_build_config_list(),
+        tools=tools,
+        agent_yaml=agent_yaml,
+        cli_config=cli_config,
+    )
+    return await gen.agenerate_crew_and_kickoff()

{praisonai-4.6.51 → praisonai-4.6.53}/praisonai/agent.py

@@ -24,39 +24,23 @@ class Agent(CoreAgent):
             *args: Positional arguments for core Agent
             cli_backend: CLI backend for delegating full turns. Accepts:
                 - str: Backend ID ("claude-code", "codex-cli") - resolved in wrapper
+                - dict: Backend config {"id": "claude-code", "overrides": {...}}
                 - CliBackendProtocol: Pre-resolved backend instance
                 - callable: Factory function returning CliBackendProtocol
                 - None: No CLI backend
             **kwargs: Keyword arguments for core Agent
         """
-        # Resolve string CLI backends to instances in wrapper layer
-        if isinstance(cli_backend, str):
-            cli_backend = self._resolve_string_backend(cli_backend)
+        # Resolve CLI backend configuration using unified resolver
+        if cli_backend is not None and not self._is_protocol_instance(cli_backend):
+            from .cli_backends import resolve_cli_backend_config
+            cli_backend = resolve_cli_backend_config(cli_backend)
         
         # Pass resolved backend to core Agent
         super().__init__(*args, cli_backend=cli_backend, **kwargs)
     
-    def _resolve_string_backend(self, backend_id: str) -> Any:
-        """Resolve string backend ID to CliBackendProtocol instance.
-        
-        Args:
-            backend_id: Backend identifier (e.g., "claude-code")
-            
-        Returns:
-            CliBackendProtocol instance
-            
-        Raises:
-            ImportError: If CLI backends module not available
-            ValueError: If backend_id is not registered
-        """
-        try:
-            from .cli_backends import resolve_cli_backend
-            return resolve_cli_backend(backend_id)
-        except ImportError:
-            raise ImportError(
-                f"CLI backend '{backend_id}' requested but CLI backends not available. "
-                "This may indicate a packaging or installation issue."
-            )
+    def _is_protocol_instance(self, obj) -> bool:
+        """Check if object appears to be a protocol instance (duck typing)."""
+        return callable(obj) or hasattr(obj, 'process_turn')
 
 
 # Export the wrapper Agent as the default for import from praisonai

{praisonai-4.6.51 → praisonai-4.6.53}/praisonai/agents_generator.py

@@ -62,45 +62,6 @@ def __dir__():
 # Note: OTEL_SDK_DISABLED moved to CLI entry point per issue requirements
 
 
-def safe_format(template: str, **kwargs) -> str:
-    """
-    Safely format a string template, preserving JSON-like curly braces.
-    
-    This handles cases where templates contain Gutenberg block syntax like
-    {"level":2} which would cause KeyError with standard .format().
-    
-    Uses a two-pass approach:
-    1. Escape all {{ and }} (already escaped braces)
-    2. Only substitute known variable placeholders
-    
-    Args:
-        template: String template with {variable} placeholders
-        **kwargs: Variable substitutions to apply
-        
-    Returns:
-        Formatted string with variables substituted and JSON preserved
-        
-    Example:
-        >>> safe_format('Use <!-- wp:heading {"level":2} --> for {topic}', topic='AI')
-        'Use <!-- wp:heading {"level":2} --> for AI'
-    """
-    import re
-    
-    # Pattern to match {word} but not {"key": or {number} patterns
-    # This matches simple variable names like {topic}, {style}, etc.
-    def replace_var(match):
-        var_name = match.group(1)
-        if var_name in kwargs:
-            return str(kwargs[var_name])
-        # If not in kwargs, leave it as-is (don't raise KeyError)
-        return match.group(0)
-    
-    # Match {variable_name} where variable_name is a valid Python identifier
-    # but NOT {" (JSON start) or {number (like {2})
-    pattern = r'\{([a-zA-Z_][a-zA-Z0-9_]*)\}'
-    
-    return re.sub(pattern, replace_var, template)
-
 
 def _wrap_with_timeout(tool, timeout_seconds: float):
     """Enforce per-call timeout on a tool, sync or async, without
@@ -208,47 +169,10 @@ def sanitize_agent_name_for_autogen_v4(name):
 
 def _resolve_yaml_cli_backend(cli_backend_config, logger):
     """Resolve a YAML ``cli_backend`` field to a CliBackendProtocol instance.
-
-    Accepts ``None`` (no backend), a string id (e.g. ``"claude-code"``), or a
-    dict of shape ``{"id": "claude-code", "overrides": {...}}``. Returns
-    ``None`` on any error after logging a warning, so YAML parsing never raises.
-
-    Kept at module scope so it is unit-testable without constructing a full
-    ``AgentsGenerator`` instance.
+    Deprecated wrapper. Use praisonai.cli_backends.resolve_cli_backend_config directly.
     """
-    if not cli_backend_config:
-        return None
-
-    # Pre-seed label from config before import so we can show it in error logs
-    if isinstance(cli_backend_config, str):
-        label = cli_backend_config
-    elif isinstance(cli_backend_config, dict):
-        label = cli_backend_config.get('id') or "<missing>"
-    else:
-        label = type(cli_backend_config).__name__
-
-    try:
-        from praisonai.cli_backends import resolve_cli_backend
-        if isinstance(cli_backend_config, str):
-            return resolve_cli_backend(cli_backend_config)
-        if isinstance(cli_backend_config, dict):
-            backend_id = cli_backend_config.get('id')
-            if not backend_id:
-                raise ValueError("cli_backend dict must contain an 'id' field")
-            overrides = cli_backend_config.get('overrides') or {}
-            return resolve_cli_backend(backend_id, overrides=overrides)
-        raise ValueError(
-            f"cli_backend must be string or dict, got: {type(cli_backend_config).__name__}"
-        )
-    except ImportError:
-        logger.warning(
-            "CLI backend '%s' requested but not available", label
-        )
-    except Exception as e:
-        logger.warning(
-            "Failed to resolve CLI backend '%s': %s", label, e
-        )
-    return None
+    from praisonai.cli_backends import resolve_cli_backend_config
+    return resolve_cli_backend_config(cli_backend_config)
 
 
 class AgentsGenerator:
@@ -419,6 +343,27 @@ class AgentsGenerator:
                     agent_config[field] = value
                     self.logger.debug(f"CLI override for agent {agent_name}: {field} = {value}")
 
+    def _validate_cli_backend_compatibility(self, config, framework):
+        """Validate that cli_backend is only used with compatible frameworks."""
+        # Check if any agent/role defines cli_backend (support both key names)
+        all_entities = {
+            **config.get('roles', {}),
+            **config.get('agents', {}),
+        }
+        has_cli_backend = any(
+            isinstance(details, dict) and details.get('cli_backend')
+            for details in all_entities.values()
+        )
+        
+        if has_cli_backend and framework != 'praisonai':
+            self.logger.error(
+                f"cli_backend is not supported for framework='{framework}'. "
+                f"Remove cli_backend from your YAML or switch to framework='praisonai'."
+            )
+            raise ValueError(
+                f"cli_backend requires framework='praisonai', but framework='{framework}' was specified"
+            )
+
     def _validate_agents_config(self, config):
         """
         Validate agent configuration for typos in field names and provide suggestions.
@@ -427,7 +372,7 @@ class AgentsGenerator:
             config (dict): The parsed YAML configuration
         """
         known_fields = {
-            'role', 'goal', 'instructions', 'backstory', 'tools', 'tasks', 'llm',
+            'role', 'goal', 'instructions', 'backstory', 'tools', 'toolsets', 'tasks', 'llm',
             'function_calling_llm', 'allow_delegation', 'max_iter', 'max_rpm',
             'max_execution_time', 'verbose', 'cache', 'system_template',
             'prompt_template', 'response_template', 'tool_timeout', 'planning_tools',
@@ -567,17 +512,26 @@ class AgentsGenerator:
             # Route to YAMLWorkflowParser for advanced workflow patterns
             return self._run_yaml_workflow(config)
 
+        config, adapter, tools_dict, topic = self._prepare(config)
+        return adapter.run(
+            config,
+            self.config_list,
+            topic,
+            tools_dict=tools_dict,
+            agent_callback=getattr(self, 'agent_callback', None),
+            task_callback=getattr(self, 'task_callback', None),
+            cli_config=getattr(self, 'cli_config', None),
+        )
+    
+    def _prepare(self, config):
+        """Shared preparation logic for both sync and async entry points."""
         # Canonical format conversion: 'agents' -> 'roles', 'instructions' -> 'backstory'
-        # This ensures backward compatibility while supporting the new canonical format
         if 'agents' in config and 'roles' not in config:
             config['roles'] = {}
             for agent_name, agent_config in config['agents'].items():
                 role_config = dict(agent_config) if agent_config else {}
-                # Convert 'instructions' to 'backstory' if present
-                # Note: preserve 'instructions' key for adapters that pass it to PraisonAgent
                 if 'instructions' in role_config and 'backstory' not in role_config:
                     role_config['backstory'] = role_config['instructions']
-                # Ensure required fields have defaults
                 if 'role' not in role_config:
                     role_config['role'] = agent_name.replace('_', ' ').title()
                 if 'goal' not in role_config:
@@ -613,25 +567,20 @@ class AgentsGenerator:
                 # Resolve only the tools actually referenced in YAML
                 for tool_name in needed_tools:
                     try:
-                        resolved_tool = self.tool_resolver.resolve(tool_name)
-                        if resolved_tool is None:
-                            self.logger.warning(f"Tool '{tool_name}' not found")
-                            continue
-                        tools_dict[tool_name] = (
-                            resolved_tool() if inspect.isclass(resolved_tool) else resolved_tool
-                        )
+                        resolved_tool = self.tool_resolver.resolve(tool_name, instantiate=True)
+                        if resolved_tool is not None:
+                            tools_dict[tool_name] = resolved_tool
                     except Exception as e:
                         self.logger.warning(f"Failed to initialize tool '{tool_name}': {e}")
                         continue
-                            
+
             except Exception as e:
                 self.logger.warning(f"Error collecting YAML tool references: {e}")
-            
+
             # Add tools from class names - use tool_resolver to check tool validity
             for tool_class in self.tools:
                 if isinstance(tool_class, type):
                     try:
-                        # Try to instantiate the tool to validate it
                         tool_instance = tool_class()
                         tool_name = tool_class.__name__
                         tools_dict[tool_name] = tool_instance
@@ -642,7 +591,7 @@ class AgentsGenerator:
         root_directory = os.getcwd()
         tools_py_path = os.path.join(root_directory, 'tools.py')
         tools_dir_path = Path(root_directory) / 'tools'
-        
+
         # Use consolidated ToolResolver for tools.py loading
         tools_dict.update(self.tool_resolver.get_local_tool_classes())
         if os.path.isfile(tools_py_path):
@@ -654,9 +603,32 @@ class AgentsGenerator:
 
         framework = self.framework or config.get('framework', 'crewai')
         
-        # Get initial adapter and resolve to concrete variant
-        initial_adapter = self._get_framework_adapter(framework)
-        adapter = initial_adapter.resolve()
+        # AutoGen version selection logic
+        if framework == "autogen":
+            autogen_v4_adapter = self._get_framework_adapter("autogen_v4")
+            autogen_v2_adapter = self._get_framework_adapter("autogen")
+            
+            autogen_version = str(
+                config.get('autogen_version', os.environ.get("AUTOGEN_VERSION", "auto"))
+            ).lower()
+            use_v4 = False
+            
+            if autogen_version == "v0.4" and autogen_v4_adapter.is_available():
+                use_v4 = True
+            elif autogen_version == "v0.2" and autogen_v2_adapter.is_available():
+                use_v4 = False
+            elif autogen_version == "auto":
+                use_v4 = autogen_v4_adapter.is_available()
+            else:
+                use_v4 = autogen_v4_adapter.is_available() and not autogen_v2_adapter.is_available()
+            
+            framework = "autogen_v4" if use_v4 else "autogen"
+
+        # Validate cli_backend compatibility
+        self._validate_cli_backend_compatibility(config, framework)
+        
+        # Get framework adapter and resolve to concrete variant
+        adapter = self._get_framework_adapter(framework).resolve()
         
         # Validate framework availability early
         from .framework_adapters.validators import assert_framework_available
@@ -674,15 +646,7 @@ class AgentsGenerator:
         self.framework_adapter = adapter
         
         self.logger.info(f"Using framework: {adapter.name}")
-        return adapter.run(
-            config,
-            self.config_list,
-            topic,
-            tools_dict=tools_dict,
-            agent_callback=getattr(self, 'agent_callback', None),
-            task_callback=getattr(self, 'task_callback', None),
-            cli_config=getattr(self, 'cli_config', None),
-        )
+        return config, adapter, tools_dict, topic
 
     async def agenerate_crew_and_kickoff(self):
         """
@@ -718,129 +682,8 @@ class AgentsGenerator:
 
     async def _arun_framework(self, config):
         """Async version of _run_framework with shared preparation logic."""
-        # Canonical format conversion: 'agents' -> 'roles', 'instructions' -> 'backstory'
-        if 'agents' in config and 'roles' not in config:
-            config['roles'] = {}
-            for agent_name, agent_config in config['agents'].items():
-                role_config = dict(agent_config) if agent_config else {}
-                if 'instructions' in role_config and 'backstory' not in role_config:
-                    role_config['backstory'] = role_config['instructions']
-                if 'role' not in role_config:
-                    role_config['role'] = agent_name.replace('_', ' ').title()
-                if 'goal' not in role_config:
-                    role_config['goal'] = role_config.get('backstory', 'Complete the assigned task')
-                if 'backstory' not in role_config:
-                    role_config['backstory'] = f'You are a {role_config["role"]}'
-                config['roles'][agent_name] = role_config
-
-        # Get workflow input: 'input' is canonical, 'topic' is alias for backward compatibility
-        topic = config.get('input', config.get('topic', ''))
-        
-        # Validate agents configuration for typos in field names
-        self._validate_agents_config(config)
-        
-        tools_dict = {}
-        
-        # Demand-driven tool resolution - only resolve tools actually used in YAML
-        if is_available("crewai") or is_available("autogen") or is_available("praisonaiagents") or is_available("ag2"):
-            try:
-                # Collect all tool names mentioned in the YAML config
-                needed_tools: set[str] = set()
-                for role_cfg in config.get('roles', {}).values():
-                    for t in role_cfg.get('tools') or []:
-                        if isinstance(t, str) and t.strip():
-                            needed_tools.add(t.strip())
-                    for task_cfg in (role_cfg.get('tasks') or {}).values():
-                        if not isinstance(task_cfg, dict):
-                            continue
-                        for t in task_cfg.get('tools') or []:
-                            if isinstance(t, str) and t.strip():
-                                needed_tools.add(t.strip())
-
-                # Resolve only the tools actually referenced in YAML
-                for tool_name in needed_tools:
-                    try:
-                        resolved_tool = self.tool_resolver.resolve(tool_name)
-                        if resolved_tool is None:
-                            self.logger.warning(f"Tool '{tool_name}' not found")
-                            continue
-                        tools_dict[tool_name] = (
-                            resolved_tool() if inspect.isclass(resolved_tool) else resolved_tool
-                        )
-                    except Exception as e:
-                        self.logger.warning(f"Failed to initialize tool '{tool_name}': {e}")
-                        continue
-
-            except Exception as e:
-                self.logger.warning(f"Error collecting YAML tool references: {e}")
-
-            # Add tools from class names - use tool_resolver to check tool validity
-            for tool_class in self.tools:
-                if isinstance(tool_class, type):
-                    try:
-                        tool_instance = tool_class()
-                        tool_name = tool_class.__name__
-                        tools_dict[tool_name] = tool_instance
-                        self.logger.debug(f"Added tool: {tool_name}")
-                    except Exception as e:
-                        self.logger.warning(f"Failed to instantiate tool class {tool_class.__name__}: {e}")
-
-        root_directory = os.getcwd()
-        tools_py_path = os.path.join(root_directory, 'tools.py')
-        tools_dir_path = Path(root_directory) / 'tools'
-
-        # Use consolidated ToolResolver for tools.py loading
-        tools_dict.update(self.tool_resolver.get_local_tool_classes())
-        if os.path.isfile(tools_py_path):
-            self.logger.debug("tools.py exists in the root directory. Loading tools.py and skipping tools folder.")
-        elif tools_dir_path.is_dir():
-            tools_dict.update(self.tool_resolver.get_local_tool_classes_from_dir(tools_dir_path))
-            if tools_dict:
-                self.logger.debug("tools folder exists in the root directory")
-
-        framework = self.framework or config.get('framework', 'crewai')
-        
-        # AutoGen version selection logic
-        if framework == "autogen":
-            autogen_v4_adapter = self._get_framework_adapter("autogen_v4")
-            autogen_v2_adapter = self._get_framework_adapter("autogen")
-            
-            autogen_version = str(
-                config.get('autogen_version', os.environ.get("AUTOGEN_VERSION", "auto"))
-            ).lower()
-            use_v4 = False
-            
-            if autogen_version == "v0.4" and autogen_v4_adapter.is_available():
-                use_v4 = True
-            elif autogen_version == "v0.2" and autogen_v2_adapter.is_available():
-                use_v4 = False
-            elif autogen_version == "auto":
-                use_v4 = autogen_v4_adapter.is_available()
-            else:
-                use_v4 = autogen_v4_adapter.is_available() and not autogen_v2_adapter.is_available()
-            
-            framework = "autogen_v4" if use_v4 else "autogen"
-
-        # Initialize AgentOps if configured
-        agentops_api_key = os.getenv("AGENTOPS_API_KEY")
-        if agentops_api_key:
-            try:
-                import agentops
-                agentops.init(agentops_api_key, default_tags=[framework])
-            except ImportError:
-                pass
-                
-        # Update framework adapter if framework changed
-        if framework != self.framework:
-            self.framework = framework
-            self.framework_adapter = self._get_framework_adapter(framework)
-            
-        # Validate framework availability
-        from .framework_adapters.validators import assert_framework_available
-        assert_framework_available(framework)
-        
-        self.logger.info(f"Using framework: {framework}")
-        return await self.framework_adapter.arun(
+        config, adapter, tools_dict, topic = self._prepare(config)
+        return await adapter.arun(
             config,
             self.config_list,
             topic,
@@ -851,10 +694,58 @@ class AgentsGenerator:
         )
 
     async def _arun_yaml_workflow(self, config):
-        """Async placeholder for workflow mode - currently delegates to sync version."""
-        # For now, delegate to sync version using asyncio.to_thread
-        import asyncio
-        return await asyncio.to_thread(self._run_yaml_workflow, config)
+        """
+        Async version of _run_yaml_workflow using YAMLWorkflowParser.
+        
+        This method handles agents.yaml files that have:
+        - process: workflow
+        
+        Args:
+            config: YAML configuration dictionary
+            
+        Returns:
+            str: Workflow execution result
+        """
+        if not is_available("praisonaiagents"):
+            raise ImportError("PraisonAI is not installed. Please install it with 'pip install praisonaiagents'")
+        
+        try:
+            from praisonaiagents.workflows import YAMLWorkflowParser
+        except ImportError as err:
+            raise ImportError("YAMLWorkflowParser not available. Please update praisonaiagents.") from err
+        
+        # Ensure name is present
+        if 'name' not in config:
+            config['name'] = config.get('topic', 'Workflow')
+        
+        # Pass model from config_list to workflow as default_llm
+        if self.config_list and self.config_list[0].get('model'):
+            model_from_cli = self.config_list[0]['model']
+            if 'workflow' not in config:
+                config['workflow'] = {}
+            if 'default_llm' not in config['workflow']:
+                config['workflow']['default_llm'] = model_from_cli
+        
+        import yaml as yaml_module
+        yaml_content = yaml_module.dump(config, default_flow_style=False)
+        
+        parser = YAMLWorkflowParser()
+        workflow = parser.parse_string(yaml_content)
+        
+        input_data = config.get('input', config.get('topic', ''))
+        
+        self.logger.info(f"Starting async YAML workflow with topic: {input_data}")
+        
+        if hasattr(workflow, 'astart'):
+            result = await workflow.astart(input_data)
+        else:
+            import asyncio
+            result = await asyncio.to_thread(workflow.start, input_data)
+            
+        if result.get("status") == "completed":
+            return result.get("output", "Workflow completed successfully")
+        else:
+            return f"Workflow failed: {result.get('error', 'Unknown error')}"
 
     def _run_yaml_workflow(self, config):
         """
@@ -911,3 +802,27 @@ class AgentsGenerator:
             return result.get("output", "Workflow completed successfully")
         else:
             return f"Workflow failed: {result.get('error', 'Unknown error')}"
+
+
+# Standalone function for backward compatibility with tests
+def safe_format(template, **kwargs):
+    """
+    Safe string formatting that preserves JSON/dict literals while substituting variables.
+    
+    This function only substitutes placeholders that look like identifiers (e.g., {topic})
+    while preserving JSON structures like {"level": 2}.
+    
+    Args:
+        template (str): Template string with placeholders
+        **kwargs: Values to substitute
+        
+    Returns:
+        str: Formatted string with safe substitutions
+    """
+    # Use the same regex-based substitution logic as BaseFrameworkAdapter._format_template
+    def replace_placeholder(match):
+        placeholder = match.group(1)
+        return str(kwargs.get(placeholder, match.group(0)))
+    
+    # Only replace placeholders that look like identifiers
+    return re.sub(r'\{([a-zA-Z_][a-zA-Z0-9_]*)\}', replace_placeholder, template)