bedrock-agentcore-starter-toolkit 0.1.14__py3-none-any.whl → 0.1.16__py3-none-any.whl

bedrock_agentcore_starter_toolkit/cli/runtime/commands.py

@@ -280,6 +280,7 @@ def configure(
             verbose=verbose,
             region=region,
             protocol=protocol.upper() if protocol else None,
+            non_interactive=non_interactive,
         )
 
         # Prepare authorization info for summary
@@ -306,8 +307,9 @@ def configure(
                 f"ECR Repository: [dim]"
                 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"
+                f"Authorization: [dim]{auth_info}[/dim]\n\n"
                 f"{headers_info}\n"
+                f"Memory: [dim]Short-term memory (30-day retention)[/dim]\n\n"
                 f"📄 Config saved to: [dim]{result.config_path}[/dim]\n\n"
                 f"[bold]Next Steps:[/bold]\n"
                 f"   [cyan]agentcore launch[/cyan]",
@@ -328,7 +330,7 @@ def launch(
         None, "--agent", "-a", help="Agent name (use 'agentcore configure list' to see available agents)"
     ),
     local: bool = typer.Option(
-        False, "--local", "-l", help="Build locally and run container locally - requires Docker/Finch/Podman"
+        False, "--local", "-l", help="Local build + local runtime - requires Docker/Finch/Podman"
     ),
     local_build: bool = typer.Option(
         False,
@@ -852,6 +854,11 @@ def status(
 
                     # Determine overall status
                     endpoint_status = endpoint_data.get("status", "Unknown") if endpoint_data else "Not Ready"
+                    # memory_info = ""
+                    # if hasattr(status_json["config"], "memory_id") and status_json["config"].get("memory_id"):
+                    #    memory_type = status_json["config"].get("memory_type", "Short-term")
+                    #    memory_id = status_json["config"].get("memory_id")
+                    #    memory_info = f"Memory: [cyan]{memory_type}[/cyan] ([dim]{memory_id}[/dim])\n"
                     if endpoint_status == "READY":
                         status_text = "Ready - Agent deployed and endpoint available"
                     else:
@@ -867,6 +874,30 @@ def status(
                         f"([cyan]{endpoint_status}[/cyan])\n"
                         f"Region: [cyan]{status_json['config']['region']}[/cyan] | "
                         f"Account: [dim]{status_json['config'].get('account', 'Not available')}[/dim]\n\n"
+                    )
+
+                    # Add memory status with proper provisioning indication
+                    if "memory_id" in status_json.get("config", {}) and status_json["config"]["memory_id"]:
+                        memory_type = status_json["config"].get("memory_type", "Unknown")
+                        memory_id = status_json["config"]["memory_id"]
+                        memory_status = status_json["config"].get("memory_status", "Unknown")
+
+                        # Color-code based on status
+                        if memory_status == "ACTIVE":
+                            panel_content += f"Memory: [green]{memory_type}[/green] ([dim]{memory_id}[/dim])\n"
+                        elif memory_status in ["CREATING", "UPDATING"]:
+                            panel_content += f"Memory: [yellow]{memory_type}[/yellow] ([dim]{memory_id}[/dim])\n"
+                            panel_content += (
+                                "         [yellow]⚠️  Memory is provisioning. "
+                                "STM will be available once ACTIVE.[/yellow]\n"
+                            )
+                        else:
+                            panel_content += f"Memory: [red]{memory_type}[/red] ([dim]{memory_id}[/dim])\n"
+
+                        panel_content += "\n"
+
+                    # Continue building the panel
+                    panel_content += (
                         f"[bold]Deployment Info:[/bold]\n"
                         f"Created: [dim]{agent_data.get('createdAt', 'Not available')}[/dim]\n"
                         f"Last Updated: [dim]"

bedrock_agentcore_starter_toolkit/cli/runtime/configuration_manager.py

@@ -2,7 +2,7 @@
 
 import os
 from pathlib import Path
-from typing import Dict, Optional
+from typing import Dict, Optional, Tuple
 
 from ..common import _handle_error, _print_success, _prompt_with_default, console
 
@@ -198,3 +198,129 @@ class ConfigurationManager:
         _print_success(f"Request header allowlist configured with {len(headers)} headers")
 
         return {"requestHeaderAllowlist": headers}
+
+    def prompt_memory_type(self) -> tuple[bool, bool]:
+        """Prompt user for memory configuration preference.
+
+        Returns:
+            Tuple of (enable_memory, enable_ltm)
+        """
+        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()
+
+        # First ask if they want memory at all
+        enable_memory_response = _prompt_with_default("Enable memory for your agent? (yes/no)", "yes").strip().lower()
+
+        enable_memory = enable_memory_response in ["yes", "y"]
+
+        if not enable_memory:
+            _print_success("Memory disabled")
+            return False, False
+
+        # If memory is enabled, ask about long-term memory
+        console.print("\n[dim]Long-term memory extracts:[/dim]")
+        console.print("  • User preferences (e.g., 'I prefer Python')")
+        console.print("  • Semantic facts (e.g., 'My birthday is in January')")
+        console.print("  • Session summaries")
+        console.print()
+
+        enable_ltm_response = _prompt_with_default("Enable long-term memory extraction? (yes/no)", "no").strip().lower()
+
+        enable_ltm = enable_ltm_response in ["yes", "y"]
+
+        if enable_ltm:
+            _print_success("Long-term memory will be configured")
+        else:
+            _print_success("Using short-term memory only")
+
+        return enable_memory, enable_ltm
+
+    def prompt_memory_selection(self) -> Tuple[str, str]:
+        """Prompt user to select existing memory or create new.
+
+        Returns:
+            Tuple of (action, value) where:
+            - action is "USE_EXISTING", "CREATE_NEW"
+            - value is memory_id for USE_EXISTING, mode for CREATE_NEW
+        """
+        if self.non_interactive:
+            # In non-interactive mode, default to creating new STM
+            return ("CREATE_NEW", "STM_ONLY")
+
+        console.print("\n🧠 [cyan]Memory Configuration[/cyan]")
+
+        # 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
+            if not region:
+                # Fall back to new memory creation if no region
+                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]")
+                for i, mem in enumerate(existing_memories, 1):
+                    # Display memory summary
+                    mem_id = mem.get("id", "unknown")
+                    mem_name = mem.get("name", "")
+                    if "memory-" in mem_id:
+                        display_name = mem_id.split("memory-")[0] + "memory"
+                    else:
+                        display_name = mem_name or mem_id[:40]
+
+                    console.print(f"  {i}. [bold]{display_name}[/bold]")
+                    if mem.get("description"):
+                        console.print(f"     [dim]{mem.get('description')}[/dim]")
+                    console.print(f"     [dim]ID: {mem_id}[/dim]")
+
+                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()
+
+                if response.isdigit():
+                    idx = int(response) - 1
+                    if 0 <= idx < len(existing_memories):
+                        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)
+        except Exception as e:
+            console.print(f"[dim]Could not list existing memories: {e}[/dim]")
+
+        # Fall back to creating new memory
+        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]")
+        console.print("  • Stores conversations within sessions")
+        console.print("  • Provides immediate context recall")
+        console.print()
+        console.print("[cyan]Optional: Long-term memory[/cyan]")
+        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()
+
+        response = _prompt_with_default("Enable long-term memory extraction? (yes/no)", "no").strip().lower()
+
+        if response in ["yes", "y"]:
+            _print_success("Configuring short-term + long-term memory")
+            return ("CREATE_NEW", "STM_AND_LTM")
+        else:
+            _print_success("Using short-term memory only")
+            return ("CREATE_NEW", "STM_ONLY")