Hacktoberfest 2026: le issue che i maintainer hanno segnato per ottobre, aperte e adatte ai principianti. Sfoglia le issue Hacktoberfest

AgentCoreMemorySessionManager discards the two boto3 clients MemoryClient builds; boto_session and boto_client_config are not passed through

Aperta Adatta ai principianti
  • Qualcosa non va?
#681 1 commento 0 reazioni 0 assegnatari Vedi su GitHub

I maintainer di solito rispondono entro 1 giorno

@avneetbansal-aws ci sta già lavorando.

Dal 28/9/2026.

  • #682 di @avneetbansal-aws — aperta

Valutazione

Difficoltà
2/5
Tempo stimato
1-3 ore
Idoneità per principianti
84/100
Tipo di issue
Bug
Chiarezza
Specificata chiaramente
Stato di attività
Attiva
Stack tecnologico
aws, python
Ambito
api, backend

Direzione di ricerca

Inizia in src/bedrock_agentcore/memory/integrations/strands/session_manager.py, in AgentCoreMemorySessionManager.init, quindi esamina MemoryClient.init in memory/client.py:76-80. Esegui la riproduzione fornita per no-session e warm-session; il lavoro è completato quando MemoryClient usa la stessa sessione dei client di override, senza modifiche alla firma pubblica, e il comportamento segnalato relativo a timing e regione è corretto.

Scritto dal modello di indicizzazione a partire dal testo della issue.

Descrizione

bug

Describe the bug

AgentCoreMemorySessionManager.__init__ builds its MemoryClient without a boto3 session, then overwrites both clients MemoryClient just created with clients from a different session.

# src/bedrock_agentcore/memory/integrations/strands/session_manager.py, 1.23.1
self.memory_client = MemoryClient(region_name=region_name)          # :151
session = boto_session or boto3.Session(region_name=region_name)    # :152
...
self.memory_client.gmcp_client = session.client(                    # :195
    "bedrock-agentcore-control", region_name=..., config=client_config
)
self.memory_client.gmdp_client = session.client(                    # :198
    "bedrock-agentcore", region_name=..., config=client_config
)

MemoryClient.__init__ accepts boto3_session (memory/client.py:76-80) and would use it. Since it isn't passed, MemoryClient creates its own boto3.Session() and builds bedrock-agentcore-control and bedrock-agentcore clients from it. Lines 195 and 198 then replace both. Those two clients are built and thrown away on every instantiation.

botocore caches the parsed service model per boto3.Session, so a fresh session pays that load again every time.

boto_session and boto_client_config are both in the signature and documented in the docstring. Neither reaches MemoryClient.

Cost

We build a session manager per invoke, so this runs on every turn. We also pass a long-lived boto_session, which is what the parameter is for, and that's where this hurts most. The injected session only reaches the override clients. MemoryClient still cold-builds its own session, and that cold build is nearly all of the remaining time.

Medians over 10 iterations after a warm-up, from the script below:

caller as shipped with the fix below
passes boto_session (a long-lived session) 42 ms 3.3 ms
passes no boto_session 97 ms 41 ms

Five consecutive runs ranged 40.3 to 43.9 ms against 3.2 to 3.5 ms for the first row, and 95.3 to 98.9 ms against 39.9 to 44.1 ms for the second.

These are from an M-series laptop. On a warm AgentCore runtime the per-turn cost is in the same range, 37 to 51 ms. The first construction on a cold container is higher, because the service-model load and credential resolution happen then.

To Reproduce

import os, statistics, time
os.environ["AWS_CONFIG_FILE"] = "/dev/null"
os.environ["AWS_SHARED_CREDENTIALS_FILE"] = "/dev/null"
os.environ["AWS_ACCESS_KEY_ID"] = "AKIAIOSFODNN7EXAMPLE"
os.environ["AWS_SECRET_ACCESS_KEY"] = "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
os.environ["AWS_EC2_METADATA_DISABLED"] = "true"

import boto3
from botocore.config import Config
from bedrock_agentcore.memory.client import MemoryClient

REGION = "us-west-2"
CFG = Config(user_agent_extra="strands-agents")    # what :184-192 builds

def pair(s):                                       # the :195/:198 overrides
    s.client("bedrock-agentcore-control", region_name=REGION, config=CFG)
    s.client("bedrock-agentcore", region_name=REGION, config=CFG)

# A long-lived session the caller passes as boto_session, primed once.
WARM = boto3.Session(region_name=REGION)
pair(WARM)

def no_session_shipped():                          # boto_session=None, as shipped
    MemoryClient(region_name=REGION)
    pair(boto3.Session(region_name=REGION))

def no_session_fixed():
    s = boto3.Session(region_name=REGION)
    MemoryClient(region_name=REGION, boto3_session=s)
    pair(s)

def warm_session_shipped():                        # boto_session=WARM, as shipped
    MemoryClient(region_name=REGION)
    pair(WARM)

def warm_session_fixed():
    MemoryClient(region_name=REGION, boto3_session=WARM)
    pair(WARM)

for name, fn in (("no session, shipped", no_session_shipped),
                 ("no session, fixed", no_session_fixed),
                 ("warm session, shipped", warm_session_shipped),
                 ("warm session, fixed", warm_session_fixed)):
    fn()                                           # warm-up
    samples = []
    for _ in range(10):
        t0 = time.perf_counter(); fn()
        samples.append((time.perf_counter() - t0) * 1000)
    print(f"{name:22s} {statistics.median(samples):6.1f} ms")

Run it with no AWS profile set. It makes no network calls, so the dummy keys only stop botocore from searching for real ones.

Expected behavior

MemoryClient should be built from the same session the overrides use. Hoisting line 152 above line 151 and passing the session through is enough:

session = boto_session or boto3.Session(region_name=region_name)
self.memory_client = MemoryClient(region_name=region_name, boto3_session=session)

No public signature changes. Callers who pass boto_session get the 42 to 3.3 ms drop, and callers who don't still save the second service-model load.

Two related points:

  1. boto_client_config can't be forwarded the same way. MemoryClient.__init__ takes only region_name, integration_source and boto3_session, and builds its own Config(user_agent_extra=...) internally. Honouring the documented boto_client_config means adding a parameter there. Until then, retry and timeout config can't be set on the memory client at all.

  2. With region_name=None and a boto_session pinned to one region, MemoryClient.region_name resolves from a fresh default session while the clients actually used come from boto_session. The attribute can disagree with the region serving the calls. Passing the session fixes that too.

Happy to test a patch against our workload. I didn't open a PR because CONTRIBUTING.md says the repo isn't accepting external ones.

Environment

  • bedrock-agentcore 1.23.1. Also present on main at cc980d14, the most recent commit to touch this file.
  • boto3 1.43.101, botocore 1.43.101
  • Python 3.13.13, macOS
  • Also reproduces on 1.18.1
Lingua principale
Python
Stelle
776
Fork
153
Merge medio
1g 8h
PR unite (30g)
15

Preparare l'ambiente

Come iniziare

  1. Leggi tutta la issue e poi la guida ai contributi del progetto.
  2. Commenta sulla issue per dire che te ne occupi tu — evita che due persone facciano lo stesso lavoro.
  3. Fai un fork del repository e lavora su un branch.
  4. Apri una pull request che faccia riferimento al numero della issue.

Altre issue di aws/bedrock-agentcore-sdk-python

Tutte le issue di aws/bedrock-agentcore-sdk-python

Issue simili

Altre issue su Python

Ricevi le nuove issue nella tua casella

Un breve riepilogo di issue GitHub adatte ai principianti.