fix: reduce DB connection pool exhaustion during LLM calls (#650)

* fix: reduce DB connection pool exhaustion by shortening connection hold time during LLM calls

All channel message handlers (Feishu, DingTalk, WeCom, Slack, Discord, WeChat)
now follow a three-phase pattern:
- Phase 1: Short transaction — load config, save user message → commit + close
- Phase 2: LLM call with no DB session held
- Phase 3: New short transaction — save assistant reply

Previously, a single DB connection was held for the entire request lifecycle,
including slow LLM calls (30s+). This caused connection pool exhaustion under
concurrent load.

Changes:
- Split _call_agent_llm into _load_agent_and_model + _call_llm_with_config
- Each channel handler manages its own connection lifecycle
- New short transactions for saving assistant replies reload ChatSession
- Background tasks (heartbeat, trigger_daemon) get new trace IDs for log correlation

* fix(release): update GitHub Models to use available openai/gpt-5 model

* fix(release): use MODELS_TOKEN secret for GitHub Models API access

* fix(heartbeat): add semaphore concurrency limit and atomic heartbeat claim to prevent duplicate triggers

* fix(startup): remove blanket A2A async enable on every restart

* openai 4.1

* fix(release): use personal models endpoint and gpt-5 for release notes

Organization-level GitHub Models endpoint returns 403 on free plan.
Switch to personal endpoint to bypass org restriction.

* fix(release): switch to gpt-4.1 for larger token limit

* fix(release): include release notes in PR body

* fix(release): sort release notes by importance in prompt

* fix(publish_page): use storage backend instead of local filesystem for S3 compatibility

---------

Co-authored-by: yaojin <yaojin@58.com>

Author: yaojin3616

.github/workflows/release.yml

@@ -196,6 +196,7 @@ jobs:
           1. Title: Start with a top-level heading exactly formatted as: # {target_tag} — <Concise title summarizing the main theme of this release>
           2. ## What's New:
              - Group related changes into thematic subheadings (e.g., ### Core Features, ### UI/UX Enhancements, ### Optimizations).
+             - Sort subheadings and items within each group by importance: major features first, then enhancements, then minor tweaks.
              - Specifically list all newly added features and optimization items. Explain what value they add.
           3. ## Bug Fixes:
              - List resolved bugs, issues, or stability improvements.
@@ -211,6 +212,7 @@ jobs:
           - Prefer grouping related commits and summarizing the feature/improvement instead of listing every commit verbatim.
           - Do NOT invent or hallucinate any features or fixes that are not present or strongly implied in the commit list.
           - Keep the language clean and consistent with previous release notes.
+          - IMPORTANT: Within each section (What's New, Bug Fixes, etc.), sort items by impact and importance in descending order. New core features and major enhancements come first, followed by smaller improvements. Bug fixes that affect stability or data integrity come before minor UI tweaks.
 
           Style Reference (Mimic this structure and formatting):
           ---
@@ -244,7 +246,7 @@ jobs:
         if: ${{ inputs.use_ai_notes }}
         shell: bash
         env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GITHUB_TOKEN: ${{ secrets.MODELS_TOKEN }}
         run: |
           set -euo pipefail
 
@@ -254,7 +256,7 @@ jobs:
 
           prompt = Path(".github/release-artifacts/release-prompt.txt").read_text(encoding="utf-8")
           payload = {
-              "model": "openai/gpt-5.4",
+              "model": "openai/gpt-4.1",
               "messages": [
                   {
                       "role": "system",
@@ -281,7 +283,7 @@ jobs:
               -H "Authorization: Bearer $GITHUB_TOKEN" \
               -H "X-GitHub-Api-Version: 2026-03-10" \
               -H "Content-Type: application/json" \
-              https://models.github.ai/orgs/dataelement/inference/chat/completions \
+              https://models.github.ai/inference/chat/completions \
               -d @.github/release-artifacts/openai-payload.json
           )
 
@@ -441,9 +443,21 @@ jobs:
         run: |
           set -euo pipefail
 
+          release_notes=""
+          if [ -s .github/release-artifacts/release-notes.generated.md ]; then
+            release_notes="$(cat .github/release-artifacts/release-notes.generated.md)"
+          fi
+
           gh pr create \
             --title "chore(release): cut ${TARGET_TAG}" \
-            --body "Automated release PR for ${TARGET_TAG}. Merging this PR will automatically tag the release and publish it." \
+            --body "$(cat <<EOF
+          Automated release PR for ${TARGET_TAG}. Merging this PR will automatically tag the release and publish it.
+
+          ---
+
+          ${release_notes}
+          EOF
+          )" \
             --head "release/${TARGET_TAG}" \
             --base "${{ github.ref_name }}"
 

backend/app/api/dingtalk.py

@@ -158,7 +158,6 @@ async def process_dingtalk_message(
         sender_nick: Display name of the sender from DingTalk.
         message_id: DingTalk message ID (used for reactions).
     """
-    import json
     import httpx
     from datetime import datetime, timezone
     from sqlalchemy import select as _select
@@ -167,7 +166,6 @@ async def process_dingtalk_message(
     from app.models.audit import ChatMessage
     from app.services.channel_session import find_or_create_channel_session
     from app.services.channel_user_service import channel_user_service
-    from app.api.feishu import _call_agent_llm
 
     async with async_session() as db:
         sender_staff_id = (sender_staff_id or "").strip()
@@ -181,7 +179,6 @@ async def process_dingtalk_message(
         if not sender_staff_id:
             logger.warning("[DingTalk] Skip message attribution because sender_staff_id is empty")
             return
-        creator_id = agent_obj.creator_id
         from app.models.agent import DEFAULT_CONTEXT_WINDOW_SIZE
         ctx_size = (agent_obj.context_window_size or DEFAULT_CONTEXT_WINDOW_SIZE) if agent_obj else DEFAULT_CONTEXT_WINDOW_SIZE
 
@@ -245,7 +242,28 @@ async def process_dingtalk_message(
             conversation_id=session_conv_id,
         ))
         sess.last_message_at = datetime.now(timezone.utc)
+
+        # Also load DingTalk credentials and agent/model config in this transaction
+        _dt_cfg_r = await db.execute(
+            _select(ChannelConfig).where(
+                ChannelConfig.agent_id == agent_id,
+                ChannelConfig.channel_type == "dingtalk",
+            )
+        )
+        _dt_cfg = _dt_cfg_r.scalar_one_or_none()
+        _dt_app_key = _dt_cfg.app_id if _dt_cfg else None
+        _dt_app_secret = _dt_cfg.app_secret if _dt_cfg else None
+
+        # Pre-load agent/model for LLM call
+        from app.api.feishu import _load_agent_and_model
+        _agent_model, _llm_model, _fallback_model = await _load_agent_and_model(db, agent_id)
+
+        # Extract agent name before closing session
+        _agent_name = agent_obj.name
+
         await db.commit()
+        # ── Phase 1 complete: release connection before slow LLM/HTTP work ──
+        await db.close()
 
         # Build LLM input text: for images, inject base64 markers so vision models can see them
         llm_user_text = user_text
@@ -262,17 +280,6 @@ async def process_dingtalk_message(
             _send_dingtalk_media_message,
         )
 
-        # Load DingTalk credentials from ChannelConfig
-        _dt_cfg_r = await db.execute(
-            _select(ChannelConfig).where(
-                ChannelConfig.agent_id == agent_id,
-                ChannelConfig.channel_type == "dingtalk",
-            )
-        )
-        _dt_cfg = _dt_cfg_r.scalar_one_or_none()
-        _dt_app_key = _dt_cfg.app_id if _dt_cfg else None
-        _dt_app_secret = _dt_cfg.app_secret if _dt_cfg else None
-
         _cfs_token = None
         if _dt_app_key and _dt_app_secret:
             # Determine send target: group -> conversation_id, P2P -> sender_staff_id
@@ -337,10 +344,12 @@ async def _dingtalk_file_sender(file_path: str, msg: str = ""):
 
             _cfs_token = _cfs.set(_dingtalk_file_sender)
 
-        # Call LLM
+        # Call LLM (no DB session needed)
+        from app.api.feishu import _call_llm_with_config
         try:
-            reply_text = await _call_agent_llm(
-                db, agent_id, llm_user_text,
+            reply_text = await _call_llm_with_config(
+                _agent_model, _llm_model, _fallback_model,
+                agent_id, llm_user_text,
                 history=history, user_id=platform_user_id,
             )
         finally:
@@ -370,7 +379,7 @@ async def _dingtalk_file_sender(file_path: str, msg: str = ""):
                 await client.post(session_webhook, json={
                     "msgtype": "markdown",
                     "markdown": {
-                        "title": agent_obj.name or "AI Reply",
+                        "title": _agent_name or "AI Reply",
                         "text": reply_text,
                     },
                 })
@@ -386,14 +395,22 @@ async def _dingtalk_file_sender(file_path: str, msg: str = ""):
             except Exception as e2:
                 logger.error(f"[DingTalk] Fallback text reply also failed: {e2}")
 
-        # Save assistant reply
-        db.add(ChatMessage(
-            agent_id=agent_id, user_id=platform_user_id,
-            role="assistant", content=reply_text,
-            conversation_id=session_conv_id,
-        ))
-        sess.last_message_at = datetime.now(timezone.utc)
-        await db.commit()
+        # Save assistant reply (new short transaction)
+        async with async_session() as _save_db:
+            _save_db.add(ChatMessage(
+                agent_id=agent_id, user_id=platform_user_id,
+                role="assistant", content=reply_text,
+                conversation_id=session_conv_id,
+            ))
+            # Reload session object to update last_message_at
+            from app.models.chat_session import ChatSession
+            _sess_r = await _save_db.execute(
+                _select(ChatSession).where(ChatSession.id == uuid.UUID(session_conv_id))
+            )
+            _sess_fresh = _sess_r.scalar_one_or_none()
+            if _sess_fresh:
+                _sess_fresh.last_message_at = datetime.now(timezone.utc)
+            await _save_db.commit()
 
         # Log activity
         from app.services.activity_logger import log_activity

backend/app/api/discord_bot.py

@@ -281,11 +281,11 @@ async def discord_interaction_webhook(
         async def handle_in_background():
             from app.models.audit import ChatMessage
             from app.models.agent import Agent as AgentModel
-            from app.api.feishu import _call_agent_llm
             from app.services.channel_session import find_or_create_channel_session
             from app.database import async_session
             from datetime import datetime, timezone
 
+            # ── Phase 1: Short transaction — load configs, save user message ──
             async with async_session() as bg_db:
                 # Load agent
                 agent_r = await bg_db.execute(select(AgentModel).where(AgentModel.id == agent_id))
@@ -296,19 +296,19 @@ async def handle_in_background():
 
                 # Find-or-create platform user for this Discord sender via unified service
                 from app.services.channel_user_service import channel_user_service
-                
+
                 _discord_username = body.get("member", {}).get("user", {}).get("username") or body.get("user", {}).get("username", "")
                 _display = _discord_username or f"Discord User {sender_id[:8]}"
                 _extra_info = {"name": _display}
-                
+
                 _platform_user = await channel_user_service.resolve_channel_user(
                     db=bg_db,
                     agent=agent_obj,
                     channel_type="discord",
                     external_user_id=sender_id,
                     extra_info=_extra_info,
                 )
-                
+
                 # Update display_name if we now have a better name
                 if _discord_username and _platform_user.display_name and _platform_user.display_name.startswith("Discord User ") and _platform_user.display_name != _discord_username:
                     _platform_user.display_name = _discord_username
@@ -340,40 +340,54 @@ async def handle_in_background():
                 # Save user message
                 bg_db.add(ChatMessage(agent_id=agent_id, user_id=platform_user_id, role="user", content=user_text, conversation_id=session_conv_id))
                 sess.last_message_at = datetime.now(timezone.utc)
-                await bg_db.commit()
 
-                # Call LLM
-                reply_text = await _call_agent_llm(
-                    bg_db,
-                    agent_id,
-                    user_text,
-                    history=history,
-                    user_id=platform_user_id,
-                    session_id=session_conv_id,
-                )
-                logger.info(f"[Discord] LLM reply: {reply_text[:80]}")
+                # Pre-load agent/model for LLM call and extract config values
+                from app.api.feishu import _load_agent_and_model
+                _agent_model, _llm_model, _fallback_model = await _load_agent_and_model(bg_db, agent_id)
 
-                # Save reply
-                bg_db.add(ChatMessage(agent_id=agent_id, user_id=platform_user_id, role="assistant", content=reply_text, conversation_id=session_conv_id))
-                sess.last_message_at = datetime.now(timezone.utc)
-                await bg_db.commit()
-
-                # Bot token stored in config — read from DB to avoid detached ORM issues
                 from sqlalchemy import select as _sel
                 cfg_r = await bg_db.execute(_sel(ChannelConfig).where(
                     ChannelConfig.agent_id == agent_id,
                     ChannelConfig.channel_type == "discord",
                 ))
                 cfg = cfg_r.scalar_one_or_none()
-                bot_token_bg = cfg.app_secret if cfg else ""
-                app_id_bg = cfg.app_id if cfg else ""
-
-                # Send chunked reply via Discord follow-up
-                if bot_token_bg and interaction_token and app_id_bg:
-                    try:
-                        await _send_discord_followup(app_id_bg, bot_token_bg, interaction_token, reply_text)
-                    except Exception as e:
-                        logger.error(f"[Discord] Failed to send follow-up: {e}")
+                _bot_token_bg = cfg.app_secret if cfg else ""
+                _app_id_bg = cfg.app_id if cfg else ""
+
+                await bg_db.commit()
+            # ── Phase 1 complete: release connection ──
+
+            # ── Phase 2: LLM call (no DB session needed) ──
+            from app.api.feishu import _call_llm_with_config
+            reply_text = await _call_llm_with_config(
+                _agent_model, _llm_model, _fallback_model,
+                agent_id,
+                user_text,
+                history=history,
+                user_id=platform_user_id,
+                session_id=session_conv_id,
+            )
+            logger.info(f"[Discord] LLM reply: {reply_text[:80]}")
+
+            # ── Phase 3: Save reply + send (new short transaction) ──
+            async with async_session() as _save_db:
+                _save_db.add(ChatMessage(agent_id=agent_id, user_id=platform_user_id, role="assistant", content=reply_text, conversation_id=session_conv_id))
+                # Reload session object to update last_message_at
+                from app.models.chat_session import ChatSession
+                _sess_r = await _save_db.execute(
+                    select(ChatSession).where(ChatSession.id == uuid.UUID(session_conv_id))
+                )
+                _sess_fresh = _sess_r.scalar_one_or_none()
+                if _sess_fresh:
+                    _sess_fresh.last_message_at = datetime.now(timezone.utc)
+                await _save_db.commit()
+
+            # Send chunked reply via Discord follow-up
+            if _bot_token_bg and interaction_token and _app_id_bg:
+                try:
+                    await _send_discord_followup(_app_id_bg, _bot_token_bg, interaction_token, reply_text)
+                except Exception as e:
+                    logger.error(f"[Discord] Failed to send follow-up: {e}")
 
         asyncio.create_task(handle_in_background())
         # Return DEFERRED_CHANNEL_MESSAGE_WITH_SOURCE — shows "thinking..." to user