google-adk 0.2.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

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/sessions/_session_util.py

@@ -0,0 +1,29 @@
+"""Utility functions for session service."""
+
+import base64
+from typing import Any, Optional
+
+from google.genai import types
+
+
+def encode_content(content: types.Content):
+  """Encodes a content object to a JSON dictionary."""
+  encoded_content = content.model_dump(exclude_none=True)
+  for p in encoded_content["parts"]:
+    if "inline_data" in p:
+      p["inline_data"]["data"] = base64.b64encode(
+          p["inline_data"]["data"]
+      ).decode("utf-8")
+  return encoded_content
+
+
+def decode_content(
+    content: Optional[dict[str, Any]],
+) -> Optional[types.Content]:
+  """Decodes a content object from a JSON dictionary."""
+  if not content:
+    return None
+  for p in content["parts"]:
+    if "inline_data" in p:
+      p["inline_data"]["data"] = base64.b64decode(p["inline_data"]["data"])
+  return types.Content.model_validate(content)

google/adk/sessions/database_session_service.py

@@ -11,14 +11,11 @@
 # 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.
-
-import base64
 import copy
 from datetime import datetime
 import json
 import logging
-from typing import Any
-from typing import Optional
+from typing import Any, Optional
 import uuid
 
 from sqlalchemy import Boolean
@@ -27,6 +24,7 @@ from sqlalchemy import Dialect
 from sqlalchemy import ForeignKeyConstraint
 from sqlalchemy import func
 from sqlalchemy import Text
+from sqlalchemy.dialects import mysql
 from sqlalchemy.dialects import postgresql
 from sqlalchemy.engine import create_engine
 from sqlalchemy.engine import Engine
@@ -48,6 +46,7 @@ from typing_extensions import override
 from tzlocal import get_localzone
 
 from ..events.event import Event
+from . import _session_util
 from .base_session_service import BaseSessionService
 from .base_session_service import GetSessionConfig
 from .base_session_service import ListEventsResponse
@@ -58,6 +57,9 @@ from .state import State
 
 logger = logging.getLogger(__name__)
 
+DEFAULT_MAX_KEY_LENGTH = 128
+DEFAULT_MAX_VARCHAR_LENGTH = 256
+
 
 class DynamicJSON(TypeDecorator):
   """A JSON-like type that uses JSONB on PostgreSQL and TEXT with JSON
@@ -70,15 +72,16 @@ class DynamicJSON(TypeDecorator):
   def load_dialect_impl(self, dialect: Dialect):
     if dialect.name == "postgresql":
       return dialect.type_descriptor(postgresql.JSONB)
-    else:
-      return dialect.type_descriptor(Text)  # Default to Text for other dialects
+    if dialect.name == "mysql":
+      # Use LONGTEXT for MySQL to address the data too long issue
+      return dialect.type_descriptor(mysql.LONGTEXT)
+    return dialect.type_descriptor(Text)  # Default to Text for other dialects
 
   def process_bind_param(self, value, dialect: Dialect):
     if value is not None:
       if dialect.name == "postgresql":
         return value  # JSONB handles dict directly
-      else:
-        return json.dumps(value)  # Serialize to JSON string for TEXT
+      return json.dumps(value)  # Serialize to JSON string for TEXT
     return value
 
   def process_result_value(self, value, dialect: Dialect):
@@ -92,17 +95,25 @@ class DynamicJSON(TypeDecorator):
 
 class Base(DeclarativeBase):
   """Base class for database tables."""
+
   pass
 
 
 class StorageSession(Base):
   """Represents a session stored in the database."""
+
   __tablename__ = "sessions"
 
-  app_name: Mapped[str] = mapped_column(String, primary_key=True)
-  user_id: Mapped[str] = mapped_column(String, primary_key=True)
+  app_name: Mapped[str] = mapped_column(
+      String(DEFAULT_MAX_KEY_LENGTH), primary_key=True
+  )
+  user_id: Mapped[str] = mapped_column(
+      String(DEFAULT_MAX_KEY_LENGTH), primary_key=True
+  )
   id: Mapped[str] = mapped_column(
-      String, primary_key=True, default=lambda: str(uuid.uuid4())
+      String(DEFAULT_MAX_KEY_LENGTH),
+      primary_key=True,
+      default=lambda: str(uuid.uuid4()),
   )
 
   state: Mapped[MutableDict[str, Any]] = mapped_column(
@@ -125,18 +136,29 @@ class StorageSession(Base):
 
 class StorageEvent(Base):
   """Represents an event stored in the database."""
+
   __tablename__ = "events"
 
-  id: Mapped[str] = mapped_column(String, primary_key=True)
-  app_name: Mapped[str] = mapped_column(String, primary_key=True)
-  user_id: Mapped[str] = mapped_column(String, primary_key=True)
-  session_id: Mapped[str] = mapped_column(String, primary_key=True)
+  id: Mapped[str] = mapped_column(
+      String(DEFAULT_MAX_KEY_LENGTH), primary_key=True
+  )
+  app_name: Mapped[str] = mapped_column(
+      String(DEFAULT_MAX_KEY_LENGTH), primary_key=True
+  )
+  user_id: Mapped[str] = mapped_column(
+      String(DEFAULT_MAX_KEY_LENGTH), primary_key=True
+  )
+  session_id: Mapped[str] = mapped_column(
+      String(DEFAULT_MAX_KEY_LENGTH), primary_key=True
+  )
 
-  invocation_id: Mapped[str] = mapped_column(String)
-  author: Mapped[str] = mapped_column(String)
-  branch: Mapped[str] = mapped_column(String, nullable=True)
+  invocation_id: Mapped[str] = mapped_column(String(DEFAULT_MAX_VARCHAR_LENGTH))
+  author: Mapped[str] = mapped_column(String(DEFAULT_MAX_VARCHAR_LENGTH))
+  branch: Mapped[str] = mapped_column(
+      String(DEFAULT_MAX_VARCHAR_LENGTH), nullable=True
+  )
   timestamp: Mapped[DateTime] = mapped_column(DateTime(), default=func.now())
-  content: Mapped[dict[str, Any]] = mapped_column(DynamicJSON)
+  content: Mapped[dict[str, Any]] = mapped_column(DynamicJSON, nullable=True)
   actions: Mapped[MutableDict[str, Any]] = mapped_column(PickleType)
 
   long_running_tool_ids_json: Mapped[Optional[str]] = mapped_column(
@@ -147,8 +169,10 @@ class StorageEvent(Base):
   )
   partial: Mapped[bool] = mapped_column(Boolean, nullable=True)
   turn_complete: Mapped[bool] = mapped_column(Boolean, nullable=True)
-  error_code: Mapped[str] = mapped_column(String, nullable=True)
-  error_message: Mapped[str] = mapped_column(String, nullable=True)
+  error_code: Mapped[str] = mapped_column(
+      String(DEFAULT_MAX_VARCHAR_LENGTH), nullable=True
+  )
+  error_message: Mapped[str] = mapped_column(String(1024), nullable=True)
   interrupted: Mapped[bool] = mapped_column(Boolean, nullable=True)
 
   storage_session: Mapped[StorageSession] = relationship(
@@ -182,9 +206,12 @@ class StorageEvent(Base):
 
 class StorageAppState(Base):
   """Represents an app state stored in the database."""
+
   __tablename__ = "app_states"
 
-  app_name: Mapped[str] = mapped_column(String, primary_key=True)
+  app_name: Mapped[str] = mapped_column(
+      String(DEFAULT_MAX_KEY_LENGTH), primary_key=True
+  )
   state: Mapped[MutableDict[str, Any]] = mapped_column(
       MutableDict.as_mutable(DynamicJSON), default={}
   )
@@ -192,13 +219,17 @@ class StorageAppState(Base):
       DateTime(), default=func.now(), onupdate=func.now()
   )
 
-
 class StorageUserState(Base):
   """Represents a user state stored in the database."""
+
   __tablename__ = "user_states"
 
-  app_name: Mapped[str] = mapped_column(String, primary_key=True)
-  user_id: Mapped[str] = mapped_column(String, primary_key=True)
+  app_name: Mapped[str] = mapped_column(
+      String(DEFAULT_MAX_KEY_LENGTH), primary_key=True
+  )
+  user_id: Mapped[str] = mapped_column(
+      String(DEFAULT_MAX_KEY_LENGTH), primary_key=True
+  )
   state: Mapped[MutableDict[str, Any]] = mapped_column(
       MutableDict.as_mutable(DynamicJSON), default={}
   )
@@ -217,7 +248,7 @@ class DatabaseSessionService(BaseSessionService):
     """
     # 1. Create DB engine for db connection
     # 2. Create all tables based on schema
-    # 3. Initialize all properies
+    # 3. Initialize all properties
 
     try:
       db_engine = create_engine(db_url)
@@ -353,6 +384,7 @@ class DatabaseSessionService(BaseSessionService):
               else True
           )
           .limit(config.num_recent_events if config else None)
+          .order_by(StorageEvent.timestamp.asc())
           .all()
       )
 
@@ -383,7 +415,7 @@ class DatabaseSessionService(BaseSessionService):
               author=e.author,
               branch=e.branch,
               invocation_id=e.invocation_id,
-              content=_decode_content(e.content),
+              content=_session_util.decode_content(e.content),
               actions=e.actions,
               timestamp=e.timestamp.timestamp(),
               long_running_tool_ids=e.long_running_tool_ids,
@@ -506,15 +538,7 @@ class DatabaseSessionService(BaseSessionService):
           interrupted=event.interrupted,
       )
       if event.content:
-        encoded_content = event.content.model_dump(exclude_none=True)
-        # Workaround for multimodal Content throwing JSON not serializable
-        # error with SQLAlchemy.
-        for p in encoded_content["parts"]:
-          if "inline_data" in p:
-            p["inline_data"]["data"] = (
-                base64.b64encode(p["inline_data"]["data"]).decode("utf-8"),
-            )
-        storage_event.content = encoded_content
+        storage_event.content = _session_util.encode_content(event.content)
 
       sessionFactory.add(storage_event)
 
@@ -574,10 +598,3 @@ def _merge_state(app_state, user_state, session_state):
   for key in user_state.keys():
     merged_state[State.USER_PREFIX + key] = user_state[key]
   return merged_state
-
-
-def _decode_content(content: dict[str, Any]) -> dict[str, Any]:
-  for p in content["parts"]:
-    if "inline_data" in p:
-      p["inline_data"]["data"] = base64.b64decode(p["inline_data"]["data"][0])
-  return content

google/adk/sessions/state.py

@@ -26,7 +26,7 @@ class State:
     """
     Args:
       value: The current value of the state dict.
-      delta: The delta change to the current value that hasn't been commited.
+      delta: The delta change to the current value that hasn't been committed.
     """
     self._value = value
     self._delta = delta

google/adk/sessions/vertex_ai_session_service.py

@@ -14,21 +14,23 @@
 import logging
 import re
 import time
-from typing import Any
-from typing import Optional
+from typing import Any, Optional
 
-from dateutil.parser import isoparse
+from dateutil import parser
 from google import genai
 from typing_extensions import override
 
 from ..events.event import Event
 from ..events.event_actions import EventActions
+from . import _session_util
 from .base_session_service import BaseSessionService
 from .base_session_service import GetSessionConfig
 from .base_session_service import ListEventsResponse
 from .base_session_service import ListSessionsResponse
 from .session import Session
 
+
+isoparse = parser.isoparse
 logger = logging.getLogger(__name__)
 
 
@@ -289,7 +291,7 @@ def _convert_event_to_json(event: Event):
     }
     event_json['actions'] = actions_json
   if event.content:
-    event_json['content'] = event.content.model_dump(exclude_none=True)
+    event_json['content'] = _session_util.encode_content(event.content)
   if event.error_code:
     event_json['error_code'] = event.error_code
   if event.error_message:
@@ -316,7 +318,7 @@ def _from_api_event(api_event: dict) -> Event:
       invocation_id=api_event['invocationId'],
       author=api_event['author'],
       actions=event_actions,
-      content=api_event.get('content', None),
+      content=_session_util.decode_content(api_event.get('content', None)),
       timestamp=isoparse(api_event['timestamp']).timestamp(),
       error_code=api_event.get('errorCode', None),
       error_message=api_event.get('errorMessage', None),

google/adk/tools/agent_tool.py

@@ -45,10 +45,9 @@ class AgentTool(BaseTool):
     skip_summarization: Whether to skip summarization of the agent output.
   """
 
-  def __init__(self, agent: BaseAgent):
+  def __init__(self, agent: BaseAgent, skip_summarization: bool = False):
     self.agent = agent
-    self.skip_summarization: bool = False
-    """Whether to skip summarization of the agent output."""
+    self.skip_summarization: bool = skip_summarization
 
     super().__init__(name=agent.name, description=agent.description)
 

google/adk/tools/application_integration_tool/__init__.py

@@ -13,7 +13,9 @@
 # limitations under the License.
 
 from .application_integration_toolset import ApplicationIntegrationToolset
+from .integration_connector_tool import IntegrationConnectorTool
 
 __all__ = [
     'ApplicationIntegrationToolset',
+    'IntegrationConnectorTool',
 ]

google/adk/tools/application_integration_tool/application_integration_toolset.py

@@ -12,21 +12,21 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Dict
-from typing import List
-from typing import Optional
+from typing import Dict, List, Optional
 
 from fastapi.openapi.models import HTTPBearer
-from google.adk.tools.application_integration_tool.clients.connections_client import ConnectionsClient
-from google.adk.tools.application_integration_tool.clients.integration_client import IntegrationClient
-from google.adk.tools.openapi_tool.auth.auth_helpers import service_account_scheme_credential
-from google.adk.tools.openapi_tool.openapi_spec_parser.openapi_toolset import OpenAPIToolset
-from google.adk.tools.openapi_tool.openapi_spec_parser.rest_api_tool import RestApiTool
 
 from ...auth.auth_credential import AuthCredential
 from ...auth.auth_credential import AuthCredentialTypes
 from ...auth.auth_credential import ServiceAccount
 from ...auth.auth_credential import ServiceAccountCredential
+from ..openapi_tool.auth.auth_helpers import service_account_scheme_credential
+from ..openapi_tool.openapi_spec_parser.openapi_spec_parser import OpenApiSpecParser
+from ..openapi_tool.openapi_spec_parser.openapi_toolset import OpenAPIToolset
+from ..openapi_tool.openapi_spec_parser.rest_api_tool import RestApiTool
+from .clients.connections_client import ConnectionsClient
+from .clients.integration_client import IntegrationClient
+from .integration_connector_tool import IntegrationConnectorTool
 
 
 # TODO(cheliu): Apply a common toolset interface
@@ -168,6 +168,7 @@ class ApplicationIntegrationToolset:
         actions,
         service_account_json,
     )
+    connection_details = {}
     if integration and trigger:
       spec = integration_client.get_openapi_spec_for_integration()
     elif connection and (entity_operations or actions):
@@ -175,16 +176,6 @@ class ApplicationIntegrationToolset:
           project, location, connection, service_account_json
       )
       connection_details = connections_client.get_connection_details()
-      tool_instructions += (
-          "ALWAYS use serviceName = "
-          + connection_details["serviceName"]
-          + ", host = "
-          + connection_details["host"]
-          + " and the connection name = "
-          + f"projects/{project}/locations/{location}/connections/{connection} when"
-          " using this tool"
-          + ". DONOT ask the user for these values as you already have those."
-      )
       spec = integration_client.get_openapi_spec_for_connection(
           tool_name,
           tool_instructions,
@@ -194,9 +185,9 @@ class ApplicationIntegrationToolset:
           "Either (integration and trigger) or (connection and"
           " (entity_operations or actions)) should be provided."
       )
-    self._parse_spec_to_tools(spec)
+    self._parse_spec_to_tools(spec, connection_details)
 
-  def _parse_spec_to_tools(self, spec_dict):
+  def _parse_spec_to_tools(self, spec_dict, connection_details):
     """Parses the spec dict to a list of RestApiTool."""
     if self.service_account_json:
       sa_credential = ServiceAccountCredential.model_validate_json(
@@ -218,12 +209,43 @@ class ApplicationIntegrationToolset:
           ),
       )
       auth_scheme = HTTPBearer(bearerFormat="JWT")
-    tools = OpenAPIToolset(
-        spec_dict=spec_dict,
-        auth_credential=auth_credential,
-        auth_scheme=auth_scheme,
-    ).get_tools()
-    for tool in tools:
+
+    if self.integration and self.trigger:
+      tools = OpenAPIToolset(
+          spec_dict=spec_dict,
+          auth_credential=auth_credential,
+          auth_scheme=auth_scheme,
+      ).get_tools()
+      for tool in tools:
+        self.generated_tools[tool.name] = tool
+      return
+
+    operations = OpenApiSpecParser().parse(spec_dict)
+
+    for open_api_operation in operations:
+      operation = getattr(open_api_operation.operation, "x-operation")
+      entity = None
+      action = None
+      if hasattr(open_api_operation.operation, "x-entity"):
+        entity = getattr(open_api_operation.operation, "x-entity")
+      elif hasattr(open_api_operation.operation, "x-action"):
+        action = getattr(open_api_operation.operation, "x-action")
+      rest_api_tool = RestApiTool.from_parsed_operation(open_api_operation)
+      if auth_scheme:
+        rest_api_tool.configure_auth_scheme(auth_scheme)
+      if auth_credential:
+        rest_api_tool.configure_auth_credential(auth_credential)
+      tool = IntegrationConnectorTool(
+          name=rest_api_tool.name,
+          description=rest_api_tool.description,
+          connection_name=connection_details["name"],
+          connection_host=connection_details["host"],
+          connection_service_name=connection_details["serviceName"],
+          entity=entity,
+          action=action,
+          operation=operation,
+          rest_api_tool=rest_api_tool,
+      )
       self.generated_tools[tool.name] = tool
 
   def get_tools(self) -> List[RestApiTool]:

google/adk/tools/application_integration_tool/clients/connections_client.py

@@ -68,12 +68,14 @@ class ConnectionsClient:
     response = self._execute_api_call(url)
 
     connection_data = response.json()
+    connection_name = connection_data.get("name", "")
     service_name = connection_data.get("serviceDirectory", "")
     host = connection_data.get("host", "")
     if host:
       service_name = connection_data.get("tlsServiceDirectory", "")
     auth_override_enabled = connection_data.get("authOverrideEnabled", False)
     return {
+        "name": connection_name,
         "serviceName": service_name,
         "host": host,
         "authOverrideEnabled": auth_override_enabled,
@@ -291,13 +293,9 @@ class ConnectionsClient:
       tool_name: str = "",
       tool_instructions: str = "",
   ) -> Dict[str, Any]:
-    description = (
-        f"Use this tool with" f' action = "{action}" and'
-    ) + f' operation = "{operation}" only. Dont ask these values from user.'
+    description = f"Use this tool to execute {action}"
     if operation == "EXECUTE_QUERY":
-      description = (
-          (f"Use this tool with" f' action = "{action}" and')
-          + f' operation = "{operation}" only. Dont ask these values from user.'
+      description += (
           " Use pageSize = 50 and timeout = 120 until user specifies a"
           " different value otherwise. If user provides a query in natural"
           " language, convert it to SQL query and then execute it using the"
@@ -308,6 +306,8 @@ class ConnectionsClient:
             "summary": f"{action_display_name}",
             "description": f"{description} {tool_instructions}",
             "operationId": f"{tool_name}_{action_display_name}",
+            "x-action": f"{action}",
+            "x-operation": f"{operation}",
             "requestBody": {
                 "content": {
                     "application/json": {
@@ -347,16 +347,12 @@ class ConnectionsClient:
         "post": {
             "summary": f"List {entity}",
             "description": (
-                f"Returns all entities of type {entity}. Use this tool with"
-                + f' entity = "{entity}" and'
-                + ' operation = "LIST_ENTITIES" only. Dont ask these values'
-                " from"
-                + ' user. Always use ""'
-                + ' as filter clause and ""'
-                + " as page token and 50 as page size until user specifies a"
-                " different value otherwise. Use single quotes for strings in"
-                f" filter clause. {tool_instructions}"
+                f"""Returns the list of {entity} data. If the page token was available in the response, let users know there are more records available. Ask if the user wants to fetch the next page of results. When passing filter use the
+                following format: `field_name1='value1' AND field_name2='value2'
+                `. {tool_instructions}"""
             ),
+            "x-operation": "LIST_ENTITIES",
+            "x-entity": f"{entity}",
             "operationId": f"{tool_name}_list_{entity}",
             "requestBody": {
                 "content": {
@@ -401,14 +397,11 @@ class ConnectionsClient:
         "post": {
             "summary": f"Get {entity}",
             "description": (
-                (
-                    f"Returns the details of the {entity}. Use this tool with"
-                    f' entity = "{entity}" and'
-                )
-                + ' operation = "GET_ENTITY" only. Dont ask these values from'
-                f" user.  {tool_instructions}"
+                f"Returns the details of the {entity}. {tool_instructions}"
             ),
             "operationId": f"{tool_name}_get_{entity}",
+            "x-operation": "GET_ENTITY",
+            "x-entity": f"{entity}",
             "requestBody": {
                 "content": {
                     "application/json": {
@@ -445,17 +438,10 @@ class ConnectionsClient:
   ) -> Dict[str, Any]:
     return {
         "post": {
-            "summary": f"Create {entity}",
-            "description": (
-                (
-                    f"Creates a new entity of type {entity}. Use this tool with"
-                    f' entity = "{entity}" and'
-                )
-                + ' operation = "CREATE_ENTITY" only. Dont ask these values'
-                " from"
-                + " user. Follow the schema of the entity provided in the"
-                f" instructions to create {entity}.  {tool_instructions}"
-            ),
+            "summary": f"Creates a new {entity}",
+            "description": f"Creates a new {entity}. {tool_instructions}",
+            "x-operation": "CREATE_ENTITY",
+            "x-entity": f"{entity}",
             "operationId": f"{tool_name}_create_{entity}",
             "requestBody": {
                 "content": {
@@ -491,18 +477,10 @@ class ConnectionsClient:
   ) -> Dict[str, Any]:
     return {
         "post": {
-            "summary": f"Update {entity}",
-            "description": (
-                (
-                    f"Updates an entity of type {entity}. Use this tool with"
-                    f' entity = "{entity}" and'
-                )
-                + ' operation = "UPDATE_ENTITY" only. Dont ask these values'
-                " from"
-                + " user. Use entityId to uniquely identify the entity to"
-                " update. Follow the schema of the entity provided in the"
-                f" instructions to update {entity}.  {tool_instructions}"
-            ),
+            "summary": f"Updates the {entity}",
+            "description": f"Updates the {entity}. {tool_instructions}",
+            "x-operation": "UPDATE_ENTITY",
+            "x-entity": f"{entity}",
             "operationId": f"{tool_name}_update_{entity}",
             "requestBody": {
                 "content": {
@@ -538,16 +516,10 @@ class ConnectionsClient:
   ) -> Dict[str, Any]:
     return {
         "post": {
-            "summary": f"Delete {entity}",
-            "description": (
-                (
-                    f"Deletes an entity of type {entity}. Use this tool with"
-                    f' entity = "{entity}" and'
-                )
-                + ' operation = "DELETE_ENTITY" only. Dont ask these values'
-                " from"
-                f" user.  {tool_instructions}"
-            ),
+            "summary": f"Delete the {entity}",
+            "description": f"Deletes the {entity}. {tool_instructions}",
+            "x-operation": "DELETE_ENTITY",
+            "x-entity": f"{entity}",
             "operationId": f"{tool_name}_delete_{entity}",
             "requestBody": {
                 "content": {