agentcore-cli 0.31.1__py3-none-any.whl

agentcore/operations/deploy/preflight.py

@@ -0,0 +1,385 @@
+"""Deploy preflight: project validation, synth, bootstrap and stack checks (port of ``preflight.ts``)."""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import sys
+from dataclasses import dataclass
+from typing import Any
+
+from agentcore.aws import account as _account
+from agentcore.cdk.local_cdk_project import LocalCdkProject
+from agentcore.cdk.toolkit import CdkToolkitWrapper, IoHost, create_cdk_toolkit_wrapper, silent_io_host
+from agentcore.cli.constants import MAX_GATEWAY_NAME_LENGTH, MAX_RUNTIME_NAME_LENGTH
+from agentcore.cloudformation.bootstrap import check_bootstrap_status, format_cdk_environment
+from agentcore.cloudformation.stack_status import check_stacks_status
+from agentcore.lib.constants import DOCKERFILE_NAME
+from agentcore.lib.errors.types import ConfigValidationError, StaleCdkConstructError, ValidationError
+from agentcore.lib.packaging.build_context import resolve_build_context
+from agentcore.lib.packaging.build_context_dockerignore import ensure_build_context_dockerignore
+from agentcore.lib.schemas.io.config_io import ConfigIO
+from agentcore.lib.schemas.io.path_resolver import require_config_root
+from agentcore.lib.utils.platform import is_windows
+from agentcore.lib.utils.subprocess import run_subprocess_capture
+
+MINIMUM_CDK_BOOTSTRAP_VERSION = 30
+
+
+@dataclass
+class PreflightContext:
+    project_spec: Any
+    aws_targets: list[Any]
+    cdk_project: LocalCdkProject
+    # True when no deployable resources remain but a deployed stack exists — deploy tears down.
+    is_teardown_deploy: bool
+    # True when deployed-state.json has no targets — never deployed.
+    is_first_deploy: bool
+
+
+@dataclass
+class SynthResult:
+    toolkit_wrapper: CdkToolkitWrapper
+    stack_names: list[str]
+
+
+@dataclass
+class BootstrapCheckResult:
+    needs_bootstrap: bool
+    target: Any | None
+
+
+@dataclass
+class StackStatusCheckResult:
+    can_deploy: bool
+    blocking_stack: str | None = None
+    message: str | None = None
+
+
+def format_error(err: BaseException | object) -> str:
+    """Message plus cause chain; the Python traceback only with AGENTCORE_DEBUG set."""
+    if isinstance(err, BaseException):
+        lines = [str(err)]
+        if os.environ.get("AGENTCORE_DEBUG") and err.__traceback__ is not None:
+            import traceback
+
+            lines += ["", "Stack trace:", "".join(traceback.format_exception(err)).rstrip()]
+        # Upstream's ConfigValidationError carries no `cause` (the Python port chains the pydantic
+        # error via `raise ... from`), so it is not followed here.
+        cause = None if isinstance(err, ConfigValidationError) else err.__cause__
+        if isinstance(cause, BaseException) and cause is not err:
+            lines += ["", "Caused by:", format_error(cause)]
+        return "\n".join(lines)
+    return str(err)
+
+
+# Spec lists whose presence means there's something to deploy (keep in sync with parse_*_outputs).
+DEPLOYABLE_RESOURCE_KEYS = (
+    "runtimes",
+    "agent_core_gateways",
+    "memories",
+    "knowledge_bases",
+    "evaluators",
+    "online_eval_configs",
+    "policy_engines",
+    "config_bundles",
+    "datasets",
+    "capacity_providers",
+    "harnesses",
+    "payments",
+)
+
+
+def has_deployable_resources(spec: Any) -> bool:
+    return any(isinstance(getattr(spec, key, None), list) and getattr(spec, key) for key in DEPLOYABLE_RESOURCE_KEYS)
+
+
+def validate_project(selected_target: Any = None) -> PreflightContext:
+    """Validate the CDK project and config; checks AWS credentials unless this is a teardown deploy."""
+    config_root = require_config_root()
+    project_root = os.path.dirname(config_root)
+
+    cdk_project = LocalCdkProject(project_root)
+    cdk_project.validate()
+
+    config_io = ConfigIO(base_dir=config_root)
+    project_spec = config_io.read_project_spec()
+    aws_targets = config_io.resolve_aws_deployment_targets()
+
+    # deployed-state.json is written after every successful deploy, so it tells whether a stack exists.
+    has_existing_stack = False
+    try:
+        has_existing_stack = len(config_io.read_deployed_state().targets) > 0
+    except Exception:  # noqa: BLE001 - no deployed state, no stack
+        pass
+
+    is_teardown_deploy = False
+    if not has_deployable_resources(project_spec):
+        if not has_existing_stack:
+            raise ValidationError(
+                "No resources defined in project. Add at least one resource (agent, memory, knowledge base, "
+                "evaluator, or gateway) before deploying."
+            )
+        is_teardown_deploy = True
+
+    validate_runtime_names(project_spec)
+    validate_gateway_names(project_spec)
+    validate_container_agents(project_spec, config_root)
+
+    # Harness specs are validated up front for a precise message, except on teardown (the files are
+    # being discarded and must not block destroying the stack).
+    if not is_teardown_deploy:
+        validate_harness_specs(project_spec, config_root)
+
+    if not is_teardown_deploy:
+        _account.validate_aws_credentials(
+            selected_target if selected_target is not None else (aws_targets or [None])[0]
+        )
+
+    return PreflightContext(
+        project_spec=project_spec,
+        aws_targets=aws_targets,
+        cdk_project=cdk_project,
+        is_teardown_deploy=is_teardown_deploy,
+        is_first_deploy=not has_existing_stack,
+    )
+
+
+def validate_runtime_names(project_spec: Any) -> None:
+    for agent in project_spec.runtimes or []:
+        if agent.name:
+            combined = f"{project_spec.name}_{agent.name}"
+            if len(combined) > MAX_RUNTIME_NAME_LENGTH:
+                raise ValidationError(
+                    f'Runtime name too long: "{combined}" ({len(combined)} chars). '
+                    f"AWS limits runtime names to {MAX_RUNTIME_NAME_LENGTH} characters. "
+                    "Shorten the project name or agent name in agentcore.json."
+                )
+
+
+def validate_gateway_names(project_spec: Any) -> None:
+    for gateway in project_spec.agent_core_gateways or []:
+        # Imported gateways carry an explicit resourceName AWS already accepted.
+        if getattr(gateway, "resource_name", None):
+            continue
+        combined = f"{project_spec.name}-{gateway.name}"
+        if len(combined) > MAX_GATEWAY_NAME_LENGTH:
+            raise ValidationError(
+                f'Gateway name too long: "{combined}" ({len(combined)} chars). '
+                f"AWS limits gateway names to {MAX_GATEWAY_NAME_LENGTH} characters. "
+                "Shorten the project name or gateway name in agentcore.json."
+            )
+
+
+def validate_container_agents(project_spec: Any, config_root: str) -> None:
+    """Container agents need a Dockerfile; warns on deprecated base images; adds a context .dockerignore."""
+    errors: list[str] = []
+    for agent in project_spec.runtimes or []:
+        if agent.build != "Container":
+            continue
+        resolved = resolve_build_context(agent, config_root)
+        if not os.path.exists(resolved.dockerfile_path):
+            errors.append(
+                f'Agent "{agent.name}": {agent.dockerfile or DOCKERFILE_NAME} not found at '
+                f"{resolved.dockerfile_path}. Container agents require a Dockerfile."
+            )
+        warn_deprecated_base_image(resolved.dockerfile_path, agent.name)
+        if agent.build_context_path:
+            created = ensure_build_context_dockerignore(resolved.build_context)
+            if created:
+                print(
+                    f'Agent "{agent.name}": created {created} with default secret exclusions because buildContextPath '
+                    "is set (the entire context is sent to Docker/CodeBuild). Review and commit it; edit to include "
+                    "any intentionally-bundled files.",
+                    file=sys.stderr,
+                )
+    if errors:
+        raise RuntimeError("\n".join(errors))
+
+
+def validate_harness_specs(project_spec: Any, config_root: str) -> None:
+    """Parse every harness.json so a bad spec fails preflight with the precise schema message."""
+    harnesses = project_spec.harnesses or []
+    if not harnesses:
+        return
+    config_io = ConfigIO(base_dir=config_root)
+    errors = []
+    for harness in harnesses:
+        try:
+            config_io.read_harness_spec(harness.name)
+        except Exception as exc:  # noqa: BLE001 - aggregated into one message
+            errors.append(f'Harness "{harness.name}": {format_error(exc)}')
+    if errors:
+        raise ValidationError("Invalid harness configuration:\n" + "\n".join(errors))
+
+
+DEPRECATED_BASE_IMAGES = {
+    "slim-bookworm": (
+        "Affected by CVE-2026-42010 (GnuTLS authentication bypass). Update the FROM line to use a Trixie-based variant."
+    ),
+}
+
+_FROM_RE = re.compile(r"^\s*FROM\s+", re.IGNORECASE)
+
+
+def warn_deprecated_base_image(dockerfile_path: str, agent_name: str) -> None:
+    try:
+        with open(dockerfile_path, encoding="utf-8") as fh:
+            content = fh.read()
+    except OSError:
+        return
+    for line in content.split("\n"):
+        if not _FROM_RE.match(line):
+            continue
+        for image, message in DEPRECATED_BASE_IMAGES.items():
+            if image in line:
+                print(
+                    f'Warning: Agent "{agent_name}" Dockerfile uses a base image containing "{image}". {message}',
+                    file=sys.stderr,
+                )
+
+
+def build_cdk_project(cdk_project: LocalCdkProject) -> None:
+    cdk_project.build()
+
+
+# ---------------------------------------------------------------------------
+# Stale CDK lock files (port of tui/utils/process.ts)
+# ---------------------------------------------------------------------------
+
+
+def is_process_running(pid: int) -> bool:
+    if is_windows:
+        result = run_subprocess_capture("tasklist", ["/FI", f"PID eq {pid}", "/NH"])
+        return "No tasks" not in result.stdout
+    try:
+        os.kill(pid, 0)
+    except ProcessLookupError:
+        return False
+    except PermissionError:
+        return True
+    except OSError:
+        return False
+    return True
+
+
+_READ_LOCK_RE = re.compile(r"^read\.(\d+)\.\d+\.lock$")
+
+
+def cleanup_stale_lock_files(cdk_out_dir: str) -> None:
+    """Remove ``read.<PID>.<n>.lock`` files whose process is gone (never touches synth.lock)."""
+    if not os.path.isdir(cdk_out_dir):
+        return
+    for name in os.listdir(cdk_out_dir):
+        match = _READ_LOCK_RE.match(name)
+        if not match:
+            continue
+        if not is_process_running(int(match.group(1))):
+            try:
+                os.unlink(os.path.join(cdk_out_dir, name))
+            except OSError:
+                pass
+
+
+# ---------------------------------------------------------------------------
+# Synth
+# ---------------------------------------------------------------------------
+
+
+def synthesize_cdk(
+    cdk_project: LocalCdkProject,
+    *,
+    io_host: IoHost | None = None,
+    previous_wrapper: CdkToolkitWrapper | None = None,
+    region: str | None = None,
+) -> SynthResult:
+    if previous_wrapper is not None:
+        previous_wrapper.dispose()
+    cleanup_stale_lock_files(os.path.join(str(cdk_project.project_dir), "cdk.out"))
+    wrapper = create_cdk_toolkit_wrapper(cdk_project.project_dir, io_host=io_host or silent_io_host, region=region)
+    try:
+        synth = wrapper.synth()
+    except Exception as exc:
+        raise rewrite_if_stale_cdk_construct(exc, str(cdk_project.project_dir)) from exc
+    return SynthResult(toolkit_wrapper=wrapper, stack_names=synth.stack_names)
+
+
+_UNKNOWN_KEYS_RE = re.compile(r"unknown keys \(remove\): (.+?)(?:\n|$)")
+
+
+def extract_unknown_keys(err: BaseException | object) -> list[str]:
+    match = _UNKNOWN_KEYS_RE.search(format_error(err))
+    if not match or not match.group(1):
+        return []
+    keys = [re.sub(r'^"|"$', "", k.strip()) for k in match.group(1).split(",")]
+    return [k for k in keys if k]
+
+
+def read_installed_cdk_construct_version(cdk_project_dir: str) -> str | None:
+    try:
+        path = os.path.join(cdk_project_dir, "node_modules", "@aws", "agentcore-cdk", "package.json")
+        with open(path, encoding="utf-8") as fh:
+            return json.load(fh).get("version")
+    except (OSError, ValueError, AttributeError):
+        return None
+
+
+def rewrite_if_stale_cdk_construct(err: BaseException, cdk_project_dir: str) -> BaseException:
+    """An "unknown keys" synth rejection means the project's @aws/agentcore-cdk is older than the CLI."""
+    keys = extract_unknown_keys(err)
+    if not keys:
+        return err
+    return StaleCdkConstructError(keys, read_installed_cdk_construct_version(cdk_project_dir), cause=err)
+
+
+def check_stack_deployability(region: str, stack_names: list[str]) -> StackStatusCheckResult:
+    blocking = check_stacks_status(region, stack_names)
+    if blocking:
+        return StackStatusCheckResult(False, blocking.stack_name, blocking.result.message)
+    return StackStatusCheckResult(True)
+
+
+def check_bootstrap_needed(aws_targets: list[Any]) -> BootstrapCheckResult:
+    """Bootstrap needed when CDKToolkit is missing/unusable or older than version 30."""
+    target = aws_targets[0] if aws_targets else None
+    if target is None:
+        return BootstrapCheckResult(False, None)
+    try:
+        status = check_bootstrap_status(target.region)
+        if not status.is_bootstrapped or (status.bootstrap_version or 0) < MINIMUM_CDK_BOOTSTRAP_VERSION:
+            return BootstrapCheckResult(True, target)
+    except Exception:  # noqa: BLE001 - deploy will fail with a clearer error
+        pass
+    return BootstrapCheckResult(False, None)
+
+
+def bootstrap_environment(toolkit_wrapper: CdkToolkitWrapper, target: Any) -> None:
+    toolkit_wrapper.bootstrap([format_cdk_environment(target.account, target.region)])
+
+
+__all__ = [
+    "DEPLOYABLE_RESOURCE_KEYS",
+    "MINIMUM_CDK_BOOTSTRAP_VERSION",
+    "BootstrapCheckResult",
+    "PreflightContext",
+    "StackStatusCheckResult",
+    "SynthResult",
+    "bootstrap_environment",
+    "build_cdk_project",
+    "check_bootstrap_needed",
+    "check_stack_deployability",
+    "cleanup_stale_lock_files",
+    "extract_unknown_keys",
+    "format_error",
+    "has_deployable_resources",
+    "read_installed_cdk_construct_version",
+    "rewrite_if_stale_cdk_construct",
+    "synthesize_cdk",
+    "validate_container_agents",
+    "validate_gateway_names",
+    "validate_harness_specs",
+    "validate_project",
+    "validate_runtime_names",
+    "warn_deprecated_base_image",
+]

agentcore/operations/deploy/region_override.py

@@ -0,0 +1,45 @@
+"""`agentcore deploy --region` (Python-port addition; upstream reads the region from aws-targets.json).
+
+The region is applied to the selected target before the normal deploy flow runs:
+- no targets yet: AWS_REGION is set so the auto-created ``default`` target lands there;
+- target exists, never deployed: its region is updated in aws-targets.json;
+- target already deployed elsewhere: refused, since moving it would orphan the existing stack.
+"""
+
+import os
+
+from agentcore.lib.errors.types import ConfigNotFoundError, ValidationError
+from agentcore.lib.schemas.io.config_io import ConfigIO
+from agentcore.schema.schemas.aws_targets import AGENTCORE_REGIONS
+
+
+def apply_region_override(region: str, target_name: str, config_io: ConfigIO | None = None) -> None:
+    if region not in AGENTCORE_REGIONS:
+        raise ValidationError(
+            f'Region "{region}" is not supported by AgentCore. Supported regions: {", ".join(AGENTCORE_REGIONS)}'
+        )
+    config_io = config_io or ConfigIO()
+    # Also drives region detection for anything that runs before or without a target.
+    os.environ["AWS_REGION"] = region
+
+    try:
+        targets = [t.to_json_dict() for t in config_io.read_aws_deployment_targets()]
+    except ConfigNotFoundError:
+        targets = []
+
+    target = next((t for t in targets if t["name"] == target_name), None)
+    if target is None or target["region"] == region:
+        return
+
+    try:
+        deployed = target_name in (config_io.read_deployed_state().targets or {})
+    except Exception:  # noqa: BLE001 - no deployed state means nothing to orphan
+        deployed = False
+    if deployed:
+        raise ValidationError(
+            f'Target "{target_name}" is already deployed to {target["region"]}. To deploy to {region}, add a new '
+            f"target to agentcore/aws-targets.json and pass --target <name>."
+        )
+
+    target["region"] = region
+    config_io.write_aws_deployment_targets(targets)

agentcore/operations/deploy/teardown.py

@@ -0,0 +1,153 @@
+"""Stack teardown after `remove all` (port of ``operations/deploy/teardown.ts``)."""
+
+from __future__ import annotations
+
+import os
+import sys
+from dataclasses import dataclass, field
+from typing import Any
+
+from agentcore.aws import agentcore_config_bundles, agentcore_harness
+from agentcore.aws.target_region import target_region
+from agentcore.cdk.toolkit import CdkToolkitWrapper, pattern_must_match, silent_io_host
+from agentcore.cloudformation import stack_discovery
+from agentcore.cloudformation.stack_discovery import DiscoveredStack
+from agentcore.lib.constants import CONFIG_DIR
+from agentcore.lib.result import Ok, ok
+from agentcore.lib.schemas.io.config_io import ConfigIO
+from agentcore.operations.harness.orphan import find_orphan_harnesses
+
+
+@dataclass
+class DeployedTarget:
+    target: Any
+    stack: DiscoveredStack
+
+
+@dataclass
+class DiscoverDeployedResult:
+    project_name: str
+    deployed_targets: list[DeployedTarget] = field(default_factory=list)
+
+
+def discover_deployed_targets(config_base_dir: str | None = None) -> DiscoverDeployedResult:
+    """Targets that have a CloudFormation stack (per-target errors, e.g. no credentials, are ignored)."""
+    config_io = ConfigIO(base_dir=config_base_dir) if config_base_dir else ConfigIO()
+    project_spec = config_io.read_project_spec()
+    deployed: list[DeployedTarget] = []
+    for target in config_io.resolve_aws_deployment_targets():
+        try:
+            stack = stack_discovery.find_stack(target.region, project_spec.name, target.name)
+            if stack:
+                deployed.append(DeployedTarget(target, stack))
+        except Exception:  # noqa: BLE001
+            pass
+    return DiscoverDeployedResult(project_spec.name, deployed)
+
+
+def destroy_target(*, target: DeployedTarget, cdk_project_dir: str, toolkit: CdkToolkitWrapper | None = None) -> None:
+    """Destroy one target's stack and drop it from deployed-state.json."""
+    if not os.path.exists(cdk_project_dir):
+        raise RuntimeError("CDK project not found. Cannot destroy without CDK project.")
+    wrapper = toolkit or CdkToolkitWrapper(cdk_project_dir, io_host=silent_io_host, region=target.target.region)
+    try:
+        # aws-targets.json is authoritative for the destroy region (aws/agentcore-cli#924).
+        with target_region(target.target.region):
+            if toolkit is None:
+                wrapper.initialize()
+            wrapper.destroy(pattern_must_match(target.stack.stack_name))
+    finally:
+        if toolkit is None:
+            wrapper.dispose()
+
+    config_io = ConfigIO()
+    try:
+        state = config_io.read_deployed_state()
+        if target.target.name in state.targets:
+            del state.targets[target.target.name]
+            config_io.write_deployed_state(state)
+    except Exception:  # noqa: BLE001
+        pass
+
+
+def get_cdk_project_dir(cwd: str | None = None) -> str:
+    return os.path.join(cwd or os.getcwd(), CONFIG_DIR, "cdk")
+
+
+def _is_not_found_message(msg: str) -> bool:
+    return "ENOENT" in msg or "not found" in msg or "does not exist" in msg
+
+
+def perform_stack_teardown(target_name: str, toolkit: CdkToolkitWrapper | None = None) -> Ok[None]:
+    """Destroy the target's stack, then remove it from deployed-state.json and aws-targets.json."""
+    cdk_project_dir = get_cdk_project_dir()
+    config_io = ConfigIO()
+    discovered = discover_deployed_targets()
+    deployed_target = next((dt for dt in discovered.deployed_targets if dt.target.name == target_name), None)
+
+    # Clean up imperatively created resources the stack destroy won't touch.
+    try:
+        state = config_io.read_deployed_state()
+        target_state = state.targets.get(target_name)
+        resources = target_state.resources if target_state else None
+
+        for orphan in [o for o in find_orphan_harnesses(state) if o.target_name == target_name]:
+            try:
+                agentcore_harness.delete_harness(region=orphan.region, harness_id=orphan.harness_id)
+                print(f'Deleted preview-build harness "{orphan.name}"')
+            except Exception as exc:  # noqa: BLE001
+                if not agentcore_harness.is_harness_not_found_error(exc):
+                    print(
+                        f'Warning: Could not delete preview-build harness "{orphan.name}" ({orphan.harness_id}) in '
+                        f"{orphan.region}: {exc}. Delete it manually to stop incurring cost.",
+                        file=sys.stderr,
+                    )
+
+        if resources is not None and resources.config_bundles:
+            region = deployed_target.target.region if deployed_target else None
+            if not region:
+                try:
+                    match = next((t for t in config_io.resolve_aws_deployment_targets() if t.name == target_name), None)
+                    region = match.region if match else None
+                except Exception:  # noqa: BLE001
+                    pass
+            if not region:
+                print(
+                    "Warning: Could not determine region for resource cleanup — resources may need manual deletion",
+                    file=sys.stderr,
+                )
+            else:
+                for bundle_name, bundle in resources.config_bundles.items():
+                    try:
+                        agentcore_config_bundles.delete_configuration_bundle(region=region, bundle_id=bundle.bundle_id)
+                        print(f'Deleted config bundle "{bundle_name}"')
+                    except Exception as exc:  # noqa: BLE001
+                        print(f'Warning: Error during config bundle "{bundle_name}" cleanup: {exc}', file=sys.stderr)
+    except Exception as exc:  # noqa: BLE001
+        if not _is_not_found_message(str(exc)):
+            print(f"Warning: Could not read deployed state for resource cleanup: {exc}", file=sys.stderr)
+
+    if deployed_target:
+        destroy_target(target=deployed_target, cdk_project_dir=cdk_project_dir, toolkit=toolkit)
+
+    # deployed-state.json first (it validates against aws-targets.json), then aws-targets.json.
+    try:
+        state = config_io.read_deployed_state()
+        state.targets.pop(target_name, None)
+        config_io.write_deployed_state(state)
+    except Exception as exc:
+        if not ("ENOENT" in str(exc) or "not found" in str(exc)):
+            raise
+    remaining = [t for t in config_io.resolve_aws_deployment_targets() if t.name != target_name]
+    config_io.write_aws_deployment_targets(remaining)
+    return ok()
+
+
+__all__ = [
+    "DeployedTarget",
+    "DiscoverDeployedResult",
+    "destroy_target",
+    "discover_deployed_targets",
+    "get_cdk_project_dir",
+    "perform_stack_teardown",
+]

agentcore/operations/dev/__init__.py

@@ -0,0 +1,61 @@
+"""Local development server (port of src/cli/operations/dev)."""
+
+from agentcore.operations.dev.config import (
+    DevConfig,
+    get_agent_port,
+    get_dev_config,
+    get_dev_port,
+    get_dev_supported_agents,
+    load_project_config,
+    requires_exact_dev_port,
+)
+from agentcore.operations.dev.invoke import invoke_agent, invoke_agent_streaming, invoke_for_protocol
+from agentcore.operations.dev.invoke_a2a import A2AAgentCard, fetch_a2a_agent_card, invoke_a2a_streaming
+from agentcore.operations.dev.invoke_agui import invoke_agui_streaming
+from agentcore.operations.dev.invoke_mcp import McpTool, McpToolsResult, call_mcp_tool, list_mcp_tools
+from agentcore.operations.dev.load_dev_env import DevEnv, load_dev_env
+from agentcore.operations.dev.server import (
+    DevServer,
+    DevServerCallbacks,
+    DevServerOptions,
+    LogLevel,
+    create_dev_server,
+    find_available_port,
+    wait_for_port,
+    wait_for_server_ready,
+)
+from agentcore.operations.dev.utils import format_mcp_tool_list, get_endpoint_url, on_shutdown_signal
+
+__all__ = [
+    "A2AAgentCard",
+    "DevConfig",
+    "DevEnv",
+    "DevServer",
+    "DevServerCallbacks",
+    "DevServerOptions",
+    "LogLevel",
+    "McpTool",
+    "McpToolsResult",
+    "call_mcp_tool",
+    "create_dev_server",
+    "fetch_a2a_agent_card",
+    "find_available_port",
+    "format_mcp_tool_list",
+    "get_agent_port",
+    "get_dev_config",
+    "get_dev_port",
+    "get_dev_supported_agents",
+    "get_endpoint_url",
+    "invoke_a2a_streaming",
+    "invoke_agent",
+    "invoke_agent_streaming",
+    "invoke_agui_streaming",
+    "invoke_for_protocol",
+    "list_mcp_tools",
+    "load_dev_env",
+    "load_project_config",
+    "on_shutdown_signal",
+    "requires_exact_dev_port",
+    "wait_for_port",
+    "wait_for_server_ready",
+]