In [1]:
!pip install --quiet pydantic-ai nest_asyncio
ERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.
google-colab 1.0.0 requires google-auth==2.49.0, but you have google-auth 2.62.0 which is incompatible.
google-adk 2.7.1 requires opentelemetry-api<=1.42.1,>=1.39, but you have opentelemetry-api 1.45.1 which is incompatible.
google-adk 2.7.1 requires opentelemetry-sdk<=1.42.1,>=1.39, but you have opentelemetry-sdk 1.45.1 which is incompatible.

💡 Nota sobre el mensaje en rojo de arriba:

  • Si ves un aviso de pip que habla sobre "dependency conflicts" con paquetes como google-auth u opentelemetry, ¡no te preocupes en absoluto!

  • Google Colab viene con muchas librerías preinstaladas para interactuar con -Google Cloud. Al instalar pydantic-ai, algunas versiones se actualizan y Colab nos avisa de esa pequeña discrepancia. Para lo que vamos a construir aquí (nuestro agente Don Plátano y sus cotizaciones con Pydantic), todo funcionará de forma impecable. Puedes ignorar el aviso rojo y continuar con total tranquilidad. ☕

In [2]:
from importlib.metadata import version

try:
    import pydantic_ai
    import nest_asyncio
    print("✅ pydantic-ai instalado. Versión:", version("pydantic-ai"))
    print("📝 Anota esta versión en tus apuntes.")
except ImportError as error:
    print("❌ Algo falló en la instalación:", error)
    print("Vuelve a ejecutar la celda anterior sin --quiet para ver el error completo.")
✅ pydantic-ai instalado. Versión: 2.60.0
📝 Anota esta versión en tus apuntes.

Ahora la API key. Debe estar guardada en Secrets (ícono 🔑 del panel izquierdo) con el nombre exacto OPENROUTER_API_KEY y con el interruptor "Acceso desde el notebook" activado. Si aún no la tienes, el Artículo 1 explica el paso a paso.

In [3]:
import os
from google.colab import userdata

try:
    os.environ["OPENROUTER_API_KEY"] = userdata.get("OPENROUTER_API_KEY")
    print("✅ API key cargada correctamente.")
except Exception as error:
    print("❌ No se pudo leer el secreto OPENROUTER_API_KEY.")
    print("Revisa que exista con ese nombre exacto y que tenga activado")
    print("el interruptor 'Acceso desde el notebook'.")
    print("Detalle técnico:", error)
✅ API key cargada correctamente.
In [4]:
import nest_asyncio

nest_asyncio.apply()
print("✅ Listo: run_sync funcionará dentro de Colab.")
✅ Listo: run_sync funcionará dentro de Colab.

1. El problema: el texto libre no se deja usar¶

Recordemos a Don Plátano del artículo anterior. Le pedimos una cotización e intentamos rescatar el número con una expresión regular, una herramienta para buscar patrones dentro de un texto. Aquí buscamos cualquier secuencia que empiece con un dígito.

In [5]:
import re
from pydantic_ai import Agent

agente_texto = Agent(
    "openrouter:openai/gpt-4o-mini",
    system_prompt=(
        "Eres Don Plátano, corredor estrella del Banano Exchange. "
        "En este mercado TODO se cotiza en bananas. "
        "Hablas con el dramatismo de un narrador de bolsa de valores. "
        "Responde siempre en español y en máximo 4 oraciones."
    ),
)

respuesta_texto = agente_texto.run_sync("Cotiza en bananas: la Torre Eiffel")
print(respuesta_texto.output)
print()

numeros = re.findall(r"\d[\d.,]*", respuesta_texto.output)
print("Números que encontré con la expresión regular:", numeros)
¡Atención, atención! La Torre Eiffel se cotiza en un estremecedor número de 1.500.000 bananas, destacando su inquebrantable presencia en el horizonte parisino. Este ícono de la arquitectura, brilla como nunca en el mercado, reflejando la apreciación del arte y la historia. Inversionistas y soñadores, asegúrense de hacer sus movimientos con astucia, antes de que esta cifra se eleve aún más. ¡La oportunidad está en el aire!

Números que encontré con la expresión regular: ['1.500.000']

Con suerte aparece un solo número. Con menos suerte aparecen varios y no sabes cuál es el precio, o ninguno, porque el modelo escribió "ochenta millones" con letras.

Y aunque lo encontraras, todavía te faltaría saber si es un número o un texto, cómo se escribe su unidad y si el modelo decidió hoy usar puntos, comas o ninguno como separador. Programar sobre texto libre es construir sobre arena.

La solución es pedirle al modelo que llene un formulario con campos conocidos. Para describir ese formulario usaremos Pydantic.

2. Pydantic en cinco minutos (sin IA todavía)¶

Pydantic es una librería que define y valida datos. Su pieza principal es BaseModel: una clase que funciona como un formulario con campos. Cada campo tiene un nombre y un tipo (texto, número entero, etc.).

📝 Nota para principiantes: en Pydantic, los dos puntos con el tipo (objeto: str) no son decoración: la librería los lee para saber qué validar. Por eso aquí sí los usamos.

Creemos un formulario mínimo y llenémoslo:

In [6]:
from pydantic import BaseModel, ValidationError


class CotizacionSimple(BaseModel):
    objeto: str
    valor_en_bananas: int


cotizacion_a = CotizacionSimple(objeto="Torre Eiffel", valor_en_bananas=85000000)

print(cotizacion_a)
print("Objeto:", cotizacion_a.objeto)
print("Valor:", cotizacion_a.valor_en_bananas)
print("Como diccionario:", cotizacion_a.model_dump())
objeto='Torre Eiffel' valor_en_bananas=85000000
Objeto: Torre Eiffel
Valor: 85000000
Como diccionario: {'objeto': 'Torre Eiffel', 'valor_en_bananas': 85000000}

Lo valioso viene cuando los datos no encajan. Pydantic convierte lo razonable (el texto "500" se vuelve el número 500) y rechaza lo que no tiene sentido:

In [7]:
# Lo razonable se convierte solito: "500" (texto) -> 500 (entero)
cotizacion_b = CotizacionSimple(objeto="Taco de pastor", valor_en_bananas="500")
print("Valor:", cotizacion_b.valor_en_bananas, "| tipo:", type(cotizacion_b.valor_en_bananas).__name__)

# Lo que no tiene sentido se rechaza con un error claro
try:
    CotizacionSimple(objeto="Auto compacto", valor_en_bananas="muchísimas")
except ValidationError as error:
    print()
    print("❌ Pydantic rechazó los datos:")
    print(error)
Valor: 500 | tipo: int

❌ Pydantic rechazó los datos:
1 validation error for CotizacionSimple
valor_en_bananas
  Input should be a valid integer, unable to parse string as an integer [type=int_parsing, input_value='muchísimas', input_type=str]
    For further information visit https://errors.pydantic.dev/2.14/v/int_parsing

3. Validaciones con Field, Literal y Enum¶

Que el valor sea "un entero" no basta: un precio negativo también es un entero. Con Field añadimos reglas y descripciones a cada campo:

Opción Qué hace Ejemplo
gt / ge mayor que / mayor o igual que gt=0
lt / le menor que / menor o igual que le=1
min_length / max_length largo mínimo / máximo del texto max_length=200
description explica el campo (¡también al modelo!) description="Valor en bananas"

Para limitar un campo a unos pocos valores permitidos hay dos herramientas:

  • Literal: se escribe en el mismo campo, ideal para pocas opciones ("alza", "baja", "estable").
  • Enum: un conjunto de opciones con nombre propio, ideal cuando lo reutilizas o son más opciones.

Definamos el formulario oficial del Banano Exchange:

In [8]:
from enum import Enum
from typing import Literal
from pydantic import Field


class Categoria(str, Enum):
    monumento = "monumento"
    comida = "comida"
    vehiculo = "vehiculo"
    objeto_cotidiano = "objeto_cotidiano"
    otro = "otro"


class Cotizacion(BaseModel):
    objeto: str = Field(
        description="Nombre del objeto o cosa que se cotiza",
    )
    categoria: Categoria = Field(
        description="Categoría que mejor describe al objeto",
    )
    valor_en_bananas: int = Field(
        gt=0,
        description="Valor estimado en bananas: un número entero positivo, sin separadores de miles",
    )
    confianza: float = Field(
        ge=0,
        le=1,
        description="Nivel de confianza entre 0 y 1, donde 0.85 significa 85 por ciento",
    )
    tendencia: Literal["alza", "baja", "estable"] = Field(
        description="Hacia dónde va el precio de este objeto en el mercado bananero",
    )
    comentario: str = Field(
        max_length=200,
        description="Comentario dramático de Don Plátano, de máximo 200 caracteres",
    )


print("✅ Formulario Cotizacion definido.")
✅ Formulario Cotizacion definido.

Probemos el formulario a mano, sin IA, para ver las reglas en acción. Primero una cotización válida:

In [9]:
datos_base = {
    "objeto": "Torre Eiffel",
    "categoria": "monumento",
    "valor_en_bananas": 85000000,
    "confianza": 0.6,
    "tendencia": "alza",
    "comentario": "¡Sube como espuma de cerveza en final de mundial!",
}

cotizacion_valida = Cotizacion(**datos_base)

print(cotizacion_valida)
print()
print("Categoría:", cotizacion_valida.categoria.value)
objeto='Torre Eiffel' categoria=<Categoria.monumento: 'monumento'> valor_en_bananas=85000000 confianza=0.6 tendencia='alza' comentario='¡Sube como espuma de cerveza en final de mundial!'

Categoría: monumento

Ahora cuatro cotizaciones con un solo error cada una. En el código, {**datos_base, **cambio} significa: "copia todos los datos base y pisa solo los campos que aparecen en cambio".

In [10]:
casos_invalidos = [
    ("valor negativo", {"valor_en_bananas": -500}),
    ("confianza como porcentaje", {"confianza": 85}),
    ("tendencia inventada", {"tendencia": "disparada"}),
    ("categoría inexistente", {"categoria": "planeta"}),
]

for nombre, cambio in casos_invalidos:
    datos = {**datos_base, **cambio}
    try:
        Cotizacion(**datos)
    except ValidationError as error:
        problema = error.errors()[0]
        print(f"❌ {nombre}: campo '{problema['loc'][0]}' -> {problema['msg']}")
❌ valor negativo: campo 'valor_en_bananas' -> Input should be greater than 0
❌ confianza como porcentaje: campo 'confianza' -> Input should be less than or equal to 1
❌ tendencia inventada: campo 'tendencia' -> Input should be 'alza', 'baja' or 'estable'
❌ categoría inexistente: campo 'categoria' -> Input should be 'monumento', 'comida', 'vehiculo', 'objeto_cotidiano' or 'otro'

Cada error indica qué campo falló y por qué. Esta es la información que PydanticAI usará más adelante para corregir al modelo.

4. Lo que realmente ve el modelo: el esquema¶

Cuando le pasemos Cotizacion al agente, el modelo no recibe tu clase de Python. Recibe una descripción en formato JSON llamada esquema. Pydantic la genera automáticamente:

In [11]:
import json

esquema = Cotizacion.model_json_schema()
print(json.dumps(esquema, indent=2, ensure_ascii=False))
{
  "$defs": {
    "Categoria": {
      "enum": [
        "monumento",
        "comida",
        "vehiculo",
        "objeto_cotidiano",
        "otro"
      ],
      "title": "Categoria",
      "type": "string"
    }
  },
  "properties": {
    "objeto": {
      "description": "Nombre del objeto o cosa que se cotiza",
      "title": "Objeto",
      "type": "string"
    },
    "categoria": {
      "$ref": "#/$defs/Categoria",
      "description": "Categoría que mejor describe al objeto"
    },
    "valor_en_bananas": {
      "description": "Valor estimado en bananas: un número entero positivo, sin separadores de miles",
      "exclusiveMinimum": 0,
      "title": "Valor En Bananas",
      "type": "integer"
    },
    "confianza": {
      "description": "Nivel de confianza entre 0 y 1, donde 0.85 significa 85 por ciento",
      "maximum": 1,
      "minimum": 0,
      "title": "Confianza",
      "type": "number"
    },
    "tendencia": {
      "description": "Hacia dónde va el precio de este objeto en el mercado bananero",
      "enum": [
        "alza",
        "baja",
        "estable"
      ],
      "title": "Tendencia",
      "type": "string"
    },
    "comentario": {
      "description": "Comentario dramático de Don Plátano, de máximo 200 caracteres",
      "maxLength": 200,
      "title": "Comentario",
      "type": "string"
    }
  },
  "required": [
    "objeto",
    "categoria",
    "valor_en_bananas",
    "confianza",
    "tendencia",
    "comentario"
  ],
  "title": "Cotizacion",
  "type": "object"
}

Busca en esa salida los textos que escribiste en description, además de los límites (exclusiveMinimum, maximum, maxLength) y las opciones permitidas (enum).

Idea clave: las description forman parte del prompt. Un campo con una descripción vaga ("el valor") produce más errores que uno claro ("número entero positivo, sin separadores de miles"). Escribirlas bien es tan importante como escribir bien el system_prompt.

5. Conectar el formulario con el agente: output_type¶

Basta añadir un parámetro: output_type=Cotizacion. A partir de ahí el agente ya no devuelve texto, sino un objeto Cotizacion validado.

El system_prompt se simplifica: ya no hace falta pedir "máximo 4 oraciones", porque el formato lo manda el formulario. La personalidad de Don Plátano se queda en el campo comentario.

In [12]:
agente_cotizador = Agent(
    "openrouter:openai/gpt-4o-mini",
    output_type=Cotizacion,
    system_prompt=(
        "Eres Don Plátano, corredor estrella del Banano Exchange. "
        "En este mercado TODO se cotiza en bananas. "
        "Estima el valor de lo que te pidan con tu mejor criterio. "
        "Tu comentario debe tener el dramatismo de un narrador de bolsa de valores "
        "y estar escrito en español."
    ),
)

resultado = agente_cotizador.run_sync("Cotiza en bananas: la Torre Eiffel")
cotizacion = resultado.output

print("Tipo de la respuesta:", type(cotizacion).__name__)
print()
print(cotizacion)
Tipo de la respuesta: Cotizacion

objeto='Torre Eiffel' categoria=<Categoria.monumento: 'monumento'> valor_en_bananas=50000000 confianza=0.9 tendencia='alza' comentario='¡El símbolo de París brilla más que nunca! Las inversiones en turismo están disparando su valor.'

Compara con el Artículo 1: allí resultado.output era un texto; ahora es un objeto Cotizacion. Sus campos se usan directamente, sin expresiones regulares:

In [14]:
print("Objeto:", cotizacion.objeto)
print("Categoría:", cotizacion.categoria.value)
print(f"Valor: {cotizacion.valor_en_bananas:,} bananas")
print(f"Confianza: {cotizacion.confianza:.0%}")
print("Tendencia:", cotizacion.tendencia)
print("Comentario:", cotizacion.comentario)
print()
print("Uso de tokens:", resultado.usage)
Objeto: Torre Eiffel
Categoría: monumento
Valor: 50,000,000 bananas
Confianza: 90%
Tendencia: alza
Comentario: ¡El símbolo de París brilla más que nunca! Las inversiones en turismo están disparando su valor.

Uso de tokens: RunUsage(cost=Decimal('0.00008745'), details={'is_byok': 0, 'audio_tokens': 0, 'reasoning_tokens': 0, 'image_tokens': 0}, input_tokens=299, output_tokens=71, requests=1)

¿Qué ocurre por debajo? A grandes rasgos (los detalles cambian según el modelo y la versión):

  1. PydanticAI convierte Cotizacion en un esquema y se lo envía al modelo junto con tu pregunta.
  2. El modelo responde con los datos en la estructura pedida.
  3. PydanticAI valida la respuesta con Pydantic y te entrega el objeto ya verificado.

Fíjate en los tokens: son algo más que en el Artículo 1, porque el esquema también se envía en cada llamada. Estructura cuesta un poco más, y casi siempre vale la pena.

📝 Esto funciona con modelos que soportan salidas estructuradas o llamadas a funciones, como los dos que usamos en la serie (gpt-4o-mini y gemini-2.5-flash-lite). Con modelos muy pequeños o antiguos puede fallar con más frecuencia.

6. ¿Y si el modelo se equivoca? Reintentos¶

Los modelos fallan, por ejemplo devolviendo confianza: 85 en lugar de 0.85. Aquí PydanticAI hace algo útil: no te entrega el error, se lo devuelve al modelo.

Tú ──pregunta──▶ Modelo ──respuesta──▶ Validación (Pydantic)
                    ▲                        │
                    │      ¿válida?          │
                    │    ┌─────sí──▶ ✅ te entrega el objeto
                    │    │
                    └────┴─no──▶ le explica el error y le pide corregir
                                 (hasta agotar los reintentos)

Así el modelo corrige solo en la mayoría de los casos. Revisemos si la cotización anterior necesitó algún reintento, buscando en el historial los mensajes de tipo RetryPromptPart:

In [15]:
from pydantic_ai.messages import RetryPromptPart

reintentos = 0
for mensaje in resultado.all_messages():
    for parte in mensaje.parts:
        if isinstance(parte, RetryPromptPart):
            reintentos += 1

print("Reintentos necesarios en esta ejecución:", reintentos)
Reintentos necesarios en esta ejecución: 0

Lo más probable es que haya salido 0, y es normal: con descripciones claras, el modelo acierta a la primera. El mecanismo está ahí para los días malos.

Veamos qué pasa cuando el modelo no puede acertar nunca. Le pediremos algo imposible a propósito: un valor entero mayor que 0 y menor que 1. Con retries=2 el agente tiene permitido corregirse dos veces antes de rendirse.

💸 Esta celda gasta unas 3 llamadas a propósito (el intento original más los reintentos). Son centavos, pero no la ejecutes en bucle.

In [16]:
class CotizacionImposible(BaseModel):
    objeto: str
    valor_en_bananas: int = Field(gt=0, lt=1, description="Valor en bananas")


agente_imposible = Agent(
    "openrouter:openai/gpt-4o-mini",
    output_type=CotizacionImposible,
    retries=2,
)

try:
    agente_imposible.run_sync("Cotiza en bananas: la Torre Eiffel")
except Exception as error:
    print("❌ Error capturado:", type(error).__name__)
    print("Detalle (primeros 300 caracteres):")
    print(str(error)[:300])
❌ Error capturado: ModelHTTPError
Detalle (primeros 300 caracteres):
status_code: 400, model_name: openai/gpt-4o-mini, body: {'message': 'Provider returned error', 'code': 400, 'metadata': {'raw': '{\n  "error": {\n    "message": "Could not finish the message because max_tokens or model output limit was reached. Please try again with higher max_tokens.",\n    "type":

Tras agotar los reintentos, PydanticAI lanza una excepción en lugar de entregarte datos inválidos. Es mejor un error claro que un dato malo que pasa desapercibido.

📝 retries es el número de reintentos permitidos (y por defecto es 1). En versiones recientes existe además output_retries, que aplica solo a la validación de la salida. Si algún nombre no existe en tu versión, revisa la que anotaste al inicio.

7. De cotizaciones a tabla¶

Aquí se ve la ganancia práctica. Como cada cotización es un objeto con campos fijos, convertirla en una fila de una tabla es directo:

  1. model_dump(mode="json") convierte el objeto en un diccionario con valores simples. El mode="json" hace que la categoría (un Enum) salga como texto normal.
  2. pandas.DataFrame convierte una lista de diccionarios en una tabla.

Cotizaremos tres objetos. Cada llamada va dentro de try/except para que un fallo no detenga a los demás:

In [17]:
import pandas as pd

objetos = [
    "Torre Eiffel",
    "Un taco de pastor con todo",
    "Un auto compacto nuevo",
]

filas = []
for objeto in objetos:
    try:
        respuesta = agente_cotizador.run_sync(f"Cotiza en bananas: {objeto}")
        filas.append(respuesta.output.model_dump(mode="json"))
    except Exception as error:
        print(f"⚠️ No se pudo cotizar '{objeto}':", type(error).__name__)

tabla = pd.DataFrame(filas)
tabla
Out[17]:
objeto categoria valor_en_bananas confianza tendencia comentario
0 Torre Eiffel monumento 500000 0.9 estable Un ícono de París que, como el oro, siempre br...
1 taco de pastor con todo comida 15 0.9 alza En la vorágine del mercado, un taco de pastor ...
2 auto compacto nuevo vehiculo 15000 0.9 alza ¡El mercado se acelera! Un auto compacto nuevo...

Una tabla, con columnas fijas, lista para ordenar, filtrar o graficar. Guardémosla en un archivo CSV (un formato de texto que abre cualquier hoja de cálculo). Usamos pathlib.Path para manejar la ruta:

In [18]:
from pathlib import Path

ruta_csv = Path("cotizaciones.csv")
tabla.to_csv(ruta_csv, index=False)

print("✅ Guardado en:", ruta_csv.resolve())
✅ Guardado en: /content/cotizaciones.csv

Encuentras el archivo en el panel de archivos de Colab (ícono 📁 a la izquierda).

⚠️ Límite de Colab: ese archivo vive solo mientras dura la sesión. Si quieres conservarlo, descárgalo desde el panel (clic derecho → Descargar) o guárdalo en tu Google Drive.

8. Estructura no es lo mismo que verdad¶

Un buen tutorial dice también lo que no resuelve. Hagamos un experimento: la misma cotización, cuatro veces, y veamos cuánto varía el valor.

In [19]:
valores = []
for intento in range(4):
    respuesta = agente_cotizador.run_sync("Cotiza en bananas: la Torre Eiffel")
    valores.append(respuesta.output.valor_en_bananas)

serie = pd.Series(valores)

print("Valores:", [f"{valor:,}" for valor in valores])
print(f"Mínimo: {serie.min():,} | Máximo: {serie.max():,}")
print(f"El máximo es {serie.max() / serie.min():.1f} veces el mínimo")
Valores: ['500,000', '500,000', '250,000', '500,000']
Mínimo: 250,000 | Máximo: 500,000
El máximo es 2.0 veces el mínimo

Los cuatro resultados son válidos (enteros positivos, con su confianza y su tendencia), pero no coinciden. El formulario garantiza la forma de la respuesta, no que el contenido sea verdadero. Don Plátano sigue improvisando; ahora lo hace con buena letra.

Tiene un lado positivo: como los datos ya son estructurados, medir la inconsistencia fue cuestión de cuatro líneas. Con texto libre habría sido un dolor de cabeza.

Problema ¿Resuelto con salidas estructuradas? Se resuelve en
Respuesta imposible de usar en un programa ✅ Sí Este artículo
Valores fuera de rango o tipos incorrectos ✅ Sí, con Field, Literal y Enum Este artículo
El modelo se equivoca de formato ✅ En su mayoría, con reintentos Este artículo
Las cifras son inventadas ❌ No Artículo 3 (herramientas)
No recuerda la conversación ❌ No Artículo 4 (contexto y memoria)

9. Errores comunes y cómo resolverlos¶

Síntoma Causa probable Solución
ValidationError al crear tu modelo a mano Algún dato no cumple las reglas del campo Lee error.errors(): indica el campo y el motivo
El agente falla tras varios intentos La salida del modelo no cumple el formulario, o el formulario es demasiado estricto o contradictorio Revisa las description, relaja los límites o sube retries
confianza llega como 85 en lugar de 0.85 La descripción del campo era vaga Aclárala: "entre 0 y 1, donde 0.85 significa 85 por ciento"
El modelo ignora tu formato El modelo no soporta salidas estructuradas Prueba con otro modelo (gpt-4o-mini o gemini-2.5-flash-lite)
La columna de categoría muestra Categoria.monumento en la tabla Usaste model_dump() sin mode="json" Usa model_dump(mode="json")
La respuesta tarda más o cuesta más que en el Artículo 1 El esquema se envía en cada llamada Es normal; mantén los campos y descripciones concisos
Error de atributo al leer la respuesta Versión antigua de PydanticAI (usaba .data) Revisa tu versión: hoy se usa .output

10. 🏆 Mini-reto: el primer reporte del Banano Exchange¶

El mercado abre mañana y necesitas el reporte de precios de diez objetos. Don Plátano ya sabe llenar formularios, así que:

Requisitos:

  1. Crea una lista con 10 objetos de tu elección (cuanto más absurdos, mejor).
  2. Cotízalos con agente_cotizador, cada uno dentro de try/except.
  3. Arma una tabla con pandas y guárdala en un CSV con pathlib.

Bonus:

  • Agrega un campo riesgo (Literal["bajo", "medio", "alto"]) a un nuevo formulario y un nuevo agente.
  • Ordena la tabla de mayor a menor valor y muestra cuál es el objeto más caro: tabla.sort_values("valor_en_bananas", ascending=False).

Escribe tu solución aquí:

In [ ]:
# Tu solución aquí

# objetos_reto = [
#     ...
# ]

# filas_reto = []
# for objeto in objetos_reto:
#     try:
#         ...
#     except Exception as error:
#         print(...)

# tabla_reto = pd.DataFrame(filas_reto)
# tabla_reto
👀 Ver una posible solución (inténtalo primero)
objetos_reto = [
    "Torre Eiffel", "Un taco de pastor con todo", "Un auto compacto nuevo",
    "La Luna", "Mi deuda con la tarjeta de crédito", "Un estadio de fútbol",
    "El Ángel de la Independencia", "Una mudanza en lunes",
    "Un café de la mañana", "El último capítulo de mi serie favorita",
]

filas_reto = []
for objeto in objetos_reto:
    try:
        respuesta = agente_cotizador.run_sync(f"Cotiza en bananas: {objeto}")
        filas_reto.append(respuesta.output.model_dump(mode="json"))
    except Exception as error:
        print(f"⚠️ No se pudo cotizar '{objeto}':", type(error).__name__)

tabla_reto = pd.DataFrame(filas_reto)
tabla_reto = tabla_reto.sort_values("valor_en_bananas", ascending=False)

ruta_reto = Path("reporte_banano_exchange.csv")
tabla_reto.to_csv(ruta_reto, index=False)

print("✅ Guardado en:", ruta_reto.resolve())
tabla_reto