ag2 0.9.6__tar.gz → 0.9.7__tar.gz

{ag2-0.9.6 → ag2-0.9.7}/.gitignore

@@ -201,3 +201,6 @@ notebook/*_server.py
 
 notebook/mcp/wikipedia_articles
 notebook/mcp/arxiv_papers
+
+
+*CLAUDE.md:

{ag2-0.9.6 → ag2-0.9.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ag2
-Version: 0.9.6
+Version: 0.9.7
 Summary: A programming framework for agentic AI
 Project-URL: Homepage, https://ag2.ai/
 Project-URL: Documentation, https://docs.ag2.ai

{ag2-0.9.6 → ag2-0.9.7}/autogen/agentchat/conversable_agent.py

@@ -3873,15 +3873,29 @@ class ConversableAgent(LLMAgent):
                     **executor_kwargs,
                 )
 
-            tools = [] if tools is None else tools
-            tools = [tools] if isinstance(tools, Tool) else tools
-            for tool in tools:
+            # Combine agent's existing tools with passed tools
+            agent_tools = self._tools.copy()  # Get agent's pre-registered tools
+            passed_tools = [] if tools is None else tools
+            passed_tools = [passed_tools] if isinstance(passed_tools, Tool) else passed_tools
+
+            # Combine both sets of tools (avoid duplicates)
+            all_tools = agent_tools.copy()
+            for tool in passed_tools:
+                if tool not in all_tools:
+                    all_tools.append(tool)
+
+            # Register all tools with the executor
+            for tool in all_tools:
                 tool.register_for_execution(self.run_executor)
+
+            # Register only newly passed tools for LLM (agent's pre-existing tools are already registered)
+            for tool in passed_tools:
                 tool.register_for_llm(self)
             yield self.run_executor
         finally:
-            if tools is not None:
-                for tool in tools:
+            # Clean up only newly passed tools (not agent's pre-existing tools)
+            if "passed_tools" in locals():
+                for tool in passed_tools:
                     self.update_tool_signature(tool_sig=tool.tool_schema["function"]["name"], is_remove=True)
 
     def _deprecated_run(

{ag2-0.9.6 → ag2-0.9.7}/autogen/logger/sqlite_logger.py

@@ -293,7 +293,7 @@ class SqliteLogger(BaseLogger):
             client_id,
             wrapper_id,
             self.session_id,
-            json.dumps(request),
+            json.dumps(to_dict(request)),
             response_messages,
             is_cached,
             cost,

{ag2-0.9.6 → ag2-0.9.7}/autogen/oai/client.py

@@ -246,6 +246,12 @@ class OpenAILLMConfigEntry(LLMConfigEntry):
     price: Optional[list[float]] = Field(default=None, min_length=2, max_length=2)
     tool_choice: Optional[Literal["none", "auto", "required"]] = None
     user: Optional[str] = None
+
+    # ⏺ The extra_body parameter flows from OpenAILLMConfigEntry to the LLM request through this path:
+    #   1. Config Definition: extra_body is defined in OpenAILLMConfigEntry (autogen/oai/client.py:248)
+    #   2. Parameter Classification: It's classified as an OpenAI client parameter (not AG2-specific) via the openai_kwargs property (autogen/oai/client.py:752-758)
+    #   3. Request Separation: In _separate_create_config() (autogen/oai/client.py:842), extra_body goes into create_config since it's not in the extra_kwargs set.
+    #   4. API Call: The create_config becomes params and gets passed directly to OpenAI's create() method via **params (autogen/oai/client.py:551,658)
     extra_body: Optional[dict[str, Any]] = (
         None  # For VLLM - See here: https://docs.vllm.ai/en/latest/serving/openai_compatible_server.html#extra-parameters
     )

{ag2-0.9.6 → ag2-0.9.7}/autogen/oai/gemini.py

@@ -126,6 +126,7 @@ class GeminiClient:
     PARAMS_MAPPING = {
         "max_tokens": "max_output_tokens",
         # "n": "candidate_count", # Gemini supports only `n=1`
+        "seed": "seed",
         "stop_sequences": "stop_sequences",
         "temperature": "temperature",
         "top_p": "top_p",

{ag2-0.9.6 → ag2-0.9.7}/autogen/oai/ollama.py

@@ -22,6 +22,7 @@ Resources:
 
 from __future__ import annotations
 
+import ast
 import copy
 import json
 import random
@@ -59,6 +60,7 @@ class OllamaLLMConfigEntry(LLMConfigEntry):
     top_k: int = Field(default=40)
     top_p: float = Field(default=0.9)
     hide_tools: Literal["if_all_run", "if_any_run", "never"] = "never"
+    native_tool_calls: bool = False
 
     def create_client(self):
         raise NotImplementedError("OllamaLLMConfigEntry.create_client is not implemented.")
@@ -612,7 +614,7 @@ def _object_to_tool_call(data_object: Any) -> list[dict[str, Any]]:
         is_invalid = False
         for i, item in enumerate(data_copy):
             try:
-                new_item = eval(item)
+                new_item = ast.literal_eval(item)
                 if isinstance(new_item, dict):
                     if is_valid_tool_call_item(new_item):
                         data_object[i] = new_item

{ag2-0.9.6 → ag2-0.9.7}/autogen/oai/openai_utils.py

@@ -467,59 +467,70 @@ def filter_config(
     filter_dict: Optional[dict[str, Union[list[Union[str, None]], set[Union[str, None]]]]],
     exclude: bool = False,
 ) -> list[dict[str, Any]]:
-    """This function filters `config_list` by checking each configuration dictionary against the criteria specified in
-    `filter_dict`. A configuration dictionary is retained if for every key in `filter_dict`, see example below.
+    """Filter configuration dictionaries based on specified criteria.
+
+    This function filters a list of configuration dictionaries by applying ALL criteria specified in `filter_dict`.
+    A configuration is included in the result if it satisfies every key-value constraint in the filter dictionary.
+    For each filter key, the configuration's corresponding field value must match at least one of the acceptable
+    values (OR logic within each criteria, AND logic between different criteria).
 
     Args:
         config_list (list of dict): A list of configuration dictionaries to be filtered.
-        filter_dict (dict): A dictionary representing the filter criteria, where each key is a
-                            field name to check within the configuration dictionaries, and the
-                            corresponding value is a list of acceptable values for that field.
-                            If the configuration's field's value is not a list, then a match occurs
-                            when it is found in the list of acceptable values. If the configuration's
-                            field's value is a list, then a match occurs if there is a non-empty
-                            intersection with the acceptable values.
-        exclude (bool): If False (the default value), configs that match the filter will be included in the returned
-            list. If True, configs that match the filter will be excluded in the returned list.
+
+        filter_dict (dict, optional): A dictionary specifying filter criteria where:
+            - Keys are field names to check in each configuration dictionary
+            - Values are lists/sets of acceptable values for that field
+            - A configuration matches if ALL filter keys are satisfied AND for each key,
+              the config's field value matches at least one acceptable value
+            - If a filter value includes None, configurations missing that field will match
+            - If None, no filtering is applied
+
+        exclude (bool, optional): If False (default), return configurations that match the filter.
+                                If True, return configurations that do NOT match the filter.
 
     Returns:
-        list of dict: A list of configuration dictionaries that meet all the criteria specified
-                      in `filter_dict`.
+        list of dict: Filtered list of configuration dictionaries.
 
-    Example:
+    Matching Logic:
+        - **Between different filter keys**: AND logic (all criteria must be satisfied)
+        - **Within each filter key's values**: OR logic (any acceptable value can match)
+        - **For list-type config values**: Match if there's any intersection with acceptable values
+        - **For scalar config values**: Match if the value is in the list of acceptable values
+        - **Missing fields**: Only match if None is included in the acceptable values for that field
+
+    Examples:
         ```python
-        # Example configuration list with various models and API types
         configs = [
-            {"model": "gpt-3.5-turbo"},
-            {"model": "gpt-4"},
-            {"model": "gpt-3.5-turbo", "api_type": "azure"},
-            {"model": "gpt-3.5-turbo", "tags": ["gpt35_turbo", "gpt-35-turbo"]},
+            {"model": "gpt-3.5-turbo", "api_type": "openai"},
+            {"model": "gpt-4", "api_type": "openai"},
+            {"model": "gpt-3.5-turbo", "api_type": "azure", "api_version": "2024-02-01"},
+            {"model": "gpt-4", "tags": ["premium", "latest"]},
         ]
-        # Define filter criteria to select configurations for the 'gpt-3.5-turbo' model
-        # that are also using the 'azure' API type
-        filter_criteria = {
-            "model": ["gpt-3.5-turbo"],  # Only accept configurations for 'gpt-3.5-turbo'
-            "api_type": ["azure"],  # Only accept configurations for 'azure' API type
-        }
-        # Apply the filter to the configuration list
-        filtered_configs = filter_config(configs, filter_criteria)
-        # The resulting `filtered_configs` will be:
-        # [{'model': 'gpt-3.5-turbo', 'api_type': 'azure', ...}]
-        # Define a filter to select a given tag
-        filter_criteria = {
-            "tags": ["gpt35_turbo"],
-        }
-        # Apply the filter to the configuration list
-        filtered_configs = filter_config(configs, filter_criteria)
-        # The resulting `filtered_configs` will be:
-        # [{'model': 'gpt-3.5-turbo', 'tags': ['gpt35_turbo', 'gpt-35-turbo']}]
+
+        # Example 1: Single criterion - matches any model in the list
+        filter_dict = {"model": ["gpt-4", "gpt-4o"]}
+        result = filter_config(configs, filter_dict)
+        # Returns: [{"model": "gpt-4", "api_type": "openai"}, {"model": "gpt-4", "tags": ["premium", "latest"]}]
+
+        # Example 2: Multiple criteria - must satisfy ALL conditions
+        filter_dict = {"model": ["gpt-3.5-turbo"], "api_type": ["azure"]}
+        result = filter_config(configs, filter_dict)
+        # Returns: [{"model": "gpt-3.5-turbo", "api_type": "azure", "api_version": "2024-02-01"}]
+
+        # Example 3: Tag filtering with list intersection
+        filter_dict = {"tags": ["premium"]}
+        result = filter_config(configs, filter_dict)
+        # Returns: [{"model": "gpt-4", "tags": ["premium", "latest"]}]
+
+        # Example 4: Exclude matching configurations
+        filter_dict = {"api_type": ["openai"]}
+        result = filter_config(configs, filter_dict, exclude=True)
+        # Returns configs that do NOT have api_type="openai"
         ```
     Note:
         - If `filter_dict` is empty or None, no filtering is applied and `config_list` is returned as is.
         - If a configuration dictionary in `config_list` does not contain a key specified in `filter_dict`,
           it is considered a non-match and is excluded from the result.
-        - If the list of acceptable values for a key in `filter_dict` includes None, then configuration
-          dictionaries that do not have that key will also be considered a match.
 
     """
     if inspect.stack()[1].function != "where":
@@ -538,18 +549,73 @@ def filter_config(
     return config_list
 
 
-def _satisfies_criteria(value: Any, criteria_values: Any) -> bool:
-    if value is None:
+def _satisfies_criteria(config_value: Any, criteria_values: Any) -> bool:
+    """Check if a configuration field value satisfies the filter criteria.
+
+    This helper function implements the matching logic between a single configuration
+    field value and the acceptable values specified in the filter criteria. It handles
+    both scalar and list-type configuration values with appropriate matching strategies.
+
+    Args:
+        config_value (Any): The value from a configuration dictionary field.
+                           Can be None, a scalar value, or a list of values.
+        criteria_values (Any): The acceptable values from the filter dictionary.
+                              Can be a single value or a list/set of acceptable values.
+
+    Returns:
+        bool: True if the config_value satisfies the criteria, False otherwise.
+
+    Matching Logic:
+        - **None config values**: Always return False (missing fields don't match)
+        - **List config values**:
+            - If criteria is a list: Match if there's any intersection (set overlap)
+            - If criteria is scalar: Match if the scalar is contained in the config list
+        - **Scalar config values**:
+            - If criteria is a list: Match if the config value is in the criteria list
+            - If criteria is scalar: Match if the values are exactly equal
+
+    Examples:
+        ```python
+        # List config value with list criteria (intersection matching)
+        _satisfies_criteria(["gpt-4", "gpt-3.5"], ["gpt-4", "claude"])  # True (gpt-4 intersects)
+        _satisfies_criteria(["tag1", "tag2"], ["tag3", "tag4"])  # False (no intersection)
+
+        # List config value with scalar criteria (containment matching)
+        _satisfies_criteria(["premium", "latest"], "premium")  # True (premium is in list)
+        _satisfies_criteria(["tag1", "tag2"], "tag3")  # False (tag3 not in list)
+
+        # Scalar config value with list criteria (membership matching)
+        _satisfies_criteria("gpt-4", ["gpt-4", "gpt-3.5"])  # True (gpt-4 in criteria)
+        _satisfies_criteria("claude", ["gpt-4", "gpt-3.5"])  # False (claude not in criteria)
+
+        # Scalar config value with scalar criteria (equality matching)
+        _satisfies_criteria("openai", "openai")  # True (exact match)
+        _satisfies_criteria("openai", "azure")  # False (different values)
+
+        # None config values (missing fields)
+        _satisfies_criteria(None, ["gpt-4"])  # False (missing field)
+        _satisfies_criteria(None, "gpt-4")  # False (missing field)
+        ```
+
+    Note:
+        This is an internal helper function used by `filter_config()`. The function
+        assumes that both parameters can be of various types and handles type
+        checking internally to determine the appropriate matching strategy.
+    """
+    if config_value is None:
         return False
 
-    if isinstance(value, list):
-        return bool(set(value) & set(criteria_values))  # Non-empty intersection
+    if isinstance(config_value, list):
+        if isinstance(criteria_values, list):
+            return bool(set(config_value) & set(criteria_values))  # Non-empty intersection
+        else:
+            return criteria_values in config_value
     else:
         # In filter_dict, filter could be either a list of values or a single value.
         # For example, filter_dict = {"model": ["gpt-3.5-turbo"]} or {"model": "gpt-3.5-turbo"}
         if isinstance(criteria_values, list):
-            return value in criteria_values
-        return bool(value == criteria_values)
+            return config_value in criteria_values
+        return bool(config_value == criteria_values)
 
 
 @export_module("autogen")
@@ -620,8 +686,6 @@ def config_list_from_json(
         with open(config_list_path) as json_file:
             config_list = json.load(json_file)
 
-    config_list = filter_config(config_list, filter_dict)
-
     return filter_config(config_list, filter_dict)
 
 

{ag2-0.9.6 → ag2-0.9.7}/autogen/tools/tool.py

@@ -96,8 +96,7 @@ class Tool:
         """
         if self._func_schema:
             agent.update_tool_signature(self._func_schema, is_remove=False)
-        else:
-            agent.register_for_llm()(self)
+        agent.register_for_llm()(self)
 
     def register_for_execution(self, agent: "ConversableAgent") -> None:
         """Registers the tool for direct execution by a ConversableAgent.

{ag2-0.9.6 → ag2-0.9.7}/autogen/version.py

@@ -4,4 +4,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.9.6"
+__version__ = "0.9.7"

ag2-0.9.7/website/docs/ecosystem/waldiez.mdx

@@ -0,0 +1,97 @@
+# Waldiez
+
+<img src="https://github.com/waldiez/waldiez/blob/main/docs/static/images/logo.png?raw=true" alt="Waldiez logo" width="300" />
+
+[Waldiez](https://waldiez.io) is an open-source, drag-and-drop platform that lets developers **design**, **orchestrate**, and **execute** multi-agent workflows across LLMs like OpenAI, Anthropic, Google, NVIDIA, Ollama, and more—backed by the AG2 multi-agent engine.
+
+## 🌟 Core Capabilities
+
+| Feature                          | Description                                                                 |
+|----------------------------------|-----------------------------------------------------------------------------|
+| 🧩 **Visual Workflow Builder**   | Build agent workflows visually via drag‑and‑drop—no code needed |
+| 🔄 **Multi-Agent Collaboration** | Real-time collaboration across agents using AG2 patterns |
+| 🌐 **Multi‑LLM & Tool Support**  | Integrates OpenAI, Anthropic, Gemini, Cohere, NVIDIA NIM, Ollama, and more |
+| ⚙️ **Rapid Prototyping**         | Export/import flows, agents, and skills easily for fast iteration |
+| 🛠 **Extensible via IDE/Studio** | Use Playground, JupyterLab, VS Code, or Waldiez Studio to design & run |
+| 🐳 **Docker‑Ready Execution**    | Run workflows via prebuilt Docker images for CLI, Jupyter, or Studio |
+
+---
+
+<img src="https://docs.waldiez.io/static/images/dark/front.webp#only-dark" alt="Waldiez logo" />
+
+## 🛠️ Installation & Setup
+
+### 1. Playground (No install)
+Use the web-based editor to visually design flows. It's **design-only**, ideal for quick mockups.
+
+### 2. Python SDK (via PyPI)
+
+#### CLI
+```bash
+pip install waldiez
+
+# Convert a Waldiez flow to a python script or a jupyter notebook
+waldiez convert --file /path/to/a/flow.waldiez --output /path/to/an/output/flow[.py|.ipynb]
+# Convert and run the script, optionally force generation if the output file already exists
+waldiez run --file /path/to/a/flow.waldiez --output /path/to/an/output/flow[.py|.ipynb] [--force]
+```
+
+#### JupyterLab
+```bash
+pip install waldiez[jupyter]
+# installs jupyterlab with waldiez extension for designing, converting and running waldiez flows
+```
+
+#### Studio
+```bash
+pip install waldiez[studio]
+# installs FastAPI-based app for designing, converting and running waldiez flows
+```
+
+### 3. Docker
+Use prebuilt images:
+
+- `waldiez/waldiez` – CLI
+- `waldiez/jupyter` – JupyterLab
+- `waldiez/studio` – FastAPI web UI
+
+```bash
+docker pull waldiez/waldiez
+docker pull waldiez/jupyter
+docker pull waldiez/studio
+```
+
+### 4. VS Code Extension
+Install the Waldiez [extension](https://marketplace.visualstudio.com/items?itemName=Waldiez.waldiez-vscode) for in-editor visual flow design.
+
+---
+
+
+## 🔬 Usage Workflow
+
+### Design
+Build workflows visually—add agents, models, tools, and set the data flow order.
+
+### Orchestrate
+Assign agent roles, handoffs and communication patterns.
+
+### Execute
+Use CLI, Docker, Jupyter, VS Code or Studio to run flows. Export to Python or notebook formats.
+
+### Monitor & Export
+View real-time logs, visualize cost analysis, and then export results (CSV, JSON) for further analysis.
+
+---
+
+## 🕹️ Remote execution
+
+Waldiez Runner orchestrates execution in isolated environments via:
+
+- **AG2 + FastStream** for isolated flow execution
+- **FastAPI + Taskiq** for task management
+- **Redis + WebSocket** for real-time I/O
+- **PostgreSQL** for persistence
+
+---
+
+For Waldiez examples and documentation visit [documentation](https://docs.waldiez.io)