agentcore-cli 0.31.1__py3-none-any.whl

agentcore/cli/commands/add/__init__.py

@@ -0,0 +1,37 @@
+"""`agentcore add` shell (port of src/cli/commands/add/command.tsx).
+
+Subcommands come from the primitives. With no subcommand, upstream opens the Add TUI; here the
+user picks a resource kind and that primitive's interactive add flow runs.
+"""
+
+import typer
+
+from agentcore.cli import interactive
+from agentcore.cli.tree import RESOURCE_KINDS
+from agentcore.lib import find_config_root
+
+
+def _require_project() -> None:
+    """Port of tui/guards requireProject."""
+    if not find_config_root():
+        typer.echo("No agentcore project found. Run `agentcore create` first.", err=True)
+        raise typer.Exit(1)
+
+
+def install_add_shell(add_app: typer.Typer) -> None:
+    add_app.info.no_args_is_help = False
+
+    @add_app.callback(invoke_without_command=True)
+    def add_root(ctx: typer.Context) -> None:
+        if ctx.invoked_subcommand is not None:
+            return
+        _require_project()
+        interactive.require_tty()
+        from agentcore.primitives.registry import all_primitives
+
+        primitives = {p.kind: p for p in all_primitives()}
+        kind = interactive.select(
+            "What would you like to add?",
+            [interactive.Choice(RESOURCE_KINDS.get(k, k).capitalize(), k) for k in primitives],
+        )
+        primitives[kind].add_interactive()

agentcore/cli/commands/add/_commander.py

@@ -0,0 +1,52 @@
+"""Commander-style argument checks for commands that upstream declares with ``requiredOption``."""
+
+from __future__ import annotations
+
+import sys
+
+import typer
+
+
+def require_options(*pairs: tuple[str, object]) -> None:
+    """``error: required option '<flags>' not specified`` (exit 1) for the first missing option, in order."""
+    for flags, value in pairs:
+        if value is None:
+            sys.stderr.write(f"error: required option '{flags}' not specified\n")
+            raise typer.Exit(1)
+
+
+def require_project() -> None:
+    from agentcore.lib.schemas.io.path_resolver import find_config_root
+
+    if not find_config_root():
+        typer.echo("No agentcore project found. Run `agentcore create` first.", err=True)
+        raise typer.Exit(1)
+
+
+# Commander's optional-value options (`--aws-skills [paths]`): bare flag -> True.
+OPTIONAL_VALUE_SENTINEL = "\x00true"
+
+
+def optional_value_command(*flags: str) -> type:
+    """A Typer command class that lets ``flags`` be given without a value (like Commander's ``[value]``).
+
+    A bare flag (end of argv, or followed by another option) receives ``OPTIONAL_VALUE_SENTINEL``.
+    """
+    from typer.core import TyperCommand
+
+    names = set(flags)
+
+    class OptionalValueCommand(TyperCommand):
+        def parse_args(self, ctx, args):  # type: ignore[no-untyped-def]
+            out: list[str] = []
+            for i, arg in enumerate(args):
+                out.append(arg)
+                if arg in names and (i + 1 == len(args) or args[i + 1].startswith("-")):
+                    out.append(OPTIONAL_VALUE_SENTINEL)
+            return super().parse_args(ctx, out)
+
+    return OptionalValueCommand
+
+
+def optional_value(value: str | None) -> str | bool | None:
+    return True if value == OPTIONAL_VALUE_SENTINEL else value

agentcore/cli/commands/add/_common.py

@@ -0,0 +1,47 @@
+"""Small helpers shared by the add/create validators."""
+
+import json
+from dataclasses import dataclass
+from functools import cache
+from typing import Any
+
+from pydantic import TypeAdapter, ValidationError
+
+
+@dataclass
+class ValidationResult:
+    valid: bool
+    error: str | None = None
+
+
+@cache
+def _adapter(schema: Any) -> TypeAdapter[Any]:
+    return TypeAdapter(schema)
+
+
+def first_issue(schema: Any, value: Any) -> str | None:
+    """Zod ``safeParse(...).error.issues[0].message`` equivalent; None when the value is valid."""
+    try:
+        if isinstance(schema, type) and hasattr(schema, "model_validate"):
+            schema.model_validate(value)
+        else:
+            _adapter(schema).validate_python(value)
+    except ValidationError as exc:
+        errors = exc.errors()
+        return errors[0]["msg"] if errors else str(exc)
+    return None
+
+
+def parse_json(text: str) -> tuple[bool, Any]:
+    """JSON.parse: (True, value) or (False, None) on a syntax error."""
+    try:
+        return True, json.loads(text)
+    except ValueError:
+        return False, None
+
+
+def js_url_ok(value: str) -> bool:
+    """``new URL(value)`` succeeds."""
+    from agentcore.schema._zod import is_js_url
+
+    return is_js_url(value)

agentcore/cli/commands/add/agent_wizard.py

@@ -0,0 +1,528 @@
+"""Interactive add-agent wizard: prompt-based port of tui/screens/agent/AddAgentScreen.tsx and the
+generate wizard (tui/screens/generate/useGenerateWizard.ts + GenerateWizardUI.tsx).
+
+Questions are asked in the upstream step order:
+
+* name -> agent type
+* create: language -> build -> protocol -> framework -> model -> API key -> memory (Strands only)
+  -> advanced settings (+ their sub-steps) -> confirm
+* byo:    code location (+ entrypoint) -> build -> model -> API key -> advanced -> confirm
+* import: region -> Bedrock agent -> alias -> framework -> memory -> inbound auth (+ JWT) -> confirm
+"""
+
+import json
+import os
+from typing import Any
+
+import typer
+
+from agentcore.cli import interactive
+from agentcore.cli.commands.add._common import first_issue, js_url_ok
+from agentcore.cli.commands.add.validate import session_storage_mount_path_issue
+from agentcore.cli.commands.shared.header_utils import parse_and_normalize_headers, validate_header_allowlist
+from agentcore.cli.commands.shared.lifecycle_utils import parse_and_validate_lifecycle_options
+from agentcore.cli.commands.shared.vpc_utils import (
+    validate_security_group_ids,
+    validate_subnet_ids,
+    validate_vpc_id,
+)
+from agentcore.cli.naming import generate_unique_name
+from agentcore.operations.agent.generate.types import (
+    ADVANCED_SETTING_OPTIONS,
+    BUILD_TYPE_OPTIONS,
+    LANGUAGE_OPTIONS,
+    MEMORY_OPTIONS,
+    NETWORK_MODE_OPTIONS,
+    Option,
+    get_model_provider_options_for_sdk,
+    get_protocol_options_for_language,
+    get_sdk_options_for_protocol,
+    validate_dockerfile_input,
+)
+from agentcore.primitives.auth_utils import JwtConfigOptions
+from agentcore.schema import (
+    LIFECYCLE_TIMEOUT_MAX,
+    LIFECYCLE_TIMEOUT_MIN,
+    MAX_EFS_MOUNTS,
+    MAX_S3_MOUNTS,
+    AgentName,
+    CustomClaimValidation,
+)
+from agentcore.templates import get_template_profile, template_uses_model
+
+AGENT_TYPE_OPTIONS = (
+    Option("create", "Create new agent"),
+    Option("byo", "Bring my own code"),
+    Option("import", "Import from Bedrock Agents"),
+)
+RUNTIME_AUTHORIZER_TYPE_OPTIONS = (
+    Option("AWS_IAM", "AWS IAM (default)", "Standard AWS IAM authentication"),
+    Option("CUSTOM_JWT", "Custom JWT", "OIDC-based token validation for inbound requests"),
+)
+JWT_CONSTRAINT_OPTIONS = (
+    Option("audience", "Allowed Audiences", "Validate token audience claims"),
+    Option("clients", "Allowed Clients", "Validate client identifiers in the token"),
+    Option("scopes", "Allowed Scopes", "Validate token scopes"),
+    Option("customClaims", "Custom Claims", "Validate custom claims in the token"),
+)
+PRIVATE_ENDPOINT_OPTIONS = (
+    Option("none", "None", "The IdP discovery endpoint is publicly reachable"),
+    Option("lattice", "VPC Lattice", "Reach the IdP through a VPC Lattice resource configuration"),
+    Option("vpc", "Managed VPC endpoint", "Reach the IdP through a managed VPC endpoint"),
+)
+PROVIDER_INFO = {
+    "OpenAI": ("OpenAI", "OPENAI_API_KEY"),
+    "Anthropic": ("Anthropic", "ANTHROPIC_API_KEY"),
+    "Gemini": ("Google Gemini", "GEMINI_API_KEY"),
+    "Bedrock": ("Amazon Bedrock", ""),
+    "LiteLLM": ("LiteLLM", "LITELLM_API_KEY"),
+}
+_STEP_LABELS = {
+    "language": "Target Language",
+    "buildType": "Build",
+    "protocol": "Protocol",
+    "sdk": "Framework",
+    "modelProvider": "Model",
+    "memory": "Memory",
+    "networkMode": "Network",
+}
+
+
+def _choices(options: Any) -> list[interactive.Choice]:
+    return [interactive.Choice(o.title, o.id, o.description) for o in options]
+
+
+def _err(check: Any) -> str | None:
+    """`true | string` validator result -> prompt validator result."""
+    return None if check is True else check
+
+
+def _csv(value: str) -> list[str]:
+    return [s.strip() for s in value.split(",") if s.strip()]
+
+
+def prompt_api_key(model_provider: str) -> str | None:
+    """Port of ApiKeySecretInput: the key may be skipped and filled into .env.local later."""
+    name, _ = PROVIDER_INFO.get(model_provider, (model_provider, ""))
+    value = interactive.text(f"{name} API key (press Enter to skip)", secret=True)
+    return value.strip() or None
+
+
+def prompt_jwt_config() -> JwtConfigOptions:
+    """Port of components/jwt-config (discovery URL, constraints, private endpoint, client credentials)."""
+
+    def validate_url(value: str) -> str | None:
+        if not js_url_ok(value):
+            return "Discovery URL must be a valid URL"
+        if not value.lower().startswith("https:"):
+            return "Discovery URL must use HTTPS"
+        if not value.endswith("/.well-known/openid-configuration"):
+            return "Discovery URL must end with /.well-known/openid-configuration"
+        return None
+
+    jwt = JwtConfigOptions(discovery_url=interactive.text("Discovery URL", validate=validate_url))
+    constraints: list[str] = []
+    while not constraints:
+        constraints = interactive.checkbox(
+            "Select JWT constraints to configure (at least one required)", _choices(JWT_CONSTRAINT_OPTIONS)
+        )
+
+    def required(v: str) -> str | None:
+        return None if _csv(v) else "At least one value is required"
+
+    if "audience" in constraints:
+        jwt.allowed_audience = _csv(interactive.text("Allowed Audiences (comma-separated)", validate=required))
+    if "clients" in constraints:
+        jwt.allowed_clients = _csv(interactive.text("Allowed Clients (comma-separated)", validate=required))
+    if "scopes" in constraints:
+        jwt.allowed_scopes = _csv(interactive.text("Allowed Scopes (comma-separated)", validate=required))
+    if "customClaims" in constraints:
+
+        def validate_claims(value: str) -> str | None:
+            try:
+                parsed = json.loads(value)
+            except ValueError:
+                return "Must be valid JSON"
+            if not isinstance(parsed, list) or not parsed:
+                return "Must be a non-empty JSON array"
+            for i, entry in enumerate(parsed):
+                issue = first_issue(CustomClaimValidation, entry)
+                if issue:
+                    return f"Invalid custom claim at index {i}: {issue}"
+            return None
+
+        jwt.custom_claims = json.loads(
+            interactive.text("Custom claims (JSON array of claim validations)", validate=validate_claims)
+        )
+
+    endpoint = interactive.select(
+        "Private network access to the IdP discovery endpoint (PrivateLink)", _choices(PRIVATE_ENDPOINT_OPTIONS)
+    )
+    if endpoint == "lattice":
+        resource = interactive.text(
+            "VPC Lattice resource-config id or ARN", validate=lambda v: None if v.strip() else "Required"
+        )
+        jwt.private_endpoint = {"selfManagedLatticeResource": {"resourceConfigurationIdentifier": resource.strip()}}
+    elif endpoint == "vpc":
+        vpc = interactive.text("VPC id", validate=lambda v: _err(validate_vpc_id(v)))
+        subnets = interactive.text("Subnet IDs (comma-separated)", validate=lambda v: _err(validate_subnet_ids(v)))
+        ip_type = interactive.select(
+            "Endpoint IP address type",
+            [
+                interactive.Choice("IPV4", "IPV4", "IPv4 addressing"),
+                interactive.Choice("IPV6", "IPV6", "IPv6 addressing"),
+            ],
+        )
+        sgs = interactive.text(
+            "Security group IDs (comma-separated, max 5; press Enter to skip)",
+            validate=lambda v: None if not v.strip() else _err(validate_security_group_ids(v)),
+        )
+        routing = interactive.text("Routing domain (press Enter to skip)")
+        resource_spec: dict[str, Any] = {
+            "vpcIdentifier": vpc.strip(),
+            "subnetIds": _csv(subnets),
+            "endpointIpAddressType": ip_type,
+        }
+        if sgs.strip():
+            resource_spec["securityGroupIds"] = _csv(sgs)
+        if routing.strip():
+            resource_spec["routingDomain"] = routing.strip()
+        jwt.private_endpoint = {"managedVpcResource": resource_spec}
+
+    client_id = interactive.text("OAuth Client ID (press Enter to skip)", secret=True).strip()
+    if client_id:
+        jwt.client_id = client_id
+        jwt.client_secret = interactive.text(
+            "OAuth Client Secret", secret=True, validate=lambda v: None if v.strip() else "Client secret is required"
+        )
+    return jwt
+
+
+def _prompt_mounts(kind: str, maximum: int, arn_validator: Any, network_mode: str | None) -> list[dict[str, str]]:
+    from agentcore.cli.commands.shared.filesystem_utils import validate_byo_mount_path
+
+    mounts: list[dict[str, str]] = []
+    example = "/mnt/efs-data" if kind == "EFS" else "/mnt/s3-data"
+    while len(mounts) < maximum:
+
+        def validate_arn(value: str) -> str | None:
+            if not value:
+                return None
+            if network_mode != "VPC":
+                return f"{kind} mounts require VPC network mode"
+            return _err(arn_validator(value))
+
+        arn = interactive.text(
+            f"{kind} access point ARN {len(mounts) + 1}/{maximum} (press Enter to skip):", validate=validate_arn
+        ).strip()
+        if not arn:
+            break
+        path = interactive.text(
+            f"{kind} mount path for ...{arn[-30:]} (e.g. {example}):",
+            validate=lambda v: _err(validate_byo_mount_path(v)),
+        )
+        mounts.append({"accessPointArn": arn, "mountPath": path.strip()})
+    return mounts
+
+
+def _prompt_advanced(options: Any, settings: list[str], capacity_provider_names: list[str], project_root: str) -> None:
+    """Advanced sub-steps, in upstream order. ``options`` is an AddAgentOptions."""
+    from agentcore.cli.commands.shared import filesystem_utils as fs
+
+    if "dockerfile" in settings and options.build_type == "Container":
+
+        def validate_dockerfile(value: str) -> str | None:
+            check = validate_dockerfile_input(value)
+            if check is not True:
+                return check  # type: ignore[return-value]
+            if "/" in value.strip() and not os.path.exists(os.path.join(project_root, value.strip())):
+                return f"File not found: {value.strip()}"
+            return None
+
+        dockerfile = interactive.text(
+            "Custom Dockerfile path (press Enter to use the default Dockerfile)", validate=validate_dockerfile
+        ).strip()
+        options.dockerfile = dockerfile or None
+
+    if "network" in settings and "capacityProvider" not in settings:
+        options.network_mode = interactive.select(_STEP_LABELS["networkMode"], _choices(NETWORK_MODE_OPTIONS))
+        if options.network_mode == "VPC":
+            options.subnets = ",".join(
+                _csv(interactive.text("Subnet IDs (comma-separated)", validate=lambda v: _err(validate_subnet_ids(v))))
+            )
+            options.security_groups = ",".join(
+                _csv(
+                    interactive.text(
+                        "Security group IDs (comma-separated)", validate=lambda v: _err(validate_security_group_ids(v))
+                    )
+                )
+            )
+            if options.build_type == "Container":
+                options.vpc_id = interactive.text("VPC ID", validate=lambda v: _err(validate_vpc_id(v))).strip()
+
+    if "headers" in settings:
+        typer.echo(
+            "Enter header names (e.g. Authorization, X-Api-Key, X-Custom-Signature). Bare names without X- prefix "
+            "are auto-prefixed with X-Amzn-Bedrock-AgentCore-Runtime-Custom- for backward compatibility."
+        )
+        headers = interactive.text(
+            "Allowed request headers (comma-separated, or press Enter to skip)",
+            validate=lambda v: validate_header_allowlist(v).error,
+        )
+        options.request_header_allowlist = parse_and_normalize_headers(headers) if headers.strip() else None
+
+    if "auth" in settings:
+        options.authorizer_type = interactive.select(
+            "Select inbound auth type", _choices(RUNTIME_AUTHORIZER_TYPE_OPTIONS)
+        )
+        if options.authorizer_type == "CUSTOM_JWT":
+            options.jwt_config = prompt_jwt_config()
+        else:
+            options.authorizer_type = None  # AWS_IAM is the default and is not written
+
+    if "lifecycle" in settings:
+
+        def lifecycle_validator(key: str):
+            def check(value: str) -> str | None:
+                if not value.strip():
+                    return None
+                result = parse_and_validate_lifecycle_options({key: value.strip()})
+                return result.error
+
+            return check
+
+        rng = f"{LIFECYCLE_TIMEOUT_MIN}-{LIFECYCLE_TIMEOUT_MAX}"
+        idle = interactive.text(
+            f"Idle session timeout in seconds ({rng}, or press Enter to skip)",
+            validate=lifecycle_validator("idleTimeout"),
+        ).strip()
+        options.idle_timeout = int(idle) if idle else None
+
+        def max_validator(value: str) -> str | None:
+            if not value.strip():
+                return None
+            result = parse_and_validate_lifecycle_options(
+                {"idleTimeout": options.idle_timeout, "maxLifetime": value.strip()}
+            )
+            return result.error
+
+        max_life = interactive.text(
+            f"Max instance lifetime in seconds ({rng}, or press Enter to skip)", validate=max_validator
+        ).strip()
+        options.max_lifetime = int(max_life) if max_life else None
+
+    if "filesystem" in settings:
+        storage = interactive.text(
+            "Session storage mount path (e.g. /mnt/session-storage, or press Enter to skip)",
+            validate=lambda v: None if not v.strip() else session_storage_mount_path_issue(v.strip()),
+        ).strip()
+        options.session_storage_mount_path = storage or None
+        options.efs_access_points = _prompt_mounts(
+            "EFS", MAX_EFS_MOUNTS, fs.validate_efs_access_point_arn, options.network_mode
+        )
+        options.s3_access_points = _prompt_mounts(
+            "S3 Files", MAX_S3_MOUNTS, fs.validate_s3_files_access_point_arn, options.network_mode
+        )
+
+    if "capacityProvider" in settings:
+        choices = [interactive.Choice("None", "__none__", "Use AgentCore-managed compute (default)")]
+        choices += [interactive.Choice(n, n, "Capacity provider in this project") for n in capacity_provider_names]
+        choices.append(interactive.Choice("Enter an ARN…", "__arn__", "Attach to an external capacity provider by ARN"))
+        picked = interactive.select(_STEP_LABELS.get("capacityProvider", "Capacity Provider"), choices)
+        if picked == "__arn__":
+            picked = interactive.text(
+                "Capacity provider ARN (arn:...:capacity-provider/...):",
+                validate=lambda v: None if v.startswith("arn:") else "Must be a capacity provider ARN",
+            ).strip()
+        if picked != "__none__":
+            options.capacity_provider = picked
+            options.network_mode = options.subnets = options.security_groups = options.vpc_id = None
+
+            def validate_volumes(value: str) -> str | None:
+                if not value.strip():
+                    return None
+                pairs = [p.split(":", 1) for p in _csv(value)]
+                if any(len(p) != 2 or not p[0] or not p[1] for p in pairs):
+                    return "Use name:path pairs, e.g. model-weights:/mnt/models"
+                check = fs.validate_capacity_provider_volume_mounts(
+                    [{"volumeName": n, "mountPath": m} for n, m in pairs]
+                )
+                return None if check.success else check.error
+
+            volumes = interactive.text(
+                "Capacity provider volume mounts as name:path, comma-separated (e.g. model-weights:/mnt/models) — "
+                "press Enter to skip:",
+                validate=validate_volumes,
+            )
+            options.capacity_provider_volumes = [
+                {"volumeName": n, "mountPath": m} for n, m in (p.split(":", 1) for p in _csv(volumes))
+            ]
+
+    if "configBundle" in settings:
+        options.with_config_bundle = True
+
+
+def _advanced_choices(build_type: str, framework: str | None, language: str, include_config_bundle: bool) -> list:
+    profile = get_template_profile(framework)
+    items = [
+        o
+        for o in ADVANCED_SETTING_OPTIONS
+        if (
+            o.id != "dockerfile"
+            or (build_type == "Container" and not (profile and profile.runtime and profile.runtime.dockerfile))
+        )
+        and (o.id != "filesystem" or language != "TypeScript")
+        and (o.id != "configBundle" or include_config_bundle)
+    ]
+    return _choices(items)
+
+
+def _confirm(rows: list[tuple[str, Any]]) -> bool:
+    for label, value in rows:
+        if value not in (None, "", []):
+            typer.echo(f"  {label}: {value}")
+    return interactive.confirm("Create this agent?", default=True)
+
+
+def run_add_agent_wizard(
+    existing_agent_names: list[str],
+    project_name: str,
+    capacity_provider_names: list[str],
+    project_root: str,
+) -> Any:
+    """Return an AddAgentOptions built from the answers, or None when the user declines."""
+    from agentcore.primitives.agent import AddAgentOptions
+
+    name = interactive.text(
+        "Agent name",
+        default=generate_unique_name("MyAgent", existing_agent_names),
+        validate=lambda v: (
+            first_issue(AgentName, v) or ("Agent name already exists" if v in existing_agent_names else None)
+        ),
+    )
+    agent_type = interactive.select("Select agent type", _choices(AGENT_TYPE_OPTIONS))
+    options = AddAgentOptions(name=name, type=agent_type)
+
+    if agent_type == "import":
+        return _import_flow(options)
+    if agent_type == "byo":
+        return _byo_flow(options, capacity_provider_names, project_root)
+
+    # create: the generate wizard
+    options.language = interactive.select(_STEP_LABELS["language"], _choices(LANGUAGE_OPTIONS))
+    options.build_type = interactive.select(_STEP_LABELS["buildType"], _choices(BUILD_TYPE_OPTIONS))
+    options.protocol = interactive.select(
+        _STEP_LABELS["protocol"], _choices(get_protocol_options_for_language(options.language))
+    )
+    options.memory = "none"
+    if options.protocol == "MCP":
+        options.framework, options.model_provider = "Strands", "Bedrock"
+    else:
+        options.framework = interactive.select(
+            _STEP_LABELS["sdk"], _choices(get_sdk_options_for_protocol(options.protocol, options.language))
+        )
+        profile = get_template_profile(options.framework)
+        if profile:
+            options.build_type = profile.required_options.get("build", options.build_type)
+            options.model_provider = profile.default_options.get("modelProvider", options.model_provider)
+        if template_uses_model(options.framework):
+            options.model_provider = interactive.select(
+                _STEP_LABELS["modelProvider"], _choices(get_model_provider_options_for_sdk(options.framework))
+            )
+            if options.model_provider != "Bedrock":
+                options.api_key = prompt_api_key(options.model_provider)
+        if options.framework == "Strands":
+            memory_options = [
+                o for o in MEMORY_OPTIONS if not (options.language == "TypeScript" and o.id == "shortTerm")
+            ]
+            options.memory = interactive.select(_STEP_LABELS["memory"], _choices(memory_options))
+
+    settings = interactive.checkbox(
+        "Customize advanced settings (select settings to configure; unselected items use defaults)",
+        _advanced_choices(options.build_type, options.framework, options.language, include_config_bundle=True),
+    )
+    _prompt_advanced(options, settings, capacity_provider_names, project_root)
+
+    rows = [
+        ("Name", options.name),
+        ("Language", options.language),
+        ("Build", options.build_type),
+        ("Protocol", options.protocol),
+        ("Framework", None if options.protocol == "MCP" else options.framework),
+        ("Model", None if options.protocol == "MCP" else options.model_provider),
+        ("Memory", options.memory if options.framework == "Strands" else None),
+    ]
+    return options if _confirm(rows) else None
+
+
+def _byo_flow(options: Any, capacity_provider_names: list[str], project_root: str) -> Any:
+    from agentcore.lib import APP_DIR
+
+    code_location = interactive.text(
+        "Code location (relative to the project root)", default=f"{APP_DIR}/{options.name}/"
+    ).strip()
+    options.code_location = code_location if code_location.endswith("/") else f"{code_location}/"
+    options.entrypoint = interactive.text("Entrypoint file", default="main.py").strip() or "main.py"
+    options.build_type = interactive.select("Select build type", _choices(BUILD_TYPE_OPTIONS))
+    options.model_provider = interactive.select(
+        "Select model provider", _choices(get_model_provider_options_for_sdk("Strands"))
+    )
+    if options.model_provider != "Bedrock":
+        options.api_key = prompt_api_key(options.model_provider)
+    options.language = "Python"
+    options.framework = "Strands"
+    settings = interactive.checkbox(
+        "Customize advanced settings (select settings to configure; unselected items use defaults)",
+        _advanced_choices(options.build_type, None, "Python", include_config_bundle=False),
+    )
+    _prompt_advanced(options, settings, capacity_provider_names, project_root)
+    rows = [
+        ("Name", options.name),
+        ("Type", "Bring my own code"),
+        ("Code", options.code_location),
+        ("Entrypoint", options.entrypoint),
+        ("Build", options.build_type),
+        ("Model", options.model_provider),
+    ]
+    return options if _confirm(rows) else None
+
+
+def _import_flow(options: Any) -> Any:
+    from agentcore.aws.bedrock_import import list_bedrock_agent_aliases, list_bedrock_agents
+    from agentcore.operations.agent.import_ import BEDROCK_REGIONS, IMPORT_FRAMEWORK_OPTIONS
+
+    region = interactive.select(
+        "Select AWS region", [interactive.Choice(f"{r.id} — {r.title}", r.id) for r in BEDROCK_REGIONS]
+    )
+    agents = list_bedrock_agents(region)
+    if not agents:
+        raise Exception(f"No Bedrock Agents found in {region}.")
+    agent_id = interactive.select(
+        "Select Bedrock Agent",
+        [interactive.Choice(a["agentName"], a["agentId"], a.get("description")) for a in agents],
+    )
+    aliases = list_bedrock_agent_aliases(region, agent_id)
+    if not aliases:
+        raise Exception("No aliases found for this agent.")
+    alias_id = interactive.select(
+        "Select Agent Alias",
+        [interactive.Choice(a["aliasName"], a["aliasId"], a.get("description")) for a in aliases],
+    )
+    options.framework = interactive.select("Select framework", _choices(IMPORT_FRAMEWORK_OPTIONS))
+    options.memory = interactive.select("Select memory configuration", _choices(MEMORY_OPTIONS))
+    auth = interactive.select("Select inbound auth mode", _choices(RUNTIME_AUTHORIZER_TYPE_OPTIONS))
+    if auth == "CUSTOM_JWT":
+        options.authorizer_type = auth
+        options.jwt_config = prompt_jwt_config()
+    options.bedrock_region, options.bedrock_agent_id, options.bedrock_alias_id = region, agent_id, alias_id
+    options.language, options.model_provider = "Python", "Bedrock"
+    rows = [
+        ("Name", options.name),
+        ("Type", "Import from Bedrock Agents"),
+        ("Region", region),
+        ("Agent", agent_id),
+        ("Alias", alias_id),
+        ("Framework", options.framework),
+        ("Memory", options.memory),
+    ]
+    return options if _confirm(rows) else None