agentcore-cli 0.31.1__py3-none-any.whl

agentcore/schema/schemas/primitives/knowledge_base.py

@@ -0,0 +1,90 @@
+"""Knowledge bases (port of ``primitives/knowledge-base.ts``)."""
+
+from __future__ import annotations
+
+from typing import Annotated, Final, Literal, get_args
+
+from pydantic import Field
+
+from ..._zod import StrictModel, array_checks, js_regex, unique_by, zstr
+
+# 1-48 chars, starts with a letter, alphanumeric + dash + underscore.
+KnowledgeBaseName = zstr(
+    min=1,
+    max=48,
+    min_msg="Name is required",
+    pattern=r"^[a-zA-Z][a-zA-Z0-9_-]{0,47}$",
+    pattern_msg=(
+        "Must begin with a letter and contain only alphanumeric characters, dashes, and underscores (max 48 chars)"
+    ),
+)
+
+# AWS S3 bucket naming rules: 3-63 chars, lowercase/digit/dot/hyphen, start+end alnum, no '..',
+# no reserved `xn--` / `sthree-` prefixes or `-s3alias` suffix.
+_S3_BUCKET_NAME = js_regex(r"^(?!xn--)(?!sthree-)[a-z0-9](?!.*\.\.)[a-z0-9.-]{1,61}[a-z0-9](?<!-s3alias)$")
+_S3_URI = js_regex(r"^s3:\/\/([^/]+)(?:\/.*)?$")
+
+
+def _is_valid_s3_uri(value: str) -> bool:
+    m = _S3_URI.search(value)
+    return bool(m) and _S3_BUCKET_NAME.search(m.group(1)) is not None
+
+
+class S3DataSource(StrictModel):
+    """S3 data source; ``uri`` must be ``s3://bucket[/prefix]`` with an AWS-compliant bucket name."""
+
+    type: Literal["S3"]
+    uri: zstr(
+        min=1,
+        refines=((_is_valid_s3_uri, "Must be a valid s3:// URI with an AWS-compliant bucket name"),),
+    )
+
+
+# Wire-verbatim `connectorParameters.type` literals of the Bedrock managed-connector API.
+ConnectorDataSourceType = Literal["WEB", "CONFLUENCE", "SHAREPOINT", "ONEDRIVE", "GOOGLEDRIVE"]
+CONNECTOR_DATA_SOURCE_TYPES: Final[tuple[ConnectorDataSourceType, ...]] = get_args(ConnectorDataSourceType)
+
+
+class ConnectorFileDataSource(StrictModel):
+    """Non-S3 data source whose connector parameters live in a project-relative JSON file."""
+
+    type: ConnectorDataSourceType
+    connector_config_file: zstr(min=1, min_msg="connectorConfigFile path is required")
+
+
+DataSource = Annotated[S3DataSource | ConnectorFileDataSource, Field(discriminator="type")]
+
+KnowledgeBaseType = Literal["AgentCoreKnowledgeBase"]
+
+
+def _data_source_key(ds: S3DataSource | ConnectorFileDataSource) -> str:
+    return ds.uri if isinstance(ds, S3DataSource) else ds.connector_config_file
+
+
+class KnowledgeBase(StrictModel):
+    """A knowledge base the CLI creates and owns, with its data sources and IAM role."""
+
+    type: KnowledgeBaseType = "AgentCoreKnowledgeBase"
+    name: KnowledgeBaseName
+    description: zstr(max=2048) | None = None
+    data_sources: Annotated[
+        list[DataSource],
+        array_checks(
+            min=1,
+            min_msg="At least one data source is required",
+            extra=[unique_by(_data_source_key, lambda k: f"Duplicate data source: {k}")],
+        ),
+    ]
+    gateway: zstr(min=1) | None = None
+
+
+__all__ = [
+    "CONNECTOR_DATA_SOURCE_TYPES",
+    "ConnectorDataSourceType",
+    "ConnectorFileDataSource",
+    "DataSource",
+    "KnowledgeBase",
+    "KnowledgeBaseName",
+    "KnowledgeBaseType",
+    "S3DataSource",
+]

agentcore/schema/schemas/primitives/memory.py

@@ -0,0 +1,113 @@
+"""Memory strategies (port of ``primitives/memory.ts``)."""
+
+from __future__ import annotations
+
+from typing import Final, Literal, get_args
+
+from pydantic import model_validator
+
+from ..._zod import Issue, ZodModel, raise_issues, zstr
+
+# Maps to AWS MemoryStrategy types (SUMMARIZATION -> SummaryMemoryStrategy in CloudFormation).
+MemoryStrategyType = Literal["SEMANTIC", "SUMMARIZATION", "USER_PREFERENCE", "EPISODIC"]
+MEMORY_STRATEGY_TYPES: Final[tuple[MemoryStrategyType, ...]] = get_args(MemoryStrategyType)
+
+# Default namespace templates per strategy type (match the CLI session.py templates).
+DEFAULT_STRATEGY_NAMESPACE_TEMPLATES: Final[dict[MemoryStrategyType, list[str]]] = {
+    "SEMANTIC": ["/users/{actorId}/facts"],
+    "USER_PREFERENCE": ["/users/{actorId}/preferences"],
+    "SUMMARIZATION": ["/summaries/{actorId}/{sessionId}"],
+    "EPISODIC": ["/episodes/{actorId}/{sessionId}"],
+}
+
+# Deprecated: use DEFAULT_STRATEGY_NAMESPACE_TEMPLATES.
+DEFAULT_STRATEGY_NAMESPACES: Final = DEFAULT_STRATEGY_NAMESPACE_TEMPLATES
+
+# Reflection templates must be the same as or a prefix of episode templates.
+DEFAULT_EPISODIC_REFLECTION_NAMESPACE_TEMPLATES: Final[list[str]] = ["/episodes/{actorId}"]
+
+# Deprecated: use DEFAULT_EPISODIC_REFLECTION_NAMESPACE_TEMPLATES.
+DEFAULT_EPISODIC_REFLECTION_NAMESPACES: Final = DEFAULT_EPISODIC_REFLECTION_NAMESPACE_TEMPLATES
+
+MemoryStrategyName = zstr(
+    min=1,
+    max=48,
+    pattern=r"^[a-zA-Z][a-zA-Z0-9_]{0,47}$",
+    pattern_msg="Must begin with a letter and contain only alphanumeric characters and underscores (max 48 chars)",
+)
+
+
+class MemoryStrategy(ZodModel):
+    """A memory strategy with optional namespace scoping.
+
+    ``namespaces`` / ``reflectionNamespaces`` are deprecated aliases of the ``*Templates`` fields;
+    specifying both forms for the same concept is rejected.
+    """
+
+    type: MemoryStrategyType
+    name: MemoryStrategyName | None = None
+    description: str | None = None
+    namespace_templates: list[str] | None = None
+    namespaces: list[str] | None = None
+    reflection_namespace_templates: list[str] | None = None
+    reflection_namespaces: list[str] | None = None
+
+    @model_validator(mode="after")
+    def _refine(self) -> MemoryStrategy:
+        issues: list[Issue] = []
+        path = ("reflectionNamespaceTemplates",)
+        if self.namespaces and self.namespace_templates:
+            issues.append(
+                (
+                    ("namespaceTemplates",),
+                    (
+                        "'namespaces' and 'namespaceTemplates' are mutually exclusive. "
+                        "Prefer 'namespaceTemplates' ('namespaces' is deprecated)."
+                    ),
+                )
+            )
+        if self.reflection_namespaces and self.reflection_namespace_templates:
+            issues.append(
+                (
+                    path,
+                    (
+                        "'reflectionNamespaces' and 'reflectionNamespaceTemplates' are mutually exclusive. "
+                        "Prefer 'reflectionNamespaceTemplates' ('reflectionNamespaces' is deprecated)."
+                    ),
+                )
+            )
+        if self.type != "EPISODIC" and (
+            self.reflection_namespace_templates is not None or self.reflection_namespaces is not None
+        ):
+            issues.append((path, "'reflectionNamespaceTemplates' is only allowed on EPISODIC strategies"))
+        if self.type == "EPISODIC":
+            reflection = (
+                self.reflection_namespace_templates
+                if self.reflection_namespace_templates is not None
+                else self.reflection_namespaces
+            )
+            if not reflection:
+                issues.append((path, "EPISODIC strategy requires reflectionNamespaceTemplates"))
+            templates = self.namespace_templates if self.namespace_templates is not None else self.namespaces
+            if (
+                reflection is not None
+                and templates is not None
+                and not all(any(ns.startswith(ref) for ns in templates) for ref in reflection)
+            ):
+                issues.append(
+                    (path, "Each reflectionNamespaceTemplate must be a prefix of at least one namespaceTemplate")
+                )
+        raise_issues(issues, self)
+        return self
+
+
+__all__ = [
+    "DEFAULT_EPISODIC_REFLECTION_NAMESPACES",
+    "DEFAULT_EPISODIC_REFLECTION_NAMESPACE_TEMPLATES",
+    "DEFAULT_STRATEGY_NAMESPACES",
+    "DEFAULT_STRATEGY_NAMESPACE_TEMPLATES",
+    "MEMORY_STRATEGY_TYPES",
+    "MemoryStrategy",
+    "MemoryStrategyName",
+    "MemoryStrategyType",
+]

agentcore/schema/schemas/primitives/online_eval_config.py

@@ -0,0 +1,77 @@
+"""Online evaluation configs (port of ``primitives/online-eval-config.ts``)."""
+
+from __future__ import annotations
+
+from typing import Annotated, Literal
+
+from pydantic import model_validator
+
+from ..._zod import Issue, ZBool, ZodModel, array_checks, raise_issues, znum, zstr
+from .tags import Tags
+
+OnlineEvalConfigName = zstr(
+    min=1,
+    max=48,
+    min_msg="Name is required",
+    pattern=r"^[a-zA-Z][a-zA-Z0-9_]{0,47}$",
+    pattern_msg="Must begin with a letter and contain only alphanumeric characters and underscores (max 48 chars)",
+)
+
+ClusteringFrequency = Literal["DAILY", "WEEKLY", "MONTHLY"]
+
+
+class ClusteringConfig(ZodModel):
+    frequencies: Annotated[list[ClusteringFrequency], array_checks(min=1, max=3)]
+
+
+class OnlineEvalConfig(ZodModel):
+    name: OnlineEvalConfigName
+    # Agent name to monitor (must match a project agent). Required for managed AgentCore agents.
+    agent: zstr(min=1, min_msg="Agent name is required") | None = None
+    # Optional runtime endpoint name to scope monitoring to a specific endpoint.
+    endpoint: zstr(min=1) | None = None
+    # CloudWatch log group names for custom/3rd-party agents (1-5 entries).
+    log_group_names: Annotated[list[zstr(min=1)], array_checks(min=1, max=5)] | None = None
+    # Service names to filter traces for custom/3rd-party agents.
+    service_names: Annotated[list[zstr(min=1)], array_checks(min=1)] | None = None
+    # Evaluator names (custom), Builtin.* IDs, or evaluator ARNs.
+    evaluators: list[zstr(min=1)] | None = None
+    insights: list[zstr(min=1)] | None = None
+    clustering_config: ClusteringConfig | None = None
+    # Sampling rate as a percentage (0.01 to 100).
+    sampling_rate: znum(ge=0.01, le=100)
+    description: zstr(max=200) | None = None
+    enable_on_create: ZBool | None = None
+    tags: Tags | None = None
+
+    @model_validator(mode="after")
+    def _refine(self) -> OnlineEvalConfig:
+        issues: list[Issue] = []
+        has_agent = self.agent is not None
+        has_log_groups = self.log_group_names is not None
+        has_evaluators = bool(self.evaluators)
+        has_insights = bool(self.insights)
+        if not (has_agent or has_log_groups):
+            issues.append(((), 'Either "agent" or "logGroupNames" must be provided'))
+        if has_agent and has_log_groups:
+            issues.append(((), '"agent" and "logGroupNames" are mutually exclusive'))
+        if self.endpoint is not None and not has_agent:
+            issues.append(((), '"endpoint" requires "agent"'))
+        if self.service_names is not None and not has_log_groups:
+            issues.append(((), '"serviceNames" requires "logGroupNames"'))
+        if not (has_evaluators or has_insights):
+            issues.append(((), "At least one of evaluators or insights must be provided"))
+        if has_evaluators and has_insights:
+            issues.append(((), "Cannot have both evaluators and insights (preview constraint)"))
+        if self.clustering_config is not None and not has_insights:
+            issues.append(((), "clusteringConfig requires insights to be set"))
+        raise_issues(issues, self)
+        return self
+
+
+__all__ = [
+    "ClusteringConfig",
+    "ClusteringFrequency",
+    "OnlineEvalConfig",
+    "OnlineEvalConfigName",
+]

agentcore/schema/schemas/primitives/payment.py

@@ -0,0 +1,114 @@
+"""Payment managers and connectors (port of ``primitives/payment.ts``)."""
+
+from __future__ import annotations
+
+from typing import Annotated, Final, Literal, get_args
+
+from pydantic import Field, model_validator
+
+from ..._zod import ZBool, ZodModel, raise_issues, zstr
+
+PaymentProvider = Literal["CoinbaseCDP", "StripePrivy"]
+PAYMENT_PROVIDERS: Final[tuple[PaymentProvider, ...]] = get_args(PaymentProvider)
+
+# Documented payment-manager defaults, materialized on write so they appear in agentcore.json.
+DEFAULT_AUTO_PAYMENT: Final = True
+DEFAULT_SPEND_LIMIT: Final = "10.00"
+
+# The CreatePaymentManager API name pattern allows no underscores (unlike connectors).
+PaymentManagerName = zstr(
+    min=1,
+    max=48,
+    min_msg="Payment manager name is required",
+    pattern=r"^[a-zA-Z][a-zA-Z0-9]{0,47}$",
+    pattern_msg="Must begin with a letter and contain only alphanumeric characters (max 48 chars)",
+)
+
+PaymentConnectorName = zstr(
+    min=1,
+    max=48,
+    min_msg="Payment connector name is required",
+    pattern=r"^[a-zA-Z][a-zA-Z0-9_]{0,47}$",
+    pattern_msg="Must begin with a letter and contain only alphanumeric characters and underscores (max 48 chars)",
+)
+
+PaymentProvisionMode = Literal["MANUAL", "QUICK_CREATE"]
+PAYMENT_PROVISION_MODES: Final[tuple[PaymentProvisionMode, ...]] = get_args(PaymentProvisionMode)
+
+
+class ManualPaymentConnector(ZodModel):
+    name: PaymentConnectorName
+    provider: PaymentProvider = "CoinbaseCDP"
+    provision_mode: Literal["MANUAL"] | None = None
+    credential_name: zstr(min=1)
+
+
+class QuickCreatePaymentConnector(ZodModel):
+    name: PaymentConnectorName
+    provider: Literal["CoinbaseCDP"]
+    provision_mode: Literal["QUICK_CREATE"]
+    # z.never().optional(): must be absent.
+    credential_name: None = None
+
+
+PaymentConnector = Annotated[QuickCreatePaymentConnector | ManualPaymentConnector, Field(union_mode="left_to_right")]
+
+PaymentAuthorizerType = Literal["AWS_IAM", "CUSTOM_JWT"]
+PAYMENT_AUTHORIZER_TYPES: Final[tuple[PaymentAuthorizerType, ...]] = get_args(PaymentAuthorizerType)
+
+
+class PaymentCustomJwtAuthorizer(ZodModel):
+    discovery_url: zstr(url=True)
+    allowed_clients: list[str] | None = None
+    allowed_audience: list[str] | None = None
+    allowed_scopes: list[str] | None = None
+
+
+class PaymentAuthorizerConfiguration(ZodModel):
+    custom_jwt_authorizer: Annotated[PaymentCustomJwtAuthorizer, Field(alias="customJWTAuthorizer")]
+
+
+class PaymentManager(ZodModel):
+    name: PaymentManagerName
+    authorizer_type: PaymentAuthorizerType = "AWS_IAM"
+    authorizer_configuration: PaymentAuthorizerConfiguration | None = None
+    connectors: list[PaymentConnector] = Field(default_factory=list)
+    description: str | None = None
+    auto_payment: ZBool = DEFAULT_AUTO_PAYMENT
+    default_spend_limit: str = DEFAULT_SPEND_LIMIT
+    payment_tool_allowlist: list[str] | None = None
+    network_preferences: list[str] | None = None
+
+    @model_validator(mode="after")
+    def _refine(self) -> PaymentManager:
+        if self.authorizer_type == "CUSTOM_JWT" and self.authorizer_configuration is None:
+            raise_issues(
+                [
+                    (
+                        ("authorizerConfiguration",),
+                        "authorizerConfiguration with customJWTAuthorizer is required when authorizerType is CUSTOM_JWT",
+                    )
+                ],
+                self,
+            )
+        return self
+
+
+__all__ = [
+    "DEFAULT_AUTO_PAYMENT",
+    "DEFAULT_SPEND_LIMIT",
+    "PAYMENT_AUTHORIZER_TYPES",
+    "PAYMENT_PROVIDERS",
+    "PAYMENT_PROVISION_MODES",
+    "ManualPaymentConnector",
+    "PaymentAuthorizerConfiguration",
+    "PaymentAuthorizerType",
+    "PaymentConnector",
+    "PaymentConnectorName",
+    "PaymentCustomJwtAuthorizer",
+    "PaymentManager",
+    "PaymentManagerName",
+    "PaymentProvider",
+    "PaymentProvisionMode",
+    "QuickCreatePaymentConnector",
+]

agentcore/schema/schemas/primitives/policy.py

@@ -0,0 +1,83 @@
+"""Policy engines and Cedar policies (port of ``primitives/policy.ts``)."""
+
+from __future__ import annotations
+
+from typing import Annotated, Final, Literal, get_args
+
+from pydantic import Field
+
+from ..._zod import ZodModel, array_checks, unique_by, zstr
+from .tags import Tags
+
+_NAME_PATTERN = r"^[A-Za-z][A-Za-z0-9_]{0,47}$"
+_NAME_PATTERN_MSG = "Must begin with a letter and contain only alphanumeric characters and underscores (max 48 chars)"
+
+PolicyEngineName = zstr(
+    min=1,
+    max=48,
+    min_msg="Policy engine name is required",
+    max_msg="Policy engine name must be 48 characters or less",
+    pattern=_NAME_PATTERN,
+    pattern_msg=_NAME_PATTERN_MSG,
+)
+
+PolicyName = zstr(
+    min=1,
+    max=48,
+    min_msg="Policy name is required",
+    max_msg="Policy name must be 48 characters or less",
+    pattern=_NAME_PATTERN,
+    pattern_msg=_NAME_PATTERN_MSG,
+)
+
+ValidationMode = Literal["FAIL_ON_ANY_FINDINGS", "IGNORE_ALL_FINDINGS"]
+VALIDATION_MODES: Final[tuple[ValidationMode, ...]] = get_args(ValidationMode)
+
+AuthorizationPhase = Literal["INITIATE", "RETURN_OUTPUT"]
+AUTHORIZATION_PHASES: Final[tuple[AuthorizationPhase, ...]] = get_args(AuthorizationPhase)
+DEFAULT_AUTHORIZATION_PHASE: Final[AuthorizationPhase] = "INITIATE"
+
+EnforcementMode = Literal["ACTIVE", "LOG_ONLY"]
+ENFORCEMENT_MODES: Final[tuple[EnforcementMode, ...]] = get_args(EnforcementMode)
+DEFAULT_ENFORCEMENT_MODE: Final[EnforcementMode] = "ACTIVE"
+
+
+class Policy(ZodModel):
+    name: PolicyName
+    description: zstr(min=1, max=4096) | None = None
+    statement: zstr(min=1, min_msg="Cedar policy statement is required")
+    source_file: str | None = None
+    validation_mode: ValidationMode = "FAIL_ON_ANY_FINDINGS"
+    enforcement_mode: EnforcementMode = "ACTIVE"
+    # Upstream is `AuthorizationPhaseSchema.optional()` where the inner schema carries
+    # `.default('INITIATE')`; Zod 4 applies inner defaults through `.optional()`, so an absent
+    # value materializes as INITIATE.
+    authorization_phase: AuthorizationPhase = "INITIATE"
+
+
+class PolicyEngine(ZodModel):
+    name: PolicyEngineName
+    description: zstr(min=1, max=4096) | None = None
+    encryption_key_arn: str | None = None
+    tags: Tags | None = None
+    policies: Annotated[
+        list[Policy],
+        array_checks(extra=[unique_by(lambda p: p.name, lambda n: f"Duplicate policy name: {n}")]),
+        Field(default_factory=list),
+    ]
+
+
+__all__ = [
+    "AUTHORIZATION_PHASES",
+    "DEFAULT_AUTHORIZATION_PHASE",
+    "DEFAULT_ENFORCEMENT_MODE",
+    "ENFORCEMENT_MODES",
+    "VALIDATION_MODES",
+    "AuthorizationPhase",
+    "EnforcementMode",
+    "Policy",
+    "PolicyEngine",
+    "PolicyEngineName",
+    "PolicyName",
+    "ValidationMode",
+]

agentcore/schema/schemas/primitives/tags.py

@@ -0,0 +1,50 @@
+"""Resource tags with AWS tagging constraints (port of ``primitives/tags.ts``)."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+from pydantic import AfterValidator
+
+from ..._zod import JS_WHITESPACE, is_letter_or_number, js_trim, raise_issues, zstr
+
+_TAG_SYMBOLS = "_.:/=+-@"
+
+
+def _has_valid_tag_chars(value: str) -> bool:
+    # /^[\p{L}\p{N}\s_.:/=+\-@]*$/u
+    return all(is_letter_or_number(ch) or ch in JS_WHITESPACE or ch in _TAG_SYMBOLS for ch in value)
+
+
+TagKey = zstr(
+    min=1,
+    max=128,
+    min_msg="Tag key is required",
+    max_msg="Tag key must be 128 characters or less",
+    refines=(
+        (_has_valid_tag_chars, "Tag key contains invalid characters"),
+        (lambda k: len(js_trim(k)) > 0, "Tag key must contain at least one non-whitespace character"),
+        (lambda k: not k.startswith("aws:"), 'Tag keys starting with "aws:" are reserved'),
+    ),
+)
+
+TagValue = zstr(
+    max=256,
+    max_msg="Tag value must be 256 characters or less",
+    refines=((_has_valid_tag_chars, "Tag value contains invalid characters"),),
+)
+
+
+def _max_tags(tags: dict[str, str]) -> dict[str, str]:
+    if len(tags) > 50:
+        raise_issues([((), "Maximum 50 tags per resource")], tags)
+    return tags
+
+
+Tags = Annotated[dict[TagKey, TagValue], AfterValidator(_max_tags)]
+
+__all__ = [
+    "TagKey",
+    "TagValue",
+    "Tags",
+]

agentcore/schema/schemas/zod_util.py

@@ -0,0 +1,5 @@
+"""Port of ``src/schema/schemas/zod-util.ts``."""
+
+from .._zod import unique_by
+
+__all__ = ["unique_by"]

agentcore/schema/types/__init__.py

@@ -0,0 +1,3 @@
+from .path import PATH_TYPES, DirectoryPath, FilePath, PathType
+
+__all__ = ["PATH_TYPES", "DirectoryPath", "FilePath", "PathType"]

agentcore/schema/types/path.py

@@ -0,0 +1,16 @@
+"""Path type markers for schema fields (port of ``src/schema/types/path.ts``).
+
+These indicate whether a string field represents a file path or a directory path, so UIs can
+offer the right kind of path completion.
+"""
+
+from __future__ import annotations
+
+from typing import Final, Literal, NewType, get_args
+
+PathType = Literal["file", "directory"]
+PATH_TYPES: Final[tuple[PathType, ...]] = get_args(PathType)
+
+# Branded string types (TS `string & { __brand }`); plain str at runtime.
+FilePath = NewType("FilePath", str)
+DirectoryPath = NewType("DirectoryPath", str)

agentcore/templates/__init__.py

@@ -0,0 +1,115 @@
+"""Template rendering (port of upstream ``src/cli/templates``).
+
+Template assets live in ``<package>/assets`` (a byte-for-byte copy of upstream ``src/assets``) and are
+rendered with Handlebars semantics identical to handlebars.js (see ``_handlebars``).
+
+Typical use::
+
+    config = AgentRenderConfig(name="MyAgent", sdk_framework="Strands", protocol="HTTP", ...)
+    create_renderer(config).render(RendererContext(output_dir=project_root))  # -> app/MyAgent/
+    CDKRenderer().render(CDKRendererContext(project_root=project_root))       # -> agentcore/cdk/
+"""
+
+from agentcore.templates.base_renderer import BaseRenderer, RendererContext
+from agentcore.templates.cdk_renderer import CDKRenderer, CDKRendererContext, CreateLogger
+from agentcore.templates.evaluator_renderer import (
+    ThirdPartyEvaluatorTemplateData,
+    render_code_based_evaluator_template,
+    render_third_party_evaluator_template,
+)
+from agentcore.templates.gateway_target_renderer import (
+    LAMBDA_TEMPLATE_TOOLS,
+    ComputeHost,
+    get_template_tool_definitions,
+    render_gateway_target_template,
+)
+from agentcore.templates.profiles import (
+    BMA_TEMPLATE_PROFILE,
+    TemplateProfile,
+    TemplateRuntimeProfile,
+    apply_template_option_defaults,
+    get_template_profile,
+    template_needs_python_venv,
+    template_uses_model,
+    validate_template_options,
+)
+from agentcore.templates.render import (
+    SafeString,
+    compile_template,
+    copy_and_render_dir,
+    copy_dir,
+    render_template,
+    resolve_template_name,
+)
+from agentcore.templates.renderers import (
+    BmaRenderer,
+    GoogleADKRenderer,
+    LangGraphRenderer,
+    McpRenderer,
+    OpenAIAgentsRenderer,
+    StrandsRenderer,
+    VercelAIRenderer,
+    create_renderer,
+)
+from agentcore.templates.schema_assets import LLM_CONTEXT_FILES
+from agentcore.templates.template_root import TEMPLATE_ROOT, get_template_path
+from agentcore.templates.types import (
+    AgentRenderConfig,
+    GatewayProviderRenderConfig,
+    GitSkillRenderConfig,
+    HeaderCredentialRenderConfig,
+    IdentityProviderRenderConfig,
+    InlineFunctionToolRenderConfig,
+    MemoryProviderRenderConfig,
+    MountRenderConfig,
+    RemoteMcpToolRenderConfig,
+)
+
+__all__ = [
+    "BMA_TEMPLATE_PROFILE",
+    "LAMBDA_TEMPLATE_TOOLS",
+    "LLM_CONTEXT_FILES",
+    "TEMPLATE_ROOT",
+    "AgentRenderConfig",
+    "BaseRenderer",
+    "BmaRenderer",
+    "CDKRenderer",
+    "CDKRendererContext",
+    "ComputeHost",
+    "CreateLogger",
+    "GatewayProviderRenderConfig",
+    "GitSkillRenderConfig",
+    "GoogleADKRenderer",
+    "HeaderCredentialRenderConfig",
+    "IdentityProviderRenderConfig",
+    "InlineFunctionToolRenderConfig",
+    "LangGraphRenderer",
+    "McpRenderer",
+    "MemoryProviderRenderConfig",
+    "MountRenderConfig",
+    "OpenAIAgentsRenderer",
+    "RemoteMcpToolRenderConfig",
+    "RendererContext",
+    "SafeString",
+    "StrandsRenderer",
+    "TemplateProfile",
+    "TemplateRuntimeProfile",
+    "ThirdPartyEvaluatorTemplateData",
+    "VercelAIRenderer",
+    "apply_template_option_defaults",
+    "compile_template",
+    "copy_and_render_dir",
+    "copy_dir",
+    "create_renderer",
+    "get_template_path",
+    "get_template_profile",
+    "get_template_tool_definitions",
+    "render_code_based_evaluator_template",
+    "render_gateway_target_template",
+    "render_template",
+    "render_third_party_evaluator_template",
+    "resolve_template_name",
+    "template_needs_python_venv",
+    "template_uses_model",
+    "validate_template_options",
+]