@aws-cdk/aws-bedrock-agentcore-alpha 2.225.0-alpha.0 → 2.227.0-alpha.0

package/agentcore/gateway/targets/target.js

@@ -0,0 +1,444 @@
+"use strict";
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GatewayTarget = void 0;
+const jsiiDeprecationWarnings = require("../../../.warnings.jsii.js");
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const bedrockagentcore = require("aws-cdk-lib/aws-bedrockagentcore");
+const iam = require("aws-cdk-lib/aws-iam");
+const metadata_resource_1 = require("aws-cdk-lib/core/lib/metadata-resource");
+const prop_injectable_1 = require("aws-cdk-lib/core/lib/prop-injectable");
+const perms_1 = require("../perms");
+const target_base_1 = require("./target-base");
+const target_configuration_1 = require("./target-configuration");
+const credential_provider_1 = require("../outbound-auth/credential-provider");
+const validation_helpers_1 = require("../validation-helpers");
+/******************************************************************************
+ *                                Class
+ *****************************************************************************/
+/**
+ *
+ * Defines tools that your gateway will host. Supports multiple target types:
+ * - Lambda: Wraps a Lambda function as MCP tools
+ * - OpenAPI: Exposes an OpenAPI/REST API as MCP tools
+ * - Smithy: Exposes a Smithy-modeled API as MCP tools
+ *
+ * @resource AWS::BedrockAgentCore::GatewayTarget
+ * @see https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/gateway-building-adding-targets.html
+ */
+let GatewayTarget = (() => {
+    let _classDecorators = [prop_injectable_1.propertyInjectable];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = target_base_1.GatewayTargetBase;
+    let _instanceExtraInitializers = [];
+    let _grantSync_decorators;
+    var GatewayTarget = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _grantSync_decorators = [(0, metadata_resource_1.MethodMetadata)()];
+            __esDecorate(this, null, _grantSync_decorators, { kind: "method", name: "grantSync", static: false, private: false, access: { has: obj => "grantSync" in obj, get: obj => obj.grantSync }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            GatewayTarget = _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.GatewayTarget", version: "2.227.0-alpha.0" };
+        /** Uniquely identifies this class. */
+        static PROPERTY_INJECTION_ID = '@aws-cdk.aws-bedrock-agentcore-alpha.GatewayTarget';
+        /**
+         * Import an existing Gateway Target using its attributes
+         * This allows you to reference a Gateway Target that was created outside of CDK
+         *
+         * @param scope The construct scope
+         * @param id The construct id
+         * @param attrs The attributes of the existing Gateway Target
+         * @returns An IGatewayTarget instance representing the imported target
+         */
+        static fromGatewayTargetAttributes(scope, id, attrs) {
+            try {
+                jsiiDeprecationWarnings._aws_cdk_aws_bedrock_agentcore_alpha_GatewayTargetAttributes(attrs);
+            }
+            catch (error) {
+                if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                    Error.captureStackTrace(error, this.fromGatewayTargetAttributes);
+                }
+                throw error;
+            }
+            class ImportedGatewayTarget extends target_base_1.GatewayTargetBase {
+                targetArn = attrs.targetArn;
+                targetId = attrs.targetId;
+                name = attrs.gatewayTargetName;
+                description = attrs.status;
+                gateway = attrs.gateway;
+                credentialProviderConfigurations = [];
+                targetProtocolType = target_base_1.GatewayTargetProtocolType.MCP;
+                status = attrs.status;
+                statusReasons = undefined;
+                createdAt = attrs.createdAt;
+                updatedAt = attrs.updatedAt;
+                constructor(s, i) {
+                    super(s, i);
+                }
+            }
+            return new ImportedGatewayTarget(scope, id);
+        }
+        /**
+         * Create a Lambda-based MCP target
+         * Convenience method for creating a target that wraps a Lambda function
+         *
+         * @param scope The construct scope
+         * @param id The construct id
+         * @param props The properties for the Lambda target
+         * @returns A new GatewayTarget instance
+         */
+        static forLambda(scope, id, props) {
+            try {
+                jsiiDeprecationWarnings._aws_cdk_aws_bedrock_agentcore_alpha_GatewayTargetLambdaProps(props);
+            }
+            catch (error) {
+                if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                    Error.captureStackTrace(error, this.forLambda);
+                }
+                throw error;
+            }
+            return new GatewayTarget(scope, id, {
+                gateway: props.gateway,
+                gatewayTargetName: props.gatewayTargetName,
+                description: props.description,
+                credentialProviderConfigurations: props.credentialProviderConfigurations,
+                targetConfiguration: target_configuration_1.LambdaTargetConfiguration.create(props.lambdaFunction, props.toolSchema),
+            });
+        }
+        /**
+         * Create an OpenAPI-based MCP target
+         * Convenience method for creating a target that exposes an OpenAPI/REST API
+         *
+         * @param scope The construct scope
+         * @param id The construct id
+         * @param props The properties for the OpenAPI target
+         * @returns A new GatewayTarget instance
+         *
+         */
+        static forOpenApi(scope, id, props) {
+            try {
+                jsiiDeprecationWarnings._aws_cdk_aws_bedrock_agentcore_alpha_GatewayTargetOpenApiProps(props);
+            }
+            catch (error) {
+                if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                    Error.captureStackTrace(error, this.forOpenApi);
+                }
+                throw error;
+            }
+            return new GatewayTarget(scope, id, {
+                gateway: props.gateway,
+                gatewayTargetName: props.gatewayTargetName,
+                description: props.description,
+                credentialProviderConfigurations: props.credentialProviderConfigurations,
+                targetConfiguration: target_configuration_1.OpenApiTargetConfiguration.create(props.apiSchema, props.validateOpenApiSchema),
+            });
+        }
+        /**
+         * Create a Smithy-based MCP target
+         * Convenience method for creating a target that exposes a Smithy-modeled API
+         *
+         * @param scope The construct scope
+         * @param id The construct id
+         * @param props The properties for the Smithy target
+         * @returns A new GatewayTarget instance
+         */
+        static forSmithy(scope, id, props) {
+            try {
+                jsiiDeprecationWarnings._aws_cdk_aws_bedrock_agentcore_alpha_GatewayTargetSmithyProps(props);
+            }
+            catch (error) {
+                if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                    Error.captureStackTrace(error, this.forSmithy);
+                }
+                throw error;
+            }
+            return new GatewayTarget(scope, id, {
+                gateway: props.gateway,
+                gatewayTargetName: props.gatewayTargetName,
+                description: props.description,
+                credentialProviderConfigurations: props.credentialProviderConfigurations,
+                targetConfiguration: target_configuration_1.SmithyTargetConfiguration.create(props.smithyModel),
+            });
+        }
+        /**
+         * Create an MCP Server-based target
+         * Convenience method for creating a target that connects to an external MCP server
+         *
+         * @param scope The construct scope
+         * @param id The construct id
+         * @param props The properties for the MCP server target
+         * @returns A new GatewayTarget instance
+         * @see https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/gateway-target-MCPservers.html
+         */
+        static forMcpServer(scope, id, props) {
+            try {
+                jsiiDeprecationWarnings._aws_cdk_aws_bedrock_agentcore_alpha_GatewayTargetMcpServerProps(props);
+            }
+            catch (error) {
+                if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                    Error.captureStackTrace(error, this.forMcpServer);
+                }
+                throw error;
+            }
+            return new GatewayTarget(scope, id, {
+                gateway: props.gateway,
+                gatewayTargetName: props.gatewayTargetName,
+                description: props.description,
+                credentialProviderConfigurations: props.credentialProviderConfigurations,
+                targetConfiguration: target_configuration_1.McpServerTargetConfiguration.create(props.endpoint),
+            });
+        }
+        /**
+         * The ARN of the gateway target
+         * @attribute
+         */
+        targetArn = __runInitializers(this, _instanceExtraInitializers);
+        /**
+         * The unique identifier of the gateway target
+         * @attribute
+         */
+        targetId;
+        /**
+         * The name of the gateway target
+         */
+        name;
+        /**
+         * Optional description for the gateway target
+         */
+        description;
+        /**
+         * The gateway this target belongs to
+         */
+        gateway;
+        /**
+         * The credential providers for this target
+         */
+        credentialProviderConfigurations;
+        /**
+         * The protocol type (always MCP for now)
+         */
+        targetProtocolType = target_base_1.GatewayTargetProtocolType.MCP;
+        /**
+         * The specific MCP target type (Lambda, OpenAPI, Smithy, or MCP Server)
+         */
+        targetType;
+        /**
+         * The status of the gateway target
+         * @attribute
+         */
+        status;
+        /**
+         * The status reasons for the gateway target
+         * @attribute
+         */
+        statusReasons;
+        /**
+         * Timestamp when the gateway target was created
+         * @attribute
+         */
+        createdAt;
+        /**
+         * Timestamp when the gateway target was last updated
+         * @attribute
+         */
+        updatedAt;
+        targetResource;
+        targetConfiguration;
+        constructor(scope, id, props) {
+            super(scope, id);
+            try {
+                jsiiDeprecationWarnings._aws_cdk_aws_bedrock_agentcore_alpha_GatewayTargetProps(props);
+            }
+            catch (error) {
+                if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                    Error.captureStackTrace(error, GatewayTarget);
+                }
+                throw error;
+            }
+            // Enhanced CDK Analytics Telemetry
+            (0, metadata_resource_1.addConstructMetadata)(this, props);
+            // Validate and assign properties
+            this.name = props.gatewayTargetName;
+            this.validateGatewayTargetName(this.name);
+            this.description = props.description;
+            if (this.description) {
+                this.validateDescription(this.description);
+            }
+            this.gateway = props.gateway;
+            this.targetConfiguration = props.targetConfiguration;
+            this.targetType = this.targetConfiguration.targetType;
+            // Get target-specific credential configurations
+            this.credentialProviderConfigurations = this._getTargetSpecificCredentials(props.credentialProviderConfigurations);
+            // Bind the target configuration
+            // This sets up permissions and dependencies
+            this.targetConfiguration.bind(this, this.gateway);
+            // Create the L1 construct
+            const cfnProps = {
+                gatewayIdentifier: this.gateway.gatewayId,
+                name: this.name,
+                description: this.description,
+                credentialProviderConfigurations: aws_cdk_lib_1.Lazy.any({
+                    produce: () => this._renderCredentialProviderConfigurations(),
+                }),
+                targetConfiguration: aws_cdk_lib_1.Lazy.any({
+                    produce: () => this.targetConfiguration._render(),
+                }),
+            };
+            this.targetResource = new bedrockagentcore.CfnGatewayTarget(this, 'Resource', cfnProps);
+            if (this.credentialProviderConfigurations) {
+                for (const provider of this.credentialProviderConfigurations) {
+                    provider
+                        .grantNeededPermissionsToRole(this.gateway.role)
+                        ?.applyBefore(this.targetResource);
+                }
+            }
+            this.targetId = this.targetResource.attrTargetId;
+            this.targetArn = this.targetResource.ref;
+            this.status = this.targetResource.attrStatus;
+            this.statusReasons = this.targetResource.attrStatusReasons;
+            this.createdAt = this.targetResource.attrCreatedAt;
+            this.updatedAt = this.targetResource.attrUpdatedAt;
+        }
+        /**
+         * Grants permission to synchronize this gateway's targets
+         *
+         * This method grants the `SynchronizeGatewayTargets` permission, which is primarily
+         * needed for MCP Server targets when you need to refresh the tool catalog after the
+         * MCP server's tools have changed.
+         */
+        grantSync(grantee) {
+            return iam.Grant.addToPrincipal({
+                grantee: grantee,
+                actions: perms_1.GatewayPerms.SYNC_PERMS,
+                resourceArns: [this.gateway.gatewayArn],
+            });
+        }
+        /**
+         * Determines the credential provider configurations based on target type
+         *
+         * - Lambda & Smithy: Default to IAM role if not provided
+         * - MCP Server: Return undefined if not provided (service handles NoAuth)
+         * - OpenAPI: Return as-is (must be explicitly provided)
+         *
+         * @param providedCredentials The credentials from props
+         * @returns The credential configurations to use, or undefined
+         * @internal
+         */
+        _getTargetSpecificCredentials(providedCredentials) {
+            if (providedCredentials && providedCredentials.length > 0) {
+                return providedCredentials;
+            }
+            // Apply target-specific defaults when not provided
+            switch (this.targetType) {
+                case target_base_1.McpTargetType.LAMBDA:
+                case target_base_1.McpTargetType.SMITHY_MODEL:
+                    return [credential_provider_1.GatewayCredentialProvider.fromIamRole()];
+                case target_base_1.McpTargetType.MCP_SERVER:
+                    // Return empty array, - service handles NoAuth automatically
+                    return undefined;
+                case target_base_1.McpTargetType.OPENAPI_SCHEMA:
+                    // No default - must be explicitly provided, service handles automatically
+                    return undefined;
+                default:
+                    return [credential_provider_1.GatewayCredentialProvider.fromIamRole()];
+            }
+        }
+        /**
+         * Renders credential provider configurations for CloudFormation
+         * @internal
+         */
+        _renderCredentialProviderConfigurations() {
+            return this.credentialProviderConfigurations?.map(provider => provider._render());
+        }
+        /**
+         * Validates the gateway target name format
+         * Pattern: ^([0-9a-zA-Z][-]?){1,100}$
+         * Max length: 100 characters
+         * @param gatewayTargetName The gateway target name to validate
+         * @throws Error if the name is invalid
+         * @internal
+         */
+        validateGatewayTargetName(gatewayTargetName) {
+            if (aws_cdk_lib_1.Token.isUnresolved(gatewayTargetName)) {
+                return;
+            }
+            const lengthErrors = (0, validation_helpers_1.validateStringField)({
+                value: gatewayTargetName,
+                fieldName: 'Gateway target name',
+                minLength: 1,
+                maxLength: 100,
+            });
+            const patternErrors = (0, validation_helpers_1.validateFieldPattern)(gatewayTargetName, 'Gateway target name', /^([0-9a-zA-Z][-]?){1,100}$/, 'Gateway target name must contain only alphanumeric characters and hyphens, with hyphens only between characters');
+            const allErrors = [...lengthErrors, ...patternErrors];
+            if (allErrors.length > 0) {
+                throw new validation_helpers_1.ValidationError(allErrors.join('\n'));
+            }
+        }
+        /**
+         * Validates the description format
+         * Must be between 1 and 200 characters
+         * @throws Error if validation fails
+         * @internal
+         */
+        validateDescription(description) {
+            if (aws_cdk_lib_1.Token.isUnresolved(description)) {
+                return;
+            }
+            const errors = (0, validation_helpers_1.validateStringField)({
+                value: description,
+                fieldName: 'Gateway target description',
+                minLength: 1,
+                maxLength: 200,
+            });
+            if (errors.length > 0) {
+                throw new validation_helpers_1.ValidationError(errors.join('\n'));
+            }
+        }
+        static {
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return GatewayTarget = _classThis;
+})();
+exports.GatewayTarget = GatewayTarget;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"target.js","sourceRoot":"","sources":["target.ts"],"names":[],"mappings":"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","sourcesContent":["import { Lazy, Token } from 'aws-cdk-lib';\nimport * as bedrockagentcore from 'aws-cdk-lib/aws-bedrockagentcore';\nimport * as iam from 'aws-cdk-lib/aws-iam';\nimport { IFunction } from 'aws-cdk-lib/aws-lambda';\nimport { addConstructMetadata, MethodMetadata } from 'aws-cdk-lib/core/lib/metadata-resource';\nimport { propertyInjectable } from 'aws-cdk-lib/core/lib/prop-injectable';\nimport { Construct } from 'constructs';\nimport { IGateway } from '../gateway-base';\nimport { GatewayPerms } from '../perms';\nimport { ApiSchema } from './schema/api-schema';\nimport { ToolSchema } from './schema/tool-schema';\nimport { GatewayTargetBase, GatewayTargetProtocolType, IGatewayTarget, IMcpGatewayTarget, McpTargetType } from './target-base';\nimport { ITargetConfiguration, LambdaTargetConfiguration, McpServerTargetConfiguration, OpenApiTargetConfiguration, SmithyTargetConfiguration } from './target-configuration';\nimport { GatewayCredentialProvider, ICredentialProviderConfig } from '../outbound-auth/credential-provider';\nimport { validateStringField, validateFieldPattern, ValidationError } from '../validation-helpers';\n\n/******************************************************************************\n *                                Props\n *****************************************************************************/\n\n/**\n * Common properties for all Gateway Target types\n */\nexport interface GatewayTargetCommonProps {\n  /**\n   * The name of the gateway target\n   * The name must be unique within the gateway\n   * Pattern: ^([0-9a-zA-Z][-]?){1,100}$\n   */\n  readonly gatewayTargetName: string;\n\n  /**\n   * Optional description for the gateway target\n   * The description can have up to 200 characters\n   * @default - No description\n   */\n  readonly description?: string;\n}\n\n/**\n * Properties for creating a Gateway Target resource\n */\nexport interface GatewayTargetProps extends GatewayTargetCommonProps {\n  /**\n   * The gateway this target belongs to\n   */\n  readonly gateway: IGateway;\n\n  /**\n   * The target configuration (Lambda, OpenAPI, or Smithy)\n   * Use one of the configuration helper classes:\n   * - LambdaTargetConfiguration.create()\n   * - OpenApiTargetConfiguration.create()\n   * - SmithyTargetConfiguration.create()\n   */\n  readonly targetConfiguration: ITargetConfiguration;\n\n  /**\n   * Credential providers for authentication\n   * @default - [GatewayCredentialProvider.fromIamRole()]\n   */\n  readonly credentialProviderConfigurations?: ICredentialProviderConfig[];\n}\n\n/**\n * Properties for creating a Lambda-based Gateway Target\n * Convenience interface for the most common use case\n */\nexport interface GatewayTargetLambdaProps extends GatewayTargetCommonProps {\n  /**\n   * The gateway this target belongs to\n   */\n  readonly gateway: IGateway;\n\n  /**\n   * The Lambda function to associate with this target\n   */\n  readonly lambdaFunction: IFunction;\n\n  /**\n   * The tool schema defining the available tools\n   */\n  readonly toolSchema: ToolSchema;\n\n  /**\n   * Credential providers for authentication\n   * Lambda targets only support IAM role authentication\n   * @default - [GatewayCredentialProvider.fromIamRole()]\n   */\n  readonly credentialProviderConfigurations?: ICredentialProviderConfig[];\n}\n\n/**\n * Properties for creating an OpenAPI-based Gateway Target\n */\nexport interface GatewayTargetOpenApiProps extends GatewayTargetCommonProps {\n  /**\n   * The gateway this target belongs to\n   */\n  readonly gateway: IGateway;\n\n  /**\n   * The OpenAPI schema defining the API\n   */\n  readonly apiSchema: ApiSchema;\n\n  /**\n   * Whether to validate the OpenAPI schema (only applies to inline schemas)\n   * Note: Validation is only performed for inline schemas during CDK synthesis.\n   * S3 and asset-based schemas cannot be validated at synthesis time.\n   * @default true\n   */\n  readonly validateOpenApiSchema?: boolean;\n\n  /**\n   * Credential providers for authentication\n   * OpenAPI targets support API key and OAuth authentication (not IAM)\n   * @default: If not provided, defaults to IAM role which will fail at runtime\n   */\n  readonly credentialProviderConfigurations?: ICredentialProviderConfig[];\n}\n\n/**\n * Properties for creating a Smithy-based Gateway Target\n */\nexport interface GatewayTargetSmithyProps extends GatewayTargetCommonProps {\n  /**\n   * The gateway this target belongs to\n   */\n  readonly gateway: IGateway;\n\n  /**\n   * The Smithy model defining the API\n   */\n  readonly smithyModel: ApiSchema;\n\n  /**\n   * Credential providers for authentication\n   * Smithy targets only support IAM role authentication\n   * @default - [GatewayCredentialProvider.fromIamRole()]\n   */\n  readonly credentialProviderConfigurations?: ICredentialProviderConfig[];\n}\n\n/**\n * Properties for creating an MCP Server-based Gateway Target\n */\nexport interface GatewayTargetMcpServerProps extends GatewayTargetCommonProps {\n  /**\n   * The gateway this target belongs to\n   */\n  readonly gateway: IGateway;\n\n  /**\n   * The HTTPS endpoint URL of the MCP server\n   *\n   * The endpoint must:\n   * - Use HTTPS protocol\n   * - Be properly URL-encoded\n   * - Point to an MCP server that implements tool capabilities\n   */\n  readonly endpoint: string;\n\n  /**\n   * Credential providers for authentication\n   */\n  readonly credentialProviderConfigurations: ICredentialProviderConfig[];\n}\n\n/**\n * Attributes for importing an existing Gateway Target\n */\nexport interface GatewayTargetAttributes {\n  /**\n   * The ARN of the gateway target\n   */\n  readonly targetArn: string;\n\n  /**\n   * The ID of the gateway target\n   */\n  readonly targetId: string;\n\n  /**\n   * The name of the gateway target\n   */\n  readonly gatewayTargetName: string;\n\n  /**\n   * The gateway this target belongs to\n   */\n  readonly gateway: IGateway;\n\n  /**\n   * Optional status of the target\n   * @default - No status\n   */\n  readonly status?: string;\n\n  /**\n   * Optional creation timestamp\n   * @default - No creation timestamp\n   */\n  readonly createdAt?: string;\n\n  /**\n   * Optional last update timestamp\n   * @default - No update timestamp\n   */\n  readonly updatedAt?: string;\n}\n\n/******************************************************************************\n *                                Class\n *****************************************************************************/\n\n/**\n *\n * Defines tools that your gateway will host. Supports multiple target types:\n * - Lambda: Wraps a Lambda function as MCP tools\n * - OpenAPI: Exposes an OpenAPI/REST API as MCP tools\n * - Smithy: Exposes a Smithy-modeled API as MCP tools\n *\n * @resource AWS::BedrockAgentCore::GatewayTarget\n * @see https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/gateway-building-adding-targets.html\n */\n@propertyInjectable\nexport class GatewayTarget extends GatewayTargetBase implements IMcpGatewayTarget {\n  /** Uniquely identifies this class. */\n  public static readonly PROPERTY_INJECTION_ID: string = '@aws-cdk.aws-bedrock-agentcore-alpha.GatewayTarget';\n  /**\n   * Import an existing Gateway Target using its attributes\n   * This allows you to reference a Gateway Target that was created outside of CDK\n   *\n   * @param scope The construct scope\n   * @param id The construct id\n   * @param attrs The attributes of the existing Gateway Target\n   * @returns An IGatewayTarget instance representing the imported target\n   */\n  public static fromGatewayTargetAttributes(\n    scope: Construct,\n    id: string,\n    attrs: GatewayTargetAttributes,\n  ): IGatewayTarget {\n    class ImportedGatewayTarget extends GatewayTargetBase {\n      public readonly targetArn = attrs.targetArn;\n      public readonly targetId = attrs.targetId;\n      public readonly name = attrs.gatewayTargetName;\n      public readonly description = attrs.status;\n      public readonly gateway = attrs.gateway;\n      public readonly credentialProviderConfigurations = [];\n      public readonly targetProtocolType = GatewayTargetProtocolType.MCP;\n      public readonly status = attrs.status;\n      public readonly statusReasons = undefined;\n      public readonly createdAt = attrs.createdAt;\n      public readonly updatedAt = attrs.updatedAt;\n\n      constructor(s: Construct, i: string) {\n        super(s, i);\n      }\n    }\n    return new ImportedGatewayTarget(scope, id);\n  }\n\n  /**\n   * Create a Lambda-based MCP target\n   * Convenience method for creating a target that wraps a Lambda function\n   *\n   * @param scope The construct scope\n   * @param id The construct id\n   * @param props The properties for the Lambda target\n   * @returns A new GatewayTarget instance\n   */\n  public static forLambda(\n    scope: Construct,\n    id: string,\n    props: GatewayTargetLambdaProps,\n  ): GatewayTarget {\n    return new GatewayTarget(scope, id, {\n      gateway: props.gateway,\n      gatewayTargetName: props.gatewayTargetName,\n      description: props.description,\n      credentialProviderConfigurations: props.credentialProviderConfigurations,\n      targetConfiguration: LambdaTargetConfiguration.create(\n        props.lambdaFunction,\n        props.toolSchema,\n      ),\n    });\n  }\n\n  /**\n   * Create an OpenAPI-based MCP target\n   * Convenience method for creating a target that exposes an OpenAPI/REST API\n   *\n   * @param scope The construct scope\n   * @param id The construct id\n   * @param props The properties for the OpenAPI target\n   * @returns A new GatewayTarget instance\n   *\n   */\n  public static forOpenApi(\n    scope: Construct,\n    id: string,\n    props: GatewayTargetOpenApiProps,\n  ): GatewayTarget {\n    return new GatewayTarget(scope, id, {\n      gateway: props.gateway,\n      gatewayTargetName: props.gatewayTargetName,\n      description: props.description,\n      credentialProviderConfigurations: props.credentialProviderConfigurations,\n      targetConfiguration: OpenApiTargetConfiguration.create(props.apiSchema, props.validateOpenApiSchema),\n    });\n  }\n\n  /**\n   * Create a Smithy-based MCP target\n   * Convenience method for creating a target that exposes a Smithy-modeled API\n   *\n   * @param scope The construct scope\n   * @param id The construct id\n   * @param props The properties for the Smithy target\n   * @returns A new GatewayTarget instance\n   */\n  public static forSmithy(\n    scope: Construct,\n    id: string,\n    props: GatewayTargetSmithyProps,\n  ): GatewayTarget {\n    return new GatewayTarget(scope, id, {\n      gateway: props.gateway,\n      gatewayTargetName: props.gatewayTargetName,\n      description: props.description,\n      credentialProviderConfigurations: props.credentialProviderConfigurations,\n      targetConfiguration: SmithyTargetConfiguration.create(props.smithyModel),\n    });\n  }\n\n  /**\n   * Create an MCP Server-based target\n   * Convenience method for creating a target that connects to an external MCP server\n   *\n   * @param scope The construct scope\n   * @param id The construct id\n   * @param props The properties for the MCP server target\n   * @returns A new GatewayTarget instance\n   * @see https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/gateway-target-MCPservers.html\n   */\n  public static forMcpServer(\n    scope: Construct,\n    id: string,\n    props: GatewayTargetMcpServerProps,\n  ): GatewayTarget {\n    return new GatewayTarget(scope, id, {\n      gateway: props.gateway,\n      gatewayTargetName: props.gatewayTargetName,\n      description: props.description,\n      credentialProviderConfigurations: props.credentialProviderConfigurations,\n      targetConfiguration: McpServerTargetConfiguration.create(props.endpoint),\n    });\n  }\n\n  /**\n   * The ARN of the gateway target\n   * @attribute\n   */\n  public readonly targetArn;\n\n  /**\n   * The unique identifier of the gateway target\n   * @attribute\n   */\n  public readonly targetId;\n\n  /**\n   * The name of the gateway target\n   */\n  public readonly name;\n\n  /**\n   * Optional description for the gateway target\n   */\n  public readonly description;\n\n  /**\n   * The gateway this target belongs to\n   */\n  public readonly gateway;\n\n  /**\n   * The credential providers for this target\n   */\n  public readonly credentialProviderConfigurations: ICredentialProviderConfig[] | undefined;\n\n  /**\n   * The protocol type (always MCP for now)\n   */\n  public readonly targetProtocolType = GatewayTargetProtocolType.MCP;\n\n  /**\n   * The specific MCP target type (Lambda, OpenAPI, Smithy, or MCP Server)\n   */\n  public readonly targetType: McpTargetType;\n\n  /**\n   * The status of the gateway target\n   * @attribute\n   */\n  public readonly status?;\n\n  /**\n   * The status reasons for the gateway target\n   * @attribute\n   */\n  public readonly statusReasons?: string[];\n\n  /**\n   * Timestamp when the gateway target was created\n   * @attribute\n   */\n  public readonly createdAt?;\n\n  /**\n   * Timestamp when the gateway target was last updated\n   * @attribute\n   */\n  public readonly updatedAt?;\n\n  private readonly targetResource: bedrockagentcore.CfnGatewayTarget;\n  private readonly targetConfiguration: ITargetConfiguration;\n\n  constructor(scope: Construct, id: string, props: GatewayTargetProps) {\n    super(scope, id);\n    // Enhanced CDK Analytics Telemetry\n    addConstructMetadata(this, props);\n\n    // Validate and assign properties\n    this.name = props.gatewayTargetName;\n    this.validateGatewayTargetName(this.name);\n\n    this.description = props.description;\n    if (this.description) {\n      this.validateDescription(this.description);\n    }\n\n    this.gateway = props.gateway;\n    this.targetConfiguration = props.targetConfiguration;\n    this.targetType = this.targetConfiguration.targetType;\n\n    // Get target-specific credential configurations\n    this.credentialProviderConfigurations = this._getTargetSpecificCredentials(\n      props.credentialProviderConfigurations,\n    );\n\n    // Bind the target configuration\n    // This sets up permissions and dependencies\n    this.targetConfiguration.bind(this, this.gateway);\n\n    // Create the L1 construct\n    const cfnProps: bedrockagentcore.CfnGatewayTargetProps = {\n      gatewayIdentifier: this.gateway.gatewayId,\n      name: this.name,\n      description: this.description,\n      credentialProviderConfigurations: Lazy.any({\n        produce: () => this._renderCredentialProviderConfigurations(),\n      }),\n\n      targetConfiguration: Lazy.any({\n        produce: () => this.targetConfiguration._render(),\n      }),\n    };\n\n    this.targetResource = new bedrockagentcore.CfnGatewayTarget(\n      this,\n      'Resource',\n      cfnProps,\n    );\n\n    if (this.credentialProviderConfigurations) {\n      for (const provider of this.credentialProviderConfigurations) {\n        provider\n          .grantNeededPermissionsToRole(this.gateway.role)\n          ?.applyBefore(this.targetResource);\n      }\n    }\n\n    this.targetId = this.targetResource.attrTargetId;\n    this.targetArn = this.targetResource.ref;\n    this.status = this.targetResource.attrStatus;\n    this.statusReasons = this.targetResource.attrStatusReasons;\n    this.createdAt = this.targetResource.attrCreatedAt;\n    this.updatedAt = this.targetResource.attrUpdatedAt;\n  }\n\n  /**\n   * Grants permission to synchronize this gateway's targets\n   *\n   * This method grants the `SynchronizeGatewayTargets` permission, which is primarily\n   * needed for MCP Server targets when you need to refresh the tool catalog after the\n   * MCP server's tools have changed.\n   */\n  @MethodMetadata()\n  public grantSync(grantee: iam.IGrantable): iam.Grant {\n    return iam.Grant.addToPrincipal({\n      grantee: grantee,\n      actions: GatewayPerms.SYNC_PERMS,\n      resourceArns: [this.gateway.gatewayArn],\n    });\n  }\n\n  /**\n   * Determines the credential provider configurations based on target type\n   *\n   * - Lambda & Smithy: Default to IAM role if not provided\n   * - MCP Server: Return undefined if not provided (service handles NoAuth)\n   * - OpenAPI: Return as-is (must be explicitly provided)\n   *\n   * @param providedCredentials The credentials from props\n   * @returns The credential configurations to use, or undefined\n   * @internal\n   */\n  private _getTargetSpecificCredentials(\n    providedCredentials: ICredentialProviderConfig[] | undefined,\n  ): ICredentialProviderConfig[] | undefined {\n    if (providedCredentials && providedCredentials.length > 0) {\n      return providedCredentials;\n    }\n    // Apply target-specific defaults when not provided\n    switch (this.targetType) {\n      case McpTargetType.LAMBDA:\n      case McpTargetType.SMITHY_MODEL:\n        return [GatewayCredentialProvider.fromIamRole()];\n\n      case McpTargetType.MCP_SERVER:\n        // Return empty array, - service handles NoAuth automatically\n        return undefined;\n\n      case McpTargetType.OPENAPI_SCHEMA:\n        // No default - must be explicitly provided, service handles automatically\n        return undefined;\n\n      default:\n        return [GatewayCredentialProvider.fromIamRole()];\n    }\n  }\n\n  /**\n   * Renders credential provider configurations for CloudFormation\n   * @internal\n   */\n  private _renderCredentialProviderConfigurations(): any {\n    return this.credentialProviderConfigurations?.map(provider => provider._render());\n  }\n\n  /**\n   * Validates the gateway target name format\n   * Pattern: ^([0-9a-zA-Z][-]?){1,100}$\n   * Max length: 100 characters\n   * @param gatewayTargetName The gateway target name to validate\n   * @throws Error if the name is invalid\n   * @internal\n   */\n  private validateGatewayTargetName(gatewayTargetName: string): void {\n    if (Token.isUnresolved(gatewayTargetName)) {\n      return;\n    }\n\n    const lengthErrors = validateStringField({\n      value: gatewayTargetName,\n      fieldName: 'Gateway target name',\n      minLength: 1,\n      maxLength: 100,\n    });\n\n    const patternErrors = validateFieldPattern(\n      gatewayTargetName,\n      'Gateway target name',\n      /^([0-9a-zA-Z][-]?){1,100}$/,\n      'Gateway target name must contain only alphanumeric characters and hyphens, with hyphens only between characters',\n    );\n\n    const allErrors = [...lengthErrors, ...patternErrors];\n    if (allErrors.length > 0) {\n      throw new ValidationError(allErrors.join('\\n'));\n    }\n  }\n\n  /**\n   * Validates the description format\n   * Must be between 1 and 200 characters\n   * @throws Error if validation fails\n   * @internal\n   */\n  private validateDescription(description: string): void {\n    if (Token.isUnresolved(description)) {\n      return;\n    }\n\n    const errors = validateStringField({\n      value: description,\n      fieldName: 'Gateway target description',\n      minLength: 1,\n      maxLength: 200,\n    });\n\n    if (errors.length > 0) {\n      throw new ValidationError(errors.join('\\n'));\n    }\n  }\n}\n"]}

package/agentcore/gateway/validation-helpers.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Error thrown when validation fails
+ * @internal
+ */
+export declare class ValidationError extends Error {
+    constructor(message: string);
+}
+interface IntervalValidation {
+    fieldName: string;
+    minLength: number;
+    maxLength: number;
+}
+interface StringLengthValidation extends IntervalValidation {
+    value: string;
+}
+/**
+ * Validates the length of a string field against minimum and maximum constraints.
+ * @param value - The string value to validate
+ * @param fieldName - Name of the field being validated (for error messages)
+ * @param minLength - Minimum allowed length (defaults to 0)
+ * @param maxLength - Maximum allowed length
+ * @returns true if validation passes
+ * @throws Error if validation fails with current length information
+ * @internal
+ */
+export declare function validateStringField(params: StringLengthValidation): string[];
+/**
+ * Validates a string field against a regex pattern.
+ * @param value - The string value to validate
+ * @param fieldName - Name of the field being validated (for error messages)
+ * @param pattern - Regular expression pattern to test against
+ * @param customMessage - Optional custom error message
+ * @returns true if validation passes
+ * @throws Error if validation fails with detailed message
+ * @internal
+ */
+export declare function validateFieldPattern(value: string, fieldName: string, pattern: RegExp, customMessage?: string): string[];
+/**
+ * @internal
+ */
+export type ValidationFn<T> = (param: T) => string[];
+/**
+ * OpenAPI schema validation parameters
+ * @internal
+ */
+export interface OpenApiSchemaValidationParams {
+    /**
+     * The OpenAPI schema to validate (as a string)
+     */
+    schema: string;
+    /**
+     * Optional name for the schema (for error messages)
+     */
+    schemaName?: string;
+}
+/**
+ * Validates an OpenAPI schema against Gateway requirements
+ * Based on AWS documentation: https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/gateway-schema-openapi.html
+ *
+ * @param params - The validation parameters
+ * @returns Array of validation error messages (empty if valid)
+ * @internal
+ */
+export declare function validateOpenApiSchema(params: OpenApiSchemaValidationParams): string[];
+export {};