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

cdk_api_mcp_server/__about__.py

@@ -1,4 +1,4 @@
 # SPDX-FileCopyrightText: 2025-present Kenji Kono <konoken@amazon.co.jp>
 #
 # SPDX-License-Identifier: MIT
-__version__ = "0.60.0"
+__version__ = "0.61.0"

cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/aws-bedrock-agentcore-alpha/README.md

@@ -580,6 +580,54 @@ runtime.connections.allowTo(databaseSecurityGroup, ec2.Port.tcp(5432), 'Allow Po
 runtime.connections.allowToAnyIpv4(ec2.Port.tcp(443), 'Allow HTTPS outbound');
 ```
 
+### Runtime IAM Permissions
+
+The Runtime construct provides convenient methods for granting IAM permissions to principals that need to invoke the runtime or manage its execution role.
+
+```typescript fixture=default
+const repository = new ecr.Repository(this, "TestRepository", {
+  repositoryName: "test-agent-runtime",
+});
+const agentRuntimeArtifact = agentcore.AgentRuntimeArtifact.fromEcrRepository(repository, "v1.0.0");
+
+// Create a runtime
+const runtime = new agentcore.Runtime(this, "MyRuntime", {
+  runtimeName: "my_runtime",
+  agentRuntimeArtifact: agentRuntimeArtifact,
+});
+
+// Create a Lambda function that needs to invoke the runtime
+const invokerFunction = new lambda.Function(this, "InvokerFunction", {
+  runtime: lambda.Runtime.PYTHON_3_12,
+  handler: "index.handler",
+  code: lambda.Code.fromInline(`
+import boto3
+def handler(event, context):
+    client = boto3.client('bedrock-agentcore')
+    # Invoke the runtime...
+  `),
+});
+
+// Grant permission to invoke the runtime directly
+runtime.grantInvokeRuntime(invokerFunction);
+
+// Grant permission to invoke the runtime on behalf of a user
+// (requires X-Amzn-Bedrock-AgentCore-Runtime-User-Id header)
+runtime.grantInvokeRuntimeForUser(invokerFunction);
+
+// Grant both invoke permissions (most common use case)
+runtime.grantInvoke(invokerFunction);
+
+// Grant specific custom permissions to the runtime's execution role
+runtime.grant(['bedrock:InvokeModel'], ['arn:aws:bedrock:*:*:*']);
+
+// Add a policy statement to the runtime's execution role
+runtime.addToRolePolicy(new iam.PolicyStatement({
+  actions: ['s3:GetObject'],
+  resources: ['arn:aws:s3:::my-bucket/*'],
+}));
+```
+
 ### Other configuration
 
 #### Lifecycle configuration

cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/aws-imagebuilder-alpha/README.md

@@ -36,6 +36,256 @@ EC2 Image Builder supports AWS-managed components for common tasks, AWS Marketpl
 that you create. Components run during specific workflow phases: build and validate phases during the build stage, and
 test phase during the test stage.
 
+### Image Pipeline
+
+An image pipeline provides the automation framework for building secure AMIs and container images. The pipeline orchestrates the entire image creation process by combining an image recipe or container recipe with infrastructure configuration and distribution configuration. Pipelines can run on a schedule or be triggered manually, and they manage the build, test, and distribution phases automatically.
+
+#### Image Pipeline Basic Usage
+
+Create a simple AMI pipeline with just an image recipe:
+
+```ts
+const imageRecipe = new imagebuilder.ImageRecipe(this, 'MyImageRecipe', {
+  baseImage: imagebuilder.BaseImage.fromSsmParameterName(
+    '/aws/service/ami-amazon-linux-latest/al2023-ami-minimal-kernel-default-x86_64'
+  )
+});
+
+const imagePipeline = new imagebuilder.ImagePipeline(this, 'MyImagePipeline', {
+  recipe: exampleImageRecipe
+});
+```
+
+Create a simple container pipeline with just a container recipe:
+
+```ts
+const containerRecipe = new imagebuilder.ContainerRecipe(this, 'MyContainerRecipe', {
+  baseImage: imagebuilder.BaseContainerImage.fromDockerHub('amazonlinux', 'latest'),
+  targetRepository: imagebuilder.Repository.fromEcr(
+    ecr.Repository.fromRepositoryName(this, 'Repository', 'my-container-repo')
+  )
+});
+
+const containerPipeline = new imagebuilder.ImagePipeline(this, 'MyContainerPipeline', {
+  recipe: exampleContainerRecipe
+});
+```
+
+#### Image Pipeline Scheduling
+
+##### Manual Pipeline Execution
+
+Create a pipeline that runs only when manually triggered:
+
+```ts
+const manualPipeline = new imagebuilder.ImagePipeline(this, 'ManualPipeline', {
+  imagePipelineName: 'my-manual-pipeline',
+  description: 'Pipeline triggered manually for production builds',
+  recipe: exampleImageRecipe
+  // No schedule property - manual execution only
+});
+
+// Grant Lambda function permission to trigger the pipeline
+manualPipeline.grantStartExecution(lambdaRole);
+```
+
+##### Automated Pipeline Scheduling
+
+Schedule a pipeline to run automatically using cron expressions:
+
+```ts
+const weeklyPipeline = new imagebuilder.ImagePipeline(this, 'WeeklyPipeline', {
+  imagePipelineName: 'weekly-build-pipeline',
+  recipe: exampleImageRecipe,
+  schedule: {
+    expression: events.Schedule.cron({
+      minute: '0',
+      hour: '6',
+      weekDay: 'MON'
+    })
+  }
+});
+```
+
+Use rate expressions for regular intervals:
+
+```ts
+const dailyPipeline = new imagebuilder.ImagePipeline(this, 'DailyPipeline', {
+  recipe: exampleContainerRecipe,
+  schedule: {
+    expression: events.Schedule.rate(Duration.days(1))
+  }
+});
+```
+
+##### Pipeline Schedule Configuration
+
+Configure advanced scheduling options:
+
+```ts
+const advancedSchedulePipeline = new imagebuilder.ImagePipeline(this, 'AdvancedSchedulePipeline', {
+  recipe: exampleImageRecipe,
+  schedule: {
+    expression: events.Schedule.rate(Duration.days(7)),
+    // Only trigger when dependencies are updated (new base images, components, etc.)
+    startCondition: imagebuilder.ScheduleStartCondition.EXPRESSION_MATCH_AND_DEPENDENCY_UPDATES_AVAILABLE,
+    // Automatically disable after 3 consecutive failures
+    autoDisableFailureCount: 3
+  },
+  // Start enabled
+  status: imagebuilder.ImagePipelineStatus.ENABLED
+});
+```
+
+#### Image Pipeline Configuration
+
+##### Infrastructure and Distribution
+
+Configure custom infrastructure and distribution settings:
+
+```ts
+const infrastructureConfiguration = new imagebuilder.InfrastructureConfiguration(this, 'Infrastructure', {
+  infrastructureConfigurationName: 'production-infrastructure',
+  instanceTypes: [
+    ec2.InstanceType.of(ec2.InstanceClass.COMPUTE7_INTEL, ec2.InstanceSize.LARGE)
+  ],
+  vpc: vpc,
+  subnetSelection: { subnetType: ec2.SubnetType.PRIVATE_WITH_EGRESS }
+});
+
+const distributionConfiguration = new imagebuilder.DistributionConfiguration(this, 'Distribution');
+distributionConfiguration.addAmiDistributions({
+  amiName: 'production-ami-{{ imagebuilder:buildDate }}',
+  amiTargetAccountIds: ['123456789012', '098765432109']
+});
+
+const productionPipeline = new imagebuilder.ImagePipeline(this, 'ProductionPipeline', {
+  recipe: exampleImageRecipe,
+  infrastructureConfiguration: infrastructureConfiguration,
+  distributionConfiguration: distributionConfiguration
+});
+```
+
+##### Pipeline Logging Configuration
+
+Configure custom CloudWatch log groups for pipeline and image logs:
+
+```ts
+const pipelineLogGroup = new logs.LogGroup(this, 'PipelineLogGroup', {
+  logGroupName: '/custom/imagebuilder/pipeline/logs',
+  retention: logs.RetentionDays.ONE_MONTH
+});
+
+const imageLogGroup = new logs.LogGroup(this, 'ImageLogGroup', {
+  logGroupName: '/custom/imagebuilder/image/logs', 
+  retention: logs.RetentionDays.ONE_WEEK
+});
+
+const loggedPipeline = new imagebuilder.ImagePipeline(this, 'LoggedPipeline', {
+  recipe: exampleImageRecipe,
+  imagePipelineLogGroup: pipelineLogGroup,
+  imageLogGroup: imageLogGroup
+});
+```
+
+##### Workflow Integration
+
+Use AWS-managed workflows for common pipeline phases:
+
+```ts
+const workflowPipeline = new imagebuilder.ImagePipeline(this, 'WorkflowPipeline', {
+  recipe: exampleImageRecipe,
+  workflows: [
+    { workflow: imagebuilder.AwsManagedWorkflow.buildImage(this, 'BuildWorkflow') },
+    { workflow: imagebuilder.AwsManagedWorkflow.testImage(this, 'TestWorkflow') }
+  ]
+});
+```
+
+For container pipelines, use container-specific workflows:
+
+```ts
+const containerWorkflowPipeline = new imagebuilder.ImagePipeline(this, 'ContainerWorkflowPipeline', {
+  recipe: exampleContainerRecipe,
+  workflows: [
+    { workflow: imagebuilder.AwsManagedWorkflow.buildContainer(this, 'BuildContainer') },
+    { workflow: imagebuilder.AwsManagedWorkflow.testContainer(this, 'TestContainer') },
+    { workflow: imagebuilder.AwsManagedWorkflow.distributeContainer(this, 'DistributeContainer') }
+  ]
+});
+```
+
+##### Advanced Features
+
+Configure image scanning for container pipelines:
+
+```ts
+const scanningRepository = new ecr.Repository(this, 'ScanningRepo');
+
+const scannedContainerPipeline = new imagebuilder.ImagePipeline(this, 'ScannedContainerPipeline', {
+  recipe: exampleContainerRecipe,
+  imageScanningEnabled: true,
+  imageScanningEcrRepository: scanningRepository,
+  imageScanningEcrTags: ['security-scan', 'latest']
+});
+```
+
+Control metadata collection and testing:
+
+```ts
+const controlledPipeline = new imagebuilder.ImagePipeline(this, 'ControlledPipeline', {
+  recipe: exampleImageRecipe,
+  enhancedImageMetadataEnabled: true,  // Collect detailed OS and package info
+  imageTestsEnabled: false  // Skip testing phase for faster builds
+});
+```
+
+#### Image Pipeline Events
+
+##### Pipeline Event Handling
+
+Handle specific pipeline events:
+
+```ts
+// Monitor CVE detection
+examplePipeline.onCVEDetected('CVEAlert', {
+  target: new targets.SnsTopic(topic)
+});
+
+// Handle pipeline auto-disable events
+examplePipeline.onImagePipelineAutoDisabled('PipelineDisabledAlert', {
+  target: new targets.LambdaFunction(lambdaFunction)
+});
+```
+
+#### Importing Image Pipelines
+
+Reference existing pipelines created outside CDK:
+
+```ts
+// Import by name
+const existingPipelineByName = imagebuilder.ImagePipeline.fromImagePipelineName(
+  this,
+  'ExistingPipelineByName',
+  'my-existing-pipeline'
+);
+
+// Import by ARN
+const existingPipelineByArn = imagebuilder.ImagePipeline.fromImagePipelineArn(
+  this,
+  'ExistingPipelineByArn',
+  'arn:aws:imagebuilder:us-east-1:123456789012:image-pipeline/imported-pipeline'
+);
+
+// Grant permissions to imported pipelines
+const automationRole = new iam.Role(this, 'AutomationRole', {
+  assumedBy: new iam.ServicePrincipal('lambda.amazonaws.com')
+});
+
+existingPipelineByName.grantStartExecution(automationRole);
+existingPipelineByArn.grantRead(lambdaRole);
+```
+
 ### Image Recipe
 
 #### Image Recipe Basic Usage
@@ -1074,3 +1324,341 @@ const testContainerWorkflow = imagebuilder.AwsManagedWorkflow.testContainer(this
 // Distribution workflows
 const distributeContainerWorkflow = imagebuilder.AwsManagedWorkflow.distributeContainer(this, 'DistributeContainer');
 ```
+
+### Lifecycle Policy
+
+Lifecycle policies help you manage the retention and cleanup of Image Builder resources automatically. These policies define rules for deprecating or deleting old image versions, managing AMI snapshots, and controlling resource costs by removing unused images based on age, count, or other criteria.
+
+#### Lifecycle Policy Basic Usage
+
+Create a lifecycle policy to automatically delete old AMI images after 30 days:
+
+```ts
+const lifecyclePolicy = new imagebuilder.LifecyclePolicy(this, 'MyLifecyclePolicy', {
+  resourceType: imagebuilder.LifecyclePolicyResourceType.AMI_IMAGE,
+  details: [
+    {
+      action: { type: imagebuilder.LifecyclePolicyActionType.DELETE },
+      filter: { ageFilter: { age: Duration.days(30) } }
+    }
+  ],
+  resourceSelection: {
+    tags: { Environment: 'development' }
+  }
+});
+```
+
+Create a lifecycle policy to keep only the 10 most recent container images:
+
+```ts
+const containerLifecyclePolicy = new imagebuilder.LifecyclePolicy(this, 'ContainerLifecyclePolicy', {
+  resourceType: imagebuilder.LifecyclePolicyResourceType.CONTAINER_IMAGE,
+  details: [
+    {
+      action: { type: imagebuilder.LifecyclePolicyActionType.DELETE },
+      filter: { countFilter: { count: 10 } }
+    }
+  ],
+  resourceSelection: {
+    tags: { Application: 'web-app' }
+  }
+});
+```
+
+#### Lifecycle Policy Resource Selection
+
+##### Tag-Based Resource Selection
+
+Apply lifecycle policies to images with specific tags:
+
+```ts
+const tagBasedPolicy = new imagebuilder.LifecyclePolicy(this, 'TagBasedPolicy', {
+  resourceType: imagebuilder.LifecyclePolicyResourceType.AMI_IMAGE,
+  details: [
+    {
+      action: { type: imagebuilder.LifecyclePolicyActionType.DELETE },
+      filter: { ageFilter: { age: Duration.days(90) } }
+    }
+  ],
+  resourceSelection: {
+    tags: {
+      Environment: 'staging',
+      Team: 'backend'
+    }
+  }
+});
+```
+
+##### Recipe-Based Resource Selection
+
+Apply lifecycle policies to specific image or container recipes:
+
+```ts
+const imageRecipe = new imagebuilder.ImageRecipe(this, 'MyImageRecipe', {
+  baseImage: imagebuilder.BaseImage.fromSsmParameterName(
+    '/aws/service/ami-amazon-linux-latest/al2023-ami-minimal-kernel-default-x86_64'
+  )
+});
+
+const containerRecipe = new imagebuilder.ContainerRecipe(this, 'MyContainerRecipe', {
+  baseImage: imagebuilder.BaseContainerImage.fromDockerHub('amazonlinux', 'latest'),
+  targetRepository: imagebuilder.Repository.fromEcr(
+    ecr.Repository.fromRepositoryName(this, 'Repository', 'my-container-repo')
+  )
+});
+
+const recipeBasedPolicy = new imagebuilder.LifecyclePolicy(this, 'RecipeBasedPolicy', {
+  resourceType: imagebuilder.LifecyclePolicyResourceType.AMI_IMAGE,
+  details: [
+    {
+      action: { type: imagebuilder.LifecyclePolicyActionType.DELETE },
+      filter: { countFilter: { count: 5 } }
+    }
+  ],
+  resourceSelection: {
+    recipes: [imageRecipe, containerRecipe]
+  }
+});
+```
+
+#### Lifecycle Policy Rules
+
+##### Age-Based Rules
+
+Delete images older than a specific time period:
+
+```ts
+const ageBasedPolicy = new imagebuilder.LifecyclePolicy(this, 'AgeBasedPolicy', {
+  resourceType: imagebuilder.LifecyclePolicyResourceType.AMI_IMAGE,
+  details: [
+    {
+      action: {
+        type: imagebuilder.LifecyclePolicyActionType.DELETE,
+        includeAmis: true,
+        includeSnapshots: true
+      },
+      filter: {
+        ageFilter: {
+          age: Duration.days(60),
+          retainAtLeast: 3  // Always keep at least 3 images
+        }
+      }
+    }
+  ],
+  resourceSelection: {
+    tags: { Environment: 'testing' }
+  }
+});
+```
+
+##### Count-Based Rules
+
+Keep only a specific number of the most recent images:
+
+```ts
+const countBasedPolicy = new imagebuilder.LifecyclePolicy(this, 'CountBasedPolicy', {
+  resourceType: imagebuilder.LifecyclePolicyResourceType.CONTAINER_IMAGE,
+  details: [
+    {
+      action: { type: imagebuilder.LifecyclePolicyActionType.DELETE },
+      filter: { countFilter: { count: 15 } }  // Keep only the 15 most recent images
+    }
+  ],
+  resourceSelection: {
+    tags: { Application: 'microservice' }
+  }
+});
+```
+
+##### Multiple Lifecycle Rules
+
+Implement a graduated approach with multiple actions:
+
+```ts
+const graduatedPolicy = new imagebuilder.LifecyclePolicy(this, 'GraduatedPolicy', {
+  resourceType: imagebuilder.LifecyclePolicyResourceType.AMI_IMAGE,
+  details: [
+    {
+      // First: Deprecate images after 30 days
+      action: {
+        type: imagebuilder.LifecyclePolicyActionType.DEPRECATE,
+        includeAmis: true
+      },
+      filter: {
+        ageFilter: {
+          age: Duration.days(30),
+          retainAtLeast: 5
+        }
+      }
+    },
+    {
+      // Second: Disable images after 60 days  
+      action: {
+        type: imagebuilder.LifecyclePolicyActionType.DISABLE,
+        includeAmis: true
+      },
+      filter: {
+        ageFilter: {
+          age: Duration.days(60),
+          retainAtLeast: 3
+        }
+      }
+    },
+    {
+      // Finally: Delete images after 90 days
+      action: {
+        type: imagebuilder.LifecyclePolicyActionType.DELETE,
+        includeAmis: true,
+        includeSnapshots: true
+      },
+      filter: {
+        ageFilter: {
+          age: Duration.days(90),
+          retainAtLeast: 1
+        }
+      }
+    }
+  ],
+  resourceSelection: {
+    tags: { Environment: 'production' }
+  }
+});
+```
+
+#### Lifecycle Policy Exclusion Rules
+
+##### AMI Exclusion Rules
+
+Exclude specific AMIs from lifecycle actions based on various criteria:
+
+```ts
+const excludeAmisPolicy = new imagebuilder.LifecyclePolicy(this, 'ExcludeAmisPolicy', {
+  resourceType: imagebuilder.LifecyclePolicyResourceType.AMI_IMAGE,
+  details: [
+    {
+      action: { type: imagebuilder.LifecyclePolicyActionType.DELETE },
+      filter: { ageFilter: { age: Duration.days(30) } },
+      exclusionRules: {
+        amiExclusionRules: {
+          isPublic: true,  // Exclude public AMIs
+          lastLaunched: Duration.days(7),  // Exclude AMIs launched in last 7 days
+          regions: ['us-west-2', 'eu-west-1'],  // Exclude AMIs in specific regions
+          sharedAccounts: ['123456789012'],  // Exclude AMIs shared with specific accounts
+          tags: {
+            Protected: 'true',
+            Environment: 'production'
+          }
+        }
+      }
+    }
+  ],
+  resourceSelection: {
+    tags: { Team: 'infrastructure' }
+  }
+});
+```
+
+##### Image Exclusion Rules
+
+Exclude Image Builder images with protective tags:
+
+```ts
+const excludeImagesPolicy = new imagebuilder.LifecyclePolicy(this, 'ExcludeImagesPolicy', {
+  resourceType: imagebuilder.LifecyclePolicyResourceType.CONTAINER_IMAGE,
+  details: [
+    {
+      action: { type: imagebuilder.LifecyclePolicyActionType.DELETE },
+      filter: { countFilter: { count: 20 } },
+      exclusionRules: {
+        imageExclusionRules: {
+          tags: {
+            DoNotDelete: 'true',
+            Critical: 'baseline'
+          }
+        }
+      }
+    }
+  ],
+  resourceSelection: {
+    tags: { Application: 'frontend' }
+  }
+});
+```
+
+#### Advanced Lifecycle Configuration
+
+##### Custom Execution Roles
+
+Provide your own IAM execution role with specific permissions:
+
+```ts
+const executionRole = new iam.Role(this, 'LifecycleExecutionRole', {
+  assumedBy: new iam.ServicePrincipal('imagebuilder.amazonaws.com'),
+  managedPolicies: [
+    iam.ManagedPolicy.fromAwsManagedPolicyName('service-role/EC2ImageBuilderLifecycleExecutionPolicy')
+  ]
+});
+
+const customRolePolicy = new imagebuilder.LifecyclePolicy(this, 'CustomRolePolicy', {
+  resourceType: imagebuilder.LifecyclePolicyResourceType.AMI_IMAGE,
+  executionRole: executionRole,
+  details: [
+    {
+      action: { type: imagebuilder.LifecyclePolicyActionType.DELETE },
+      filter: { ageFilter: { age: Duration.days(45) } }
+    }
+  ],
+  resourceSelection: {
+    tags: { Environment: 'development' }
+  }
+});
+```
+
+##### Lifecycle Policy Status
+
+Control whether the lifecycle policy is active:
+
+```ts
+const disabledPolicy = new imagebuilder.LifecyclePolicy(this, 'DisabledPolicy', {
+  lifecyclePolicyName: 'my-disabled-policy',
+  description: 'A lifecycle policy that is temporarily disabled',
+  status: imagebuilder.LifecyclePolicyStatus.DISABLED,
+  resourceType: imagebuilder.LifecyclePolicyResourceType.AMI_IMAGE,
+  details: [
+    {
+      action: { type: imagebuilder.LifecyclePolicyActionType.DELETE },
+      filter: { ageFilter: { age: Duration.days(30) } }
+    }
+  ],
+  resourceSelection: {
+    tags: { Environment: 'testing' }
+  },
+  tags: {
+    Owner: 'DevOps',
+    CostCenter: 'Engineering'
+  }
+});
+```
+
+##### Importing Lifecycle Policies
+
+Reference lifecycle policies created outside of CDK:
+
+```ts
+// Import by name
+const importedByName = imagebuilder.LifecyclePolicy.fromLifecyclePolicyName(
+  this,
+  'ImportedByName',
+  'existing-lifecycle-policy'
+);
+
+// Import by ARN
+const importedByArn = imagebuilder.LifecyclePolicy.fromLifecyclePolicyArn(
+  this,
+  'ImportedByArn',
+  'arn:aws:imagebuilder:us-east-1:123456789012:lifecycle-policy/my-policy'
+);
+
+importedByName.grantRead(lambdaRole);
+importedByArn.grant(lambdaRole, 'imagebuilder:PutLifecyclePolicy');
+```

cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/mixins-preview/README.md

@@ -15,17 +15,26 @@
 
 <!--END STABILITY BANNER-->
 
+This package provides two main features:
+
+1. **Mixins** - Composable abstractions for adding functionality to constructs
+2. **EventBridge Event Patterns** - Type-safe event patterns for AWS resources
+
+---
+
+## CDK Mixins
+
 CDK Mixins provide a new, advanced way to add functionality through composable abstractions.
 Unlike traditional L2 constructs that bundle all features together, Mixins allow you to pick and choose exactly the capabilities you need for constructs.
 
-## Key Benefits
+### Key Benefits
 
 * **Universal Compatibility**: Apply the same abstractions to L1 constructs, L2 constructs, or custom constructs
 * **Composable Design**: Mix and match features without being locked into specific implementations  
 * **Cross-Service Abstractions**: Use common patterns like encryption across different AWS services
 * **Escape Hatch Freedom**: Customize resources in a safe, typed way while keeping the abstractions you want
 
-## Basic Usage
+### Basic Usage
 
 Mixins use `Mixins.of()` as the fundamental API for applying abstractions to constructs:
 
@@ -37,7 +46,7 @@ Mixins.of(bucket)
   .apply(new AutoDeleteObjects());
 ```
 
-### Fluent Syntax with `.with()`
+#### Fluent Syntax with `.with()`
 
 For convenience, you can use the `.with()` method for a more fluent syntax:
 
@@ -53,7 +62,7 @@ The `.with()` method is available after importing `@aws-cdk/mixins-preview/with`
 
 > **Note**: The `.with()` fluent syntax is only available in JavaScript and TypeScript. Other jsii languages (Python, Java, C#, and Go) should use the `Mixins.of(...).mustApply()` syntax instead. The import requirement is temporary during the preview phase. Once the API is stable, the `.with()` method will be available by default on all constructs and in all languages.
 
-## Creating Custom Mixins
+### Creating Custom Mixins
 
 Mixins are simple classes that implement the `IMixin` interface (usually by extending the abstract `Mixin` class:
 
@@ -77,7 +86,7 @@ const bucket = new s3.CfnBucket(scope, "MyBucket");
 Mixins.of(bucket).apply(new CustomVersioningMixin());
 ```
 
-## Construct Selection
+### Construct Selection
 
 Mixins operate on construct trees and can be applied selectively:
 
@@ -94,9 +103,9 @@ Mixins.of(scope, ConstructSelector.byId(/.*-prod-.*/))
   .apply(new ProductionSecurityMixin());
 ```
 
-## Built-in Mixins
+### Built-in Mixins
 
-### Cross-Service Mixins
+#### Cross-Service Mixins
 
 **EncryptionAtRest**: Applies encryption to supported AWS resources
 
@@ -109,7 +118,7 @@ const logGroup = new logs.CfnLogGroup(scope, "LogGroup");
 Mixins.of(logGroup).apply(new EncryptionAtRest());
 ```
 
-### S3-Specific Mixins
+#### S3-Specific Mixins
 
 **AutoDeleteObjects**: Configures automatic object deletion for S3 buckets
 
@@ -125,6 +134,30 @@ const bucket = new s3.CfnBucket(scope, "Bucket");
 Mixins.of(bucket).apply(new EnableVersioning());
 ```
 
+### Logs Delivery
+
+Configures vended logs delivery for supported resources to various destinations:
+
+```typescript
+import '@aws-cdk/mixins-preview/with';
+import * as cloudfrontMixins from '@aws-cdk/mixins-preview/aws_cloudfront/mixins';
+
+// Create CloudFront distribution
+declare const bucket: s3.Bucket;
+const distribution = new cloudfront.Distribution(scope, 'Distribution', {
+  defaultBehavior: {
+    origin: origins.S3BucketOrigin.withOriginAccessControl(bucket),
+  },
+});
+
+// Create log destination
+const logGroup = new logs.LogGroup(scope, 'DeliveryLogGroup');
+
+// Configure log delivery using the mixin
+distribution
+  .with(cloudfrontMixins.CfnDistributionLogsMixin.CONNECTION_LOGS.toLogGroup(logGroup));
+```
+
 ### L1 Property Mixins
 
 For every CloudFormation resource, CDK Mixins automatically generates type-safe property mixins. These allow you to apply L1 properties with full TypeScript support:
@@ -154,7 +187,7 @@ Mixins.of(bucket).apply(new CfnBucketPropsMixin(
   { strategy: PropertyMergeStrategy.MERGE }
 ));
 
-// OVERWRITE: Replaces existing property values
+// OVERRIDE: Replaces existing property values
 Mixins.of(bucket).apply(new CfnBucketPropsMixin(
   { versioningConfiguration: { status: "Enabled" } },
   { strategy: PropertyMergeStrategy.OVERRIDE }
@@ -169,7 +202,7 @@ import { CfnFunctionPropsMixin } from '@aws-cdk/mixins-preview/aws_lambda/mixins
 import { CfnTablePropsMixin } from '@aws-cdk/mixins-preview/aws_dynamodb/mixins';
 ```
 
-## Error Handling
+### Error Handling
 
 Mixins provide comprehensive error handling:
 
@@ -182,3 +215,89 @@ Mixins.of(scope)
 Mixins.of(scope)
   .mustApply(new EncryptionAtRest()); // Throws if no constructs support the mixin
 ```
+
+---
+
+## EventBridge Event Patterns
+
+CDK Mixins automatically generates typed EventBridge event patterns for AWS resources. These patterns work with both L1 and L2 constructs, providing a consistent interface for creating EventBridge rules.
+
+### Event Patterns Basic Usage
+
+```typescript
+import { BucketEvents } from '@aws-cdk/mixins-preview/aws_s3/events';
+import * as events from 'aws-cdk-lib/aws-events';
+import * as targets from 'aws-cdk-lib/aws-events-targets';
+
+// Works with L2 constructs
+const bucket = new s3.Bucket(scope, 'Bucket');
+const bucketEvents = BucketEvents.fromBucket(bucket);
+declare const fn: lambda.Function;
+
+new events.Rule(scope, 'Rule', {
+  eventPattern: bucketEvents.objectCreatedPattern({
+    object: { key: ['uploads/*'] }
+  }),
+  targets: [new targets.LambdaFunction(fn)]
+});
+
+// Also works with L1 constructs
+const cfnBucket = new s3.CfnBucket(scope, 'CfnBucket');
+const cfnBucketEvents = BucketEvents.fromBucket(cfnBucket);
+
+new events.CfnRule(scope, 'CfnRule', {
+  state: 'ENABLED',
+  eventPattern: cfnBucketEvents.objectCreatedPattern({
+    object: { key: ['uploads/*'] }
+  }),
+  targets: [{ arn: fn.functionArn, id: 'L1' }]
+});
+```
+
+### Event Pattern Features
+
+**Automatic Resource Injection**: Resource identifiers are automatically included in patterns
+
+```typescript
+import { BucketEvents } from '@aws-cdk/mixins-preview/aws_s3/events';
+
+declare const bucket: s3.Bucket;
+const bucketEvents = BucketEvents.fromBucket(bucket);
+
+// Bucket name is automatically injected from the bucket reference
+const pattern = bucketEvents.objectCreatedPattern();
+// pattern.detail.bucket.name === bucket.bucketName
+```
+
+**Event Metadata Support**: Control EventBridge pattern metadata
+
+```typescript
+import { BucketEvents } from '@aws-cdk/mixins-preview/aws_s3/events';
+
+declare const bucket: s3.Bucket;
+const bucketEvents = BucketEvents.fromBucket(bucket);
+
+const pattern = bucketEvents.objectCreatedPattern({
+  eventMetadata: {
+    region: ['us-east-1', 'us-west-2'],
+    version: ['0']
+  }
+});
+```
+
+### Available Events
+
+Event patterns are generated for EventBridge events available in the AWS Event Schema Registry. Common examples:
+
+**S3 Events**:
+
+* `objectCreatedPattern()` - Object creation events
+* `objectDeletedPattern()` - Object deletion events
+* `objectTagsAddedPattern()` - Object tagging events
+* `awsAPICallViaCloudTrailPattern()` - CloudTrail API calls
+
+Import events from service-specific modules:
+
+```typescript
+import { BucketEvents } from '@aws-cdk/mixins-preview/aws_s3/events';
+```

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

@@ -16,6 +16,8 @@ running on AWS Lambda, or any web application.
   - [AWS Lambda-backed APIs](#aws-lambda-backed-apis)
   - [AWS StepFunctions backed APIs](#aws-stepfunctions-backed-apis)
   - [Integration Targets](#integration-targets)
+    - [Response Streaming](#response-streaming)
+    - [Lambda Integration Permissions](#lambda-integration-permissions)
   - [Usage Plan \& API Keys](#usage-plan--api-keys)
     - [Adding an API Key to an imported RestApi](#adding-an-api-key-to-an-imported-restapi)
     - [⚠️ Multiple API Keys](#️-multiple-api-keys)
@@ -334,6 +336,20 @@ const getMessageIntegration = new apigateway.AwsIntegration({
 });
 ```
 
+### Response Streaming
+
+Integrations support response streaming, which allows responses to be streamed back to clients.
+This is useful for large payloads or when you want to start sending data before the entire response is ready.
+
+To enable response streaming, set `ResponseTransferMode.STREAM` to the `responseTransferMode` option:
+
+```ts
+declare const handler: lambda.Function;
+new apigateway.LambdaIntegration(handler, {
+  responseTransferMode: apigateway.ResponseTransferMode.STREAM,
+});
+```
+
 ### Lambda Integration Permissions
 
 By default, creating a `LambdaIntegration` will add a permission for API Gateway to invoke your AWS Lambda function, scoped to the specific method which uses the integration.

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigateway/integ.restapi-stream.ts

@@ -0,0 +1,51 @@
+import { Code, Function, Runtime } from 'aws-cdk-lib/aws-lambda';
+import { App, Stack } from 'aws-cdk-lib';
+import { ExpectedResult, IntegTest } from '@aws-cdk/integ-tests-alpha';
+import { Construct } from 'constructs';
+import { LambdaIntegration, ResponseTransferMode, RestApi } from 'aws-cdk-lib/aws-apigateway';
+
+class RestApiStreamStack extends Stack {
+  public readonly api: RestApi;
+  constructor(scope: Construct) {
+    super(scope, 'RestApiStreamStack');
+
+    const fn = new Function(this, 'myfn', {
+      code: Code.fromInline(`exports.handler = awslambda.streamifyResponse(async (event, responseStream, context) => {
+        const metadata = {
+          statusCode: 200,
+          headers: { 'Content-Type': 'text/plain' }
+        };
+        responseStream = awslambda.HttpResponseStream.from(responseStream, metadata);
+        responseStream.write('Hello, ');
+        await new Promise(resolve => setTimeout(resolve, 100));
+        responseStream.write('streaming ');
+        await new Promise(resolve => setTimeout(resolve, 100));
+        responseStream.write('world!');
+        responseStream.end();
+      });`),
+      runtime: Runtime.NODEJS_24_X,
+      handler: 'index.handler',
+    });
+
+    this.api = new RestApi(this, 'Api');
+    this.api.root.addMethod('POST', new LambdaIntegration(fn, { responseTransferMode: ResponseTransferMode.STREAM }));
+  }
+}
+
+const app = new App({
+  postCliContext: {
+    '@aws-cdk/aws-lambda:useCdkManagedLogGroup': false,
+  },
+});
+const testCase = new RestApiStreamStack(app);
+const integ = new IntegTest(app, 'rest-api-stream', {
+  testCases: [testCase],
+});
+
+const call = integ.assertions.httpApiCall(testCase.api.deploymentStage.urlForPath('/'), {
+  method: 'POST',
+});
+call.expect(ExpectedResult.objectLike({
+  status: 200,
+  body: 'Hello, streaming world!',
+}));

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs-patterns/integ.alb-fargate-service-public-private-switch.ts

@@ -3,8 +3,13 @@ import * as ecs from 'aws-cdk-lib/aws-ecs';
 import * as cdk from 'aws-cdk-lib';
 import * as integ from '@aws-cdk/integ-tests-alpha';
 import * as ecsPatterns from 'aws-cdk-lib/aws-ecs-patterns';
+import { ECS_PATTERNS_UNIQUE_TARGET_GROUP_ID } from 'aws-cdk-lib/cx-api';
 
-const app = new cdk.App();
+const app = new cdk.App({
+  postCliContext: {
+    [ECS_PATTERNS_UNIQUE_TARGET_GROUP_ID]: true,
+  },
+});
 const stack = new cdk.Stack(app, 'aws-ecs-integ-alb-fargate-public-private-switch');
 
 const vpc = new ec2.Vpc(stack, 'Vpc', { maxAzs: 2, restrictDefaultSecurityGroup: false });

{konokenj_cdk_api_mcp_server-0.60.0.dist-info → konokenj_cdk_api_mcp_server-0.61.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: konokenj.cdk-api-mcp-server
-Version: 0.60.0
+Version: 0.61.0
 Summary: An MCP server provides AWS CDK API Reference
 Project-URL: Documentation, https://github.com/konokenj/cdk-api-mcp-server#readme
 Project-URL: Issues, https://github.com/konokenj/cdk-api-mcp-server/issues
@@ -26,7 +26,7 @@ Description-Content-Type: text/markdown
 [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/konokenj.cdk-api-mcp-server.svg)](https://pypi.org/project/konokenj.cdk-api-mcp-server)
 
 <!-- DEP-VERSIONS-START -->
-[![aws-cdk](https://img.shields.io/badge/aws%20cdk-v2.229.0-blue.svg)](https://github.com/konokenj/cdk-api-mcp-server/blob/main/current-versions/aws-cdk.txt)
+[![aws-cdk](https://img.shields.io/badge/aws%20cdk-v2.229.1-blue.svg)](https://github.com/konokenj/cdk-api-mcp-server/blob/main/current-versions/aws-cdk.txt)
 <!-- DEP-VERSIONS-END -->
 
 ---

{konokenj_cdk_api_mcp_server-0.60.0.dist-info → konokenj_cdk_api_mcp_server-0.61.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-cdk_api_mcp_server/__about__.py,sha256=qJgWfWRLAHoroEG77CLQ2oAiZTOb4aM-sDJpKVMHlTk,129
+cdk_api_mcp_server/__about__.py,sha256=K0yl0BYcoJjpNacBBbmXpqgvDl9_hRNyLXsRo6FPirs,129
 cdk_api_mcp_server/__init__.py,sha256=yJA6yIEhJviC-qNlB-nC6UR1JblQci_d84i-viHZkc0,187
 cdk_api_mcp_server/models.py,sha256=cMS1Hi29M41YjuBxqqrzNrNvyG3MgnUBb1SqYpMCJ30,692
 cdk_api_mcp_server/resources.py,sha256=R7LVwn29I4BJzU5XAwKbX8j6uy-3ZxcB1b0HzZ_Z2PI,6689
@@ -9,7 +9,7 @@ cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/app-staging-synthesizer
 cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/aws-amplify-alpha/README.md,sha256=OIdszebPa0EqMIaHhqWgH6A64AcwQioIKC-NHDyZKrI,12636
 cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/aws-applicationsignals-alpha/README.md,sha256=6nqc-WbHB1iFE3vXDr6hyQs8tYS6wwnWutXePY4EF4w,10873
 cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/aws-apprunner-alpha/README.md,sha256=Jtm3RbnP4jQy8BYXwHvaRbMKizUjr4SqvimVMYhu6WQ,11982
-cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/aws-bedrock-agentcore-alpha/README.md,sha256=mOoV0VbrH4MvgA5eEuPjvcExkIrtCAvjGR997jCUyxg,94169
+cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/aws-bedrock-agentcore-alpha/README.md,sha256=-oEUT46pHphAMDs-gPnouXwQXFg4mLGzKaKs3h84f1I,95809
 cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/aws-bedrock-alpha/README.md,sha256=ZFThRraeK0rx1CF2foaEDzKsWxL1Qb9yqpCFM8eKvIo,65269
 cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/aws-cloud9-alpha/README.md,sha256=0N8kldvHAKsNQHKtsj8PaQywiDUVrd6rEwVNQV0equY,7718
 cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/aws-codestar-alpha/README.md,sha256=J-c-thqWwZFQT3Exjr_AY95BBgTA14Wb9aJ32gmEizQ,1509
@@ -20,7 +20,7 @@ cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/aws-eks-v2-alpha/README
 cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/aws-elasticache-alpha/README.md,sha256=5rwHuZ0rekBgrFzF1ig9rAxqufypWy8XN8-7y3De0dA,15152
 cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/aws-gamelift-alpha/README.md,sha256=pZqlGXpIekT05CmRYo99QPI-7S1iGtKoNESGryLQFxQ,28324
 cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/aws-glue-alpha/README.md,sha256=BCr7YEJ6Ht3oYR21NMCH3t1N738QjQ9Sh_dL_DUhECQ,32235
-cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/aws-imagebuilder-alpha/README.md,sha256=4d9nvPey6Pnfk-_Z7b0hETPYgYOqyrpLUHkKw5rhI90,34028
+cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/aws-imagebuilder-alpha/README.md,sha256=9W9RsI0MNRbd4S0WTQxnrBGxxlRLP4mR18TppIEQITQ,50697
 cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/aws-iot-actions-alpha/README.md,sha256=R6vkGxu-JjfB1IfGVquiD6Gcn4RQQpgbGo36njBdJe4,11947
 cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/aws-iot-alpha/README.md,sha256=18MkQScFBUO_qZnfYj9wfsdY_vRvvEyar2OT_QbO_N4,6909
 cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/aws-iotevents-actions-alpha/README.md,sha256=0Al2K5gHcEce_cH07YM1GuFFrJ0mrr85ZWGVrj2cs9s,4477
@@ -46,13 +46,13 @@ cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/cfnspec/README.md,sha25
 cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/custom-resource-handlers/README.md,sha256=QctOoyGt6AqVWeFhRwpkCSxHZ1XFWj_nCKlkJHDFock,965
 cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/example-construct-library/README.md,sha256=vnVXyvtN9ICph68sw2y6gkdD_gmas0PiUa9TkwNckWQ,4501
 cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/integ-tests-alpha/README.md,sha256=VifKLrR404_yLVT0E3ai8f3R5K0h22VNwQplpSUSZqc,17489
-cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/mixins-preview/README.md,sha256=kOR3lr1nRgQvZotnLYt3DUfcUzC0PJM6TNTwxy3ouCQ,6110
+cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/mixins-preview/README.md,sha256=bhNnfP2bBS2AuPQfIsPlvVmqn3wOz5DDI3yVBz_1rkI,9584
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/README.md/README.md,sha256=fDaQqPonfLmfQpukU4aAJcjQI5xHI40D3Li0I056Q7s,76468
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/assertions/MIGRATING.md,sha256=SYGX8QNB1Pm_rVYDBp4QRWkqwnxOb3CHzeFglUy_53k,3347
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/assertions/README.md,sha256=3yo3D05n5explTIgnuF-vkk01MTYeAYe7_3rcsD2baE,18299
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/assets/README.md,sha256=kL56RlfxBa5LwV0cRseybeKIRKHhEXPjUo0HWPZqdO8,53
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-acmpca/README.md,sha256=RGFU8j3ndIVE6TFClCB6CqXGZsRuQihPUV63ZpxfrnY,1770
-cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigateway/README.md,sha256=JGK3dV0CAyCnMYpDiZGpnHQuQzJpuFavR892W6g4s7A,66325
+cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigateway/README.md,sha256=S3ELghCoO5BJDiX7qlfzonswpYPPg0zIuFdeTE6pHXQ,66942
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigateway/integ.api-definition.asset.ts,sha256=boLnVIGcaOjg2TGEhOC0mLldISYkj7NwahqhjUxU-jM,1258
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigateway/integ.api-definition.inline.ts,sha256=NjNlh_yI_yYJ0jsdT0Swp2JwhvYIzwC4g_2YK1LChgU,1722
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigateway/integ.api-with-authorizer-and-method.ts,sha256=eQRXMq81lE36q-LInjICbtM0yuHQGCzWNySr0IlCs08,1093
@@ -76,6 +76,7 @@ cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigateway/integ
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigateway/integ.restapi-import.lit.ts,sha256=PWe7_kQhUoUk_5c5XySAuHNqaRY4TjVYfFw90ZDm-XQ,3896
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigateway/integ.restapi-ip-address-type.ts,sha256=T2rhIMaYQICvq30EC3LuJSCgORxOjU2ynB7l4BdO7J0,1969
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigateway/integ.restapi-metrics.ts,sha256=v-WGRXnX0PorSfrzTeGkXXgigi905Rg49azGE2wg-SI,907
+cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigateway/integ.restapi-stream.ts,sha256=DmNYPwv-zFiLTnoPGJ0bLlnqNdP0cqAlv9psdFA5QTE,1814
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigateway/integ.restapi.access-log-firehose.ts,sha256=TGo5hdUGf08kAn2Aua7_7grFHqb096XGjeWWdDYKtT4,2602
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigateway/integ.restapi.access-log.ts,sha256=BJgvho6pl6SwOULrlHKTUYShYtkhqglfXg-kTd4I3Qs,1935
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigateway/integ.restapi.books.ts,sha256=lJVCckdTlcx4mlfwP-Mf8mZKwSValB9ysMB-4u5mYJc,2309
@@ -670,7 +671,7 @@ cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs-patterns/int
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs-patterns/integ.alb-fargate-service-https.ts,sha256=3dktKjKxT-C6UnR8iAzLGpuglqdWkCxBMcfrWcQzB_o,1359
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs-patterns/integ.alb-fargate-service-idle-timeout.ts,sha256=1nDG3rd-hm3RnQ4xiFT4pdAR9Z3T88OoR7sB5oWIwJw,994
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs-patterns/integ.alb-fargate-service-ipv6.ts,sha256=KHu8xfWrNhROvDbiQHKS01FxRO_rNf1Flp3V0qI5D10,1195
-cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs-patterns/integ.alb-fargate-service-public-private-switch.ts,sha256=sBJogVNG4upIS1EpHCwpkakBFxdA8Ayz8tavEaghP1M,1592
+cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs-patterns/integ.alb-fargate-service-public-private-switch.ts,sha256=ofEzzKJHAauq1_6dpg63icbnH_bjwfuh1beZ0WVYeCQ,1743
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs-patterns/integ.alb-fargate-service-smart-defaults.ts,sha256=pH9NWZes2NeQdYMQwL6T4de8OC2nlWSmJswxyKrGluY,5606
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs-patterns/integ.application-load-balanced-ecs-service.ts,sha256=AW0TxIUs43BjiGhpHZHCjqtFXC_8mZ-FjfXOQWDew6o,2581
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs-patterns/integ.asset-image.ts,sha256=dVWEvGZC44OoqkcskIJxWaw5dUacsxBRAnlNZD5xxEw,1117
@@ -1465,8 +1466,8 @@ cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/pipelines/integ.pipe
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/region-info/README.md,sha256=vewWkV3ds9o9iyyYaJBNTkaKJ2XA6K2yF17tAxUnujg,2718
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/triggers/README.md,sha256=hYIx7DbG_7p4LYLUfxDwgIQjw9UNdz1GLrqDe8_Dbko,4132
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/triggers/integ.triggers.ts,sha256=LfeVru_CggiFXKPVa8vwt6Uv43SV3oAioDGmd8PyMHc,2859
-konokenj_cdk_api_mcp_server-0.60.0.dist-info/METADATA,sha256=76tCTaQpibDQgKHPDcm89DLmh7ygWIKJ5wx1XxQ7F4M,2646
-konokenj_cdk_api_mcp_server-0.60.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-konokenj_cdk_api_mcp_server-0.60.0.dist-info/entry_points.txt,sha256=bVDhMdyCC1WNMPOMbmB82jvWII2CIrwTZDygdCf0cYQ,79
-konokenj_cdk_api_mcp_server-0.60.0.dist-info/licenses/LICENSE.txt,sha256=5OIAASeg1HM22mVZ1enz9bgZ7TlsGfWXnj02P9OgFyk,1098
-konokenj_cdk_api_mcp_server-0.60.0.dist-info/RECORD,,
+konokenj_cdk_api_mcp_server-0.61.0.dist-info/METADATA,sha256=P0XyRaSLgudxEXVnyfbU22YT8l1RxwgVv-5aZ9lm5Lo,2646
+konokenj_cdk_api_mcp_server-0.61.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+konokenj_cdk_api_mcp_server-0.61.0.dist-info/entry_points.txt,sha256=bVDhMdyCC1WNMPOMbmB82jvWII2CIrwTZDygdCf0cYQ,79
+konokenj_cdk_api_mcp_server-0.61.0.dist-info/licenses/LICENSE.txt,sha256=5OIAASeg1HM22mVZ1enz9bgZ7TlsGfWXnj02P9OgFyk,1098
+konokenj_cdk_api_mcp_server-0.61.0.dist-info/RECORD,,