bedrock-agentcore-starter-toolkit 0.1.21__tar.gz → 0.1.22__tar.gz

{bedrock_agentcore_starter_toolkit-0.1.21 → bedrock_agentcore_starter_toolkit-0.1.22}/.gitignore

@@ -11,7 +11,7 @@ __pycache__*
 dist
 .dockerignore
 .bedrock_agentcore.yaml
-.bedrock_agentcore/*
+.bedrock_agentcore/
 .ipynb_checkpoints
 Dockerfile
 *.iml
@@ -22,3 +22,8 @@ documentation/.cache
 .agentcore.yaml
 output*/
 .serena/
+specs/
+.claude/
+.specify/
+coverage.json
+CLAUDE.md

{bedrock_agentcore_starter_toolkit-0.1.21 → bedrock_agentcore_starter_toolkit-0.1.22}/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## [0.1.22] - 2025-10-09
+
+### Changes
+
+- Enhanced configuration management with source_path support and improved build workflow (#262) (949abae)
+- feat: add request_header support for runtime config (#260) (e811f4f)
+- fix: add non-interactive flag to integration tests (#261) (c99b5ee)
+- Support vpc (#221) (8a9c3b4)
+- chore: bump version to 0.1.21 (#259) (3e787bd)
+
 ## [0.1.21] - 2025-10-08
 
 ### Changes

{bedrock_agentcore_starter_toolkit-0.1.21 → bedrock_agentcore_starter_toolkit-0.1.22}/PKG-INFO

@@ -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 → bedrock_agentcore_starter_toolkit-0.1.22}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "bedrock-agentcore-starter-toolkit"
-version = "0.1.21"
+version = "0.1.22"
 description = "A starter toolkit for using Bedrock AgentCore"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -28,7 +28,7 @@ classifiers = [
 dependencies = [
     "boto3>=1.40.35",
     "botocore>=1.40.35",
-    "bedrock-agentcore>=0.1.4",
+    "bedrock-agentcore>=0.1.7",
     "docstring_parser>=0.15,<1.0",
     "httpx>=0.28.1",
     "jinja2>=3.1.6",
@@ -115,6 +115,7 @@ concurrency = ["thread", "multiprocessing"]
 omit = [
     "src/bedrock_agentcore_starter_toolkit/cli/import_agent/*", # CLI requires user input to test
     "src/bedrock_agentcore_starter_toolkit/services/import_agent/utils.py", # Utils are not tested directly
+    "src/bedrock_agentcore_starter_toolkit/operations/runtime/exceptions.py", # Simple exception classes
 ]
 
 [tool.coverage.report]

{bedrock_agentcore_starter_toolkit-0.1.21 → bedrock_agentcore_starter_toolkit-0.1.22}/src/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-0.1.21 → bedrock_agentcore_starter_toolkit-0.1.22}/src/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-0.1.21 → bedrock_agentcore_starter_toolkit-0.1.22}/src/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-0.1.21 → bedrock_agentcore_starter_toolkit-0.1.22}/src/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-0.1.21 → bedrock_agentcore_starter_toolkit-0.1.22}/src/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-0.1.22/src/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-0.1.21 → bedrock_agentcore_starter_toolkit-0.1.22}/src/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-0.1.21 → bedrock_agentcore_starter_toolkit-0.1.22}/src/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."""