@cdklabs/cdk-appmod-catalog-blueprints 1.10.0 → 1.12.0

package/lib/framework/agents/knowledge-base/base-knowledge-base.js

@@ -103,5 +103,5 @@ class BaseKnowledgeBase extends constructs_1.Construct {
 }
 exports.BaseKnowledgeBase = BaseKnowledgeBase;
 _a = JSII_RTTI_SYMBOL_1;
-BaseKnowledgeBase[_a] = { fqn: "@cdklabs/cdk-appmod-catalog-blueprints.BaseKnowledgeBase", version: "1.10.0" };
+BaseKnowledgeBase[_a] = { fqn: "@cdklabs/cdk-appmod-catalog-blueprints.BaseKnowledgeBase", version: "1.12.0" };
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-knowledge-base.js","sourceRoot":"","sources":["../../../../use-cases/framework/agents/knowledge-base/base-knowledge-base.ts"],"names":[],"mappings":";;;;;AAMA,2CAAuC;AASvC;;;;;;;;;;;;;;;;GAgBG;AACH,MAAsB,iBAAkB,SAAQ,sBAAS;IAiCvD;;;;;;;;OAQG;IACH,YAAY,KAAgB,EAAE,EAAU,EAAE,KAA6B;QACrE,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAEjB,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;QAE1B,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC;QACvB,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC,WAAW,CAAC;QACrC,IAAI,CAAC,eAAe,GAAG,KAAK,CAAC,SAAS,IAAI,EAAE,eAAe,EAAE,CAAC,EAAE,CAAC;QACjE,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC,GAAG,CAAC;IAC7B,CAAC;IAED;;;;;;;;;;OAUG;IACO,aAAa,CAAC,KAA6B;QACnD,IAAI,CAAC,KAAK,CAAC,IAAI,IAAI,KAAK,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC;YAC5C,MAAM,IAAI,KAAK,CAAC,sCAAsC,CAAC,CAAC;QAC1D,CAAC;QACD,IAAI,CAAC,KAAK,CAAC,WAAW,IAAI,KAAK,CAAC,WAAW,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC;YAC1D,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAC;QACjE,CAAC;IACH,CAAC;IAYD;;;;;;;;;OASG;IACI,mBAAmB;QACxB,OAAO;YACL,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,SAAS,EAAE,IAAI,CAAC,eAAe;YAC/B,GAAG,EAAE,IAAI,CAAC,SAAS;SACpB,CAAC;IACJ,CAAC;IAED;;;;;;;;OAQG;IACI,kBAAkB;QACvB,OAAO,SAAS,CAAC;IACnB,CAAC;IAED;;;;;;;;OAQG;IACI,mBAAmB;QACxB,OAAO,SAAS,CAAC;IACnB,CAAC;;AA9HH,8CA+HC","sourcesContent":["// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n// SPDX-License-Identifier: Apache-2.0\n\nimport { PolicyStatement } from 'aws-cdk-lib/aws-iam';\nimport { LayerVersion } from 'aws-cdk-lib/aws-lambda';\nimport { Asset } from 'aws-cdk-lib/aws-s3-assets';\nimport { Construct } from 'constructs';\nimport { IKnowledgeBase } from './i-knowledge-base';\nimport {\n  AclConfiguration,\n  BaseKnowledgeBaseProps,\n  KnowledgeBaseRuntimeConfig,\n  RetrievalConfiguration,\n} from './knowledge-base-props';\n\n/**\n * Abstract base class for knowledge base implementations.\n *\n * This class provides common functionality for all knowledge base implementations,\n * including configuration management, validation, and default behaviors. Concrete\n * implementations (like BedrockKnowledgeBase) extend this class and implement\n * the abstract methods.\n *\n * The base class handles:\n * - Props validation (name and description are required)\n * - Default retrieval configuration (numberOfResults defaults to 5)\n * - ACL configuration storage\n * - Base runtime configuration export\n *\n * Subclasses must implement:\n * - `generateIamPermissions()`: Return IAM permissions specific to the KB type\n */\nexport abstract class BaseKnowledgeBase extends Construct implements IKnowledgeBase {\n  /**\n   * Human-readable name for this knowledge base.\n   *\n   * This name is used for logging, display purposes, and to help the agent\n   * identify which knowledge base to query.\n   */\n  public readonly name: string;\n\n  /**\n   * Human-readable description of what this knowledge base contains.\n   *\n   * This description is included in the agent's system prompt to help\n   * the agent decide when to query this knowledge base.\n   */\n  public readonly description: string;\n\n  /**\n   * Retrieval configuration for this knowledge base.\n   *\n   * Contains settings like numberOfResults and optional metadata filters.\n   * Defaults to { numberOfResults: 5 } if not provided.\n   */\n  protected readonly retrievalConfig: RetrievalConfiguration;\n\n  /**\n   * ACL configuration for identity-aware retrieval.\n   *\n   * When enabled, retrieval queries will be filtered based on user\n   * identity context.\n   */\n  protected readonly aclConfig?: AclConfiguration;\n\n  /**\n   * Creates a new BaseKnowledgeBase instance.\n   *\n   * @param scope - The scope in which to define this construct\n   * @param id - The scoped construct ID\n   * @param props - Configuration properties for the knowledge base\n   * @throws Error if name is empty or not provided\n   * @throws Error if description is empty or not provided\n   */\n  constructor(scope: Construct, id: string, props: BaseKnowledgeBaseProps) {\n    super(scope, id);\n\n    this.validateProps(props);\n\n    this.name = props.name;\n    this.description = props.description;\n    this.retrievalConfig = props.retrieval ?? { numberOfResults: 5 };\n    this.aclConfig = props.acl;\n  }\n\n  /**\n   * Validates the provided props at construction time.\n   *\n   * Ensures that required fields (name and description) are provided\n   * and not empty. Subclasses can override this method to add additional\n   * validation, but should call super.validateProps() first.\n   *\n   * @param props - The props to validate\n   * @throws Error if name is empty or not provided\n   * @throws Error if description is empty or not provided\n   */\n  protected validateProps(props: BaseKnowledgeBaseProps): void {\n    if (!props.name || props.name.trim() === '') {\n      throw new Error('name is required and cannot be empty');\n    }\n    if (!props.description || props.description.trim() === '') {\n      throw new Error('description is required and cannot be empty');\n    }\n  }\n\n  /**\n   * Generate IAM policy statements required for accessing this knowledge base.\n   *\n   * This abstract method must be implemented by subclasses to return the\n   * specific IAM permissions needed for their knowledge base type.\n   *\n   * @returns Array of IAM PolicyStatement objects granting necessary permissions\n   */\n  public abstract generateIamPermissions(): PolicyStatement[];\n\n  /**\n   * Export configuration for runtime use by the retrieval tool.\n   *\n   * Returns a configuration object containing the base knowledge base\n   * settings. Subclasses should override this method to add implementation-\n   * specific configuration, calling super.exportConfiguration() to include\n   * the base configuration.\n   *\n   * @returns Runtime configuration object for the retrieval tool\n   */\n  public exportConfiguration(): KnowledgeBaseRuntimeConfig {\n    return {\n      name: this.name,\n      description: this.description,\n      retrieval: this.retrievalConfig,\n      acl: this.aclConfig,\n    };\n  }\n\n  /**\n   * Provide the retrieval tool asset for this knowledge base type.\n   *\n   * By default, returns undefined to use the framework's default retrieval\n   * tool. Subclasses can override this method to provide a custom retrieval\n   * tool implementation.\n   *\n   * @returns undefined to use the default retrieval tool\n   */\n  public retrievalToolAsset(): Asset | undefined {\n    return undefined;\n  }\n\n  /**\n   * Provide Lambda layers required by the retrieval tool.\n   *\n   * By default, returns undefined indicating no additional layers are needed.\n   * Subclasses can override this method to provide Lambda layers containing\n   * dependencies required by their retrieval tool.\n   *\n   * @returns undefined indicating no additional layers needed\n   */\n  public retrievalToolLayers(): LayerVersion[] | undefined {\n    return undefined;\n  }\n}\n"]}

package/lib/framework/agents/knowledge-base/bedrock-knowledge-base.js

@@ -188,5 +188,5 @@ class BedrockKnowledgeBase extends base_knowledge_base_1.BaseKnowledgeBase {
 }
 exports.BedrockKnowledgeBase = BedrockKnowledgeBase;
 _a = JSII_RTTI_SYMBOL_1;
-BedrockKnowledgeBase[_a] = { fqn: "@cdklabs/cdk-appmod-catalog-blueprints.BedrockKnowledgeBase", version: "1.10.0" };
+BedrockKnowledgeBase[_a] = { fqn: "@cdklabs/cdk-appmod-catalog-blueprints.BedrockKnowledgeBase", version: "1.12.0" };
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bedrock-knowledge-base.js","sourceRoot":"","sources":["../../../../use-cases/framework/agents/knowledge-base/bedrock-knowledge-base.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 { Stack } from 'aws-cdk-lib';\nimport { Effect, PolicyStatement } from 'aws-cdk-lib/aws-iam';\nimport { Asset } from 'aws-cdk-lib/aws-s3-assets';\nimport { Construct } from 'constructs';\nimport { BaseKnowledgeBase } from './base-knowledge-base';\nimport {\n  BedrockKnowledgeBaseProps,\n  CreateKnowledgeBaseConfiguration,\n  GuardrailConfiguration,\n  KnowledgeBaseRuntimeConfig,\n  VectorStoreConfiguration,\n} from './knowledge-base-props';\n\n/**\n * Amazon Bedrock Knowledge Base implementation.\n *\n * This class provides integration with Amazon Bedrock Knowledge Bases,\n * which use vector stores (S3 Vectors by default) for semantic search.\n * It is the default knowledge base implementation when none is specified.\n *\n * The implementation handles:\n * - ARN construction from knowledge base ID (if ARN not provided)\n * - IAM permission generation for Bedrock Retrieve and RetrieveAndGenerate APIs\n * - Optional guardrail configuration for content filtering\n * - Runtime configuration export for the retrieval tool\n */\nexport class BedrockKnowledgeBase extends BaseKnowledgeBase {\n  /**\n   * The unique identifier for the Bedrock Knowledge Base.\n   *\n   * This is the ID assigned by Bedrock when the knowledge base was created.\n   */\n  public readonly knowledgeBaseId: string;\n\n  /**\n   * The ARN of the Bedrock Knowledge Base.\n   *\n   * If not provided in props, this is constructed from the knowledgeBaseId\n   * using the current region and account.\n   */\n  public readonly knowledgeBaseArn: string;\n\n  /**\n   * Guardrail configuration for content filtering.\n   *\n   * When configured, the guardrail will be applied during retrieval\n   * operations to filter inappropriate or sensitive content.\n   */\n  private readonly guardrailConfig?: GuardrailConfiguration;\n\n  /**\n   * Vector store configuration.\n   *\n   * Defines the type of vector store used by this knowledge base.\n   * Defaults to S3 Vectors if not specified.\n   */\n  private readonly vectorStoreConfig: VectorStoreConfiguration;\n\n  /**\n   * Configuration for creating a new knowledge base.\n   *\n   * When provided, indicates that this construct should create a new\n   * Bedrock Knowledge Base rather than reference an existing one.\n   *\n   * Note: KB creation is an advanced feature. Currently, this property\n   * stores the configuration for future implementation.\n   */\n  private readonly createConfig?: CreateKnowledgeBaseConfiguration;\n\n  /**\n   * The AWS region where the knowledge base is deployed.\n   */\n  private readonly region: string;\n\n  /**\n   * The AWS account ID where the knowledge base is deployed.\n   */\n  private readonly account: string;\n\n  /**\n   * Creates a new BedrockKnowledgeBase instance.\n   *\n   * @param scope - The scope in which to define this construct\n   * @param id - The scoped construct ID\n   * @param props - Configuration properties for the Bedrock Knowledge Base\n   * @throws Error if knowledgeBaseId is empty or not provided\n   */\n  constructor(scope: Construct, id: string, props: BedrockKnowledgeBaseProps) {\n    super(scope, id, props);\n\n    this.validateBedrockProps(props);\n\n    const stack = Stack.of(this);\n    this.region = stack.region;\n    this.account = stack.account;\n\n    this.knowledgeBaseId = props.knowledgeBaseId;\n    this.knowledgeBaseArn =\n      props.knowledgeBaseArn ??\n      `arn:aws:bedrock:${this.region}:${this.account}:knowledge-base/${props.knowledgeBaseId}`;\n    this.guardrailConfig = props.guardrail;\n    // Default to S3 Vectors if not specified\n    this.vectorStoreConfig = props.vectorStore ?? { type: 's3-vectors' };\n    this.createConfig = props.create;\n\n    // Note: KB creation is handled separately when create config is provided\n    // This is an advanced feature that will create actual AWS resources\n    if (this.createConfig) {\n      this.setupKnowledgeBaseCreation();\n    }\n  }\n\n  /**\n   * Sets up knowledge base creation when create configuration is provided.\n   *\n   * This method is called during construction when the `create` property\n   * is specified. It prepares the necessary resources for creating a new\n   * Bedrock Knowledge Base.\n   *\n   * Note: Full KB creation implementation requires CloudFormation custom\n   * resources or L1 constructs. This is a placeholder for future implementation.\n   */\n  private setupKnowledgeBaseCreation(): void {\n    // KB creation is an advanced feature\n    // The actual implementation would involve:\n    // 1. Creating an IAM role for Bedrock KB\n    // 2. Creating the Bedrock KB via CfnKnowledgeBase\n    // 3. Creating a data source pointing to the S3 bucket\n    // 4. Configuring the embedding model\n    // 5. Setting up the vector store (S3 Vectors by default)\n    //\n    // For now, this stores the configuration for reference.\n    // Users should create KBs via the Bedrock console or CLI\n    // and reference them by ID.\n  }\n\n  /**\n   * Validates Bedrock-specific props at construction time.\n   *\n   * Ensures that the knowledgeBaseId is provided and not empty.\n   *\n   * @param props - The props to validate\n   * @throws Error if knowledgeBaseId is empty or not provided\n   */\n  private validateBedrockProps(props: BedrockKnowledgeBaseProps): void {\n    if (!props.knowledgeBaseId || props.knowledgeBaseId.trim() === '') {\n      throw new Error('knowledgeBaseId is required and cannot be empty');\n    }\n  }\n\n  /**\n   * Generate IAM policy statements required for accessing this Bedrock Knowledge Base.\n   *\n   * Returns permissions for:\n   * - bedrock:Retrieve - Query the knowledge base\n   * - bedrock:RetrieveAndGenerate - Query and generate responses\n   * - bedrock:ApplyGuardrail - Apply guardrail (if configured)\n   * - s3:GetObject - Access S3 vectors (if using S3 Vectors with custom bucket)\n   * - s3:GetObject - Access data source bucket (if create config provided)\n   *\n   * All permissions are scoped to the specific knowledge base ARN\n   * following the principle of least privilege.\n   *\n   * @returns Array of IAM PolicyStatement objects granting necessary permissions\n   */\n  public generateIamPermissions(): PolicyStatement[] {\n    const statements: PolicyStatement[] = [\n      new PolicyStatement({\n        effect: Effect.ALLOW,\n        actions: ['bedrock:Retrieve', 'bedrock:RetrieveAndGenerate'],\n        resources: [this.knowledgeBaseArn],\n      }),\n    ];\n\n    // Add guardrail permissions if configured\n    if (this.guardrailConfig) {\n      statements.push(\n        new PolicyStatement({\n          effect: Effect.ALLOW,\n          actions: ['bedrock:ApplyGuardrail'],\n          resources: [\n            `arn:aws:bedrock:${this.region}:${this.account}:guardrail/${this.guardrailConfig.guardrailId}`,\n          ],\n        }),\n      );\n    }\n\n    // Add S3 permissions if using S3 Vectors with a custom bucket\n    if (this.vectorStoreConfig.type === 's3-vectors' && this.vectorStoreConfig.bucketName) {\n      const prefix = this.vectorStoreConfig.prefix ?? 'vectors/';\n      statements.push(\n        new PolicyStatement({\n          effect: Effect.ALLOW,\n          actions: ['s3:GetObject'],\n          resources: [\n            `arn:aws:s3:::${this.vectorStoreConfig.bucketName}/${prefix}*`,\n          ],\n        }),\n      );\n    }\n\n    // Add data source bucket permissions if create config is provided\n    if (this.createConfig) {\n      const dataSourcePrefix = this.createConfig.dataSourcePrefix ?? '';\n      statements.push(\n        new PolicyStatement({\n          effect: Effect.ALLOW,\n          actions: ['s3:GetObject', 's3:ListBucket'],\n          resources: [\n            `arn:aws:s3:::${this.createConfig.dataSourceBucketName}`,\n            `arn:aws:s3:::${this.createConfig.dataSourceBucketName}/${dataSourcePrefix}*`,\n          ],\n        }),\n      );\n    }\n\n    return statements;\n  }\n\n  /**\n   * Export configuration for runtime use by the retrieval tool.\n   *\n   * Returns a configuration object containing all Bedrock-specific\n   * settings needed to query the knowledge base at runtime, including:\n   * - Base configuration (name, description, retrieval, acl)\n   * - Knowledge base type ('bedrock')\n   * - Knowledge base ID and ARN\n   * - Vector store configuration\n   * - Guardrail configuration (if present)\n   *\n   * @returns Runtime configuration object for the retrieval tool\n   */\n  public exportConfiguration(): KnowledgeBaseRuntimeConfig {\n    return {\n      ...super.exportConfiguration(),\n      type: 'bedrock',\n      knowledgeBaseId: this.knowledgeBaseId,\n      knowledgeBaseArn: this.knowledgeBaseArn,\n      vectorStore: this.vectorStoreConfig,\n      guardrail: this.guardrailConfig,\n    };\n  }\n\n  /**\n   * Provide the Bedrock-specific retrieval tool asset.\n   *\n   * Returns an Asset containing the Python retrieval tool that uses\n   * the Amazon Bedrock Agent Runtime API to query knowledge bases.\n   * This tool is automatically added to agents that use Bedrock\n   * knowledge bases.\n   *\n   * @returns Asset containing the Bedrock retrieval tool\n   */\n  public retrievalToolAsset(): Asset {\n    return new Asset(this, 'BedrockRetrievalTool', {\n      path: path.join(__dirname, '../resources/knowledge-base-tool'),\n      exclude: ['test_*', '*_test.py'],\n    });\n  }\n}\n"]}

package/lib/framework/agents/resources/agentcore-agent-handler/Dockerfile

@@ -0,0 +1,20 @@
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+FROM python:3.13-slim
+
+WORKDIR /app
+
+# Install dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy handler code
+COPY main.py .
+
+# AgentCore Runtime HTTP protocol: listen on port 8080
+EXPOSE 8080
+
+# Use opentelemetry-instrument wrapper so ADOT auto-instrumentation
+# emits traces/spans to AgentCore Observability when enabled.
+CMD ["opentelemetry-instrument", "python", "main.py"]

package/lib/framework/agents/resources/agentcore-agent-handler/main.py

@@ -0,0 +1,224 @@
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+AgentCore Runtime Handler for Strands Agent.
+
+Uses the Bedrock AgentCore SDK to run as a managed container.
+The SDK handles the HTTP server (port 8080), /invocations and /ping
+endpoints, and SSE streaming.
+
+Architecture:
+    AgentCore Runtime → Container (port 8080) → AgentCore SDK → Strands Agent → Bedrock
+"""
+
+import os
+import json
+import uuid
+import importlib
+import sys
+import tempfile
+import zipfile
+import base64
+import logging
+import traceback
+import boto3
+from opentelemetry import baggage
+from opentelemetry import context as otel_context
+
+from bedrock_agentcore.runtime import BedrockAgentCoreApp
+from strands import Agent
+from strands.models import BedrockModel
+from strands.agent.conversation_manager import SlidingWindowConversationManager
+from strands.session.s3_session_manager import S3SessionManager as StrandsS3SessionManager
+
+logger = logging.getLogger(__name__)
+logging.basicConfig(level=logging.INFO)
+
+s3_client = boto3.client('s3')
+
+# Configuration from environment variables
+MODEL_ID = os.getenv('MODEL_ID', 'anthropic.claude-3-5-sonnet-20241022-v2:0')
+SYSTEM_PROMPT_BUCKET = os.getenv('SYSTEM_PROMPT_S3_BUCKET_NAME')
+SYSTEM_PROMPT_KEY = os.getenv('SYSTEM_PROMPT_S3_KEY')
+TOOLS_CONFIG = os.getenv('TOOLS_CONFIG', '[]')
+KNOWLEDGE_BASE_SYSTEM_PROMPT_ADDITION = os.getenv('KNOWLEDGE_BASE_SYSTEM_PROMPT_ADDITION', '')
+SESSION_BUCKET = os.getenv('SESSION_BUCKET')
+
+
+def load_system_prompt() -> str:
+    """Load system prompt from S3 at cold start."""
+    if not SYSTEM_PROMPT_BUCKET or not SYSTEM_PROMPT_KEY:
+        return 'You are a helpful AI assistant.'
+
+    try:
+        response = s3_client.get_object(
+            Bucket=SYSTEM_PROMPT_BUCKET,
+            Key=SYSTEM_PROMPT_KEY
+        )
+        return response['Body'].read().decode('utf-8')
+    except Exception as e:
+        logger.error(f'Failed to load system prompt: {e}')
+        return 'You are a helpful AI assistant.'
+
+
+def load_tools_from_s3() -> list:
+    """Load tool modules from S3 based on TOOLS_CONFIG env var."""
+    tools = []
+    try:
+        tools_config = json.loads(TOOLS_CONFIG)
+    except (json.JSONDecodeError, TypeError):
+        logger.warning('Invalid TOOLS_CONFIG, no tools loaded')
+        return tools
+
+    for tool_def in tools_config:
+        try:
+            bucket_name = tool_def.get('bucketName')
+            key = tool_def.get('key')
+            is_zip = tool_def.get('isZipArchive', False)
+
+            if not bucket_name or not key:
+                continue
+
+            tmp_dir = tempfile.mkdtemp()
+
+            if is_zip:
+                zip_path = os.path.join(tmp_dir, 'tools.zip')
+                s3_client.download_file(bucket_name, key, zip_path)
+                with zipfile.ZipFile(zip_path, 'r') as zf:
+                    zf.extractall(tmp_dir)
+                os.remove(zip_path)
+                sys.path.insert(0, tmp_dir)
+                for fname in os.listdir(tmp_dir):
+                    if fname.endswith('.py') and not fname.startswith('_'):
+                        mod_name = fname[:-3]
+                        mod = importlib.import_module(mod_name)
+                        for attr_name in dir(mod):
+                            attr = getattr(mod, attr_name)
+                            if callable(attr) and hasattr(attr, '__wrapped__'):
+                                tools.append(attr)
+            else:
+                file_path = os.path.join(tmp_dir, os.path.basename(key))
+                s3_client.download_file(bucket_name, key, file_path)
+                sys.path.insert(0, tmp_dir)
+                mod_name = os.path.basename(key).replace('.py', '')
+                mod = importlib.import_module(mod_name)
+                for attr_name in dir(mod):
+                    attr = getattr(mod, attr_name)
+                    if callable(attr) and hasattr(attr, '__wrapped__'):
+                        tools.append(attr)
+
+        except Exception as e:
+            logger.error(f'Failed to load tool from S3: {e}')
+            continue
+
+    logger.info(f'Loaded {len(tools)} tools from S3')
+    return tools
+
+
+def extract_user_id_from_headers(headers: dict) -> str | None:
+    """Extract user sub from JWT Authorization header.
+
+    AgentCore validates the JWT before forwarding the request,
+    so we only need to decode the payload — no verification needed.
+    """
+    auth = headers.get('authorization', '')
+    if not auth.lower().startswith('bearer '):
+        return None
+    token = auth[7:]
+    try:
+        payload_b64 = token.split('.')[1]
+        padding = 4 - len(payload_b64) % 4
+        if padding != 4:
+            payload_b64 += '=' * padding
+        payload = json.loads(base64.urlsafe_b64decode(payload_b64))
+        return payload.get('sub')
+    except Exception:
+        return None
+
+
+# Cold start: load system prompt and tools
+SYSTEM_PROMPT = load_system_prompt()
+if KNOWLEDGE_BASE_SYSTEM_PROMPT_ADDITION:
+    SYSTEM_PROMPT = SYSTEM_PROMPT + '\n\n' + KNOWLEDGE_BASE_SYSTEM_PROMPT_ADDITION
+AGENT_TOOLS = load_tools_from_s3()
+
+app = BedrockAgentCoreApp()
+
+
+@app.entrypoint
+async def handle_invocation(payload, context):
+    """Handle agent invocation with streaming response.
+
+    The SDK calls this for POST /invocations. Yielding dicts streams them
+    as SSE events. The SDK handles serialization and transport.
+    """
+    user_message = payload.get('prompt') or payload.get('message', '')
+
+    # Session ID from AgentCore header or generate new
+    session_id = context.session_id or str(uuid.uuid4())
+
+    # Propagate session ID in OTEL baggage so ADOT can correlate
+    # traces/spans with the correct session in downstream headers.
+    ctx = baggage.set_baggage('session.id', session_id)
+    otel_context.attach(ctx)
+
+    # Extract user identity from the raw Starlette request headers.
+    # The SDK's context.request_headers may not include Authorization
+    # (it extracts it into workload_access_token), so we read directly
+    # from the underlying request object — same as the old FastAPI path.
+    headers = dict(context.request.headers) if context.request else {}
+    user_id = (
+        headers.get('x-amzn-bedrock-agentcore-runtime-user-id')
+        or extract_user_id_from_headers(headers)
+    )
+
+    logger.info('Invocation: session=%s, user=%s, message=%s...', session_id, user_id, user_message[:80])
+
+    # Yield session metadata first so the frontend can track the session
+    yield {'session_id': session_id}
+
+    try:
+        system_prompt = SYSTEM_PROMPT
+        if user_id:
+            system_prompt += (
+                '\n\n## Authenticated User\n'
+                f'The current authenticated user ID is: {user_id}\n'
+                'Use this ID when looking up their transactions or other '
+                'user specific information. Do not ask the user for their customer ID.'
+            )
+
+        session_manager = None
+        if SESSION_BUCKET:
+            session_manager = StrandsS3SessionManager(
+                session_id=session_id,
+                bucket=SESSION_BUCKET,
+            )
+
+        conversation_manager = SlidingWindowConversationManager(window_size=20)
+        model = BedrockModel(model_id=MODEL_ID, streaming=True)
+
+        agent = Agent(
+            model=model,
+            system_prompt=system_prompt,
+            tools=AGENT_TOOLS if AGENT_TOOLS else None,
+            session_manager=session_manager,
+            conversation_manager=conversation_manager,
+            callback_handler=None,
+        )
+
+        async for event in agent.stream_async(user_message):
+            if 'data' in event:
+                yield {'text': event['data']}
+
+        yield {'done': True}
+
+    except Exception as e:
+        error_detail = f'{type(e).__name__}: {e}'
+        logger.error('Error processing invocation: %s', error_detail)
+        traceback.print_exc()
+        yield {'error': error_detail}
+
+
+if __name__ == '__main__':
+    app.run()

package/lib/framework/agents/resources/agentcore-agent-handler/requirements.txt

@@ -0,0 +1,5 @@
+bedrock-agentcore>=1.0.0
+strands-agents>=1.0.0
+boto3>=1.0.0
+aws-lambda-powertools>=2.0.0
+aws-opentelemetry-distro>=0.10.0

package/lib/framework/agents/resources/interactive-agent-handler/index.py

@@ -16,7 +16,6 @@ Architecture:
 import os
 import json
 import uuid
-import time
 import importlib
 import sys
 import tempfile
@@ -32,6 +31,8 @@ import uvicorn
 
 from strands import Agent
 from strands.models import BedrockModel
+from strands.agent.conversation_manager import SlidingWindowConversationManager
+from strands.session.s3_session_manager import S3SessionManager as StrandsS3SessionManager
 from aws_lambda_powertools import Logger, Tracer, Metrics
 from aws_lambda_powertools.metrics import MetricUnit
 
@@ -50,9 +51,6 @@ SYSTEM_PROMPT_KEY = os.getenv('SYSTEM_PROMPT_S3_KEY')
 TOOLS_CONFIG = os.getenv('TOOLS_CONFIG', '[]')
 KNOWLEDGE_BASE_SYSTEM_PROMPT_ADDITION = os.getenv('KNOWLEDGE_BASE_SYSTEM_PROMPT_ADDITION', '')
 SESSION_BUCKET = os.getenv('SESSION_BUCKET')
-CONTEXT_ENABLED = os.getenv('CONTEXT_ENABLED', 'true').lower() == 'true'
-CONTEXT_STRATEGY = os.getenv('CONTEXT_STRATEGY', 'SlidingWindow')
-CONTEXT_WINDOW_SIZE = int(os.getenv('CONTEXT_WINDOW_SIZE', '20'))
 
 
 def load_system_prompt() -> str:
@@ -135,74 +133,6 @@ if KNOWLEDGE_BASE_SYSTEM_PROMPT_ADDITION:
 AGENT_TOOLS = load_tools_from_s3()
 
 
-class SessionManager:
-    """Manages conversation sessions in S3."""
-
-    def __init__(self, bucket: Optional[str] = None):
-        self.bucket = bucket
-        self.enabled = bucket is not None
-
-    def get_session(self, session_id: str) -> List[Dict[str, Any]]:
-        """Retrieve message history from S3."""
-        if not self.enabled:
-            return []
-
-        key = f'sessions/{session_id}.json'
-        try:
-            response = s3_client.get_object(Bucket=self.bucket, Key=key)
-            data = json.loads(response['Body'].read().decode('utf-8'))
-            return data.get('messages', [])
-        except s3_client.exceptions.NoSuchKey:
-            return []
-        except Exception as e:
-            logger.warning(f'Failed to load session {session_id}: {e}')
-            return []
-
-    def save_session(self, session_id: str, messages: List[Dict[str, Any]]) -> None:
-        """Save message history to S3."""
-        if not self.enabled:
-            return
-
-        key = f'sessions/{session_id}.json'
-        data = {
-            'session_id': session_id,
-            'messages': messages,
-            'updated_at': time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime()),
-        }
-        try:
-            s3_client.put_object(
-                Bucket=self.bucket,
-                Key=key,
-                Body=json.dumps(data),
-                ContentType='application/json'
-            )
-        except Exception as e:
-            logger.error(f'Failed to save session {session_id}: {e}')
-
-
-class ContextManager:
-    """Manages conversation context windowing."""
-
-    def __init__(self, strategy: str = 'SlidingWindow', window_size: int = 20, enabled: bool = True):
-        self.strategy = strategy
-        self.window_size = window_size
-        self.enabled = enabled
-
-    def get_context(self, messages: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
-        """Apply context windowing to message history."""
-        if not self.enabled or self.strategy == 'Null':
-            return []
-
-        if self.strategy == 'SlidingWindow':
-            return messages[-self.window_size:] if len(messages) > self.window_size else list(messages)
-
-        return list(messages)
-
-
-# Initialize managers
-session_manager = SessionManager(SESSION_BUCKET)
-context_manager = ContextManager(CONTEXT_STRATEGY, CONTEXT_WINDOW_SIZE, CONTEXT_ENABLED)
-
 # FastAPI app
 app = FastAPI()
 
@@ -249,28 +179,34 @@ async def chat(request: ChatRequest):
 
         full_response = ''
         try:
-            # Load session history
-            messages = session_manager.get_session(session_id)
+            # Create Strands-native session manager (handles load/save automatically)
+            session_manager = None
+            if SESSION_BUCKET:
+                session_manager = StrandsS3SessionManager(
+                    session_id=session_id,
+                    bucket_name=SESSION_BUCKET,
+                )
 
-            # Apply context windowing
-            context = context_manager.get_context(messages)
+            # Create Strands-native conversation manager for context windowing
+            conversation_manager = SlidingWindowConversationManager(window_size=20)
 
             # Create Bedrock model
             model = BedrockModel(model_id=MODEL_ID, streaming=True)
 
-            # Create agent with system prompt, tools, and conversation history.
+            # Create agent with Strands-native session and conversation management.
+            # Strands handles session persistence and context windowing automatically.
             # Disable the default callback handler so stream_async yields all events.
             agent = Agent(
                 model=model,
                 system_prompt=SYSTEM_PROMPT,
                 tools=AGENT_TOOLS if AGENT_TOOLS else None,
-                messages=list(context) if context else None,
+                session_manager=session_manager,
+                conversation_manager=conversation_manager,
                 callback_handler=None,
             )
 
             # Use stream_async for true token-by-token streaming.
             # Each event with a "data" key contains a text chunk from the model.
-            result = None
             async for event in agent.stream_async(user_message):
                 # Text chunk from model — stream it to the client immediately
                 if 'data' in event:
@@ -278,20 +214,7 @@ async def chat(request: ChatRequest):
                     full_response += chunk
                     yield format_sse(json.dumps({'text': chunk}))
 
-                # Capture the final result for session saving
-                if 'result' in event:
-                    result = event['result']
-
-            # Save updated session with the agent's actual messages if available.
-            # The agent maintains its own messages list during stream_async,
-            # so we can use it directly for accurate conversation history.
-            if hasattr(agent, 'messages') and agent.messages:
-                session_manager.save_session(session_id, list(agent.messages))
-            else:
-                # Fallback: append manually
-                messages.append({'role': 'user', 'content': [{'text': user_message}]})
-                messages.append({'role': 'assistant', 'content': [{'text': full_response}]})
-                session_manager.save_session(session_id, messages)
+            # Session is saved automatically by Strands S3SessionManager
 
             metrics.add_metric(name='ChatResponses', unit=MetricUnit.Count, value=1)