bedrock-agentcore-starter-toolkit 0.1.14__py3-none-any.whl → 0.1.15__py3-none-any.whl

bedrock_agentcore_starter_toolkit/operations/runtime/launch.py

@@ -130,6 +130,145 @@ def _ensure_execution_role(agent_config, project_config, config_path, agent_name
     raise ValueError("Execution role not configured and auto-create not enabled")
 
 
+def _ensure_memory_for_agent(
+    agent_config: BedrockAgentCoreAgentSchema,
+    project_config: BedrockAgentCoreConfigSchema,
+    config_path: Path,
+    agent_name: str,
+) -> Optional[str]:
+    """Ensure memory resource exists for agent. Returns memory_id or None.
+
+    This function is idempotent - it creates memory if needed or reuses existing.
+    """
+    # If memory already exists, return it
+    if agent_config.memory and agent_config.memory.memory_id:
+        log.info("Using existing memory: %s", agent_config.memory.memory_id)
+        return agent_config.memory.memory_id
+
+    # If memory not enabled, skip
+    if not agent_config.memory or not agent_config.memory.is_enabled:
+        return None
+
+    log.info("Creating memory resource for agent: %s", agent_name)
+    try:
+        from ...operations.memory.constants import StrategyType
+        from ...operations.memory.manager import MemoryManager
+
+        memory_manager = MemoryManager(region_name=agent_config.aws.region)
+        memory_name = f"{agent_name}_mem"  # Short name under 48 char limit
+
+        # Check if memory already exists
+        existing_memory = None
+        try:
+            memories = memory_manager.list_memories()
+            for m in memories:
+                if m.id.startswith(memory_name):
+                    existing_memory = memory_manager.get_memory(m.id)
+                    log.info("Found existing memory: %s", m.id)
+                    break
+        except Exception as e:
+            log.debug("Error checking for existing memory: %s", e)
+
+        # Determine if we need to create new memory or add strategies to existing
+        if existing_memory:
+            # Check if strategies need to be added
+            existing_strategies = []
+            if hasattr(existing_memory, "strategies") and existing_memory.strategies:
+                existing_strategies = existing_memory.strategies
+
+            log.info("Existing memory has %d strategies", len(existing_strategies))
+
+            # If LTM is enabled but no strategies exist, add them
+            if agent_config.memory.has_ltm and len(existing_strategies) == 0:
+                log.info("Adding LTM strategies to existing memory...")
+                memory_manager.update_memory_strategies_and_wait(
+                    memory_id=existing_memory.id,
+                    add_strategies=[
+                        {
+                            StrategyType.USER_PREFERENCE.value: {
+                                "name": "UserPreferences",
+                                "namespaces": ["/users/{actorId}/preferences"],
+                            }
+                        },
+                        {
+                            StrategyType.SEMANTIC.value: {
+                                "name": "SemanticFacts",
+                                "namespaces": ["/users/{actorId}/facts"],
+                            }
+                        },
+                        {
+                            StrategyType.SUMMARY.value: {
+                                "name": "SessionSummaries",
+                                "namespaces": ["/summaries/{actorId}/{sessionId}"],
+                            }
+                        },
+                    ],
+                    max_wait=30,
+                    poll_interval=5,
+                )
+                memory = existing_memory
+                log.info("✅ LTM strategies added to existing memory")
+            else:
+                memory = existing_memory
+                if agent_config.memory.has_ltm and len(existing_strategies) > 0:
+                    log.info("✅ Using existing memory with %d strategies", len(existing_strategies))
+                else:
+                    log.info("✅ Using existing STM-only memory")
+        else:
+            # Create new memory with appropriate strategies
+            strategies = []
+            if agent_config.memory.has_ltm:
+                log.info("Creating new memory with LTM strategies...")
+                strategies = [
+                    {
+                        StrategyType.USER_PREFERENCE.value: {
+                            "name": "UserPreferences",
+                            "namespaces": ["/users/{actorId}/preferences"],
+                        }
+                    },
+                    {
+                        StrategyType.SEMANTIC.value: {
+                            "name": "SemanticFacts",
+                            "namespaces": ["/users/{actorId}/facts"],
+                        }
+                    },
+                    {
+                        StrategyType.SUMMARY.value: {
+                            "name": "SessionSummaries",
+                            "namespaces": ["/summaries/{actorId}/{sessionId}"],
+                        }
+                    },
+                ]
+            else:
+                log.info("Creating new STM-only memory...")
+
+            # Use private method to avoid waiting
+            memory = memory_manager._create_memory(
+                name=memory_name,
+                description=f"Memory for agent {agent_name} with {'STM+LTM' if strategies else 'STM only'}",
+                strategies=strategies,
+                event_expiry_days=agent_config.memory.event_expiry_days or 30,
+                memory_execution_role_arn=None,
+            )
+            log.info("✅ New memory created: %s (provisioning in background)", memory.id)
+
+        # Save memory configuration
+        agent_config.memory.memory_id = memory.id
+        agent_config.memory.memory_arn = memory.arn
+        agent_config.memory.memory_name = memory_name
+        agent_config.memory.first_invoke_memory_check_done = False
+
+        project_config.agents[agent_config.name] = agent_config
+        save_config(project_config, config_path)
+
+        return memory.id
+
+    except Exception as e:
+        log.error("Memory creation failed: %s", str(e))
+        log.warning("Continuing without memory.")
+        return None
+
+
 def _deploy_to_bedrock_agentcore(
     agent_config: BedrockAgentCoreAgentSchema,
     project_config: BedrockAgentCoreConfigSchema,
@@ -144,6 +283,16 @@ def _deploy_to_bedrock_agentcore(
     """Deploy agent to Bedrock AgentCore with retry logic for role validation."""
     log.info("Deploying to Bedrock AgentCore...")
 
+    # Prepare environment variables
+    if env_vars is None:
+        env_vars = {}
+
+    # Add memory configuration to env_vars if it exists
+    if agent_config.memory and agent_config.memory.memory_id:
+        env_vars["BEDROCK_AGENTCORE_MEMORY_ID"] = agent_config.memory.memory_id
+        env_vars["BEDROCK_AGENTCORE_MEMORY_NAME"] = agent_config.memory.memory_name
+        log.info("Passing memory configuration to agent: %s", agent_config.memory.memory_id)
+
     bedrock_agentcore_client = BedrockAgentCoreClient(region)
 
     # Transform network configuration to AWS API format
@@ -277,6 +426,18 @@ def launch_bedrock_agentcore(
     project_config = load_config(config_path)
     agent_config = project_config.get_agent_config(agent_name)
 
+    if env_vars is None:
+        env_vars = {}
+
+    # Ensure memory exists for non-CodeBuild paths
+    if not use_codebuild:
+        _ensure_memory_for_agent(agent_config, project_config, config_path, agent_config.name)
+
+    # Add memory configuration to environment variables if available
+    if agent_config.memory and agent_config.memory.memory_id:
+        env_vars["BEDROCK_AGENTCORE_MEMORY_ID"] = agent_config.memory.memory_id
+        env_vars["BEDROCK_AGENTCORE_MEMORY_NAME"] = agent_config.memory.memory_name
+
     # Handle CodeBuild deployment (but not for local mode)
     if use_codebuild and not local:
         return _launch_with_codebuild(
@@ -491,6 +652,9 @@ def _launch_with_codebuild(
     env_vars: Optional[dict] = None,
 ) -> LaunchResult:
     """Launch using CodeBuild for ARM64 builds."""
+    # Create memory if configured
+    _ensure_memory_for_agent(agent_config, project_config, config_path, agent_name)
+
     # Execute shared CodeBuild workflow with full deployment mode
     build_id, ecr_uri, region, account_id = _execute_codebuild_workflow(
         config_path=config_path,

bedrock_agentcore_starter_toolkit/operations/runtime/models.py

@@ -21,6 +21,7 @@ class ConfigureResult(BaseModel):
     execution_role: Optional[str] = Field(None, description="AWS execution role ARN")
     ecr_repository: Optional[str] = Field(None, description="ECR repository URI")
     auto_create_ecr: bool = Field(False, description="Whether ECR will be auto-created")
+    memory_id: Optional[str] = Field(default=None, description="Memory resource ID if created")
 
 
 # Launch operation models
@@ -69,6 +70,12 @@ class StatusConfigInfo(BaseModel):
     ecr_repository: Optional[str] = Field(None, description="ECR repository URI")
     agent_id: Optional[str] = Field(None, description="BedrockAgentCore agent ID")
     agent_arn: Optional[str] = Field(None, description="BedrockAgentCore agent ARN")
+    memory_id: Optional[str] = Field(None, description="Memory resource ID")
+    memory_status: Optional[str] = Field(None, description="Memory provisioning status (CREATING/ACTIVE/FAILED)")
+    memory_type: Optional[str] = Field(None, description="Memory type (STM or STM+LTM)")
+    memory_enabled: Optional[bool] = Field(None, description="Whether memory is enabled")
+    memory_strategies: Optional[List[str]] = Field(None, description="Active memory strategies")
+    memory_details: Optional[Dict[str, Any]] = Field(None, description="Detailed memory resource information")
 
 
 class StatusResult(BaseModel):

bedrock_agentcore_starter_toolkit/operations/runtime/status.py

@@ -38,6 +38,68 @@ def get_status(config_path: Path, agent_name: Optional[str] = None) -> StatusRes
         agent_arn=agent_config.bedrock_agentcore.agent_arn,
     )
 
+    if agent_config.memory and agent_config.memory.memory_id:
+        try:
+            from ...operations.memory.manager import MemoryManager
+
+            memory_manager = MemoryManager(region_name=agent_config.aws.region)
+
+            # Get full memory details
+            memory_status = memory_manager.get_memory_status(agent_config.memory.memory_id)
+            memory = memory_manager.get_memory(agent_config.memory.memory_id)
+            strategies = memory_manager.get_memory_strategies(agent_config.memory.memory_id)
+
+            # Build detailed memory info
+            memory_details = {
+                "id": memory.get("id"),
+                "name": memory.get("name"),
+                "status": memory_status,
+                "description": memory.get("description"),
+                "event_expiry_days": memory.get("eventExpiryDuration"),
+                "created_at": memory.get("createdAt"),
+                "updated_at": memory.get("updatedAt"),
+                "strategies": [],
+            }
+
+            # Get strategy details
+            for strategy in strategies:
+                strategy_info = {
+                    "id": strategy.get("strategyId"),
+                    "name": strategy.get("name"),
+                    "type": strategy.get("type"),
+                    "status": strategy.get("status"),
+                    "namespaces": strategy.get("namespaces", []),
+                }
+                memory_details["strategies"].append(strategy_info)
+
+            # Set the status info fields
+            if memory_status == "ACTIVE":
+                if strategies and len(strategies) > 0:
+                    config_info.memory_type = f"STM+LTM ({len(strategies)} strategies)"
+                else:
+                    config_info.memory_type = "STM only"
+                config_info.memory_enabled = True
+            elif memory_status in ["CREATING", "UPDATING"]:
+                if agent_config.memory.has_ltm:
+                    config_info.memory_type = "STM+LTM (provisioning...)"
+                else:
+                    config_info.memory_type = "STM (provisioning...)"
+                config_info.memory_enabled = False
+            else:
+                config_info.memory_type = f"Error ({memory_status})"
+                config_info.memory_enabled = False
+
+            config_info.memory_id = agent_config.memory.memory_id
+            config_info.memory_status = memory_status
+
+            # Add the detailed memory info to config_info
+            # You'll need to add this field to StatusConfigInfo model
+            config_info.memory_details = memory_details
+
+        except Exception as e:
+            config_info.memory_type = f"Error checking: {str(e)}"
+            config_info.memory_enabled = False
+
     # Initialize status result
     agent_details = None
     endpoint_details = None

bedrock_agentcore_starter_toolkit/utils/runtime/container.py

@@ -108,6 +108,8 @@ class ContainerRuntime:
         aws_region: Optional[str] = None,
         enable_observability: bool = True,
         requirements_file: Optional[str] = None,
+        memory_id: Optional[str] = None,
+        memory_name: Optional[str] = None,
     ) -> Path:
         """Generate Dockerfile from template."""
         current_platform = self._get_current_platform()
@@ -164,6 +166,8 @@ class ContainerRuntime:
             "aws_region": aws_region,
             "system_packages": [],
             "observability_enabled": enable_observability,
+            "memory_id": memory_id,
+            "memory_name": memory_name,
         }
 
         dockerfile_path = output_dir / "Dockerfile"

bedrock_agentcore_starter_toolkit/utils/runtime/schema.py

@@ -1,10 +1,35 @@
 """Typed configuration schema for Bedrock AgentCore SDK."""
 
-from typing import Dict, List, Optional
+from typing import Dict, List, Literal, Optional
 
 from pydantic import BaseModel, Field, field_validator
 
 
+class MemoryConfig(BaseModel):
+    """Memory configuration for BedrockAgentCore."""
+
+    mode: Literal["STM_ONLY", "STM_AND_LTM"] = Field(
+        default="STM_ONLY", description="Memory mode - always has STM, optionally adds LTM"
+    )
+    memory_id: Optional[str] = Field(default=None, description="Memory resource ID")
+    memory_arn: Optional[str] = Field(default=None, description="Memory resource ARN")
+    memory_name: Optional[str] = Field(default=None, description="Memory name")
+    event_expiry_days: int = Field(default=30, description="Event expiry duration in days")
+    first_invoke_memory_check_done: bool = Field(
+        default=False, description="Whether first invoke memory check has been performed"
+    )
+
+    @property
+    def is_enabled(self) -> bool:
+        """Check if memory is enabled (always true now)."""
+        return True
+
+    @property
+    def has_ltm(self) -> bool:
+        """Check if LTM is enabled."""
+        return self.mode == "STM_AND_LTM"
+
+
 class NetworkConfiguration(BaseModel):
     """Network configuration for BedrockAgentCore deployment."""
 
@@ -80,6 +105,7 @@ class BedrockAgentCoreAgentSchema(BaseModel):
     aws: AWSConfig = Field(default_factory=AWSConfig)
     bedrock_agentcore: BedrockAgentCoreDeploymentInfo = Field(default_factory=BedrockAgentCoreDeploymentInfo)
     codebuild: CodeBuildConfig = Field(default_factory=CodeBuildConfig)
+    memory: MemoryConfig = Field(default_factory=MemoryConfig)
     authorizer_configuration: Optional[dict] = Field(default=None, description="JWT authorizer configuration")
     request_header_configuration: Optional[dict] = Field(default=None, description="Request header configuration")
     oauth_configuration: Optional[dict] = Field(default=None, description="Oauth configuration")

bedrock_agentcore_starter_toolkit/utils/runtime/templates/Dockerfile.j2

@@ -1,8 +1,15 @@
 FROM ghcr.io/astral-sh/uv:python{{ python_version }}-bookworm-slim
 WORKDIR /app
 
-# Configure UV for container environment
-ENV UV_SYSTEM_PYTHON=1 UV_COMPILE_BYTECODE=1
+# All environment variables in one layer
+ENV UV_SYSTEM_PYTHON=1 \
+    UV_COMPILE_BYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    DOCKER_CONTAINER=1{% if aws_region %} \
+    AWS_REGION={{ aws_region }} \
+    AWS_DEFAULT_REGION={{ aws_region }}{% endif %}{% if memory_id %} \
+    BEDROCK_AGENTCORE_MEMORY_ID={{ memory_id }}{% endif %}{% if memory_name %} \
+    BEDROCK_AGENTCORE_MEMORY_NAME={{ memory_name }}{% endif %}
 
 {% if dependencies_file %}
 {% if dependencies_install_path %}

bedrock_agentcore_starter_toolkit/utils/runtime/templates/execution_role_policy.json.j2

@@ -120,6 +120,16 @@
         "arn:aws:bedrock-agentcore:{{ region }}:{{ account_id }}:workload-identity-directory/default/workload-identity/{{ agent_name }}-*"
       ]
     },
+    {
+      "Sid": "BedrockAgentCoreIdentityGetCredentialProviderClientSecret",
+      "Effect": "Allow",
+      "Action": [
+        "secretsmanager:GetSecretValue"
+      ],
+      "Resource": [
+        "arn:aws:secretsmanager:{{ region }}:{{ account_id }}:secret:bedrock-agentcore-identity!default/oauth2/*"
+      ]
+    },
     {
       "Sid": "BedrockAgentCoreIdentityGetResourceOauth2Token",
       "Effect": "Allow",
@@ -156,8 +166,29 @@
       ],
       "Resource": [
         "arn:aws:bedrock:*::foundation-model/*",
+        "arn:aws:bedrock:*:*:inference-profile/*",
         "arn:aws:bedrock:{{ region }}:{{ account_id }}:*"
       ]
+    },
+    {
+      "Sid": "BedrockAgentCoreCodeInterpreter",
+      "Effect": "Allow",
+      "Action": [
+        "bedrock-agentcore:CreateCodeInterpreter",
+        "bedrock-agentcore:StartCodeInterpreterSession",
+        "bedrock-agentcore:InvokeCodeInterpreter",
+        "bedrock-agentcore:StopCodeInterpreterSession",
+        "bedrock-agentcore:DeleteCodeInterpreter",
+        "bedrock-agentcore:ListCodeInterpreters",
+        "bedrock-agentcore:GetCodeInterpreter",
+        "bedrock-agentcore:GetCodeInterpreterSession",
+        "bedrock-agentcore:ListCodeInterpreterSessions"
+      ],
+      "Resource": [
+        "arn:aws:bedrock-agentcore:{{ region }}:aws:code-interpreter/*",
+        "arn:aws:bedrock-agentcore:{{ region }}:{{ account_id }}:code-interpreter/*",
+        "arn:aws:bedrock-agentcore:{{ region }}:{{ account_id }}:code-interpreter-custom/*"
+      ]
     }
   ]
 }

{bedrock_agentcore_starter_toolkit-0.1.14.dist-info → bedrock_agentcore_starter_toolkit-0.1.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bedrock-agentcore-starter-toolkit
-Version: 0.1.14
+Version: 0.1.15
 Summary: A starter toolkit for using Bedrock AgentCore
 Project-URL: Homepage, https://github.com/aws/bedrock-agentcore-starter-toolkit
 Project-URL: Bug Tracker, https://github.com/aws/bedrock-agentcore-starter-toolkit/issues

{bedrock_agentcore_starter_toolkit-0.1.14.dist-info → bedrock_agentcore_starter_toolkit-0.1.15.dist-info}/RECORD

@@ -9,8 +9,8 @@ bedrock_agentcore_starter_toolkit/cli/import_agent/__init__.py,sha256=tyM3dXM3Tc
 bedrock_agentcore_starter_toolkit/cli/import_agent/agent_info.py,sha256=CcPXbKNnI9fc7NyFmZBjB3PkB0wAz2Q_kBGoUVcnngA,9736
 bedrock_agentcore_starter_toolkit/cli/import_agent/commands.py,sha256=vpA66fGwKf6cxBelT3Yb_Af5Ow3AMquGLIDe-tBLjmc,22419
 bedrock_agentcore_starter_toolkit/cli/runtime/__init__.py,sha256=0zKPPoYThoDIr3DZhIQJavq5nVTKRsgcE1s9--wx118,60
-bedrock_agentcore_starter_toolkit/cli/runtime/commands.py,sha256=BHjIr_S9UcddnLuK7exwgMSJTJxKmbaJfiJZtBrE9PY,49310
-bedrock_agentcore_starter_toolkit/cli/runtime/configuration_manager.py,sha256=ye0Dr-Hf6LUyJGU0TAFFXIDmBru0rqmAxSl389IIKkk,8875
+bedrock_agentcore_starter_toolkit/cli/runtime/commands.py,sha256=0k86wtUZmSPZA4w6jpmMRYjKpSU0XosWljkVwWpt4yc,51234
+bedrock_agentcore_starter_toolkit/cli/runtime/configuration_manager.py,sha256=72UVvnzD3aqaOBNhIMMHjNN5-mgR2oUnnWyA33oFoLM,14602
 bedrock_agentcore_starter_toolkit/notebook/__init__.py,sha256=wH1ZzIVKsKT_P0qX2kIIoyVxeHj8K40odfR1YI3McHw,129
 bedrock_agentcore_starter_toolkit/notebook/runtime/__init__.py,sha256=DoGfB_uGFLANJVE9rSZtTH3ymw76WBWmD9vORvBIdXs,66
 bedrock_agentcore_starter_toolkit/notebook/runtime/bedrock_agentcore.py,sha256=ywtwvcVGX4l7cmsLgkgw7KeL3Fx1HfRCE3dIuds7CZk,15544
@@ -21,21 +21,30 @@ bedrock_agentcore_starter_toolkit/operations/gateway/constants.py,sha256=0_4J6BN
 bedrock_agentcore_starter_toolkit/operations/gateway/create_lambda.py,sha256=MQsBJfUj26zBh7LqYWLoekHuvbAHIJE8qcXwrmJOhM0,2875
 bedrock_agentcore_starter_toolkit/operations/gateway/create_role.py,sha256=Oma9s6K4T9EFgwPAUDungDL9fGa3W0LsHBknIXUmSpI,4474
 bedrock_agentcore_starter_toolkit/operations/gateway/exceptions.py,sha256=WjsrE7lT2708CJniM_ISMzkfNX4IUteGgvOxleD9JZY,272
+bedrock_agentcore_starter_toolkit/operations/memory/README.md,sha256=ruf0ljBArKPe_C_DFQr0cxmXiUpagkfkGfAfa8qvd1k,31213
 bedrock_agentcore_starter_toolkit/operations/memory/__init__.py,sha256=PAj25QAlnlvjaQIgfIpfxXXVXu5BTOXy-xDMDh6_HIc,59
-bedrock_agentcore_starter_toolkit/operations/memory/constants.py,sha256=E7jBvcXAHXoj9jOlpkN1bpoUqMsb-Ji-NQie6P1eIoQ,3583
-bedrock_agentcore_starter_toolkit/operations/memory/manager.py,sha256=OJG3uOhRH9LuXlAL317nL8FbhOr1uiboxXgagyBzj7A,35708
+bedrock_agentcore_starter_toolkit/operations/memory/constants.py,sha256=0HWpxJZXmnmekIEW5TJjn9KmEqVi_REJzUN1l68ohYQ,3226
+bedrock_agentcore_starter_toolkit/operations/memory/manager.py,sha256=EwwNInqlIU3_d3dIphzp5ylNEEWISDduhlmjHkXrioA,44514
+bedrock_agentcore_starter_toolkit/operations/memory/strategy_validator.py,sha256=loMZj7BBvyDjaFfLkpfEaOdbqi_zw2pL2sZChze-Jj4,17972
 bedrock_agentcore_starter_toolkit/operations/memory/models/DictWrapper.py,sha256=GtPnR2NoZ9BXZX4fFYupG97T-YEet2NrBFlaDZIS-gM,1693
 bedrock_agentcore_starter_toolkit/operations/memory/models/Memory.py,sha256=As1b9al57zlYWUAHcwIuHjL-6QAsfH_zhxD8xU9gh3I,424
 bedrock_agentcore_starter_toolkit/operations/memory/models/MemoryStrategy.py,sha256=CnVfWqrSWefSxK5Oh1jllZRr1_JTnUvROLuuqTVVlWM,478
 bedrock_agentcore_starter_toolkit/operations/memory/models/MemorySummary.py,sha256=H5Itj_R3XKaUHJk4_8N_ViAfwkI-9wDhBrmOQq570Sw,469
+bedrock_agentcore_starter_toolkit/operations/memory/models/__init__.py,sha256=zyBO5bICw6otL528wNwkNl1BJ8BLyW0BfoVyD5hepbQ,2997
+bedrock_agentcore_starter_toolkit/operations/memory/models/strategies/__init__.py,sha256=rn9PQKaNkxQrSSWJ_QLST9XjAkcL8rSyWg1w8kvLf7I,1617
+bedrock_agentcore_starter_toolkit/operations/memory/models/strategies/base.py,sha256=9CWKNBBe3yI3xtdMhN1K8z9_0NWIsypkuwiQDi_Fzls,2625
+bedrock_agentcore_starter_toolkit/operations/memory/models/strategies/custom.py,sha256=6PSRoY2DTMca1Lb40b9YC5nCRZblkFVarvTP3qRDuXU,7544
+bedrock_agentcore_starter_toolkit/operations/memory/models/strategies/semantic.py,sha256=Dp5L_zSojst8YSWRDMolFIbfQ72vqEeFlK9sPJKQ_I4,1073
+bedrock_agentcore_starter_toolkit/operations/memory/models/strategies/summary.py,sha256=X0sVh-6Hw9PPnpPQucG_M7gVyXUiElZInFXBN8WDFUQ,1015
+bedrock_agentcore_starter_toolkit/operations/memory/models/strategies/user_preference.py,sha256=JJPAzt_Shix5a-RJEf7xOEzN5kxtX3dpP8xoMvry61U,996
 bedrock_agentcore_starter_toolkit/operations/runtime/__init__.py,sha256=0jRUuwSoqh4R_WqzfP4XAXngrgyFK5uH8JGXUVars6Y,793
-bedrock_agentcore_starter_toolkit/operations/runtime/configure.py,sha256=MI-5jJDYzd0BsRdaWzVMa_eoYvOVo89533B-4gSmY7Y,10484
+bedrock_agentcore_starter_toolkit/operations/runtime/configure.py,sha256=IOvuxMRkzQ_kPfHMvcRURoUn1tvLn13Xd0QgO1x6Kw0,12806
 bedrock_agentcore_starter_toolkit/operations/runtime/create_role.py,sha256=1-b_wBvkOXNh-HJsxATwHfXQqj0dpdETds0FNSTY0BE,16116
-bedrock_agentcore_starter_toolkit/operations/runtime/destroy.py,sha256=XuQQ_fBetQxanIZQx5MMvKYQGbaUHqU9JwJXZOeraco,23541
-bedrock_agentcore_starter_toolkit/operations/runtime/invoke.py,sha256=QduqWCu4Buszcg50IKCkNHxbUMERf4CXb3bX4YP_9Ew,4764
-bedrock_agentcore_starter_toolkit/operations/runtime/launch.py,sha256=o5SEVCIFKJKcGrcraKMyuLL9-4dBY0LoLsTyIVWk3ZI,20009
-bedrock_agentcore_starter_toolkit/operations/runtime/models.py,sha256=iSpD6Zc-FyS4Fu_oRzXzre4N9uYuzBMDkvZZx4MhBGE,4220
-bedrock_agentcore_starter_toolkit/operations/runtime/status.py,sha256=tpOtzAq1S3z_7baxR_WOT8Avo3MtWKGpelVOOfb-uMA,2516
+bedrock_agentcore_starter_toolkit/operations/runtime/destroy.py,sha256=w80NppiAFEQefrQpBoF4YBL2pCreKM_TFNYG68irdYs,25147
+bedrock_agentcore_starter_toolkit/operations/runtime/invoke.py,sha256=49bfVSGICisXlOiqtFc6vUfd24z3ibQxPPeZy1QMoWw,6764
+bedrock_agentcore_starter_toolkit/operations/runtime/launch.py,sha256=k4wVd7_Li8ZpuZgNOauVWjwQ_sRft0OuF9Db89fLC1o,27046
+bedrock_agentcore_starter_toolkit/operations/runtime/models.py,sha256=TdUS-O1crCGmigKb_N3WaLBeubsuFiUczyZktzcAHjY,4894
+bedrock_agentcore_starter_toolkit/operations/runtime/status.py,sha256=4lK-zp29rZhdEJpOoRKqRAjXpEGEMdsb-MBTQQHoJiM,5267
 bedrock_agentcore_starter_toolkit/services/__init__.py,sha256=s7QtYYFCCX2ff0gZHUdDxCDI3zhUq0fPsjevZbF9xdA,66
 bedrock_agentcore_starter_toolkit/services/codebuild.py,sha256=-ys84zixz2Y4g3kATnITrQ5cjREU_aZjjgMc3D_giFU,14311
 bedrock_agentcore_starter_toolkit/services/ecr.py,sha256=nW9wIZcXI6amZeLVSmM9F6awVBQP1-zrFXTozSNEDjo,2805
@@ -54,18 +63,18 @@ bedrock_agentcore_starter_toolkit/services/import_agent/scripts/bedrock_to_stran
 bedrock_agentcore_starter_toolkit/utils/endpoints.py,sha256=1gIDRd1oO1fymYpiedVit7m6zl5k6N8Ns9N-2ix7ZaE,1153
 bedrock_agentcore_starter_toolkit/utils/logging_config.py,sha256=NtZDyndNKCAbz7jZ0leb13bb3UmjjRUTSVwI8MMlOfw,2191
 bedrock_agentcore_starter_toolkit/utils/runtime/config.py,sha256=qRQid59rD3zJ0d0hcBY4-8R52PNIWEIUt9iR3biuz_c,4495
-bedrock_agentcore_starter_toolkit/utils/runtime/container.py,sha256=wGJLxwT2mhTGPxSoFb6x9lW7Tyz37YghIvSs4jBnO8A,15679
+bedrock_agentcore_starter_toolkit/utils/runtime/container.py,sha256=vrwIIoDCJ_rLLGbJLbLRhjlBzjdVBnR3I0HjuByJQX4,15839
 bedrock_agentcore_starter_toolkit/utils/runtime/entrypoint.py,sha256=d-XjEwvQOdpRHvBGLdIBCs1fgUwNwB0EL_WkcdQXwXQ,5893
 bedrock_agentcore_starter_toolkit/utils/runtime/logs.py,sha256=ZZ9PD4QO0BSms5KphhUb3-6-IPTkmwkY-Zn2AWM9Aew,1601
 bedrock_agentcore_starter_toolkit/utils/runtime/policy_template.py,sha256=CgER7YXPh0BpR6JcTcumDL_k8bhmfLSEok1sf09-31I,2054
-bedrock_agentcore_starter_toolkit/utils/runtime/schema.py,sha256=KqNlF8_va5GuOVoUWMN2lT5QenJwgqG_3i_mQ-FPHJw,6533
-bedrock_agentcore_starter_toolkit/utils/runtime/templates/Dockerfile.j2,sha256=VYFZ01c5YUBgU2Qgj1AY0jXkOkjJgTV07Htf2cUp52Q,1269
+bedrock_agentcore_starter_toolkit/utils/runtime/schema.py,sha256=19YP2yd7g5-JdTz-S93iXsrubKo9c6VYpDDtgrh8luU,7590
+bedrock_agentcore_starter_toolkit/utils/runtime/templates/Dockerfile.j2,sha256=fnnw8DsRcda2ZQDvLxAz1RYTml_IMG5q0d0iKn3DB1I,1595
 bedrock_agentcore_starter_toolkit/utils/runtime/templates/dockerignore.template,sha256=b_70sBi0MwkTuA9TqxPqFcWK7TcmpaXBJ6M2Ipox65Q,691
-bedrock_agentcore_starter_toolkit/utils/runtime/templates/execution_role_policy.json.j2,sha256=-0AXT46IYVQr4fwueXTQ0FVXcCshZFNx7-2mViR34Co,4941
+bedrock_agentcore_starter_toolkit/utils/runtime/templates/execution_role_policy.json.j2,sha256=hsYLCgaWMfXuwva90yb1DVEO_HUkIjHHNcPKb60E18k,6180
 bedrock_agentcore_starter_toolkit/utils/runtime/templates/execution_role_trust_policy.json.j2,sha256=PPJF6Ofq70W5DUE0NlbmnZjw5RkgepPgkskxEgEG28o,473
-bedrock_agentcore_starter_toolkit-0.1.14.dist-info/METADATA,sha256=mhElnY7zlazFcm2PZVczfRVbQgLssTeYA8mtmnjK_40,9999
-bedrock_agentcore_starter_toolkit-0.1.14.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-bedrock_agentcore_starter_toolkit-0.1.14.dist-info/entry_points.txt,sha256=Tf94DkUf2Tp8P7p8MEXLxre7A7Pp_XNukteiz0wHnk8,77
-bedrock_agentcore_starter_toolkit-0.1.14.dist-info/licenses/LICENSE.txt,sha256=nNPOMinitYdtfbhdQgsPgz1UowBznU6QVN3Xs0pSTKU,10768
-bedrock_agentcore_starter_toolkit-0.1.14.dist-info/licenses/NOTICE.txt,sha256=rkBsg8DbKqfIoQbveqX9foR4uJPUVAokbkr02pRPilE,8674
-bedrock_agentcore_starter_toolkit-0.1.14.dist-info/RECORD,,
+bedrock_agentcore_starter_toolkit-0.1.15.dist-info/METADATA,sha256=nBSdXlWL9yqQKDkEGlfUXBRL5tUz3wnqjpHlqygOb70,9999
+bedrock_agentcore_starter_toolkit-0.1.15.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+bedrock_agentcore_starter_toolkit-0.1.15.dist-info/entry_points.txt,sha256=Tf94DkUf2Tp8P7p8MEXLxre7A7Pp_XNukteiz0wHnk8,77
+bedrock_agentcore_starter_toolkit-0.1.15.dist-info/licenses/LICENSE.txt,sha256=nNPOMinitYdtfbhdQgsPgz1UowBznU6QVN3Xs0pSTKU,10768
+bedrock_agentcore_starter_toolkit-0.1.15.dist-info/licenses/NOTICE.txt,sha256=rkBsg8DbKqfIoQbveqX9foR4uJPUVAokbkr02pRPilE,8674
+bedrock_agentcore_starter_toolkit-0.1.15.dist-info/RECORD,,