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

bedrock_agentcore_starter_toolkit/cli/cli.py

@@ -6,7 +6,7 @@ from ..cli.gateway.commands import create_mcp_gateway, create_mcp_gateway_target
 from ..utils.logging_config import setup_toolkit_logging
 from .runtime.commands import configure_app, invoke, launch, status
 
-app = typer.Typer(name="agentcore", help="BedrockAgentCore CLI", add_completion=False)
+app = typer.Typer(name="agentcore", help="BedrockAgentCore CLI", add_completion=False, rich_markup_mode="rich")
 
 # Setup centralized logging for CLI
 setup_toolkit_logging(mode="cli")

bedrock_agentcore_starter_toolkit/cli/common.py

@@ -18,7 +18,7 @@ def _handle_error(message: str, exception: Optional[Exception] = None) -> NoRetu
         raise typer.Exit(1)
 
 
-def _handle_warn(message: str) -> NoReturn:
+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")
 

bedrock_agentcore_starter_toolkit/cli/runtime/commands.py

@@ -262,35 +262,102 @@ def launch(
     agent: Optional[str] = typer.Option(
         None, "--agent", "-a", help="Agent name (use 'agentcore configure list' to see available agents)"
     ),
-    local: bool = typer.Option(False, "--local", "-l", help="Run locally"),
-    push_ecr: bool = typer.Option(False, "--push-ecr", "-p", help="Build and push to ECR only (no deployment)"),
-    codebuild: bool = typer.Option(False, "--codebuild", "-cb", help="Use CodeBuild for ARM64 builds"),
+    local: bool = typer.Option(
+        False, "--local", "-l", help="Build locally and run container locally - requires Docker/Finch/Podman"
+    ),
+    local_build: bool = typer.Option(
+        False,
+        "--local-build",
+        "-lb",
+        help="Build locally and deploy to cloud runtime - requires Docker/Finch/Podman",
+    ),
     auto_update_on_conflict: bool = typer.Option(
-        False, "--auto-update-on-conflict", help="Enable automatic update when agent already exists"
+        False,
+        "--auto-update-on-conflict",
+        "-auc",
+        help="Automatically update existing agent instead of failing with ConflictException",
     ),
     envs: List[str] = typer.Option(  # noqa: B008
         None, "--env", "-env", help="Environment variables for agent (format: KEY=VALUE)"
     ),
+    code_build: bool = typer.Option(
+        False,
+        "--code-build",
+        help="[DEPRECATED] CodeBuild is now the default. Use no flags for CodeBuild deployment.",
+        hidden=True,
+    ),
 ):
-    """Launch Bedrock AgentCore locally or to cloud."""
+    """Launch Bedrock AgentCore with three deployment modes.
+
+    🚀 DEFAULT (no flags): CodeBuild + cloud runtime (RECOMMENDED)
+       - Build ARM64 containers in the cloud with CodeBuild
+       - Deploy to Bedrock AgentCore runtime
+       - No local Docker required
+       - CHANGED: CodeBuild is now the default (previously required --code-build flag)
+
+    💻 --local: Local build + local runtime
+       - Build container locally and run locally
+       - requires Docker/Finch/Podman
+       - For local development and testing
+
+    🔧 --local-build: Local build + cloud runtime
+       - Build container locally with Docker
+       - Deploy to Bedrock AgentCore runtime
+       - requires Docker/Finch/Podman
+       - Use when you need custom build control but want cloud deployment
+
+    MIGRATION GUIDE:
+    - OLD: agentcore launch --code-build  →  NEW: agentcore launch
+    - OLD: agentcore launch --local       →  NEW: agentcore launch --local (unchanged)
+    - NEW: agentcore launch --local-build (build locally + deploy to cloud)
+    """
+    # Handle deprecated --code-build flag
+    if code_build:
+        console.print("[yellow]⚠️  DEPRECATION WARNING: --code-build flag is deprecated[/yellow]")
+        console.print("[yellow]   CodeBuild is now the default deployment method[/yellow]")
+        console.print("[yellow]   MIGRATION: Simply use 'agentcore launch' (no flags needed)[/yellow]")
+        console.print("[yellow]   This flag will be removed in a future version[/yellow]\n")
+
     # Validate mutually exclusive options
-    if sum([local, push_ecr, codebuild]) > 1:
-        _handle_error("Error: --local, --push-ecr, and --codebuild cannot be used together")
+    if sum([local, local_build, code_build]) > 1:
+        _handle_error("Error: --local, --local-build, and --code-build cannot be used together")
 
     config_path = Path.cwd() / ".bedrock_agentcore.yaml"
 
     try:
-        # Show launch mode
+        # Show launch mode with enhanced migration guidance
         if local:
             mode = "local"
-        elif push_ecr:
-            mode = "push-ecr"
-        elif codebuild:
+            console.print(f"[cyan]🏠 Launching Bedrock AgentCore ({mode} mode)...[/cyan]")
+            console.print("[dim]   • Build and run container locally[/dim]")
+            console.print("[dim]   • Requires Docker/Finch/Podman to be installed[/dim]")
+            console.print("[dim]   • Perfect for development and testing[/dim]\n")
+        elif local_build:
+            mode = "local-build"
+            console.print(f"[cyan]🔧 Launching Bedrock AgentCore ({mode} mode - NEW!)...[/cyan]")
+            console.print("[dim]   • Build container locally with Docker[/dim]")
+            console.print("[dim]   • Deploy to Bedrock AgentCore cloud runtime[/dim]")
+            console.print("[dim]   • Requires Docker/Finch/Podman to be installed[/dim]")
+            console.print("[dim]   • Use when you need custom build control[/dim]\n")
+        elif code_build:
+            # Handle deprecated flag - treat as default
             mode = "codebuild"
+            console.print(f"[cyan]🚀 Launching Bedrock AgentCore ({mode} mode - RECOMMENDED)...[/cyan]")
+            console.print("[dim]   • Build ARM64 containers in the cloud with CodeBuild[/dim]")
+            console.print("[dim]   • No local Docker required[/dim]")
+            console.print("[dim]   • Production-ready deployment[/dim]\n")
         else:
-            mode = "cloud"
+            mode = "codebuild"
+            console.print(f"[cyan]🚀 Launching Bedrock AgentCore ({mode} mode - RECOMMENDED)...[/cyan]")
+            console.print("[dim]   • Build ARM64 containers in the cloud with CodeBuild[/dim]")
+            console.print("[dim]   • No local Docker required (DEFAULT behavior)[/dim]")
+            console.print("[dim]   • Production-ready deployment[/dim]\n")
 
-        console.print(f"[cyan]Launching Bedrock AgentCore ({mode} mode)...[/cyan]\n")
+            # Show deployment options hint for first-time users
+            console.print("[dim]💡 Deployment options:[/dim]")
+            console.print("[dim]   • agentcore launch                → CodeBuild (current)[/dim]")
+            console.print("[dim]   • agentcore launch --local        → Local development[/dim]")
+            console.print("[dim]   • agentcore launch --local-build  → Local build + cloud deploy[/dim]\n")
 
         # Use the operations module
         with console.status("[bold]Launching Bedrock AgentCore...[/bold]"):
@@ -304,13 +371,12 @@ def launch(
                     key, value = env_var.split("=", 1)
                     env_vars[key] = value
 
-            # Call the operation
+            # Call the operation - CodeBuild is now default, unless --local-build is specified
             result = launch_bedrock_agentcore(
                 config_path=config_path,
                 agent_name=agent,
                 local=local,
-                push_ecr_only=push_ecr,
-                use_codebuild=codebuild,
+                use_codebuild=not local_build,
                 env_vars=env_vars,
                 auto_update_on_conflict=auto_update_on_conflict,
             )
@@ -330,20 +396,6 @@ def launch(
             except KeyboardInterrupt:
                 console.print("\n[yellow]Stopped[/yellow]")
 
-        elif result.mode == "push-ecr":
-            _print_success(f"Image pushed to ECR: [cyan]{result.ecr_uri}:latest[/cyan]")
-            console.print(
-                Panel(
-                    f"[green]ECR Push Successful![/green]\n\n"
-                    f"Image: [cyan]{result.tag}[/cyan]\n"
-                    f"ECR URI: [cyan]{result.ecr_uri}:latest[/cyan]\n\n"
-                    f"Your image is now available in ECR.\n"
-                    f"Run [cyan]agentcore launch[/cyan] to deploy to Bedrock AgentCore.",
-                    title="Push to ECR Complete",
-                    border_style="green",
-                )
-            )
-
         elif result.mode == "codebuild":
             _print_success(f"CodeBuild completed: [cyan]{result.codebuild_id}[/cyan]")
             _print_success(f"ARM64 image pushed to ECR: [cyan]{result.ecr_uri}:latest[/cyan]")
@@ -386,13 +438,22 @@ def launch(
                 )
             )
 
-        else:  # cloud mode
+        else:  # cloud mode (either CodeBuild default or local-build)
             _print_success(f"Image pushed to ECR: [cyan]{result.ecr_uri}:latest[/cyan]")
 
             # Show deployment success panel
             agent_name = result.tag.split(":")[0].replace("bedrock_agentcore-", "")
+
+            # Determine deployment type for panel title
+            if local_build:
+                title = "Local Build Deployment Complete"
+                deployment_type = "Local Docker Build Deployment Successful!"
+            else:
+                title = "CodeBuild Deployment Complete"
+                deployment_type = "CodeBuild Deployment Successful!"
+
             deploy_panel = (
-                f"[green]Deployment Successful![/green]\n\n"
+                f"[green]{deployment_type}[/green]\n\n"
                 f"Agent Name: {agent_name}\n"
                 f"Agent ARN: [cyan]{result.agent_arn}[/cyan]\n"
                 f"ECR URI: [cyan]{result.ecr_uri}[/cyan]\n\n"
@@ -420,7 +481,7 @@ def launch(
             console.print(
                 Panel(
                     deploy_panel,
-                    title="Bedrock AgentCore Deployed",
+                    title=title,
                     border_style="green",
                 )
             )
@@ -484,7 +545,14 @@ def invoke(
 
         # Display payload
         console.print("[bold]Payload:[/bold]")
-        console.print(Syntax(json.dumps(payload_data, indent=2), "json", background_color="default", word_wrap=True))
+        console.print(
+            Syntax(
+                json.dumps(payload_data, indent=2, ensure_ascii=False),
+                "json",
+                background_color="default",
+                word_wrap=True,
+            )
+        )
 
         # Invoke
         result = invoke_bedrock_agentcore(
@@ -497,17 +565,31 @@ def invoke(
             local_mode=local_mode,
         )
         console.print(f"Session ID: [cyan]{result.session_id}[/cyan]")
-        console.print("\n[bold]Response:[/bold]")
-        console.print(
-            Syntax(
-                json.dumps(result.response, indent=2, default=str), "json", background_color="default", word_wrap=True
+        if result.response != {}:
+            console.print("\n[bold]Response:[/bold]")
+            console.print(
+                Syntax(
+                    json.dumps(result.response, indent=2, default=str, ensure_ascii=False),
+                    "json",
+                    background_color="default",
+                    word_wrap=True,
+                )
             )
-        )
 
     except FileNotFoundError:
-        _handle_error(".bedrock_agentcore.yaml not found. Run 'bedrock_agentcore configure --entrypoint <file>' first")
+        console.print("[red].bedrock_agentcore.yaml not found[/red]")
+        console.print("Run the following commands to get started:")
+        console.print("  1. agentcore configure --entrypoint your_agent.py")
+        console.print("  2. agentcore launch")
+        console.print('  3. agentcore invoke \'{"message": "Hello"}\'')
+        raise typer.Exit(1) from None
     except ValueError as e:
         if "not deployed" in str(e):
+            console.print("[yellow]Agent not deployed yet[/yellow]")
+            console.print("Deploy your agent first:")
+            console.print("  agentcore launch                    # Deploy to AWS (recommended)")
+            console.print("  agentcore launch --local            # Run locally")
+            console.print("Then check status: agentcore status")
             _handle_error("Bedrock AgentCore not deployed. Run 'bedrock_agentcore launch' first", e)
         else:
             _handle_error(f"Invocation failed: {e}", e)
@@ -639,12 +721,20 @@ def status(
         else:  # full json verbose output
             console.print(
                 Syntax(
-                    json.dumps(status_json, indent=2, default=str), "json", background_color="default", word_wrap=True
+                    json.dumps(status_json, indent=2, default=str, ensure_ascii=False),
+                    "json",
+                    background_color="default",
+                    word_wrap=True,
                 )
             )
 
     except FileNotFoundError:
-        _handle_error(".bedrock_agentcore.yaml not found. Run 'bedrock_agentcore configure --entrypoint <file>' first")
+        console.print("[yellow]Configuration not found[/yellow]")
+        console.print("Run the following commands to get started:")
+        console.print("  1. agentcore configure --entrypoint your_agent.py")
+        console.print("  2. agentcore launch")
+        console.print('  3. agentcore invoke \'{"message": "Hello"}\'')
+        raise typer.Exit(1) from None
     except ValueError as e:
         _handle_error(f"Status failed: {e}", e)
     except Exception as e:

bedrock_agentcore_starter_toolkit/notebook/runtime/bedrock_agentcore.py

@@ -45,6 +45,7 @@ class Runtime:
         authorizer_configuration: Optional[Dict[str, Any]] = None,
         region: Optional[str] = None,
         protocol: Optional[Literal["HTTP", "MCP"]] = None,
+        disable_otel: bool = False,
     ) -> ConfigureResult:
         """Configure Bedrock AgentCore from notebook using an entrypoint file.
 
@@ -62,6 +63,7 @@ class Runtime:
             authorizer_configuration: JWT authorizer configuration dictionary
             region: AWS region for deployment
             protocol: agent server protocol, must be either HTTP or MCP
+            disable_otel: Whether to disable OpenTelemetry observability (default: False)
 
         Returns:
             ConfigureResult with configuration details
@@ -110,6 +112,7 @@ class Runtime:
             ecr_repository=ecr_repository,
             container_runtime=container_runtime,
             auto_create_ecr=auto_create_ecr,
+            enable_observability=not disable_otel,
             requirements_file=final_requirements_file,
             authorizer_configuration=authorizer_configuration,
             region=region,
@@ -123,17 +126,15 @@ class Runtime:
     def launch(
         self,
         local: bool = False,
-        push_ecr: bool = False,
-        use_codebuild: bool = False,
+        local_build: bool = False,
         auto_update_on_conflict: bool = False,
         env_vars: Optional[Dict] = None,
     ) -> LaunchResult:
         """Launch Bedrock AgentCore from notebook.
 
         Args:
-            local: Whether to build for local execution only
-            push_ecr: Whether to push to ECR only (no deployment)
-            use_codebuild: Whether to use CodeBuild for ARM64 builds (cloud deployment only)
+            local: Whether to build and run locally (requires Docker/Finch/Podman)
+            local_build: Whether to build locally and deploy to cloud (requires Docker/Finch/Podman)
             auto_update_on_conflict: Whether to automatically update resources on conflict (default: False)
             env_vars: environment variables for agent container
 
@@ -141,26 +142,75 @@ class Runtime:
             LaunchResult with deployment details
         """
         if not self._config_path:
+            log.warning("Configuration required before launching")
+            log.info("Call .configure() first to set up your agent")
+            log.info("Example: runtime.configure(entrypoint='my_agent.py')")
             raise ValueError("Must configure before launching. Call .configure() first.")
 
-        # Validate mutually exclusive options
-        exclusive_options = [local, push_ecr, use_codebuild]
-        if sum(exclusive_options) > 1:
-            raise ValueError("Only one of 'local', 'push_ecr', or 'use_codebuild' can be True")
-
-        result = launch_bedrock_agentcore(
-            self._config_path,
-            local=local,
-            push_ecr_only=push_ecr,
-            use_codebuild=use_codebuild,
-            auto_update_on_conflict=auto_update_on_conflict,
-            env_vars=env_vars,
-        )
+        # Enhanced validation for mutually exclusive options with helpful guidance
+        if local and local_build:
+            raise ValueError(
+                "Cannot use both 'local' and 'local_build' flags together.\n"
+                "Choose one deployment mode:\n"
+                "• runtime.launch(local=True) - for local development\n"
+                "• runtime.launch(local_build=True) - for local build + cloud deployment\n"
+                "• runtime.launch() - for CodeBuild deployment (recommended)"
+            )
+
+        # Inform user about deployment mode with enhanced migration guidance
+        if local:
+            log.info("🏠 Local mode: building and running locally")
+            log.info("   • Build and run container locally")
+            log.info("   • Requires Docker/Finch/Podman to be installed")
+            log.info("   • Perfect for development and testing")
+        elif local_build:
+            log.info("🔧 Local build mode: building locally, deploying to cloud (NEW OPTION!)")
+            log.info("   • Build container locally with Docker")
+            log.info("   • Deploy to Bedrock AgentCore cloud runtime")
+            log.info("   • Requires Docker/Finch/Podman to be installed")
+            log.info("   • Use when you need custom build control")
+        else:
+            log.info("🚀 CodeBuild mode: building in cloud (RECOMMENDED - DEFAULT)")
+            log.info("   • Build ARM64 containers in the cloud with CodeBuild")
+            log.info("   • No local Docker required")
+
+            # Show deployment options hint for first-time notebook users
+            log.info("💡 Available deployment modes:")
+            log.info("   • runtime.launch()                           → CodeBuild (current)")
+            log.info("   • runtime.launch(local=True)                 → Local development")
+            log.info("   • runtime.launch(local_build=True)           → Local build + cloud deploy (NEW)")
+
+        # Map to the underlying operation's use_codebuild parameter
+        # use_codebuild=False when local=True OR local_build=True
+        use_codebuild = not (local or local_build)
+
+        try:
+            result = launch_bedrock_agentcore(
+                self._config_path,
+                local=local,
+                use_codebuild=use_codebuild,
+                auto_update_on_conflict=auto_update_on_conflict,
+                env_vars=env_vars,
+            )
+        except RuntimeError as e:
+            # Enhance Docker-related error messages
+            error_msg = str(e)
+            if "docker" in error_msg.lower() or "container runtime" in error_msg.lower():
+                if local or local_build:
+                    enhanced_msg = (
+                        f"Docker/Finch/Podman is required for {'local' if local else 'local-build'} mode.\n\n"
+                    )
+                    enhanced_msg += "Options to fix this:\n"
+                    enhanced_msg += "1. Install Docker/Finch/Podman and try again\n"
+                    enhanced_msg += "2. Use CodeBuild mode instead: runtime.launch() - no Docker required\n\n"
+                    enhanced_msg += f"Original error: {error_msg}"
+                    raise RuntimeError(enhanced_msg) from e
+            raise
 
         if result.mode == "cloud":
             log.info("Deployed to cloud: %s", result.agent_arn)
-            # Show log information for cloud deployments
-            if result.agent_id:
+            # For local_build mode, show minimal output; for pure cloud mode, show log details
+            if not local_build and result.agent_id:
                 from ...utils.runtime.logs import get_agent_log_paths, get_aws_tail_commands
 
                 runtime_logs, otel_logs = get_agent_log_paths(result.agent_id)
@@ -185,11 +235,14 @@ class Runtime:
                 log.info("   %s", otel_logs)
                 log.info("💡 Tail logs with: %s", follow_cmd)
                 log.info("💡 Or view recent logs: %s", since_cmd)
-        elif result.mode == "push-ecr":
-            log.info("Pushed to ECR: %s", result.ecr_uri)
         else:
             log.info("Built for local: %s", result.tag)
 
+        # For notebook interface, clear verbose build output to keep output clean
+        # especially for local_build mode where build logs can be very verbose
+        if local_build and hasattr(result, "build_output"):
+            result.build_output = None
+
         return result
 
     def invoke(
@@ -213,6 +266,12 @@ class Runtime:
             Response from the Bedrock AgentCore endpoint
         """
         if not self._config_path:
+            log.warning("Agent not configured and deployed")
+            log.info("Required workflow: .configure() → .launch() → .invoke()")
+            log.info("Example:")
+            log.info("  runtime.configure(entrypoint='my_agent.py')")
+            log.info("  runtime.launch()")
+            log.info("  runtime.invoke({'message': 'Hello'})")
             raise ValueError("Must configure and launch first.")
 
         result = invoke_bedrock_agentcore(
@@ -232,8 +291,47 @@ class Runtime:
             StatusResult with configuration, agent, and endpoint status
         """
         if not self._config_path:
+            log.warning("Configuration not found")
+            log.info("Call .configure() first to set up your agent")
+            log.info("Example: runtime.configure(entrypoint='my_agent.py')")
             raise ValueError("Must configure first. Call .configure() first.")
 
         result = get_status(self._config_path)
         log.info("Retrieved Bedrock AgentCore status for: %s", self.name or "Bedrock AgentCore")
         return result
+
+    def help_deployment_modes(self):
+        """Display information about available deployment modes and migration guidance."""
+        print("\n🚀 Bedrock AgentCore Deployment Modes:")
+        print("=" * 50)
+
+        print("\n1. 📦 CodeBuild Mode (RECOMMENDED - DEFAULT)")
+        print("   Usage: runtime.launch()")
+        print("   • Build ARM64 containers in the cloud with CodeBuild")
+        print("   • No local Docker/Finch/Podman required")
+        print("   • ✅ Works in SageMaker Notebooks, Cloud9, laptops")
+
+        print("\n2. 🏠 Local Development Mode")
+        print("   Usage: runtime.launch(local=True)")
+        print("   • Build and run container locally")
+        print("   • Requires Docker/Finch/Podman installation")
+        print("   • Perfect for development and testing")
+        print("   • Fast iteration and debugging")
+
+        print("\n3. 🔧 Local Build Mode (NEW!)")
+        print("   Usage: runtime.launch(local_build=True)")
+        print("   • Build container locally with Docker")
+        print("   • Deploy to Bedrock AgentCore cloud runtime")
+        print("   • Requires Docker/Finch/Podman installation")
+        print("   • Use when you need custom build control")
+
+        print("\n📋 Migration Guide:")
+        print("   • CodeBuild is now the default (no code changes needed)")
+        print("   • Previous --code-build flag is deprecated")
+        print("   • local_build=True option for hybrid workflows")
+
+        print("\n💡 Quick Start:")
+        print("   runtime.configure(entrypoint='my_agent.py')")
+        print("   runtime.launch()  # Uses CodeBuild by default")
+        print('   runtime.invoke({"prompt": "Hello"})')
+        print()

bedrock_agentcore_starter_toolkit/operations/runtime/configure.py

@@ -145,11 +145,14 @@ def configure_bedrock_agentcore(
         log.debug("Agent name from BedrockAgentCoreApp: %s", agent_name)
         log.debug("Config path: %s", config_path)
 
+    # Convert to POSIX for cross-platform compatibility
+    entrypoint_path_str = entrypoint_path.as_posix()
+
     # Determine entrypoint format
     if bedrock_agentcore_name:
-        entrypoint = f"{str(entrypoint_path)}:{bedrock_agentcore_name}"
+        entrypoint = f"{entrypoint_path_str}:{bedrock_agentcore_name}"
     else:
-        entrypoint = str(entrypoint_path)
+        entrypoint = entrypoint_path_str
 
     if verbose:
         log.debug("Using entrypoint format: %s", entrypoint)

bedrock_agentcore_starter_toolkit/operations/runtime/invoke.py

@@ -53,7 +53,7 @@ def invoke_bedrock_agentcore(
 
     # Convert payload to string if needed
     if isinstance(payload, dict):
-        payload_str = json.dumps(payload)
+        payload_str = json.dumps(payload, ensure_ascii=False)
     else:
         payload_str = str(payload)
 

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/runtime.py

@@ -10,9 +10,13 @@ from typing import Any, Dict, Optional
 import boto3
 import requests
 from botocore.exceptions import ClientError
+from rich.console import Console
 
 from ..utils.endpoints import get_control_plane_endpoint, get_data_plane_endpoint
 
+logger = logging.getLogger(__name__)
+console = Console()
+
 
 def generate_session_id() -> str:
     """Generate session ID."""
@@ -47,19 +51,26 @@ def _handle_aws_response(response) -> dict:
 
 
 def _handle_streaming_response(response) -> Dict[str, Any]:
-    logger = logging.getLogger("bedrock_agentcore.stream")
-    logger.setLevel(logging.INFO)
-
-    content = []
+    complete_text = ""
     for line in response.iter_lines(chunk_size=1):
         if line:
             line = line.decode("utf-8")
             if line.startswith("data: "):
-                line = line[6:]
-                logger.info(line)
-                content.append(line)
-
-    return {"response": "\n".join(content)}
+                json_chunk = line[6:]
+                try:
+                    parsed_chunk = json.loads(json_chunk)
+                    if isinstance(parsed_chunk, str):
+                        text_chunk = parsed_chunk
+                    else:
+                        text_chunk = json.dumps(parsed_chunk, ensure_ascii=False)
+                        text_chunk += "\n"
+                    console.print(text_chunk, end="", style="bold cyan")
+                    complete_text += text_chunk
+                except json.JSONDecodeError:
+                    console.print(json_chunk, style="bold cyan")
+                    continue
+    console.print()
+    return {}
 
 
 class BedrockAgentCoreClient:
@@ -128,7 +139,19 @@ class BedrockAgentCoreClient:
             if error_code == "ConflictException":
                 if not auto_update_on_conflict:
                     self.logger.error("Agent '%s' already exists and auto_update_on_conflict is disabled", agent_name)
-                    raise
+                    # Create a more helpful error message
+                    raise ClientError(
+                        {
+                            "Error": {
+                                "Code": "ConflictException",
+                                "Message": (
+                                    f"Agent '{agent_name}' already exists. To update the existing agent, "
+                                    "use the --auto-update-on-conflict flag with the launch command."
+                                ),
+                            }
+                        },
+                        "CreateAgentRuntime",
+                    ) from e
 
                 self.logger.info("Agent '%s' already exists, searching for existing agent...", agent_name)
 
@@ -428,7 +451,7 @@ class HttpBedrockAgentCoreClient:
                 params={"qualifier": endpoint_name},
                 headers=headers,
                 json=body,
-                timeout=100,
+                timeout=900,
                 stream=True,
             )
             return _handle_http_response(response)
@@ -466,7 +489,7 @@ class LocalBedrockAgentCoreClient:
 
         try:
             # Make request with timeout
-            response = requests.post(url, headers=headers, json=body, timeout=100, stream=True)
+            response = requests.post(url, headers=headers, json=body, timeout=900, stream=True)
             return _handle_http_response(response)
         except requests.exceptions.RequestException as e:
             self.logger.error("Failed to invoke agent endpoint: %s", str(e))

bedrock_agentcore_starter_toolkit/utils/runtime/container.py

@@ -29,21 +29,56 @@ class ContainerRuntime:
         """
         runtime_type = runtime_type or self.DEFAULT_RUNTIME
         self.available_runtimes = ["finch", "docker", "podman"]
+        self.runtime = None
+        self.has_local_runtime = False
 
         if runtime_type == "auto":
             for runtime in self.available_runtimes:
                 if self._is_runtime_installed(runtime):
                     self.runtime = runtime
+                    self.has_local_runtime = True
                     break
             else:
-                raise RuntimeError("No container runtime found. Please install Docker, Finch, or Podman.")
+                # 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"
+                )
+                self.runtime = "none"
+                self.has_local_runtime = False
         elif runtime_type in self.available_runtimes:
             if self._is_runtime_installed(runtime_type):
                 self.runtime = runtime_type
+                self.has_local_runtime = True
             else:
-                raise RuntimeError(f"{runtime_type.capitalize()} is not installed")
+                # 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()}"
+                )
+                self.runtime = "none"
+                self.has_local_runtime = False
         else:
-            raise ValueError(f"Unsupported runtime: {runtime_type}")
+            if runtime_type == "none":
+                raise ValueError(
+                    "No supported container engine found.\n\n"
+                    "AgentCore requires one of the following container engines for local builds:\n"
+                    "• Docker (any recent version, including Docker Desktop)\n"
+                    "• Finch (Amazon's open-source container engine)\n"
+                    "• Podman (compatible alternative to Docker)\n\n"
+                    "To install:\n"
+                    "• Docker: https://docs.docker.com/get-docker/\n"
+                    "• Finch: https://github.com/runfinch/finch\n"
+                    "• Podman: https://podman.io/getting-started/installation\n\n"
+                    "Alternative: Use CodeBuild for cloud-based building (no container engine needed):\n"
+                    "  agentcore launch  # Uses CodeBuild (default)"
+                )
+            else:
+                raise ValueError(f"Unsupported runtime: {runtime_type}")
 
     def _is_runtime_installed(self, runtime: str) -> bool:
         """Check if runtime is installed."""
@@ -190,6 +225,14 @@ class ContainerRuntime:
 
     def build(self, dockerfile_dir: Path, tag: str, platform: Optional[str] = None) -> Tuple[bool, List[str]]:
         """Build container image."""
+        if not self.has_local_runtime:
+            return False, [
+                "No container runtime available for local build",
+                "💡 Recommendation: Use CodeBuild for building containers in the cloud",
+                "💡 Run 'agentcore launch' (default) for CodeBuild deployment",
+                "💡 For local builds, please install Docker, Finch, or Podman",
+            ]
+
         if not dockerfile_dir.exists():
             return False, [f"Directory not found: {dockerfile_dir}"]
 
@@ -212,6 +255,14 @@ class ContainerRuntime:
             port: Port to expose (default: 8080)
             env_vars: Additional environment variables to pass to container
         """
+        if not self.has_local_runtime:
+            raise RuntimeError(
+                "No container runtime available for local run\n"
+                "💡 Recommendation: Use CodeBuild for building containers in the cloud\n"
+                "💡 Run 'agentcore launch' (default) for CodeBuild deployment\n"
+                "💡 For local runs, please install Docker, Finch, or Podman"
+            )
+
         container_name = f"{tag.split(':')[0]}-{int(time.time())}"
         cmd = [self.runtime, "run", "-it", "--rm", "-p", f"{port}:8080", "--name", container_name]
 

bedrock_agentcore_starter_toolkit/utils/runtime/entrypoint.py

@@ -144,7 +144,6 @@ def _handle_explicit_file(package_dir: Path, explicit_file: str) -> DependencyIn
     # Ensure file is within project directory for Docker context
     try:
         relative_path = explicit_path.relative_to(package_dir.resolve())
-        file_path = str(relative_path)
     except ValueError:
         raise ValueError(
             f"Requirements file must be within project directory. File: {explicit_path}, Project: {package_dir}"
@@ -155,14 +154,21 @@ def _handle_explicit_file(package_dir: Path, explicit_file: str) -> DependencyIn
     install_path = None
 
     if file_type == "pyproject":
-        if "/" in file_path:
+        if len(relative_path.parts) > 1:
             # pyproject.toml in subdirectory - install from that directory
-            install_path = str(Path(file_path).parent)
+            install_path = Path(relative_path).parent
         else:
             # pyproject.toml in root - install from current directory
-            install_path = "."
+            install_path = Path(".")
 
-    return DependencyInfo(file=file_path, type=file_type, resolved_path=str(explicit_path), install_path=install_path)
+    # Get POSIX strings for file and install path
+    file_path = relative_path.as_posix()
+    install_path = install_path and install_path.as_posix()
+
+    # Maintain local format for explicit path
+    explicit_path = str(explicit_path)
+
+    return DependencyInfo(file=file_path, type=file_type, resolved_path=explicit_path, install_path=install_path)
 
 
 def validate_requirements_file(build_dir: Path, requirements_file: str) -> DependencyInfo:

{bedrock_agentcore_starter_toolkit-0.1.2.dist-info → bedrock_agentcore_starter_toolkit-0.1.3.dist-info}/METADATA

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

{bedrock_agentcore_starter_toolkit-0.1.2.dist-info → bedrock_agentcore_starter_toolkit-0.1.3.dist-info}/RECORD

@@ -1,14 +1,14 @@
 bedrock_agentcore_starter_toolkit/__init__.py,sha256=tN3-JWKvxk4ZSJQJIHQ4mMsDtt8J_cDCz-drcGU9USA,120
-bedrock_agentcore_starter_toolkit/cli/cli.py,sha256=cZ9rQ5i46kq38W3U4HxWH6zKQGWl0nUZkUB6UHu19Bw,850
-bedrock_agentcore_starter_toolkit/cli/common.py,sha256=eVjxsQQC4RjvyZouRBTUBPjoWDSE4yQ6q9Mi6WsuDrc,1315
+bedrock_agentcore_starter_toolkit/cli/cli.py,sha256=r_SNlkUH5L6Cbvv17ssjd4McKP9gwgQhCTFULN0G0kA,875
+bedrock_agentcore_starter_toolkit/cli/common.py,sha256=R9ZRKmW9gq7u7gkTiCUOTCQTno2lXnsplnq2x0-k2v8,1311
 bedrock_agentcore_starter_toolkit/cli/gateway/__init__.py,sha256=8IZ0kSe6Kz5s2j-SBsoc6qy04MbK85RMTQwZCiR2wmo,68
 bedrock_agentcore_starter_toolkit/cli/gateway/commands.py,sha256=3DuXCvqXlmHU2cmjGzDruyc2Fkrpgoi158myj0vc3nA,3265
 bedrock_agentcore_starter_toolkit/cli/runtime/__init__.py,sha256=0zKPPoYThoDIr3DZhIQJavq5nVTKRsgcE1s9--wx118,60
-bedrock_agentcore_starter_toolkit/cli/runtime/commands.py,sha256=LgErKPNHXqBavdz8Bqngc90tUEBSZg4V2oClqAw1G4w,28422
+bedrock_agentcore_starter_toolkit/cli/runtime/commands.py,sha256=4Mk4ZjlgzYA55Zt--wCDxC84pgso7hpDhdLIUn1f3CI,33141
 bedrock_agentcore_starter_toolkit/cli/runtime/configuration_manager.py,sha256=5TJK80uzA1ARh263smLfthw1t5Ona3bAtdO1pE7OfNo,5808
 bedrock_agentcore_starter_toolkit/notebook/__init__.py,sha256=wH1ZzIVKsKT_P0qX2kIIoyVxeHj8K40odfR1YI3McHw,129
 bedrock_agentcore_starter_toolkit/notebook/runtime/__init__.py,sha256=DoGfB_uGFLANJVE9rSZtTH3ymw76WBWmD9vORvBIdXs,66
-bedrock_agentcore_starter_toolkit/notebook/runtime/bedrock_agentcore.py,sha256=ep-NVyzjHJfPRhVeuJxpcIbg8FEYHMFF4BwudurjBe0,9738
+bedrock_agentcore_starter_toolkit/notebook/runtime/bedrock_agentcore.py,sha256=UvG-X9Ny_z4VhMG8BNTy-OaZMFU4VIQ8QIHz2lm7Dyo,15328
 bedrock_agentcore_starter_toolkit/operations/__init__.py,sha256=L7sCNjfZviiVVoh2f3NEs2sbjNqFkmIRI3ZPYMMWMz0,51
 bedrock_agentcore_starter_toolkit/operations/gateway/README.md,sha256=aJla3qAaZmM0b4t9q4lQYqfamAugU0FyyzsufFMRi_A,8192
 bedrock_agentcore_starter_toolkit/operations/gateway/__init__.py,sha256=5Qo1GeN-DghNp9g0coFUs7WpUJDboJoidOVs-5Co7fo,233
@@ -18,20 +18,20 @@ bedrock_agentcore_starter_toolkit/operations/gateway/create_lambda.py,sha256=MQs
 bedrock_agentcore_starter_toolkit/operations/gateway/create_role.py,sha256=a38JE28PbdRabskTgLXsiqHqWS1vt06jxEEGneYPO_g,3145
 bedrock_agentcore_starter_toolkit/operations/gateway/exceptions.py,sha256=WjsrE7lT2708CJniM_ISMzkfNX4IUteGgvOxleD9JZY,272
 bedrock_agentcore_starter_toolkit/operations/runtime/__init__.py,sha256=7ucAtIbabrDmEaHOfGqHtEr2CkQlEsb5O2tkHirXCqU,673
-bedrock_agentcore_starter_toolkit/operations/runtime/configure.py,sha256=BIvFX5EF73X8VNOKQThsyYSWTWLDUkM4di8HW1MGVe8,8948
+bedrock_agentcore_starter_toolkit/operations/runtime/configure.py,sha256=7xjNN6fn1U2cv20W2tmHdlbSjc-RU953tnbOaH5iXPQ,9056
 bedrock_agentcore_starter_toolkit/operations/runtime/create_role.py,sha256=5-BL_EA1LFy6vSTl5Rppj1et7Y0tuaB8C9-Ze4ESt1A,15952
-bedrock_agentcore_starter_toolkit/operations/runtime/invoke.py,sha256=klDICZq-EHcxDjJhb1oVa7-vuFUvq5-HioqWrk__H_E,4539
-bedrock_agentcore_starter_toolkit/operations/runtime/launch.py,sha256=6zOt6BEd4rcQz57WIH9MtOqCBN0FEUfp7B68gjXV3jk,15940
-bedrock_agentcore_starter_toolkit/operations/runtime/models.py,sha256=6xzNOTSeJj-9kXQKWOGECrBbYopHNNrZfUBsEvl1fNg,3683
+bedrock_agentcore_starter_toolkit/operations/runtime/invoke.py,sha256=ZcPXI7Zx7NO7G7fM2xY6JKVoo2CR2sdyBlBJ63Pd6MI,4559
+bedrock_agentcore_starter_toolkit/operations/runtime/launch.py,sha256=vG6SFKVWtKNtxIkpDA9tHlvHDs1LYA4_t-M_RUXXfyo,19206
+bedrock_agentcore_starter_toolkit/operations/runtime/models.py,sha256=Qr45hc73a25cqmiSErq9-degckPXuVhnENyDSshU_mU,3673
 bedrock_agentcore_starter_toolkit/operations/runtime/status.py,sha256=tpOtzAq1S3z_7baxR_WOT8Avo3MtWKGpelVOOfb-uMA,2516
 bedrock_agentcore_starter_toolkit/services/codebuild.py,sha256=i5VbjqAWrPsPwLUdGSWI-_beqFHPqN3FnVLKM4s3rSo,13445
 bedrock_agentcore_starter_toolkit/services/ecr.py,sha256=nW9wIZcXI6amZeLVSmM9F6awVBQP1-zrFXTozSNEDjo,2805
-bedrock_agentcore_starter_toolkit/services/runtime.py,sha256=qL1kk3PL-e7ivArFbVdKyf9PKIPyor2hRdI7rc_Bmws,17214
+bedrock_agentcore_starter_toolkit/services/runtime.py,sha256=TPN2eElh-X-svPpVHn_dHF0Fzl1kAqUIgVSlG_vHaPc,18353
 bedrock_agentcore_starter_toolkit/utils/endpoints.py,sha256=1gIDRd1oO1fymYpiedVit7m6zl5k6N8Ns9N-2ix7ZaE,1153
 bedrock_agentcore_starter_toolkit/utils/logging_config.py,sha256=NtZDyndNKCAbz7jZ0leb13bb3UmjjRUTSVwI8MMlOfw,2191
 bedrock_agentcore_starter_toolkit/utils/runtime/config.py,sha256=qRQid59rD3zJ0d0hcBY4-8R52PNIWEIUt9iR3biuz_c,4495
-bedrock_agentcore_starter_toolkit/utils/runtime/container.py,sha256=6mYVA1YOTTWowBtCNdheLWTH1qL7t7Fd3ogloLIuvxQ,12829
-bedrock_agentcore_starter_toolkit/utils/runtime/entrypoint.py,sha256=FSZskJc0iZ27RsVbiL5-CYUi1fYdvIxVXUlR1IyvgiU,7144
+bedrock_agentcore_starter_toolkit/utils/runtime/container.py,sha256=wGJLxwT2mhTGPxSoFb6x9lW7Tyz37YghIvSs4jBnO8A,15679
+bedrock_agentcore_starter_toolkit/utils/runtime/entrypoint.py,sha256=0MlqXCUcW9Dvr_9I0KC5PDq7GdIgSueTBIaOUUVtcBA,7355
 bedrock_agentcore_starter_toolkit/utils/runtime/logs.py,sha256=RUP5W2rbkXf33Kis4MnaI8xIjkpidO1at3kiXmxAw0I,1082
 bedrock_agentcore_starter_toolkit/utils/runtime/policy_template.py,sha256=CgER7YXPh0BpR6JcTcumDL_k8bhmfLSEok1sf09-31I,2054
 bedrock_agentcore_starter_toolkit/utils/runtime/schema.py,sha256=gZ0zPvry-ZkXwqUEAy6Izz1RJvmZaXA6a2twnSdk1AY,6418
@@ -39,9 +39,9 @@ bedrock_agentcore_starter_toolkit/utils/runtime/templates/Dockerfile.j2,sha256=t
 bedrock_agentcore_starter_toolkit/utils/runtime/templates/dockerignore.template,sha256=b_70sBi0MwkTuA9TqxPqFcWK7TcmpaXBJ6M2Ipox65Q,691
 bedrock_agentcore_starter_toolkit/utils/runtime/templates/execution_role_policy.json.j2,sha256=eFPp6sl7TS7p_FSdCqSMkXNZnDg-ahg9rhufT71A0SQ,2477
 bedrock_agentcore_starter_toolkit/utils/runtime/templates/execution_role_trust_policy.json.j2,sha256=PPJF6Ofq70W5DUE0NlbmnZjw5RkgepPgkskxEgEG28o,473
-bedrock_agentcore_starter_toolkit-0.1.2.dist-info/METADATA,sha256=pZrKNdIXcD6dZ-gYzQWDF4F3kndlJ5opiO_UHtHo_nA,6198
-bedrock_agentcore_starter_toolkit-0.1.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-bedrock_agentcore_starter_toolkit-0.1.2.dist-info/entry_points.txt,sha256=Tf94DkUf2Tp8P7p8MEXLxre7A7Pp_XNukteiz0wHnk8,77
-bedrock_agentcore_starter_toolkit-0.1.2.dist-info/licenses/LICENSE.txt,sha256=nNPOMinitYdtfbhdQgsPgz1UowBznU6QVN3Xs0pSTKU,10768
-bedrock_agentcore_starter_toolkit-0.1.2.dist-info/licenses/NOTICE.txt,sha256=rkBsg8DbKqfIoQbveqX9foR4uJPUVAokbkr02pRPilE,8674
-bedrock_agentcore_starter_toolkit-0.1.2.dist-info/RECORD,,
+bedrock_agentcore_starter_toolkit-0.1.3.dist-info/METADATA,sha256=iX0FQeMib-MtEBtK6nBnp-3nSk8_el-QjlN_8fG_fBk,6198
+bedrock_agentcore_starter_toolkit-0.1.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+bedrock_agentcore_starter_toolkit-0.1.3.dist-info/entry_points.txt,sha256=Tf94DkUf2Tp8P7p8MEXLxre7A7Pp_XNukteiz0wHnk8,77
+bedrock_agentcore_starter_toolkit-0.1.3.dist-info/licenses/LICENSE.txt,sha256=nNPOMinitYdtfbhdQgsPgz1UowBznU6QVN3Xs0pSTKU,10768
+bedrock_agentcore_starter_toolkit-0.1.3.dist-info/licenses/NOTICE.txt,sha256=rkBsg8DbKqfIoQbveqX9foR4uJPUVAokbkr02pRPilE,8674
+bedrock_agentcore_starter_toolkit-0.1.3.dist-info/RECORD,,