ag2 0.9.8.post1__py3-none-any.whl → 0.9.10__py3-none-any.whl

autogen/agentchat/groupchat.py

@@ -48,6 +48,7 @@ SELECT_SPEAKER_PROMPT_TEMPLATE = (
 @export_module("autogen")
 class GroupChat:
     """(In preview) A group chat class that contains the following data fields:
+
     - agents: a list of participating agents.
     - messages: a list of messages in the group chat.
     - max_round: the maximum number of rounds.
@@ -103,9 +104,9 @@ class GroupChat:
         Default is 2.
     - select_speaker_transform_messages: (optional) the message transformations to apply to the nested select speaker agent-to-agent chat messages.
         Takes a TransformMessages object, defaults to None and is only utilised when the speaker selection method is "auto".
-    - select_speaker_auto_verbose: whether to output the select speaker responses and selections
+    - select_speaker_auto_verbose: whether to output the select speaker responses and selections.
         If set to True, the outputs from the two agents in the nested select speaker chat will be output, along with
-        whether the responses were successful, or not, in selecting an agent
+        whether the responses were successful, or not, in selecting an agent.
         Applies only to "auto" speaker selection method.
     - allow_repeat_speaker: whether to allow the same speaker to speak consecutively.
         Default is True, in which case all speakers are allowed to speak consecutively.
@@ -174,6 +175,7 @@ class GroupChat:
     )
 
     allowed_speaker_transitions_dict: dict[str, list[Agent]] = field(init=False)
+    _inter_agent_guardrails: list = field(default_factory=list, init=False)
 
     def __post_init__(self):
         # Post init steers clears of the automatically generated __init__ method from dataclass
@@ -575,7 +577,7 @@ class GroupChat:
             return self.next_agent(last_speaker)
 
         # auto speaker selection with 2-agent chat
-        return self._auto_select_speaker(last_speaker, selector, messages, agents)
+        return self._auto_select_speaker(last_speaker, selector, messages if messages else self.messages, agents)
 
     async def a_select_speaker(self, last_speaker: Agent, selector: ConversableAgent) -> Agent:
         """Select the next speaker (with requery), asynchronously."""
@@ -587,7 +589,7 @@ class GroupChat:
             return self.next_agent(last_speaker)
 
         # auto speaker selection with 2-agent chat
-        return await self.a_auto_select_speaker(last_speaker, selector, messages, agents)
+        return await self.a_auto_select_speaker(last_speaker, selector, messages if messages else self.messages, agents)
 
     def _finalize_speaker(self, last_speaker: Agent, final: bool, name: str, agents: list[Agent] | None) -> Agent:
         if not final:
@@ -1000,7 +1002,7 @@ class GroupChat:
             message_content = message_content["content"]
         message_content = content_str(message_content)
 
-        mentions = dict()
+        mentions = {}
         for agent in agents:
             # Finds agent mentions, taking word boundaries into account,
             # accommodates escaping underscores and underscores as spaces
@@ -1052,6 +1054,30 @@ class GroupChat:
                 return f"{guardrail.activation_message}\nJustification: {guardrail_result.justification}"
         return None
 
+    def _run_inter_agent_guardrails(
+        self,
+        *,
+        src_agent_name: str,
+        dst_agent_name: str,
+        message_content: str,
+    ) -> str | None:
+        """Run policy-driven inter-agent guardrails, if any are configured.
+
+        Returns optional replacement content when a guardrail triggers.
+        """
+        guardrails = getattr(self, "_inter_agent_guardrails", None)
+        if not guardrails:
+            return None
+        for gr in guardrails:
+            reply = gr.check_and_act(
+                src_agent_name=src_agent_name,
+                dst_agent_name=dst_agent_name,
+                message_content=message_content,
+            )
+            if reply is not None:
+                return reply
+        return None
+
 
 @export_module("autogen")
 class GroupChatManager(ConversableAgent):
@@ -1208,7 +1234,21 @@ class GroupChatManager(ConversableAgent):
             # broadcast the message to all agents except the speaker
             for agent in groupchat.agents:
                 if agent != speaker:
-                    self.send(message, agent, request_reply=False, silent=True)
+                    inter_reply = groupchat._run_inter_agent_guardrails(
+                        src_agent_name=speaker.name,
+                        dst_agent_name=agent.name,
+                        message_content=message,
+                    )
+                    if inter_reply is not None:
+                        replacement = (
+                            {"content": inter_reply, "name": speaker.name}
+                            if not isinstance(inter_reply, dict)
+                            else inter_reply
+                        )
+                        self.send(replacement, agent, request_reply=False, silent=True)
+                    else:
+                        self.send(message, agent, request_reply=False, silent=True)
+
             if self._is_termination_msg(message):
                 # The conversation is over
                 termination_reason = f"Termination message condition on the GroupChatManager '{self.name}' met"
@@ -1707,19 +1747,20 @@ class GroupChatManager(ConversableAgent):
             agent._raise_exception_on_async_reply_functions()
 
     def clear_agents_history(self, reply: dict[str, Any], groupchat: GroupChat) -> str:
-        """Clears history of messages for all agents or selected one. Can preserve selected number of last messages.
-        That function is called when user manually provide "clear history" phrase in his reply.
-        When "clear history" is provided, the history of messages for all agents is cleared.
-        When "clear history `<agent_name>`" is provided, the history of messages for selected agent is cleared.
-        When "clear history `<nr_of_messages_to_preserve>`" is provided, the history of messages for all agents is cleared
-        except last `<nr_of_messages_to_preserve>` messages.
-        When "clear history `<agent_name>` `<nr_of_messages_to_preserve>`" is provided, the history of messages for selected
-        agent is cleared except last `<nr_of_messages_to_preserve>` messages.
-        Phrase "clear history" and optional arguments are cut out from the reply before it passed to the chat.
-
-        Args:
-            reply (dict): reply message dict to analyze.
-            groupchat (GroupChat): GroupChat object.
+        """Clears history of messages for all agents or a selected one. Can preserve a selected number of last messages.\n
+        \n
+        This function is called when the user manually provides the "clear history" phrase in their reply.\n
+        When "clear history" is provided, the history of messages for all agents is cleared.\n
+        When "clear history `<agent_name>`" is provided, the history of messages for the selected agent is cleared.\n
+        When "clear history `<nr_of_messages_to_preserve>`" is provided, the history of messages for all agents is cleared\n
+        except for the last `<nr_of_messages_to_preserve>` messages.\n
+        When "clear history `<agent_name>` `<nr_of_messages_to_preserve>`" is provided, the history of messages for the selected\n
+        agent is cleared except for the last `<nr_of_messages_to_preserve>` messages.\n
+        The phrase "clear history" and optional arguments are cut out from the reply before it is passed to the chat.\n
+        \n
+        Args:\n
+            reply (dict): reply message dict to analyze.\n
+            groupchat (GroupChat): GroupChat object.\n
         """
         iostream = IOStream.get_default()
 

autogen/agentchat/realtime/experimental/clients/realtime_client.py

@@ -8,7 +8,7 @@ from contextlib import AbstractAsyncContextManager
 from logging import Logger
 from typing import Any, Literal, Protocol, TypeVar, runtime_checkable
 
-from asyncer import create_task_group
+from anyio import create_task_group
 
 from .....doc_utils import export_module
 from .....llm_config import LLMConfig
@@ -140,7 +140,7 @@ class RealtimeClientBase:
         Args:
             audio (str): The audio.
         """
-        await self.add_event(InputAudioBufferDelta(delta=audio, item_id=None, raw_message=dict()))
+        await self.add_event(InputAudioBufferDelta(delta=audio, item_id=None, raw_message={}))
 
 
 _realtime_client_classes: dict[str, type[RealtimeClientProtocol]] = {}

autogen/agentchat/realtime/experimental/function_observer.py

@@ -2,14 +2,13 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-import asyncio
 import json
 from typing import TYPE_CHECKING, Any, Optional
 
-from asyncer import asyncify
 from pydantic import BaseModel
 
 from ....doc_utils import export_module
+from ....fast_depends.utils import asyncify
 from .realtime_events import FunctionCall, RealtimeEvent
 from .realtime_observer import RealtimeObserver
 
@@ -49,7 +48,7 @@ class FunctionObserver(RealtimeObserver):
         """
         if name in self.agent.registered_realtime_tools:
             func = self.agent.registered_realtime_tools[name].func
-            func = func if asyncio.iscoroutinefunction(func) else asyncify(func)
+            func = asyncify(func)
             try:
                 result = await func(**kwargs)
             except Exception:

autogen/agentchat/realtime/experimental/realtime_agent.py

@@ -7,8 +7,7 @@ from dataclasses import dataclass
 from logging import Logger, getLogger
 from typing import Any, TypeVar
 
-from anyio import lowlevel
-from asyncer import create_task_group
+from anyio import create_task_group, lowlevel
 
 from ....doc_utils import export_module
 from ....llm_config import LLMConfig
@@ -102,7 +101,7 @@ class RealtimeAgent:
 
     async def start_observers(self) -> None:
         for observer in self._observers:
-            self._tg.soonify(observer.run)(self)
+            self._tg.start_soon(observer.run, self)
 
         # wait for the observers to be ready
         for observer in self._observers:

autogen/agentchat/realtime/experimental/realtime_swarm.py

@@ -3,18 +3,21 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import logging
+import uuid
 import warnings
 from collections import defaultdict
 from collections.abc import Callable
+from functools import partial
 from typing import TYPE_CHECKING, Any, Optional, TypeVar
 
 import anyio
-from asyncer import asyncify, create_task_group, syncify
+from anyio import create_task_group, from_thread
 
 from ....agentchat.contrib.swarm_agent import AfterWorkOption, initiate_swarm_chat
 from ....cache import AbstractCache
 from ....code_utils import content_str
 from ....doc_utils import export_module
+from ....fast_depends.utils import asyncify
 from ... import Agent, ChatResult, ConversableAgent, LLMAgent
 from ...utils import consolidate_chat_info, gather_usage_summary
 
@@ -211,6 +214,7 @@ class SwarmableAgent(Agent):
         summary_args: dict[str, Any] | None = {},
         **kwargs: dict[str, Any],
     ) -> ChatResult:
+        chat_id = uuid.uuid4().int
         _chat_info = locals().copy()
         _chat_info["sender"] = self
         consolidate_chat_info(_chat_info, uniform_sender=self)
@@ -226,6 +230,7 @@ class SwarmableAgent(Agent):
         recipient.previous_cache = None  # type: ignore[attr-defined]
 
         chat_result = ChatResult(
+            chat_id=chat_id,
             chat_history=self.chat_messages[recipient],
             summary=summary,
             cost=gather_usage_summary([self, recipient]),  # type: ignore[arg-type]
@@ -349,7 +354,7 @@ class SwarmableRealtimeAgent(SwarmableAgent):
         self._agents = agents
         self._realtime_agent = realtime_agent
 
-        self._answer_event: anyio.Event = anyio.Event()
+        self._answer_event = anyio.Event()
         self._answer: str = ""
         self.question_message = question_message or QUESTION_MESSAGE
 
@@ -419,12 +424,13 @@ class SwarmableRealtimeAgent(SwarmableAgent):
 
         async def get_input() -> None:
             async with create_task_group() as tg:
-                tg.soonify(self.ask_question)(
+                tg.start_soon(
+                    self.ask_question,
                     self.question_message.format(messages[-1]["content"]),
                     question_timeout=QUESTION_TIMEOUT_SECONDS,
                 )
 
-        syncify(get_input)()
+        from_thread.run_sync(get_input)
 
         return True, {"role": "user", "content": self._answer}  # type: ignore[return-value]
 
@@ -449,12 +455,17 @@ class SwarmableRealtimeAgent(SwarmableAgent):
         )(self.set_answer)
 
         async def on_observers_ready() -> None:
-            self._realtime_agent._tg.soonify(asyncify(initiate_swarm_chat))(
-                initial_agent=self._initial_agent,
-                agents=self._agents,
-                user_agent=self,  # type: ignore[arg-type]
-                messages="Find out what the user wants.",
-                after_work=AfterWorkOption.REVERT_TO_USER,
+            self._realtime_agent._tg.start_soon(
+                asyncify(
+                    partial(
+                        initiate_swarm_chat,
+                        initial_agent=self._initial_agent,
+                        agents=self._agents,
+                        user_agent=self,  # type: ignore[arg-type]
+                        messages="Find out what the user wants.",
+                        after_work=AfterWorkOption.REVERT_TO_USER,
+                    )
+                )
             )
 
         self._realtime_agent.callbacks.on_observers_ready = on_observers_ready

autogen/agentchat/user_proxy_agent.py

@@ -15,15 +15,15 @@ from .conversable_agent import ConversableAgent
 
 @export_module("autogen")
 class UserProxyAgent(ConversableAgent):
-    """(In preview) A proxy agent for the user, that can execute code and provide feedback to the other agents.
-
-    UserProxyAgent is a subclass of ConversableAgent configured with `human_input_mode` to ALWAYS
-    and `llm_config` to False. By default, the agent will prompt for human input every time a message is received.
-    Code execution is enabled by default. LLM-based auto reply is disabled by default.
-    To modify auto reply, register a method with [`register_reply`](../ConversableAgent#register-reply).
-    To modify the way to get human input, override `get_human_input` method.
-    To modify the way to execute code blocks, single code block, or function call, override `execute_code_blocks`,
-    `run_code`, and `execute_function` methods respectively.
+    """(In preview) A proxy agent for the user, that can execute code and provide feedback to the other agents.\n
+    \n
+        UserProxyAgent is a subclass of ConversableAgent configured with `human_input_mode` to ALWAYS\n
+        and `llm_config` to False. By default, the agent will prompt for human input every time a message is received.\n
+        Code execution is enabled by default. LLM-based auto reply is disabled by default.\n
+        To modify auto reply, register a method with [`register_reply`](../ConversableAgent#register-reply).\n
+        To modify the way to get human input, override `get_human_input` method.\n
+        To modify the way to execute code blocks, single code block, or function call, override `execute_code_blocks`,\n
+        `run_code`, and `execute_function` methods respectively.\n
     """
 
     # Default UserProxyAgent.description values, based on human_input_mode
@@ -47,50 +47,52 @@ class UserProxyAgent(ConversableAgent):
         description: str | None = None,
         **kwargs: Any,
     ):
-        """Args:
-        name (str): name of the agent.
-        is_termination_msg (function): a function that takes a message in the form of a dictionary
-            and returns a boolean value indicating if this received message is a termination message.
-            The dict can contain the following keys: "content", "role", "name", "function_call".
-        max_consecutive_auto_reply (int): the maximum number of consecutive auto replies.
-            default to None (no limit provided, class attribute MAX_CONSECUTIVE_AUTO_REPLY will be used as the limit in this case).
-            The limit only plays a role when human_input_mode is not "ALWAYS".
-        human_input_mode (str): whether to ask for human inputs every time a message is received.
-            Possible values are "ALWAYS", "TERMINATE", "NEVER".
-            (1) When "ALWAYS", the agent prompts for human input every time a message is received.
-                Under this mode, the conversation stops when the human input is "exit",
-                or when is_termination_msg is True and there is no human input.
-            (2) When "TERMINATE", the agent only prompts for human input only when a termination message is received or
-                the number of auto reply reaches the max_consecutive_auto_reply.
-            (3) When "NEVER", the agent will never prompt for human input. Under this mode, the conversation stops
-                when the number of auto reply reaches the max_consecutive_auto_reply or when is_termination_msg is True.
-        function_map (dict[str, callable]): Mapping function names (passed to openai) to callable functions.
-        code_execution_config (dict or False): config for the code execution.
-            To disable code execution, set to False. Otherwise, set to a dictionary with the following keys:
-            - work_dir (Optional, str): The working directory for the code execution.
-                If None, a default working directory will be used.
-                The default working directory is the "extensions" directory under
-                "path_to_autogen".
-            - use_docker (Optional, list, str or bool): The docker image to use for code execution.
-                Default is True, which means the code will be executed in a docker container. A default list of images will be used.
-                If a list or a str of image name(s) is provided, the code will be executed in a docker container
-                with the first image successfully pulled.
-                If False, the code will be executed in the current environment.
-                We strongly recommend using docker for code execution.
-            - timeout (Optional, int): The maximum execution time in seconds.
-            - last_n_messages (Experimental, Optional, int): The number of messages to look back for code execution. Default to 1.
-        default_auto_reply (str or dict or None): the default auto reply message when no code execution or llm based reply is generated.
-        llm_config (LLMConfig or dict or False or None): llm inference configuration.
-            Please refer to [OpenAIWrapper.create](https://docs.ag2.ai/latest/docs/api-reference/autogen/OpenAIWrapper/#autogen.OpenAIWrapper.create)
-            for available options.
-            Default to False, which disables llm-based auto reply.
-            When set to None, will use self.DEFAULT_CONFIG, which defaults to False.
-        system_message (str or List): system message for ChatCompletion inference.
-            Only used when llm_config is not False. Use it to reprogram the agent.
-        description (str): a short description of the agent. This description is used by other agents
-            (e.g. the GroupChatManager) to decide when to call upon this agent. (Default: system_message)
-        **kwargs (dict): Please refer to other kwargs in
-            [ConversableAgent](https://docs.ag2.ai/latest/docs/api-reference/autogen/ConversableAgent).
+        """Initialize a UserProxyAgent.
+
+        Args:
+        name (str): name of the agent.\n
+        is_termination_msg (function): a function that takes a message in the form of a dictionary\n
+            and returns a boolean value indicating if this received message is a termination message.\n
+            The dict can contain the following keys: "content", "role", "name", "function_call".\n
+        max_consecutive_auto_reply (int): the maximum number of consecutive auto replies.\n
+            default to None (no limit provided, class attribute MAX_CONSECUTIVE_AUTO_REPLY will be used as the limit in this case).\n
+            The limit only plays a role when human_input_mode is not "ALWAYS".\n
+        human_input_mode (str): whether to ask for human inputs every time a message is received.\n
+            Possible values are "ALWAYS", "TERMINATE", "NEVER".\n
+            (1) When "ALWAYS", the agent prompts for human input every time a message is received.\n
+                Under this mode, the conversation stops when the human input is "exit",\n
+                or when is_termination_msg is True and there is no human input.\n
+            (2) When "TERMINATE", the agent only prompts for human input only when a termination message is received or\n
+                the number of auto reply reaches the max_consecutive_auto_reply.\n
+            (3) When "NEVER", the agent will never prompt for human input. Under this mode, the conversation stops\n
+                when the number of auto reply reaches the max_consecutive_auto_reply or when is_termination_msg is True.\n
+        function_map (dict[str, callable]): Mapping function names (passed to openai) to callable functions.\n
+        code_execution_config (dict or False): config for the code execution.\n
+            To disable code execution, set to False. Otherwise, set to a dictionary with the following keys:\n
+            - work_dir (Optional, str): The working directory for the code execution.\n
+                If None, a default working directory will be used.\n
+                The default working directory is the "extensions" directory under\n
+                "path_to_autogen".\n
+            - use_docker (Optional, list, str or bool): The docker image to use for code execution.\n
+                Default is True, which means the code will be executed in a docker container. A default list of images will be used.\n
+                If a list or a str of image name(s) is provided, the code will be executed in a docker container\n
+                with the first image successfully pulled.\n
+                If False, the code will be executed in the current environment.\n
+                We strongly recommend using docker for code execution.\n
+            - timeout (Optional, int): The maximum execution time in seconds.\n
+            - last_n_messages (Experimental, Optional, int): The number of messages to look back for code execution. Default to 1.\n
+        default_auto_reply (str or dict or None): the default auto reply message when no code execution or llm based reply is generated.\n
+        llm_config (LLMConfig or dict or False or None): llm inference configuration.\n
+            Please refer to [OpenAIWrapper.create](https://docs.ag2.ai/latest/docs/api-reference/autogen/OpenAIWrapper/#autogen.OpenAIWrapper.create)\n
+            for available options.\n
+            Default to False, which disables llm-based auto reply.\n
+            When set to None, will use self.DEFAULT_CONFIG, which defaults to False.\n
+        system_message (str or List): system message for ChatCompletion inference.\n
+            Only used when llm_config is not False. Use it to reprogram the agent.\n
+        description (str): a short description of the agent. This description is used by other agents\n
+            (e.g. the GroupChatManager) to decide when to call upon this agent. (Default: system_message)\n
+        **kwargs (dict): Please refer to other kwargs in\n
+            [ConversableAgent](https://docs.ag2.ai/latest/docs/api-reference/autogen/ConversableAgent).\n
         """
         super().__init__(
             name=name,

autogen/agents/experimental/document_agent/document_agent.py

@@ -198,15 +198,6 @@ class DocAgent(ConversableAgent):
         )
         self.register_reply([ConversableAgent, None], self.generate_inner_group_chat_reply, position=0)
 
-        self.context_variables: ContextVariables = ContextVariables(
-            data={
-                "DocumentsToIngest": [],
-                "DocumentsIngested": [],
-                "QueriesToRun": [],
-                "QueryResults": [],
-            }
-        )
-
         self._triage_agent = DocumentTriageAgent(llm_config=llm_config)
 
         def create_error_agent_prompt(agent: ConversableAgent, messages: list[dict[str, Any]]) -> str:
@@ -396,7 +387,7 @@ class DocAgent(ConversableAgent):
             else:
                 # First time initialization - no deduplication needed
                 context_variables["DocumentsToIngest"] = ingestions
-                context_variables["QueriesToRun"] = [query for query in queries]
+                context_variables["QueriesToRun"] = list(queries)
                 context_variables["TaskInitiated"] = True
                 response_message = "Updated context variables with task decisions"
 

autogen/agents/experimental/document_agent/parser_utils.py

@@ -15,7 +15,11 @@ from .document_utils import handle_input
 
 with optional_import_block():
     from docling.datamodel.base_models import InputFormat
-    from docling.datamodel.pipeline_options import AcceleratorDevice, AcceleratorOptions, PdfPipelineOptions
+    from docling.datamodel.pipeline_options import (  # type: ignore[attr-defined]
+        AcceleratorDevice,
+        AcceleratorOptions,
+        PdfPipelineOptions,
+    )
     from docling.document_converter import DocumentConverter, PdfFormatOption
 
 __all__ = ["docling_parse_docs"]

autogen/browser_utils.py

@@ -58,10 +58,10 @@ class SimpleTextBrowser:
         self.start_page: str = start_page if start_page else "about:blank"
         self.viewport_size = viewport_size  # Applies only to the standard uri types
         self.downloads_folder = downloads_folder
-        self.history: list[str] = list()
+        self.history: list[str] = []
         self.page_title: str | None = None
         self.viewport_current_page = 0
-        self.viewport_pages: list[tuple[int, int]] = list()
+        self.viewport_pages: list[tuple[int, int]] = []
         self.set_address(self.start_page)
         self.bing_base_url = bing_base_url
         self.bing_api_key = bing_api_key
@@ -182,7 +182,7 @@ class SimpleTextBrowser:
     def _bing_search(self, query: str) -> None:
         results = self._bing_api_call(query)
 
-        web_snippets: list[str] = list()
+        web_snippets: list[str] = []
         idx = 0
         for page in results["webPages"]["value"]:
             idx += 1
@@ -194,7 +194,7 @@ class SimpleTextBrowser:
                         f"{idx}. [{dl['name']}]({dl['url']})\n{dl.get('snippet', '')}"  # type: ignore[index]
                     )
 
-        news_snippets = list()
+        news_snippets = []
         if "news" in results:
             for page in results["news"]["value"]:
                 idx += 1

autogen/cache/abstract_cache_base.py

@@ -4,16 +4,12 @@
 #
 # Portions derived from  https://github.com/microsoft/autogen are under the MIT License.
 # SPDX-License-Identifier: MIT
-import sys
 from types import TracebackType
 from typing import Any, Protocol
 
-from ..doc_utils import export_module
+from typing_extensions import Self
 
-if sys.version_info >= (3, 11):
-    from typing import Self
-else:
-    from typing_extensions import Self
+from ..doc_utils import export_module
 
 
 @export_module("autogen.cache")

autogen/cache/disk_cache.py

@@ -4,19 +4,14 @@
 #
 # Portions derived from  https://github.com/microsoft/autogen are under the MIT License.
 # SPDX-License-Identifier: MIT
-import sys
 from types import TracebackType
 from typing import Any
 
 import diskcache
+from typing_extensions import Self
 
 from .abstract_cache_base import AbstractCache
 
-if sys.version_info >= (3, 11):
-    from typing import Self
-else:
-    from typing_extensions import Self
-
 
 class DiskCache(AbstractCache):
     """Implementation of AbstractCache using the DiskCache library.

autogen/cache/in_memory_cache.py

@@ -4,16 +4,12 @@
 #
 # Portions derived from  https://github.com/microsoft/autogen are under the MIT License.
 # SPDX-License-Identifier: MIT
-import sys
 from types import TracebackType
 from typing import Any
 
-from .abstract_cache_base import AbstractCache
+from typing_extensions import Self
 
-if sys.version_info >= (3, 11):
-    from typing import Self
-else:
-    from typing_extensions import Self
+from .abstract_cache_base import AbstractCache
 
 
 class InMemoryCache(AbstractCache):

autogen/cache/redis_cache.py

@@ -5,14 +5,10 @@
 # Portions derived from  https://github.com/microsoft/autogen are under the MIT License.
 # SPDX-License-Identifier: MIT
 import pickle
-import sys
 from types import TracebackType
 from typing import Any
 
-if sys.version_info >= (3, 11):
-    from typing import Self
-else:
-    from typing_extensions import Self
+from typing_extensions import Self
 
 from ..import_utils import optional_import_block, require_optional_import
 from .abstract_cache_base import AbstractCache

autogen/coding/__init__.py

@@ -10,7 +10,7 @@ from .factory import CodeExecutorFactory
 from .local_commandline_code_executor import LocalCommandLineCodeExecutor
 from .markdown_code_extractor import MarkdownCodeExtractor
 
-__all__ = (
+__all__ = [
     "CodeBlock",
     "CodeExecutor",
     "CodeExecutorFactory",
@@ -19,4 +19,12 @@ __all__ = (
     "DockerCommandLineCodeExecutor",
     "LocalCommandLineCodeExecutor",
     "MarkdownCodeExtractor",
-)
+]
+
+# Try to import YepCode executor and add to __all__ if available
+try:
+    from .yepcode_code_executor import YepCodeCodeExecutor, YepCodeCodeResult  # noqa: F401
+
+    __all__.extend(["YepCodeCodeExecutor", "YepCodeCodeResult"])
+except ImportError:
+    pass

autogen/coding/base.py

@@ -98,13 +98,14 @@ class IPythonCodeResult(CodeResult):
 CodeExecutionConfig = TypedDict(
     "CodeExecutionConfig",
     {
-        "executor": Literal["ipython-embedded", "commandline-local"] | CodeExecutor,
+        "executor": Literal["ipython-embedded", "commandline-local", "yepcode"] | CodeExecutor,
         "last_n_messages": int | Literal["auto"],
         "timeout": int,
         "use_docker": bool | str | list[str],
         "work_dir": str,
         "ipython-embedded": Mapping[str, Any],
         "commandline-local": Mapping[str, Any],
+        "yepcode": Mapping[str, Any],
     },
     total=False,
 )