AWS Bedrock Invalid Model ID

import boto3
import argparse

def print_ids(region: str, provider_filter: str = None, family_filter: str = None):
    br = boto3.client("bedrock", region_name=region)
    resp = br.list_foundation_models()

    print(f"# Bedrock foundation models available in {region}")
    print(f"# Fetched via list_foundation_models()\n")

    for m in resp["modelSummaries"]:
        model_id = m["modelId"]

        if provider_filter and not model_id.startswith(f"{provider_filter}."):
            continue
        if family_filter and family_filter not in model_id:
            continue

        provider = m.get("providerName", "")
        name = m.get("modelName", "")
        streaming = "streaming" if m.get("responseStreamingSupported") else "sync-only"
        lifecycle = m.get("modelLifecycle", {}).get("status", "")

        print(f"{model_id}")
        print(f"    provider  = {provider}")
        print(f"    name      = {name}")
        print(f"    streaming = {streaming}")
        print(f"    lifecycle = {lifecycle}\n")

if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("--region", default="us-east-1")
    parser.add_argument("--provider", help="Filter: anthropic, amazon, meta, mistral, cohere")
    parser.add_argument("--family", help="Substring filter: sonnet, opus, haiku, nova, etc.")
    args = parser.parse_args()
    print_ids(args.region, args.provider, args.family)

import re
from typing import Optional

# Provider.family-generation-YYYYMMDD-vX:Y
# Allow optional us./eu./apac. profile prefix.
_MODEL_ID_PATTERN = re.compile(
    r"^"
    r"(?:(?P<prefix>us|eu|apac)\.)?"          # optional profile prefix
    r"(?P<provider>[a-z0-9]+)\."               # provider (anthropic, amazon, meta, ...)
    r"(?P<family>[a-z0-9\-]+?)"                # family (claude-sonnet, nova-pro, ...)
    r"(?:-(?P<date>\d{8}))?"                   # optional YYYYMMDD version date
    r"-v(?P<major>\d+)"                        # interface version
    r"(?::(?P<minor>\d+))?"                    # optional revision
    r"$"
)

_KNOWN_PROVIDERS = {"anthropic", "amazon", "meta", "mistral", "cohere",
                    "ai21", "stability", "deepseek"}

def validate(model_id: str) -> tuple[bool, Optional[str]]:
    """Return (valid, error_reason). Reason is None when valid."""
    if not model_id:
        return False, "empty string"
    if model_id != model_id.strip():
        return False, "leading or trailing whitespace"
    if model_id != model_id.lower():
        return False, "must be lowercase"

    match = _MODEL_ID_PATTERN.match(model_id)
    if not match:
        return False, f"does not match pattern {_MODEL_ID_PATTERN.pattern}"

    provider = match.group("provider")
    if provider not in _KNOWN_PROVIDERS:
        return False, f"unknown provider '{provider}' (known: {_KNOWN_PROVIDERS})"

    # Anthropic requires the version date; Amazon does not for older Nova.
    if provider == "anthropic" and not match.group("date"):
        return False, "Anthropic models require YYYYMMDD version date"

    # Almost every model requires the :N revision suffix.
    if match.group("minor") is None:
        return False, "missing revision suffix (e.g. :0)"

    return True, None

# Self-test
if __name__ == "__main__":
    for candidate in [
        "anthropic.claude-sonnet-4-6-20250929-v1:0",  # valid
        "anthropic.claude-sonnet-4-6-v1:0",           # invalid: no date
        "anthropic.claude-sonnet-4-6-20250929-v1",    # invalid: no :0
        "Anthropic.Claude-Sonnet-4-6-20250929-v1:0",  # invalid: uppercase
        "us.anthropic.claude-opus-4-7-20260315-v1:0", # valid: profile prefix
        "amazon.nova-pro-v1:0",                        # valid: no date needed
    ]:
        ok, reason = validate(candidate)
        status = "OK" if ok else f"INVALID: {reason}"
        print(f"{candidate:<50} {status}")

from typing import Literal

def normalize(model_ref: str,
              target: Literal["id", "arn"],
              region: str = "us-east-1",
              account: str = None) -> str:
    """Convert between model ID and model ARN.

    Examples:
        normalize("anthropic.claude-sonnet-4-6-20250929-v1:0", target="arn")
        -> "arn:aws:bedrock:us-east-1::foundation-model/anthropic.claude-sonnet-4-6-20250929-v1:0"

        normalize("arn:aws:bedrock:us-east-1::foundation-model/anthropic.claude-...", target="id")
        -> "anthropic.claude-..."
    """
    is_arn = model_ref.startswith("arn:aws:bedrock:")

    if target == "id":
        if not is_arn:
            return model_ref  # already an ID
        # Extract the last path segment after "foundation-model/" or "inference-profile/"
        return model_ref.rsplit("/", 1)[-1]

    elif target == "arn":
        if is_arn:
            return model_ref  # already an ARN
        # Detect profile vs foundation model
        if model_ref.startswith(("us.", "eu.", "apac.")):
            # Inference profile — needs the account ID.
            if not account:
                raise ValueError("inference-profile ARN requires account ID")
            return f"arn:aws:bedrock:{region}:{account}:inference-profile/{model_ref}"
        # Foundation model — no account in ARN.
        return f"arn:aws:bedrock:{region}::foundation-model/{model_ref}"

    raise ValueError(f"target must be 'id' or 'arn', got {target}")

# Quick self-check
if __name__ == "__main__":
    tests = [
        ("anthropic.claude-sonnet-4-6-20250929-v1:0", "arn", "us-east-1", None),
        ("arn:aws:bedrock:us-east-1::foundation-model/anthropic.claude-haiku-4-5-20251001-v1:0", "id", None, None),
        ("us.anthropic.claude-opus-4-7-20260315-v1:0", "arn", "us-east-1", "123456789012"),
    ]
    for ref, target, region, account in tests:
        result = normalize(ref, target, region=region or "us-east-1", account=account)
        print(f"{ref[:50]:<52} --{target}--> {result[:80]}")