Use AWS MemoryCreated waiter in MemoryClient._wait_for_memory_active()

Abierto
#248 0 comentarios 0 reacciones 0 asignados Ver en GitHub

Los mantenedores suelen responder en 1 día

Nadie ha tomado este issue todavía.

Evaluación

Dificultad
3/5
Tiempo estimado
1-2 días
Aptitud para principiantes
48/100
Tipo de issue
Refactorización
Claridad
Bien especificado
Estado de actividad
Estancado
Stack tecnológico
aws, python
Área
api, backend

Línea de trabajo

Comienza en MemoryClient.wait_for_memory_active() e inspecciona cómo lo utilizan create_memory_and_wait(), add*_strategy_and_wait() y update_memory_strategies_and_wait(). Verifica la configuración del waiter memory_created y el comportamiento de fallback, y confirma después que delete_memory_and_wait() sigue utilizando polling manual; se considera terminado cuando los métodos afectados esperan correctamente y mantienen la compatibilidad hacia atrás.

Escrito por el modelo de indexación a partir del texto del issue.

Descripción

Summary

Replace manual polling in MemoryClient._wait_for_memory_active() with the AWS memory_created waiter for more efficient waiting.

Current Implementation

The current _wait_for_memory_active() method uses manual polling with a default 10-second interval:

def _wait_for_memory_active(self, memory_id: str, max_wait: int, poll_interval: int) -> Dict[str, Any]:
    start_time = time.time()
    while time.time() - start_time < max_wait:
        status = self.get_memory_status(memory_id)
        if status == MemoryStatus.ACTIVE.value:
            return memory
        elif status == MemoryStatus.FAILED.value:
            raise RuntimeError(...)
        time.sleep(poll_interval)  # Default: 10 seconds
    raise TimeoutError(...)

Proposed Implementation

Use the memory_created waiter (confirmed available in boto3):

def _wait_for_memory_active(self, memory_id: str, max_wait: int = 300, poll_interval: int = 2) -> Dict[str, Any]:
    try:
        waiter = self.gmcp_client.get_waiter('memory_created')
        waiter.wait(
            memoryId=memory_id,
            WaiterConfig={
                'Delay': poll_interval,
                'MaxAttempts': max_wait // poll_interval
            }
        )
        # Get final memory state
        response = self.gmcp_client.get_memory(memoryId=memory_id)
        return self._normalize_memory_response(response["memory"])
    except Exception:
        # Fallback to manual polling for backwards compatibility
        return self._wait_for_memory_active_polling(memory_id, max_wait, poll_interval)

Benefits

Aspect Manual Polling AWS Waiter
Default poll interval 10s 2s
Error handling Custom AWS-managed
Retry logic Custom Built-in
Maintenance SDK team AWS/botocore

Affected Methods

This change would improve the following methods that use _wait_for_memory_active():

  • create_memory_and_wait()
  • add_*_strategy_and_wait() methods
  • update_memory_strategies_and_wait()

Backwards Compatibility

Include fallback to manual polling if:

  • Waiter is not available in older boto3 versions
  • Waiter fails unexpectedly

Notes

  • The memory_created waiter is confirmed available: client.waiter_names returns ['memory_created']
  • No memory_deleted waiter exists, so delete_memory_and_wait() must continue using manual polling
Lenguaje dominante
Python
Estrellas
786
Forks
163
Merge medio
4 h
PR fusionados (30 d)
22

Preparar el entorno

Primeros pasos

  1. Lee el issue completo y luego la guía de contribución del proyecto.
  2. Comenta en el issue que vas a ocuparte — evita que dos personas hagan lo mismo.
  3. Haz un fork del repositorio y trabaja en una rama.
  4. Abre un pull request que haga referencia al número del issue.

Más de aws/bedrock-agentcore-sdk-python

Todos los issues de aws/bedrock-agentcore-sdk-python

Issues similares

Más issues de Python

Recibe los nuevos issues en tu correo

Un resumen breve de issues de GitHub para principiantes.