@cdklabs/cdk-appmod-catalog-blueprints 1.4.1 → 1.6.0

package/lib/document-processing/bedrock-document-processing.js

@@ -11,6 +11,7 @@ const aws_cdk_lib_1 = require("aws-cdk-lib");
 const aws_ec2_1 = require("aws-cdk-lib/aws-ec2");
 const aws_iam_1 = require("aws-cdk-lib/aws-iam");
 const aws_lambda_1 = require("aws-cdk-lib/aws-lambda");
+const aws_stepfunctions_1 = require("aws-cdk-lib/aws-stepfunctions");
 const aws_stepfunctions_tasks_1 = require("aws-cdk-lib/aws-stepfunctions-tasks");
 const base_document_processing_1 = require("./base-document-processing");
 const framework_1 = require("../framework");
@@ -58,9 +59,24 @@ class BedrockDocumentProcessing extends base_document_processing_1.BaseDocumentP
      * @param scope - The scope in which to define this construct
      * @param id - The scoped construct ID. Must be unique within the scope.
      * @param props - Configuration properties for the Bedrock document processing pipeline
+     * @throws Error if chunking configuration is invalid
      */
     constructor(scope, id, props) {
         super(scope, id, props);
+        /** Counter for generating unique classification step IDs */
+        this._classificationStepCounter = 0;
+        /** Counter for generating unique processing step IDs */
+        this._processingStepCounter = 0;
+        /** Counter for generating unique aggregation step IDs */
+        this._aggregationStepCounter = 0;
+        /** Counter for generating unique enrichment step IDs */
+        this._enrichmentStepCounter = 0;
+        /** Counter for generating unique post-processing step IDs */
+        this._postProcessingStepCounter = 0;
+        // Validate chunking configuration if provided
+        if (props.enableChunking && props.chunkingConfig) {
+            this.validateChunkingConfig(props.chunkingConfig);
+        }
         if (props.network) {
             props.network.createServiceEndpoint('vpce-bedrock', aws_ec2_1.InterfaceVpcEndpointAwsService.BEDROCK);
             props.network.createServiceEndpoint('vpce-bedrock-runtime', aws_ec2_1.InterfaceVpcEndpointAwsService.BEDROCK_RUNTIME);
@@ -68,6 +84,77 @@ class BedrockDocumentProcessing extends base_document_processing_1.BaseDocumentP
         this.bedrockDocumentProcessingProps = props;
         this.stateMachine = this.handleStateMachineCreation('bedrock-document-processing-workflow');
     }
+    /**
+     * Validates the chunking configuration parameters.
+     *
+     * Ensures that:
+     * - Chunk size is greater than 0
+     * - Overlap is non-negative and less than chunk size
+     * - Thresholds are greater than 0
+     * - Max concurrency is greater than 0
+     * - Min success threshold is between 0 and 1
+     *
+     * @param config - The chunking configuration to validate
+     * @throws Error if any configuration parameter is invalid
+     */
+    validateChunkingConfig(config) {
+        // Validate chunk size (for fixed-pages strategy)
+        if (config.chunkSize !== undefined) {
+            if (config.chunkSize <= 0) {
+                throw new Error('ChunkingConfig validation error: chunkSize must be greater than 0');
+            }
+        }
+        // Validate overlap pages (for fixed-pages strategy)
+        if (config.overlapPages !== undefined) {
+            if (config.overlapPages < 0) {
+                throw new Error('ChunkingConfig validation error: overlapPages must be non-negative');
+            }
+            const effectiveChunkSize = config.chunkSize || 50; // default chunk size
+            if (config.overlapPages >= effectiveChunkSize) {
+                throw new Error('ChunkingConfig validation error: overlapPages must be less than chunkSize');
+            }
+        }
+        // Validate page threshold
+        if (config.pageThreshold !== undefined && config.pageThreshold <= 0) {
+            throw new Error('ChunkingConfig validation error: pageThreshold must be greater than 0');
+        }
+        // Validate token threshold
+        if (config.tokenThreshold !== undefined && config.tokenThreshold <= 0) {
+            throw new Error('ChunkingConfig validation error: tokenThreshold must be greater than 0');
+        }
+        // Validate max tokens per chunk (for token-based strategy)
+        if (config.maxTokensPerChunk !== undefined && config.maxTokensPerChunk <= 0) {
+            throw new Error('ChunkingConfig validation error: maxTokensPerChunk must be greater than 0');
+        }
+        // Validate overlap tokens (for token-based and hybrid strategies)
+        if (config.overlapTokens !== undefined) {
+            if (config.overlapTokens < 0) {
+                throw new Error('ChunkingConfig validation error: overlapTokens must be non-negative');
+            }
+            const effectiveMaxTokens = config.maxTokensPerChunk || 100000; // default max tokens
+            if (config.overlapTokens >= effectiveMaxTokens) {
+                throw new Error('ChunkingConfig validation error: overlapTokens must be less than maxTokensPerChunk');
+            }
+        }
+        // Validate max pages per chunk (for hybrid strategy)
+        if (config.maxPagesPerChunk !== undefined && config.maxPagesPerChunk <= 0) {
+            throw new Error('ChunkingConfig validation error: maxPagesPerChunk must be greater than 0');
+        }
+        // Validate target tokens per chunk (for hybrid strategy)
+        if (config.targetTokensPerChunk !== undefined && config.targetTokensPerChunk <= 0) {
+            throw new Error('ChunkingConfig validation error: targetTokensPerChunk must be greater than 0');
+        }
+        // Validate max concurrency
+        if (config.maxConcurrency !== undefined && config.maxConcurrency <= 0) {
+            throw new Error('ChunkingConfig validation error: maxConcurrency must be greater than 0');
+        }
+        // Validate min success threshold
+        if (config.minSuccessThreshold !== undefined) {
+            if (config.minSuccessThreshold < 0 || config.minSuccessThreshold > 1) {
+                throw new Error('ChunkingConfig validation error: minSuccessThreshold must be between 0 and 1');
+            }
+        }
+    }
     /**
      * Implements the document classification step using Amazon Bedrock.
      *
@@ -75,47 +162,60 @@ class BedrockDocumentProcessing extends base_document_processing_1.BaseDocumentP
      * the document type. The function reads the document from S3 and sends it to
      * Bedrock with the classification prompt.
      *
+     * This method caches the Lambda function to avoid creating duplicate resources,
+     * but creates a new LambdaInvoke task each time to allow proper state chaining.
+     *
      * @returns LambdaInvoke task configured for document classification
      */
     classificationStep() {
-        const prompt = this.bedrockDocumentProcessingProps.classificationPrompt || BedrockDocumentProcessing.DEFAULT_CLASSIFICATION_PROMPT;
-        const adjustedModelId = bedrock_1.BedrockModelUtils.deriveActualModelId(this.bedrockDocumentProcessingProps.classificationBedrockModel);
-        const role = this.generateLambdaRoleForBedrock('ClassificationLambdaRole', this.bedrockDocumentProcessingProps.classificationBedrockModel);
-        const { region, account } = aws_cdk_lib_1.Stack.of(this);
-        const generatedLogPermissions = utilities_1.LambdaIamUtils.createLogsPermissions({
-            account,
-            functionName: 'bedrock-idp-classification',
-            region,
-            scope: this,
-            enableObservability: this.bedrockDocumentProcessingProps.enableObservability,
-        });
-        this.encryptionKey.grantEncryptDecrypt(role);
-        const bedrockFunction = new aws_lambda_python_alpha_1.PythonFunction(this, 'BedrockClassificationFunction', {
-            functionName: generatedLogPermissions.uniqueFunctionName,
-            architecture: aws_lambda_1.Architecture.X86_64,
-            runtime: framework_1.DefaultRuntimes.PYTHON,
-            entry: path.join(__dirname, 'resources/default-bedrock-invoke'),
-            role,
-            memorySize: 512,
-            timeout: this.bedrockDocumentProcessingProps.stepTimeouts || aws_cdk_lib_1.Duration.minutes(5),
-            environment: {
-                MODEL_ID: adjustedModelId,
-                PROMPT: prompt,
-                INVOKE_TYPE: 'classification',
-                ...powertools_config_1.PowertoolsConfig.generateDefaultLambdaConfig(this.bedrockDocumentProcessingProps.enableObservability, this.metricNamespace, this.metricServiceName),
-            },
-            environmentEncryption: this.encryptionKey,
-            vpc: this.bedrockDocumentProcessingProps.network ? this.bedrockDocumentProcessingProps.network.vpc : undefined,
-            vpcSubnets: this.bedrockDocumentProcessingProps.network ? this.bedrockDocumentProcessingProps.network.applicationSubnetSelection() : undefined,
-        });
-        for (const statement of generatedLogPermissions.policyStatements) {
-            bedrockFunction.role?.addToPrincipalPolicy(statement);
-        }
-        if (this.bedrockDocumentProcessingProps.network) {
-            bedrockFunction.role?.addToPrincipalPolicy(utilities_1.LambdaIamUtils.generateLambdaVPCPermissions());
+        // Create Lambda function only once
+        if (!this._classificationFunction) {
+            const prompt = this.bedrockDocumentProcessingProps.classificationPrompt || BedrockDocumentProcessing.DEFAULT_CLASSIFICATION_PROMPT;
+            const adjustedModelId = bedrock_1.BedrockModelUtils.deriveActualModelId(this.bedrockDocumentProcessingProps.classificationBedrockModel);
+            const role = this.generateLambdaRoleForBedrock('ClassificationLambdaRole', this.bedrockDocumentProcessingProps.classificationBedrockModel);
+            const { region, account } = aws_cdk_lib_1.Stack.of(this);
+            const generatedLogPermissions = utilities_1.LambdaIamUtils.createLogsPermissions({
+                account,
+                functionName: 'bedrock-idp-classification',
+                region,
+                scope: this,
+                enableObservability: this.bedrockDocumentProcessingProps.enableObservability,
+            });
+            this.encryptionKey.grantEncryptDecrypt(role);
+            this._classificationFunction = new aws_lambda_python_alpha_1.PythonFunction(this, 'BedrockClassificationFunction', {
+                functionName: generatedLogPermissions.uniqueFunctionName,
+                architecture: aws_lambda_1.Architecture.X86_64,
+                runtime: framework_1.DefaultRuntimes.PYTHON,
+                entry: path.join(__dirname, 'resources/default-bedrock-invoke'),
+                role,
+                memorySize: 512,
+                timeout: this.bedrockDocumentProcessingProps.stepTimeouts || aws_cdk_lib_1.Duration.minutes(5),
+                environment: {
+                    MODEL_ID: adjustedModelId,
+                    PROMPT: prompt,
+                    INVOKE_TYPE: 'classification',
+                    ...powertools_config_1.PowertoolsConfig.generateDefaultLambdaConfig(this.bedrockDocumentProcessingProps.enableObservability, this.metricNamespace, this.metricServiceName),
+                },
+                environmentEncryption: this.encryptionKey,
+                vpc: this.bedrockDocumentProcessingProps.network
+                    ? this.bedrockDocumentProcessingProps.network.vpc
+                    : undefined,
+                vpcSubnets: this.bedrockDocumentProcessingProps.network
+                    ? this.bedrockDocumentProcessingProps.network.applicationSubnetSelection()
+                    : undefined,
+            });
+            for (const statement of generatedLogPermissions.policyStatements) {
+                this._classificationFunction.role?.addToPrincipalPolicy(statement);
+            }
+            if (this.bedrockDocumentProcessingProps.network) {
+                this._classificationFunction.role?.addToPrincipalPolicy(utilities_1.LambdaIamUtils.generateLambdaVPCPermissions());
+            }
         }
-        return new aws_stepfunctions_tasks_1.LambdaInvoke(this, 'ClassificationStep', {
-            lambdaFunction: bedrockFunction,
+        // Always create a new LambdaInvoke task to allow proper state chaining
+        const stepId = `ClassificationStep-${this._classificationStepCounter}`;
+        this._classificationStepCounter++;
+        return new aws_stepfunctions_tasks_1.LambdaInvoke(this, stepId, {
+            lambdaFunction: this._classificationFunction,
             resultPath: '$.classificationResult',
             resultSelector: {
                 'documentClassification.$': '$.Payload.documentClassification',
@@ -129,46 +229,59 @@ class BedrockDocumentProcessing extends base_document_processing_1.BaseDocumentP
      * structured data from the document. Uses the classification result from the
      * previous step to provide context for more accurate extraction.
      *
+     * This method caches the Lambda function to avoid creating duplicate resources,
+     * but creates a new LambdaInvoke task each time to allow proper state chaining.
+     *
      * @returns LambdaInvoke task configured for document extraction
      */
     processingStep() {
-        const prompt = this.bedrockDocumentProcessingProps.processingPrompt || BedrockDocumentProcessing.DEFAULT_PROCESSING_PROMPT;
-        const adjustedModelId = bedrock_1.BedrockModelUtils.deriveActualModelId(this.bedrockDocumentProcessingProps.processingBedrockModel);
-        const role = this.generateLambdaRoleForBedrock('ProcessingLambdaRole', this.bedrockDocumentProcessingProps.processingBedrockModel);
-        const { region, account } = aws_cdk_lib_1.Stack.of(this);
-        const generatedLogPermissions = utilities_1.LambdaIamUtils.createLogsPermissions({
-            account,
-            functionName: 'bedrock-idp-processing',
-            region,
-            scope: this,
-        });
-        this.encryptionKey.grantEncryptDecrypt(role);
-        const bedrockFunction = new aws_lambda_python_alpha_1.PythonFunction(this, 'BedrockExtractionFunction', {
-            functionName: generatedLogPermissions.uniqueFunctionName,
-            runtime: framework_1.DefaultRuntimes.PYTHON,
-            architecture: aws_lambda_1.Architecture.X86_64,
-            entry: path.join(__dirname, 'resources/default-bedrock-invoke'),
-            role,
-            memorySize: 512,
-            timeout: this.bedrockDocumentProcessingProps.stepTimeouts || aws_cdk_lib_1.Duration.minutes(5),
-            environment: {
-                MODEL_ID: adjustedModelId,
-                PROMPT: prompt,
-                INVOKE_TYPE: 'processing',
-                ...powertools_config_1.PowertoolsConfig.generateDefaultLambdaConfig(this.bedrockDocumentProcessingProps.enableObservability, this.metricNamespace, this.metricServiceName),
-            },
-            environmentEncryption: this.encryptionKey,
-            vpc: this.bedrockDocumentProcessingProps.network ? this.bedrockDocumentProcessingProps.network.vpc : undefined,
-            vpcSubnets: this.bedrockDocumentProcessingProps.network ? this.bedrockDocumentProcessingProps.network.applicationSubnetSelection() : undefined,
-        });
-        for (const statement of generatedLogPermissions.policyStatements) {
-            bedrockFunction.role?.addToPrincipalPolicy(statement);
-        }
-        if (this.bedrockDocumentProcessingProps.network) {
-            bedrockFunction.role?.addToPrincipalPolicy(utilities_1.LambdaIamUtils.generateLambdaVPCPermissions());
+        // Create Lambda function only once
+        if (!this._processingFunction) {
+            const prompt = this.bedrockDocumentProcessingProps.processingPrompt || BedrockDocumentProcessing.DEFAULT_PROCESSING_PROMPT;
+            const adjustedModelId = bedrock_1.BedrockModelUtils.deriveActualModelId(this.bedrockDocumentProcessingProps.processingBedrockModel);
+            const role = this.generateLambdaRoleForBedrock('ProcessingLambdaRole', this.bedrockDocumentProcessingProps.processingBedrockModel);
+            const { region, account } = aws_cdk_lib_1.Stack.of(this);
+            const generatedLogPermissions = utilities_1.LambdaIamUtils.createLogsPermissions({
+                account,
+                functionName: 'bedrock-idp-processing',
+                region,
+                scope: this,
+            });
+            this.encryptionKey.grantEncryptDecrypt(role);
+            this._processingFunction = new aws_lambda_python_alpha_1.PythonFunction(this, 'BedrockExtractionFunction', {
+                functionName: generatedLogPermissions.uniqueFunctionName,
+                runtime: framework_1.DefaultRuntimes.PYTHON,
+                architecture: aws_lambda_1.Architecture.X86_64,
+                entry: path.join(__dirname, 'resources/default-bedrock-invoke'),
+                role,
+                memorySize: 512,
+                timeout: this.bedrockDocumentProcessingProps.stepTimeouts || aws_cdk_lib_1.Duration.minutes(5),
+                environment: {
+                    MODEL_ID: adjustedModelId,
+                    PROMPT: prompt,
+                    INVOKE_TYPE: 'processing',
+                    ...powertools_config_1.PowertoolsConfig.generateDefaultLambdaConfig(this.bedrockDocumentProcessingProps.enableObservability, this.metricNamespace, this.metricServiceName),
+                },
+                environmentEncryption: this.encryptionKey,
+                vpc: this.bedrockDocumentProcessingProps.network
+                    ? this.bedrockDocumentProcessingProps.network.vpc
+                    : undefined,
+                vpcSubnets: this.bedrockDocumentProcessingProps.network
+                    ? this.bedrockDocumentProcessingProps.network.applicationSubnetSelection()
+                    : undefined,
+            });
+            for (const statement of generatedLogPermissions.policyStatements) {
+                this._processingFunction.role?.addToPrincipalPolicy(statement);
+            }
+            if (this.bedrockDocumentProcessingProps.network) {
+                this._processingFunction.role?.addToPrincipalPolicy(utilities_1.LambdaIamUtils.generateLambdaVPCPermissions());
+            }
         }
-        return new aws_stepfunctions_tasks_1.LambdaInvoke(this, 'ProcessingStep', {
-            lambdaFunction: bedrockFunction,
+        // Always create a new LambdaInvoke task to allow proper state chaining
+        const stepId = `ProcessingStep-${this._processingStepCounter}`;
+        this._processingStepCounter++;
+        return new aws_stepfunctions_tasks_1.LambdaInvoke(this, stepId, {
+            lambdaFunction: this._processingFunction,
             resultPath: '$.processingResult',
             resultSelector: {
                 'documentClassification.$': '$.Payload.documentClassification',
@@ -182,6 +295,7 @@ class BedrockDocumentProcessing extends base_document_processing_1.BaseDocumentP
             inlinePolicies: {
                 BedrockInvokePolicy: new aws_iam_1.PolicyDocument({
                     statements: [
+                        // S3 read-only access for document retrieval - least privilege
                         ...this.ingressAdapter.generateAdapterIAMPolicies(),
                         bedrock_1.BedrockModelUtils.generateModelIAMPermissions(this, model),
                     ],
@@ -202,9 +316,13 @@ class BedrockDocumentProcessing extends base_document_processing_1.BaseDocumentP
         if (!this.bedrockDocumentProcessingProps.enrichmentLambdaFunction) {
             return undefined;
         }
-        return new aws_stepfunctions_tasks_1.LambdaInvoke(this, 'EnrichmentStep', {
+        const stepId = `EnrichmentStep-${this._enrichmentStepCounter}`;
+        this._enrichmentStepCounter++;
+        return new aws_stepfunctions_tasks_1.LambdaInvoke(this, stepId, {
             lambdaFunction: this.bedrockDocumentProcessingProps.enrichmentLambdaFunction,
             resultPath: '$.enrichedResult',
+            outputPath: '$',
+            payloadResponseOnly: true,
         });
     }
     /**
@@ -220,15 +338,515 @@ class BedrockDocumentProcessing extends base_document_processing_1.BaseDocumentP
         if (!this.bedrockDocumentProcessingProps.postProcessingLambdaFunction) {
             return undefined;
         }
-        return new aws_stepfunctions_tasks_1.LambdaInvoke(this, 'PostProcessingStep', {
+        const stepId = `PostProcessingStep-${this._postProcessingStepCounter}`;
+        this._postProcessingStepCounter++;
+        return new aws_stepfunctions_tasks_1.LambdaInvoke(this, stepId, {
             lambdaFunction: this.bedrockDocumentProcessingProps.postProcessingLambdaFunction,
             resultPath: '$.postProcessedResult',
+            outputPath: '$',
+            payloadResponseOnly: true,
         });
     }
+    /**
+     * Implements the optional preprocessing step for PDF chunking.
+     *
+     * When chunking is enabled, creates a Lambda function that analyzes PDFs and
+     * splits large documents into manageable chunks. The function:
+     * 1. Analyzes the PDF to determine page count and token estimates
+     * 2. Decides if chunking is needed based on configured thresholds
+     * 3. If chunking is needed, splits the PDF and uploads chunks to S3
+     *
+     * @returns LambdaInvoke task for PDF analysis and chunking, or undefined if chunking is disabled
+     */
+    preprocessingStep() {
+        // Only enable chunking if explicitly configured
+        if (!this.bedrockDocumentProcessingProps.enableChunking) {
+            return undefined;
+        }
+        const { region, account } = aws_cdk_lib_1.Stack.of(this);
+        const chunkingConfig = this.bedrockDocumentProcessingProps.chunkingConfig || {};
+        // Create IAM role for chunking Lambda with least privilege permissions
+        // Chunking Lambda needs: GetObject (read raw PDFs), PutObject (write chunks)
+        const role = new aws_iam_1.Role(this, 'ChunkingLambdaRole', {
+            assumedBy: new aws_iam_1.ServicePrincipal('lambda.amazonaws.com'),
+            inlinePolicies: {
+                ChunkingPolicy: new aws_iam_1.PolicyDocument({
+                    statements: [
+                        ...this.ingressAdapter.generateAdapterIAMPolicies(),
+                    ],
+                }),
+            },
+        });
+        const generatedLogPermissions = utilities_1.LambdaIamUtils.createLogsPermissions({
+            account,
+            functionName: 'bedrock-idp-chunking',
+            region,
+            scope: this,
+            enableObservability: this.bedrockDocumentProcessingProps.enableObservability,
+        });
+        this.encryptionKey.grantEncryptDecrypt(role);
+        // Create PDF Analysis & Chunking Lambda
+        const chunkingLambda = new aws_lambda_python_alpha_1.PythonFunction(this, 'PDFChunkingFunction', {
+            functionName: generatedLogPermissions.uniqueFunctionName,
+            entry: path.join(__dirname, 'resources/pdf-chunking'),
+            index: 'handler.py',
+            handler: 'handler',
+            runtime: framework_1.DefaultRuntimes.PYTHON,
+            architecture: aws_lambda_1.Architecture.X86_64,
+            role,
+            memorySize: 2048,
+            timeout: aws_cdk_lib_1.Duration.minutes(10),
+            environment: {
+                CHUNKING_STRATEGY: chunkingConfig.strategy || 'hybrid',
+                PAGE_THRESHOLD: String(chunkingConfig.pageThreshold || 100),
+                TOKEN_THRESHOLD: String(chunkingConfig.tokenThreshold || 150000),
+                CHUNK_SIZE: String(chunkingConfig.chunkSize || 50),
+                OVERLAP_PAGES: String(chunkingConfig.overlapPages || 5),
+                MAX_TOKENS_PER_CHUNK: String(chunkingConfig.maxTokensPerChunk || 100000),
+                OVERLAP_TOKENS: String(chunkingConfig.overlapTokens || 5000),
+                TARGET_TOKENS_PER_CHUNK: String(chunkingConfig.targetTokensPerChunk || 80000),
+                MAX_PAGES_PER_CHUNK: String(chunkingConfig.maxPagesPerChunk || 99),
+                ...powertools_config_1.PowertoolsConfig.generateDefaultLambdaConfig(this.bedrockDocumentProcessingProps.enableObservability, this.metricNamespace, this.metricServiceName),
+            },
+            environmentEncryption: this.encryptionKey,
+            vpc: this.bedrockDocumentProcessingProps.network
+                ? this.bedrockDocumentProcessingProps.network.vpc
+                : undefined,
+            vpcSubnets: this.bedrockDocumentProcessingProps.network
+                ? this.bedrockDocumentProcessingProps.network.applicationSubnetSelection()
+                : undefined,
+        });
+        for (const statement of generatedLogPermissions.policyStatements) {
+            chunkingLambda.role?.addToPrincipalPolicy(statement);
+        }
+        if (this.bedrockDocumentProcessingProps.network) {
+            chunkingLambda.role?.addToPrincipalPolicy(utilities_1.LambdaIamUtils.generateLambdaVPCPermissions());
+        }
+        return new aws_stepfunctions_tasks_1.LambdaInvoke(this, 'PDFAnalysisAndChunking', {
+            lambdaFunction: chunkingLambda,
+            resultPath: '$.chunkingResult',
+            resultSelector: {
+                'requiresChunking.$': '$.Payload.requiresChunking',
+                'tokenAnalysis.$': '$.Payload.tokenAnalysis',
+                'strategy.$': '$.Payload.strategy',
+                'chunks.$': '$.Payload.chunks',
+            },
+        });
+    }
+    /**
+     * Provides additional metadata fields for chunking to be stored in DynamoDB.
+     *
+     * When chunking is enabled, adds fields for:
+     * - ChunkingEnabled: string representation of boolean flag
+     * - ChunkingStrategy: strategy used (fixed-pages, token-based, hybrid)
+     * - TokenAnalysis: JSON string with token analysis results
+     * - ChunkMetadata: JSON string array with chunk information
+     *
+     * @returns Record of DynamoDB attribute values for chunking metadata
+     */
+    preprocessingMetadata() {
+        if (!this.bedrockDocumentProcessingProps.enableChunking) {
+            return {};
+        }
+        return {
+            ChunkingEnabled: aws_stepfunctions_tasks_1.DynamoAttributeValue.fromString(aws_stepfunctions_1.JsonPath.stringAt('States.Format(\'{}\', $.chunkingResult.requiresChunking)')),
+            ChunkingStrategy: aws_stepfunctions_tasks_1.DynamoAttributeValue.fromString(aws_stepfunctions_1.JsonPath.stringAt('$.chunkingResult.strategy')),
+            TokenAnalysis: aws_stepfunctions_tasks_1.DynamoAttributeValue.fromString(aws_stepfunctions_1.JsonPath.jsonToString(aws_stepfunctions_1.JsonPath.objectAt('$.chunkingResult.tokenAnalysis'))),
+            ChunkMetadata: aws_stepfunctions_tasks_1.DynamoAttributeValue.fromString(aws_stepfunctions_1.JsonPath.jsonToString(aws_stepfunctions_1.JsonPath.objectAt('$.chunkingResult.chunks'))),
+        };
+    }
+    /**
+     * Creates the processing workflow with conditional branching for chunked documents.
+     *
+     * When chunking is enabled, creates a Choice State that:
+     * - Routes to chunked processing flow if document was chunked
+     * - Routes to standard processing flow if document was not chunked
+     *
+     * When chunking is disabled, returns the standard processing workflow.
+     *
+     * @returns Step Functions chain for processing the document
+     */
+    createProcessingWorkflow() {
+        // If chunking is not enabled, use standard workflow
+        if (!this.bedrockDocumentProcessingProps.enableChunking) {
+            return this.createStandardProcessingWorkflow();
+        }
+        // Create Choice State to check if chunking was applied
+        const choiceState = new aws_stepfunctions_1.Choice(this, 'CheckIfChunked');
+        choiceState
+            .when(aws_stepfunctions_1.Condition.booleanEquals('$.chunkingResult.requiresChunking', true), this.createChunkedProcessingFlow())
+            .otherwise(
+        // Pass 'Standard' prefix to avoid construct ID collisions with chunked flow
+        this.createStandardProcessingWorkflow('Standard'));
+        return choiceState;
+    }
+    /**
+     * Creates the chunked processing flow for large documents.
+     *
+     * This flow:
+     * 1. Uses a Map State to process each chunk in parallel (or sequentially)
+     * 2. Each chunk goes through classification and processing
+     * 3. Results are aggregated using the aggregation Lambda
+     * 4. DynamoDB is updated with the aggregated result
+     * 5. Temporary chunks are cleaned up from S3
+     *
+     * @returns Step Functions chain for chunked document processing
+     */
+    createChunkedProcessingFlow() {
+        const chunkingConfig = this.bedrockDocumentProcessingProps.chunkingConfig || {};
+        const maxConcurrency = chunkingConfig.processingMode === 'sequential'
+            ? 1
+            : (chunkingConfig.maxConcurrency || 10);
+        // Create Map State for processing chunks
+        const mapState = new aws_stepfunctions_1.Map(this, 'ProcessChunks', {
+            itemsPath: '$.chunkingResult.chunks',
+            maxConcurrency,
+            parameters: {
+                'documentId.$': '$.documentId',
+                'chunk.$': '$$.Map.Item.Value',
+                'chunkIndex.$': '$$.Map.Item.Index',
+                'totalChunks.$': 'States.ArrayLength($.chunkingResult.chunks)',
+                // Override content to point to the chunk PDF, not the original document
+                'content': {
+                    'location': 's3',
+                    'bucket.$': '$$.Map.Item.Value.bucket',
+                    'key.$': '$$.Map.Item.Value.key',
+                    'filename.$': '$.content.filename',
+                },
+                'contentType.$': '$.contentType',
+            },
+            resultPath: '$.chunkResults',
+        });
+        // Define per-chunk processing: classification → processing
+        const chunkClassification = this.classificationStep();
+        const chunkProcessing = this.processingStep();
+        mapState.itemProcessor(chunkClassification.next(chunkProcessing));
+        // Create aggregation step (Lambda invoke only, normalization added separately)
+        const aggregationLambdaStep = this.createAggregationStep();
+        // Add a Pass state to normalize the aggregated result for downstream compatibility
+        // This copies aggregatedResult to processingResult so enrichment/post-processing
+        // see a consistent structure regardless of whether chunking was used
+        const normalizeState = new aws_stepfunctions_1.Pass(this, 'NormalizeAggregatedResult', {
+            parameters: {
+                'documentId.$': '$.documentId',
+                'contentType.$': '$.contentType',
+                'content.$': '$.content',
+                'chunkingResult.$': '$.chunkingResult',
+                'chunkResults.$': '$.chunkResults',
+                'aggregatedResult.$': '$.aggregatedResult',
+                // Copy aggregated result to processingResult for downstream compatibility
+                'processingResult': {
+                    'result.$': '$.aggregatedResult.result',
+                },
+                // Also set classificationResult from the first successful chunk for consistency
+                'classificationResult.$': '$.chunkResults[0].classificationResult',
+            },
+        });
+        // Create DynamoDB update step for aggregated result
+        const updateAggregatedResultStep = this.createUpdateAggregatedResultStep();
+        // Create cleanup step
+        const cleanupStep = this.createCleanupStep();
+        // Create move to processed chain with 'Chunked' prefix to avoid ID collisions
+        const moveToProcessed = this.ingressAdapter.createSuccessChain(this, 'Chunked');
+        // Create error handler for aggregation failures
+        const aggregationErrorHandler = this.createAggregationErrorHandler();
+        // Get optional enrichment and post-processing steps
+        const enrichmentStep = this.enrichmentStep();
+        const postProcessingStep = this.postProcessingStep();
+        // Build the final chain after aggregation
+        // Chain: Map State → Aggregation → DynamoDB Update → [Enrichment] → [PostProcessing] → Cleanup → Move to Processed
+        let finalChain = cleanupStep
+            .addRetry({
+            errors: ['Lambda.ServiceException', 'Lambda.TooManyRequestsException'],
+            interval: aws_cdk_lib_1.Duration.seconds(2),
+            maxAttempts: 3,
+            backoffRate: 2,
+        })
+            .next(moveToProcessed);
+        // Add post-processing if provided (insert before cleanup)
+        if (postProcessingStep) {
+            const postProcessingErrorHandler = new aws_stepfunctions_tasks_1.DynamoUpdateItem(this, 'ChunkedPostProcessingFailDDBUpdate', {
+                table: this.documentProcessingTable,
+                key: {
+                    DocumentId: aws_stepfunctions_tasks_1.DynamoAttributeValue.fromString(aws_stepfunctions_1.JsonPath.stringAt('$.documentId')),
+                },
+                updateExpression: 'SET WorkflowStatus = :newStatus',
+                expressionAttributeValues: {
+                    ':newStatus': aws_stepfunctions_tasks_1.DynamoAttributeValue.fromString('post-processing-failure'),
+                },
+                resultPath: aws_stepfunctions_1.JsonPath.DISCARD,
+            }).next(this.ingressAdapter.createFailedChain(this, 'ChunkedPostProc'));
+            finalChain = postProcessingStep
+                .addCatch(postProcessingErrorHandler, {
+                resultPath: aws_stepfunctions_1.JsonPath.DISCARD,
+            })
+                .next(new aws_stepfunctions_tasks_1.DynamoUpdateItem(this, 'ChunkedPostProcessingSuccessUpdate', {
+                table: this.documentProcessingTable,
+                key: {
+                    DocumentId: aws_stepfunctions_tasks_1.DynamoAttributeValue.fromString(aws_stepfunctions_1.JsonPath.stringAt('$.documentId')),
+                },
+                updateExpression: 'SET WorkflowStatus = :newStatus, PostProcessingResult = :postProcessingResult',
+                expressionAttributeValues: {
+                    ':newStatus': aws_stepfunctions_tasks_1.DynamoAttributeValue.fromString('post-processing-complete'),
+                    ':postProcessingResult': aws_stepfunctions_tasks_1.DynamoAttributeValue.fromString(aws_stepfunctions_1.JsonPath.jsonToString(aws_stepfunctions_1.JsonPath.objectAt('$.postProcessedResult'))),
+                },
+                resultPath: aws_stepfunctions_1.JsonPath.DISCARD,
+            }).next(finalChain));
+        }
+        // Add enrichment if provided (insert before post-processing or cleanup)
+        if (enrichmentStep) {
+            const enrichmentErrorHandler = new aws_stepfunctions_tasks_1.DynamoUpdateItem(this, 'ChunkedEnrichmentFailDDBUpdate', {
+                table: this.documentProcessingTable,
+                key: {
+                    DocumentId: aws_stepfunctions_tasks_1.DynamoAttributeValue.fromString(aws_stepfunctions_1.JsonPath.stringAt('$.documentId')),
+                },
+                updateExpression: 'SET WorkflowStatus = :newStatus',
+                expressionAttributeValues: {
+                    ':newStatus': aws_stepfunctions_tasks_1.DynamoAttributeValue.fromString('enrichment-failure'),
+                },
+                resultPath: aws_stepfunctions_1.JsonPath.DISCARD,
+            }).next(this.ingressAdapter.createFailedChain(this, 'ChunkedEnrich'));
+            finalChain = enrichmentStep
+                .addCatch(enrichmentErrorHandler, {
+                resultPath: aws_stepfunctions_1.JsonPath.DISCARD,
+            })
+                .next(new aws_stepfunctions_tasks_1.DynamoUpdateItem(this, 'ChunkedEnrichmentSuccessUpdate', {
+                table: this.documentProcessingTable,
+                key: {
+                    DocumentId: aws_stepfunctions_tasks_1.DynamoAttributeValue.fromString(aws_stepfunctions_1.JsonPath.stringAt('$.documentId')),
+                },
+                updateExpression: 'SET WorkflowStatus = :newStatus, EnrichmentResult = :enrichmentResult',
+                expressionAttributeValues: {
+                    ':newStatus': postProcessingStep
+                        ? aws_stepfunctions_tasks_1.DynamoAttributeValue.fromString('enrichment-complete')
+                        : aws_stepfunctions_tasks_1.DynamoAttributeValue.fromString('complete'),
+                    ':enrichmentResult': aws_stepfunctions_tasks_1.DynamoAttributeValue.fromString(aws_stepfunctions_1.JsonPath.jsonToString(aws_stepfunctions_1.JsonPath.objectAt('$.enrichedResult'))),
+                },
+                resultPath: aws_stepfunctions_1.JsonPath.DISCARD,
+            }).next(finalChain));
+        }
+        // Chain: Map State → Aggregation → Normalize → DynamoDB Update → [Enrichment] → [PostProcessing] → Cleanup → Move to Processed
+        return mapState
+            .addCatch(aggregationErrorHandler, {
+            resultPath: '$.error',
+        })
+            .next(aggregationLambdaStep
+            .addCatch(aggregationErrorHandler, {
+            resultPath: '$.error',
+        })
+            .addRetry({
+            errors: ['Lambda.ServiceException', 'Lambda.TooManyRequestsException'],
+            interval: aws_cdk_lib_1.Duration.seconds(2),
+            maxAttempts: 3,
+            backoffRate: 2,
+        })
+            .next(normalizeState.next(updateAggregatedResultStep
+            .addRetry({
+            errors: ['DynamoDB.ProvisionedThroughputExceededException'],
+            interval: aws_cdk_lib_1.Duration.seconds(1),
+            maxAttempts: 3,
+            backoffRate: 2,
+        })
+            .next(finalChain))));
+    }
+    /**
+     * Creates the aggregation step for combining chunk results using Bedrock.
+     *
+     * Uses the same Bedrock invoke Lambda pattern as the processing step but with
+     * a different prompt designed for aggregating multiple chunk results.
+     * The chunk processing results are passed as text data to the model.
+     *
+     * @returns LambdaInvoke task for result aggregation
+     */
+    createAggregationStep() {
+        // Create Lambda function only once (reuses bedrock-invoke pattern)
+        if (!this._aggregationFunction) {
+            const prompt = this.bedrockDocumentProcessingProps.aggregationPrompt || BedrockDocumentProcessing.DEFAULT_AGGREGATION_PROMPT;
+            const adjustedModelId = bedrock_1.BedrockModelUtils.deriveActualModelId(this.bedrockDocumentProcessingProps.processingBedrockModel);
+            const role = this.generateLambdaRoleForBedrock('AggregationLambdaRole', this.bedrockDocumentProcessingProps.processingBedrockModel);
+            const { region, account } = aws_cdk_lib_1.Stack.of(this);
+            const generatedLogPermissions = utilities_1.LambdaIamUtils.createLogsPermissions({
+                account,
+                functionName: 'bedrock-idp-aggregation',
+                region,
+                scope: this,
+                enableObservability: this.bedrockDocumentProcessingProps.enableObservability,
+            });
+            this.encryptionKey.grantEncryptDecrypt(role);
+            this._aggregationFunction = new aws_lambda_python_alpha_1.PythonFunction(this, 'BedrockAggregationFunction', {
+                functionName: generatedLogPermissions.uniqueFunctionName,
+                architecture: aws_lambda_1.Architecture.X86_64,
+                runtime: framework_1.DefaultRuntimes.PYTHON,
+                entry: path.join(__dirname, 'resources/default-bedrock-invoke'),
+                role,
+                memorySize: 1024,
+                timeout: this.bedrockDocumentProcessingProps.stepTimeouts || aws_cdk_lib_1.Duration.minutes(5),
+                environment: {
+                    MODEL_ID: adjustedModelId,
+                    PROMPT: prompt,
+                    INVOKE_TYPE: 'aggregation',
+                    INVOKE_MAX_TOKENS: '64000', // Aggregation may need more tokens for merged output
+                    ...powertools_config_1.PowertoolsConfig.generateDefaultLambdaConfig(this.bedrockDocumentProcessingProps.enableObservability, this.metricNamespace, this.metricServiceName),
+                },
+                environmentEncryption: this.encryptionKey,
+                vpc: this.bedrockDocumentProcessingProps.network
+                    ? this.bedrockDocumentProcessingProps.network.vpc
+                    : undefined,
+                vpcSubnets: this.bedrockDocumentProcessingProps.network
+                    ? this.bedrockDocumentProcessingProps.network.applicationSubnetSelection()
+                    : undefined,
+            });
+            for (const statement of generatedLogPermissions.policyStatements) {
+                this._aggregationFunction.role?.addToPrincipalPolicy(statement);
+            }
+            if (this.bedrockDocumentProcessingProps.network) {
+                this._aggregationFunction.role?.addToPrincipalPolicy(utilities_1.LambdaIamUtils.generateLambdaVPCPermissions());
+            }
+        }
+        // Always create a new LambdaInvoke task to allow proper state chaining
+        const stepId = `AggregationStep-${this._aggregationStepCounter}`;
+        this._aggregationStepCounter++;
+        // Pass chunk results as data content - the Lambda will format them for Bedrock
+        return new aws_stepfunctions_tasks_1.LambdaInvoke(this, stepId, {
+            lambdaFunction: this._aggregationFunction,
+            payload: aws_stepfunctions_1.TaskInput.fromObject({
+                'documentId.$': '$.documentId',
+                'contentType': 'data',
+                'content': {
+                    // Pass the chunk results as JSON string for the Lambda to process
+                    'data.$': 'States.JsonToString($.chunkResults)',
+                },
+            }),
+            // Store in both aggregatedResult AND processingResult for consistency with non-chunked flow
+            // This allows enrichment/post-processing steps to use $.processingResult regardless of chunking
+            resultPath: '$.aggregatedResult',
+            resultSelector: {
+                'result.$': '$.Payload.result',
+            },
+        });
+    }
+    /**
+     * Creates the DynamoDB update step for storing aggregated results.
+     *
+     * Updates the document record with:
+     * - AggregatedResult: JSON string with classification, entities, and summary
+     * - WorkflowStatus: 'complete'
+     *
+     * @returns DynamoUpdateItem task for storing aggregated results
+     */
+    createUpdateAggregatedResultStep() {
+        return new aws_stepfunctions_tasks_1.DynamoUpdateItem(this, 'StoreAggregatedResult', {
+            table: this.documentProcessingTable,
+            key: {
+                DocumentId: aws_stepfunctions_tasks_1.DynamoAttributeValue.fromString(aws_stepfunctions_1.JsonPath.stringAt('$.documentId')),
+            },
+            updateExpression: 'SET AggregatedResult = :result, WorkflowStatus = :status',
+            expressionAttributeValues: {
+                ':result': aws_stepfunctions_tasks_1.DynamoAttributeValue.fromString(aws_stepfunctions_1.JsonPath.jsonToString(aws_stepfunctions_1.JsonPath.objectAt('$.aggregatedResult'))),
+                ':status': aws_stepfunctions_tasks_1.DynamoAttributeValue.fromString('complete'),
+            },
+            resultPath: aws_stepfunctions_1.JsonPath.DISCARD,
+        });
+    }
+    /**
+     * Creates the cleanup Lambda step for removing temporary chunk files.
+     *
+     * The cleanup Lambda:
+     * - Deletes all chunk files from S3 chunks/ prefix
+     * - Uses batch delete for efficiency (up to 1000 objects per request)
+     * - Logs errors but doesn't fail the workflow
+     *
+     * @returns LambdaInvoke task for chunk cleanup
+     */
+    createCleanupStep() {
+        // Create Lambda function only once
+        if (!this._cleanupFunction) {
+            const { region, account } = aws_cdk_lib_1.Stack.of(this);
+            const role = new aws_iam_1.Role(this, 'CleanupLambdaRole', {
+                assumedBy: new aws_iam_1.ServicePrincipal('lambda.amazonaws.com'),
+                inlinePolicies: {
+                    CleanupPolicy: new aws_iam_1.PolicyDocument({
+                        statements: [
+                            // S3 access for deleting chunks only - least privilege
+                            ...this.ingressAdapter.generateAdapterIAMPolicies(['s3:DeleteObject'], true),
+                        ],
+                    }),
+                },
+            });
+            const generatedLogPermissions = utilities_1.LambdaIamUtils.createLogsPermissions({
+                account,
+                functionName: 'bedrock-idp-cleanup',
+                region,
+                scope: this,
+                enableObservability: this.bedrockDocumentProcessingProps.enableObservability,
+            });
+            this.encryptionKey.grantEncryptDecrypt(role);
+            this._cleanupFunction = new aws_lambda_python_alpha_1.PythonFunction(this, 'CleanupFunction', {
+                functionName: generatedLogPermissions.uniqueFunctionName,
+                entry: path.join(__dirname, 'resources/cleanup'),
+                index: 'handler.py',
+                handler: 'handler',
+                runtime: framework_1.DefaultRuntimes.PYTHON,
+                architecture: aws_lambda_1.Architecture.X86_64,
+                role,
+                memorySize: 512,
+                timeout: aws_cdk_lib_1.Duration.minutes(5),
+                environment: {
+                    ...powertools_config_1.PowertoolsConfig.generateDefaultLambdaConfig(this.bedrockDocumentProcessingProps.enableObservability, this.metricNamespace, this.metricServiceName),
+                },
+                environmentEncryption: this.encryptionKey,
+                vpc: this.bedrockDocumentProcessingProps.network
+                    ? this.bedrockDocumentProcessingProps.network.vpc
+                    : undefined,
+                vpcSubnets: this.bedrockDocumentProcessingProps.network
+                    ? this.bedrockDocumentProcessingProps.network.applicationSubnetSelection()
+                    : undefined,
+            });
+            for (const statement of generatedLogPermissions.policyStatements) {
+                this._cleanupFunction.role?.addToPrincipalPolicy(statement);
+            }
+            if (this.bedrockDocumentProcessingProps.network) {
+                this._cleanupFunction.role?.addToPrincipalPolicy(utilities_1.LambdaIamUtils.generateLambdaVPCPermissions());
+            }
+        }
+        return new aws_stepfunctions_tasks_1.LambdaInvoke(this, 'CleanupChunks', {
+            lambdaFunction: this._cleanupFunction,
+            payload: aws_stepfunctions_1.TaskInput.fromObject({
+                'documentId.$': '$.documentId',
+                'chunks.$': '$.chunkingResult.chunks',
+            }),
+            resultPath: aws_stepfunctions_1.JsonPath.DISCARD,
+        });
+    }
+    /**
+     * Creates the error handler for aggregation failures.
+     *
+     * When aggregation fails:
+     * - Updates DynamoDB with 'aggregation-failure' status
+     * - Moves document to failed/ prefix
+     *
+     * @returns Step Functions chain for handling aggregation errors
+     */
+    createAggregationErrorHandler() {
+        const updateFailureStatus = new aws_stepfunctions_tasks_1.DynamoUpdateItem(this, 'AggregationFailDDBUpdate', {
+            table: this.documentProcessingTable,
+            key: {
+                DocumentId: aws_stepfunctions_tasks_1.DynamoAttributeValue.fromString(aws_stepfunctions_1.JsonPath.stringAt('$.documentId')),
+            },
+            updateExpression: 'SET WorkflowStatus = :newStatus',
+            expressionAttributeValues: {
+                ':newStatus': aws_stepfunctions_tasks_1.DynamoAttributeValue.fromString('aggregation-failure'),
+            },
+            resultPath: aws_stepfunctions_1.JsonPath.DISCARD,
+        });
+        // Use 'Chunked' prefix to avoid ID collisions with standard workflow
+        const moveToFailed = this.ingressAdapter.createFailedChain(this, 'Chunked');
+        return updateFailureStatus.next(moveToFailed);
+    }
 }
 exports.BedrockDocumentProcessing = BedrockDocumentProcessing;
 _a = JSII_RTTI_SYMBOL_1;
-BedrockDocumentProcessing[_a] = { fqn: "@cdklabs/cdk-appmod-catalog-blueprints.BedrockDocumentProcessing", version: "1.4.1" };
+BedrockDocumentProcessing[_a] = { fqn: "@cdklabs/cdk-appmod-catalog-blueprints.BedrockDocumentProcessing", version: "1.6.0" };
 BedrockDocumentProcessing.DEFAULT_CLASSIFICATION_PROMPT = `
   Analyze the document below, and classify the type of document it is (eg. INVOICE, IDENTITY_DOCUMENT, RECEIPT, etc). The result should be in JSON and should follow the following structure (only respond in JSON with the following structure and do not use markdown to indicate the json, just output plain old json with nothing else):
 
@@ -258,4 +876,26 @@ BedrockDocumentProcessing.DEFAULT_PROCESSING_PROMPT = `
   Attached document is as follows:
 
   `;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bedrock-document-processing.js","sourceRoot":"","sources":["../../use-cases/document-processing/bedrock-document-processing.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n// SPDX-License-Identifier: Apache-2.0\n\nimport * as path from 'path';\nimport { PythonFunction } from '@aws-cdk/aws-lambda-python-alpha';\nimport { Duration, Stack } from 'aws-cdk-lib';\nimport { InterfaceVpcEndpointAwsService } from 'aws-cdk-lib/aws-ec2';\nimport { Role, ServicePrincipal, PolicyDocument } from 'aws-cdk-lib/aws-iam';\nimport { Function, Architecture } from 'aws-cdk-lib/aws-lambda';\nimport { StateMachine } from 'aws-cdk-lib/aws-stepfunctions';\nimport { LambdaInvoke } from 'aws-cdk-lib/aws-stepfunctions-tasks';\nimport { Construct } from 'constructs';\nimport { BaseDocumentProcessing, BaseDocumentProcessingProps, DocumentProcessingStepType } from './base-document-processing';\nimport { DefaultRuntimes } from '../framework';\nimport { BedrockModelProps, BedrockModelUtils } from '../framework/bedrock';\nimport { LambdaIamUtils } from '../utilities';\nimport { PowertoolsConfig } from '../utilities/observability/powertools-config';\n\n/**\n * Configuration properties for BedrockDocumentProcessing construct.\n * Extends BaseDocumentProcessingProps with Bedrock-specific options.\n */\nexport interface BedrockDocumentProcessingProps extends BaseDocumentProcessingProps {\n  /**\n   * Bedrock foundation model for document classification step.\n   */\n  readonly classificationBedrockModel?: BedrockModelProps;\n\n  /**\n   * Bedrock foundation model for document extraction step.\n   */\n  readonly processingBedrockModel?: BedrockModelProps;\n  /**\n   * Custom prompt template for document classification.\n   * Must include placeholder for document content.\n   * @default DEFAULT_CLASSIFICATION_PROMPT\n   */\n  readonly classificationPrompt?: string;\n  /**\n   * Custom prompt template for document extraction.\n   * Must include placeholder for document content and classification result.\n   * @default DEFAULT_EXTRACTION_PROMPT\n   */\n  readonly processingPrompt?: string;\n  /**\n   * Optional Lambda function for document enrichment step.\n   * If provided, will be invoked after extraction with workflow state.\n   */\n  readonly enrichmentLambdaFunction?: Function;\n  /**\n   * Optional Lambda function for post-processing step.\n   * If provided, will be invoked after enrichment with workflow state.\n   */\n  readonly postProcessingLambdaFunction?: Function;\n  /**\n   * Timeout for individual Step Functions tasks (classification, extraction, etc.).\n   * @default Duration.minutes(5)\n   */\n  readonly stepTimeouts?: Duration;\n}\n\n/**\n * Document processing workflow powered by Amazon Bedrock foundation models.\n *\n * Extends BaseDocumentProcessing to provide AI-powered document classification and extraction\n * using Amazon Bedrock foundation models. This implementation offers:\n *\n * ## Key Features\n * - **AI-Powered Classification**: Uses Claude 3.7 Sonnet (configurable) to classify document types\n * - **Intelligent Extraction**: Extracts structured data from documents using foundation models\n * - **Cross-Region Inference**: Optional support for improved availability via inference profiles\n * - **Flexible Processing**: Optional enrichment and post-processing Lambda functions\n * - **Cost Optimized**: Configurable timeouts and model selection for cost control\n *\n * ## Processing Workflow\n * S3 Upload → Classification (Bedrock) → Extraction (Bedrock) → [Enrichment] → [Post-Processing] → Results\n *\n * ## Default Models\n * - Classification: Claude 3.7 Sonnet (anthropic.claude-3-7-sonnet-20250219-v1:0)\n * - Extraction: Claude 3.7 Sonnet (anthropic.claude-3-7-sonnet-20250219-v1:0)\n *\n * ## Prompt Templates\n * The construct uses default prompts that can be customized:\n * - **Classification**: Analyzes document and returns JSON with documentClassification field\n * - **Extraction**: Uses classification result to extract entities in structured JSON format\n *\n * ## Cross-Region Inference\n * When enabled, uses Bedrock inference profiles for improved availability:\n * - US prefix: Routes to US-based regions for lower latency\n * - EU prefix: Routes to EU-based regions for data residency compliance\n */\nexport class BedrockDocumentProcessing extends BaseDocumentProcessing {\n  protected static readonly DEFAULT_CLASSIFICATION_PROMPT = `\n  Analyze the document below, and classify the type of document it is (eg. INVOICE, IDENTITY_DOCUMENT, RECEIPT, etc). The result should be in JSON and should follow the following structure (only respond in JSON with the following structure and do not use markdown to indicate the json, just output plain old json with nothing else):\n\n  {\n      documentClassification: <CLASSIFICATION>\n  }\n\n  Attached document is as follows:\n\n  `;\n\n  protected static readonly DEFAULT_PROCESSING_PROMPT = `\n  The document below has been classified as [ACTUAL_CLASSIFICATION]. Extract important entities from the document and return the result as JSON following the structure below (only respond in JSON with the following structure and do not use markdown to indicate the json, just output plain old json with nothing else):\n\n  {\n      documentClassification: <CLASSIFICATION>,\n      result: {\n        entities: [\n            {\n                type: <TYPE OF ENTITY>\n                value: <VALUE OF ENTITY>\n            },\n            ...\n        ]\n      }\n  }\n\n  Attached document is as follows:\n\n  `;\n\n  /** Configuration properties specific to Bedrock document processing */\n  protected readonly bedrockDocumentProcessingProps: BedrockDocumentProcessingProps;\n  /** The Step Functions state machine that orchestrates the document processing workflow */\n  readonly stateMachine: StateMachine;\n\n  /**\n   * Creates a new BedrockDocumentProcessing construct.\n   *\n   * Initializes the Bedrock-powered document processing pipeline with AI classification\n   * and extraction capabilities. Creates Lambda functions with appropriate IAM roles\n   * for Bedrock model invocation and S3 access.\n   *\n   * @param scope - The scope in which to define this construct\n   * @param id - The scoped construct ID. Must be unique within the scope.\n   * @param props - Configuration properties for the Bedrock document processing pipeline\n   */\n  constructor(scope: Construct, id: string, props: BedrockDocumentProcessingProps) {\n    super(scope, id, props);\n    if (props.network) {\n      props.network.createServiceEndpoint('vpce-bedrock', InterfaceVpcEndpointAwsService.BEDROCK);\n      props.network.createServiceEndpoint('vpce-bedrock-runtime', InterfaceVpcEndpointAwsService.BEDROCK_RUNTIME);\n    }\n\n    this.bedrockDocumentProcessingProps = props;\n    this.stateMachine = this.handleStateMachineCreation('bedrock-document-processing-workflow');\n  }\n\n  /**\n   * Implements the document classification step using Amazon Bedrock.\n   *\n   * Creates a Lambda function that invokes the configured Bedrock model to classify\n   * the document type. The function reads the document from S3 and sends it to\n   * Bedrock with the classification prompt.\n   *\n   * @returns LambdaInvoke task configured for document classification\n   */\n  protected classificationStep(): DocumentProcessingStepType {\n    const prompt = this.bedrockDocumentProcessingProps.classificationPrompt || BedrockDocumentProcessing.DEFAULT_CLASSIFICATION_PROMPT;\n    const adjustedModelId = BedrockModelUtils.deriveActualModelId(this.bedrockDocumentProcessingProps.classificationBedrockModel);\n    const role = this.generateLambdaRoleForBedrock('ClassificationLambdaRole', this.bedrockDocumentProcessingProps.classificationBedrockModel);\n    const { region, account } = Stack.of(this);\n    const generatedLogPermissions = LambdaIamUtils.createLogsPermissions({\n      account,\n      functionName: 'bedrock-idp-classification',\n      region,\n      scope: this,\n      enableObservability: this.bedrockDocumentProcessingProps.enableObservability,\n    });\n\n    this.encryptionKey.grantEncryptDecrypt(role);\n\n    const bedrockFunction = new PythonFunction(this, 'BedrockClassificationFunction', {\n      functionName: generatedLogPermissions.uniqueFunctionName,\n      architecture: Architecture.X86_64,\n      runtime: DefaultRuntimes.PYTHON,\n      entry: path.join(__dirname, 'resources/default-bedrock-invoke'),\n      role,\n      memorySize: 512,\n      timeout: this.bedrockDocumentProcessingProps.stepTimeouts || Duration.minutes(5),\n      environment: {\n        MODEL_ID: adjustedModelId,\n        PROMPT: prompt,\n        INVOKE_TYPE: 'classification',\n        ...PowertoolsConfig.generateDefaultLambdaConfig(\n          this.bedrockDocumentProcessingProps.enableObservability,\n          this.metricNamespace,\n          this.metricServiceName,\n        ),\n      },\n      environmentEncryption: this.encryptionKey,\n      vpc: this.bedrockDocumentProcessingProps.network ? this.bedrockDocumentProcessingProps.network.vpc : undefined,\n      vpcSubnets: this.bedrockDocumentProcessingProps.network ? this.bedrockDocumentProcessingProps.network.applicationSubnetSelection() : undefined,\n    });\n\n    for (const statement of generatedLogPermissions.policyStatements) {\n      bedrockFunction.role?.addToPrincipalPolicy(statement);\n    }\n\n    if (this.bedrockDocumentProcessingProps.network) {\n      bedrockFunction.role?.addToPrincipalPolicy(LambdaIamUtils.generateLambdaVPCPermissions());\n    }\n\n    return new LambdaInvoke(this, 'ClassificationStep', {\n      lambdaFunction: bedrockFunction,\n      resultPath: '$.classificationResult',\n      resultSelector: {\n        'documentClassification.$': '$.Payload.documentClassification',\n      },\n    });\n  }\n\n  /**\n   * Implements the document extraction step using Amazon Bedrock.\n   *\n   * Creates a Lambda function that invokes the configured Bedrock model to extract\n   * structured data from the document. Uses the classification result from the\n   * previous step to provide context for more accurate extraction.\n   *\n   * @returns LambdaInvoke task configured for document extraction\n   */\n  protected processingStep(): DocumentProcessingStepType {\n    const prompt = this.bedrockDocumentProcessingProps.processingPrompt || BedrockDocumentProcessing.DEFAULT_PROCESSING_PROMPT;\n    const adjustedModelId = BedrockModelUtils.deriveActualModelId(this.bedrockDocumentProcessingProps.processingBedrockModel);\n    const role = this.generateLambdaRoleForBedrock('ProcessingLambdaRole', this.bedrockDocumentProcessingProps.processingBedrockModel);\n    const { region, account } = Stack.of(this);\n\n    const generatedLogPermissions = LambdaIamUtils.createLogsPermissions({\n      account,\n      functionName: 'bedrock-idp-processing',\n      region,\n      scope: this,\n    });\n    this.encryptionKey.grantEncryptDecrypt(role);\n    const bedrockFunction = new PythonFunction(this, 'BedrockExtractionFunction', {\n      functionName: generatedLogPermissions.uniqueFunctionName,\n      runtime: DefaultRuntimes.PYTHON,\n      architecture: Architecture.X86_64,\n      entry: path.join(__dirname, 'resources/default-bedrock-invoke'),\n      role,\n      memorySize: 512,\n      timeout: this.bedrockDocumentProcessingProps.stepTimeouts || Duration.minutes(5),\n      environment: {\n        MODEL_ID: adjustedModelId,\n        PROMPT: prompt,\n        INVOKE_TYPE: 'processing',\n        ...PowertoolsConfig.generateDefaultLambdaConfig(\n          this.bedrockDocumentProcessingProps.enableObservability,\n          this.metricNamespace,\n          this.metricServiceName,\n        ),\n      },\n      environmentEncryption: this.encryptionKey,\n      vpc: this.bedrockDocumentProcessingProps.network ? this.bedrockDocumentProcessingProps.network.vpc : undefined,\n      vpcSubnets: this.bedrockDocumentProcessingProps.network ? this.bedrockDocumentProcessingProps.network.applicationSubnetSelection() : undefined,\n    });\n\n    for (const statement of generatedLogPermissions.policyStatements) {\n      bedrockFunction.role?.addToPrincipalPolicy(statement);\n    }\n\n    if (this.bedrockDocumentProcessingProps.network) {\n      bedrockFunction.role?.addToPrincipalPolicy(LambdaIamUtils.generateLambdaVPCPermissions());\n    }\n\n    return new LambdaInvoke(this, 'ProcessingStep', {\n      lambdaFunction: bedrockFunction,\n      resultPath: '$.processingResult',\n      resultSelector: {\n        'documentClassification.$': '$.Payload.documentClassification',\n        'result.$': '$.Payload.result',\n      },\n    });\n  }\n\n  protected generateLambdaRoleForBedrock(id: string, model?: BedrockModelProps) {\n    return new Role(this, id, {\n      assumedBy: new ServicePrincipal('lambda.amazonaws.com'),\n      inlinePolicies: {\n        BedrockInvokePolicy: new PolicyDocument({\n          statements: [\n            ...this.ingressAdapter.generateAdapterIAMPolicies(),\n            BedrockModelUtils.generateModelIAMPermissions(this, model),\n          ],\n        }),\n      },\n    });\n  }\n\n  /**\n   * Implements the optional document enrichment step.\n   *\n   * If an enrichment Lambda function is provided in the props, creates a LambdaInvoke\n   * task to perform additional processing on the extracted data. This step is useful\n   * for data validation, transformation, or integration with external systems.\n   *\n   * @returns LambdaInvoke task for enrichment, or undefined to skip this step\n   */\n  protected enrichmentStep(): DocumentProcessingStepType | undefined {\n    if (!this.bedrockDocumentProcessingProps.enrichmentLambdaFunction) {\n      return undefined;\n    }\n\n    return new LambdaInvoke(this, 'EnrichmentStep', {\n      lambdaFunction: this.bedrockDocumentProcessingProps.enrichmentLambdaFunction,\n      resultPath: '$.enrichedResult',\n    });\n  }\n\n  /**\n   * Implements the optional post-processing step.\n   *\n   * If a post-processing Lambda function is provided in the props, creates a LambdaInvoke\n   * task to perform final processing on the workflow results. This step is useful for\n   * data formatting, notifications, or integration with downstream systems.\n   *\n   * @returns LambdaInvoke task for post-processing, or undefined to skip this step\n   */\n  protected postProcessingStep(): DocumentProcessingStepType | undefined {\n    if (!this.bedrockDocumentProcessingProps.postProcessingLambdaFunction) {\n      return undefined;\n    }\n\n    return new LambdaInvoke(this, 'PostProcessingStep', {\n      lambdaFunction: this.bedrockDocumentProcessingProps.postProcessingLambdaFunction,\n      resultPath: '$.postProcessedResult',\n    });\n  }\n}"]}
+BedrockDocumentProcessing.DEFAULT_AGGREGATION_PROMPT = `
+  You are given the processing results from multiple chunks of a large document that was split for processing.
+  Your task is to synthesize these chunk results into a single, coherent final result.
+
+  Instructions:
+  1. Review all the chunk results provided below
+  2. Merge and deduplicate any overlapping information (chunks may have overlapping pages)
+  3. Synthesize the information into a unified, coherent result
+  4. Maintain the same output format as the individual chunk results
+  5. If the chunks contain summaries, create a comprehensive summary that covers all sections
+  6. If the chunks contain entities, deduplicate and consolidate them
+  7. Preserve important details from each chunk while avoiding redundancy
+
+  Return the result as JSON (only respond in JSON without markdown formatting):
+
+  {
+      "result": <SYNTHESIZED_RESULT>
+  }
+
+  The chunk results to aggregate are as follows:
+
+  `;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bedrock-document-processing.js","sourceRoot":"","sources":["../../use-cases/document-processing/bedrock-document-processing.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n// SPDX-License-Identifier: Apache-2.0\n\nimport * as path from 'path';\nimport { PythonFunction } from '@aws-cdk/aws-lambda-python-alpha';\nimport { Duration, Stack } from 'aws-cdk-lib';\nimport { InterfaceVpcEndpointAwsService } from 'aws-cdk-lib/aws-ec2';\nimport { Role, ServicePrincipal, PolicyDocument } from 'aws-cdk-lib/aws-iam';\nimport { Function, Architecture } from 'aws-cdk-lib/aws-lambda';\nimport { IChainable, Choice, Condition, Map, JsonPath, TaskInput, Pass } from 'aws-cdk-lib/aws-stepfunctions';\nimport { DynamoAttributeValue, DynamoUpdateItem, LambdaInvoke } from 'aws-cdk-lib/aws-stepfunctions-tasks';\nimport { Construct } from 'constructs';\nimport { BaseDocumentProcessing, BaseDocumentProcessingProps, DocumentProcessingStepType } from './base-document-processing';\nimport { ChunkingConfig } from './chunking-config';\nimport { DefaultRuntimes } from '../framework';\nimport { BedrockModelProps, BedrockModelUtils } from '../framework/bedrock';\nimport { LambdaIamUtils } from '../utilities';\nimport { PowertoolsConfig } from '../utilities/observability/powertools-config';\n\n/**\n * Configuration properties for BedrockDocumentProcessing construct.\n * Extends BaseDocumentProcessingProps with Bedrock-specific options.\n */\nexport interface BedrockDocumentProcessingProps extends BaseDocumentProcessingProps {\n  /**\n   * Bedrock foundation model for document classification step.\n   */\n  readonly classificationBedrockModel?: BedrockModelProps;\n\n  /**\n   * Bedrock foundation model for document extraction step.\n   */\n  readonly processingBedrockModel?: BedrockModelProps;\n  /**\n   * Custom prompt template for document classification.\n   * Must include placeholder for document content.\n   * @default DEFAULT_CLASSIFICATION_PROMPT\n   */\n  readonly classificationPrompt?: string;\n  /**\n   * Custom prompt template for document extraction.\n   * Must include placeholder for document content and classification result.\n   * @default DEFAULT_EXTRACTION_PROMPT\n   */\n  readonly processingPrompt?: string;\n  /**\n   * Optional Lambda function for document enrichment step.\n   * If provided, will be invoked after extraction with workflow state.\n   */\n  readonly enrichmentLambdaFunction?: Function;\n  /**\n   * Optional Lambda function for post-processing step.\n   * If provided, will be invoked after enrichment with workflow state.\n   */\n  readonly postProcessingLambdaFunction?: Function;\n  /**\n   * Timeout for individual Step Functions tasks (classification, extraction, etc.).\n   * @default Duration.minutes(5)\n   */\n  readonly stepTimeouts?: Duration;\n\n  /**\n   * Custom prompt template for aggregating results from multiple chunks.\n   * Used when chunking is enabled to merge processing results from all chunks\n   * into a single coherent result.\n   *\n   * The prompt receives the concatenated processing results from all chunks\n   * and should instruct the model to synthesize them into a unified output.\n   *\n   * @default DEFAULT_AGGREGATION_PROMPT\n   */\n  readonly aggregationPrompt?: string;\n\n  /**\n   * Enable PDF chunking for large documents.\n   *\n   * When enabled, documents exceeding configured thresholds will be automatically\n   * split into chunks, processed in parallel or sequentially, and results aggregated.\n   *\n   * This feature is useful for:\n   * - Processing large PDFs (>100 pages)\n   * - Handling documents that exceed Bedrock token limits (~200K tokens)\n   * - Improving processing reliability for complex documents\n   * - Processing documents with variable content density\n   *\n   * The chunking workflow:\n   * 1. Analyzes PDF to determine page count and estimate token count\n   * 2. Decides if chunking is needed based on configured thresholds\n   * 3. If chunking is needed, splits PDF into chunks and uploads to S3\n   * 4. Processes each chunk through classification and extraction\n   * 5. Aggregates results using majority voting for classification\n   * 6. Deduplicates entities across chunks\n   * 7. Cleans up temporary chunk files from S3\n   *\n   * @default false\n   */\n  readonly enableChunking?: boolean;\n\n  /**\n   * Configuration for PDF chunking behavior.\n   *\n   * Only applies when `enableChunking` is true. Allows customization of:\n   * - **Chunking strategy**: How documents are split (fixed-pages, token-based, or hybrid)\n   * - **Thresholds**: When to trigger chunking based on page count or token count\n   * - **Chunk size and overlap**: Control chunk boundaries and context preservation\n   * - **Processing mode**: Parallel (faster) or sequential (cost-optimized)\n   * - **Aggregation strategy**: How to combine results from multiple chunks\n   *\n   * ## Default Configuration\n   *\n   * If not provided, uses sensible defaults optimized for most use cases:\n   * - Strategy: `'hybrid'` (recommended - balances token and page limits)\n   * - Page threshold: 100 pages\n   * - Token threshold: 150,000 tokens\n   * - Processing mode: `'parallel'`\n   * - Max concurrency: 10\n   * - Aggregation strategy: `'majority-vote'`\n   *\n   * ## Strategy Comparison\n   *\n   * | Strategy | Best For | Pros | Cons |\n   * |----------|----------|------|------|\n   * | `hybrid` | Most documents | Balances token/page limits | Slightly more complex |\n   * | `token-based` | Variable density | Respects model limits | Slower analysis |\n   * | `fixed-pages` | Uniform density | Simple, fast | May exceed token limits |\n   *\n   * @default undefined (uses default configuration when enableChunking is true)\n   *\n   * @see {@link ChunkingConfig} for detailed configuration options\n   */\n  readonly chunkingConfig?: ChunkingConfig;\n}\n\n/**\n * Document processing workflow powered by Amazon Bedrock foundation models.\n *\n * Extends BaseDocumentProcessing to provide AI-powered document classification and extraction\n * using Amazon Bedrock foundation models. This implementation offers:\n *\n * ## Key Features\n * - **AI-Powered Classification**: Uses Claude 3.7 Sonnet (configurable) to classify document types\n * - **Intelligent Extraction**: Extracts structured data from documents using foundation models\n * - **Cross-Region Inference**: Optional support for improved availability via inference profiles\n * - **Flexible Processing**: Optional enrichment and post-processing Lambda functions\n * - **Cost Optimized**: Configurable timeouts and model selection for cost control\n *\n * ## Processing Workflow\n * S3 Upload → Classification (Bedrock) → Extraction (Bedrock) → [Enrichment] → [Post-Processing] → Results\n *\n * ## Default Models\n * - Classification: Claude 3.7 Sonnet (anthropic.claude-3-7-sonnet-20250219-v1:0)\n * - Extraction: Claude 3.7 Sonnet (anthropic.claude-3-7-sonnet-20250219-v1:0)\n *\n * ## Prompt Templates\n * The construct uses default prompts that can be customized:\n * - **Classification**: Analyzes document and returns JSON with documentClassification field\n * - **Extraction**: Uses classification result to extract entities in structured JSON format\n *\n * ## Cross-Region Inference\n * When enabled, uses Bedrock inference profiles for improved availability:\n * - US prefix: Routes to US-based regions for lower latency\n * - EU prefix: Routes to EU-based regions for data residency compliance\n */\nexport class BedrockDocumentProcessing extends BaseDocumentProcessing {\n  protected static readonly DEFAULT_CLASSIFICATION_PROMPT = `\n  Analyze the document below, and classify the type of document it is (eg. INVOICE, IDENTITY_DOCUMENT, RECEIPT, etc). The result should be in JSON and should follow the following structure (only respond in JSON with the following structure and do not use markdown to indicate the json, just output plain old json with nothing else):\n\n  {\n      documentClassification: <CLASSIFICATION>\n  }\n\n  Attached document is as follows:\n\n  `;\n\n  protected static readonly DEFAULT_PROCESSING_PROMPT = `\n  The document below has been classified as [ACTUAL_CLASSIFICATION]. Extract important entities from the document and return the result as JSON following the structure below (only respond in JSON with the following structure and do not use markdown to indicate the json, just output plain old json with nothing else):\n\n  {\n      documentClassification: <CLASSIFICATION>,\n      result: {\n        entities: [\n            {\n                type: <TYPE OF ENTITY>\n                value: <VALUE OF ENTITY>\n            },\n            ...\n        ]\n      }\n  }\n\n  Attached document is as follows:\n\n  `;\n\n  protected static readonly DEFAULT_AGGREGATION_PROMPT = `\n  You are given the processing results from multiple chunks of a large document that was split for processing.\n  Your task is to synthesize these chunk results into a single, coherent final result.\n\n  Instructions:\n  1. Review all the chunk results provided below\n  2. Merge and deduplicate any overlapping information (chunks may have overlapping pages)\n  3. Synthesize the information into a unified, coherent result\n  4. Maintain the same output format as the individual chunk results\n  5. If the chunks contain summaries, create a comprehensive summary that covers all sections\n  6. If the chunks contain entities, deduplicate and consolidate them\n  7. Preserve important details from each chunk while avoiding redundancy\n\n  Return the result as JSON (only respond in JSON without markdown formatting):\n\n  {\n      \"result\": <SYNTHESIZED_RESULT>\n  }\n\n  The chunk results to aggregate are as follows:\n\n  `;\n\n  /** Configuration properties specific to Bedrock document processing */\n  protected readonly bedrockDocumentProcessingProps: BedrockDocumentProcessingProps;\n  /** The Step Functions state machine that orchestrates the document processing workflow */\n  readonly stateMachine;\n  /** Cached classification Lambda function to avoid duplicate resource creation */\n  private _classificationFunction?: Function;\n  /** Cached processing Lambda function to avoid duplicate resource creation */\n  private _processingFunction?: Function;\n  /** Counter for generating unique classification step IDs */\n  private _classificationStepCounter = 0;\n  /** Counter for generating unique processing step IDs */\n  private _processingStepCounter = 0;\n  /** Cached aggregation Lambda function to avoid duplicate resource creation */\n  private _aggregationFunction?: Function;\n  /** Counter for generating unique aggregation step IDs */\n  private _aggregationStepCounter = 0;\n  /** Cached cleanup Lambda function to avoid duplicate resource creation */\n  private _cleanupFunction?: Function;\n  /** Counter for generating unique enrichment step IDs */\n  private _enrichmentStepCounter = 0;\n  /** Counter for generating unique post-processing step IDs */\n  private _postProcessingStepCounter = 0;\n\n\n  /**\n   * Creates a new BedrockDocumentProcessing construct.\n   *\n   * Initializes the Bedrock-powered document processing pipeline with AI classification\n   * and extraction capabilities. Creates Lambda functions with appropriate IAM roles\n   * for Bedrock model invocation and S3 access.\n   *\n   * @param scope - The scope in which to define this construct\n   * @param id - The scoped construct ID. Must be unique within the scope.\n   * @param props - Configuration properties for the Bedrock document processing pipeline\n   * @throws Error if chunking configuration is invalid\n   */\n  constructor(scope: Construct, id: string, props: BedrockDocumentProcessingProps) {\n    super(scope, id, props);\n\n    // Validate chunking configuration if provided\n    if (props.enableChunking && props.chunkingConfig) {\n      this.validateChunkingConfig(props.chunkingConfig);\n    }\n\n    if (props.network) {\n      props.network.createServiceEndpoint('vpce-bedrock', InterfaceVpcEndpointAwsService.BEDROCK);\n      props.network.createServiceEndpoint('vpce-bedrock-runtime', InterfaceVpcEndpointAwsService.BEDROCK_RUNTIME);\n    }\n\n    this.bedrockDocumentProcessingProps = props;\n    this.stateMachine = this.handleStateMachineCreation('bedrock-document-processing-workflow');\n  }\n\n  /**\n   * Validates the chunking configuration parameters.\n   *\n   * Ensures that:\n   * - Chunk size is greater than 0\n   * - Overlap is non-negative and less than chunk size\n   * - Thresholds are greater than 0\n   * - Max concurrency is greater than 0\n   * - Min success threshold is between 0 and 1\n   *\n   * @param config - The chunking configuration to validate\n   * @throws Error if any configuration parameter is invalid\n   */\n  private validateChunkingConfig(config: ChunkingConfig): void {\n    // Validate chunk size (for fixed-pages strategy)\n    if (config.chunkSize !== undefined) {\n      if (config.chunkSize <= 0) {\n        throw new Error('ChunkingConfig validation error: chunkSize must be greater than 0');\n      }\n    }\n\n    // Validate overlap pages (for fixed-pages strategy)\n    if (config.overlapPages !== undefined) {\n      if (config.overlapPages < 0) {\n        throw new Error('ChunkingConfig validation error: overlapPages must be non-negative');\n      }\n      const effectiveChunkSize = config.chunkSize || 50; // default chunk size\n      if (config.overlapPages >= effectiveChunkSize) {\n        throw new Error('ChunkingConfig validation error: overlapPages must be less than chunkSize');\n      }\n    }\n\n    // Validate page threshold\n    if (config.pageThreshold !== undefined && config.pageThreshold <= 0) {\n      throw new Error('ChunkingConfig validation error: pageThreshold must be greater than 0');\n    }\n\n    // Validate token threshold\n    if (config.tokenThreshold !== undefined && config.tokenThreshold <= 0) {\n      throw new Error('ChunkingConfig validation error: tokenThreshold must be greater than 0');\n    }\n\n    // Validate max tokens per chunk (for token-based strategy)\n    if (config.maxTokensPerChunk !== undefined && config.maxTokensPerChunk <= 0) {\n      throw new Error('ChunkingConfig validation error: maxTokensPerChunk must be greater than 0');\n    }\n\n    // Validate overlap tokens (for token-based and hybrid strategies)\n    if (config.overlapTokens !== undefined) {\n      if (config.overlapTokens < 0) {\n        throw new Error('ChunkingConfig validation error: overlapTokens must be non-negative');\n      }\n      const effectiveMaxTokens = config.maxTokensPerChunk || 100000; // default max tokens\n      if (config.overlapTokens >= effectiveMaxTokens) {\n        throw new Error('ChunkingConfig validation error: overlapTokens must be less than maxTokensPerChunk');\n      }\n    }\n\n    // Validate max pages per chunk (for hybrid strategy)\n    if (config.maxPagesPerChunk !== undefined && config.maxPagesPerChunk <= 0) {\n      throw new Error('ChunkingConfig validation error: maxPagesPerChunk must be greater than 0');\n    }\n\n    // Validate target tokens per chunk (for hybrid strategy)\n    if (config.targetTokensPerChunk !== undefined && config.targetTokensPerChunk <= 0) {\n      throw new Error('ChunkingConfig validation error: targetTokensPerChunk must be greater than 0');\n    }\n\n    // Validate max concurrency\n    if (config.maxConcurrency !== undefined && config.maxConcurrency <= 0) {\n      throw new Error('ChunkingConfig validation error: maxConcurrency must be greater than 0');\n    }\n\n    // Validate min success threshold\n    if (config.minSuccessThreshold !== undefined) {\n      if (config.minSuccessThreshold < 0 || config.minSuccessThreshold > 1) {\n        throw new Error('ChunkingConfig validation error: minSuccessThreshold must be between 0 and 1');\n      }\n    }\n  }\n\n  /**\n   * Implements the document classification step using Amazon Bedrock.\n   *\n   * Creates a Lambda function that invokes the configured Bedrock model to classify\n   * the document type. The function reads the document from S3 and sends it to\n   * Bedrock with the classification prompt.\n   *\n   * This method caches the Lambda function to avoid creating duplicate resources,\n   * but creates a new LambdaInvoke task each time to allow proper state chaining.\n   *\n   * @returns LambdaInvoke task configured for document classification\n   */\n  protected classificationStep(): DocumentProcessingStepType {\n    // Create Lambda function only once\n    if (!this._classificationFunction) {\n      const prompt = this.bedrockDocumentProcessingProps.classificationPrompt || BedrockDocumentProcessing.DEFAULT_CLASSIFICATION_PROMPT;\n      const adjustedModelId = BedrockModelUtils.deriveActualModelId(this.bedrockDocumentProcessingProps.classificationBedrockModel);\n      const role = this.generateLambdaRoleForBedrock('ClassificationLambdaRole', this.bedrockDocumentProcessingProps.classificationBedrockModel);\n      const { region, account } = Stack.of(this);\n      const generatedLogPermissions = LambdaIamUtils.createLogsPermissions({\n        account,\n        functionName: 'bedrock-idp-classification',\n        region,\n        scope: this,\n        enableObservability: this.bedrockDocumentProcessingProps.enableObservability,\n      });\n\n      this.encryptionKey.grantEncryptDecrypt(role);\n\n      this._classificationFunction = new PythonFunction(this, 'BedrockClassificationFunction', {\n        functionName: generatedLogPermissions.uniqueFunctionName,\n        architecture: Architecture.X86_64,\n        runtime: DefaultRuntimes.PYTHON,\n        entry: path.join(__dirname, 'resources/default-bedrock-invoke'),\n        role,\n        memorySize: 512,\n        timeout: this.bedrockDocumentProcessingProps.stepTimeouts || Duration.minutes(5),\n        environment: {\n          MODEL_ID: adjustedModelId,\n          PROMPT: prompt,\n          INVOKE_TYPE: 'classification',\n          ...PowertoolsConfig.generateDefaultLambdaConfig(\n            this.bedrockDocumentProcessingProps.enableObservability,\n            this.metricNamespace,\n            this.metricServiceName,\n          ),\n        },\n        environmentEncryption: this.encryptionKey,\n        vpc: this.bedrockDocumentProcessingProps.network\n          ? this.bedrockDocumentProcessingProps.network.vpc\n          : undefined,\n        vpcSubnets: this.bedrockDocumentProcessingProps.network\n          ? this.bedrockDocumentProcessingProps.network.applicationSubnetSelection()\n          : undefined,\n      });\n\n      for (const statement of generatedLogPermissions.policyStatements) {\n        this._classificationFunction.role?.addToPrincipalPolicy(statement);\n      }\n\n      if (this.bedrockDocumentProcessingProps.network) {\n        this._classificationFunction.role?.addToPrincipalPolicy(LambdaIamUtils.generateLambdaVPCPermissions());\n      }\n    }\n\n    // Always create a new LambdaInvoke task to allow proper state chaining\n    const stepId = `ClassificationStep-${this._classificationStepCounter}`;\n    this._classificationStepCounter++;\n\n    return new LambdaInvoke(this, stepId, {\n      lambdaFunction: this._classificationFunction,\n      resultPath: '$.classificationResult',\n      resultSelector: {\n        'documentClassification.$': '$.Payload.documentClassification',\n      },\n    });\n  }\n\n  /**\n   * Implements the document extraction step using Amazon Bedrock.\n   *\n   * Creates a Lambda function that invokes the configured Bedrock model to extract\n   * structured data from the document. Uses the classification result from the\n   * previous step to provide context for more accurate extraction.\n   *\n   * This method caches the Lambda function to avoid creating duplicate resources,\n   * but creates a new LambdaInvoke task each time to allow proper state chaining.\n   *\n   * @returns LambdaInvoke task configured for document extraction\n   */\n  protected processingStep(): DocumentProcessingStepType {\n    // Create Lambda function only once\n    if (!this._processingFunction) {\n      const prompt = this.bedrockDocumentProcessingProps.processingPrompt || BedrockDocumentProcessing.DEFAULT_PROCESSING_PROMPT;\n      const adjustedModelId = BedrockModelUtils.deriveActualModelId(this.bedrockDocumentProcessingProps.processingBedrockModel);\n      const role = this.generateLambdaRoleForBedrock('ProcessingLambdaRole', this.bedrockDocumentProcessingProps.processingBedrockModel);\n      const { region, account } = Stack.of(this);\n\n      const generatedLogPermissions = LambdaIamUtils.createLogsPermissions({\n        account,\n        functionName: 'bedrock-idp-processing',\n        region,\n        scope: this,\n      });\n      this.encryptionKey.grantEncryptDecrypt(role);\n      this._processingFunction = new PythonFunction(this, 'BedrockExtractionFunction', {\n        functionName: generatedLogPermissions.uniqueFunctionName,\n        runtime: DefaultRuntimes.PYTHON,\n        architecture: Architecture.X86_64,\n        entry: path.join(__dirname, 'resources/default-bedrock-invoke'),\n        role,\n        memorySize: 512,\n        timeout: this.bedrockDocumentProcessingProps.stepTimeouts || Duration.minutes(5),\n        environment: {\n          MODEL_ID: adjustedModelId,\n          PROMPT: prompt,\n          INVOKE_TYPE: 'processing',\n          ...PowertoolsConfig.generateDefaultLambdaConfig(\n            this.bedrockDocumentProcessingProps.enableObservability,\n            this.metricNamespace,\n            this.metricServiceName,\n          ),\n        },\n        environmentEncryption: this.encryptionKey,\n        vpc: this.bedrockDocumentProcessingProps.network\n          ? this.bedrockDocumentProcessingProps.network.vpc\n          : undefined,\n        vpcSubnets: this.bedrockDocumentProcessingProps.network\n          ? this.bedrockDocumentProcessingProps.network.applicationSubnetSelection()\n          : undefined,\n      });\n\n      for (const statement of generatedLogPermissions.policyStatements) {\n        this._processingFunction.role?.addToPrincipalPolicy(statement);\n      }\n\n      if (this.bedrockDocumentProcessingProps.network) {\n        this._processingFunction.role?.addToPrincipalPolicy(LambdaIamUtils.generateLambdaVPCPermissions());\n      }\n    }\n\n    // Always create a new LambdaInvoke task to allow proper state chaining\n    const stepId = `ProcessingStep-${this._processingStepCounter}`;\n    this._processingStepCounter++;\n\n    return new LambdaInvoke(this, stepId, {\n      lambdaFunction: this._processingFunction,\n      resultPath: '$.processingResult',\n      resultSelector: {\n        'documentClassification.$': '$.Payload.documentClassification',\n        'result.$': '$.Payload.result',\n      },\n    });\n  }\n\n  protected generateLambdaRoleForBedrock(id: string, model?: BedrockModelProps) {\n    return new Role(this, id, {\n      assumedBy: new ServicePrincipal('lambda.amazonaws.com'),\n      inlinePolicies: {\n        BedrockInvokePolicy: new PolicyDocument({\n          statements: [\n            // S3 read-only access for document retrieval - least privilege\n            ...this.ingressAdapter.generateAdapterIAMPolicies(),\n            BedrockModelUtils.generateModelIAMPermissions(this, model),\n          ],\n        }),\n      },\n    });\n  }\n\n  /**\n   * Implements the optional document enrichment step.\n   *\n   * If an enrichment Lambda function is provided in the props, creates a LambdaInvoke\n   * task to perform additional processing on the extracted data. This step is useful\n   * for data validation, transformation, or integration with external systems.\n   *\n   * @returns LambdaInvoke task for enrichment, or undefined to skip this step\n   */\n  protected enrichmentStep(): DocumentProcessingStepType | undefined {\n    if (!this.bedrockDocumentProcessingProps.enrichmentLambdaFunction) {\n      return undefined;\n    }\n\n    const stepId = `EnrichmentStep-${this._enrichmentStepCounter}`;\n    this._enrichmentStepCounter++;\n\n    return new LambdaInvoke(this, stepId, {\n      lambdaFunction: this.bedrockDocumentProcessingProps.enrichmentLambdaFunction,\n      resultPath: '$.enrichedResult',\n      outputPath: '$',\n      payloadResponseOnly: true,\n    });\n  }\n\n  /**\n   * Implements the optional post-processing step.\n   *\n   * If a post-processing Lambda function is provided in the props, creates a LambdaInvoke\n   * task to perform final processing on the workflow results. This step is useful for\n   * data formatting, notifications, or integration with downstream systems.\n   *\n   * @returns LambdaInvoke task for post-processing, or undefined to skip this step\n   */\n  protected postProcessingStep(): DocumentProcessingStepType | undefined {\n    if (!this.bedrockDocumentProcessingProps.postProcessingLambdaFunction) {\n      return undefined;\n    }\n\n    const stepId = `PostProcessingStep-${this._postProcessingStepCounter}`;\n    this._postProcessingStepCounter++;\n\n    return new LambdaInvoke(this, stepId, {\n      lambdaFunction: this.bedrockDocumentProcessingProps.postProcessingLambdaFunction,\n      resultPath: '$.postProcessedResult',\n      outputPath: '$',\n      payloadResponseOnly: true,\n    });\n  }\n\n\n  /**\n   * Implements the optional preprocessing step for PDF chunking.\n   *\n   * When chunking is enabled, creates a Lambda function that analyzes PDFs and\n   * splits large documents into manageable chunks. The function:\n   * 1. Analyzes the PDF to determine page count and token estimates\n   * 2. Decides if chunking is needed based on configured thresholds\n   * 3. If chunking is needed, splits the PDF and uploads chunks to S3\n   *\n   * @returns LambdaInvoke task for PDF analysis and chunking, or undefined if chunking is disabled\n   */\n  protected preprocessingStep(): DocumentProcessingStepType | undefined {\n    // Only enable chunking if explicitly configured\n    if (!this.bedrockDocumentProcessingProps.enableChunking) {\n      return undefined;\n    }\n\n    const { region, account } = Stack.of(this);\n    const chunkingConfig = this.bedrockDocumentProcessingProps.chunkingConfig || {};\n\n    // Create IAM role for chunking Lambda with least privilege permissions\n    // Chunking Lambda needs: GetObject (read raw PDFs), PutObject (write chunks)\n    const role = new Role(this, 'ChunkingLambdaRole', {\n      assumedBy: new ServicePrincipal('lambda.amazonaws.com'),\n      inlinePolicies: {\n        ChunkingPolicy: new PolicyDocument({\n          statements: [\n            ...this.ingressAdapter.generateAdapterIAMPolicies(),\n          ],\n        }),\n      },\n    });\n\n    const generatedLogPermissions = LambdaIamUtils.createLogsPermissions({\n      account,\n      functionName: 'bedrock-idp-chunking',\n      region,\n      scope: this,\n      enableObservability: this.bedrockDocumentProcessingProps.enableObservability,\n    });\n\n    this.encryptionKey.grantEncryptDecrypt(role);\n\n    // Create PDF Analysis & Chunking Lambda\n    const chunkingLambda = new PythonFunction(this, 'PDFChunkingFunction', {\n      functionName: generatedLogPermissions.uniqueFunctionName,\n      entry: path.join(__dirname, 'resources/pdf-chunking'),\n      index: 'handler.py',\n      handler: 'handler',\n      runtime: DefaultRuntimes.PYTHON,\n      architecture: Architecture.X86_64,\n      role,\n      memorySize: 2048,\n      timeout: Duration.minutes(10),\n      environment: {\n        CHUNKING_STRATEGY: chunkingConfig.strategy || 'hybrid',\n        PAGE_THRESHOLD: String(chunkingConfig.pageThreshold || 100),\n        TOKEN_THRESHOLD: String(chunkingConfig.tokenThreshold || 150000),\n        CHUNK_SIZE: String(chunkingConfig.chunkSize || 50),\n        OVERLAP_PAGES: String(chunkingConfig.overlapPages || 5),\n        MAX_TOKENS_PER_CHUNK: String(chunkingConfig.maxTokensPerChunk || 100000),\n        OVERLAP_TOKENS: String(chunkingConfig.overlapTokens || 5000),\n        TARGET_TOKENS_PER_CHUNK: String(chunkingConfig.targetTokensPerChunk || 80000),\n        MAX_PAGES_PER_CHUNK: String(chunkingConfig.maxPagesPerChunk || 99),\n        ...PowertoolsConfig.generateDefaultLambdaConfig(\n          this.bedrockDocumentProcessingProps.enableObservability,\n          this.metricNamespace,\n          this.metricServiceName,\n        ),\n      },\n      environmentEncryption: this.encryptionKey,\n      vpc: this.bedrockDocumentProcessingProps.network\n        ? this.bedrockDocumentProcessingProps.network.vpc\n        : undefined,\n      vpcSubnets: this.bedrockDocumentProcessingProps.network\n        ? this.bedrockDocumentProcessingProps.network.applicationSubnetSelection()\n        : undefined,\n    });\n\n    for (const statement of generatedLogPermissions.policyStatements) {\n      chunkingLambda.role?.addToPrincipalPolicy(statement);\n    }\n\n    if (this.bedrockDocumentProcessingProps.network) {\n      chunkingLambda.role?.addToPrincipalPolicy(LambdaIamUtils.generateLambdaVPCPermissions());\n    }\n\n    return new LambdaInvoke(this, 'PDFAnalysisAndChunking', {\n      lambdaFunction: chunkingLambda,\n      resultPath: '$.chunkingResult',\n      resultSelector: {\n        'requiresChunking.$': '$.Payload.requiresChunking',\n        'tokenAnalysis.$': '$.Payload.tokenAnalysis',\n        'strategy.$': '$.Payload.strategy',\n        'chunks.$': '$.Payload.chunks',\n      },\n    });\n  }\n\n  /**\n   * Provides additional metadata fields for chunking to be stored in DynamoDB.\n   *\n   * When chunking is enabled, adds fields for:\n   * - ChunkingEnabled: string representation of boolean flag\n   * - ChunkingStrategy: strategy used (fixed-pages, token-based, hybrid)\n   * - TokenAnalysis: JSON string with token analysis results\n   * - ChunkMetadata: JSON string array with chunk information\n   *\n   * @returns Record of DynamoDB attribute values for chunking metadata\n   */\n  protected preprocessingMetadata(): Record<string, DynamoAttributeValue> {\n    if (!this.bedrockDocumentProcessingProps.enableChunking) {\n      return {};\n    }\n\n    return {\n      ChunkingEnabled: DynamoAttributeValue.fromString(\n        JsonPath.stringAt('States.Format(\\'{}\\', $.chunkingResult.requiresChunking)'),\n      ),\n      ChunkingStrategy: DynamoAttributeValue.fromString(\n        JsonPath.stringAt('$.chunkingResult.strategy'),\n      ),\n      TokenAnalysis: DynamoAttributeValue.fromString(\n        JsonPath.jsonToString(JsonPath.objectAt('$.chunkingResult.tokenAnalysis')),\n      ),\n      ChunkMetadata: DynamoAttributeValue.fromString(\n        JsonPath.jsonToString(JsonPath.objectAt('$.chunkingResult.chunks')),\n      ),\n    };\n  }\n\n  /**\n   * Creates the processing workflow with conditional branching for chunked documents.\n   *\n   * When chunking is enabled, creates a Choice State that:\n   * - Routes to chunked processing flow if document was chunked\n   * - Routes to standard processing flow if document was not chunked\n   *\n   * When chunking is disabled, returns the standard processing workflow.\n   *\n   * @returns Step Functions chain for processing the document\n   */\n  protected createProcessingWorkflow(): IChainable {\n    // If chunking is not enabled, use standard workflow\n    if (!this.bedrockDocumentProcessingProps.enableChunking) {\n      return this.createStandardProcessingWorkflow();\n    }\n\n    // Create Choice State to check if chunking was applied\n    const choiceState = new Choice(this, 'CheckIfChunked');\n\n    choiceState\n      .when(\n        Condition.booleanEquals('$.chunkingResult.requiresChunking', true),\n        this.createChunkedProcessingFlow(),\n      )\n      .otherwise(\n        // Pass 'Standard' prefix to avoid construct ID collisions with chunked flow\n        this.createStandardProcessingWorkflow('Standard'),\n      );\n\n    return choiceState;\n  }\n\n\n  /**\n   * Creates the chunked processing flow for large documents.\n   *\n   * This flow:\n   * 1. Uses a Map State to process each chunk in parallel (or sequentially)\n   * 2. Each chunk goes through classification and processing\n   * 3. Results are aggregated using the aggregation Lambda\n   * 4. DynamoDB is updated with the aggregated result\n   * 5. Temporary chunks are cleaned up from S3\n   *\n   * @returns Step Functions chain for chunked document processing\n   */\n  private createChunkedProcessingFlow(): IChainable {\n    const chunkingConfig = this.bedrockDocumentProcessingProps.chunkingConfig || {};\n    const maxConcurrency = chunkingConfig.processingMode === 'sequential'\n      ? 1\n      : (chunkingConfig.maxConcurrency || 10);\n\n    // Create Map State for processing chunks\n    const mapState = new Map(this, 'ProcessChunks', {\n      itemsPath: '$.chunkingResult.chunks',\n      maxConcurrency,\n      parameters: {\n        'documentId.$': '$.documentId',\n        'chunk.$': '$$.Map.Item.Value',\n        'chunkIndex.$': '$$.Map.Item.Index',\n        'totalChunks.$': 'States.ArrayLength($.chunkingResult.chunks)',\n        // Override content to point to the chunk PDF, not the original document\n        'content': {\n          'location': 's3',\n          'bucket.$': '$$.Map.Item.Value.bucket',\n          'key.$': '$$.Map.Item.Value.key',\n          'filename.$': '$.content.filename',\n        },\n        'contentType.$': '$.contentType',\n      },\n      resultPath: '$.chunkResults',\n    });\n\n    // Define per-chunk processing: classification → processing\n    const chunkClassification = this.classificationStep();\n    const chunkProcessing = this.processingStep();\n\n    mapState.itemProcessor(\n      chunkClassification.next(chunkProcessing),\n    );\n\n    // Create aggregation step (Lambda invoke only, normalization added separately)\n    const aggregationLambdaStep = this.createAggregationStep();\n\n    // Add a Pass state to normalize the aggregated result for downstream compatibility\n    // This copies aggregatedResult to processingResult so enrichment/post-processing\n    // see a consistent structure regardless of whether chunking was used\n    const normalizeState = new Pass(this, 'NormalizeAggregatedResult', {\n      parameters: {\n        'documentId.$': '$.documentId',\n        'contentType.$': '$.contentType',\n        'content.$': '$.content',\n        'chunkingResult.$': '$.chunkingResult',\n        'chunkResults.$': '$.chunkResults',\n        'aggregatedResult.$': '$.aggregatedResult',\n        // Copy aggregated result to processingResult for downstream compatibility\n        'processingResult': {\n          'result.$': '$.aggregatedResult.result',\n        },\n        // Also set classificationResult from the first successful chunk for consistency\n        'classificationResult.$': '$.chunkResults[0].classificationResult',\n      },\n    });\n\n    // Create DynamoDB update step for aggregated result\n    const updateAggregatedResultStep = this.createUpdateAggregatedResultStep();\n\n    // Create cleanup step\n    const cleanupStep = this.createCleanupStep();\n\n    // Create move to processed chain with 'Chunked' prefix to avoid ID collisions\n    const moveToProcessed = this.ingressAdapter.createSuccessChain(this, 'Chunked');\n\n    // Create error handler for aggregation failures\n    const aggregationErrorHandler = this.createAggregationErrorHandler();\n\n    // Get optional enrichment and post-processing steps\n    const enrichmentStep = this.enrichmentStep();\n    const postProcessingStep = this.postProcessingStep();\n\n    // Build the final chain after aggregation\n    // Chain: Map State → Aggregation → DynamoDB Update → [Enrichment] → [PostProcessing] → Cleanup → Move to Processed\n    let finalChain: IChainable = cleanupStep\n      .addRetry({\n        errors: ['Lambda.ServiceException', 'Lambda.TooManyRequestsException'],\n        interval: Duration.seconds(2),\n        maxAttempts: 3,\n        backoffRate: 2,\n      })\n      .next(moveToProcessed);\n\n    // Add post-processing if provided (insert before cleanup)\n    if (postProcessingStep) {\n      const postProcessingErrorHandler = new DynamoUpdateItem(this, 'ChunkedPostProcessingFailDDBUpdate', {\n        table: this.documentProcessingTable,\n        key: {\n          DocumentId: DynamoAttributeValue.fromString(JsonPath.stringAt('$.documentId')),\n        },\n        updateExpression: 'SET WorkflowStatus = :newStatus',\n        expressionAttributeValues: {\n          ':newStatus': DynamoAttributeValue.fromString('post-processing-failure'),\n        },\n        resultPath: JsonPath.DISCARD,\n      }).next(this.ingressAdapter.createFailedChain(this, 'ChunkedPostProc'));\n\n      finalChain = postProcessingStep\n        .addCatch(postProcessingErrorHandler, {\n          resultPath: JsonPath.DISCARD,\n        })\n        .next(\n          new DynamoUpdateItem(this, 'ChunkedPostProcessingSuccessUpdate', {\n            table: this.documentProcessingTable,\n            key: {\n              DocumentId: DynamoAttributeValue.fromString(JsonPath.stringAt('$.documentId')),\n            },\n            updateExpression: 'SET WorkflowStatus = :newStatus, PostProcessingResult = :postProcessingResult',\n            expressionAttributeValues: {\n              ':newStatus': DynamoAttributeValue.fromString('post-processing-complete'),\n              ':postProcessingResult': DynamoAttributeValue.fromString(JsonPath.jsonToString(JsonPath.objectAt('$.postProcessedResult'))),\n            },\n            resultPath: JsonPath.DISCARD,\n          }).next(finalChain),\n        );\n    }\n\n    // Add enrichment if provided (insert before post-processing or cleanup)\n    if (enrichmentStep) {\n      const enrichmentErrorHandler = new DynamoUpdateItem(this, 'ChunkedEnrichmentFailDDBUpdate', {\n        table: this.documentProcessingTable,\n        key: {\n          DocumentId: DynamoAttributeValue.fromString(JsonPath.stringAt('$.documentId')),\n        },\n        updateExpression: 'SET WorkflowStatus = :newStatus',\n        expressionAttributeValues: {\n          ':newStatus': DynamoAttributeValue.fromString('enrichment-failure'),\n        },\n        resultPath: JsonPath.DISCARD,\n      }).next(this.ingressAdapter.createFailedChain(this, 'ChunkedEnrich'));\n\n      finalChain = enrichmentStep\n        .addCatch(enrichmentErrorHandler, {\n          resultPath: JsonPath.DISCARD,\n        })\n        .next(\n          new DynamoUpdateItem(this, 'ChunkedEnrichmentSuccessUpdate', {\n            table: this.documentProcessingTable,\n            key: {\n              DocumentId: DynamoAttributeValue.fromString(JsonPath.stringAt('$.documentId')),\n            },\n            updateExpression: 'SET WorkflowStatus = :newStatus, EnrichmentResult = :enrichmentResult',\n            expressionAttributeValues: {\n              ':newStatus': postProcessingStep\n                ? DynamoAttributeValue.fromString('enrichment-complete')\n                : DynamoAttributeValue.fromString('complete'),\n              ':enrichmentResult': DynamoAttributeValue.fromString(JsonPath.jsonToString(JsonPath.objectAt('$.enrichedResult'))),\n            },\n            resultPath: JsonPath.DISCARD,\n          }).next(finalChain),\n        );\n    }\n\n    // Chain: Map State → Aggregation → Normalize → DynamoDB Update → [Enrichment] → [PostProcessing] → Cleanup → Move to Processed\n    return mapState\n      .addCatch(aggregationErrorHandler, {\n        resultPath: '$.error',\n      })\n      .next(\n        aggregationLambdaStep\n          .addCatch(aggregationErrorHandler, {\n            resultPath: '$.error',\n          })\n          .addRetry({\n            errors: ['Lambda.ServiceException', 'Lambda.TooManyRequestsException'],\n            interval: Duration.seconds(2),\n            maxAttempts: 3,\n            backoffRate: 2,\n          })\n          .next(\n            normalizeState.next(\n              updateAggregatedResultStep\n                .addRetry({\n                  errors: ['DynamoDB.ProvisionedThroughputExceededException'],\n                  interval: Duration.seconds(1),\n                  maxAttempts: 3,\n                  backoffRate: 2,\n                })\n                .next(finalChain),\n            ),\n          ),\n      );\n  }\n\n  /**\n   * Creates the aggregation step for combining chunk results using Bedrock.\n   *\n   * Uses the same Bedrock invoke Lambda pattern as the processing step but with\n   * a different prompt designed for aggregating multiple chunk results.\n   * The chunk processing results are passed as text data to the model.\n   *\n   * @returns LambdaInvoke task for result aggregation\n   */\n  private createAggregationStep(): LambdaInvoke {\n    // Create Lambda function only once (reuses bedrock-invoke pattern)\n    if (!this._aggregationFunction) {\n      const prompt = this.bedrockDocumentProcessingProps.aggregationPrompt || BedrockDocumentProcessing.DEFAULT_AGGREGATION_PROMPT;\n      const adjustedModelId = BedrockModelUtils.deriveActualModelId(this.bedrockDocumentProcessingProps.processingBedrockModel);\n      const role = this.generateLambdaRoleForBedrock('AggregationLambdaRole', this.bedrockDocumentProcessingProps.processingBedrockModel);\n      const { region, account } = Stack.of(this);\n\n      const generatedLogPermissions = LambdaIamUtils.createLogsPermissions({\n        account,\n        functionName: 'bedrock-idp-aggregation',\n        region,\n        scope: this,\n        enableObservability: this.bedrockDocumentProcessingProps.enableObservability,\n      });\n\n      this.encryptionKey.grantEncryptDecrypt(role);\n\n      this._aggregationFunction = new PythonFunction(this, 'BedrockAggregationFunction', {\n        functionName: generatedLogPermissions.uniqueFunctionName,\n        architecture: Architecture.X86_64,\n        runtime: DefaultRuntimes.PYTHON,\n        entry: path.join(__dirname, 'resources/default-bedrock-invoke'),\n        role,\n        memorySize: 1024,\n        timeout: this.bedrockDocumentProcessingProps.stepTimeouts || Duration.minutes(5),\n        environment: {\n          MODEL_ID: adjustedModelId,\n          PROMPT: prompt,\n          INVOKE_TYPE: 'aggregation',\n          INVOKE_MAX_TOKENS: '64000', // Aggregation may need more tokens for merged output\n          ...PowertoolsConfig.generateDefaultLambdaConfig(\n            this.bedrockDocumentProcessingProps.enableObservability,\n            this.metricNamespace,\n            this.metricServiceName,\n          ),\n        },\n        environmentEncryption: this.encryptionKey,\n        vpc: this.bedrockDocumentProcessingProps.network\n          ? this.bedrockDocumentProcessingProps.network.vpc\n          : undefined,\n        vpcSubnets: this.bedrockDocumentProcessingProps.network\n          ? this.bedrockDocumentProcessingProps.network.applicationSubnetSelection()\n          : undefined,\n      });\n\n      for (const statement of generatedLogPermissions.policyStatements) {\n        this._aggregationFunction.role?.addToPrincipalPolicy(statement);\n      }\n\n      if (this.bedrockDocumentProcessingProps.network) {\n        this._aggregationFunction.role?.addToPrincipalPolicy(LambdaIamUtils.generateLambdaVPCPermissions());\n      }\n    }\n\n    // Always create a new LambdaInvoke task to allow proper state chaining\n    const stepId = `AggregationStep-${this._aggregationStepCounter}`;\n    this._aggregationStepCounter++;\n\n    // Pass chunk results as data content - the Lambda will format them for Bedrock\n    return new LambdaInvoke(this, stepId, {\n      lambdaFunction: this._aggregationFunction,\n      payload: TaskInput.fromObject({\n        'documentId.$': '$.documentId',\n        'contentType': 'data',\n        'content': {\n          // Pass the chunk results as JSON string for the Lambda to process\n          'data.$': 'States.JsonToString($.chunkResults)',\n        },\n      }),\n      // Store in both aggregatedResult AND processingResult for consistency with non-chunked flow\n      // This allows enrichment/post-processing steps to use $.processingResult regardless of chunking\n      resultPath: '$.aggregatedResult',\n      resultSelector: {\n        'result.$': '$.Payload.result',\n      },\n    });\n  }\n\n  /**\n   * Creates the DynamoDB update step for storing aggregated results.\n   *\n   * Updates the document record with:\n   * - AggregatedResult: JSON string with classification, entities, and summary\n   * - WorkflowStatus: 'complete'\n   *\n   * @returns DynamoUpdateItem task for storing aggregated results\n   */\n  private createUpdateAggregatedResultStep(): DynamoUpdateItem {\n    return new DynamoUpdateItem(this, 'StoreAggregatedResult', {\n      table: this.documentProcessingTable,\n      key: {\n        DocumentId: DynamoAttributeValue.fromString(JsonPath.stringAt('$.documentId')),\n      },\n      updateExpression: 'SET AggregatedResult = :result, WorkflowStatus = :status',\n      expressionAttributeValues: {\n        ':result': DynamoAttributeValue.fromString(\n          JsonPath.jsonToString(JsonPath.objectAt('$.aggregatedResult')),\n        ),\n        ':status': DynamoAttributeValue.fromString('complete'),\n      },\n      resultPath: JsonPath.DISCARD,\n    });\n  }\n\n  /**\n   * Creates the cleanup Lambda step for removing temporary chunk files.\n   *\n   * The cleanup Lambda:\n   * - Deletes all chunk files from S3 chunks/ prefix\n   * - Uses batch delete for efficiency (up to 1000 objects per request)\n   * - Logs errors but doesn't fail the workflow\n   *\n   * @returns LambdaInvoke task for chunk cleanup\n   */\n  private createCleanupStep(): LambdaInvoke {\n    // Create Lambda function only once\n    if (!this._cleanupFunction) {\n      const { region, account } = Stack.of(this);\n\n      const role = new Role(this, 'CleanupLambdaRole', {\n        assumedBy: new ServicePrincipal('lambda.amazonaws.com'),\n        inlinePolicies: {\n          CleanupPolicy: new PolicyDocument({\n            statements: [\n              // S3 access for deleting chunks only - least privilege\n              ...this.ingressAdapter.generateAdapterIAMPolicies(['s3:DeleteObject'], true),\n            ],\n          }),\n        },\n      });\n\n      const generatedLogPermissions = LambdaIamUtils.createLogsPermissions({\n        account,\n        functionName: 'bedrock-idp-cleanup',\n        region,\n        scope: this,\n        enableObservability: this.bedrockDocumentProcessingProps.enableObservability,\n      });\n\n      this.encryptionKey.grantEncryptDecrypt(role);\n\n      this._cleanupFunction = new PythonFunction(this, 'CleanupFunction', {\n        functionName: generatedLogPermissions.uniqueFunctionName,\n        entry: path.join(__dirname, 'resources/cleanup'),\n        index: 'handler.py',\n        handler: 'handler',\n        runtime: DefaultRuntimes.PYTHON,\n        architecture: Architecture.X86_64,\n        role,\n        memorySize: 512,\n        timeout: Duration.minutes(5),\n        environment: {\n          ...PowertoolsConfig.generateDefaultLambdaConfig(\n            this.bedrockDocumentProcessingProps.enableObservability,\n            this.metricNamespace,\n            this.metricServiceName,\n          ),\n        },\n        environmentEncryption: this.encryptionKey,\n        vpc: this.bedrockDocumentProcessingProps.network\n          ? this.bedrockDocumentProcessingProps.network.vpc\n          : undefined,\n        vpcSubnets: this.bedrockDocumentProcessingProps.network\n          ? this.bedrockDocumentProcessingProps.network.applicationSubnetSelection()\n          : undefined,\n      });\n\n      for (const statement of generatedLogPermissions.policyStatements) {\n        this._cleanupFunction.role?.addToPrincipalPolicy(statement);\n      }\n\n      if (this.bedrockDocumentProcessingProps.network) {\n        this._cleanupFunction.role?.addToPrincipalPolicy(LambdaIamUtils.generateLambdaVPCPermissions());\n      }\n    }\n\n    return new LambdaInvoke(this, 'CleanupChunks', {\n      lambdaFunction: this._cleanupFunction,\n      payload: TaskInput.fromObject({\n        'documentId.$': '$.documentId',\n        'chunks.$': '$.chunkingResult.chunks',\n      }),\n      resultPath: JsonPath.DISCARD,\n    });\n  }\n\n  /**\n   * Creates the error handler for aggregation failures.\n   *\n   * When aggregation fails:\n   * - Updates DynamoDB with 'aggregation-failure' status\n   * - Moves document to failed/ prefix\n   *\n   * @returns Step Functions chain for handling aggregation errors\n   */\n  private createAggregationErrorHandler(): IChainable {\n    const updateFailureStatus = new DynamoUpdateItem(this, 'AggregationFailDDBUpdate', {\n      table: this.documentProcessingTable,\n      key: {\n        DocumentId: DynamoAttributeValue.fromString(JsonPath.stringAt('$.documentId')),\n      },\n      updateExpression: 'SET WorkflowStatus = :newStatus',\n      expressionAttributeValues: {\n        ':newStatus': DynamoAttributeValue.fromString('aggregation-failure'),\n      },\n      resultPath: JsonPath.DISCARD,\n    });\n\n    // Use 'Chunked' prefix to avoid ID collisions with standard workflow\n    const moveToFailed = this.ingressAdapter.createFailedChain(this, 'Chunked');\n\n    return updateFailureStatus.next(moveToFailed);\n  }\n}\n"]}