bedrock-agentcore-starter-toolkit 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

bedrock_agentcore_starter_toolkit/operations/runtime/launch.py

@@ -15,6 +15,7 @@ from ...services.ecr import deploy_to_ecr, get_or_create_ecr_repository
 from ...services.runtime import BedrockAgentCoreClient
 from ...utils.runtime.config import load_config, save_config
 from ...utils.runtime.container import ContainerRuntime
+from ...utils.runtime.schema import BedrockAgentCoreAgentSchema, BedrockAgentCoreConfigSchema
 from .create_role import get_or_create_runtime_execution_role
 from .models import LaunchResult
 
@@ -137,7 +138,14 @@ def _ensure_execution_role(agent_config, project_config, config_path, agent_name
 
 
 def _deploy_to_bedrock_agentcore(
-    agent_config, project_config, config_path, agent_name, ecr_uri, region, env_vars=None, auto_update_on_conflict=False
+    agent_config: BedrockAgentCoreAgentSchema,
+    project_config: BedrockAgentCoreConfigSchema,
+    config_path: Path,
+    agent_name: str,
+    ecr_uri: str,
+    region: str,
+    env_vars: Optional[dict] = None,
+    auto_update_on_conflict: bool = False,
 ):
     """Deploy agent to Bedrock AgentCore with retry logic for role validation."""
     log.info("Deploying to Bedrock AgentCore...")
@@ -215,6 +223,16 @@ def _deploy_to_bedrock_agentcore(
     agent_config.bedrock_agentcore.agent_id = agent_id
     agent_config.bedrock_agentcore.agent_arn = agent_arn
 
+    # Reset session id if present
+    existing_session_id = agent_config.bedrock_agentcore.agent_session_id
+    if existing_session_id is not None:
+        log.warning(
+            "⚠️ Session ID will be reset to connect to the updated agent. "
+            "The previous agent remains accessible via the original session ID: %s",
+            existing_session_id,
+        )
+        agent_config.bedrock_agentcore.agent_session_id = None
+
     # Update the project config and save
     project_config.agents[agent_config.name] = agent_config
     save_config(project_config, config_path)
@@ -233,8 +251,7 @@ def launch_bedrock_agentcore(
     config_path: Path,
     agent_name: Optional[str] = None,
     local: bool = False,
-    push_ecr_only: bool = False,
-    use_codebuild: bool = False,
+    use_codebuild: bool = True,
     env_vars: Optional[dict] = None,
     auto_update_on_conflict: bool = False,
 ) -> LaunchResult:
@@ -244,7 +261,6 @@ def launch_bedrock_agentcore(
         config_path: Path to BedrockAgentCore configuration file
         agent_name: Name of agent to launch (for project configurations)
         local: Whether to run locally
-        push_ecr_only: Whether to only build and push to ECR without deploying
         use_codebuild: Whether to use CodeBuild for ARM64 builds
         env_vars: Environment variables to pass to local container (dict of key-value pairs)
         auto_update_on_conflict: Whether to automatically update when agent already exists (default: False)
@@ -256,18 +272,19 @@ def launch_bedrock_agentcore(
     project_config = load_config(config_path)
     agent_config = project_config.get_agent_config(agent_name)
 
-    # Handle CodeBuild deployment
-    if use_codebuild:
+    # Handle CodeBuild deployment (but not for local mode)
+    if use_codebuild and not local:
         return _launch_with_codebuild(
             config_path=config_path,
             agent_name=agent_config.name,
             agent_config=agent_config,
             project_config=project_config,
             auto_update_on_conflict=auto_update_on_conflict,
+            env_vars=env_vars,
         )
 
     # Log which agent is being launched
-    mode = "locally" if local else "to ECR only" if push_ecr_only else "to cloud"
+    mode = "locally" if local else "to cloud"
     log.info("Launching Bedrock AgentCore agent '%s' %s", agent_config.name, mode)
 
     # Validate configuration
@@ -278,17 +295,45 @@ def launch_bedrock_agentcore(
     # Initialize container runtime
     runtime = ContainerRuntime(agent_config.container_runtime)
 
+    # Check if we need local runtime for this operation
+    if local and not runtime.has_local_runtime:
+        raise RuntimeError(
+            "Cannot run locally - no container runtime available\n"
+            "💡 Recommendation: Use CodeBuild for cloud deployment\n"
+            "💡 Run 'agentcore launch' (without --local) for CodeBuild deployment\n"
+            "💡 For local runs, please install Docker, Finch, or Podman"
+        )
+
+    # Check if we need local runtime for local-build mode (cloud deployment with local build)
+    if not local and not use_codebuild and not runtime.has_local_runtime:
+        raise RuntimeError(
+            "Cannot build locally - no container runtime available\n"
+            "💡 Recommendation: Use CodeBuild for cloud deployment (no Docker needed)\n"
+            "💡 Run 'agentcore launch' (without --local-build) for CodeBuild deployment\n"
+            "💡 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
 
     bedrock_agentcore_name = agent_config.name
     tag = f"bedrock_agentcore-{bedrock_agentcore_name}:latest"
 
-    # Step 1: Build Docker image
+    # Step 1: Build Docker image (only if we need it)
     success, output = runtime.build(build_dir, tag)
     if not success:
         error_lines = output[-10:] if len(output) > 10 else output
-        raise RuntimeError(f"Build failed: {' '.join(error_lines)}")
+        error_message = " ".join(error_lines)
+
+        # Check if this is a container runtime issue and suggest CodeBuild
+        if "No container runtime available" in error_message:
+            raise RuntimeError(
+                f"Build failed: {error_message}\n"
+                "💡 Recommendation: Use CodeBuild for building containers in the cloud\n"
+                "💡 Run 'agentcore launch' (default) for CodeBuild deployment"
+            )
+        else:
+            raise RuntimeError(f"Build failed: {error_message}")
 
     log.info("Docker image built: %s", tag)
 
@@ -323,15 +368,6 @@ def launch_bedrock_agentcore(
 
     log.info("Image uploaded to ECR: %s", ecr_uri)
 
-    # If push_ecr_only, return early
-    if push_ecr_only:
-        return LaunchResult(
-            mode="push-ecr",
-            tag=tag,
-            ecr_uri=ecr_uri,
-            build_output=output,
-        )
-
     # Step 4: Deploy agent (with retry logic for role readiness)
     agent_id, agent_arn = _deploy_to_bedrock_agentcore(
         agent_config,
@@ -354,12 +390,14 @@ def launch_bedrock_agentcore(
     )
 
 
-def _launch_with_codebuild(
+def _execute_codebuild_workflow(
     config_path: Path,
     agent_name: str,
     agent_config,
     project_config,
+    ecr_only: bool = False,
     auto_update_on_conflict: bool = False,
+    env_vars: Optional[dict] = None,
 ) -> LaunchResult:
     """Launch using CodeBuild for ARM64 builds."""
     log.info(
@@ -368,7 +406,6 @@ def _launch_with_codebuild(
         agent_config.aws.account,
         agent_config.aws.region,
     )
-
     # Validate configuration
     errors = agent_config.validate(for_local=False)
     if errors:
@@ -381,13 +418,16 @@ def _launch_with_codebuild(
     session = boto3.Session(region_name=region)
     account_id = agent_config.aws.account  # Use existing account from config
 
-    # Step 1: Setup AWS resources
-    log.info("Setting up AWS resources (ECR repository, execution roles)...")
+    # 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]}"
-    _ensure_execution_role(agent_config, project_config, config_path, agent_name, region, account_id)
 
-    # Step 2: Prepare CodeBuild
+    # 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)
+
+    # Prepare CodeBuild
     log.info("Preparing CodeBuild project and uploading source...")
     codebuild_service = CodeBuildService(session)
 
@@ -404,16 +444,54 @@ def _launch_with_codebuild(
         source_location=source_location,
     )
 
-    # Step 3: Execute CodeBuild
+    # Execute CodeBuild
     log.info("Starting CodeBuild build (this may take several minutes)...")
     build_id = codebuild_service.start_build(project_name, source_location)
     codebuild_service.wait_for_completion(build_id)
     log.info("CodeBuild completed successfully")
 
-    # Update CodeBuild config
-    agent_config.codebuild.project_name = project_name
-    agent_config.codebuild.execution_role = codebuild_execution_role
-    agent_config.codebuild.source_bucket = codebuild_service.source_bucket
+    # Update CodeBuild config only for full deployments, not ECR-only
+    if not ecr_only:
+        agent_config.codebuild.project_name = project_name
+        agent_config.codebuild.execution_role = codebuild_execution_role
+        agent_config.codebuild.source_bucket = codebuild_service.source_bucket
+
+        # Save config changes
+        project_config.agents[agent_config.name] = agent_config
+        save_config(project_config, config_path)
+        log.info("✅ CodeBuild project configuration saved")
+    else:
+        log.info("✅ ECR-only build completed (project configuration not saved)")
+
+    return build_id, ecr_uri, region, account_id
+
+
+def _launch_with_codebuild(
+    config_path: Path,
+    agent_name: str,
+    agent_config,
+    project_config,
+    auto_update_on_conflict: bool = False,
+    env_vars: Optional[dict] = None,
+) -> LaunchResult:
+    """Launch using CodeBuild for ARM64 builds."""
+    log.info(
+        "Starting CodeBuild ARM64 deployment for agent '%s' to account %s (%s)",
+        agent_name,
+        agent_config.aws.account,
+        agent_config.aws.region,
+    )
+
+    # Execute shared CodeBuild workflow with full deployment mode
+    build_id, ecr_uri, region, account_id = _execute_codebuild_workflow(
+        config_path=config_path,
+        agent_name=agent_name,
+        agent_config=agent_config,
+        project_config=project_config,
+        ecr_only=False,
+        auto_update_on_conflict=auto_update_on_conflict,
+        env_vars=env_vars,
+    )
 
     # Deploy to Bedrock AgentCore
     agent_id, agent_arn = _deploy_to_bedrock_agentcore(
@@ -423,7 +501,7 @@ def _launch_with_codebuild(
         agent_name,
         ecr_uri,
         region,
-        env_vars=None,
+        env_vars=env_vars,
         auto_update_on_conflict=auto_update_on_conflict,
     )
 

bedrock_agentcore_starter_toolkit/operations/runtime/models.py

@@ -27,7 +27,7 @@ class ConfigureResult(BaseModel):
 class LaunchResult(BaseModel):
     """Result of launch operation."""
 
-    mode: str = Field(..., description="Launch mode: local, push-ecr, cloud, or codebuild")
+    mode: str = Field(..., description="Launch mode: local, cloud, or codebuild")
     tag: str = Field(..., description="Docker image tag")
     env_vars: Optional[Dict[str, str]] = Field(default=None, description="Environment variables for local deployment")
 

bedrock_agentcore_starter_toolkit/services/__init__.py

@@ -0,0 +1 @@
+"""Services module for the Bedrock Agent Core Starter Toolkit."""

bedrock_agentcore_starter_toolkit/services/import_agent/__init__.py

@@ -0,0 +1 @@
+"""Import Agent Utility for Bedrock Agents -> Bedrock AgentCore."""

bedrock_agentcore_starter_toolkit/services/import_agent/assets/memory_manager_template.py

@@ -0,0 +1,207 @@
+# pylint: disable=line-too-long
+"""Long Term Memory Manager for generated agents.
+
+This module provides a custom memory manager that mimics the functionality of Bedrock Agents
+Long Term Memory and Sessions.
+"""
+
+import asyncio
+import json
+import os
+import weakref
+from datetime import datetime
+from typing import Any, Dict, List, Set
+
+
+class LongTermMemoryManager:
+    """Custom Memory Manager to have equivalent functionality with Bedrock Agents Long Term Memory and Sessions."""
+
+    # Class variable to keep track of all instances
+    _instances: Set[weakref.ref] = set()
+
+    def __init__(
+        self,
+        llm_summarizer,
+        storage_path: str = "output",
+        max_sessions: int = 10,
+        summarization_prompt: str = None,
+        max_days: int = 30,
+        platform: str = "langchain",
+    ):
+        """Initialize the LongTermMemoryManager."""
+        self.llm_summarizer = llm_summarizer
+        self.storage_path = storage_path
+        self.max_sessions = max_sessions
+        self.max_days = max_days
+        self.current_session_messages = []
+        self.summarization_prompt = summarization_prompt
+        self._last_memory_update_time = 0
+        self.platform = platform
+        self._session_ended = False  # Track if this instance has ended its session
+
+        self.session_summaries = self._load_session_summaries()
+
+        # Register this instance in the class-level instances set
+        self._instances.add(weakref.ref(self, self._cleanup_reference))
+
+    @staticmethod
+    def _cleanup_reference(ref):
+        """Callback for when a weak reference is removed."""
+        LongTermMemoryManager._instances.discard(ref)
+
+    def _load_session_summaries(self) -> List[Dict[str, Any]]:
+        """Load all stored session summaries."""
+        summary_file = self.storage_path
+        if os.path.exists(summary_file):
+            with open(summary_file, "r") as f:
+                return json.load(f)
+        return []
+
+    def _save_session_summaries(self):
+        summary_file = self.storage_path
+        with open(summary_file, "a+", encoding="utf-8") as f:
+            f.truncate(0)
+            json.dump(self.session_summaries, f)
+        self._last_memory_update_time = datetime.now().timestamp()
+
+    def add_message(self, message: Dict[str, str]):
+        """Add a message to the current session."""
+        self.current_session_messages.append(message)
+
+    def _generate_session_summary(self) -> str:
+        try:
+            conversation_str = "\n\n".join(
+                [f"{msg['role'].capitalize()}: {msg['content']}" for msg in self.current_session_messages]
+            )
+
+            past_summaries = "\n".join([summary["summary"] for summary in self.session_summaries])
+
+            summarization_prompt = self.summarization_prompt.replace(
+                "$past_conversation_summary$", past_summaries
+            ).replace("$conversation$", conversation_str)
+
+            if self.platform == "langchain":
+                summary_response = self.llm_summarizer.invoke(summarization_prompt).content
+            else:
+
+                def inference(model, messages, system_prompt=""):
+                    async def run_inference():
+                        results = []
+                        async for event in model.stream(messages=messages, system_prompt=system_prompt):
+                            results.append(event)
+                        return results
+
+                    response = asyncio.run(run_inference())
+
+                    text = ""
+                    for chunk in response:
+                        if "contentBlockDelta" not in chunk:
+                            continue
+                        text += chunk["contentBlockDelta"].get("delta", {}).get("text", "")
+
+                    return text
+
+                summary_response = inference(
+                    self.llm_summarizer, messages=[{"role": "user", "content": [{"text": summarization_prompt}]}]
+                )
+
+            return summary_response
+        except Exception as e:
+            print(f"Error generating summary: {str(e)}")
+            message = self.current_session_messages[-1]["content"] if self.current_session_messages else "No messages"
+            return f"Session summary generation failed. Last message: {message}"
+
+    @classmethod
+    def _cleanup_instance(cls):
+        """Remove dead references from the instances set."""
+        cls._instances = {ref for ref in cls._instances if ref() is not None}
+
+    @classmethod
+    def get_active_instances_count(cls):
+        """Return the number of active memory manager instances."""
+        # Clean up any dead references first
+        cls._instances = {ref for ref in cls._instances if ref() is not None}
+        return len(cls._instances)
+
+    @classmethod
+    def get_active_instances(cls):
+        """Return a list of all active memory manager instances."""
+        # Clean up any dead references first
+        cls._instances = {ref for ref in cls._instances if ref() is not None}
+        return [ref() for ref in cls._instances if ref() is not None]
+
+    @classmethod
+    def end_all_sessions(cls):
+        """End sessions for all active memory manager instances.
+
+        This is a convenience method that can be called from anywhere to end all sessions.
+        """
+        instances = cls.get_active_instances()
+        if instances:
+            instances[0].end_session()
+
+    def end_session(self):
+        """End the current session and trigger end_session for all other instances.
+
+        This ensures that when one agent ends its session, all other agents do the same.
+        """
+        # Prevent recursive calls
+        if self._session_ended:
+            return
+
+        self._session_ended = True
+
+        # Process this instance's session
+        if self.current_session_messages:
+            summary = self._generate_session_summary()
+            session_summary = {"timestamp": datetime.now().isoformat(), "summary": summary}
+            self.session_summaries.append(session_summary)
+
+            self.session_summaries = [
+                summary
+                for summary in self.session_summaries
+                if (
+                    datetime.fromisoformat(session_summary["timestamp"]) - datetime.fromisoformat(summary["timestamp"])
+                ).days
+                <= self.max_days
+            ]
+
+            if len(self.session_summaries) > self.max_sessions:
+                self.session_summaries = self.session_summaries[-self.max_sessions :]
+
+            self._save_session_summaries()
+
+            self.current_session_messages = []
+
+        # End sessions for all other instances
+        for instance_ref in list(self._instances):
+            instance = instance_ref()
+            if instance is not None and instance is not self and not instance._session_ended:
+                try:
+                    instance.end_session()
+                except Exception as e:
+                    print(f"Error ending session for another instance: {str(e)}")
+
+        # Reset the flag so this instance can be used again if needed
+        self._session_ended = False
+
+    def get_memory_synopsis(self) -> str:
+        """Get a synopsis of the memory, including all session summaries."""
+        return "\n".join([summary["summary"] for summary in self.session_summaries])
+
+    def has_memory_changed(self) -> bool:
+        """Check if the memory has changed since the last update."""
+        summary_file = self.storage_path
+
+        if not os.path.exists(summary_file):
+            return False
+
+        current_mtime = os.path.getmtime(summary_file)
+        if current_mtime != self._last_memory_update_time:
+            self._last_memory_update_time = current_mtime
+            return True
+        return False
+
+    def clear_current_session(self):
+        """Clear the current session messages."""
+        self.current_session_messages = []

bedrock_agentcore_starter_toolkit/services/import_agent/assets/requirements_langchain.j2

@@ -0,0 +1,9 @@
+bedrock-agentcore
+bedrock-agentcore-starter-toolkit
+langchain
+langchain-aws
+langchain-community
+langchain-mcp-adapters
+langgraph
+inputimeout
+opentelemetry-instrumentation-langchain

bedrock_agentcore_starter_toolkit/services/import_agent/assets/requirements_strands.j2

@@ -0,0 +1,5 @@
+bedrock-agentcore
+bedrock-agentcore-starter-toolkit
+strands-agents
+strands-agents-tools
+inputimeout