feat(sessions): Add session title management functionality

src/google/adk/cli/adk_web_server.py

@@ -821,6 +821,21 @@ async def create_session(
 
       return session
 
+    @app.patch(
+        "/apps/{app_name}/users/{user_id}/sessions/{session_id}/title",
+        response_model_exclude_none=True,
+    )
+    async def update_session_title(
+        app_name: str,
+        user_id: str,
+        session_id: str,
+        title: Optional[str] = None,
+    ) -> dict[str, str]:
+      await self.session_service.update_session_title(
+          app_name=app_name, user_id=user_id, session_id=session_id, title=title
+      )
+      return {"status": "success"}
+
     @app.delete("/apps/{app_name}/users/{user_id}/sessions/{session_id}")
     async def delete_session(
         app_name: str, user_id: str, session_id: str

src/google/adk/sessions/base_session_service.py

@@ -56,6 +56,7 @@ async def create_session(
       user_id: str,
       state: Optional[dict[str, Any]] = None,
       session_id: Optional[str] = None,
+      title: Optional[str] = None,
   ) -> Session:
     """Creates a new session.
 
@@ -102,6 +103,24 @@ async def delete_session(
   ) -> None:
     """Deletes a session."""
 
+  @abc.abstractmethod
+  async def update_session_title(
+      self,
+      *,
+      app_name: str,
+      user_id: str,
+      session_id: str,
+      title: Optional[str],
+  ) -> None:
+    """Updates the title of a session.
+
+    Args:
+      app_name: The name of the app.
+      user_id: The id of the user.
+      session_id: The id of the session.
+      title: The new title for the session. If None, clears the title.
+    """
+
   async def append_event(self, session: Session, event: Event) -> Event:
     """Appends an event to a session object."""
     if event.partial:

src/google/adk/sessions/database_session_service.py

@@ -167,6 +167,10 @@ class StorageSession(Base):
       MutableDict.as_mutable(DynamicJSON), default={}
   )
 
+  title: Mapped[Optional[str]] = mapped_column(
+      String(DEFAULT_MAX_VARCHAR_LENGTH), nullable=True
+  )
+
   create_time: Mapped[datetime] = mapped_column(
       PreciseTimestamp, default=func.now()
   )
@@ -215,6 +219,7 @@ def to_session(
         state=state,
         events=events,
         last_update_time=self.update_timestamp_tz,
+        title=self.title,
     )
 
 
@@ -497,6 +502,7 @@ async def create_session(
       user_id: str,
       state: Optional[dict[str, Any]] = None,
       session_id: Optional[str] = None,
+      title: Optional[str] = None,
   ) -> Session:
     # 1. Populate states.
     # 2. Build storage session object
@@ -546,6 +552,7 @@ async def create_session(
           user_id=user_id,
           id=session_id,
           state=session_state,
+          title=title,
       )
       sql_session.add(storage_session)
       await sql_session.commit()
@@ -672,6 +679,28 @@ async def delete_session(
       await sql_session.execute(stmt)
       await sql_session.commit()
 
+  @override
+  async def update_session_title(
+      self,
+      *,
+      app_name: str,
+      user_id: str,
+      session_id: str,
+      title: Optional[str],
+  ) -> None:
+    await self._ensure_tables_created()
+    async with self.database_session_factory() as sql_session:
+      storage_session = await sql_session.get(
+          StorageSession, (app_name, user_id, session_id)
+      )
+      if storage_session is None:
+        raise ValueError(
+            f"Session not found: app_name={app_name}, user_id={user_id},"
+            f" session_id={session_id}"
+        )
+      storage_session.title = title
+      await sql_session.commit()
+
   @override
   async def append_event(self, session: Session, event: Event) -> Event:
     await self._ensure_tables_created()

src/google/adk/sessions/in_memory_session_service.py

@@ -58,12 +58,14 @@ async def create_session(
       user_id: str,
       state: Optional[dict[str, Any]] = None,
       session_id: Optional[str] = None,
+      title: Optional[str] = None,
   ) -> Session:
     return self._create_session_impl(
         app_name=app_name,
         user_id=user_id,
         state=state,
         session_id=session_id,
+        title=title,
     )
 
   def create_session_sync(
@@ -73,13 +75,15 @@ def create_session_sync(
       user_id: str,
       state: Optional[dict[str, Any]] = None,
       session_id: Optional[str] = None,
+      title: Optional[str] = None,
   ) -> Session:
     logger.warning('Deprecated. Please migrate to the async method.')
     return self._create_session_impl(
         app_name=app_name,
         user_id=user_id,
         state=state,
         session_id=session_id,
+        title=title,
     )
 
   def _create_session_impl(
@@ -89,6 +93,7 @@ def _create_session_impl(
       user_id: str,
       state: Optional[dict[str, Any]] = None,
       session_id: Optional[str] = None,
+      title: Optional[str] = None,
   ) -> Session:
     if session_id and self._get_session_impl(
         app_name=app_name, user_id=user_id, session_id=session_id
@@ -116,6 +121,7 @@ def _create_session_impl(
         id=session_id,
         state=session_state or {},
         last_update_time=time.time(),
+        title=title,
     )
 
     if app_name not in self.sessions:
@@ -286,6 +292,26 @@ def _delete_session_impl(
 
     self.sessions[app_name][user_id].pop(session_id)
 
+  @override
+  async def update_session_title(
+      self,
+      *,
+      app_name: str,
+      user_id: str,
+      session_id: str,
+      title: Optional[str],
+  ) -> None:
+    if (
+        app_name not in self.sessions
+        or user_id not in self.sessions[app_name]
+        or session_id not in self.sessions[app_name][user_id]
+    ):
+      raise ValueError(
+          f'Session not found: app_name={app_name}, user_id={user_id},'
+          f' session_id={session_id}'
+      )
+    self.sessions[app_name][user_id][session_id].title = title
+
   @override
   async def append_event(self, session: Session, event: Event) -> Event:
     if event.partial:

src/google/adk/sessions/migrate_from_sqlalchemy_sqlite.py

@@ -86,16 +86,40 @@ def migrate(source_db_url: str, dest_db_path: str):
 
     # Migrate sessions
     logger.info("Migrating sessions...")
-    sessions = source_session.query(dss.StorageSession).all()
+    rows = source_session.query(
+        dss.StorageSession.app_name,
+        dss.StorageSession.user_id,
+        dss.StorageSession.id,
+        dss.StorageSession.state,
+        dss.StorageSession.create_time,
+        dss.StorageSession.update_time,
+    ).all()
+    sessions = [
+        type(
+            "StorageSession",
+            (),
+            {
+                "app_name": row[0],
+                "user_id": row[1],
+                "id": row[2],
+                "state": row[3],
+                "create_time": row[4],
+                "update_time": row[5],
+                "title": None,
+            },
+        )()
+        for row in rows
+    ]
     for item in sessions:
       dest_cursor.execute(
-          "INSERT INTO sessions (app_name, user_id, id, state, create_time,"
-          " update_time) VALUES (?, ?, ?, ?, ?, ?)",
+          "INSERT INTO sessions (app_name, user_id, id, state, title,"
+          " create_time, update_time) VALUES (?, ?, ?, ?, ?, ?, ?)",
           (
               item.app_name,
               item.user_id,
               item.id,
               json.dumps(item.state),
+              item.title,
               item.create_time.replace(tzinfo=timezone.utc).timestamp(),
               item.update_time.replace(tzinfo=timezone.utc).timestamp(),
           ),

src/google/adk/sessions/session.py

@@ -15,6 +15,7 @@
 from __future__ import annotations
 
 from typing import Any
+from typing import Optional
 
 from pydantic import alias_generators
 from pydantic import BaseModel
@@ -48,3 +49,5 @@ class Session(BaseModel):
   call/response, etc."""
   last_update_time: float = 0.0
   """The last update time of the session."""
+  title: Optional[str] = None
+  """The title of the session."""

src/google/adk/sessions/sqlite_session_service.py

@@ -64,6 +64,7 @@
     user_id TEXT NOT NULL,
     id TEXT NOT NULL,
     state TEXT NOT NULL,
+    title TEXT,
     create_time REAL NOT NULL,
     update_time REAL NOT NULL,
     PRIMARY KEY (app_name, user_id, id)
@@ -121,6 +122,7 @@ async def create_session(
       user_id: str,
       state: Optional[dict[str, Any]] = None,
       session_id: Optional[str] = None,
+      title: Optional[str] = None,
   ) -> Session:
     if session_id:
       session_id = session_id.strip()
@@ -160,14 +162,15 @@ async def create_session(
       # Store the session
       await db.execute(
           """
-          INSERT INTO sessions (app_name, user_id, id, state, create_time, update_time)
-          VALUES (?, ?, ?, ?, ?, ?)
+          INSERT INTO sessions (app_name, user_id, id, state, title, create_time, update_time)
+          VALUES (?, ?, ?, ?, ?, ?, ?)
           """,
           (
               app_name,
               user_id,
               session_id,
               json.dumps(session_state),
+              title,
               now,
               now,
           ),
@@ -185,6 +188,7 @@ async def create_session(
           state=merged_state,
           events=[],
           last_update_time=now,
+          title=title,
       )
 
   @override
@@ -198,14 +202,15 @@ async def get_session(
   ) -> Optional[Session]:
     async with self._get_db_connection() as db:
       async with db.execute(
-          "SELECT state, update_time FROM sessions WHERE app_name=? AND"
+          "SELECT state, title, update_time FROM sessions WHERE app_name=? AND"
           " user_id=? AND id=?",
           (app_name, user_id, session_id),
       ) as cursor:
         session_row = await cursor.fetchone()
         if session_row is None:
           return None
         session_state = json.loads(session_row["state"])
+        title = session_row["title"]
         last_update_time = session_row["update_time"]
 
       # Build events query
@@ -248,6 +253,7 @@ async def get_session(
           state=merged_state,
           events=events,
           last_update_time=last_update_time,
+          title=title,
       )
 
   @override
@@ -259,13 +265,13 @@ async def list_sessions(
       # Fetch sessions
       if user_id:
         session_rows = await db.execute_fetchall(
-            "SELECT id, user_id, state, update_time FROM sessions WHERE"
+            "SELECT id, user_id, state, title, update_time FROM sessions WHERE"
             " app_name=? AND user_id=?",
             (app_name, user_id),
         )
       else:
         session_rows = await db.execute_fetchall(
-            "SELECT id, user_id, state, update_time FROM sessions WHERE"
+            "SELECT id, user_id, state, title, update_time FROM sessions WHERE"
             " app_name=?",
             (app_name,),
         )
@@ -291,6 +297,7 @@ async def list_sessions(
       for row in session_rows:
         session_user_id = row["user_id"]
         session_state = json.loads(row["state"])
+        title = row["title"]
         user_state = user_states_map.get(session_user_id, {})
         merged_state = _merge_state(app_state, user_state, session_state)
         sessions_list.append(
@@ -301,10 +308,36 @@ async def list_sessions(
                 state=merged_state,
                 events=[],
                 last_update_time=row["update_time"],
+                title=title,
             )
         )
     return ListSessionsResponse(sessions=sessions_list)
 
+  @override
+  async def update_session_title(
+      self,
+      *,
+      app_name: str,
+      user_id: str,
+      session_id: str,
+      title: Optional[str],
+  ) -> None:
+    async with self._get_db_connection() as db:
+      async with db.execute(
+          "SELECT 1 FROM sessions WHERE app_name=? AND user_id=? AND id=?",
+          (app_name, user_id, session_id),
+      ) as cursor:
+        if not await cursor.fetchone():
+          raise ValueError(
+              f"Session not found: app_name={app_name}, user_id={user_id},"
+              f" session_id={session_id}"
+          )
+      await db.execute(
+          "UPDATE sessions SET title=? WHERE app_name=? AND user_id=? AND id=?",
+          (title, app_name, user_id, session_id),
+      )
+      await db.commit()
+
   @override
   async def delete_session(
       self, *, app_name: str, user_id: str, session_id: str