fix: minor fixes

Author: riturajFi

.vscode/settings.json

@@ -177,6 +177,9 @@ class Session(BaseModel):
     disable_task_tracking: bool = Field(
         False, description="Whether task tracking is disabled for this session"
     )
+    display_title: str | None = Field(
+        None, description="Optional generated display title for the session"
+    )
     configs: dict[str, Any] | None = Field(
         None, description="Session configuration dictionary"
     )

src/client/acontext-py/src/acontext/types/session.py

@@ -150,6 +150,26 @@ async def test_async_sessions_create_with_use_uuid_and_user(
     assert kwargs["json_data"]["configs"] == {"agent": "bot1"}
 
 
+@patch("acontext.async_client.AcontextAsyncClient.request", new_callable=AsyncMock)
+@pytest.mark.asyncio
+async def test_async_sessions_create_parses_display_title(
+    mock_request, async_client: AcontextAsyncClient
+) -> None:
+    """Test that display_title from API is available on Session model."""
+    mock_request.return_value = {
+        "id": "session-id",
+        "project_id": "project-id",
+        "display_title": "Plan migration rollout",
+        "configs": {},
+        "created_at": "2024-01-01T00:00:00Z",
+        "updated_at": "2024-01-01T00:00:00Z",
+    }
+
+    session = await async_client.sessions.create()
+
+    assert session.display_title == "Plan migration rollout"
+
+
 @patch("acontext.async_client.AcontextAsyncClient.request", new_callable=AsyncMock)
 @pytest.mark.asyncio
 async def test_async_store_message_with_files_uses_multipart_payload(

src/client/acontext-py/tests/test_async_client.py

@@ -461,6 +461,25 @@ def test_sessions_create_with_use_uuid_and_user(
     assert kwargs["json_data"]["configs"] == {"agent": "bot1"}
 
 
+@patch("acontext.client.AcontextClient.request")
+def test_sessions_create_parses_display_title(
+    mock_request, client: AcontextClient
+) -> None:
+    """Test that display_title from API is available on Session model."""
+    mock_request.return_value = {
+        "id": "session-id",
+        "project_id": "project-id",
+        "display_title": "Plan migration rollout",
+        "configs": {},
+        "created_at": "2024-01-01T00:00:00Z",
+        "updated_at": "2024-01-01T00:00:00Z",
+    }
+
+    session = client.sessions.create()
+
+    assert session.display_title == "Plan migration rollout"
+
+
 @patch("acontext.client.AcontextClient.request")
 def test_sessions_list_filter_by_configs(mock_request, client: AcontextClient) -> None:
     """Test that filter_by_configs is JSON-encoded and sent to API."""

src/client/acontext-py/tests/test_client.py

@@ -49,6 +49,7 @@ export const SessionSchema = z.object({
   project_id: z.string(),
   user_id: z.string().nullable().optional(),
   disable_task_tracking: z.boolean(),
+  display_title: z.string().nullable().optional(),
   configs: z.record(z.string(), z.unknown()).nullable(),
   created_at: z.string(),
   updated_at: z.string(),

src/client/acontext-ts/src/types/session.ts

@@ -123,6 +123,16 @@ describe('AcontextClient Unit Tests', () => {
       expect(session.id).toBe(customUuid);
     });
 
+    test('should parse display_title in session response', async () => {
+      const createdSession = mockSession({
+        display_title: 'Plan migration rollout',
+      });
+      client.mock().onPost('/session', () => createdSession);
+
+      const session = await client.sessions.create();
+      expect(session.display_title).toBe('Plan migration rollout');
+    });
+
     test('should store a message in acontext format', async () => {
       const sessionId = 'test-session-id';
       const storedMessage = mockMessage({

src/client/acontext-ts/tests/client.test.ts

@@ -195,6 +195,7 @@ export function mockSession(overrides?: Partial<{
   project_id: string;
   user_id: string | null;
   disable_task_tracking: boolean;
+  display_title: string | null;
   configs: Record<string, unknown> | null;
   created_at: string;
   updated_at: string;
@@ -205,6 +206,7 @@ export function mockSession(overrides?: Partial<{
     project_id: overrides?.project_id ?? mockId(),
     user_id: overrides?.user_id ?? null,
     disable_task_tracking: overrides?.disable_task_tracking ?? false,
+    display_title: overrides?.display_title ?? null,
     configs: overrides?.configs ?? {},
     created_at: overrides?.created_at ?? now,
     updated_at: overrides?.updated_at ?? now,

src/client/acontext-ts/tests/mocks.ts

@@ -18,6 +18,7 @@
 from ..schema.orm import ORM_BASE
 from ..env import LOG as logger
 from ..env import DEFAULT_CORE_CONFIG
+from .schema_migrations import apply_runtime_schema_patches
 
 
 class DatabaseClient:
@@ -196,9 +197,16 @@ async def create_tables(self) -> None:
         logger.info("pgvector extension init")
         async with self.engine.begin() as conn:
             await conn.run_sync(ORM_BASE.metadata.create_all)
+        await self._apply_schema_migrations()
 
         self._table_created = True
 
+    async def _apply_schema_migrations(self) -> None:
+        """Apply idempotent schema patches for existing deployments."""
+        async with self.get_session_context() as db_session:
+            patch_names = await apply_runtime_schema_patches(db_session)
+        logger.info(f"Schema patches ensured: {', '.join(patch_names)}")
+
     async def drop_tables(self) -> None:
         """Drop all tables defined in the ORM models."""
         async with self.engine.begin() as conn:

src/server/core/acontext_core/infra/db.py

@@ -0,0 +1,17 @@
+from sqlalchemy import text
+from sqlalchemy.ext.asyncio import AsyncSession
+
+DISPLAY_TITLE_COLUMN_PATCH_NAME = "sessions.display_title"
+DISPLAY_TITLE_COLUMN_PATCH_SQL = text(
+    "ALTER TABLE sessions ADD COLUMN IF NOT EXISTS display_title TEXT;"
+)
+
+
+async def apply_runtime_schema_patches(db_session: AsyncSession) -> list[str]:
+    """Apply idempotent runtime schema patches for existing deployments."""
+    applied_patch_names: list[str] = []
+
+    await db_session.execute(DISPLAY_TITLE_COLUMN_PATCH_SQL)
+    applied_patch_names.append(DISPLAY_TITLE_COLUMN_PATCH_NAME)
+
+    return applied_patch_names

src/server/core/acontext_core/infra/schema_migrations.py

@@ -133,9 +133,9 @@ async def process_session_pending_message(
 
     pending_message_ids = None
     try:
-        async with DB_CLIENT.get_session_context() as session:
+        async with DB_CLIENT.get_session_context() as db_session:
             r = await MD.get_message_ids(
-                session,
+                db_session,
                 session_id,
                 limit=(
                     project_config.project_session_message_buffer_max_overflow
@@ -153,22 +153,22 @@ async def process_session_pending_message(
                     f"Project {project_id} has disabled new task creation, skip"
                 )
                 await MD.update_message_status_to(
-                    session, pending_message_ids, TaskStatus.FAILED
+                    db_session, pending_message_ids, TaskStatus.FAILED
                 )
                 return Result.resolve(None)
             await MD.update_message_status_to(
-                session, pending_message_ids, TaskStatus.RUNNING
+                db_session, pending_message_ids, TaskStatus.RUNNING
             )
         LOG.info(f"Unpending {len(pending_message_ids)} session messages to process")
 
-        async with DB_CLIENT.get_session_context() as session:
-            r = await MD.fetch_messages_data_by_ids(session, pending_message_ids)
+        async with DB_CLIENT.get_session_context() as db_session:
+            r = await MD.fetch_messages_data_by_ids(db_session, pending_message_ids)
             messages, eil = r.unpack()
             if eil:
                 return r
 
             r = await MD.fetch_previous_messages_by_datetime(
-                session,
+                db_session,
                 session_id,
                 messages[0].created_at,
                 limit=project_config.project_session_message_use_previous_messages_turns,
@@ -181,7 +181,9 @@ async def process_session_pending_message(
             ]
             first_user_message_text = None
             try:
-                r = await SD.should_generate_session_display_title(session, session_id)
+                r = await SD.should_generate_session_display_title(
+                    db_session, session_id
+                )
                 should_generate_title, eil = r.unpack()
                 if eil:
                     raise ValueError(eil.errmsg)
@@ -217,8 +219,10 @@ async def process_session_pending_message(
         if first_user_message_text is not None:
             try:
                 title_candidate = None
-                r = await generate_session_title_candidate(first_user_message_text)
-                title_candidate_raw, eil = r.unpack()
+                title_result = await generate_session_title_candidate(
+                    first_user_message_text
+                )
+                title_candidate_raw, eil = title_result.unpack()
                 if eil:
                     raise ValueError(eil.errmsg)
 
@@ -236,9 +240,9 @@ async def process_session_pending_message(
                     )
 
                 if title_candidate is not None:
-                    async with DB_CLIENT.get_session_context() as session:
+                    async with DB_CLIENT.get_session_context() as db_session:
                         r = await SD.update_session_display_title(
-                            session, session_id, title_candidate
+                            db_session, session_id, title_candidate
                         )
                         _, eil = r.unpack()
                         if eil:
@@ -249,7 +253,7 @@ async def process_session_pending_message(
                     f"Skip title generation/persist for session {session_id}: {title_err}"
                 )
 
-        r = await AT.task_agent_curd(
+        agent_result = await AT.task_agent_curd(
             project_id,
             session_id,
             messages_data,
@@ -258,21 +262,22 @@ async def process_session_pending_message(
         )
 
         after_status = TaskStatus.SUCCESS
-        if not r.ok():
+        if not agent_result.ok():
             after_status = TaskStatus.FAILED
-        async with DB_CLIENT.get_session_context() as session:
+        async with DB_CLIENT.get_session_context() as db_session:
             await MD.update_message_status_to(
-                session, pending_message_ids, after_status
+                db_session, pending_message_ids, after_status
             )
-        return r
+
+        return agent_result
     except Exception as e:
         if pending_message_ids is None:
             raise e
         LOG.error(
             f"Exception while processing session pending message: {e}, rollback {len(pending_message_ids)} message status to failed"
         )
-        async with DB_CLIENT.get_session_context() as session:
+        async with DB_CLIENT.get_session_context() as db_session:
             await MD.update_message_status_to(
-                session, pending_message_ids, TaskStatus.FAILED
+                db_session, pending_message_ids, TaskStatus.FAILED
             )
         raise e