Edits for pre-compile regex(faster-compile)

src/google/adk/memory/in_memory_memory_service.py

@@ -37,9 +37,12 @@ def _user_key(app_name: str, user_id: str) -> str:
   return f'{app_name}/{user_id}'
 
 
+_RE_WORDS = re.compile(r'[A-Za-z]+')
+
+
 def _extract_words_lower(text: str) -> set[str]:
   """Extracts words from a string and converts them to lowercase."""
-  return set([word.lower() for word in re.findall(r'[A-Za-z]+', text)])
+  return {word.lower() for word in _RE_WORDS.findall(text)}
 
 
 class InMemoryMemoryService(BaseMemoryService):

src/google/adk/models/gemini_llm_connection.py

@@ -50,6 +50,10 @@ def __init__(
     self._api_backend = api_backend
     self._model_version = model_version
 
+  def _is_gemini_31_live(self) -> bool:
+    mv = (self._model_version or '').lower()
+    return 'gemini-3.1' in mv and 'live' in mv
+
   async def send_history(self, history: list[types.Content]):
     """Sends the conversation history to the gemini model.
 
@@ -111,13 +115,36 @@ async def send_content(self, content: types.Content):
           ),
       )
     else:
-      logger.debug('Sending LLM new content %s', content)
-      await self._gemini_session.send(
-          input=types.LiveClientContent(
-              turns=[content],
-              turn_complete=True,
+      # Gemini 3.1 live models require in-session text to go through
+      # send_realtime_input(text=...) instead of LiveClientContent.
+      if self._is_gemini_31_live():
+        text_chunks = []
+        unsupported_parts = []
+
+        for part in content.parts:
+          if part.text:
+            text_chunks.append(part.text)
+          else:
+            unsupported_parts.append(part)
+
+        if unsupported_parts:
+          raise ValueError(
+              'Gemini 3.1 live only supports in-session text via '
+              'send_realtime_input(text=...). Non-text parts should be sent '
+              'through realtime audio/video paths.'
           )
-      )
+
+        combined_text = ''.join(text_chunks)
+        logger.debug('Sending Gemini 3.1 live realtime text: %s', combined_text)
+        await self._gemini_session.send_realtime_input(text=combined_text)
+      else:
+        logger.debug('Sending LLM new content %s', content)
+        await self._gemini_session.send(
+            input=types.LiveClientContent(
+                turns=[content],
+                turn_complete=True,
+            )
+        )
 
   async def send_realtime(self, input: RealtimeInput):
     """Sends a chunk of audio or a frame of video to the model in realtime.
@@ -128,7 +155,10 @@ async def send_realtime(self, input: RealtimeInput):
     if isinstance(input, types.Blob):
       # The blob is binary and is very large. So let's not log it.
       logger.debug('Sending LLM Blob.')
-      await self._gemini_session.send_realtime_input(media=input)
+      if self._is_gemini_31_live():
+        await self._gemini_session.send_realtime_input(audio=input)
+      else:
+        await self._gemini_session.send_realtime_input(media=input)
 
     elif isinstance(input, types.ActivityStart):
       logger.debug('Sending LLM activity start signal.')
@@ -204,13 +234,24 @@ async def receive(self) -> AsyncGenerator[LlmResponse, None]:
               llm_response.grounding_metadata = (
                   message.server_content.grounding_metadata
               )
-            if content.parts[0].text:
-              text += content.parts[0].text
+
+            saw_text = False
+            saw_non_text_non_inline = False
+
+            for part in content.parts:
+              if part.text:
+                text += part.text
+                saw_text = True
+              # don't yield the merged text event when receiving audio data
+              elif not part.inline_data:
+                saw_non_text_non_inline = True
+
+            if saw_text:
               llm_response.partial = True
-            # don't yield the merged text event when receiving audio data
-            elif text and not content.parts[0].inline_data:
+            elif text and saw_non_text_non_inline:
               yield self.__build_full_text_response(text)
               text = ''
+
             yield llm_response
           # Note: in some cases, tool_call may arrive before
           # generation_complete, causing transcription to appear after

src/google/adk/models/gemma_llm.py

@@ -37,6 +37,10 @@
 
 logger = logging.getLogger('google_adk.' + __name__)
 
+_MARKDOWN_CODE_BLOCK_RE = re.compile(
+    r'```(?:(json|tool_code))?\s*(.*?)\s*```', re.DOTALL
+)
+
 
 class GemmaFunctionCallingMixin:
   """Mixin providing function calling support for Gemma models.
@@ -113,10 +117,7 @@ def _extract_function_calls_from_response(
     try:
       json_candidate = None
 
-      markdown_code_block_pattern = re.compile(
-          r'```(?:(json|tool_code))?\s*(.*?)\s*```', re.DOTALL
-      )
-      block_match = markdown_code_block_pattern.search(response_text)
+      block_match = _MARKDOWN_CODE_BLOCK_RE.search(response_text)
 
       if block_match:
         json_candidate = block_match.group(2).strip()

src/google/adk/models/registry.py

@@ -34,6 +34,9 @@
 Value is the class that implements the model.
 """
 
+_compiled_regex_cache: dict[str, re.Pattern] = {}
+"""Cache for compiled regex patterns, keyed by the raw regex string."""
+
 
 class LLMRegistry:
   """Registry for LLMs."""
@@ -69,6 +72,8 @@ def _register(model_name_regex: str, llm_cls: type[BaseLlm]):
       )
 
     _llm_registry_dict[model_name_regex] = llm_cls
+    if model_name_regex not in _compiled_regex_cache:
+      _compiled_regex_cache[model_name_regex] = re.compile(model_name_regex)
 
   @staticmethod
   def register(llm_cls: type[BaseLlm]):
@@ -96,7 +101,8 @@ def resolve(model: str) -> type[BaseLlm]:
     """
 
     for regex, llm_class in _llm_registry_dict.items():
-      if re.compile(regex).fullmatch(model):
+      compiled = _compiled_regex_cache.get(regex) or re.compile(regex)
+      if compiled.fullmatch(model):
         return llm_class
 
     # Provide helpful error messages for known patterns

src/google/adk/sessions/_session_util.py

@@ -40,11 +40,11 @@ def extract_state_delta(
   """Extracts app, user, and session state deltas from a state dictionary."""
   deltas = {"app": {}, "user": {}, "session": {}}
   if state:
-    for key in state.keys():
+    for key, value in state.items():
       if key.startswith(State.APP_PREFIX):
-        deltas["app"][key.removeprefix(State.APP_PREFIX)] = state[key]
+        deltas["app"][key.removeprefix(State.APP_PREFIX)] = value
       elif key.startswith(State.USER_PREFIX):
-        deltas["user"][key.removeprefix(State.USER_PREFIX)] = state[key]
+        deltas["user"][key.removeprefix(State.USER_PREFIX)] = value
       elif not key.startswith(State.TEMP_PREFIX):
-        deltas["session"][key] = state[key]
+        deltas["session"][key] = value
   return deltas

src/google/adk/sessions/database_session_service.py

@@ -162,10 +162,10 @@ def _merge_state(
 ) -> dict[str, Any]:
   """Merge app, user, and session states into a single state dictionary."""
   merged_state = copy.deepcopy(session_state)
-  for key in app_state.keys():
-    merged_state[State.APP_PREFIX + key] = app_state[key]
-  for key in user_state.keys():
-    merged_state[State.USER_PREFIX + key] = user_state[key]
+  for key, value in app_state.items():
+    merged_state[State.APP_PREFIX + key] = value
+  for key, value in user_state.items():
+    merged_state[State.USER_PREFIX + key] = value
   return merged_state
 
 

src/google/adk/sessions/in_memory_session_service.py

@@ -200,10 +200,8 @@ def _merge_state(
     """Merges app and user state into session state."""
     # Merge app state
     if app_name in self.app_state:
-      for key in self.app_state[app_name].keys():
-        copied_session.state[State.APP_PREFIX + key] = self.app_state[app_name][
-            key
-        ]
+      for key, value in self.app_state[app_name].items():
+        copied_session.state[State.APP_PREFIX + key] = value
 
     if (
         app_name not in self.user_state
@@ -212,10 +210,8 @@ def _merge_state(
       return copied_session
 
     # Merge session state with user state.
-    for key in self.user_state[app_name][user_id].keys():
-      copied_session.state[State.USER_PREFIX + key] = self.user_state[app_name][
-          user_id
-      ][key]
+    for key, value in self.user_state[app_name][user_id].items():
+      copied_session.state[State.USER_PREFIX + key] = value
     return copied_session
 
   @override

src/google/adk/tools/_gemini_schema_util.py

@@ -24,6 +24,12 @@
 
 from ..utils.variant_utils import get_google_llm_variant
 
+# Pre-compiled regex patterns for _to_snake_case
+_RE_NON_ALNUM = re.compile(r"[^a-zA-Z0-9]+")
+_RE_LOWER_UPPER = re.compile(r"([a-z0-9])([A-Z])")
+_RE_UPPER_UPPER_LOWER = re.compile(r"([A-Z]+)([A-Z][a-z])")
+_RE_MULTI_UNDERSCORE = re.compile(r"_+")
+
 
 class _ExtendedJSONSchema(JSONSchema):
   property_ordering: Optional[list[str]] = Field(
@@ -54,19 +60,19 @@ def _to_snake_case(text: str) -> str:
   """
 
   # Handle spaces and non-alphanumeric characters (replace with underscores)
-  text = re.sub(r"[^a-zA-Z0-9]+", "_", text)
+  text = _RE_NON_ALNUM.sub("_", text)
 
   # Insert underscores before uppercase letters (handling both CamelCases)
-  text = re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", text)  # lowerCamelCase
-  text = re.sub(
-      r"([A-Z]+)([A-Z][a-z])", r"\1_\2", text
+  text = _RE_LOWER_UPPER.sub(r"\1_\2", text)  # lowerCamelCase
+  text = _RE_UPPER_UPPER_LOWER.sub(
+      r"\1_\2", text
   )  # UpperCamelCase and acronyms
 
   # Convert to lowercase
   text = text.lower()
 
   # Remove consecutive underscores (clean up extra underscores)
-  text = re.sub(r"_+", "_", text)
+  text = _RE_MULTI_UNDERSCORE.sub("_", text)
 
   # Remove leading and trailing underscores
   text = text.strip("_")