ag2 0.10.2__py3-none-any.whl

autogen/llm_config/types.py

@@ -0,0 +1,37 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from autogen.oai.anthropic import AnthropicLLMConfigEntry
+from autogen.oai.bedrock import BedrockLLMConfigEntry
+from autogen.oai.cerebras import CerebrasLLMConfigEntry
+from autogen.oai.client import (
+    AzureOpenAILLMConfigEntry,
+    DeepSeekLLMConfigEntry,
+    OpenAILLMConfigEntry,
+    OpenAIResponsesLLMConfigEntry,
+    OpenAIV2LLMConfigEntry,
+)
+from autogen.oai.cohere import CohereLLMConfigEntry
+from autogen.oai.gemini import GeminiLLMConfigEntry
+from autogen.oai.groq import GroqLLMConfigEntry
+from autogen.oai.mistral import MistralLLMConfigEntry
+from autogen.oai.ollama import OllamaLLMConfigEntry
+from autogen.oai.together import TogetherLLMConfigEntry
+
+ConfigEntries = (
+    AnthropicLLMConfigEntry
+    | CerebrasLLMConfigEntry
+    | BedrockLLMConfigEntry
+    | AzureOpenAILLMConfigEntry
+    | DeepSeekLLMConfigEntry
+    | OpenAILLMConfigEntry
+    | OpenAIResponsesLLMConfigEntry
+    | OpenAIV2LLMConfigEntry
+    | CohereLLMConfigEntry
+    | GeminiLLMConfigEntry
+    | GroqLLMConfigEntry
+    | MistralLLMConfigEntry
+    | OllamaLLMConfigEntry
+    | TogetherLLMConfigEntry
+)

autogen/llm_config/utils.py

@@ -0,0 +1,223 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# Portions derived from  https://github.com/microsoft/autogen are under the MIT License.
+# SPDX-License-Identifier: MIT
+import json
+import os
+from pathlib import Path
+from typing import Any
+
+
+def config_list_from_json(
+    env_or_file: str | Path,
+    file_location: str | Path | None = "",
+    filter_dict: dict[str, list[str | None] | set[str | None]] | None = None,
+) -> list[dict[str, Any]]:
+    """Retrieves a list of API configurations from a JSON stored in an environment variable or a file.
+
+    This function attempts to parse JSON data from the given `env_or_file` parameter. If `env_or_file` is an
+    environment variable containing JSON data, it will be used directly. Otherwise, it is assumed to be a filename,
+    and the function will attempt to read the file from the specified `file_location`.
+
+    The `filter_dict` parameter allows for filtering the configurations based on specified criteria. Each key in the
+    `filter_dict` corresponds to a field in the configuration dictionaries, and the associated value is a list or set
+    of acceptable values for that field. If a field is missing in a configuration and `None` is included in the list
+    of acceptable values for that field, the configuration will still be considered a match.
+
+    Args:
+        env_or_file (str): The name of the environment variable, the filename, or the environment variable of the filename
+            that containing the JSON data.
+        file_location (str, optional): The directory path where the file is located, if `env_or_file` is a filename.
+        filter_dict (dict, optional): A dictionary specifying the filtering criteria for the configurations, with
+            keys representing field names and values being lists or sets of acceptable values for those fields.
+
+    Example:
+    ```python
+    # Suppose we have an environment variable 'CONFIG_JSON' with the following content:
+    # '[{"model": "gpt-3.5-turbo", "api_type": "azure"}, {"model": "gpt-4"}]'
+
+    # We can retrieve a filtered list of configurations like this:
+    filter_criteria = {"model": ["gpt-3.5-turbo"]}
+    configs = config_list_from_json("CONFIG_JSON", filter_dict=filter_criteria)
+    # The 'configs' variable will now contain only the configurations that match the filter criteria.
+    ```
+
+    Returns:
+        List[Dict]: A list of configuration dictionaries that match the filtering criteria specified in `filter_dict`.
+
+    Raises:
+        FileNotFoundError: if env_or_file is neither found as an environment variable nor a file
+    """
+    env_str = os.environ.get(str(env_or_file))
+
+    if env_str:
+        # The environment variable exists. We should use information from it.
+        if os.path.exists(env_str):  # noqa: SIM108
+            # It is a file location, and we need to load the json from the file.
+            json_str = Path(env_str).read_text()
+        else:
+            # Else, it should be a JSON string by itself.
+            json_str = env_str
+        config_list = json.loads(json_str)
+
+    else:
+        # The environment variable does not exist.
+        # So, `env_or_file` is a filename. We should use the file location.
+        config_list_path = Path(file_location) / env_or_file if file_location else Path(env_or_file)
+
+        with open(config_list_path) as json_file:
+            config_list = json.load(json_file)
+
+    return filter_config(config_list, filter_dict)
+
+
+def filter_config(
+    config_list: list[dict[str, Any]],
+    filter_dict: dict[str, list[str | None] | set[str | None]] | None,
+    exclude: bool = False,
+) -> list[dict[str, Any]]:
+    """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, 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: Filtered list of configuration dictionaries.
+
+    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
+        configs = [
+            {"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"]},
+        ]
+
+        # 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 filter_dict:
+        return [
+            item
+            for item in config_list
+            if all(_satisfies_criteria(item.get(key), values) != exclude for key, values in filter_dict.items())
+        ]
+
+    return config_list
+
+
+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(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 config_value in criteria_values
+        return bool(config_value == criteria_values)

autogen/logger/__init__.py

@@ -0,0 +1,11 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# Portions derived from  https://github.com/microsoft/autogen are under the MIT License.
+# SPDX-License-Identifier: MIT
+from .file_logger import FileLogger
+from .logger_factory import LoggerFactory
+from .sqlite_logger import SqliteLogger
+
+__all__ = ("FileLogger", "LoggerFactory", "SqliteLogger")

autogen/logger/base_logger.py

@@ -0,0 +1,129 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# Portions derived from  https://github.com/microsoft/autogen are under the MIT License.
+# SPDX-License-Identifier: MIT
+from __future__ import annotations
+
+import sqlite3
+import uuid
+from abc import ABC, abstractmethod
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, TypeVar
+
+if TYPE_CHECKING:
+    from openai import AzureOpenAI, OpenAI
+    from openai.types.chat import ChatCompletion
+
+    from .. import Agent, ConversableAgent, OpenAIWrapper
+
+F = TypeVar("F", bound=Callable[..., Any])
+ConfigItem = dict[str, str | list[str]]
+LLMConfig = dict[str, None | float | int | ConfigItem | list[ConfigItem]]
+
+
+class BaseLogger(ABC):
+    @abstractmethod
+    def start(self) -> str:
+        """Open a connection to the logging database, and start recording.
+
+        Returns:
+            session_id (str):     a unique id for the logging session
+        """
+        ...
+
+    @abstractmethod
+    def log_chat_completion(
+        self,
+        invocation_id: uuid.UUID,
+        client_id: int,
+        wrapper_id: int,
+        source: str | Agent,
+        request: dict[str, float | str | list[dict[str, str]]],
+        response: str | ChatCompletion,
+        is_cached: int,
+        cost: float,
+        start_time: str,
+    ) -> None:
+        """Log a chat completion to database.
+
+        In AG2, chat completions are somewhat complicated because they are handled by the `autogen.oai.OpenAIWrapper` class.
+        One invocation to `create` can lead to multiple underlying OpenAI calls, depending on the llm_config list used, and
+        any errors or retries.
+
+        Args:
+            invocation_id (uuid):               A unique identifier for the invocation to the OpenAIWrapper.create method call
+            client_id (int):                    A unique identifier for the underlying OpenAI client instance
+            wrapper_id (int):                   A unique identifier for the OpenAIWrapper instance
+            source (str or Agent):              The source/creator of the event as a string name or an Agent instance
+            request (dict):                     A dictionary representing the request or call to the OpenAI client endpoint
+            response (str or ChatCompletion):   The response from OpenAI
+            is_cached (int):                    1 if the response was a cache hit, 0 otherwise
+            cost(float):                        The cost for OpenAI response
+            start_time (str):                   A string representing the moment the request was initiated
+        """
+        ...
+
+    @abstractmethod
+    def log_new_agent(self, agent: ConversableAgent, init_args: dict[str, Any]) -> None:
+        """Log the birth of a new agent.
+
+        Args:
+            agent (ConversableAgent):   The agent to log.
+            init_args (dict):           The arguments passed to the construct the conversable agent
+        """
+        ...
+
+    @abstractmethod
+    def log_event(self, source: str | Agent, name: str, **kwargs: dict[str, Any]) -> None:
+        """Log an event for an agent.
+
+        Args:
+            source (str or Agent):      The source/creator of the event as a string name or an Agent instance
+            name (str):                 The name of the event
+            kwargs (dict):              The event information to log
+        """
+        ...
+
+    @abstractmethod
+    def log_new_wrapper(self, wrapper: OpenAIWrapper, init_args: dict[str, LLMConfig | list[LLMConfig]]) -> None:
+        """Log the birth of a new OpenAIWrapper.
+
+        Args:
+            wrapper (OpenAIWrapper):    The wrapper to log.
+            init_args (dict):           The arguments passed to the construct the wrapper
+        """
+        ...
+
+    @abstractmethod
+    def log_new_client(self, client: AzureOpenAI | OpenAI, wrapper: OpenAIWrapper, init_args: dict[str, Any]) -> None:
+        """Log the birth of a new OpenAIWrapper.
+
+        Args:
+            client: The client to log.
+            wrapper: The wrapper that created the client.
+            init_args: The arguments passed to the construct the client.
+        """
+        ...
+
+    @abstractmethod
+    def log_function_use(self, source: str | Agent, function: F, args: dict[str, Any], returns: Any) -> None:
+        """Log the use of a registered function (could be a tool)
+
+        Args:
+            source (str or Agent):      The source/creator of the event as a string name or an Agent instance
+            function (F):               The function information
+            args (dict):                The function args to log
+            returns (any):              The return
+        """
+
+    @abstractmethod
+    def stop(self) -> None:
+        """Close the connection to the logging database, and stop logging."""
+        ...
+
+    @abstractmethod
+    def get_connection(self) -> None | sqlite3.Connection:
+        """Return a connection to the logging database."""
+        ...

autogen/logger/file_logger.py

@@ -0,0 +1,262 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# Portions derived from  https://github.com/microsoft/autogen are under the MIT License.
+# SPDX-License-Identifier: MIT
+from __future__ import annotations
+
+import json
+import logging
+import os
+import threading
+import uuid
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from ..doc_utils import export_module
+from .base_logger import BaseLogger, LLMConfig
+from .logger_utils import get_current_ts, to_dict
+
+if TYPE_CHECKING:
+    from openai import AzureOpenAI, OpenAI
+    from openai.types.chat import ChatCompletion
+
+    from .. import Agent, ConversableAgent, OpenAIWrapper
+    from ..oai.anthropic import AnthropicClient
+    from ..oai.bedrock import BedrockClient
+    from ..oai.cerebras import CerebrasClient
+    from ..oai.cohere import CohereClient
+    from ..oai.gemini import GeminiClient
+    from ..oai.groq import GroqClient
+    from ..oai.mistral import MistralAIClient
+    from ..oai.ollama import OllamaClient
+    from ..oai.together import TogetherClient
+
+logger = logging.getLogger(__name__)
+
+F = TypeVar("F", bound=Callable[..., Any])
+
+__all__ = ("FileLogger",)
+
+
+def safe_serialize(obj: Any) -> str:
+    def default(o: Any) -> str:
+        if hasattr(o, "to_json"):
+            return str(o.to_json())
+        else:
+            return f"<<non-serializable: {type(o).__qualname__}>>"
+
+    return json.dumps(obj, default=default)
+
+
+@export_module("autogen.logger")
+class FileLogger(BaseLogger):
+    def __init__(self, config: dict[str, Any]):
+        self.config = config
+        self.session_id = str(uuid.uuid4())
+
+        curr_dir = os.getcwd()
+        self.log_dir = os.path.join(curr_dir, "autogen_logs")
+        os.makedirs(self.log_dir, exist_ok=True)
+
+        self.log_file = os.path.join(self.log_dir, self.config.get("filename", "runtime.log"))
+        try:
+            with open(self.log_file, "a"):
+                pass
+        except Exception as e:
+            logger.error(f"[file_logger] Failed to create logging file: {e}")
+
+        self.logger = logging.getLogger(__name__)
+        self.logger.setLevel(logging.INFO)
+        file_handler = logging.FileHandler(self.log_file)
+        self.logger.addHandler(file_handler)
+
+    def start(self) -> str:
+        """Start the logger and return the session_id."""
+        try:
+            self.logger.info(f"Started new session with Session ID: {self.session_id}")
+        except Exception as e:
+            logger.error(f"[file_logger] Failed to create logging file: {e}")
+        finally:
+            return self.session_id
+
+    def log_chat_completion(
+        self,
+        invocation_id: uuid.UUID,
+        client_id: int,
+        wrapper_id: int,
+        source: str | Agent,
+        request: dict[str, float | str | list[dict[str, str]]],
+        response: str | ChatCompletion,
+        is_cached: int,
+        cost: float,
+        start_time: str,
+    ) -> None:
+        """Log a chat completion."""
+        thread_id = threading.get_ident()
+        source_name = (
+            source
+            if isinstance(source, str)
+            else source.name
+            if hasattr(source, "name") and source.name is not None
+            else ""
+        )
+        try:
+            log_data = json.dumps({
+                "invocation_id": str(invocation_id),
+                "client_id": client_id,
+                "wrapper_id": wrapper_id,
+                "request": to_dict(request),
+                "response": str(response),
+                "is_cached": is_cached,
+                "cost": cost,
+                "start_time": start_time,
+                "end_time": get_current_ts(),
+                "thread_id": thread_id,
+                "source_name": source_name,
+            })
+
+            self.logger.info(log_data)
+        except Exception as e:
+            self.logger.error(f"[file_logger] Failed to log chat completion: {e}")
+
+    def log_new_agent(self, agent: ConversableAgent, init_args: dict[str, Any] = {}) -> None:
+        """Log a new agent instance."""
+        thread_id = threading.get_ident()
+
+        try:
+            log_data = json.dumps({
+                "id": id(agent),
+                "agent_name": agent.name if hasattr(agent, "name") and agent.name is not None else "",
+                "wrapper_id": to_dict(
+                    agent.client.wrapper_id if hasattr(agent, "client") and agent.client is not None else ""
+                ),
+                "session_id": self.session_id,
+                "current_time": get_current_ts(),
+                "agent_type": type(agent).__name__,
+                "args": to_dict(init_args),
+                "thread_id": thread_id,
+            })
+            self.logger.info(log_data)
+        except Exception as e:
+            self.logger.error(f"[file_logger] Failed to log new agent: {e}")
+
+    def log_event(self, source: str | Agent, name: str, **kwargs: dict[str, Any]) -> None:
+        """Log an event from an agent or a string source."""
+        from .. import Agent
+
+        # This takes an object o as input and returns a string. If the object o cannot be serialized, instead of raising an error,
+        # it returns a string indicating that the object is non-serializable, along with its type's qualified name obtained using __qualname__.
+        json_args = json.dumps(kwargs, default=lambda o: f"<<non-serializable: {type(o).__qualname__}>>")
+        thread_id = threading.get_ident()
+
+        if isinstance(source, Agent):
+            try:
+                log_data = json.dumps({
+                    "source_id": id(source),
+                    "source_name": str(source.name) if hasattr(source, "name") else source,
+                    "event_name": name,
+                    "agent_module": source.__module__,
+                    "agent_class": source.__class__.__name__,
+                    "json_state": json_args,
+                    "timestamp": get_current_ts(),
+                    "thread_id": thread_id,
+                })
+                self.logger.info(log_data)
+            except Exception as e:
+                self.logger.error(f"[file_logger] Failed to log event {e}")
+        else:
+            try:
+                log_data = json.dumps({
+                    "source_id": id(source),
+                    "source_name": str(source.name) if hasattr(source, "name") else source,
+                    "event_name": name,
+                    "json_state": json_args,
+                    "timestamp": get_current_ts(),
+                    "thread_id": thread_id,
+                })
+                self.logger.info(log_data)
+            except Exception as e:
+                self.logger.error(f"[file_logger] Failed to log event {e}")
+
+    def log_new_wrapper(self, wrapper: OpenAIWrapper, init_args: dict[str, LLMConfig | list[LLMConfig]] = {}) -> None:
+        """Log a new wrapper instance."""
+        thread_id = threading.get_ident()
+
+        try:
+            log_data = json.dumps({
+                "wrapper_id": id(wrapper),
+                "session_id": self.session_id,
+                "json_state": json.dumps(init_args),
+                "timestamp": get_current_ts(),
+                "thread_id": thread_id,
+            })
+            self.logger.info(log_data)
+        except Exception as e:
+            self.logger.error(f"[file_logger] Failed to log event {e}")
+
+    def log_new_client(
+        self,
+        client: (
+            AzureOpenAI
+            | OpenAI
+            | CerebrasClient
+            | GeminiClient
+            | AnthropicClient
+            | MistralAIClient
+            | TogetherClient
+            | GroqClient
+            | CohereClient
+            | OllamaClient
+            | BedrockClient
+        ),
+        wrapper: OpenAIWrapper,
+        init_args: dict[str, Any],
+    ) -> None:
+        """Log a new client instance."""
+        thread_id = threading.get_ident()
+
+        try:
+            log_data = json.dumps({
+                "client_id": id(client),
+                "wrapper_id": id(wrapper),
+                "session_id": self.session_id,
+                "class": type(client).__name__,
+                "json_state": json.dumps(init_args),
+                "timestamp": get_current_ts(),
+                "thread_id": thread_id,
+            })
+            self.logger.info(log_data)
+        except Exception as e:
+            self.logger.error(f"[file_logger] Failed to log event {e}")
+
+    def log_function_use(self, source: str | Agent, function: F, args: dict[str, Any], returns: Any) -> None:
+        """Log a registered function(can be a tool) use from an agent or a string source."""
+        thread_id = threading.get_ident()
+
+        try:
+            log_data = json.dumps({
+                "source_id": id(source),
+                "source_name": str(source.name) if hasattr(source, "name") else source,
+                "agent_module": source.__module__,
+                "agent_class": source.__class__.__name__,
+                "timestamp": get_current_ts(),
+                "thread_id": thread_id,
+                "input_args": safe_serialize(args),
+                "returns": safe_serialize(returns),
+            })
+            self.logger.info(log_data)
+        except Exception as e:
+            self.logger.error(f"[file_logger] Failed to log event {e}")
+
+    def get_connection(self) -> None:
+        """Method is intentionally left blank because there is no specific connection needed for the FileLogger."""
+        pass
+
+    def stop(self) -> None:
+        """Close the file handler and remove it from the logger."""
+        for handler in self.logger.handlers:
+            if isinstance(handler, logging.FileHandler):
+                handler.close()
+                self.logger.removeHandler(handler)