bedrock-agentcore-starter-toolkit 0.1.22__py3-none-any.whl → 0.1.23__py3-none-any.whl

bedrock_agentcore_starter_toolkit/operations/runtime/configure.py

@@ -1,14 +1,16 @@
 """Configure operation - creates BedrockAgentCore configuration and Dockerfile."""
 
 import logging
+import os
 import re
 from pathlib import Path
-from typing import Any, Dict, Optional, Tuple
+from typing import Any, Dict, Literal, Optional, Tuple
 
 from ...cli.runtime.configuration_manager import ConfigurationManager
 from ...services.ecr import get_account_id, get_region
 from ...utils.runtime.config import merge_agent_config, save_config
 from ...utils.runtime.container import ContainerRuntime
+from ...utils.runtime.entrypoint import detect_dependencies
 from ...utils.runtime.schema import (
     AWSConfig,
     BedrockAgentCoreAgentSchema,
@@ -24,6 +26,103 @@ from .models import ConfigureResult
 log = logging.getLogger(__name__)
 
 
+def get_relative_path(path: Path, base: Optional[Path] = None) -> str:
+    """Convert path to relative format with OS-native separators.
+
+    Args:
+        path: Absolute or relative path
+        base: Base directory (defaults to current working directory)
+
+    Returns:
+        Path relative to base with OS-native separators
+
+    Raises:
+        ValueError: If path is empty or invalid
+    """
+    # Validate input
+    if not path or str(path).strip() == "":
+        raise ValueError("Path cannot be empty")
+
+    # Ensure path is a Path object
+    path_obj = Path(path) if not isinstance(path, Path) else path
+    base = base or Path.cwd()
+
+    try:
+        rel_path = path_obj.relative_to(base)
+        return str(rel_path)
+    except ValueError:
+        # Path is outside base - keep full path for clarity
+        # Don't lose directory structure by showing just the filename
+        return str(path_obj)
+
+
+def detect_entrypoint(source_path: Path) -> Optional[Path]:
+    """Detect entrypoint file in source directory.
+
+    Args:
+        source_path: Directory to search for entrypoint
+
+    Returns:
+        Path to detected entrypoint file, or None if not found
+    """
+    ENTRYPOINT_CANDIDATES = ["agent.py", "app.py", "main.py", "__main__.py"]
+
+    source_dir = Path(source_path)
+    for candidate in ENTRYPOINT_CANDIDATES:
+        candidate_path = source_dir / candidate
+        if candidate_path.exists():
+            log.debug("Detected entrypoint: %s", candidate_path)
+            return candidate_path
+
+    log.debug("No entrypoint found in %s", source_path)
+    return None
+
+
+def detect_requirements(source_path: Path):
+    """Detect requirements file in the source directory.
+
+    Args:
+        source_path: Source directory (where entrypoint is located)
+
+    Returns:
+        DependencyInfo object with detection results
+    """
+    # Resolve to absolute path for consistent behavior
+    source_path_resolved = Path(source_path).resolve()
+    log.debug("Checking for requirements in source directory: %s", source_path_resolved)
+
+    deps = detect_dependencies(source_path_resolved)
+    if deps.found:
+        log.debug("Found requirements in source directory: %s", deps.resolved_path)
+    else:
+        log.debug("No requirements file found in source directory: %s", source_path_resolved)
+
+    return deps
+
+
+def infer_agent_name(entrypoint_path: Path, base: Optional[Path] = None) -> str:
+    """Infer agent name from entrypoint path.
+
+    Args:
+        entrypoint_path: Path to agent entrypoint file
+        base: Base directory for relative path (defaults to cwd)
+
+    Returns:
+        Suggested agent name (e.g., 'agents_writer_main' from 'agents/writer/main.py')
+    """
+    rel_entrypoint = get_relative_path(entrypoint_path, base)
+
+    # Remove .py extension if present (only at the end)
+    if rel_entrypoint.endswith(".py"):
+        rel_entrypoint = rel_entrypoint[:-3]
+
+    # Replace spaces and OS path separators with underscores
+    suggested_name = rel_entrypoint.replace(" ", "_").replace(os.sep, "_")
+
+    log.debug("Inferred agent name: %s from %s", suggested_name, get_relative_path(entrypoint_path, base))
+    return suggested_name
+
+
 def configure_bedrock_agentcore(
     agent_name: str,
     entrypoint_path: Path,
@@ -34,6 +133,7 @@ def configure_bedrock_agentcore(
     auto_create_ecr: bool = True,
     auto_create_execution_role: bool = True,
     enable_observability: bool = True,
+    memory_mode: Literal["NO_MEMORY", "STM_ONLY", "STM_AND_LTM"] = "STM_ONLY",
     requirements_file: Optional[str] = None,
     authorizer_configuration: Optional[Dict[str, Any]] = None,
     request_header_configuration: Optional[Dict[str, Any]] = None,
@@ -55,6 +155,7 @@ def configure_bedrock_agentcore(
         auto_create_ecr: Whether to auto-create ECR repository
         auto_create_execution_role: Whether to auto-create execution role if not provided
         enable_observability: Whether to enable observability
+        memory_mode: Memory configuration mode - "NO_MEMORY", "STM_ONLY" (default), or "STM_AND_LTM"
         requirements_file: Path to requirements file
         authorizer_configuration: JWT authorizer configuration dictionary
         request_header_configuration: Request header configuration dictionary
@@ -121,32 +222,52 @@ def configure_bedrock_agentcore(
             else:
                 log.debug("No execution role provided and auto-create disabled")
 
-    if verbose:
-        log.debug("Prompting for memory configuration")
-
+    # Pass region to ConfigurationManager so it can check for existing memories
     config_manager = ConfigurationManager(build_dir / ".bedrock_agentcore.yaml", non_interactive)
 
-    # New memory selection flow
-    action, value = config_manager.prompt_memory_selection()
-
+    # Handle memory configuration
     memory_config = MemoryConfig()
-    if action == "USE_EXISTING":
-        # Using existing memory - just store the ID
-        memory_config.memory_id = value
-        memory_config.mode = "STM_AND_LTM"  # Assume existing has strategies
-        memory_config.memory_name = f"{agent_name}_memory"
-        log.info("Using existing memory resource: %s", value)
-    elif action == "CREATE_NEW":
-        # Create new with specified mode
-        memory_config.mode = value  # This is the mode (STM_ONLY, STM_AND_LTM, NO_MEMORY)
+
+    # Check if memory is explicitly disabled FIRST (works in both interactive and non-interactive modes)
+    if memory_mode == "NO_MEMORY":
+        memory_config.mode = "NO_MEMORY"
+        log.info("Memory disabled")
+    elif non_interactive:
+        # Non-interactive mode: use explicit memory_mode parameter
+        memory_config.mode = memory_mode
         memory_config.event_expiry_days = 30
         memory_config.memory_name = f"{agent_name}_memory"
-        log.info("Will create new memory with mode: %s", value)
+        log.info("Will create new memory with mode: %s", memory_mode)
 
-    if memory_config.mode == "STM_AND_LTM":
-        log.info("Memory configuration: Short-term + Long-term memory enabled")
-    elif memory_config.mode == "STM_ONLY":
-        log.info("Memory configuration: Short-term memory only")
+        if memory_mode == "STM_AND_LTM":
+            log.info("Memory configuration: Short-term + Long-term memory enabled")
+        else:  # STM_ONLY
+            log.info("Memory configuration: Short-term memory only")
+    else:
+        # Interactive mode: prompt user (only if memory not explicitly disabled)
+        action, value = config_manager.prompt_memory_selection()
+
+        if action == "USE_EXISTING":
+            # Using existing memory - just store the ID
+            memory_config.memory_id = value
+            memory_config.mode = "STM_AND_LTM"  # Assume existing has strategies
+            memory_config.memory_name = f"{agent_name}_memory"
+            log.info("Using existing memory resource: %s", value)
+        elif action == "CREATE_NEW":
+            # Create new with specified mode
+            memory_config.mode = value
+            memory_config.event_expiry_days = 30
+            memory_config.memory_name = f"{agent_name}_memory"
+            log.info("Will create new memory with mode: %s", value)
+
+            if value == "STM_AND_LTM":
+                log.info("Memory configuration: Short-term + Long-term memory enabled")
+            else:  # STM_ONLY
+                log.info("Memory configuration: Short-term memory only")
+        elif action == "SKIP":
+            # User chose to skip memory setup
+            memory_config.mode = "NO_MEMORY"
+            log.info("Memory disabled by user choice")
 
     # Check for existing memory configuration from previous launch
     config_path = build_dir / ".bedrock_agentcore.yaml"
@@ -224,7 +345,9 @@ def configure_bedrock_agentcore(
         source_path,
         protocol,
     )
-    log.info("Generated Dockerfile: %s", dockerfile_path)
+    # Log with relative path for better readability
+    rel_dockerfile_path = get_relative_path(Path(dockerfile_path))
+    log.info("Generated Dockerfile: %s", rel_dockerfile_path)
 
     # Ensure .dockerignore exists at Docker build context location
     if source_path:

bedrock_agentcore_starter_toolkit/operations/runtime/destroy.py

@@ -80,7 +80,16 @@ def destroy_bedrock_agentcore(
         _destroy_codebuild_project(session, agent_config, result, dry_run)
 
         # 5. Remove memory resource
-        _destroy_memory(session, agent_config, result, dry_run)
+        if agent_config.memory and agent_config.memory.memory_id and agent_config.memory.mode != "NO_MEMORY":
+            if agent_config.memory.was_created_by_toolkit:
+                # Memory was created by toolkit during configure/launch - delete it
+                _destroy_memory(session, agent_config, result, dry_run)
+                if not dry_run:
+                    log.info("Deleted memory (was created by toolkit): %s", agent_config.memory.memory_id)
+            else:
+                # Memory was pre-existing - preserve it
+                result.warnings.append(f"Memory {agent_config.memory.memory_id} preserved (was pre-existing)")
+                log.info("Preserving pre-existing memory: %s", agent_config.memory.memory_id)
 
         # 6. Remove CodeBuild IAM Role
         _destroy_codebuild_iam_role(session, agent_config, result, dry_run)
@@ -130,10 +139,9 @@ def _destroy_agentcore_endpoint(
             endpoint_name = endpoint_response.get("name", "DEFAULT")
             endpoint_arn = endpoint_response.get("agentRuntimeEndpointArn")
 
-            # Special case: DEFAULT endpoint cannot be explicitly deleted
+            # DEFAULT endpoint is automatically deleted when agent is deleted
             if endpoint_name == "DEFAULT":
-                result.warnings.append("DEFAULT endpoint cannot be explicitly deleted, skipping")
-                log.info("Skipping deletion of DEFAULT endpoint")
+                log.info("DEFAULT endpoint will be automatically deleted with agent")
                 return
 
             if dry_run:
@@ -147,7 +155,13 @@ def _destroy_agentcore_endpoint(
                     result.resources_removed.append(f"AgentCore endpoint: {endpoint_arn}")
                     log.info("Deleted AgentCore endpoint: %s", endpoint_arn)
                 except ClientError as delete_error:
-                    if delete_error.response["Error"]["Code"] not in ["ResourceNotFoundException", "NotFound"]:
+                    error_code = delete_error.response["Error"]["Code"]
+
+                    # Handle ConflictException for DEFAULT endpoint gracefully
+                    if error_code == "ConflictException":
+                        log.info("DEFAULT endpoint will be automatically deleted with agent")
+                        return
+                    elif error_code not in ["ResourceNotFoundException", "NotFound"]:
                         result.errors.append(f"Failed to delete endpoint {endpoint_arn}: {delete_error}")
                         log.error("Failed to delete endpoint: %s", delete_error)
                     else:
@@ -369,7 +383,9 @@ def _destroy_codebuild_project(
     """Remove CodeBuild project for this agent."""
     try:
         codebuild_client = session.client("codebuild", region_name=agent_config.aws.region)
-        project_name = f"bedrock-agentcore-{agent_config.name}-builder"
+        from ...services.ecr import sanitize_ecr_repo_name
+
+        project_name = f"bedrock-agentcore-{sanitize_ecr_repo_name(agent_config.name)}-builder"
 
         if dry_run:
             result.resources_removed.append(f"CodeBuild project: {project_name} (DRY RUN)")

bedrock_agentcore_starter_toolkit/operations/runtime/invoke.py

@@ -30,10 +30,10 @@ def invoke_bedrock_agentcore(
     project_config = load_config(config_path)
     agent_config = project_config.get_agent_config(agent_name)
 
-    # Check memory status on first invoke if LTM is enabled
+    # Check memory status on first invoke if memory is enabled (STM or LTM)
     if (
         agent_config.memory
-        and agent_config.memory.has_ltm
+        and agent_config.memory.mode != "NO_MEMORY"
         and agent_config.memory.memory_id
         and not agent_config.memory.first_invoke_memory_check_done
     ):
@@ -45,10 +45,19 @@ def invoke_bedrock_agentcore(
             memory_status = memory_manager.get_memory_status(agent_config.memory.memory_id)
 
             if memory_status != MemoryStatus.ACTIVE.value:
+                # Determine memory type for better messaging
+                memory_type = "Memory"
+                if agent_config.memory.has_ltm:
+                    memory_type = "Long-term memory"
+                    time_estimate = "60-180 seconds"
+                else:
+                    memory_type = "Short-term memory"
+                    time_estimate = "30-90 seconds"
+
                 # Provide graceful error message
                 error_message = (
                     f"Memory is still provisioning (current status: {memory_status}). "
-                    f"Long-term memory extraction takes 60-180 seconds to activate.\n\n"
+                    f"{memory_type} takes {time_estimate} to activate.\n\n"
                     f"Please wait and check status with:\n"
                     f"  agentcore status{f' --agent {agent_name}' if agent_name else ''}"
                 )

bedrock_agentcore_starter_toolkit/operations/runtime/launch.py

@@ -140,7 +140,13 @@ def _ensure_memory_for_agent(
     """Ensure memory resource exists for agent. Returns memory_id or None.
 
     This function is idempotent - it creates memory if needed or reuses existing.
+    CRITICAL: Never overwrites was_created_by_toolkit flag - that's set by configure.
     """
+    # Check if memory is disabled
+    if agent_config.memory and agent_config.memory.mode == "NO_MEMORY":
+        log.info("Memory disabled - skipping memory creation")
+        return None
+
     # 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)
@@ -158,14 +164,16 @@ def _ensure_memory_for_agent(
         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
+        # Check if memory already exists in cloud
         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)
+                    log.info("Found existing memory in cloud: %s", m.id)
+                    # DO NOT OVERWRITE was_created_by_toolkit flag
+                    # The flag from configure tells us the user's intent
                     break
         except Exception as e:
             log.debug("Error checking for existing memory: %s", e)
@@ -251,9 +259,16 @@ def _ensure_memory_for_agent(
                 event_expiry_days=agent_config.memory.event_expiry_days or 30,
                 memory_execution_role_arn=None,
             )
+
+            # Ensure was_created_by_toolkit is True since we just created it
+            # (Should already be True from configure if user chose CREATE_NEW)
+            if not agent_config.memory.was_created_by_toolkit:
+                log.warning("Memory created but flag was False - correcting to True")
+                agent_config.memory.was_created_by_toolkit = True
+
             log.info("✅ New memory created: %s (provisioning in background)", memory.id)
 
-        # Save memory configuration
+        # Save memory configuration (preserving was_created_by_toolkit flag)
         agent_config.memory.memory_id = memory.id
         agent_config.memory.memory_arn = memory.arn
         agent_config.memory.memory_name = memory_name

bedrock_agentcore_starter_toolkit/operations/runtime/status.py

@@ -38,7 +38,11 @@ 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:
+    # Check if memory is disabled first
+    if agent_config.memory and agent_config.memory.mode == "NO_MEMORY":
+        config_info.memory_type = "Disabled"
+        config_info.memory_enabled = False
+    elif agent_config.memory and agent_config.memory.memory_id:
         try:
             from ...operations.memory.manager import MemoryManager
 
@@ -91,9 +95,6 @@ def get_status(config_path: Path, agent_name: Optional[str] = None) -> StatusRes
 
             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:

bedrock_agentcore_starter_toolkit/services/codebuild.py

@@ -14,6 +14,7 @@ import boto3
 from botocore.exceptions import ClientError
 
 from ..operations.runtime.create_role import get_or_create_codebuild_execution_role
+from .ecr import sanitize_ecr_repo_name
 
 
 class CodeBuildService:
@@ -159,7 +160,7 @@ class CodeBuildService:
         self, agent_name: str, ecr_repository_uri: str, execution_role: str, source_location: str
     ) -> str:
         """Create or update CodeBuild project for ARM64 builds."""
-        project_name = f"bedrock-agentcore-{agent_name}-builder"
+        project_name = f"bedrock-agentcore-{sanitize_ecr_repo_name(agent_name)}-builder"
 
         buildspec = self._get_arm64_buildspec(ecr_repository_uri)
 

bedrock_agentcore_starter_toolkit/services/ecr.py

@@ -1,12 +1,54 @@
 """ECR (Elastic Container Registry) service integration."""
 
 import base64
+import re
 
 import boto3
 
 from ..utils.runtime.container import ContainerRuntime
 
 
+def sanitize_ecr_repo_name(name: str) -> str:
+    """Sanitize agent name for ECR repository naming requirements.
+
+    ECR repository names must:
+    - Contain only lowercase letters, numbers, hyphens (-), underscores (_), and forward slashes (/)
+    - Start with a lowercase letter or number
+    - Be between 2 and 256 characters
+
+    Args:
+        name: Agent name to sanitize
+
+    Returns:
+        Sanitized repository name component
+    """
+    # Convert to lowercase
+    name = name.lower()
+
+    # Replace invalid characters with hyphens
+    name = re.sub(r"[^a-z0-9_\-/]", "-", name)
+
+    # Ensure starts with alphanumeric
+    if name and not name[0].isalnum():
+        name = "a" + name  # Prefix with 'a' if starts with non-alphanumeric
+
+    # Remove consecutive hyphens/underscores
+    name = re.sub(r"[-_]{2,}", "-", name)
+
+    # Strip trailing hyphens/underscores
+    name = name.rstrip("-_")
+
+    # Ensure minimum length
+    if len(name) < 2:
+        name = name + "-agent"
+
+    # Truncate if too long (leave room for prefix)
+    if len(name) > 200:
+        name = name[:200].rstrip("-_")
+
+    return name
+
+
 def get_account_id() -> str:
     """Get AWS account ID."""
     return boto3.client("sts").get_caller_identity()["Account"]
@@ -38,8 +80,8 @@ def get_or_create_ecr_repository(agent_name: str, region: str) -> str:
     Returns:
         ECR repository URI
     """
-    # Generate deterministic repository name based on agent name
-    repo_name = f"bedrock-agentcore-{agent_name}"
+    # Generate deterministic repository name based on agent name (sanitized for ECR requirements)
+    repo_name = f"bedrock-agentcore-{sanitize_ecr_repo_name(agent_name)}"
 
     ecr = boto3.client("ecr", region_name=region)
 

bedrock_agentcore_starter_toolkit/utils/runtime/container.py

@@ -44,8 +44,10 @@ class ContainerRuntime:
             else:
                 # Informational message - default CodeBuild deployment works fine
                 console.print("\n💡 [cyan]No container engine found (Docker/Finch/Podman not installed)[/cyan]")
-                _print_success("Default deployment uses CodeBuild (no container engine needed)")
-                console.print("[dim]For local builds, install Docker, Finch, or Podman[/dim]")
+                _print_success(
+                    "Default deployment uses CodeBuild (no container engine needed), "
+                    "For local builds, install Docker, Finch, or Podman"
+                )
                 self.runtime = "none"
                 self.has_local_runtime = False
         elif runtime_type in self.available_runtimes:
@@ -131,9 +133,10 @@ class ContainerRuntime:
 
         if current_platform != required_platform:
             _handle_warn(
-                f"[WARNING] Platform mismatch: Current system is '{current_platform}' "
-                f"but Bedrock AgentCore requires '{required_platform}'.\n"
-                "For deployment options and workarounds, see: "
+                f"Platform mismatch: Current system is '{current_platform}' "
+                f"but Bedrock AgentCore requires '{required_platform}', so local builds won't work.\n"
+                "Please use default launch command which will do a remote cross-platform build using code build."
+                "For deployment other options and workarounds, see: "
                 "https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/getting-started-custom.html\n"
             )
 
@@ -150,9 +153,8 @@ class ContainerRuntime:
         # If source_path provided: module path relative to source_path (Docker build context)
         # Otherwise: module path relative to project root
         build_context_root = Path(source_path) if source_path else output_dir
-
         # Generate .dockerignore if it doesn't exist
-        self._ensure_dockerignore(output_dir)
+        self._ensure_dockerignore(build_context_root)
 
         # Validate module path against build context root
         self._validate_module_path(agent_path, build_context_root)
@@ -167,11 +169,12 @@ class ContainerRuntime:
         # - Otherwise: check project root (output_dir)
         # - If explicit requirements_file provided: use that regardless
         if source_path and not requirements_file:
-            # Check source_path directory for dependencies
             source_dir = Path(source_path)
             deps = detect_dependencies(source_dir, explicit_file=None)
+        if source_path:
+            source_dir = Path(source_path)
+            deps = detect_dependencies(source_dir, explicit_file=requirements_file)
         else:
-            # Check project root for dependencies (or use explicit file)
             deps = detect_dependencies(output_dir, explicit_file=requirements_file)
 
         # Add logic to avoid duplicate installation

bedrock_agentcore_starter_toolkit/utils/runtime/schema.py

@@ -1,6 +1,5 @@
 """Typed configuration schema for Bedrock AgentCore SDK."""
 
-from pathlib import Path
 from typing import Dict, List, Literal, Optional
 
 from pydantic import BaseModel, Field, field_validator
@@ -16,7 +15,7 @@ class NetworkModeConfig(BaseModel):
 class MemoryConfig(BaseModel):
     """Memory configuration for BedrockAgentCore."""
 
-    mode: Literal["STM_ONLY", "STM_AND_LTM"] = Field(
+    mode: Literal["STM_ONLY", "STM_AND_LTM", "NO_MEMORY"] = Field(
         default="STM_ONLY", description="Memory mode - always has STM, optionally adds LTM"
     )
     memory_id: Optional[str] = Field(default=None, description="Memory resource ID")
@@ -26,11 +25,14 @@ class MemoryConfig(BaseModel):
     first_invoke_memory_check_done: bool = Field(
         default=False, description="Whether first invoke memory check has been performed"
     )
+    was_created_by_toolkit: bool = Field(
+        default=False, description="Whether memory was created by toolkit (vs reused existing)"
+    )
 
     @property
     def is_enabled(self) -> bool:
-        """Check if memory is enabled (always true now)."""
-        return True
+        """Check if memory is enabled."""
+        return self.mode != "NO_MEMORY"
 
     @property
     def has_ltm(self) -> bool:
@@ -158,37 +160,6 @@ class BedrockAgentCoreAgentSchema(BaseModel):
     request_header_configuration: Optional[dict] = Field(default=None, description="Request header configuration")
     oauth_configuration: Optional[dict] = Field(default=None, description="Oauth configuration")
 
-    @field_validator("source_path")
-    @classmethod
-    def validate_source_path(cls, v: Optional[str]) -> Optional[str]:
-        """Validate source path if provided.
-
-        Args:
-            v: Source path value
-
-        Returns:
-            Validated source path or None
-
-        Raises:
-            ValueError: If source path is invalid
-        """
-        if v is None:
-            return v
-
-        # Convert to Path for validation
-        source_path = Path(v)
-
-        # Check if path exists
-        if not source_path.exists():
-            raise ValueError(f"Source path does not exist: {v}")
-
-        # Check if it's a directory
-        if not source_path.is_dir():
-            raise ValueError(f"Source path must be a directory: {v}")
-
-        # Return absolute path string
-        return str(source_path.resolve())
-
     def get_authorizer_configuration(self) -> Optional[dict]:
         """Get the authorizer configuration."""
         return self.authorizer_configuration

bedrock_agentcore_starter_toolkit/utils/runtime/templates/Dockerfile.j2

@@ -28,12 +28,6 @@ RUN uv pip install -r {{ dependencies_file }}
 RUN uv pip install aws-opentelemetry-distro>=0.10.1
 {% endif %}
 
-# Set AWS region environment variable
-{% if aws_region %}
-ENV AWS_REGION={{ aws_region }}
-ENV AWS_DEFAULT_REGION={{ aws_region }}
-{% endif %}
-
 # Signal that this is running in Docker for host binding logic
 ENV DOCKER_CONTAINER=1
 

{bedrock_agentcore_starter_toolkit-0.1.22.dist-info → bedrock_agentcore_starter_toolkit-0.1.23.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bedrock-agentcore-starter-toolkit
-Version: 0.1.22
+Version: 0.1.23
 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