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

bedrock_agentcore_starter_toolkit/cli/common.py

@@ -20,7 +20,7 @@ def _handle_error(message: str, exception: Optional[Exception] = None) -> NoRetu
 
 def _handle_warn(message: str) -> None:
     """Handle errors with consistent formatting and exit."""
-    console.print(f"⚠️  {message}", new_line_start=True, style="bold yellow underline")
+    console.print(f"⚠️ {message}", new_line_start=True, style="yellow")
 
 
 def _print_success(message: str) -> None:

bedrock_agentcore_starter_toolkit/cli/runtime/commands.py

@@ -15,13 +15,16 @@ from rich.syntax import Syntax
 from ...operations.runtime import (
     configure_bedrock_agentcore,
     destroy_bedrock_agentcore,
+    detect_entrypoint,
+    detect_requirements,
+    get_relative_path,
     get_status,
+    infer_agent_name,
     invoke_bedrock_agentcore,
     launch_bedrock_agentcore,
     validate_agent_name,
 )
 from ...utils.runtime.config import load_config
-from ...utils.runtime.entrypoint import parse_entrypoint
 from ...utils.runtime.logs import get_agent_log_paths, get_aws_tail_commands, get_genai_observability_url
 from ..common import _handle_error, _print_success, console
 from .configuration_manager import ConfigurationManager
@@ -47,63 +50,102 @@ def _show_configuration_not_found_panel():
 
 
 def _validate_requirements_file(file_path: str) -> str:
-    """Validate requirements file and return the path."""
+    """Validate requirements file and return the absolute path."""
     from ...utils.runtime.entrypoint import validate_requirements_file
 
     try:
         deps = validate_requirements_file(Path.cwd(), file_path)
-        _print_success(f"Using requirements file: [dim]{deps.resolved_path}[/dim]")
-        return file_path
+        rel_path = get_relative_path(Path(deps.resolved_path))
+        _print_success(f"Using requirements file: [dim]{rel_path}[/dim]")
+        # Return absolute path for consistency with entrypoint handling
+        return str(Path(deps.resolved_path).resolve())
     except (FileNotFoundError, ValueError) as e:
         _handle_error(str(e), e)
 
 
-def _prompt_for_requirements_file(prompt_text: str, default: str = "") -> Optional[str]:
-    """Prompt user for requirements file path with validation."""
-    response = prompt(prompt_text, completer=PathCompleter(), default=default)
+def _prompt_for_requirements_file(prompt_text: str, source_path: str, default: str = "") -> Optional[str]:
+    """Prompt user for requirements file path with validation.
+
+    Args:
+        prompt_text: Prompt message to display
+        source_path: Source directory path for validation
+        default: Default path to pre-populate
+    """
+    # Pre-populate with relative source directory path if no default provided
+    if not default:
+        rel_source = get_relative_path(Path(source_path))
+        default = f"{rel_source}/"
+
+    # Use PathCompleter without filter - allow navigation anywhere
+    response = prompt(prompt_text, completer=PathCompleter(), complete_while_typing=True, default=default)
 
     if response.strip():
+        # Validate file exists and is in source directory
+        req_file = Path(response.strip()).resolve()
+        source_dir = Path(source_path).resolve()
+
+        # Check if requirements file is within source directory
+        try:
+            if not req_file.is_relative_to(source_dir):
+                rel_source = get_relative_path(source_dir)
+                console.print(f"[red]Error: Requirements file must be in source directory: {rel_source}[/red]")
+                return _prompt_for_requirements_file(prompt_text, source_path, default)
+        except (ValueError, AttributeError):
+            # is_relative_to not available or other error - skip validation
+            pass
+
         return _validate_requirements_file(response.strip())
 
     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."""
-    from ...utils.runtime.entrypoint import detect_dependencies
+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
+    """
     if requirements_file:
         # User provided file - validate and show confirmation
         return _validate_requirements_file(requirements_file)
 
+    # Use operations layer for detection - source_path is always provided
+    deps = detect_requirements(Path(source_path))
+
     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]")
+            rel_deps_path = get_relative_path(Path(deps.resolved_path))
+            _print_success(f"Using detected requirements file: [cyan]{rel_deps_path}[/cyan]")
             return None  # Use detected file
         else:
             _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]")
+        rel_deps_path = get_relative_path(Path(deps.resolved_path))
+
+        console.print(f"\n🔍 [cyan]Detected dependency file:[/cyan] [bold]{rel_deps_path}[/bold]")
         console.print("[dim]Press Enter to use this file, or type a different path (use Tab for autocomplete):[/dim]")
 
-        result = _prompt_for_requirements_file("Path or Press Enter to use detected dependency file: ", default="")
+        result = _prompt_for_requirements_file(
+            "Path or Press Enter to use detected dependency file: ", source_path=source_path, default=rel_deps_path
+        )
 
         if result is None:
             # Use detected file
-            _print_success(f"Using detected file: [dim]{deps.file}[/dim]")
+            _print_success(f"Using detected requirements file: [cyan]{rel_deps_path}[/cyan]")
 
         return result
     else:
         console.print("\n[yellow]⚠️  No dependency file found (requirements.txt or pyproject.toml)[/yellow]")
         console.print("[dim]Enter path to requirements file (use Tab for autocomplete), or press Enter to skip:[/dim]")
 
-        result = _prompt_for_requirements_file("Path: ")
+        result = _prompt_for_requirements_file("Path: ", source_path=source_path)
 
         if result is None:
             _handle_error("No requirements file specified and none found automatically")
@@ -111,6 +153,29 @@ def _handle_requirements_file_display(requirements_file: Optional[str], non_inte
         return result
 
 
+def _detect_entrypoint_in_source(source_path: str, non_interactive: bool = False) -> str:
+    """Detect entrypoint file in source directory with CLI display."""
+    source_dir = Path(source_path)
+
+    # Use operations layer for detection
+    detected = detect_entrypoint(source_dir)
+
+    if not detected:
+        # No fallback prompt - fail with clear error message
+        rel_source = get_relative_path(source_dir)
+        _handle_error(
+            f"No entrypoint file found in {rel_source}\n"
+            f"Expected one of: main.py, agent.py, app.py, __main__.py\n"
+            f"Please specify full file path (e.g., {rel_source}/your_agent.py)"
+        )
+
+    # Show detection and confirm
+    rel_entrypoint = get_relative_path(detected)
+
+    _print_success(f"Using entrypoint file: [cyan]{rel_entrypoint}[/cyan]")
+    return str(detected)
+
+
 # Define options at module level to avoid B008
 ENV_OPTION = typer.Option(None, "--env", "-env", help="Environment variables for local mode (format: KEY=VALUE)")
 
@@ -164,7 +229,12 @@ def set_default(name: str = typer.Argument(...)):
 @configure_app.callback(invoke_without_command=True)
 def configure(
     ctx: typer.Context,
-    entrypoint: Optional[str] = typer.Option(None, "--entrypoint", "-e", help="Python file with BedrockAgentCoreApp"),
+    entrypoint: Optional[str] = typer.Option(
+        None,
+        "--entrypoint",
+        "-e",
+        help="Entry point: file path (e.g., agent.py) or directory path (auto-detects main.py, agent.py, app.py)",
+    ),
     agent_name: Optional[str] = typer.Option(None, "--name", "-n"),
     execution_role: Optional[str] = typer.Option(None, "--execution-role", "-er"),
     code_build_execution_role: Optional[str] = typer.Option(None, "--code-build-execution-role", "-cber"),
@@ -174,6 +244,7 @@ def configure(
         None, "--requirements-file", "-rf", help="Path to requirements file"
     ),
     disable_otel: bool = typer.Option(False, "--disable-otel", "-do", help="Disable OpenTelemetry"),
+    disable_memory: bool = typer.Option(False, "--disable-memory", "-dm", help="Disable memory"),
     authorizer_config: Optional[str] = typer.Option(
         None, "--authorizer-config", "-ac", help="OAuth authorizer configuration as JSON string"
     ),
@@ -191,33 +262,74 @@ def configure(
         False, "--non-interactive", "-ni", help="Skip prompts; use defaults unless overridden"
     ),
 ):
-    """Configure a Bedrock AgentCore agent. The agent name defaults to your Python file name."""
+    """Configure a Bedrock AgentCore agent interactively or with parameters.
+
+    Examples:
+      agentcore configure                          # Fully interactive (current directory)
+      agentcore configure --entrypoint writer/   # Directory (auto-detect entrypoint)
+      agentcore configure --entrypoint agent.py    # File (use as entrypoint)
+    """
     if ctx.invoked_subcommand is not None:
         return
 
-    if not entrypoint:
-        _handle_error("--entrypoint is required")
-
     if protocol and protocol.upper() not in ["HTTP", "MCP", "A2A"]:
         _handle_error("Error: --protocol must be either HTTP or MCP or A2A")
 
     console.print("[cyan]Configuring Bedrock AgentCore...[/cyan]")
-    try:
-        _, file_name = parse_entrypoint(entrypoint)
-        agent_name = agent_name or file_name
-
-        valid, error = validate_agent_name(agent_name)
-        if not valid:
-            _handle_error(error)
-
-        console.print(f"[dim]Agent name: {agent_name}[/dim]")
-    except ValueError as e:
-        _handle_error(f"Error: {e}", e)
 
-    # Create configuration manager for clean, elegant prompting
+    # Create configuration manager early for consistent prompting
     config_path = Path.cwd() / ".bedrock_agentcore.yaml"
     config_manager = ConfigurationManager(config_path, non_interactive)
 
+    # Interactive entrypoint selection
+    if not entrypoint:
+        if non_interactive:
+            entrypoint_input = "."
+        else:
+            console.print("\n📂 [cyan]Entrypoint Selection[/cyan]")
+            console.print("[dim]Specify the entry point (use Tab for autocomplete):[/dim]")
+            console.print("[dim]  • File path: weather/agent.py[/dim]")
+            console.print("[dim]  • Directory: weather/ (auto-detects main.py, agent.py, app.py)[/dim]")
+            console.print("[dim]  • Current directory: press Enter[/dim]")
+
+            entrypoint_input = (
+                prompt("Entrypoint: ", completer=PathCompleter(), complete_while_typing=True, default="").strip() or "."
+            )
+    else:
+        entrypoint_input = entrypoint
+
+    # Resolve the entrypoint_input (handles both file and directory)
+    entrypoint_path = Path(entrypoint_input).resolve()
+
+    if entrypoint_path.is_file():
+        # It's a file - use directly as entrypoint
+        entrypoint = str(entrypoint_path)
+        source_path = str(entrypoint_path.parent)
+        if not non_interactive:
+            rel_path = get_relative_path(entrypoint_path)
+            _print_success(f"Using file: {rel_path}")
+    elif entrypoint_path.is_dir():
+        # It's a directory - detect entrypoint within it
+        source_path = str(entrypoint_path)
+        entrypoint = _detect_entrypoint_in_source(source_path, non_interactive)
+    else:
+        _handle_error(f"Path not found: {entrypoint_input}")
+
+    # Process agent name
+    entrypoint_path = Path(entrypoint)
+
+    # Infer agent name from full entrypoint path (e.g., agents/writer/main.py -> agents_writer_main)
+    if not agent_name:
+        suggested_name = infer_agent_name(entrypoint_path)
+        agent_name = config_manager.prompt_agent_name(suggested_name)
+
+    valid, error = validate_agent_name(agent_name)
+    if not valid:
+        _handle_error(error)
+
+    # Handle dependency file selection with simplified logic
+    final_requirements_file = _handle_requirements_file_display(requirements_file, non_interactive, source_path)
+
     # Interactive prompts for missing values - clean and elegant
     if not execution_role:
         execution_role = config_manager.prompt_execution_role()
@@ -236,9 +348,6 @@ def configure(
         auto_create_ecr = False
         _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)
-
     # Handle OAuth authorization configuration
     oauth_config = None
     if authorizer_config:
@@ -264,6 +373,11 @@ def configure(
     else:
         request_header_config = config_manager.prompt_request_header_allowlist()
 
+    if disable_memory:
+        memory_mode_value = "NO_MEMORY"
+    else:
+        memory_mode_value = "STM_ONLY"
+
     try:
         result = configure_bedrock_agentcore(
             agent_name=agent_name,
@@ -274,6 +388,7 @@ def configure(
             container_runtime=container_runtime,
             auto_create_ecr=auto_create_ecr,
             enable_observability=not disable_otel,
+            memory_mode=memory_mode_value,
             requirements_file=final_requirements_file,
             authorizer_configuration=oauth_config,
             request_header_configuration=request_header_config,
@@ -281,6 +396,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
@@ -294,22 +410,26 @@ def configure(
             headers = request_header_config.get("requestHeaderAllowlist", [])
             headers_info = f"Request Headers Allowlist: [dim]{len(headers)} headers configured[/dim]\n"
 
+        execution_role_display = "Auto-create" if not result.execution_role else result.execution_role
+        memory_info = "Short-term memory (30-day retention)"
+        if disable_memory:
+            memory_info = "Disabled"
+
         console.print(
             Panel(
-                f"[green]Configuration Complete[/green]\n\n"
-                f"[bold]Agent Details:[/bold]\n"
+                f"[bold]Agent Details[/bold]\n"
                 f"Agent Name: [cyan]{agent_name}[/cyan]\n"
                 f"Runtime: [cyan]{result.runtime}[/cyan]\n"
                 f"Region: [cyan]{result.region}[/cyan]\n"
-                f"Account: [dim]{result.account_id}[/dim]\n\n"
-                f"[bold]Configuration:[/bold]\n"
-                f"Execution Role: [dim]{result.execution_role}[/dim]\n"
-                f"ECR Repository: [dim]"
+                f"Account: [cyan]{result.account_id}[/cyan]\n\n"
+                f"[bold]Configuration[/bold]\n"
+                f"Execution Role: [cyan]{execution_role_display}[/cyan]\n"
+                f"ECR Repository: [cyan]"
                 f"{'Auto-create' if result.auto_create_ecr else result.ecr_repository or 'N/A'}"
-                f"[/dim]\n"
-                f"Authorization: [dim]{auth_info}[/dim]\n\n"
+                f"[/cyan]\n"
+                f"Authorization: [cyan]{auth_info}[/cyan]\n\n"
                 f"{headers_info}\n"
-                f"Memory: [dim]Short-term memory (30-day retention)[/dim]\n\n"
+                f"Memory: [cyan]{memory_info}[/cyan]\n\n"
                 f"📄 Config saved to: [dim]{result.config_path}[/dim]\n\n"
                 f"[bold]Next Steps:[/bold]\n"
                 f"   [cyan]agentcore launch[/cyan]",
@@ -473,7 +593,6 @@ def launch(
             region = agent_config.aws.region if agent_config else "us-east-1"
 
             deploy_panel = (
-                f"✅ [green]CodeBuild Deployment Successful![/green]\n\n"
                 f"[bold]Agent Details:[/bold]\n"
                 f"Agent Name: [cyan]{agent_name}[/cyan]\n"
                 f"Agent ARN: [cyan]{result.agent_arn}[/cyan]\n"
@@ -513,15 +632,12 @@ def launch(
 
             if local_build:
                 title = "Local Build Success"
-                deployment_type = "✅ [green]Local Build Deployment Successful![/green]"
                 icon = "🔧"
             else:
                 title = "Deployment Success"
-                deployment_type = "✅ [green]Deployment Successful![/green]"
                 icon = "🚀"
 
             deploy_panel = (
-                f"{deployment_type}\n\n"
                 f"[bold]Agent Details:[/bold]\n"
                 f"Agent Name: [cyan]{agent_name}[/cyan]\n"
                 f"Agent ARN: [cyan]{result.agent_arn}[/cyan]\n"

bedrock_agentcore_starter_toolkit/cli/runtime/configuration_manager.py

@@ -10,18 +10,43 @@ from ..common import _handle_error, _print_success, _prompt_with_default, consol
 class ConfigurationManager:
     """Manages interactive configuration prompts with existing configuration defaults."""
 
-    def __init__(self, config_path: Path, non_interactive: bool = False):
+    def __init__(self, config_path: Path, non_interactive: bool = False, region: Optional[str] = None):
         """Initialize the ConfigPrompt with a configuration path.
 
         Args:
             config_path: Path to the configuration file
             non_interactive: If True, use defaults without prompting
+            region: AWS region for checking existing memories (optional, from configure operation)
         """
         from ...utils.runtime.config import load_config_if_exists
 
         project_config = load_config_if_exists(config_path)
         self.existing_config = project_config.get_agent_config() if project_config else None
         self.non_interactive = non_interactive
+        self.region = region
+
+    def prompt_agent_name(self, suggested_name: str) -> str:
+        """Prompt for agent name with a suggested default.
+
+        Args:
+            suggested_name: The suggested agent name based on entrypoint path
+
+        Returns:
+            The selected or entered agent name
+        """
+        if self.non_interactive:
+            _print_success(f"Agent name (inferred): {suggested_name}")
+            return suggested_name
+
+        console.print(f"\n🏷️  [cyan]Inferred agent name[/cyan]: {suggested_name}")
+        console.print("[dim]Press Enter to use this name, or type a different one (alphanumeric without '-')[/dim]")
+        agent_name = _prompt_with_default("Agent name", suggested_name)
+
+        if not agent_name:
+            agent_name = suggested_name
+
+        _print_success(f"Using agent name: [cyan]{agent_name}[/cyan]")
+        return agent_name
 
     def prompt_execution_role(self) -> Optional[str]:
         """Prompt for execution role. Returns role name/ARN or None for auto-creation."""
@@ -205,7 +230,7 @@ class ConfigurationManager:
         Returns:
             Tuple of (enable_memory, enable_ltm)
         """
-        console.print("\n🧠 [cyan]Memory Configuration[/cyan]")
+        console.print("\n[cyan]Memory Configuration[/cyan]")
         console.print("Short-term memory stores conversation within sessions.")
         console.print("Long-term memory extracts preferences and facts across sessions.")
         console.print()
@@ -238,7 +263,7 @@ class ConfigurationManager:
         return enable_memory, enable_ltm
 
     def prompt_memory_selection(self) -> Tuple[str, str]:
-        """Prompt user to select existing memory or create new.
+        """Prompt user to select existing memory or create new (no skip option).
 
         Returns:
             Tuple of (action, value) where:
@@ -249,23 +274,26 @@ class ConfigurationManager:
             # In non-interactive mode, default to creating new STM
             return ("CREATE_NEW", "STM_ONLY")
 
-        console.print("\n🧠 [cyan]Memory Configuration[/cyan]")
+        console.print("\n[cyan]Memory Configuration[/cyan]")
+        console.print("[dim]Tip: Use --disable-memory flag to skip memory entirely[/dim]\n")
 
         # Try to list existing memories
         try:
             from ...operations.memory.manager import MemoryManager
 
-            # Need region - will be passed from configure.py
-            region = self.existing_config.aws.region if self.existing_config else None
+            # Get region from passed parameter OR existing config
+            region = self.region or (self.existing_config.aws.region if self.existing_config else None)
+
             if not region:
-                # Fall back to new memory creation if no region
+                # No region available - skip to new memory creation
+                console.print("[dim]No region configured yet, proceeding with new memory creation[/dim]")
                 return self._prompt_new_memory_config()
 
             memory_manager = MemoryManager(region_name=region)
             existing_memories = memory_manager.list_memories(max_results=10)
 
             if existing_memories:
-                console.print("\n[cyan]Existing memory resources found:[/cyan]")
+                console.print("[cyan]Existing memory resources found:[/cyan]")
                 for i, mem in enumerate(existing_memories, 1):
                     # Display memory summary
                     mem_id = mem.get("id", "unknown")
@@ -283,7 +311,6 @@ class ConfigurationManager:
                 console.print("\n[dim]Options:[/dim]")
                 console.print("[dim]  • Enter a number to use existing memory[/dim]")
                 console.print("[dim]  • Press Enter to create new memory[/dim]")
-                console.print("[dim]  • Type 's' to skip memory setup[/dim]")
 
                 response = _prompt_with_default("Your choice", "").strip().lower()
 
@@ -293,9 +320,11 @@ class ConfigurationManager:
                         selected = existing_memories[idx]
                         _print_success(f"Using existing memory: {selected.get('name', selected.get('id'))}")
                         return ("USE_EXISTING", selected.get("id"))
-                elif response == "s":
-                    _print_success("Skipping memory configuration")
-                    return ("SKIP", None)
+            else:
+                # No existing memories found
+                console.print("[yellow]No existing memory resources found in your account[/yellow]")
+                console.print("[dim]Proceeding with new memory creation...[/dim]\n")
+
         except Exception as e:
             console.print(f"[dim]Could not list existing memories: {e}[/dim]")
 
@@ -303,9 +332,8 @@ class ConfigurationManager:
         return self._prompt_new_memory_config()
 
     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]")
+        """Prompt for new memory configuration (no skip option)."""
+        console.print("[green]✓ Short-term memory will be enabled (default)[/green]")
         console.print("  • Stores conversations within sessions")
         console.print("  • Provides immediate context recall")
         console.print()
@@ -313,10 +341,10 @@ class ConfigurationManager:
         console.print("  • Extracts user preferences across sessions")
         console.print("  • Remembers facts and patterns")
         console.print("  • Creates session summaries")
-        console.print("  • [dim]Note: Takes 60-90 seconds to process[/dim]")
+        console.print("  • [dim]Note: Takes 120-180 seconds to process[/dim]")
         console.print()
 
-        response = _prompt_with_default("Enable long-term memory extraction? (yes/no)", "no").strip().lower()
+        response = _prompt_with_default("Enable long-term memory? (yes/no)", "no").strip().lower()
 
         if response in ["yes", "y"]:
             _print_success("Configuring short-term + long-term memory")

bedrock_agentcore_starter_toolkit/notebook/runtime/bedrock_agentcore.py

@@ -44,9 +44,11 @@ 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,
+        memory_mode: Literal["NO_MEMORY", "STM_ONLY", "STM_AND_LTM"] = "STM_ONLY",
         non_interactive: bool = True,
     ) -> ConfigureResult:
         """Configure Bedrock AgentCore from notebook using an entrypoint file.
@@ -64,13 +66,31 @@ 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)
+            memory_mode: Memory configuration mode (default: "STM_ONLY")
+                - "NO_MEMORY": Disable memory entirely (stateless agent)
+                - "STM_ONLY": Short-term memory only (default)
+                - "STM_AND_LTM": Short-term + long-term memory with strategy extraction
             non_interactive: Skip interactive prompts and use defaults (default: True)
 
         Returns:
             ConfigureResult with configuration details
+
+        Example:
+            # Default: STM only (backward compatible)
+            runtime.configure(entrypoint='handler.py')
+
+            # Explicitly enable LTM
+            runtime.configure(entrypoint='handler.py', memory_mode='STM_AND_LTM')
+
+            # Disable memory entirely
+            runtime.configure(entrypoint='handler.py', memory_mode='NO_MEMORY')
+
+            # Invalid - raises error
+            runtime.configure(entrypoint='handler.py', disable_memory=True, memory_mode='STM_AND_LTM')
         """
         if protocol and protocol.upper() not in ["HTTP", "MCP", "A2A"]:
             raise ValueError("protocol must be either HTTP or MCP or A2A")
@@ -99,7 +119,7 @@ class Runtime:
             handler_dir = Path(file_path).parent
             req_file_path = handler_dir / "requirements.txt"
 
-            all_requirements = []  # "bedrock_agentcore" # Always include bedrock_agentcore
+            all_requirements = []
             all_requirements.extend(requirements)
 
             req_file_path.write_text("\n".join(all_requirements))
@@ -107,6 +127,13 @@ class Runtime:
 
             final_requirements_file = str(req_file_path)
 
+        if memory_mode == "NO_MEMORY":
+            log.info("Memory disabled - agent will be stateless")
+        elif memory_mode == "STM_AND_LTM":
+            log.info("Memory configured with STM + LTM")
+        else:  # STM_ONLY
+            log.info("Memory configured with STM only")
+
         # Configure using the operations module
         result = configure_bedrock_agentcore(
             agent_name=agent_name,
@@ -118,8 +145,10 @@ class Runtime:
             container_runtime=container_runtime,
             auto_create_ecr=auto_create_ecr,
             enable_observability=not disable_otel,
+            memory_mode=memory_mode,
             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/memory/manager.py

@@ -451,7 +451,7 @@ class MemoryManager:
         logger.info("🔎 Retrieving memory resource with ID: %s...", memory_id)
         try:
             response = self._control_plane_client.get_memory(memoryId=memory_id).get("memory", {})
-            logger.info("  ✅ Found memory: %s", memory_id)
+            logger.info("  Found memory: %s", memory_id)
             return Memory(response)
         except ClientError as e:
             logger.error("  ❌ Error retrieving memory: %s", e)

bedrock_agentcore_starter_toolkit/operations/runtime/__init__.py

@@ -1,6 +1,13 @@
 """Bedrock AgentCore operations - shared business logic for CLI and notebook interfaces."""
 
-from .configure import configure_bedrock_agentcore, validate_agent_name
+from .configure import (
+    configure_bedrock_agentcore,
+    detect_entrypoint,
+    detect_requirements,
+    get_relative_path,
+    infer_agent_name,
+    validate_agent_name,
+)
 from .destroy import destroy_bedrock_agentcore
 from .invoke import invoke_bedrock_agentcore
 from .launch import launch_bedrock_agentcore
@@ -18,6 +25,10 @@ __all__ = [
     "configure_bedrock_agentcore",
     "destroy_bedrock_agentcore",
     "validate_agent_name",
+    "detect_entrypoint",
+    "detect_requirements",
+    "get_relative_path",
+    "infer_agent_name",
     "launch_bedrock_agentcore",
     "invoke_bedrock_agentcore",
     "get_status",