youtu-agent 0.1.2__py3-none-any.whl

utils/__init__.py

@@ -0,0 +1,35 @@
+from .agents_utils import AgentsUtils, ChatCompletionConverter
+from .common import get_event_loop, load_class_from_file, schema_to_basemodel
+from .env import EnvUtils
+from .image import encode_image
+from .llm_output_parser import LLMOutputParser
+from .log import get_logger, oneline_object, setup_logging
+from .openai_utils import OpenAIUtils, SimplifiedAsyncOpenAI
+from .path import CACHE_DIR, DIR_ROOT, FileUtils
+from .print_utils import PrintUtils
+from .sqlmodel_utils import SQLModelUtils
+from .token import TokenUtils
+from .tool_cache import async_file_cache
+
+__all__ = [
+    "PrintUtils",
+    "SimplifiedAsyncOpenAI",
+    "OpenAIUtils",
+    "AgentsUtils",
+    "ChatCompletionConverter",
+    "oneline_object",
+    "setup_logging",
+    "schema_to_basemodel",
+    "load_class_from_file",
+    "get_logger",
+    "SQLModelUtils",
+    "async_file_cache",
+    "DIR_ROOT",
+    "FileUtils",
+    "CACHE_DIR",
+    "TokenUtils",
+    "get_event_loop",
+    "EnvUtils",
+    "LLMOutputParser",
+    "encode_image",
+]

utils/agents_utils.py

@@ -0,0 +1,359 @@
+import json
+import logging
+import os
+import uuid
+from collections.abc import AsyncIterator, Iterable
+from typing import Literal
+
+from agents import (
+    FunctionTool,
+    HandoffOutputItem,
+    ItemHelpers,
+    MessageOutputItem,
+    Model,
+    ModelSettings,
+    ModelTracing,
+    OpenAIChatCompletionsModel,
+    OpenAIResponsesModel,
+    ReasoningItem,
+    RunItem,
+    RunResult,
+    StreamEvent,
+    ToolCallItem,
+    ToolCallOutputItem,
+    TResponseInputItem,
+)
+from agents.models.chatcmpl_converter import Converter
+from agents.stream_events import AgentUpdatedStreamEvent, RawResponsesStreamEvent, RunItemStreamEvent
+from agents.tracing import Trace, gen_trace_id, get_current_trace
+from openai import AsyncOpenAI
+from openai.types.chat import ChatCompletionMessageParam, ChatCompletionToolParam
+from openai.types.responses import ResponseFunctionToolCall
+
+from .image import encode_image
+from .openai_utils import OpenAIChatCompletionParams
+from .print_utils import PrintUtils
+
+logger = logging.getLogger(__name__)
+
+
+class ChatCompletionConverter(Converter):
+    @classmethod
+    def items_to_messages(cls, items: str | Iterable[TResponseInputItem]) -> list[ChatCompletionMessageParam]:
+        # skip reasoning, see chatcmpl_converter.Converter.items_to_messages()
+        # agents.exceptions.UserError: Unhandled item type or structure:
+        # {'id': '__fake_id__', 'summary': [{'text': '...', 'type': 'summary_text'}], 'type': 'reasoning'}
+        if not isinstance(items, str):  # TODO: check it!
+            items = cls.filter_items(items)
+        return Converter.items_to_messages(items)
+
+    @classmethod
+    def filter_items(cls, items: str | Iterable[TResponseInputItem]) -> str | list[TResponseInputItem]:
+        if isinstance(items, str):
+            return items
+        filtered_items = []
+        for item in items:
+            if item.get("type", None) == "reasoning":
+                continue
+            filtered_items.append(item)
+        return filtered_items
+
+    @classmethod
+    def items_to_dict(cls, items: str | Iterable[TResponseInputItem]) -> list[dict]:
+        """convert items to a list of dict which have {"role", "content"}
+        WIP!
+        """
+        if isinstance(items, str):
+            return [{"role": "user", "content": items}]
+        result = []
+        for item in items:
+            if msg := Converter.maybe_easy_input_message(item):
+                result.append(msg)
+            elif msg := Converter.maybe_input_message(item):
+                result.append(msg)
+            elif msg := Converter.maybe_response_output_message(item):
+                result.append(msg)
+            elif msg := Converter.maybe_file_search_call(item):
+                msg.update({"role": "tool", "content": msg["results"]})
+                result.append(msg)
+            elif msg := Converter.maybe_function_tool_call(item):
+                msg.update({"role": "assistant", "content": f"{msg['name']}({msg['arguments']})"})
+                result.append(msg)
+            elif msg := Converter.maybe_function_tool_call_output(item):
+                msg.update({"role": "tool", "content": msg["output"], "tool_call_id": msg["call_id"]})
+                result.append(msg)
+            elif msg := Converter.maybe_reasoning_message(item):
+                msg.update({"role": "assistant", "content": msg["summary"]})
+                result.append(msg)
+            else:
+                logger.warning(f"Unknown message type: {item}")
+                result.append({"role": "assistant", "content": f"Unknown message type: {item}"})
+        return result
+
+
+class AgentsUtils:
+    """Utils for openai-agents SDK"""
+
+    @staticmethod
+    def generate_group_id() -> str:
+        """Generate a unique group ID. (Used in OpenAI tracing)
+        Ref: https://openai.github.io/openai-agents-python/tracing/
+        """
+        return uuid.uuid4().hex[:16]
+
+    @staticmethod
+    def gen_trace_id() -> str:
+        return gen_trace_id()
+
+    @staticmethod
+    def get_current_trace() -> Trace:
+        return get_current_trace()
+
+    @staticmethod
+    def get_agents_model(
+        type: Literal["responses", "chat.completions", "litellm"] = None,
+        model: str = None,
+        base_url: str = None,
+        api_key: str = None,
+    ) -> Model:
+        type = type or os.getenv("UTU_LLM_TYPE", "chat.completions")
+        model = model or os.getenv("UTU_LLM_MODEL")
+        if type == "litellm":
+            # Ref: https://docs.litellm.ai/docs/providers
+            # NOTE: should set .evn properly! e.g. AZURE_API_KEY, AZURE_API_BASE, AZURE_API_VERSION for Azure
+            #   https://docs.litellm.ai/docs/providers/azure/
+            from agents.extensions.models.litellm_model import LitellmModel
+
+            return LitellmModel(model=model)
+
+        base_url = base_url or os.getenv("UTU_LLM_BASE_URL")
+        api_key = api_key or os.getenv("UTU_LLM_API_KEY")
+        if not api_key or not base_url:
+            raise ValueError("UTU_LLM_API_KEY and UTU_LLM_BASE_URL must be set")
+        openai_client = AsyncOpenAI(
+            api_key=api_key,
+            base_url=base_url,
+            timeout=100,
+        )
+        if type == "chat.completions":
+            return OpenAIChatCompletionsModel(model=model, openai_client=openai_client)
+        elif type == "responses":
+            return OpenAIResponsesModel(model=model, openai_client=openai_client)
+        else:
+            raise ValueError("Invalid type: " + type)
+
+    @staticmethod
+    def get_trajectory_from_agent_result(agent_result: RunResult, agent_name: str = None) -> dict:
+        if agent_name is None:
+            agent_name = agent_result.last_agent.name
+        return {
+            "agent": agent_name,
+            "trajectory": ChatCompletionConverter.items_to_messages(agent_result.to_input_list()),
+        }
+
+    @staticmethod
+    def print_new_items(new_items: list[RunItem]) -> None:
+        """Print new items generated by Runner.run()"""
+        for new_item in new_items:
+            agent_name = new_item.agent.name
+            if isinstance(new_item, MessageOutputItem):
+                PrintUtils.print_bot(f"{agent_name}: {ItemHelpers.text_message_output(new_item)}")
+            elif isinstance(new_item, HandoffOutputItem):
+                PrintUtils.print_info(f"Handed off from {new_item.source_agent.name} to {new_item.target_agent.name}")
+            elif isinstance(new_item, ToolCallItem):
+                assert isinstance(new_item.raw_item, ResponseFunctionToolCall)  # DONOT use openai's built-in tools
+                PrintUtils.print_info(
+                    f"{agent_name}: Calling a tool: {new_item.raw_item.name}({json.loads(new_item.raw_item.arguments)})"
+                )
+            elif isinstance(new_item, ToolCallOutputItem):
+                PrintUtils.print_tool(f"Tool call output: {new_item.output}")
+            elif isinstance(new_item, ReasoningItem):
+                PrintUtils.print_info(f"{agent_name}: Reasoning: {new_item.raw_item}")
+            else:
+                PrintUtils.print_info(f"{agent_name}: Skipping item: {new_item.__class__.__name__}")
+
+    @staticmethod
+    async def print_stream_events(result: AsyncIterator[StreamEvent]) -> None:
+        """Print stream events generated by Runner.run_streamed()"""
+        async for event in result:
+            # print(f"> [DEBUG] event: {event}")
+            if isinstance(event, RawResponsesStreamEvent):
+                # event.data -- ResponseStreamEvent
+                if event.data.type == "response.output_item.added":
+                    match event.data.item.type:
+                        # computer_call, code_interpreter_call, custom_tool_call, file_search_call, function_call,
+                        # we_search_call, image_generation_call, local_shell_call,
+                        # mcp_call, mcp_list_tools, mcp_approval_request, message, reasoning
+                        case "message":
+                            pass
+                        case "function_call":
+                            PrintUtils.print_bot(
+                                f"<toolcall name={event.data.item.name}>{event.data.item.arguments}", end=""
+                            )
+                        case _:
+                            PrintUtils.print_bot(f"<{event.data.item.type}>", end="")
+                elif event.data.type == "response.output_item.done":
+                    match event.data.item.type:
+                        case "message":
+                            pass
+                            # PrintUtils.print_bot("")  # add a new line?
+                        case "function_call":
+                            PrintUtils.print_bot("</toolcall>")
+                        case _:
+                            # PrintUtils.print_bot(f"</{event.data.item.type}>")
+                            logger.info(f"</{event.data.item.type}>")  # It seems that vllm's output order is wrong
+                elif event.data.type == "response.content_part.added":
+                    match event.data.part.type:
+                        # output_text, refusal
+                        case "output_text":
+                            pass
+                        case "refusal":
+                            PrintUtils.print_bot(f"<refusal>{event.data.part.refusal}", end="")
+                        case _:
+                            logger.warning(f"Unknown part type: {event.data.part.type}! {event}")
+                elif event.data.type == "response.content_part.done":
+                    match event.data.part.type:
+                        case "output_text":
+                            pass
+                        case "refusal":
+                            PrintUtils.print_bot("</refusal>")
+                        case _:
+                            logger.warning(f"Unknown part type: {event.data.part.type}! {event}")
+                elif event.data.type == "response.reasoning_summary_part.added":
+                    PrintUtils.print_info("<reasoning_summary>", end="")
+                elif event.data.type == "response.reasoning_summary_part.done":
+                    # PrintUtils.print_info("</reasoning_summary>", end="")
+                    logger.info("</reasoning_summary>")  # It seems that vllm's output order is wrong
+                elif event.data.type == "response.reasoning_summary_text.delta":
+                    PrintUtils.print_info(f"{event.data.delta}", end="")
+                elif event.data.type == "response.function_call_arguments.delta":
+                    PrintUtils.print_bot(f"{event.data.delta}", end="")
+                elif event.data.type == "response.function_call_arguments.done":
+                    pass
+                elif event.data.type == "response.output_text.delta":
+                    PrintUtils.print_bot(f"{event.data.delta}", end="")
+                elif event.data.type == "response.reasoning_text.delta":
+                    PrintUtils.print_info(f"{event.data.delta}", end="")
+                elif event.data.type == "response.reasoning_text.done":
+                    PrintUtils.print_info("</reasoning_text>", end="")
+                elif event.data.type in ("response.output_text.done",):
+                    PrintUtils.print_info("")
+                elif event.data.type in (
+                    "response.created",
+                    "response.completed",
+                    "response.in_progress",
+                ):
+                    pass
+                else:
+                    PrintUtils.print_info(f"Unknown event type: {event.data.type}! {event}")
+                    # raise ValueError(f"Unknown event type: {event.data.type}")
+            elif isinstance(event, RunItemStreamEvent):
+                item: RunItem = event.item
+                if item.type == "message_output_item":
+                    pass  # do not print twice to avoid duplicate! (already handled `response.output_text.delta`)
+                    # PrintUtils.print_bot(f"{ItemHelpers.text_message_output(item).strip()}")
+                elif item.type == "reasoning_item":
+                    pass
+                elif item.type == "tool_call_item":
+                    pass
+                    # PrintUtils.print_bot([tool_call] {item.raw_item.name}({item.raw_item.arguments})")
+                elif item.type == "tool_call_output_item":
+                    PrintUtils.print_tool(f"[tool_output] {item.output}")  # item.raw_item
+                elif item.type == "handoff_call_item":  # same as `ToolCallItem`
+                    PrintUtils.print_bot(f"[handoff_call] {item.raw_item.name}({item.raw_item.arguments})")
+                elif item.type == "handoff_output_item":
+                    PrintUtils.print_info(f">> Handoff from {item.source_agent.name} to {item.target_agent.name}")
+                elif event.type in (
+                    "mcp_list_tools_item",
+                    "mcp_approval_request_item",
+                    "mcp_approval_response_item",
+                ):
+                    PrintUtils.print_info(f"  >>> Skipping item: {event}")
+                else:
+                    PrintUtils.print_info(f"  >>> Skipping item: {item.__class__.__name__}")
+            elif isinstance(event, AgentUpdatedStreamEvent):
+                PrintUtils.print_info(f">> new agent: {event.new_agent.name}")
+            # skip events from youtu-agent
+            elif event.type in ("orchestrator_stream_event", "orchestra_stream_event"):
+                pass
+            else:
+                logger.warning(f"Unknown event type: {event.type}! {event}")
+        print()  # Newline after stream?
+
+    @staticmethod
+    def convert_model_settings(params: OpenAIChatCompletionParams) -> ModelSettings:
+        # "tools", "messages", "model"
+        # FIXME: move to extra_args
+        for p in ("max_completion_tokens", "top_logprobs", "logprobs", "seed", "stop"):
+            if p in params:
+                logger.warning(f"Parameter `{p}` is not supported in ModelSettings")
+        return ModelSettings(
+            max_tokens=params.get("max_tokens", None),
+            temperature=params.get("temperature", None),
+            top_p=params.get("top_p", None),
+            frequency_penalty=params.get("frequency_penalty", None),
+            presence_penalty=params.get("presence_penalty", None),
+            tool_choice=params.get("tool_choice", None),
+            parallel_tool_calls=params.get("parallel_tool_calls", None),
+            extra_query=params.get("extra_query", None),
+            extra_body=params.get("extra_body", None),
+            extra_headers=params.get("extra_headers", None),
+        )
+
+    @staticmethod
+    def convert_sp_input(
+        messages: list[ChatCompletionMessageParam],
+    ) -> tuple[str | None, str | list[TResponseInputItem]]:
+        if isinstance(messages, str):
+            return None, messages
+        if messages[0].get("role", None) == "system":
+            return messages[0]["content"], messages[1:]
+        return None, messages
+
+    @staticmethod
+    def convert_tool(tool: ChatCompletionToolParam) -> FunctionTool:
+        assert tool["type"] == "function"
+        return FunctionTool(
+            name=tool["function"]["name"],
+            description=tool["function"].get("description", ""),
+            params_json_schema=tool["function"].get("parameters", None),
+            on_invoke_tool=None,
+        )
+
+    @staticmethod
+    def get_message_from_image(image_url: str) -> dict:
+        """Get a message dict for image input."""
+        # from openai.types.responses.response_input_item_param import Message
+        # from openai.types.responses.response_input_image_param import ResponseInputImageParam
+        return {"role": "user", "content": [{"type": "input_image", "image_url": encode_image(image_url)}]}
+
+
+class SimplifiedOpenAIChatCompletionsModel(OpenAIChatCompletionsModel):
+    """extend OpenAIChatCompletionsModel to support basic api
+    - enable tracing based on SimplifiedAsyncOpenAI
+    """
+
+    async def query_one(self, **kwargs) -> str:
+        system_instructions, input = AgentsUtils.convert_sp_input(kwargs["messages"])
+        model_settings = AgentsUtils.convert_model_settings(kwargs)
+        tools = [AgentsUtils.convert_tool(tool) for tool in kwargs.get("tools", [])]
+        response = await self.get_response(
+            system_instructions=system_instructions,
+            input=input,
+            model_settings=model_settings,
+            tools=tools,
+            output_schema=None,
+            handoffs=[],
+            tracing=ModelTracing.ENABLED,
+            previous_response_id=None,
+            prompt=None,
+        )
+        return ChatCompletionConverter.items_to_messages(response.to_input_items())
+        # with generation_span(
+        #     model=kwargs["model"],
+        #     model_config=_model_settings,
+        #     input=_messages,
+        # ) as span_generation:
+        #     result = await self.chat.completions.create(**kwargs)
+        #     span_generation.span_data.output = result.choices[0].message.model_dump()
+        #     return result

utils/common.py

@@ -0,0 +1,82 @@
+import asyncio
+import importlib.util
+import sys
+from pathlib import Path
+
+from pydantic import BaseModel, Field
+
+from .path import DIR_ROOT
+
+
+def get_event_loop() -> asyncio.AbstractEventLoop:
+    try:
+        loop = asyncio.get_event_loop()
+    except RuntimeError:
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+    return loop
+
+
+def schema_to_basemodel(schema: dict, class_name: str = None) -> type[BaseModel]:
+    type_map = {
+        "string": str,
+        "integer": int,
+        "number": float,
+        "boolean": bool,
+    }
+
+    def get_python_type(prop_schema):
+        prop_type = prop_schema.get("type")
+
+        if prop_type == "array":
+            item_type = prop_schema.get("items", {}).get("type", "string")
+            return list[type_map.get(item_type, str)]
+
+        return type_map.get(prop_type, str)
+
+    annotations = {}
+    fields = {}
+    properties = schema.get("properties", {})
+    required_fields = set(schema.get("required", []))
+
+    for field_name, field_schema in properties.items():
+        annotations[field_name] = get_python_type(field_schema)
+        field_kwargs = {}
+        if "description" in field_schema:
+            field_kwargs["description"] = field_schema["description"]
+        if field_name not in required_fields:
+            field_kwargs["default"] = None
+            annotations[field_name] = annotations[field_name] | None
+        if field_kwargs:
+            fields[field_name] = Field(**field_kwargs)
+    attrs = {
+        "__annotations__": annotations,
+        "__module__": __name__,
+    }
+    attrs.update(fields)
+
+    class_name = class_name or schema.get("title", "GeneratedModel")
+    ModelClass = type(class_name, (BaseModel,), attrs)
+    return ModelClass
+
+
+def load_class_from_file(filepath: str, class_name: str) -> type:
+    """Load class from file."""
+    if not filepath.startswith("/"):
+        filepath = str(DIR_ROOT / filepath)
+
+    filepath = Path(filepath).absolute()
+    module_name = filepath.stem
+    spec = importlib.util.spec_from_file_location(module_name, filepath)
+    if spec is None:
+        raise ImportError(f"Could not load spec from file '{filepath}'")
+
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[module_name] = module
+
+    spec.loader.exec_module(module)
+
+    if hasattr(module, class_name):
+        return getattr(module, class_name)
+    else:
+        raise AttributeError(f"Class '{class_name}' not found in module '{module_name}'")

utils/env.py

@@ -0,0 +1,34 @@
+import importlib.metadata
+import os
+
+from dotenv import find_dotenv, load_dotenv
+
+load_dotenv(find_dotenv(raise_error_if_not_found=True), verbose=True, override=True)
+
+
+class EnvUtils:
+    @staticmethod
+    def get_env(key: str, default: str | None = None) -> str | None:
+        """Get the value of an environment variable. Raise an error if default is not privided (None)"""
+        if default is None:
+            res = os.getenv(key)
+            if res is None:
+                raise ValueError(f"Environment variable {key} is not set")
+            return res
+        return os.getenv(key, default)
+
+    @staticmethod
+    def assert_env(key: str | list[str]) -> None:
+        if isinstance(key, list):
+            for k in key:
+                EnvUtils.assert_env(k)
+        else:
+            if not os.getenv(key):
+                raise ValueError(f"Environment variable {key} is not set")
+
+    @staticmethod
+    def ensure_package(package_name: str) -> None:
+        try:
+            importlib.metadata.version(package_name)
+        except importlib.metadata.PackageNotFoundError:
+            raise ValueError(f"Package {package_name} is required but not installed!") from None

utils/image.py

@@ -0,0 +1,16 @@
+import base64
+import pathlib
+
+import requests
+
+
+def encode_image(image_path: str) -> str:
+    """Encode an image from a local path or URL to a base64 string."""
+    if pathlib.Path(image_path).is_file():
+        with open(image_path, "rb") as image_file:
+            return base64.b64encode(image_file.read()).decode("utf-8")
+    else:
+        response = requests.get(image_path)
+        response.raise_for_status()
+        image_base64 = base64.b64encode(response.content).decode("utf-8")
+        return f"data:image/jpeg;base64,{image_base64}"

utils/llm_output_parser.py

@@ -0,0 +1,64 @@
+import json
+import re
+
+LANGUAGE_TO_CANDS = {
+    "python": ["py", "python"],
+    "json": ["json"],
+    "javascript": ["js", "javascript"],
+    "yaml": ["yaml", "yml"],
+}
+
+
+class LLMOutputParser:
+    @staticmethod
+    def extract_code_blocks(s: str) -> list[tuple[str, str]]:
+        """Parse all code blocks (language, code) from the given string."""
+        pattern = re.compile(r"```(\w*)\n(.*?)```", re.DOTALL)
+        code_blocks = []
+        for match in pattern.finditer(s):
+            language = match.group(1).strip()
+            code = match.group(2).strip()
+            code_blocks.append((language, code))
+        return code_blocks
+
+    @staticmethod
+    def extract_code_block_with_language(s: str, language: str) -> str:
+        code_blocks = LLMOutputParser.extract_code_blocks(s)
+        if not code_blocks:
+            return s  # fallback
+        for lang, code in code_blocks:
+            if lang.lower() in LANGUAGE_TO_CANDS[language]:
+                return code
+        return code_blocks[0][1]  # fallback
+
+    @staticmethod
+    def extract_code_python(s: str) -> str:
+        """Extract the first code block with the given language from the given string."""
+        return LLMOutputParser.extract_code_block_with_language(s, "python")
+
+    @staticmethod
+    def extract_code_json(s: str, try_parse: bool = True) -> str | dict:
+        """Extract the first json code block from the given string."""
+        code = LLMOutputParser.extract_code_block_with_language(s, "json")
+        if try_parse:
+            try:
+                return json.loads(code)
+            except json.JSONDecodeError:
+                return code
+        return code
+
+    @staticmethod
+    def camel_to_snake(name: str) -> str:
+        """Convert CamelCase / PascalCase to snake_case."""
+        s1 = re.sub(r"(.)([A-Z][a-z]+)", r"\1_\2", name)
+        s2 = re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", s1)
+        return s2.lower()
+
+    @staticmethod
+    def snake_to_camel(name: str, pascal: bool = True) -> str:
+        """Convert snake_case to CamelCase / PascalCase."""
+        components = name.split("_")
+        if pascal:
+            return "".join(x.title() for x in components)
+        else:
+            return components[0].lower() + "".join(x.title() for x in components[1:])

utils/log.py

@@ -0,0 +1,79 @@
+import json
+import logging
+import pathlib
+from logging.handlers import TimedRotatingFileHandler
+from typing import Literal
+
+from colorlog import ColoredFormatter
+
+DIR_LOGS = pathlib.Path(__file__).parent.parent.parent / "logs"
+DIR_LOGS.mkdir(exist_ok=True)
+
+# Flag to track if logging has been set up
+_LOGGING_INITIALIZED = False
+
+
+def setup_logging(level: Literal["WARNING", "INFO", "DEBUG"] = "WARNING") -> None:
+    # Check if logging has already been initialized
+    global _LOGGING_INITIALIZED
+    if _LOGGING_INITIALIZED:
+        logging.getLogger().warning("Logging has already been initialized! Skipping...")
+        return
+
+    utu_logger = logging.getLogger("utu")
+    utu_logger.setLevel(logging.DEBUG)
+    if utu_logger.handlers:
+        utu_logger.handlers.clear()
+
+    console_handler = logging.StreamHandler()
+    console_handler.setLevel(level)
+    color_formatter = ColoredFormatter(
+        "%(green)s%(asctime)s%(reset)s[%(blue)s%(name)s%(reset)s] - "
+        "%(log_color)s%(levelname)s%(reset)s - %(filename)s:%(lineno)d - %(green)s%(message)s%(reset)s",
+        # " - %(cyan)s%(threadName)s%(reset)s",
+        log_colors={
+            "DEBUG": "cyan",
+            "INFO": "white",
+            "WARNING": "yellow",
+            "ERROR": "red",
+            "CRITICAL": "red,bg_white",
+        },
+        secondary_log_colors={"asctime": {"green": "green"}, "name": {"blue": "blue"}},
+    )
+    console_handler.setFormatter(color_formatter)
+
+    file_handler = TimedRotatingFileHandler(
+        DIR_LOGS / "utu.log", when="midnight", interval=1, backupCount=30, encoding="utf-8"
+    )
+    file_handler.setLevel(logging.DEBUG)
+    formatter = logging.Formatter(
+        "%(asctime)s[%(name)s] - %(levelname)s - %(filename)s:%(lineno)d - %(message)s - %(threadName)s"
+    )
+    file_handler.setFormatter(formatter)
+
+    utu_logger.addHandler(console_handler)
+    utu_logger.addHandler(file_handler)
+    utu_logger.info(f"Logging initialized with level {level}.")
+
+    # Mark logging as initialized
+    _LOGGING_INITIALIZED = True
+
+
+def get_logger(name: str, level: int | str = logging.DEBUG) -> logging.Logger:
+    logger = logging.getLogger(name)
+    logger.setLevel(level)
+
+    def log_error_with_exc(msg, *args, **kwargs):
+        kwargs["exc_info"] = True
+        logger.error(msg, *args, **kwargs)
+
+    logger.error_exc = log_error_with_exc
+    return logger
+
+
+def oneline_object(obj: object, limit: int = 100) -> str:
+    try:
+        s = json.dumps(obj, ensure_ascii=False)
+    except TypeError:
+        s = json.dumps(str(obj), ensure_ascii=False)
+    return f"{s[:limit]}..." if len(s) > limit else s

utils/openai_utils/__init__.py

@@ -0,0 +1,5 @@
+from .openai_utils import OpenAIUtils
+from .simplified_client import SimplifiedAsyncOpenAI
+from .types import OpenAIChatCompletionParams, OpenAIResponsesParams
+
+__all__ = ["OpenAIUtils", "SimplifiedAsyncOpenAI", "OpenAIChatCompletionParams", "OpenAIResponsesParams"]