chibi-bot 1.6.0b0__py3-none-any.whl

chibi/__main__.py

@@ -0,0 +1,343 @@
+from contextvars import Context
+from typing import Any, Coroutine, TypeVar
+
+from loguru import logger
+from telegram import (
+    BotCommand,
+    CallbackQuery,
+    InlineQueryResultArticle,
+    InputTextMessageContent,
+    Update,
+    constants,
+)
+from telegram.ext import (
+    Application,
+    ApplicationBuilder,
+    CallbackQueryHandler,
+    CommandHandler,
+    ContextTypes,
+    InlineQueryHandler,
+    MessageHandler,
+    filters,
+)
+
+from chibi.config import application_settings, gpt_settings, telegram_settings
+from chibi.constants import GROUP_CHAT_TYPES, UserAction, UserContext
+from chibi.schemas.app import ModelChangeSchema
+from chibi.services.bot import (
+    handle_available_model_options,
+    handle_available_provider_options,
+    handle_image_generation,
+    handle_model_selection,
+    handle_provider_api_key_set,
+    handle_reset,
+    handle_user_prompt,
+)
+from chibi.services.providers import RegisteredProviders
+from chibi.services.task_manager import task_manager
+from chibi.utils.app import log_application_settings, run_heartbeat
+from chibi.utils.telegram import (
+    check_user_allowance,
+    current_user_action,
+    get_telegram_chat,
+    get_telegram_message,
+    get_user_context,
+    set_user_action,
+    set_user_context,
+    user_interacts_with_bot,
+)
+
+_T = TypeVar("_T")
+
+
+class ChibiBot:
+    def __init__(self) -> None:
+        self.commands = [
+            BotCommand(command="help", description="Show this help message"),
+            BotCommand(
+                command="ask",
+                description=(
+                    "Ask me any question (in group chat, for example) (e.g. /ask which program language is the best?)"
+                ),
+            ),
+            BotCommand(
+                command="reset",
+                description="Reset your conversation history (will reduce prompt and save some tokens)",
+            ),
+        ]
+        if not application_settings.hide_imagine:
+            self.commands.append(
+                BotCommand(command="imagine", description="Generate image from prompt"),
+            )
+            self.commands.append(BotCommand(command="image_models", description="Select image generation model"))
+        if not application_settings.hide_models:
+            self.commands.append(BotCommand(command="gpt_models", description="Select GPT model"))
+
+        if gpt_settings.public_mode:
+            self.commands.append(
+                BotCommand(
+                    command="set_api_key",
+                    description="Set an API key (token) for any of supported providers",
+                )
+            )
+
+    def run_task(
+        self,
+        coro: Coroutine[Any, Any, _T],
+        name: str | None = None,
+        context: Context | None = None,
+    ) -> None:
+        task_manager.run_task(coro)
+
+    async def help(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+        telegram_message = get_telegram_message(update=update)
+        commands = [f"/{command.command} - {command.description}" for command in self.commands]
+        commands_desc = "\n".join(commands)
+        help_text = (
+            f"Hey! My name is {telegram_settings.bot_name}, and I'm your ChatGPT experience provider!\n\n"
+            f"{commands_desc}"
+        )
+        await telegram_message.reply_text(help_text, disable_web_page_preview=True)
+
+    @check_user_allowance
+    async def reset(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+        self.run_task(handle_reset(update=update, context=context))
+
+    async def _handle_message_with_api_key(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+        provider_name = get_user_context(context=context, key=UserContext.SELECTED_PROVIDER, expected_type=str)
+        if not provider_name:
+            return None
+        self.run_task(handle_provider_api_key_set(update=update, context=context, provider_name=provider_name))
+        return None
+
+    @check_user_allowance
+    async def imagine(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+        telegram_message = get_telegram_message(update=update)
+        assert telegram_message.text
+        prompt = telegram_message.text.replace("/imagine", "", 1).strip()
+        if prompt:
+            self.run_task(handle_image_generation(update=update, context=context, prompt=prompt))
+            return None
+        set_user_action(context=context, action=UserAction.IMAGINE)
+        await telegram_message.reply_text("Ok, now give me an image prompt.")
+
+    @check_user_allowance
+    async def prompt(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+        telegram_chat = get_telegram_chat(update=update)
+        telegram_message = get_telegram_message(update=update)
+        if telegram_message.voice:
+            self.run_task(handle_user_prompt(update=update, context=context))
+            return None
+
+        prompt = telegram_message.text
+
+        if not prompt:
+            return None
+
+        if current_user_action(context=context) == UserAction.SET_API_KEY:
+            set_user_action(context=context, action=UserAction.NONE)
+            return await self._handle_message_with_api_key(update=update, context=context)
+
+        if current_user_action(context=context) == UserAction.IMAGINE:
+            self.run_task(handle_image_generation(update=update, context=context, prompt=prompt))
+            return None
+
+        if (
+            telegram_chat.type in GROUP_CHAT_TYPES
+            and telegram_settings.answer_direct_messages_only
+            and "/ask" not in prompt
+            and not user_interacts_with_bot(update=update, context=context)
+        ):
+            return None
+        self.run_task(handle_user_prompt(update=update, context=context))
+
+    @check_user_allowance
+    async def ask(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+        self.run_task(handle_user_prompt(update=update, context=context))
+
+    @check_user_allowance
+    async def show_gpt_models_menu(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+        telegram_message = get_telegram_message(update=update)
+        reply_markup = await handle_available_model_options(update=update, context=context)
+
+        if active_model := get_user_context(context=context, key=UserContext.ACTIVE_MODEL, expected_type=str):
+            message = f"Active model: {active_model}. You  may select another one from the list below:"
+        else:
+            message = "Please, select model:"
+        set_user_action(context=context, action=UserAction.SELECT_MODEL)
+        await telegram_message.reply_text(text=message, reply_markup=reply_markup)
+
+    @check_user_allowance
+    async def show_image_models_menu(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+        telegram_message = get_telegram_message(update=update)
+        reply_markup = await handle_available_model_options(update=update, context=context, image_generation=True)
+
+        if active_model := get_user_context(context=context, key=UserContext.ACTIVE_IMAGE_MODEL, expected_type=str):
+            message = f"Active model: {active_model}. You  may select another one from the list below:"
+        else:
+            message = "Please, select model:"
+        set_user_action(context=context, action=UserAction.SELECT_MODEL)
+        await telegram_message.reply_text(text=message, reply_markup=reply_markup)
+
+    async def show_api_key_set_menu(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+        telegram_message = get_telegram_message(update=update)
+        reply_markup = await handle_available_provider_options()
+
+        message = "Please, select a provider:"
+        await telegram_message.reply_text(text=message, reply_markup=reply_markup)
+        set_user_action(context=context, action=UserAction.SELECT_PROVIDER)
+
+    async def _compute_model_selection_action(
+        self, query: CallbackQuery, update: Update, context: ContextTypes.DEFAULT_TYPE
+    ) -> None:
+        mapped_models = get_user_context(
+            context=context,
+            key=UserContext.MAPPED_MODELS,
+            expected_type=dict[str, ModelChangeSchema],
+        )
+        await query.answer()
+
+        if not mapped_models or not query.data:
+            await query.delete_message()
+            return None
+
+        if query.data == "-1":
+            await query.delete_message()
+            return None
+
+        model = mapped_models.get(query.data)
+        if not model:
+            await query.delete_message()
+            return None
+
+        if model.image_generation:
+            set_user_context(context=context, key=UserContext.ACTIVE_IMAGE_MODEL, value=model.name)
+        else:
+            set_user_context(context=context, key=UserContext.ACTIVE_MODEL, value=model.name)
+        self.run_task(
+            handle_model_selection(
+                update=update,
+                context=context,
+                model=model,
+                query=query,
+            )
+        )
+        set_user_action(context=context, action=UserAction.NONE)
+
+    async def _compute_provider_selection_action(
+        self, query: CallbackQuery, context: ContextTypes.DEFAULT_TYPE
+    ) -> None:
+        await query.answer()
+        provider_name = query.data
+        if not provider_name or provider_name not in RegisteredProviders.all.keys():
+            await query.delete_message()
+            return
+        set_user_context(context=context, key=UserContext.SELECTED_PROVIDER, value=provider_name)
+        await query.edit_message_text(
+            text=f"{provider_name} selected.\nNow please send me an API key",
+        )
+        set_user_action(context=context, action=UserAction.SET_API_KEY)
+
+    async def handle_selection(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+        action = current_user_action(context=context)
+        if not action or action == UserAction.NONE:
+            return None
+
+        query = update.callback_query
+        if not query:
+            return None
+
+        if action == UserAction.SELECT_MODEL:
+            return await self._compute_model_selection_action(query=query, update=update, context=context)
+
+        if action == UserAction.SELECT_PROVIDER:
+            return await self._compute_provider_selection_action(query=query, context=context)
+
+    @check_user_allowance
+    async def inline_query(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+        inline_query = update.inline_query
+        if not inline_query:
+            return
+        query = inline_query.query
+        results = [
+            InlineQueryResultArticle(
+                id=query,
+                title="Ask ChatGPT",
+                input_message_content=InputTextMessageContent(query),
+                description=query,
+                thumbnail_url="https://github.com/s-nagaev/chibi/raw/main/docs/logo.png",
+            )
+        ]
+
+        await inline_query.answer(results)
+
+    async def error_handler(self, update: object, context: ContextTypes.DEFAULT_TYPE) -> None:
+        logger.error(f"Error occurred while handling an update: {context.error}")
+
+    async def post_init(self, application: Application) -> None:
+        await application.bot.set_my_commands(self.commands)
+
+    def run(self) -> None:
+        builder = (
+            ApplicationBuilder()
+            .base_url(telegram_settings.telegram_base_url)
+            .base_file_url(telegram_settings.telegram_base_file_url)
+            .token(telegram_settings.token)
+            .post_init(self.post_init)
+            .post_shutdown(task_manager.shutdown)
+        )
+
+        if telegram_settings.proxy:
+            builder = builder.proxy(telegram_settings.proxy).get_updates_proxy(telegram_settings.proxy)
+        app = builder.build()
+
+        if not application_settings.hide_imagine:
+            app.add_handler(CommandHandler(command="imagine", callback=self.imagine))
+
+        if not application_settings.hide_models:
+            app.add_handler(CommandHandler("gpt_models", self.show_gpt_models_menu))
+            app.add_handler(CommandHandler("image_models", self.show_image_models_menu))
+        app.add_handler(CallbackQueryHandler(self.handle_selection))
+
+        if gpt_settings.public_mode:
+            app.add_handler(CommandHandler("set_api_key", self.show_api_key_set_menu))
+
+        app.add_handler(CommandHandler("ask", self.ask))
+        app.add_handler(CommandHandler("help", self.help))
+        app.add_handler(CommandHandler("reset", self.reset))
+        app.add_handler(CommandHandler("start", self.help))
+
+        app.add_handler(MessageHandler(filters.TEXT | filters.VOICE | filters.AUDIO & (~filters.COMMAND), self.prompt))
+
+        app.add_handler(
+            InlineQueryHandler(
+                self.inline_query,
+                chat_types=[
+                    constants.ChatType.PRIVATE,
+                    constants.ChatType.GROUP,
+                    constants.ChatType.SUPERGROUP,
+                ],
+            )
+        )
+        # app.add_error_handler(self.error_handler)
+        if application_settings.heartbeat_url:
+            if not app.job_queue:
+                logger.error("Could not launch heartbeat beacon: application job queue was shut down or never started.")
+            else:
+                url = application_settings.heartbeat_url
+                logger.info(
+                    f"Launching heartbeat beacon: calling {url[:30]}..{url[-3:]} "
+                    f"every {application_settings.heartbeat_frequency_call} seconds."
+                )
+                app.job_queue.run_repeating(
+                    callback=run_heartbeat,
+                    interval=application_settings.heartbeat_frequency_call,
+                    first=0.0,
+                )
+        app.run_polling()
+
+
+if __name__ == "__main__":
+    log_application_settings()
+    telegram_bot = ChibiBot()
+    telegram_bot.run()

chibi/cli.py

@@ -0,0 +1,90 @@
+import os
+import subprocess
+import sys
+
+import click
+
+from chibi.config_generator import CONFIG_PATH, generate_default_config
+from chibi.service import Service
+
+
+def _get_service() -> Service:
+    """Get an instance of the Service class.
+
+    Returns:
+        Service: Initialized service instance.
+    """
+    return Service()
+
+
+@click.group()
+def main() -> None:
+    """Chibi CLI for managing the bot service."""
+    pass
+
+
+@main.command()
+def start() -> None:
+    """Start the Chibi bot service as a daemon."""
+    service = _get_service()
+    service.start()
+
+
+@main.command()
+def stop() -> None:
+    """Stop the running Chibi bot service."""
+    service = _get_service()
+    service.stop()
+
+
+@main.command()
+def restart() -> None:
+    """Restart the Chibi bot service."""
+    service = _get_service()
+    service.restart()
+
+
+@main.command()
+def config() -> None:
+    """Open the Chibi configuration file in the default editor."""
+    if not os.path.exists(CONFIG_PATH):
+        click.echo("Creating default configuration...")
+        generate_default_config()
+
+    editor = os.environ.get("EDITOR", "vi")
+    try:
+        result = subprocess.call([editor, CONFIG_PATH])
+        if result != 0:
+            click.echo("Warning: Editor exited with non-zero status.", err=True)
+    except FileNotFoundError:
+        click.echo(f"Error: Editor '{editor}' not found.", err=True)
+        sys.exit(1)
+    except Exception as e:
+        click.echo(f"Error opening editor: {e}", err=True)
+        sys.exit(1)
+
+
+@main.command()
+def logs() -> None:
+    """Tail the Chibi log file."""
+    service = _get_service()
+    log_path = service.log_path
+
+    if not os.path.exists(log_path):
+        click.echo(f"Log file {log_path} does not exist yet. Start the service first.")
+        sys.exit(1)
+
+    try:
+        subprocess.call(["tail", "-n", "50", "-f", log_path])
+    except KeyboardInterrupt:
+        click.echo("\nLog tailing stopped.")
+    except FileNotFoundError:
+        click.echo("Error: 'tail' command not found.", err=True)
+        sys.exit(1)
+    except Exception as e:
+        click.echo(f"Error tailing logs: {e}", err=True)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

chibi/config/__init__.py

@@ -0,0 +1,6 @@
+import chibi.config.logging  # noqa: F401
+from chibi.config.app import application_settings
+from chibi.config.gpt import gpt_settings
+from chibi.config.telegram import telegram_settings
+
+__all__ = ["application_settings", "gpt_settings", "telegram_settings"]

chibi/config/app.py

@@ -0,0 +1,123 @@
+import sys
+from functools import lru_cache
+from pathlib import Path
+from typing import Literal
+
+from loguru import logger
+from pydantic import Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class ApplicationSettings(BaseSettings):
+    """
+    Application settings loaded from environment or .env file.
+
+    Attributes:
+        redis: Redis connection URL.
+        redis_password: Password for Redis.
+        aws_region: AWS region for DynamoDB.
+        aws_access_key_id: AWS access key ID.
+        aws_secret_access_key: AWS secret access key.
+        ddb_users_table: DynamoDB table name for users.
+        ddb_messages_table: DynamoDB table name for messages.
+        local_data_path: Filesystem path for local storage.
+        log_prompt_data: Whether to log prompt data.
+        hide_models: Hide model options in UI.
+        hide_imagine: Hide imagine commands.
+        heartbeat_url: URL for heartbeat check.
+        heartbeat_frequency_call: Interval between heartbeat calls.
+        heartbeat_retry_calls: Number of retries for heartbeat.
+        heartbeat_proxy: Proxy URL for heartbeat.
+    """
+
+    model_config = SettingsConfigDict(
+        env_file=(".env",),
+        extra="ignore",
+    )
+
+    # Redis settings
+    redis: str | None = Field(default=None)
+    redis_password: str | None = Field(default=None)
+
+    # DynamoDB settings
+    aws_region: str | None = Field(default=None)
+    aws_access_key_id: str | None = Field(default=None)
+    aws_secret_access_key: str | None = Field(default=None)
+    ddb_users_table: str | None = Field(default=None)
+    ddb_messages_table: str | None = Field(default=None)
+
+    # Local storage settings
+    local_data_path: str = Field(default="/app/data")
+
+    # MCP settings
+    enable_mcp_sse: bool = Field(default=True)
+    enable_mcp_stdio: bool = Field(default=False)
+
+    # HeartBeat settings
+    heartbeat_url: str | None = Field(default=None)
+    heartbeat_frequency_call: int = Field(default=60, ge=30)
+    heartbeat_retry_calls: int = Field(default=3)
+    heartbeat_proxy: str | None = Field(default=None)
+
+    # InfluxDB settings
+    influxdb_url: str | None = Field(default=None)
+    influxdb_token: str | None = Field(default=None)
+    influxdb_org: str | None = Field(default=None)
+    influxdb_bucket: str | None = Field(default=None)
+
+    # Interface
+    hide_models: bool = Field(default=False)
+    hide_imagine: bool = Field(default=False)
+
+    # Other settings
+    log_prompt_data: bool = Field(default=False)
+
+    # Agent settings
+    home_dir: str = Field(default="~/chibi")  # AI agent's home directory
+    working_dir: str = Field(default="~/chibi")  # AI agent's CWD
+    skills_dir: str = Field(default=(Path(".") / "skills").absolute().as_posix())  # absolute path to dir with skills
+    # max_consecutive_tool_calls: int = Field(default=50)
+
+    @property
+    def is_influx_configured(self) -> bool:
+        return all((self.influxdb_url, self.influxdb_token, self.influxdb_org, self.influxdb_bucket))
+
+    @property
+    def storage_backend(self) -> Literal["local", "redis", "dynamodb"]:
+        if self.redis:
+            return "redis"
+        if self.aws_access_key_id and self.aws_secret_access_key:
+            return "dynamodb"
+        return "local"
+
+
+@lru_cache()
+def _get_application_settings() -> ApplicationSettings:
+    return ApplicationSettings()
+
+
+def add_user_context(record) -> bool:
+    user_id = record["extra"].get("user_id")
+    record["extra"]["user_id"] = f"[{user_id}] " if user_id else ""
+    return True
+
+
+logger.remove()
+logger.add(
+    sys.stderr,
+    format="<level>{level: <9}</level> | "
+    "<green>{time:YYYY-MM-DD HH:mm:ss.SSS zz}</green> | "
+    "{extra[user_id]}"
+    "<level>{message}</level>",
+    filter=add_user_context,
+)
+logger.level("TOOL", no=20, color="<light-blue>")
+logger.level("THINK", no=20, color="<light-magenta>")
+logger.level("CALL", no=20, color="<magenta>")
+logger.level("CHECK", no=20, color="<light-red>")
+logger.level("MODERATOR", no=20, color="<light-red>")
+logger.level("SUBAGENT", no=20, color="<cyan>")
+logger.level("DELEGATE", no=20, color="<blue>")
+
+
+application_settings = _get_application_settings()

chibi/config/gpt.py

@@ -0,0 +1,108 @@
+from functools import lru_cache
+from typing import Literal
+
+from pydantic import Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+from chibi.constants import IMAGE_ASPECT_RATIO_LITERAL, IMAGE_SIZE_LITERAL, get_llm_prompt
+
+
+class GPTSettings(BaseSettings):
+    model_config = SettingsConfigDict(env_file=".env", env_file_encoding="utf-8", extra="ignore")
+
+    alibaba_key: str | None = Field(alias="ALIBABA_API_KEY", default=None)
+    anthropic_key: str | None = Field(alias="ANTHROPIC_API_KEY", default=None)
+    cloudflare_account_id: str | None = Field(alias="CLOUDFLARE_ACCOUNT_ID", default=None)
+    cloudflare_key: str | None = Field(alias="CLOUDFLARE_API_KEY", default=None)
+    customopenai_key: str | None = Field(alias="CUSTOMOPENAI_API_KEY", default=None)
+    customopenai_url: str = Field(alias="CUSTOMOPENAI_URL", default="http://localhost:1234/v1")
+    deepseek_key: str | None = Field(alias="DEEPSEEK_API_KEY", default=None)
+    gemini_key: str | None = Field(alias="GEMINI_API_KEY", default=None)
+    grok_key: str | None = Field(alias="GROK_API_KEY", default=None)
+    mistralai_key: str | None = Field(alias="MISTRALAI_API_KEY", default=None)
+    moonshotai_key: str | None = Field(alias="MOONSHOTAI_API_KEY", default=None)
+    openai_key: str | None = Field(alias="OPENAI_API_KEY", default=None)
+    suno_key: str | None = Field(alias="SUNO_API_ORG_API_KEY", default=None)
+    elevenlabs_api_key: str | None = Field(alias="ELEVEN_LABS_API_KEY", default=None)
+    minimax_api_key: str | None = Field(alias="MINIMAX_API_KEY", default=None)
+
+    frequency_penalty: float = Field(default=0)
+    max_tokens: int = Field(default=32000)
+    presence_penalty: float = Field(default=0)
+    temperature: float = Field(default=1)
+
+    backoff_factor: float = Field(default=0.5)
+    retries: int = Field(default=3)
+    timeout: int = Field(default=600)
+
+    image_generations_monthly_limit: int = Field(alias="IMAGE_GENERATIONS_LIMIT", default=0)
+    image_n_choices: int = Field(default=1, ge=1, le=4)
+    image_quality: Literal["standard", "hd"] = Field(default="standard")
+    image_size: IMAGE_SIZE_LITERAL = Field(default="1024x1024")
+    image_aspect_ratio: IMAGE_ASPECT_RATIO_LITERAL = Field(default="16:9")
+    image_size_nano_banana: Literal["1K", "2K", "4K"] = Field(default="2K")
+    image_size_imagen: Literal["1K", "2K"] = Field(default="2K")
+    image_size_alibaba: str = "1664*928"
+
+    default_model: str | None = Field(default=None)
+    default_provider: str | None = Field(default=None)
+
+    stt_provider: str | None = Field(default=None)
+    stt_model: str | None = Field(default=None)
+    tts_provider: str | None = Field(default=None)
+    tts_model: str | None = Field(default=None)
+
+    moderation_provider: str | None = Field(default=None)
+    moderation_model: str | None = Field(default=None)
+
+    max_conversation_age_minutes: int = Field(default=360)
+    max_history_tokens: int = Field(default=64000)
+
+    image_generations_whitelist_raw: str | None = Field(alias="IMAGE_GENERATIONS_WHITELIST", default=None)
+    models_whitelist_raw: str | None = Field(alias="MODELS_WHITELIST", default=None)
+    proxy: str | None = Field(default=None)
+    public_mode: bool = Field(default=False)
+    show_llm_thoughts: bool = Field(default=False)
+
+    filesystem_access: bool = Field(default=False)
+    allow_delegation: bool = Field(default=True)
+    tools_whitelist_raw: str | None = Field(alias="TOOLS_WHITELIST", default=None)
+
+    google_search_api_key: str | None = Field(default=None)
+    google_search_cx: str | None = Field(default=None)
+
+    @property
+    def google_search_client_set(self) -> bool:
+        return bool(self.google_search_api_key) and bool(self.google_search_cx)
+
+    @property
+    def assistant_prompt(self) -> str:
+        return get_llm_prompt(filesystem_access=self.filesystem_access, allow_delegation=self.allow_delegation)
+
+    @property
+    def models_whitelist(self) -> list[str]:
+        return [x.strip() for x in self.models_whitelist_raw.split(",")] if self.models_whitelist_raw else []
+
+    @property
+    def image_generations_whitelist(self) -> list[str]:
+        return (
+            [x.strip() for x in self.image_generations_whitelist_raw.split(",")]
+            if self.image_generations_whitelist_raw
+            else []
+        )
+
+    @property
+    def tools_whitelist(self) -> list[str]:
+        return [x.strip() for x in self.tools_whitelist_raw.split(",")] if self.tools_whitelist_raw else []
+
+    @property
+    def messages_ttl(self) -> int:
+        return self.max_conversation_age_minutes * 60
+
+
+@lru_cache()
+def _get_gpt_settings() -> GPTSettings:
+    return GPTSettings()
+
+
+gpt_settings: GPTSettings = _get_gpt_settings()

chibi/config/logging.py

@@ -0,0 +1,15 @@
+import sys
+from typing import Any
+
+from loguru import logger
+
+config: dict[Any, Any] = {
+    "handlers": [
+        {
+            "sink": sys.stdout,
+            "colorize": True,
+            "format": "<lvl>{level}</lvl>\t| <green>{time:YYYY-MM-DD HH:mm:ss.SSS zz}</green> |  <lvl>{message}</lvl>",
+        },
+    ],
+}
+logger.configure(**config)