agentcore-cli 0.31.1__py3-none-any.whl

agentcore/operations/agent/generate/schema_mapper.py

@@ -0,0 +1,319 @@
+"""GenerateConfig -> agentcore.json resources / template render config
+(port of src/cli/operations/agent/generate/schema-mapper.ts).
+
+Resources are produced as camelCase JSON dicts, ready for ``ConfigIO.write_project_spec``.
+"""
+
+import dataclasses
+from dataclasses import dataclass
+from typing import Any
+
+from agentcore.lib import APP_DIR, ConfigIO
+from agentcore.lib.schemas.io.config_io import to_jsonable
+from agentcore.operations.agent.generate.types import (
+    DEFAULT_MEMORY_EXPIRY_DAYS,
+    DEFAULT_NETWORK_MODE,
+    DEFAULT_PYTHON_ENTRYPOINT,
+    GenerateConfig,
+)
+from agentcore.primitives.auth_utils import build_authorizer_config_from_jwt_config
+from agentcore.primitives.credential_utils import (
+    compute_default_credential_env_var_name,
+    compute_managed_oauth_credential_name,
+)
+from agentcore.schema import (
+    DEFAULT_ENTRYPOINT_BY_LANGUAGE,
+    DEFAULT_EPISODIC_REFLECTION_NAMESPACE_TEMPLATES,
+    DEFAULT_PYTHON_VERSION,
+    DEFAULT_RUNTIME_BY_LANGUAGE,
+    DEFAULT_STRATEGY_NAMESPACE_TEMPLATES,
+    is_framework_supported_for_protocol,
+)
+from agentcore.templates import (
+    AgentRenderConfig,
+    GatewayProviderRenderConfig,
+    IdentityProviderRenderConfig,
+    MemoryProviderRenderConfig,
+    MountRenderConfig,
+    TemplateRuntimeProfile,
+    get_template_profile,
+)
+
+ACTOR_ID_HEADER = "X-Amzn-Bedrock-AgentCore-Runtime-Custom-Actor-Id"
+
+
+@dataclass
+class GenerateConfigMappingResult:
+    agent: dict[str, Any]
+    memories: list[dict[str, Any]]
+    credentials: list[dict[str, Any]]
+
+
+def compute_default_gateway_env_var_name(gateway_name: str) -> str:
+    """Port of GatewayPrimitive.computeDefaultGatewayEnvVarName (kept local to avoid a cross-area import)."""
+    return f"AGENTCORE_GATEWAY_{gateway_name.upper().replace('-', '_')}_URL"
+
+
+def _compute_credential_name(project_name: str, provider_name: str) -> str:
+    return f"{project_name}{provider_name}"
+
+
+def _strategy(strategy_type: str) -> dict[str, Any]:
+    strategy: dict[str, Any] = {"type": strategy_type}
+    templates = DEFAULT_STRATEGY_NAMESPACE_TEMPLATES.get(strategy_type)  # type: ignore[call-overload]
+    if templates:
+        strategy["namespaceTemplates"] = list(templates)
+    if strategy_type == "EPISODIC":
+        strategy["reflectionNamespaceTemplates"] = list(DEFAULT_EPISODIC_REFLECTION_NAMESPACE_TEMPLATES)
+    return strategy
+
+
+def map_generate_input_to_memories(memory: str, project_name: str) -> list[dict[str, Any]]:
+    """none -> []; shortTerm -> memory without strategies; longAndShortTerm -> four strategies."""
+    if memory == "none":
+        return []
+    strategies: list[dict[str, Any]] = []
+    if memory == "longAndShortTerm":
+        strategies = [_strategy(t) for t in ("SEMANTIC", "USER_PREFERENCE", "SUMMARIZATION", "EPISODIC")]
+    return [
+        {"name": f"{project_name}Memory", "eventExpiryDuration": DEFAULT_MEMORY_EXPIRY_DAYS, "strategies": strategies}
+    ]
+
+
+def map_model_provider_to_credentials(model_provider: str, project_name: str) -> list[dict[str, Any]]:
+    """Bedrock uses IAM, so no credential is needed."""
+    if model_provider == "Bedrock":
+        return []
+    return [
+        {"authorizerType": "ApiKeyCredentialProvider", "name": _compute_credential_name(project_name, model_provider)}
+    ]
+
+
+def _template_runtime(config: GenerateConfig) -> TemplateRuntimeProfile | None:
+    if not is_framework_supported_for_protocol(config.protocol or "HTTP", config.sdk):  # type: ignore[arg-type]
+        return None
+    profile = get_template_profile(config.sdk)
+    return profile.runtime if profile else None
+
+
+def apply_template_runtime_defaults(config: GenerateConfig) -> GenerateConfig:
+    """Apply the framework template's runtime settings; user-supplied values win."""
+    runtime = _template_runtime(config)
+    if runtime is None:
+        return config
+    max_lifetime = (
+        config.max_lifetime
+        if config.max_lifetime is not None
+        else max(runtime.max_lifetime, config.idle_runtime_session_timeout or 0)
+    )
+    profile = get_template_profile(config.sdk)
+    required_build = profile.required_options.get("build") if profile else None
+    return dataclasses.replace(
+        config,
+        build_type=required_build or config.build_type,
+        dockerfile=config.dockerfile or runtime.dockerfile,
+        idle_runtime_session_timeout=(
+            config.idle_runtime_session_timeout
+            if config.idle_runtime_session_timeout is not None
+            else min(runtime.idle_runtime_session_timeout, max_lifetime)
+        ),
+        max_lifetime=max_lifetime,
+    )
+
+
+def _template_runtime_fields(config: GenerateConfig) -> dict[str, Any]:
+    runtime = _template_runtime(config)
+    if runtime is None:
+        return {}
+    fields: dict[str, Any] = {}
+    if runtime.additional_policies:
+        fields["additionalPolicies"] = list(runtime.additional_policies)
+    if runtime.tags:
+        fields["tags"] = dict(runtime.tags)
+    return fields
+
+
+def _filesystem_configurations(config: GenerateConfig) -> dict[str, Any]:
+    from agentcore.cli.commands.shared.filesystem_utils import build_filesystem_configurations
+
+    return build_filesystem_configurations(
+        config.session_storage_mount_path,
+        config.efs_access_points,
+        config.s3_access_points,
+        config.capacity_provider_volumes,
+    )
+
+
+def map_generate_config_to_agent(generate_config: GenerateConfig) -> dict[str, Any]:
+    config = apply_template_runtime_defaults(generate_config)
+    protocol = config.protocol or "HTTP"
+    # A capacity provider supplies its own network topology: no networkMode/networkConfig then.
+    network_mode = None if config.capacity_provider_configuration else (config.network_mode or DEFAULT_NETWORK_MODE)
+
+    needs_actor_header = (
+        config.language == "TypeScript" and config.sdk == "Strands" and config.memory == "longAndShortTerm"
+    )
+    allowlist = list(config.request_header_allowlist or [])
+    if needs_actor_header and ACTOR_ID_HEADER not in allowlist:
+        allowlist.append(ACTOR_ID_HEADER)
+
+    agent: dict[str, Any] = {"name": config.project_name, "build": config.build_type or "CodeZip"}
+    if config.dockerfile:
+        agent["dockerfile"] = config.dockerfile
+    agent["entrypoint"] = (
+        DEFAULT_ENTRYPOINT_BY_LANGUAGE["TypeScript"] if config.language == "TypeScript" else DEFAULT_PYTHON_ENTRYPOINT
+    )
+    agent["codeLocation"] = f"{APP_DIR}/{config.project_name}/"
+    agent["runtimeVersion"] = (
+        DEFAULT_RUNTIME_BY_LANGUAGE["TypeScript"] if config.language == "TypeScript" else DEFAULT_PYTHON_VERSION
+    )
+    if network_mode is not None:
+        agent["networkMode"] = network_mode
+    agent["protocol"] = protocol
+    if network_mode == "VPC" and config.subnets and config.security_groups:
+        network_config: dict[str, Any] = {"subnets": config.subnets, "securityGroups": config.security_groups}
+        # Only a Container build carries a vpcId.
+        if config.build_type == "Container" and config.vpc_id:
+            network_config["vpcId"] = config.vpc_id
+        agent["networkConfig"] = network_config
+    if allowlist:
+        agent["requestHeaderAllowlist"] = allowlist
+    if config.authorizer_type:
+        agent["authorizerType"] = config.authorizer_type
+    if config.authorizer_type == "CUSTOM_JWT" and config.jwt_config:
+        agent["authorizerConfiguration"] = build_authorizer_config_from_jwt_config(config.jwt_config)
+    if config.idle_runtime_session_timeout is not None or config.max_lifetime is not None:
+        lifecycle: dict[str, Any] = {}
+        if config.idle_runtime_session_timeout is not None:
+            lifecycle["idleRuntimeSessionTimeout"] = config.idle_runtime_session_timeout
+        if config.max_lifetime is not None:
+            lifecycle["maxLifetime"] = config.max_lifetime
+        agent["lifecycleConfiguration"] = lifecycle
+    if config.capacity_provider_configuration:
+        agent["capacityProviderConfiguration"] = dict(config.capacity_provider_configuration)
+    agent.update(_filesystem_configurations(config))
+    if protocol == "MCP":
+        agent["instrumentation"] = {"enableOtel": False}
+    agent.update(_template_runtime_fields(config))
+    return agent
+
+
+def map_generate_config_to_resources(config: GenerateConfig) -> GenerateConfigMappingResult:
+    return GenerateConfigMappingResult(
+        agent=map_generate_config_to_agent(config),
+        memories=map_generate_input_to_memories(config.memory, config.project_name),
+        credentials=map_model_provider_to_credentials(config.model_provider, config.project_name),
+    )
+
+
+def _compute_memory_env_var_name(memory_name: str) -> str:
+    return f"MEMORY_{memory_name.upper()}_ID"
+
+
+def _map_memory_option_to_memory_providers(memory: str, project_name: str) -> list[MemoryProviderRenderConfig]:
+    if memory == "none":
+        return []
+    memory_name = f"{project_name}Memory"
+    memories = map_generate_input_to_memories(memory, project_name)
+    strategies = [s["type"] for s in memories[0]["strategies"]] if memories else []
+    return [
+        MemoryProviderRenderConfig(
+            name=memory_name, env_var_name=_compute_memory_env_var_name(memory_name), strategies=strategies
+        )
+    ]
+
+
+def map_model_provider_to_identity_providers(
+    model_provider: str, project_name: str
+) -> list[IdentityProviderRenderConfig]:
+    if model_provider == "Bedrock":
+        return []
+    credential_name = _compute_credential_name(project_name, model_provider)
+    return [
+        IdentityProviderRenderConfig(
+            name=credential_name, env_var_name=compute_default_credential_env_var_name(credential_name)
+        )
+    ]
+
+
+def _read_project(config_base_dir: str | None) -> dict[str, Any] | None:
+    try:
+        io = ConfigIO(base_dir=config_base_dir) if config_base_dir else ConfigIO()
+        return to_jsonable(io.read_project_spec())
+    except Exception:  # noqa: BLE001 - upstream treats an unreadable project as "no gateways/payments"
+        return None
+
+
+def _map_gateways_to_gateway_providers(project: dict[str, Any] | None) -> list[GatewayProviderRenderConfig]:
+    if not project:
+        return []
+    providers: list[GatewayProviderRenderConfig] = []
+    for gateway in project.get("agentCoreGateways", []):
+        provider = GatewayProviderRenderConfig(
+            name=gateway["name"],
+            env_var_name=compute_default_gateway_env_var_name(gateway["name"]),
+            auth_type=gateway.get("authorizerType"),
+        )
+        jwt = (gateway.get("authorizerConfiguration") or {}).get("customJwtAuthorizer")
+        if gateway.get("authorizerType") == "CUSTOM_JWT" and jwt:
+            cred_name = compute_managed_oauth_credential_name(gateway["name"])
+            if any(c["name"] == cred_name for c in project.get("credentials", [])):
+                provider.credential_provider_name = cred_name
+                provider.discovery_url = jwt.get("discoveryUrl")
+                scopes = jwt.get("allowedScopes")
+                if scopes:
+                    provider.scopes = " ".join(scopes)
+        providers.append(provider)
+    return providers
+
+
+def map_generate_config_to_render_config(
+    generate_config: GenerateConfig,
+    identity_providers: list[IdentityProviderRenderConfig],
+    config_base_dir: str | None = None,
+) -> AgentRenderConfig:
+    """Map to the template render config. ``config_base_dir`` replaces upstream's cwd-based project lookup."""
+    config = apply_template_runtime_defaults(generate_config)
+    is_mcp = config.protocol == "MCP"
+    project = _read_project(config_base_dir)
+    gateway_providers = [] if is_mcp else _map_gateways_to_gateway_providers(project)
+    ts_non_strands = config.language == "TypeScript" and config.sdk != "Strands"
+
+    if is_mcp or ts_non_strands:
+        has_memory = False
+    elif config.language == "TypeScript":
+        has_memory = config.memory == "longAndShortTerm"
+    else:
+        has_memory = config.memory != "none"
+
+    auth_types: list[str] = []
+    for g in gateway_providers:
+        if g.auth_type not in auth_types:
+            auth_types.append(g.auth_type)
+
+    return AgentRenderConfig(
+        name=config.project_name,
+        sdk_framework=config.sdk,  # type: ignore[arg-type]
+        target_language=config.language,  # type: ignore[arg-type]
+        model_provider=config.model_provider,  # type: ignore[arg-type]
+        has_memory=has_memory,
+        has_identity=False if is_mcp else len(identity_providers) > 0,
+        has_gateway=len(gateway_providers) > 0,
+        has_payment=bool(project and project.get("payments")),
+        is_vpc=config.network_mode == "VPC",
+        build_type=config.build_type,  # type: ignore[arg-type]
+        memory_providers=[]
+        if (is_mcp or ts_non_strands)
+        else _map_memory_option_to_memory_providers(config.memory, config.project_name),
+        identity_providers=[] if is_mcp else identity_providers,
+        gateway_providers=gateway_providers,
+        gateway_auth_types=auth_types,
+        protocol=config.protocol,  # type: ignore[arg-type]
+        dockerfile=config.dockerfile,
+        session_storage_mount_path=config.session_storage_mount_path,
+        efs_mounts=[MountRenderConfig(mount_path=ap["mountPath"]) for ap in (config.efs_access_points or [])],
+        s3_mounts=[MountRenderConfig(mount_path=ap["mountPath"]) for ap in (config.s3_access_points or [])],
+        needs_os=bool(config.session_storage_mount_path or config.efs_access_points or config.s3_access_points),
+        enable_otel=not is_mcp and config.language != "TypeScript",
+        has_config_bundle=config.with_config_bundle,
+    )

agentcore/operations/agent/generate/types.py

@@ -0,0 +1,172 @@
+"""Generate-wizard config types and option lists (port of src/cli/tui/screens/generate/types.ts
+and defaults.ts). Shared by `create`, `add agent` and the interactive wizard.
+
+Mount/capacity-provider entries are camelCase JSON dicts, as they go straight into agentcore.json.
+"""
+
+from dataclasses import dataclass
+from typing import Any, Final, Literal
+
+from agentcore.primitives.auth_utils import JwtConfigOptions
+from agentcore.schema import (
+    DEFAULT_MODEL_IDS,
+    DEFAULT_PYTHON_VERSION,
+    PROTOCOL_FRAMEWORK_MATRIX,
+    get_frameworks_for_language,
+    get_supported_model_providers,
+)
+from agentcore.schema._zod import js_regex
+
+MemoryOption = Literal["none", "shortTerm", "longAndShortTerm"]
+
+# defaults.ts
+DEFAULT_NETWORK_MODE: Final = "PUBLIC"
+DEFAULT_PYTHON_ENTRYPOINT: Final = "main.py"
+DEFAULT_MEMORY_EXPIRY_DAYS: Final = 30
+
+
+@dataclass
+class GenerateConfig:
+    # Note: upstream calls this `projectName`, but it is the agent name.
+    project_name: str
+    build_type: str = "CodeZip"
+    protocol: str = "HTTP"
+    sdk: str = "Strands"
+    model_provider: str = "Bedrock"
+    memory: str = "none"
+    language: str = "Python"
+    dockerfile: str | None = None
+    api_key: str | None = None
+    network_mode: str | None = None
+    subnets: list[str] | None = None
+    security_groups: list[str] | None = None
+    vpc_id: str | None = None
+    request_header_allowlist: list[str] | None = None
+    authorizer_type: str | None = None
+    jwt_config: JwtConfigOptions | None = None
+    idle_runtime_session_timeout: int | None = None
+    max_lifetime: int | None = None
+    session_storage_mount_path: str | None = None
+    efs_access_points: list[dict[str, Any]] | None = None
+    s3_access_points: list[dict[str, Any]] | None = None
+    capacity_provider_configuration: dict[str, Any] | None = None
+    capacity_provider_volumes: list[dict[str, Any]] | None = None
+    with_config_bundle: bool | None = None
+
+
+@dataclass(frozen=True)
+class Option:
+    id: str
+    title: str
+    description: str | None = None
+
+
+LANGUAGE_OPTIONS: Final = (Option("Python", "Python"), Option("TypeScript", "TypeScript"))
+
+BUILD_TYPE_OPTIONS: Final = (
+    Option("CodeZip", "Direct Code Deploy", "Upload code directly to AgentCore"),
+    Option("Container", "Container", "Build and deploy a Docker container"),
+)
+
+PROTOCOL_OPTIONS: Final = (
+    Option("HTTP", "HTTP", "Standard HTTP agent (default)"),
+    Option("MCP", "MCP", "Model Context Protocol tool server"),
+    Option("A2A", "A2A", "Agent-to-Agent protocol"),
+    Option("AGUI", "AG-UI", "Stream rich agent events to frontends"),
+)
+
+
+def get_protocol_options_for_language(language: str | None = None) -> list[Option]:
+    """TypeScript only supports HTTP."""
+    if language == "TypeScript":
+        return [o for o in PROTOCOL_OPTIONS if o.id == "HTTP"]
+    return list(PROTOCOL_OPTIONS)
+
+
+SDK_OPTIONS: Final = (
+    Option("Strands", "Strands Agents SDK", "AWS native agent framework"),
+    Option("LangChain_LangGraph", "LangChain + LangGraph", "Popular open-source frameworks"),
+    Option("GoogleADK", "Google ADK", "Google Agent Development Kit"),
+    Option("OpenAIAgents", "OpenAI Agents", "OpenAI native agent SDK"),
+    Option("VercelAI", "Vercel AI SDK", "Vercel AI SDK for TypeScript agents"),
+    Option("BedrockManagedAgents", "Bedrock Managed Agents", "Runtime environment for Bedrock Managed Agents sessions"),
+)
+
+
+def get_sdk_options_for_protocol(protocol: str, language: str | None = None) -> list[Option]:
+    supported = PROTOCOL_FRAMEWORK_MATRIX[protocol]  # type: ignore[index]
+    options = [o for o in SDK_OPTIONS if o.id in supported]
+    if language in ("Python", "TypeScript"):
+        by_language = get_frameworks_for_language(language)  # type: ignore[arg-type]
+        options = [o for o in options if o.id in by_language]
+    return options
+
+
+MODEL_PROVIDER_OPTIONS: Final = (
+    Option("Bedrock", f"Amazon Bedrock ({DEFAULT_MODEL_IDS['Bedrock']})", "AWS managed model inference"),
+    Option("Anthropic", f"Anthropic ({DEFAULT_MODEL_IDS['Anthropic']})", "Claude models via Anthropic API"),
+    Option("OpenAI", f"OpenAI ({DEFAULT_MODEL_IDS['OpenAI']})", "GPT models via OpenAI API"),
+    Option("Gemini", f"Google Gemini ({DEFAULT_MODEL_IDS['Gemini']})", "Gemini models via Google API"),
+)
+
+
+def get_model_provider_options_for_sdk(sdk: str) -> list[Option]:
+    supported = get_supported_model_providers(sdk)  # type: ignore[arg-type]
+    return [o for o in MODEL_PROVIDER_OPTIONS if o.id in supported]
+
+
+NETWORK_MODE_OPTIONS: Final = (Option("PUBLIC", "Public"), Option("VPC", "VPC", "Attach to your VPC"))
+
+ADVANCED_SETTING_OPTIONS: Final = (
+    Option("dockerfile", "Custom Dockerfile", "Specify a custom Dockerfile path"),
+    Option("network", "VPC networking", "Attach to your VPC with subnets & security groups"),
+    Option("headers", "Request header allowlist", "Allow custom headers through to your agent"),
+    Option("auth", "Custom auth (JWT)", "OIDC-based token validation for inbound requests"),
+    Option("lifecycle", "Lifecycle timeouts", "Idle timeout & max instance lifetime"),
+    Option("filesystem", "Filesystem mounts", "Session storage, EFS, and S3 Files mounts"),
+    Option("capacityProvider", "Capacity provider", "Run on a customer-managed EC2 compute pool (+ mount its volumes)"),
+    Option("configBundle", "Config bundle", "Manage system prompt and tool config without redeploying"),
+)
+
+MEMORY_OPTIONS: Final = (
+    Option("none", "None", "No memory"),
+    Option("shortTerm", "Short-term memory", "Context within a session"),
+    Option("longAndShortTerm", "Long-term and short-term", "Persists across sessions"),
+)
+
+_DOCKERFILE_NAME_REGEX = js_regex(r"^[a-zA-Z0-9][a-zA-Z0-9._-]*$")
+
+
+def validate_dockerfile_input(value: str) -> bool | str:
+    """True if valid, else an error message. Path inputs (containing '/') are not checked here."""
+    trimmed = value.strip()
+    if not trimmed or "/" in trimmed:
+        return True
+    if len(trimmed) > 255:
+        return "Dockerfile name must be 255 characters or fewer"
+    if not _DOCKERFILE_NAME_REGEX.search(trimmed):
+        return "Must be a valid filename (starts with alphanumeric)"
+    return True
+
+
+__all__ = [
+    "ADVANCED_SETTING_OPTIONS",
+    "BUILD_TYPE_OPTIONS",
+    "DEFAULT_MEMORY_EXPIRY_DAYS",
+    "DEFAULT_NETWORK_MODE",
+    "DEFAULT_PYTHON_ENTRYPOINT",
+    "DEFAULT_PYTHON_VERSION",
+    "LANGUAGE_OPTIONS",
+    "MEMORY_OPTIONS",
+    "MODEL_PROVIDER_OPTIONS",
+    "NETWORK_MODE_OPTIONS",
+    "PROTOCOL_OPTIONS",
+    "SDK_OPTIONS",
+    "GenerateConfig",
+    "MemoryOption",
+    "Option",
+    "get_model_provider_options_for_sdk",
+    "get_protocol_options_for_language",
+    "get_sdk_options_for_protocol",
+    "validate_dockerfile_input",
+]

agentcore/operations/agent/generate/write_agent_to_project.py

@@ -0,0 +1,67 @@
+"""Write a generated agent into agentcore.json (port of write-agent-to-project.ts)."""
+
+from typing import Any
+
+from agentcore.cli.constants import SCHEMA_VERSION
+from agentcore.lib import AgentAlreadyExistsError, ConfigIO, require_config_root
+from agentcore.lib.schemas.io.config_io import to_jsonable
+from agentcore.operations.agent.generate.schema_mapper import (
+    map_generate_config_to_agent,
+    map_generate_input_to_memories,
+    map_model_provider_to_credentials,
+)
+from agentcore.operations.agent.generate.types import GenerateConfig
+
+
+def write_agent_to_project(
+    config: GenerateConfig, *, config_base_dir: str | None = None, credential_strategy: Any = None
+) -> None:
+    """Add the agent to runtimes[], its memory to memories[] and (unless reused) its credential.
+
+    ``credential_strategy`` is a ``CredentialStrategy`` (see primitives/credential.py).
+    """
+    base_dir = config_base_dir or require_config_root()
+    config_io = ConfigIO(base_dir=base_dir)
+    agent_name = config.project_name
+    agent = map_generate_config_to_agent(config)
+    memories = map_generate_input_to_memories(config.memory, agent_name)
+
+    if config_io.config_exists("project"):
+        project = to_jsonable(config_io.read_project_spec())
+        if any(r["name"] == agent_name for r in project["runtimes"]):
+            raise AgentAlreadyExistsError(agent_name)
+        project["runtimes"].append(agent)
+        project["memories"].extend(memories)
+        if credential_strategy is not None:
+            if not credential_strategy.reuse:
+                credentials = map_model_provider_to_credentials(config.model_provider, project["name"])
+                if credentials:
+                    credentials[0]["name"] = credential_strategy.credential_name
+                    project["credentials"].extend(credentials)
+        else:
+            project["credentials"].extend(map_model_provider_to_credentials(config.model_provider, project["name"]))
+        config_io.write_project_spec(project)
+        return
+
+    # Standalone generate: the agent name doubles as the project name.
+    config_io.write_project_spec(
+        {
+            "name": agent_name,
+            "version": SCHEMA_VERSION,
+            "managedBy": "CDK",
+            "runtimes": [agent],
+            "memories": memories,
+            "knowledgeBases": [],
+            "credentials": map_model_provider_to_credentials(config.model_provider, agent_name),
+            "evaluators": [],
+            "onlineEvalConfigs": [],
+            "agentCoreGateways": [],
+            "policyEngines": [],
+            "configBundles": [],
+            "abTests": [],
+            "harnesses": [],
+            "datasets": [],
+            "payments": [],
+            "capacityProviders": [],
+        }
+    )

agentcore/operations/agent/import_/__init__.py

@@ -0,0 +1,31 @@
+"""Bedrock Agent import (port of src/cli/operations/agent/import/)."""
+
+from agentcore.operations.agent.import_.base_translator import (
+    BaseBedrockTranslator,
+    CollaboratorContext,
+    ImportedFeatures,
+    TranslationResult,
+    TranslatorOptions,
+    sanitize_py_identifier,
+)
+from agentcore.operations.agent.import_.constants import BEDROCK_REGIONS, IMPORT_FRAMEWORK_OPTIONS
+from agentcore.operations.agent.import_.execute import ExecuteImportAgentParams, execute_import_agent
+from agentcore.operations.agent.import_.langgraph_translator import LangGraphTranslator
+from agentcore.operations.agent.import_.pyproject_generator import generate_pyproject_toml
+from agentcore.operations.agent.import_.strands_translator import StrandsTranslator
+
+__all__ = [
+    "BEDROCK_REGIONS",
+    "IMPORT_FRAMEWORK_OPTIONS",
+    "BaseBedrockTranslator",
+    "CollaboratorContext",
+    "ExecuteImportAgentParams",
+    "ImportedFeatures",
+    "LangGraphTranslator",
+    "StrandsTranslator",
+    "TranslationResult",
+    "TranslatorOptions",
+    "execute_import_agent",
+    "generate_pyproject_toml",
+    "sanitize_py_identifier",
+]