google-adk 0.0.1__py3-none-any.whl → 0.0.2__py3-none-any.whl

google/adk/flows/llm_flows/agent_transfer.py

@@ -0,0 +1,132 @@
+# Copyright 2025 Google LLC
+#
+# 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.
+
+"""Handles agent transfer for LLM flow."""
+
+from __future__ import annotations
+
+import typing
+from typing import AsyncGenerator
+
+from typing_extensions import override
+
+from ...agents.invocation_context import InvocationContext
+from ...events.event import Event
+from ...models.llm_request import LlmRequest
+from ...tools.function_tool import FunctionTool
+from ...tools.tool_context import ToolContext
+from ...tools.transfer_to_agent_tool import transfer_to_agent
+from ._base_llm_processor import BaseLlmRequestProcessor
+
+if typing.TYPE_CHECKING:
+  from ...agents import BaseAgent
+  from ...agents import LlmAgent
+
+
+class _AgentTransferLlmRequestProcessor(BaseLlmRequestProcessor):
+  """Agent transfer request processor."""
+
+  @override
+  async def run_async(
+      self, invocation_context: InvocationContext, llm_request: LlmRequest
+  ) -> AsyncGenerator[Event, None]:
+    from ...agents.llm_agent import LlmAgent
+
+    if not isinstance(invocation_context.agent, LlmAgent):
+      return
+
+    transfer_targets = _get_transfer_targets(invocation_context.agent)
+    if not transfer_targets:
+      return
+
+    llm_request.append_instructions([
+        _build_target_agents_instructions(
+            invocation_context.agent, transfer_targets
+        )
+    ])
+
+    transfer_to_agent_tool = FunctionTool(func=transfer_to_agent)
+    tool_context = ToolContext(invocation_context)
+    await transfer_to_agent_tool.process_llm_request(
+        tool_context=tool_context, llm_request=llm_request
+    )
+
+    return
+    yield  # AsyncGenerator requires yield statement in function body.
+
+
+request_processor = _AgentTransferLlmRequestProcessor()
+
+
+def _build_target_agents_info(target_agent: BaseAgent) -> str:
+  return f"""
+Agent name: {target_agent.name}
+Agent description: {target_agent.description}
+"""
+
+
+line_break = '\n'
+
+
+def _build_target_agents_instructions(
+    agent: LlmAgent, target_agents: list[BaseAgent]
+) -> str:
+  si = f"""
+You have a list of other agents to transfer to:
+
+{line_break.join([
+    _build_target_agents_info(target_agent) for target_agent in target_agents
+])}
+
+If you are the best to answer the question according to your description, you
+can answer it.
+
+If another agent is better for answering the question according to its
+description, call `{_TRANSFER_TO_AGENT_FUNCTION_NAME}` function to transfer the
+question to that agent. When transfering, do not generate any text other than
+the function call.
+"""
+
+  if agent.parent_agent:
+    si += f"""
+Your parent agent is {agent.parent_agent.name}. If neither the other agents nor
+you are best for answering the question according to the descriptions, transfer
+to your parent agent. If you don't have parent agent, try answer by yourself.
+"""
+  return si
+
+
+_TRANSFER_TO_AGENT_FUNCTION_NAME = transfer_to_agent.__name__
+
+
+def _get_transfer_targets(agent: LlmAgent) -> list[BaseAgent]:
+  from ...agents.llm_agent import LlmAgent
+
+  result = []
+  result.extend(agent.sub_agents)
+
+  if not agent.parent_agent or not isinstance(agent.parent_agent, LlmAgent):
+    return result
+
+  if not agent.disallow_transfer_to_parent:
+    result.append(agent.parent_agent)
+
+  if not agent.disallow_transfer_to_peers:
+    result.extend([
+        peer_agent
+        for peer_agent in agent.parent_agent.sub_agents
+        if peer_agent.name != agent.name
+    ])
+
+  return result

google/adk/flows/llm_flows/audio_transcriber.py

@@ -0,0 +1,109 @@
+# Copyright 2025 Google LLC
+#
+# 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 __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from google.cloud import speech
+from google.genai import types as genai_types
+
+if TYPE_CHECKING:
+  from ...agents.invocation_context import InvocationContext
+
+
+class AudioTranscriber:
+  """Transcribes audio using Google Cloud Speech-to-Text."""
+
+  def __init__(self):
+    self.client = speech.SpeechClient()
+
+  def transcribe_file(
+      self, invocation_context: InvocationContext
+  ) -> list[genai_types.Content]:
+    """Transcribe audio, bundling consecutive segments from the same speaker.
+
+    The ordering of speakers will be preserved. Audio blobs will be merged for
+    the same speaker as much as we can do reduce the transcription latency.
+
+    Args:
+        invocation_context: The invocation context to access the transcription
+          cache.
+
+    Returns:
+        A list of Content objects containing the transcribed text.
+    """
+
+    bundled_audio = []
+    current_speaker = None
+    current_audio_data = b''
+    contents = []
+
+    # Step1: merge audio blobs
+    for transcription_entry in invocation_context.transcription_cache or []:
+      speaker, audio_data = (
+          transcription_entry.role,
+          transcription_entry.data,
+      )
+
+      if isinstance(audio_data, genai_types.Content):
+        if current_speaker is not None:
+          bundled_audio.append((current_speaker, current_audio_data))
+          current_speaker = None
+          current_audio_data = b''
+        bundled_audio.append((speaker, audio_data))
+        continue
+
+      if not audio_data.data:
+        continue
+
+      if speaker == current_speaker:
+        current_audio_data += audio_data.data
+      else:
+        if current_speaker is not None:
+          bundled_audio.append((current_speaker, current_audio_data))
+        current_speaker = speaker
+        current_audio_data = audio_data.data
+
+    # Append the last audio segment if any
+    if current_speaker is not None:
+      bundled_audio.append((current_speaker, current_audio_data))
+
+    # reset cache
+    invocation_context.transcription_cache = []
+
+    # Step2: transcription
+    for speaker, data in bundled_audio:
+      if speaker == 'user':
+        audio = speech.RecognitionAudio(content=data)
+
+        config = speech.RecognitionConfig(
+            encoding=speech.RecognitionConfig.AudioEncoding.LINEAR16,
+            sample_rate_hertz=16000,
+            language_code='en-US',
+        )
+
+        response = self.client.recognize(config=config, audio=audio)
+
+        for result in response.results:
+          transcript = result.alternatives[0].transcript
+
+          parts = [genai_types.Part(text=transcript)]
+          role = speaker.lower()
+          content = genai_types.Content(role=role, parts=parts)
+          contents.append(content)
+      else:
+        # don't need to transcribe model which are already text
+        contents.append(data)
+
+    return contents

google/adk/flows/llm_flows/auto_flow.py

@@ -0,0 +1,49 @@
+# Copyright 2025 Google LLC
+#
+# 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.
+
+"""Implementation of AutoFlow."""
+
+from . import agent_transfer
+from .single_flow import SingleFlow
+
+
+class AutoFlow(SingleFlow):
+  """AutoFlow is SingleFlow with agent transfer capability.
+
+  Agent transfer is allowed in the following direction:
+
+  1. from parent to sub-agent;
+  2. from sub-agent to parent;
+  3. from sub-agent to its peer agents;
+
+  For peer-agent transfers, it's only enabled when all below conditions are met:
+
+  - The parent agent is also of AutoFlow;
+  - `disallow_transfer_to_peer` option of this agent is False (default).
+
+  Depending on the target agent flow type, the transfer may be automatically
+  reversed. The condition is as below:
+
+  - If the flow type of the tranferee agent is also auto, transfee agent will
+    remain as the active agent. The transfee agent will respond to the user's
+    next message directly.
+  - If the flow type of the transfere agent is not auto, the active agent will
+    be reversed back to previous agent.
+
+  TODO: allow user to config auto-reverse function.
+  """
+
+  def __init__(self):
+    super().__init__()
+    self.request_processors += [agent_transfer.request_processor]