agentcore-cli 0.31.1__py3-none-any.whl

agentcore/cli/commands/import_/types.py

@@ -0,0 +1,150 @@
+"""Port of commands/import/types.ts.
+
+Project specs, targets and AWS details are handled as camelCase JSON dicts, exactly as upstream
+treats them as plain objects.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any, Generic, Literal, TypeVar
+
+if TYPE_CHECKING:
+    from agentcore.cli.commands.import_.import_utils import ImportedResource, ProjectContext
+    from agentcore.logging.exec_logger import ExecLogger
+
+ImportableResourceType = Literal["runtime", "memory", "evaluator", "online-eval", "gateway"]
+IMPORTABLE_RESOURCES: tuple[ImportableResourceType, ...] = ("runtime", "memory", "evaluator", "online-eval", "gateway")
+
+
+@dataclass
+class ParsedStarterToolkitAgent:
+    name: str
+    entrypoint: str
+    build: Literal["CodeZip", "Container"]
+    language: str
+    network_mode: Literal["PUBLIC", "VPC"]
+    protocol: str
+    enable_otel: bool
+    runtime_version: str | None = None
+    source_path: str | None = None
+    network_config: dict[str, Any] | None = None
+    physical_agent_id: str | None = None
+    physical_agent_arn: str | None = None
+    authorizer_type: str | None = None
+    authorizer_configuration: dict[str, Any] | None = None
+    execution_role_arn: str | None = None
+
+
+@dataclass
+class ParsedStarterToolkitMemory:
+    name: str
+    mode: str
+    event_expiry_days: Any
+    physical_memory_id: str | None = None
+    physical_memory_arn: str | None = None
+
+
+@dataclass
+class ParsedStarterToolkitCredential:
+    name: str
+    provider_type: Literal["oauth", "api_key"]
+
+
+@dataclass
+class ParsedStarterToolkitConfig:
+    agents: list[ParsedStarterToolkitAgent] = field(default_factory=list)
+    memories: list[ParsedStarterToolkitMemory] = field(default_factory=list)
+    credentials: list[ParsedStarterToolkitCredential] = field(default_factory=list)
+    aws_target: dict[str, str] = field(default_factory=dict)
+    default_agent: str | None = None
+
+
+@dataclass
+class ResourceToImport:
+    resource_type: str
+    logical_resource_id: str
+    resource_identifier: dict[str, str]
+
+
+@dataclass
+class ImportResult:
+    """Result of the starter-toolkit import (``agentcore import --source``)."""
+
+    success: bool
+    error: BaseException | None = None
+    project_spec: dict[str, Any] | None = None
+    imported_agents: list[str] | None = None
+    imported_memories: list[str] | None = None
+    stack_name: str | None = None
+    log_path: str | None = None
+
+
+@dataclass
+class ImportResourceResult:
+    """Result for single-resource import (runtime, memory, evaluator, ...)."""
+
+    success: bool
+    resource_type: ImportableResourceType
+    resource_name: str
+    resource_id: str | None = None
+    error: BaseException | None = None
+    log_path: str | None = None
+
+
+@dataclass
+class ImportResourceOptions:
+    arn: str | None = None
+    target: str | None = None
+    name: str | None = None
+    yes: bool | None = None
+    on_progress: Callable[[str], None] | None = None
+    # Runtime-only (RuntimeImportOptions)
+    code: str | None = None
+    entrypoint: str | None = None
+
+
+RuntimeImportOptions = ImportResourceOptions
+
+TDetail = TypeVar("TDetail")
+TSummary = TypeVar("TSummary")
+
+
+@dataclass
+class BeforeWriteContext(Generic[TDetail]):
+    detail: TDetail
+    local_name: str
+    project_spec: dict[str, Any]
+    ctx: ProjectContext
+    target: Any
+    options: ImportResourceOptions
+    on_progress: Callable[[str], None]
+    logger: ExecLogger
+
+
+@dataclass
+class ResourceImportDescriptor(Generic[TDetail, TSummary]):
+    """Resource-type-specific behaviour for the generic import orchestrator."""
+
+    resource_type: ImportableResourceType
+    display_name: str
+    log_command: str
+    list_resources: Callable[[str], list[TSummary]]
+    get_detail: Callable[[str, str], TDetail]
+    parse_resource_id: Callable[[str, Any], str]
+    extract_summary_id: Callable[[TSummary], str]
+    format_list_item: Callable[[TSummary, int], str]
+    format_auto_select_message: Callable[[TSummary], str]
+    extract_detail_name: Callable[[TDetail], str]
+    extract_detail_arn: Callable[[TDetail], str]
+    ready_status: str
+    extract_detail_status: Callable[[TDetail], str]
+    get_existing_names: Callable[[dict[str, Any]], list[str]]
+    add_to_project_spec: Callable[[TDetail, str, dict[str, Any]], ImportResourceResult]
+    cfn_resource_type: str
+    cfn_name_property: str
+    cfn_identifier_key: str
+    build_deployed_state_entry: Callable[[str, str, TDetail], ImportedResource]
+    before_config_write: Callable[[BeforeWriteContext[TDetail]], ImportResourceResult | None] | None = None
+    rollback_extra: Callable[[], None] | None = None

agentcore/cli/commands/import_/yaml_parser.py

@@ -0,0 +1,265 @@
+"""Starter toolkit ``.bedrock_agentcore.yaml`` parser (port of commands/import/yaml-parser.ts).
+
+Deliberately keeps upstream's minimal line-based YAML parser (with its quirks, e.g. a bare
+``key:`` becomes ``{}``) instead of a full YAML library, so imports behave identically.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from typing import Any
+
+from agentcore.cli.commands.import_._js import js_number, js_string, truthy
+from agentcore.cli.commands.import_.constants import RUNTIME_TYPE_MAP
+from agentcore.cli.commands.import_.types import (
+    ParsedStarterToolkitAgent,
+    ParsedStarterToolkitConfig,
+    ParsedStarterToolkitCredential,
+    ParsedStarterToolkitMemory,
+)
+from agentcore.schema.constants import PROTOCOL_MODES
+
+_Frame = dict[str, Any]
+
+
+def _find_parent(stack: list[_Frame], indent: int) -> _Frame:
+    while len(stack) > 1 and stack[-1]["indent"] >= indent:
+        stack.pop()
+    return stack[-1]
+
+
+def _parse_yaml_value(value: str) -> Any:
+    if value in ("null", "~", ""):
+        return None
+    if value == "true":
+        return True
+    if value == "false":
+        return False
+    if len(value) >= 2 and (
+        (value.startswith('"') and value.endswith('"')) or (value.startswith("'") and value.endswith("'"))
+    ):
+        return value[1:-1]
+    if value in ('"', "'"):
+        # JS: startsWith and endsWith on a 1-char quote are both true; slice(1, -1) is ''.
+        return ""
+    num = js_number(value)
+    if num is not None and value.strip() != "":
+        return num
+    return value
+
+
+def _first_non_space(line: str) -> int:
+    for i, ch in enumerate(line):
+        if not ch.isspace():
+            return i
+    return -1
+
+
+def parse_simple_yaml(content: str) -> dict[str, Any]:
+    try:
+        parsed = json.loads(content)
+        return parsed if isinstance(parsed, dict) else {}
+    except ValueError:
+        pass
+
+    result: dict[str, Any] = {}
+    stack: list[_Frame] = [{"indent": -1, "obj": result}]
+
+    for raw_line in content.split("\n"):
+        trimmed = raw_line.strip()
+        if not trimmed or trimmed.startswith("#"):
+            continue
+        indent = _first_non_space(raw_line)
+
+        if trimmed.startswith("- "):
+            parent_entry = _find_parent(stack, indent)
+            parent_obj: dict[str, Any] = parent_entry["obj"]
+            keys = list(parent_obj.keys())
+            last_key = keys[-1] if keys else None
+
+            # "key:" followed by "- item": the empty object created for "key:" becomes an array.
+            if not last_key and len(parent_obj) == 0 and len(stack) > 1:
+                stack.pop()
+                parent_entry = stack[-1]
+                parent_obj = parent_entry["obj"]
+                keys = list(parent_obj.keys())
+                last_key = keys[-1] if keys else None
+
+            if last_key:
+                if not isinstance(parent_obj[last_key], list):
+                    parent_obj[last_key] = []
+                item_content = trimmed[2:].strip()
+                colon = item_content.find(":")
+                if colon > 0 and not item_content.startswith("http"):
+                    item_obj: dict[str, Any] = {}
+                    item_key = item_content[:colon].strip()
+                    item_val = item_content[colon + 1 :].strip()
+                    item_obj[item_key] = {} if item_val == "" else _parse_yaml_value(item_val)
+                    parent_obj[last_key].append(item_obj)
+                    stack.append({"indent": indent, "obj": item_obj})
+                else:
+                    parent_obj[last_key].append(_parse_yaml_value(item_content))
+            continue
+
+        colon = trimmed.find(":")
+        if colon == -1:
+            continue
+        key = trimmed[:colon].strip()
+        value_str = trimmed[colon + 1 :].strip()
+        parent = _find_parent(stack, indent)
+        if value_str in ("", "|"):
+            child: dict[str, Any] = {}
+            parent["obj"][key] = child
+            stack.append({"indent": indent, "obj": child})
+        else:
+            parent["obj"][key] = _parse_yaml_value(value_str)
+
+    return result
+
+
+def _as_dict(value: Any) -> dict[str, Any] | None:
+    return value if isinstance(value, dict) else None
+
+
+def _extract_authorizer_config(raw: Any) -> dict[str, Any]:
+    """Starter toolkit uses ``customJWTAuthorizer`` (capital JWT); the CLI schema ``customJwtAuthorizer``."""
+    if raw is None or raw == "null" or not isinstance(raw, (dict, list)):
+        return {}
+    if not isinstance(raw, dict):
+        return {}
+    jwt_raw = raw.get("customJWTAuthorizer")
+    if not jwt_raw or not isinstance(jwt_raw, (dict, list)) or not isinstance(jwt_raw, dict):
+        return {}
+    discovery_url = jwt_raw.get("discoveryUrl")
+    if not truthy(discovery_url):
+        return {}
+    jwt: dict[str, Any] = {"discoveryUrl": discovery_url}
+    for key in ("allowedAudience", "allowedClients", "allowedScopes", "customClaims"):
+        if isinstance(jwt_raw.get(key), list):
+            jwt[key] = jwt_raw[key]
+    return {"authorizer_type": "CUSTOM_JWT", "authorizer_configuration": {"customJwtAuthorizer": jwt}}
+
+
+def _nn(value: Any, default: Any) -> Any:
+    """JS ``value ?? default``."""
+    return default if value is None else value
+
+
+def parse_starter_toolkit_yaml(file_path: str) -> ParsedStarterToolkitConfig:
+    with open(file_path, encoding="utf-8") as fh:
+        content = fh.read()
+    raw = parse_simple_yaml(content)
+    yaml_dir = os.path.dirname(os.path.abspath(file_path))
+
+    agents: list[ParsedStarterToolkitAgent] = []
+    memories: list[ParsedStarterToolkitMemory] = []
+    credentials: list[ParsedStarterToolkitCredential] = []
+    aws_target: dict[str, str] = {}
+
+    default_agent = raw.get("default_agent")
+    agents_map = raw.get("agents")
+
+    if truthy(agents_map) and isinstance(agents_map, dict):
+        for agent_key, agent_config in agents_map.items():
+            agent_config = agent_config if isinstance(agent_config, dict) else {}
+            aws_config = _as_dict(agent_config.get("aws"))
+            bedrock_config = _as_dict(agent_config.get("bedrock_agentcore"))
+            memory_config = _as_dict(agent_config.get("memory"))
+            network_config = _as_dict(aws_config.get("network_configuration")) if aws_config else None
+            protocol_config = _as_dict(aws_config.get("protocol_configuration")) if aws_config else None
+            obs_config = _as_dict(aws_config.get("observability")) if aws_config else None
+
+            if aws_config is not None and (not aws_target.get("account") or not aws_target.get("region")):
+                aws_target = {
+                    "account": js_string(_nn(aws_config.get("account"), "")),
+                    "region": js_string(_nn(aws_config.get("region"), "")),
+                }
+
+            deployment_type = js_string(_nn(agent_config.get("deployment_type"), "container"))
+            build = "CodeZip" if deployment_type == "direct_code_deploy" else "Container"
+
+            raw_runtime_type = js_string(_nn(agent_config.get("runtime_type"), "PYTHON_3_12"))
+            runtime_version = RUNTIME_TYPE_MAP.get(raw_runtime_type, "PYTHON_3_12")
+
+            network_mode = js_string(_nn(network_config.get("network_mode") if network_config else None, "PUBLIC"))
+            mode_config = _as_dict(network_config.get("network_mode_config")) if network_config else None
+
+            protocol_raw = js_string(_nn(protocol_config.get("server_protocol") if protocol_config else None, "HTTP"))
+            protocol = protocol_raw if protocol_raw in PROTOCOL_MODES else "HTTP"
+
+            parsed_network: dict[str, Any] | None = None
+            if network_mode == "VPC" and mode_config is not None:
+                parsed_network = {
+                    "subnets": mode_config["subnets"] if isinstance(mode_config.get("subnets"), list) else [],
+                    "securityGroups": mode_config["security_groups"]
+                    if isinstance(mode_config.get("security_groups"), list)
+                    else [],
+                }
+                vpc_id = mode_config.get("vpc_id")
+                if isinstance(vpc_id, str) and vpc_id:
+                    parsed_network["vpcId"] = vpc_id
+
+            name = js_string(_nn(agent_config.get("name"), agent_key))
+            source_path = agent_config.get("source_path")
+            auth = _extract_authorizer_config(agent_config.get("authorizer_configuration"))
+            execution_role = aws_config.get("execution_role") if aws_config else None
+            enabled = obs_config.get("enabled") if obs_config else None
+
+            agents.append(
+                ParsedStarterToolkitAgent(
+                    name=name,
+                    entrypoint=js_string(_nn(agent_config.get("entrypoint"), "main.py")),
+                    build=build,  # type: ignore[arg-type]
+                    runtime_version=runtime_version,
+                    language=_nn(agent_config.get("language"), "python"),
+                    source_path=os.path.abspath(os.path.join(yaml_dir, js_string(source_path)))
+                    if truthy(source_path)
+                    else None,
+                    network_mode=network_mode,  # type: ignore[arg-type]
+                    network_config=parsed_network,
+                    protocol=protocol,
+                    enable_otel=_nn(enabled, True),
+                    physical_agent_id=bedrock_config.get("agent_id") if bedrock_config else None,
+                    physical_agent_arn=bedrock_config.get("agent_arn") if bedrock_config else None,
+                    authorizer_type=auth.get("authorizer_type"),
+                    authorizer_configuration=auth.get("authorizer_configuration"),
+                    execution_role_arn=execution_role if truthy(execution_role) else None,
+                )
+            )
+
+            # Memory per agent; a bare "mode:" parses as {} and is ignored.
+            mode = memory_config.get("mode") if memory_config else None
+            if memory_config is not None and isinstance(mode, str) and mode != "NO_MEMORY" and mode:
+                mem_name = _nn(memory_config.get("memory_name"), f"{name}_memory")
+                if not any(m.name == mem_name for m in memories):
+                    memories.append(
+                        ParsedStarterToolkitMemory(
+                            name=mem_name,
+                            mode=mode,
+                            event_expiry_days=_nn(memory_config.get("event_expiry_days"), 30),
+                            physical_memory_id=memory_config.get("memory_id"),
+                            physical_memory_arn=memory_config.get("memory_arn"),
+                        )
+                    )
+
+            identity_config = _as_dict(agent_config.get("identity"))
+            if identity_config is not None:
+                providers = identity_config.get("credential_providers")
+                if isinstance(providers, list):
+                    for provider in providers:
+                        provider_name = provider.get("name") if isinstance(provider, dict) else None
+                        if truthy(provider_name) and not any(c.name == provider_name for c in credentials):
+                            credentials.append(ParsedStarterToolkitCredential(provider_name, "oauth"))
+
+            api_key_cred_name = agent_config.get("api_key_credential_provider_name")
+            if truthy(api_key_cred_name) and not any(c.name == api_key_cred_name for c in credentials):
+                credentials.append(ParsedStarterToolkitCredential(api_key_cred_name, "api_key"))
+
+    return ParsedStarterToolkitConfig(
+        default_agent=default_agent,
+        agents=agents,
+        memories=memories,
+        credentials=credentials,
+        aws_target=aws_target,
+    )

agentcore/cli/commands/init.py

@@ -0,0 +1,196 @@
+"""`agentcore init NAME --framework strands|langgraph|custom` (Python-port addition).
+
+A short form of `agentcore create` for the quick-start flow::
+
+    agentcore init my-agent --framework strands
+    cd my-agent && agentcore dev
+
+NAME becomes the folder. The project and agent names are derived from it, because project
+names allow only letters and digits and agent names letters, digits and underscores
+(`my-agent` -> project `MyAgent`, agent `my_agent`). `invoke --agent-name my-agent` accepts
+the hyphenated form.
+"""
+
+import json
+import os
+import re
+import textwrap
+
+import typer
+
+from agentcore.cli.commands.create import handle_create_cli, print_create_summary
+from agentcore.cli.run_command import run_cli_command
+from agentcore.lib.errors.types import ValidationError
+
+DESCRIPTION = "Initialize a new agent project (framework: strands, langgraph, or custom)."
+
+# Short names accepted by --framework; upstream names are accepted too (case-insensitive).
+FRAMEWORK_ALIASES = {
+    "strands": "Strands",
+    "langgraph": "LangChain_LangGraph",
+    "langchain": "LangChain_LangGraph",
+    "langchain_langgraph": "LangChain_LangGraph",
+    "googleadk": "GoogleADK",
+    "google-adk": "GoogleADK",
+    "openai": "OpenAIAgents",
+    "openaiagents": "OpenAIAgents",
+    "openai-agents": "OpenAIAgents",
+    "vercelai": "VercelAI",
+    "vercel-ai": "VercelAI",
+}
+TYPESCRIPT_ONLY = {"VercelAI"}
+NEXT_STEPS = ["agentcore dev", "agentcore deploy --region us-east-1"]
+
+
+def derive_names(folder: str) -> tuple[str, str]:
+    """(project name, agent name) for a folder name, or ValidationError if none can be derived."""
+    words = [w for w in re.split(r"[^A-Za-z0-9]+", folder) if w]
+    if not words or not words[0][0].isalpha():
+        raise ValidationError(f'"{folder}" must start with a letter (e.g. my-agent).')
+    project = "".join(w[0].upper() + w[1:] for w in words)[:23]
+    agent = "_".join(words)[:48]
+    return project, agent
+
+
+def resolve_framework(value: str) -> str:
+    """Upstream framework name for --framework, or "custom"."""
+    key = value.strip().lower()
+    if key == "custom":
+        return "custom"
+    if key in FRAMEWORK_ALIASES:
+        return FRAMEWORK_ALIASES[key]
+    for upstream in set(FRAMEWORK_ALIASES.values()):
+        if key == upstream.lower():
+            return upstream
+    raise ValidationError(f'Unknown framework "{value}". Use strands, langgraph, or custom.')
+
+
+_CUSTOM_MAIN = textwrap.dedent(
+    """\
+    from bedrock_agentcore.runtime import BedrockAgentCoreApp
+
+    app = BedrockAgentCoreApp()
+
+
+    @app.entrypoint
+    async def invoke(payload, context):
+        prompt = payload.get("prompt", "")
+        # Replace this with your agent: call a model, run tools, return the answer.
+        return {"result": f"You said: {prompt}"}
+
+
+    if __name__ == "__main__":
+        app.run()
+    """
+)
+
+_CUSTOM_PYPROJECT = textwrap.dedent(
+    """\
+    [build-system]
+    requires = ["hatchling"]
+    build-backend = "hatchling.build"
+
+    [project]
+    name = "{name}"
+    version = "0.1.0"
+    description = "AgentCore Runtime Application (custom code)"
+    requires-python = ">=3.10"
+    dependencies = [
+        "aws-opentelemetry-distro ~= 0.18.0",
+        "bedrock-agentcore >= 1.18.1",
+        "botocore[crt] >= 1.35.0",
+    ]
+
+    [tool.hatch.build.targets.wheel]
+    packages = ["."]
+    """
+)
+
+
+def _init_custom(folder: str, project: str, agent: str, cwd: str, o: dict) -> None:
+    """Project plus a bring-your-own-code agent with a minimal entrypoint to start from."""
+    from agentcore.cli.commands.create.action import create_project
+    from agentcore.primitives.agent import PRIMITIVE as agent_primitive
+    from agentcore.primitives.agent import AddAgentOptions
+
+    if os.path.exists(os.path.join(cwd, folder)):
+        raise ValidationError(f"A folder named '{folder}' already exists in this directory")
+    created = create_project(
+        project, cwd, skip_git=bool(o.get("skipGit")), skip_install=bool(o.get("skipInstall")), directory=folder
+    )
+    if not created.success:
+        raise created.error
+
+    project_root = created.value["projectPath"]
+    code_dir = os.path.join(project_root, "app", agent)
+    os.makedirs(code_dir, exist_ok=True)
+    with open(os.path.join(code_dir, "main.py"), "w", encoding="utf-8") as fh:
+        fh.write(_CUSTOM_MAIN)
+    with open(os.path.join(code_dir, "pyproject.toml"), "w", encoding="utf-8") as fh:
+        fh.write(_CUSTOM_PYPROJECT.format(name=agent))
+
+    added = agent_primitive.add(
+        AddAgentOptions(
+            name=agent,
+            type="byo",
+            language="Python",
+            build_type=o.get("build") or "CodeZip",
+            code_location=f"app/{agent}/",
+            entrypoint="main.py",
+            protocol=o.get("protocol") or "HTTP",
+            model_provider=o.get("modelProvider") or "Bedrock",
+        ),
+        config_base_dir=os.path.join(project_root, "agentcore"),
+    )
+    if not added.success:
+        raise added.error
+
+    if o.get("json"):
+        typer.echo(
+            json.dumps({"success": True, "projectPath": project_root, "agentName": agent}, separators=(",", ":"))
+        )
+    else:
+        print_create_summary(project, agent, "Python", "custom", directory=folder, next_steps=NEXT_STEPS)
+
+
+def register(app: typer.Typer) -> None:
+    @app.command("init", help=DESCRIPTION)
+    def init(
+        name: str = typer.Argument(..., help="Project folder name (e.g. my-agent)"),
+        framework: str = typer.Option("strands", "--framework", help="strands, langgraph, or custom"),
+        model_provider: str = typer.Option("Bedrock", "--model-provider", help="Bedrock, Anthropic, OpenAI, or Gemini"),
+        api_key: str | None = typer.Option(None, "--api-key", help="API key for non-Bedrock providers"),
+        protocol: str = typer.Option("HTTP", "--protocol", help="HTTP, MCP, A2A, or AGUI"),
+        language: str | None = typer.Option(None, "--language", help="Python or TypeScript (default: Python)"),
+        build: str = typer.Option("CodeZip", "--build", help="CodeZip or Container"),
+        memory: str = typer.Option("none", "--memory", help="none, shortTerm, or longAndShortTerm"),
+        output_dir: str | None = typer.Option(None, "--output-dir", help="Where to create the folder"),
+        skip_git: bool = typer.Option(False, "--skip-git", help="Skip git init"),
+        skip_install: bool = typer.Option(False, "--skip-install", help="Skip dependency installation"),
+        as_json: bool = typer.Option(False, "--json", help="Output as JSON"),
+    ) -> None:
+        o: dict = {
+            "directory": name,
+            "modelProvider": model_provider,
+            "apiKey": api_key,
+            "protocol": protocol,
+            "build": build,
+            "memory": memory,
+            "outputDir": output_dir,
+            "skipGit": skip_git,
+            "skipInstall": skip_install,
+            "json": as_json,
+            "nextSteps": NEXT_STEPS,
+        }
+
+        def run() -> None:
+            project, agent = derive_names(name)
+            resolved = resolve_framework(framework)
+            o.update(projectName=project, name=agent, framework=resolved)
+            o["language"] = language or ("TypeScript" if resolved in TYPESCRIPT_ONLY else "Python")
+            if resolved == "custom":
+                _init_custom(name, project, agent, output_dir or os.getcwd(), o)
+            else:
+                handle_create_cli(o)  # validates, prints and exits like `agentcore create`
+
+        run_cli_command(as_json, run)

agentcore/cli/commands/invoke/__init__.py

@@ -0,0 +1,32 @@
+"""`agentcore invoke` (port of src/cli/commands/invoke)."""
+
+import typer
+
+from agentcore.cli.commands.invoke.action import (
+    InvokeContext,
+    build_harness_base_opts,
+    handle_harness_invoke_by_arn,
+    handle_invoke,
+    load_invoke_config,
+)
+from agentcore.cli.commands.invoke.resolve import ResolveInvokeResult, resolve_invoke_target
+from agentcore.cli.commands.invoke.types import InvokeOptions, InvokeResult
+
+__all__ = [
+    "InvokeContext",
+    "InvokeOptions",
+    "InvokeResult",
+    "ResolveInvokeResult",
+    "build_harness_base_opts",
+    "handle_harness_invoke_by_arn",
+    "handle_invoke",
+    "load_invoke_config",
+    "register",
+    "resolve_invoke_target",
+]
+
+
+def register(app: typer.Typer) -> None:
+    from agentcore.cli.commands.invoke.command import register_invoke
+
+    register_invoke(app)