konokenj.cdk-api-mcp-server 0.61.0__py3-none-any.whl → 0.63.0__py3-none-any.whl

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-dynamodb/TABLE_V1_API.md

@@ -211,12 +211,12 @@ To get the partition key and sort key of the table or indexes you have configure
 ```ts
 declare const table: dynamodb.Table;
 
-// For single keys, use schema() (deprecated for compound keys)
+// For single keys, use schema() (deprecated for multi-attribute keys)
 const schema = table.schema();
 const partitionKey = schema.partitionKey;
 const sortKey = schema.sortKey;
 
-// For compound keys, use schemaV2() which returns normalized arrays
+// For multi-attribute keys, use schemaV2() which returns normalized arrays
 const schemaV2 = table.schemaV2();
 const partitionKeys = schemaV2.partitionKeys; // Attribute[]
 const sortKeys = schemaV2.sortKeys; // Attribute[]
@@ -225,11 +225,11 @@ const sortKeys = schemaV2.sortKeys; // Attribute[]
 const indexSchema = table.schemaV2('INDEX_NAME');
 ```
 
-Note: `schema()` is deprecated for indexes with compound keys and will throw an error. Use `schemaV2()` instead, which always returns normalized arrays.
+Note: `schema()` is deprecated for indexes with multi-attribute keys and will throw an error. Use `schemaV2()` instead, which always returns normalized arrays.
 
-## Global Secondary Indexes with Compound Keys
+## Global Secondary Indexes with multi-attribute Keys
 
-Global secondary indexes support compound keys, allowing you to specify multiple partition keys and/or multiple sort keys. This enables more flexible query patterns for complex data models.
+Global secondary indexes support multi-attribute keys, allowing you to specify multiple partition keys and/or multiple sort keys. This enables more flexible query patterns for complex data models.
 
 **Key Constraints:**
 - You can specify up to **4 partition keys** per global secondary index
@@ -249,7 +249,7 @@ const table = new dynamodb.Table(this, 'Table', {
 });
 
 table.addGlobalSecondaryIndex({
-  indexName: 'compound-gsi',
+  indexName: 'multi-attribute-gsi',
   partitionKeys: [
     { name: 'gsi_pk1', type: dynamodb.AttributeType.STRING },
     { name: 'gsi_pk2', type: dynamodb.AttributeType.NUMBER },

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-dynamodb/integ.dynamodb-v2.policy.ts

@@ -33,10 +33,18 @@ class TestStack extends Stack {
       removalPolicy: RemovalPolicy.DESTROY,
       resourcePolicy: docu,
     });
+
+    const table = new dynamodb.TableV2(this, 'TableTestV2-2', {
+      partitionKey: {
+        name: 'id',
+        type: dynamodb.AttributeType.STRING,
+      },
+    });
+    table.grantReadData(new iam.AccountRootPrincipal());
   }
 }
 
-const stack = new TestStack(app, 'ResourcePolicyTest-v2', { env: { region: 'eu-west-1' } });
+const stack = new TestStack(app, 'ResourcePolicyTest-v2');
 
 new IntegTest(app, 'table-v2-resource-policy-integ-test', {
   testCases: [stack],

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-dynamodb/integ.dynamodb.ts

@@ -147,6 +147,7 @@ tableWithCMK.grantStreamRead(role);
 
 const user = new iam.User(stack, 'User');
 table.grantReadData(user);
+table.grantReadData(new iam.AccountRootPrincipal());
 tableWithGlobalAndLocalSecondaryIndex.grantReadData(user);
 
 app.synth();

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ec2/README.md

@@ -1939,30 +1939,57 @@ The `volumeInitializationRate` must be:
 
 ### Configuring Instance Metadata Service (IMDS)
 
-#### Toggling IMDSv1
+#### Comprehensive Metadata Options
 
-You can configure [EC2 Instance Metadata Service](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html) options to either
-allow both IMDSv1 and IMDSv2 or enforce IMDSv2 when interacting with the IMDS.
-
-To do this for a single `Instance`, you can use the `requireImdsv2` property.
-The example below demonstrates IMDSv2 being required on a single `Instance`:
+You can configure [EC2 Instance Metadata Service](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html) options using individual properties. This provides comprehensive control over all metadata service settings:
 
 ```ts
 declare const vpc: ec2.Vpc;
 declare const instanceType: ec2.InstanceType;
 declare const machineImage: ec2.IMachineImage;
 
+// Example 1: Enforce IMDSv2 with comprehensive options
 new ec2.Instance(this, 'Instance', {
   vpc,
   instanceType,
   machineImage,
+  httpEndpoint: true,
+  httpProtocolIpv6: false,
+  httpPutResponseHopLimit: 2,
+  httpTokens: ec2.HttpTokens.REQUIRED,
+  instanceMetadataTags: true,
+});
 
-  // ...
+// Example 2: Enforce IMDSv2 with minimal configuration
+new ec2.Instance(this, 'SecureInstance', {
+  vpc,
+  instanceType,
+  machineImage,
+  httpTokens: ec2.HttpTokens.REQUIRED,
+});
+```
+
+#### Simple IMDSv2 Enforcement
+
+For simple IMDSv2 enforcement without additional configuration, you can use the `requireImdsv2` property:
 
+```ts
+declare const vpc: ec2.Vpc;
+declare const instanceType: ec2.InstanceType;
+declare const machineImage: ec2.IMachineImage;
+
+new ec2.Instance(this, 'Instance', {
+  vpc,
+  instanceType,
+  machineImage,
+
+  // Simple IMDSv2 enforcement
   requireImdsv2: true,
 });
 ```
 
+#### Applying to Multiple Instances
+
 You can also use the either the `InstanceRequireImdsv2Aspect` for EC2 instances or the `LaunchTemplateRequireImdsv2Aspect` for EC2 launch templates
 to apply the operation to multiple instances or launch templates, respectively.
 

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ec2/integ.instance-metadata-options.ts

@@ -0,0 +1,51 @@
+import * as cdk from 'aws-cdk-lib';
+import { IntegTest } from '@aws-cdk/integ-tests-alpha';
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
+
+const app = new cdk.App();
+
+class TestStack extends cdk.Stack {
+  constructor(scope: cdk.App, id: string, props?: cdk.StackProps) {
+    super(scope, id, props);
+
+    const vpc = new ec2.Vpc(this, 'VPC', {
+      maxAzs: 3,
+      natGateways: 1,
+    });
+
+    // Test instance with comprehensive metadata options
+    new ec2.Instance(this, 'InstanceWithMetadataOptions', {
+      vpc,
+      instanceType: ec2.InstanceType.of(ec2.InstanceClass.T3, ec2.InstanceSize.NANO),
+      machineImage: new ec2.AmazonLinuxImage({ generation: ec2.AmazonLinuxGeneration.AMAZON_LINUX_2 }),
+      httpEndpoint: true,
+      httpProtocolIpv6: false,
+      httpPutResponseHopLimit: 2,
+      httpTokens: ec2.HttpTokens.REQUIRED,
+      instanceMetadataTags: true,
+    });
+
+    // Test instance with partial metadata options
+    new ec2.Instance(this, 'InstanceWithPartialMetadataOptions', {
+      vpc,
+      instanceType: ec2.InstanceType.of(ec2.InstanceClass.T3, ec2.InstanceSize.NANO),
+      machineImage: new ec2.AmazonLinuxImage({ generation: ec2.AmazonLinuxGeneration.AMAZON_LINUX_2 }),
+      httpTokens: ec2.HttpTokens.REQUIRED,
+      instanceMetadataTags: true,
+    });
+
+    // Test instance with backward compatibility (requireImdsv2)
+    new ec2.Instance(this, 'InstanceWithRequireImdsv2', {
+      vpc,
+      instanceType: ec2.InstanceType.of(ec2.InstanceClass.T3, ec2.InstanceSize.NANO),
+      machineImage: new ec2.AmazonLinuxImage({ generation: ec2.AmazonLinuxGeneration.AMAZON_LINUX_2 }),
+      requireImdsv2: true,
+    });
+  }
+}
+
+const testCase = new TestStack(app, 'integ-ec2-instance-metadata-options');
+
+new IntegTest(app, 'instance-metadata-options-test', {
+  testCases: [testCase],
+});

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ec2/integ.vpc-dual-stack-ec2.ts

@@ -2,7 +2,6 @@
  * Note: this integ test may take around 10 minutes to complete successfully.
  */
 
-/* eslint-disable no-console */
 import * as cdk from 'aws-cdk-lib';
 import { ExpectedResult, IntegTest } from '@aws-cdk/integ-tests-alpha';
 import * as ec2 from 'aws-cdk-lib/aws-ec2';

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs/integ.fargate-with-efs.ts

@@ -3,7 +3,7 @@ import * as efs from 'aws-cdk-lib/aws-efs';
 import * as cdk from 'aws-cdk-lib';
 import { Construct } from 'constructs';
 import * as ecs from 'aws-cdk-lib/aws-ecs';
-// eslint-disable-next-line import/no-extraneous-dependencies
+
 import * as integ from '@aws-cdk/integ-tests-alpha';
 
 class FargateWithEfsStack extends cdk.Stack {

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-efs/integ.efs-filesystem-policy.ts

@@ -1,7 +1,7 @@
 import * as ec2 from 'aws-cdk-lib/aws-ec2';
 import { AccountRootPrincipal, PolicyDocument, PolicyStatement } from 'aws-cdk-lib/aws-iam';
 import * as cdk from 'aws-cdk-lib';
-// eslint-disable-next-line import/no-extraneous-dependencies
+
 import * as integ from '@aws-cdk/integ-tests-alpha';
 import { AccessPoint, FileSystem } from 'aws-cdk-lib/aws-efs';
 

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-efs/integ.efs.ts

@@ -1,7 +1,7 @@
 import * as ec2 from 'aws-cdk-lib/aws-ec2';
 import * as cdk from 'aws-cdk-lib';
 import { FileSystem } from 'aws-cdk-lib/aws-efs';
-// eslint-disable-next-line import/no-extraneous-dependencies
+
 import * as integ from '@aws-cdk/integ-tests-alpha';
 
 const app = new cdk.App();

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-elasticloadbalancing/integ.instanceTarget.elb.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import * as ec2 from 'aws-cdk-lib/aws-ec2';
-// eslint-disable-next-line import/no-extraneous-dependencies
+
 import * as iam from 'aws-cdk-lib/aws-iam';
 import * as cdk from 'aws-cdk-lib';
 import * as integ from '@aws-cdk/integ-tests-alpha';

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-globalaccelerator/integ.globalaccelerator-endpoints.ts

@@ -16,12 +16,12 @@ const stack = new Stack(app, 'global-accelerator-endpoints2');
 const vpc = new Vpc(stack, 'Vpc');
 const accelerator = new ga.Accelerator(stack, 'Accelerator');
 const listener =
-accelerator.addListener('Listener', {
-  portRanges: [
-    { fromPort: 80 },
-    { fromPort: 443 },
-  ],
-});
+  accelerator.addListener('Listener', {
+    portRanges: [
+      { fromPort: 80 },
+      { fromPort: 443 },
+    ],
+  });
 
 const alb = new ApplicationLoadBalancer(stack, 'ALB', { vpc });
 alb.applyRemovalPolicy(RemovalPolicy.DESTROY);

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-globalaccelerator/integ.globalaccelerator-unique-name.ts

@@ -1,5 +1,5 @@
 import { App, Stack } from 'aws-cdk-lib';
-// eslint-disable-next-line import/no-extraneous-dependencies
+
 import { IntegTest } from '@aws-cdk/integ-tests-alpha';
 import * as ga from 'aws-cdk-lib/aws-globalaccelerator';
 

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-lambda/README.md

@@ -733,6 +733,196 @@ new lambda.LayerVersion(this, 'MyLayer', {
 });
 ```
 
+## Capacity Providers
+
+Lambda capacity providers allow you to run Lambda functions on dedicated compute resources instead of the default serverless execution environment. Capacity providers can have multiple functions and function versions associated with them, but a function can be attached to at most one capacity provider.
+
+### Creating a Capacity Provider
+
+To create a capacity provider, you need to specify the VPC configuration and optionally configure permissions, scaling, and instance requirements:
+
+```ts
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
+
+// Create a VPC for the capacity provider
+const vpc = new ec2.Vpc(this, 'MyVpc');
+const securityGroup = new ec2.SecurityGroup(this, 'SecurityGroup', { vpc });
+
+// Create a basic capacity provider
+const capacityProvider = new lambda.CapacityProvider(this, 'MyCapacityProvider', {
+  capacityProviderName: 'my-capacity-provider',
+  subnets: vpc.privateSubnets,
+  securityGroups: [securityGroup],
+});
+```
+
+By default, permissions are granted to the capacity provider to manage instances using the AWS managed policy AWSLambdaManagedEC2ResourceOperator. You can also supply a custom role via the `operatorRole` parameter.
+
+### Configuring Scaling Policies
+
+You can configure target tracking scaling policies to automatically scale your capacity provider based on CPU utilization:
+
+```ts
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
+
+const vpc = new ec2.Vpc(this, 'MyVpc');
+const securityGroup = new ec2.SecurityGroup(this, 'SecurityGroup', { vpc });
+
+const capacityProvider = new lambda.CapacityProvider(this, 'MyCapacityProvider', {
+  subnets: vpc.privateSubnets,
+  securityGroups: [securityGroup],
+  scalingOptions: lambda.ScalingOptions.manual([
+    lambda.TargetTrackingScalingPolicy.cpuUtilization(70),
+  ]),
+});
+```
+
+### Instance Type Configuration
+
+You can control which EC2 instance types the capacity provider can use:
+
+```ts
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
+
+const vpc = new ec2.Vpc(this, 'MyVpc');
+const securityGroup = new ec2.SecurityGroup(this, 'SecurityGroup', { vpc });
+
+// Allow only specific instance families
+const allowCapacityProvider = new lambda.CapacityProvider(this, 'MyCapacityProviderAllowed', {
+  subnets: vpc.privateSubnets,
+  securityGroups: [securityGroup],
+  instanceTypeFilter: lambda.InstanceTypeFilter.allow([
+    ec2.InstanceType.of(ec2.InstanceClass.M5, ec2.InstanceSize.LARGE),
+    ec2.InstanceType.of(ec2.InstanceClass.M5, ec2.InstanceSize.XLARGE),
+  ]),
+});
+
+// Or exclude specific instance types
+const excludeCapacityProvider = new lambda.CapacityProvider(this, 'MyCapacityProviderExcluded', {
+  subnets: vpc.privateSubnets,
+  securityGroups: [securityGroup],
+  instanceTypeFilter: lambda.InstanceTypeFilter.exclude([
+    ec2.InstanceType.of(ec2.InstanceClass.T2, ec2.InstanceSize.MICRO),
+  ]),
+});
+```
+
+### Using a Capacity Provider with Lambda Functions
+
+Once you have a capacity provider, you can configure Lambda functions to use it:
+
+```ts
+declare const capacityProvider: lambda.CapacityProvider;
+
+const fn = new lambda.Function(this, 'MyFunction', {
+  // Runtime must be equal to or newer than NODEJS_22_X
+  runtime: lambda.Runtime.NODEJS_22_X,
+  handler: 'index.handler',
+  code: lambda.Code.fromAsset(path.join(__dirname, 'lambda-handler')),
+});
+
+// Associate the function with the capacity provider
+capacityProvider.addFunction(fn, {
+  perExecutionEnvironmentMaxConcurrency: 10,
+  executionEnvironmentMemoryGiBPerVCpu: 4,
+});
+```
+
+Note that once you use a capacity provider in a function, it cannot be removed, only changed.
+
+#### CapacityProviderFunctionOptions (addFunction method)
+
+| Name | Type | Required | Description |
+|------|------|----------|-------------|
+| perExecutionEnvironmentMaxConcurrency | number | No | Maximum concurrent invokes per execution environment. |
+| executionEnvironmentMemoryGiBPerVCpu | number | No | Memory per VCPU in GiB. |
+| publishToLatestPublished | boolean | No | Whether to automatically publish to $LATEST.PUBLISHED version. |
+| latestPublishedScalingConfig | LatestPublishedScalingConfig | No | Scaling configuration for $LATEST.PUBLISHED version. |
+
+#### LatestPublishedScalingConfig
+
+| Name | Type | Required | Description |
+|------|------|----------|-------------|
+| minExecutionEnvironments | number | No | Minimum execution environments for $LATEST.PUBLISHED version. |
+| maxExecutionEnvironments | number | No | Maximum execution environments for $LATEST.PUBLISHED version. |
+
+### Capacity Provider Versions
+
+When publishing Lambda versions that use capacity providers, you can configure scaling settings specific to each version.
+
+To publish a permanent version with specific scaling properties, you can use the [`currentVersion`](#currentversion-updated-hashing-logic) property of the function:
+
+```ts
+const fn = new lambda.Function(this, 'MyFunction', {
+  runtime: lambda.Runtime.NODEJS_22_X,
+  handler: 'index.handler',
+  code: lambda.Code.fromAsset(path.join(__dirname, 'lambda-handler')),
+  currentVersionOptions: {
+    minExecutionEnvironments: 3,
+  }
+});
+
+const version = fn.latestVersion
+```
+
+You can also specify scaling properties for the special `$LATEST.PUBLISHED` version when attaching the function to the capacity provider.
+
+`$LATEST.PUBLISHED` is a version that is automatically published when you deploy changes to your function.
+
+```ts
+declare const capacityProvider: lambda.CapacityProvider;
+declare const fn: lambda.Function;
+
+capacityProvider.addFunction(fn, {
+  latestPublishedScalingConfig: {
+    minExecutionEnvironments: 5,
+    maxExecutionEnvironments: 25,
+  },
+});
+```
+
+#### VersionOptions (Capacity Provider Related Fields)
+
+| Name | Type | Required | Description |
+|------|------|----------|-------------|
+| minExecutionEnvironments | number | No | Minimum execution environments to maintain for this version. |
+| maxExecutionEnvironments | number | No | Maximum execution environments allowed for this version. |
+
+### Security and Encryption
+
+Capacity providers support encryption using AWS KMS keys:
+
+```ts
+import * as kms from 'aws-cdk-lib/aws-kms';
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
+
+const vpc = new ec2.Vpc(this, 'MyVpc');
+const securityGroup = new ec2.SecurityGroup(this, 'SecurityGroup', { vpc });
+const kmsKey = new kms.Key(this, 'MyKey');
+
+const capacityProvider = new lambda.CapacityProvider(this, 'MyCapacityProvider', {
+  subnets: vpc.privateSubnets,
+  securityGroups: [securityGroup],
+  kmsKey: kmsKey,
+});
+```
+
+### Capacity Provider Configuration Reference
+
+#### CapacityProviderProps
+
+| Name | Type | Required | Description |
+|------|------|----------|-------------|
+| capacityProviderName | string | No | Name of the capacity provider. Must be unique within the AWS account and region. |
+| securityGroups | ISecurityGroup[] | Yes | Security groups to associate with EC2 instances. Up to 5 allowed. |
+| subnets | ISubnet[] | Yes | Subnets where the capacity provider can launch EC2 instances. 1-16 subnets supported. |
+| operatorRole | IRole | No | IAM role for Lambda to manage the capacity provider. Uses AWS Managed Policy AWSLambdaManagedEC2ResourceOperator by default. |
+| architectures | Architecture[] | No | Instruction set architecture for compute instances. |
+| instanceTypeFilter | InstanceTypeFilter | No | Filter for allowed or excluded instance types. |
+| maxVCpuCount | number | No | Maximum number of EC2 instances for scaling. |
+| scalingOptions | ScalingOptions | No | Scaling configuration including policies. |
+| kmsKey | IKey | No | KMS key for encrypting capacity provider data. |
+
 ## Lambda Insights
 
 Lambda functions can be configured to use CloudWatch [Lambda Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Lambda-Insights.html)
@@ -1181,6 +1371,26 @@ const fn = new lambda.Function(this, 'MyFunction', {
 const version = fn.currentVersion;
 ```
 
+## Lambda with Durable Configuration
+
+Lambda functions can be configured with durability to enable long-running, stateful executions.
+
+```ts
+const fn = new lambda.Function(this, 'MyFunction', {
+  runtime: lambda.Runtime.NODEJS_24_X,
+  handler: 'index.handler',
+  code: lambda.Code.fromAsset(path.join(__dirname, 'lambda-handler')),
+  durableConfig: { executionTimeout: Duration.hours(1), retentionPeriod: Duration.days(30) }, // 1 hour timeout, 30 days retention
+});
+```
+*Note:* If adding the `durableConfig` property to an existing lambda function, a resource replacement will be triggered.
+For the resource replacement to succeed, you cannot explicitly set the `functionName` parameter, or else it will
+result in CloudFormation deployment errors. Modifying the parameters within `durableConfig` will not trigger a resource replacement.
+
+*Further Note:* Deletion for durable functions will wait for all running executions to complete. CloudFormation will wait up to 1 hour, 
+after which the stack update or deletion will timeout. If you have functions that are stuck deleting, please check if there
+are any running executions for the function.
+
 ## AutoScaling
 
 You can use Application AutoScaling to automatically configure the provisioned concurrency for your functions. AutoScaling can be set to track utilization or be based on a schedule. To configure AutoScaling on a function alias:

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-lambda/integ.capacity-provider-all-fields.ts

@@ -0,0 +1,61 @@
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
+import * as iam from 'aws-cdk-lib/aws-iam';
+import * as lambda from 'aws-cdk-lib/aws-lambda';
+import * as cdk from 'aws-cdk-lib/core';
+import * as integ from '@aws-cdk/integ-tests-alpha';
+
+const app = new cdk.App();
+const stack = new cdk.Stack(app, 'CapacityProviderAllFieldsStack');
+
+const vpc = new ec2.Vpc(stack, 'Vpc', { maxAzs: 2 });
+const securityGroup = new ec2.SecurityGroup(stack, 'SecurityGroup', { vpc });
+
+const operatorRole = new iam.Role(stack, 'OperatorRole', {
+  assumedBy: new iam.ServicePrincipal('lambda.amazonaws.com'),
+  managedPolicies: [iam.ManagedPolicy.fromAwsManagedPolicyName('AmazonLambdaCapacityProviderOperatorRolePolicy')],
+});
+
+const capacityProvider = new lambda.CapacityProvider(stack, 'CapacityProvider', {
+  capacityProviderName: 'test-capacity-provider',
+  subnets: vpc.privateSubnets,
+  securityGroups: [securityGroup],
+  operatorRole: operatorRole,
+  architectures: [lambda.Architecture.X86_64],
+  instanceTypeFilter: lambda.InstanceTypeFilter.allow([ec2.InstanceType.of(ec2.InstanceClass.T2, ec2.InstanceSize.MICRO)]),
+  maxVCpuCount: 12,
+  scalingOptions: lambda.ScalingOptions.manual([
+    lambda.TargetTrackingScalingPolicy.cpuUtilization(70),
+  ]),
+});
+
+const testCase = new integ.IntegTest(app, 'CapacityProviderAllFieldsTest', {
+  testCases: [stack],
+});
+
+const getCapacityProvider = testCase.assertions.awsApiCall('Lambda', 'GetCapacityProvider', {
+  CapacityProviderName: capacityProvider.capacityProviderName,
+});
+
+getCapacityProvider.expect(integ.ExpectedResult.objectLike({
+  CapacityProviderArn: capacityProvider.capacityProviderArn,
+  State: 'Active',
+  CapacityProviderScalingConfig: {
+    MaxVCpuCount: 12,
+    ScalingMode: 'Manual',
+    ScalingPolicies: [{
+      PredefinedMetricType: 'LambdaCapacityProviderAverageCPUUtilization',
+      TargetValue: 70,
+    }],
+  },
+  PermissionsConfig: {
+    CapacityProviderOperatorRoleArn: operatorRole.roleArn,
+  },
+  VpcConfig: {
+    SubnetIds: vpc.privateSubnets.map(subnet => subnet.subnetId),
+    SecurityGroupIds: [securityGroup.securityGroupId],
+  },
+  InstanceRequirements: {
+    Architectures: ['x86_64'],
+    AllowedInstanceTypes: ['t2.micro'],
+  },
+}));

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-lambda/integ.capacity-provider-defaults.ts

@@ -0,0 +1,34 @@
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
+import * as lambda from 'aws-cdk-lib/aws-lambda';
+import * as cdk from 'aws-cdk-lib/core';
+import * as integ from '@aws-cdk/integ-tests-alpha';
+
+const app = new cdk.App();
+const stack = new cdk.Stack(app, 'CapacityProviderDefaultsStack');
+
+const vpc = new ec2.Vpc(stack, 'Vpc', { maxAzs: 2 });
+const securityGroup = new ec2.SecurityGroup(stack, 'SecurityGroup', { vpc });
+
+const capacityProvider = new lambda.CapacityProvider(stack, 'CapacityProvider', {
+  subnets: vpc.privateSubnets,
+  securityGroups: [securityGroup],
+});
+
+const testCase = new integ.IntegTest(app, 'CapacityProviderDefaultsTest', {
+  testCases: [stack],
+});
+
+const getCapacityProvider = testCase.assertions.awsApiCall('Lambda', 'GetCapacityProvider', {
+  CapacityProviderName: capacityProvider.capacityProviderName,
+});
+
+getCapacityProvider.expect(integ.ExpectedResult.objectLike({
+  State: 'Active',
+  PermissionsConfig: {
+    CapacityProviderOperatorRoleArn: integ.ExpectedResult.stringLikeRegexp('arn:aws:iam::\\d{12}:role/.+'),
+  },
+  VpcConfig: {
+    SubnetIds: vpc.privateSubnets.map(subnet => subnet.subnetId),
+    SecurityGroupIds: [securityGroup.securityGroupId],
+  },
+}));

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-lambda/integ.durable-config.ts

@@ -0,0 +1,19 @@
+import * as lambda from 'aws-cdk-lib/aws-lambda';
+import { IntegTest } from '@aws-cdk/integ-tests-alpha';
+import { App, Stack, Duration } from 'aws-cdk-lib';
+
+const app = new App();
+const stack = new Stack(app, 'aws-cdk-lambda-durable-config');
+
+new lambda.Function(stack, 'DurableFunction', {
+  runtime: lambda.Runtime.NODEJS_22_X,
+  handler: 'index.handler',
+  code: lambda.Code.fromInline('exports.handler = async () => ({ statusCode: 200, body: "Hello World" });'),
+  durableConfig: { executionTimeout: Duration.hours(1), retentionPeriod: Duration.days(30) },
+});
+
+new IntegTest(app, 'lambda-durable-config', {
+  testCases: [stack],
+});
+
+app.synth();

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-lambda/integ.function-capacity-provider-all-fields.ts

@@ -0,0 +1,57 @@
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
+import * as lambda from 'aws-cdk-lib/aws-lambda';
+import * as cdk from 'aws-cdk-lib/core';
+import * as integ from '@aws-cdk/integ-tests-alpha';
+
+const app = new cdk.App();
+const stack = new cdk.Stack(app, 'FunctionCapacityProviderAllFieldsStack');
+
+const vpc = new ec2.Vpc(stack, 'Vpc', { maxAzs: 2 });
+const securityGroup = new ec2.SecurityGroup(stack, 'SecurityGroup', { vpc });
+
+const capacityProvider = new lambda.CapacityProvider(stack, 'CapacityProvider', {
+  subnets: vpc.privateSubnets,
+  securityGroups: [securityGroup],
+});
+
+const fn = new lambda.Function(stack, 'Function', {
+  runtime: lambda.Runtime.NODEJS_LATEST,
+  handler: 'index.handler',
+  code: lambda.Code.fromInline('exports.handler = async () => ({ statusCode: 200 });'),
+});
+
+capacityProvider.addFunction(fn, {
+  perExecutionEnvironmentMaxConcurrency: 10,
+  executionEnvironmentMemoryGiBPerVCpu: 2,
+  publishToLatestPublished: true,
+  latestPublishedScalingConfig: {
+    minExecutionEnvironments: 1,
+    maxExecutionEnvironments: 5,
+  },
+});
+
+const testCase = new integ.IntegTest(app, 'FunctionCapacityProviderAllFieldsTest', {
+  testCases: [stack],
+});
+
+const getFunction = testCase.assertions.awsApiCall('Lambda', 'GetFunction', {
+  FunctionName: fn.functionName,
+});
+
+getFunction.expect(integ.ExpectedResult.objectLike({
+  Configuration: {
+    State: 'Active',
+    PublishToLatestPublished: true,
+    CapacityProviderConfig: {
+      LambdaManagedInstancesCapacityProviderConfig: {
+        CapacityProviderArn: capacityProvider.capacityProviderArn,
+        PerExecutionEnvironmentMaxConcurrency: 10,
+        ExecutionEnvironmentMemoryGiBPerVCpu: 2,
+      },
+    },
+    FunctionScalingConfig: {
+      MinExecutionEnvironments: 1,
+      MaxExecutionEnvironments: 5,
+    },
+  },
+}));