import { BedrockRuntimeClient, ConverseCommand, ConverseCommandInput } from '@aws-sdk/client-bedrock-runtime';

const client = new BedrockRuntimeClient({
  region: 'us-east-1',
});

export const handler = async (): Promise<any> => {
  const input: ConverseCommandInput = {
    modelId: 'amazon.nova-lite-v1:0',
    system: [
      {
        text: 'Tu es un assistant utile qui aide les utilisateurs à obtenir des informations sur la météo actuelle dans une ville',
      },
      {
        cachePoint: {
          type: 'default',
        },
      },
    ],
    messages: [
      {
        role: 'user',
        content: [
          {
            text: 'Salut, ca va ?',
          },
        ],
      },
    ],
  };

  const response = await client.send(new ConverseCommand(input));

  return response.output;
};

import { join, resolve } from 'path';

import { Construct } from 'constructs';
import { RemovalPolicy, Duration, Stack, StackProps } from 'aws-cdk-lib';
import { LogGroup, RetentionDays } from 'aws-cdk-lib/aws-logs';
import { NodejsFunction, OutputFormat, SourceMapMode } from 'aws-cdk-lib/aws-lambda-nodejs';
import { Role, ServicePrincipal, ManagedPolicy, PolicyStatement, Effect } from 'aws-cdk-lib/aws-iam';
import { Function, Code, Runtime, Architecture } from 'aws-cdk-lib/aws-lambda';

export class BedrockCachingStack extends Stack {
  constructor(scope: Construct, id: string, props: StackProps) {
    super(scope, id, props);

    const app = 'bedrock-caching';
    const env = 'dev';

    const role = new Role(this, 'Role', {
      roleName: `${app}-function-${env}`,
      assumedBy: new ServicePrincipal('lambda.amazonaws.com'),
      managedPolicies: [ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSLambdaVPCAccessExecutionRole')],
    });

    role.addToPolicy(
      new PolicyStatement({
        effect: Effect.ALLOW,
        actions: ['bedrock:*'],
        resources: ['*'],
      })
    );

    const functionName = `${app}-hello-${env}`;

    const logGroup = new LogGroup(this, 'LogGroup', {
      logGroupName: `/aws/lambda/${functionName}`,
      retention: RetentionDays.ONE_MONTH,
      removalPolicy: RemovalPolicy.DESTROY,
    });

    const function1 = new NodejsFunction(this, 'Function', {
      runtime: Runtime.NODEJS_22_X,
      memorySize: 512,
      timeout: Duration.seconds(10),
      architecture: Architecture.ARM_64,
      entry: resolve(join(process.cwd(), 'src/handlers', 'hello-bedrock-handler.ts')),
      handler: 'handler',
      functionName,
      logGroup,
      role,
      bundling: {
        platform: 'node',
        format: OutputFormat.CJS,
        forceDockerBundling: false,
        minify: true,
        sourceMap: true,
        sourcesContent: true,
        sourceMapMode: SourceMapMode.INLINE,
        metafile: false,
      },
      awsSdkConnectionReuse: false,
    });

    function1.node.addDependency(logGroup);
  }
}