@aws-cdk/aws-bedrock-agentcore-alpha 2.253.0-alpha.0 → 2.254.0-alpha.0

package/README.md

@@ -98,6 +98,8 @@ This construct library facilitates the deployment of Bedrock AgentCore primitive
     - [Tools schema For Lambda target](#tools-schema-for-lambda-target)
     - [Api schema For OpenAPI and Smithy target](#api-schema-for-openapi-and-smithy-target)
     - [Outbound auth](#outbound-auth)
+      - [Token Vault credential providers](#token-vault-credential-providers)
+      - [Workload identities](#workload-identities)
     - [Basic Gateway Target Creation](#basic-gateway-target-creation)
       - [Using addTarget methods (Recommended)](#using-addtarget-methods-recommended)
       - [Using static factory methods](#using-static-factory-methods)
@@ -1517,7 +1519,7 @@ credential provider attached enabling you to securely access targets whether the
 | `description` | `string` | No | Optional description for the gateway target. Maximum 200 characters |
 | `gateway` | `IGateway` | Yes | The gateway this target belongs to |
 | `targetConfiguration` | `ITargetConfiguration` | Yes | The target configuration (Lambda, OpenAPI, Smithy, or API Gateway). **Note:** Users typically don't create this directly. When using convenience methods like `GatewayTarget.forLambda()`, `GatewayTarget.forOpenApi()`, `GatewayTarget.forSmithy()`, `GatewayTarget.forApiGateway()`, `GatewayTarget.forMcpServer()` or the gateway's `addLambdaTarget()`, `addOpenApiTarget()`, `addSmithyTarget()`, `addApiGatewayTarget()`, `addMcpServerTarget()` methods, this configuration is created internally for you. Only needed when using the GatewayTarget constructor directly for [advanced scenarios](#advanced-usage-direct-configuration-for-gateway-target). |
-| `credentialProviderConfigurations` | `IGatewayCredentialProvider[]` | No | Credential providers for authentication. Defaults to `[GatewayCredentialProvider.fromIamRole()]`. Use `GatewayCredentialProvider.fromApiKeyIdentityArn()`, `GatewayCredentialProvider.fromOauthIdentityArn()`, or `GatewayCredentialProvider.fromIamRole()` |
+| `credentialProviderConfigurations` | `IGatewayCredentialProvider[]` | No | Credential providers for authentication. Defaults to `[GatewayCredentialProvider.fromIamRole()]`. With Token Vault L2 constructs, prefer `GatewayCredentialProvider.fromApiKeyIdentity()` / `fromOauthIdentity()`; otherwise use `fromApiKeyIdentityArn()` / `fromOauthIdentityArn()`, or `fromIamRole()` |
 | `validateOpenApiSchema` | `boolean` | No | (OpenAPI targets only) Whether to validate the OpenAPI schema at synthesis time. Defaults to `true`. Only applies to inline and local asset schemas. For more information refer here <https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/gateway-schema-openapi.html> |
 
 This approach gives you full control over the configuration but is typically not necessary for most use cases.
@@ -1724,6 +1726,93 @@ The gateway authenticates on its own behalf, not on behalf of a user.
 
 **Note > You need to set up the outbound identity before you can create a gateway target.
 
+#### Token Vault credential providers
+
+AgentCore stores outbound **API key** and **OAuth2** client credentials in Token Vault. This module includes L2 constructs that create those resources and connect them to gateway targets.
+
+**Shared OAuth2 fields** — Every `OAuth2CredentialProvider` factory accepts the same **`clientId`** and **`clientSecret`**, plus optional **`oAuth2CredentialProviderName`** and **`tags`**. Extra properties appear only when an IdP needs them (for example **`tenantId`** for Microsoft, or **`issuer`** / endpoint overrides for Okta and other *included* configurations).
+
+**Vendor factories** — Prefer `OAuth2CredentialProvider.usingSlack`, `.usingGithub`, `.usingGoogle`, `.usingMicrosoft`, `.usingOkta`, `.usingAuth0`, `.usingCognito`, and the other `using*` helpers for known providers. Each maps to the matching CloudFormation *included* provider configuration.
+
+**Custom OAuth2 (`usingCustom`)** — Supply **exactly one** of:
+
+- **`discoveryUrl`** — OIDC/OAuth2 discovery document URL (for example `https://idp.example.com/.well-known/openid-configuration`), or
+- **`authorizationServerMetadata`** — Manual authorization server metadata (`issuer`, `authorizationEndpoint`, `tokenEndpoint`, and other fields supported by the `AWS::BedrockAgentCore::OAuth2CredentialProvider` resource).
+
+Do not pass both. The construct validates this at synthesis time when values are known; if you use CDK tokens, ensure the resolved template still satisfies the service rules.
+
+**Wiring to gateway targets** — After you create a provider in CDK, pass the construct to **`GatewayCredentialProvider.fromOauthIdentity()`** or **`fromApiKeyIdentity()`** (optional API key header/query settings go in the second argument for API keys). Alternatively, call **`bindForGatewayOAuthTarget`** / **`bindForGatewayApiKeyTarget`** on the provider and pass that object to **`fromOauthIdentityArn`** / **`fromApiKeyIdentityArn`**. You can still pass raw ARNs from the console or API when the provider already exists.
+
+**Example: GitHub OAuth2 and an MCP target**
+
+```typescript fixture=default
+const gateway = new agentcore.Gateway(this, "MyGateway", {
+  gatewayName: "my-gateway",
+});
+
+const oauth = agentcore.OAuth2CredentialProvider.usingGithub(this, "GhOAuth", {
+  oAuth2CredentialProviderName: "github-oauth",
+  clientId: "your-client-id",
+  clientSecret: cdk.SecretValue.unsafePlainText("your-client-secret"),
+});
+
+gateway.addMcpServerTarget("Mcp", {
+  gatewayTargetName: "mcp-server",
+  description: "MCP with GitHub OAuth",
+  endpoint: "https://my-mcp-server.example.com",
+  credentialProviderConfigurations: [
+    agentcore.GatewayCredentialProvider.fromOauthIdentity(oauth, {
+      scopes: ["read:user"],
+    }),
+  ],
+});
+```
+
+**Example: custom IdP with a discovery URL**
+
+```typescript fixture=default
+agentcore.OAuth2CredentialProvider.usingCustom(this, "CustomOAuth", {
+  oAuth2CredentialProviderName: "custom-idp",
+  clientId: "your-client-id",
+  clientSecret: cdk.SecretValue.unsafePlainText("your-client-secret"),
+  discoveryUrl: "https://idp.example.com/.well-known/openid-configuration",
+});
+```
+
+**Example: custom IdP with explicit authorization server metadata**
+
+```typescript fixture=default
+agentcore.OAuth2CredentialProvider.usingCustom(this, "CustomOAuthMeta", {
+  clientId: "your-client-id",
+  clientSecret: cdk.SecretValue.unsafePlainText("your-client-secret"),
+  authorizationServerMetadata: {
+    issuer: "https://idp.example.com",
+    authorizationEndpoint: "https://idp.example.com/oauth2/authorize",
+    tokenEndpoint: "https://idp.example.com/oauth2/token",
+  },
+});
+```
+
+#### Workload identities
+
+A **workload identity** is the stable identity of an agent in your AWS account within the AgentCore Identity model. It ties together IAM roles, OAuth2 flows, API keys, and workload access tokens so agents can authenticate consistently across environments. For conceptual background, see [Understanding workload identities](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/understanding-agent-identities.html).
+
+**Agent identity directory** — Each account has a single logical directory that holds every workload identity, whether it was created by AgentCore Runtime, AgentCore Gateway, or manually (for example through CloudFormation or the control-plane API). The directory is created automatically when the first workload identity exists. Resource ARNs follow the pattern described in [Understanding the agent identity directory](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/agent-identity-directory.html) (`workload-identity-directory/default` and child `workload-identity/<name>` entries).
+
+**When to create one in CDK** — Runtime and Gateway can create workload identities for you during deployment. Use the **`WorkloadIdentity`** L2 when you need a **manually defined** identity (custom name, allowed OAuth2 return URLs, tags) or when integrating workloads that are not driven by those services.
+
+**Construct** — `WorkloadIdentity` maps to **`AWS::BedrockAgentCore::WorkloadIdentity`**. It exposes `workloadIdentityArn`, `workloadIdentityName`, and `workloadIdentityRef` for wiring into IAM or other AgentCore resources. Import an existing identity with **`WorkloadIdentity.fromWorkloadIdentityAttributes`**. Grant helpers (`grantRead`, `grantAdmin`, `grantFullAccess`) align with [directory-level IAM patterns](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/agent-identity-directory.html#directory-access-control-and-permissions) such as listing identities on the directory resource and scoping mutations to specific identity ARNs.
+
+**Example**
+
+```typescript fixture=default
+new agentcore.WorkloadIdentity(this, "MyWorkloadIdentity", {
+  workloadIdentityName: "customer-support-agent-prod",
+  allowedResourceOauth2ReturnUrls: ["https://app.example.com/oauth/callback"],
+  tags: { team: "agents", env: "prod" },
+});
+```
+
 ### Basic Gateway Target Creation
 
 You can create targets in two ways: using the static factory methods on `GatewayTarget` or using the convenient `addTarget` methods on the gateway instance.
@@ -1776,21 +1865,54 @@ const lambdaTarget = gateway.addLambdaTarget("MyLambdaTarget", {
 });
 ```
 
-- OpenAPI Target
+- OpenAPI Target (using Token Vault L2 construct — preferred)
 
 ``` typescript
 const gateway = new agentcore.Gateway(this, "MyGateway", {
   gatewayName: "my-gateway",
 });
 
-// These ARNs are returned when creating the API key credential provider via Console or API
+// Create an API key credential provider in Token Vault
+const apiKeyProvider = new agentcore.ApiKeyCredentialProvider(this, "MyApiKeyProvider", {
+  apiKeyCredentialProviderName: "my-apikey",
+});
+
+const bucket = s3.Bucket.fromBucketName(this, "ExistingBucket", "my-schema-bucket");
+const s3mySchema = agentcore.ApiSchema.fromS3File(bucket, "schemas/myschema.yaml");
+
+// Add an OpenAPI target using the L2 construct directly
+const target = gateway.addOpenApiTarget("MyTarget", {
+  gatewayTargetName: "my-api-target",
+  description: "Target for external API integration",
+  apiSchema: s3mySchema,
+  credentialProviderConfigurations: [
+    agentcore.GatewayCredentialProvider.fromApiKeyIdentity(apiKeyProvider, {
+      credentialLocation: agentcore.ApiKeyCredentialLocation.header({
+        credentialParameterName: "X-API-Key",
+      }),
+    }),
+  ],
+});
+
+// This makes sure your s3 bucket is available before target
+target.node.addDependency(bucket);
+```
+
+- OpenAPI Target (using ARNs — for providers created outside of CDK)
+
+``` typescript
+const gateway = new agentcore.Gateway(this, "MyGateway", {
+  gatewayName: "my-gateway",
+});
+
+// ARNs from the console/API, or from ApiKeyCredentialProvider + bindForGatewayApiKeyTarget
 const apiKeyProviderArn = "arn:aws:bedrock-agentcore:us-east-1:123456789012:token-vault/abc123/apikeycredentialprovider/my-apikey"
 const apiKeySecretArn = "arn:aws:secretsmanager:us-east-1:123456789012:secret:my-apikey-secret-abc123"
 
 const bucket = s3.Bucket.fromBucketName(this, "ExistingBucket", "my-schema-bucket");
 const s3mySchema = agentcore.ApiSchema.fromS3File(bucket, "schemas/myschema.yaml");
 
-// Add an OpenAPI target directly to the gateway
+// Add an OpenAPI target using ARNs directly
 const target = gateway.addOpenApiTarget("MyTarget", {
   gatewayTargetName: "my-api-target",
   description: "Target for external API integration",
@@ -1806,7 +1928,7 @@ const target = gateway.addOpenApiTarget("MyTarget", {
   ],
 });
 
-// This make sure your s3 bucket is available before target 
+// This makes sure your s3 bucket is available before target
 target.node.addDependency(bucket);
 ```
 
@@ -1838,8 +1960,7 @@ const gateway = new agentcore.Gateway(this, "MyGateway", {
   gatewayName: "my-gateway",
 });
 
-// OAuth2 authentication (recommended)
-// Note: Create the OAuth provider using AWS console or Identity L2 construct when available
+// OAuth2 (recommended): use OAuth2CredentialProvider + bindForGatewayOAuthTarget, or ARNs from console/API
 const oauthProviderArn = "arn:aws:bedrock-agentcore:us-east-1:123456789012:token-vault/abc123/oauth2credentialprovider/my-oauth";
 const oauthSecretArn = "arn:aws:secretsmanager:us-east-1:123456789012:secret:my-oauth-secret-abc123";
 
@@ -1948,7 +2069,7 @@ const gateway = new agentcore.Gateway(this, "MyGateway", {
   gatewayName: "my-gateway",
 });
 
-// outbound auth (Use AWS console to create it, Once Identity L2 construct is available you can use it to create identity)
+// Outbound auth: ApiKeyCredentialProvider + bindForGatewayApiKeyTarget, or ARNs from console/API
 const apiKeyIdentityArn = "arn:aws:bedrock-agentcore:us-east-1:123456789012:token-vault/abc123/apikeycredentialprovider/my-apikey"
 const apiKeySecretArn = "arn:aws:secretsmanager:us-east-1:123456789012:secret:my-apikey-secret-abc123"
 
@@ -2001,8 +2122,7 @@ const gateway = new agentcore.Gateway(this, "MyGateway", {
   gatewayName: "my-gateway",
 });
 
-// OAuth2 authentication (recommended)
-// Note: Create the OAuth provider using AWS console or Identity L2 construct when available
+// OAuth2 (recommended): use OAuth2CredentialProvider + bindForGatewayOAuthTarget, or ARNs from console/API
 const oauthProviderArn = "arn:aws:bedrock-agentcore:us-east-1:123456789012:token-vault/abc123/oauth2credentialprovider/my-oauth";
 const oauthSecretArn = "arn:aws:secretsmanager:us-east-1:123456789012:secret:my-oauth-secret-abc123";
 
@@ -3009,6 +3129,15 @@ policyEngine.grantEvaluate(lambdaRole);
 
 The Online Evaluation construct enables continuous monitoring and assessment of your agent's performance using live traffic. It automatically samples agent traces from CloudWatch Logs or Agent Endpoints and applies built-in evaluators to assess quality metrics like helpfulness, correctness, and safety.
 
+### Prerequisites
+
+Before creating an `OnlineEvaluationConfig`, ensure the following are configured in your account:
+
+- **CloudWatch Transaction Search** enabled — this creates the `aws/spans` log group required by the evaluation service. See [Enable Transaction Search](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/observability-configure.html).
+- **AWS Distro for OpenTelemetry (ADOT) SDK** instrumenting your agent to emit traces.
+
+For full details, see [AgentCore Evaluations Prerequisites](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/evaluations-prerequisites.html).
+
 ### Online Evaluation Properties
 
 | Name | Type | Required | Description |
@@ -3103,6 +3232,7 @@ Custom evaluators let you define evaluation logic tailored to your specific use
 | `evaluatorConfig` | `EvaluatorConfig` | Yes | Configuration defining how the evaluator assesses performance |
 | `level` | `EvaluationLevel` | Yes | The level at which the evaluator operates: `TOOL_CALL`, `TRACE`, or `SESSION` |
 | `description` | `string` | No | Description of the evaluator. Maximum 200 characters |
+| `tags` | `{ [key: string]: string }` | No | Tags for the evaluator. A list of key:value pairs to apply to this Evaluator resource |
 
 #### LLM-as-a-Judge Evaluator
 

package/lib/evaluation/custom-evaluator.d.ts

@@ -48,6 +48,15 @@ export interface EvaluatorProps {
      * @maxLength 200
      */
     readonly description?: string;
+    /**
+     * Tags for the evaluator.
+     * A list of key:value pairs of tags to apply to this Evaluator resource.
+     *
+     * @default - No tags
+     */
+    readonly tags?: {
+        [key: string]: string;
+    };
 }
 /**
  * A custom evaluator for Amazon Bedrock AgentCore.

package/lib/evaluation/custom-evaluator.js

@@ -110,7 +110,7 @@ let Evaluator = (() => {
             Evaluator = _classThis = _classDescriptor.value;
             if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
         }
-        static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-bedrock-agentcore-alpha.Evaluator", version: "2.253.0-alpha.0" };
+        static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-bedrock-agentcore-alpha.Evaluator", version: "2.254.0-alpha.0" };
         /** Uniquely identifies this class. */
         static PROPERTY_INJECTION_ID = '@aws-cdk.aws-bedrock-agentcore-alpha.Evaluator';
         /**
@@ -223,12 +223,18 @@ let Evaluator = (() => {
             (0, metadata_resource_1.addConstructMetadata)(this, props);
             (0, validation_helpers_1.throwIfInvalid)(validation_helpers_1.validateEvaluatorName, props.evaluatorName, this);
             (0, validation_helpers_1.throwIfInvalid)(validation_helpers_1.validateDescription, props.description, this);
+            if (props.tags) {
+                (0, validation_helpers_1.throwIfInvalid)(validation_helpers_1.validateEvaluatorTags, props.tags, this);
+            }
             this.evaluatorName = this.physicalName;
             const resource = new bedrockagentcore.CfnEvaluator(this, 'Resource', {
                 evaluatorName: this.physicalName,
                 evaluatorConfig: props.evaluatorConfig._bind(),
                 level: props.level.value,
                 description: props.description,
+                tags: props.tags && Object.keys(props.tags).length > 0
+                    ? Object.entries(props.tags).map(([key, value]) => ({ key, value }))
+                    : undefined,
             });
             // If code-based, grant the bedrock-agentcore service permission to invoke
             // the Lambda function, scoped to this specific evaluator for confused deputy prevention.
@@ -253,4 +259,4 @@ let Evaluator = (() => {
     return Evaluator = _classThis;
 })();
 exports.Evaluator = Evaluator;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"custom-evaluator.js","sourceRoot":"","sources":["custom-evaluator.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n *  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n *\n *  Licensed under the Apache License, Version 2.0 (the \"License\"). You may not use this file except in compliance\n *  with the License. A copy of the License is located at\n *\n *      http://www.apache.org/licenses/LICENSE-2.0\n *\n *  or in the 'license' file accompanying this file. This file is distributed on an 'AS IS' BASIS, WITHOUT WARRANTIES\n *  OR CONDITIONS OF ANY KIND, express or implied. See the License for the specific language governing permissions\n *  and limitations under the License.\n */\n\nimport { Arn, ArnFormat, Stack } from 'aws-cdk-lib';\nimport * as bedrockagentcore from 'aws-cdk-lib/aws-bedrockagentcore';\nimport * as iam from 'aws-cdk-lib/aws-iam';\nimport { addConstructMetadata } from 'aws-cdk-lib/core/lib/metadata-resource';\nimport { propertyInjectable } from 'aws-cdk-lib/core/lib/prop-injectable';\nimport type { Construct } from 'constructs';\nimport { type IEvaluator, EvaluatorBase } from './evaluator-base';\nimport type { EvaluatorConfig } from './evaluator-config';\nimport type { EvaluationLevel, EvaluatorAttributes } from './types';\nimport {\n  throwIfInvalid,\n  validateDescription,\n  validateEvaluatorName,\n} from './validation-helpers';\n\n/**\n * Properties for creating an Evaluator.\n */\nexport interface EvaluatorProps {\n  /**\n   * The name of the evaluator.\n   *\n   * Must be unique within your account. Valid characters are a-z, A-Z, 0-9, _ (underscore).\n   * Must start with a letter and can be up to 48 characters long.\n   *\n   * @pattern ^[a-zA-Z][a-zA-Z0-9_]{0,47}$\n   */\n  readonly evaluatorName: string;\n\n  /**\n   * The configuration that defines how the evaluator assesses agent performance.\n   *\n   * Use `EvaluatorConfig.llmAsAJudge()` for model-based evaluation or\n   * `EvaluatorConfig.codeBased()` for Lambda-based evaluation.\n   */\n  readonly evaluatorConfig: EvaluatorConfig;\n\n  /**\n   * The level at which the evaluator assesses agent performance.\n   *\n   * Determines what granularity of data the evaluator operates on:\n   * tool call, trace (single request-response), or session (full conversation).\n   */\n  readonly level: EvaluationLevel;\n\n  /**\n   * The description of the evaluator.\n   *\n   * @default - No description\n   * @maxLength 200\n   */\n  readonly description?: string;\n}\n\n/**\n * A custom evaluator for Amazon Bedrock AgentCore.\n *\n * Custom evaluators enable you to define evaluation logic tailored to your specific\n * use cases. Supports two evaluation strategies:\n * - **LLM-as-a-Judge**: Uses a foundation model with custom instructions and a rating scale.\n * - **Code-based**: Uses a Lambda function for custom evaluation logic.\n *\n * Custom evaluators are used with `OnlineEvaluationConfig` via `EvaluatorReference.custom()`.\n *\n * @resource AWS::BedrockAgentCore::Evaluator\n *\n * @example\n * // Create a custom LLM-as-a-Judge evaluator\n * const evaluator = new agentcore.Evaluator(this, 'MyEvaluator', {\n *   evaluatorName: 'my_custom_evaluator',\n *   level: agentcore.EvaluationLevel.SESSION,\n *   evaluatorConfig: agentcore.EvaluatorConfig.llmAsAJudge({\n *     instructions: 'Evaluate whether the agent response is helpful and accurate.',\n *     modelId: 'us.anthropic.claude-sonnet-4-6',\n *     ratingScale: agentcore.EvaluatorRatingScale.categorical([\n *       { label: 'Good', definition: 'The response is helpful and accurate.' },\n *       { label: 'Bad', definition: 'The response is not helpful or contains errors.' },\n *     ]),\n *   }),\n * });\n *\n * // Use the custom evaluator in an online evaluation configuration\n * new agentcore.OnlineEvaluationConfig(this, 'MyEvaluation', {\n *   onlineEvaluationConfigName: 'my_evaluation',\n *   evaluators: [\n *     agentcore.EvaluatorReference.builtin(agentcore.BuiltinEvaluator.HELPFULNESS),\n *     agentcore.EvaluatorReference.custom(evaluator),\n *   ],\n *   dataSource: agentcore.DataSourceConfig.fromCloudWatchLogs({\n *     logGroupNames: ['/aws/bedrock-agentcore/my-agent'],\n *     serviceNames: ['my-agent.default'],\n *   }),\n * });\n */\n@propertyInjectable\nexport class Evaluator extends EvaluatorBase {\n  /** Uniquely identifies this class. */\n  public static readonly PROPERTY_INJECTION_ID: string =\n    '@aws-cdk.aws-bedrock-agentcore-alpha.Evaluator';\n\n  /**\n   * Import an existing Evaluator by its ID.\n   *\n   * @param scope - The construct scope\n   * @param id - Construct identifier\n   * @param evaluatorId - The evaluator ID to import\n   * @returns An IEvaluator reference\n   */\n  public static fromEvaluatorId(\n    scope: Construct,\n    id: string,\n    evaluatorId: string,\n  ): IEvaluator {\n    const stack = Stack.of(scope);\n    const evaluatorArn = Arn.format(\n      {\n        service: 'bedrock-agentcore',\n        resource: 'evaluator',\n        resourceName: evaluatorId,\n      },\n      stack,\n    );\n\n    return Evaluator.fromEvaluatorAttributes(scope, id, {\n      evaluatorArn,\n      evaluatorId,\n    });\n  }\n\n  /**\n   * Import an existing Evaluator by its ARN.\n   *\n   * @param scope - The construct scope\n   * @param id - Construct identifier\n   * @param evaluatorArn - The evaluator ARN to import\n   * @returns An IEvaluator reference\n   */\n  public static fromEvaluatorArn(\n    scope: Construct,\n    id: string,\n    evaluatorArn: string,\n  ): IEvaluator {\n    const arnParts = Arn.split(evaluatorArn, ArnFormat.SLASH_RESOURCE_NAME);\n    const evaluatorId = arnParts.resourceName!;\n\n    return Evaluator.fromEvaluatorAttributes(scope, id, {\n      evaluatorArn,\n      evaluatorId,\n    });\n  }\n\n  /**\n   * Import an existing Evaluator from its attributes.\n   *\n   * @param scope - The construct scope\n   * @param id - Construct identifier\n   * @param attrs - The evaluator attributes\n   * @returns An IEvaluator reference\n   */\n  public static fromEvaluatorAttributes(\n    scope: Construct,\n    id: string,\n    attrs: EvaluatorAttributes,\n  ): IEvaluator {\n    class Import extends EvaluatorBase {\n      public readonly evaluatorArn = attrs.evaluatorArn;\n      public readonly evaluatorId = attrs.evaluatorId;\n      public readonly evaluatorName = attrs.evaluatorName ?? attrs.evaluatorId;\n      public readonly status = undefined;\n      public readonly createdAt = undefined;\n      public readonly updatedAt = undefined;\n    }\n\n    return new Import(scope, id);\n  }\n\n  /**\n   * The ARN of the evaluator.\n   * @attribute\n   */\n  public readonly evaluatorArn: string;\n\n  /**\n   * The unique identifier of the evaluator.\n   * @attribute\n   */\n  public readonly evaluatorId: string;\n\n  /**\n   * The name of the evaluator.\n   * @attribute\n   */\n  public readonly evaluatorName: string;\n\n  /**\n   * The lifecycle status of the evaluator.\n   * @attribute\n   */\n  public readonly status?: string;\n\n  /**\n   * The timestamp when the evaluator was created.\n   * @attribute\n   */\n  public readonly createdAt?: string;\n\n  /**\n   * The timestamp when the evaluator was last updated.\n   * @attribute\n   */\n  public readonly updatedAt?: string;\n\n  constructor(scope: Construct, id: string, props: EvaluatorProps) {\n    super(scope, id, {\n      physicalName: props.evaluatorName,\n    });\n\n    addConstructMetadata(this, props);\n\n    throwIfInvalid(validateEvaluatorName, props.evaluatorName, this);\n    throwIfInvalid(validateDescription, props.description, this);\n\n    this.evaluatorName = this.physicalName;\n\n    const resource = new bedrockagentcore.CfnEvaluator(this, 'Resource', {\n      evaluatorName: this.physicalName,\n      evaluatorConfig: props.evaluatorConfig._bind(),\n      level: props.level.value,\n      description: props.description,\n    });\n\n    // If code-based, grant the bedrock-agentcore service permission to invoke\n    // the Lambda function, scoped to this specific evaluator for confused deputy prevention.\n    if (props.evaluatorConfig.lambdaFunction) {\n      const stack = Stack.of(this);\n      props.evaluatorConfig.lambdaFunction.addPermission('BedrockAgentCoreEvaluatorInvoke', {\n        principal: new iam.ServicePrincipal('bedrock-agentcore.amazonaws.com'),\n        sourceAccount: stack.account,\n        sourceArn: resource.attrEvaluatorArn,\n      });\n    }\n\n    this.evaluatorArn = resource.attrEvaluatorArn;\n    this.evaluatorId = resource.attrEvaluatorId;\n    this.status = resource.attrStatus;\n    this.createdAt = resource.attrCreatedAt;\n    this.updatedAt = resource.attrUpdatedAt;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"custom-evaluator.js","sourceRoot":"","sources":["custom-evaluator.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n *  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n *\n *  Licensed under the Apache License, Version 2.0 (the \"License\"). You may not use this file except in compliance\n *  with the License. A copy of the License is located at\n *\n *      http://www.apache.org/licenses/LICENSE-2.0\n *\n *  or in the 'license' file accompanying this file. This file is distributed on an 'AS IS' BASIS, WITHOUT WARRANTIES\n *  OR CONDITIONS OF ANY KIND, express or implied. See the License for the specific language governing permissions\n *  and limitations under the License.\n */\n\nimport { Arn, ArnFormat, Stack } from 'aws-cdk-lib';\nimport * as bedrockagentcore from 'aws-cdk-lib/aws-bedrockagentcore';\nimport * as iam from 'aws-cdk-lib/aws-iam';\nimport { addConstructMetadata } from 'aws-cdk-lib/core/lib/metadata-resource';\nimport { propertyInjectable } from 'aws-cdk-lib/core/lib/prop-injectable';\nimport type { Construct } from 'constructs';\nimport { type IEvaluator, EvaluatorBase } from './evaluator-base';\nimport type { EvaluatorConfig } from './evaluator-config';\nimport type { EvaluationLevel, EvaluatorAttributes } from './types';\nimport {\n  throwIfInvalid,\n  validateDescription,\n  validateEvaluatorName,\n  validateEvaluatorTags,\n} from './validation-helpers';\n\n/**\n * Properties for creating an Evaluator.\n */\nexport interface EvaluatorProps {\n  /**\n   * The name of the evaluator.\n   *\n   * Must be unique within your account. Valid characters are a-z, A-Z, 0-9, _ (underscore).\n   * Must start with a letter and can be up to 48 characters long.\n   *\n   * @pattern ^[a-zA-Z][a-zA-Z0-9_]{0,47}$\n   */\n  readonly evaluatorName: string;\n\n  /**\n   * The configuration that defines how the evaluator assesses agent performance.\n   *\n   * Use `EvaluatorConfig.llmAsAJudge()` for model-based evaluation or\n   * `EvaluatorConfig.codeBased()` for Lambda-based evaluation.\n   */\n  readonly evaluatorConfig: EvaluatorConfig;\n\n  /**\n   * The level at which the evaluator assesses agent performance.\n   *\n   * Determines what granularity of data the evaluator operates on:\n   * tool call, trace (single request-response), or session (full conversation).\n   */\n  readonly level: EvaluationLevel;\n\n  /**\n   * The description of the evaluator.\n   *\n   * @default - No description\n   * @maxLength 200\n   */\n  readonly description?: string;\n\n  /**\n   * Tags for the evaluator.\n   * A list of key:value pairs of tags to apply to this Evaluator resource.\n   *\n   * @default - No tags\n   */\n  readonly tags?: { [key: string]: string };\n}\n\n/**\n * A custom evaluator for Amazon Bedrock AgentCore.\n *\n * Custom evaluators enable you to define evaluation logic tailored to your specific\n * use cases. Supports two evaluation strategies:\n * - **LLM-as-a-Judge**: Uses a foundation model with custom instructions and a rating scale.\n * - **Code-based**: Uses a Lambda function for custom evaluation logic.\n *\n * Custom evaluators are used with `OnlineEvaluationConfig` via `EvaluatorReference.custom()`.\n *\n * @resource AWS::BedrockAgentCore::Evaluator\n *\n * @example\n * // Create a custom LLM-as-a-Judge evaluator\n * const evaluator = new agentcore.Evaluator(this, 'MyEvaluator', {\n *   evaluatorName: 'my_custom_evaluator',\n *   level: agentcore.EvaluationLevel.SESSION,\n *   evaluatorConfig: agentcore.EvaluatorConfig.llmAsAJudge({\n *     instructions: 'Evaluate whether the agent response is helpful and accurate.',\n *     modelId: 'us.anthropic.claude-sonnet-4-6',\n *     ratingScale: agentcore.EvaluatorRatingScale.categorical([\n *       { label: 'Good', definition: 'The response is helpful and accurate.' },\n *       { label: 'Bad', definition: 'The response is not helpful or contains errors.' },\n *     ]),\n *   }),\n * });\n *\n * // Use the custom evaluator in an online evaluation configuration\n * new agentcore.OnlineEvaluationConfig(this, 'MyEvaluation', {\n *   onlineEvaluationConfigName: 'my_evaluation',\n *   evaluators: [\n *     agentcore.EvaluatorReference.builtin(agentcore.BuiltinEvaluator.HELPFULNESS),\n *     agentcore.EvaluatorReference.custom(evaluator),\n *   ],\n *   dataSource: agentcore.DataSourceConfig.fromCloudWatchLogs({\n *     logGroupNames: ['/aws/bedrock-agentcore/my-agent'],\n *     serviceNames: ['my-agent.default'],\n *   }),\n * });\n */\n@propertyInjectable\nexport class Evaluator extends EvaluatorBase {\n  /** Uniquely identifies this class. */\n  public static readonly PROPERTY_INJECTION_ID: string =\n    '@aws-cdk.aws-bedrock-agentcore-alpha.Evaluator';\n\n  /**\n   * Import an existing Evaluator by its ID.\n   *\n   * @param scope - The construct scope\n   * @param id - Construct identifier\n   * @param evaluatorId - The evaluator ID to import\n   * @returns An IEvaluator reference\n   */\n  public static fromEvaluatorId(\n    scope: Construct,\n    id: string,\n    evaluatorId: string,\n  ): IEvaluator {\n    const stack = Stack.of(scope);\n    const evaluatorArn = Arn.format(\n      {\n        service: 'bedrock-agentcore',\n        resource: 'evaluator',\n        resourceName: evaluatorId,\n      },\n      stack,\n    );\n\n    return Evaluator.fromEvaluatorAttributes(scope, id, {\n      evaluatorArn,\n      evaluatorId,\n    });\n  }\n\n  /**\n   * Import an existing Evaluator by its ARN.\n   *\n   * @param scope - The construct scope\n   * @param id - Construct identifier\n   * @param evaluatorArn - The evaluator ARN to import\n   * @returns An IEvaluator reference\n   */\n  public static fromEvaluatorArn(\n    scope: Construct,\n    id: string,\n    evaluatorArn: string,\n  ): IEvaluator {\n    const arnParts = Arn.split(evaluatorArn, ArnFormat.SLASH_RESOURCE_NAME);\n    const evaluatorId = arnParts.resourceName!;\n\n    return Evaluator.fromEvaluatorAttributes(scope, id, {\n      evaluatorArn,\n      evaluatorId,\n    });\n  }\n\n  /**\n   * Import an existing Evaluator from its attributes.\n   *\n   * @param scope - The construct scope\n   * @param id - Construct identifier\n   * @param attrs - The evaluator attributes\n   * @returns An IEvaluator reference\n   */\n  public static fromEvaluatorAttributes(\n    scope: Construct,\n    id: string,\n    attrs: EvaluatorAttributes,\n  ): IEvaluator {\n    class Import extends EvaluatorBase {\n      public readonly evaluatorArn = attrs.evaluatorArn;\n      public readonly evaluatorId = attrs.evaluatorId;\n      public readonly evaluatorName = attrs.evaluatorName ?? attrs.evaluatorId;\n      public readonly status = undefined;\n      public readonly createdAt = undefined;\n      public readonly updatedAt = undefined;\n    }\n\n    return new Import(scope, id);\n  }\n\n  /**\n   * The ARN of the evaluator.\n   * @attribute\n   */\n  public readonly evaluatorArn: string;\n\n  /**\n   * The unique identifier of the evaluator.\n   * @attribute\n   */\n  public readonly evaluatorId: string;\n\n  /**\n   * The name of the evaluator.\n   * @attribute\n   */\n  public readonly evaluatorName: string;\n\n  /**\n   * The lifecycle status of the evaluator.\n   * @attribute\n   */\n  public readonly status?: string;\n\n  /**\n   * The timestamp when the evaluator was created.\n   * @attribute\n   */\n  public readonly createdAt?: string;\n\n  /**\n   * The timestamp when the evaluator was last updated.\n   * @attribute\n   */\n  public readonly updatedAt?: string;\n\n  constructor(scope: Construct, id: string, props: EvaluatorProps) {\n    super(scope, id, {\n      physicalName: props.evaluatorName,\n    });\n\n    addConstructMetadata(this, props);\n\n    throwIfInvalid(validateEvaluatorName, props.evaluatorName, this);\n    throwIfInvalid(validateDescription, props.description, this);\n\n    if (props.tags) {\n      throwIfInvalid(validateEvaluatorTags, props.tags, this);\n    }\n\n    this.evaluatorName = this.physicalName;\n\n    const resource = new bedrockagentcore.CfnEvaluator(this, 'Resource', {\n      evaluatorName: this.physicalName,\n      evaluatorConfig: props.evaluatorConfig._bind(),\n      level: props.level.value,\n      description: props.description,\n      tags: props.tags && Object.keys(props.tags).length > 0\n        ? Object.entries(props.tags).map(([key, value]) => ({ key, value }))\n        : undefined,\n    });\n\n    // If code-based, grant the bedrock-agentcore service permission to invoke\n    // the Lambda function, scoped to this specific evaluator for confused deputy prevention.\n    if (props.evaluatorConfig.lambdaFunction) {\n      const stack = Stack.of(this);\n      props.evaluatorConfig.lambdaFunction.addPermission('BedrockAgentCoreEvaluatorInvoke', {\n        principal: new iam.ServicePrincipal('bedrock-agentcore.amazonaws.com'),\n        sourceAccount: stack.account,\n        sourceArn: resource.attrEvaluatorArn,\n      });\n    }\n\n    this.evaluatorArn = resource.attrEvaluatorArn;\n    this.evaluatorId = resource.attrEvaluatorId;\n    this.status = resource.attrStatus;\n    this.createdAt = resource.attrCreatedAt;\n    this.updatedAt = resource.attrUpdatedAt;\n  }\n}\n"]}

package/lib/evaluation/data-source.js

@@ -31,7 +31,7 @@ const validation_helpers_1 = require("./validation-helpers");
  * });
  */
 class DataSourceConfig {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-bedrock-agentcore-alpha.DataSourceConfig", version: "2.253.0-alpha.0" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-bedrock-agentcore-alpha.DataSourceConfig", version: "2.254.0-alpha.0" };
     /**
      * Creates a CloudWatch Logs data source configuration.
      *

package/lib/evaluation/evaluator-base.js

@@ -21,7 +21,7 @@ const iam = require("aws-cdk-lib/aws-iam");
  * Contains methods and attributes valid for evaluators either created with CDK or imported.
  */
 class EvaluatorBase extends aws_cdk_lib_1.Resource {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-bedrock-agentcore-alpha.EvaluatorBase", version: "2.253.0-alpha.0" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-bedrock-agentcore-alpha.EvaluatorBase", version: "2.254.0-alpha.0" };
     constructor(scope, id, props = {}) {
         super(scope, id, props);
     }

package/lib/evaluation/evaluator-config.js

@@ -25,7 +25,7 @@ const validation_helpers_1 = require("./validation-helpers");
  * ]);
  */
 class EvaluatorRatingScale {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-bedrock-agentcore-alpha.EvaluatorRatingScale", version: "2.253.0-alpha.0" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-bedrock-agentcore-alpha.EvaluatorRatingScale", version: "2.254.0-alpha.0" };
     /**
      * Creates a categorical rating scale.
      *
@@ -88,7 +88,7 @@ exports.EvaluatorRatingScale = EvaluatorRatingScale;
  * });
  */
 class EvaluatorConfig {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-bedrock-agentcore-alpha.EvaluatorConfig", version: "2.253.0-alpha.0" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-bedrock-agentcore-alpha.EvaluatorConfig", version: "2.254.0-alpha.0" };
     /**
      * Creates an LLM-as-a-Judge evaluator configuration.
      *

package/lib/evaluation/evaluator.js

@@ -19,7 +19,7 @@ const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
  * const custom = agentcore.EvaluatorReference.custom(myCustomEvaluator);
  */
 class EvaluatorReference {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-bedrock-agentcore-alpha.EvaluatorReference", version: "2.253.0-alpha.0" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-bedrock-agentcore-alpha.EvaluatorReference", version: "2.254.0-alpha.0" };
     /**
      * Creates a reference to a built-in evaluator.
      *

package/lib/evaluation/online-evaluation-base.js

@@ -21,7 +21,7 @@ const iam = require("aws-cdk-lib/aws-iam");
  * Contains methods and attributes valid for configurations either created with CDK or imported.
  */
 class OnlineEvaluationBase extends aws_cdk_lib_1.Resource {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-bedrock-agentcore-alpha.OnlineEvaluationBase", version: "2.253.0-alpha.0" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-bedrock-agentcore-alpha.OnlineEvaluationBase", version: "2.254.0-alpha.0" };
     constructor(scope, id, props = {}) {
         super(scope, id, props);
     }

package/lib/evaluation/online-evaluation.d.ts

@@ -33,6 +33,15 @@ export interface OnlineEvaluationConfigProps extends OnlineEvaluationBaseProps {
      * The data source configuration that specifies where to read agent traces from.
      */
     readonly dataSource: DataSourceConfig;
+    /**
+     * Tags for the online evaluation configuration.
+     * A list of key:value pairs of tags to apply to this OnlineEvaluationConfig resource.
+     *
+     * @default - No tags
+     */
+    readonly tags?: {
+        [key: string]: string;
+    };
 }
 /**
  * Online evaluation configuration for Amazon Bedrock AgentCore.

package/lib/evaluation/online-evaluation.js

@@ -93,7 +93,7 @@ let OnlineEvaluationConfig = (() => {
             OnlineEvaluationConfig = _classThis = _classDescriptor.value;
             if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
         }
-        static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-bedrock-agentcore-alpha.OnlineEvaluationConfig", version: "2.253.0-alpha.0" };
+        static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-bedrock-agentcore-alpha.OnlineEvaluationConfig", version: "2.254.0-alpha.0" };
         /** Uniquely identifies this class. */
         static PROPERTY_INJECTION_ID = '@aws-cdk.aws-bedrock-agentcore-alpha.OnlineEvaluationConfig';
         /**
@@ -233,6 +233,9 @@ let OnlineEvaluationConfig = (() => {
             (0, validation_helpers_1.throwIfInvalid)(validation_helpers_1.validateSamplingPercentage, props.samplingPercentage, this);
             (0, validation_helpers_1.throwIfInvalid)(validation_helpers_1.validateFilters, props.filters, this);
             (0, validation_helpers_1.throwIfInvalid)(validation_helpers_1.validateSessionTimeout, props.sessionTimeout?.toMinutes(), this);
+            if (props.tags) {
+                (0, validation_helpers_1.throwIfInvalid)(validation_helpers_1.validateEvaluationTags, props.tags, this);
+            }
             this.onlineEvaluationConfigName = this.physicalName;
             this.executionRole = props.executionRole ?? this.createExecutionRole(props.dataSource);
             this.grantPrincipal = this.executionRole;
@@ -244,6 +247,9 @@ let OnlineEvaluationConfig = (() => {
                 rule: this.buildRuleConfig(props),
                 description: props.description,
                 executionStatus: props.executionStatus?.value,
+                tags: props.tags && Object.keys(props.tags).length > 0
+                    ? Object.entries(props.tags).map(([key, value]) => ({ key, value }))
+                    : undefined,
             });
             // Ensure the execution role's policies are created before the L1 resource,
             // because BedrockAgentCore validates role permissions at create time.
@@ -385,4 +391,4 @@ let OnlineEvaluationConfig = (() => {
     return OnlineEvaluationConfig = _classThis;
 })();
 exports.OnlineEvaluationConfig = OnlineEvaluationConfig;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"online-evaluation.js","sourceRoot":"","sources":["online-evaluation.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n *  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n *\n *  Licensed under the Apache License, Version 2.0 (the \"License\"). You may not use this file except in compliance\n *  with the License. A copy of the License is located at\n *\n *      http://www.apache.org/licenses/LICENSE-2.0\n *\n *  or in the 'license' file accompanying this file. This file is distributed on an 'AS IS' BASIS, WITHOUT WARRANTIES\n *  OR CONDITIONS OF ANY KIND, express or implied. See the License for the specific language governing permissions\n *  and limitations under the License.\n */\n\nimport { Arn, ArnFormat, Aws, Stack } from 'aws-cdk-lib';\nimport * as bedrockagentcore from 'aws-cdk-lib/aws-bedrockagentcore';\nimport * as iam from 'aws-cdk-lib/aws-iam';\nimport { addConstructMetadata } from 'aws-cdk-lib/core/lib/metadata-resource';\nimport { propertyInjectable } from 'aws-cdk-lib/core/lib/prop-injectable';\nimport type { Construct } from 'constructs';\nimport type { DataSourceConfig } from './data-source';\nimport type { EvaluatorReference } from './evaluator';\nimport { type IOnlineEvaluationConfig, OnlineEvaluationBase } from './online-evaluation-base';\nimport {\n  EVALUATION_BEDROCK_MODEL_PERMS,\n  EVALUATION_CLOUDWATCH_INDEX_POLICY_PERMS,\n  EVALUATION_CLOUDWATCH_LOGS_DESCRIBE_PERMS,\n  EVALUATION_CLOUDWATCH_LOGS_QUERY_PERMS,\n  EVALUATION_CLOUDWATCH_LOGS_WRITE_PERMS,\n} from './perms';\nimport {\n  type OnlineEvaluationBaseProps,\n  type OnlineEvaluationConfigAttributes,\n} from './types';\nimport {\n  validateConfigName,\n  validateDescription,\n  validateEvaluators,\n  validateSamplingPercentage,\n  validateFilters,\n  validateSessionTimeout,\n  throwIfInvalid,\n} from './validation-helpers';\n\n/**\n * Properties for creating an OnlineEvaluationConfig.\n */\nexport interface OnlineEvaluationConfigProps extends OnlineEvaluationBaseProps {\n  /**\n   * The list of evaluators to apply during online evaluation.\n   *\n   * Can include both built-in evaluators and custom evaluators.\n   *\n   * @minimum 1\n   * @maximum 10\n   */\n  readonly evaluators: EvaluatorReference[];\n\n  /**\n   * The data source configuration that specifies where to read agent traces from.\n   */\n  readonly dataSource: DataSourceConfig;\n}\n\n/**\n * Online evaluation configuration for Amazon Bedrock AgentCore.\n *\n * Enables continuous evaluation of agent performance using built-in or custom evaluators.\n * Supports CloudWatch Logs and Agent Endpoint data sources.\n *\n * @resource AWS::BedrockAgentCore::OnlineEvaluationConfig\n *\n * @example\n * // Basic usage with built-in evaluators\n * const evaluation = new agentcore.OnlineEvaluationConfig(this, 'MyEvaluation', {\n *   onlineEvaluationConfigName: 'my_evaluation',\n *   evaluators: [\n *     agentcore.EvaluatorReference.builtin(agentcore.BuiltinEvaluator.HELPFULNESS),\n *     agentcore.EvaluatorReference.builtin(agentcore.BuiltinEvaluator.CORRECTNESS),\n *   ],\n *   dataSource: agentcore.DataSourceConfig.fromCloudWatchLogs({\n *     logGroupNames: ['/aws/bedrock-agentcore/my-agent'],\n *     serviceNames: ['my-agent.default'],\n *   }),\n * });\n */\n@propertyInjectable\nexport class OnlineEvaluationConfig extends OnlineEvaluationBase {\n  /** Uniquely identifies this class. */\n  public static readonly PROPERTY_INJECTION_ID: string =\n    '@aws-cdk.aws-bedrock-agentcore-alpha.OnlineEvaluationConfig';\n\n  /**\n   * Import an existing OnlineEvaluationConfig by its ID.\n   *\n   * @param scope - The construct scope\n   * @param id - Construct identifier\n   * @param onlineEvaluationConfigId - The configuration ID to import\n   * @returns An IOnlineEvaluationConfig reference\n   */\n  public static fromOnlineEvaluationConfigId(\n    scope: Construct,\n    id: string,\n    onlineEvaluationConfigId: string,\n  ): IOnlineEvaluationConfig {\n    const stack = Stack.of(scope);\n    const configArn = Arn.format(\n      {\n        service: 'bedrock-agentcore',\n        resource: 'online-evaluation-config',\n        resourceName: onlineEvaluationConfigId,\n      },\n      stack,\n    );\n\n    return OnlineEvaluationConfig.fromOnlineEvaluationConfigAttributes(scope, id, {\n      onlineEvaluationConfigArn: configArn,\n      onlineEvaluationConfigId: onlineEvaluationConfigId,\n      onlineEvaluationConfigName: onlineEvaluationConfigId,\n    });\n  }\n\n  /**\n   * Import an existing OnlineEvaluationConfig by its ARN.\n   *\n   * @param scope - The construct scope\n   * @param id - Construct identifier\n   * @param onlineEvaluationConfigArn - The configuration ARN to import\n   * @returns An IOnlineEvaluationConfig reference\n   */\n  public static fromOnlineEvaluationConfigArn(\n    scope: Construct,\n    id: string,\n    onlineEvaluationConfigArn: string,\n  ): IOnlineEvaluationConfig {\n    const arnParts = Arn.split(onlineEvaluationConfigArn, ArnFormat.SLASH_RESOURCE_NAME);\n    const configId = arnParts.resourceName!;\n\n    return OnlineEvaluationConfig.fromOnlineEvaluationConfigAttributes(scope, id, {\n      onlineEvaluationConfigArn: onlineEvaluationConfigArn,\n      onlineEvaluationConfigId: configId,\n      onlineEvaluationConfigName: configId,\n    });\n  }\n\n  /**\n   * Import an existing OnlineEvaluationConfig from its attributes.\n   *\n   * @param scope - The construct scope\n   * @param id - Construct identifier\n   * @param attrs - The configuration attributes\n   * @returns An IOnlineEvaluationConfig reference\n   */\n  public static fromOnlineEvaluationConfigAttributes(\n    scope: Construct,\n    id: string,\n    attrs: OnlineEvaluationConfigAttributes,\n  ): IOnlineEvaluationConfig {\n    class Import extends OnlineEvaluationBase {\n      public readonly onlineEvaluationConfigArn = attrs.onlineEvaluationConfigArn;\n      public readonly onlineEvaluationConfigId = attrs.onlineEvaluationConfigId;\n      public readonly onlineEvaluationConfigName = attrs.onlineEvaluationConfigName;\n      public readonly executionRole = attrs.executionRoleArn\n        ? iam.Role.fromRoleArn(scope, `${id}Role`, attrs.executionRoleArn)\n        : undefined;\n      public readonly status = undefined;\n      public readonly executionStatus = undefined;\n      public readonly createdAt = undefined;\n      public readonly updatedAt = undefined;\n      public readonly grantPrincipal: iam.IPrincipal;\n\n      constructor(s: Construct, i: string) {\n        super(s, i);\n        this.grantPrincipal = this.executionRole ?? new iam.UnknownPrincipal({ resource: this });\n      }\n    }\n\n    return new Import(scope, id);\n  }\n\n  /**\n   * The ARN of the online evaluation configuration.\n   * @attribute\n   */\n  public readonly onlineEvaluationConfigArn: string;\n\n  /**\n   * The unique identifier of the online evaluation configuration.\n   * @attribute\n   */\n  public readonly onlineEvaluationConfigId: string;\n\n  /**\n   * The name of the online evaluation configuration.\n   * @attribute\n   */\n  public readonly onlineEvaluationConfigName: string;\n\n  /**\n   * The IAM execution role for the evaluation.\n   */\n  public readonly executionRole?: iam.IRole;\n\n  /**\n   * The lifecycle status of the configuration.\n   * @attribute\n   */\n  public readonly status?: string;\n\n  /**\n   * The execution status of the evaluation (ENABLED or DISABLED).\n   */\n  public readonly executionStatus?: string;\n\n  /**\n   * The timestamp when the configuration was created.\n   * @attribute\n   */\n  public readonly createdAt?: string;\n\n  /**\n   * The timestamp when the configuration was last updated.\n   * @attribute\n   */\n  public readonly updatedAt?: string;\n\n  /**\n   * The principal to grant permissions to.\n   */\n  public readonly grantPrincipal: iam.IPrincipal;\n\n  constructor(scope: Construct, id: string, props: OnlineEvaluationConfigProps) {\n    super(scope, id, {\n      physicalName: props.onlineEvaluationConfigName,\n    });\n\n    addConstructMetadata(this, props);\n\n    throwIfInvalid(validateConfigName, props.onlineEvaluationConfigName, this);\n    throwIfInvalid(validateDescription, props.description, this);\n    throwIfInvalid(validateEvaluators, props.evaluators, this);\n    throwIfInvalid(validateSamplingPercentage, props.samplingPercentage, this);\n    throwIfInvalid(validateFilters, props.filters, this);\n    throwIfInvalid(validateSessionTimeout, props.sessionTimeout?.toMinutes(), this);\n\n    this.onlineEvaluationConfigName = this.physicalName;\n    this.executionRole = props.executionRole ?? this.createExecutionRole(props.dataSource);\n    this.grantPrincipal = this.executionRole;\n\n    const resource = new bedrockagentcore.CfnOnlineEvaluationConfig(this, 'Resource', {\n      onlineEvaluationConfigName: this.physicalName,\n      evaluators: props.evaluators.map((e) => e.bind()),\n      dataSourceConfig: props.dataSource.bind(),\n      evaluationExecutionRoleArn: this.executionRole!.roleArn,\n      rule: this.buildRuleConfig(props),\n      description: props.description,\n      executionStatus: props.executionStatus?.value,\n    });\n\n    // Ensure the execution role's policies are created before the L1 resource,\n    // because BedrockAgentCore validates role permissions at create time.\n    if (this.executionRole instanceof iam.Role && this.executionRole.node.defaultChild) {\n      resource.node.addDependency(this.executionRole);\n    }\n\n    this.onlineEvaluationConfigArn = resource.attrOnlineEvaluationConfigArn;\n    this.onlineEvaluationConfigId = resource.attrOnlineEvaluationConfigId;\n    this.status = resource.attrStatus;\n    this.executionStatus = resource.executionStatus;\n    this.createdAt = resource.attrCreatedAt;\n    this.updatedAt = resource.attrUpdatedAt;\n  }\n\n  private createExecutionRole(dataSource: DataSourceConfig): iam.IRole {\n    const stack = Stack.of(this);\n\n    const role = new iam.Role(this, 'ExecutionRole', {\n      assumedBy: new iam.ServicePrincipal('bedrock-agentcore.amazonaws.com', {\n        conditions: {\n          StringEquals: {\n            'aws:SourceAccount': stack.account,\n            'aws:ResourceAccount': stack.account,\n          },\n          ArnLike: {\n            'aws:SourceArn': [\n              Arn.format(\n                {\n                  service: 'bedrock-agentcore',\n                  resource: 'evaluator',\n                  resourceName: '*',\n                },\n                stack,\n              ),\n              Arn.format(\n                {\n                  service: 'bedrock-agentcore',\n                  resource: 'online-evaluation-config',\n                  resourceName: '*',\n                },\n                stack,\n              ),\n            ],\n          },\n        },\n      }),\n      description: 'Execution role for Bedrock AgentCore Online Evaluation',\n    });\n\n    // The service requires query access to user-specified log groups AND the\n    // implicit aws/spans log group it uses internally for trace data.\n    const logGroupArns = [\n      ...dataSource.cloudWatchLogsConfig.logGroupNames,\n      'aws/spans',\n    ].flatMap(\n      (name) => [\n        Arn.format(\n          {\n            service: 'logs',\n            resource: 'log-group',\n            resourceName: name,\n            arnFormat: ArnFormat.COLON_RESOURCE_NAME,\n          },\n          stack,\n        ),\n        Arn.format(\n          {\n            service: 'logs',\n            resource: 'log-group',\n            resourceName: `${name}:*`,\n            arnFormat: ArnFormat.COLON_RESOURCE_NAME,\n          },\n          stack,\n        ),\n      ],\n    );\n\n    // logs:DescribeLogGroups does not support resource-level permissions.\n    // The resource must be '*' per the IAM service authorization reference.\n    // See: https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazoncloudwatchlogs.html\n    role.addToPolicy(\n      new iam.PolicyStatement({\n        sid: 'CloudWatchLogDescribeStatement',\n        actions: EVALUATION_CLOUDWATCH_LOGS_DESCRIBE_PERMS,\n        resources: ['*'],\n      }),\n    );\n\n    role.addToPolicy(\n      new iam.PolicyStatement({\n        sid: 'CloudWatchLogQueryStatement',\n        actions: EVALUATION_CLOUDWATCH_LOGS_QUERY_PERMS,\n        resources: logGroupArns,\n      }),\n    );\n\n    role.addToPolicy(\n      new iam.PolicyStatement({\n        sid: 'CloudWatchLogWriteStatement',\n        actions: EVALUATION_CLOUDWATCH_LOGS_WRITE_PERMS,\n        resources: [\n          Arn.format(\n            {\n              service: 'logs',\n              resource: 'log-group',\n              resourceName: '/aws/bedrock-agentcore/evaluations/*',\n              arnFormat: ArnFormat.COLON_RESOURCE_NAME,\n            },\n            stack,\n          ),\n        ],\n      }),\n    );\n\n    role.addToPolicy(\n      new iam.PolicyStatement({\n        sid: 'CloudWatchIndexPolicyStatement',\n        actions: EVALUATION_CLOUDWATCH_INDEX_POLICY_PERMS,\n        resources: [\n          Arn.format(\n            {\n              service: 'logs',\n              resource: 'log-group',\n              resourceName: 'aws/spans',\n              arnFormat: ArnFormat.COLON_RESOURCE_NAME,\n            },\n            stack,\n          ),\n          Arn.format(\n            {\n              service: 'logs',\n              resource: 'log-group',\n              resourceName: 'aws/spans:*',\n              arnFormat: ArnFormat.COLON_RESOURCE_NAME,\n            },\n            stack,\n          ),\n        ],\n      }),\n    );\n\n    role.addToPolicy(\n      new iam.PolicyStatement({\n        sid: 'BedrockInvokeStatement',\n        actions: EVALUATION_BEDROCK_MODEL_PERMS,\n        resources: [\n          `arn:${Aws.PARTITION}:bedrock:*::foundation-model/*`,\n          Arn.format(\n            {\n              service: 'bedrock',\n              resource: 'inference-profile',\n              resourceName: '*',\n              region: '*',\n            },\n            stack,\n          ),\n        ],\n      }),\n    );\n\n    return role;\n  }\n\n  private buildRuleConfig(props: OnlineEvaluationConfigProps): bedrockagentcore.CfnOnlineEvaluationConfig.RuleProperty {\n    return {\n      samplingConfig: {\n        samplingPercentage: props.samplingPercentage ?? 10,\n      },\n      sessionConfig: {\n        sessionTimeoutMinutes: props.sessionTimeout?.toMinutes() ?? 15,\n      },\n      ...(props.filters && props.filters.length > 0 ? {\n        filters: props.filters.map((f) => ({\n          key: f.key,\n          operator: f.operator.value,\n          value: f.value._bind(),\n        })),\n      } : {}),\n    };\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"online-evaluation.js","sourceRoot":"","sources":["online-evaluation.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n *  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n *\n *  Licensed under the Apache License, Version 2.0 (the \"License\"). You may not use this file except in compliance\n *  with the License. A copy of the License is located at\n *\n *      http://www.apache.org/licenses/LICENSE-2.0\n *\n *  or in the 'license' file accompanying this file. This file is distributed on an 'AS IS' BASIS, WITHOUT WARRANTIES\n *  OR CONDITIONS OF ANY KIND, express or implied. See the License for the specific language governing permissions\n *  and limitations under the License.\n */\n\nimport { Arn, ArnFormat, Aws, Stack } from 'aws-cdk-lib';\nimport * as bedrockagentcore from 'aws-cdk-lib/aws-bedrockagentcore';\nimport * as iam from 'aws-cdk-lib/aws-iam';\nimport { addConstructMetadata } from 'aws-cdk-lib/core/lib/metadata-resource';\nimport { propertyInjectable } from 'aws-cdk-lib/core/lib/prop-injectable';\nimport type { Construct } from 'constructs';\nimport type { DataSourceConfig } from './data-source';\nimport type { EvaluatorReference } from './evaluator';\nimport { type IOnlineEvaluationConfig, OnlineEvaluationBase } from './online-evaluation-base';\nimport {\n  EVALUATION_BEDROCK_MODEL_PERMS,\n  EVALUATION_CLOUDWATCH_INDEX_POLICY_PERMS,\n  EVALUATION_CLOUDWATCH_LOGS_DESCRIBE_PERMS,\n  EVALUATION_CLOUDWATCH_LOGS_QUERY_PERMS,\n  EVALUATION_CLOUDWATCH_LOGS_WRITE_PERMS,\n} from './perms';\nimport {\n  type OnlineEvaluationBaseProps,\n  type OnlineEvaluationConfigAttributes,\n} from './types';\nimport {\n  validateConfigName,\n  validateDescription,\n  validateEvaluators,\n  validateSamplingPercentage,\n  validateFilters,\n  validateSessionTimeout,\n  validateEvaluationTags,\n  throwIfInvalid,\n} from './validation-helpers';\n\n/**\n * Properties for creating an OnlineEvaluationConfig.\n */\nexport interface OnlineEvaluationConfigProps extends OnlineEvaluationBaseProps {\n  /**\n   * The list of evaluators to apply during online evaluation.\n   *\n   * Can include both built-in evaluators and custom evaluators.\n   *\n   * @minimum 1\n   * @maximum 10\n   */\n  readonly evaluators: EvaluatorReference[];\n\n  /**\n   * The data source configuration that specifies where to read agent traces from.\n   */\n  readonly dataSource: DataSourceConfig;\n\n  /**\n   * Tags for the online evaluation configuration.\n   * A list of key:value pairs of tags to apply to this OnlineEvaluationConfig resource.\n   *\n   * @default - No tags\n   */\n  readonly tags?: { [key: string]: string };\n}\n\n/**\n * Online evaluation configuration for Amazon Bedrock AgentCore.\n *\n * Enables continuous evaluation of agent performance using built-in or custom evaluators.\n * Supports CloudWatch Logs and Agent Endpoint data sources.\n *\n * @resource AWS::BedrockAgentCore::OnlineEvaluationConfig\n *\n * @example\n * // Basic usage with built-in evaluators\n * const evaluation = new agentcore.OnlineEvaluationConfig(this, 'MyEvaluation', {\n *   onlineEvaluationConfigName: 'my_evaluation',\n *   evaluators: [\n *     agentcore.EvaluatorReference.builtin(agentcore.BuiltinEvaluator.HELPFULNESS),\n *     agentcore.EvaluatorReference.builtin(agentcore.BuiltinEvaluator.CORRECTNESS),\n *   ],\n *   dataSource: agentcore.DataSourceConfig.fromCloudWatchLogs({\n *     logGroupNames: ['/aws/bedrock-agentcore/my-agent'],\n *     serviceNames: ['my-agent.default'],\n *   }),\n * });\n */\n@propertyInjectable\nexport class OnlineEvaluationConfig extends OnlineEvaluationBase {\n  /** Uniquely identifies this class. */\n  public static readonly PROPERTY_INJECTION_ID: string =\n    '@aws-cdk.aws-bedrock-agentcore-alpha.OnlineEvaluationConfig';\n\n  /**\n   * Import an existing OnlineEvaluationConfig by its ID.\n   *\n   * @param scope - The construct scope\n   * @param id - Construct identifier\n   * @param onlineEvaluationConfigId - The configuration ID to import\n   * @returns An IOnlineEvaluationConfig reference\n   */\n  public static fromOnlineEvaluationConfigId(\n    scope: Construct,\n    id: string,\n    onlineEvaluationConfigId: string,\n  ): IOnlineEvaluationConfig {\n    const stack = Stack.of(scope);\n    const configArn = Arn.format(\n      {\n        service: 'bedrock-agentcore',\n        resource: 'online-evaluation-config',\n        resourceName: onlineEvaluationConfigId,\n      },\n      stack,\n    );\n\n    return OnlineEvaluationConfig.fromOnlineEvaluationConfigAttributes(scope, id, {\n      onlineEvaluationConfigArn: configArn,\n      onlineEvaluationConfigId: onlineEvaluationConfigId,\n      onlineEvaluationConfigName: onlineEvaluationConfigId,\n    });\n  }\n\n  /**\n   * Import an existing OnlineEvaluationConfig by its ARN.\n   *\n   * @param scope - The construct scope\n   * @param id - Construct identifier\n   * @param onlineEvaluationConfigArn - The configuration ARN to import\n   * @returns An IOnlineEvaluationConfig reference\n   */\n  public static fromOnlineEvaluationConfigArn(\n    scope: Construct,\n    id: string,\n    onlineEvaluationConfigArn: string,\n  ): IOnlineEvaluationConfig {\n    const arnParts = Arn.split(onlineEvaluationConfigArn, ArnFormat.SLASH_RESOURCE_NAME);\n    const configId = arnParts.resourceName!;\n\n    return OnlineEvaluationConfig.fromOnlineEvaluationConfigAttributes(scope, id, {\n      onlineEvaluationConfigArn: onlineEvaluationConfigArn,\n      onlineEvaluationConfigId: configId,\n      onlineEvaluationConfigName: configId,\n    });\n  }\n\n  /**\n   * Import an existing OnlineEvaluationConfig from its attributes.\n   *\n   * @param scope - The construct scope\n   * @param id - Construct identifier\n   * @param attrs - The configuration attributes\n   * @returns An IOnlineEvaluationConfig reference\n   */\n  public static fromOnlineEvaluationConfigAttributes(\n    scope: Construct,\n    id: string,\n    attrs: OnlineEvaluationConfigAttributes,\n  ): IOnlineEvaluationConfig {\n    class Import extends OnlineEvaluationBase {\n      public readonly onlineEvaluationConfigArn = attrs.onlineEvaluationConfigArn;\n      public readonly onlineEvaluationConfigId = attrs.onlineEvaluationConfigId;\n      public readonly onlineEvaluationConfigName = attrs.onlineEvaluationConfigName;\n      public readonly executionRole = attrs.executionRoleArn\n        ? iam.Role.fromRoleArn(scope, `${id}Role`, attrs.executionRoleArn)\n        : undefined;\n      public readonly status = undefined;\n      public readonly executionStatus = undefined;\n      public readonly createdAt = undefined;\n      public readonly updatedAt = undefined;\n      public readonly grantPrincipal: iam.IPrincipal;\n\n      constructor(s: Construct, i: string) {\n        super(s, i);\n        this.grantPrincipal = this.executionRole ?? new iam.UnknownPrincipal({ resource: this });\n      }\n    }\n\n    return new Import(scope, id);\n  }\n\n  /**\n   * The ARN of the online evaluation configuration.\n   * @attribute\n   */\n  public readonly onlineEvaluationConfigArn: string;\n\n  /**\n   * The unique identifier of the online evaluation configuration.\n   * @attribute\n   */\n  public readonly onlineEvaluationConfigId: string;\n\n  /**\n   * The name of the online evaluation configuration.\n   * @attribute\n   */\n  public readonly onlineEvaluationConfigName: string;\n\n  /**\n   * The IAM execution role for the evaluation.\n   */\n  public readonly executionRole?: iam.IRole;\n\n  /**\n   * The lifecycle status of the configuration.\n   * @attribute\n   */\n  public readonly status?: string;\n\n  /**\n   * The execution status of the evaluation (ENABLED or DISABLED).\n   */\n  public readonly executionStatus?: string;\n\n  /**\n   * The timestamp when the configuration was created.\n   * @attribute\n   */\n  public readonly createdAt?: string;\n\n  /**\n   * The timestamp when the configuration was last updated.\n   * @attribute\n   */\n  public readonly updatedAt?: string;\n\n  /**\n   * The principal to grant permissions to.\n   */\n  public readonly grantPrincipal: iam.IPrincipal;\n\n  constructor(scope: Construct, id: string, props: OnlineEvaluationConfigProps) {\n    super(scope, id, {\n      physicalName: props.onlineEvaluationConfigName,\n    });\n\n    addConstructMetadata(this, props);\n\n    throwIfInvalid(validateConfigName, props.onlineEvaluationConfigName, this);\n    throwIfInvalid(validateDescription, props.description, this);\n    throwIfInvalid(validateEvaluators, props.evaluators, this);\n    throwIfInvalid(validateSamplingPercentage, props.samplingPercentage, this);\n    throwIfInvalid(validateFilters, props.filters, this);\n    throwIfInvalid(validateSessionTimeout, props.sessionTimeout?.toMinutes(), this);\n\n    if (props.tags) {\n      throwIfInvalid(validateEvaluationTags, props.tags, this);\n    }\n\n    this.onlineEvaluationConfigName = this.physicalName;\n    this.executionRole = props.executionRole ?? this.createExecutionRole(props.dataSource);\n    this.grantPrincipal = this.executionRole;\n\n    const resource = new bedrockagentcore.CfnOnlineEvaluationConfig(this, 'Resource', {\n      onlineEvaluationConfigName: this.physicalName,\n      evaluators: props.evaluators.map((e) => e.bind()),\n      dataSourceConfig: props.dataSource.bind(),\n      evaluationExecutionRoleArn: this.executionRole!.roleArn,\n      rule: this.buildRuleConfig(props),\n      description: props.description,\n      executionStatus: props.executionStatus?.value,\n      tags: props.tags && Object.keys(props.tags).length > 0\n        ? Object.entries(props.tags).map(([key, value]) => ({ key, value }))\n        : undefined,\n    });\n\n    // Ensure the execution role's policies are created before the L1 resource,\n    // because BedrockAgentCore validates role permissions at create time.\n    if (this.executionRole instanceof iam.Role && this.executionRole.node.defaultChild) {\n      resource.node.addDependency(this.executionRole);\n    }\n\n    this.onlineEvaluationConfigArn = resource.attrOnlineEvaluationConfigArn;\n    this.onlineEvaluationConfigId = resource.attrOnlineEvaluationConfigId;\n    this.status = resource.attrStatus;\n    this.executionStatus = resource.executionStatus;\n    this.createdAt = resource.attrCreatedAt;\n    this.updatedAt = resource.attrUpdatedAt;\n  }\n\n  private createExecutionRole(dataSource: DataSourceConfig): iam.IRole {\n    const stack = Stack.of(this);\n\n    const role = new iam.Role(this, 'ExecutionRole', {\n      assumedBy: new iam.ServicePrincipal('bedrock-agentcore.amazonaws.com', {\n        conditions: {\n          StringEquals: {\n            'aws:SourceAccount': stack.account,\n            'aws:ResourceAccount': stack.account,\n          },\n          ArnLike: {\n            'aws:SourceArn': [\n              Arn.format(\n                {\n                  service: 'bedrock-agentcore',\n                  resource: 'evaluator',\n                  resourceName: '*',\n                },\n                stack,\n              ),\n              Arn.format(\n                {\n                  service: 'bedrock-agentcore',\n                  resource: 'online-evaluation-config',\n                  resourceName: '*',\n                },\n                stack,\n              ),\n            ],\n          },\n        },\n      }),\n      description: 'Execution role for Bedrock AgentCore Online Evaluation',\n    });\n\n    // The service requires query access to user-specified log groups AND the\n    // implicit aws/spans log group it uses internally for trace data.\n    const logGroupArns = [\n      ...dataSource.cloudWatchLogsConfig.logGroupNames,\n      'aws/spans',\n    ].flatMap(\n      (name) => [\n        Arn.format(\n          {\n            service: 'logs',\n            resource: 'log-group',\n            resourceName: name,\n            arnFormat: ArnFormat.COLON_RESOURCE_NAME,\n          },\n          stack,\n        ),\n        Arn.format(\n          {\n            service: 'logs',\n            resource: 'log-group',\n            resourceName: `${name}:*`,\n            arnFormat: ArnFormat.COLON_RESOURCE_NAME,\n          },\n          stack,\n        ),\n      ],\n    );\n\n    // logs:DescribeLogGroups does not support resource-level permissions.\n    // The resource must be '*' per the IAM service authorization reference.\n    // See: https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazoncloudwatchlogs.html\n    role.addToPolicy(\n      new iam.PolicyStatement({\n        sid: 'CloudWatchLogDescribeStatement',\n        actions: EVALUATION_CLOUDWATCH_LOGS_DESCRIBE_PERMS,\n        resources: ['*'],\n      }),\n    );\n\n    role.addToPolicy(\n      new iam.PolicyStatement({\n        sid: 'CloudWatchLogQueryStatement',\n        actions: EVALUATION_CLOUDWATCH_LOGS_QUERY_PERMS,\n        resources: logGroupArns,\n      }),\n    );\n\n    role.addToPolicy(\n      new iam.PolicyStatement({\n        sid: 'CloudWatchLogWriteStatement',\n        actions: EVALUATION_CLOUDWATCH_LOGS_WRITE_PERMS,\n        resources: [\n          Arn.format(\n            {\n              service: 'logs',\n              resource: 'log-group',\n              resourceName: '/aws/bedrock-agentcore/evaluations/*',\n              arnFormat: ArnFormat.COLON_RESOURCE_NAME,\n            },\n            stack,\n          ),\n        ],\n      }),\n    );\n\n    role.addToPolicy(\n      new iam.PolicyStatement({\n        sid: 'CloudWatchIndexPolicyStatement',\n        actions: EVALUATION_CLOUDWATCH_INDEX_POLICY_PERMS,\n        resources: [\n          Arn.format(\n            {\n              service: 'logs',\n              resource: 'log-group',\n              resourceName: 'aws/spans',\n              arnFormat: ArnFormat.COLON_RESOURCE_NAME,\n            },\n            stack,\n          ),\n          Arn.format(\n            {\n              service: 'logs',\n              resource: 'log-group',\n              resourceName: 'aws/spans:*',\n              arnFormat: ArnFormat.COLON_RESOURCE_NAME,\n            },\n            stack,\n          ),\n        ],\n      }),\n    );\n\n    role.addToPolicy(\n      new iam.PolicyStatement({\n        sid: 'BedrockInvokeStatement',\n        actions: EVALUATION_BEDROCK_MODEL_PERMS,\n        resources: [\n          `arn:${Aws.PARTITION}:bedrock:*::foundation-model/*`,\n          Arn.format(\n            {\n              service: 'bedrock',\n              resource: 'inference-profile',\n              resourceName: '*',\n              region: '*',\n            },\n            stack,\n          ),\n        ],\n      }),\n    );\n\n    return role;\n  }\n\n  private buildRuleConfig(props: OnlineEvaluationConfigProps): bedrockagentcore.CfnOnlineEvaluationConfig.RuleProperty {\n    return {\n      samplingConfig: {\n        samplingPercentage: props.samplingPercentage ?? 10,\n      },\n      sessionConfig: {\n        sessionTimeoutMinutes: props.sessionTimeout?.toMinutes() ?? 15,\n      },\n      ...(props.filters && props.filters.length > 0 ? {\n        filters: props.filters.map((f) => ({\n          key: f.key,\n          operator: f.operator.value,\n          value: f.value._bind(),\n        })),\n      } : {}),\n    };\n  }\n}\n"]}