@cdklabs/cdk-appmod-catalog-blueprints 1.16.0 → 1.17.0

package/lib/document-processing/localstack-agentic-document-processing.js

@@ -0,0 +1,66 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalStackAgenticDocumentProcessing = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const path = require("path");
+const aws_lambda_1 = require("aws-cdk-lib/aws-lambda");
+const aws_stepfunctions_tasks_1 = require("aws-cdk-lib/aws-stepfunctions-tasks");
+const agentic_document_processing_1 = require("./agentic-document-processing");
+const localstack_batch_agent_1 = require("../framework/agents/localstack-batch-agent");
+const localstack_1 = require("../framework/localstack");
+class LocalStackAgenticDocumentProcessing extends agentic_document_processing_1.AgenticDocumentProcessing {
+    constructor(scope, id, props) {
+        super(scope, id, {
+            ...props,
+            _skipBedrockVpcEndpoints: true,
+        });
+        this.applyLocalStackEnvironment(props.localStack || {});
+    }
+    resolveBedrockInvokeEntry() {
+        return path.join(__dirname, 'resources/default-localstack-invoke');
+    }
+    processingStep() {
+        if (!this._localStackBatchAgent) {
+            const agentProps = this.bedrockDocumentProcessingProps;
+            const processingAgentProps = agentProps.processingAgentParameters;
+            this._localStackBatchAgent = new localstack_batch_agent_1.LocalStackBatchAgent(this, 'IDPLocalStackBatchAgent', {
+                ...processingAgentProps,
+                localStack: agentProps.localStack,
+            });
+            const adapterPolicyStatements = this.ingressAdapter.generateAdapterIAMPolicies();
+            for (const statement of adapterPolicyStatements) {
+                this._localStackBatchAgent.agentRole.addToPrincipalPolicy(statement);
+            }
+        }
+        if (this._localStackProcessingStepCounter === undefined) {
+            this._localStackProcessingStepCounter = 0;
+        }
+        const stepId = `ProcessingStep-${this._localStackProcessingStepCounter}`;
+        this._localStackProcessingStepCounter++;
+        return new aws_stepfunctions_tasks_1.LambdaInvoke(this, stepId, {
+            lambdaFunction: this._localStackBatchAgent.agentFunction,
+            resultPath: '$.processingResult',
+            resultSelector: {
+                'result.$': '$.Payload.result',
+            },
+        });
+    }
+    applyLocalStackEnvironment(localStack) {
+        const localStackEnv = localstack_1.LocalStackIntegrationUtils.toLambdaEnvironment({
+            enabled: true,
+            ...localStack,
+        });
+        for (const child of this.node.findAll()) {
+            if (child instanceof aws_lambda_1.Function) {
+                for (const [key, value] of Object.entries(localStackEnv)) {
+                    child.addEnvironment(key, value);
+                }
+            }
+        }
+    }
+}
+exports.LocalStackAgenticDocumentProcessing = LocalStackAgenticDocumentProcessing;
+_a = JSII_RTTI_SYMBOL_1;
+LocalStackAgenticDocumentProcessing[_a] = { fqn: "@cdklabs/cdk-appmod-catalog-blueprints.LocalStackAgenticDocumentProcessing", version: "1.17.0" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/document-processing/localstack-bedrock-document-processing.d.ts

@@ -0,0 +1,16 @@
+import { Construct } from 'constructs';
+import { BedrockDocumentProcessing, BedrockDocumentProcessingProps } from './bedrock-document-processing';
+import { LocalStackEndpointOverrides } from '../framework/localstack';
+export interface LocalStackBedrockDocumentProcessingProps extends BedrockDocumentProcessingProps {
+    /**
+     * LocalStack endpoint routing configuration for Lambda runtime SDK calls.
+     *
+     * @default { enabled: true }
+     */
+    readonly localStack?: LocalStackEndpointOverrides;
+}
+export declare class LocalStackBedrockDocumentProcessing extends BedrockDocumentProcessing {
+    constructor(scope: Construct, id: string, props: LocalStackBedrockDocumentProcessingProps);
+    protected resolveBedrockInvokeEntry(): string;
+    private applyLocalStackEnvironment;
+}

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

@@ -0,0 +1,38 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalStackBedrockDocumentProcessing = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const path = require("path");
+const aws_lambda_1 = require("aws-cdk-lib/aws-lambda");
+const bedrock_document_processing_1 = require("./bedrock-document-processing");
+const localstack_1 = require("../framework/localstack");
+class LocalStackBedrockDocumentProcessing extends bedrock_document_processing_1.BedrockDocumentProcessing {
+    constructor(scope, id, props) {
+        super(scope, id, {
+            ...props,
+            _skipBedrockVpcEndpoints: true,
+        });
+        this.applyLocalStackEnvironment(props.localStack);
+    }
+    resolveBedrockInvokeEntry() {
+        return path.join(__dirname, 'resources/default-localstack-invoke');
+    }
+    applyLocalStackEnvironment(localStack) {
+        const localStackEnv = localstack_1.LocalStackIntegrationUtils.toLambdaEnvironment({
+            enabled: true,
+            ...localStack,
+        });
+        for (const child of this.node.findAll()) {
+            if (child instanceof aws_lambda_1.Function) {
+                for (const [key, value] of Object.entries(localStackEnv)) {
+                    child.addEnvironment(key, value);
+                }
+            }
+        }
+    }
+}
+exports.LocalStackBedrockDocumentProcessing = LocalStackBedrockDocumentProcessing;
+_a = JSII_RTTI_SYMBOL_1;
+LocalStackBedrockDocumentProcessing[_a] = { fqn: "@cdklabs/cdk-appmod-catalog-blueprints.LocalStackBedrockDocumentProcessing", version: "1.17.0" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/document-processing/resources/cleanup/handler.py

@@ -36,8 +36,23 @@ except ImportError:
 logger = logging.getLogger()
 logger.setLevel(os.environ.get('LOG_LEVEL', 'INFO'))
 
+def _resolve_endpoint_url(*service_env_keys: str) -> str | None:
+    for key in service_env_keys:
+        endpoint = os.getenv(key)
+        if endpoint:
+            return endpoint
+    return None
+
+
+def _create_boto3_client(service_name: str, *service_env_keys: str):
+    endpoint_url = _resolve_endpoint_url(*service_env_keys, 'AWS_ENDPOINT_URL')
+    if endpoint_url:
+        return boto3.client(service_name, endpoint_url=endpoint_url)
+    return boto3.client(service_name)
+
+
 # Initialize S3 client
-s3_client = boto3.client('s3')
+s3_client = _create_boto3_client('s3', 'AWS_ENDPOINT_URL_S3')
 
 
 def handler(event: Dict[str, Any], context: Any) -> Dict[str, Any]:

package/lib/document-processing/resources/default-localstack-invoke/index.py

@@ -0,0 +1,184 @@
+import base64
+import logging
+import os
+from aws_lambda_powertools import Metrics, Tracer
+from aws_lambda_powertools.metrics import MetricUnit
+
+from provider_runtime import (
+    MODEL_PROVIDER_OLLAMA,
+    create_boto3_client,
+    extract_pdf_text_for_ollama,
+    invoke_model,
+    normalize_model_response,
+    resolve_model_provider,
+)
+
+s3 = create_boto3_client('s3', 'AWS_ENDPOINT_URL_S3')
+bedrock = create_boto3_client('bedrock-runtime', 'AWS_ENDPOINT_URL_BEDROCK_RUNTIME')
+metrics = Metrics()
+tracer = Tracer()
+logger = logging.getLogger()
+logger.setLevel(os.getenv('LOG_LEVEL', 'INFO').upper())
+
+
+def parse_chunk_metadata(event):
+    """
+    Parse optional chunk metadata from the event payload.
+    
+    Returns a dictionary with chunk information if present, None otherwise.
+    Supports both direct chunk metadata and nested chunk object format.
+    """
+    # Check for direct chunkMetadata field
+    if 'chunkMetadata' in event:
+        return event['chunkMetadata']
+    
+    # Check for chunk object (from Map State iteration)
+    if 'chunk' in event:
+        chunk = event['chunk']
+        return {
+            'chunkIndex': chunk.get('chunkIndex', event.get('chunkIndex', 0)),
+            'totalChunks': event.get('totalChunks', 1),
+            'startPage': chunk.get('startPage', 0),
+            'endPage': chunk.get('endPage', 0),
+            'pageCount': chunk.get('pageCount', 0),
+            'estimatedTokens': chunk.get('estimatedTokens', 0),
+            'overlapPages': chunk.get('overlapPages', 0),
+        }
+    
+    return None
+
+
+def build_chunk_context_prompt(chunk_metadata):
+    """
+    Build a context prompt for chunk-aware processing.
+    
+    Args:
+        chunk_metadata: Dictionary containing chunk information
+        
+    Returns:
+        String with chunk context to prepend to the main prompt
+    """
+    if not chunk_metadata:
+        return ""
+    
+    chunk_index = chunk_metadata.get('chunkIndex', 0)
+    total_chunks = chunk_metadata.get('totalChunks', 1)
+    start_page = chunk_metadata.get('startPage', 0)
+    end_page = chunk_metadata.get('endPage', 0)
+    overlap_pages = chunk_metadata.get('overlapPages', 0)
+    
+    # Build context string
+    context_parts = [
+        f"You are analyzing chunk {chunk_index + 1} of {total_chunks} from pages {start_page + 1} to {end_page + 1}."
+    ]
+    
+    # Add overlap information if applicable
+    if overlap_pages > 0 and chunk_index > 0:
+        context_parts.append(
+            f"Note: This chunk includes {overlap_pages} overlapping pages from the previous chunk for context."
+        )
+    
+    return "\n".join(context_parts) + "\n\n"
+
+
+@metrics.log_metrics
+@tracer.capture_lambda_handler
+def handler(event, context):
+    invoke_type = os.environ["INVOKE_TYPE"]
+    tracer.put_annotation(key="invoke_type", value=invoke_type)
+    tracer.put_annotation(key="documentId", value=event["documentId"])
+    metrics.add_dimension(name="invoke_type", value=invoke_type)
+    content_type = event["contentType"]
+    
+    # Parse optional chunk metadata
+    chunk_metadata = parse_chunk_metadata(event)
+    if chunk_metadata:
+        tracer.put_annotation(key="chunkIndex", value=str(chunk_metadata.get('chunkIndex', 0)))
+        tracer.put_annotation(key="totalChunks", value=str(chunk_metadata.get('totalChunks', 1)))
+        metrics.add_dimension(name="is_chunked", value="true")
+    else:
+        metrics.add_dimension(name="is_chunked", value="false")
+    
+    # Format prompt if classification result exists
+    prompt = os.environ['PROMPT']
+    if 'classificationResult' in event:
+        classification = event['classificationResult']['documentClassification']
+        prompt = prompt.replace("[ACTUAL_CLASSIFICATION]", classification)
+    
+    # Add chunk context to prompt if processing a chunk
+    chunk_context = build_chunk_context_prompt(chunk_metadata)
+    if chunk_context:
+        prompt = chunk_context + prompt
+
+    model_provider = resolve_model_provider()
+    
+    # Build content based on file type
+    content = [{'type': 'text', 'text': prompt}]
+    if content_type == 'file':
+        content_location = event['content']['location']
+        
+        if content_location == 's3':
+            # Use chunk-specific S3 location if available, otherwise use original content
+            if chunk_metadata and 'bucket' in chunk_metadata and 'key' in chunk_metadata:
+                bucket = chunk_metadata['bucket']
+                key = chunk_metadata['key']
+            else:
+                bucket = event['content']['bucket']
+                key = event['content']['key']
+            
+            # Check file type
+            ext = key.lower().split('.')[-1]
+            if ext not in ['jpg', 'jpeg', 'png', 'pdf']:
+                raise ValueError(f"Unsupported file type: {ext}")
+            
+            media_type = {'jpg': 'image/jpeg', 'jpeg': 'image/jpeg', 'png': 'image/png', 'pdf': 'application/pdf'}[ext]
+            
+            # Download file to /tmp
+            local_path = f"/tmp/{key.split('/')[-1]}"
+            s3.download_file(bucket, key, local_path)
+
+            if model_provider == MODEL_PROVIDER_OLLAMA:
+                if ext == 'pdf':
+                    extracted_text = extract_pdf_text_for_ollama(local_path)
+                    if extracted_text:
+                        content.append({
+                            'type': 'text',
+                            'text': f'Document text extract:\n\n{extracted_text}'
+                        })
+                    else:
+                        content.append({
+                            'type': 'text',
+                            'text': (
+                                'Document is PDF, but text extraction returned no content. '
+                                'Classify based on any other provided context.'
+                            )
+                        })
+                else:
+                    content.append({
+                        'type': 'text',
+                        'text': (
+                            f'Input includes an image ({media_type}). '
+                            'Direct Ollama mode does not attach image bytes in this workflow.'
+                        )
+                    })
+            else:
+                # Read and encode file
+                with open(local_path, 'rb') as f:
+                    file_data = base64.b64encode(f.read()).decode('utf-8')
+
+                if ext == 'pdf':
+                    content.append({'type': 'document', 'source': {'type': 'base64', 'media_type': media_type, 'data': file_data}})
+                else:
+                    content.append({'type': 'image', 'source': {'type': 'base64', 'media_type': media_type, 'data': file_data}})
+    
+    elif content_type == 'data':
+        content.append({
+            'type': 'text',
+            'text': event['content']['data']
+        })
+
+    model_id = os.environ['MODEL_ID']
+    max_tokens = int(os.getenv('INVOKE_MAX_TOKENS', '1000'))
+    response_text = invoke_model(content, max_tokens, model_id, bedrock, logger)
+    metrics.add_metric(name="SuccessfulInvocation", unit=MetricUnit.Count, value=1)
+    return normalize_model_response(response_text, invoke_type)

package/lib/document-processing/resources/default-localstack-invoke/provider_runtime.py

@@ -0,0 +1,251 @@
+import json
+import logging
+import os
+import re
+from typing import Any, Dict, Optional
+from urllib import error as urllib_error
+from urllib import request as urllib_request
+
+import boto3
+
+MODEL_PROVIDER_BEDROCK = 'bedrock'
+MODEL_PROVIDER_OLLAMA = 'ollama'
+DEFAULT_MODEL_PROVIDER = MODEL_PROVIDER_BEDROCK
+DEFAULT_OLLAMA_BASE_URL = 'http://host.docker.internal:11434'
+OLLAMA_CHAT_PATH = '/api/chat'
+
+JSON_CODE_BLOCK_PATTERN = re.compile(r'```(?:json)?\s*({.*?})\s*```', re.DOTALL)
+JSON_OBJECT_PATTERN = re.compile(r'({[^{}]*(?:{[^{}]*}[^{}]*)*})', re.DOTALL)
+MAX_OLLAMA_DOCUMENT_CONTEXT_CHARS = 12000
+MAX_DEBUG_PAYLOAD_CHARS = int(os.getenv('DEBUG_OLLAMA_MAX_CHARS', '4000'))
+
+
+def _resolve_endpoint_url(*service_env_keys: str) -> Optional[str]:
+    for key in service_env_keys:
+        endpoint = os.getenv(key)
+        if endpoint:
+            return endpoint
+    return None
+
+
+def create_boto3_client(service_name: str, *service_env_keys: str):
+    endpoint_url = _resolve_endpoint_url(*service_env_keys, 'AWS_ENDPOINT_URL')
+    if endpoint_url:
+        return boto3.client(service_name, endpoint_url=endpoint_url)
+    return boto3.client(service_name)
+
+
+def _is_truthy_env(var_name: str) -> bool:
+    return os.getenv(var_name, '').strip().lower() in {'1', 'true', 'yes', 'on'}
+
+
+def _debug_ollama_enabled() -> bool:
+    return _is_truthy_env('DEBUG_OLLAMA_PAYLOAD')
+
+
+def _truncate_for_debug(text: str, max_chars: int = MAX_DEBUG_PAYLOAD_CHARS) -> str:
+    if len(text) <= max_chars:
+        return text
+    return f'{text[:max_chars]}...[truncated]'
+
+
+def resolve_model_provider() -> str:
+    provider = os.getenv('MODEL_PROVIDER', DEFAULT_MODEL_PROVIDER).strip().lower()
+    if provider in {MODEL_PROVIDER_BEDROCK, MODEL_PROVIDER_OLLAMA}:
+        return provider
+    return DEFAULT_MODEL_PROVIDER
+
+
+def _resolve_ollama_model_id(model_id: str) -> str:
+    explicit_model = os.getenv('OLLAMA_MODEL_ID')
+    if explicit_model:
+        return explicit_model
+    if model_id.startswith('ollama.'):
+        return model_id.split('ollama.', 1)[1]
+    if model_id.startswith('ollama/'):
+        return model_id.split('ollama/', 1)[1]
+    return model_id
+
+
+def _extract_json_object(response_text: str) -> Optional[Dict[str, Any]]:
+    text = response_text.strip()
+    if not text:
+        return None
+
+    try:
+        parsed = json.loads(text)
+        if isinstance(parsed, dict):
+            return parsed
+    except json.JSONDecodeError:
+        pass
+
+    candidates: list[tuple[Dict[str, Any], int]] = []
+
+    for json_code_block in JSON_CODE_BLOCK_PATTERN.finditer(response_text):
+        try:
+            parsed = json.loads(json_code_block.group(1))
+            if isinstance(parsed, dict):
+                candidates.append((parsed, json_code_block.end()))
+        except json.JSONDecodeError:
+            pass
+
+    for raw_json in JSON_OBJECT_PATTERN.finditer(response_text):
+        try:
+            parsed = json.loads(raw_json.group(1))
+            if isinstance(parsed, dict):
+                candidates.append((parsed, raw_json.end()))
+        except json.JSONDecodeError:
+            pass
+
+    if candidates:
+        return max(candidates, key=lambda candidate: candidate[1])[0]
+
+    return None
+
+
+def normalize_model_response(response_text: str, invoke_type: str) -> Dict[str, Any]:
+    parsed = _extract_json_object(response_text)
+    if parsed is None:
+        if invoke_type == 'classification':
+            return {'documentClassification': 'UNKNOWN'}
+        return {'raw_response': response_text}
+
+    if invoke_type == 'classification' and 'documentClassification' not in parsed:
+        classification = parsed.get('classification') or parsed.get('document_type') or parsed.get('type')
+        parsed['documentClassification'] = classification or 'UNKNOWN'
+
+    return parsed
+
+
+def _build_ollama_prompt(content: list[Dict[str, Any]]) -> str:
+    prompt_parts = []
+    for item in content:
+        item_type = item.get('type')
+        if item_type == 'text':
+            prompt_parts.append(item.get('text', ''))
+            continue
+
+        if item_type in {'document', 'image'}:
+            source = item.get('source', {})
+            media_type = source.get('media_type', 'application/octet-stream')
+            prompt_parts.append(
+                f"[Attached {item_type} with media type '{media_type}' omitted in direct Ollama mode.]",
+            )
+
+    return '\n\n'.join(part for part in prompt_parts if part)
+
+
+def extract_pdf_text_for_ollama(local_path: str) -> str:
+    """Extract text from a PDF file for direct Ollama prompt mode."""
+    try:
+        from PyPDF2 import PdfReader
+    except ImportError:
+        return ''
+
+    text_parts: list[str] = []
+    try:
+        reader = PdfReader(local_path)
+        for page in reader.pages:
+            page_text = page.extract_text() or ''
+            if page_text:
+                text_parts.append(page_text.strip())
+            if sum(len(part) for part in text_parts) >= MAX_OLLAMA_DOCUMENT_CONTEXT_CHARS:
+                break
+    except Exception:
+        return ''
+
+    joined = '\n\n'.join(part for part in text_parts if part)
+    if len(joined) > MAX_OLLAMA_DOCUMENT_CONTEXT_CHARS:
+        return f'{joined[:MAX_OLLAMA_DOCUMENT_CONTEXT_CHARS]}\n\n[Document text truncated]'
+    return joined
+
+
+def _invoke_bedrock_model(content: list[Dict[str, Any]], max_tokens: int, model_id: str, bedrock_client) -> str:
+    response = bedrock_client.invoke_model(
+        modelId=model_id,
+        body=json.dumps({
+            'anthropic_version': 'bedrock-2023-05-31',
+            'max_tokens': max_tokens,
+            'messages': [{'role': 'user', 'content': content}],
+        }),
+    )
+    response_payload = response['body'].read()
+    parsed_response = json.loads(response_payload)
+    return parsed_response['content'][0]['text']
+
+
+def _invoke_ollama_model(content: list[Dict[str, Any]], max_tokens: int, model_id: str, logger: logging.Logger) -> str:
+    ollama_base_url = os.getenv('OLLAMA_BASE_URL', DEFAULT_OLLAMA_BASE_URL).rstrip('/')
+    ollama_model_id = _resolve_ollama_model_id(model_id)
+    ollama_prompt = _build_ollama_prompt(content)
+    ollama_num_ctx = os.getenv('OLLAMA_NUM_CTX')
+
+    options: Dict[str, Any] = {
+        'num_predict': max_tokens,
+    }
+    if ollama_num_ctx:
+        try:
+            options['num_ctx'] = int(ollama_num_ctx)
+        except ValueError:
+            logger.warning('Ignoring invalid OLLAMA_NUM_CTX value: %s', ollama_num_ctx)
+
+    request_payload: Dict[str, Any] = {
+        'model': ollama_model_id,
+        'messages': [{'role': 'user', 'content': ollama_prompt}],
+        'stream': False,
+        'options': options,
+    }
+    request_body = json.dumps(request_payload).encode('utf-8')
+
+    if _debug_ollama_enabled():
+        logger.info(
+            'Ollama request debug: model=%s base_url=%s prompt_len=%s request=%s',
+            ollama_model_id,
+            ollama_base_url,
+            len(ollama_prompt),
+            _truncate_for_debug(json.dumps(request_payload)),
+        )
+
+    request = urllib_request.Request(
+        f'{ollama_base_url}{OLLAMA_CHAT_PATH}',
+        data=request_body,
+        headers={'Content-Type': 'application/json'},
+        method='POST',
+    )
+
+    try:
+        with urllib_request.urlopen(request, timeout=120) as response:
+            raw_payload = response.read().decode('utf-8')
+    except urllib_error.HTTPError as error:
+        error_payload = error.read().decode('utf-8', errors='replace')
+        raise RuntimeError(f'Ollama HTTP error {error.code}: {error_payload}') from error
+    except urllib_error.URLError as error:
+        raise RuntimeError(f'Failed to connect to Ollama endpoint: {error}') from error
+
+    if _debug_ollama_enabled():
+        logger.info(
+            'Ollama raw response debug: %s',
+            _truncate_for_debug(raw_payload),
+        )
+
+    payload = json.loads(raw_payload)
+    message = payload.get('message', {})
+    if isinstance(message, dict) and isinstance(message.get('content'), str):
+        return message['content']
+
+    if isinstance(payload.get('response'), str):
+        return payload['response']
+
+    raise RuntimeError(f'Unexpected Ollama response format: {payload}')
+
+
+def invoke_model(
+    content: list[Dict[str, Any]],
+    max_tokens: int,
+    model_id: str,
+    bedrock_client,
+    logger: logging.Logger,
+) -> str:
+    if resolve_model_provider() == MODEL_PROVIDER_OLLAMA:
+        return _invoke_ollama_model(content, max_tokens, model_id, logger)
+    return _invoke_bedrock_model(content, max_tokens, model_id, bedrock_client)

package/lib/document-processing/resources/default-localstack-invoke/requirements.txt

@@ -0,0 +1,5 @@
+boto3>=1.26.0
+aws-lambda-powertools
+urllib3>=1.26.0,<2.0.0
+aws-xray-sdk
+PyPDF2>=3.0.0

package/lib/document-processing/resources/default-sqs-consumer/index.py

@@ -7,7 +7,22 @@ import re
 from aws_lambda_powertools import Metrics, Tracer
 from aws_lambda_powertools.metrics import MetricUnit
 
-sfn_client = boto3.client('stepfunctions')
+def _resolve_endpoint_url(*service_env_keys):
+    for key in service_env_keys:
+        endpoint = os.getenv(key)
+        if endpoint:
+            return endpoint
+    return None
+
+
+def _create_boto3_client(service_name, *service_env_keys):
+    endpoint_url = _resolve_endpoint_url(*service_env_keys, 'AWS_ENDPOINT_URL')
+    if endpoint_url:
+        return boto3.client(service_name, endpoint_url=endpoint_url)
+    return boto3.client(service_name)
+
+
+sfn_client = _create_boto3_client('stepfunctions', 'AWS_ENDPOINT_URL_STEPFUNCTIONS')
 metrics = Metrics()
 tracer = Tracer()
 
@@ -113,4 +128,4 @@ def handler(event, context):
         'statusCode': 200,
         'processedCount': len(results),
         'results': results
-    }
+    }

package/lib/document-processing/resources/pdf-chunking/handler.py

@@ -68,8 +68,23 @@ structured_logger = get_logger(__name__)
 logger = logging.getLogger()
 logger.setLevel(os.environ.get('LOG_LEVEL', 'INFO'))
 
+def _resolve_endpoint_url(*service_env_keys: str) -> Optional[str]:
+    for key in service_env_keys:
+        endpoint = os.getenv(key)
+        if endpoint:
+            return endpoint
+    return None
+
+
+def _create_boto3_client(service_name: str, *service_env_keys: str):
+    endpoint_url = _resolve_endpoint_url(*service_env_keys, 'AWS_ENDPOINT_URL')
+    if endpoint_url:
+        return boto3.client(service_name, endpoint_url=endpoint_url)
+    return boto3.client(service_name)
+
+
 # Initialize AWS clients
-s3_client = boto3.client('s3')
+s3_client = _create_boto3_client('s3', 'AWS_ENDPOINT_URL_S3')
 
 # Get Powertools metrics instance
 metrics = get_metrics()

package/lib/document-processing/tests/localstack-agentic-document-processing.test.d.ts

@@ -0,0 +1 @@
+export {};