agentcore-cli 0.31.1__py3-none-any.whl

agentcore/cli/commands/create/__init__.py

@@ -0,0 +1,643 @@
+"""`agentcore create` (port of src/cli/commands/create/command.tsx)."""
+
+import json
+from typing import Any
+
+import typer
+
+from agentcore.cli import interactive
+from agentcore.cli.commands.create.action import (
+    CreateWithAgentOptions,
+    create_project,
+    create_project_with_agent,
+    create_project_with_harness,
+    get_dry_run_info,
+    get_harness_dry_run_info,
+    parse_container_flag,
+)
+from agentcore.cli.commands.create.harness_validate import (
+    DEFAULT_HARNESS_MODEL_IDS,
+    normalize_harness_model_provider,
+    validate_create_harness_options,
+)
+from agentcore.cli.commands.create.validate import validate_create_options
+from agentcore.cli.constants import ANSI, COMMAND_DESCRIPTIONS
+from agentcore.cli.errors import get_error_message
+from agentcore.cli.run_command import run_cli_command
+from agentcore.lib import ValidationError, get_working_directory, serialize_result
+from agentcore.primitives.base import ADDITIONAL_PARAMS_JSON_ERROR
+from agentcore.schema import LIFECYCLE_TIMEOUT_MAX, LIFECYCLE_TIMEOUT_MIN, is_capacity_provider_arn
+
+# Flags that route to the agent/runtime path (`memory` is agent-only; harnesses use other flags).
+AGENT_PATH_FLAGS = (
+    "framework",
+    "language",
+    "build",
+    "protocol",
+    "type",
+    "agentId",
+    "agentAliasId",
+    "memory",
+    "capacityProvider",
+)
+HARNESS_ONLY_FLAGS = (
+    "modelId",
+    "apiKeyArn",
+    "apiBase",
+    "additionalParams",
+    "maxIterations",
+    "maxTokens",
+    "timeout",
+    "truncationStrategy",
+    "container",
+)
+MIXED_FLAGS_ERROR = (
+    "Cannot mix agent-path flags (--framework, --language, etc.) with harness-only flags "
+    "(--model-id, --max-iterations, etc.)"
+)
+
+_GREEN, _CYAN, _DIM, _RESET = "\x1b[32m", "\x1b[36m", "\x1b[2m", "\x1b[0m"
+
+
+def _dumps(payload: Any) -> str:
+    return json.dumps(payload, separators=(",", ":"))
+
+
+def is_agent_path(options: dict[str, Any]) -> bool:
+    return any(options.get(flag) is not None for flag in AGENT_PATH_FLAGS)
+
+
+def has_harness_only_flags(options: dict[str, Any]) -> bool:
+    return any(options.get(flag) is not None for flag in HARNESS_ONLY_FLAGS)
+
+
+def has_any_flag(o: dict[str, Any]) -> bool:
+    """Upstream's `hasAnyFlag` chain (some flags, e.g. --with-config-bundle, are deliberately absent)."""
+    keys = (
+        "name", "projectName", "defaults", "build", "language", "framework", "modelProvider", "apiKey",
+        "memory", "protocol", "type", "agentId", "agentAliasId", "region", "networkMode", "subnets",
+        "securityGroups", "vpcId", "idleTimeout", "maxLifetime", "capacityProvider", "outputDir", "skipGit",
+        "skipPythonSetup", "skipInstall", "dryRun", "json", "modelId", "apiKeyArn", "maxIterations",
+        "maxTokens", "timeout", "truncationStrategy",
+    )  # fmt: skip
+    return (
+        any(o.get(k) for k in keys)
+        or o.get("agent") is False
+        or o.get("harnessMemory") is False
+        or bool(o.get("cpVolumeName"))
+        or bool(o.get("cpVolumeMountPath"))
+    )
+
+
+def print_create_summary(
+    project_name: str,
+    agent_name: str | None,
+    language: str | None,
+    framework: str | None,
+    directory: str | None = None,
+    next_steps: list[str] | None = None,
+) -> None:
+    folder = directory or project_name
+    typer.echo("")
+    typer.echo(f"{_DIM}Created:{_RESET}")
+    typer.echo(f"  {folder}/")
+    if agent_name:
+        agent_path, config_path = f"app/{agent_name}/", "agentcore/"
+        width = max(len(agent_path), len(config_path))
+        typer.echo(f"    {agent_path.ljust(width)}  {_DIM}{language} agent ({framework or 'agent'}){_RESET}")
+        typer.echo(f"    {config_path.ljust(width)}  {_DIM}Config and CDK project{_RESET}")
+    else:
+        typer.echo(f"    agentcore/  {_DIM}Config and CDK project{_RESET}")
+    typer.echo("")
+    typer.echo(f"{_GREEN}Project created successfully!{_RESET}")
+    typer.echo("")
+    typer.echo("To continue, navigate to your new project:")
+    typer.echo("")
+    typer.echo(f"  {_CYAN}cd {folder}{_RESET}")
+    for step in next_steps or ["agentcore"]:
+        typer.echo(f"  {_CYAN}{step}{_RESET}")
+    typer.echo("")
+
+
+def print_create_harness_summary(project_name: str, harness_name: str) -> None:
+    typer.echo("")
+    typer.echo(f"{_DIM}Created:{_RESET}")
+    typer.echo(f"  {project_name}/")
+    typer.echo(f"    agentcore/              {_DIM}Config and CDK project{_RESET}")
+    typer.echo(f"    app/{harness_name}/  {_DIM}Harness config{_RESET}")
+    typer.echo("")
+    typer.echo(f"{_GREEN}Harness project created successfully!{_RESET}")
+    typer.echo("")
+    typer.echo("To continue:")
+    typer.echo(f"  {_CYAN}cd {project_name}{_RESET}")
+    typer.echo(f"  {_CYAN}agentcore deploy{_RESET}")
+    typer.echo("")
+
+
+def _resolve_mounts(options: dict[str, Any]) -> dict[str, Any]:
+    from agentcore.cli.commands.shared.filesystem_utils import resolve_and_validate_filesystem_mounts
+    from agentcore.cli.commands.shared.vpc_utils import parse_comma_separated_list
+
+    return resolve_and_validate_filesystem_mounts(options, parse_comma_separated_list)
+
+
+def _dry_run_exit(validation: Any, as_json: bool, result: Any) -> None:
+    if not validation.valid:
+        if as_json:
+            typer.echo(_dumps({"success": False, "error": validation.error}))
+        else:
+            typer.echo(validation.error, err=True)
+        raise typer.Exit(1)
+    if as_json:
+        typer.echo(_dumps(serialize_result(result)))
+    elif result.success:
+        typer.echo("Dry run - would create:")
+        for path in result.value.get("wouldCreate", []):
+            typer.echo(f"  {path}")
+    raise typer.Exit(0)
+
+
+def _progress_printer(gated: bool):
+    green, red, reset = (ANSI.green, ANSI.red, ANSI.reset) if gated else ("\x1b[32m", "\x1b[31m", "\x1b[0m")
+
+    def on_progress(step: str, status: str) -> None:
+        if status == "done":
+            typer.echo(f"{green}[done]{reset}  {step}")
+        elif status == "error":
+            typer.echo(f"{red}[error]{reset} {step}")
+
+    return on_progress
+
+
+def handle_create_harness_cli(o: dict[str, Any]) -> None:
+    command_cwd = get_working_directory()
+    cwd = o.get("outputDir") or command_cwd
+    name = o.get("name") or o.get("projectName")
+    project_name = o.get("projectName") or name
+    as_json = bool(o.get("json"))
+    validation_input = {
+        "name": name,
+        "projectName": project_name,
+        "modelProvider": o.get("modelProvider"),
+        "modelId": o.get("modelId"),
+        "apiKeyArn": o.get("apiKeyArn"),
+        "container": o.get("container"),
+        "networkMode": o.get("networkMode"),
+        "subnets": o.get("subnets"),
+        "securityGroups": o.get("securityGroups"),
+        "vpcId": o.get("vpcId"),
+        "efsAccessPointArn": o.get("efsAccessPointArn"),
+        "efsMountPath": o.get("efsMountPath"),
+        "s3AccessPointArn": o.get("s3AccessPointArn"),
+        "s3MountPath": o.get("s3MountPath"),
+    }
+
+    if o.get("dryRun"):
+        validation = validate_create_harness_options(dict(validation_input), cwd)
+        _dry_run_exit(validation, as_json, get_harness_dry_run_info(name or "", cwd, project_name))
+
+    def run() -> Any:
+        validation = validate_create_harness_options(dict(validation_input), cwd)
+        if not validation.valid:
+            from agentcore.lib.result import Err
+
+            return Err(ValidationError(validation.error or ""))
+        provider = normalize_harness_model_provider(o["modelProvider"]) if o.get("modelProvider") else "bedrock"
+        model_id = o.get("modelId") or DEFAULT_HARNESS_MODEL_IDS.get(
+            provider or "", "global.anthropic.claude-sonnet-4-6"
+        )
+        container = parse_container_flag(o.get("container"))
+        additional_params = None
+        if o.get("additionalParams"):
+            try:
+                additional_params = json.loads(o["additionalParams"])
+            except ValueError:
+                raise Exception(ADDITIONAL_PARAMS_JSON_ERROR) from None
+        mounts = _resolve_mounts(o)
+        from agentcore.cli.commands.shared.vpc_utils import parse_comma_separated_list
+
+        harness_options = {
+            "name": name,
+            "modelProvider": provider,
+            "modelId": model_id,
+            "apiKeyArn": o.get("apiKeyArn"),
+            "apiBase": o.get("apiBase"),
+            "additionalParams": additional_params,
+            "containerUri": container.get("containerUri"),
+            "dockerfilePath": container.get("dockerfilePath"),
+            "dockerfileBaseDir": command_cwd,
+            "skipMemory": o.get("harnessMemory") is False,
+            "maxIterations": int(o["maxIterations"]) if o.get("maxIterations") else None,
+            "maxTokens": int(o["maxTokens"]) if o.get("maxTokens") else None,
+            "timeoutSeconds": float(o["timeout"]) if o.get("timeout") else None,
+            "truncationStrategy": o.get("truncationStrategy"),
+            "networkMode": o.get("networkMode"),
+            "subnets": parse_comma_separated_list(o.get("subnets")),
+            "securityGroups": parse_comma_separated_list(o.get("securityGroups")),
+            "vpcId": o.get("vpcId"),
+            "idleTimeout": int(o["idleTimeout"]) if o.get("idleTimeout") else None,
+            "maxLifetime": int(o["maxLifetime"]) if o.get("maxLifetime") else None,
+            "sessionStoragePath": o.get("sessionStorageMountPath"),
+            "efsAccessPoints": mounts.get("efsMounts"),
+            "s3AccessPoints": mounts.get("s3Mounts"),
+        }
+        return create_project_with_harness(
+            harness_options,
+            cwd,
+            project_name=project_name,
+            skip_git=bool(o.get("skipGit")),
+            skip_install=bool(o.get("skipInstall")),
+            on_progress=None if as_json else _progress_printer(gated=True),
+        )
+
+    result = run()
+    if as_json:
+        typer.echo(_dumps(serialize_result(result)))
+    elif result.success:
+        print_create_harness_summary(project_name or "", name or "")
+    else:
+        typer.echo(str(result.error) if isinstance(result.error, BaseException) else "Create failed", err=True)
+    raise typer.Exit(0 if result.success else 1)
+
+
+def handle_create_cli(o: dict[str, Any]) -> None:
+    from agentcore.cli.commands.shared import filesystem_utils as fs
+    from agentcore.cli.commands.shared.vpc_utils import parse_comma_separated_list
+
+    cwd = o.get("outputDir") or get_working_directory()
+    name = o.get("name") or o.get("projectName")
+    project_name = o.get("projectName") or name
+    as_json = bool(o.get("json"))
+
+    if o.get("dryRun"):
+        validation = validate_create_options(o, cwd)
+        _dry_run_exit(
+            validation,
+            as_json,
+            get_dry_run_info(name or "", cwd, o.get("language"), o.get("framework"), project_name),
+        )
+
+    def run() -> None:
+        validation = validate_create_options(o, cwd)
+        if not validation.valid:
+            raise ValidationError(validation.error or "")
+        on_progress = None if as_json else _progress_printer(gated=False)
+        skip_agent = o.get("agent") is False
+        mounts = _resolve_mounts(o)
+
+        capacity_provider = o.get("capacityProvider")
+        if capacity_provider and o.get("networkMode") is not None:
+            raise ValidationError(
+                "--network-mode cannot be set when attaching a capacity provider (--capacity-provider) — the "
+                "capacity provider supplies the network topology. Remove --network-mode."
+            )
+        if capacity_provider and not is_capacity_provider_arn(capacity_provider):
+            raise ValidationError(
+                f'--capacity-provider "{capacity_provider}" is a capacity provider name, but a new project has no '
+                "capacity providers to reference by name. Pass an external capacity provider ARN, or scaffold the "
+                'project first and then run "agentcore add capacity-provider" followed by '
+                f'"agentcore add agent --capacity-provider {capacity_provider}".'
+            )
+        cp_pairs = fs.zip_capacity_provider_volume_pairs(o.get("cpVolumeName") or [], o.get("cpVolumeMountPath") or [])
+        if not cp_pairs.success:
+            raise ValidationError(cp_pairs.error or "")
+        cp_check = fs.validate_capacity_provider_volume_mounts(cp_pairs.mounts)
+        if not cp_check.success:
+            raise ValidationError(cp_check.error or "")
+        if cp_pairs.mounts and not capacity_provider:
+            raise ValidationError(
+                "Capacity provider volume mounts (--cp-volume-name / --cp-volume-mount-path) require attaching the "
+                "runtime to a capacity provider (--capacity-provider <name-or-arn>)."
+            )
+        cp_config = None
+        if capacity_provider:
+            cp_config = (
+                {"capacityProviderArn": capacity_provider}
+                if is_capacity_provider_arn(capacity_provider)
+                else {"capacityProviderName": capacity_provider}
+            )
+
+        if skip_agent:
+            result = create_project(
+                project_name or "",
+                cwd,
+                skip_git=bool(o.get("skipGit")),
+                skip_install=bool(o.get("skipInstall")),
+                on_progress=on_progress,
+                directory=o.get("directory"),
+            )
+        else:
+            result = create_project_with_agent(
+                CreateWithAgentOptions(
+                    name=name or "",
+                    project_name=project_name,
+                    cwd=cwd,
+                    type=o.get("type"),
+                    build_type=o.get("build") or "CodeZip",
+                    language=o.get("language") or ("Python" if o.get("type") == "import" else None),  # type: ignore[arg-type]
+                    framework=o.get("framework"),
+                    model_provider=o.get("modelProvider"),
+                    api_key=o.get("apiKey"),
+                    memory=o.get("memory") or "none",
+                    protocol=o.get("protocol"),
+                    agent_id=o.get("agentId"),
+                    agent_alias_id=o.get("agentAliasId"),
+                    region=o.get("region"),
+                    network_mode=o.get("networkMode"),
+                    subnets=parse_comma_separated_list(o.get("subnets")),
+                    security_groups=parse_comma_separated_list(o.get("securityGroups")),
+                    vpc_id=o.get("vpcId"),
+                    idle_timeout=int(o["idleTimeout"]) if o.get("idleTimeout") else None,
+                    max_lifetime=int(o["maxLifetime"]) if o.get("maxLifetime") else None,
+                    session_storage_mount_path=o.get("sessionStorageMountPath"),
+                    efs_access_points=mounts.get("efsMounts") or [],
+                    s3_access_points=mounts.get("s3Mounts") or [],
+                    capacity_provider_configuration=cp_config,
+                    capacity_provider_volumes=cp_pairs.mounts,
+                    with_config_bundle=o.get("withConfigBundle"),
+                    directory=o.get("directory"),
+                    skip_git=bool(o.get("skipGit")),
+                    skip_install=bool(o.get("skipInstall")),
+                    skip_python_setup=bool(o.get("skipPythonSetup")),
+                    on_progress=on_progress,
+                )
+            )
+        if not result.success:
+            raise result.error
+        if as_json:
+            typer.echo(_dumps({"success": True, **result.value}))
+        else:
+            print_create_summary(
+                project_name or "",
+                result.value.get("agentName"),
+                o.get("language"),
+                o.get("framework"),
+                directory=o.get("directory"),
+                next_steps=o.get("nextSteps"),
+            )
+            if o.get("skipInstall"):
+                typer.echo(
+                    "\nDependency installation was skipped. Run 'npm install' in agentcore/cdk/ and 'uv sync' in "
+                    "your agent directory manually."
+                )
+
+    run_cli_command(as_json, run)
+
+
+def dispatch_create(o: dict[str, Any]) -> None:
+    """The flag routing of upstream's create action."""
+    if not has_any_flag(o):
+        interactive.require_tty()
+        from agentcore.cli.commands.create.wizard import run_create_wizard
+
+        run_create_wizard()
+        return
+
+    if is_agent_path(o) and has_harness_only_flags(o):
+        if o.get("json"):
+            typer.echo(_dumps({"success": False, "error": MIXED_FLAGS_ERROR}))
+        else:
+            typer.echo(MIXED_FLAGS_ERROR, err=True)
+        raise typer.Exit(1)
+
+    if o.get("agent") is False:
+        o["language"] = o.get("language") or "Python"
+        handle_create_cli(o)
+        return
+
+    has_cp_volume_flags = bool(o.get("cpVolumeName")) or bool(o.get("cpVolumeMountPath"))
+    if is_agent_path(o) or has_cp_volume_flags:
+        o["language"] = o.get("language") or "Python"
+        handle_create_cli(o)
+        return
+
+    if not o.get("json") and not o.get("modelProvider") and not has_harness_only_flags(o):
+        typer.echo("Creating a harness project (pass --framework to create an agent project instead).")
+    handle_create_harness_cli(o)
+
+
+def register(app: typer.Typer) -> None:
+    lifecycle = f"({LIFECYCLE_TIMEOUT_MIN}-{LIFECYCLE_TIMEOUT_MAX})"
+
+    @app.command("create", help=COMMAND_DESCRIPTIONS["create"])
+    def create(
+        name: str | None = typer.Option(None, "--name", help="Resource name [non-interactive]"),
+        project_name: str | None = typer.Option(
+            None,
+            "--project-name",
+            help="Project name (start with letter, alphanumeric only, max 23 chars) [non-interactive]",
+        ),
+        no_agent: bool = typer.Option(False, "--no-agent", help="Skip agent creation [non-interactive]"),
+        defaults: bool = typer.Option(
+            False,
+            "--defaults",
+            help="Create a harness project with default settings (this is the default) [non-interactive]",
+        ),
+        build: str | None = typer.Option(
+            None, "--build", help="Build type: CodeZip or Container (default: CodeZip) [non-interactive]"
+        ),
+        language: str | None = typer.Option(
+            None, "--language", help="Target language: Python or TypeScript (default: Python) [non-interactive]"
+        ),
+        framework: str | None = typer.Option(
+            None,
+            "--framework",
+            help="Agent framework (Strands, LangChain_LangGraph, GoogleADK, OpenAIAgents, VercelAI, "
+            "BedrockManagedAgents) [non-interactive]",
+        ),
+        model_provider: str | None = typer.Option(
+            None, "--model-provider", help="Model provider (Bedrock, Anthropic, OpenAI, Gemini) [non-interactive]"
+        ),
+        api_key: str | None = typer.Option(
+            None, "--api-key", help="API key for non-Bedrock providers [non-interactive]"
+        ),
+        memory: str | None = typer.Option(
+            None, "--memory", help="Memory option (none, shortTerm, longAndShortTerm) [non-interactive]"
+        ),
+        protocol: str | None = typer.Option(
+            None, "--protocol", help="Protocol: HTTP, MCP, A2A, AGUI (default: HTTP) [non-interactive]"
+        ),
+        agent_type: str | None = typer.Option(
+            None, "--type", help="Agent type: create or import (default: create) [non-interactive]"
+        ),
+        agent_id: str | None = typer.Option(
+            None, "--agent-id", help="Bedrock Agent ID (required for --type import) [non-interactive]"
+        ),
+        agent_alias_id: str | None = typer.Option(
+            None, "--agent-alias-id", help="Bedrock Agent Alias ID (required for --type import) [non-interactive]"
+        ),
+        region: str | None = typer.Option(
+            None, "--region", help="AWS region for Bedrock Agent (required for --type import) [non-interactive]"
+        ),
+        network_mode: str | None = typer.Option(
+            None, "--network-mode", help="Network mode (PUBLIC, VPC) [non-interactive]"
+        ),
+        subnets: str | None = typer.Option(
+            None, "--subnets", help="Comma-separated subnet IDs (required for VPC mode) [non-interactive]"
+        ),
+        security_groups: str | None = typer.Option(
+            None,
+            "--security-groups",
+            help="Comma-separated security group IDs (required for VPC mode) [non-interactive]",
+        ),
+        vpc_id: str | None = typer.Option(
+            None, "--vpc-id", help="VPC ID (required for Container builds with VPC mode) [non-interactive]"
+        ),
+        idle_timeout: str | None = typer.Option(
+            None, "--idle-timeout", help=f"Idle session timeout in seconds {lifecycle} [non-interactive]"
+        ),
+        max_lifetime: str | None = typer.Option(
+            None, "--max-lifetime", help=f"Max instance lifetime in seconds {lifecycle} [non-interactive]"
+        ),
+        session_storage_mount_path: str | None = typer.Option(
+            None,
+            "--session-storage-mount-path",
+            help="Absolute mount path for session filesystem storage under /mnt (e.g. /mnt/data) [non-interactive]",
+        ),
+        efs_access_point_arn: list[str] = typer.Option(
+            [],
+            "--efs-access-point-arn",
+            help="EFS access point ARN (repeatable, paired with --efs-mount-path) [non-interactive]",
+        ),
+        efs_mount_path: list[str] = typer.Option(
+            [],
+            "--efs-mount-path",
+            help="EFS mount path (e.g. /mnt/tools, paired with --efs-access-point-arn) [non-interactive]",
+        ),
+        s3_access_point_arn: list[str] = typer.Option(
+            [],
+            "--s3-access-point-arn",
+            help="S3 Files access point ARN (repeatable, paired with --s3-mount-path) [non-interactive]",
+        ),
+        s3_mount_path: list[str] = typer.Option(
+            [],
+            "--s3-mount-path",
+            help="S3 Files mount path (e.g. /mnt/datasets, paired with --s3-access-point-arn) [non-interactive]",
+        ),
+        capacity_provider: str | None = typer.Option(
+            None,
+            "--capacity-provider",
+            help="Attach the agent to a capacity provider — an in-project capacity-provider name or an external CP "
+            "ARN [non-interactive]",
+        ),
+        cp_volume_name: list[str] = typer.Option(
+            [],
+            "--cp-volume-name",
+            help="Capacity provider volume name to mount (repeatable, paired with --cp-volume-mount-path) "
+            "[non-interactive]",
+        ),
+        cp_volume_mount_path: list[str] = typer.Option(
+            [],
+            "--cp-volume-mount-path",
+            help="Capacity provider volume mount path (e.g. /mnt/models, paired with --cp-volume-name) "
+            "[non-interactive]",
+        ),
+        with_config_bundle: bool = typer.Option(
+            False, "--with-config-bundle", help="Create a config bundle wired into the agent template [non-interactive]"
+        ),
+        output_dir: str | None = typer.Option(
+            None, "--output-dir", help="Output directory (default: current directory) [non-interactive]"
+        ),
+        skip_git: bool = typer.Option(False, "--skip-git", help="Skip git repository initialization [non-interactive]"),
+        skip_python_setup: bool = typer.Option(
+            False, "--skip-python-setup", help="Skip Python virtual environment setup [non-interactive]"
+        ),
+        skip_install: bool = typer.Option(
+            False, "--skip-install", help="Skip all dependency installation (npm install, uv sync) [non-interactive]"
+        ),
+        dry_run: bool = typer.Option(
+            False, "--dry-run", help="Preview what would be created without making changes [non-interactive]"
+        ),
+        as_json: bool = typer.Option(False, "--json", help="Output as JSON [non-interactive]"),
+        model_id: str | None = typer.Option(None, "--model-id", help="Model ID for harness [non-interactive]"),
+        api_key_arn: str | None = typer.Option(
+            None, "--api-key-arn", help="API key ARN for non-Bedrock harness providers [non-interactive]"
+        ),
+        api_base: str | None = typer.Option(
+            None,
+            "--api-base",
+            help="Base URL for the harness model provider API endpoint (lite_llm) [non-interactive]",
+        ),
+        additional_params: str | None = typer.Option(
+            None,
+            "--additional-params",
+            help="Provider-specific harness params as a JSON object (lite_llm) [non-interactive]",
+        ),
+        no_harness_memory: bool = typer.Option(
+            False,
+            "--no-harness-memory",
+            help="Disable memory for the harness (this is the default) [non-interactive]",
+        ),
+        max_iterations: str | None = typer.Option(
+            None, "--max-iterations", help="Max agent loop iterations (harness) [non-interactive]"
+        ),
+        max_tokens: str | None = typer.Option(
+            None, "--max-tokens", help="Max tokens per iteration (harness) [non-interactive]"
+        ),
+        timeout: str | None = typer.Option(
+            None, "--timeout", help="Max execution duration in seconds (harness) [non-interactive]"
+        ),
+        truncation_strategy: str | None = typer.Option(
+            None,
+            "--truncation-strategy",
+            help="Truncation strategy: sliding_window or summarization (harness) [non-interactive]",
+        ),
+        container: str | None = typer.Option(
+            None, "--container", help="Container image URI or Dockerfile path (harness) [non-interactive]"
+        ),
+    ) -> None:
+        options: dict[str, Any] = {
+            "name": name,
+            "projectName": project_name,
+            "agent": not no_agent,
+            "defaults": defaults or None,
+            "build": build,
+            "language": language,
+            "framework": framework,
+            "modelProvider": model_provider,
+            "apiKey": api_key,
+            "memory": memory,
+            "protocol": protocol,
+            "type": agent_type,
+            "agentId": agent_id,
+            "agentAliasId": agent_alias_id,
+            "region": region,
+            "networkMode": network_mode,
+            "subnets": subnets,
+            "securityGroups": security_groups,
+            "vpcId": vpc_id,
+            "idleTimeout": idle_timeout,
+            "maxLifetime": max_lifetime,
+            "sessionStorageMountPath": session_storage_mount_path,
+            "efsAccessPointArn": list(efs_access_point_arn),
+            "efsMountPath": list(efs_mount_path),
+            "s3AccessPointArn": list(s3_access_point_arn),
+            "s3MountPath": list(s3_mount_path),
+            "capacityProvider": capacity_provider,
+            "cpVolumeName": list(cp_volume_name),
+            "cpVolumeMountPath": list(cp_volume_mount_path),
+            "withConfigBundle": with_config_bundle or None,
+            "outputDir": output_dir,
+            "skipGit": skip_git or None,
+            "skipPythonSetup": skip_python_setup or None,
+            "skipInstall": skip_install or None,
+            "dryRun": dry_run or None,
+            "json": as_json or None,
+            "modelId": model_id,
+            "apiKeyArn": api_key_arn,
+            "apiBase": api_base,
+            "additionalParams": additional_params,
+            "harnessMemory": False if no_harness_memory else None,
+            "maxIterations": max_iterations,
+            "maxTokens": max_tokens,
+            "timeout": timeout,
+            "truncationStrategy": truncation_strategy,
+            "container": container,
+        }
+        try:
+            dispatch_create(options)
+        except typer.Exit:
+            raise
+        except Exception as exc:  # noqa: BLE001 - top-level command boundary, as upstream
+            typer.echo(f"Error: {get_error_message(exc)}", err=True)
+            raise typer.Exit(1) from None