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

bedrock_agentcore_starter_toolkit/cli/runtime/commands.py

@@ -68,17 +68,34 @@ def _prompt_for_requirements_file(prompt_text: str, default: str = "") -> Option
     return None
 
 
-def _handle_requirements_file_display(requirements_file: Optional[str], non_interactive: bool = False) -> Optional[str]:
-    """Handle requirements file with display logic for CLI."""
+def _handle_requirements_file_display(
+    requirements_file: Optional[str], non_interactive: bool = False, source_path: Optional[str] = None
+) -> Optional[str]:
+    """Handle requirements file with display logic for CLI.
+
+    Args:
+        requirements_file: Explicit requirements file path
+        non_interactive: Whether to skip interactive prompts
+        source_path: Optional source code directory (checks here first, then falls back to project root)
+    """
     from ...utils.runtime.entrypoint import detect_dependencies
 
     if requirements_file:
         # User provided file - validate and show confirmation
         return _validate_requirements_file(requirements_file)
 
+    # Detect dependencies:
+    # - If source_path provided: check source_path only
+    # - Otherwise: check project root (Path.cwd())
+    if source_path:
+        source_dir = Path(source_path)
+        deps = detect_dependencies(source_dir)
+    else:
+        # No source_path, check project root
+        deps = detect_dependencies(Path.cwd())
+
     if non_interactive:
         # Auto-detection for non-interactive mode
-        deps = detect_dependencies(Path.cwd())
         if deps.found:
             _print_success(f"Using detected file: [dim]{deps.file}[/dim]")
             return None  # Use detected file
@@ -86,8 +103,6 @@ def _handle_requirements_file_display(requirements_file: Optional[str], non_inte
             _handle_error("No requirements file specified and none found automatically")
 
     # Auto-detection with interactive prompt
-    deps = detect_dependencies(Path.cwd())
-
     if deps.found:
         console.print(f"\n🔍 [cyan]Detected dependency file:[/cyan] [bold]{deps.file}[/bold]")
         console.print("[dim]Press Enter to use this file, or type a different path (use Tab for autocomplete):[/dim]")
@@ -190,6 +205,7 @@ def configure(
     non_interactive: bool = typer.Option(
         False, "--non-interactive", "-ni", help="Skip prompts; use defaults unless overridden"
     ),
+    source_path: Optional[str] = typer.Option(None, "--source-path", "-sp", help="Path to agent source code directory"),
 ):
     """Configure a Bedrock AgentCore agent. The agent name defaults to your Python file name."""
     if ctx.invoked_subcommand is not None:
@@ -237,7 +253,7 @@ def configure(
         _print_success(f"Using existing ECR repository: [dim]{ecr_repository}[/dim]")
 
     # Handle dependency file selection with simplified logic
-    final_requirements_file = _handle_requirements_file_display(requirements_file, non_interactive)
+    final_requirements_file = _handle_requirements_file_display(requirements_file, non_interactive, source_path)
 
     # Handle OAuth authorization configuration
     oauth_config = None
@@ -281,6 +297,7 @@ def configure(
             region=region,
             protocol=protocol.upper() if protocol else None,
             non_interactive=non_interactive,
+            source_path=source_path,
         )
 
         # Prepare authorization info for summary

bedrock_agentcore_starter_toolkit/cli/runtime/configuration_manager.py

@@ -304,7 +304,6 @@ class ConfigurationManager:
 
     def _prompt_new_memory_config(self) -> Tuple[str, str]:
         """Prompt for new memory configuration."""
-        console.print("\n🧠 [cyan]Memory Configuration[/cyan]")
         console.print("[green]✓ Short-term memory is enabled by default[/green]")
         console.print("  • Stores conversations within sessions")
         console.print("  • Provides immediate context recall")

bedrock_agentcore_starter_toolkit/notebook/runtime/bedrock_agentcore.py

@@ -44,6 +44,7 @@ class Runtime:
         auto_create_ecr: bool = True,
         auto_create_execution_role: bool = False,
         authorizer_configuration: Optional[Dict[str, Any]] = None,
+        request_header_configuration: Optional[Dict[str, Any]] = None,
         region: Optional[str] = None,
         protocol: Optional[Literal["HTTP", "MCP", "A2A"]] = None,
         disable_otel: bool = False,
@@ -64,6 +65,7 @@ class Runtime:
             auto_create_ecr: Whether to auto-create ECR repository
             auto_create_execution_role: Whether to auto-create execution role (makes execution_role optional)
             authorizer_configuration: JWT authorizer configuration dictionary
+            request_header_configuration: Request header configuration dictionary
             region: AWS region for deployment
             protocol: agent server protocol, must be either HTTP or MCP or A2A
             disable_otel: Whether to disable OpenTelemetry observability (default: False)
@@ -120,6 +122,7 @@ class Runtime:
             enable_observability=not disable_otel,
             requirements_file=final_requirements_file,
             authorizer_configuration=authorizer_configuration,
+            request_header_configuration=request_header_configuration,
             region=region,
             protocol=protocol.upper() if protocol else None,
             non_interactive=non_interactive,

bedrock_agentcore_starter_toolkit/operations/runtime/configure.py

@@ -41,6 +41,7 @@ def configure_bedrock_agentcore(
     region: Optional[str] = None,
     protocol: Optional[str] = None,
     non_interactive: bool = False,
+    source_path: Optional[str] = None,
 ) -> ConfigureResult:
     """Configure Bedrock AgentCore application with deployment settings.
 
@@ -61,6 +62,7 @@ def configure_bedrock_agentcore(
         region: AWS region for deployment
         protocol: agent server protocol, must be either HTTP or MCP or A2A
         non_interactive: Skip interactive prompts and use defaults
+        source_path: Optional path to agent source code directory
 
     Returns:
         ConfigureResult model with configuration details
@@ -73,10 +75,13 @@ def configure_bedrock_agentcore(
         log.setLevel(logging.INFO)
     # Log agent name at the start of configuration
     log.info("Configuring BedrockAgentCore agent: %s", agent_name)
+
+    # Build directory is always project root for module validation and dependency detection
     build_dir = Path.cwd()
 
     if verbose:
         log.debug("Build directory: %s", build_dir)
+        log.debug("Source path: %s", source_path or "None (using build directory)")
         log.debug("Bedrock AgentCore name: %s", agent_name)
         log.debug("Entrypoint path: %s", entrypoint_path)
 
@@ -196,24 +201,48 @@ def configure_bedrock_agentcore(
         if memory_id:
             log.debug("  Memory ID: %s", memory_id)
 
+    # Determine output directory for Dockerfile based on source_path
+    # If source_path provided: write to .bedrock_agentcore/{agent_name}/ directly
+    # Otherwise: write to project root (legacy)
+    if source_path:
+        from ...utils.runtime.config import get_agentcore_directory
+
+        dockerfile_output_dir = get_agentcore_directory(Path.cwd(), agent_name, source_path)
+    else:
+        dockerfile_output_dir = build_dir
+
+    # Generate Dockerfile in the correct location (no moving needed)
     dockerfile_path = runtime.generate_dockerfile(
         entrypoint_path,
-        build_dir,
+        dockerfile_output_dir,
         bedrock_agentcore_name or "bedrock_agentcore",
         region,
         enable_observability,
         requirements_file,
         memory_id,
         memory_name,
+        source_path,
         protocol,
     )
-
-    # Check if .dockerignore was created
-    dockerignore_path = build_dir / ".dockerignore"
-
     log.info("Generated Dockerfile: %s", dockerfile_path)
-    if dockerignore_path.exists():
-        log.info("Generated .dockerignore: %s", dockerignore_path)
+
+    # Ensure .dockerignore exists at Docker build context location
+    if source_path:
+        # For source_path: .dockerignore at source directory (Docker build context)
+        source_dockerignore = Path(source_path) / ".dockerignore"
+        if not source_dockerignore.exists():
+            template_path = (
+                Path(__file__).parent.parent.parent / "utils" / "runtime" / "templates" / "dockerignore.template"
+            )
+            if template_path.exists():
+                source_dockerignore.write_text(template_path.read_text())
+                log.info("Generated .dockerignore: %s", source_dockerignore)
+        dockerignore_path = source_dockerignore
+    else:
+        # Legacy: .dockerignore at project root
+        dockerignore_path = build_dir / ".dockerignore"
+        if dockerignore_path.exists():
+            log.info("Generated .dockerignore: %s", dockerignore_path)
 
     # Handle project configuration (named agents)
     config_path = build_dir / ".bedrock_agentcore.yaml"
@@ -258,6 +287,7 @@ def configure_bedrock_agentcore(
         entrypoint=entrypoint,
         platform=ContainerRuntime.DEFAULT_PLATFORM,
         container_runtime=runtime.runtime,
+        source_path=str(Path(source_path).resolve()) if source_path else None,
         aws=AWSConfig(
             execution_role=execution_role_arn,
             execution_role_auto_create=execution_role_auto_create,

bedrock_agentcore_starter_toolkit/operations/runtime/destroy.py

@@ -11,6 +11,7 @@ from ...operations.memory.manager import MemoryManager
 from ...services.runtime import BedrockAgentCoreClient
 from ...utils.runtime.config import load_config, save_config
 from ...utils.runtime.schema import BedrockAgentCoreAgentSchema, BedrockAgentCoreConfigSchema
+from .exceptions import RuntimeToolkitException
 from .models import DestroyResult
 
 log = logging.getLogger(__name__)
@@ -102,7 +103,7 @@ def destroy_bedrock_agentcore(
 
     except Exception as e:
         log.error("Destroy operation failed: %s", str(e))
-        raise RuntimeError(f"Destroy operation failed: {e}") from e
+        raise RuntimeToolkitException(f"Destroy operation failed: {e}") from e
 
 
 def _destroy_agentcore_endpoint(

bedrock_agentcore_starter_toolkit/operations/runtime/exceptions.py

@@ -0,0 +1,27 @@
+"""Exceptions for the Bedrock AgentCore Runtime module."""
+
+from typing import List, Optional
+
+
+class RuntimeException(Exception):
+    """Base exception for all Runtime SDK errors."""
+
+    pass
+
+
+class RuntimeToolkitException(RuntimeException):
+    """Raised when runtime operations fail with resource tracking."""
+
+    def __init__(self, message: str, created_resources: Optional[List[str]] = None):
+        """Initialize RuntimeToolkitException with optional resource tracking.
+
+        Args:
+            message: Error message
+            created_resources: List of resources created before failure
+        """
+        self.created_resources = created_resources or []
+        if created_resources:
+            full_message = f"{message}. Resources created: {created_resources}"
+        else:
+            full_message = message
+        super().__init__(full_message)

bedrock_agentcore_starter_toolkit/operations/runtime/launch.py

@@ -19,6 +19,7 @@ from ...utils.runtime.container import ContainerRuntime
 from ...utils.runtime.logs import get_genai_observability_url
 from ...utils.runtime.schema import BedrockAgentCoreAgentSchema, BedrockAgentCoreConfigSchema
 from .create_role import get_or_create_runtime_execution_role
+from .exceptions import RuntimeToolkitException
 from .models import LaunchResult
 
 log = logging.getLogger(__name__)
@@ -479,14 +480,24 @@ def launch_bedrock_agentcore(
             "💡 For local builds, please install Docker, Finch, or Podman"
         )
 
-    # Get build context - always use project root (where config and Dockerfile are)
-    build_dir = config_path.parent
+    # Get build context - use source_path if configured, otherwise use project root
+    build_dir = Path(agent_config.source_path) if agent_config.source_path else config_path.parent
+    log.info("Using build directory: %s", build_dir)
 
     bedrock_agentcore_name = agent_config.name
     tag = f"bedrock_agentcore-{bedrock_agentcore_name}:latest"
 
     # Step 1: Build Docker image (only if we need it)
-    success, output = runtime.build(build_dir, tag)
+    # When using source_path, Dockerfile is in .bedrock_agentcore/{agent_name}/ directory
+    from ...utils.runtime.config import get_agentcore_directory
+
+    dockerfile_dir = get_agentcore_directory(config_path.parent, agent_config.name, agent_config.source_path)
+    dockerfile_path = dockerfile_dir / "Dockerfile"
+
+    if not dockerfile_path.exists():
+        raise RuntimeError(f"Dockerfile not found at {dockerfile_path}. Please run 'agentcore configure' first.")
+
+    success, output = runtime.build(build_dir, tag, dockerfile_path=dockerfile_path)
     if not success:
         error_lines = output[-10:] if len(output) > 10 else output
         error_message = " ".join(error_lines)
@@ -573,53 +584,82 @@ def _execute_codebuild_workflow(
         agent_config.aws.account,
         agent_config.aws.region,
     )
-    # Validate configuration
-    errors = agent_config.validate(for_local=False)
-    if errors:
-        raise ValueError(f"Invalid configuration: {', '.join(errors)}")
 
-    region = agent_config.aws.region
-    if not region:
-        raise ValueError("Region not found in configuration")
+    # Track created resources for error context
+    created_resources = []
 
-    session = boto3.Session(region_name=region)
-    account_id = agent_config.aws.account  # Use existing account from config
+    try:
+        # Validate configuration
+        errors = agent_config.validate(for_local=False)
+        if errors:
+            raise ValueError(f"Invalid configuration: {', '.join(errors)}")
+
+        region = agent_config.aws.region
+        if not region:
+            raise ValueError("Region not found in configuration")
+
+        session = boto3.Session(region_name=region)
+        account_id = agent_config.aws.account  # Use existing account from config
+
+        # Setup AWS resources
+        log.info("Setting up AWS resources (ECR repository%s)...", "" if ecr_only else ", execution roles")
+        ecr_uri = _ensure_ecr_repository(agent_config, project_config, config_path, agent_name, region)
+        if ecr_uri:
+            created_resources.append(f"ECR Repository: {ecr_uri}")
+        ecr_repository_arn = f"arn:aws:ecr:{region}:{account_id}:repository/{ecr_uri.split('/')[-1]}"
+
+        # Setup execution role only if not ECR-only mode
+        if not ecr_only:
+            _ensure_execution_role(agent_config, project_config, config_path, agent_name, region, account_id)
+            if agent_config.aws.execution_role:
+                created_resources.append(f"Runtime Execution Role: {agent_config.aws.execution_role}")
+
+        # Prepare CodeBuild
+        log.info("Preparing CodeBuild project and uploading source...")
+        codebuild_service = CodeBuildService(session)
+
+        # Use cached CodeBuild role from config if available
+        if hasattr(agent_config, "codebuild") and agent_config.codebuild.execution_role:
+            log.info("Using CodeBuild role from config: %s", agent_config.codebuild.execution_role)
+            codebuild_execution_role = agent_config.codebuild.execution_role
+        else:
+            codebuild_execution_role = codebuild_service.create_codebuild_execution_role(
+                account_id=account_id, ecr_repository_arn=ecr_repository_arn, agent_name=agent_name
+            )
+            if codebuild_execution_role:
+                created_resources.append(f"CodeBuild Execution Role: {codebuild_execution_role}")
 
-    # Setup AWS resources
-    log.info("Setting up AWS resources (ECR repository%s)...", "" if ecr_only else ", execution roles")
-    ecr_uri = _ensure_ecr_repository(agent_config, project_config, config_path, agent_name, region)
-    ecr_repository_arn = f"arn:aws:ecr:{region}:{account_id}:repository/{ecr_uri.split('/')[-1]}"
+        # Get source directory - use source_path if configured, otherwise use current directory
+        source_dir = str(Path(agent_config.source_path)) if agent_config.source_path else "."
 
-    # Setup execution role only if not ECR-only mode
-    if not ecr_only:
-        _ensure_execution_role(agent_config, project_config, config_path, agent_name, region, account_id)
+        # Get Dockerfile directory - use agentcore directory if source_path provided
+        from ...utils.runtime.config import get_agentcore_directory
 
-    # Prepare CodeBuild
-    log.info("Preparing CodeBuild project and uploading source...")
-    codebuild_service = CodeBuildService(session)
+        dockerfile_dir = get_agentcore_directory(config_path.parent, agent_name, agent_config.source_path)
 
-    # Use cached CodeBuild role from config if available
-    if hasattr(agent_config, "codebuild") and agent_config.codebuild.execution_role:
-        log.info("Using CodeBuild role from config: %s", agent_config.codebuild.execution_role)
-        codebuild_execution_role = agent_config.codebuild.execution_role
-    else:
-        codebuild_execution_role = codebuild_service.create_codebuild_execution_role(
-            account_id=account_id, ecr_repository_arn=ecr_repository_arn, agent_name=agent_name
+        source_location = codebuild_service.upload_source(
+            agent_name=agent_name, source_dir=source_dir, dockerfile_dir=str(dockerfile_dir)
         )
 
-    source_location = codebuild_service.upload_source(agent_name=agent_name)
+        # Use cached project name from config if available
+        if hasattr(agent_config, "codebuild") and agent_config.codebuild.project_name:
+            log.info("Using CodeBuild project from config: %s", agent_config.codebuild.project_name)
+            project_name = agent_config.codebuild.project_name
+        else:
+            project_name = codebuild_service.create_or_update_project(
+                agent_name=agent_name,
+                ecr_repository_uri=ecr_uri,
+                execution_role=codebuild_execution_role,
+                source_location=source_location,
+            )
+            if project_name:
+                created_resources.append(f"CodeBuild Project: {project_name}")
 
-    # Use cached project name from config if available
-    if hasattr(agent_config, "codebuild") and agent_config.codebuild.project_name:
-        log.info("Using CodeBuild project from config: %s", agent_config.codebuild.project_name)
-        project_name = agent_config.codebuild.project_name
-    else:
-        project_name = codebuild_service.create_or_update_project(
-            agent_name=agent_name,
-            ecr_repository_uri=ecr_uri,
-            execution_role=codebuild_execution_role,
-            source_location=source_location,
-        )
+    except Exception as e:
+        if created_resources:
+            log.error("Launch failed after creating the following resources: %s. Error: %s", created_resources, str(e))
+            raise RuntimeToolkitException("Launch failed", created_resources) from e
+        raise
 
     # Execute CodeBuild
     log.info("Starting CodeBuild build (this may take several minutes)...")

bedrock_agentcore_starter_toolkit/services/codebuild.py

@@ -6,8 +6,9 @@ import os
 import tempfile
 import time
 import zipfile
+from importlib.resources import files
 from pathlib import Path
-from typing import List
+from typing import List, Optional
 
 import boto3
 from botocore.exceptions import ClientError
@@ -70,21 +71,28 @@ class CodeBuildService:
 
         return bucket_name
 
-    def upload_source(self, agent_name: str) -> str:
-        """Upload current directory to S3, respecting .dockerignore patterns."""
+    def upload_source(self, agent_name: str, source_dir: str = ".", dockerfile_dir: Optional[str] = None) -> str:
+        """Upload source directory to S3, respecting .dockerignore patterns.
+
+        Args:
+            agent_name: Name of the agent
+            source_dir: Directory to upload (defaults to current directory)
+            dockerfile_dir: Directory containing Dockerfile (may be different from source_dir)
+        """
         account_id = self.account_id
         bucket_name = self.ensure_source_bucket(account_id)
         self.source_bucket = bucket_name
 
-        # Parse .dockerignore patterns
+        # Parse .dockerignore patterns from template for consistent filtering
         ignore_patterns = self._parse_dockerignore()
 
         with tempfile.NamedTemporaryFile(suffix=".zip", delete=False) as temp_zip:
             try:
                 with zipfile.ZipFile(temp_zip.name, "w", zipfile.ZIP_DEFLATED) as zipf:
-                    for root, dirs, files in os.walk("."):
-                        # Convert to relative path
-                        rel_root = os.path.relpath(root, ".")
+                    # First, add all files from source_dir
+                    for root, dirs, files in os.walk(source_dir):
+                        # Convert to relative path from source_dir
+                        rel_root = os.path.relpath(root, source_dir)
                         if rel_root == ".":
                             rel_root = ""
 
@@ -107,6 +115,16 @@ class CodeBuildService:
                             file_path = Path(root) / file
                             zipf.write(file_path, file_rel_path)
 
+                    # If Dockerfile is in a different directory, include it in the zip
+                    if dockerfile_dir and source_dir != dockerfile_dir:
+                        dockerfile_path = Path(dockerfile_dir) / "Dockerfile"
+                        source_dockerfile = Path(source_dir) / "Dockerfile"
+
+                        if dockerfile_path.exists() and not source_dockerfile.exists():
+                            # Include the Dockerfile from dockerfile_dir
+                            zipf.write(dockerfile_path, "Dockerfile")
+                            self.logger.info("Including Dockerfile from %s in source.zip", dockerfile_dir)
+
                 # Create agent-organized S3 key: agentname/source.zip (fixed naming for cache consistency)
                 s3_key = f"{agent_name}/source.zip"
 
@@ -280,21 +298,32 @@ phases:
 """
 
     def _parse_dockerignore(self) -> List[str]:
-        """Parse .dockerignore file and return list of patterns."""
-        dockerignore_path = Path(".dockerignore")
-        patterns = []
-
-        if dockerignore_path.exists():
-            with open(dockerignore_path, "r") as f:
-                for line in f:
-                    line = line.strip()
-                    if line and not line.startswith("#"):
-                        patterns.append(line)
-
-            self.logger.info("Using .dockerignore with %d patterns", len(patterns))
-        else:
-            # Default patterns if no .dockerignore
-            patterns = [
+        """Parse .dockerignore patterns from template for consistent filtering.
+
+        Always uses the dockerignore.template to ensure consistent file filtering
+        during zip creation, regardless of source_path configuration.
+        """
+        # Use dockerignore.template from package resources
+        try:
+            template_content = (
+                files("bedrock_agentcore_starter_toolkit")
+                .joinpath("utils/runtime/templates/dockerignore.template")
+                .read_text()
+            )
+
+            patterns = []
+            for line in template_content.splitlines():
+                line = line.strip()
+                if line and not line.startswith("#"):
+                    patterns.append(line)
+
+            self.logger.info("Using dockerignore.template with %d patterns for zip filtering", len(patterns))
+            return patterns
+
+        except Exception as e:
+            # Fallback to minimal default patterns if template not found
+            self.logger.warning("Could not load dockerignore.template (%s), using minimal default patterns", e)
+            return [
                 ".git",
                 "__pycache__",
                 "*.pyc",
@@ -305,9 +334,6 @@ phases:
                 "*.egg-info",
                 ".bedrock_agentcore.yaml",  # Always exclude config
             ]
-            self.logger.info("No .dockerignore found, using default exclude patterns")
-
-        return patterns
 
     def _should_ignore(self, path: str, patterns: List[str], is_dir: bool = False) -> bool:
         """Check if path should be ignored based on dockerignore patterns."""

bedrock_agentcore_starter_toolkit/utils/runtime/config.py

@@ -5,7 +5,9 @@ from pathlib import Path
 from typing import Optional
 
 import yaml
+from pydantic import ValidationError
 
+from ...operations.runtime.exceptions import RuntimeToolkitException
 from .schema import BedrockAgentCoreAgentSchema, BedrockAgentCoreConfigSchema
 
 log = logging.getLogger(__name__)
@@ -58,8 +60,25 @@ def load_config(config_path: Path) -> BedrockAgentCoreConfigSchema:
     # New format
     try:
         return BedrockAgentCoreConfigSchema.model_validate(data)
+    except ValidationError as e:
+        # Convert Pydantic errors to user-friendly messages
+        friendly_errors = []
+        for error in e.errors():
+            field = ".".join(str(loc) for loc in error["loc"])
+            msg = error["msg"]
+            # Make common errors more user-friendly
+            if "Source path does not exist" in msg:
+                friendly_errors.append(f"{field}: {msg} (check if the directory exists)")
+            elif "field required" in msg:
+                friendly_errors.append(f"{field}: This field is required")
+            elif "Input should be" in msg:
+                friendly_errors.append(f"{field}: {msg}")
+            else:
+                friendly_errors.append(f"{field}: {msg}")
+
+        raise RuntimeToolkitException("Configuration validation failed:\n• " + "\n• ".join(friendly_errors)) from e
     except Exception as e:
-        raise ValueError(f"Invalid configuration format: {e}") from e
+        raise RuntimeToolkitException(f"Invalid configuration format: {e}") from e
 
 
 def save_config(config: BedrockAgentCoreConfigSchema, config_path: Path):
@@ -127,3 +146,26 @@ def merge_agent_config(
     config.default_agent = agent_name
 
     return config
+
+
+def get_agentcore_directory(project_root: Path, agent_name: str, source_path: Optional[str] = None) -> Path:
+    """Get the agentcore directory for an agent's build artifacts.
+
+    Args:
+        project_root: Project root directory (typically Path.cwd())
+        agent_name: Name of the agent
+        source_path: Optional source path configuration
+
+    Returns:
+        Path to agentcore directory:
+        - If source_path provided: {project_root}/.bedrock_agentcore/{agent_name}/
+        - Otherwise: {project_root}/ (legacy single-agent behavior)
+    """
+    if source_path:
+        # Multi-agent support: use .bedrock_agentcore/{agent_name}/ for artifact isolation
+        agentcore_dir = project_root / ".bedrock_agentcore" / agent_name
+        agentcore_dir.mkdir(parents=True, exist_ok=True)
+        return agentcore_dir
+    else:
+        # Legacy single-agent: artifacts at project root
+        return project_root

bedrock_agentcore_starter_toolkit/utils/runtime/container.py

@@ -8,10 +8,13 @@ from pathlib import Path
 from typing import List, Optional, Tuple
 
 from jinja2 import Template
+from rich.console import Console
 
-from ...cli.common import _handle_warn
+from ...cli.common import _handle_warn, _print_success
 from .entrypoint import detect_dependencies, get_python_version
 
+console = Console()
+
 log = logging.getLogger(__name__)
 
 
@@ -40,12 +43,9 @@ class ContainerRuntime:
                     break
             else:
                 # Informational message - default CodeBuild deployment works fine
-                _handle_warn(
-                    "ℹ️  No container engine found (Docker/Finch/Podman not installed)\n"
-                    "✅ Default deployment uses CodeBuild (no container engine needed)\n"
-                    "💡 Run 'agentcore launch' for cloud-based building and deployment\n"
-                    "💡 For local builds, install Docker, Finch, or Podman"
-                )
+                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]")
                 self.runtime = "none"
                 self.has_local_runtime = False
         elif runtime_type in self.available_runtimes:
@@ -55,10 +55,9 @@ class ContainerRuntime:
             else:
                 # Convert hard error to warning - suggest CodeBuild instead
                 _handle_warn(
-                    f"⚠️  {runtime_type.capitalize()} is not installed\n"
-                    "💡 Recommendation: Use CodeBuild for building containers in the cloud\n"
-                    "💡 Run 'agentcore launch' (default) for CodeBuild deployment\n"
-                    f"💡 For local builds, please install {runtime_type.capitalize()}"
+                    f"{runtime_type.capitalize()} is not installed\n"
+                    "Recommendation: Use CodeBuild for building containers in the cloud\n"
+                    f"For local builds, please install {runtime_type.capitalize()}"
                 )
                 self.runtime = "none"
                 self.has_local_runtime = False
@@ -110,9 +109,23 @@ class ContainerRuntime:
         requirements_file: Optional[str] = None,
         memory_id: Optional[str] = None,
         memory_name: Optional[str] = None,
+        source_path: Optional[str] = None,
         protocol: Optional[str] = None,
     ) -> Path:
-        """Generate Dockerfile from template."""
+        """Generate Dockerfile from template.
+
+        Args:
+            agent_path: Path to agent entrypoint file
+            output_dir: Output directory for Dockerfile (project root)
+            agent_name: Name of the agent
+            aws_region: AWS region
+            enable_observability: Whether to enable observability
+            requirements_file: Optional explicit requirements file path
+            memory_id: Optional memory ID
+            memory_name: Optional memory name
+            source_path: Optional source code directory (for dependency detection)
+            protocol: Optional protocol configuration (HTTP or HTTPS)
+        """
         current_platform = self._get_current_platform()
         required_platform = self.DEFAULT_PLATFORM
 
@@ -133,23 +146,39 @@ class ContainerRuntime:
         with open(template_path) as f:
             template = Template(f.read())
 
+        # Calculate build context root first (needed for validation)
+        # 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)
 
-        # Validate module path before generating Dockerfile
-        self._validate_module_path(agent_path, output_dir)
+        # Validate module path against build context root
+        self._validate_module_path(agent_path, build_context_root)
 
-        # Calculate module path relative to project root
-        agent_module_path = self._get_module_path(agent_path, output_dir)
+        # Calculate module path relative to Docker build context
+        agent_module_path = self._get_module_path(agent_path, build_context_root)
 
         wheelhouse_dir = output_dir / "wheelhouse"
 
-        # Detect dependencies using the new DependencyInfo class
-        deps = detect_dependencies(output_dir, explicit_file=requirements_file)
+        # Detect dependencies:
+        # - If source_path provided: check source_path only
+        # - 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)
+        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
+        # Check for pyproject.toml in the appropriate directory
         has_current_package = False
-        if (output_dir / "pyproject.toml").exists():
+        check_dir = Path(source_path) if source_path else output_dir
+        if (check_dir / "pyproject.toml").exists():
             # Only install current package if deps isn't already pointing to it
             if not (deps.found and deps.is_root_package):
                 has_current_package = True
@@ -189,6 +218,7 @@ class ContainerRuntime:
         """Validate that the agent path can be converted to a valid Python module path."""
         try:
             agent_path = agent_path.resolve()
+            project_root = project_root.resolve()
             relative_path = agent_path.relative_to(project_root)
             for part in relative_path.parts[:-1]:  # Check all directory parts
                 if "-" in part:
@@ -206,6 +236,7 @@ class ContainerRuntime:
         """Get the Python module path for the agent file."""
         try:
             agent_path = agent_path.resolve()
+            project_root = project_root.resolve()
             # Get relative path from project root
             relative_path = agent_path.relative_to(project_root)
             # Convert to module path (e.g., src/agents/my_agent.py -> src.agents.my_agent)
@@ -229,8 +260,21 @@ class ContainerRuntime:
         arch = arch_map.get(machine, machine)
         return f"linux/{arch}"
 
-    def build(self, dockerfile_dir: Path, tag: str, platform: Optional[str] = None) -> Tuple[bool, List[str]]:
-        """Build container image."""
+    def build(
+        self,
+        build_context: Path,
+        tag: str,
+        dockerfile_path: Optional[Path] = None,
+        platform: Optional[str] = None,
+    ) -> Tuple[bool, List[str]]:
+        """Build container image.
+
+        Args:
+            build_context: Directory to use as build context
+            tag: Tag for the built image
+            dockerfile_path: Optional path to Dockerfile (if not in build_context)
+            platform: Optional platform override
+        """
         if not self.has_local_runtime:
             return False, [
                 "No container runtime available for local build",
@@ -239,17 +283,29 @@ class ContainerRuntime:
                 "💡 For local builds, please install Docker, Finch, or Podman",
             ]
 
-        if not dockerfile_dir.exists():
-            return False, [f"Directory not found: {dockerfile_dir}"]
+        if not build_context.exists():
+            return False, [f"Build context directory not found: {build_context}"]
 
-        dockerfile_path = dockerfile_dir / "Dockerfile"
-        if not dockerfile_path.exists():
-            return False, [f"Dockerfile not found in {dockerfile_dir}"]
+        # Determine Dockerfile location
+        if dockerfile_path:
+            # Use provided Dockerfile path
+            if not dockerfile_path.exists():
+                return False, [f"Dockerfile not found: {dockerfile_path}"]
+        else:
+            # Look for Dockerfile in build context
+            dockerfile_path = build_context / "Dockerfile"
+            if not dockerfile_path.exists():
+                return False, [f"Dockerfile not found in {build_context}"]
 
         cmd = [self.runtime, "build", "-t", tag]
+
+        # Use -f flag if Dockerfile is not in the build context
+        if dockerfile_path.parent != build_context:
+            cmd.extend(["-f", str(dockerfile_path)])
+
         build_platform = platform or self.DEFAULT_PLATFORM
         cmd.extend(["--platform", build_platform])
-        cmd.append(str(dockerfile_dir))
+        cmd.append(str(build_context))
 
         return self._execute_command(cmd)
 

bedrock_agentcore_starter_toolkit/utils/runtime/schema.py

@@ -1,10 +1,18 @@
 """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
 
 
+class NetworkModeConfig(BaseModel):
+    """Network mode configuration for VPC deployments."""
+
+    security_groups: List[str] = Field(default_factory=list, description="List of security group IDs")
+    subnets: List[str] = Field(default_factory=list, description="List of subnet IDs")
+
+
 class MemoryConfig(BaseModel):
     """Memory configuration for BedrockAgentCore."""
 
@@ -34,10 +42,38 @@ class NetworkConfiguration(BaseModel):
     """Network configuration for BedrockAgentCore deployment."""
 
     network_mode: str = Field(default="PUBLIC", description="Network mode for deployment")
+    network_mode_config: Optional[NetworkModeConfig] = Field(
+        default=None, description="Network mode configuration (required for VPC mode)"
+    )
+
+    @field_validator("network_mode")
+    @classmethod
+    def validate_network_mode(cls, v: str) -> str:
+        """Validate network mode and ensure VPC config is provided when needed."""
+        valid_modes = ["PUBLIC", "VPC"]
+        if v not in valid_modes:
+            raise ValueError(f"Invalid network_mode: {v}. Must be one of {valid_modes}")
+        return v
+
+    @field_validator("network_mode_config")
+    @classmethod
+    def validate_network_mode_config(cls, v: Optional[NetworkModeConfig], info) -> Optional[NetworkModeConfig]:
+        """Validate that network_mode_config is provided when network_mode is VPC."""
+        if info.data.get("network_mode") == "VPC" and v is None:
+            raise ValueError("network_mode_config is required when network_mode is VPC")
+        return v
 
     def to_aws_dict(self) -> dict:
         """Convert to AWS API format with camelCase keys."""
-        return {"networkMode": self.network_mode}
+        result = {"networkMode": self.network_mode}
+
+        if self.network_mode_config:
+            result["networkModeConfig"] = {
+                "securityGroups": self.network_mode_config.security_groups,
+                "subnets": self.network_mode_config.subnets,
+            }
+
+        return result
 
 
 class ProtocolConfiguration(BaseModel):
@@ -113,6 +149,7 @@ class BedrockAgentCoreAgentSchema(BaseModel):
     entrypoint: str = Field(..., description="Entrypoint file path")
     platform: str = Field(default="linux/amd64", description="Target platform")
     container_runtime: str = Field(default="docker", description="Container runtime to use")
+    source_path: Optional[str] = Field(default=None, description="Directory containing agent source code")
     aws: AWSConfig = Field(default_factory=AWSConfig)
     bedrock_agentcore: BedrockAgentCoreDeploymentInfo = Field(default_factory=BedrockAgentCoreDeploymentInfo)
     codebuild: CodeBuildConfig = Field(default_factory=CodeBuildConfig)
@@ -121,6 +158,37 @@ 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

@@ -4,6 +4,7 @@ WORKDIR /app
 # All environment variables in one layer
 ENV UV_SYSTEM_PYTHON=1 \
     UV_COMPILE_BYTECODE=1 \
+    UV_NO_PROGRESS=1 \
     PYTHONUNBUFFERED=1 \
     DOCKER_CONTAINER=1{% if aws_region %} \
     AWS_REGION={{ aws_region }} \

bedrock_agentcore_starter_toolkit/utils/runtime/templates/dockerignore.template

@@ -63,6 +63,7 @@ tests/
 # Bedrock AgentCore specific - keep config but exclude runtime files
 .bedrock_agentcore.yaml
 .dockerignore
+.bedrock_agentcore/
 
 # Keep wheelhouse for offline installations
 # wheelhouse/

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bedrock-agentcore-starter-toolkit
-Version: 0.1.21
+Version: 0.1.22
 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
@@ -22,7 +22,7 @@ Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.10
 Requires-Dist: autopep8>=2.3.2
-Requires-Dist: bedrock-agentcore>=0.1.4
+Requires-Dist: bedrock-agentcore>=0.1.7
 Requires-Dist: boto3>=1.40.35
 Requires-Dist: botocore>=1.40.35
 Requires-Dist: docstring-parser<1.0,>=0.15

{bedrock_agentcore_starter_toolkit-0.1.21.dist-info → bedrock_agentcore_starter_toolkit-0.1.22.dist-info}/RECORD

@@ -9,11 +9,11 @@ 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=oFviB4Fx2Ff43IHxwWg1q8QLYU2IK3IUS96_MO0IH5k,51255
-bedrock_agentcore_starter_toolkit/cli/runtime/configuration_manager.py,sha256=72UVvnzD3aqaOBNhIMMHjNN5-mgR2oUnnWyA33oFoLM,14602
+bedrock_agentcore_starter_toolkit/cli/runtime/commands.py,sha256=jmkgolQdY9qC7dpWWzel6zb6uI1VggMyZe7DNgepoC4,51960
+bedrock_agentcore_starter_toolkit/cli/runtime/configuration_manager.py,sha256=qTpVMwZGORP2NmDO9uNfSocikKfzPSKgVSzuywSBlwk,14536
 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=pGIO6lOdOR71BX6uTW6xhOKAuYSx6jxtvIggy8NmHHI,15742
+bedrock_agentcore_starter_toolkit/notebook/runtime/bedrock_agentcore.py,sha256=HbERHCoTExo6KqJ3vOg_jgupehjjd2kXYx8_o-B2Rls,15966
 bedrock_agentcore_starter_toolkit/operations/__init__.py,sha256=L7sCNjfZviiVVoh2f3NEs2sbjNqFkmIRI3ZPYMMWMz0,51
 bedrock_agentcore_starter_toolkit/operations/gateway/__init__.py,sha256=5Qo1GeN-DghNp9g0coFUs7WpUJDboJoidOVs-5Co7fo,233
 bedrock_agentcore_starter_toolkit/operations/gateway/client.py,sha256=9KQzRAEGWbBDVVacdB1GqN_HJ06vwTBs6tLwfxYROoY,26498
@@ -38,15 +38,16 @@ bedrock_agentcore_starter_toolkit/operations/memory/models/strategies/semantic.p
 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=qNioReDz0xW0TTc1ihpcd6Cm1t3cM0u4kYrxMttivYI,12848
+bedrock_agentcore_starter_toolkit/operations/runtime/configure.py,sha256=-0j-LfGOo6wky339x3SnG3bq_DYQl0e8n6gweci1XOs,14451
 bedrock_agentcore_starter_toolkit/operations/runtime/create_role.py,sha256=1-b_wBvkOXNh-HJsxATwHfXQqj0dpdETds0FNSTY0BE,16116
-bedrock_agentcore_starter_toolkit/operations/runtime/destroy.py,sha256=w80NppiAFEQefrQpBoF4YBL2pCreKM_TFNYG68irdYs,25147
+bedrock_agentcore_starter_toolkit/operations/runtime/destroy.py,sha256=Zy2U2SwW6Z4y05Wi5xlEg0Ue2O3Euf-pywaMZ1t4J7c,25206
+bedrock_agentcore_starter_toolkit/operations/runtime/exceptions.py,sha256=7iZNVbsz5XyvnpMM4paJb5_LT6DYdEI3nHhM9f3BERE,869
 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/launch.py,sha256=TL-EkrVPhrwqbC2yf9MwhibOogpGKov7IAdZWq2c7s4,29252
 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/codebuild.py,sha256=uFumFMHE8eZU6pDM8LoUku5AezKFCDqRZ4FiOB5Be4U,15861
 bedrock_agentcore_starter_toolkit/services/ecr.py,sha256=nW9wIZcXI6amZeLVSmM9F6awVBQP1-zrFXTozSNEDjo,2805
 bedrock_agentcore_starter_toolkit/services/runtime.py,sha256=lqBB-4uJuxNKbnPHpRskQ7bajiZ2MpjnbqPnKnvTinY,22408
 bedrock_agentcore_starter_toolkit/services/xray.py,sha256=CRlcfVXpghVy7PvZqLUC4rp49Sw5DQ98rUU61HAluRM,6363
@@ -62,19 +63,19 @@ bedrock_agentcore_starter_toolkit/services/import_agent/scripts/bedrock_to_langc
 bedrock_agentcore_starter_toolkit/services/import_agent/scripts/bedrock_to_strands.py,sha256=eC3v2Ts7B_RUGl4bkUim2uFYYuZZYP9syYBlylJ2gXs,14642
 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=h6IxLFORkyVaZIhx2flrLGf2qFxVXXD26C0F2FtsAjo,15923
+bedrock_agentcore_starter_toolkit/utils/runtime/config.py,sha256=ujl_3CNXv2VY48tLkYF7VjemnIrKulmHZ-t2OH3Wmzg,6398
+bedrock_agentcore_starter_toolkit/utils/runtime/container.py,sha256=7r3qCVetkm2Dtmn8BnW31J_Fo5FYj1beMaG0yj2Ap-A,18293
 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=019Lt1RkDka7ZiM5uCnucY69-vC5LYIhY-Os0AxXsS4,7959
-bedrock_agentcore_starter_toolkit/utils/runtime/templates/Dockerfile.j2,sha256=3CK9AG26w3tMmLA6XDI_rpjZZNDhneJj3ghtTM9YAf8,1607
-bedrock_agentcore_starter_toolkit/utils/runtime/templates/dockerignore.template,sha256=b_70sBi0MwkTuA9TqxPqFcWK7TcmpaXBJ6M2Ipox65Q,691
+bedrock_agentcore_starter_toolkit/utils/runtime/schema.py,sha256=tF-shNJhIqiycA_uab2c7G3XYqq3mUkfdXGXixdtfOk,10420
+bedrock_agentcore_starter_toolkit/utils/runtime/templates/Dockerfile.j2,sha256=TUHfWCcuiHw5la-4fWDOmoZDIaY3v6GtKm4fLiqfIE0,1630
+bedrock_agentcore_starter_toolkit/utils/runtime/templates/dockerignore.template,sha256=IDKPnAiCdMLjuvLdItzQiybCW--SEvHAN2yr-B5Mxj4,711
 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.21.dist-info/METADATA,sha256=Bn1VGJrPP0p5HvynOBD1-fktM-915TBCw_brI8AKa0c,9999
-bedrock_agentcore_starter_toolkit-0.1.21.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-bedrock_agentcore_starter_toolkit-0.1.21.dist-info/entry_points.txt,sha256=Tf94DkUf2Tp8P7p8MEXLxre7A7Pp_XNukteiz0wHnk8,77
-bedrock_agentcore_starter_toolkit-0.1.21.dist-info/licenses/LICENSE.txt,sha256=nNPOMinitYdtfbhdQgsPgz1UowBznU6QVN3Xs0pSTKU,10768
-bedrock_agentcore_starter_toolkit-0.1.21.dist-info/licenses/NOTICE.txt,sha256=rkBsg8DbKqfIoQbveqX9foR4uJPUVAokbkr02pRPilE,8674
-bedrock_agentcore_starter_toolkit-0.1.21.dist-info/RECORD,,
+bedrock_agentcore_starter_toolkit-0.1.22.dist-info/METADATA,sha256=4B6BcF1-rXyst3vfu9Wm7F8j8dbPZByY94_GbZjCoZQ,9999
+bedrock_agentcore_starter_toolkit-0.1.22.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+bedrock_agentcore_starter_toolkit-0.1.22.dist-info/entry_points.txt,sha256=Tf94DkUf2Tp8P7p8MEXLxre7A7Pp_XNukteiz0wHnk8,77
+bedrock_agentcore_starter_toolkit-0.1.22.dist-info/licenses/LICENSE.txt,sha256=nNPOMinitYdtfbhdQgsPgz1UowBznU6QVN3Xs0pSTKU,10768
+bedrock_agentcore_starter_toolkit-0.1.22.dist-info/licenses/NOTICE.txt,sha256=rkBsg8DbKqfIoQbveqX9foR4uJPUVAokbkr02pRPilE,8674
+bedrock_agentcore_starter_toolkit-0.1.22.dist-info/RECORD,,