new apporach

Author: riturajFi

src/server/core/acontext_core/service/controller/message.py

@@ -6,46 +6,11 @@
 from ...schema.utils import asUUID
 from ...schema.result import Result
 from ...llm.agent import task as AT
-from ...llm.complete import llm_complete
 from ...env import LOG
 from ...schema.config import ProjectConfig
 from ...telemetry.log import get_wide_event
 from ...telemetry.get_metrics import get_metrics
 from ...constants import ExcessMetricTags
-from ..data import session as SD
-
-TITLE_INPUT_MAX_CHARS = 512
-TITLE_INPUT_MIN_CHARS = 12
-TITLE_GENERATION_MAX_TOKENS = 24
-TITLE_OUTPUT_MAX_CHARS = 80
-NON_INFORMATIVE_TITLE_INPUTS = {
-    "hi",
-    "hello",
-    "hey",
-    "ok",
-    "okay",
-    "thanks",
-    "thank you",
-    "test",
-    "testing",
-}
-TITLE_GENERATION_SYSTEM_PROMPT = """You generate concise session titles.
-Given a user's first message, return one short, informative title.
-Rules:
-- 3 to 8 words.
-- Use plain text only.
-- Do not use quotes.
-- Do not include punctuation at the end.
-"""
-
-
-def normalize_title_input_text(text: str, max_chars: int = TITLE_INPUT_MAX_CHARS) -> str | None:
-    normalized = " ".join(text.strip().split())
-    if normalized == "":
-        return None
-    if len(normalized) > max_chars:
-        normalized = normalized[:max_chars].rstrip()
-    return normalized
 
 
 async def _try_rollback_to_failed(pending_message_ids: list) -> None:
@@ -59,84 +24,6 @@ async def _try_rollback_to_failed(pending_message_ids: list) -> None:
             "session.pending_message_rollback_failed",
             pending_message_ids=[str(mid) for mid in pending_message_ids],
         )
-def check_title_input_quality(text: str | None) -> tuple[bool, str]:
-    if text is None:
-        return False, "empty"
-    normalized = normalize_title_input_text(text)
-    if normalized is None:
-        return False, "empty"
-    if len(normalized) < TITLE_INPUT_MIN_CHARS:
-        return False, "too_short"
-    if normalized.lower() in NON_INFORMATIVE_TITLE_INPUTS:
-        return False, "non_informative"
-    return True, "ok"
-
-
-def extract_first_user_message_text(messages: list[MessageBlob]) -> str | None:
-    for message in messages:
-        if message.role != "user":
-            continue
-        text_parts = [
-            part.text.strip()
-            for part in message.parts
-            if part.type == "text"
-            and isinstance(part.text, str)
-            and part.text.strip() != ""
-        ]
-        if text_parts:
-            return normalize_title_input_text("\n".join(text_parts))
-    return None
-
-
-def sanitize_generated_title(
-    title_candidate: str | None,
-    fallback_text: str | None,
-    max_chars: int = TITLE_OUTPUT_MAX_CHARS,
-) -> str | None:
-    def _clean(text: str | None) -> str | None:
-        if text is None:
-            return None
-        cleaned = " ".join(text.replace("\n", " ").replace("\r", " ").split())
-        cleaned = cleaned.strip("`'\"“”‘’ ").strip()
-        if cleaned == "":
-            return None
-        if len(cleaned) > max_chars:
-            cleaned = cleaned[:max_chars].rstrip()
-        cleaned = cleaned.strip("`'\"“”‘’ ").strip()
-        if cleaned == "":
-            return None
-        if not any(ch.isalnum() for ch in cleaned):
-            return None
-        return cleaned
-
-    cleaned_title = _clean(title_candidate)
-    if cleaned_title is not None:
-        return cleaned_title
-
-    cleaned_fallback = _clean(fallback_text)
-    if cleaned_fallback is None:
-        return None
-    return " ".join(cleaned_fallback.split()[:8])
-
-
-async def generate_session_title_candidate(
-    first_user_message_text: str,
-) -> Result[str | None]:
-    r = await llm_complete(
-        system_prompt=TITLE_GENERATION_SYSTEM_PROMPT,
-        history_messages=[{"role": "user", "content": first_user_message_text}],
-        max_tokens=TITLE_GENERATION_MAX_TOKENS,
-        prompt_kwargs={"prompt_id": "session.display_title.first_user"},
-    )
-    llm_response, eil = r.unpack()
-    if eil:
-        return Result.reject(eil.errmsg)
-    if llm_response.content is None:
-        return Result.resolve(None)
-    title_candidate = llm_response.content.strip()
-    if title_candidate == "":
-        return Result.resolve(None)
-    return Result.resolve(title_candidate)
 
 
 async def process_session_pending_message(
@@ -197,79 +84,6 @@ async def process_session_pending_message(
                 )
                 for m in messages
             ]
-            first_user_message_text = None
-            try:
-                r = await SD.should_generate_session_display_title(
-                    db_session, session_id
-                )
-                should_generate_title, eil = r.unpack()
-                if eil:
-                    raise ValueError(eil.errmsg)
-                if not should_generate_title:
-                    LOG.debug(
-                        f"Session {session_id} already has display_title, "
-                        "skip title-input extraction"
-                    )
-                else:
-                    first_user_message_text = extract_first_user_message_text(
-                        messages_data
-                    )
-                    is_quality_ok, quality_reason = check_title_input_quality(
-                        first_user_message_text
-                    )
-                    if not is_quality_ok:
-                        first_user_message_text = None
-                        LOG.debug(
-                            f"Skip title-input generation for session {session_id}: "
-                            f"{quality_reason}"
-                        )
-                    else:
-                        LOG.debug(
-                            f"Extracted first user text from pending session {session_id}, "
-                            f"length={len(first_user_message_text)}"
-                        )
-            except Exception as title_gate_err:
-                first_user_message_text = None
-                LOG.warning(
-                    f"Skip title extraction for session {session_id}: {title_gate_err}"
-                )
-
-        if first_user_message_text is not None:
-            try:
-                title_candidate = None
-                title_result = await generate_session_title_candidate(
-                    first_user_message_text
-                )
-                title_candidate_raw, eil = title_result.unpack()
-                if eil:
-                    raise ValueError(eil.errmsg)
-
-                title_candidate = sanitize_generated_title(
-                    title_candidate_raw, first_user_message_text
-                )
-                if title_candidate is None:
-                    LOG.debug(
-                        f"Title generation produced unusable content for session {session_id}"
-                    )
-                else:
-                    LOG.debug(
-                        f"Generated session title candidate for session {session_id}: "
-                        f"{title_candidate[:80]}"
-                    )
-
-                if title_candidate is not None:
-                    async with DB_CLIENT.get_session_context() as db_session:
-                        r = await SD.update_session_display_title(
-                            db_session, session_id, title_candidate
-                        )
-                        _, eil = r.unpack()
-                        if eil:
-                            raise ValueError(eil.errmsg)
-                    LOG.debug(f"Persisted display_title for session {session_id}")
-            except Exception as title_err:
-                LOG.warning(
-                    f"Skip title generation/persist for session {session_id}: {title_err}"
-                )
 
         ls_session = None
         async with DB_CLIENT.get_session_context() as session:

src/server/core/acontext_core/service/data/task.py

@@ -3,11 +3,11 @@
 from sqlalchemy.orm import selectinload
 from sqlalchemy.orm.attributes import flag_modified
 from sqlalchemy.ext.asyncio import AsyncSession
-from ...env import LOG
 from ...schema.orm import Task, Message
 from ...schema.result import Result
 from ...schema.utils import asUUID
 from ...schema.session.task import TaskSchema
+from . import session as SD
 
 
 async def fetch_planning_task(
@@ -102,6 +102,14 @@ async def fetch_first_task_description(
     return Result.resolve(description or None)
 
 
+async def _sync_session_display_title(
+    db_session: AsyncSession, session_id: asUUID
+) -> None:
+    title, eil = (await fetch_first_task_description(db_session, session_id)).unpack()
+    if eil is None and title:
+        await SD.update_session_display_title_once(db_session, session_id, title)
+
+
 async def update_task(
     db_session: AsyncSession,
     task_id: asUUID,
@@ -131,6 +139,7 @@ async def update_task(
         flag_modified(task, "data")
 
     await db_session.flush()
+    await _sync_session_display_title(db_session, task.session_id)
     # Changes will be committed when the session context exits
     return Result.resolve(task)
 
@@ -184,6 +193,7 @@ async def insert_task(
 
     db_session.add(task)
     await db_session.flush()
+    await _sync_session_display_title(db_session, session_id)
     return Result.resolve(task)
 
 

src/server/core/tests/service/test_task_data_title_sync.py

@@ -0,0 +1,115 @@
+import uuid
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+from acontext_core.schema.result import Result
+from acontext_core.schema.orm import Task
+from acontext_core.service.data.task import insert_task, update_task
+
+
+MODULE = "acontext_core.service.data.task"
+
+
+class TestTaskTitleSync:
+    @pytest.mark.asyncio
+    async def test_insert_task_syncs_session_title_from_first_task(self):
+        db_session = AsyncMock()
+        db_session.add = MagicMock()
+        db_session.execute = AsyncMock(return_value=MagicMock())
+        db_session.flush = AsyncMock()
+        project_id = uuid.uuid4()
+        session_id = uuid.uuid4()
+
+        with (
+            patch(
+                f"{MODULE}.fetch_first_task_description",
+                new_callable=AsyncMock,
+                return_value=Result.resolve("First task title"),
+            ),
+            patch(
+                f"{MODULE}.SD.update_session_display_title_once",
+                new_callable=AsyncMock,
+                return_value=Result.resolve(True),
+            ) as update_title_mock,
+        ):
+            result = await insert_task(
+                db_session,
+                project_id,
+                session_id,
+                after_order=0,
+                data={"task_description": "First task title"},
+            )
+
+            assert result.ok()
+            update_title_mock.assert_awaited_once_with(
+                db_session, session_id, "First task title"
+            )
+
+    @pytest.mark.asyncio
+    async def test_update_task_syncs_session_title_from_first_task(self):
+        db_session = AsyncMock()
+        task = Task(
+            session_id=uuid.uuid4(),
+            project_id=uuid.uuid4(),
+            order=1,
+            data={"task_description": "Old title"},
+            status="pending",
+        )
+        query_result = MagicMock()
+        query_result.scalars.return_value.first.return_value = task
+        db_session.execute = AsyncMock(return_value=query_result)
+        db_session.flush = AsyncMock()
+
+        with (
+            patch(
+                f"{MODULE}.fetch_first_task_description",
+                new_callable=AsyncMock,
+                return_value=Result.resolve("First task title"),
+            ),
+            patch(
+                f"{MODULE}.SD.update_session_display_title_once",
+                new_callable=AsyncMock,
+                return_value=Result.resolve(True),
+            ) as update_title_mock,
+        ):
+            result = await update_task(
+                db_session,
+                task.id,
+                patch_data={"task_description": "New title"},
+            )
+
+            assert result.ok()
+            update_title_mock.assert_awaited_once_with(
+                db_session, task.session_id, "First task title"
+            )
+
+    @pytest.mark.asyncio
+    async def test_skips_title_write_when_first_task_title_is_missing(self):
+        db_session = AsyncMock()
+        db_session.add = MagicMock()
+        db_session.execute = AsyncMock(return_value=MagicMock())
+        db_session.flush = AsyncMock()
+
+        with (
+            patch(
+                f"{MODULE}.fetch_first_task_description",
+                new_callable=AsyncMock,
+                return_value=Result.resolve(None),
+            ),
+            patch(
+                f"{MODULE}.SD.update_session_display_title_once",
+                new_callable=AsyncMock,
+                return_value=Result.resolve(True),
+            ) as update_title_mock,
+        ):
+            result = await insert_task(
+                db_session,
+                uuid.uuid4(),
+                uuid.uuid4(),
+                after_order=0,
+                data={"task_description": "First task title"},
+            )
+
+            assert result.ok()
+            update_title_mock.assert_not_awaited()