aws-cdk-lib.aws_bedrockagentcore.CfnHarnessProps

CfnHarnessProps Struct

Properties for defining a CfnHarness.

CfnHarnessProps

used as props by

• CfnHarness

Source

Generated code

Type last changed

v2.273.0 · 8 Oct 2026

Example

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import { aws_bedrockagentcore as bedrockagentcore } from 'aws-cdk-lib';

declare const additionalParams: any;
declare const awsIam: any;
declare const disabled: any;
declare const inputSchema: any;
declare const none: any;
const cfnHarnessProps: bedrockagentcore.CfnHarnessProps = {
  executionRoleArn: 'executionRoleArn',
  harnessName: 'harnessName',
  model: {
    bedrockModelConfig: {
      modelId: 'modelId',

      // the properties below are optional
      additionalParams: additionalParams,
      apiFormat: 'apiFormat',
      maxTokens: 123,
      temperature: 123,
      topP: 123,
    },
    geminiModelConfig: {
      apiKeyArn: 'apiKeyArn',
      modelId: 'modelId',

      // the properties below are optional
      additionalParams: additionalParams,
      maxTokens: 123,
      temperature: 123,
      topK: 123,
      topP: 123,
    },
    liteLlmModelConfig: {
      modelId: 'modelId',

      // the properties below are optional
      additionalParams: additionalParams,
      apiBase: 'apiBase',
      apiKeyArn: 'apiKeyArn',
      maxTokens: 123,
      temperature: 123,
      topP: 123,
    },
    openAiModelConfig: {
      apiKeyArn: 'apiKeyArn',
      modelId: 'modelId',

      // the properties below are optional
      additionalParams: additionalParams,
      apiBase: 'apiBase',
      apiFormat: 'apiFormat',
      maxTokens: 123,
      temperature: 123,
      topP: 123,
    },
  },

  // the properties below are optional
  allowedTools: ['allowedTools'],
  authorizerConfiguration: {
    customJwtAuthorizer: {
      discoveryUrl: 'discoveryUrl',

      // the properties below are optional
      advertisedScopeMapping: {
        advertisedScopeMappingKey: 'advertisedScopeMapping',
      },
      allowedAudience: ['allowedAudience'],
      allowedClients: ['allowedClients'],
      allowedScopes: ['allowedScopes'],
      customClaims: [{
        authorizingClaimMatchValue: {
          claimMatchOperator: 'claimMatchOperator',
          claimMatchValue: {
            matchValueString: 'matchValueString',
            matchValueStringList: ['matchValueStringList'],
          },
        },
        inboundTokenClaimName: 'inboundTokenClaimName',
        inboundTokenClaimValueType: 'inboundTokenClaimValueType',
      }],
      privateEndpoint: {
        managedVpcResource: {
          endpointIpAddressType: 'endpointIpAddressType',
          subnetIds: ['subnetIds'],
          vpcIdentifier: 'vpcIdentifier',

          // the properties below are optional
          routingDomain: 'routingDomain',
          securityGroupIds: ['securityGroupIds'],
          tags: {
            tagsKey: 'tags',
          },
        },
        selfManagedLatticeResource: {
          resourceConfigurationIdentifier: 'resourceConfigurationIdentifier',
        },
      },
      privateEndpointOverrides: [{
        domain: 'domain',
        privateEndpoint: {
          managedVpcResource: {
            endpointIpAddressType: 'endpointIpAddressType',
            subnetIds: ['subnetIds'],
            vpcIdentifier: 'vpcIdentifier',

            // the properties below are optional
            routingDomain: 'routingDomain',
            securityGroupIds: ['securityGroupIds'],
            tags: {
              tagsKey: 'tags',
            },
          },
          selfManagedLatticeResource: {
            resourceConfigurationIdentifier: 'resourceConfigurationIdentifier',
          },
        },
      }],
    },
  },
  environment: {
    agentCoreRuntimeEnvironment: {
      agentRuntimeArn: 'agentRuntimeArn',
      agentRuntimeId: 'agentRuntimeId',
      agentRuntimeName: 'agentRuntimeName',
      filesystemConfigurations: [{
        efsAccessPoint: {
          accessPointArn: 'accessPointArn',
          mountPath: 'mountPath',
        },
        s3FilesAccessPoint: {
          accessPointArn: 'accessPointArn',
          mountPath: 'mountPath',
        },
        sessionStorage: {
          mountPath: 'mountPath',
        },
      }],
      lifecycleConfiguration: {
        idleRuntimeSessionTimeout: 123,
        maxLifetime: 123,
      },
      networkConfiguration: {
        networkMode: 'networkMode',

        // the properties below are optional
        networkModeConfig: {
          securityGroups: ['securityGroups'],
          subnets: ['subnets'],
        },
      },
    },
  },
  environmentArtifact: {
    containerConfiguration: {
      containerUri: 'containerUri',
    },
  },
  environmentVariables: {
    environmentVariablesKey: 'environmentVariables',
  },
  hooks: [{
    afterInvocation: {
      name: 'name',
      target: {
        eventBridge: {
          arn: 'arn',
        },
        lambda: {
          arn: 'arn',

          // the properties below are optional
          failureMode: 'failureMode',
          timeoutSeconds: 123,
        },
        sns: {
          arn: 'arn',
        },
      },
    },
    afterToolCall: {
      name: 'name',
      target: {
        eventBridge: {
          arn: 'arn',
        },
        lambda: {
          arn: 'arn',

          // the properties below are optional
          failureMode: 'failureMode',
          timeoutSeconds: 123,
        },
        sns: {
          arn: 'arn',
        },
      },
    },
    beforeInvocation: {
      name: 'name',
      target: {
        eventBridge: {
          arn: 'arn',
        },
        lambda: {
          arn: 'arn',

          // the properties below are optional
          failureMode: 'failureMode',
          timeoutSeconds: 123,
        },
        sns: {
          arn: 'arn',
        },
      },
    },
    beforeToolCall: {
      name: 'name',
      target: {
        eventBridge: {
          arn: 'arn',
        },
        lambda: {
          arn: 'arn',

          // the properties below are optional
          failureMode: 'failureMode',
          timeoutSeconds: 123,
        },
        sns: {
          arn: 'arn',
        },
      },
    },
  }],
  maxIterations: 123,
  maxTokens: 123,
  memory: {
    agentCoreMemoryConfiguration: {
      arn: 'arn',

      // the properties below are optional
      actorId: 'actorId',
      messagesCount: 123,
      retrievalConfig: {
        retrievalConfigKey: {
          relevanceScore: 123,
          strategyId: 'strategyId',
          topK: 123,
        },
      },
    },
    disabled: disabled,
    managedMemoryConfiguration: {
      arn: 'arn',
      encryptionKeyArn: 'encryptionKeyArn',
      eventExpiryDuration: 123,
      strategies: ['strategies'],
    },
  },
  skills: [{
    awsSkills: {
      paths: ['paths'],
    },
    git: {
      url: 'url',

      // the properties below are optional
      auth: {
        credentialArn: 'credentialArn',

        // the properties below are optional
        username: 'username',
      },
      path: 'path',
    },
    path: 'path',
    s3: {
      uri: 'uri',
    },
  }],
  systemPrompt: [{
    text: 'text',
  }],
  tags: [{
    key: 'key',
    value: 'value',
  }],
  timeoutSeconds: 123,
  tools: [{
    type: 'type',

    // the properties below are optional
    config: {
      agentCoreBrowser: {
        browserArn: 'browserArn',
      },
      agentCoreCodeInterpreter: {
        codeInterpreterArn: 'codeInterpreterArn',
      },
      agentCoreGateway: {
        gatewayArn: 'gatewayArn',

        // the properties below are optional
        outboundAuth: {
          awsIam: awsIam,
          none: none,
          oauth: {
            providerArn: 'providerArn',
            scopes: ['scopes'],

            // the properties below are optional
            customParameters: {
              customParametersKey: 'customParameters',
            },
            defaultReturnUrl: 'defaultReturnUrl',
            grantType: 'grantType',
          },
        },
      },
      inlineFunction: {
        description: 'description',
        inputSchema: inputSchema,
      },
      remoteMcp: {
        url: 'url',

        // the properties below are optional
        headers: {
          headersKey: 'headers',
        },
      },
    },
    name: 'name',
  }],
  truncation: {
    strategy: 'strategy',

    // the properties below are optional
    config: {
      slidingWindow: {
        messagesCount: 123,
      },
      summarization: {
        preserveRecentMessages: 123,
        summarizationSystemPrompt: 'summarizationSystemPrompt',
        summaryRatio: 123,
      },
    },
  },
};

Properties

allowedTools?optionalstring[]allowed_tools?optionaltyping.List[str]allowedTools?optionalList<String>AllowedTools?optionalstring[]AllowedTools?optional*[]*string#

The tools that the agent is allowed to use.

authorizerConfiguration?optionalIResolvable | CfnHarness.AuthorizerConfigurationPropertyauthorizer_configuration?optionaltyping.Union[IResolvable, AuthorizerConfigurationProperty]authorizerConfiguration?optionalIResolvableAuthorizerConfiguration?optionalIResolvableAuthorizerConfiguration?optionalinterface{}#

environment?optionalIResolvable | CfnHarness.HarnessEnvironmentProviderPropertyenvironment?optionaltyping.Union[IResolvable, HarnessEnvironmentProviderProperty]environment?optionalIResolvableEnvironment?optionalIResolvableEnvironment?optionalinterface{}#

environmentArtifact?optionalIResolvable | CfnHarness.HarnessEnvironmentArtifactPropertyenvironment_artifact?optionaltyping.Union[IResolvable, HarnessEnvironmentArtifactProperty]environmentArtifact?optionalIResolvableEnvironmentArtifact?optionalIResolvableEnvironmentArtifact?optionalinterface{}#

environmentVariables?optionalIResolvable | { [key: string]: string }environment_variables?optionaltyping.Union[IResolvable, typing.Mapping[str, str]]environmentVariables?optionalIResolvableEnvironmentVariables?optionalIResolvableEnvironmentVariables?optionalinterface{}#

Environment variables to set in the harness runtime environment.

executionRoleArnstringexecution_role_arnstrexecutionRoleArnStringExecutionRoleArnstringExecutionRoleArn*stringrequired#

The ARN of the IAM role that the harness assumes when running.

harnessNamestringharness_namestrharnessNameStringHarnessNamestringHarnessName*stringrequired#

The name of the harness.

hooks?optionalIResolvable | IResolvable | CfnHarness.HarnessHookProperty[]hooks?optionaltyping.Union[IResolvable, typing.List[typing.Union[IResolvable, HarnessHookProperty]]]hooks?optionalIResolvableHooks?optionalIResolvableHooks?optionalinterface{}#

Lifecycle hooks that fire at well-defined points in the agent loop for policy enforcement, audit, and governance.

maxIterations?optionalnumbermax_iterations?optionalint | floatmaxIterations?optionalNumberMaxIterations?optionaldoubleMaxIterations?optional*float64#

The maximum number of iterations the agent loop can execute per invocation.

maxTokens?optionalnumbermax_tokens?optionalint | floatmaxTokens?optionalNumberMaxTokens?optionaldoubleMaxTokens?optional*float64#

The maximum number of tokens the agent can generate per iteration.

memory?optionalIResolvable | CfnHarness.HarnessMemoryConfigurationPropertymemory?optionaltyping.Union[IResolvable, HarnessMemoryConfigurationProperty]memory?optionalIResolvableMemory?optionalIResolvableMemory?optionalinterface{}#

modelIResolvable | CfnHarness.HarnessModelConfigurationPropertymodeltyping.Union[IResolvable, HarnessModelConfigurationProperty]modelIResolvableModelIResolvableModelinterface{}required#

skills?optionalIResolvable | IResolvable | CfnHarness.HarnessSkillProperty[]skills?optionaltyping.Union[IResolvable, typing.List[typing.Union[IResolvable, HarnessSkillProperty]]]skills?optionalIResolvableSkills?optionalIResolvableSkills?optionalinterface{}#

The skills available to the agent.

systemPrompt?optionalIResolvable | IResolvable | CfnHarness.HarnessSystemContentBlockProperty[]system_prompt?optionaltyping.Union[IResolvable, typing.List[typing.Union[IResolvable, HarnessSystemContentBlockProperty]]]systemPrompt?optionalIResolvableSystemPrompt?optionalIResolvableSystemPrompt?optionalinterface{}#

The system prompt that defines the agent's behavior.

tags?optionalCfnTag[]tags?optionaltyping.List[CfnTag]tags?optionalList<CfnTag>Tags?optionalCfnTag[]Tags?optional*[]CfnTag#

Tags to apply to the harness resource.

timeoutSeconds?optionalnumbertimeout_seconds?optionalint | floattimeoutSeconds?optionalNumberTimeoutSeconds?optionaldoubleTimeoutSeconds?optional*float64#

The maximum duration in seconds for the agent loop execution per invocation.

tools?optionalIResolvable | IResolvable | CfnHarness.HarnessToolProperty[]tools?optionaltyping.Union[IResolvable, typing.List[typing.Union[IResolvable, HarnessToolProperty]]]tools?optionalIResolvableTools?optionalIResolvableTools?optionalinterface{}#

The tools available to the agent.

truncation?optionalIResolvable | CfnHarness.HarnessTruncationConfigurationPropertytruncation?optionaltyping.Union[IResolvable, HarnessTruncationConfigurationProperty]truncation?optionalIResolvableTruncation?optionalIResolvableTruncation?optionalinterface{}#