bedrock-agentcore-starter-toolkit 0.1.21__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,
@@ -41,6 +141,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.
 
@@ -54,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
@@ -61,6 +163,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 +176,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)
 
@@ -116,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"
@@ -196,24 +322,50 @@ 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)
+    # 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:
+        # 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 +410,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__)
@@ -79,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)
@@ -102,7 +112,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(
@@ -129,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:
@@ -146,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:
@@ -368,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/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/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

@@ -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__)
@@ -139,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)
@@ -157,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)
@@ -250,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
@@ -479,14 +495,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 +599,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)...")