agentcore-cli 0.31.1__py3-none-any.whl

agentcore/schema/_zod.py

@@ -0,0 +1,395 @@
+"""Internal helpers that reproduce Zod (v4) parsing semantics on top of Pydantic v2.
+
+Upstream validates with Zod. To keep validation and the JSON wire format faithful we:
+
+* translate JavaScript regex sources to Python (``$`` -> ``\\Z``, ASCII ``\\d``, JS ``\\s`` / ``.``),
+* measure string lengths in UTF-16 code units like JavaScript does,
+* reject ``null`` for optional fields (Zod ``.optional()`` only accepts ``undefined``),
+* omit unset optional fields when dumping (``JSON.stringify`` drops ``undefined``),
+* report refinement issues with the same path/message as upstream ``ctx.addIssue`` calls.
+"""
+
+from __future__ import annotations
+
+import math
+import re
+import unicodedata
+from collections.abc import Callable, Iterable, Sequence
+from typing import Annotated, Any, TypeVar
+
+from pydantic import (
+    AfterValidator,
+    BaseModel,
+    ConfigDict,
+    PlainValidator,
+    SerializationInfo,
+    SerializerFunctionWrapHandler,
+    ValidationError,
+    model_serializer,
+    model_validator,
+)
+from pydantic.alias_generators import to_camel
+from pydantic_core import PydanticCustomError
+
+T = TypeVar("T")
+
+Loc = tuple[str | int, ...]
+Issue = tuple[Loc, str]
+
+# ---------------------------------------------------------------------------
+# JavaScript string semantics
+# ---------------------------------------------------------------------------
+
+# Characters matched by JS `\s` and stripped by String.prototype.trim().
+JS_WHITESPACE = "\t\n\v\f\r              

  　"
+_JS_WS_CLASS = r"\t\n\x0b\x0c\r    - 

  　"
+# JS `.` (without the `s` flag) matches anything except line terminators.
+_JS_DOT = r"[^\n\r

]"
+
+
+def js_trim(value: str) -> str:
+    return value.strip(JS_WHITESPACE)
+
+
+def js_len(value: str) -> int:
+    """String length in UTF-16 code units (JavaScript ``String.length``)."""
+    return len(value.encode("utf-16-le")) // 2
+
+
+def js_regex(source: str) -> re.Pattern[str]:
+    """Compile a JavaScript regex source (no flags) with equivalent Python semantics."""
+    out: list[str] = []
+    in_class = False
+    i = 0
+    while i < len(source):
+        ch = source[i]
+        if ch == "\\" and i + 1 < len(source):
+            nxt = source[i + 1]
+            if nxt == "d":
+                out.append("0-9" if in_class else "[0-9]")
+            elif nxt == "s":
+                out.append(_JS_WS_CLASS if in_class else f"[{_JS_WS_CLASS}]")
+            else:
+                out.append(ch + nxt)
+            i += 2
+            continue
+        if in_class:
+            if ch == "]":
+                in_class = False
+            out.append(ch)
+        elif ch == "[":
+            in_class = True
+            out.append(ch)
+            # A literal ']' or '^]' right after '[' is part of the class in both dialects.
+        elif ch == ".":
+            out.append(_JS_DOT)
+        elif ch == "$":
+            out.append(r"\Z")
+        else:
+            out.append(ch)
+        i += 1
+    return re.compile("".join(out))
+
+
+def is_js_url(value: str) -> bool:
+    """Approximates ``new URL(value)`` succeeding (WHATWG URL parsing), as used by ``z.url()``."""
+    m = re.match(r"^([A-Za-z][A-Za-z0-9+.\-]*):(.*)$", value, re.DOTALL)
+    if not m:
+        return False
+    scheme, rest = m.group(1).lower(), m.group(2)
+    rest = re.sub(r"[\t\n\r]", "", rest)
+    special = {"http", "https", "ws", "wss", "ftp"}
+    if scheme == "file" or scheme not in special:
+        return True
+    rest = rest.lstrip("/\\")
+    authority = re.split(r"[/\\?#]", rest, maxsplit=1)[0]
+    host_port = authority.rsplit("@", 1)[-1]
+    if host_port.startswith("["):
+        return re.fullmatch(r"\[[0-9A-Fa-f:.]+\](:[0-9]*)?", host_port) is not None
+    host, _, port = host_port.partition(":")
+    if not host:
+        return False
+    if port and (not port.isdigit() or int(port) > 65535):
+        return False
+    return re.search(r"[\x00-\x20#%/:<>?@\[\\\]^|\x7f]", host) is None
+
+
+# ---------------------------------------------------------------------------
+# Issue reporting
+# ---------------------------------------------------------------------------
+
+
+def raise_issues(issues: Sequence[Issue], value: Any) -> None:
+    """Raise all collected issues as one ValidationError whose locs Pydantic re-roots."""
+    if not issues:
+        return
+    raise ValidationError.from_exception_data(
+        "zod",
+        [{"type": PydanticCustomError("custom", msg), "loc": loc, "input": value} for loc, msg in issues],
+    )
+
+
+def unique_by(key_fn: Callable[[Any], str], error_message: Callable[[str], str]) -> Callable[[list[T]], list[T]]:
+    """Port of ``uniqueBy`` (zod-util.ts): flag every repeated key at its array index."""
+
+    def check(items: list[T]) -> list[T]:
+        seen: set[str] = set()
+        issues: list[Issue] = []
+        for idx, item in enumerate(items):
+            key = key_fn(item)
+            if key in seen:
+                issues.append(((idx,), error_message(key)))
+            seen.add(key)
+        raise_issues(issues, items)
+        return items
+
+    return check
+
+
+# ---------------------------------------------------------------------------
+# Primitive types
+# ---------------------------------------------------------------------------
+
+
+def _check_str(
+    value: str,
+    *,
+    min_len: int | None,
+    max_len: int | None,
+    pattern: re.Pattern[str] | None,
+    min_msg: str | None,
+    max_msg: str | None,
+    pattern_msg: str | None,
+    starts_with: str | None,
+    refines: Sequence[tuple[Callable[[str], bool], str]],
+) -> list[str]:
+    errors: list[str] = []
+    n = js_len(value)
+    if min_len is not None and n < min_len:
+        errors.append(min_msg or f"Too small: expected string to have >={min_len} characters")
+    if max_len is not None and n > max_len:
+        errors.append(max_msg or f"Too big: expected string to have <={max_len} characters")
+    if pattern is not None and not pattern.search(value):
+        errors.append(pattern_msg or f"Invalid string: must match pattern {pattern.pattern}")
+    if starts_with is not None and not value.startswith(starts_with):
+        errors.append(f'Invalid string: must start with "{starts_with}"')
+    for fn, msg in refines:
+        if not fn(value):
+            errors.append(msg)
+    return errors
+
+
+def zstr(
+    *,
+    min: int | None = None,
+    max: int | None = None,
+    pattern: re.Pattern[str] | str | None = None,
+    min_msg: str | None = None,
+    max_msg: str | None = None,
+    pattern_msg: str | None = None,
+    starts_with: str | None = None,
+    url: bool = False,
+    url_msg: str = "Invalid URL",
+    trim: bool = False,
+    refines: Sequence[tuple[Callable[[str], bool], str]] = (),
+) -> Any:
+    """Build an annotated ``str`` type equivalent to a chained ``z.string()`` schema.
+
+    Check order follows the typical upstream chain: trim -> url -> min/max/regex/startsWith -> refines.
+    Like Zod, every failing length/pattern/refine check is reported; an invalid URL stops further checks.
+    """
+    compiled = js_regex(pattern) if isinstance(pattern, str) else pattern
+
+    def validate(value: str) -> str:
+        if trim:
+            value = js_trim(value)
+        if url:
+            # z.url() trims the value and requires WHATWG URL parsing to succeed.
+            value = js_trim(value)
+            if not is_js_url(value):
+                raise_issues([((), url_msg)], value)
+        errors = _check_str(
+            value,
+            min_len=min,
+            max_len=max,
+            pattern=compiled,
+            min_msg=min_msg,
+            max_msg=max_msg,
+            pattern_msg=pattern_msg,
+            starts_with=starts_with,
+            refines=refines,
+        )
+        raise_issues([((), e) for e in errors], value)
+        return value
+
+    return Annotated[str, AfterValidator(validate)]
+
+
+def _is_number(value: Any) -> bool:
+    return isinstance(value, (int, float)) and not isinstance(value, bool)
+
+
+def _number(
+    value: Any, *, integer: bool, ge: float | None, le: float | None, ge_msg: str | None, le_msg: str | None
+) -> int | float:
+    if not _is_number(value) or (isinstance(value, float) and not math.isfinite(value)):
+        raise PydanticCustomError("invalid_type", f"Invalid input: expected number, received {_js_type(value)}")
+    if isinstance(value, float) and value.is_integer():
+        # JSON.stringify(1.0) === "1": keep integral numbers as ints so dumps stay byte-compatible.
+        value = int(value)
+    if integer and (not isinstance(value, int) or abs(value) > 9007199254740991):
+        raise PydanticCustomError("invalid_type", "Invalid input: expected int, received number")
+    errors: list[str] = []
+    if ge is not None and value < ge:
+        errors.append(ge_msg or f"Too small: expected number to be >={_fmt_num(ge)}")
+    if le is not None and value > le:
+        errors.append(le_msg or f"Too big: expected number to be <={_fmt_num(le)}")
+    raise_issues([((), e) for e in errors], value)
+    return value
+
+
+def _fmt_num(n: float) -> str:
+    return str(int(n)) if float(n).is_integer() else str(n)
+
+
+def _js_type(value: Any) -> str:
+    if value is None:
+        return "null"
+    if isinstance(value, bool):
+        return "boolean"
+    if isinstance(value, str):
+        return "string"
+    if isinstance(value, (list, tuple)):
+        return "array"
+    if isinstance(value, float):
+        return "number"
+    return "object" if isinstance(value, dict) else type(value).__name__
+
+
+def znum(
+    *, ge: float | None = None, le: float | None = None, ge_msg: str | None = None, le_msg: str | None = None
+) -> Any:
+    """``z.number()`` with optional ``.min()``/``.max()``. Integral values dump as ints like JS."""
+    return Annotated[
+        int | float,
+        PlainValidator(lambda v: _number(v, integer=False, ge=ge, le=le, ge_msg=ge_msg, le_msg=le_msg)),
+    ]
+
+
+def zint(
+    *, ge: float | None = None, le: float | None = None, ge_msg: str | None = None, le_msg: str | None = None
+) -> Any:
+    """``z.number().int()`` with optional bounds (Zod v4 ints are JS safe integers)."""
+    return Annotated[
+        int,
+        PlainValidator(lambda v: int(_number(v, integer=True, ge=ge, le=le, ge_msg=ge_msg, le_msg=le_msg))),
+    ]
+
+
+def _bool(value: Any) -> bool:
+    if not isinstance(value, bool):
+        raise PydanticCustomError("invalid_type", f"Invalid input: expected boolean, received {_js_type(value)}")
+    return value
+
+
+ZBool = Annotated[bool, PlainValidator(_bool)]
+
+
+def array_checks(
+    *,
+    min: int | None = None,
+    max: int | None = None,
+    length: int | None = None,
+    min_msg: str | None = None,
+    max_msg: str | None = None,
+    extra: Iterable[Callable[[list[Any]], list[Any]]] = (),
+) -> AfterValidator:
+    """Length checks for ``z.array()`` followed by ``superRefine`` callbacks (e.g. ``unique_by``)."""
+    extra = tuple(extra)
+
+    def check(items: list[Any]) -> list[Any]:
+        errors: list[str] = []
+        n = len(items)
+        if length is not None:
+            if n < length:
+                errors.append(min_msg or f"Too small: expected array to have >={length} items")
+            elif n > length:
+                errors.append(max_msg or f"Too big: expected array to have <={length} items")
+        if min is not None and n < min:
+            errors.append(min_msg or f"Too small: expected array to have >={min} items")
+        if max is not None and n > max:
+            errors.append(max_msg or f"Too big: expected array to have <={max} items")
+        raise_issues([((), e) for e in errors], items)
+        for fn in extra:
+            items = fn(items)
+        return items
+
+    return AfterValidator(check)
+
+
+# ---------------------------------------------------------------------------
+# Unicode helpers
+# ---------------------------------------------------------------------------
+
+
+def is_letter_or_number(ch: str) -> bool:
+    """``\\p{L}`` / ``\\p{N}`` membership."""
+    return unicodedata.category(ch)[0] in ("L", "N")
+
+
+# ---------------------------------------------------------------------------
+# Base models
+# ---------------------------------------------------------------------------
+
+
+class ZodModel(BaseModel):
+    """Base for ``z.object()`` ports: unknown keys stripped, camelCase wire names.
+
+    * Optional fields default to ``None`` but an explicit ``null`` is rejected, like ``.optional()``.
+    * ``model_dump(by_alias=True)`` omits ``None``-valued fields (``undefined`` in JS), while keeping
+      ``null`` values nested inside free-form ``z.unknown()`` payloads. Use :meth:`to_json_dict`.
+    """
+
+    model_config = ConfigDict(
+        alias_generator=to_camel,
+        populate_by_name=True,
+        extra="ignore",
+        protected_namespaces=(),
+    )
+
+    @model_validator(mode="before")
+    @classmethod
+    def _reject_null(cls, data: Any) -> Any:
+        if isinstance(data, dict):
+            issues: list[Issue] = []
+            for name, field in cls.model_fields.items():
+                for key in {field.alias or name, name}:
+                    if key in data and data[key] is None:
+                        issues.append(((key,), "Invalid input: expected nonoptional, received null"))
+            raise_issues(issues, data)
+        return data
+
+    @model_serializer(mode="wrap")
+    def _drop_undefined(self, handler: SerializerFunctionWrapHandler, info: SerializationInfo) -> Any:
+        data = handler(self)
+        if isinstance(data, dict):
+            for name, field in type(self).model_fields.items():
+                if getattr(self, name, None) is None:
+                    data.pop(field.alias if info.by_alias and field.alias else name, None)
+        return data
+
+    def to_json_dict(self) -> dict[str, Any]:
+        """Dump with upstream wire keys (camelCase), omitting unset optional fields."""
+        return self.model_dump(mode="json", by_alias=True)
+
+
+class StrictModel(ZodModel):
+    """``z.object().strict()`` / ``z.strictObject()``: unknown keys are rejected."""
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class PassthroughModel(ZodModel):
+    """``z.object().passthrough()``: unknown keys are preserved and re-emitted."""
+
+    model_config = ConfigDict(extra="allow")

agentcore/schema/constants.py

@@ -0,0 +1,306 @@
+"""Feature and infrastructure constants shared across schemas (port of ``src/schema/constants.ts``)."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable, Mapping
+from typing import Any, Final, Literal, get_args
+
+from ._zod import js_regex
+
+# ============================================================================
+# Feature Constants (shared across all schemas)
+# ============================================================================
+
+SDKFramework = Literal[
+    "Strands",
+    "LangChain_LangGraph",
+    "GoogleADK",
+    "OpenAIAgents",
+    "VercelAI",
+    "BedrockManagedAgents",
+]
+SDK_FRAMEWORKS: Final[tuple[SDKFramework, ...]] = get_args(SDKFramework)
+
+TargetLanguage = Literal["Python", "TypeScript", "Other"]
+TARGET_LANGUAGES: Final[tuple[TargetLanguage, ...]] = get_args(TargetLanguage)
+
+ModelProvider = Literal["Bedrock", "Gemini", "OpenAI", "Anthropic", "LiteLLM"]
+MODEL_PROVIDERS: Final[tuple[ModelProvider, ...]] = get_args(ModelProvider)
+
+# Providers that use credentials (Bedrock uses IAM, no credential needed). LiteLLM's API key is optional.
+CREDENTIAL_PROVIDERS: Final[tuple[ModelProvider, ...]] = ("Gemini", "OpenAI", "Anthropic", "LiteLLM")
+
+
+def match_enum_value(options: Any, input: str) -> str | None:
+    """Case-insensitively match ``input`` against enum options; returns the canonical value or None.
+
+    ``options`` may be a ``Literal`` type or any iterable of strings (upstream takes a Zod enum).
+    """
+    values: Iterable[str] = get_args(options) or options
+    lower = input.lower()
+    return next((v for v in values if v.lower() == lower), None)
+
+
+# Short names that --framework also accepts.
+_SDK_FRAMEWORK_ALIASES: Final[Mapping[str, SDKFramework]] = {"bma": "BedrockManagedAgents"}
+
+
+def match_sdk_framework(input: str) -> SDKFramework | None:
+    """Case-insensitively match a --framework value, including its short names."""
+    lower = input.lower()
+    if lower in _SDK_FRAMEWORK_ALIASES:
+        return _SDK_FRAMEWORK_ALIASES[lower]
+    return match_enum_value(SDK_FRAMEWORKS, input)  # type: ignore[return-value]
+
+
+# Default model IDs used for each provider (the models generated in agent templates).
+DEFAULT_MODEL_IDS: Final[dict[ModelProvider, str]] = {
+    "Bedrock": "us.anthropic.claude-sonnet-4-5-20250514-v1:0",
+    "Anthropic": "claude-sonnet-4-5-20250514",
+    "OpenAI": "gpt-4.1",
+    "Gemini": "gemini-2.5-flash",
+    # LiteLLM model ids are provider-prefixed (e.g. "bedrock/...", "openai/gpt-4o"); no single default.
+    "LiteLLM": "bedrock/us.anthropic.claude-sonnet-4-5-20250514-v1:0",
+}
+
+# Which model providers are supported for each SDK framework.
+SDK_MODEL_PROVIDER_MATRIX: Final[dict[SDKFramework, tuple[ModelProvider, ...]]] = {
+    # LiteLLM is supported for Strands (used by harness export) — it proxies to any provider.
+    "Strands": ("Bedrock", "Anthropic", "OpenAI", "Gemini", "LiteLLM"),
+    "LangChain_LangGraph": ("Bedrock", "Anthropic", "OpenAI", "Gemini"),
+    "GoogleADK": ("Gemini",),
+    "OpenAIAgents": ("OpenAI",),
+    "VercelAI": ("Bedrock", "Anthropic", "OpenAI", "Gemini"),
+    # BMA runs no model in the runtime: Bedrock Managed Agents (Mantle) runs Codex and calls in.
+    "BedrockManagedAgents": ("Bedrock",),
+}
+
+
+def get_supported_model_providers(sdk: SDKFramework) -> tuple[ModelProvider, ...]:
+    return SDK_MODEL_PROVIDER_MATRIX[sdk]
+
+
+def is_model_provider_supported(sdk: SDKFramework, provider: ModelProvider) -> bool:
+    return provider in SDK_MODEL_PROVIDER_MATRIX[sdk]
+
+
+# ============================================================================
+# Reserved Project Names (Python package conflicts)
+# ============================================================================
+
+# Names that would conflict with Python package names when creating a virtual environment
+# (normalized: lowercase, no separators, since project names are alphanumeric only).
+RESERVED_PROJECT_NAMES: Final[tuple[str, ...]] = (
+    # Core SDK packages
+    "anthropic",
+    "autogen",
+    "autogenagentchat",
+    "autogenext",
+    "bedrock",
+    "bedrockagentcore",
+    "googleadk",
+    "googlegenerativeai",
+    "langchain",
+    "langchainanthropic",
+    "langchainaws",
+    "langchaingooglegenai",
+    "langchainmcpadapters",
+    "langchainopenai",
+    "langgraph",
+    "mcp",
+    "openai",
+    "openaiagents",
+    "strands",
+    "strandsagents",
+    "strandsagentstools",
+    # AG-UI adapter packages
+    "agui",
+    "aguistrands",
+    "aguilanggraph",
+    "aguiadk",
+    "aguiprotocol",
+    "vercelai",
+    "aisdk",
+    # Common utilities
+    "httpx",
+    "pytest",
+    "pytestasyncio",
+    "pythondotenv",
+    # Build tools
+    "hatchling",
+    "setuptools",
+    "wheel",
+    # AWS packages
+    "awsopentelemetrydistro",
+    "boto3",
+    "botocore",
+    # Common Python stdlib/package names that could cause issues
+    "test",
+    "tests",
+    "src",
+    "lib",
+    "dist",
+    "build",
+    "env",
+    "venv",
+    "site",
+    "pip",
+    "uv",
+)
+
+
+def is_reserved_project_name(name: str) -> bool:
+    """Check if a project name is reserved (case-insensitive)."""
+    return name.lower() in RESERVED_PROJECT_NAMES
+
+
+# ============================================================================
+# Infrastructure Constants (shared between agent-env and mcp schemas)
+# ============================================================================
+
+PythonRuntime = Literal["PYTHON_3_10", "PYTHON_3_11", "PYTHON_3_12", "PYTHON_3_13", "PYTHON_3_14"]
+PYTHON_RUNTIMES: Final[tuple[PythonRuntime, ...]] = get_args(PythonRuntime)
+
+DEFAULT_PYTHON_VERSION: Final[PythonRuntime] = "PYTHON_3_14"
+
+NodeRuntime = Literal["NODE_18", "NODE_20", "NODE_22"]
+NODE_RUNTIMES: Final[tuple[NodeRuntime, ...]] = get_args(NodeRuntime)
+
+DEFAULT_NODE_VERSION: Final[NodeRuntime] = "NODE_22"
+
+# Combined runtime version supporting both Python and Node/TypeScript runtimes.
+RuntimeVersion = Literal[PythonRuntime, NodeRuntime]
+RUNTIME_VERSIONS: Final[tuple[str, ...]] = PYTHON_RUNTIMES + NODE_RUNTIMES
+
+DEFAULT_ENTRYPOINT_BY_LANGUAGE: Final[dict[Literal["Python", "TypeScript"], str]] = {
+    "Python": "main.py",
+    "TypeScript": "main.js",
+}
+
+DEFAULT_RUNTIME_BY_LANGUAGE: Final[dict[Literal["Python", "TypeScript"], str]] = {
+    "Python": DEFAULT_PYTHON_VERSION,
+    "TypeScript": DEFAULT_NODE_VERSION,
+}
+
+NetworkMode = Literal["PUBLIC", "VPC"]
+NETWORK_MODES: Final[tuple[NetworkMode, ...]] = get_args(NetworkMode)
+
+# ============================================================================
+# AWS Network Resource ID Patterns (single source of truth)
+#
+# Canonical AWS resource ID format: lowercase hex, exactly 8 chars (legacy) or 17 chars (current).
+# ============================================================================
+
+VPC_ID_PATTERN: Final = js_regex(r"^vpc-(?:[0-9a-f]{8}|[0-9a-f]{17})$")
+SUBNET_ID_PATTERN: Final = js_regex(r"^subnet-(?:[0-9a-f]{8}|[0-9a-f]{17})$")
+SECURITY_GROUP_ID_PATTERN: Final = js_regex(r"^sg-(?:[0-9a-f]{8}|[0-9a-f]{17})$")
+
+# CodeBuild caps a project's VPC config at 5 security groups (vs 16 for the runtime).
+MAX_CONTAINER_BUILD_SECURITY_GROUPS: Final = 5
+
+
+def _get(spec: Any, camel: str, snake: str) -> Any:
+    if isinstance(spec, Mapping):
+        return spec.get(camel, spec.get(snake))
+    return getattr(spec, snake, None)
+
+
+def is_container_build(spec: Any) -> bool:
+    """Whether a build runs the container-image pipeline (CodeBuild), needing an explicit vpcId in VPC mode.
+
+    True when ``build == 'Container'``, or the spec carries a ``dockerfile`` (from-source container
+    harness) or a ``containerUri`` (prebuilt image harness). Accepts a model or a camelCase/snake_case
+    mapping.
+    """
+    return (
+        _get(spec, "build", "build") == "Container"
+        or bool(_get(spec, "containerUri", "container_uri"))
+        or bool(_get(spec, "dockerfile", "dockerfile"))
+    )
+
+
+# ============================================================================
+# Protocol Mode
+# ============================================================================
+
+ProtocolMode = Literal["HTTP", "MCP", "A2A", "AGUI"]
+PROTOCOL_MODES: Final[tuple[ProtocolMode, ...]] = get_args(ProtocolMode)
+
+# Which SDK frameworks are supported for each protocol mode. MCP is a standalone tool server.
+PROTOCOL_FRAMEWORK_MATRIX: Final[dict[ProtocolMode, tuple[SDKFramework, ...]]] = {
+    "HTTP": ("Strands", "LangChain_LangGraph", "GoogleADK", "OpenAIAgents", "VercelAI", "BedrockManagedAgents"),
+    "MCP": (),
+    "A2A": ("Strands", "GoogleADK", "LangChain_LangGraph"),
+    "AGUI": ("Strands", "LangChain_LangGraph", "GoogleADK"),
+}
+
+
+def get_supported_frameworks_for_protocol(protocol: ProtocolMode) -> tuple[SDKFramework, ...]:
+    return PROTOCOL_FRAMEWORK_MATRIX[protocol]
+
+
+def is_framework_supported_for_protocol(protocol: ProtocolMode, framework: SDKFramework) -> bool:
+    return framework in PROTOCOL_FRAMEWORK_MATRIX[protocol]
+
+
+# Which SDK frameworks ship templates for each target language (Vercel AI is TypeScript-only).
+LANGUAGE_FRAMEWORK_MATRIX: Final[dict[str, tuple[SDKFramework, ...]]] = {
+    "Python": ("Strands", "LangChain_LangGraph", "GoogleADK", "OpenAIAgents", "BedrockManagedAgents"),
+    "TypeScript": ("Strands", "VercelAI"),
+}
+
+# Languages that scaffold from templates (excludes 'Other', which is BYO-only).
+TemplateLanguage = Literal["Python", "TypeScript"]
+
+
+def get_frameworks_for_language(language: TemplateLanguage) -> tuple[SDKFramework, ...]:
+    return LANGUAGE_FRAMEWORK_MATRIX[language]
+
+
+def is_framework_supported_for_language(language: TemplateLanguage, framework: SDKFramework) -> bool:
+    return framework in get_frameworks_for_language(language)
+
+
+__all__ = [
+    "CREDENTIAL_PROVIDERS",
+    "DEFAULT_ENTRYPOINT_BY_LANGUAGE",
+    "DEFAULT_MODEL_IDS",
+    "DEFAULT_NODE_VERSION",
+    "DEFAULT_PYTHON_VERSION",
+    "DEFAULT_RUNTIME_BY_LANGUAGE",
+    "LANGUAGE_FRAMEWORK_MATRIX",
+    "MAX_CONTAINER_BUILD_SECURITY_GROUPS",
+    "MODEL_PROVIDERS",
+    "NETWORK_MODES",
+    "NODE_RUNTIMES",
+    "PROTOCOL_FRAMEWORK_MATRIX",
+    "PROTOCOL_MODES",
+    "PYTHON_RUNTIMES",
+    "RESERVED_PROJECT_NAMES",
+    "RUNTIME_VERSIONS",
+    "SDK_FRAMEWORKS",
+    "SDK_MODEL_PROVIDER_MATRIX",
+    "SECURITY_GROUP_ID_PATTERN",
+    "SUBNET_ID_PATTERN",
+    "TARGET_LANGUAGES",
+    "VPC_ID_PATTERN",
+    "ModelProvider",
+    "NetworkMode",
+    "NodeRuntime",
+    "ProtocolMode",
+    "PythonRuntime",
+    "RuntimeVersion",
+    "SDKFramework",
+    "TargetLanguage",
+    "TemplateLanguage",
+    "get_frameworks_for_language",
+    "get_supported_frameworks_for_protocol",
+    "get_supported_model_providers",
+    "is_container_build",
+    "is_framework_supported_for_language",
+    "is_framework_supported_for_protocol",
+    "is_model_provider_supported",
+    "is_reserved_project_name",
+    "match_enum_value",
+    "match_sdk_framework",
+]