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

bedrock_agentcore_starter_toolkit/operations/runtime/status.py

@@ -38,7 +38,11 @@ def get_status(config_path: Path, agent_name: Optional[str] = None) -> StatusRes
         agent_arn=agent_config.bedrock_agentcore.agent_arn,
     )
 
-    if agent_config.memory and agent_config.memory.memory_id:
+    # Check if memory is disabled first
+    if agent_config.memory and agent_config.memory.mode == "NO_MEMORY":
+        config_info.memory_type = "Disabled"
+        config_info.memory_enabled = False
+    elif agent_config.memory and agent_config.memory.memory_id:
         try:
             from ...operations.memory.manager import MemoryManager
 
@@ -91,9 +95,6 @@ def get_status(config_path: Path, agent_name: Optional[str] = None) -> StatusRes
 
             config_info.memory_id = agent_config.memory.memory_id
             config_info.memory_status = memory_status
-
-            # Add the detailed memory info to config_info
-            # You'll need to add this field to StatusConfigInfo model
             config_info.memory_details = memory_details
 
         except Exception as e:

bedrock_agentcore_starter_toolkit/services/codebuild.py

@@ -6,13 +6,15 @@ 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
 
 from ..operations.runtime.create_role import get_or_create_codebuild_execution_role
+from .ecr import sanitize_ecr_repo_name
 
 
 class CodeBuildService:
@@ -70,21 +72,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 +116,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"
 
@@ -141,7 +160,7 @@ class CodeBuildService:
         self, agent_name: str, ecr_repository_uri: str, execution_role: str, source_location: str
     ) -> str:
         """Create or update CodeBuild project for ARM64 builds."""
-        project_name = f"bedrock-agentcore-{agent_name}-builder"
+        project_name = f"bedrock-agentcore-{sanitize_ecr_repo_name(agent_name)}-builder"
 
         buildspec = self._get_arm64_buildspec(ecr_repository_uri)
 
@@ -280,21 +299,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 +335,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."""

bedrock_agentcore_starter_toolkit/services/ecr.py

@@ -1,12 +1,54 @@
 """ECR (Elastic Container Registry) service integration."""
 
 import base64
+import re
 
 import boto3
 
 from ..utils.runtime.container import ContainerRuntime
 
 
+def sanitize_ecr_repo_name(name: str) -> str:
+    """Sanitize agent name for ECR repository naming requirements.
+
+    ECR repository names must:
+    - Contain only lowercase letters, numbers, hyphens (-), underscores (_), and forward slashes (/)
+    - Start with a lowercase letter or number
+    - Be between 2 and 256 characters
+
+    Args:
+        name: Agent name to sanitize
+
+    Returns:
+        Sanitized repository name component
+    """
+    # Convert to lowercase
+    name = name.lower()
+
+    # Replace invalid characters with hyphens
+    name = re.sub(r"[^a-z0-9_\-/]", "-", name)
+
+    # Ensure starts with alphanumeric
+    if name and not name[0].isalnum():
+        name = "a" + name  # Prefix with 'a' if starts with non-alphanumeric
+
+    # Remove consecutive hyphens/underscores
+    name = re.sub(r"[-_]{2,}", "-", name)
+
+    # Strip trailing hyphens/underscores
+    name = name.rstrip("-_")
+
+    # Ensure minimum length
+    if len(name) < 2:
+        name = name + "-agent"
+
+    # Truncate if too long (leave room for prefix)
+    if len(name) > 200:
+        name = name[:200].rstrip("-_")
+
+    return name
+
+
 def get_account_id() -> str:
     """Get AWS account ID."""
     return boto3.client("sts").get_caller_identity()["Account"]
@@ -38,8 +80,8 @@ def get_or_create_ecr_repository(agent_name: str, region: str) -> str:
     Returns:
         ECR repository URI
     """
-    # Generate deterministic repository name based on agent name
-    repo_name = f"bedrock-agentcore-{agent_name}"
+    # Generate deterministic repository name based on agent name (sanitized for ECR requirements)
+    repo_name = f"bedrock-agentcore-{sanitize_ecr_repo_name(agent_name)}"
 
     ecr = boto3.client("ecr", region_name=region)
 

bedrock_agentcore_starter_toolkit/utils/runtime/config.py

@@ -5,7 +5,9 @@ from pathlib import Path
 from typing import Optional
 
 import yaml
+from pydantic import ValidationError
 
+from ...operations.runtime.exceptions import RuntimeToolkitException
 from .schema import BedrockAgentCoreAgentSchema, BedrockAgentCoreConfigSchema
 
 log = logging.getLogger(__name__)
@@ -58,8 +60,25 @@ def load_config(config_path: Path) -> BedrockAgentCoreConfigSchema:
     # New format
     try:
         return BedrockAgentCoreConfigSchema.model_validate(data)
+    except ValidationError as e:
+        # Convert Pydantic errors to user-friendly messages
+        friendly_errors = []
+        for error in e.errors():
+            field = ".".join(str(loc) for loc in error["loc"])
+            msg = error["msg"]
+            # Make common errors more user-friendly
+            if "Source path does not exist" in msg:
+                friendly_errors.append(f"{field}: {msg} (check if the directory exists)")
+            elif "field required" in msg:
+                friendly_errors.append(f"{field}: This field is required")
+            elif "Input should be" in msg:
+                friendly_errors.append(f"{field}: {msg}")
+            else:
+                friendly_errors.append(f"{field}: {msg}")
+
+        raise RuntimeToolkitException("Configuration validation failed:\n• " + "\n• ".join(friendly_errors)) from e
     except Exception as e:
-        raise ValueError(f"Invalid configuration format: {e}") from e
+        raise RuntimeToolkitException(f"Invalid configuration format: {e}") from e
 
 
 def save_config(config: BedrockAgentCoreConfigSchema, config_path: Path):
@@ -127,3 +146,26 @@ def merge_agent_config(
     config.default_agent = agent_name
 
     return config
+
+
+def get_agentcore_directory(project_root: Path, agent_name: str, source_path: Optional[str] = None) -> Path:
+    """Get the agentcore directory for an agent's build artifacts.
+
+    Args:
+        project_root: Project root directory (typically Path.cwd())
+        agent_name: Name of the agent
+        source_path: Optional source path configuration
+
+    Returns:
+        Path to agentcore directory:
+        - If source_path provided: {project_root}/.bedrock_agentcore/{agent_name}/
+        - Otherwise: {project_root}/ (legacy single-agent behavior)
+    """
+    if source_path:
+        # Multi-agent support: use .bedrock_agentcore/{agent_name}/ for artifact isolation
+        agentcore_dir = project_root / ".bedrock_agentcore" / agent_name
+        agentcore_dir.mkdir(parents=True, exist_ok=True)
+        return agentcore_dir
+    else:
+        # Legacy single-agent: artifacts at project root
+        return project_root

bedrock_agentcore_starter_toolkit/utils/runtime/container.py

@@ -8,10 +8,13 @@ from pathlib import Path
 from typing import List, Optional, Tuple
 
 from jinja2 import Template
+from rich.console import Console
 
-from ...cli.common import _handle_warn
+from ...cli.common import _handle_warn, _print_success
 from .entrypoint import detect_dependencies, get_python_version
 
+console = Console()
+
 log = logging.getLogger(__name__)
 
 
@@ -40,11 +43,10 @@ class ContainerRuntime:
                     break
             else:
                 # Informational message - default CodeBuild deployment works fine
-                _handle_warn(
-                    "ℹ️  No container engine found (Docker/Finch/Podman not installed)\n"
-                    "✅ Default deployment uses CodeBuild (no container engine needed)\n"
-                    "💡 Run 'agentcore launch' for cloud-based building and deployment\n"
-                    "💡 For local builds, install Docker, Finch, or Podman"
+                console.print("\n💡 [cyan]No container engine found (Docker/Finch/Podman not installed)[/cyan]")
+                _print_success(
+                    "Default deployment uses CodeBuild (no container engine needed), "
+                    "For local builds, install Docker, Finch, or Podman"
                 )
                 self.runtime = "none"
                 self.has_local_runtime = False
@@ -55,10 +57,9 @@ class ContainerRuntime:
             else:
                 # Convert hard error to warning - suggest CodeBuild instead
                 _handle_warn(
-                    f"⚠️  {runtime_type.capitalize()} is not installed\n"
-                    "💡 Recommendation: Use CodeBuild for building containers in the cloud\n"
-                    "💡 Run 'agentcore launch' (default) for CodeBuild deployment\n"
-                    f"💡 For local builds, please install {runtime_type.capitalize()}"
+                    f"{runtime_type.capitalize()} is not installed\n"
+                    "Recommendation: Use CodeBuild for building containers in the cloud\n"
+                    f"For local builds, please install {runtime_type.capitalize()}"
                 )
                 self.runtime = "none"
                 self.has_local_runtime = False
@@ -110,17 +111,32 @@ class ContainerRuntime:
         requirements_file: Optional[str] = None,
         memory_id: Optional[str] = None,
         memory_name: Optional[str] = None,
+        source_path: Optional[str] = None,
         protocol: Optional[str] = None,
     ) -> Path:
-        """Generate Dockerfile from template."""
+        """Generate Dockerfile from template.
+
+        Args:
+            agent_path: Path to agent entrypoint file
+            output_dir: Output directory for Dockerfile (project root)
+            agent_name: Name of the agent
+            aws_region: AWS region
+            enable_observability: Whether to enable observability
+            requirements_file: Optional explicit requirements file path
+            memory_id: Optional memory ID
+            memory_name: Optional memory name
+            source_path: Optional source code directory (for dependency detection)
+            protocol: Optional protocol configuration (HTTP or HTTPS)
+        """
         current_platform = self._get_current_platform()
         required_platform = self.DEFAULT_PLATFORM
 
         if current_platform != required_platform:
             _handle_warn(
-                f"[WARNING] Platform mismatch: Current system is '{current_platform}' "
-                f"but Bedrock AgentCore requires '{required_platform}'.\n"
-                "For deployment options and workarounds, see: "
+                f"Platform mismatch: Current system is '{current_platform}' "
+                f"but Bedrock AgentCore requires '{required_platform}', so local builds won't work.\n"
+                "Please use default launch command which will do a remote cross-platform build using code build."
+                "For deployment other options and workarounds, see: "
                 "https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/getting-started-custom.html\n"
             )
 
@@ -133,23 +149,39 @@ class ContainerRuntime:
         with open(template_path) as f:
             template = Template(f.read())
 
+        # Calculate build context root first (needed for validation)
+        # If source_path provided: module path relative to source_path (Docker build context)
+        # Otherwise: module path relative to project root
+        build_context_root = Path(source_path) if source_path else output_dir
         # Generate .dockerignore if it doesn't exist
-        self._ensure_dockerignore(output_dir)
+        self._ensure_dockerignore(build_context_root)
 
-        # Validate module path before generating Dockerfile
-        self._validate_module_path(agent_path, output_dir)
+        # Validate module path against build context root
+        self._validate_module_path(agent_path, build_context_root)
 
-        # Calculate module path relative to project root
-        agent_module_path = self._get_module_path(agent_path, output_dir)
+        # Calculate module path relative to Docker build context
+        agent_module_path = self._get_module_path(agent_path, build_context_root)
 
         wheelhouse_dir = output_dir / "wheelhouse"
 
-        # Detect dependencies using the new DependencyInfo class
-        deps = detect_dependencies(output_dir, explicit_file=requirements_file)
+        # Detect dependencies:
+        # - If source_path provided: check source_path only
+        # - Otherwise: check project root (output_dir)
+        # - If explicit requirements_file provided: use that regardless
+        if source_path and not requirements_file:
+            source_dir = Path(source_path)
+            deps = detect_dependencies(source_dir, explicit_file=None)
+        if source_path:
+            source_dir = Path(source_path)
+            deps = detect_dependencies(source_dir, explicit_file=requirements_file)
+        else:
+            deps = detect_dependencies(output_dir, explicit_file=requirements_file)
 
         # Add logic to avoid duplicate installation
+        # Check for pyproject.toml in the appropriate directory
         has_current_package = False
-        if (output_dir / "pyproject.toml").exists():
+        check_dir = Path(source_path) if source_path else output_dir
+        if (check_dir / "pyproject.toml").exists():
             # Only install current package if deps isn't already pointing to it
             if not (deps.found and deps.is_root_package):
                 has_current_package = True
@@ -189,6 +221,7 @@ class ContainerRuntime:
         """Validate that the agent path can be converted to a valid Python module path."""
         try:
             agent_path = agent_path.resolve()
+            project_root = project_root.resolve()
             relative_path = agent_path.relative_to(project_root)
             for part in relative_path.parts[:-1]:  # Check all directory parts
                 if "-" in part:
@@ -206,6 +239,7 @@ class ContainerRuntime:
         """Get the Python module path for the agent file."""
         try:
             agent_path = agent_path.resolve()
+            project_root = project_root.resolve()
             # Get relative path from project root
             relative_path = agent_path.relative_to(project_root)
             # Convert to module path (e.g., src/agents/my_agent.py -> src.agents.my_agent)
@@ -229,8 +263,21 @@ class ContainerRuntime:
         arch = arch_map.get(machine, machine)
         return f"linux/{arch}"
 
-    def build(self, dockerfile_dir: Path, tag: str, platform: Optional[str] = None) -> Tuple[bool, List[str]]:
-        """Build container image."""
+    def build(
+        self,
+        build_context: Path,
+        tag: str,
+        dockerfile_path: Optional[Path] = None,
+        platform: Optional[str] = None,
+    ) -> Tuple[bool, List[str]]:
+        """Build container image.
+
+        Args:
+            build_context: Directory to use as build context
+            tag: Tag for the built image
+            dockerfile_path: Optional path to Dockerfile (if not in build_context)
+            platform: Optional platform override
+        """
         if not self.has_local_runtime:
             return False, [
                 "No container runtime available for local build",
@@ -239,17 +286,29 @@ class ContainerRuntime:
                 "💡 For local builds, please install Docker, Finch, or Podman",
             ]
 
-        if not dockerfile_dir.exists():
-            return False, [f"Directory not found: {dockerfile_dir}"]
+        if not build_context.exists():
+            return False, [f"Build context directory not found: {build_context}"]
 
-        dockerfile_path = dockerfile_dir / "Dockerfile"
-        if not dockerfile_path.exists():
-            return False, [f"Dockerfile not found in {dockerfile_dir}"]
+        # Determine Dockerfile location
+        if dockerfile_path:
+            # Use provided Dockerfile path
+            if not dockerfile_path.exists():
+                return False, [f"Dockerfile not found: {dockerfile_path}"]
+        else:
+            # Look for Dockerfile in build context
+            dockerfile_path = build_context / "Dockerfile"
+            if not dockerfile_path.exists():
+                return False, [f"Dockerfile not found in {build_context}"]
 
         cmd = [self.runtime, "build", "-t", tag]
+
+        # Use -f flag if Dockerfile is not in the build context
+        if dockerfile_path.parent != build_context:
+            cmd.extend(["-f", str(dockerfile_path)])
+
         build_platform = platform or self.DEFAULT_PLATFORM
         cmd.extend(["--platform", build_platform])
-        cmd.append(str(dockerfile_dir))
+        cmd.append(str(build_context))
 
         return self._execute_command(cmd)
 

bedrock_agentcore_starter_toolkit/utils/runtime/schema.py

@@ -5,10 +5,17 @@ from typing import Dict, List, Literal, Optional
 from pydantic import BaseModel, Field, field_validator
 
 
+class NetworkModeConfig(BaseModel):
+    """Network mode configuration for VPC deployments."""
+
+    security_groups: List[str] = Field(default_factory=list, description="List of security group IDs")
+    subnets: List[str] = Field(default_factory=list, description="List of subnet IDs")
+
+
 class MemoryConfig(BaseModel):
     """Memory configuration for BedrockAgentCore."""
 
-    mode: Literal["STM_ONLY", "STM_AND_LTM"] = Field(
+    mode: Literal["STM_ONLY", "STM_AND_LTM", "NO_MEMORY"] = Field(
         default="STM_ONLY", description="Memory mode - always has STM, optionally adds LTM"
     )
     memory_id: Optional[str] = Field(default=None, description="Memory resource ID")
@@ -18,11 +25,14 @@ class MemoryConfig(BaseModel):
     first_invoke_memory_check_done: bool = Field(
         default=False, description="Whether first invoke memory check has been performed"
     )
+    was_created_by_toolkit: bool = Field(
+        default=False, description="Whether memory was created by toolkit (vs reused existing)"
+    )
 
     @property
     def is_enabled(self) -> bool:
-        """Check if memory is enabled (always true now)."""
-        return True
+        """Check if memory is enabled."""
+        return self.mode != "NO_MEMORY"
 
     @property
     def has_ltm(self) -> bool:
@@ -34,10 +44,38 @@ class NetworkConfiguration(BaseModel):
     """Network configuration for BedrockAgentCore deployment."""
 
     network_mode: str = Field(default="PUBLIC", description="Network mode for deployment")
+    network_mode_config: Optional[NetworkModeConfig] = Field(
+        default=None, description="Network mode configuration (required for VPC mode)"
+    )
+
+    @field_validator("network_mode")
+    @classmethod
+    def validate_network_mode(cls, v: str) -> str:
+        """Validate network mode and ensure VPC config is provided when needed."""
+        valid_modes = ["PUBLIC", "VPC"]
+        if v not in valid_modes:
+            raise ValueError(f"Invalid network_mode: {v}. Must be one of {valid_modes}")
+        return v
+
+    @field_validator("network_mode_config")
+    @classmethod
+    def validate_network_mode_config(cls, v: Optional[NetworkModeConfig], info) -> Optional[NetworkModeConfig]:
+        """Validate that network_mode_config is provided when network_mode is VPC."""
+        if info.data.get("network_mode") == "VPC" and v is None:
+            raise ValueError("network_mode_config is required when network_mode is VPC")
+        return v
 
     def to_aws_dict(self) -> dict:
         """Convert to AWS API format with camelCase keys."""
-        return {"networkMode": self.network_mode}
+        result = {"networkMode": self.network_mode}
+
+        if self.network_mode_config:
+            result["networkModeConfig"] = {
+                "securityGroups": self.network_mode_config.security_groups,
+                "subnets": self.network_mode_config.subnets,
+            }
+
+        return result
 
 
 class ProtocolConfiguration(BaseModel):
@@ -113,6 +151,7 @@ class BedrockAgentCoreAgentSchema(BaseModel):
     entrypoint: str = Field(..., description="Entrypoint file path")
     platform: str = Field(default="linux/amd64", description="Target platform")
     container_runtime: str = Field(default="docker", description="Container runtime to use")
+    source_path: Optional[str] = Field(default=None, description="Directory containing agent source code")
     aws: AWSConfig = Field(default_factory=AWSConfig)
     bedrock_agentcore: BedrockAgentCoreDeploymentInfo = Field(default_factory=BedrockAgentCoreDeploymentInfo)
     codebuild: CodeBuildConfig = Field(default_factory=CodeBuildConfig)

bedrock_agentcore_starter_toolkit/utils/runtime/templates/Dockerfile.j2

@@ -4,6 +4,7 @@ WORKDIR /app
 # All environment variables in one layer
 ENV UV_SYSTEM_PYTHON=1 \
     UV_COMPILE_BYTECODE=1 \
+    UV_NO_PROGRESS=1 \
     PYTHONUNBUFFERED=1 \
     DOCKER_CONTAINER=1{% if aws_region %} \
     AWS_REGION={{ aws_region }} \
@@ -27,12 +28,6 @@ RUN uv pip install -r {{ dependencies_file }}
 RUN uv pip install aws-opentelemetry-distro>=0.10.1
 {% endif %}
 
-# Set AWS region environment variable
-{% if aws_region %}
-ENV AWS_REGION={{ aws_region }}
-ENV AWS_DEFAULT_REGION={{ aws_region }}
-{% endif %}
-
 # Signal that this is running in Docker for host binding logic
 ENV DOCKER_CONTAINER=1
 

bedrock_agentcore_starter_toolkit/utils/runtime/templates/dockerignore.template

@@ -63,6 +63,7 @@ tests/
 # Bedrock AgentCore specific - keep config but exclude runtime files
 .bedrock_agentcore.yaml
 .dockerignore
+.bedrock_agentcore/
 
 # Keep wheelhouse for offline installations
 # wheelhouse/

{bedrock_agentcore_starter_toolkit-0.1.21.dist-info → bedrock_agentcore_starter_toolkit-0.1.23.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bedrock-agentcore-starter-toolkit
-Version: 0.1.21
+Version: 0.1.23
 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