Spanish updates

Author: madebygps

examples/spanish/agent_mcp_local.py

@@ -44,15 +44,14 @@
 
 
 async def main() -> None:
-    """Ejecuta un agente conectado a un servidor MCP local para registrar gastos."""
+    """Run an agent connected to a local MCP server to log expenses."""
     async with (
-        MCPStreamableHTTPTool(name="Servidor MCP de Gastos", url=MCP_SERVER_URL) as mcp_server,
+        MCPStreamableHTTPTool(name="Expenses MCP Server", url=MCP_SERVER_URL) as mcp_server,
         ChatAgent(
             chat_client=client,
             instructions=(
                 "Ayudas a la gente con tareas usando las herramientas disponibles. "
                 f"La fecha de hoy es {datetime.now().strftime('%Y-%m-%d')}. "
-                "Responde en español."
             ),
             tools=[mcp_server],
         ) as agent,

examples/spanish/agent_mcp_remote.py

@@ -42,7 +42,7 @@
 
 
 async def main() -> None:
-    """Ejecuta un agente que usa un servidor MCP remoto (Microsoft Learn) para responder preguntas de documentación."""
+    """Run an agent that uses a remote MCP server (Microsoft Learn) to answer documentation questions."""
     async with (
         MCPStreamableHTTPTool(
             name="Microsoft Learn MCP",
@@ -53,7 +53,6 @@ async def main() -> None:
             instructions=(
                 "Ayudas con preguntas sobre la documentación de Microsoft. "
                 "Usa las herramientas disponibles para buscar documentación relevante. "
-                "Responde en español."
             ),
             tools=[mcp_server],
         ) as agent,

examples/spanish/agent_middleware.py

@@ -1,39 +1,39 @@
 """
-Diagrama de flujo del middleware:
+Middleware flow diagram:
 
- agent.run("mensaje del usuario")
+ agent.run("user message")
  │
  ▼
  ┌─────────────────────────────────────────────┐
- │         Middleware de Agente                │
- │  (temporización, bloqueo, registro)         │
+ │         Agent Middleware                    │
+ │  (timing, blocking, logging)                │
  │                                             │
  │  ┌───────────────────────────────────────┐  │
- │  │       Middleware de Chat              │  │
- │  │  (registro, conteo de mensajes)       │  │
+ │  │       Chat Middleware                 │  │
+ │  │  (logging, message counting)          │  │
  │  │                                       │  │
  │  │        ┌──────────────┐               │  │
- │  │        │  Modelo IA   │               │  │
+ │  │        │  AI Model    │               │  │
  │  │        └──────┬───────┘               │  │
- │  │               │ llamadas a funciones  │  │
+ │  │               │ function calls        │  │
  │  │               ▼                       │  │
  │  │  ┌──────────────────────────────────┐ │  │
- │  │  │   Middleware de Funciones        │ │  │
- │  │  │  (registro, temporización)       │ │  │
+ │  │  │   Function Middleware           │ │  │
+ │  │  │  (logging, timing)              │ │  │
  │  │  │                                  │ │  │
  │  │  │  get_weather(), get_date(), ...  │ │  │
  │  │  └──────────────────────────────────┘ │  │
  │  │               │                       │  │
  │  │               ▼                       │  │
  │  │        ┌──────────────┐               │  │
- │  │        │  Modelo IA   │               │  │
- │  │        │ (resp final) │               │  │
+ │  │        │  AI Model    │               │  │
+ │  │        │ (final resp) │               │  │
  │  │        └──────────────┘               │  │
  │  └───────────────────────────────────────┘  │
  └─────────────────────────────────────────────┘
  │
  ▼
- respuesta
+ response
 """
 
 import asyncio
@@ -49,7 +49,7 @@
 from agent_framework import (
     AgentMiddleware,
     AgentRunContext,
-    AgentRunResponse,
+    AgentResponse,
     ChatAgent,
     ChatContext,
     ChatMessage,
@@ -98,9 +98,9 @@
 
 
 def get_weather(
-    city: Annotated[str, Field(description="La ciudad para consultar el clima.")],
+    city: Annotated[str, Field(description="The city to get the weather for.")],
 ) -> dict:
-    """Devuelve datos del clima para una ciudad dada, un diccionario con temperatura y descripción."""
+    """Return weather data for a given city, with temperature and description."""
     logger.info(f"Obteniendo clima para {city}")
     if random.random() < 0.05:
         return {"temperature": 22, "description": "Soleado"}
@@ -109,77 +109,77 @@ def get_weather(
 
 
 def get_current_date() -> str:
-    """Obtiene la fecha actual del sistema y la devuelve como texto en formato AAAA-MM-DD."""
+    """Get the current system date as text in YYYY-MM-DD format."""
     logger.info("Obteniendo fecha actual")
     return datetime.now().strftime("%Y-%m-%d")
 
 
-# ---- Middleware basado en funciones ----
+# ---- Function-based middleware ----
 
 
 async def timing_agent_middleware(
     context: AgentRunContext,
     next: Callable[[AgentRunContext], Awaitable[None]],
 ) -> None:
-    """Middleware de agente que registra el tiempo de ejecución."""
+    """Agent middleware that logs execution time."""
     start = time.perf_counter()
-    logger.info("[⏲️ Temporización][ Middleware de Agente] Iniciando ejecución del agente")
+    logger.info("[⏲️ Temporización][ Agent Middleware] Iniciando ejecución del agente")
 
     await next(context)
 
     elapsed = time.perf_counter() - start
-    logger.info(f"[⏲️ Temporización][ Middleware de Agente] Ejecución completada en {elapsed:.2f}s")
+    logger.info(f"[⏲️ Temporización][ Agent Middleware] Ejecución completada en {elapsed:.2f}s")
 
 
 async def logging_function_middleware(
     context: FunctionInvocationContext,
     next: Callable[[FunctionInvocationContext], Awaitable[None]],
 ) -> None:
-    """Middleware de función que registra las llamadas y resultados de funciones."""
+    """Function middleware that logs function calls and results."""
     logger.info(
-        f"[🪵 Registro][ Middleware de Función] Llamando a {context.function.name} con args: {context.arguments}"
+        f"[🪵 Registro][ Function Middleware] Llamando a {context.function.name} con args: {context.arguments}"
     )
 
     await next(context)
 
-    logger.info(f"[🪵 Registro][ Middleware de Función] {context.function.name} devolvió: {context.result}")
+    logger.info(f"[🪵 Registro][ Function Middleware] {context.function.name} devolvió: {context.result}")
 
 
 async def logging_chat_middleware(
     context: ChatContext,
     next: Callable[[ChatContext], Awaitable[None]],
 ) -> None:
-    """Middleware de chat que registra las interacciones con la IA."""
-    logger.info(f"[💬 Registro][ Middleware de Chat] Enviando {len(context.messages)} mensajes a la IA")
+    """Chat middleware that logs interactions with the AI."""
+    logger.info(f"[💬 Registro][ Chat Middleware] Enviando {len(context.messages)} mensajes a la IA")
 
     await next(context)
 
-    logger.info("[💬 Registro][ Middleware de Chat] Respuesta de la IA recibida")
+    logger.info("[💬 Registro][ Chat Middleware] Respuesta de la IA recibida")
 
 
 # ---- Middleware basado en clases ----
 
 
 class BlockingAgentMiddleware(AgentMiddleware):
-    """Middleware de agente que bloquea solicitudes con palabras prohibidas."""
+    """Agent middleware that blocks requests with forbidden words."""
 
     def __init__(self, blocked_words: list[str]) -> None:
-        """Inicializa con una lista de palabras que deben ser bloqueadas."""
+        """Initialize with a list of words that should be blocked."""
         self.blocked_words = blocked_words
 
     async def process(
         self,
         context: AgentRunContext,
         next: Callable[[AgentRunContext], Awaitable[None]],
     ) -> None:
-        """Verifica los mensajes en busca de contenido bloqueado y termina si lo encuentra."""
+        """Check messages for blocked content and terminate if found."""
         last_message = context.messages[-1] if context.messages else None
         if last_message and last_message.text:
             for word in self.blocked_words:
                 if word.lower() in last_message.text.lower():
-                    logger.warning(f"[❌ Bloqueo][ Middleware de Agente] Solicitud bloqueada: contiene '{word}'")
+                    logger.warning(f"[❌ Bloqueo][ Agent Middleware] Solicitud bloqueada: contiene '{word}'")
                     context.terminate = True
-                    context.result = AgentRunResponse(
+                    context.result = AgentResponse(
                         messages=[
                             ChatMessage(
                                 role=Role.ASSISTANT, text=f"Lo siento, no puedo procesar solicitudes sobre '{word}'."
@@ -192,46 +192,46 @@ async def process(
 
 
 class TimingFunctionMiddleware(FunctionMiddleware):
-    """Middleware de función que mide el tiempo de ejecución de cada llamada a función."""
+    """Function middleware that measures each function call execution time."""
 
     async def process(
         self,
         context: FunctionInvocationContext,
         next: Callable[[FunctionInvocationContext], Awaitable[None]],
     ) -> None:
-        """Mide el tiempo de ejecución de la función y registra la duración."""
+        """Measure function execution time and log the duration."""
         start = time.perf_counter()
-        logger.info(f"[⌚️ Temporización][ Middleware de Función] Iniciando {context.function.name}")
+        logger.info(f"[⌚️ Temporización][ Function Middleware] Iniciando {context.function.name}")
 
         await next(context)
 
         elapsed = time.perf_counter() - start
-        logger.info(f"[⌚️ Temporización][ Middleware de Función] {context.function.name} tardó {elapsed:.4f}s")
+        logger.info(f"[⌚️ Temporización][ Function Middleware] {context.function.name} tardó {elapsed:.4f}s")
 
 
 class MessageCountChatMiddleware(ChatMiddleware):
-    """Middleware de chat que cuenta el número total de mensajes enviados a la IA."""
+    """Chat middleware that counts total messages sent to the AI."""
 
     def __init__(self) -> None:
-        """Inicializa el contador de mensajes."""
+        """Initialize the message counter."""
         self.total_messages = 0
 
     async def process(
         self,
         context: ChatContext,
         next: Callable[[ChatContext], Awaitable[None]],
     ) -> None:
-        """Cuenta los mensajes y registra el total acumulado."""
+        """Count messages and log the running total."""
         self.total_messages += len(context.messages)
         logger.info(
-            "[🔢 Conteo][ Middleware de Chat] Mensajes en esta solicitud: %s, total hasta ahora: %s",
+            "[🔢 Conteo][ Chat Middleware] Mensajes en esta solicitud: %s, total hasta ahora: %s",
             len(context.messages),
             self.total_messages,
         )
 
         await next(context)
 
-        logger.info("[🔢 Conteo][ Middleware de Chat] Respuesta de chat recibida")
+        logger.info("[🔢 Conteo][ Chat Middleware] Respuesta de chat recibida")
 
 
 # ---- Configuración del agente ----
@@ -247,7 +247,6 @@ async def process(
     instructions=(
         "Ayudas a la gente a planificar su fin de semana. "
         "Usa las herramientas disponibles para consultar el clima y la fecha. "
-        "Responde en español."
     ),
     tools=[get_weather, get_current_date],
     middleware=[
@@ -263,7 +262,7 @@ async def process(
 
 
 async def main() -> None:
-    """Ejecuta el agente con diferentes entradas para demostrar el comportamiento del middleware."""
+    """Run the agent with different inputs to demonstrate middleware behavior."""
     # Solicitud normal - todo el middleware se ejecuta
     logger.info("=== Solicitud Normal ===")
     response = await agent.run("¿Cómo estará el clima este fin de semana en Madrid?")
@@ -281,10 +280,10 @@ async def extra_agent_middleware(
         context: AgentRunContext,
         next: Callable[[AgentRunContext], Awaitable[None]],
     ) -> None:
-        """Middleware a nivel de ejecución que solo aplica a esta ejecución específica."""
-        logger.info("[🏃🏽‍♀️ Middleware de Ejecución] Este middleware solo aplica a esta ejecución")
+        """Execution middleware that only applies to this specific run."""
+        logger.info("[🏃🏽‍♀️ Execution Middleware] Este middleware solo aplica a esta ejecución")
         await next(context)
-        logger.info("[🏃🏽‍♀️ Middleware de Ejecución] Ejecución completada")
+        logger.info("[🏃🏽‍♀️ Execution Middleware] Ejecución completada")
 
     response = await agent.run(
         "¿Cómo estará el clima en Barcelona?",

examples/spanish/agent_supervisor.py

@@ -51,10 +51,10 @@
 
 
 def get_weather(
-    city: Annotated[str, Field(description="Ciudad para consultar el clima.")],
-    date: Annotated[str, Field(description="Fecha (YYYY-MM-DD) para la que se quiere el clima.")],
+    city: Annotated[str, Field(description="City to fetch the weather for.")],
+    date: Annotated[str, Field(description="Date (YYYY-MM-DD) to fetch the weather for.")],
 ) -> dict:
-    """Devuelve datos meteorológicos para una ciudad y fecha dadas."""
+    """Return weather data for a given city and date."""
     logger.info(f"Obteniendo el clima para {city} en {date}")
     if random.random() < 0.05:
         return {"temperature": 72, "description": "Soleado"}
@@ -63,10 +63,10 @@ def get_weather(
 
 
 def get_activities(
-    city: Annotated[str, Field(description="Ciudad para consultar actividades.")],
-    date: Annotated[str, Field(description="Fecha (YYYY-MM-DD) para consultar actividades.")],
+    city: Annotated[str, Field(description="City to fetch activities for.")],
+    date: Annotated[str, Field(description="Date (YYYY-MM-DD) to fetch activities for.")],
 ) -> list[dict]:
-    """Devuelve una lista de actividades para la ciudad y la fecha indicadas."""
+    """Return a list of activities for the given city and date."""
     logger.info(f"Obteniendo actividades para {city} en {date}")
     return [
         {"name": "Senderismo", "location": city},
@@ -76,7 +76,7 @@ def get_activities(
 
 
 def get_current_date() -> str:
-    """Obtiene la fecha actual del sistema (YYYY-MM-DD)."""
+    """Get the current system date (YYYY-MM-DD)."""
     logger.info("Obteniendo la fecha actual")
     return datetime.now().strftime("%Y-%m-%d")
 
@@ -93,7 +93,7 @@ def get_current_date() -> str:
 
 
 async def plan_weekend(query: str) -> str:
-    """Planifica un fin de semana según la consulta del usuario y devuelve la respuesta final."""
+    """Plan a weekend from the user query and return the final response."""
     logger.info("Herramienta: plan_weekend invocada")
     response = await weekend_agent.run(query)
     return response.text
@@ -105,9 +105,9 @@ async def plan_weekend(query: str) -> str:
 
 
 def find_recipes(
-    query: Annotated[str, Field(description="Consulta del usuario o comida/ingrediente deseado")],
+    query: Annotated[str, Field(description="User query or desired meal/ingredient")],
 ) -> list[dict]:
-    """Devuelve recetas (JSON) basadas en una consulta."""
+    """Return recipes (JSON) based on a query."""
     logger.info(f"Buscando recetas para '{query}'")
     if "pasta" in query.lower():
         recipes = [
@@ -141,7 +141,7 @@ def find_recipes(
 
 
 def check_fridge() -> list[str]:
-    """Devuelve una lista JSON de ingredientes actualmente en el refrigerador."""
+    """Return a JSON list of ingredients currently in the fridge."""
     logger.info("Revisando los ingredientes del refrigerador")
     if random.random() < 0.5:
         items = ["pasta", "salsa de tomate", "pimientos", "aceite de oliva"]
@@ -162,7 +162,7 @@ def check_fridge() -> list[str]:
 
 
 async def plan_meal(query: str) -> str:
-    """Planifica una comida según la consulta del usuario y devuelve la respuesta final."""
+    """Plan a meal from the user query and return the final response."""
     logger.info("Herramienta: plan_meal invocada")
     response = await meal_agent.run(query)
     return response.text

examples/spanish/agent_tool.py

@@ -44,9 +44,9 @@
 
 
 def get_weather(
-    city: Annotated[str, Field(description="Nombre de la ciudad")],
+    city: Annotated[str, Field(description="City name")],
 ) -> dict:
-    """Devuelve datos meteorológicos para una ciudad: temperatura y descripción."""
+    """Return weather data for a city: temperature and description."""
     logger.info(f"Obteniendo el clima para {city}")
     if random.random() < 0.05:
         return {