Add pydantic test

Author: maxkorp

typescript-sdk/apps/dojo/e2e/tests/pydanticAITests/backendToolRenderingPage.spec.ts

@@ -0,0 +1,54 @@
+import { test, expect } from "@playwright/test";
+
+test("[PydanticAI] Backend Tool Rendering displays weather cards", async ({ page }) => {
+  // Set shorter default timeout for this test
+  test.setTimeout(30000); // 30 seconds total
+
+  await page.goto("/pydantic-ai/feature/backend_tool_rendering");
+
+  // Verify suggestion buttons are visible
+  await expect(page.getByRole("button", { name: "Weather in San Francisco" })).toBeVisible({
+    timeout: 5000,
+  });
+
+  // Click first suggestion and verify weather card appears
+  await page.getByRole("button", { name: "Weather in San Francisco" }).click();
+
+  // Wait for either test ID or fallback to "Current Weather" text
+  const weatherCard = page.getByTestId("weather-card");
+  const currentWeatherText = page.getByText("Current Weather");
+
+  // Try test ID first, fallback to text
+  try {
+    await expect(weatherCard).toBeVisible({ timeout: 10000 });
+  } catch (e) {
+    // Fallback to checking for "Current Weather" text
+    await expect(currentWeatherText.first()).toBeVisible({ timeout: 10000 });
+  }
+
+  // Verify weather content is present (use flexible selectors)
+  const hasHumidity = await page
+    .getByText("Humidity")
+    .isVisible()
+    .catch(() => false);
+  const hasWind = await page
+    .getByText("Wind")
+    .isVisible()
+    .catch(() => false);
+  const hasCityName = await page
+    .locator("h3")
+    .filter({ hasText: /San Francisco/i })
+    .isVisible()
+    .catch(() => false);
+
+  // At least one of these should be true
+  expect(hasHumidity || hasWind || hasCityName).toBeTruthy();
+
+  // Click second suggestion
+  await page.getByRole("button", { name: "Weather in New York" }).click();
+  await page.waitForTimeout(2000);
+
+  // Verify at least one weather-related element is still visible
+  const weatherElements = await page.getByText(/Weather|Humidity|Wind|Temperature/i).count();
+  expect(weatherElements).toBeGreaterThan(0);
+});

typescript-sdk/apps/dojo/src/agents.ts

@@ -52,6 +52,9 @@ export const agentsIntegrations: AgentIntegrationConfig[] = [
         tool_based_generative_ui: new PydanticAIAgent({
           url: `${envVars.pydanticAIUrl}/tool_based_generative_ui/`,
         }),
+        backend_tool_rendering: new PydanticAIAgent({
+          url: `${envVars.pydanticAIUrl}/backend_tool_rendering`,
+        }),
       };
     },
   },

typescript-sdk/integrations/pydantic-ai/examples/server/__init__.py

@@ -21,6 +21,7 @@
 from .api import (
     agentic_chat_app,
     agentic_generative_ui_app,
+    backend_tool_rendering_app,
     human_in_the_loop_app,
     predictive_state_updates_app,
     shared_state_app,
@@ -30,6 +31,7 @@
 app = FastAPI(title='Pydantic AI AG-UI server')
 app.mount('/agentic_chat', agentic_chat_app, 'Agentic Chat')
 app.mount('/agentic_generative_ui', agentic_generative_ui_app, 'Agentic Generative UI')
+app.mount('/backend_tool_rendering', backend_tool_rendering_app, 'Backend Tool Rendering')
 app.mount('/human_in_the_loop', human_in_the_loop_app, 'Human in the Loop')
 app.mount(
     '/predictive_state_updates',

typescript-sdk/integrations/pydantic-ai/examples/server/api/__init__.py

@@ -4,6 +4,7 @@
 
 from .agentic_chat import app as agentic_chat_app
 from .agentic_generative_ui import app as agentic_generative_ui_app
+from .backend_tool_rendering import app as backend_tool_rendering_app
 from .human_in_the_loop import app as human_in_the_loop_app
 from .predictive_state_updates import app as predictive_state_updates_app
 from .shared_state import app as shared_state_app
@@ -12,6 +13,7 @@
 __all__ = [
     'agentic_chat_app',
     'agentic_generative_ui_app',
+    'backend_tool_rendering_app',
     'human_in_the_loop_app',
     'predictive_state_updates_app',
     'shared_state_app',

typescript-sdk/integrations/pydantic-ai/examples/server/api/backend_tool_rendering.py

@@ -0,0 +1,118 @@
+"""Backend Tool Rendering feature."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from textwrap import dedent
+from zoneinfo import ZoneInfo
+
+import httpx
+from pydantic_ai import Agent
+
+agent = Agent(
+    "openai:gpt-4o-mini",
+    instructions=dedent(
+        """
+        When planning tasks use tools only, without any other messages.
+        IMPORTANT:
+        - Use the `generate_task_steps` tool to display the suggested steps to the user
+        - Do not call the `generate_task_steps` twice in a row, ever.
+        - Never repeat the plan, or send a message detailing steps
+        - If accepted, confirm the creation of the plan and the number of selected (enabled) steps only
+        - If not accepted, ask the user for more information, DO NOT use the `generate_task_steps` tool again
+        """
+    ),
+)
+app = agent.to_ag_ui()
+
+
+def get_weather_condition(code: int) -> str:
+    """Map weather code to human-readable condition.
+
+    Args:
+        code: WMO weather code.
+
+    Returns:
+        Human-readable weather condition string.
+    """
+    conditions = {
+        0: "Clear sky",
+        1: "Mainly clear",
+        2: "Partly cloudy",
+        3: "Overcast",
+        45: "Foggy",
+        48: "Depositing rime fog",
+        51: "Light drizzle",
+        53: "Moderate drizzle",
+        55: "Dense drizzle",
+        56: "Light freezing drizzle",
+        57: "Dense freezing drizzle",
+        61: "Slight rain",
+        63: "Moderate rain",
+        65: "Heavy rain",
+        66: "Light freezing rain",
+        67: "Heavy freezing rain",
+        71: "Slight snow fall",
+        73: "Moderate snow fall",
+        75: "Heavy snow fall",
+        77: "Snow grains",
+        80: "Slight rain showers",
+        81: "Moderate rain showers",
+        82: "Violent rain showers",
+        85: "Slight snow showers",
+        86: "Heavy snow showers",
+        95: "Thunderstorm",
+        96: "Thunderstorm with slight hail",
+        99: "Thunderstorm with heavy hail",
+    }
+    return conditions.get(code, "Unknown")
+
+
+@agent.tool_plain
+async def get_weather(location: str) -> dict[str, str | float]:
+    """Get current weather for a location.
+
+    Args:
+        location: City name.
+
+    Returns:
+        Dictionary with weather information including temperature, feels like,
+        humidity, wind speed, wind gust, conditions, and location name.
+    """
+    async with httpx.AsyncClient() as client:
+        # Geocode the location
+        geocoding_url = (
+            f"https://geocoding-api.open-meteo.com/v1/search?name={location}&count=1"
+        )
+        geocoding_response = await client.get(geocoding_url)
+        geocoding_data = geocoding_response.json()
+
+        if not geocoding_data.get("results"):
+            raise ValueError(f"Location '{location}' not found")
+
+        result = geocoding_data["results"][0]
+        latitude = result["latitude"]
+        longitude = result["longitude"]
+        name = result["name"]
+
+        # Get weather data
+        weather_url = (
+            f"https://api.open-meteo.com/v1/forecast?"
+            f"latitude={latitude}&longitude={longitude}"
+            f"&current=temperature_2m,apparent_temperature,relative_humidity_2m,"
+            f"wind_speed_10m,wind_gusts_10m,weather_code"
+        )
+        weather_response = await client.get(weather_url)
+        weather_data = weather_response.json()
+
+        current = weather_data["current"]
+
+        return {
+            "temperature": current["temperature_2m"],
+            "feelsLike": current["apparent_temperature"],
+            "humidity": current["relative_humidity_2m"],
+            "windSpeed": current["wind_speed_10m"],
+            "windGust": current["wind_gusts_10m"],
+            "conditions": get_weather_condition(current["weather_code"]),
+            "location": name,
+        }