feat(adk): align stores with ADK 2 contract

sqlspec/config.py

@@ -606,10 +606,10 @@ class ADKConfig(TypedDict):
     """
 
     session_table: NotRequired[str]
-    """Name of the sessions table. Default: 'adk_sessions'"""
+    """Name of the sessions table. Default: 'adk_session'"""
 
     events_table: NotRequired[str]
-    """Name of the events table. Default: 'adk_events'"""
+    """Name of the events table. Default: 'adk_event'"""
 
     memory_table: NotRequired[str]
     """Name of the memory entries table. Default: 'adk_memory_entries'"""

sqlspec/extensions/adk/_config_utils.py

@@ -28,6 +28,9 @@ class _ADKSessionStoreConfig(TypedDict):
 
     session_table: str
     events_table: str
+    app_state_table: str
+    user_state_table: str
+    metadata_table: str
     owner_id_column: NotRequired[str]
 
 
@@ -45,6 +48,7 @@ class _ADKArtifactStoreConfig(TypedDict):
     """Normalized ADK artifact store configuration."""
 
     artifact_table: str
+    storage_uri: NotRequired[str]
 
 
 class _ADKConfigSource(Protocol):
@@ -66,11 +70,12 @@ def _get_adk_session_store_config(config: _ADKConfigSource) -> _ADKSessionStoreC
     """Return normalized session store table settings."""
 
     adk_config = _get_adk_config_from_extension(config)
-    session_table = adk_config.get("session_table")
-    events_table = adk_config.get("events_table")
     result: _ADKSessionStoreConfig = {
-        "session_table": str(session_table) if session_table is not None else "adk_sessions",
-        "events_table": str(events_table) if events_table is not None else "adk_events",
+        "session_table": str(adk_config.get("session_table") or "adk_session"),
+        "events_table": str(adk_config.get("events_table") or "adk_event"),
+        "app_state_table": str(adk_config.get("app_state_table") or "adk_app_state"),
+        "user_state_table": str(adk_config.get("user_state_table") or "adk_user_state"),
+        "metadata_table": str(adk_config.get("metadata_table") or "adk_internal_metadata"),
     }
     owner_id = adk_config.get("owner_id_column")
     if owner_id is not None:
@@ -83,14 +88,11 @@ def _get_adk_memory_store_config(config: _ADKConfigSource) -> _ADKMemoryStoreCon
 
     adk_config = _get_adk_config_from_extension(config)
     enable_memory = adk_config.get("enable_memory")
-    memory_table = adk_config.get("memory_table")
-    use_fts = adk_config.get("memory_use_fts")
     max_results = adk_config.get("memory_max_results")
-
     result: _ADKMemoryStoreConfig = {
         "enable_memory": bool(enable_memory) if enable_memory is not None else True,
-        "memory_table": str(memory_table) if memory_table is not None else "adk_memory_entries",
-        "use_fts": bool(use_fts) if use_fts is not None else False,
+        "memory_table": str(adk_config.get("memory_table") or "adk_memory"),
+        "use_fts": bool(adk_config.get("memory_use_fts", False)),
         "max_results": int(max_results) if isinstance(max_results, int) else 20,
     }
     owner_id = adk_config.get("owner_id_column")
@@ -103,8 +105,11 @@ def _get_adk_artifact_store_config(config: _ADKConfigSource) -> _ADKArtifactStor
     """Return normalized artifact store settings."""
 
     adk_config = _get_adk_config_from_extension(config)
-    artifact_table = adk_config.get("artifact_table")
-    return {"artifact_table": str(artifact_table) if artifact_table is not None else "adk_artifact_versions"}
+    result: _ADKArtifactStoreConfig = {"artifact_table": str(adk_config.get("artifact_table") or "adk_artifact")}
+    storage_uri = adk_config.get("artifact_storage_uri")
+    if storage_uri is not None:
+        result["storage_uri"] = str(storage_uri)
+    return result
 
 
 def _resolve_adk_store_path(config: Any, store_suffix: str) -> str:
@@ -178,7 +183,8 @@ def _is_adk_memory_migration_enabled(config: Any) -> bool:
     include_memory = adk_config.get("include_memory_migration")
     if include_memory is not None:
         return bool(include_memory)
-    return bool(adk_config.get("enable_memory", True))
+    enable_memory = adk_config.get("enable_memory")
+    return bool(enable_memory) if enable_memory is not None else True
 
 
 def _validate_adk_store_registration(config: Any) -> None:

sqlspec/extensions/adk/_types.py

@@ -27,15 +27,17 @@ class SessionRecord(TypedDict):
 class EventRecord(TypedDict):
     """Database record for an event.
 
-    Stores the full ADK Event as a single JSON blob (``event_json``) alongside
-    a small number of indexed scalar columns used for query filtering.
+    Stores the full ADK Event as a single JSON blob (``event_data``) alongside
+    indexed scalar columns used for scoped query filtering.
 
     This design eliminates column drift with upstream ADK: new Event fields are
-    automatically captured in ``event_json`` without schema changes.
+    automatically captured in ``event_data`` without schema changes.
     """
 
+    id: str
+    app_name: str
+    user_id: str
     session_id: str
     invocation_id: str
-    author: str
     timestamp: datetime
-    event_json: "dict[str, Any]"
+    event_data: "dict[str, Any]"

sqlspec/extensions/adk/converters.py

@@ -1,9 +1,9 @@
 """Conversion functions between ADK models and database records.
 
 Implements full-event JSON storage: the entire Event is serialized via
-``Event.model_dump_json(exclude_none=True)`` into a single ``event_json``
+``Event.model_dump(exclude_none=True, mode="json")`` into a single ``event_data``
 column, with a small set of indexed scalar columns extracted alongside for
-query performance. Reconstruction uses ``Event.model_validate_json()``.
+query performance. Reconstruction uses ``Event.model_validate()``.
 
 Also provides scoped-state helpers that normalise ADK state prefixes
 (``app:``, ``user:``, ``temp:``) so the shared service layer can split,
@@ -106,42 +106,51 @@ def record_to_session(record: SessionRecord, events: "list[EventRecord]") -> "Se
 # ---------------------------------------------------------------------------
 
 
-def event_to_record(event: "Event", session_id: str) -> EventRecord:
+def event_to_record(event: "Event", app_name: str, user_id: str, session_id: str) -> EventRecord:
     """Convert ADK Event to database record using full-event JSON storage.
 
-    The entire Event is serialized into ``event_json`` via Pydantic's
-    ``model_dump_json(exclude_none=True)``. A small number of indexed scalar
-    columns are extracted alongside for query performance.
+    The entire Event is serialized into ``event_data`` via Pydantic's
+    ``model_dump(exclude_none=True, mode="json")``. Indexed scalar columns are
+    extracted alongside for scoped filtering.
 
     Args:
         event: ADK Event object.
+        app_name: Name of the parent app.
+        user_id: ID of the parent user.
         session_id: ID of the parent session.
 
     Returns:
         EventRecord for database storage.
     """
+    event_data = _normalize_event_data(event.model_dump(exclude_none=True, mode="json"))
     return EventRecord(
+        id=event.id,
+        app_name=app_name,
+        user_id=user_id,
         session_id=session_id,
         invocation_id=event.invocation_id,
-        author=event.author,
         timestamp=datetime.fromtimestamp(event.timestamp, tz=timezone.utc),
-        event_json=event.model_dump(exclude_none=True, mode="json"),
+        event_data=event_data,
     )
 
 
 def record_to_event(record: "EventRecord") -> "Event":
     """Convert database record to ADK Event.
 
-    Reconstruction is lossless: the full Event is restored from
-    ``event_json`` via ``Event.model_validate_json()``.
+    Reconstruction is lossless for valid ADK payloads: the full Event is
+    restored from ``event_data`` via ``Event.model_validate()``.
 
     Args:
         record: Event database record.
 
     Returns:
         ADK Event object.
     """
-    return Event.model_validate(record["event_json"])
+    event_data = _normalize_event_data(record["event_data"])
+    event_data.setdefault("id", record["id"])
+    event_data.setdefault("invocation_id", record["invocation_id"])
+    event_data.setdefault("timestamp", record["timestamp"].timestamp())
+    return Event.model_validate(event_data)
 
 
 # ---------------------------------------------------------------------------
@@ -213,3 +222,17 @@ def merge_scoped_state(
     if user_state is not None:
         merged.update(user_state)
     return merged
+
+
+def _normalize_event_data(event_data: "dict[str, Any]") -> "dict[str, Any]":
+    """Return event data acceptable to ADK 2.2's Event model.
+
+    ADK 2.2 guards an assigned ``event.actions = None`` during service writes,
+    but explicit ``actions: null`` does not validate as a durable Event shape.
+    SQLSpec therefore omits that key before storing or restoring payloads.
+    """
+
+    normalized = dict(event_data)
+    if normalized.get("actions") is None:
+        normalized.pop("actions", None)
+    return normalized