google-adk 0.1.1__py3-none-any.whl → 0.3.0__py3-none-any.whl

google/adk/cli/fast_api.py

@@ -13,7 +13,9 @@
 # limitations under the License.
 
 import asyncio
+from contextlib import asynccontextmanager
 import importlib
+import inspect
 import json
 import logging
 import os
@@ -28,6 +30,7 @@ from typing import Literal
 from typing import Optional
 
 import click
+from click import Tuple
 from fastapi import FastAPI
 from fastapi import HTTPException
 from fastapi import Query
@@ -56,6 +59,7 @@ from ..agents.llm_agent import Agent
 from ..agents.run_config import StreamingMode
 from ..artifacts import InMemoryArtifactService
 from ..events.event import Event
+from ..memory.in_memory_memory_service import InMemoryMemoryService
 from ..runners import Runner
 from ..sessions.database_session_service import DatabaseSessionService
 from ..sessions.in_memory_session_service import InMemorySessionService
@@ -144,7 +148,7 @@ def get_fast_api_app(
       export.SimpleSpanProcessor(ApiServerSpanExporter(trace_dict))
   )
   if trace_to_cloud:
-    envs.load_dotenv()
+    envs.load_dotenv_for_agent("", agent_dir)
     if project_id := os.environ.get("GOOGLE_CLOUD_PROJECT", None):
       processor = export.BatchSpanProcessor(
           CloudTraceSpanExporter(project_id=project_id)
@@ -158,8 +162,22 @@ def get_fast_api_app(
 
   trace.set_tracer_provider(provider)
 
+  exit_stacks = []
+
+  @asynccontextmanager
+  async def internal_lifespan(app: FastAPI):
+    if lifespan:
+      async with lifespan(app) as lifespan_context:
+        yield
+
+        if exit_stacks:
+          for stack in exit_stacks:
+            await stack.aclose()
+    else:
+      yield
+
   # Run the FastAPI server.
-  app = FastAPI(lifespan=lifespan)
+  app = FastAPI(lifespan=internal_lifespan)
 
   if allow_origins:
     app.add_middleware(
@@ -178,6 +196,7 @@ def get_fast_api_app(
 
   # Build the Artifact service
   artifact_service = InMemoryArtifactService()
+  memory_service = InMemoryMemoryService()
 
   # Build the Session service
   agent_engine_id = ""
@@ -355,7 +374,7 @@ def get_fast_api_app(
       "/apps/{app_name}/eval_sets/{eval_set_id}/add_session",
       response_model_exclude_none=True,
   )
-  def add_session_to_eval_set(
+  async def add_session_to_eval_set(
       app_name: str, eval_set_id: str, req: AddSessionToEvalSetRequest
   ):
     pattern = r"^[a-zA-Z0-9_]+$"
@@ -390,7 +409,9 @@ def get_fast_api_app(
     test_data = evals.convert_session_to_eval_format(session)
 
     # Populate the session with initial session state.
-    initial_session_state = create_empty_state(_get_root_agent(app_name))
+    initial_session_state = create_empty_state(
+        await _get_root_agent_async(app_name)
+    )
 
     eval_set_data.append({
         "name": req.eval_id,
@@ -427,7 +448,7 @@ def get_fast_api_app(
       "/apps/{app_name}/eval_sets/{eval_set_id}/run_eval",
       response_model_exclude_none=True,
   )
-  def run_eval(
+  async def run_eval(
       app_name: str, eval_set_id: str, req: RunEvalRequest
   ) -> list[RunEvalResult]:
     from .cli_eval import run_evals
@@ -444,7 +465,7 @@ def get_fast_api_app(
       logger.info(
           "Eval ids to run list is empty. We will all evals in the eval set."
       )
-    root_agent = _get_root_agent(app_name)
+    root_agent = await _get_root_agent_async(app_name)
     eval_results = list(
         run_evals(
             eval_set_to_evals,
@@ -574,7 +595,7 @@ def get_fast_api_app(
     )
     if not session:
       raise HTTPException(status_code=404, detail="Session not found")
-    runner = _get_runner(req.app_name)
+    runner = await _get_runner_async(req.app_name)
     events = [
         event
         async for event in runner.run_async(
@@ -601,7 +622,7 @@ def get_fast_api_app(
     async def event_generator():
       try:
         stream_mode = StreamingMode.SSE if req.streaming else StreamingMode.NONE
-        runner = _get_runner(req.app_name)
+        runner = await _get_runner_async(req.app_name)
         async for event in runner.run_async(
             user_id=req.user_id,
             session_id=req.session_id,
@@ -627,7 +648,7 @@ def get_fast_api_app(
       "/apps/{app_name}/users/{user_id}/sessions/{session_id}/events/{event_id}/graph",
       response_model_exclude_none=True,
   )
-  def get_event_graph(
+  async def get_event_graph(
       app_name: str, user_id: str, session_id: str, event_id: str
   ):
     # Connect to managed session if agent_engine_id is set.
@@ -644,7 +665,7 @@ def get_fast_api_app(
 
     function_calls = event.get_function_calls()
     function_responses = event.get_function_responses()
-    root_agent = _get_root_agent(app_name)
+    root_agent = await _get_root_agent_async(app_name)
     dot_graph = None
     if function_calls:
       function_call_highlights = []
@@ -701,7 +722,7 @@ def get_fast_api_app(
     live_request_queue = LiveRequestQueue()
 
     async def forward_events():
-      runner = _get_runner(app_name)
+      runner = await _get_runner_async(app_name)
       async for event in runner.run_live(
           session=session, live_request_queue=live_request_queue
       ):
@@ -735,30 +756,50 @@ def get_fast_api_app(
     except Exception as e:
       logger.exception("Error during live websocket communication: %s", e)
       traceback.print_exc()
+      WEBSOCKET_INTERNAL_ERROR_CODE = 1011
+      WEBSOCKET_MAX_BYTES_FOR_REASON = 123
+      await websocket.close(
+          code=WEBSOCKET_INTERNAL_ERROR_CODE,
+          reason=str(e)[:WEBSOCKET_MAX_BYTES_FOR_REASON],
+      )
     finally:
       for task in pending:
         task.cancel()
 
-  def _get_root_agent(app_name: str) -> Agent:
+  async def _get_root_agent_async(app_name: str) -> Agent:
     """Returns the root agent for the given app."""
     if app_name in root_agent_dict:
       return root_agent_dict[app_name]
-    envs.load_dotenv_for_agent(os.path.basename(app_name), agent_dir)
     agent_module = importlib.import_module(app_name)
-    root_agent: Agent = agent_module.agent.root_agent
+    if getattr(agent_module.agent, "root_agent"):
+      root_agent = agent_module.agent.root_agent
+    else:
+      raise ValueError(f'Unable to find "root_agent" from {app_name}.')
+
+    # Handle an awaitable root agent and await for the actual agent.
+    if inspect.isawaitable(root_agent):
+      try:
+        agent, exit_stack = await root_agent
+        exit_stacks.append(exit_stack)
+        root_agent = agent
+      except Exception as e:
+        raise RuntimeError(f"error getting root agent, {e}") from e
+
     root_agent_dict[app_name] = root_agent
     return root_agent
 
-  def _get_runner(app_name: str) -> Runner:
+  async def _get_runner_async(app_name: str) -> Runner:
     """Returns the runner for the given app."""
+    envs.load_dotenv_for_agent(os.path.basename(app_name), agent_dir)
     if app_name in runner_dict:
       return runner_dict[app_name]
-    root_agent = _get_root_agent(app_name)
+    root_agent = await _get_root_agent_async(app_name)
     runner = Runner(
         app_name=agent_engine_id if agent_engine_id else app_name,
         agent=root_agent,
         artifact_service=artifact_service,
         session_service=session_service,
+        memory_service=memory_service,
     )
     runner_dict[app_name] = runner
     return runner

google/adk/cli/utils/envs.py

@@ -50,8 +50,5 @@ def load_dotenv_for_agent(
         agent_name,
         dotenv_file_path,
     )
-    logger.info(
-        'Reloaded %s file for %s at %s', filename, agent_name, dotenv_file_path
-    )
   else:
     logger.info('No %s file found for %s', filename, agent_name)

google/adk/cli/utils/evals.py

@@ -66,7 +66,7 @@ def convert_session_to_eval_format(session: Session) -> list[dict[str, Any]]:
                 'tool_input': tool_input,
             })
           elif subsequent_part.text:
-            # Also keep track of all the natural langauge responses that
+            # Also keep track of all the natural language responses that
             # agent (or sub agents) generated.
             intermediate_agent_responses.append(
                 {'author': event_author, 'text': subsequent_part.text}
@@ -75,7 +75,7 @@ def convert_session_to_eval_format(session: Session) -> list[dict[str, Any]]:
       # If we are here then either we are done reading all the events or we
       # encountered an event that had content authored by the end-user.
       # This, basically means an end of turn.
-      # We assume that the last natural langauge intermediate response is the
+      # We assume that the last natural language intermediate response is the
       # final response from the agent/model. We treat that as a reference.
       eval_case.append({
           'query': query,

google/adk/evaluation/agent_evaluator.py

@@ -55,7 +55,7 @@ def load_json(file_path: str) -> Union[Dict, List]:
 
 
 class AgentEvaluator:
-  """An evaluator for Agents, mainly intented for helping with test cases."""
+  """An evaluator for Agents, mainly intended for helping with test cases."""
 
   @staticmethod
   def find_config_for_test_file(test_file: str):
@@ -91,7 +91,7 @@ class AgentEvaluator:
         look for 'root_agent' in the loaded module.
       eval_dataset: The eval data set. This can be either a string representing
         full path to the file containing eval dataset, or a directory that is
-        recusively explored for all files that have a `.test.json` suffix.
+        recursively explored for all files that have a `.test.json` suffix.
       num_runs: Number of times all entries in the eval dataset should be
         assessed.
       agent_name: The name of the agent.

google/adk/evaluation/evaluation_generator.py

@@ -42,10 +42,10 @@ class EvaluationGenerator:
     """Returns evaluation responses for the given dataset and agent.
 
     Args:
-      eval_dataset: The dataset that needs to be scraped for resposnes.
+      eval_dataset: The dataset that needs to be scraped for responses.
       agent_module_path: Path to the module that contains the root agent.
       repeat_num: Number of time the eval dataset should be repeated. This is
-        usually done to remove uncertainity that a single run may bring.
+        usually done to remove uncertainty that a single run may bring.
       agent_name: The name of the agent that should be evaluated. This is
         usually the sub-agent.
       initial_session: Initial session for the eval data.
@@ -253,8 +253,8 @@ class EvaluationGenerator:
       all_mock_tools: set[str],
   ):
     """Recursively apply the before_tool_callback to the root agent and all its subagents."""
-    # check if the agent has tools that defined by evalset
-    # We use function name to check if tools match
+    # Check if the agent has tools that are defined by evalset.
+    # We use function names to check if tools match
     if not isinstance(agent, Agent) and not isinstance(agent, LlmAgent):
       return
 

google/adk/evaluation/response_evaluator.py

@@ -35,14 +35,14 @@ class ResponseEvaluator:
     Args:
       raw_eval_dataset: The dataset that will be evaluated.
       evaluation_criteria: The evaluation criteria to be used. This method
-        support two criterias, `response_evaluation_score` and
+        support two criteria, `response_evaluation_score` and
         `response_match_score`.
       print_detailed_results: Prints detailed results on the console. This is
         usually helpful during debugging.
 
     A note on evaluation_criteria:
       `response_match_score`: This metric compares the agents final natural
-        language reponse with the expected final response, stored in the
+        language response with the expected final response, stored in the
         "reference" field in test/eval files. We use Rouge metric to compare the
         two responses.
 
@@ -56,7 +56,7 @@ class ResponseEvaluator:
         Value range: [0, 5], where 0 means that the agent's response is not
         coherent, while 5 means it is . High values are good.
     A note on raw_eval_dataset:
-      The dataset should be a list session, where each sesssion is represented
+      The dataset should be a list session, where each session is represented
       as a list of interaction that need evaluation. Each evaluation is
       represented as a dictionary that is expected to have values for the
       following keys:
@@ -106,9 +106,11 @@ class ResponseEvaluator:
     eval_dataset = pd.DataFrame(flattened_queries).rename(
         columns={"query": "prompt", "expected_tool_use": "reference_trajectory"}
     )
-    eval_task = EvalTask(dataset=eval_dataset, metrics=metrics)
 
-    eval_result = eval_task.evaluate()
+    eval_result = ResponseEvaluator._perform_eval(
+        dataset=eval_dataset, metrics=metrics
+    )
+
     if print_detailed_results:
       ResponseEvaluator._print_results(eval_result)
     return eval_result.summary_metrics
@@ -129,6 +131,16 @@ class ResponseEvaluator:
       metrics.append("rouge_1")
     return metrics
 
+  @staticmethod
+  def _perform_eval(dataset, metrics):
+    """This method hides away the call to external service.
+
+    Primarily helps with unit testing.
+    """
+    eval_task = EvalTask(dataset=dataset, metrics=metrics)
+
+    return eval_task.evaluate()
+
   @staticmethod
   def _print_results(eval_result):
     print("Evaluation Summary Metrics:", eval_result.summary_metrics)

google/adk/evaluation/trajectory_evaluator.py

@@ -31,10 +31,9 @@ class TrajectoryEvaluator:
   ):
     r"""Returns the mean tool use accuracy of the eval dataset.
 
-    Tool use accuracy is calculated by comparing the expected and actuall tool
-    use trajectories. An exact match scores a 1, 0 otherwise. The final number
-    is an
-    average of these individual scores.
+    Tool use accuracy is calculated by comparing the expected and the actual
+    tool use trajectories. An exact match scores a 1, 0 otherwise. The final
+    number is an average of these individual scores.
 
     Value range: [0, 1], where 0 is means none of the too use entries aligned,
     and 1 would mean all of them aligned. Higher value is good.
@@ -45,7 +44,7 @@ class TrajectoryEvaluator:
         usually helpful during debugging.
 
     A note on eval_dataset:
-      The dataset should be a list session, where each sesssion is represented
+      The dataset should be a list session, where each session is represented
       as a list of interaction that need evaluation. Each evaluation is
       represented as a dictionary that is expected to have values for the
       following keys:

google/adk/events/event.py

@@ -70,7 +70,7 @@ class Event(LlmResponse):
   agent_2, and agent_2 is the parent of agent_3.
 
   Branch is used when multiple sub-agent shouldn't see their peer agents'
-  conversaction history.
+  conversation history.
   """
 
   # The following are computed fields.
@@ -94,7 +94,7 @@ class Event(LlmResponse):
         not self.get_function_calls()
         and not self.get_function_responses()
         and not self.partial
-        and not self.has_trailing_code_exeuction_result()
+        and not self.has_trailing_code_execution_result()
     )
 
   def get_function_calls(self) -> list[types.FunctionCall]:
@@ -115,7 +115,7 @@ class Event(LlmResponse):
           func_response.append(part.function_response)
     return func_response
 
-  def has_trailing_code_exeuction_result(
+  def has_trailing_code_execution_result(
       self,
   ) -> bool:
     """Returns whether the event has a trailing code execution result."""

google/adk/flows/llm_flows/_nl_planning.py

@@ -87,15 +87,21 @@ class _NlPlanningResponse(BaseLlmResponseProcessor):
       return
 
     # Postprocess the LLM response.
+    callback_context = CallbackContext(invocation_context)
     processed_parts = planner.process_planning_response(
-        CallbackContext(invocation_context), llm_response.content.parts
+        callback_context, llm_response.content.parts
     )
     if processed_parts:
       llm_response.content.parts = processed_parts
 
-    # Maintain async generator behavior
-    if False:  # Ensures it behaves as a generator
-      yield  # This is a no-op but maintains generator structure
+    if callback_context.state.has_delta():
+      state_update_event = Event(
+          invocation_id=invocation_context.invocation_id,
+          author=invocation_context.agent.name,
+          branch=invocation_context.branch,
+          actions=callback_context._event_actions,
+      )
+      yield state_update_event
 
 
 response_processor = _NlPlanningResponse()

google/adk/flows/llm_flows/agent_transfer.py

@@ -94,7 +94,7 @@ 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
+question to that agent. When transferring, do not generate any text other than
 the function call.
 """
 

google/adk/flows/llm_flows/base_llm_flow.py

@@ -115,7 +115,7 @@ class BaseLlmFlow(ABC):
           yield event
           # send back the function response
           if event.get_function_responses():
-            logger.debug('Sending back last function resonse event: %s', event)
+            logger.debug('Sending back last function response event: %s', event)
             invocation_context.live_request_queue.send_content(event.content)
           if (
               event.content

google/adk/flows/llm_flows/contents.py

@@ -111,7 +111,7 @@ def _rearrange_events_for_latest_function_response(
   """Rearrange the events for the latest function_response.
 
   If the latest function_response is for an async function_call, all events
-  bewteen the initial function_call and the latest function_response will be
+  between the initial function_call and the latest function_response will be
   removed.
 
   Args:
@@ -310,7 +310,7 @@ def _merge_function_response_events(
     function_response_events: A list of function_response events.
       NOTE: function_response_events must fulfill these requirements: 1. The
         list is in increasing order of timestamp; 2. the first event is the
-        initial function_reponse event; 3. all later events should contain at
+        initial function_response event; 3. all later events should contain at
         least one function_response part that related to the function_call
         event. (Note, 3. may not be true when aync function return some
         intermediate response, there could also be some intermediate model

google/adk/flows/llm_flows/functions.py

@@ -310,9 +310,7 @@ async def _process_function_live_helper(
       function_response = {
           'status': f'No active streaming function named {function_name} found'
       }
-  elif inspect.isasyncgenfunction(tool.func):
-    print('is async')
-
+  elif hasattr(tool, "func") and inspect.isasyncgenfunction(tool.func):
     # for streaming tool use case
     # we require the function to be a async generator function
     async def run_tool_and_update_queue(tool, function_args, tool_context):

google/adk/flows/llm_flows/instructions.py

@@ -52,7 +52,7 @@ class _InstructionsLlmRequestProcessor(BaseLlmRequestProcessor):
     # Appends global instructions if set.
     if (
         isinstance(root_agent, LlmAgent) and root_agent.global_instruction
-    ):  # not emtpy str
+    ):  # not empty str
       raw_si = root_agent.canonical_global_instruction(
           ReadonlyContext(invocation_context)
       )
@@ -60,7 +60,7 @@ class _InstructionsLlmRequestProcessor(BaseLlmRequestProcessor):
       llm_request.append_instructions([si])
 
     # Appends agent instructions if set.
-    if agent.instruction:  # not emtpy str
+    if agent.instruction:  # not empty str
       raw_si = agent.canonical_instruction(ReadonlyContext(invocation_context))
       si = _populate_values(raw_si, invocation_context)
       llm_request.append_instructions([si])

google/adk/models/gemini_llm_connection.py

@@ -152,7 +152,7 @@ class GeminiLlmConnection(BaseLlmConnection):
         ):
           # TODO: Right now, we just support output_transcription without
           # changing interface and data protocol. Later, we can consider to
-          # support output_transcription as a separete field in LlmResponse.
+          # support output_transcription as a separate field in LlmResponse.
 
           # Transcription is always considered as partial event
           # We rely on other control signals to determine when to yield the
@@ -179,7 +179,7 @@ class GeminiLlmConnection(BaseLlmConnection):
         # in case of empty content or parts, we sill surface it
         # in case it's an interrupted message, we merge the previous partial
         # text. Other we don't merge. because content can be none when model
-        # safty threshold is triggered
+        # safety threshold is triggered
         if message.server_content.interrupted and text:
           yield self.__build_full_text_response(text)
           text = ''

google/adk/models/lite_llm.py

@@ -136,54 +136,68 @@ def _safe_json_serialize(obj) -> str:
 
 def _content_to_message_param(
     content: types.Content,
-) -> Message:
-  """Converts a types.Content to a litellm Message.
+) -> Union[Message, list[Message]]:
+  """Converts a types.Content to a litellm Message or list of Messages.
+
+  Handles multipart function responses by returning a list of
+  ChatCompletionToolMessage objects if multiple function_response parts exist.
 
   Args:
     content: The content to convert.
 
   Returns:
-    The litellm Message.
+    A litellm Message, a list of litellm Messages.
   """
 
-  if content.parts and content.parts[0].function_response:
-    return ChatCompletionToolMessage(
-        role="tool",
-        tool_call_id=content.parts[0].function_response.id,
-        content=_safe_json_serialize(
-            content.parts[0].function_response.response
-        ),
-    )
+  tool_messages = []
+  for part in content.parts:
+    if part.function_response:
+      tool_messages.append(
+          ChatCompletionToolMessage(
+              role="tool",
+              tool_call_id=part.function_response.id,
+              content=_safe_json_serialize(part.function_response.response),
+          )
+      )
+  if tool_messages:
+    return tool_messages if len(tool_messages) > 1 else tool_messages[0]
 
+  # Handle user or assistant messages
   role = _to_litellm_role(content.role)
+  message_content = _get_content(content.parts) or None
 
   if role == "user":
-    return ChatCompletionUserMessage(
-        role="user", content=_get_content(content.parts)
-    )
-  else:
-
-    tool_calls = [
-        ChatCompletionMessageToolCall(
-            type="function",
-            id=part.function_call.id,
-            function=Function(
-                name=part.function_call.name,
-                arguments=part.function_call.args,
-            ),
-        )
-        for part in content.parts
-        if part.function_call
-    ]
+    return ChatCompletionUserMessage(role="user", content=message_content)
+  else:  # assistant/model
+    tool_calls = []
+    content_present = False
+    for part in content.parts:
+        if part.function_call:
+            tool_calls.append(
+                ChatCompletionMessageToolCall(
+                    type="function",
+                    id=part.function_call.id,
+                    function=Function(
+                        name=part.function_call.name,
+                        arguments=part.function_call.args,
+                    ),
+                )
+            )
+        elif part.text or part.inline_data:
+            content_present = True
+
+    final_content = message_content if content_present else None
 
     return ChatCompletionAssistantMessage(
         role=role,
-        content=_get_content(content.parts),
+        content=final_content,
         tool_calls=tool_calls or None,
     )
 
 
-def _get_content(parts: Iterable[types.Part]) -> OpenAIMessageContent | str:
+def _get_content(
+    parts: Iterable[types.Part],
+) -> Union[OpenAIMessageContent, str]:
   """Converts a list of parts to litellm content.
 
   Args:
@@ -435,10 +449,13 @@ def _get_completion_inputs(
   Returns:
     The litellm inputs (message list and tool dictionary).
   """
-  messages = [
-      _content_to_message_param(content)
-      for content in llm_request.contents or []
-  ]
+  messages = []
+  for content in llm_request.contents or []:
+    message_param_or_list = _content_to_message_param(content)
+    if isinstance(message_param_or_list, list):
+        messages.extend(message_param_or_list)
+    elif message_param_or_list: # Ensure it's not None before appending
+        messages.append(message_param_or_list)
 
   if llm_request.config.system_instruction:
     messages.insert(

google/adk/models/llm_response.py

@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-from typing import Optional
+from typing import Any, Optional
 
 from google.genai import types
 from pydantic import BaseModel
@@ -37,6 +37,7 @@ class LlmResponse(BaseModel):
     error_message: Error message if the response is an error.
     interrupted: Flag indicating that LLM was interrupted when generating the
       content. Usually it's due to user interruption during a bidi streaming.
+    custom_metadata: The custom metadata of the LlmResponse.
   """
 
   model_config = ConfigDict(extra='forbid')
@@ -71,6 +72,14 @@ class LlmResponse(BaseModel):
   Usually it's due to user interruption during a bidi streaming.
   """
 
+  custom_metadata: Optional[dict[str, Any]] = None
+  """The custom metadata of the LlmResponse.
+
+  An optional key-value pair to label an LlmResponse.
+
+  NOTE: the entire dict must be JSON serializable.
+  """
+
   @staticmethod
   def create(
       generate_content_response: types.GenerateContentResponse,

google/adk/planners/built_in_planner.py

@@ -56,6 +56,7 @@ class BuiltInPlanner(BasePlanner):
       llm_request: The LLM request to apply the thinking config to.
     """
     if self.thinking_config:
+      llm_request.config = llm_request.config or types.GenerateContentConfig()
       llm_request.config.thinking_config = self.thinking_config
 
   @override

google/adk/planners/plan_re_act_planner.py

@@ -31,9 +31,9 @@ FINAL_ANSWER_TAG = '/*FINAL_ANSWER*/'
 
 
 class PlanReActPlanner(BasePlanner):
-  """Plan-Re-Act planner that constraints the LLM response to generate a plan before any action/observation.
+  """Plan-Re-Act planner that constrains the LLM response to generate a plan before any action/observation.
 
-  Note: this planner does not require the model to support buil-in thinking
+  Note: this planner does not require the model to support built-in thinking
   features or setting the thinking config.
   """