konokenj.cdk-api-mcp-server 0.51.0__py3-none-any.whl → 0.52.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.51.0"
+__version__ = "0.52.0"

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

@@ -45,6 +45,11 @@ This construct library facilitates the deployment of Bedrock AgentCore primitive
   - [Code Interpreter Network Modes](#code-interpreter-network-modes)
   - [Basic Code Interpreter Creation](#basic-code-interpreter-creation)
   - [Code Interpreter IAM permissions](#code-interpreter-iam-permissions)
+- [Memory](#memory)
+  - [Memory properties](#memory-properties)
+  - [Basic Memory Creation](#basic-memory-creation)
+  - [LTM Memory Extraction Stategies](#ltm-memory-extraction-stategies)
+  - [Memory Strategy Methods](#memory-strategy-methods)
 
 
 ## AgentCore Runtime
@@ -298,6 +303,10 @@ IAM authentication is the default mode, when no authorizerConfiguration is set t
 To configure AWS Cognito User Pool authentication:
 
 ```typescript
+declare const userPool: cognito.UserPool;
+declare const userPoolClient: cognito.UserPoolClient;
+declare const anotherUserPoolClient: cognito.UserPoolClient;
+
 const repository = new ecr.Repository(this, "TestRepository", {
   repositoryName: "test-agent-runtime",
 });
@@ -307,9 +316,8 @@ const runtime = new agentcore.Runtime(this, "MyAgentRuntime", {
   runtimeName: "myAgent",
   agentRuntimeArtifact: agentRuntimeArtifact,
   authorizerConfiguration: agentcore.RuntimeAuthorizerConfiguration.usingCognito(
-    "us-west-2_ABC123",  // User Pool ID (required)
-    "client123",         // Client ID (required)
-    "us-west-2"         // Region (optional, defaults to stack region)
+    userPool, // User Pool (required)
+    [userPoolClient, anotherUserPoolClient], // User Pool Clients
   ),
 });
 ```
@@ -794,3 +802,317 @@ const codeInterpreter = new agentcore.CodeInterpreterCustom(this, "MyCodeInterpr
   },
 });
 ```
+
+## Memory
+
+Memory is a critical component of intelligence. While Large Language Models (LLMs) have impressive capabilities, they lack persistent memory across conversations. Amazon Bedrock AgentCore Memory addresses this limitation by providing a managed service that enables AI agents to maintain context over time, remember important facts, and deliver consistent, personalized experiences.
+
+AgentCore Memory operates on two levels:
+
+- **Short-Term Memory**: Immediate conversation context and session-based information that provides continuity within a single interaction or closely related sessions.
+- **Long-Term Memory**: Persistent information extracted and stored across multiple conversations, including facts, preferences, and summaries that enable personalized experiences over time.
+
+When you interact with the memory via the `CreateEvent` API, you store interactions in Short-Term Memory (STM) instantly. These interactions can include everything from user messages, assistant responses, to tool actions.
+
+To write to long-term memory, you need to configure extraction strategies which define how and where to store information from conversations for future use. These strategies are asynchronously processed from raw events after every few turns based on the strategy that was selected. You can't create long term memory records directly, as they are extracted asynchronously by AgentCore Memory.
+
+### Memory Properties
+
+| Name | Type | Required | Description |
+|------|------|----------|-------------|
+| `memoryName` | `string` | Yes | The name of the memory |
+| `expirationDuration` | `Duration` | No | Short-term memory expiration in days (between 7 and 365). Default: 90 days |
+| `description` | `string` | No | Optional description for the memory. Default: no description. |
+| `kmsKey` | `IKey` | No | Custom KMS key to use for encryption. Default: Your data is encrypted with a key that AWS owns and manages for you |
+| `memoryStrategies` | `MemoryStrategyBase[]` | No | Built-in extraction strategies to use for this memory. Default: No extraction strategies (short term memory only) |
+| `executionRole` | `iam.IRole` | No | The IAM role that provides permissions for the memory to access AWS services. Default: A new role will be created. |
+| `tags` | `{ [key: string]: string }` | No | Tags for memory. Default: no tags. |
+
+### Basic Memory Creation
+
+Below you can find how to configure a simple short-term memory (STM) with no long-term memory extraction strategies.
+Note how you set `expirationDuration`, which defines the time the events will be stored in the short-term memory before they expire.
+
+```typescript fixture=default
+
+// Create a basic memory with default settings, no LTM strategies
+const memory = new agentcore.Memory(this, "MyMemory", {
+  memoryName: "my_memory",
+  description: "A memory for storing user interactions for a period of 90 days",
+  expirationDuration: cdk.Duration.days(90),
+});
+```
+
+Basic Memory with Custom KMS Encryption
+
+```typescript fixture=default
+// Create a custom KMS key for encryption
+const encryptionKey = new kms.Key(this, "MemoryEncryptionKey", {
+  enableKeyRotation: true,
+  description: "KMS key for memory encryption",
+});
+
+// Create memory with custom encryption
+const memory = new agentcore.Memory(this, "MyMemory", {
+  memoryName: "my_encrypted_memory",
+  description: "Memory with custom KMS encryption",
+  expirationDuration: cdk.Duration.days(90),
+  kmsKey: encryptionKey,
+});
+```
+
+### LTM Memory Extraction Stategies
+
+If you need long-term memory for context recall across sessions, you can setup memory extraction strategies
+to extract the relevant memory from the raw events.
+
+Amazon Bedrock AgentCore Memory has different memory strategies for extracting and organizing information:
+
+- **Summarization**: to summarize interactions to preserve critical context and key insights.
+- **Semantic Memory**: to extract general factual knowledge, concepts and meanings from raw conversations using vector embeddings.
+This enables similarity-based retrieval of relevant facts and context.
+- **User Preferences**: to extract user behavior patterns from raw conversations.
+
+You can use built-in extraction strategies for quick setup, or create custom extraction strategies with specific models and prompt templates.
+
+### Memory with Built-in Strategies
+
+The library provides three built-in LTM strategies. These are default strategies for organizing and extracting memory data,
+each optimized for specific use cases.
+
+For example: An agent helps multiple users with cloud storage setup. From these conversations,
+see how each strategy processes users expressing confusion about account connection:
+
+1. **Summarization Strategy** (`MemoryStrategy.usingBuiltInSummarization()`)
+This strategy compresses conversations into concise overviews, preserving essential context and key insights for quick recall.
+Extracted memory example: Users confused by cloud setup during onboarding.
+
+   - Extracts concise summaries to preserve critical context and key insights
+   - Namespace: `/strategies/{memoryStrategyId}/actors/{actorId}/sessions/{sessionId}`
+
+2. **Semantic Memory Strategy** (`MemoryStrategy.usingBuiltInSemantic()`)
+Distills general facts, concepts, and underlying meanings from raw conversational data, presenting the information in a context-independent format.
+Extracted memory example: In-context learning = task-solving via examples, no training needed.
+
+   - Extracts general factual knowledge, concepts and meanings from raw conversations
+   - Namespace: `/strategies/{memoryStrategyId}/actors/{actorId}`
+
+3. **User Preference Strategy** (`MemoryStrategy.usingBuiltInUserPreference()`)
+Captures individual preferences, interaction patterns, and personalized settings to enhance future experiences.
+Extracted memory example: User needs clear guidance on cloud storage account connection during onboarding.
+
+   - Extracts user behavior patterns from raw conversations
+   - Namespace: `/strategies/{memoryStrategyId}/actors/{actorId}`
+
+```typescript fixture=default
+// Create memory with built-in strategies
+const memory = new agentcore.Memory(this, "MyMemory", {
+  memoryName: "my_memory",
+  description: "Memory with built-in strategies",
+  expirationDuration: cdk.Duration.days(90),
+  memoryStrategies: [
+    agentcore.MemoryStrategy.usingBuiltInSummarization(),
+    agentcore.MemoryStrategy.usingBuiltInSemantic(),
+    agentcore.MemoryStrategy.usingBuiltInUserPreference(),
+  ],
+});
+```
+
+The name generated for each built in memory strategy is as follows:
+
+- For Summarization: `summary_builtin_cdk001`
+- For Semantic:`semantic_builtin_cdk001>`
+- For User Preferences: `preference_builtin_cdk001`
+
+### Memory with custom Strategies
+
+With Long-Term Memory, organization is managed through Namespaces.
+
+An `actor` refers to entity such as end users or agent/user combinations. For example, in a coding support chatbot,
+the actor is usually the developer asking questions. Using the actor ID helps the system know which user the memory belongs to,
+keeping each user's data separate and organized.
+
+A `session` is usually a single conversation or interaction period between the user and the AI agent.
+It groups all related messages and events that happen during that conversation.
+
+A `namespace` is used to logically group and organize long-term memories. It ensures data stays neat, separate, and secure.
+
+With AgentCore Memory, you need to add a namespace when you define a memory strategy. This namespace helps define where the long-term memory
+will be logically grouped. Every time a new long-term memory is extracted using this memory strategy, it is saved under the namespace you set.
+This means that all long-term memories are scoped to their specific namespace, keeping them organized and preventing any mix-ups with other
+users or sessions. You should use a hierarchical format separated by forward slashes /. This helps keep memories organized clearly. As needed,
+you can choose to use the below pre-defined variables within braces in the namespace based on your applications' organization needs:
+
+- `actorId` – Identifies who the long-term memory belongs to, such as a user
+- `memoryStrategyId` – Shows which memory strategy is being used. This strategy identifier is auto-generated when you create a memory using CreateMemory operation.
+- `sessionId` – Identifies which session or conversation the memory is from.
+
+For example, if you define the following namespace as the input to your strategy in CreateMemory operation:
+
+```shell
+/strategy/{memoryStrategyId}/actor/{actorId}/session/{sessionId}
+```
+
+After memory creation, this namespace might look like:
+
+```shell
+/strategy/summarization-93483043//actor/actor-9830m2w3/session/session-9330sds8
+```
+
+You can customise the namespace, i.e. where the memories are stored by using the following methods:
+
+1. **Summarization Strategy** (`MemoryStrategy.usingSummarization(props)`)
+1. **Semantic Memory Strategy** (`MemoryStrategy.usingSemantic(props)`)
+1. **User Preference Strategy** (`MemoryStrategy.usingUserPreference(props)`)
+
+```typescript fixture=default
+// Create memory with built-in strategies
+const memory = new agentcore.Memory(this, "MyMemory", {
+  memoryName: "my_memory",
+  description: "Memory with built-in strategies",
+  expirationDuration: cdk.Duration.days(90),
+  memoryStrategies: [
+    agentcore.MemoryStrategy.usingUserPreference({
+        name: "CustomerPreferences",
+        namespaces: ["support/customer/{actorId}/preferences"]
+    }),
+    agentcore.MemoryStrategy.usingSemantic({
+        name: "CustomerSupportSemantic",
+        namespaces: ["support/customer/{actorId}/semantic"]
+    }),
+  ],
+});
+```
+
+Custom memory strategies let you tailor memory extraction and consolidation to your specific domain or use case.
+You can override the prompts for extracting and consolidating semantic, summary, or user preferences.
+You can also choose the model that you want to use for extraction and consolidation.
+
+The custom prompts you create are appended to a non-editable system prompt.
+
+Since a custom strategy requires you to invoke certain FMs, you need a role with appropriate permissions. For that, you can:
+
+- Let the L2 construct create a minimum permission role for you when use L2 Bedrock Foundation Models.
+- Use a custom role with the overly permissive `AmazonBedrockAgentCoreMemoryBedrockModelInferenceExecutionRolePolicy` managed policy.
+- Use a custom role with your own custom policies.
+
+#### Memory with Custom Execution Role
+
+Keep in mind that memories that **do not** use custom strategies do not require a service role.
+So even if you provide it, it will be ignored as it will never be used.
+
+```typescript fixture=default
+// Create a custom execution role
+const executionRole = new iam.Role(this, "MemoryExecutionRole", {
+  assumedBy: new iam.ServicePrincipal("bedrock-agentcore.amazonaws.com"),
+  managedPolicies: [
+    iam.ManagedPolicy.fromAwsManagedPolicyName(
+      "AmazonBedrockAgentCoreMemoryBedrockModelInferenceExecutionRolePolicy"
+    ),
+  ],
+});
+
+// Create memory with custom execution role
+const memory = new agentcore.Memory(this, "MyMemory", {
+  memoryName: "my_memory",
+  description: "Memory with custom execution role",
+  expirationDuration: cdk.Duration.days(90),
+  executionRole: executionRole,
+});
+```
+
+In customConsolidation and customExtraction, the model property uses the [@aws-cdk/aws-bedrock-alph](https://www.npmjs.com/package/@aws-cdk/aws-bedrock-alpha) library which must be installed separately.
+
+```typescript fixture=default
+// Create a custom semantic memory strategy
+const customSemanticStrategy = agentcore.MemoryStrategy.usingSemantic({
+  name: "customSemanticStrategy",
+  description: "Custom semantic memory strategy",
+  namespaces: ["/custom/strategies/{memoryStrategyId}/actors/{actorId}"],
+  customConsolidation: {
+    model: bedrock.BedrockFoundationModel.ANTHROPIC_CLAUDE_3_5_SONNET_V1_0,
+    appendToPrompt: "Custom consolidation prompt for semantic memory",
+  },
+  customExtraction: {
+    model: bedrock.BedrockFoundationModel.ANTHROPIC_CLAUDE_3_5_SONNET_V1_0,
+    appendToPrompt: "Custom extraction prompt for semantic memory",
+  },
+});
+
+// Create memory with custom strategy
+const memory = new agentcore.Memory(this, "MyMemory", {
+  memoryName: "my-custom-memory",
+  description: "Memory with custom strategy",
+  expirationDuration: cdk.Duration.days(90),
+  memoryStrategies: [customSemanticStrategy],
+});
+```
+
+### Memory with self-managed Strategies
+
+A self-managed strategy in Amazon Bedrock AgentCore Memory gives you complete control over your memory extraction and consolidation pipelines. 
+With a self-managed strategy, you can build custom memory processing workflows while leveraging Amazon Bedrock AgentCore for storage and retrieval.
+
+For additional information, you can refer to the [developer guide for self managed strategies](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/memory-self-managed-strategies.html).
+
+Create the required AWS resources including:
+
+- an S3 bucket in your account where Amazon Bedrock AgentCore will deliver batched event payloads.
+- an SNS topic for job notifications. Use FIFO topics if processing order within sessions is important for your use case.
+
+The construct will apply the correct permissions to the memory execution role to access these resources.
+
+```typescript fixture=default
+
+const bucket = new s3.Bucket(this, 'memoryBucket', {
+  bucketName: 'test-memory',
+  removalPolicy: cdk.RemovalPolicy.DESTROY,
+  autoDeleteObjects: true,
+});
+
+const topic = new sns.Topic(this, 'topic');
+
+// Create a custom semantic memory strategy
+const selfManagedStrategy = agentcore.MemoryStrategy.usingSelfManaged({
+  name: "selfManagedStrategy",
+  description: "self managed memory strategy",
+  historicalContextWindowSize: 5,
+  invocationConfiguration: {
+    topic: topic,
+    s3Location: {
+      bucketName: bucket.bucketName,
+      objectKey: 'memory/',
+    }
+  },
+  triggerConditions: {
+    messageBasedTrigger: 1,
+    timeBasedTrigger: cdk.Duration.seconds(10),
+    tokenBasedTrigger: 100
+  }
+});
+
+// Create memory with custom strategy
+const memory = new agentcore.Memory(this, "MyMemory", {
+  memoryName: "my-custom-memory",
+  description: "Memory with custom strategy",
+  expirationDuration: cdk.Duration.days(90),
+  memoryStrategies: [selfManagedStrategy],
+});
+```
+
+### Memory Strategy Methods
+
+You can add new memory strategies to the memory construct using the `addMemoryStrategy()` method, for instance:
+
+```typescript fixture=default
+// Create memory without initial strategies
+const memory = new agentcore.Memory(this, "test-memory", {
+  memoryName: "test_memory_add_strategy",
+  description: "A test memory for testing addMemoryStrategy method",
+  expirationDuration: cdk.Duration.days(90),
+});
+
+// Add strategies after instantiation
+memory.addMemoryStrategy(agentcore.MemoryStrategy.usingBuiltInSummarization());
+memory.addMemoryStrategy(agentcore.MemoryStrategy.usingBuiltInSemantic());
+```

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

@@ -1652,6 +1652,15 @@ const api = new apigateway.SpecRestApi(this, 'books-api', {
 });
 ```
 
+`SpecRestApi` also supports binary media types, similar to `RestApi`:
+
+```ts
+const api = new apigateway.SpecRestApi(this, 'books-api', {
+  apiDefinition: apigateway.ApiDefinition.fromAsset('path-to-file.json'),
+  binaryMediaTypes: ['image/png', 'application/pdf']
+});
+```
+
 ### Endpoint configuration
 
 By default, `SpecRestApi` will create an edge optimized endpoint.

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

@@ -14,6 +14,7 @@ class Test extends cdk.Stack {
       apiDefinition: apigateway.ApiDefinition.fromAsset(path.join(__dirname, 'sample-definition.yaml')),
       disableExecuteApiEndpoint: true,
       minCompressionSize: Size.bytes(1024),
+      binaryMediaTypes: ['image/png', 'application/pdf'],
       retainDeployments: true,
       cloudWatchRole: true,
       deployOptions: {

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

@@ -14,11 +14,13 @@
   - [VPC Link](#vpc-link)
   - [Private Integration](#private-integration)
   - [Generating ARN for Execute API](#generating-arn-for-execute-api)
-  - [Access Logging](#access-logging)
 - [WebSocket API](#websocket-api)
   - [Manage Connections Permission](#manage-connections-permission)
   - [Managing access to WebSocket APIs](#managing-access-to-websocket-apis)
   - [Usage Plan and API Keys](#usage-plan-and-api-keys)
+- [Common Config](#common-config)
+  - [Route Settings](#route-settings)
+  - [Access Logging](#access-logging)
 
 ## Introduction
 
@@ -375,65 +377,6 @@ const arn = api.arnForExecuteApi('GET', '/myApiPath', 'dev');
 - The 'ANY' method can be used for matching any HTTP methods not explicitly defined.
 - The function gracefully handles undefined parameters by using wildcards, making it flexible for various API configurations.
 
-## Access Logging
-
-You can turn on logging to write logs to CloudWatch Logs.
-Read more at [Configure logging for HTTP APIs in API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-logging.html)
-
-```ts
-import * as logs from 'aws-cdk-lib/aws-logs';
-
-declare const api: apigwv2.HttpApi;
-declare const logGroup: logs.LogGroup;
-
-const stage = new apigwv2.HttpStage(this, 'Stage', {
-  httpApi: api,
-  accessLogSettings: {
-    destination: new apigwv2.LogGroupLogDestination(logGroup),
-  },
-});
-```
-
-The following code will generate the access log in the [CLF format](https://en.wikipedia.org/wiki/Common_Log_Format).
-
-```ts
-import * as apigw from 'aws-cdk-lib/aws-apigateway';
-import * as logs from 'aws-cdk-lib/aws-logs';
-
-declare const api: apigwv2.HttpApi;
-declare const logGroup: logs.LogGroup;
-
-const stage = new apigwv2.HttpStage(this, 'Stage', {
-  httpApi: api,
-  accessLogSettings: {
-    destination: new apigwv2.LogGroupLogDestination(logGroup),
-    format: apigw.AccessLogFormat.clf(),
-  },
-});
-```
-
-You can also configure your own access log format by using the `AccessLogFormat.custom()` API.
-`AccessLogField` provides commonly used fields. The following code configures access log to contain.
-
-```ts
-import * as apigw from 'aws-cdk-lib/aws-apigateway';
-import * as logs from 'aws-cdk-lib/aws-logs';
-
-declare const api: apigwv2.HttpApi;
-declare const logGroup: logs.LogGroup;
-
-const stage = new apigwv2.HttpStage(this, 'Stage', {
-  httpApi: api,
-  accessLogSettings: {
-    destination: new apigwv2.LogGroupLogDestination(logGroup),
-    format: apigw.AccessLogFormat.custom(
-      `${apigw.AccessLogField.contextRequestId()} ${apigw.AccessLogField.contextErrorMessage()} ${apigw.AccessLogField.contextErrorMessageString()}
-      ${apigw.AccessLogField.contextAuthorizerError()} ${apigw.AccessLogField.contextAuthorizerIntegrationStatus()}`
-    ),
-  },
-});
-```
-
 ## WebSocket API
 
 A WebSocket API in API Gateway is a collection of WebSocket routes that are integrated with backend HTTP endpoints,
@@ -578,26 +521,6 @@ const webSocketApi = new apigwv2.WebSocketApi(this, 'mywsapi',{
 });
 ```
 
-## Common Config
-
-Common config for both HTTP API and WebSocket API
-
-### Route Settings
-
-Represents a collection of route settings.
-
-```ts
-declare const api: apigwv2.HttpApi;
-
-new apigwv2.HttpStage(this, 'Stage', {
-  httpApi: api,
-  throttle: {
-    rateLimit: 1000,
-    burstLimit: 1000,
-  },
-  detailedMetricsEnabled: true,
-});
-```
 ## Usage Plan and API Keys
 
 A usage plan specifies who can access one or more deployed WebSocket API stages, and the rate at which they can be accessed. The plan uses API keys to
@@ -740,4 +663,93 @@ const key = new apigwv2.RateLimitedApiKey(this, 'rate-limited-api-key', {
     burstLimit: 200
   }
 });            
-```
+```
+
+## Common Config
+
+Common config for both HTTP API and WebSocket API
+
+### Route Settings
+
+Represents a collection of route settings.
+
+```ts
+declare const api: apigwv2.HttpApi;
+
+new apigwv2.HttpStage(this, 'Stage', {
+  httpApi: api,
+  throttle: {
+    rateLimit: 1000,
+    burstLimit: 1000,
+  },
+  detailedMetricsEnabled: true,
+});
+```
+
+### Access Logging
+
+You can turn on logging to write logs to CloudWatch Logs.
+Read more at Configure logging for [HTTP APIs](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-logging.html) or [WebSocket APIs](https://docs.aws.amazon.com/apigateway/latest/developerguide/websocket-api-logging.html)
+
+```ts
+import * as logs from 'aws-cdk-lib/aws-logs';
+
+declare const httpApi: apigwv2.HttpApi;
+declare const webSocketApi : apigwv2.WebSocketApi;
+declare const logGroup: logs.LogGroup;
+
+new apigwv2.HttpStage(this, 'HttpStage', {
+  httpApi,
+  accessLogSettings: {
+    destination: new apigwv2.LogGroupLogDestination(logGroup),
+  },
+});
+
+new apigwv2.WebSocketStage(this, 'WebSocketStage', {
+  webSocketApi,
+  stageName: 'dev',
+  accessLogSettings: {
+    destination: new apigwv2.LogGroupLogDestination(logGroup),
+  },
+});
+```
+
+The following code will generate the access log in the [CLF format](https://en.wikipedia.org/wiki/Common_Log_Format).
+
+```ts
+import * as apigw from 'aws-cdk-lib/aws-apigateway';
+import * as logs from 'aws-cdk-lib/aws-logs';
+
+declare const api: apigwv2.HttpApi;
+declare const logGroup: logs.LogGroup;
+
+const stage = new apigwv2.HttpStage(this, 'Stage', {
+  httpApi: api,
+  accessLogSettings: {
+    destination: new apigwv2.LogGroupLogDestination(logGroup),
+    format: apigw.AccessLogFormat.clf(),
+  },
+});
+```
+
+You can also configure your own access log format by using the `AccessLogFormat.custom()` API.
+`AccessLogField` provides commonly used fields. The following code configures access log to contain.
+
+```ts
+import * as apigw from 'aws-cdk-lib/aws-apigateway';
+import * as logs from 'aws-cdk-lib/aws-logs';
+
+declare const api: apigwv2.HttpApi;
+declare const logGroup: logs.LogGroup;
+
+const stage = new apigwv2.HttpStage(this, 'Stage', {
+  httpApi: api,
+  accessLogSettings: {
+    destination: new apigwv2.LogGroupLogDestination(logGroup),
+    format: apigw.AccessLogFormat.custom(
+      `${apigw.AccessLogField.contextRequestId()} ${apigw.AccessLogField.contextErrorMessage()} ${apigw.AccessLogField.contextErrorMessageString()}
+      ${apigw.AccessLogField.contextAuthorizerError()} ${apigw.AccessLogField.contextAuthorizerIntegrationStatus()}`
+    ),
+  },
+});
+```

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigatewayv2/integ.stage.ts

@@ -1,12 +1,19 @@
 #!/usr/bin/env node
+import { IntegTest } from '@aws-cdk/integ-tests-alpha';
 import * as cdk from 'aws-cdk-lib';
-import * as apigw from 'aws-cdk-lib/aws-apigatewayv2';
+import * as apigwv2 from 'aws-cdk-lib/aws-apigatewayv2';
+import * as apigw from 'aws-cdk-lib/aws-apigateway';
+import * as logs from 'aws-cdk-lib/aws-logs';
 
 const app = new cdk.App();
 const stack = new cdk.Stack(app, 'aws-cdk-aws-apigatewayv2-websocket-stage');
 
-const webSocketApi = new apigw.WebSocketApi(stack, 'WebSocketApi');
-new apigw.WebSocketStage(stack, 'WebSocketStage', {
+const logGroup = new logs.LogGroup(stack, 'MyLogGroup', {
+  removalPolicy: cdk.RemovalPolicy.DESTROY,
+});
+
+const webSocketApi = new apigwv2.WebSocketApi(stack, 'WebSocketApi');
+new apigwv2.WebSocketStage(stack, 'WebSocketStage', {
   webSocketApi,
   stageName: 'dev',
   throttle: {
@@ -15,6 +22,15 @@ new apigw.WebSocketStage(stack, 'WebSocketStage', {
   },
   detailedMetricsEnabled: true,
   description: 'My Stage',
+  accessLogSettings: {
+    destination: new apigwv2.LogGroupLogDestination(logGroup),
+    format: apigw.AccessLogFormat.custom(JSON.stringify({
+      extendedRequestId: apigw.AccessLogField.contextExtendedRequestId(),
+      requestTime: apigw.AccessLogField.contextRequestTime(),
+    })),
+  },
 });
 
-app.synth();
+new IntegTest(app, 'aws-cdk-aws-apigatewayv2-websocket-stage-test', {
+  testCases: [stack],
+});

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-iam/integ.managed-policy.ts

@@ -1,6 +1,7 @@
 import { App, Stack } from 'aws-cdk-lib';
 import { IntegTest } from '@aws-cdk/integ-tests-alpha';
 import { AccountRootPrincipal, Grant, ManagedPolicy, PolicyStatement, Role, User } from 'aws-cdk-lib/aws-iam';
+import * as lambda from 'aws-cdk-lib/aws-lambda';
 
 const app = new App();
 
@@ -34,6 +35,14 @@ policy.attachToRole(role);
 const importedRole = Role.fromRoleArn(stack, 'ImportedRole', role.roleArn);
 policy.attachToRole(importedRole);
 
+// Can be passed to grantInvoke, see https://github.com/aws/aws-cdk/issues/32980
+const func = new lambda.Function(stack, 'Function', {
+  runtime: lambda.Runtime.NODEJS_LATEST,
+  handler: 'index.handler',
+  code: lambda.Code.fromInline('export const handler = async () => null'),
+});
+func.grantInvoke(policy);
+
 new IntegTest(app, 'ManagedPolicyInteg', {
   testCases: [stack],
 });

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

@@ -1,6 +1,7 @@
 import { App, Stack } from 'aws-cdk-lib';
 import { IntegTest } from '@aws-cdk/integ-tests-alpha';
 import { AccountRootPrincipal, Grant, Policy, PolicyStatement, Role, User } from 'aws-cdk-lib/aws-iam';
+import * as lambda from 'aws-cdk-lib/aws-lambda';
 
 const app = new App();
 
@@ -21,6 +22,14 @@ role.grantAssumeRole(user);
 
 Grant.addToPrincipal({ actions: ['iam:*'], resourceArns: [role.roleArn], grantee: policy2 });
 
+// Can be passed to grantInvoke, see https://github.com/aws/aws-cdk/issues/32980
+const func = new lambda.Function(stack, 'Function', {
+  runtime: lambda.Runtime.NODEJS_LATEST,
+  handler: 'index.handler',
+  code: lambda.Code.fromInline('export const handler = async () => null'),
+});
+func.grantInvoke(policy);
+
 new IntegTest(app, 'PolicyInteg', {
   testCases: [stack],
 });

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

@@ -483,8 +483,11 @@ Data can be transformed before being delivered to destinations. There are two ty
 data processing for delivery streams: record transformation with AWS Lambda, and record
 format conversion using a schema stored in an AWS Glue table. If both types of data
 processing are configured, then the Lambda transformation is performed first. By default,
-no data processing occurs. This construct library currently only supports data
-transformation with AWS Lambda. See [#15501](https://github.com/aws/aws-cdk/issues/15501)
+no data processing occurs.
+
+This construct library currently only supports data
+transformation with AWS Lambda and some built-in data processors.
+See [#15501](https://github.com/aws/aws-cdk/issues/15501)
 to track the status of adding support for record format conversion.
 
 ### Data transformation with AWS Lambda
@@ -520,7 +523,7 @@ const lambdaProcessor = new firehose.LambdaFunctionProcessor(lambdaFunction, {
 });
 declare const bucket: s3.Bucket;
 const s3Destination = new firehose.S3Bucket(bucket, {
-  processor: lambdaProcessor,
+  processors: [lambdaProcessor],
 });
 new firehose.DeliveryStream(this, 'Delivery Stream', {
   destination: s3Destination,
@@ -532,6 +535,60 @@ new firehose.DeliveryStream(this, 'Delivery Stream', {
 See: [Data Transformation](https://docs.aws.amazon.com/firehose/latest/dev/data-transformation.html)
 in the *Amazon Data Firehose Developer Guide*.
 
+### Add a new line delimiter when delivering data to Amazon S3
+
+You can specify the `AppendDelimiterToRecordProcessor` built-in processor to add a new line delimiter between records in objects that are delivered to Amazon S3. This can be helpful for parsing objects in Amazon S3.
+For details, see [Use Amazon S3 bucket prefix to deliver data](https://docs.aws.amazon.com/firehose/latest/dev/dynamic-partitioning-s3bucketprefix.html).
+
+```ts
+declare const bucket: s3.Bucket;
+const s3Destination = new firehose.S3Bucket(bucket, {
+  processors: [
+    new firehose.AppendDelimiterToRecordProcessor(),
+  ],
+});
+new firehose.DeliveryStream(this, 'Delivery Stream', {
+  destination: s3Destination,
+});
+```
+
+### Decompress and extract message of CloudWatch Logs
+
+CloudWatch Logs events are sent to Firehose in compressed gzip format. If you want to deliver decompressed log events to Firehose destinations, you can use the `DecompressionProcessor` to automatically decompress CloudWatch Logs.
+For details, see [Send CloudWatch Logs to Firehose](https://docs.aws.amazon.com/firehose/latest/dev/writing-with-cloudwatch-logs.html).
+
+You may also needed to specify `AppendDelimiterToRecordProcessor`
+because decompressed log events record has no trailing newline.
+
+```ts
+declare const bucket: s3.Bucket;
+const s3Destination = new firehose.S3Bucket(bucket, {
+  processors: [
+    new firehose.DecompressionProcessor(),
+    new firehose.AppendDelimiterToRecordProcessor(),
+  ],
+});
+new firehose.DeliveryStream(this, 'Delivery Stream', {
+  destination: s3Destination,
+});
+```
+
+When you enable decompression, you have the option to also enable message extraction. When using message extraction, Firehose filters out all metadata, such as owner, loggroup, logstream, and others from the decompressed CloudWatch Logs records and delivers only the content inside the message fields.
+
+```ts
+declare const bucket: s3.Bucket;
+const s3Destination = new firehose.S3Bucket(bucket, {
+  processors: [
+    new firehose.DecompressionProcessor(),
+    new firehose.CloudWatchLogProcessor({ dataMessageExtraction: true }),
+  ],
+});
+new firehose.DeliveryStream(this, 'Delivery Stream', {
+  destination: s3Destination,
+});
+```
+
+
 ## Specifying an IAM role
 
 The DeliveryStream class automatically creates IAM service roles with all the minimum

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-kinesisfirehose/integ.cloudwatch-logs-processors.ts

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+import * as path from 'path';
+import * as firehose from 'aws-cdk-lib/aws-kinesisfirehose';
+import * as lambdanodejs from 'aws-cdk-lib/aws-lambda-nodejs';
+import * as s3 from 'aws-cdk-lib/aws-s3';
+import * as cdk from 'aws-cdk-lib';
+import { IntegTest } from '@aws-cdk/integ-tests-alpha';
+
+const app = new cdk.App();
+
+const stack = new cdk.Stack(app, 'firehose-delivery-stream-cloudwatch-logs-processors');
+
+const bucket = new s3.Bucket(stack, 'DestinationBucket', {
+  removalPolicy: cdk.RemovalPolicy.DESTROY,
+  autoDeleteObjects: true,
+});
+
+const dataProcessorFunction = new lambdanodejs.NodejsFunction(stack, 'DataProcessorFunction', {
+  entry: path.join(__dirname, 'lambda-data-processor.js'),
+  timeout: cdk.Duration.minutes(1),
+});
+
+new firehose.DeliveryStream(stack, 'DecompressCloudWatchLogsEntry', {
+  destination: new firehose.S3Bucket(bucket, {
+    processors: [
+      new firehose.DecompressionProcessor(),
+      new firehose.AppendDelimiterToRecordProcessor(),
+      new firehose.LambdaFunctionProcessor(dataProcessorFunction),
+    ],
+  }),
+});
+
+new firehose.DeliveryStream(stack, 'ExtractCloudWatchLogsEntry', {
+  destination: new firehose.S3Bucket(bucket, {
+    processors: [
+      new firehose.DecompressionProcessor(),
+      new firehose.CloudWatchLogProcessor({ dataMessageExtraction: true }),
+      new firehose.LambdaFunctionProcessor(dataProcessorFunction),
+    ],
+  }),
+});
+
+new IntegTest(app, 'integ-tests', {
+  testCases: [stack],
+});

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-lambda/integ.runtime.fromasset.ts

@@ -10,20 +10,35 @@ const app = new App({
 });
 const stack = new Stack(app, 'aws-cdk-lambda-runtime-fromasset');
 
-const lambdaFunction = new Function(stack, 'MyFunction', {
+const lambdaFunctionJava21 = new Function(stack, 'MyFunctionJava21', {
   runtime: Runtime.JAVA_21,
   handler: 'com.mycompany.app.LambdaMethodHandler::handleRequest',
   code: Code.fromAsset(path.join(__dirname, 'my-app-1.0-SNAPSHOT.zip')),
 });
 
+const lambdaFunctionJava25 = new Function(stack, 'MyFunctionJava25', {
+  runtime: Runtime.JAVA_25,
+  handler: 'com.mycompany.app.LambdaMethodHandler::handleRequest',
+  code: Code.fromAsset(path.join(__dirname, 'my-app-1.0-SNAPSHOT.zip')),
+});
+
 const integTest = new integ.IntegTest(app, 'Integ', { testCases: [stack] });
 
-const invoke = integTest.assertions.invokeFunction({
-  functionName: lambdaFunction.functionName,
+const invokeJava21 = integTest.assertions.invokeFunction({
+  functionName: lambdaFunctionJava21.functionName,
+  payload: '123',
+});
+
+invokeJava21.expect(integ.ExpectedResult.objectLike({
+  Payload: '"123"',
+}));
+
+const invokeJava25 = integTest.assertions.invokeFunction({
+  functionName: lambdaFunctionJava25.functionName,
   payload: '123',
 });
 
-invoke.expect(integ.ExpectedResult.objectLike({
+invokeJava25.expect(integ.ExpectedResult.objectLike({
   Payload: '"123"',
 }));
 

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-lambda/integ.runtime.inlinecode.ts

@@ -55,6 +55,13 @@ const python313 = new Function(stack, 'PYTHON_3_13', {
 });
 new CfnOutput(stack, 'PYTHON_3_13-functionName', { value: python313.functionName });
 
+const python314 = new Function(stack, 'PYTHON_3_14', {
+  code: new InlineCode('def handler(event, context):\n  return "success"'),
+  handler: 'index.handler',
+  runtime: Runtime.PYTHON_3_14,
+});
+new CfnOutput(stack, 'PYTHON_3_14-functionName', { value: python314.functionName });
+
 const node20xfn = new Function(stack, 'NODEJS_20_X', {
   code: new InlineCode('exports.handler = async function(event) { return "success" }'),
   handler: 'index.handler',

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/cx-api/FEATURE_FLAGS.md

@@ -38,7 +38,7 @@ Flags come in three types:
 | [@aws-cdk/core:enablePartitionLiterals](#aws-cdkcoreenablepartitionliterals) | Make ARNs concrete if AWS partition is known | 2.38.0 | fix |
 | [@aws-cdk/aws-ecs:disableExplicitDeploymentControllerForCircuitBreaker](#aws-cdkaws-ecsdisableexplicitdeploymentcontrollerforcircuitbreaker) | Avoid setting the "ECS" deployment controller when adding a circuit breaker | 2.51.0 | fix |
 | [@aws-cdk/aws-events:eventsTargetQueueSameAccount](#aws-cdkaws-eventseventstargetqueuesameaccount) | Event Rules may only push to encrypted SQS queues in the same account | 2.51.0 | fix |
-| [@aws-cdk/aws-iam:importedRoleStackSafeDefaultPolicyName](#aws-cdkaws-iamimportedrolestacksafedefaultpolicyname) | Enable this feature to by default create default policy names for imported roles that depend on the stack the role is in. | 2.60.0 | fix |
+| [@aws-cdk/aws-iam:importedRoleStackSafeDefaultPolicyName](#aws-cdkaws-iamimportedrolestacksafedefaultpolicyname) | Enable this feature to create default policy names for imported roles that depend on the stack the role is in. | 2.60.0 | fix |
 | [@aws-cdk/aws-s3:serverAccessLogsUseBucketPolicy](#aws-cdkaws-s3serveraccesslogsusebucketpolicy) | Use S3 Bucket Policy instead of ACLs for Server Access Logging | 2.60.0 | fix |
 | [@aws-cdk/customresources:installLatestAwsSdkDefault](#aws-cdkcustomresourcesinstalllatestawssdkdefault) | Whether to install the latest SDK by default in AwsCustomResource | 2.60.0 | new default |
 | [@aws-cdk/aws-route53-patters:useCertificate](#aws-cdkaws-route53-pattersusecertificate) | Use the official `Certificate` resource instead of `DnsValidatedCertificate` | 2.61.0 | new default |
@@ -879,7 +879,7 @@ always apply, regardless of the value of this flag.
 
 ### @aws-cdk/aws-iam:importedRoleStackSafeDefaultPolicyName
 
-*Enable this feature to by default create default policy names for imported roles that depend on the stack the role is in.*
+*Enable this feature to create default policy names for imported roles that depend on the stack the role is in.*
 
 Flag type: Backwards incompatible bugfix
 
@@ -902,7 +902,7 @@ This new implementation creates default policy names based on the constructs nod
 
 Flag type: Backwards incompatible bugfix
 
-Enable this feature flag to use S3 Bucket Policy for granting permission fo Server Access Logging
+Enable this feature flag to use S3 Bucket Policy for granting permission for Server Access Logging
 rather than using the canned `LogDeliveryWrite` ACL. ACLs do not work when Object Ownership is
 enabled on the bucket.
 
@@ -1282,7 +1282,7 @@ Set this flag to false for existing mount targets.
 Flag type: New default behavior
 
 If this is set, and a `runtime` prop is not passed to, Lambda NodeJs
-functions will us the latest version of the runtime provided by the Lambda
+functions will use the latest version of the runtime provided by the Lambda
 service. Do not use this if you your lambda function is reliant on dependencies
 shipped as part of the runtime environment.
 
@@ -1504,7 +1504,7 @@ When this feature flag is disabled, it will keep the root account principal in t
 
 Flag type: New default behavior
 
-When this featuer flag is enabled, remove the default deployment alarm settings when creating a AWS ECS service.
+When this feature flag is enabled, remove the default deployment alarm settings when creating a AWS ECS service.
 
 
 | Since | Unset behaves like | Recommended value |
@@ -1755,8 +1755,8 @@ the latest Amazon Linux 2023 version will be used instead of Amazon Linux 2.
 
 Flag type: Configuration option
 
-Currently, when Aspects are invoked in one single pass of the construct tree.
-This means that the Aspects that create other Aspects are not run and Aspects that create new nodes of the tree sometimes do not inherit their parent Aspects.
+Previously, Aspects were invoked in a single pass of the construct tree.
+This meant that Aspects which created other Aspects were not run, and Aspects that created new nodes in the tree sometimes did not inherit their parent Aspects.
 
 When this feature flag is enabled, a stabilization loop is run to recurse the construct tree multiple times when invoking Aspects.
 
@@ -1995,7 +1995,7 @@ When enabled, table replica will be default to the removal policy of source tabl
 
 Flag type: New default behavior
 
-When this feature flag is enabled, the SDK API call response to desribe user pool client values will be logged in the custom
+When this feature flag is enabled, the SDK API call response to describe user pool client values will be logged in the custom
 resource lambda function logs.
 
 When this feature flag is disabled, the SDK API call response to describe user pool client values will not be logged in the custom
@@ -2174,7 +2174,7 @@ When this feature flag is disabled, a loggroup is created by Lambda service on f
 of the function (existing behavior).
 LogGroups created in this way do not support Tag propagation, Property Injectors, Aspects.
 
-DO NOT ENABLE: If you have and existing app defining a lambda function and
+DO NOT ENABLE: If you have an existing app defining a lambda function and
 have not supplied a logGroup or logRetention prop and your lambda function has
 executed at least once, the logGroup has been already created with the same name
 so your deployment will start failing.

{konokenj_cdk_api_mcp_server-0.51.0.dist-info → konokenj_cdk_api_mcp_server-0.52.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: konokenj.cdk-api-mcp-server
-Version: 0.51.0
+Version: 0.52.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.221.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.221.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.51.0.dist-info → konokenj_cdk_api_mcp_server-0.52.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-cdk_api_mcp_server/__about__.py,sha256=wlgAQ3B3wATW8z6aaZQmTw1D4VHqQBjNiASXyYu9Qdg,129
+cdk_api_mcp_server/__about__.py,sha256=mXNeCDlpNGyOG90CmfYPJyxHV9MLXOYUnV499VqChXg,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=Guco4NsWQmSm05TrYD55t6BnL1dugOUwH_ZHmt6b14o,35627
+cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/aws-bedrock-agentcore-alpha/README.md,sha256=M0QhroHDCU8PC2XPNa7PncJtVZYgyhjpBnk47uTc_PM,50954
 cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/aws-bedrock-alpha/README.md,sha256=o4IpchOHFzGdZdeX9WPIfFyHAs98uLKIkfSlBOgygB0,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
@@ -51,7 +51,7 @@ cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/assertions/MIGRATING
 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=Qujd0YE8WYrmfumuPTDu-7jBzeClGEZjxLIJhNtEVgo,64739
+cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigateway/README.md,sha256=S67azcCiKHOcF-DeqRp64IadOWEp8E2arsXicUrwaZg,65012
 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
@@ -84,7 +84,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.vpc-endpoint.ts,sha256=LFlUv9sQ_r16-MFhlV3e9Eaa3o4tXMm2fT6S71CBuS0,4773
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigateway/integ.spec-restapi-endpointconfiguration.ts,sha256=vfv45uUMBA7XEWlx8YnOKVAU7pXfbO6fwx5-8JK26k4,854
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigateway/integ.spec-restapi.import-deploymentstage.ts,sha256=01s3ckwgTqJ4t3gLOqPJBY4BldUInsweHqnYBwT1mkI,1832
-cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigateway/integ.spec-restapi.ts,sha256=WQWL6yv6Fe-uhuYmmp_Wg0Cu-jVL7CozWpKGeh2KyMg,2931
+cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigateway/integ.spec-restapi.ts,sha256=Uy1rPsiVrMk8zi2uQgAYebYOeIBVisR144XH61Dg1Ow,2989
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigateway/integ.stepfunctions-api-without-default-method-responses.ts,sha256=v8gyEaURYiP57S-QNK_bbDVEcE6wENE3f_JNtYZ3YEM,1120
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigateway/integ.stepfunctions-api.ts,sha256=GXMRMzXZRfTLrWsevPgHA3UVvcsu1pveggQrSXrrQB0,1611
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigateway/integ.stepfunctions-startexecution-without-default-method-responses.ts,sha256=z2UYWbUpbDoLHKexifR_AtRQLwh-ge7dCXjWKfYJAbU,1250
@@ -93,13 +93,13 @@ 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.token-authorizer.ts,sha256=aSoN0khMwpURVvR7U2fUsjJOubZ_zUhG8b2rgkjSp2M,3597
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigateway/integ.usage-plan.multikey.ts,sha256=9njyhYXRAQr-yHR4zvG0CYKS0MXHSoq4bJwZDWa_bAM,556
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigateway/integ.usage-plan.sharing.ts,sha256=_SSf6j8I-B4neywqtUikOWwvfoTU2Ph9IlDnuJllsbY,998
-cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigatewayv2/README.md,sha256=2cq_39qk6-6puyrQfFw1KChuI6pWBunohD4C4ZS94hY,30482
+cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigatewayv2/README.md,sha256=5mttUnkn8o4nT0AHbWTkUMPYCWjn-KZduGdHGoUp0sA,30876
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigatewayv2/integ.api-apikey.ts,sha256=_hI2T1TIom2UmrXqX9oWSkFLb0QNPAuIb3d-wR2YmpY,370
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigatewayv2/integ.api-domain-name.ts,sha256=il_sIMzx1KgsYstJrcxz2XYVq8DlpTj8oViQX_PLiDk,1960
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigatewayv2/integ.api-dualstack.ts,sha256=BFbAzMWIdS5w4Bcp30Ow9YSRo8qJWhL18w9PQo4U6rU,440
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigatewayv2/integ.api-grant-invoke.ts,sha256=oleJiGqC5-cJWoEIIJlvpqnIc3_QsKZ5JP3GbIYuTDI,996
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigatewayv2/integ.api.ts,sha256=2zmU04diShE0ZSMqI1PFMJ7K0zMJC7tQbxb6uKqw7GQ,467
-cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigatewayv2/integ.stage.ts,sha256=g3YJqt3ZJ2EG7XsDZk6IXZWkH8sbUyYOoDyU4RPzma8,513
+cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigatewayv2/integ.stage.ts,sha256=mXQcGHJu13586Pr7hYJqmxPwgYInxjB0CdCXzpRjfSI,1158
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigatewayv2/integ.usage-plan.ts,sha256=J3kLq2yD4lKR7y3B6XZjtIUxEmbGS6HhrKei6EtaNR8,1956
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigatewayv2-authorizers/README.md,sha256=O5FyfQtU2qhYokDH9MZbgFejKz7zD6UTwSeX1pcLky4,13049
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigatewayv2-authorizers/integ.iam.ts,sha256=lvRtxBcfeAd_hWzp4y2XjUrBaXvrTvTlbenZPrTVjm4,1879
@@ -852,12 +852,12 @@ cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-iam/integ.emr-se
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-iam/integ.group.ts,sha256=tw9TZ4VV3uxWgGEFN4vINTKWzom4aTl--MkHWUNVXdw,391
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-iam/integ.imported-role.ts,sha256=lGWDhl9-f-nZMIyq7OrrtxZMm6hQOP8BlqNiTdg0Keo,4176
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-iam/integ.instance-profile.ts,sha256=zdje2SHsI17PneKfh4VhyH8Qv8ex-DbtBx_ERff_sys,2639
-cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-iam/integ.managed-policy.ts,sha256=t73GOq34_J4vY1soKkQEkUUUy5YXzLC376SQp4pFaeM,1425
+cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-iam/integ.managed-policy.ts,sha256=HK8gTSkky_2vXZzwrkbBw4DDKbcEHNwSIl5ZJOOF9ic,1785
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-iam/integ.oidc-provider-native.ts,sha256=l0nWLnBj6FN-MBkN4GNSUO8vzQ-JwUNC7ydp5WOVxP0,2929
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-iam/integ.oidc-provider-reject-unauthorized-connection.ts,sha256=ughh-eQ4rp5sIzleHsSm0Mu8ljtBSp_9VmQui_Vd8A0,1352
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-iam/integ.oidc-provider.ts,sha256=yZ-WuAZ-hbU2ZNgzmo8e4OTAiMWE1E9_O6HGMl-qxrc,1353
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-iam/integ.permissions-boundary.ts,sha256=PeVW04PoiCNfWw_xTU8haQP8hvfGQfMiNmDYDX96s48,1158
-cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-iam/integ.policy.ts,sha256=LHD7zreR3geN4Wzh87-wZU1A76vv0b61mnlsctUrKnc,970
+cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-iam/integ.policy.ts,sha256=RcgVccJYBEk_ANRG4hg36GgX_dMPgyHgx7J-PfY7q9A,1330
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-iam/integ.principal-with-conditions-and-tags.ts,sha256=ffBh_rhJk2OuOQf8YBc7FNuPtJiFdBpI-C1sWMxGKOM,601
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-iam/integ.principal-with-conditions.ts,sha256=msH-LQ67sOzATp4ntUIe9MMEqnci7NbafSPT2ae0ugI,692
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-iam/integ.role-from-lookup.ts,sha256=hFroyd3A_FJLNKQaofCh-0AfTFcoxWr_K0Hts5qSWYg,1199
@@ -873,7 +873,8 @@ cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-kinesis/integ.st
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-kinesis/integ.stream-dashboard.ts,sha256=ziOjkJ5WfaTPiVw7S1oqqEzzmZSl6h69OyMSSdsXh98,2804
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-kinesis/integ.stream-shard-level-monitoring.ts,sha256=Psd698h-ewAaGqb71sUNrgyT77G6KdjSZ_9IMQLnGBM,1540
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-kinesis/integ.stream.ts,sha256=kj0fTRhyXUG8TjWbsY1klNyJzw2AZdUfVmIWuXWCzJQ,388
-cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-kinesisfirehose/README.md,sha256=PIucvVY-WMEZT57tPjsHaOBTJcXhpPlbtv0htzIttBE,27030
+cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-kinesisfirehose/README.md,sha256=3idOvjiFb9T2ZzrduZgC6KfK2b9khzdlZQmFe2t68gg,29262
+cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-kinesisfirehose/integ.cloudwatch-logs-processors.ts,sha256=YOwbVzeZfG6YxifQ01Q1JNbsC31uEsBQngo05wlw3Vk,1478
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-kinesisfirehose/integ.delivery-stream.source-stream.ts,sha256=gTQNvpVUsP-IGMdMCC5SozS_GhRI_MxAo9eCuZpZbII,2235
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-kinesisfirehose/integ.delivery-stream.ts,sha256=DXJlTu1eJOs7bFW35Tl-JCan6Eg1dUJMom6PU0mFTB8,1490
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-kinesisfirehose/integ.kinesis-stream-events-target.ts,sha256=bLE3v9K0_V2KbR5oTGiePpoLOo_bpjkloqF3eNcKBOQ,2138
@@ -925,8 +926,8 @@ cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-lambda/integ.par
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-lambda/integ.permissions.ts,sha256=cPipX4JdqILlhfxMhVX1B5w4RmYPzMS97dOvXaluOM8,1221
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-lambda/integ.ruby.file.ts,sha256=aA4DuzLNaZcRFHt0fGUDieOXSBAgqn8CPnftmDR4cP0,2181
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-lambda/integ.runtime-management.ts,sha256=oPksgNlqMPQYpoSLzjsI1b1OJZWP_lXutvnDCoXHvOQ,644
-cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-lambda/integ.runtime.fromasset.ts,sha256=hYRcigdNsYxWLPWeOvaGYZfAlgQQZT7uOcKRnpcTKUM,1265
-cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-lambda/integ.runtime.inlinecode.ts,sha256=57v7Kxw4xhLKMBpR9Ds7H_4i_NjwMDNrcsX-_NobMa4,2995
+cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-lambda/integ.runtime.fromasset.ts,sha256=-GOWBQKCspzWUJ0xSQB1RUXPxhON5PS1MsxEEhJOuDk,1752
+cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-lambda/integ.runtime.inlinecode.ts,sha256=PHy4_9lhdB9PgDHCaWQrXsp4TpIA18oqRs_86o63wPA,3276
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-lambda/integ.runtimes.ts,sha256=DUCnYFjTvBe5NJzDfR0chtlWkKVVwzEjvbjG7JoyPNU,550
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-lambda/integ.vpc-lambda.ts,sha256=omZiVvKZ_W8vrHENnIyFGCnMq4GZWBb5k2dEb62B8z4,585
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-lambda-destinations/README.md,sha256=_6ZqM3kbkZCmN-9BtU3FbERs82Shv4D2QiWuq47T_VI,5453
@@ -1404,7 +1405,7 @@ cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/custom-resources/int
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/custom-resources/integ.provider-with-waiter-state-machine-custom-role.ts,sha256=60mjzf_2NI9zO30B2Guye5sA7kxIl4yrLMXUEWIDO9I,2401
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/custom-resources/integ.provider-with-waiter-state-machine.ts,sha256=6Ci2_ABcu5azSj1f0EzY1VD4lQUg9KI5l1Q7ieejI-0,2058
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/custom-resources/integ.provider.ts,sha256=u_YVV0YZk6hyIxo5JOOSwwUORbqS3BVbJU6DIAwxuk0,1814
-cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/cx-api/FEATURE_FLAGS.md,sha256=dHJMOjPOzD5lNAQjTiy4fTv0vG3XmzSPL9dVyo-MwC0,111533
+cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/cx-api/FEATURE_FLAGS.md,sha256=zNUPoE55jlVtneLyvwQ0bTLsEIwb1D-TczICRuYVrdw,111510
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/cx-api/NESTED_ASSEMBLIES.md,sha256=P8PNyr4hIC_i-9aUxa301-5-N4tLcoHYnELBp3C6SQQ,4949
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/cx-api/README.md,sha256=4Gvb735iDvpcWvocmAezGrwcia_LIhv4j6rS6_nFKeE,27422
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/lambda-layer-awscli/README.md,sha256=kMrrptXZcAiK_TXRQD4XcaNRa3RXaIoIUQRZYi29b30,681
@@ -1435,8 +1436,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=4OHplMoBOgHGkktAzoU-TuNmJQS5wGAUvBfj5bGSe_Y,2807
-konokenj_cdk_api_mcp_server-0.51.0.dist-info/METADATA,sha256=fsIE1V36P5u1agmMVTotX_jp5_Bq19lOxNu7w2URyak,2646
-konokenj_cdk_api_mcp_server-0.51.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-konokenj_cdk_api_mcp_server-0.51.0.dist-info/entry_points.txt,sha256=bVDhMdyCC1WNMPOMbmB82jvWII2CIrwTZDygdCf0cYQ,79
-konokenj_cdk_api_mcp_server-0.51.0.dist-info/licenses/LICENSE.txt,sha256=5OIAASeg1HM22mVZ1enz9bgZ7TlsGfWXnj02P9OgFyk,1098
-konokenj_cdk_api_mcp_server-0.51.0.dist-info/RECORD,,
+konokenj_cdk_api_mcp_server-0.52.0.dist-info/METADATA,sha256=-fYByqNkuYaOzZKR4PJyTI8msORwFNgP38nY1Q00tc4,2646
+konokenj_cdk_api_mcp_server-0.52.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+konokenj_cdk_api_mcp_server-0.52.0.dist-info/entry_points.txt,sha256=bVDhMdyCC1WNMPOMbmB82jvWII2CIrwTZDygdCf0cYQ,79
+konokenj_cdk_api_mcp_server-0.52.0.dist-info/licenses/LICENSE.txt,sha256=5OIAASeg1HM22mVZ1enz9bgZ7TlsGfWXnj02P9OgFyk,1098
+konokenj_cdk_api_mcp_server-0.52.0.dist-info/RECORD,,