This is page 519 of 542. Use http://codebase.md/awslabs/mcp?lines=true&page={x} to view the full context.
# Directory Structure
```
├── .devcontainer
│ └── devcontainer.json
├── .github
│ ├── actions
│ │ ├── build-and-push-container-image
│ │ │ └── action.yml
│ │ └── clear-space-ubuntu-latest-agressively
│ │ └── action.yml
│ ├── codecov.yml
│ ├── CODEOWNERS
│ ├── dependabot.yml
│ ├── ISSUE_TEMPLATE
│ │ ├── bug_report.yml
│ │ ├── documentation.yml
│ │ ├── feature_request.yml
│ │ ├── rfc.yml
│ │ └── support_awslabs_mcp_servers.yml
│ ├── pull_request_template.md
│ ├── SECURITY
│ ├── SUPPORT
│ └── workflows
│ ├── aws-api-mcp-upgrade-version.yml
│ ├── bandit-requirements.txt
│ ├── bandit.yml
│ ├── cfn_nag.yml
│ ├── check-gh-pages-builds.yml
│ ├── check-license-header-hash.txt
│ ├── check-license-header.json
│ ├── check-license-header.yml
│ ├── checkov.yml
│ ├── codeql.yml
│ ├── dependency-review-action.yml
│ ├── detect-secrets-requirements.txt
│ ├── gh-pages.yml
│ ├── merge-prevention.yml
│ ├── powershell.yml
│ ├── pre-commit-requirements.txt
│ ├── pre-commit.yml
│ ├── pull-request-lint.yml
│ ├── python.yml
│ ├── RELEASE_INSTRUCTIONS.md
│ ├── release-initiate-branch.yml
│ ├── release-merge-tag.yml
│ ├── release.py
│ ├── release.yml
│ ├── scanners.yml
│ ├── scorecard-analysis.yml
│ ├── semgrep-requirements.txt
│ ├── semgrep.yml
│ ├── stale.yml
│ ├── trivy.yml
│ └── typescript.yml
├── .gitignore
├── .pre-commit-config.yaml
├── .python-version
├── .ruff.toml
├── .secrets.baseline
├── CODE_OF_CONDUCT.md
├── CONTRIBUTING.md
├── DESIGN_GUIDELINES.md
├── DEVELOPER_GUIDE.md
├── docs
│ └── images
│ └── root-readme
│ ├── cline-api-provider-filled.png
│ ├── cline-chat-interface.png
│ ├── cline-custom-instructions.png
│ ├── cline-select-aws-profile.png
│ ├── cline-select-bedrock.png
│ ├── configure-mcp-servers.png
│ ├── install-cline-extension.png
│ ├── mcp-servers-installed.png
│ └── select-mcp-servers.png
├── docusaurus
│ ├── .gitignore
│ ├── docs
│ │ ├── installation.md
│ │ ├── intro.md
│ │ ├── samples
│ │ │ ├── index.md
│ │ │ ├── mcp-integration-with-kb.md
│ │ │ ├── mcp-integration-with-nova-canvas.md
│ │ │ └── stepfunctions-tool-mcp-server.md
│ │ ├── servers
│ │ │ ├── amazon-bedrock-agentcore-mcp-server.md
│ │ │ ├── amazon-keyspaces-mcp-server.md
│ │ │ ├── amazon-mq-mcp-server.md
│ │ │ ├── amazon-neptune-mcp-server.md
│ │ │ ├── amazon-qbusiness-anonymous-mcp-server.md
│ │ │ ├── amazon-qindex-mcp-server.md
│ │ │ ├── amazon-sns-sqs-mcp-server.md
│ │ │ ├── aurora-dsql-mcp-server.md
│ │ │ ├── aws-api-mcp-server.md
│ │ │ ├── aws-appsync-mcp-server.md
│ │ │ ├── aws-bedrock-custom-model-import-mcp-server.md
│ │ │ ├── aws-bedrock-data-automation-mcp-server.md
│ │ │ ├── aws-dataprocessing-mcp-server.md
│ │ │ ├── aws-diagram-mcp-server.md
│ │ │ ├── aws-documentation-mcp-server.md
│ │ │ ├── aws-healthomics-mcp-server.md
│ │ │ ├── aws-iot-sitewise-mcp-server.md
│ │ │ ├── aws-knowledge-mcp-server.md
│ │ │ ├── aws-location-mcp-server.md
│ │ │ ├── aws-msk-mcp-server.md
│ │ │ ├── aws-pricing-mcp-server.md
│ │ │ ├── aws-serverless-mcp-server.md
│ │ │ ├── aws-support-mcp-server.md
│ │ │ ├── bedrock-kb-retrieval-mcp-server.md
│ │ │ ├── billing-cost-management-mcp-server.md
│ │ │ ├── ccapi-mcp-server.md
│ │ │ ├── cdk-mcp-server.md
│ │ │ ├── cfn-mcp-server.md
│ │ │ ├── cloudtrail-mcp-server.md
│ │ │ ├── cloudwatch-appsignals-mcp-server.md
│ │ │ ├── cloudwatch-mcp-server.md
│ │ │ ├── code-doc-gen-mcp-server.md
│ │ │ ├── core-mcp-server.md
│ │ │ ├── cost-explorer-mcp-server.md
│ │ │ ├── documentdb-mcp-server.md
│ │ │ ├── dynamodb-mcp-server.md
│ │ │ ├── ecs-mcp-server.md
│ │ │ ├── eks-mcp-server.md
│ │ │ ├── elasticache-mcp-server.md
│ │ │ ├── finch-mcp-server.md
│ │ │ ├── frontend-mcp-server.md
│ │ │ ├── git-repo-research-mcp-server.md
│ │ │ ├── healthlake-mcp-server.md
│ │ │ ├── iam-mcp-server.md
│ │ │ ├── kendra-index-mcp-server.md
│ │ │ ├── lambda-tool-mcp-server.md
│ │ │ ├── memcached-mcp-server.md
│ │ │ ├── mysql-mcp-server.md
│ │ │ ├── nova-canvas-mcp-server.md
│ │ │ ├── openapi-mcp-server.md
│ │ │ ├── postgres-mcp-server.md
│ │ │ ├── prometheus-mcp-server.md
│ │ │ ├── redshift-mcp-server.md
│ │ │ ├── s3-tables-mcp-server.md
│ │ │ ├── stepfunctions-tool-mcp-server.md
│ │ │ ├── syntheticdata-mcp-server.md
│ │ │ ├── terraform-mcp-server.md
│ │ │ ├── timestream-for-influxdb-mcp-server.md
│ │ │ ├── valkey-mcp-server.md
│ │ │ └── well-architected-security-mcp-server.mdx
│ │ └── vibe_coding.md
│ ├── docusaurus.config.ts
│ ├── package-lock.json
│ ├── package.json
│ ├── README.md
│ ├── sidebars.ts
│ ├── src
│ │ ├── components
│ │ │ ├── HomepageFeatures
│ │ │ │ └── styles.module.css
│ │ │ └── ServerCards
│ │ │ ├── index.tsx
│ │ │ └── styles.module.css
│ │ ├── css
│ │ │ ├── custom.css
│ │ │ └── doc-override.css
│ │ └── pages
│ │ ├── index.module.css
│ │ └── servers.tsx
│ ├── static
│ │ ├── .nojekyll
│ │ ├── assets
│ │ │ ├── icons
│ │ │ │ ├── activity.svg
│ │ │ │ ├── book-open.svg
│ │ │ │ ├── cpu.svg
│ │ │ │ ├── database.svg
│ │ │ │ ├── dollar-sign.svg
│ │ │ │ ├── help-circle.svg
│ │ │ │ ├── key.svg
│ │ │ │ ├── server.svg
│ │ │ │ ├── share-2.svg
│ │ │ │ ├── tool.svg
│ │ │ │ └── zap.svg
│ │ │ └── server-cards.json
│ │ └── img
│ │ ├── aws-logo.svg
│ │ └── logo.png
│ └── tsconfig.json
├── LICENSE
├── NOTICE
├── README.md
├── samples
│ ├── mcp-integration-with-kb
│ │ ├── .env.example
│ │ ├── .python-version
│ │ ├── assets
│ │ │ └── simplified-mcp-flow-diagram.png
│ │ ├── clients
│ │ │ └── client_server.py
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── user_interfaces
│ │ │ └── chat_bedrock_st.py
│ │ └── uv.lock
│ ├── mcp-integration-with-nova-canvas
│ │ ├── .env.example
│ │ ├── .python-version
│ │ ├── clients
│ │ │ └── client_server.py
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── user_interfaces
│ │ │ └── image_generator_st.py
│ │ └── uv.lock
│ ├── README.md
│ └── stepfunctions-tool-mcp-server
│ ├── README.md
│ └── sample_state_machines
│ ├── customer-create
│ │ └── app.py
│ ├── customer-id-from-email
│ │ └── app.py
│ ├── customer-info-from-id
│ │ └── app.py
│ └── template.yml
├── scripts
│ ├── README.md
│ └── verify_package_name.py
├── src
│ ├── amazon-bedrock-agentcore-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── amazon_bedrock_agentcore_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── config.py
│ │ │ ├── server.py
│ │ │ └── utils
│ │ │ ├── __init__.py
│ │ │ ├── cache.py
│ │ │ ├── doc_fetcher.py
│ │ │ ├── indexer.py
│ │ │ ├── text_processor.py
│ │ │ └── url_validator.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── SECURITY.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── test_cache.py
│ │ │ ├── test_config.py
│ │ │ ├── test_doc_fetcher.py
│ │ │ ├── test_indexer.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_server.py
│ │ │ ├── test_text_processor.py
│ │ │ └── test_url_validator.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── amazon-kendra-index-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── amazon_kendra_index_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── server.py
│ │ │ └── util.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── amazon-keyspaces-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── amazon_keyspaces_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── client.py
│ │ │ ├── config.py
│ │ │ ├── consts.py
│ │ │ ├── llm_context.py
│ │ │ ├── models.py
│ │ │ ├── server.py
│ │ │ └── services.py
│ │ ├── CHANGELOG.md
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── run_tests.sh
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── test_client.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_query_analysis_service.py
│ │ │ ├── test_server.py
│ │ │ └── test_services.py
│ │ └── uv.lock
│ ├── amazon-mq-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── amazon_mq_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── aws_service_mcp_generator.py
│ │ │ ├── consts.py
│ │ │ ├── rabbitmq
│ │ │ │ ├── __init__.py
│ │ │ │ ├── admin.py
│ │ │ │ ├── connection.py
│ │ │ │ ├── doc
│ │ │ │ │ ├── rabbitmq_broker_sizing_guide.md
│ │ │ │ │ ├── rabbitmq_performance_optimization_best_practice.md
│ │ │ │ │ ├── rabbitmq_production_deployment_guidelines.md
│ │ │ │ │ ├── rabbitmq_quorum_queue_migration_guide.md
│ │ │ │ │ └── rabbitmq_setup_best_practice.md
│ │ │ │ ├── handlers.py
│ │ │ │ └── module.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── example
│ │ │ └── sample_mcp_q_cli.json
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── .gitignore
│ │ │ ├── rabbitmq
│ │ │ │ ├── __init__.py
│ │ │ │ ├── conftest.py
│ │ │ │ ├── test_admin.py
│ │ │ │ ├── test_connection.py
│ │ │ │ ├── test_handlers.py
│ │ │ │ └── test_module.py
│ │ │ ├── test_aws_service_mcp_generator.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── amazon-neptune-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── amazon_neptune_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── exceptions.py
│ │ │ ├── graph_store
│ │ │ │ ├── __init__.py
│ │ │ │ ├── analytics.py
│ │ │ │ ├── base.py
│ │ │ │ └── database.py
│ │ │ ├── models.py
│ │ │ ├── neptune.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── test_analytics.py
│ │ │ ├── test_database.py
│ │ │ ├── test_exceptions.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_models.py
│ │ │ ├── test_neptune.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── amazon-qbusiness-anonymous-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── amazon_qbusiness_anonymous_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── clients.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── amazon-qindex-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── amazon_qindex_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── clients.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_clients.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ └── test_server.py
│ │ └── uv.lock
│ ├── amazon-sns-sqs-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── amazon_sns_sqs_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── common.py
│ │ │ ├── consts.py
│ │ │ ├── generator.py
│ │ │ ├── server.py
│ │ │ ├── sns.py
│ │ │ └── sqs.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── print_tools.py
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── run_tests.sh
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── .gitignore
│ │ │ ├── README.md
│ │ │ ├── test_common.py
│ │ │ ├── test_generator.py
│ │ │ ├── test_server.py
│ │ │ ├── test_sns.py
│ │ │ └── test_sqs.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aurora-dsql-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aurora_dsql_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── consts.py
│ │ │ ├── mutable_sql_detector.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_connection_reuse.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_profile_option.py
│ │ │ ├── test_readonly_enforcement.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-api-mcp-server
│ │ ├── .gitattributes
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_api_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── core
│ │ │ │ ├── __init__.py
│ │ │ │ ├── agent_scripts
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── manager.py
│ │ │ │ │ ├── models.py
│ │ │ │ │ └── registry
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── application-failure-troubleshooting.script.md
│ │ │ │ │ ├── cloudtral-mutli-region-setup.script.md
│ │ │ │ │ ├── create_amazon_aurora_db_cluster_with_instances.script.md
│ │ │ │ │ ├── lambda-timeout-debugging.script.md
│ │ │ │ │ ├── scripts_format.md
│ │ │ │ │ └── troubleshoot-permissions-with-cloudtrail-events.script.md
│ │ │ │ ├── aws
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── driver.py
│ │ │ │ │ ├── pagination.py
│ │ │ │ │ ├── regions.py
│ │ │ │ │ ├── service.py
│ │ │ │ │ └── services.py
│ │ │ │ ├── common
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── command_metadata.py
│ │ │ │ │ ├── command.py
│ │ │ │ │ ├── config.py
│ │ │ │ │ ├── errors.py
│ │ │ │ │ ├── file_operations.py
│ │ │ │ │ ├── file_system_controls.py
│ │ │ │ │ ├── helpers.py
│ │ │ │ │ ├── models.py
│ │ │ │ │ └── py.typed
│ │ │ │ ├── data
│ │ │ │ │ └── api_metadata.json
│ │ │ │ ├── metadata
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ └── read_only_operations_list.py
│ │ │ │ ├── parser
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── custom_validators
│ │ │ │ │ │ ├── __init__.py
│ │ │ │ │ │ ├── botocore_param_validator.py
│ │ │ │ │ │ ├── ec2_validator.py
│ │ │ │ │ │ └── ssm_validator.py
│ │ │ │ │ ├── interpretation.py
│ │ │ │ │ ├── lexer.py
│ │ │ │ │ └── parser.py
│ │ │ │ ├── py.typed
│ │ │ │ └── security
│ │ │ │ ├── __init__.py
│ │ │ │ ├── aws_api_customization.json
│ │ │ │ └── policy.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── CONTRIBUTING.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── agent_scripts
│ │ │ │ ├── __init__.py
│ │ │ │ ├── test_manager.py
│ │ │ │ └── test_registry
│ │ │ │ ├── another_valid_script.script.md
│ │ │ │ ├── test_script.script.md
│ │ │ │ └── valid_script.script.md
│ │ │ ├── aws
│ │ │ │ ├── __init__.py
│ │ │ │ ├── test_driver.py
│ │ │ │ ├── test_pagination.py
│ │ │ │ ├── test_service.py
│ │ │ │ └── test_services.py
│ │ │ ├── common
│ │ │ │ ├── test_command.py
│ │ │ │ ├── test_config.py
│ │ │ │ ├── test_file_operations.py
│ │ │ │ ├── test_file_system_controls.py
│ │ │ │ ├── test_file_validation.py
│ │ │ │ └── test_helpers.py
│ │ │ ├── fixtures.py
│ │ │ ├── history_handler.py
│ │ │ ├── metadata
│ │ │ │ ├── __init__.py
│ │ │ │ └── test_read_only_operations_list.py
│ │ │ ├── parser
│ │ │ │ ├── __init__.py
│ │ │ │ ├── test_file_path_detection.py
│ │ │ │ ├── test_lexer.py
│ │ │ │ ├── test_parser_customizations.py
│ │ │ │ └── test_parser.py
│ │ │ ├── test_security_policy.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-appsync-mcp-server
│ │ ├── .dockerignore
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_appsync_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── decorators.py
│ │ │ ├── helpers.py
│ │ │ ├── operations
│ │ │ │ ├── __init__.py
│ │ │ │ ├── create_api_cache.py
│ │ │ │ ├── create_api_key.py
│ │ │ │ ├── create_api.py
│ │ │ │ ├── create_channel_namespace.py
│ │ │ │ ├── create_datasource.py
│ │ │ │ ├── create_domain_name.py
│ │ │ │ ├── create_function.py
│ │ │ │ ├── create_graphql_api.py
│ │ │ │ ├── create_resolver.py
│ │ │ │ └── create_schema.py
│ │ │ ├── server.py
│ │ │ ├── tools
│ │ │ │ ├── __init__.py
│ │ │ │ ├── create_api_cache.py
│ │ │ │ ├── create_api_key.py
│ │ │ │ ├── create_api.py
│ │ │ │ ├── create_channel_namespace.py
│ │ │ │ ├── create_datasource.py
│ │ │ │ ├── create_domain_name.py
│ │ │ │ ├── create_function.py
│ │ │ │ ├── create_graphql_api.py
│ │ │ │ ├── create_resolver.py
│ │ │ │ └── create_schema.py
│ │ │ └── validators.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── test_all_create_tools_write_protection.py
│ │ │ ├── test_create_api_cache.py
│ │ │ ├── test_create_api_key.py
│ │ │ ├── test_create_api.py
│ │ │ ├── test_create_channel_namespace.py
│ │ │ ├── test_create_datasource_tool.py
│ │ │ ├── test_create_datasource.py
│ │ │ ├── test_create_domain_name.py
│ │ │ ├── test_create_function.py
│ │ │ ├── test_create_graphql_api.py
│ │ │ ├── test_create_resolver.py
│ │ │ ├── test_create_schema_tool.py
│ │ │ ├── test_create_schema.py
│ │ │ ├── test_helpers.py
│ │ │ ├── test_server.py
│ │ │ ├── test_validators.py
│ │ │ └── test_write_operation.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-bedrock-custom-model-import-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_bedrock_custom_model_import_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── client.py
│ │ │ ├── llm_context.py
│ │ │ ├── models.py
│ │ │ ├── prompts.py
│ │ │ ├── server.py
│ │ │ ├── services
│ │ │ │ ├── __init__.py
│ │ │ │ ├── imported_model_service.py
│ │ │ │ └── model_import_service.py
│ │ │ ├── tools
│ │ │ │ ├── create_model_import_job.py
│ │ │ │ ├── delete_imported_model.py
│ │ │ │ ├── get_imported_model.py
│ │ │ │ ├── get_model_import_job.py
│ │ │ │ ├── list_imported_models.py
│ │ │ │ └── list_model_import_jobs.py
│ │ │ └── utils
│ │ │ ├── __init__.py
│ │ │ ├── aws.py
│ │ │ ├── config.py
│ │ │ ├── consts.py
│ │ │ └── matching.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── services
│ │ │ │ ├── test_imported_model_service.py
│ │ │ │ └── test_model_import_service.py
│ │ │ ├── test_client.py
│ │ │ ├── test_init.py
│ │ │ ├── test_llm_context.py
│ │ │ ├── test_prompts.py
│ │ │ ├── test_server.py
│ │ │ ├── tools
│ │ │ │ ├── test_create_model_import_job.py
│ │ │ │ ├── test_delete_imported_model.py
│ │ │ │ ├── test_get_imported_model.py
│ │ │ │ ├── test_get_model_import_job.py
│ │ │ │ ├── test_list_imported_models.py
│ │ │ │ └── test_list_model_import_jobs.py
│ │ │ └── utils
│ │ │ ├── test_aws.py
│ │ │ ├── test_config.py
│ │ │ └── test_matching.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-bedrock-data-automation-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_bedrock_data_automation_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── helpers.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── test_helpers.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-dataprocessing-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_dataprocessing_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── core
│ │ │ │ ├── __init__.py
│ │ │ │ └── glue_data_catalog
│ │ │ │ ├── __init__.py
│ │ │ │ ├── data_catalog_database_manager.py
│ │ │ │ ├── data_catalog_handler.py
│ │ │ │ └── data_catalog_table_manager.py
│ │ │ ├── handlers
│ │ │ │ ├── __init__.py
│ │ │ │ ├── athena
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── athena_data_catalog_handler.py
│ │ │ │ │ ├── athena_query_handler.py
│ │ │ │ │ └── athena_workgroup_handler.py
│ │ │ │ ├── commons
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ └── common_resource_handler.py
│ │ │ │ ├── emr
│ │ │ │ │ ├── emr_ec2_cluster_handler.py
│ │ │ │ │ ├── emr_ec2_instance_handler.py
│ │ │ │ │ └── emr_ec2_steps_handler.py
│ │ │ │ └── glue
│ │ │ │ ├── __init__.py
│ │ │ │ ├── crawler_handler.py
│ │ │ │ ├── data_catalog_handler.py
│ │ │ │ ├── glue_commons_handler.py
│ │ │ │ ├── glue_etl_handler.py
│ │ │ │ ├── interactive_sessions_handler.py
│ │ │ │ └── worklows_handler.py
│ │ │ ├── models
│ │ │ │ ├── __init__.py
│ │ │ │ ├── athena_models.py
│ │ │ │ ├── common_resource_models.py
│ │ │ │ ├── data_catalog_models.py
│ │ │ │ ├── emr_models.py
│ │ │ │ └── glue_models.py
│ │ │ ├── server.py
│ │ │ └── utils
│ │ │ ├── __init__.py
│ │ │ ├── aws_helper.py
│ │ │ ├── consts.py
│ │ │ ├── logging_helper.py
│ │ │ └── sql_analyzer.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── core
│ │ │ │ ├── __init__.py
│ │ │ │ └── glue_data_catalog
│ │ │ │ ├── __init__.py
│ │ │ │ ├── test_data_catalog_database_manager.py
│ │ │ │ ├── test_data_catalog_handler.py
│ │ │ │ └── test_data_catalog_table_manager.py
│ │ │ ├── handlers
│ │ │ │ ├── __init__.py
│ │ │ │ ├── athena
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── test_athena_data_catalog_handler.py
│ │ │ │ │ ├── test_athena_query_handler.py
│ │ │ │ │ ├── test_athena_workgroup_handler.py
│ │ │ │ │ └── test_custom_tags_athena.py
│ │ │ │ ├── commons
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ └── test_common_resource_handler.py
│ │ │ │ ├── emr
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── test_custom_tags_emr.py
│ │ │ │ │ ├── test_emr_ec2_cluster_handler.py
│ │ │ │ │ ├── test_emr_ec2_instance_handler.py
│ │ │ │ │ └── test_emr_ec2_steps_handler.py
│ │ │ │ └── glue
│ │ │ │ ├── __init__.py
│ │ │ │ ├── test_crawler_handler.py
│ │ │ │ ├── test_custom_tags_glue.py
│ │ │ │ ├── test_data_catalog_handler.py
│ │ │ │ ├── test_glue_commons_handler.py
│ │ │ │ ├── test_glue_etl_handler.py
│ │ │ │ ├── test_glue_interactive_sessions_handler.py
│ │ │ │ └── test_glue_workflows_handler.py
│ │ │ ├── models
│ │ │ │ ├── __init__.py
│ │ │ │ ├── test_athena_models.py
│ │ │ │ ├── test_common_resource_models.py
│ │ │ │ ├── test_data_catalog_models.py
│ │ │ │ ├── test_emr_models.py
│ │ │ │ ├── test_glue_models.py
│ │ │ │ ├── test_interactive_sessions_models.py
│ │ │ │ └── test_workflows_models.py
│ │ │ ├── test_init.py
│ │ │ ├── test_server.py
│ │ │ └── utils
│ │ │ ├── __init__.py
│ │ │ ├── test_aws_helper.py
│ │ │ ├── test_custom_tags.py
│ │ │ ├── test_logging_helper.py
│ │ │ └── test_sql_analyzer.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-diagram-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_diagram_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── diagrams_tools.py
│ │ │ ├── models.py
│ │ │ ├── scanner.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── .gitignore
│ │ │ ├── conftest.py
│ │ │ ├── README.md
│ │ │ ├── resources
│ │ │ │ ├── __init__.py
│ │ │ │ └── example_diagrams
│ │ │ │ ├── __init__.py
│ │ │ │ ├── aws_example.py
│ │ │ │ ├── flow_example.py
│ │ │ │ └── sequence_example.py
│ │ │ ├── test_diagrams.py
│ │ │ ├── test_models.py
│ │ │ ├── test_sarif_fix.py
│ │ │ ├── test_scanner.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-documentation-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_documentation_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── models.py
│ │ │ ├── server_aws_cn.py
│ │ │ ├── server_aws.py
│ │ │ ├── server_utils.py
│ │ │ ├── server.py
│ │ │ └── util.py
│ │ ├── basic-usage.gif
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── constants.py
│ │ │ ├── resources
│ │ │ │ └── lambda_sns_raw.html
│ │ │ ├── test_aws_cn_get_available_services_live.py
│ │ │ ├── test_aws_cn_read_documentation_live.py
│ │ │ ├── test_aws_read_documentation_live.py
│ │ │ ├── test_aws_recommend_live.py
│ │ │ ├── test_aws_search_live.py
│ │ │ ├── test_metadata_handling.py
│ │ │ ├── test_models.py
│ │ │ ├── test_server_aws_cn.py
│ │ │ ├── test_server_aws.py
│ │ │ ├── test_server_utils.py
│ │ │ ├── test_server.py
│ │ │ └── test_util.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-healthomics-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_healthomics_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── consts.py
│ │ │ ├── models.py
│ │ │ ├── server.py
│ │ │ ├── tools
│ │ │ │ ├── __init__.py
│ │ │ │ ├── helper_tools.py
│ │ │ │ ├── run_analysis.py
│ │ │ │ ├── troubleshooting.py
│ │ │ │ ├── workflow_analysis.py
│ │ │ │ ├── workflow_execution.py
│ │ │ │ ├── workflow_linting.py
│ │ │ │ └── workflow_management.py
│ │ │ └── utils
│ │ │ ├── __init__.py
│ │ │ ├── aws_utils.py
│ │ │ ├── s3_utils.py
│ │ │ └── validation_utils.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── docs
│ │ │ └── workflow_linting.md
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── conftest.py
│ │ │ ├── test_aws_utils.py
│ │ │ ├── test_consts.py
│ │ │ ├── test_helper_tools.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_models.py
│ │ │ ├── test_run_analysis.py
│ │ │ ├── test_s3_utils.py
│ │ │ ├── test_server.py
│ │ │ ├── test_troubleshooting.py
│ │ │ ├── test_workflow_analysis.py
│ │ │ ├── test_workflow_execution.py
│ │ │ ├── test_workflow_linting.py
│ │ │ ├── test_workflow_management.py
│ │ │ └── test_workflow_tools.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-iot-sitewise-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_iot_sitewise_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── client.py
│ │ │ ├── models.py
│ │ │ ├── prompts
│ │ │ │ ├── __init__.py
│ │ │ │ ├── asset_hierarchy.py
│ │ │ │ ├── bulk_import_workflow.py
│ │ │ │ ├── data_exploration.py
│ │ │ │ └── data_ingestion.py
│ │ │ ├── server.py
│ │ │ ├── tool_metadata.py
│ │ │ ├── tools
│ │ │ │ ├── __init__.py
│ │ │ │ ├── sitewise_access.py
│ │ │ │ ├── sitewise_asset_models.py
│ │ │ │ ├── sitewise_assets.py
│ │ │ │ ├── sitewise_data.py
│ │ │ │ ├── sitewise_gateways.py
│ │ │ │ └── sitewise_metadata_transfer.py
│ │ │ └── validation.py
│ │ ├── CHANGELOG.md
│ │ ├── DEVELOPMENT.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── examples
│ │ │ └── wind_farm_example.py
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── run_server.py
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── test_client.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_models.py
│ │ │ ├── test_server.py
│ │ │ ├── test_sitewise_access.py
│ │ │ ├── test_sitewise_asset_models.py
│ │ │ ├── test_sitewise_assets.py
│ │ │ ├── test_sitewise_data.py
│ │ │ ├── test_sitewise_gateways.py
│ │ │ ├── test_sitewise_metadata_transfer.py
│ │ │ └── test_validation.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-knowledge-mcp-server
│ │ └── README.md
│ ├── aws-location-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_location_server
│ │ │ ├── __init__.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── test_server_integration.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-msk-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_msk_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── server.py
│ │ │ └── tools
│ │ │ ├── __init__.py
│ │ │ ├── common_functions
│ │ │ │ ├── __init__.py
│ │ │ │ ├── client_manager.py
│ │ │ │ └── common_functions.py
│ │ │ ├── logs_and_telemetry
│ │ │ │ ├── __init__.py
│ │ │ │ ├── cluster_metrics_tools.py
│ │ │ │ ├── list_customer_iam_access.py
│ │ │ │ └── metric_config.py
│ │ │ ├── mutate_cluster
│ │ │ │ ├── __init__.py
│ │ │ │ ├── batch_associate_scram_secret.py
│ │ │ │ ├── batch_disassociate_scram_secret.py
│ │ │ │ ├── create_cluster_v2.py
│ │ │ │ ├── put_cluster_policy.py
│ │ │ │ ├── reboot_broker.py
│ │ │ │ ├── update_broker_count.py
│ │ │ │ ├── update_broker_storage.py
│ │ │ │ ├── update_broker_type.py
│ │ │ │ ├── update_cluster_configuration.py
│ │ │ │ ├── update_monitoring.py
│ │ │ │ └── update_security.py
│ │ │ ├── mutate_config
│ │ │ │ ├── __init__.py
│ │ │ │ ├── create_configuration.py
│ │ │ │ ├── tag_resource.py
│ │ │ │ ├── untag_resource.py
│ │ │ │ └── update_configuration.py
│ │ │ ├── mutate_vpc
│ │ │ │ ├── __init__.py
│ │ │ │ ├── create_vpc_connection.py
│ │ │ │ ├── delete_vpc_connection.py
│ │ │ │ └── reject_client_vpc_connection.py
│ │ │ ├── read_cluster
│ │ │ │ ├── __init__.py
│ │ │ │ ├── describe_cluster_operation.py
│ │ │ │ ├── describe_cluster.py
│ │ │ │ ├── get_bootstrap_brokers.py
│ │ │ │ ├── get_cluster_policy.py
│ │ │ │ ├── get_compatible_kafka_versions.py
│ │ │ │ ├── list_client_vpc_connections.py
│ │ │ │ ├── list_cluster_operations.py
│ │ │ │ ├── list_nodes.py
│ │ │ │ └── list_scram_secrets.py
│ │ │ ├── read_config
│ │ │ │ ├── __init__.py
│ │ │ │ ├── describe_configuration_revision.py
│ │ │ │ ├── describe_configuration.py
│ │ │ │ ├── list_configuration_revisions.py
│ │ │ │ └── list_tags_for_resource.py
│ │ │ ├── read_global
│ │ │ │ ├── __init__.py
│ │ │ │ ├── list_clusters.py
│ │ │ │ ├── list_configurations.py
│ │ │ │ ├── list_kafka_versions.py
│ │ │ │ └── list_vpc_connections.py
│ │ │ ├── read_vpc
│ │ │ │ ├── __init__.py
│ │ │ │ └── describe_vpc_connection.py
│ │ │ └── static_tools
│ │ │ ├── __init__.py
│ │ │ └── cluster_best_practices.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_client_manager.py
│ │ │ ├── test_cluster_metrics_tools.py
│ │ │ ├── test_common_functions.py
│ │ │ ├── test_create_cluster_v2.py
│ │ │ ├── test_create_configuration.py
│ │ │ ├── test_create_vpc_connection.py
│ │ │ ├── test_delete_vpc_connection.py
│ │ │ ├── test_describe_cluster_operation.py
│ │ │ ├── test_describe_cluster.py
│ │ │ ├── test_describe_configuration_revision.py
│ │ │ ├── test_describe_configuration.py
│ │ │ ├── test_describe_vpc_connection.py
│ │ │ ├── test_get_bootstrap_brokers.py
│ │ │ ├── test_get_cluster_policy.py
│ │ │ ├── test_get_compatible_kafka_versions.py
│ │ │ ├── test_init.py
│ │ │ ├── test_list_client_vpc_connections.py
│ │ │ ├── test_list_cluster_operations.py
│ │ │ ├── test_list_clusters.py
│ │ │ ├── test_list_configuration_revisions.py
│ │ │ ├── test_list_configurations.py
│ │ │ ├── test_list_customer_iam_access.py
│ │ │ ├── test_list_kafka_versions.py
│ │ │ ├── test_list_nodes.py
│ │ │ ├── test_list_scram_secrets.py
│ │ │ ├── test_list_tags_for_resource.py
│ │ │ ├── test_list_vpc_connections.py
│ │ │ ├── test_logs_and_telemetry.py
│ │ │ ├── test_main.py
│ │ │ ├── test_mutate_cluster_init.py
│ │ │ ├── test_mutate_cluster_success_cases.py
│ │ │ ├── test_mutate_cluster.py
│ │ │ ├── test_mutate_config_init.py
│ │ │ ├── test_mutate_vpc_init.py
│ │ │ ├── test_read_cluster_init_updated.py
│ │ │ ├── test_read_cluster_init.py
│ │ │ ├── test_read_config_init.py
│ │ │ ├── test_read_global_init.py
│ │ │ ├── test_read_vpc_init.py
│ │ │ ├── test_reject_client_vpc_connection.py
│ │ │ ├── test_server.py
│ │ │ ├── test_static_tools_init.py
│ │ │ ├── test_tag_resource.py
│ │ │ ├── test_tool_descriptions.py
│ │ │ ├── test_untag_resource.py
│ │ │ └── test_update_configuration.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-pricing-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_pricing_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── cdk_analyzer.py
│ │ │ ├── consts.py
│ │ │ ├── helpers.py
│ │ │ ├── models.py
│ │ │ ├── pricing_client.py
│ │ │ ├── pricing_transformer.py
│ │ │ ├── report_generator.py
│ │ │ ├── server.py
│ │ │ ├── static
│ │ │ │ ├── __init__.py
│ │ │ │ ├── COST_REPORT_TEMPLATE.md
│ │ │ │ └── patterns
│ │ │ │ ├── __init__.py
│ │ │ │ └── BEDROCK.md
│ │ │ └── terraform_analyzer.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── test_cdk_analyzer.py
│ │ │ ├── test_helpers.py
│ │ │ ├── test_pricing_client.py
│ │ │ ├── test_pricing_transformer.py
│ │ │ ├── test_report_generator.py
│ │ │ ├── test_server.py
│ │ │ └── test_terraform_analyzer.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-serverless-mcp-server
│ │ ├── .pre-commit.config.yaml
│ │ ├── .python-version
│ │ ├── .secrets.baseline
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_serverless_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── models.py
│ │ │ ├── resources
│ │ │ │ ├── __init__.py
│ │ │ │ ├── deployment_details.py
│ │ │ │ ├── deployment_list.py
│ │ │ │ ├── template_details.py
│ │ │ │ └── template_list.py
│ │ │ ├── server.py
│ │ │ ├── template
│ │ │ │ ├── __init__.py
│ │ │ │ ├── registry.py
│ │ │ │ ├── renderer.py
│ │ │ │ └── templates
│ │ │ │ ├── backend.j2
│ │ │ │ ├── frontend.j2
│ │ │ │ ├── fullstack.j2
│ │ │ │ └── README.md
│ │ │ ├── templates
│ │ │ │ ├── __init__.py
│ │ │ │ └── iam_policies.py
│ │ │ ├── tools
│ │ │ │ ├── common
│ │ │ │ │ └── base_tool.py
│ │ │ │ ├── esm
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── esm_diagnosis.py
│ │ │ │ │ ├── esm_guidance.py
│ │ │ │ │ ├── esm_recommend.py
│ │ │ │ │ └── secure_esm_guidance.py
│ │ │ │ ├── guidance
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── deploy_serverless_app_help.py
│ │ │ │ │ ├── get_iac_guidance.py
│ │ │ │ │ ├── get_lambda_event_schemas.py
│ │ │ │ │ ├── get_lambda_guidance.py
│ │ │ │ │ └── get_serverless_templates.py
│ │ │ │ ├── poller
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── esm_diagnosis.py
│ │ │ │ │ ├── esm_guidance.py
│ │ │ │ │ └── esm_recommend.py
│ │ │ │ ├── sam
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── sam_build.py
│ │ │ │ │ ├── sam_deploy.py
│ │ │ │ │ ├── sam_init.py
│ │ │ │ │ ├── sam_local_invoke.py
│ │ │ │ │ └── sam_logs.py
│ │ │ │ ├── schemas
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── describe_schema.py
│ │ │ │ │ ├── list_registries.py
│ │ │ │ │ └── search_schema.py
│ │ │ │ └── webapps
│ │ │ │ ├── __init__.py
│ │ │ │ ├── configure_domain.py
│ │ │ │ ├── deploy_webapp.py
│ │ │ │ ├── get_metrics.py
│ │ │ │ ├── update_webapp_frontend.py
│ │ │ │ ├── utils
│ │ │ │ │ ├── deploy_service.py
│ │ │ │ │ ├── frontend_uploader.py
│ │ │ │ │ └── startup_script_generator.py
│ │ │ │ └── webapp_deployment_help.py
│ │ │ └── utils
│ │ │ ├── __init__.py
│ │ │ ├── aws_client_helper.py
│ │ │ ├── cloudformation.py
│ │ │ ├── const.py
│ │ │ ├── data_scrubber.py
│ │ │ ├── deployment_manager.py
│ │ │ ├── github.py
│ │ │ └── process.py
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── README.md
│ │ │ ├── test_cloudformation.py
│ │ │ ├── test_configure_domain.py
│ │ │ ├── test_data_scrubber.py
│ │ │ ├── test_deploy_serverless_app_help.py
│ │ │ ├── test_deploy_service.py
│ │ │ ├── test_deploy_webapp.py
│ │ │ ├── test_deployment_details.py
│ │ │ ├── test_deployment_help.py
│ │ │ ├── test_deployment_list.py
│ │ │ ├── test_deployment_manager.py
│ │ │ ├── test_esm_diagnosis.py
│ │ │ ├── test_esm_guidance.py
│ │ │ ├── test_esm_recommend.py
│ │ │ ├── test_frontend_uploader.py
│ │ │ ├── test_get_iac_guidance.py
│ │ │ ├── test_get_lambda_event_schemas.py
│ │ │ ├── test_get_lambda_guidance.py
│ │ │ ├── test_get_metrics.py
│ │ │ ├── test_get_serverless_templates.py
│ │ │ ├── test_github.py
│ │ │ ├── test_iam_policies.py
│ │ │ ├── test_models.py
│ │ │ ├── test_process.py
│ │ │ ├── test_sam_build.py
│ │ │ ├── test_sam_deploy.py
│ │ │ ├── test_sam_init.py
│ │ │ ├── test_sam_local_invoke.py
│ │ │ ├── test_sam_logs.py
│ │ │ ├── test_schemas.py
│ │ │ ├── test_secure_esm_guidance.py
│ │ │ ├── test_server.py
│ │ │ ├── test_startup_script_generator.py
│ │ │ ├── test_template_details.py
│ │ │ ├── test_template_list.py
│ │ │ ├── test_template_registry.py
│ │ │ ├── test_template_renderer.py
│ │ │ └── test_update_webapp_frontend.py
│ │ └── uv.lock
│ ├── aws-support-mcp-server
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_support_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── client.py
│ │ │ ├── consts.py
│ │ │ ├── debug_helper.py
│ │ │ ├── errors.py
│ │ │ ├── formatters.py
│ │ │ ├── models.py
│ │ │ └── server.py
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftests.py
│ │ │ ├── test_aws_support_mcp_server.py
│ │ │ └── test_models.py
│ │ └── uv.lock
│ ├── bedrock-kb-retrieval-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── bedrock_kb_retrieval_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── knowledgebases
│ │ │ │ ├── __init__.py
│ │ │ │ ├── clients.py
│ │ │ │ ├── discovery.py
│ │ │ │ └── retrieval.py
│ │ │ ├── models.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── run_tests.sh
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── .gitignore
│ │ │ ├── conftest.py
│ │ │ ├── README.md
│ │ │ ├── test_clients.py
│ │ │ ├── test_discovery.py
│ │ │ ├── test_env_config.py
│ │ │ ├── test_models.py
│ │ │ ├── test_retrieval.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── billing-cost-management-mcp-server
│ │ ├── __init__.py
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── billing_cost_management_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── models.py
│ │ │ ├── prompts
│ │ │ │ ├── __init__.py
│ │ │ │ ├── decorator.py
│ │ │ │ ├── graviton_migration.py
│ │ │ │ ├── README.md
│ │ │ │ ├── savings_plans.py
│ │ │ │ └── types.py
│ │ │ ├── server.py
│ │ │ ├── templates
│ │ │ │ └── recommendation_templates
│ │ │ │ ├── ebs_volume.template
│ │ │ │ ├── ec2_asg.template
│ │ │ │ ├── ec2_instance.template
│ │ │ │ ├── ecs_service.template
│ │ │ │ ├── idle.template
│ │ │ │ ├── lambda_function.template
│ │ │ │ ├── rds_database.template
│ │ │ │ ├── reserved_instances.template
│ │ │ │ └── savings_plans.template
│ │ │ ├── tools
│ │ │ │ ├── __init__.py
│ │ │ │ ├── aws_pricing_operations.py
│ │ │ │ ├── aws_pricing_tools.py
│ │ │ │ ├── bcm_pricing_calculator_tools.py
│ │ │ │ ├── budget_tools.py
│ │ │ │ ├── compute_optimizer_tools.py
│ │ │ │ ├── cost_anomaly_tools.py
│ │ │ │ ├── cost_comparison_tools.py
│ │ │ │ ├── cost_explorer_operations.py
│ │ │ │ ├── cost_explorer_tools.py
│ │ │ │ ├── cost_optimization_hub_helpers.py
│ │ │ │ ├── cost_optimization_hub_tools.py
│ │ │ │ ├── free_tier_usage_tools.py
│ │ │ │ ├── recommendation_details_tools.py
│ │ │ │ ├── ri_performance_tools.py
│ │ │ │ ├── sp_performance_tools.py
│ │ │ │ ├── storage_lens_tools.py
│ │ │ │ └── unified_sql_tools.py
│ │ │ └── utilities
│ │ │ ├── __init__.py
│ │ │ ├── aws_service_base.py
│ │ │ ├── constants.py
│ │ │ ├── logging_utils.py
│ │ │ └── sql_utils.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── requirements.txt
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── prompts
│ │ │ │ ├── __init__.py
│ │ │ │ └── test_prompts.py
│ │ │ ├── README.md
│ │ │ ├── test_models.py
│ │ │ ├── test_server.py
│ │ │ ├── tools
│ │ │ │ ├── __init__.py
│ │ │ │ ├── fixtures.py
│ │ │ │ ├── test_aws_bcm_pricing_calculator_tools.py
│ │ │ │ ├── test_aws_pricing_tools.py
│ │ │ │ ├── test_budget_tools.py
│ │ │ │ ├── test_compute_optimizer_tools.py
│ │ │ │ ├── test_cost_anomaly_tools_enhanced.py
│ │ │ │ ├── test_cost_anomaly_tools.py
│ │ │ │ ├── test_cost_comparison_tools.py
│ │ │ │ ├── test_cost_explorer_operations.py
│ │ │ │ ├── test_cost_explorer_tools.py
│ │ │ │ ├── test_cost_optimization_hub_helpers.py
│ │ │ │ ├── test_cost_optimization_hub_tools.py
│ │ │ │ ├── test_free_tier_usage_tools_new.py
│ │ │ │ ├── test_recommendation_details_tools.py
│ │ │ │ ├── test_ri_performance_tools.py
│ │ │ │ ├── test_sp_performance_tools.py
│ │ │ │ ├── test_storage_lens_tools.py
│ │ │ │ └── test_unified_sql_tools.py
│ │ │ └── utilities
│ │ │ ├── test_aws_service_base.py
│ │ │ └── test_sql_utils.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── ccapi-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── ccapi_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── aws_client.py
│ │ │ ├── cloud_control_utils.py
│ │ │ ├── context.py
│ │ │ ├── errors.py
│ │ │ ├── iac_generator.py
│ │ │ ├── impl
│ │ │ │ ├── __init__.py
│ │ │ │ ├── tools
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── explanation.py
│ │ │ │ │ ├── infrastructure_generation.py
│ │ │ │ │ ├── resource_operations.py
│ │ │ │ │ ├── security_scanning.py
│ │ │ │ │ └── session_management.py
│ │ │ │ └── utils
│ │ │ │ ├── __init__.py
│ │ │ │ └── validation.py
│ │ │ ├── infrastructure_generator.py
│ │ │ ├── models
│ │ │ │ ├── __init__.py
│ │ │ │ └── models.py
│ │ │ ├── schema_manager.py
│ │ │ ├── server.py
│ │ │ └── static
│ │ │ └── __init__.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── run_tests.sh
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── test_aws_client.py
│ │ │ ├── test_checkov_install.py
│ │ │ ├── test_cloud_control_utils.py
│ │ │ ├── test_context.py
│ │ │ ├── test_errors.py
│ │ │ ├── test_explanation.py
│ │ │ ├── test_iac_generator.py
│ │ │ ├── test_infrastructure_generation.py
│ │ │ ├── test_infrastructure_generator.py
│ │ │ ├── test_models.py
│ │ │ ├── test_resource_operations.py
│ │ │ ├── test_schema_manager.py
│ │ │ ├── test_security_scanning.py
│ │ │ ├── test_server.py
│ │ │ ├── test_session_management.py
│ │ │ └── test_validation.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── cdk-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── cdk_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── core
│ │ │ │ ├── __init__.py
│ │ │ │ ├── resources.py
│ │ │ │ ├── search_utils.py
│ │ │ │ ├── server.py
│ │ │ │ └── tools.py
│ │ │ ├── data
│ │ │ │ ├── __init__.py
│ │ │ │ ├── cdk_nag_parser.py
│ │ │ │ ├── construct_descriptions.py
│ │ │ │ ├── genai_cdk_loader.py
│ │ │ │ ├── lambda_layer_parser.py
│ │ │ │ ├── lambda_powertools_loader.py
│ │ │ │ ├── schema_generator.py
│ │ │ │ └── solutions_constructs_parser.py
│ │ │ ├── server.py
│ │ │ └── static
│ │ │ ├── __init__.py
│ │ │ ├── CDK_GENERAL_GUIDANCE.md
│ │ │ ├── CDK_NAG_GUIDANCE.md
│ │ │ └── lambda_powertools
│ │ │ ├── bedrock.md
│ │ │ ├── cdk.md
│ │ │ ├── dependencies.md
│ │ │ ├── index.md
│ │ │ ├── insights.md
│ │ │ ├── logging.md
│ │ │ ├── metrics.md
│ │ │ └── tracing.md
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── core
│ │ │ │ ├── test_resources_enhanced.py
│ │ │ │ ├── test_resources.py
│ │ │ │ ├── test_search_utils.py
│ │ │ │ ├── test_server.py
│ │ │ │ └── test_tools.py
│ │ │ └── data
│ │ │ ├── test_cdk_nag_parser.py
│ │ │ ├── test_genai_cdk_loader.py
│ │ │ ├── test_lambda_powertools_loader.py
│ │ │ ├── test_schema_generator.py
│ │ │ └── test_solutions_constructs_parser.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── cfn-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── cfn_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── aws_client.py
│ │ │ ├── cloud_control_utils.py
│ │ │ ├── context.py
│ │ │ ├── errors.py
│ │ │ ├── iac_generator.py
│ │ │ ├── schema_manager.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── run_tests.sh
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── test_aws_client.py
│ │ │ ├── test_cloud_control_utils.py
│ │ │ ├── test_errors.py
│ │ │ ├── test_iac_generator.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_schema_manager.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── cloudtrail-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── cloudtrail_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── common.py
│ │ │ ├── models.py
│ │ │ ├── server.py
│ │ │ └── tools.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_models.py
│ │ │ ├── test_server.py
│ │ │ └── test_tools.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── cloudwatch-appsignals-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── cloudwatch_appsignals_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── audit_presentation_utils.py
│ │ │ ├── audit_utils.py
│ │ │ ├── aws_clients.py
│ │ │ ├── canary_utils.py
│ │ │ ├── server.py
│ │ │ ├── service_audit_utils.py
│ │ │ ├── service_tools.py
│ │ │ ├── sli_report_client.py
│ │ │ ├── slo_tools.py
│ │ │ ├── trace_tools.py
│ │ │ └── utils.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── conftest.py
│ │ │ ├── test_audit_presentation_utils.py
│ │ │ ├── test_audit_utils.py
│ │ │ ├── test_aws_profile.py
│ │ │ ├── test_canary_utils.py
│ │ │ ├── test_initialization.py
│ │ │ ├── test_server_audit_functions.py
│ │ │ ├── test_server_audit_tools.py
│ │ │ ├── test_server.py
│ │ │ ├── test_service_audit_utils.py
│ │ │ ├── test_service_tools_operations.py
│ │ │ ├── test_sli_report_client.py
│ │ │ ├── test_slo_tools.py
│ │ │ └── test_utils.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── cloudwatch-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── cloudwatch_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── cloudwatch_alarms
│ │ │ │ ├── models.py
│ │ │ │ └── tools.py
│ │ │ ├── cloudwatch_logs
│ │ │ │ ├── models.py
│ │ │ │ └── tools.py
│ │ │ ├── cloudwatch_metrics
│ │ │ │ ├── data
│ │ │ │ │ └── metric_metadata.json
│ │ │ │ ├── models.py
│ │ │ │ └── tools.py
│ │ │ ├── common.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── cloudwatch_alarms
│ │ │ │ ├── test_active_alarms.py
│ │ │ │ ├── test_alarm_history_integration.py
│ │ │ │ ├── test_alarm_history.py
│ │ │ │ └── test_alarms_error_handling.py
│ │ │ ├── cloudwatch_logs
│ │ │ │ ├── test_logs_error_handling.py
│ │ │ │ ├── test_logs_models.py
│ │ │ │ └── test_logs_server.py
│ │ │ ├── cloudwatch_metrics
│ │ │ │ ├── test_metrics_error_handling.py
│ │ │ │ ├── test_metrics_models.py
│ │ │ │ ├── test_metrics_server.py
│ │ │ │ └── test_validation_error.py
│ │ │ ├── test_common_and_server.py
│ │ │ ├── test_init.py
│ │ │ └── test_main.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── code-doc-gen-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── code_doc_gen_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── server.py
│ │ │ └── utils
│ │ │ ├── doc_generator.py
│ │ │ ├── models.py
│ │ │ ├── repomix_manager.py
│ │ │ └── templates.py
│ │ ├── CHANGELOG.md
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_doc_generator_edge_cases.py
│ │ │ ├── test_doc_generator.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_repomix_manager_scenarios.py
│ │ │ ├── test_repomix_manager.py
│ │ │ ├── test_repomix_statistics.py
│ │ │ ├── test_server_extended.py
│ │ │ ├── test_server.py
│ │ │ └── test_templates.py
│ │ └── uv.lock
│ ├── core-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── core_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── server.py
│ │ │ └── static
│ │ │ ├── __init__.py
│ │ │ └── PROMPT_UNDERSTANDING.md
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── README.md
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_response_types.py
│ │ │ ├── test_server.py
│ │ │ └── test_static.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── cost-explorer-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── cost_explorer_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── comparison_handler.py
│ │ │ ├── constants.py
│ │ │ ├── cost_usage_handler.py
│ │ │ ├── forecasting_handler.py
│ │ │ ├── helpers.py
│ │ │ ├── metadata_handler.py
│ │ │ ├── models.py
│ │ │ ├── server.py
│ │ │ └── utility_handler.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── test_comparison_handler.py
│ │ │ ├── test_cost_usage_handler.py
│ │ │ ├── test_forecasting_handler.py
│ │ │ ├── test_helpers.py
│ │ │ ├── test_metadata_handler.py
│ │ │ ├── test_models.py
│ │ │ ├── test_server.py
│ │ │ └── test_utility_handler.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── documentdb-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ └── documentdb_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── analytic_tools.py
│ │ │ ├── config.py
│ │ │ ├── connection_tools.py
│ │ │ ├── db_management_tools.py
│ │ │ ├── query_tools.py
│ │ │ ├── server.py
│ │ │ └── write_tools.py
│ │ ├── CHANGELOG.md
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── conftest.py
│ │ │ ├── test_analytic_tools.py
│ │ │ ├── test_connection_tools.py
│ │ │ ├── test_db_management_tools.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_query_tools.py
│ │ │ └── test_write_tools.py
│ │ └── uv.lock
│ ├── dynamodb-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── dynamodb_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── common.py
│ │ │ ├── database_analysis_queries.py
│ │ │ ├── database_analyzers.py
│ │ │ ├── prompts
│ │ │ │ └── dynamodb_architect.md
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── evals
│ │ │ │ ├── dynamic_evaluators.py
│ │ │ │ ├── evaluation_registry.py
│ │ │ │ ├── logging_config.py
│ │ │ │ ├── multiturn_evaluator.py
│ │ │ │ ├── README.md
│ │ │ │ ├── scenarios.py
│ │ │ │ └── test_dspy_evals.py
│ │ │ ├── test_dynamodb_server.py
│ │ │ └── test_source_db_integration.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── ecs-mcp-server
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── ecs_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── api
│ │ │ │ ├── __init__.py
│ │ │ │ ├── containerize.py
│ │ │ │ ├── delete.py
│ │ │ │ ├── ecs_troubleshooting.py
│ │ │ │ ├── infrastructure.py
│ │ │ │ ├── resource_management.py
│ │ │ │ ├── status.py
│ │ │ │ └── troubleshooting_tools
│ │ │ │ ├── __init__.py
│ │ │ │ ├── detect_image_pull_failures.py
│ │ │ │ ├── fetch_cloudformation_status.py
│ │ │ │ ├── fetch_network_configuration.py
│ │ │ │ ├── fetch_service_events.py
│ │ │ │ ├── fetch_task_failures.py
│ │ │ │ ├── fetch_task_logs.py
│ │ │ │ ├── get_ecs_troubleshooting_guidance.py
│ │ │ │ └── utils.py
│ │ │ ├── main.py
│ │ │ ├── modules
│ │ │ │ ├── __init__.py
│ │ │ │ ├── aws_knowledge_proxy.py
│ │ │ │ ├── containerize.py
│ │ │ │ ├── delete.py
│ │ │ │ ├── deployment_status.py
│ │ │ │ ├── infrastructure.py
│ │ │ │ ├── resource_management.py
│ │ │ │ └── troubleshooting.py
│ │ │ ├── templates
│ │ │ │ ├── ecr_infrastructure.json
│ │ │ │ └── ecs_infrastructure.json
│ │ │ └── utils
│ │ │ ├── arn_parser.py
│ │ │ ├── aws.py
│ │ │ ├── config.py
│ │ │ ├── docker.py
│ │ │ ├── security.py
│ │ │ ├── templates.py
│ │ │ └── time_utils.py
│ │ ├── DEVELOPMENT.md
│ │ ├── pyproject.toml
│ │ ├── pyrightconfig.json
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── integ
│ │ │ │ └── mcp-inspector
│ │ │ │ ├── .gitignore
│ │ │ │ ├── README.md
│ │ │ │ ├── run-tests.sh
│ │ │ │ └── scenarios
│ │ │ │ ├── 01_comprehensive_troubleshooting
│ │ │ │ │ ├── 01_create.sh
│ │ │ │ │ ├── 02_validate.sh
│ │ │ │ │ ├── 03_cleanup.sh
│ │ │ │ │ ├── description.txt
│ │ │ │ │ └── utils
│ │ │ │ │ ├── mcp_helpers.sh
│ │ │ │ │ └── validation_helpers.sh
│ │ │ │ └── 02_test_knowledge_proxy_tools
│ │ │ │ ├── 01_create.sh
│ │ │ │ ├── 02_validate.sh
│ │ │ │ ├── 03_cleanup.sh
│ │ │ │ ├── description.txt
│ │ │ │ └── utils
│ │ │ │ ├── knowledge_validation_helpers.sh
│ │ │ │ └── mcp_knowledge_helpers.sh
│ │ │ ├── llm_testing
│ │ │ │ ├── invalid_cfn_template.yaml
│ │ │ │ ├── README.md
│ │ │ │ ├── run_tests.sh
│ │ │ │ ├── scenarios
│ │ │ │ │ ├── 01_cloudformation_failure
│ │ │ │ │ │ ├── 01_create.sh
│ │ │ │ │ │ ├── 02_validate.sh
│ │ │ │ │ │ ├── 03_prompts.txt
│ │ │ │ │ │ ├── 04_evaluation.md
│ │ │ │ │ │ ├── 05_cleanup.sh
│ │ │ │ │ │ └── description.txt
│ │ │ │ │ ├── 02_service_failure
│ │ │ │ │ │ ├── 01_create.sh
│ │ │ │ │ │ ├── 02_validate.sh
│ │ │ │ │ │ ├── 03_prompts.txt
│ │ │ │ │ │ ├── 04_evaluation.md
│ │ │ │ │ │ ├── 05_cleanup.sh
│ │ │ │ │ │ └── description.txt
│ │ │ │ │ ├── 03_task_exit_failure
│ │ │ │ │ │ ├── 01_create.sh
│ │ │ │ │ │ ├── 02_validate.sh
│ │ │ │ │ │ ├── 03_prompts.txt
│ │ │ │ │ │ ├── 04_evaluation.md
│ │ │ │ │ │ ├── 05_cleanup.sh
│ │ │ │ │ │ └── description.txt
│ │ │ │ │ ├── 04_network_configuration_failure
│ │ │ │ │ │ ├── 01_create.sh
│ │ │ │ │ │ ├── 02_validate.sh
│ │ │ │ │ │ ├── 03_prompts.txt
│ │ │ │ │ │ ├── 05_cleanup.sh
│ │ │ │ │ │ └── description.txt
│ │ │ │ │ ├── 05_resource_constraint_failure
│ │ │ │ │ │ ├── 01_create.sh
│ │ │ │ │ │ ├── 02_validate.sh
│ │ │ │ │ │ ├── 03_prompts.txt
│ │ │ │ │ │ ├── 05_cleanup.sh
│ │ │ │ │ │ └── description.txt
│ │ │ │ │ └── 06_load_balancer_failure
│ │ │ │ │ ├── 01_create.sh
│ │ │ │ │ ├── 02_validate.sh
│ │ │ │ │ ├── 03_prompts.txt
│ │ │ │ │ ├── 05_cleanup.sh
│ │ │ │ │ └── description.txt
│ │ │ │ ├── SCRIPT_IMPROVEMENTS.md
│ │ │ │ └── utils
│ │ │ │ ├── aws_helpers.sh
│ │ │ │ └── evaluation_template.md
│ │ │ └── unit
│ │ │ ├── __init__.py
│ │ │ ├── api
│ │ │ │ ├── conftest.py
│ │ │ │ ├── test_delete_api.py
│ │ │ │ ├── test_ecs_troubleshooting.py
│ │ │ │ ├── test_resource_management_api.py
│ │ │ │ └── troubleshooting_tools
│ │ │ │ └── test_fetch_network_configuration.py
│ │ │ ├── conftest.py
│ │ │ ├── modules
│ │ │ │ ├── test_aws_knowledge_proxy.py
│ │ │ │ └── test_resource_management_module.py
│ │ │ ├── test_aws_role_utils.py
│ │ │ ├── test_aws_utils.py
│ │ │ ├── test_containerize.py
│ │ │ ├── test_delete.py
│ │ │ ├── test_docker_utils.py
│ │ │ ├── test_docker_with_role.py
│ │ │ ├── test_image_pull_failure_extended.py
│ │ │ ├── test_image_pull_failure.py
│ │ │ ├── test_infrastructure_role.py
│ │ │ ├── test_infrastructure.py
│ │ │ ├── test_integration.py
│ │ │ ├── test_main.py
│ │ │ ├── test_resource_management_api_operation.py
│ │ │ ├── test_resource_management_tool.py
│ │ │ ├── test_resource_management.py
│ │ │ ├── test_security_integration.py
│ │ │ ├── test_status_pytest.py
│ │ │ ├── test_status.py
│ │ │ ├── troubleshooting_tools
│ │ │ │ ├── __init__.py
│ │ │ │ ├── conftest.py
│ │ │ │ ├── test_detect_image_pull_failures.py
│ │ │ │ ├── test_fetch_cloudformation_status.py
│ │ │ │ ├── test_fetch_service_events.py
│ │ │ │ ├── test_fetch_task_failures.py
│ │ │ │ ├── test_fetch_task_logs.py
│ │ │ │ ├── test_get_ecs_troubleshooting_guidance.py
│ │ │ │ ├── test_is_ecr_image_security.py
│ │ │ │ └── test_utils.py
│ │ │ └── utils
│ │ │ ├── __init__.py
│ │ │ ├── async_test_utils.py
│ │ │ ├── test_arn_parser.py
│ │ │ ├── test_config.py
│ │ │ ├── test_docker.py
│ │ │ ├── test_response_sanitization.py
│ │ │ ├── test_security_extended.py
│ │ │ ├── test_security.py
│ │ │ ├── test_templates.py
│ │ │ └── test_time_utils.py
│ │ └── uv.lock
│ ├── eks-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── eks_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── aws_helper.py
│ │ │ ├── cloudwatch_handler.py
│ │ │ ├── cloudwatch_metrics_guidance_handler.py
│ │ │ ├── consts.py
│ │ │ ├── data
│ │ │ │ └── eks_cloudwatch_metrics_guidance.json
│ │ │ ├── eks_kb_handler.py
│ │ │ ├── eks_stack_handler.py
│ │ │ ├── iam_handler.py
│ │ │ ├── insights_handler.py
│ │ │ ├── k8s_apis.py
│ │ │ ├── k8s_client_cache.py
│ │ │ ├── k8s_handler.py
│ │ │ ├── logging_helper.py
│ │ │ ├── models.py
│ │ │ ├── scripts
│ │ │ │ └── update_eks_cloudwatch_metrics_guidance.py
│ │ │ ├── server.py
│ │ │ ├── templates
│ │ │ │ ├── eks-templates
│ │ │ │ │ └── eks-with-vpc.yaml
│ │ │ │ └── k8s-templates
│ │ │ │ ├── deployment.yaml
│ │ │ │ └── service.yaml
│ │ │ └── vpc_config_handler.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_aws_helper.py
│ │ │ ├── test_cloudwatch_handler.py
│ │ │ ├── test_cloudwatch_metrics_guidance_handler.py
│ │ │ ├── test_eks_kb_handler.py
│ │ │ ├── test_eks_stack_handler.py
│ │ │ ├── test_iam_handler.py
│ │ │ ├── test_init.py
│ │ │ ├── test_insights_handler.py
│ │ │ ├── test_k8s_apis.py
│ │ │ ├── test_k8s_client_cache.py
│ │ │ ├── test_k8s_handler.py
│ │ │ ├── test_logging_helper.py
│ │ │ ├── test_main.py
│ │ │ ├── test_models.py
│ │ │ ├── test_server.py
│ │ │ └── test_vpc_config_handler.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── elasticache-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── elasticache_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── common
│ │ │ │ ├── __init__.py
│ │ │ │ ├── connection.py
│ │ │ │ ├── decorators.py
│ │ │ │ └── server.py
│ │ │ ├── context.py
│ │ │ ├── main.py
│ │ │ └── tools
│ │ │ ├── __init__.py
│ │ │ ├── cc
│ │ │ │ ├── __init__.py
│ │ │ │ ├── connect.py
│ │ │ │ ├── create.py
│ │ │ │ ├── delete.py
│ │ │ │ ├── describe.py
│ │ │ │ ├── modify.py
│ │ │ │ ├── parsers.py
│ │ │ │ └── processors.py
│ │ │ ├── ce
│ │ │ │ ├── __init__.py
│ │ │ │ └── get_cost_and_usage.py
│ │ │ ├── cw
│ │ │ │ ├── __init__.py
│ │ │ │ └── get_metric_statistics.py
│ │ │ ├── cwlogs
│ │ │ │ ├── __init__.py
│ │ │ │ ├── create_log_group.py
│ │ │ │ ├── describe_log_groups.py
│ │ │ │ ├── describe_log_streams.py
│ │ │ │ ├── filter_log_events.py
│ │ │ │ └── get_log_events.py
│ │ │ ├── firehose
│ │ │ │ ├── __init__.py
│ │ │ │ └── list_delivery_streams.py
│ │ │ ├── misc
│ │ │ │ ├── __init__.py
│ │ │ │ ├── batch_apply_update_action.py
│ │ │ │ ├── batch_stop_update_action.py
│ │ │ │ ├── describe_cache_engine_versions.py
│ │ │ │ ├── describe_engine_default_parameters.py
│ │ │ │ ├── describe_events.py
│ │ │ │ └── describe_service_updates.py
│ │ │ ├── rg
│ │ │ │ ├── __init__.py
│ │ │ │ ├── complete_migration.py
│ │ │ │ ├── connect.py
│ │ │ │ ├── create.py
│ │ │ │ ├── delete.py
│ │ │ │ ├── describe.py
│ │ │ │ ├── modify.py
│ │ │ │ ├── parsers.py
│ │ │ │ ├── processors.py
│ │ │ │ ├── start_migration.py
│ │ │ │ └── test_migration.py
│ │ │ └── serverless
│ │ │ ├── __init__.py
│ │ │ ├── connect.py
│ │ │ ├── create.py
│ │ │ ├── delete.py
│ │ │ ├── describe.py
│ │ │ ├── models.py
│ │ │ └── modify.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_connection.py
│ │ │ ├── test_decorators.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ └── tools
│ │ │ ├── cc
│ │ │ │ ├── __init__.py
│ │ │ │ ├── test_connect_additional.py
│ │ │ │ ├── test_connect_coverage_additional.py
│ │ │ │ ├── test_connect_coverage.py
│ │ │ │ ├── test_connect.py
│ │ │ │ ├── test_create_additional.py
│ │ │ │ ├── test_create.py
│ │ │ │ ├── test_delete.py
│ │ │ │ ├── test_describe.py
│ │ │ │ ├── test_modify.py
│ │ │ │ ├── test_parsers.py
│ │ │ │ └── test_processors.py
│ │ │ ├── ce
│ │ │ │ ├── __init__.py
│ │ │ │ └── test_get_cost_and_usage.py
│ │ │ ├── cw
│ │ │ │ └── test_get_metric_statistics.py
│ │ │ ├── cwlogs
│ │ │ │ ├── __init__.py
│ │ │ │ ├── test_create_log_group.py
│ │ │ │ ├── test_describe_log_groups.py
│ │ │ │ ├── test_describe_log_streams.py
│ │ │ │ ├── test_filter_log_events.py
│ │ │ │ └── test_get_log_events.py
│ │ │ ├── firehose
│ │ │ │ └── test_list_delivery_streams.py
│ │ │ ├── misc
│ │ │ │ ├── __init__.py
│ │ │ │ ├── test_batch_apply_update_action.py
│ │ │ │ ├── test_batch_stop_update_action.py
│ │ │ │ ├── test_describe_cache_engine_versions.py
│ │ │ │ ├── test_describe_engine_default_parameters.py
│ │ │ │ ├── test_describe_events.py
│ │ │ │ └── test_describe_service_updates.py
│ │ │ ├── rg
│ │ │ │ ├── __init__.py
│ │ │ │ ├── test_complete_migration.py
│ │ │ │ ├── test_connect_additional.py
│ │ │ │ ├── test_connect_coverage_additional.py
│ │ │ │ ├── test_connect_optional_fields.py
│ │ │ │ ├── test_connect_partial_coverage.py
│ │ │ │ ├── test_connect.py
│ │ │ │ ├── test_create.py
│ │ │ │ ├── test_delete.py
│ │ │ │ ├── test_describe.py
│ │ │ │ ├── test_modify.py
│ │ │ │ ├── test_parsers.py
│ │ │ │ ├── test_processors.py
│ │ │ │ ├── test_start_migration.py
│ │ │ │ └── test_test_migration.py
│ │ │ └── serverless
│ │ │ ├── test_connect_additional.py
│ │ │ ├── test_connect_coverage_additional.py
│ │ │ ├── test_connect_optional_fields.py
│ │ │ ├── test_connect.py
│ │ │ ├── test_create.py
│ │ │ ├── test_delete.py
│ │ │ ├── test_describe.py
│ │ │ └── test_modify.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── finch-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── finch_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── consts.py
│ │ │ ├── models.py
│ │ │ ├── server.py
│ │ │ └── utils
│ │ │ ├── __init__.py
│ │ │ ├── build.py
│ │ │ ├── common.py
│ │ │ ├── ecr.py
│ │ │ ├── push.py
│ │ │ └── vm.py
│ │ ├── CHANGELOG.md
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── test_cli_flags.py
│ │ │ ├── test_logging_configuration.py
│ │ │ ├── test_server.py
│ │ │ ├── test_utils_build.py
│ │ │ ├── test_utils_common.py
│ │ │ ├── test_utils_ecr.py
│ │ │ ├── test_utils_push.py
│ │ │ └── test_utils_vm.py
│ │ └── uv.lock
│ ├── frontend-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── frontend_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── server.py
│ │ │ ├── static
│ │ │ │ └── react
│ │ │ │ ├── essential-knowledge.md
│ │ │ │ └── troubleshooting.md
│ │ │ └── utils
│ │ │ ├── __init__.py
│ │ │ └── file_utils.py
│ │ ├── CHANGELOG.md
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_file_utils.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ └── test_server.py
│ │ └── uv.lock
│ ├── git-repo-research-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── git_repo_research_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── defaults.py
│ │ │ ├── embeddings.py
│ │ │ ├── github_search.py
│ │ │ ├── indexer.py
│ │ │ ├── models.py
│ │ │ ├── repository.py
│ │ │ ├── search.py
│ │ │ ├── server.py
│ │ │ └── utils.py
│ │ ├── CHANGELOG.md
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── run_tests.sh
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── test_errors_repository.py
│ │ │ ├── test_github_search_edge_cases.py
│ │ │ ├── test_graphql_github_search.py
│ │ │ ├── test_local_repository.py
│ │ │ ├── test_repository_utils.py
│ │ │ ├── test_rest_github_search.py
│ │ │ ├── test_search.py
│ │ │ ├── test_server.py
│ │ │ └── test_url_repository.py
│ │ └── uv.lock
│ ├── healthlake-mcp-server
│ │ ├── .dockerignore
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── healthlake_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── fhir_operations.py
│ │ │ ├── main.py
│ │ │ ├── models.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── CONTRIBUTING.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── examples
│ │ │ ├── mcp_config.json
│ │ │ └── README.md
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── conftest.py
│ │ │ ├── test_fhir_client_comprehensive.py
│ │ │ ├── test_fhir_error_scenarios.py
│ │ │ ├── test_fhir_operations.py
│ │ │ ├── test_integration_mock_based.py
│ │ │ ├── test_main_edge_cases.py
│ │ │ ├── test_main.py
│ │ │ ├── test_mcp_integration_coverage.py
│ │ │ ├── test_models_edge_cases.py
│ │ │ ├── test_models.py
│ │ │ ├── test_readonly_mode.py
│ │ │ ├── test_server_core.py
│ │ │ ├── test_server_error_handling.py
│ │ │ ├── test_server_mcp_handlers.py
│ │ │ ├── test_server_toolhandler.py
│ │ │ └── test_server_validation.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── iam-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── iam_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── aws_client.py
│ │ │ ├── context.py
│ │ │ ├── errors.py
│ │ │ ├── models.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── DESIGN_COMPLIANCE.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── examples
│ │ │ ├── get_policy_document_example.py
│ │ │ └── inline_policy_demo.py
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── run_tests.sh
│ │ ├── tests
│ │ │ ├── test_context.py
│ │ │ ├── test_errors.py
│ │ │ ├── test_inline_policies.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── lambda-tool-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── lambda_tool_mcp_server
│ │ │ ├── __init__.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── examples
│ │ │ ├── README.md
│ │ │ └── sample_functions
│ │ │ ├── customer-create
│ │ │ │ └── app.py
│ │ │ ├── customer-id-from-email
│ │ │ │ └── app.py
│ │ │ ├── customer-info-from-id
│ │ │ │ └── app.py
│ │ │ └── template.yml
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── .gitignore
│ │ │ ├── conftest.py
│ │ │ ├── README.md
│ │ │ ├── test_format_lambda_response.py
│ │ │ ├── test_integration_coverage.py
│ │ │ ├── test_integration.py
│ │ │ ├── test_register_lambda_functions.py
│ │ │ ├── test_schema_integration.py
│ │ │ ├── test_server_coverage_additional.py
│ │ │ ├── test_server_coverage.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── mcp-lambda-handler
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ └── mcp_lambda_handler
│ │ │ ├── __init__.py
│ │ │ ├── mcp_lambda_handler.py
│ │ │ ├── session.py
│ │ │ └── types.py
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ └── test_lambda_handler.py
│ │ └── uv.lock
│ ├── memcached-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── memcached_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── common
│ │ │ │ ├── config.py
│ │ │ │ ├── connection.py
│ │ │ │ └── server.py
│ │ │ ├── context.py
│ │ │ ├── main.py
│ │ │ └── tools
│ │ │ └── cache.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── ELASTICACHECONNECT.md
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_cache_readonly.py
│ │ │ ├── test_cache.py
│ │ │ ├── test_connection.py
│ │ │ ├── test_init.py
│ │ │ └── test_main.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── mysql-mcp-server
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── mysql_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── connection
│ │ │ │ ├── __init__.py
│ │ │ │ ├── abstract_db_connection.py
│ │ │ │ ├── asyncmy_pool_connection.py
│ │ │ │ ├── db_connection_singleton.py
│ │ │ │ └── rds_data_api_connection.py
│ │ │ ├── mutable_sql_detector.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── conftest.py
│ │ │ ├── test_abstract_db_connection.py
│ │ │ ├── test_asyncmy_pool_connection.py
│ │ │ ├── test_db_connection_singleton.py
│ │ │ ├── test_rds_data_api_connection.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── nova-canvas-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── nova_canvas_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── consts.py
│ │ │ ├── models.py
│ │ │ ├── novacanvas.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── .gitignore
│ │ │ ├── conftest.py
│ │ │ ├── README.md
│ │ │ ├── test_models.py
│ │ │ ├── test_novacanvas.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── openapi-mcp-server
│ │ ├── .coveragerc
│ │ ├── .dockerignore
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── AUTHENTICATION.md
│ │ ├── AWS_BEST_PRACTICES.md
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── openapi_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── api
│ │ │ │ ├── __init__.py
│ │ │ │ └── config.py
│ │ │ ├── auth
│ │ │ │ ├── __init__.py
│ │ │ │ ├── api_key_auth.py
│ │ │ │ ├── auth_cache.py
│ │ │ │ ├── auth_errors.py
│ │ │ │ ├── auth_factory.py
│ │ │ │ ├── auth_protocol.py
│ │ │ │ ├── auth_provider.py
│ │ │ │ ├── base_auth.py
│ │ │ │ ├── basic_auth.py
│ │ │ │ ├── bearer_auth.py
│ │ │ │ ├── cognito_auth.py
│ │ │ │ └── register.py
│ │ │ ├── patch
│ │ │ │ └── __init__.py
│ │ │ ├── prompts
│ │ │ │ ├── __init__.py
│ │ │ │ ├── generators
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── operation_prompts.py
│ │ │ │ │ └── workflow_prompts.py
│ │ │ │ ├── models.py
│ │ │ │ └── prompt_manager.py
│ │ │ ├── server.py
│ │ │ └── utils
│ │ │ ├── __init__.py
│ │ │ ├── cache_provider.py
│ │ │ ├── config.py
│ │ │ ├── error_handler.py
│ │ │ ├── http_client.py
│ │ │ ├── metrics_provider.py
│ │ │ ├── openapi_validator.py
│ │ │ └── openapi.py
│ │ ├── CHANGELOG.md
│ │ ├── DEPLOYMENT.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── OBSERVABILITY.md
│ │ ├── pyproject.toml
│ │ ├── pyrightconfig.json
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── api
│ │ │ │ └── test_config.py
│ │ │ ├── auth
│ │ │ │ ├── test_api_key_auth.py
│ │ │ │ ├── test_auth_cache.py
│ │ │ │ ├── test_auth_errors.py
│ │ │ │ ├── test_auth_factory_caching.py
│ │ │ │ ├── test_auth_factory_coverage.py
│ │ │ │ ├── test_auth_factory.py
│ │ │ │ ├── test_auth_protocol_additional.py
│ │ │ │ ├── test_auth_protocol_boost.py
│ │ │ │ ├── test_auth_protocol_coverage.py
│ │ │ │ ├── test_auth_protocol_extended.py
│ │ │ │ ├── test_auth_protocol_improved.py
│ │ │ │ ├── test_auth_protocol.py
│ │ │ │ ├── test_auth_provider_additional.py
│ │ │ │ ├── test_base_auth_coverage.py
│ │ │ │ ├── test_base_auth.py
│ │ │ │ ├── test_basic_auth.py
│ │ │ │ ├── test_bearer_auth.py
│ │ │ │ ├── test_cognito_auth_additional_coverage.py
│ │ │ │ ├── test_cognito_auth_boost_coverage.py
│ │ │ │ ├── test_cognito_auth_client_credentials.py
│ │ │ │ ├── test_cognito_auth_coverage_boost.py
│ │ │ │ ├── test_cognito_auth_exceptions.py
│ │ │ │ ├── test_cognito_auth.py
│ │ │ │ ├── test_register_coverage.py
│ │ │ │ └── test_register.py
│ │ │ ├── prompts
│ │ │ │ ├── standalone
│ │ │ │ │ ├── test_operation_prompt.py
│ │ │ │ │ ├── test_prompt_arguments.py
│ │ │ │ │ └── test_secure_operation_prompt.py
│ │ │ │ ├── test_mcp_prompt_manager_integration.py
│ │ │ │ ├── test_mcp_prompt_manager.py
│ │ │ │ ├── test_models_dict_method.py
│ │ │ │ ├── test_operation_prompts_extended.py
│ │ │ │ ├── test_prompt_manager_additional.py
│ │ │ │ ├── test_prompt_manager_comprehensive.py
│ │ │ │ ├── test_prompt_manager_coverage.py
│ │ │ │ └── test_prompt_registration.py
│ │ │ ├── README.md
│ │ │ ├── test_api_name.py
│ │ │ ├── test_cache_coverage_89.py
│ │ │ ├── test_client.py
│ │ │ ├── test_coverage_boost.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main_extended.py
│ │ │ ├── test_main.py
│ │ │ ├── test_openapi_coverage_89.py
│ │ │ ├── test_server_auth_errors.py
│ │ │ ├── test_server_coverage_boost_2.py
│ │ │ ├── test_server_coverage_boost.py
│ │ │ ├── test_server_exception_handling.py
│ │ │ ├── test_server_extended.py
│ │ │ ├── test_server_httpx_version.py
│ │ │ ├── test_server_part1.py
│ │ │ ├── test_server_route_logging.py
│ │ │ ├── test_server_signal_handlers.py
│ │ │ ├── test_server.py
│ │ │ └── utils
│ │ │ ├── test_cache_provider.py
│ │ │ ├── test_error_handler_boost.py
│ │ │ ├── test_error_handler_extended.py
│ │ │ ├── test_error_handler_fix.py
│ │ │ ├── test_error_handler.py
│ │ │ ├── test_http_client_comprehensive.py
│ │ │ ├── test_http_client_extended.py
│ │ │ ├── test_http_client_extended2.py
│ │ │ ├── test_http_client_import_error.py
│ │ │ ├── test_http_client.py
│ │ │ ├── test_metrics_provider_decorators.py
│ │ │ ├── test_metrics_provider_extended2.py
│ │ │ ├── test_metrics_provider_prometheus.py
│ │ │ ├── test_metrics_provider.py
│ │ │ ├── test_openapi_validator.py
│ │ │ └── test_openapi.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── postgres-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── postgres_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── connection
│ │ │ │ ├── __init__.py
│ │ │ │ ├── abstract_db_connection.py
│ │ │ │ ├── db_connection_singleton.py
│ │ │ │ ├── psycopg_pool_connection.py
│ │ │ │ └── rds_api_connection.py
│ │ │ ├── mutable_sql_detector.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── conftest.py
│ │ │ ├── test_psycopg_connector.py
│ │ │ ├── test_server.py
│ │ │ └── test_singleton.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── prometheus-mcp-server
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── prometheus_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── consts.py
│ │ │ ├── models.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── conftest.py
│ │ │ ├── test_aws_credentials.py
│ │ │ ├── test_config_manager.py
│ │ │ ├── test_consts.py
│ │ │ ├── test_coverage_gaps.py
│ │ │ ├── test_coverage_improvement.py
│ │ │ ├── test_final_coverage.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_models.py
│ │ │ ├── test_prometheus_client.py
│ │ │ ├── test_prometheus_connection.py
│ │ │ ├── test_security_validator.py
│ │ │ ├── test_server_coverage.py
│ │ │ ├── test_tools.py
│ │ │ └── test_workspace_config.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── redshift-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── redshift_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── consts.py
│ │ │ ├── models.py
│ │ │ ├── redshift.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_redshift.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── s3-tables-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── s3_tables_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── constants.py
│ │ │ ├── database.py
│ │ │ ├── engines
│ │ │ │ ├── __init__.py
│ │ │ │ └── pyiceberg.py
│ │ │ ├── file_processor
│ │ │ │ ├── __init__.py
│ │ │ │ ├── csv.py
│ │ │ │ ├── parquet.py
│ │ │ │ └── utils.py
│ │ │ ├── models.py
│ │ │ ├── namespaces.py
│ │ │ ├── resources.py
│ │ │ ├── s3_operations.py
│ │ │ ├── server.py
│ │ │ ├── table_buckets.py
│ │ │ ├── tables.py
│ │ │ └── utils.py
│ │ ├── CHANGELOG.md
│ │ ├── CONTEXT.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_csv.py
│ │ │ ├── test_database.py
│ │ │ ├── test_file_processor_utils.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_namespaces.py
│ │ │ ├── test_parquet.py
│ │ │ ├── test_pyiceberg.py
│ │ │ ├── test_resources.py
│ │ │ ├── test_s3_operations.py
│ │ │ ├── test_server.py
│ │ │ ├── test_table_buckets.py
│ │ │ ├── test_tables.py
│ │ │ └── test_utils.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── stepfunctions-tool-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── stepfunctions_tool_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── aws_helper.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── .gitignore
│ │ │ ├── README.md
│ │ │ ├── test_aws_helper.py
│ │ │ ├── test_create_state_machine_tool.py
│ │ │ ├── test_filter_state_machines_by_tag.py
│ │ │ ├── test_format_state_machine_response.py
│ │ │ ├── test_get_schema_arn_from_state_machine_arn.py
│ │ │ ├── test_get_schema_from_registry.py
│ │ │ ├── test_invoke_express_state_machine_impl.py
│ │ │ ├── test_invoke_standard_state_machine_impl.py
│ │ │ ├── test_main.py
│ │ │ ├── test_register_state_machines.py
│ │ │ ├── test_sanitize_tool_name.py
│ │ │ ├── test_server.py
│ │ │ └── test_validate_state_machine_name.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── syntheticdata-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── syntheticdata_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── pandas_interpreter.py
│ │ │ ├── server.py
│ │ │ └── storage
│ │ │ ├── __init__.py
│ │ │ ├── base.py
│ │ │ ├── loader.py
│ │ │ └── s3.py
│ │ ├── CHANGELOG.md
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── test_constants.py
│ │ │ ├── test_pandas_interpreter.py
│ │ │ ├── test_server.py
│ │ │ └── test_storage
│ │ │ ├── __init__.py
│ │ │ ├── test_loader.py
│ │ │ └── test_s3.py
│ │ └── uv.lock
│ ├── terraform-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── terraform_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── impl
│ │ │ │ ├── resources
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── terraform_aws_provider_resources_listing.py
│ │ │ │ │ └── terraform_awscc_provider_resources_listing.py
│ │ │ │ └── tools
│ │ │ │ ├── __init__.py
│ │ │ │ ├── execute_terraform_command.py
│ │ │ │ ├── execute_terragrunt_command.py
│ │ │ │ ├── run_checkov_scan.py
│ │ │ │ ├── search_aws_provider_docs.py
│ │ │ │ ├── search_awscc_provider_docs.py
│ │ │ │ ├── search_specific_aws_ia_modules.py
│ │ │ │ ├── search_user_provided_module.py
│ │ │ │ └── utils.py
│ │ │ ├── models
│ │ │ │ ├── __init__.py
│ │ │ │ └── models.py
│ │ │ ├── scripts
│ │ │ │ ├── generate_aws_provider_resources.py
│ │ │ │ ├── generate_awscc_provider_resources.py
│ │ │ │ └── scrape_aws_terraform_best_practices.py
│ │ │ ├── server.py
│ │ │ └── static
│ │ │ ├── __init__.py
│ │ │ ├── AWS_PROVIDER_RESOURCES.md
│ │ │ ├── AWS_TERRAFORM_BEST_PRACTICES.md
│ │ │ ├── AWSCC_PROVIDER_RESOURCES.md
│ │ │ ├── MCP_INSTRUCTIONS.md
│ │ │ └── TERRAFORM_WORKFLOW_GUIDE.md
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── .gitignore
│ │ │ ├── conftest.py
│ │ │ ├── README.md
│ │ │ ├── test_command_impl.py
│ │ │ ├── test_execute_terraform_command.py
│ │ │ ├── test_execute_terragrunt_command.py
│ │ │ ├── test_models.py
│ │ │ ├── test_parameter_annotations.py
│ │ │ ├── test_resources.py
│ │ │ ├── test_run_checkov_scan.py
│ │ │ ├── test_search_user_provided_module.py
│ │ │ ├── test_server.py
│ │ │ ├── test_tool_implementations.py
│ │ │ ├── test_utils_additional.py
│ │ │ └── test_utils.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── timestream-for-influxdb-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── timestream_for_influxdb_mcp_server
│ │ │ ├── __init__.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── valkey-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── valkey_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── common
│ │ │ │ ├── __init__.py
│ │ │ │ ├── config.py
│ │ │ │ ├── connection.py
│ │ │ │ └── server.py
│ │ │ ├── context.py
│ │ │ ├── main.py
│ │ │ ├── tools
│ │ │ │ ├── __init__.py
│ │ │ │ ├── bitmap.py
│ │ │ │ ├── hash.py
│ │ │ │ ├── hyperloglog.py
│ │ │ │ ├── json.py
│ │ │ │ ├── list.py
│ │ │ │ ├── misc.py
│ │ │ │ ├── server_management.py
│ │ │ │ ├── set.py
│ │ │ │ ├── sorted_set.py
│ │ │ │ ├── stream.py
│ │ │ │ └── string.py
│ │ │ └── version.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── ELASTICACHECONNECT.md
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_bitmap.py
│ │ │ ├── test_config.py
│ │ │ ├── test_connection.py
│ │ │ ├── test_hash.py
│ │ │ ├── test_hyperloglog.py
│ │ │ ├── test_init.py
│ │ │ ├── test_json_additional.py
│ │ │ ├── test_json_readonly.py
│ │ │ ├── test_json.py
│ │ │ ├── test_list_additional.py
│ │ │ ├── test_list_readonly.py
│ │ │ ├── test_list.py
│ │ │ ├── test_main.py
│ │ │ ├── test_misc.py
│ │ │ ├── test_server_management.py
│ │ │ ├── test_set_readonly.py
│ │ │ ├── test_set.py
│ │ │ ├── test_sorted_set_additional.py
│ │ │ ├── test_sorted_set_readonly.py
│ │ │ ├── test_sorted_set.py
│ │ │ ├── test_stream_additional.py
│ │ │ ├── test_stream_readonly.py
│ │ │ ├── test_stream.py
│ │ │ └── test_string.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ └── well-architected-security-mcp-server
│ ├── .python-version
│ ├── awslabs
│ │ └── well_architected_security_mcp_server
│ │ ├── __init__.py
│ │ ├── consts.py
│ │ ├── server.py
│ │ └── util
│ │ ├── __init__.py
│ │ ├── network_security.py
│ │ ├── prompt_utils.py
│ │ ├── resource_utils.py
│ │ ├── security_services.py
│ │ └── storage_security.py
│ ├── PROMPT_TEMPLATE.md
│ ├── pyproject.toml
│ ├── README.md
│ ├── tests
│ │ ├── __init__.py
│ │ ├── conftest.py
│ │ ├── README.md
│ │ ├── test_access_analyzer_fix.py
│ │ ├── test_network_security_additional.py
│ │ ├── test_network_security.py
│ │ ├── test_prompt_utils_coverage.py
│ │ ├── test_prompt_utils.py
│ │ ├── test_resource_utils_fix.py
│ │ ├── test_resource_utils.py
│ │ ├── test_security_services_additional.py
│ │ ├── test_security_services_coverage.py
│ │ ├── test_security_services.py
│ │ ├── test_server_additional.py
│ │ ├── test_server_coverage.py
│ │ ├── test_server_prompts.py
│ │ ├── test_server_security_findings.py
│ │ ├── test_server.py
│ │ ├── test_storage_security_additional.py
│ │ ├── test_storage_security_comprehensive.py
│ │ ├── test_storage_security_edge_cases.py
│ │ ├── test_storage_security_recommendations.py
│ │ ├── test_storage_security.py
│ │ └── test_user_agent_config.py
│ └── uv.lock
└── VIBE_CODING_TIPS_TRICKS.md
```
# Files
--------------------------------------------------------------------------------
/src/aws-healthomics-mcp-server/tests/test_workflow_execution.py:
--------------------------------------------------------------------------------
```python
1 | # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
2 | #
3 | # Licensed under the Apache License, Version 2.0 (the "License");
4 | # you may not use this file except in compliance with the License.
5 | # You may obtain a copy of the License at
6 | #
7 | # http://www.apache.org/licenses/LICENSE-2.0
8 | #
9 | # Unless required by applicable law or agreed to in writing, software
10 | # distributed under the License is distributed on an "AS IS" BASIS,
11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | # See the License for the specific language governing permissions and
13 | # limitations under the License.
14 |
15 | """Unit tests for workflow execution tools."""
16 |
17 | import botocore.exceptions
18 | import pytest
19 | from awslabs.aws_healthomics_mcp_server.tools.workflow_execution import (
20 | get_run,
21 | get_run_task,
22 | list_run_tasks,
23 | list_runs,
24 | start_run,
25 | )
26 | from datetime import datetime, timedelta, timezone
27 | from unittest.mock import AsyncMock, MagicMock, patch
28 |
29 |
30 | @pytest.mark.asyncio
31 | async def test_get_run_success():
32 | """Test successful retrieval of run details."""
33 | # Mock response data
34 | creation_time = datetime.now(timezone.utc)
35 | start_time = creation_time
36 | stop_time = datetime.now(timezone.utc)
37 |
38 | mock_response = {
39 | 'id': 'run-12345',
40 | 'arn': 'arn:aws:omics:us-east-1:123456789012:run/run-12345',
41 | 'name': 'test-run',
42 | 'status': 'COMPLETED',
43 | 'workflowId': 'wfl-12345',
44 | 'workflowType': 'WDL',
45 | 'workflowVersionName': 'v1.0',
46 | 'creationTime': creation_time,
47 | 'startTime': start_time,
48 | 'stopTime': stop_time,
49 | 'outputUri': 's3://bucket/output/',
50 | 'roleArn': 'arn:aws:iam::123456789012:role/HealthOmicsRole',
51 | 'runOutputUri': 's3://bucket/run-output/',
52 | 'parameters': {'param1': 'value1'},
53 | 'uuid': 'abc-123-def-456',
54 | 'statusMessage': 'Run completed successfully',
55 | }
56 |
57 | # Mock context and client
58 | mock_ctx = AsyncMock()
59 | mock_client = MagicMock()
60 | mock_client.get_run.return_value = mock_response
61 |
62 | with patch(
63 | 'awslabs.aws_healthomics_mcp_server.tools.workflow_execution.get_omics_client',
64 | return_value=mock_client,
65 | ):
66 | result = await get_run(mock_ctx, run_id='run-12345')
67 |
68 | # Verify client was called correctly
69 | mock_client.get_run.assert_called_once_with(id='run-12345')
70 |
71 | # Verify result contains all expected fields
72 | assert result['id'] == 'run-12345'
73 | assert result['arn'] == 'arn:aws:omics:us-east-1:123456789012:run/run-12345'
74 | assert result['name'] == 'test-run'
75 | assert result['status'] == 'COMPLETED'
76 | assert result['workflowId'] == 'wfl-12345'
77 | assert result['workflowType'] == 'WDL'
78 | assert result['workflowVersionName'] == 'v1.0'
79 | assert result['creationTime'] == creation_time.isoformat()
80 | assert result['startTime'] == start_time.isoformat()
81 | assert result['stopTime'] == stop_time.isoformat()
82 | assert result['outputUri'] == 's3://bucket/output/'
83 | assert result['roleArn'] == 'arn:aws:iam::123456789012:role/HealthOmicsRole'
84 | assert result['runOutputUri'] == 's3://bucket/run-output/'
85 | assert result['parameters'] == {'param1': 'value1'}
86 | assert result['uuid'] == 'abc-123-def-456'
87 | assert result['statusMessage'] == 'Run completed successfully'
88 |
89 |
90 | @pytest.mark.asyncio
91 | async def test_get_run_minimal_response():
92 | """Test run retrieval with minimal response fields."""
93 | # Mock response with minimal fields
94 | creation_time = datetime.now(timezone.utc)
95 | mock_response = {
96 | 'id': 'run-12345',
97 | 'arn': 'arn:aws:omics:us-east-1:123456789012:run/run-12345',
98 | 'name': 'test-run',
99 | 'status': 'QUEUED',
100 | 'workflowId': 'wfl-12345',
101 | 'workflowType': 'WDL',
102 | 'creationTime': creation_time,
103 | 'outputUri': 's3://bucket/output/',
104 | 'roleArn': 'arn:aws:iam::123456789012:role/HealthOmicsRole',
105 | 'runOutputUri': 's3://bucket/run-output/',
106 | }
107 |
108 | # Mock context and client
109 | mock_ctx = AsyncMock()
110 | mock_client = MagicMock()
111 | mock_client.get_run.return_value = mock_response
112 |
113 | with patch(
114 | 'awslabs.aws_healthomics_mcp_server.tools.workflow_execution.get_omics_client',
115 | return_value=mock_client,
116 | ):
117 | result = await get_run(mock_ctx, run_id='run-12345')
118 |
119 | # Verify required fields
120 | assert result['id'] == 'run-12345'
121 | assert result['status'] == 'QUEUED'
122 | assert result['creationTime'] == creation_time.isoformat()
123 | assert result['roleArn'] == 'arn:aws:iam::123456789012:role/HealthOmicsRole'
124 | assert result['runOutputUri'] == 's3://bucket/run-output/'
125 |
126 | # Verify optional fields are not present
127 | assert 'startTime' not in result
128 | assert 'stopTime' not in result
129 | assert 'parameters' not in result
130 | assert 'statusMessage' not in result
131 | assert 'failureReason' not in result
132 |
133 |
134 | @pytest.mark.asyncio
135 | async def test_get_run_failed_status():
136 | """Test run retrieval with failed status and failure reason."""
137 | # Mock response for failed run
138 | mock_response = {
139 | 'id': 'run-12345',
140 | 'status': 'FAILED',
141 | 'failureReason': 'Resource quota exceeded',
142 | 'statusMessage': 'Run failed due to resource constraints',
143 | 'roleArn': 'arn:aws:iam::123456789012:role/HealthOmicsRole',
144 | 'runOutputUri': 's3://bucket/run-output/',
145 | }
146 |
147 | # Mock context and client
148 | mock_ctx = AsyncMock()
149 | mock_client = MagicMock()
150 | mock_client.get_run.return_value = mock_response
151 |
152 | with patch(
153 | 'awslabs.aws_healthomics_mcp_server.tools.workflow_execution.get_omics_client',
154 | return_value=mock_client,
155 | ):
156 | result = await get_run(mock_ctx, run_id='run-12345')
157 |
158 | # Verify failure information
159 | assert result['status'] == 'FAILED'
160 | assert result['failureReason'] == 'Resource quota exceeded'
161 | assert result['statusMessage'] == 'Run failed due to resource constraints'
162 |
163 |
164 | @pytest.mark.asyncio
165 | async def test_get_run_boto_error():
166 | """Test handling of BotoCoreError."""
167 | # Mock context and client
168 | mock_ctx = AsyncMock()
169 | mock_client = MagicMock()
170 | mock_client.get_run.side_effect = botocore.exceptions.BotoCoreError()
171 |
172 | with patch(
173 | 'awslabs.aws_healthomics_mcp_server.tools.workflow_execution.get_omics_client',
174 | return_value=mock_client,
175 | ):
176 | with pytest.raises(botocore.exceptions.BotoCoreError):
177 | await get_run(mock_ctx, run_id='run-12345')
178 |
179 | # Verify error was reported to context
180 | mock_ctx.error.assert_called_once()
181 | assert 'AWS error getting run' in mock_ctx.error.call_args[0][0]
182 |
183 |
184 | @pytest.mark.asyncio
185 | async def test_get_run_client_error():
186 | """Test handling of ClientError."""
187 | # Mock context and client
188 | mock_ctx = AsyncMock()
189 | mock_client = MagicMock()
190 | mock_client.get_run.side_effect = botocore.exceptions.ClientError(
191 | {'Error': {'Code': 'ResourceNotFoundException', 'Message': 'Run not found'}}, 'GetRun'
192 | )
193 |
194 | with patch(
195 | 'awslabs.aws_healthomics_mcp_server.tools.workflow_execution.get_omics_client',
196 | return_value=mock_client,
197 | ):
198 | with pytest.raises(botocore.exceptions.ClientError):
199 | await get_run(mock_ctx, run_id='run-12345')
200 |
201 | # Verify error was reported to context
202 | mock_ctx.error.assert_called_once()
203 | assert 'AWS error getting run' in mock_ctx.error.call_args[0][0]
204 |
205 |
206 | @pytest.mark.asyncio
207 | async def test_get_run_unexpected_error():
208 | """Test handling of unexpected errors."""
209 | # Mock context and client
210 | mock_ctx = AsyncMock()
211 | mock_client = MagicMock()
212 | mock_client.get_run.side_effect = Exception('Unexpected error')
213 |
214 | with patch(
215 | 'awslabs.aws_healthomics_mcp_server.tools.workflow_execution.get_omics_client',
216 | return_value=mock_client,
217 | ):
218 | with pytest.raises(Exception, match='Unexpected error'):
219 | await get_run(mock_ctx, run_id='run-12345')
220 |
221 | # Verify error was reported to context
222 | mock_ctx.error.assert_called_once()
223 | assert 'Unexpected error getting run' in mock_ctx.error.call_args[0][0]
224 |
225 |
226 | @pytest.mark.asyncio
227 | async def test_get_run_none_timestamps():
228 | """Test handling of None values for timestamps."""
229 | # Mock response with None timestamps
230 | mock_response = {
231 | 'id': 'run-12345',
232 | 'status': 'PENDING',
233 | 'creationTime': None,
234 | 'startTime': None,
235 | 'stopTime': None,
236 | 'roleArn': 'arn:aws:iam::123456789012:role/HealthOmicsRole',
237 | 'runOutputUri': 's3://bucket/run-output/',
238 | }
239 |
240 | # Mock context and client
241 | mock_ctx = AsyncMock()
242 | mock_client = MagicMock()
243 | mock_client.get_run.return_value = mock_response
244 |
245 | with patch(
246 | 'awslabs.aws_healthomics_mcp_server.tools.workflow_execution.get_omics_client',
247 | return_value=mock_client,
248 | ):
249 | result = await get_run(mock_ctx, run_id='run-12345')
250 |
251 | # Verify timestamp handling
252 | assert result['creationTime'] is None
253 | assert 'startTime' not in result
254 | assert 'stopTime' not in result
255 |
256 |
257 | # Tests for list_runs function
258 |
259 |
260 | @pytest.mark.asyncio
261 | async def test_list_runs_success():
262 | """Test successful listing of runs."""
263 | # Mock response data
264 | creation_time = datetime.now(timezone.utc)
265 | start_time = datetime.now(timezone.utc)
266 | stop_time = datetime.now(timezone.utc)
267 |
268 | mock_response = {
269 | 'items': [
270 | {
271 | 'id': 'run-12345',
272 | 'arn': 'arn:aws:omics:us-east-1:123456789012:run/run-12345',
273 | 'name': 'test-run-1',
274 | 'status': 'COMPLETED',
275 | 'workflowId': 'wfl-12345',
276 | 'workflowType': 'WDL',
277 | 'creationTime': creation_time,
278 | 'startTime': start_time,
279 | 'stopTime': stop_time,
280 | },
281 | {
282 | 'id': 'run-67890',
283 | 'arn': 'arn:aws:omics:us-east-1:123456789012:run/run-67890',
284 | 'name': 'test-run-2',
285 | 'status': 'RUNNING',
286 | 'workflowId': 'wfl-67890',
287 | 'workflowType': 'CWL',
288 | 'creationTime': creation_time,
289 | 'startTime': start_time,
290 | },
291 | ],
292 | 'nextToken': 'next-page-token',
293 | }
294 |
295 | # Mock context and client
296 | mock_ctx = AsyncMock()
297 | mock_client = MagicMock()
298 | mock_client.list_runs.return_value = mock_response
299 |
300 | with patch(
301 | 'awslabs.aws_healthomics_mcp_server.tools.workflow_execution.get_omics_client',
302 | return_value=mock_client,
303 | ):
304 | result = await list_runs(
305 | ctx=mock_ctx,
306 | max_results=10,
307 | next_token=None,
308 | status=None,
309 | created_after=None,
310 | created_before=None,
311 | )
312 |
313 | # Verify client was called correctly
314 | mock_client.list_runs.assert_called_once_with(maxResults=10)
315 |
316 | # Verify result structure
317 | assert 'runs' in result
318 | assert 'nextToken' in result
319 | assert result['nextToken'] == 'next-page-token'
320 | assert len(result['runs']) == 2
321 |
322 | # Verify first run
323 | run1 = result['runs'][0]
324 | assert run1['id'] == 'run-12345'
325 | assert run1['name'] == 'test-run-1'
326 | assert run1['status'] == 'COMPLETED'
327 | assert run1['workflowId'] == 'wfl-12345'
328 | assert run1['workflowType'] == 'WDL'
329 | assert run1['creationTime'] == creation_time.isoformat()
330 | assert run1['startTime'] == start_time.isoformat()
331 | assert run1['stopTime'] == stop_time.isoformat()
332 |
333 | # Verify second run (no stopTime)
334 | run2 = result['runs'][1]
335 | assert run2['id'] == 'run-67890'
336 | assert run2['status'] == 'RUNNING'
337 | assert 'stopTime' not in run2
338 |
339 |
340 | @pytest.mark.asyncio
341 | async def test_list_runs_with_filters():
342 | """Test listing runs with status filter (no date filters)."""
343 | mock_response = {'items': []}
344 |
345 | # Mock context and client
346 | mock_ctx = AsyncMock()
347 | mock_client = MagicMock()
348 | mock_client.list_runs.return_value = mock_response
349 |
350 | with patch(
351 | 'awslabs.aws_healthomics_mcp_server.tools.workflow_execution.get_omics_client',
352 | return_value=mock_client,
353 | ):
354 | await list_runs(
355 | ctx=mock_ctx,
356 | max_results=25,
357 | next_token='previous-token',
358 | status='COMPLETED',
359 | created_after=None,
360 | created_before=None,
361 | )
362 |
363 | # Verify client was called with status filter only (no date filters)
364 | mock_client.list_runs.assert_called_once_with(
365 | maxResults=25,
366 | startingToken='previous-token',
367 | status='COMPLETED',
368 | )
369 |
370 |
371 | @pytest.mark.asyncio
372 | async def test_list_runs_empty_response():
373 | """Test listing runs with empty response."""
374 | mock_response = {'items': []}
375 |
376 | # Mock context and client
377 | mock_ctx = AsyncMock()
378 | mock_client = MagicMock()
379 | mock_client.list_runs.return_value = mock_response
380 |
381 | with patch(
382 | 'awslabs.aws_healthomics_mcp_server.tools.workflow_execution.get_omics_client',
383 | return_value=mock_client,
384 | ):
385 | result = await list_runs(
386 | ctx=mock_ctx,
387 | max_results=10,
388 | next_token=None,
389 | status=None,
390 | created_after=None,
391 | created_before=None,
392 | )
393 |
394 | # Verify empty result
395 | assert result['runs'] == []
396 | assert 'nextToken' not in result
397 |
398 |
399 | @pytest.mark.asyncio
400 | async def test_list_runs_invalid_status():
401 | """Test listing runs with invalid status."""
402 | mock_ctx = AsyncMock()
403 |
404 | with pytest.raises(ValueError, match='Invalid run status'):
405 | await list_runs(
406 | ctx=mock_ctx,
407 | max_results=10,
408 | next_token=None,
409 | status='INVALID_STATUS',
410 | created_after=None,
411 | created_before=None,
412 | )
413 |
414 | # Verify error was reported to context
415 | mock_ctx.error.assert_called_once()
416 | assert 'Invalid run status' in mock_ctx.error.call_args[0][0]
417 |
418 |
419 | @pytest.mark.asyncio
420 | async def test_list_runs_boto_error():
421 | """Test handling of BotoCoreError in list_runs."""
422 | # Mock context and client
423 | mock_ctx = AsyncMock()
424 | mock_client = MagicMock()
425 | mock_client.list_runs.side_effect = botocore.exceptions.BotoCoreError()
426 |
427 | with patch(
428 | 'awslabs.aws_healthomics_mcp_server.tools.workflow_execution.get_omics_client',
429 | return_value=mock_client,
430 | ):
431 | with pytest.raises(botocore.exceptions.BotoCoreError):
432 | await list_runs(
433 | ctx=mock_ctx,
434 | max_results=10,
435 | next_token=None,
436 | status=None,
437 | created_after=None,
438 | created_before=None,
439 | )
440 |
441 | # Verify error was reported to context
442 | mock_ctx.error.assert_called_once()
443 | assert 'AWS error listing runs' in mock_ctx.error.call_args[0][0]
444 |
445 |
446 | @pytest.mark.asyncio
447 | async def test_list_runs_client_error():
448 | """Test handling of ClientError in list_runs."""
449 | # Mock context and client
450 | mock_ctx = AsyncMock()
451 | mock_client = MagicMock()
452 | mock_client.list_runs.side_effect = botocore.exceptions.ClientError(
453 | {'Error': {'Code': 'AccessDenied', 'Message': 'Access denied'}}, 'ListRuns'
454 | )
455 |
456 | with patch(
457 | 'awslabs.aws_healthomics_mcp_server.tools.workflow_execution.get_omics_client',
458 | return_value=mock_client,
459 | ):
460 | with pytest.raises(botocore.exceptions.ClientError):
461 | await list_runs(
462 | ctx=mock_ctx,
463 | max_results=10,
464 | next_token=None,
465 | status=None,
466 | created_after=None,
467 | created_before=None,
468 | )
469 |
470 | # Verify error was reported to context
471 | mock_ctx.error.assert_called_once()
472 | assert 'AWS error listing runs' in mock_ctx.error.call_args[0][0]
473 |
474 |
475 | @pytest.mark.asyncio
476 | async def test_list_runs_unexpected_error():
477 | """Test handling of unexpected errors in list_runs."""
478 | # Mock context and client
479 | mock_ctx = AsyncMock()
480 | mock_client = MagicMock()
481 | mock_client.list_runs.side_effect = Exception('Unexpected error')
482 |
483 | with patch(
484 | 'awslabs.aws_healthomics_mcp_server.tools.workflow_execution.get_omics_client',
485 | return_value=mock_client,
486 | ):
487 | with pytest.raises(Exception, match='Unexpected error'):
488 | await list_runs(
489 | ctx=mock_ctx,
490 | max_results=10,
491 | next_token=None,
492 | status=None,
493 | created_after=None,
494 | created_before=None,
495 | )
496 |
497 | # Verify error was reported to context
498 | mock_ctx.error.assert_called_once()
499 | assert 'Unexpected error listing runs' in mock_ctx.error.call_args[0][0]
500 |
501 |
502 | @pytest.mark.asyncio
503 | async def test_list_runs_minimal_run_data():
504 | """Test listing runs with minimal run data."""
505 | # Mock response with minimal fields
506 | creation_time = datetime.now(timezone.utc)
507 | mock_response = {
508 | 'items': [
509 | {
510 | 'id': 'run-12345',
511 | 'status': 'QUEUED',
512 | 'creationTime': creation_time,
513 | }
514 | ]
515 | }
516 |
517 | # Mock context and client
518 | mock_ctx = AsyncMock()
519 | mock_client = MagicMock()
520 | mock_client.list_runs.return_value = mock_response
521 |
522 | with patch(
523 | 'awslabs.aws_healthomics_mcp_server.tools.workflow_execution.get_omics_client',
524 | return_value=mock_client,
525 | ):
526 | result = await list_runs(
527 | ctx=mock_ctx,
528 | max_results=10,
529 | next_token=None,
530 | status=None,
531 | created_after=None,
532 | created_before=None,
533 | )
534 |
535 | # Verify minimal run data
536 | run = result['runs'][0]
537 | assert run['id'] == 'run-12345'
538 | assert run['status'] == 'QUEUED'
539 | assert run['creationTime'] == creation_time.isoformat()
540 |
541 | # Verify optional fields are not present
542 | assert run.get('arn') is None
543 | assert run.get('name') is None
544 | assert run.get('workflowId') is None
545 | assert run.get('workflowType') is None
546 | assert 'startTime' not in run
547 | assert 'stopTime' not in run
548 |
549 |
550 | @pytest.mark.asyncio
551 | async def test_list_runs_none_timestamps():
552 | """Test listing runs with None timestamps."""
553 | # Mock response with None timestamps
554 | mock_response = {
555 | 'items': [
556 | {
557 | 'id': 'run-12345',
558 | 'status': 'PENDING',
559 | 'creationTime': None,
560 | 'startTime': None,
561 | 'stopTime': None,
562 | }
563 | ]
564 | }
565 |
566 | # Mock context and client
567 | mock_ctx = AsyncMock()
568 | mock_client = MagicMock()
569 | mock_client.list_runs.return_value = mock_response
570 |
571 | with patch(
572 | 'awslabs.aws_healthomics_mcp_server.tools.workflow_execution.get_omics_client',
573 | return_value=mock_client,
574 | ):
575 | result = await list_runs(
576 | ctx=mock_ctx,
577 | max_results=10,
578 | next_token=None,
579 | status=None,
580 | created_after=None,
581 | created_before=None,
582 | )
583 |
584 | # Verify timestamp handling
585 | run = result['runs'][0]
586 | assert run['creationTime'] is None
587 | assert 'startTime' not in run
588 | assert 'stopTime' not in run
589 |
590 |
591 | @pytest.mark.asyncio
592 | async def test_list_runs_default_parameters():
593 | """Test list_runs with default parameters."""
594 | mock_response = {'items': []}
595 |
596 | # Mock context and client
597 | mock_ctx = AsyncMock()
598 | mock_client = MagicMock()
599 | mock_client.list_runs.return_value = mock_response
600 |
601 | with patch(
602 | 'awslabs.aws_healthomics_mcp_server.tools.workflow_execution.get_omics_client',
603 | return_value=mock_client,
604 | ):
605 | await list_runs(
606 | ctx=mock_ctx,
607 | max_results=10,
608 | next_token=None,
609 | status=None,
610 | created_after=None,
611 | created_before=None,
612 | )
613 |
614 | # Verify client was called with default parameters only
615 | mock_client.list_runs.assert_called_once_with(maxResults=10)
616 |
617 |
618 | @pytest.mark.asyncio
619 | async def test_list_runs_with_date_filters():
620 | """Test listing runs with client-side date filtering."""
621 | # Create test data with different creation times
622 | base_time = datetime(2023, 6, 15, 12, 0, 0, tzinfo=timezone.utc)
623 |
624 | mock_response = {
625 | 'items': [
626 | {
627 | 'id': 'run-1',
628 | 'name': 'old-run',
629 | 'status': 'COMPLETED',
630 | 'workflowId': 'wfl-1',
631 | 'workflowType': 'WDL',
632 | 'creationTime': base_time - timedelta(days=10), # 2023-06-05
633 | },
634 | {
635 | 'id': 'run-2',
636 | 'name': 'middle-run',
637 | 'status': 'COMPLETED',
638 | 'workflowId': 'wfl-2',
639 | 'workflowType': 'WDL',
640 | 'creationTime': base_time, # 2023-06-15
641 | },
642 | {
643 | 'id': 'run-3',
644 | 'name': 'new-run',
645 | 'status': 'COMPLETED',
646 | 'workflowId': 'wfl-3',
647 | 'workflowType': 'WDL',
648 | 'creationTime': base_time + timedelta(days=10), # 2023-06-25
649 | },
650 | ]
651 | }
652 |
653 | # Mock context and client
654 | mock_ctx = AsyncMock()
655 | mock_client = MagicMock()
656 | mock_client.list_runs.return_value = mock_response
657 |
658 | with patch(
659 | 'awslabs.aws_healthomics_mcp_server.tools.workflow_execution.get_omics_client',
660 | return_value=mock_client,
661 | ):
662 | # Test filtering with created_after
663 | result = await list_runs(
664 | ctx=mock_ctx,
665 | max_results=10,
666 | next_token=None,
667 | status=None,
668 | created_after='2023-06-10T00:00:00Z',
669 | created_before=None,
670 | )
671 |
672 | # Should return runs created after 2023-06-10 (run-2 and run-3)
673 | assert len(result['runs']) == 2
674 | assert result['runs'][0]['id'] == 'run-2'
675 | assert result['runs'][1]['id'] == 'run-3'
676 |
677 | # Verify client was called with larger batch size for filtering
678 | mock_client.list_runs.assert_called_once_with(maxResults=100)
679 |
680 |
681 | @pytest.mark.asyncio
682 | async def test_list_runs_with_created_before_filter():
683 | """Test listing runs with created_before filter."""
684 | base_time = datetime(2023, 6, 15, 12, 0, 0, tzinfo=timezone.utc)
685 |
686 | mock_response = {
687 | 'items': [
688 | {
689 | 'id': 'run-1',
690 | 'name': 'old-run',
691 | 'status': 'COMPLETED',
692 | 'workflowId': 'wfl-1',
693 | 'workflowType': 'WDL',
694 | 'creationTime': base_time - timedelta(days=10), # 2023-06-05
695 | },
696 | {
697 | 'id': 'run-2',
698 | 'name': 'middle-run',
699 | 'status': 'COMPLETED',
700 | 'workflowId': 'wfl-2',
701 | 'workflowType': 'WDL',
702 | 'creationTime': base_time, # 2023-06-15
703 | },
704 | {
705 | 'id': 'run-3',
706 | 'name': 'new-run',
707 | 'status': 'COMPLETED',
708 | 'workflowId': 'wfl-3',
709 | 'workflowType': 'WDL',
710 | 'creationTime': base_time + timedelta(days=10), # 2023-06-25
711 | },
712 | ]
713 | }
714 |
715 | mock_ctx = AsyncMock()
716 | mock_client = MagicMock()
717 | mock_client.list_runs.return_value = mock_response
718 |
719 | with patch(
720 | 'awslabs.aws_healthomics_mcp_server.tools.workflow_execution.get_omics_client',
721 | return_value=mock_client,
722 | ):
723 | # Test filtering with created_before
724 | result = await list_runs(
725 | ctx=mock_ctx,
726 | max_results=10,
727 | next_token=None,
728 | status=None,
729 | created_after=None,
730 | created_before='2023-06-20T00:00:00Z',
731 | )
732 |
733 | # Should return runs created before 2023-06-20 (run-1 and run-2)
734 | assert len(result['runs']) == 2
735 | assert result['runs'][0]['id'] == 'run-1'
736 | assert result['runs'][1]['id'] == 'run-2'
737 |
738 |
739 | @pytest.mark.asyncio
740 | async def test_list_runs_with_both_date_filters():
741 | """Test listing runs with both created_after and created_before filters."""
742 | base_time = datetime(2023, 6, 15, 12, 0, 0, tzinfo=timezone.utc)
743 |
744 | mock_response = {
745 | 'items': [
746 | {
747 | 'id': 'run-1',
748 | 'name': 'old-run',
749 | 'status': 'COMPLETED',
750 | 'workflowId': 'wfl-1',
751 | 'workflowType': 'WDL',
752 | 'creationTime': base_time - timedelta(days=10), # 2023-06-05
753 | },
754 | {
755 | 'id': 'run-2',
756 | 'name': 'middle-run',
757 | 'status': 'COMPLETED',
758 | 'workflowId': 'wfl-2',
759 | 'workflowType': 'WDL',
760 | 'creationTime': base_time, # 2023-06-15
761 | },
762 | {
763 | 'id': 'run-3',
764 | 'name': 'new-run',
765 | 'status': 'COMPLETED',
766 | 'workflowId': 'wfl-3',
767 | 'workflowType': 'WDL',
768 | 'creationTime': base_time + timedelta(days=10), # 2023-06-25
769 | },
770 | ]
771 | }
772 |
773 | mock_ctx = AsyncMock()
774 | mock_client = MagicMock()
775 | mock_client.list_runs.return_value = mock_response
776 |
777 | with patch(
778 | 'awslabs.aws_healthomics_mcp_server.tools.workflow_execution.get_omics_client',
779 | return_value=mock_client,
780 | ):
781 | # Test filtering with both date filters
782 | result = await list_runs(
783 | ctx=mock_ctx,
784 | max_results=10,
785 | next_token=None,
786 | status=None,
787 | created_after='2023-06-10T00:00:00Z',
788 | created_before='2023-06-20T00:00:00Z',
789 | )
790 |
791 | # Should return only run-2 (created between the two dates)
792 | assert len(result['runs']) == 1
793 | assert result['runs'][0]['id'] == 'run-2'
794 |
795 |
796 | @pytest.mark.asyncio
797 | async def test_list_runs_invalid_created_after():
798 | """Test list_runs with invalid created_after datetime."""
799 | mock_ctx = AsyncMock()
800 |
801 | with pytest.raises(ValueError, match='Invalid created_after datetime'):
802 | await list_runs(
803 | ctx=mock_ctx,
804 | max_results=10,
805 | next_token=None,
806 | status=None,
807 | created_after='invalid-datetime',
808 | created_before=None,
809 | )
810 |
811 | # Verify error was reported to context
812 | mock_ctx.error.assert_called_once()
813 |
814 |
815 | @pytest.mark.asyncio
816 | async def test_list_runs_invalid_created_before():
817 | """Test list_runs with invalid created_before datetime."""
818 | mock_ctx = AsyncMock()
819 |
820 | with pytest.raises(ValueError, match='Invalid created_before datetime'):
821 | await list_runs(
822 | ctx=mock_ctx,
823 | max_results=10,
824 | next_token=None,
825 | status=None,
826 | created_after=None,
827 | created_before='not-a-datetime',
828 | )
829 |
830 | # Verify error was reported to context
831 | mock_ctx.error.assert_called_once()
832 |
833 |
834 | @pytest.mark.asyncio
835 | async def test_list_runs_date_filter_no_matching_runs():
836 | """Test date filtering when no runs match the criteria."""
837 | base_time = datetime(2023, 6, 15, 12, 0, 0, tzinfo=timezone.utc)
838 |
839 | mock_response = {
840 | 'items': [
841 | {
842 | 'id': 'run-1',
843 | 'name': 'old-run',
844 | 'status': 'COMPLETED',
845 | 'workflowId': 'wfl-1',
846 | 'workflowType': 'WDL',
847 | 'creationTime': base_time - timedelta(days=10), # 2023-06-05
848 | },
849 | ]
850 | }
851 |
852 | mock_ctx = AsyncMock()
853 | mock_client = MagicMock()
854 | mock_client.list_runs.return_value = mock_response
855 |
856 | with patch(
857 | 'awslabs.aws_healthomics_mcp_server.tools.workflow_execution.get_omics_client',
858 | return_value=mock_client,
859 | ):
860 | # Filter for runs after the only run's creation time
861 | result = await list_runs(
862 | ctx=mock_ctx,
863 | max_results=10,
864 | next_token=None,
865 | status=None,
866 | created_after='2023-06-10T00:00:00Z',
867 | created_before=None,
868 | )
869 |
870 | # Should return empty list
871 | assert len(result['runs']) == 0
872 | assert 'nextToken' not in result
873 |
874 |
875 | @pytest.mark.asyncio
876 | async def test_list_runs_date_filter_with_missing_creation_time():
877 | """Test date filtering when some runs have missing creation times."""
878 | base_time = datetime(2023, 6, 15, 12, 0, 0, tzinfo=timezone.utc)
879 |
880 | mock_response = {
881 | 'items': [
882 | {
883 | 'id': 'run-1',
884 | 'name': 'run-with-time',
885 | 'status': 'COMPLETED',
886 | 'workflowId': 'wfl-1',
887 | 'workflowType': 'WDL',
888 | 'creationTime': base_time,
889 | },
890 | {
891 | 'id': 'run-2',
892 | 'name': 'run-without-time',
893 | 'status': 'COMPLETED',
894 | 'workflowId': 'wfl-2',
895 | 'workflowType': 'WDL',
896 | # No creationTime field
897 | },
898 | ]
899 | }
900 |
901 | mock_ctx = AsyncMock()
902 | mock_client = MagicMock()
903 | mock_client.list_runs.return_value = mock_response
904 |
905 | with patch(
906 | 'awslabs.aws_healthomics_mcp_server.tools.workflow_execution.get_omics_client',
907 | return_value=mock_client,
908 | ):
909 | result = await list_runs(
910 | ctx=mock_ctx,
911 | max_results=10,
912 | next_token=None,
913 | status=None,
914 | created_after='2023-06-10T00:00:00Z',
915 | created_before=None,
916 | )
917 |
918 | # Should return only the run with a valid creation time
919 | assert len(result['runs']) == 1
920 | assert result['runs'][0]['id'] == 'run-1'
921 |
922 |
923 | @pytest.mark.asyncio
924 | async def test_parse_iso_datetime_various_formats():
925 | """Test the parse_iso_datetime helper function with various formats."""
926 | from awslabs.aws_healthomics_mcp_server.tools.workflow_execution import parse_iso_datetime
927 |
928 | # Test various valid formats
929 | dt1 = parse_iso_datetime('2023-06-15T12:00:00Z')
930 | assert dt1.year == 2023
931 | assert dt1.month == 6
932 | assert dt1.day == 15
933 |
934 | dt2 = parse_iso_datetime('2023-06-15T12:00:00+00:00')
935 | assert dt2.year == 2023
936 |
937 | dt3 = parse_iso_datetime('2023-06-15T12:00:00')
938 | assert dt3.year == 2023
939 |
940 | # Test invalid format
941 | with pytest.raises(ValueError, match='Invalid datetime format'):
942 | parse_iso_datetime('not-a-date')
943 |
944 |
945 | @pytest.mark.asyncio
946 | async def test_filter_runs_by_creation_time():
947 | """Test the filter_runs_by_creation_time helper function."""
948 | from awslabs.aws_healthomics_mcp_server.tools.workflow_execution import (
949 | filter_runs_by_creation_time,
950 | )
951 |
952 | base_time = datetime(2023, 6, 15, 12, 0, 0, tzinfo=timezone.utc)
953 |
954 | runs = [
955 | {
956 | 'id': 'run-1',
957 | 'creationTime': (base_time - timedelta(days=10)).isoformat(),
958 | },
959 | {
960 | 'id': 'run-2',
961 | 'creationTime': base_time.isoformat(),
962 | },
963 | {
964 | 'id': 'run-3',
965 | 'creationTime': (base_time + timedelta(days=10)).isoformat(),
966 | },
967 | ]
968 |
969 | # Test no filters
970 | result = filter_runs_by_creation_time(runs)
971 | assert len(result) == 3
972 |
973 | # Test created_after filter
974 | result = filter_runs_by_creation_time(runs, created_after='2023-06-10T00:00:00Z')
975 | assert len(result) == 2
976 | assert result[0]['id'] == 'run-2'
977 | assert result[1]['id'] == 'run-3'
978 |
979 | # Test created_before filter
980 | result = filter_runs_by_creation_time(runs, created_before='2023-06-20T00:00:00Z')
981 | assert len(result) == 2
982 | assert result[0]['id'] == 'run-1'
983 | assert result[1]['id'] == 'run-2'
984 |
985 | # Test both filters
986 | result = filter_runs_by_creation_time(
987 | runs, created_after='2023-06-10T00:00:00Z', created_before='2023-06-20T00:00:00Z'
988 | )
989 | assert len(result) == 1
990 | assert result[0]['id'] == 'run-2'
991 |
992 |
993 | @pytest.mark.asyncio
994 | async def test_start_run_success():
995 | """Test successful workflow run start."""
996 | # Mock response data
997 | mock_response = {
998 | 'id': 'run-12345',
999 | 'arn': 'arn:aws:omics:us-east-1:123456789012:run/run-12345',
1000 | 'status': 'PENDING',
1001 | 'name': 'test-run',
1002 | 'workflowId': 'wfl-12345',
1003 | }
1004 |
1005 | # Mock context and client
1006 | mock_ctx = AsyncMock()
1007 | mock_client = MagicMock()
1008 | mock_client.start_run.return_value = mock_response
1009 |
1010 | with patch(
1011 | 'awslabs.aws_healthomics_mcp_server.tools.workflow_execution.get_omics_client',
1012 | return_value=mock_client,
1013 | ):
1014 | result = await start_run(
1015 | mock_ctx,
1016 | workflow_id='wfl-12345',
1017 | role_arn='arn:aws:iam::123456789012:role/HealthOmicsRole',
1018 | name='test-run',
1019 | output_uri='s3://my-bucket/outputs/',
1020 | parameters={'param1': 'value1'},
1021 | workflow_version_name=None,
1022 | storage_type='DYNAMIC',
1023 | storage_capacity=None,
1024 | cache_id=None,
1025 | cache_behavior=None,
1026 | )
1027 |
1028 | # Verify client was called correctly
1029 | mock_client.start_run.assert_called_once_with(
1030 | workflowId='wfl-12345',
1031 | roleArn='arn:aws:iam::123456789012:role/HealthOmicsRole',
1032 | name='test-run',
1033 | outputUri='s3://my-bucket/outputs/',
1034 | parameters={'param1': 'value1'},
1035 | storageType='DYNAMIC',
1036 | )
1037 |
1038 | # Verify result contains expected fields
1039 | assert result['id'] == 'run-12345'
1040 | assert result['status'] == 'PENDING'
1041 | assert result['name'] == 'test-run'
1042 | assert result['workflowId'] == 'wfl-12345'
1043 |
1044 |
1045 | @pytest.mark.asyncio
1046 | async def test_start_run_with_static_storage():
1047 | """Test workflow run start with static storage."""
1048 | # Mock response data
1049 | mock_response = {
1050 | 'id': 'run-12345',
1051 | 'arn': 'arn:aws:omics:us-east-1:123456789012:run/run-12345',
1052 | 'status': 'PENDING',
1053 | 'name': 'test-run',
1054 | 'workflowId': 'wfl-12345',
1055 | }
1056 |
1057 | # Mock context and client
1058 | mock_ctx = AsyncMock()
1059 | mock_client = MagicMock()
1060 | mock_client.start_run.return_value = mock_response
1061 |
1062 | with patch(
1063 | 'awslabs.aws_healthomics_mcp_server.tools.workflow_execution.get_omics_client',
1064 | return_value=mock_client,
1065 | ):
1066 | await start_run(
1067 | mock_ctx,
1068 | workflow_id='wfl-12345',
1069 | role_arn='arn:aws:iam::123456789012:role/HealthOmicsRole',
1070 | name='test-run',
1071 | output_uri='s3://my-bucket/outputs/',
1072 | parameters={'param1': 'value1'},
1073 | workflow_version_name=None,
1074 | storage_type='STATIC',
1075 | storage_capacity=1000,
1076 | cache_id=None,
1077 | cache_behavior=None,
1078 | )
1079 |
1080 | # Verify client was called with static storage parameters
1081 | mock_client.start_run.assert_called_once_with(
1082 | workflowId='wfl-12345',
1083 | roleArn='arn:aws:iam::123456789012:role/HealthOmicsRole',
1084 | name='test-run',
1085 | outputUri='s3://my-bucket/outputs/',
1086 | parameters={'param1': 'value1'},
1087 | storageType='STATIC',
1088 | storageCapacity=1000,
1089 | )
1090 |
1091 |
1092 | @pytest.mark.asyncio
1093 | async def test_start_run_static_without_capacity():
1094 | """Test workflow run start with static storage but no capacity."""
1095 | # Mock context
1096 | mock_ctx = AsyncMock()
1097 |
1098 | with pytest.raises(ValueError, match='Storage capacity is required'):
1099 | await start_run(
1100 | mock_ctx,
1101 | workflow_id='wfl-12345',
1102 | role_arn='arn:aws:iam::123456789012:role/HealthOmicsRole',
1103 | name='test-run',
1104 | output_uri='s3://my-bucket/outputs/',
1105 | parameters={'param1': 'value1'},
1106 | workflow_version_name=None,
1107 | storage_type='STATIC',
1108 | storage_capacity=None,
1109 | cache_id=None,
1110 | cache_behavior=None,
1111 | )
1112 |
1113 | # Verify error was reported to context
1114 | mock_ctx.error.assert_called_once()
1115 |
1116 |
1117 | @pytest.mark.asyncio
1118 | async def test_start_run_with_cache():
1119 | """Test workflow run start with caching enabled."""
1120 | # Mock response data
1121 | mock_response = {
1122 | 'id': 'run-12345',
1123 | 'arn': 'arn:aws:omics:us-east-1:123456789012:run/run-12345',
1124 | 'status': 'PENDING',
1125 | 'name': 'test-run',
1126 | 'workflowId': 'wfl-12345',
1127 | }
1128 |
1129 | # Mock context and client
1130 | mock_ctx = AsyncMock()
1131 | mock_client = MagicMock()
1132 | mock_client.start_run.return_value = mock_response
1133 |
1134 | with patch(
1135 | 'awslabs.aws_healthomics_mcp_server.tools.workflow_execution.get_omics_client',
1136 | return_value=mock_client,
1137 | ):
1138 | await start_run(
1139 | mock_ctx,
1140 | workflow_id='wfl-12345',
1141 | role_arn='arn:aws:iam::123456789012:role/HealthOmicsRole',
1142 | name='test-run',
1143 | output_uri='s3://my-bucket/outputs/',
1144 | parameters={'param1': 'value1'},
1145 | workflow_version_name=None,
1146 | storage_type='DYNAMIC',
1147 | storage_capacity=None,
1148 | cache_id='cache-12345',
1149 | cache_behavior='CACHE_ALWAYS',
1150 | )
1151 |
1152 | # Verify client was called with cache parameters
1153 | expected_call = mock_client.start_run.call_args[1]
1154 | assert expected_call['cacheId'] == 'cache-12345'
1155 | assert expected_call['cacheBehavior'] == 'CACHE_ALWAYS'
1156 |
1157 |
1158 | @pytest.mark.asyncio
1159 | async def test_start_run_boto_error():
1160 | """Test handling of BotoCoreError in start_run."""
1161 | # Mock context and client
1162 | mock_ctx = AsyncMock()
1163 | mock_client = MagicMock()
1164 | mock_client.start_run.side_effect = botocore.exceptions.BotoCoreError()
1165 |
1166 | with (
1167 | patch(
1168 | 'awslabs.aws_healthomics_mcp_server.tools.workflow_execution.get_omics_client',
1169 | return_value=mock_client,
1170 | ),
1171 | pytest.raises(botocore.exceptions.BotoCoreError),
1172 | ):
1173 | await start_run(
1174 | mock_ctx,
1175 | workflow_id='wfl-12345',
1176 | role_arn='arn:aws:iam::123456789012:role/HealthOmicsRole',
1177 | name='test-run',
1178 | output_uri='s3://my-bucket/outputs/',
1179 | parameters={'param1': 'value1'},
1180 | workflow_version_name=None,
1181 | storage_type='DYNAMIC',
1182 | storage_capacity=None,
1183 | cache_id=None,
1184 | cache_behavior=None,
1185 | )
1186 |
1187 | # Verify error was reported to context
1188 | mock_ctx.error.assert_called_once()
1189 | assert 'AWS error starting run' in mock_ctx.error.call_args[0][0]
1190 |
1191 |
1192 | @pytest.mark.asyncio
1193 | async def test_list_run_tasks_success():
1194 | """Test successful listing of run tasks."""
1195 | # Mock response data
1196 | creation_time = datetime.now(timezone.utc)
1197 | start_time = creation_time
1198 | stop_time = datetime.now(timezone.utc)
1199 |
1200 | mock_response = {
1201 | 'items': [
1202 | {
1203 | 'taskId': 'task-12345',
1204 | 'status': 'COMPLETED',
1205 | 'name': 'test-task',
1206 | 'cpus': 2,
1207 | 'memory': 4096,
1208 | 'startTime': start_time,
1209 | 'stopTime': stop_time,
1210 | },
1211 | {
1212 | 'taskId': 'task-67890',
1213 | 'status': 'RUNNING',
1214 | 'name': 'test-task-2',
1215 | 'cpus': 4,
1216 | 'memory': 8192,
1217 | 'startTime': start_time,
1218 | },
1219 | ],
1220 | 'nextToken': 'next-token-123',
1221 | }
1222 |
1223 | # Mock context and client
1224 | mock_ctx = AsyncMock()
1225 | mock_client = MagicMock()
1226 | mock_client.list_run_tasks.return_value = mock_response
1227 |
1228 | with patch(
1229 | 'awslabs.aws_healthomics_mcp_server.tools.workflow_execution.get_omics_client',
1230 | return_value=mock_client,
1231 | ):
1232 | result = await list_run_tasks(
1233 | mock_ctx,
1234 | run_id='run-12345',
1235 | max_results=10,
1236 | next_token=None,
1237 | status='COMPLETED',
1238 | )
1239 |
1240 | # Verify client was called correctly
1241 | mock_client.list_run_tasks.assert_called_once_with(
1242 | id='run-12345',
1243 | maxResults=10,
1244 | status='COMPLETED',
1245 | )
1246 |
1247 | # Verify result structure
1248 | assert 'tasks' in result
1249 | assert 'nextToken' in result
1250 | assert len(result['tasks']) == 2
1251 |
1252 | # Verify first task
1253 | task1 = result['tasks'][0]
1254 | assert task1['taskId'] == 'task-12345'
1255 | assert task1['status'] == 'COMPLETED'
1256 | assert task1['name'] == 'test-task'
1257 | assert task1['cpus'] == 2
1258 | assert task1['memory'] == 4096
1259 | assert task1['startTime'] == start_time.isoformat()
1260 | assert task1['stopTime'] == stop_time.isoformat()
1261 |
1262 | # Verify second task (no stopTime since it's still running)
1263 | task2 = result['tasks'][1]
1264 | assert task2['taskId'] == 'task-67890'
1265 | assert task2['status'] == 'RUNNING'
1266 | assert task2['startTime'] == start_time.isoformat()
1267 | assert 'stopTime' not in task2
1268 |
1269 |
1270 | @pytest.mark.asyncio
1271 | async def test_list_run_tasks_empty_response():
1272 | """Test listing run tasks with empty response."""
1273 | # Mock empty response
1274 | mock_response = {'items': []}
1275 |
1276 | # Mock context and client
1277 | mock_ctx = AsyncMock()
1278 | mock_client = MagicMock()
1279 | mock_client.list_run_tasks.return_value = mock_response
1280 |
1281 | with patch(
1282 | 'awslabs.aws_healthomics_mcp_server.tools.workflow_execution.get_omics_client',
1283 | return_value=mock_client,
1284 | ):
1285 | result = await list_run_tasks(
1286 | mock_ctx,
1287 | run_id='run-12345',
1288 | max_results=10,
1289 | next_token=None,
1290 | status=None,
1291 | )
1292 |
1293 | # Verify result structure
1294 | assert result['tasks'] == []
1295 | assert 'nextToken' not in result
1296 |
1297 |
1298 | @pytest.mark.asyncio
1299 | async def test_list_run_tasks_boto_error():
1300 | """Test handling of BotoCoreError in list_run_tasks."""
1301 | # Mock context and client
1302 | mock_ctx = AsyncMock()
1303 | mock_client = MagicMock()
1304 | mock_client.list_run_tasks.side_effect = botocore.exceptions.BotoCoreError()
1305 |
1306 | with (
1307 | patch(
1308 | 'awslabs.aws_healthomics_mcp_server.tools.workflow_execution.get_omics_client',
1309 | return_value=mock_client,
1310 | ),
1311 | pytest.raises(botocore.exceptions.BotoCoreError),
1312 | ):
1313 | await list_run_tasks(
1314 | mock_ctx,
1315 | run_id='run-12345',
1316 | max_results=10,
1317 | next_token=None,
1318 | status=None,
1319 | )
1320 |
1321 | # Verify error was reported to context
1322 | mock_ctx.error.assert_called_once()
1323 | assert 'AWS error listing tasks for run' in mock_ctx.error.call_args[0][0]
1324 |
1325 |
1326 | @pytest.mark.asyncio
1327 | async def test_list_runs_with_invalid_creation_time():
1328 | """Test list_runs handling of runs with invalid creation times."""
1329 | # Mock context and client
1330 | mock_ctx = AsyncMock()
1331 | mock_client = MagicMock()
1332 |
1333 | # Create a mock datetime object that will fail when isoformat() is called
1334 | class MockInvalidDateTime:
1335 | def isoformat(self):
1336 | raise ValueError('Invalid datetime')
1337 |
1338 | # Mock response with invalid creation time
1339 | mock_response = {
1340 | 'items': [
1341 | {
1342 | 'id': 'run-12345',
1343 | 'name': 'test-run',
1344 | 'status': 'COMPLETED',
1345 | 'creationTime': MockInvalidDateTime(), # Invalid datetime
1346 | },
1347 | {
1348 | 'id': 'run-67890',
1349 | 'name': 'test-run-2',
1350 | 'status': 'COMPLETED',
1351 | 'creationTime': datetime.now(timezone.utc), # Valid datetime
1352 | },
1353 | ],
1354 | 'nextToken': None,
1355 | }
1356 | mock_client.list_runs.return_value = mock_response
1357 |
1358 | with patch(
1359 | 'awslabs.aws_healthomics_mcp_server.tools.workflow_execution.get_omics_client',
1360 | return_value=mock_client,
1361 | ):
1362 | # This should raise an exception due to the invalid datetime
1363 | with pytest.raises(Exception, match='Invalid datetime'):
1364 | await list_runs(
1365 | ctx=mock_ctx,
1366 | max_results=10,
1367 | next_token=None,
1368 | status=None,
1369 | created_after=None,
1370 | created_before=None,
1371 | )
1372 |
1373 | # Verify error was reported to context
1374 | mock_ctx.error.assert_called_once()
1375 | assert 'Unexpected error listing runs' in mock_ctx.error.call_args[0][0]
1376 |
1377 |
1378 | # Note: get_omics_client tests have been moved to test_aws_utils.py since the function
1379 | # is now centralized in aws_utils.py
1380 |
1381 |
1382 | @pytest.mark.asyncio
1383 | async def test_start_run_invalid_storage_type():
1384 | """Test start_run with invalid storage type."""
1385 | mock_ctx = AsyncMock()
1386 |
1387 | with pytest.raises(ValueError, match='Invalid storage type'):
1388 | await start_run(
1389 | ctx=mock_ctx,
1390 | workflow_id='wfl-12345',
1391 | role_arn='arn:aws:iam::123456789012:role/HealthOmicsRole',
1392 | name='test-run',
1393 | output_uri='s3://bucket/output/',
1394 | parameters={'param1': 'value1'},
1395 | workflow_version_name=None,
1396 | storage_type='INVALID_TYPE', # Invalid storage type
1397 | storage_capacity=None,
1398 | cache_id=None,
1399 | cache_behavior=None,
1400 | )
1401 |
1402 | # Verify error was reported to context
1403 | mock_ctx.error.assert_called_once()
1404 | assert 'Invalid storage type' in mock_ctx.error.call_args[0][0]
1405 |
1406 |
1407 | @pytest.mark.asyncio
1408 | async def test_start_run_static_storage_without_capacity():
1409 | """Test start_run with STATIC storage but no capacity."""
1410 | mock_ctx = AsyncMock()
1411 |
1412 | with pytest.raises(
1413 | ValueError, match='Storage capacity is required when using STATIC storage type'
1414 | ):
1415 | await start_run(
1416 | ctx=mock_ctx,
1417 | workflow_id='wfl-12345',
1418 | role_arn='arn:aws:iam::123456789012:role/HealthOmicsRole',
1419 | name='test-run',
1420 | output_uri='s3://bucket/output/',
1421 | parameters={'param1': 'value1'},
1422 | workflow_version_name=None,
1423 | storage_type='STATIC',
1424 | storage_capacity=None, # Missing capacity for STATIC storage
1425 | cache_id=None,
1426 | cache_behavior=None,
1427 | )
1428 |
1429 | # Verify error was reported to context
1430 | mock_ctx.error.assert_called_once()
1431 | assert (
1432 | 'Storage capacity is required when using STATIC storage type'
1433 | in mock_ctx.error.call_args[0][0]
1434 | )
1435 |
1436 |
1437 | @pytest.mark.asyncio
1438 | async def test_start_run_invalid_cache_behavior():
1439 | """Test start_run with invalid cache behavior."""
1440 | mock_ctx = AsyncMock()
1441 |
1442 | with pytest.raises(ValueError, match='Invalid cache behavior'):
1443 | await start_run(
1444 | ctx=mock_ctx,
1445 | workflow_id='wfl-12345',
1446 | role_arn='arn:aws:iam::123456789012:role/HealthOmicsRole',
1447 | name='test-run',
1448 | output_uri='s3://bucket/output/',
1449 | parameters={'param1': 'value1'},
1450 | workflow_version_name=None,
1451 | storage_type='DYNAMIC',
1452 | storage_capacity=None,
1453 | cache_id=None,
1454 | cache_behavior='INVALID_BEHAVIOR', # Invalid cache behavior
1455 | )
1456 |
1457 | # Verify error was reported to context
1458 | mock_ctx.error.assert_called_once()
1459 | assert 'Invalid cache behavior' in mock_ctx.error.call_args[0][0]
1460 |
1461 |
1462 | @pytest.mark.asyncio
1463 | async def test_start_run_cache_behavior_without_cache_id():
1464 | """Test start_run with cache_behavior but no cache_id."""
1465 | mock_ctx = AsyncMock()
1466 |
1467 | with pytest.raises(ValueError, match='cache_behavior requires cache_id to be provided'):
1468 | await start_run(
1469 | ctx=mock_ctx,
1470 | workflow_id='wfl-12345',
1471 | role_arn='arn:aws:iam::123456789012:role/HealthOmicsRole',
1472 | name='test-run',
1473 | output_uri='s3://bucket/output/',
1474 | parameters={'param1': 'value1'},
1475 | workflow_version_name=None,
1476 | storage_type='DYNAMIC',
1477 | storage_capacity=None,
1478 | cache_id=None, # No cache_id provided
1479 | cache_behavior='CACHE_ALWAYS', # But cache_behavior is provided
1480 | )
1481 |
1482 | # Verify error was reported to context
1483 | mock_ctx.error.assert_called_once()
1484 | assert 'cache_behavior requires cache_id to be provided' in mock_ctx.error.call_args[0][0]
1485 |
1486 |
1487 | @pytest.mark.asyncio
1488 | async def test_start_run_invalid_s3_uri():
1489 | """Test start_run with invalid S3 URI."""
1490 | mock_ctx = AsyncMock()
1491 |
1492 | with patch(
1493 | 'awslabs.aws_healthomics_mcp_server.tools.workflow_execution.ensure_s3_uri_ends_with_slash'
1494 | ) as mock_ensure_s3_uri:
1495 | mock_ensure_s3_uri.side_effect = ValueError('Invalid S3 URI format')
1496 |
1497 | with pytest.raises(ValueError, match='Invalid S3 URI'):
1498 | await start_run(
1499 | ctx=mock_ctx,
1500 | workflow_id='wfl-12345',
1501 | role_arn='arn:aws:iam::123456789012:role/HealthOmicsRole',
1502 | name='test-run',
1503 | output_uri='invalid-uri', # Invalid S3 URI
1504 | parameters={'param1': 'value1'},
1505 | workflow_version_name=None,
1506 | storage_type='DYNAMIC',
1507 | storage_capacity=None,
1508 | cache_id=None,
1509 | cache_behavior=None,
1510 | )
1511 |
1512 | # Verify error was reported to context
1513 | mock_ctx.error.assert_called_once()
1514 | assert 'Invalid S3 URI' in mock_ctx.error.call_args[0][0]
1515 |
1516 |
1517 | @pytest.mark.asyncio
1518 | async def test_start_run_boto_error_new():
1519 | """Test start_run with BotoCoreError."""
1520 | mock_ctx = AsyncMock()
1521 | mock_client = MagicMock()
1522 | mock_client.start_run.side_effect = botocore.exceptions.BotoCoreError()
1523 |
1524 | with patch(
1525 | 'awslabs.aws_healthomics_mcp_server.tools.workflow_execution.get_omics_client',
1526 | return_value=mock_client,
1527 | ):
1528 | with patch(
1529 | 'awslabs.aws_healthomics_mcp_server.tools.workflow_execution.ensure_s3_uri_ends_with_slash',
1530 | return_value='s3://bucket/output/',
1531 | ):
1532 | with pytest.raises(botocore.exceptions.BotoCoreError):
1533 | await start_run(
1534 | ctx=mock_ctx,
1535 | workflow_id='wfl-12345',
1536 | role_arn='arn:aws:iam::123456789012:role/HealthOmicsRole',
1537 | name='test-run',
1538 | output_uri='s3://bucket/output/',
1539 | parameters={'param1': 'value1'},
1540 | workflow_version_name=None,
1541 | storage_type='DYNAMIC',
1542 | storage_capacity=None,
1543 | cache_id=None,
1544 | cache_behavior=None,
1545 | )
1546 |
1547 | # Verify error was reported to context
1548 | mock_ctx.error.assert_called_once()
1549 | assert 'AWS error starting run' in mock_ctx.error.call_args[0][0]
1550 |
1551 |
1552 | @pytest.mark.asyncio
1553 | async def test_start_run_unexpected_error_new():
1554 | """Test start_run with unexpected error."""
1555 | mock_ctx = AsyncMock()
1556 | mock_client = MagicMock()
1557 | mock_client.start_run.side_effect = Exception('Unexpected error')
1558 |
1559 | with patch(
1560 | 'awslabs.aws_healthomics_mcp_server.tools.workflow_execution.get_omics_client',
1561 | return_value=mock_client,
1562 | ):
1563 | with patch(
1564 | 'awslabs.aws_healthomics_mcp_server.tools.workflow_execution.ensure_s3_uri_ends_with_slash',
1565 | return_value='s3://bucket/output/',
1566 | ):
1567 | with pytest.raises(Exception, match='Unexpected error'):
1568 | await start_run(
1569 | ctx=mock_ctx,
1570 | workflow_id='wfl-12345',
1571 | role_arn='arn:aws:iam::123456789012:role/HealthOmicsRole',
1572 | name='test-run',
1573 | output_uri='s3://bucket/output/',
1574 | parameters={'param1': 'value1'},
1575 | workflow_version_name=None,
1576 | storage_type='DYNAMIC',
1577 | storage_capacity=None,
1578 | cache_id=None,
1579 | cache_behavior=None,
1580 | )
1581 |
1582 | # Verify error was reported to context
1583 | mock_ctx.error.assert_called_once()
1584 | assert 'Unexpected error starting run' in mock_ctx.error.call_args[0][0]
1585 |
1586 |
1587 | @pytest.mark.asyncio
1588 | async def test_list_run_tasks_invalid_status():
1589 | """Test list_run_tasks with invalid status."""
1590 | mock_ctx = AsyncMock()
1591 | mock_client = MagicMock()
1592 |
1593 | # Mock the client to raise a ValidationException for invalid status
1594 | mock_client.list_run_tasks.side_effect = botocore.exceptions.ClientError(
1595 | {'Error': {'Code': 'ValidationException', 'Message': 'Invalid status value'}},
1596 | 'ListRunTasks',
1597 | )
1598 |
1599 | with patch(
1600 | 'awslabs.aws_healthomics_mcp_server.tools.workflow_execution.get_omics_client',
1601 | return_value=mock_client,
1602 | ):
1603 | with pytest.raises(botocore.exceptions.ClientError):
1604 | await list_run_tasks(
1605 | ctx=mock_ctx,
1606 | run_id='1234567890', # Use valid run ID format
1607 | max_results=10,
1608 | next_token=None,
1609 | status='INVALID_STATUS', # Invalid task status
1610 | )
1611 |
1612 | # Verify error was reported to context
1613 | mock_ctx.error.assert_called_once()
1614 | assert 'Unexpected error listing tasks for run' in mock_ctx.error.call_args[0][0]
1615 |
1616 |
1617 | @pytest.mark.asyncio
1618 | async def test_get_run_boto_error_new():
1619 | """Test get_run with BotoCoreError."""
1620 | mock_ctx = AsyncMock()
1621 | mock_client = MagicMock()
1622 | mock_client.get_run.side_effect = botocore.exceptions.BotoCoreError()
1623 |
1624 | with patch(
1625 | 'awslabs.aws_healthomics_mcp_server.tools.workflow_execution.get_omics_client',
1626 | return_value=mock_client,
1627 | ):
1628 | with pytest.raises(botocore.exceptions.BotoCoreError):
1629 | await get_run(ctx=mock_ctx, run_id='run-12345')
1630 |
1631 | # Verify error was reported to context
1632 | mock_ctx.error.assert_called_once()
1633 | assert 'AWS error getting run' in mock_ctx.error.call_args[0][0]
1634 |
1635 |
1636 | @pytest.mark.asyncio
1637 | async def test_get_run_unexpected_error_new():
1638 | """Test get_run with unexpected error."""
1639 | mock_ctx = AsyncMock()
1640 | mock_client = MagicMock()
1641 | mock_client.get_run.side_effect = Exception('Unexpected error')
1642 |
1643 | with patch(
1644 | 'awslabs.aws_healthomics_mcp_server.tools.workflow_execution.get_omics_client',
1645 | return_value=mock_client,
1646 | ):
1647 | with pytest.raises(Exception, match='Unexpected error'):
1648 | await get_run(ctx=mock_ctx, run_id='run-12345')
1649 |
1650 | # Verify error was reported to context
1651 | mock_ctx.error.assert_called_once()
1652 | assert 'Unexpected error getting run' in mock_ctx.error.call_args[0][0]
1653 |
1654 |
1655 | @pytest.mark.asyncio
1656 | async def test_list_run_tasks_boto_error_new():
1657 | """Test list_run_tasks with BotoCoreError."""
1658 | mock_ctx = AsyncMock()
1659 | mock_client = MagicMock()
1660 | mock_client.list_run_tasks.side_effect = botocore.exceptions.BotoCoreError()
1661 |
1662 | with patch(
1663 | 'awslabs.aws_healthomics_mcp_server.tools.workflow_execution.get_omics_client',
1664 | return_value=mock_client,
1665 | ):
1666 | with pytest.raises(botocore.exceptions.BotoCoreError):
1667 | await list_run_tasks(
1668 | ctx=mock_ctx,
1669 | run_id='1234567890',
1670 | max_results=10,
1671 | next_token=None,
1672 | status=None,
1673 | )
1674 |
1675 | # Verify error was reported to context
1676 | mock_ctx.error.assert_called_once()
1677 | assert 'AWS error listing tasks for run' in mock_ctx.error.call_args[0][0]
1678 |
1679 |
1680 | @pytest.mark.asyncio
1681 | async def test_list_run_tasks_unexpected_error():
1682 | """Test list_run_tasks with unexpected error."""
1683 | mock_ctx = AsyncMock()
1684 | mock_client = MagicMock()
1685 | mock_client.list_run_tasks.side_effect = Exception('Unexpected error')
1686 |
1687 | with patch(
1688 | 'awslabs.aws_healthomics_mcp_server.tools.workflow_execution.get_omics_client',
1689 | return_value=mock_client,
1690 | ):
1691 | with pytest.raises(Exception, match='Unexpected error'):
1692 | await list_run_tasks(
1693 | ctx=mock_ctx,
1694 | run_id='1234567890',
1695 | max_results=10,
1696 | next_token=None,
1697 | status=None,
1698 | )
1699 |
1700 | # Verify error was reported to context
1701 | mock_ctx.error.assert_called_once()
1702 | assert 'Unexpected error listing tasks for run' in mock_ctx.error.call_args[0][0]
1703 |
1704 |
1705 | # Tests for get_run_task function
1706 |
1707 |
1708 | @pytest.mark.asyncio
1709 | async def test_get_run_task_success():
1710 | """Test successful retrieval of task details."""
1711 | # Mock response data with all possible fields
1712 | start_time = datetime.now(timezone.utc)
1713 | stop_time = datetime.now(timezone.utc)
1714 |
1715 | mock_response = {
1716 | 'taskId': 'task-12345',
1717 | 'status': 'COMPLETED',
1718 | 'name': 'test-task',
1719 | 'cpus': 4,
1720 | 'memory': 8192,
1721 | 'startTime': start_time,
1722 | 'stopTime': stop_time,
1723 | 'statusMessage': 'Task completed successfully',
1724 | 'logStream': 'log-stream-name',
1725 | 'imageDetails': {
1726 | 'imageUri': '123456789012.dkr.ecr.us-east-1.amazonaws.com/my-repo:latest',
1727 | 'imageDigest': 'sha256:abcdef123456...',
1728 | },
1729 | }
1730 |
1731 | # Mock context and client
1732 | mock_ctx = AsyncMock()
1733 | mock_client = MagicMock()
1734 | mock_client.get_run_task.return_value = mock_response
1735 |
1736 | with patch(
1737 | 'awslabs.aws_healthomics_mcp_server.tools.workflow_execution.get_omics_client',
1738 | return_value=mock_client,
1739 | ):
1740 | result = await get_run_task(mock_ctx, run_id='run-12345', task_id='task-12345')
1741 |
1742 | # Verify client was called correctly
1743 | mock_client.get_run_task.assert_called_once_with(id='run-12345', taskId='task-12345')
1744 |
1745 | # Verify result contains all expected fields
1746 | assert result['taskId'] == 'task-12345'
1747 | assert result['status'] == 'COMPLETED'
1748 | assert result['name'] == 'test-task'
1749 | assert result['cpus'] == 4
1750 | assert result['memory'] == 8192
1751 | assert result['startTime'] == start_time.isoformat()
1752 | assert result['stopTime'] == stop_time.isoformat()
1753 | assert result['statusMessage'] == 'Task completed successfully'
1754 | assert result['logStream'] == 'log-stream-name'
1755 | assert result['imageDetails'] == {
1756 | 'imageUri': '123456789012.dkr.ecr.us-east-1.amazonaws.com/my-repo:latest',
1757 | 'imageDigest': 'sha256:abcdef123456...',
1758 | }
1759 |
1760 |
1761 | @pytest.mark.asyncio
1762 | async def test_get_run_task_minimal_response():
1763 | """Test task retrieval with minimal response fields."""
1764 | # Mock response with minimal required fields
1765 | mock_response = {
1766 | 'taskId': 'task-12345',
1767 | 'status': 'RUNNING',
1768 | 'name': 'test-task',
1769 | 'cpus': 2,
1770 | 'memory': 4096,
1771 | }
1772 |
1773 | # Mock context and client
1774 | mock_ctx = AsyncMock()
1775 | mock_client = MagicMock()
1776 | mock_client.get_run_task.return_value = mock_response
1777 |
1778 | with patch(
1779 | 'awslabs.aws_healthomics_mcp_server.tools.workflow_execution.get_omics_client',
1780 | return_value=mock_client,
1781 | ):
1782 | result = await get_run_task(mock_ctx, run_id='run-12345', task_id='task-12345')
1783 |
1784 | # Verify required fields
1785 | assert result['taskId'] == 'task-12345'
1786 | assert result['status'] == 'RUNNING'
1787 | assert result['name'] == 'test-task'
1788 | assert result['cpus'] == 2
1789 | assert result['memory'] == 4096
1790 |
1791 | # Verify optional fields are not present
1792 | assert 'startTime' not in result
1793 | assert 'stopTime' not in result
1794 | assert 'statusMessage' not in result
1795 | assert 'logStream' not in result
1796 | assert 'imageDetails' not in result
1797 |
1798 |
1799 | @pytest.mark.asyncio
1800 | async def test_get_run_task_with_image_details():
1801 | """Test task retrieval specifically focusing on imageDetails field."""
1802 | # Mock response with imageDetails
1803 | mock_response = {
1804 | 'taskId': 'task-12345',
1805 | 'status': 'COMPLETED',
1806 | 'name': 'test-task',
1807 | 'cpus': 4,
1808 | 'memory': 8192,
1809 | 'imageDetails': {
1810 | 'imageUri': 'public.ecr.aws/biocontainers/samtools:1.15.1--h1170115_0',
1811 | 'imageDigest': 'sha256:1234567890abcdef...',
1812 | 'registryId': '123456789012',
1813 | 'repositoryName': 'biocontainers/samtools',
1814 | },
1815 | }
1816 |
1817 | # Mock context and client
1818 | mock_ctx = AsyncMock()
1819 | mock_client = MagicMock()
1820 | mock_client.get_run_task.return_value = mock_response
1821 |
1822 | with patch(
1823 | 'awslabs.aws_healthomics_mcp_server.tools.workflow_execution.get_omics_client',
1824 | return_value=mock_client,
1825 | ):
1826 | result = await get_run_task(mock_ctx, run_id='run-12345', task_id='task-12345')
1827 |
1828 | # Verify imageDetails is properly returned
1829 | assert 'imageDetails' in result
1830 | assert (
1831 | result['imageDetails']['imageUri']
1832 | == 'public.ecr.aws/biocontainers/samtools:1.15.1--h1170115_0'
1833 | )
1834 | assert result['imageDetails']['imageDigest'] == 'sha256:1234567890abcdef...'
1835 | assert result['imageDetails']['registryId'] == '123456789012'
1836 | assert result['imageDetails']['repositoryName'] == 'biocontainers/samtools'
1837 |
1838 |
1839 | @pytest.mark.asyncio
1840 | async def test_get_run_task_failed_status():
1841 | """Test task retrieval with failed status."""
1842 | # Mock response for failed task
1843 | mock_response = {
1844 | 'taskId': 'task-12345',
1845 | 'status': 'FAILED',
1846 | 'name': 'test-task',
1847 | 'cpus': 4,
1848 | 'memory': 8192,
1849 | 'statusMessage': 'Task failed due to resource constraints',
1850 | }
1851 |
1852 | # Mock context and client
1853 | mock_ctx = AsyncMock()
1854 | mock_client = MagicMock()
1855 | mock_client.get_run_task.return_value = mock_response
1856 |
1857 | with patch(
1858 | 'awslabs.aws_healthomics_mcp_server.tools.workflow_execution.get_omics_client',
1859 | return_value=mock_client,
1860 | ):
1861 | result = await get_run_task(mock_ctx, run_id='run-12345', task_id='task-12345')
1862 |
1863 | # Verify failure information
1864 | assert result['status'] == 'FAILED'
1865 | assert result['statusMessage'] == 'Task failed due to resource constraints'
1866 |
1867 |
1868 | @pytest.mark.asyncio
1869 | async def test_get_run_task_boto_error():
1870 | """Test handling of BotoCoreError."""
1871 | # Mock context and client
1872 | mock_ctx = AsyncMock()
1873 | mock_client = MagicMock()
1874 | mock_client.get_run_task.side_effect = botocore.exceptions.BotoCoreError()
1875 |
1876 | with patch(
1877 | 'awslabs.aws_healthomics_mcp_server.tools.workflow_execution.get_omics_client',
1878 | return_value=mock_client,
1879 | ):
1880 | with pytest.raises(botocore.exceptions.BotoCoreError):
1881 | await get_run_task(mock_ctx, run_id='run-12345', task_id='task-12345')
1882 |
1883 | # Verify error was reported to context
1884 | mock_ctx.error.assert_called_once()
1885 | assert 'AWS error getting task task-12345 for run run-12345' in mock_ctx.error.call_args[0][0]
1886 |
1887 |
1888 | @pytest.mark.asyncio
1889 | async def test_get_run_task_client_error():
1890 | """Test handling of ClientError."""
1891 | # Mock context and client
1892 | mock_ctx = AsyncMock()
1893 | mock_client = MagicMock()
1894 | mock_client.get_run_task.side_effect = botocore.exceptions.ClientError(
1895 | {'Error': {'Code': 'ResourceNotFoundException', 'Message': 'Task not found'}}, 'GetRunTask'
1896 | )
1897 |
1898 | with patch(
1899 | 'awslabs.aws_healthomics_mcp_server.tools.workflow_execution.get_omics_client',
1900 | return_value=mock_client,
1901 | ):
1902 | with pytest.raises(botocore.exceptions.ClientError):
1903 | await get_run_task(mock_ctx, run_id='run-12345', task_id='task-12345')
1904 |
1905 | # Verify error was reported to context
1906 | mock_ctx.error.assert_called_once()
1907 | assert 'AWS error getting task task-12345 for run run-12345' in mock_ctx.error.call_args[0][0]
1908 |
1909 |
1910 | @pytest.mark.asyncio
1911 | async def test_get_run_task_unexpected_error():
1912 | """Test handling of unexpected errors."""
1913 | # Mock context and client
1914 | mock_ctx = AsyncMock()
1915 | mock_client = MagicMock()
1916 | mock_client.get_run_task.side_effect = Exception('Unexpected error')
1917 |
1918 | with patch(
1919 | 'awslabs.aws_healthomics_mcp_server.tools.workflow_execution.get_omics_client',
1920 | return_value=mock_client,
1921 | ):
1922 | with pytest.raises(Exception, match='Unexpected error'):
1923 | await get_run_task(mock_ctx, run_id='run-12345', task_id='task-12345')
1924 |
1925 | # Verify error was reported to context
1926 | mock_ctx.error.assert_called_once()
1927 | assert (
1928 | 'Unexpected error getting task task-12345 for run run-12345'
1929 | in mock_ctx.error.call_args[0][0]
1930 | )
1931 |
```