Use AWS MemoryCreated waiter in MemoryClient._wait_for_memory_active()

Open
#248 0 comments 0 reactions 0 assignees View on GitHub

Maintainers usually reply within 1 day

Nobody has claimed this yet.

Assessment

Difficulty
3/5
Estimated time
1-2 days
Newbie friendliness
48/100
Issue type
Refactor
Clarity
Clearly specified
Activity status
Stale
Tech stack
aws, python
Domain
api, backend

Research direction

Start at MemoryClient.wait_for_memory_active() and inspect how create_memory_and_wait(), add*_strategy_and_wait(), and update_memory_strategies_and_wait() use it. Verify the memory_created waiter configuration and fallback behavior, then confirm delete_memory_and_wait() still uses manual polling; done means the affected methods wait successfully while preserving backward compatibility.

Written by the indexing model from the issue text.

Description

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
Dominant language
Python
Stars
786
Forks
163
Avg merge
4h
Merged PRs (30d)
22

Getting set up

First steps

  1. Read the whole issue, then the project's contributing guide.
  2. Comment on the issue to say you are picking it up — it saves two people doing the same work.
  3. Fork the repository and make your change on a branch.
  4. Open a pull request that references the issue number.

More from aws/bedrock-agentcore-sdk-python

All issues in aws/bedrock-agentcore-sdk-python

Similar issues

More Python issues

Get new issues in your inbox

A short digest of beginner-friendly GitHub issues.