:sparkles: Implement Gemini client pool (#7)

* 📝 docs: clarify client id usage

* :sparkles: Add logging and checking

* 🔧 fix env override for list items

* :bug: Fix config reading and singleton of client pool

* :loud_sound: Add more logs

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

---------

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

README.md

@@ -48,11 +48,13 @@ pip install -e .
 
 ### Configuration
 
-Edit `config/config.yaml` and set your Gemini credentials:
+Edit `config/config.yaml` and provide at least one credential pair:
 ```yaml
 gemini:
-  secure_1psid: "YOUR_SECURE_1PSID_HERE"
-  secure_1psidts: "YOUR_SECURE_1PSIDTS_HERE"
+  clients:
+    - id: "client-a"
+      secure_1psid: "YOUR_SECURE_1PSID_HERE"
+      secure_1psidts: "YOUR_SECURE_1PSIDTS_HERE"
 ```
 
 > [!NOTE]
@@ -79,8 +81,9 @@ docker run -p 8000:8000 \
   -v $(pwd)/config:/app/config \
   -v $(pwd)/data:/app/data \
   -e CONFIG_SERVER__API_KEY="your-api-key-here" \
-  -e CONFIG_GEMINI__SECURE_1PSID="your-secure-1psid" \
-  -e CONFIG_GEMINI__SECURE_1PSIDTS="your-secure-1psidts" \
+  -e CONFIG_GEMINI__CLIENTS__0__ID="client-a" \
+  -e CONFIG_GEMINI__CLIENTS__0__SECURE_1PSID="your-secure-1psid" \
+  -e CONFIG_GEMINI__CLIENTS__0__SECURE_1PSIDTS="your-secure-1psidts" \
   ghcr.io/nativu5/gemini-fastapi
 ```
 
@@ -102,8 +105,9 @@ services:
       - CONFIG_SERVER__HOST=0.0.0.0
       - CONFIG_SERVER__PORT=8000
       - CONFIG_SERVER__API_KEY=${API_KEY}
-      - CONFIG_GEMINI__SECURE_1PSID=${SECURE_1PSID}
-      - CONFIG_GEMINI__SECURE_1PSIDTS=${SECURE_1PSIDTS}
+      - CONFIG_GEMINI__CLIENTS__0__ID=client-a
+      - CONFIG_GEMINI__CLIENTS__0__SECURE_1PSID=${SECURE_1PSID}
+      - CONFIG_GEMINI__CLIENTS__0__SECURE_1PSIDTS=${SECURE_1PSIDTS}
     restart: on-failure:3 # Avoid retrying too many times
 ```
 
@@ -134,14 +138,21 @@ You can override any configuration option using environment variables with the `
 # Override server settings
 export CONFIG_SERVER__API_KEY="your-secure-api-key"
 
-# Override Gemini credentials
-export CONFIG_GEMINI__SECURE_1PSID="your-secure-1psid"
-export CONFIG_GEMINI__SECURE_1PSIDTS="your-secure-1psidts"
+# Override Gemini credentials (first client)
+export CONFIG_GEMINI__CLIENTS__0__ID="client-a"
+export CONFIG_GEMINI__CLIENTS__0__SECURE_1PSID="your-secure-1psid"
+export CONFIG_GEMINI__CLIENTS__0__SECURE_1PSIDTS="your-secure-1psidts"
 
 # Override conversation storage size limit
 export CONFIG_STORAGE__MAX_SIZE=268435456  # 256 MB
 ```
 
+### Client IDs and Conversation Reuse
+
+Conversations are stored with the ID of the client that generated them.
+Keep these identifiers stable in your configuration so that sessions remain valid
+when you update the cookie list.
+
 ### Gemini Credentials
 
 > [!WARNING]

README.zh.md

@@ -49,11 +49,13 @@ pip install -e .
 
 ### 配置
 
-编辑 `config/config.yaml` 并填写 Gemini 凭证：
+编辑 `config/config.yaml` 并提供至少一组凭证：
 ```yaml
 gemini:
-  secure_1psid: "YOUR_SECURE_1PSID_HERE"
-  secure_1psidts: "YOUR_SECURE_1PSIDTS_HERE"
+  clients:
+    - id: "client-a"
+      secure_1psid: "YOUR_SECURE_1PSID_HERE"
+      secure_1psidts: "YOUR_SECURE_1PSIDTS_HERE"
 ```
 
 > [!NOTE]
@@ -80,8 +82,9 @@ docker run -p 8000:8000 \
   -v $(pwd)/config:/app/config \
   -v $(pwd)/data:/app/data \
   -e CONFIG_SERVER__API_KEY="your-api-key-here" \
-  -e CONFIG_GEMINI__SECURE_1PSID="your-secure-1psid" \
-  -e CONFIG_GEMINI__SECURE_1PSIDTS="your-secure-1psidts" \
+  -e CONFIG_GEMINI__CLIENTS__0__ID="client-a" \
+  -e CONFIG_GEMINI__CLIENTS__0__SECURE_1PSID="your-secure-1psid" \
+  -e CONFIG_GEMINI__CLIENTS__0__SECURE_1PSIDTS="your-secure-1psidts" \
   ghcr.io/nativu5/gemini-fastapi
 ```
 
@@ -103,8 +106,9 @@ services:
       - CONFIG_SERVER__HOST=0.0.0.0
       - CONFIG_SERVER__PORT=8000
       - CONFIG_SERVER__API_KEY=${API_KEY}
-      - CONFIG_GEMINI__SECURE_1PSID=${SECURE_1PSID}
-      - CONFIG_GEMINI__SECURE_1PSIDTS=${SECURE_1PSIDTS}
+      - CONFIG_GEMINI__CLIENTS__0__ID=client-a
+      - CONFIG_GEMINI__CLIENTS__0__SECURE_1PSID=${SECURE_1PSID}
+      - CONFIG_GEMINI__CLIENTS__0__SECURE_1PSIDTS=${SECURE_1PSIDTS}
     restart: on-failure:3 # 避免过多重试
 ```
 
@@ -136,13 +140,19 @@ docker compose up -d
 export CONFIG_SERVER__API_KEY="your-secure-api-key"
 
 # 覆盖 Gemini Cookie
-export CONFIG_GEMINI__SECURE_1PSID="your-secure-1psid"
-export CONFIG_GEMINI__SECURE_1PSIDTS="your-secure-1psidts"
+export CONFIG_GEMINI__CLIENTS__0__ID="client-a"
+export CONFIG_GEMINI__CLIENTS__0__SECURE_1PSID="your-secure-1psid"
+export CONFIG_GEMINI__CLIENTS__0__SECURE_1PSIDTS="your-secure-1psidts"
 
 # 覆盖对话存储大小限制
 export CONFIG_STORAGE__MAX_SIZE=268435456  # 256 MB
 ```
 
+### 客户端 ID 与会话重用
+
+会话在保存时会绑定创建它的客户端 ID。请在配置中保持这些 `id` 值稳定，
+这样在更新 Cookie 列表时依然可以复用旧会话。
+
 ### Gemini 凭据
 
 > [!WARNING]

app/main.py

@@ -6,20 +6,20 @@ from loguru import logger
 from .server.chat import router as chat_router
 from .server.health import router as health_router
 from .server.middleware import add_cors_middleware, add_exception_handler
-from .services.client import SingletonGeminiClient
+from .services.pool import GeminiClientPool
 
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     try:
-        client = SingletonGeminiClient()
-        await client.init()
+        pool = GeminiClientPool()
+        await pool.init()
     except Exception as e:
-        logger.exception(f"Failed to initialize Gemini client: {e}")
+        logger.exception(f"Failed to initialize Gemini clients: {e}")
         raise
 
-    logger.info("Gemini client initialized on server startup.")
-    logger.info("Gemini API Server ready to serve requests.")
+    logger.success(f"Gemini clients initialized: {[c.id for c in pool.clients]}.")
+    logger.success("Gemini API Server ready to serve requests.")
     yield
 
 

app/models/models.py

@@ -84,6 +84,7 @@ class HealthCheckResponse(BaseModel):
 
     ok: bool
     storage: Optional[Dict[str, str | int]] = None
+    clients: Optional[Dict[str, bool]] = None
     error: Optional[str] = None
 
 
@@ -95,6 +96,7 @@ class ConversationInStore(BaseModel):
 
     # NOTE: Gemini Web API do not support changing models once a conversation is created.
     model: str = Field(..., description="Model used for the conversation")
+    client_id: str = Field(..., description="Identifier of the Gemini client")
     metadata: list[str | None] = Field(
         ..., description="Metadata for Gemini API to locate the conversation"
     )

app/server/chat.py

@@ -15,7 +15,11 @@ from ..models import (
     ModelData,
     ModelListResponse,
 )
-from ..services import LMDBConversationStore, SingletonGeminiClient
+from ..services import (
+    GeminiClientPool,
+    GeminiClientWrapper,
+    LMDBConversationStore,
+)
 from ..utils.helper import estimate_tokens
 from .middleware import get_temp_dir, verify_api_key
 
@@ -49,7 +53,7 @@ async def create_chat_completion(
     api_key: str = Depends(verify_api_key),
     tmp_dir: Path = Depends(get_temp_dir),
 ):
-    client = SingletonGeminiClient()
+    pool = GeminiClientPool()
     db = LMDBConversationStore()
     model = Model.from_name(request.model)
 
@@ -61,10 +65,12 @@ async def create_chat_completion(
 
     # Check if conversation is reusable
     session = None
+    client = None
     if _check_reusable(request.messages):
         try:
             # Exclude the last message from user
             if old_conv := db.find(model.model_name, request.messages[:-1]):
+                client = pool.acquire(old_conv.client_id)
                 session = client.start_chat(metadata=old_conv.metadata, model=model)
         except Exception as e:
             session = None
@@ -72,15 +78,18 @@ async def create_chat_completion(
 
     if session:
         # Just send the last message to the existing session
-        model_input, files = await client.process_message(
+        model_input, files = await GeminiClientWrapper.process_message(
             request.messages[-1], tmp_dir, tagged=False
         )
         logger.debug(f"Found reusable session: {session.metadata}")
     else:
         # Start a new session and concat messages into a single string
-        session = client.start_chat(model=model)
         try:
-            model_input, files = await client.process_conversation(request.messages, tmp_dir)
+            client = pool.acquire()
+            session = client.start_chat(model=model)
+            model_input, files = await GeminiClientWrapper.process_conversation(
+                request.messages, tmp_dir
+            )
         except ValueError as e:
             raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e))
         except Exception as e:
@@ -90,21 +99,25 @@ async def create_chat_completion(
 
     # Generate response
     try:
-        logger.debug(f"Input length: {len(model_input)}, files count: {len(files)}")
+        assert session and client, "Session and client not available"
+        logger.debug(
+            f"Client ID: {client.id}, Input length: {len(model_input)}, files count: {len(files)}"
+        )
         response = await session.send_message(model_input, files=files)
     except Exception as e:
         logger.exception(f"Error generating content from Gemini API: {e}")
         raise
 
     # Format and clean the output
-    model_output = client.extract_output(response)
-    stored_output = client.extract_output(response, include_thoughts=False)
+    model_output = GeminiClientWrapper.extract_output(response)
+    stored_output = GeminiClientWrapper.extract_output(response, include_thoughts=False)
 
     # After cleaning, persist the conversation
     try:
         last_message = Message(role="assistant", content=stored_output)
         conv = ConversationInStore(
             model=model.model_name,
+            client_id=client.id,
             metadata=session.metadata,
             messages=[*request.messages, last_message],
         )

app/server/health.py

@@ -2,26 +2,32 @@ from fastapi import APIRouter
 from loguru import logger
 
 from ..models import HealthCheckResponse
-from ..services import LMDBConversationStore, SingletonGeminiClient
+from ..services import GeminiClientPool, LMDBConversationStore
 
 router = APIRouter()
 
 
 @router.get("/health", response_model=HealthCheckResponse)
 async def health_check():
-    client = SingletonGeminiClient()
+    pool = GeminiClientPool()
     db = LMDBConversationStore()
 
-    if not client.running:
-        try:
-            await client.init()
-        except Exception as e:
-            logger.error(f"Failed to initialize Gemini client: {e}")
-            return HealthCheckResponse(ok=False, error=str(e))
+    try:
+        await pool.init()
+    except Exception as e:
+        logger.error(f"Failed to initialize Gemini clients: {e}")
+        return HealthCheckResponse(ok=False, error=str(e))
+
+    client_status = pool.status()
+
+    if not all(client_status.values()):
+        logger.warning("One or more Gemini clients not running")
 
     stat = db.stats()
     if not stat:
         logger.error("Failed to retrieve LMDB conversation store stats")
-        return HealthCheckResponse(ok=False, error="LMDB conversation store unavailable")
+        return HealthCheckResponse(
+            ok=False, error="LMDB conversation store unavailable", clients=client_status
+        )
 
-    return HealthCheckResponse(ok=True, storage=stat)
+    return HealthCheckResponse(ok=all(client_status.values()), storage=stat, clients=client_status)

app/services/__init__.py

@@ -1,7 +1,9 @@
-from .client import SingletonGeminiClient
+from .client import GeminiClientWrapper
 from .lmdb import LMDBConversationStore
+from .pool import GeminiClientPool
 
 __all__ = [
+    "GeminiClientPool",
+    "GeminiClientWrapper",
     "LMDBConversationStore",
-    "SingletonGeminiClient",
 ]

app/services/client.py

@@ -6,15 +6,14 @@ from gemini_webapi import GeminiClient, ModelOutput
 from ..models import Message
 from ..utils import g_config
 from ..utils.helper import add_tag, save_file_to_tempfile, save_url_to_tempfile
-from ..utils.singleton import Singleton
 
 
-class SingletonGeminiClient(GeminiClient, metaclass=Singleton):
-    def __init__(self, **kwargs):
-        kwargs.setdefault("secure_1psid", g_config.gemini.secure_1psid)
-        kwargs.setdefault("secure_1psidts", g_config.gemini.secure_1psidts)
+class GeminiClientWrapper(GeminiClient):
+    """Gemini client with helper methods."""
 
+    def __init__(self, client_id: str, **kwargs):
         super().__init__(**kwargs)
+        self.id = client_id
 
     async def init(self, **kwargs):
         # Inject default configuration values
@@ -77,7 +76,7 @@ class SingletonGeminiClient(GeminiClient, metaclass=Singleton):
         files: list[Path | str] = []
 
         for msg in messages:
-            input_part, files_part = await SingletonGeminiClient.process_message(msg, tempdir)
+            input_part, files_part = await GeminiClientWrapper.process_message(msg, tempdir)
             conversation.append(input_part)
             files.extend(files_part)
 

app/services/lmdb.py

@@ -21,10 +21,11 @@ def hash_message(message: Message) -> str:
     return hashlib.sha256(message_bytes).hexdigest()
 
 
-def hash_conversation(model: str, messages: List[Message]) -> str:
-    """Generate a hash for a list of messages."""
+def hash_conversation(client_id: str, model: str, messages: List[Message]) -> str:
+    """Generate a hash for a list of messages and client id."""
     # Create a combined hash from all individual message hashes
     combined_hash = hashlib.sha256()
+    combined_hash.update(client_id.encode("utf-8"))
     combined_hash.update(model.encode("utf-8"))
     for message in messages:
         message_hash = hash_message(message)
@@ -35,7 +36,7 @@ def hash_conversation(model: str, messages: List[Message]) -> str:
 class LMDBConversationStore(metaclass=Singleton):
     """LMDB-based storage for Message lists with hash-based key-value operations."""
 
-    CUSTOM_KEY_BINDING_PREFIX = "hash:"
+    HASH_LOOKUP_PREFIX = "hash:"
 
     def __init__(self, db_path: Optional[str] = None, max_db_size: Optional[int] = None):
         """
@@ -115,7 +116,7 @@ class LMDBConversationStore(metaclass=Singleton):
             raise ValueError("Messages list cannot be empty")
 
         # Generate hash for the message list
-        message_hash = hash_conversation(conv.model, conv.messages)
+        message_hash = hash_conversation(conv.client_id, conv.model, conv.messages)
         storage_key = custom_key or message_hash
 
         # Prepare data for storage
@@ -132,11 +133,10 @@ class LMDBConversationStore(metaclass=Singleton):
                 txn.put(storage_key.encode("utf-8"), value, overwrite=True)
 
                 # Store hash -> key mapping for reverse lookup
-                if custom_key:
-                    txn.put(
-                        f"{self.CUSTOM_KEY_BINDING_PREFIX}{message_hash}".encode("utf-8"),
-                        custom_key.encode("utf-8"),
-                    )
+                txn.put(
+                    f"{self.HASH_LOOKUP_PREFIX}{message_hash}".encode("utf-8"),
+                    storage_key.encode("utf-8"),
+                )
 
                 logger.debug(f"Stored {len(conv.messages)} messages with key: {storage_key}")
                 return storage_key
@@ -185,21 +185,21 @@ class LMDBConversationStore(metaclass=Singleton):
         if not messages:
             return None
 
-        message_hash = hash_conversation(model, messages)
-        key = f"{self.CUSTOM_KEY_BINDING_PREFIX}{message_hash}"
-
-        try:
-            with self._get_transaction(write=False) as txn:
-                # Try custom key binding first
-                key = txn.get(key.encode("utf-8"), default=None)
-                key = key.decode("utf-8") if key else message_hash  # type: ignore
-
-                # Fallback to hash if no custom key found
-                return self.get(key)
-
-        except Exception as e:
-            logger.error(f"Failed to retrieve messages by message list: {e}")
-            return None
+        for c in g_config.gemini.clients:
+            message_hash = hash_conversation(c.id, model, messages)
+            key = f"{self.HASH_LOOKUP_PREFIX}{message_hash}"
+            try:
+                with self._get_transaction(write=False) as txn:
+                    mapped = txn.get(key.encode("utf-8"))
+                    if mapped:
+                        return self.get(mapped.decode("utf-8"))  # type: ignore
+            except Exception as e:
+                logger.error(f"Failed to retrieve messages by message list for client {c.id}: {e}")
+                continue
+
+            if conv := self.get(message_hash):
+                return conv
+        return None
 
     def exists(self, key: str) -> bool:
         """
@@ -237,16 +237,16 @@ class LMDBConversationStore(metaclass=Singleton):
 
                 storage_data = orjson.loads(data)  # type: ignore
                 conv = ConversationInStore.model_validate(storage_data)
-                message_hash = hash_conversation(conv.model, conv.messages)
+                message_hash = hash_conversation(conv.client_id, conv.model, conv.messages)
 
                 # Delete main data
                 txn.delete(key.encode("utf-8"))
 
                 # Clean up hash mapping if it exists
                 if message_hash and key != message_hash:
-                    txn.delete(f"{self.CUSTOM_KEY_BINDING_PREFIX}{message_hash}".encode("utf-8"))
+                    txn.delete(f"{self.HASH_LOOKUP_PREFIX}{message_hash}".encode("utf-8"))
 
-                logger.info(f"Deleted messages with key: {key}")
+                logger.debug(f"Deleted messages with key: {key}")
                 return conv
 
         except Exception as e:
@@ -274,7 +274,7 @@ class LMDBConversationStore(metaclass=Singleton):
                 for key, _ in cursor:
                     key_str = key.decode("utf-8")
                     # Skip internal hash mappings
-                    if key_str.startswith(self.CUSTOM_KEY_BINDING_PREFIX):
+                    if key_str.startswith(self.HASH_LOOKUP_PREFIX):
                         continue
 
                     if not prefix or key_str.startswith(prefix):

app/services/pool.py

@@ -0,0 +1,60 @@
+from collections import deque
+from typing import Dict, List, Optional
+
+from ..utils import g_config
+from ..utils.singleton import Singleton
+from .client import GeminiClientWrapper
+
+
+class GeminiClientPool(metaclass=Singleton):
+    """Pool of GeminiClient instances identified by unique ids."""
+
+    def __init__(self) -> None:
+        self._clients: List[GeminiClientWrapper] = []
+        self._id_map: Dict[str, GeminiClientWrapper] = {}
+        self._round_robin: deque[GeminiClientWrapper] = deque()
+
+        if len(g_config.gemini.clients) == 0:
+            raise ValueError("No Gemini clients configured")
+
+        for c in g_config.gemini.clients:
+            client = GeminiClientWrapper(
+                client_id=c.id,
+                secure_1psid=c.secure_1psid,
+                secure_1psidts=c.secure_1psidts,
+            )
+            self._clients.append(client)
+            self._id_map[c.id] = client
+            self._round_robin.append(client)
+
+    async def init(self) -> None:
+        """Initialize all clients in the pool."""
+        for client in self._clients:
+            if not client.running:
+                await client.init(
+                    timeout=g_config.gemini.timeout,
+                    auto_refresh=g_config.gemini.auto_refresh,
+                    verbose=g_config.gemini.verbose,
+                    refresh_interval=g_config.gemini.refresh_interval,
+                )
+
+    def acquire(self, client_id: Optional[str] = None) -> GeminiClientWrapper:
+        """Return a client by id or using round-robin."""
+        if client_id:
+            client = self._id_map.get(client_id)
+            if not client:
+                raise ValueError(f"Client id {client_id} not found")
+            return client
+
+        client = self._round_robin[0]
+        self._round_robin.rotate(-1)
+        return client
+
+    @property
+    def clients(self) -> List[GeminiClientWrapper]:
+        """Return managed clients."""
+        return self._clients
+
+    def status(self) -> Dict[str, bool]:
+        """Return running status for each client."""
+        return {client.id: client.running for client in self._clients}

app/utils/config.py

@@ -4,7 +4,11 @@ from typing import Literal, Optional
 
 from loguru import logger
 from pydantic import BaseModel, Field, ValidationError
-from pydantic_settings import BaseSettings, SettingsConfigDict, YamlConfigSettingsSource
+from pydantic_settings import (
+    BaseSettings,
+    SettingsConfigDict,
+    YamlConfigSettingsSource,
+)
 
 CONFIG_PATH = "config/config.yaml"
 
@@ -20,11 +24,20 @@ class ServerConfig(BaseModel):
     )
 
 
-class GeminiConfig(BaseModel):
-    """Gemini API configuration"""
+class GeminiClientSettings(BaseModel):
+    """Credential set for one Gemini client."""
 
+    id: str = Field(..., description="Unique identifier for the client")
     secure_1psid: str = Field(..., description="Gemini Secure 1PSID")
     secure_1psidts: str = Field(..., description="Gemini Secure 1PSIDTS")
+
+
+class GeminiConfig(BaseModel):
+    """Gemini API configuration"""
+
+    clients: list[GeminiClientSettings] = Field(
+        ..., description="List of Gemini client credential pairs"
+    )
     timeout: int = Field(default=60, ge=1, description="Init timeout")
     auto_refresh: bool = Field(True, description="Enable auto-refresh for Gemini cookies")
     refresh_interval: int = Field(
@@ -50,8 +63,10 @@ class CORSConfig(BaseModel):
 
 
 class StorageConfig(BaseModel):
+    """LMDB Storage configuration"""
+
     path: str = Field(
-        default="data/msg.lmdb",
+        default="data/lmdb",
         description="Path to the storage directory where data will be saved",
     )
     max_size: int = Field(
@@ -62,6 +77,8 @@ class StorageConfig(BaseModel):
 
 
 class LoggingConfig(BaseModel):
+    """Logging configuration"""
+
     level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] = Field(
         default="DEBUG",
         description="Logging level",
@@ -100,6 +117,7 @@ class Config(BaseSettings):
     model_config = SettingsConfigDict(
         env_prefix="CONFIG_",
         env_nested_delimiter="__",
+        nested_model_default_partial_update=True,
         yaml_file=os.getenv("CONFIG_PATH", CONFIG_PATH),
     )
 
@@ -113,7 +131,55 @@ class Config(BaseSettings):
         file_secret_settings,
     ):
         """Read settings: env -> yaml -> default"""
-        return (env_settings, YamlConfigSettingsSource(settings_cls))
+        return (
+            env_settings,
+            YamlConfigSettingsSource(settings_cls),
+        )
+
+
+def extract_gemini_clients_env() -> dict[int, dict[str, str]]:
+    """Extract and remove all Gemini clients related environment variables, return a mapping from index to field dict."""
+    prefix = "CONFIG_GEMINI__CLIENTS__"
+    env_overrides: dict[int, dict[str, str]] = {}
+    to_delete = []
+    for k, v in os.environ.items():
+        if k.startswith(prefix):
+            parts = k.split("__")
+            if len(parts) < 4:
+                continue
+            index_str, field = parts[2], parts[3].lower()
+            if not index_str.isdigit():
+                continue
+            idx = int(index_str)
+            env_overrides.setdefault(idx, {})[field] = v
+            to_delete.append(k)
+    # Remove these environment variables to avoid Pydantic parsing errors
+    for k in to_delete:
+        del os.environ[k]
+    return env_overrides
+
+
+def _merge_clients_with_env(
+    base_clients: list[GeminiClientSettings] | None, env_overrides: dict[int, dict[str, str]]
+):
+    """Override base_clients with env_overrides, return the new clients list."""
+    if not env_overrides:
+        return base_clients
+    result_clients: list[GeminiClientSettings] = []
+    if base_clients:
+        result_clients = [client.model_copy() for client in base_clients]
+    for idx in sorted(env_overrides):
+        overrides = env_overrides[idx]
+        if idx < len(result_clients):
+            client_dict = result_clients[idx].model_dump()
+            client_dict.update(overrides)
+            result_clients[idx] = GeminiClientSettings(**client_dict)
+        elif idx == len(result_clients):
+            new_client = GeminiClientSettings(**overrides)
+            result_clients.append(new_client)
+        else:
+            raise IndexError(f"Client index {idx} in env is out of range.")
+    return result_clients if result_clients else base_clients
 
 
 def initialize_config() -> Config:
@@ -124,8 +190,18 @@ def initialize_config() -> Config:
         Config: Configuration object
     """
     try:
-        # Using environment variables and YAML file for configuration
-        return Config()  # type: ignore
+        # First, extract and remove Gemini clients related environment variables
+        env_clients_overrides = extract_gemini_clients_env()
+
+        # Then, initialize Config with pydantic_settings
+        config = Config()  # type: ignore
+
+        # Synthesize clients
+        config.gemini.clients = _merge_clients_with_env(
+            config.gemini.clients, env_clients_overrides
+        )  # type: ignore
+
+        return config
     except ValidationError as e:
         logger.error(f"Configuration validation failed: {e!s}")
         sys.exit(1)

app/utils/logging.py

@@ -37,7 +37,7 @@ def setup_logging(
     # Setup standard logging library interceptor
     _setup_logging_intercept()
 
-    logger.info("Logger initialized.")
+    logger.debug("Logger initialized.")
 
 
 def _setup_logging_intercept() -> None:

config/config.yaml

@@ -13,8 +13,10 @@ cors:
   allow_headers: ["*"]
 
 gemini:
-  secure_1psid: "YOUR_SECURE_1PSID_HERE"       # Required: Gemini session cookie
-  secure_1psidts: "YOUR_SECURE_1PSIDTS_HERE"   # Required: Gemini timestamp cookie
+  clients:
+    - id: "example-id-1"   # Arbitrary client ID
+      secure_1psid: "YOUR_SECURE_1PSID_HERE"
+      secure_1psidts: "YOUR_SECURE_1PSIDTS_HERE"
   timeout: 60              # Init timeout in seconds
   auto_refresh: true       # Auto-refresh session cookies
   refresh_interval: 540    # Refresh interval in seconds