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

package/lib/evaluation/evaluator-base.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvaluatorBase = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+/**
+ *  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance
+ *  with the License. A copy of the License is located at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  or in the 'license' file accompanying this file. This file is distributed on an 'AS IS' BASIS, WITHOUT WARRANTIES
+ *  OR CONDITIONS OF ANY KIND, express or implied. See the License for the specific language governing permissions
+ *  and limitations under the License.
+ */
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const iam = require("aws-cdk-lib/aws-iam");
+/**
+ * Abstract base class for Evaluator.
+ * 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" };
+    constructor(scope, id, props = {}) {
+        super(scope, id, props);
+    }
+    /**
+     * A reference to this Evaluator resource.
+     */
+    get evaluatorRef() {
+        return {
+            evaluatorArn: this.evaluatorArn,
+        };
+    }
+    /**
+     * Grants IAM actions to the IAM Principal.
+     *
+     * [disable-awslint:no-grants]
+     *
+     * @param grantee - The IAM principal to grant permissions to
+     * @param actions - The actions to grant
+     * @returns An IAM Grant object representing the granted permissions
+     */
+    grant(grantee, ...actions) {
+        return iam.Grant.addToPrincipal({
+            grantee,
+            actions,
+            resourceArns: [this.evaluatorArn],
+            scope: this,
+        });
+    }
+}
+exports.EvaluatorBase = EvaluatorBase;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,195 @@
+/**
+ *  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance
+ *  with the License. A copy of the License is located at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  or in the 'license' file accompanying this file. This file is distributed on an 'AS IS' BASIS, WITHOUT WARRANTIES
+ *  OR CONDITIONS OF ANY KIND, express or implied. See the License for the specific language governing permissions
+ *  and limitations under the License.
+ */
+import type { Duration } from 'aws-cdk-lib';
+import type * as bedrockagentcore from 'aws-cdk-lib/aws-bedrockagentcore';
+import type * as lambda from 'aws-cdk-lib/aws-lambda';
+import type { CategoricalRatingOption, EvaluatorInferenceConfig, NumericalRatingOption } from './types';
+/**
+ * Options for configuring an LLM-as-a-Judge custom evaluator.
+ *
+ * Uses a foundation model to assess agent performance based on
+ * custom instructions and a rating scale.
+ */
+export interface LlmAsAJudgeOptions {
+    /**
+     * The evaluation instructions that guide the language model in assessing agent performance.
+     *
+     * These instructions define the evaluation criteria, context, and expected behavior.
+     * Instructions must contain placeholders appropriate for the evaluation level
+     * (e.g., `{context}`, `{available_tools}` for SESSION level).
+     *
+     * Note: Evaluators using reference-input placeholders (e.g., `{expected_tool_trajectory}`,
+     * `{assertions}`, `{expected_response}`) are only compatible with on-demand evaluation,
+     * not online evaluation.
+     *
+     * @see https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/custom-evaluators.html
+     */
+    readonly instructions: string;
+    /**
+     * The identifier of the Amazon Bedrock model to use for evaluation.
+     *
+     * Accepts standard model IDs (e.g., `'anthropic.claude-sonnet-4-6'`)
+     * and cross-region inference profile IDs with region prefixes
+     * (e.g., `'us.anthropic.claude-sonnet-4-6'`, `'eu.anthropic.claude-sonnet-4-6'`).
+     */
+    readonly modelId: string;
+    /**
+     * The rating scale that defines how the evaluator should score agent performance.
+     */
+    readonly ratingScale: EvaluatorRatingScale;
+    /**
+     * Optional inference configuration parameters that control model behavior during evaluation.
+     *
+     * When not specified, the foundation model uses its own default values for
+     * maxTokens, temperature, and topP.
+     *
+     * @default - The foundation model's default inference parameters are used
+     * @see https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/custom-evaluators.html
+     */
+    readonly inferenceConfig?: EvaluatorInferenceConfig;
+    /**
+     * Additional model-specific request fields.
+     *
+     * @default - No additional fields
+     */
+    readonly additionalModelRequestFields?: {
+        [key: string]: any;
+    };
+}
+/**
+ * Options for configuring a code-based custom evaluator using a Lambda function.
+ *
+ * Uses a Lambda function to implement custom evaluation logic.
+ */
+export interface CodeBasedOptions {
+    /**
+     * The Lambda function used for evaluation.
+     *
+     * The function will be granted invoke permissions for the
+     * `bedrock-agentcore.amazonaws.com` service principal, scoped
+     * to this specific evaluator resource.
+     */
+    readonly lambdaFunction: lambda.IFunction;
+    /**
+     * The timeout for the Lambda function invocation during evaluation.
+     *
+     * When not specified, the AgentCore evaluation service uses its default
+     * timeout for Lambda-based evaluators.
+     *
+     * @default - The AgentCore evaluation service's default Lambda timeout is used
+     * @see https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/custom-evaluators.html
+     */
+    readonly timeout?: Duration;
+}
+/**
+ * Represents a rating scale for custom LLM-as-a-Judge evaluators.
+ *
+ * Rating scales define how the evaluator scores agent performance.
+ * Use either categorical (discrete labels) or numerical (labeled numeric values) scales.
+ *
+ * @example
+ * // Categorical rating scale
+ * const categorical = agentcore.EvaluatorRatingScale.categorical([
+ *   { label: 'Good', definition: 'The response fully addresses the query.' },
+ *   { label: 'Bad', definition: 'The response fails to address the query.' },
+ * ]);
+ *
+ * // Numerical rating scale
+ * const numerical = agentcore.EvaluatorRatingScale.numerical([
+ *   { label: 'Poor', definition: 'Inadequate response.', value: 1 },
+ *   { label: 'Good', definition: 'Adequate response.', value: 3 },
+ *   { label: 'Excellent', definition: 'Outstanding response.', value: 5 },
+ * ]);
+ */
+export declare class EvaluatorRatingScale {
+    /**
+     * Creates a categorical rating scale.
+     *
+     * Categorical scales define discrete labels for scoring, such as "Good" / "Bad"
+     * or "Pass" / "Fail".
+     *
+     * @param options - The categorical rating options (at least 1 required)
+     */
+    static categorical(options: CategoricalRatingOption[]): EvaluatorRatingScale;
+    /**
+     * Creates a numerical rating scale.
+     *
+     * Numerical scales define labeled numeric values for scoring, such as
+     * 1 (Poor) through 5 (Excellent).
+     *
+     * @param options - The numerical rating options (at least 1 required)
+     */
+    static numerical(options: NumericalRatingOption[]): EvaluatorRatingScale;
+    private readonly config;
+    private constructor();
+    /**
+     * Binds the rating scale to produce the L1 property.
+     * @internal
+     */
+    _bind(): bedrockagentcore.CfnEvaluator.RatingScaleProperty;
+}
+/**
+ * Configuration for a custom evaluator.
+ *
+ * Defines how an evaluator assesses agent performance. Supports two strategies:
+ * - **LLM-as-a-Judge**: Uses a foundation model with custom instructions and a rating scale.
+ * - **Code-based**: Uses a Lambda function for custom evaluation logic.
+ *
+ * @example
+ * // LLM-as-a-Judge evaluator
+ * const llmConfig = agentcore.EvaluatorConfig.llmAsAJudge({
+ *   instructions: 'Evaluate whether the agent response is helpful.',
+ *   modelId: 'us.anthropic.claude-sonnet-4-6',
+ *   ratingScale: agentcore.EvaluatorRatingScale.categorical([
+ *     { label: 'Good', definition: 'The response is helpful.' },
+ *     { label: 'Bad', definition: 'The response is not helpful.' },
+ *   ]),
+ * });
+ *
+ * // Code-based evaluator
+ * declare const myEvalFunction: lambda.IFunction;
+ * const codeConfig = agentcore.EvaluatorConfig.codeBased({
+ *   lambdaFunction: myEvalFunction,
+ * });
+ */
+export declare class EvaluatorConfig {
+    /**
+     * Creates an LLM-as-a-Judge evaluator configuration.
+     *
+     * Uses a foundation model to assess agent performance based on custom
+     * instructions and a rating scale.
+     *
+     * @param options - The LLM-as-a-Judge configuration options
+     */
+    static llmAsAJudge(options: LlmAsAJudgeOptions): EvaluatorConfig;
+    /**
+     * Creates a code-based evaluator configuration using a Lambda function.
+     *
+     * The Lambda function implements custom evaluation logic. The function will
+     * automatically be granted invoke permissions for the bedrock-agentcore service.
+     *
+     * @param options - The code-based configuration options
+     */
+    static codeBased(options: CodeBasedOptions): EvaluatorConfig;
+    /**
+     * The Lambda function used for code-based evaluation, if applicable.
+     */
+    readonly lambdaFunction?: lambda.IFunction;
+    private readonly cfnConfig;
+    private constructor();
+    /**
+     * Binds the evaluator configuration to produce the L1 property.
+     * @internal
+     */
+    _bind(): bedrockagentcore.CfnEvaluator.EvaluatorConfigProperty;
+}

package/lib/evaluation/evaluator-config.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvaluatorConfig = exports.EvaluatorRatingScale = void 0;
+const jsiiDeprecationWarnings = require("../../.warnings.jsii.js");
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const validation_helpers_1 = require("./validation-helpers");
+/**
+ * Represents a rating scale for custom LLM-as-a-Judge evaluators.
+ *
+ * Rating scales define how the evaluator scores agent performance.
+ * Use either categorical (discrete labels) or numerical (labeled numeric values) scales.
+ *
+ * @example
+ * // Categorical rating scale
+ * const categorical = agentcore.EvaluatorRatingScale.categorical([
+ *   { label: 'Good', definition: 'The response fully addresses the query.' },
+ *   { label: 'Bad', definition: 'The response fails to address the query.' },
+ * ]);
+ *
+ * // Numerical rating scale
+ * const numerical = agentcore.EvaluatorRatingScale.numerical([
+ *   { label: 'Poor', definition: 'Inadequate response.', value: 1 },
+ *   { label: 'Good', definition: 'Adequate response.', value: 3 },
+ *   { label: 'Excellent', definition: 'Outstanding response.', value: 5 },
+ * ]);
+ */
+class EvaluatorRatingScale {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-bedrock-agentcore-alpha.EvaluatorRatingScale", version: "2.253.0-alpha.0" };
+    /**
+     * Creates a categorical rating scale.
+     *
+     * Categorical scales define discrete labels for scoring, such as "Good" / "Bad"
+     * or "Pass" / "Fail".
+     *
+     * @param options - The categorical rating options (at least 1 required)
+     */
+    static categorical(options) {
+        (0, validation_helpers_1.throwIfInvalid)(validation_helpers_1.validateCategoricalRatingScale, options);
+        return new EvaluatorRatingScale({ categorical: options });
+    }
+    /**
+     * Creates a numerical rating scale.
+     *
+     * Numerical scales define labeled numeric values for scoring, such as
+     * 1 (Poor) through 5 (Excellent).
+     *
+     * @param options - The numerical rating options (at least 1 required)
+     */
+    static numerical(options) {
+        (0, validation_helpers_1.throwIfInvalid)(validation_helpers_1.validateNumericalRatingScale, options);
+        return new EvaluatorRatingScale({ numerical: options });
+    }
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Binds the rating scale to produce the L1 property.
+     * @internal
+     */
+    _bind() {
+        return this.config;
+    }
+}
+exports.EvaluatorRatingScale = EvaluatorRatingScale;
+/**
+ * Configuration for a custom evaluator.
+ *
+ * Defines how an evaluator assesses agent performance. Supports two strategies:
+ * - **LLM-as-a-Judge**: Uses a foundation model with custom instructions and a rating scale.
+ * - **Code-based**: Uses a Lambda function for custom evaluation logic.
+ *
+ * @example
+ * // LLM-as-a-Judge evaluator
+ * const llmConfig = agentcore.EvaluatorConfig.llmAsAJudge({
+ *   instructions: 'Evaluate whether the agent response is helpful.',
+ *   modelId: 'us.anthropic.claude-sonnet-4-6',
+ *   ratingScale: agentcore.EvaluatorRatingScale.categorical([
+ *     { label: 'Good', definition: 'The response is helpful.' },
+ *     { label: 'Bad', definition: 'The response is not helpful.' },
+ *   ]),
+ * });
+ *
+ * // Code-based evaluator
+ * declare const myEvalFunction: lambda.IFunction;
+ * const codeConfig = agentcore.EvaluatorConfig.codeBased({
+ *   lambdaFunction: myEvalFunction,
+ * });
+ */
+class EvaluatorConfig {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-bedrock-agentcore-alpha.EvaluatorConfig", version: "2.253.0-alpha.0" };
+    /**
+     * Creates an LLM-as-a-Judge evaluator configuration.
+     *
+     * Uses a foundation model to assess agent performance based on custom
+     * instructions and a rating scale.
+     *
+     * @param options - The LLM-as-a-Judge configuration options
+     */
+    static llmAsAJudge(options) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_bedrock_agentcore_alpha_LlmAsAJudgeOptions(options);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.llmAsAJudge);
+            }
+            throw error;
+        }
+        (0, validation_helpers_1.throwIfInvalid)(validation_helpers_1.validateInstructions, options.instructions);
+        const modelConfig = {
+            bedrockEvaluatorModelConfig: {
+                modelId: options.modelId,
+                ...(options.inferenceConfig !== undefined ? {
+                    inferenceConfig: {
+                        maxTokens: options.inferenceConfig.maxTokens,
+                        temperature: options.inferenceConfig.temperature,
+                        topP: options.inferenceConfig.topP,
+                    },
+                } : {}),
+                ...(options.additionalModelRequestFields !== undefined ? {
+                    additionalModelRequestFields: options.additionalModelRequestFields,
+                } : {}),
+            },
+        };
+        const cfnConfig = {
+            llmAsAJudge: {
+                instructions: options.instructions,
+                modelConfig,
+                ratingScale: options.ratingScale._bind(),
+            },
+        };
+        return new EvaluatorConfig(cfnConfig);
+    }
+    /**
+     * Creates a code-based evaluator configuration using a Lambda function.
+     *
+     * The Lambda function implements custom evaluation logic. The function will
+     * automatically be granted invoke permissions for the bedrock-agentcore service.
+     *
+     * @param options - The code-based configuration options
+     */
+    static codeBased(options) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_bedrock_agentcore_alpha_CodeBasedOptions(options);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.codeBased);
+            }
+            throw error;
+        }
+        const timeoutInSeconds = options.timeout?.toSeconds();
+        const cfnConfig = {
+            codeBased: {
+                lambdaConfig: {
+                    lambdaArn: options.lambdaFunction.functionArn,
+                    ...(timeoutInSeconds !== undefined ? {
+                        lambdaTimeoutInSeconds: timeoutInSeconds,
+                    } : {}),
+                },
+            },
+        };
+        return new EvaluatorConfig(cfnConfig, options.lambdaFunction);
+    }
+    /**
+     * The Lambda function used for code-based evaluation, if applicable.
+     */
+    lambdaFunction;
+    cfnConfig;
+    constructor(cfnConfig, lambdaFunction) {
+        this.cfnConfig = cfnConfig;
+        this.lambdaFunction = lambdaFunction;
+    }
+    /**
+     * Binds the evaluator configuration to produce the L1 property.
+     * @internal
+     */
+    _bind() {
+        return this.cfnConfig;
+    }
+}
+exports.EvaluatorConfig = EvaluatorConfig;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"evaluator-config.js","sourceRoot":"","sources":["evaluator-config.ts"],"names":[],"mappings":";;;;;AAiBA,6DAK8B;AAoF9B;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAa,oBAAoB;;IAC/B;;;;;;;OAOG;IACI,MAAM,CAAC,WAAW,CAAC,OAAkC;QAC1D,IAAA,mCAAc,EAAC,mDAA8B,EAAE,OAAO,CAAC,CAAC;QACxD,OAAO,IAAI,oBAAoB,CAAC,EAAE,WAAW,EAAE,OAAO,EAAE,CAAC,CAAC;KAC3D;IAED;;;;;;;OAOG;IACI,MAAM,CAAC,SAAS,CAAC,OAAgC;QACtD,IAAA,mCAAc,EAAC,iDAA4B,EAAE,OAAO,CAAC,CAAC;QACtD,OAAO,IAAI,oBAAoB,CAAC,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC,CAAC;KACzD;IAEgB,MAAM,CAAoD;IAE3E,YAAoB,MAAyD;QAC3E,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;KACtB;IAED;;;OAGG;IACI,KAAK;QACV,OAAO,IAAI,CAAC,MAAM,CAAC;KACpB;;AAvCH,oDAwCC;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAa,eAAe;;IAC1B;;;;;;;OAOG;IACI,MAAM,CAAC,WAAW,CAAC,OAA2B;;;;;;;;;;QACnD,IAAA,mCAAc,EAAC,yCAAoB,EAAE,OAAO,CAAC,YAAY,CAAC,CAAC;QAE3D,MAAM,WAAW,GAA+D;YAC9E,2BAA2B,EAAE;gBAC3B,OAAO,EAAE,OAAO,CAAC,OAAO;gBACxB,GAAG,CAAC,OAAO,CAAC,eAAe,KAAK,SAAS,CAAC,CAAC,CAAC;oBAC1C,eAAe,EAAE;wBACf,SAAS,EAAE,OAAO,CAAC,eAAe,CAAC,SAAS;wBAC5C,WAAW,EAAE,OAAO,CAAC,eAAe,CAAC,WAAW;wBAChD,IAAI,EAAE,OAAO,CAAC,eAAe,CAAC,IAAI;qBACnC;iBACF,CAAC,CAAC,CAAC,EAAE,CAAC;gBACP,GAAG,CAAC,OAAO,CAAC,4BAA4B,KAAK,SAAS,CAAC,CAAC,CAAC;oBACvD,4BAA4B,EAAE,OAAO,CAAC,4BAA4B;iBACnE,CAAC,CAAC,CAAC,EAAE,CAAC;aACR;SACF,CAAC;QAEF,MAAM,SAAS,GAA0D;YACvE,WAAW,EAAE;gBACX,YAAY,EAAE,OAAO,CAAC,YAAY;gBAClC,WAAW;gBACX,WAAW,EAAE,OAAO,CAAC,WAAW,CAAC,KAAK,EAAE;aACzC;SACF,CAAC;QAEF,OAAO,IAAI,eAAe,CAAC,SAAS,CAAC,CAAC;KACvC;IAED;;;;;;;OAOG;IACI,MAAM,CAAC,SAAS,CAAC,OAAyB;;;;;;;;;;QAC/C,MAAM,gBAAgB,GAAG,OAAO,CAAC,OAAO,EAAE,SAAS,EAAE,CAAC;QAEtD,MAAM,SAAS,GAA0D;YACvE,SAAS,EAAE;gBACT,YAAY,EAAE;oBACZ,SAAS,EAAE,OAAO,CAAC,cAAc,CAAC,WAAW;oBAC7C,GAAG,CAAC,gBAAgB,KAAK,SAAS,CAAC,CAAC,CAAC;wBACnC,sBAAsB,EAAE,gBAAgB;qBACzC,CAAC,CAAC,CAAC,EAAE,CAAC;iBACR;aACF;SACF,CAAC;QAEF,OAAO,IAAI,eAAe,CAAC,SAAS,EAAE,OAAO,CAAC,cAAc,CAAC,CAAC;KAC/D;IAED;;OAEG;IACa,cAAc,CAAoB;IAEjC,SAAS,CAAwD;IAElF,YACE,SAAgE,EAChE,cAAiC;QAEjC,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;QAC3B,IAAI,CAAC,cAAc,GAAG,cAAc,CAAC;KACtC;IAED;;;OAGG;IACI,KAAK;QACV,OAAO,IAAI,CAAC,SAAS,CAAC;KACvB;;AArFH,0CAsFC","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 type { Duration } from 'aws-cdk-lib';\nimport type * as bedrockagentcore from 'aws-cdk-lib/aws-bedrockagentcore';\nimport type * as lambda from 'aws-cdk-lib/aws-lambda';\nimport type { CategoricalRatingOption, EvaluatorInferenceConfig, NumericalRatingOption } from './types';\nimport {\n  throwIfInvalid,\n  validateCategoricalRatingScale,\n  validateInstructions,\n  validateNumericalRatingScale,\n} from './validation-helpers';\n\n/**\n * Options for configuring an LLM-as-a-Judge custom evaluator.\n *\n * Uses a foundation model to assess agent performance based on\n * custom instructions and a rating scale.\n */\nexport interface LlmAsAJudgeOptions {\n  /**\n   * The evaluation instructions that guide the language model in assessing agent performance.\n   *\n   * These instructions define the evaluation criteria, context, and expected behavior.\n   * Instructions must contain placeholders appropriate for the evaluation level\n   * (e.g., `{context}`, `{available_tools}` for SESSION level).\n   *\n   * Note: Evaluators using reference-input placeholders (e.g., `{expected_tool_trajectory}`,\n   * `{assertions}`, `{expected_response}`) are only compatible with on-demand evaluation,\n   * not online evaluation.\n   *\n   * @see https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/custom-evaluators.html\n   */\n  readonly instructions: string;\n\n  /**\n   * The identifier of the Amazon Bedrock model to use for evaluation.\n   *\n   * Accepts standard model IDs (e.g., `'anthropic.claude-sonnet-4-6'`)\n   * and cross-region inference profile IDs with region prefixes\n   * (e.g., `'us.anthropic.claude-sonnet-4-6'`, `'eu.anthropic.claude-sonnet-4-6'`).\n   */\n  readonly modelId: string;\n\n  /**\n   * The rating scale that defines how the evaluator should score agent performance.\n   */\n  readonly ratingScale: EvaluatorRatingScale;\n\n  /**\n   * Optional inference configuration parameters that control model behavior during evaluation.\n   *\n   * When not specified, the foundation model uses its own default values for\n   * maxTokens, temperature, and topP.\n   *\n   * @default - The foundation model's default inference parameters are used\n   * @see https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/custom-evaluators.html\n   */\n  readonly inferenceConfig?: EvaluatorInferenceConfig;\n\n  /**\n   * Additional model-specific request fields.\n   *\n   * @default - No additional fields\n   */\n  readonly additionalModelRequestFields?: { [key: string]: any };\n}\n\n/**\n * Options for configuring a code-based custom evaluator using a Lambda function.\n *\n * Uses a Lambda function to implement custom evaluation logic.\n */\nexport interface CodeBasedOptions {\n  /**\n   * The Lambda function used for evaluation.\n   *\n   * The function will be granted invoke permissions for the\n   * `bedrock-agentcore.amazonaws.com` service principal, scoped\n   * to this specific evaluator resource.\n   */\n  readonly lambdaFunction: lambda.IFunction;\n\n  /**\n   * The timeout for the Lambda function invocation during evaluation.\n   *\n   * When not specified, the AgentCore evaluation service uses its default\n   * timeout for Lambda-based evaluators.\n   *\n   * @default - The AgentCore evaluation service's default Lambda timeout is used\n   * @see https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/custom-evaluators.html\n   */\n  readonly timeout?: Duration;\n}\n\n/**\n * Represents a rating scale for custom LLM-as-a-Judge evaluators.\n *\n * Rating scales define how the evaluator scores agent performance.\n * Use either categorical (discrete labels) or numerical (labeled numeric values) scales.\n *\n * @example\n * // Categorical rating scale\n * const categorical = agentcore.EvaluatorRatingScale.categorical([\n *   { label: 'Good', definition: 'The response fully addresses the query.' },\n *   { label: 'Bad', definition: 'The response fails to address the query.' },\n * ]);\n *\n * // Numerical rating scale\n * const numerical = agentcore.EvaluatorRatingScale.numerical([\n *   { label: 'Poor', definition: 'Inadequate response.', value: 1 },\n *   { label: 'Good', definition: 'Adequate response.', value: 3 },\n *   { label: 'Excellent', definition: 'Outstanding response.', value: 5 },\n * ]);\n */\nexport class EvaluatorRatingScale {\n  /**\n   * Creates a categorical rating scale.\n   *\n   * Categorical scales define discrete labels for scoring, such as \"Good\" / \"Bad\"\n   * or \"Pass\" / \"Fail\".\n   *\n   * @param options - The categorical rating options (at least 1 required)\n   */\n  public static categorical(options: CategoricalRatingOption[]): EvaluatorRatingScale {\n    throwIfInvalid(validateCategoricalRatingScale, options);\n    return new EvaluatorRatingScale({ categorical: options });\n  }\n\n  /**\n   * Creates a numerical rating scale.\n   *\n   * Numerical scales define labeled numeric values for scoring, such as\n   * 1 (Poor) through 5 (Excellent).\n   *\n   * @param options - The numerical rating options (at least 1 required)\n   */\n  public static numerical(options: NumericalRatingOption[]): EvaluatorRatingScale {\n    throwIfInvalid(validateNumericalRatingScale, options);\n    return new EvaluatorRatingScale({ numerical: options });\n  }\n\n  private readonly config: bedrockagentcore.CfnEvaluator.RatingScaleProperty;\n\n  private constructor(config: bedrockagentcore.CfnEvaluator.RatingScaleProperty) {\n    this.config = config;\n  }\n\n  /**\n   * Binds the rating scale to produce the L1 property.\n   * @internal\n   */\n  public _bind(): bedrockagentcore.CfnEvaluator.RatingScaleProperty {\n    return this.config;\n  }\n}\n\n/**\n * Configuration for a custom evaluator.\n *\n * Defines how an evaluator assesses agent performance. Supports two 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 * @example\n * // LLM-as-a-Judge evaluator\n * const llmConfig = agentcore.EvaluatorConfig.llmAsAJudge({\n *   instructions: 'Evaluate whether the agent response is helpful.',\n *   modelId: 'us.anthropic.claude-sonnet-4-6',\n *   ratingScale: agentcore.EvaluatorRatingScale.categorical([\n *     { label: 'Good', definition: 'The response is helpful.' },\n *     { label: 'Bad', definition: 'The response is not helpful.' },\n *   ]),\n * });\n *\n * // Code-based evaluator\n * declare const myEvalFunction: lambda.IFunction;\n * const codeConfig = agentcore.EvaluatorConfig.codeBased({\n *   lambdaFunction: myEvalFunction,\n * });\n */\nexport class EvaluatorConfig {\n  /**\n   * Creates an LLM-as-a-Judge evaluator configuration.\n   *\n   * Uses a foundation model to assess agent performance based on custom\n   * instructions and a rating scale.\n   *\n   * @param options - The LLM-as-a-Judge configuration options\n   */\n  public static llmAsAJudge(options: LlmAsAJudgeOptions): EvaluatorConfig {\n    throwIfInvalid(validateInstructions, options.instructions);\n\n    const modelConfig: bedrockagentcore.CfnEvaluator.EvaluatorModelConfigProperty = {\n      bedrockEvaluatorModelConfig: {\n        modelId: options.modelId,\n        ...(options.inferenceConfig !== undefined ? {\n          inferenceConfig: {\n            maxTokens: options.inferenceConfig.maxTokens,\n            temperature: options.inferenceConfig.temperature,\n            topP: options.inferenceConfig.topP,\n          },\n        } : {}),\n        ...(options.additionalModelRequestFields !== undefined ? {\n          additionalModelRequestFields: options.additionalModelRequestFields,\n        } : {}),\n      },\n    };\n\n    const cfnConfig: bedrockagentcore.CfnEvaluator.EvaluatorConfigProperty = {\n      llmAsAJudge: {\n        instructions: options.instructions,\n        modelConfig,\n        ratingScale: options.ratingScale._bind(),\n      },\n    };\n\n    return new EvaluatorConfig(cfnConfig);\n  }\n\n  /**\n   * Creates a code-based evaluator configuration using a Lambda function.\n   *\n   * The Lambda function implements custom evaluation logic. The function will\n   * automatically be granted invoke permissions for the bedrock-agentcore service.\n   *\n   * @param options - The code-based configuration options\n   */\n  public static codeBased(options: CodeBasedOptions): EvaluatorConfig {\n    const timeoutInSeconds = options.timeout?.toSeconds();\n\n    const cfnConfig: bedrockagentcore.CfnEvaluator.EvaluatorConfigProperty = {\n      codeBased: {\n        lambdaConfig: {\n          lambdaArn: options.lambdaFunction.functionArn,\n          ...(timeoutInSeconds !== undefined ? {\n            lambdaTimeoutInSeconds: timeoutInSeconds,\n          } : {}),\n        },\n      },\n    };\n\n    return new EvaluatorConfig(cfnConfig, options.lambdaFunction);\n  }\n\n  /**\n   * The Lambda function used for code-based evaluation, if applicable.\n   */\n  public readonly lambdaFunction?: lambda.IFunction;\n\n  private readonly cfnConfig: bedrockagentcore.CfnEvaluator.EvaluatorConfigProperty;\n\n  private constructor(\n    cfnConfig: bedrockagentcore.CfnEvaluator.EvaluatorConfigProperty,\n    lambdaFunction?: lambda.IFunction,\n  ) {\n    this.cfnConfig = cfnConfig;\n    this.lambdaFunction = lambdaFunction;\n  }\n\n  /**\n   * Binds the evaluator configuration to produce the L1 property.\n   * @internal\n   */\n  public _bind(): bedrockagentcore.CfnEvaluator.EvaluatorConfigProperty {\n    return this.cfnConfig;\n  }\n}\n"]}

package/lib/evaluation/evaluator.d.ts

@@ -0,0 +1,68 @@
+/**
+ *  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance
+ *  with the License. A copy of the License is located at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  or in the 'license' file accompanying this file. This file is distributed on an 'AS IS' BASIS, WITHOUT WARRANTIES
+ *  OR CONDITIONS OF ANY KIND, express or implied. See the License for the specific language governing permissions
+ *  and limitations under the License.
+ */
+import type { IEvaluator } from './evaluator-base';
+import type { BuiltinEvaluator, EvaluatorReferenceBindResult } from './types';
+/**
+ * Represents a reference to an evaluator for online evaluation.
+ *
+ * Use the static factory methods to create evaluator references:
+ * - `EvaluatorReference.builtin()` for built-in evaluators
+ * - `EvaluatorReference.custom()` for custom evaluators
+ *
+ * @example
+ * // Using built-in evaluators
+ * const helpfulness = agentcore.EvaluatorReference.builtin(agentcore.BuiltinEvaluator.HELPFULNESS);
+ *
+ * // Using custom evaluators
+ * declare const myCustomEvaluator: agentcore.IEvaluator;
+ * const custom = agentcore.EvaluatorReference.custom(myCustomEvaluator);
+ */
+export declare class EvaluatorReference {
+    /**
+     * Creates a reference to a built-in evaluator.
+     *
+     * Built-in evaluators are provided by Amazon Bedrock AgentCore and assess
+     * different aspects of agent performance at various levels (session, trace, or tool call).
+     *
+     * @param evaluator - The built-in evaluator to reference
+     * @returns An EvaluatorReference instance
+     *
+     * @example
+     * const helpfulness = agentcore.EvaluatorReference.builtin(agentcore.BuiltinEvaluator.HELPFULNESS);
+     * const goalSuccess = agentcore.EvaluatorReference.builtin(agentcore.BuiltinEvaluator.GOAL_SUCCESS_RATE);
+     */
+    static builtin(evaluator: BuiltinEvaluator): EvaluatorReference;
+    /**
+     * Creates a reference to a custom evaluator.
+     *
+     * Custom evaluators are created using the `Evaluator` construct and can be
+     * LLM-as-a-Judge or code-based (Lambda) evaluators.
+     *
+     * @param evaluator - The custom evaluator construct to reference
+     * @returns An EvaluatorReference instance
+     *
+     * @example
+     * declare const myCustomEvaluator: agentcore.IEvaluator;
+     * const ref = agentcore.EvaluatorReference.custom(myCustomEvaluator);
+     */
+    static custom(evaluator: IEvaluator): EvaluatorReference;
+    /**
+     * The evaluator identifier.
+     */
+    readonly evaluatorId: string;
+    private constructor();
+    /**
+     * Binds the evaluator reference to produce the L1 property.
+     */
+    bind(): EvaluatorReferenceBindResult;
+}

package/lib/evaluation/evaluator.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvaluatorReference = void 0;
+const jsiiDeprecationWarnings = require("../../.warnings.jsii.js");
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+/**
+ * Represents a reference to an evaluator for online evaluation.
+ *
+ * Use the static factory methods to create evaluator references:
+ * - `EvaluatorReference.builtin()` for built-in evaluators
+ * - `EvaluatorReference.custom()` for custom evaluators
+ *
+ * @example
+ * // Using built-in evaluators
+ * const helpfulness = agentcore.EvaluatorReference.builtin(agentcore.BuiltinEvaluator.HELPFULNESS);
+ *
+ * // Using custom evaluators
+ * declare const myCustomEvaluator: agentcore.IEvaluator;
+ * 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" };
+    /**
+     * Creates a reference to a built-in evaluator.
+     *
+     * Built-in evaluators are provided by Amazon Bedrock AgentCore and assess
+     * different aspects of agent performance at various levels (session, trace, or tool call).
+     *
+     * @param evaluator - The built-in evaluator to reference
+     * @returns An EvaluatorReference instance
+     *
+     * @example
+     * const helpfulness = agentcore.EvaluatorReference.builtin(agentcore.BuiltinEvaluator.HELPFULNESS);
+     * const goalSuccess = agentcore.EvaluatorReference.builtin(agentcore.BuiltinEvaluator.GOAL_SUCCESS_RATE);
+     */
+    static builtin(evaluator) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_bedrock_agentcore_alpha_BuiltinEvaluator(evaluator);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.builtin);
+            }
+            throw error;
+        }
+        return new EvaluatorReference(evaluator.value);
+    }
+    /**
+     * Creates a reference to a custom evaluator.
+     *
+     * Custom evaluators are created using the `Evaluator` construct and can be
+     * LLM-as-a-Judge or code-based (Lambda) evaluators.
+     *
+     * @param evaluator - The custom evaluator construct to reference
+     * @returns An EvaluatorReference instance
+     *
+     * @example
+     * declare const myCustomEvaluator: agentcore.IEvaluator;
+     * const ref = agentcore.EvaluatorReference.custom(myCustomEvaluator);
+     */
+    static custom(evaluator) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_bedrock_agentcore_alpha_IEvaluator(evaluator);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.custom);
+            }
+            throw error;
+        }
+        return new EvaluatorReference(evaluator.evaluatorId);
+    }
+    /**
+     * The evaluator identifier.
+     */
+    evaluatorId;
+    constructor(evaluatorId) {
+        this.evaluatorId = evaluatorId;
+    }
+    /**
+     * Binds the evaluator reference to produce the L1 property.
+     */
+    bind() {
+        return {
+            evaluatorId: this.evaluatorId,
+        };
+    }
+}
+exports.EvaluatorReference = EvaluatorReference;
+//# sourceMappingURL=data:application/json;base64,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