feat: ADK 1.19/2.0 cross-version regression suite + lazy-import compat fixes (#559)

* update new feature and enhancement for log

* feat: add ADK 1.19/2.0 cross-version regression suite and lazy-import compat fixes

Adds a 44-test regression suite targeting every veadk↔ADK seam where 1.19 and
2.0 differ, and fixes two compat bugs the suite caught when run against ADK
2.0.

New tests (tests/test_adk_compat_regression.py)
-----------------------------------------------
- A. Direct coverage of every public helper in veadk.utils.adk_compat that
  test_adk_compat.py didn't already exercise (get_adk_version, is_adk_gte,
  should_use_async_db_drivers, llm_request_has_field, plus the getter path
  for get_event_function_responses).
- B. Edge cases for the event extractors: parts=None / empty / mixed, no
  content, broken getters falling back to part traversal.
- C. Integration against real ADK Event / Content / Part objects so we
  notice if ADK silently changes its public surface.
- D. Agent.run override gated by is_adk_gte("2.0.0") (skipped on v2 by
  design; verifies NotImplementedError still surfaces on v1).
- E. ArkLlm version-branching: ImportError when LlmRequest lacks
  previous_interaction_id; get_previous_interaction_id on real LlmRequest.
- F. tool_attributes_extractors fallback variants (model_dump path, empty
  sentinel, attribute object, missing attrs).
- G. Runner.intercept_new_message integration with a synthetic LLM:
  session_service is InMemorySessionService for local STM, create_session
  contract, end-to-end yield, None-event filtering, part.text=None
  tolerance.
- H. ADK public-surface assumptions (version module, LlmRequest.model_fields,
  Event.get_function_calls/responses).

Compat fixes caught by running the suite under ADK 2.0
------------------------------------------------------
- veadk/agent.py: gate the legacy Agent.run NotImplementedError override on
  `not is_adk_gte("2.0.0")`. ADK 2.0 promotes BaseAgent.run to a @Final
  async generator that the Workflow/NodeRunner engine invokes internally;
  overriding it breaks workflow execution.
- veadk/utils/patches.py: walk `mod.__dict__` instead of `dir(mod)` +
  `getattr` when patching tracers across google.adk.* modules. ADK 2.0's
  `google.adk.tools` package defines `__getattr__` for lazy submodule
  loading; the old dir+getattr pattern triggered every lazy module, including
  optional ones like discovery_engine_search_tool that need google-cloud-*
  deps veadk doesn't ship.
- veadk/evaluation/eval_set_recorder.py: defer the
  `from google.adk.cli.utils import evals` import to the call site. ADK 2.0
  has that module top-import gcs_eval_set_results_manager unconditionally,
  which requires google-cloud-storage — needlessly tainting any veadk caller
  who only imports veadk.Runner.

Regression results
------------------
Both versions show identical counts; each skips exactly the one test that
doesn't apply to its API surface (the suite is symmetric across versions):

* ADK 1.19.0: 195 passed + 1 skipped
  (skip: test_get_previous_interaction_id_with_real_llm_request —
   v1 LlmRequest lacks previous_interaction_id)
* ADK 2.0.0:  195 passed + 1 skipped
  (skip: test_agent_run_raises_notimplemented_on_legacy_adk —
   override is removed on v2 by design)

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

* chore: add Apache-2.0 header to adk_compat.py and apply ruff format

- Add the missing license header to veadk/utils/adk_compat.py so the
  license-header-check CI passes.
- Reformat the new compat test files and eval_set_recorder.py with
  ruff-format (v0.11.12) so the pre-commit CI passes.

---------

Co-authored-by: Claude Opus 4.7 <noreply@anthropic.com>
Co-authored-by: fangyaozheng@bytedance.com <fangyaozheng@bytedance.com>

Author: 3 people

tests/test_adk_compat.py

@@ -0,0 +1,177 @@
+# Copyright (c) 2025 Beijing Volcano Engine Technology Co., Ltd. and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from types import SimpleNamespace
+
+from veadk.memory.short_term_memory_backends.mysql_backend import MysqlSTMBackend
+from veadk.memory.short_term_memory_backends.postgresql_backend import (
+    PostgreSqlSTMBackend,
+)
+from veadk.memory.short_term_memory_backends.sqlite_backend import SQLiteSTMBackend
+from veadk.tracing.telemetry.attributes.extractors.tool_attributes_extractors import (
+    tool_gen_ai_tool_output,
+)
+from veadk.tracing.telemetry.attributes.extractors.types import ToolAttributesParams
+import veadk.utils.adk_compat as adk_compat
+
+
+def test_get_previous_interaction_id_missing_field():
+    llm_request = SimpleNamespace()
+    assert adk_compat.get_previous_interaction_id(llm_request) is None
+
+
+def test_get_previous_interaction_id_with_field():
+    llm_request = SimpleNamespace(previous_interaction_id="interaction_123")
+    assert adk_compat.get_previous_interaction_id(llm_request) == "interaction_123"
+
+
+def test_get_event_function_calls_from_getter():
+    expected_calls = [SimpleNamespace(name="tool_a")]
+
+    class Event:
+        def get_function_calls(self):
+            return expected_calls
+
+    calls = adk_compat.get_event_function_calls(Event())
+    assert calls == expected_calls
+
+
+def test_get_event_function_calls_fallback_to_parts():
+    part1 = SimpleNamespace(function_call=SimpleNamespace(name="tool_1"))
+    part2 = SimpleNamespace(function_call=None)
+    event = SimpleNamespace(content=SimpleNamespace(parts=[part1, part2]))
+
+    calls = adk_compat.get_event_function_calls(event)
+    assert len(calls) == 1
+    assert calls[0].name == "tool_1"
+
+
+def test_get_event_function_calls_getter_error_fallback_to_parts():
+    class Event:
+        content = SimpleNamespace(
+            parts=[SimpleNamespace(function_call="fallback_call")]
+        )
+
+        def get_function_calls(self):
+            raise RuntimeError("broken getter")
+
+    calls = adk_compat.get_event_function_calls(Event())
+    assert calls == ["fallback_call"]
+
+
+def test_get_event_function_responses_fallback_to_parts():
+    part = SimpleNamespace(function_response=SimpleNamespace(name="tool_resp"))
+    event = SimpleNamespace(content=SimpleNamespace(parts=[part]))
+
+    responses = adk_compat.get_event_function_responses(event)
+    assert len(responses) == 1
+    assert responses[0].name == "tool_resp"
+
+
+def test_mysql_backend_url_respects_async_driver_flag(monkeypatch):
+    monkeypatch.setattr(
+        "veadk.memory.short_term_memory_backends.mysql_backend.should_use_async_db_drivers",
+        lambda: True,
+    )
+    backend = MysqlSTMBackend()
+    assert backend._db_url.startswith("mysql+aiomysql://")
+
+    monkeypatch.setattr(
+        "veadk.memory.short_term_memory_backends.mysql_backend.should_use_async_db_drivers",
+        lambda: False,
+    )
+    backend = MysqlSTMBackend()
+    assert backend._db_url.startswith("mysql+pymysql://")
+
+
+def test_postgresql_backend_url_respects_async_driver_flag(monkeypatch):
+    monkeypatch.setattr(
+        "veadk.memory.short_term_memory_backends.postgresql_backend.should_use_async_db_drivers",
+        lambda: True,
+    )
+    backend = PostgreSqlSTMBackend()
+    assert backend._db_url.startswith("postgresql+asyncpg://")
+
+    monkeypatch.setattr(
+        "veadk.memory.short_term_memory_backends.postgresql_backend.should_use_async_db_drivers",
+        lambda: False,
+    )
+    backend = PostgreSqlSTMBackend()
+    assert backend._db_url.startswith("postgresql://")
+
+
+def test_sqlite_backend_url_respects_async_driver_flag(monkeypatch, tmp_path):
+    db_file = tmp_path / "compat-test.db"
+
+    monkeypatch.setattr(
+        "veadk.memory.short_term_memory_backends.sqlite_backend.should_use_async_db_drivers",
+        lambda: True,
+    )
+    backend = SQLiteSTMBackend(local_path=str(db_file))
+    assert backend._db_url.startswith("sqlite+aiosqlite:///")
+
+    monkeypatch.setattr(
+        "veadk.memory.short_term_memory_backends.sqlite_backend.should_use_async_db_drivers",
+        lambda: False,
+    )
+    backend = SQLiteSTMBackend(local_path=str(db_file))
+    assert backend._db_url.startswith("sqlite:///")
+
+
+def test_tool_output_extractor_accepts_dict_response():
+    function_response_event = SimpleNamespace(
+        content=SimpleNamespace(
+            parts=[
+                SimpleNamespace(
+                    function_response={
+                        "id": "id_1",
+                        "name": "tool_name",
+                        "response": {"ok": True},
+                    }
+                )
+            ]
+        )
+    )
+    params = ToolAttributesParams(
+        tool=SimpleNamespace(name="tool_name"),
+        args={},
+        function_response_event=function_response_event,
+    )
+
+    response = tool_gen_ai_tool_output(params)
+    assert '"name": "tool_name"' in response.content
+
+
+def test_tool_output_extractor_accepts_object_response():
+    function_response_event = SimpleNamespace(
+        content=SimpleNamespace(
+            parts=[
+                SimpleNamespace(
+                    function_response=SimpleNamespace(
+                        id="id_2",
+                        name="tool_obj",
+                        response={"status": "done"},
+                    )
+                )
+            ]
+        )
+    )
+    params = ToolAttributesParams(
+        tool=SimpleNamespace(name="tool_obj"),
+        args={},
+        function_response_event=function_response_event,
+    )
+
+    response = tool_gen_ai_tool_output(params)
+    assert '"name": "tool_obj"' in response.content