@aws-cdk/aws-bedrock-agentcore-alpha 2.228.0-alpha.0 → 2.229.0-alpha.0

package/lib/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.229.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.GATEWAY_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 { GATEWAY_SYNC_PERMS } 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: GATEWAY_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/lib/index.d.ts

@@ -1 +1,30 @@
-export * from '../agentcore';
+export * from './memory/memory';
+export * from './memory/strategies/managed-strategy';
+export * from './memory/strategies/self-managed-strategy';
+export * from './memory/memory-strategy';
+export * from './network/network-configuration';
+export * from './runtime/perms';
+export * from './runtime/types';
+export * from './runtime/runtime-base';
+export * from './runtime/runtime-artifact';
+export * from './runtime/runtime-authorizer-configuration';
+export * from './runtime/runtime-endpoint-base';
+export * from './runtime/runtime-endpoint';
+export * from './runtime/runtime';
+export * from './tools/code-interpreter';
+export * from './tools/browser';
+export * from './gateway/gateway-base';
+export * from './gateway/gateway';
+export * from './gateway/perms';
+export * from './gateway/protocol';
+export * from './gateway/inbound-auth/authorizer';
+export * from './gateway/outbound-auth/credential-provider';
+export * from './gateway/outbound-auth/api-key';
+export * from './gateway/outbound-auth/iam-role';
+export * from './gateway/outbound-auth/oauth';
+export * from './gateway/targets/target-base';
+export * from './gateway/targets/target';
+export * from './gateway/targets/target-configuration';
+export * from './gateway/targets/schema/base-schema';
+export * from './gateway/targets/schema/api-schema';
+export * from './gateway/targets/schema/tool-schema';

package/lib/index.js

@@ -1,8 +1,4 @@
 "use strict";
-// The index.ts files contains a list of files we want to
-// include as part of the public API of this module.
-// In general, all files including L2 classes will be listed here,
-// while all files including only utility functions will be omitted from here.
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -18,5 +14,58 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("../agentcore"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEseURBQXlEO0FBQ3pELG9EQUFvRDtBQUNwRCxrRUFBa0U7QUFDbEUsOEVBQThFOzs7Ozs7Ozs7Ozs7Ozs7O0FBRTlFLCtDQUE2QiIsInNvdXJjZXNDb250ZW50IjpbIi8vIFRoZSBpbmRleC50cyBmaWxlcyBjb250YWlucyBhIGxpc3Qgb2YgZmlsZXMgd2Ugd2FudCB0b1xuLy8gaW5jbHVkZSBhcyBwYXJ0IG9mIHRoZSBwdWJsaWMgQVBJIG9mIHRoaXMgbW9kdWxlLlxuLy8gSW4gZ2VuZXJhbCwgYWxsIGZpbGVzIGluY2x1ZGluZyBMMiBjbGFzc2VzIHdpbGwgYmUgbGlzdGVkIGhlcmUsXG4vLyB3aGlsZSBhbGwgZmlsZXMgaW5jbHVkaW5nIG9ubHkgdXRpbGl0eSBmdW5jdGlvbnMgd2lsbCBiZSBvbWl0dGVkIGZyb20gaGVyZS5cblxuZXhwb3J0ICogZnJvbSAnLi4vYWdlbnRjb3JlJztcbiJdfQ==
+__exportStar(require("./memory/memory"), exports);
+__exportStar(require("./memory/strategies/managed-strategy"), exports);
+__exportStar(require("./memory/strategies/self-managed-strategy"), exports);
+__exportStar(require("./memory/memory-strategy"), exports);
+// ===================================
+// Network Configuration
+// ===================================
+__exportStar(require("./network/network-configuration"), exports);
+// ===================================
+// Runtime
+// ===================================
+__exportStar(require("./runtime/perms"), exports);
+__exportStar(require("./runtime/types"), exports);
+__exportStar(require("./runtime/runtime-base"), exports);
+__exportStar(require("./runtime/runtime-artifact"), exports);
+__exportStar(require("./runtime/runtime-authorizer-configuration"), exports);
+__exportStar(require("./runtime/runtime-endpoint-base"), exports);
+__exportStar(require("./runtime/runtime-endpoint"), exports);
+__exportStar(require("./runtime/runtime"), exports);
+// Tools
+// ===================================
+__exportStar(require("./tools/code-interpreter"), exports);
+__exportStar(require("./tools/browser"), exports);
+// ===================================
+// Gateway
+// ===================================
+__exportStar(require("./gateway/gateway-base"), exports);
+__exportStar(require("./gateway/gateway"), exports);
+__exportStar(require("./gateway/perms"), exports);
+__exportStar(require("./gateway/protocol"), exports);
+// validation-helpers contains internal utilities and should not be exported
+// ===================================
+// Gateway - Inbound Auth
+// ===================================
+__exportStar(require("./gateway/inbound-auth/authorizer"), exports);
+// ===================================
+// Gateway - Outbound Auth
+// ===================================
+__exportStar(require("./gateway/outbound-auth/credential-provider"), exports);
+__exportStar(require("./gateway/outbound-auth/api-key"), exports);
+__exportStar(require("./gateway/outbound-auth/iam-role"), exports);
+__exportStar(require("./gateway/outbound-auth/oauth"), exports);
+// ===================================
+// Gateway - Targets
+// ===================================
+__exportStar(require("./gateway/targets/target-base"), exports);
+__exportStar(require("./gateway/targets/target"), exports);
+__exportStar(require("./gateway/targets/target-configuration"), exports);
+// ===================================
+// Gateway - Schemas
+// ===================================
+__exportStar(require("./gateway/targets/schema/base-schema"), exports);
+__exportStar(require("./gateway/targets/schema/api-schema"), exports);
+__exportStar(require("./gateway/targets/schema/tool-schema"), exports);
+//# sourceMappingURL=data:application/json;base64,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

package/{agentcore → lib}/memory/memory-strategy.js

@@ -53,7 +53,7 @@ var MemoryStrategyType;
  * @see https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/memory-strategies.html
  */
 class MemoryStrategy {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-bedrock-agentcore-alpha.MemoryStrategy", version: "2.228.0-alpha.0" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-bedrock-agentcore-alpha.MemoryStrategy", version: "2.229.0-alpha.0" };
     /**
      * Default strategies for organizing and extracting memory data, each optimized for specific use cases.
      * This strategy compresses conversations into concise overviews, preserving essential context and key insights for quick recall.

package/{agentcore → lib}/memory/memory.js

@@ -99,7 +99,7 @@ const MEMORY_EXPIRATION_DAYS_MAX = 365;
  * Contains methods and attributes valid for Memories either created with CDK or imported.
  */
 class MemoryBase extends aws_cdk_lib_1.Resource {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-bedrock-agentcore-alpha.MemoryBase", version: "2.228.0-alpha.0" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-bedrock-agentcore-alpha.MemoryBase", version: "2.229.0-alpha.0" };
     constructor(scope, id) {
         super(scope, id);
     }
@@ -352,7 +352,7 @@ let Memory = (() => {
             Memory = _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.Memory", version: "2.228.0-alpha.0" };
+        static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-bedrock-agentcore-alpha.Memory", version: "2.229.0-alpha.0" };
         /** Uniquely identifies this class. */
         static PROPERTY_INJECTION_ID = '@aws-cdk.aws-bedrock-agentcore-alpha.Memory';
         /**