rasa-pro 3.14.0.dev2__tar.gz → 3.14.0.dev3__tar.gz

{rasa_pro-3.14.0.dev2 → rasa_pro-3.14.0.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: rasa-pro
-Version: 3.14.0.dev2
+Version: 3.14.0.dev3
 Summary: State-of-the-art open-core Conversational AI framework for Enterprises that natively leverages generative AI for effortless assistant development.
 Keywords: nlp,machine-learning,machine-learning-library,bot,bots,botkit,rasa conversational-agents,conversational-ai,chatbot,chatbot-framework,bot-framework
 Author: Rasa Technologies GmbH

{rasa_pro-3.14.0.dev2 → rasa_pro-3.14.0.dev3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "rasa-pro"
-version = "3.14.0.dev2"
+version = "3.14.0.dev3"
 description = "State-of-the-art open-core Conversational AI framework for Enterprises that natively leverages generative AI for effortless assistant development."
 authors = [ "Rasa Technologies GmbH <hi@rasa.com>",]
 maintainers = [ "Tom Bocklisch <tom@rasa.com>",]
@@ -374,6 +374,7 @@ convention = "google"
 
 
 
+
 [tool.poetry.group.dev.dependencies]
 ruff = ">=0.3.5,<0.4.0"
 docker = "~7.1.0"

{rasa_pro-3.14.0.dev2 → rasa_pro-3.14.0.dev3}/rasa/agents/agent_manager.py

@@ -77,6 +77,8 @@ class AgentManager(metaclass=Singleton):
         Raises:
             ConnectionError: If the agent connection fails.
         """
+        # Add the agent to the manager
+        agent_identifier = make_agent_identifier(agent_name, protocol_type)
         try:
             # Create the agent client
             client = AgentFactory.create_client(protocol_type, config)
@@ -84,8 +86,6 @@ class AgentManager(metaclass=Singleton):
             # Connect the agent client
             await client.connect()
 
-            # Add the agent to the manager
-            agent_identifier = make_agent_identifier(agent_name, protocol_type)
             self._add_agent(agent_identifier, client)
             structlogger.info(
                 "agent_manager.connect_agent.success",

{rasa_pro-3.14.0.dev2 → rasa_pro-3.14.0.dev3}/rasa/agents/constants.py

@@ -5,6 +5,7 @@ TOOL_DESCRIPTION_KEY = "description"
 TOOL_PARAMETERS_KEY = "parameters"
 TOOL_STRICT_KEY = "strict"
 TOOL_TYPE_FUNCTION_KEY = "function"
+TOOL_EXECUTOR_KEY = "tool_executor"
 
 # MCP Tool related constants (secondary)
 TOOL_ADDITIONAL_PROPERTIES_KEY = "additionalProperties"

{rasa_pro-3.14.0.dev2 → rasa_pro-3.14.0.dev3}/rasa/agents/protocol/mcp/mcp_base_agent.py

@@ -1,5 +1,6 @@
 import json
 from abc import abstractmethod
+from inspect import isawaitable
 from typing import Any, Dict, List, Optional, Tuple
 
 import structlog
@@ -25,6 +26,7 @@ from rasa.agents.schemas import (
     AgentOutput,
     AgentToolResult,
     AgentToolSchema,
+    CustomToolSchema,
 )
 from rasa.core.available_agents import AgentConfig, AgentMCPServerConfig, ProtocolConfig
 from rasa.shared.agents.utils import make_agent_identifier
@@ -112,6 +114,12 @@ class MCPBaseAgent(AgentProtocol):
         # Stores the MCP tools for the agent.
         self._mcp_tools: List[AgentToolSchema] = []
 
+        # Stores the custom tools for the agent.
+        self._custom_tools: List[CustomToolSchema] = [
+            CustomToolSchema.from_dict(tool)
+            for tool in self.get_custom_tool_definitions()
+        ]
+
         # Maps the tool names to the MCP servers that provide them.
         # key: tool name, value: server name.
         self._tool_to_server_mapper: Dict[str, str] = {}
@@ -164,28 +172,29 @@ class MCPBaseAgent(AgentProtocol):
     @classmethod
     def get_agent_specific_built_in_tools(
         cls, agent_input: AgentInput
-    ) -> List[Dict[str, Any]]:
+    ) -> List[AgentToolSchema]:
         """Get agentic specific built-in tools."""
         return []
 
-    @staticmethod
-    def get_additional_tools(agent_input: AgentInput) -> List[Dict[str, Any]]:
-        """Get additional tools for MCP. Override to add specific tools.
-        This method can be overridden to provide additional tools that the agent
+    def get_custom_tool_definitions(self) -> List[Dict[str, Any]]:
+        """Add custom tool definitions and their executors for MCP agents.
+
+        This method can be overridden to provide custom tools that the agent
         can use during its operation. The tools should be defined in the OpenAI
         JSON format, which includes the tool name, description, and parameters.
 
         Refer: https://platform.openai.com/docs/guides/function-calling?api-mode=responses
 
-        Args:
-            agent_input: The agent input.
+        Note:
+            The tool executor method should be a coroutine function that returns an
+            AgentToolResult object.
 
         Returns:
-            A list of additional tools.
+            A list of custom tool definitions along with their tool executor method.
 
         Example:
             ```python
-            def get_additional_tools(self) -> List[Dict[str, Any]]:
+            def get_custom_tool_definitions(self) -> List[Dict[str, Any]]:
                 return [
                     {
                         "type": "function",
@@ -207,6 +216,7 @@ class MCPBaseAgent(AgentProtocol):
                                 "required": ["location"],
                             },
                         },
+                        "tool_executor": self.get_current_weather,
                     }
                 ]
             ```
@@ -334,23 +344,17 @@ class MCPBaseAgent(AgentProtocol):
         session = await connection.ensure_active_session()
         return await session.list_tools()
 
-    @classmethod
-    def get_built_in_tools(cls, agent_input: AgentInput) -> List[AgentToolSchema]:
-        """Get built-in tools that are always available for MCP agents."""
-        built_in_tools = []
-        if agent_specific_built_in_tools := cls.get_agent_specific_built_in_tools(
-            agent_input
-        ):
-            built_in_tools.extend(agent_specific_built_in_tools)
-        if additional_tools := cls.get_additional_tools(agent_input):
-            built_in_tools.extend(additional_tools)
-        return [
-            AgentToolSchema.from_openai_json_format(tool) for tool in built_in_tools
-        ]
+    def get_custom_tools(self) -> List[AgentToolSchema]:
+        """Get the custom tools for the agent."""
+        return [tool.tool_definition for tool in self._custom_tools]
 
     def get_available_tools(self, agent_input: AgentInput) -> List[AgentToolSchema]:
         """Get the available tools for the agent."""
-        return self._mcp_tools + self.get_built_in_tools(agent_input)
+        return (
+            self._mcp_tools
+            + self.get_agent_specific_built_in_tools(agent_input)
+            + self.get_custom_tools()
+        )
 
     async def _get_filtered_tools_from_server(
         self,
@@ -567,33 +571,6 @@ class MCPBaseAgent(AgentProtocol):
                 ),
             )
 
-    async def execute_additional_tool(
-        self, tool_name: str, arguments: Dict[str, Any]
-    ) -> Optional[AgentToolResult]:
-        """Execute additional tool. Override to add logic for specific tool.
-
-        Args:
-            tool_name: The name of the tool to execute.
-            arguments: The arguments to pass to the tool.
-
-        Returns:
-            The result of the tool execution as an AgentOutput object.
-
-        Example:
-            ```python
-            async def execute_additional_tool(
-                self, tool_name: str, arguments: Dict[str, Any]
-            ) -> Optional[AgentToolResult]:
-                if tool_name == "get_location":
-                    return get_location_tool(arguments)
-                elif tool_name == "get_current_weather":
-                    return get_current_weather_tool(arguments)
-                return None
-
-            ```
-        """
-        return None
-
     async def _execute_tool_call(
         self, tool_name: str, arguments: Dict[str, Any]
     ) -> AgentToolResult:
@@ -610,10 +587,10 @@ class MCPBaseAgent(AgentProtocol):
             The result of the tool execution as an AgentToolResult object.
         """
         try:
-            if additional_tool_result := await self.execute_additional_tool(
-                tool_name, arguments
-            ):
-                return additional_tool_result
+            for custom_tool in self._custom_tools:
+                if custom_tool.tool_name == tool_name:
+                    result = custom_tool.tool_executor(arguments)
+                    return await result if isawaitable(result) else result
         except Exception as e:
             return AgentToolResult(
                 tool_name=tool_name,

{rasa_pro-3.14.0.dev2 → rasa_pro-3.14.0.dev3}/rasa/agents/protocol/mcp/mcp_open_agent.py

@@ -24,6 +24,7 @@ from rasa.agents.schemas import (
     AgentInput,
     AgentOutput,
     AgentToolResult,
+    AgentToolSchema,
 )
 from rasa.core.available_agents import AgentMCPServerConfig, ProtocolConfig
 from rasa.shared.agents.utils import make_agent_identifier
@@ -105,9 +106,9 @@ class MCPOpenAgent(MCPBaseAgent):
     @classmethod
     def get_agent_specific_built_in_tools(
         cls, agent_input: AgentInput
-    ) -> List[Dict[str, Any]]:
+    ) -> List[AgentToolSchema]:
         """Get agentic specific built-in tools."""
-        return [cls.get_task_completed_tool()]
+        return [AgentToolSchema.from_openai_json_format(cls.get_task_completed_tool())]
 
     def _run_task_completed_tool(
         self,

{rasa_pro-3.14.0.dev2 → rasa_pro-3.14.0.dev3}/rasa/agents/protocol/mcp/mcp_task_agent.py

@@ -18,7 +18,9 @@ from rasa.agents.schemas import (
     AgentInput,
     AgentOutput,
     AgentToolResult,
+    AgentToolSchema,
 )
+from rasa.agents.schemas.agent_input import AgentInputSlot
 from rasa.core.available_agents import AgentMCPServerConfig, ProtocolConfig
 from rasa.shared.agents.utils import make_agent_identifier
 from rasa.shared.constants import (
@@ -70,11 +72,18 @@ class MCPTaskAgent(MCPBaseAgent):
     @classmethod
     def get_agent_specific_built_in_tools(
         cls, agent_input: AgentInput
-    ) -> List[Dict[str, Any]]:
+    ) -> List[AgentToolSchema]:
         """Get agentic specific built-in tools."""
+        slot_names = cls._get_slot_names_from_exit_conditions(agent_input)
+        slot_definitions = [
+            slot for slot in agent_input.slots if slot.name in slot_names
+        ]
+
         return [
-            cls.get_slot_specific_set_slot_tool(slot_name)
-            for slot_name in cls._get_slot_names_from_exit_conditions(agent_input)
+            AgentToolSchema.from_openai_json_format(
+                cls.get_slot_specific_set_slot_tool(slot)
+            )
+            for slot in slot_definitions
         ]
 
     @classmethod
@@ -89,11 +98,11 @@ class MCPTaskAgent(MCPBaseAgent):
             for name in re.findall(r"\bslots\.(\w+)", condition)
         }
 
+        slot_names = agent_input.slot_names
+
         # Keep only slots that actually exist in agent_input.slots
         valid_slot_names = [
-            slot_name
-            for slot_name in extracted_slot_names
-            if slot_name in agent_input.slots
+            slot_name for slot_name in extracted_slot_names if slot_name in slot_names
         ]
 
         structlogger.debug(
@@ -105,15 +114,18 @@ class MCPTaskAgent(MCPBaseAgent):
         return valid_slot_names
 
     @classmethod
-    def get_slot_specific_set_slot_tool(cls, slot_name: str) -> Dict[str, Any]:
+    def get_slot_specific_set_slot_tool(cls, slot: AgentInputSlot) -> Dict[str, Any]:
         """Get the set slot tool."""
+        tool_description = f"Set the slot '{slot.name}' to a specific value. "
+        tool_description += f"The slot type is {slot.type}."
+        if slot.type == "categorical":
+            tool_description += f" The allowed values are: {slot.allowed_values}."
+
         return {
             "type": "function",
             "function": {
-                "name": f"set_slot_{slot_name}",
-                # We need to add the description, slot type, and allowed values
-                # (if present) to the description as well.
-                "description": f"Set the slot {slot_name} to a specific value.",
+                "name": f"set_slot_{slot.name}",
+                "description": tool_description,
                 "parameters": {
                     "type": "object",
                     "properties": {
@@ -234,12 +246,22 @@ class MCPTaskAgent(MCPBaseAgent):
             ),
         )
 
+    def render_prompt_template(self, context: AgentInput) -> str:
+        """Render the prompt template with the provided inputs."""
+        slot_names = self._get_slot_names_from_exit_conditions(context)
+
+        return Template(self.prompt_template).render(
+            **context.model_dump(exclude={"id", "timestamp", "events"}),
+            description=self._description,
+            slot_names=slot_names,
+        )
+
     async def send_message(self, agent_input: AgentInput) -> AgentOutput:
         """Send a message to the LLM and return the response."""
         messages = self.build_messages_for_llm_request(agent_input)
         tool_results: Dict[str, AgentToolResult] = {}
 
-        _slots = agent_input.slots.copy()
+        _slot_values = {slot.name: slot.value for slot in agent_input.slots}
         _available_tools = self.get_available_tools(agent_input)
         _available_tools_names = [tool.name for tool in _available_tools]
 
@@ -337,10 +359,10 @@ class MCPTaskAgent(MCPBaseAgent):
                             tool_call.tool_name
                         ):
                             if (
-                                slot_name in agent_input.slots
+                                slot_name in _slot_values
                                 and "slot_value" in tool_call.tool_args
                             ):
-                                _slots.update(
+                                _slot_values.update(
                                     self._run_set_slot_tool(
                                         slot_name, tool_call.tool_args
                                     )
@@ -392,13 +414,13 @@ class MCPTaskAgent(MCPBaseAgent):
                             )
 
                         exit_met, internal_error = self._is_exit_conditions_met(
-                            agent_input, _slots
+                            agent_input, _slot_values
                         )
 
                         # Agent signals task completion if exit conditions are met.
                         if exit_met:
                             return self._generate_agent_task_completed_output(
-                                agent_input, _slots, tool_results
+                                agent_input, _slot_values, tool_results
                             )
 
                         # If an internal error occurred while checking the exit

{rasa_pro-3.14.0.dev2 → rasa_pro-3.14.0.dev3}/rasa/agents/schemas/__init__.py

@@ -1,6 +1,12 @@
 from rasa.agents.schemas.agent_input import AgentInput
 from rasa.agents.schemas.agent_output import AgentOutput
 from rasa.agents.schemas.agent_tool_result import AgentToolResult
-from rasa.agents.schemas.agent_tool_schema import AgentToolSchema
+from rasa.agents.schemas.agent_tool_schema import AgentToolSchema, CustomToolSchema
 
-__all__ = ["AgentInput", "AgentOutput", "AgentToolSchema", "AgentToolResult"]
+__all__ = [
+    "AgentInput",
+    "AgentOutput",
+    "AgentToolSchema",
+    "AgentToolResult",
+    "CustomToolSchema",
+]

{rasa_pro-3.14.0.dev2 → rasa_pro-3.14.0.dev3}/rasa/agents/schemas/agent_input.py

@@ -5,12 +5,21 @@ from pydantic import BaseModel
 from rasa.shared.core.events import Event
 
 
+class AgentInputSlot(BaseModel):
+    """A class that represents the schema of the input slot to the agent."""
+
+    name: str
+    value: Any
+    type: str
+    allowed_values: Optional[List[Any]] = None
+
+
 class AgentInput(BaseModel):
     """A class that represents the schema of the input to the agent."""
 
     id: str
     user_message: str
-    slots: Dict[str, Any]
+    slots: List[AgentInputSlot]
     conversation_history: str
     events: List[Event]
     metadata: Dict[str, Any]
@@ -22,3 +31,8 @@ class AgentInput(BaseModel):
         """
 
         arbitrary_types_allowed = True
+
+    @property
+    def slot_names(self) -> List[str]:
+        """Get the names of the slots in the input."""
+        return [slot.name for slot in self.slots]

{rasa_pro-3.14.0.dev2 → rasa_pro-3.14.0.dev3}/rasa/agents/schemas/agent_tool_schema.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, Optional
+from typing import Any, Callable, Dict, Optional
 
 from mcp import Tool
 from pydantic import BaseModel
@@ -6,6 +6,7 @@ from pydantic import BaseModel
 from rasa.agents.constants import (
     TOOL_ADDITIONAL_PROPERTIES_KEY,
     TOOL_DESCRIPTION_KEY,
+    TOOL_EXECUTOR_KEY,
     TOOL_NAME_KEY,
     TOOL_PARAMETERS_KEY,
     TOOL_PROPERTIES_KEY,
@@ -110,3 +111,24 @@ class AgentToolSchema(BaseModel):
             TOOL_TYPE_KEY: TOOL_TYPE_FUNCTION_KEY,
             TOOL_TYPE_FUNCTION_KEY: self.model_dump(exclude={TOOL_TYPE_KEY}),
         }
+
+
+class CustomToolSchema(BaseModel):
+    """A class that represents the schema of a custom agent tool."""
+
+    tool_name: str
+    tool_definition: AgentToolSchema
+    tool_executor: Callable
+
+    @classmethod
+    def from_dict(cls, config: Dict[str, Any]) -> "CustomToolSchema":
+        """Convert a custom tool config to CustomToolSchema."""
+        agent_tool_schema = AgentToolSchema.from_openai_json_format(config)
+        if TOOL_EXECUTOR_KEY not in config:
+            raise ValueError("Custom tool executor is required.")
+
+        return cls(
+            tool_name=agent_tool_schema.name,
+            tool_definition=agent_tool_schema,
+            tool_executor=config[TOOL_EXECUTOR_KEY],
+        )

{rasa_pro-3.14.0.dev2 → rasa_pro-3.14.0.dev3}/rasa/agents/templates/mcp_task_agent_prompt_template.jinja2

@@ -1,8 +1,12 @@
 You are a helpful assistant that should assist the user in the best possible way.
 
-### Task
+### Description of your capabilities
 {{ description }}
 
+### Task
+* Use the tools available to gather the required information to set the following slots: {{ slot_names }}.
+* In order to set the slot values, use the `set_slot_<slot_name>` tool.
+
 ### Instructions
 * Always make sure to output responses to the user in a clear, helpful format.
 * Always avoid asking multiple questions at once. Ask questions sequentially one at a time and wait for the user's response before proceeding to next question.
@@ -10,4 +14,4 @@ You are a helpful assistant that should assist the user in the best possible way
 * Strictly avoid making up information or ability to take some action which is not available in `tool` provided.
 
 ### Conversation history
-{{ conversation_history }}
+{{ conversation_history }}

{rasa_pro-3.14.0.dev2 → rasa_pro-3.14.0.dev3}/rasa/core/policies/flow_policy.py

@@ -138,7 +138,7 @@ class FlowPolicy(Policy):
         # create executor and predict next action
         try:
             prediction = await flow_executor.advance_flows(
-                tracker, domain.action_names_or_texts, flows
+                tracker, domain.action_names_or_texts, flows, domain.slots
             )
             return self._create_prediction_result(
                 prediction.action_name,
@@ -165,7 +165,7 @@ class FlowPolicy(Policy):
             events = tracker.create_stack_updated_events(updated_stack)
             tracker.update_with_events(events)
             prediction = await flow_executor.advance_flows(
-                tracker, domain.action_names_or_texts, flows
+                tracker, domain.action_names_or_texts, flows, domain.slots
             )
             collected_events = events + (prediction.events or [])
             return self._create_prediction_result(

{rasa_pro-3.14.0.dev2 → rasa_pro-3.14.0.dev3}/rasa/core/policies/flows/flow_executor.py

@@ -16,6 +16,7 @@ from rasa.agents.constants import (
 )
 from rasa.agents.core.types import AgentStatus, ProtocolType
 from rasa.agents.schemas import AgentInput, AgentOutput
+from rasa.agents.schemas.agent_input import AgentInputSlot
 from rasa.core.available_agents import AvailableAgents
 from rasa.core.available_endpoints import AvailableEndpoints
 from rasa.core.constants import ACTIVE_FLOW_METADATA_KEY, STEP_ID_METADATA_KEY
@@ -103,7 +104,7 @@ from rasa.shared.core.flows.steps import (
     SetSlotsFlowStep,
 )
 from rasa.shared.core.flows.steps.constants import START_STEP
-from rasa.shared.core.slots import Slot, SlotRejection
+from rasa.shared.core.slots import CategoricalSlot, Slot, SlotRejection
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.utils.llm import tracker_as_readable_transcript
 
@@ -387,7 +388,10 @@ def reset_scoped_slots(
 
 
 async def advance_flows(
-    tracker: DialogueStateTracker, available_actions: List[str], flows: FlowsList
+    tracker: DialogueStateTracker,
+    available_actions: List[str],
+    flows: FlowsList,
+    slots: List[Slot],
 ) -> FlowActionPrediction:
     """Advance the current flows until the next action.
 
@@ -395,6 +399,7 @@ async def advance_flows(
         tracker: The tracker to get the next action for.
         available_actions: The actions that are available in the domain.
         flows: All flows.
+        slots: The slots that are available in the domain.
 
     Returns:
     The predicted action and the events to run.
@@ -404,13 +409,16 @@ async def advance_flows(
         # if there are no flows, there is nothing to do
         return FlowActionPrediction(None, 0.0)
 
-    return await advance_flows_until_next_action(tracker, available_actions, flows)
+    return await advance_flows_until_next_action(
+        tracker, available_actions, flows, slots
+    )
 
 
 async def advance_flows_until_next_action(
     tracker: DialogueStateTracker,
     available_actions: List[str],
     flows: FlowsList,
+    slots: List[Slot],
 ) -> FlowActionPrediction:
     """Advance the flow and select the next action to execute.
 
@@ -476,6 +484,7 @@ async def advance_flows_until_next_action(
                     available_actions,
                     flows,
                     previous_step_id,
+                    slots,
                 )
                 new_events = step_result.events
                 if (
@@ -586,6 +595,7 @@ async def run_step(
     available_actions: List[str],
     flows: FlowsList,
     previous_step_id: str,
+    slots: List[Slot],
 ) -> FlowStepResult:
     """Run a single step of a flow.
 
@@ -604,6 +614,7 @@ async def run_step(
         available_actions: The actions that are available in the domain.
         flows: All flows.
         previous_step_id: The ID of the previous step.
+        slots: The slots that are available in the domain.
 
     Returns:
     A result of running the step describing where to transition to.
@@ -643,7 +654,7 @@ async def run_step(
         return _run_link_step(initial_events, stack, step)
 
     elif isinstance(step, CallFlowStep):
-        return await _run_call_step(initial_events, stack, step, tracker)
+        return await _run_call_step(initial_events, stack, step, tracker, slots)
 
     elif isinstance(step, SetSlotsFlowStep):
         return _run_set_slot_step(initial_events, step)
@@ -717,12 +728,13 @@ async def _run_call_step(
     stack: DialogueStack,
     step: CallFlowStep,
     tracker: DialogueStateTracker,
+    slots: List[Slot],
 ) -> FlowStepResult:
     structlogger.debug("flow.step.run.call")
     if step.is_calling_mcp_tool():
         return await call_mcp_tool(initial_events, stack, step, tracker)
     elif step.is_calling_agent():
-        return await run_agent(initial_events, stack, step, tracker)
+        return await run_agent(initial_events, stack, step, tracker, slots)
     else:
         stack.push(
             UserFlowStackFrame(
@@ -885,6 +897,7 @@ async def run_agent(
     stack: DialogueStack,
     step: CallFlowStep,
     tracker: DialogueStateTracker,
+    slots: List[Slot],
 ) -> FlowStepResult:
     """Run an agent call step."""
     structlogger.debug(
@@ -942,7 +955,7 @@ async def run_agent(
         user_message=tracker.latest_message.text or ""
         if tracker.latest_message
         else "",
-        slots=_filter_slots_for_agent(tracker.current_slot_values()),
+        slots=_prepare_slots_for_agent(tracker.current_slot_values(), slots),
         conversation_history=tracker_as_readable_transcript(tracker),
         events=tracker.current_state().get("events") or [],
         metadata=agent_input_metadata,
@@ -1156,18 +1169,43 @@ async def _call_agent_with_retry(
     )
 
 
-def _filter_slots_for_agent(slots: Dict[str, Any]) -> Dict[str, Any]:
-    """Filter out slots that should not be forwarded to agents.
+def _prepare_slots_for_agent(
+    slot_values: Dict[str, Any], slot_definitions: List[Slot]
+) -> List[AgentInputSlot]:
+    """Prepare the slots for the agent.
+
+    Filter out slots that should not be forwarded to agents.
+    Add the slot type and allowed values to the slot dictionary.
 
     Args:
-        slots: The full slot dictionary from the tracker.
+        slot_values: The full slot dictionary from the tracker.
+        slot_definitions: The slot definitions from the domain.
 
     Returns:
-        A copy of the slot dictionary excluding slots listed in
-        `SLOTS_EXCLUDED_FOR_AGENT`.
+        A list of slots containing the name, current value, type, and allowed values.
     """
-    return {
-        key: value
-        for key, value in slots.items()
-        if key not in SLOTS_EXCLUDED_FOR_AGENT
-    }
+
+    def _get_slot_definition(slot_name: str) -> Optional[Slot]:
+        for slot in slot_definitions:
+            if slot.name == slot_name:
+                return slot
+        return None
+
+    filtered_slots: List[AgentInputSlot] = []
+    for key, value in slot_values.items():
+        if key in SLOTS_EXCLUDED_FOR_AGENT:
+            continue
+        slot_definition = _get_slot_definition(key)
+        if slot_definition:
+            filtered_slots.append(
+                AgentInputSlot(
+                    name=key,
+                    value=value,
+                    type=slot_definition.type_name if slot_definition else "any",
+                    allowed_values=slot_definition.values
+                    if isinstance(slot_definition, CategoricalSlot)
+                    else None,
+                )
+            )
+
+    return filtered_slots