@cdklabs/cdk-appmod-catalog-blueprints 1.16.0 → 1.17.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.16.0" };
+BaseKnowledgeBase[_a] = { fqn: "@cdklabs/cdk-appmod-catalog-blueprints.BaseKnowledgeBase", version: "1.17.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.16.0" };
+BedrockKnowledgeBase[_a] = { fqn: "@cdklabs/cdk-appmod-catalog-blueprints.BedrockKnowledgeBase", version: "1.17.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/localstack-batch-agent.d.ts

@@ -0,0 +1,15 @@
+import { Construct } from 'constructs';
+import { BatchAgent, BatchAgentProps } from './batch-agent';
+import { LocalStackEndpointOverrides } from '../localstack';
+export interface LocalStackBatchAgentProps extends BatchAgentProps {
+    /**
+     * LocalStack endpoint routing configuration for Lambda runtime SDK calls.
+     *
+     * @default { enabled: true }
+     */
+    readonly localStack?: LocalStackEndpointOverrides;
+}
+export declare class LocalStackBatchAgent extends BatchAgent {
+    constructor(scope: Construct, id: string, props: LocalStackBatchAgentProps);
+    protected resolveAgentRuntimeEntry(): string;
+}

package/lib/framework/agents/localstack-batch-agent.js

@@ -0,0 +1,33 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalStackBatchAgent = 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 batch_agent_1 = require("./batch-agent");
+const localstack_1 = require("../localstack");
+class LocalStackBatchAgent extends batch_agent_1.BatchAgent {
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        const localStackEnv = localstack_1.LocalStackIntegrationUtils.toLambdaEnvironment({
+            enabled: true,
+            ...props.localStack,
+        });
+        for (const child of this.node.findAll()) {
+            if (!(child instanceof aws_lambda_1.Function)) {
+                continue;
+            }
+            for (const [key, value] of Object.entries(localStackEnv)) {
+                child.addEnvironment(key, value);
+            }
+        }
+    }
+    resolveAgentRuntimeEntry() {
+        return path.join(__dirname, 'resources/default-ollama-agent');
+    }
+}
+exports.LocalStackBatchAgent = LocalStackBatchAgent;
+_a = JSII_RTTI_SYMBOL_1;
+LocalStackBatchAgent[_a] = { fqn: "@cdklabs/cdk-appmod-catalog-blueprints.LocalStackBatchAgent", version: "1.17.0" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/framework/agents/resources/default-ollama-agent/batch.py

@@ -0,0 +1,396 @@
+"""
+Batch agent Lambda handler for processing documents with AI agents.
+
+This module provides the Lambda handler for batch processing of documents
+using Amazon Bedrock agents with tool integration.
+"""
+
+import json
+import os
+import re
+from enum import Enum
+from typing import Any, Dict, Optional
+
+from aws_lambda_powertools import Logger, Metrics, Tracer
+from aws_lambda_powertools.metrics import MetricUnit
+from strands import Agent
+from strands_tools import file_read
+
+import runtime_support
+from utils import (
+    convert_tools_config_into_model,
+    create_boto3_client,
+    download_and_load_system_prompt,
+    download_tools,
+)
+
+
+class ContentType(str, Enum):
+    """
+    Document content type enumeration.
+    
+    Defines how document content is provided to the agent.
+    """
+    FILE = "file"  # Document stored in S3 or file system
+    DATA = "data"  # Document content provided inline
+
+
+class ContentLocation(str, Enum):
+    """
+    Document storage location enumeration.
+    
+    Defines where file-based documents are stored.
+    """
+    S3 = "s3"  # Document stored in Amazon S3
+
+
+class InvokeType(str, Enum):
+    """
+    Agent invocation type enumeration.
+    
+    Defines the processing mode for the agent.
+    """
+    BATCH = "batch"                    # Batch processing (one document at a time)
+    INTERACTIVE = "interactive"        # Interactive conversation mode (future)
+    ATTACH_DIRECTLY = "attach-directly"  # Direct invocation (e.g., RAG, API endpoints)
+    CLASSIFICATION = "classification"  # Document classification step
+    PROCESSING = "processing"          # Document processing step
+    AGGREGATION = "aggregation"        # Document aggregation step
+
+# Initialize AWS Lambda Powertools
+logger = Logger()
+metrics = Metrics()
+tracer = Tracer()
+
+# Initialize AWS clients
+s3_client = create_boto3_client('s3', 'AWS_ENDPOINT_URL_S3')
+
+# Load configuration at module initialization
+TOOLS_CONFIG = convert_tools_config_into_model(os.getenv('TOOLS_CONFIG', '{}'))
+AGENT_TOOLS = download_tools(TOOLS_CONFIG)
+SYSTEM_PROMPT = download_and_load_system_prompt(
+    os.environ['SYSTEM_PROMPT_S3_BUCKET_NAME'],
+    os.environ['SYSTEM_PROMPT_S3_KEY']
+)
+
+
+def extract_json_from_text(text: str) -> Optional[Dict[str, Any]]:
+    """
+    Extract JSON object from text containing JSON in code blocks or raw format.
+    
+    Attempts to extract JSON in the following order:
+    1. JSON within ```json code blocks
+    2. Raw JSON objects in the text
+    
+    Args:
+        text: Text potentially containing JSON data
+        
+    Returns:
+        Parsed JSON dictionary if found, None otherwise
+    """
+    return runtime_support.extract_json_from_text(text, logger)
+
+
+def download_document_from_s3(bucket: str, key: str) -> str:
+    """
+    Download a document from S3 to local /tmp directory.
+    
+    Args:
+        bucket: S3 bucket name
+        key: S3 object key
+        
+    Returns:
+        Local file path where document was downloaded
+        
+    Raises:
+        ClientError: If S3 download fails
+    """
+    filename = key.split('/')[-1]
+    local_path = f"/tmp/{filename}"
+    
+    logger.info("Downloading document from S3", extra={
+        "bucket": bucket,
+        "key": key,
+        "local_path": local_path
+    })
+    
+    s3_client.download_file(bucket, key, local_path)
+    return local_path
+
+
+def build_agent_prompt(base_prompt: str, event: Dict[str, Any], invoke_type: InvokeType) -> str:
+    """
+    Build the complete agent prompt from base prompt and event data.
+    
+    Args:
+        base_prompt: Base prompt template
+        event: Lambda event containing document and classification data
+        
+    Returns:
+        Complete prompt with document information and classification
+        
+    Raises:
+        ValueError: If content_type is invalid or required fields are missing
+    """
+    prompt = base_prompt or "Analyze the attached document and verify the information using the provided tools."
+    
+    # Replace classification placeholder if present
+    if 'classificationResult' in event:
+        classification = event['classificationResult']['documentClassification']
+        prompt = prompt.replace("[ACTUAL_CLASSIFICATION]", classification)
+        logger.info("Added classification to prompt", extra={"classification": classification})
+    
+    # Validate and process content based on type
+    content_type_str = event.get('contentType', '')
+    content = event.get('content', {})
+    
+    try:
+        content_type = ContentType(content_type_str)
+    except ValueError:
+        logger.error("Invalid content type", extra={
+            "content_type": content_type_str,
+            "valid_types": [ct.value for ct in ContentType]
+        })
+        raise ValueError(
+            f"Invalid content_type '{content_type_str}'. "
+            f"Must be one of: {', '.join(ct.value for ct in ContentType)}"
+        )
+    
+    # Process based on content type
+    if content_type == ContentType.FILE:
+        location = content.get('location', '')
+        
+        # Validate location
+        try:
+            location_enum = ContentLocation(location)
+        except ValueError:
+            logger.error("Invalid content location", extra={
+                "location": location,
+                "valid_locations": [loc.value for loc in ContentLocation]
+            })
+            raise ValueError(
+                f"Invalid content location '{location}'. "
+                f"Must be one of: {', '.join(loc.value for loc in ContentLocation)}"
+            )
+        
+        if location_enum == ContentLocation.S3:
+            if 'bucket' not in content or 'key' not in content:
+                raise ValueError("S3 content must include 'bucket' and 'key' fields")
+            
+            local_path = download_document_from_s3(content['bucket'], content['key'])
+            prompt += f" Attached document is located in {local_path}"
+            logger.info("Added file location to prompt", extra={"path": local_path})
+    
+    elif content_type == ContentType.DATA:
+        if 'data' not in content:
+            raise ValueError("Data content must include 'data' field")
+        
+        if invoke_type == InvokeType.BATCH:
+            prompt += f" Attached document content are as follows: {content['data']}"
+        elif invoke_type == InvokeType.ATTACH_DIRECTLY:
+            prompt += f" {content['data']}"
+        logger.info("Added inline data to prompt")
+    
+    return prompt
+
+
+@metrics.log_metrics
+@tracer.capture_lambda_handler
+def handler(event: Dict[str, Any], context: Any) -> Dict[str, Any]:
+    """
+    Lambda handler for batch agent processing.
+    
+    Processes documents using an AI agent with tool integration.
+    Supports both file-based (S3) and inline data inputs.
+    
+    Args:
+        event: Lambda event containing:
+            - contentType: 'file' or 'data' (see ContentType enum)
+            - content: Document location or inline data
+            - classificationResult: Optional document classification
+        context: Lambda context object
+        
+    Returns:
+        Dictionary with 'result' key containing agent response
+        (parsed as JSON if EXPECT_JSON is enabled)
+        
+    Raises:
+        KeyError: If required environment variables are missing
+        ValueError: If event contains invalid content_type or missing required fields
+        Exception: If agent invocation fails
+    """
+    # Load configuration
+    runtime_support.configure_provider_runtime()
+    model_id = os.getenv("MODEL_ID")
+    model = runtime_support.build_agent_model(model_id)
+    base_prompt = os.getenv("PROMPT")
+    expect_json = bool(os.getenv("EXPECT_JSON", ""))
+    output_contract = runtime_support.resolve_output_contract()
+    invoke_type_str = os.environ.get("INVOKE_TYPE", InvokeType.BATCH.value)
+    
+    # Validate invoke type
+    try:
+        invoke_type = InvokeType(invoke_type_str)
+    except ValueError:
+        logger.warning("Invalid invoke type, using default", extra={
+            "invoke_type": invoke_type_str,
+            "default": InvokeType.BATCH.value
+        })
+        invoke_type = InvokeType.BATCH
+    
+    # Add observability metadata
+    tracer.put_annotation(key="invoke_type", value=invoke_type.value)
+    tracer.put_annotation(key="expect_json", value=expect_json)
+    metrics.add_dimension(name="invoke_type", value=invoke_type.value)
+    metrics.add_dimension(name="output_contract", value=output_contract)
+    
+    logger.info("Processing batch agent request", extra={
+        "model_id": model_id,
+        "expect_json": expect_json,
+        "output_contract": output_contract,
+        "invoke_type": invoke_type.value,
+        "content_type": event.get('contentType')
+    })
+    
+    try:
+        # Build complete prompt (validates content_type and structure)
+        prompt = build_agent_prompt(base_prompt, event, invoke_type)
+        if runtime_support.debug_agent_payload_enabled():
+            logger.info(
+                "Agent payload debug",
+                extra={
+                    "system_prompt_preview": runtime_support.truncate_for_debug(SYSTEM_PROMPT),
+                    "prompt_preview": runtime_support.truncate_for_debug(prompt),
+                },
+            )
+
+        # Initialize and invoke agent
+        agent = Agent(
+            model=model,
+            tools=AGENT_TOOLS + [file_read],
+            system_prompt=SYSTEM_PROMPT
+        )
+        
+        logger.info("Invoking agent", extra={"prompt_length": len(prompt)})
+        response = agent(prompt)
+
+        message_payload = runtime_support.extract_response_message(response)
+        if runtime_support.debug_agent_payload_enabled():
+            logger.info(
+                "Agent response payload debug",
+                extra={
+                    "message_preview": runtime_support.truncate_for_debug(json.dumps(message_payload)),
+                },
+            )
+        if runtime_support.debug_agent_tool_flow_enabled():
+            logger.info(
+                "Agent tool flow summary",
+                extra=runtime_support.summarize_tool_usage_from_message(message_payload),
+            )
+
+        # Extract response text
+        response_text = runtime_support.extract_response_text(response)
+        logger.info("Agent invocation successful", extra={
+            "response_length": len(response_text)
+        })
+        
+        # Record success metric
+        metrics.add_metric(
+            name="SuccessfulAgentInvocation",
+            unit=MetricUnit.Count,
+            value=1
+        )
+        
+        # Parse JSON if requested
+        if expect_json:
+            result = extract_json_from_text(response_text)
+            if result is None or runtime_support.is_empty_assistant_payload(result):
+                logger.warning(
+                    "Expected JSON but final response was empty or non-JSON; requesting final JSON retry",
+                    extra={
+                        "initial_response_length": len(response_text),
+                        "initial_response_preview": response_text[:500],
+                    },
+                )
+                retry_response = agent(runtime_support.build_final_json_retry_prompt())
+                retry_text = runtime_support.extract_response_text(retry_response)
+                retry_message_payload = runtime_support.extract_response_message(retry_response)
+                if runtime_support.debug_agent_payload_enabled():
+                    logger.info(
+                        "Agent retry payload debug",
+                        extra={
+                            "retry_message_preview": runtime_support.truncate_for_debug(json.dumps(retry_message_payload)),
+                        },
+                    )
+                if runtime_support.debug_agent_tool_flow_enabled():
+                    logger.info(
+                        "Agent retry tool flow summary",
+                        extra=runtime_support.summarize_tool_usage_from_message(retry_message_payload),
+                    )
+                retry_result = extract_json_from_text(retry_text)
+
+                if retry_result is None or runtime_support.is_empty_assistant_payload(retry_result):
+                    logger.warning(
+                        "Retry did not return valid JSON",
+                        extra={
+                            "retry_response_length": len(retry_text),
+                            "retry_response_preview": retry_text[:500],
+                        },
+                    )
+                    result = {
+                        "raw_response": retry_text,
+                        "initial_response": response_text,
+                    }
+                else:
+                    result = retry_result
+
+            if (
+                runtime_support.is_fraud_output_contract_enabled()
+                and isinstance(result, dict)
+                and not runtime_support.is_complete_fraud_result(result)
+            ):
+                logger.warning(
+                    "Result JSON missing required fraud schema fields; forcing a required-tools retry",
+                    extra={
+                        "result_preview": runtime_support.truncate_for_debug(json.dumps(result)),
+                    },
+                )
+                schema_retry_response = agent(runtime_support.build_required_tools_retry_prompt())
+                schema_retry_text = runtime_support.extract_response_text(schema_retry_response)
+                schema_retry_result = extract_json_from_text(schema_retry_text)
+
+                if schema_retry_result is None or not runtime_support.is_complete_fraud_result(schema_retry_result):
+                    raise ValueError(
+                        "Agent response did not include required fraud schema after required-tools retry",
+                    )
+
+                result = schema_retry_result
+        else:
+            result = response_text
+        
+        return {"result": result}
+    
+    except ValueError as e:
+        # Validation errors (invalid content_type, missing fields, etc.)
+        logger.error("Validation error", extra={
+            "error": str(e),
+            "error_type": "ValidationError"
+        })
+        metrics.add_metric(
+            name="ValidationError",
+            unit=MetricUnit.Count,
+            value=1
+        )
+        raise
+        
+    except Exception as e:
+        logger.error("Agent invocation failed", extra={
+            "error": str(e),
+            "error_type": type(e).__name__
+        })
+        metrics.add_metric(
+            name="FailedAgentInvocation",
+            unit=MetricUnit.Count,
+            value=1
+        )
+        raise

package/lib/framework/agents/resources/default-ollama-agent/models.py

@@ -0,0 +1,7 @@
+from pydantic import BaseModel
+
+class ToolLocationDefinition(BaseModel):
+    bucketName: str
+    key: str
+    isFile: bool
+    isZipArchive: bool

package/lib/framework/agents/resources/default-ollama-agent/requirements.txt

@@ -0,0 +1,9 @@
+strands-agents>=1.0.0
+ollama>=0.4.8,<1.0.0
+boto3>=1.0.0
+strands-agents-tools[file_read]
+urllib3>=1.26.0,<2.0.0
+aws-lambda-powertools
+aws-xray-sdk
+pydantic
+aws-opentelemetry-distro