@aws-sdk/client-bedrock-agent-runtime 3.701.0 → 3.705.0

package/dist-es/BedrockAgentRuntime.js

@@ -6,7 +6,9 @@ import { InvokeAgentCommand } from "./commands/InvokeAgentCommand";
 import { InvokeFlowCommand } from "./commands/InvokeFlowCommand";
 import { InvokeInlineAgentCommand, } from "./commands/InvokeInlineAgentCommand";
 import { OptimizePromptCommand, } from "./commands/OptimizePromptCommand";
+import { RerankCommand } from "./commands/RerankCommand";
 import { RetrieveAndGenerateCommand, } from "./commands/RetrieveAndGenerateCommand";
+import { RetrieveAndGenerateStreamCommand, } from "./commands/RetrieveAndGenerateStreamCommand";
 import { RetrieveCommand } from "./commands/RetrieveCommand";
 const commands = {
     DeleteAgentMemoryCommand,
@@ -15,8 +17,10 @@ const commands = {
     InvokeFlowCommand,
     InvokeInlineAgentCommand,
     OptimizePromptCommand,
+    RerankCommand,
     RetrieveCommand,
     RetrieveAndGenerateCommand,
+    RetrieveAndGenerateStreamCommand,
 };
 export class BedrockAgentRuntime extends BedrockAgentRuntimeClient {
 }

package/dist-es/commands/RerankCommand.js

@@ -0,0 +1,23 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { commonParams } from "../endpoint/EndpointParameters";
+import { RerankRequestFilterSensitiveLog, RerankResponseFilterSensitiveLog, } from "../models/models_0";
+import { de_RerankCommand, se_RerankCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class RerankCommand extends $Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonBedrockAgentRunTimeService", "Rerank", {})
+    .n("BedrockAgentRuntimeClient", "RerankCommand")
+    .f(RerankRequestFilterSensitiveLog, RerankResponseFilterSensitiveLog)
+    .ser(se_RerankCommand)
+    .de(de_RerankCommand)
+    .build() {
+}

package/dist-es/commands/RetrieveAndGenerateStreamCommand.js

@@ -0,0 +1,27 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { commonParams } from "../endpoint/EndpointParameters";
+import { RetrieveAndGenerateStreamRequestFilterSensitiveLog, RetrieveAndGenerateStreamResponseFilterSensitiveLog, } from "../models/models_0";
+import { de_RetrieveAndGenerateStreamCommand, se_RetrieveAndGenerateStreamCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class RetrieveAndGenerateStreamCommand extends $Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonBedrockAgentRunTimeService", "RetrieveAndGenerateStream", {
+    eventStream: {
+        output: true,
+    },
+})
+    .n("BedrockAgentRuntimeClient", "RetrieveAndGenerateStreamCommand")
+    .f(RetrieveAndGenerateStreamRequestFilterSensitiveLog, RetrieveAndGenerateStreamResponseFilterSensitiveLog)
+    .ser(se_RetrieveAndGenerateStreamCommand)
+    .de(de_RetrieveAndGenerateStreamCommand)
+    .build() {
+}

package/dist-es/commands/index.js

@@ -4,5 +4,7 @@ export * from "./InvokeAgentCommand";
 export * from "./InvokeFlowCommand";
 export * from "./InvokeInlineAgentCommand";
 export * from "./OptimizePromptCommand";
+export * from "./RerankCommand";
 export * from "./RetrieveAndGenerateCommand";
+export * from "./RetrieveAndGenerateStreamCommand";
 export * from "./RetrieveCommand";

package/dist-es/models/models_0.js

@@ -67,6 +67,38 @@ export var FunctionSchema;
         return visitor._(value.$unknown[0], value.$unknown[1]);
     };
 })(FunctionSchema || (FunctionSchema = {}));
+export const ConfirmationState = {
+    CONFIRM: "CONFIRM",
+    DENY: "DENY",
+};
+export const ResponseState = {
+    FAILURE: "FAILURE",
+    REPROMPT: "REPROMPT",
+};
+export var InvocationResultMember;
+(function (InvocationResultMember) {
+    InvocationResultMember.visit = (value, visitor) => {
+        if (value.apiResult !== undefined)
+            return visitor.apiResult(value.apiResult);
+        if (value.functionResult !== undefined)
+            return visitor.functionResult(value.functionResult);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(InvocationResultMember || (InvocationResultMember = {}));
+export const PayloadType = {
+    RETURN_CONTROL: "RETURN_CONTROL",
+    TEXT: "TEXT",
+};
+export var InvocationInputMember;
+(function (InvocationInputMember) {
+    InvocationInputMember.visit = (value, visitor) => {
+        if (value.apiInvocationInput !== undefined)
+            return visitor.apiInvocationInput(value.apiInvocationInput);
+        if (value.functionInvocationInput !== undefined)
+            return visitor.functionInvocationInput(value.functionInvocationInput);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(InvocationInputMember || (InvocationInputMember = {}));
 export class BadGatewayException extends __BaseException {
     constructor(opts) {
         super({
@@ -251,6 +283,18 @@ export var FlowResponseStream;
         return visitor._(value.$unknown[0], value.$unknown[1]);
     };
 })(FlowResponseStream || (FlowResponseStream = {}));
+export var ContentBlock;
+(function (ContentBlock) {
+    ContentBlock.visit = (value, visitor) => {
+        if (value.text !== undefined)
+            return visitor.text(value.text);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(ContentBlock || (ContentBlock = {}));
+export const ConversationRole = {
+    ASSISTANT: "assistant",
+    USER: "user",
+};
 export const FileSourceType = {
     BYTE_CONTENT: "BYTE_CONTENT",
     S3: "S3",
@@ -259,45 +303,49 @@ export const FileUseCase = {
     CHAT: "CHAT",
     CODE_INTERPRETER: "CODE_INTERPRETER",
 };
+export const AttributeType = {
+    BOOLEAN: "BOOLEAN",
+    NUMBER: "NUMBER",
+    STRING: "STRING",
+    STRING_LIST: "STRING_LIST",
+};
 export const SearchType = {
     HYBRID: "HYBRID",
     SEMANTIC: "SEMANTIC",
 };
-export const ConfirmationState = {
-    CONFIRM: "CONFIRM",
-    DENY: "DENY",
-};
-export const ResponseState = {
-    FAILURE: "FAILURE",
-    REPROMPT: "REPROMPT",
+export const RerankingMetadataSelectionMode = {
+    ALL: "ALL",
+    SELECTIVE: "SELECTIVE",
 };
-export var InvocationResultMember;
-(function (InvocationResultMember) {
-    InvocationResultMember.visit = (value, visitor) => {
-        if (value.apiResult !== undefined)
-            return visitor.apiResult(value.apiResult);
-        if (value.functionResult !== undefined)
-            return visitor.functionResult(value.functionResult);
+export var RerankingMetadataSelectiveModeConfiguration;
+(function (RerankingMetadataSelectiveModeConfiguration) {
+    RerankingMetadataSelectiveModeConfiguration.visit = (value, visitor) => {
+        if (value.fieldsToInclude !== undefined)
+            return visitor.fieldsToInclude(value.fieldsToInclude);
+        if (value.fieldsToExclude !== undefined)
+            return visitor.fieldsToExclude(value.fieldsToExclude);
         return visitor._(value.$unknown[0], value.$unknown[1]);
     };
-})(InvocationResultMember || (InvocationResultMember = {}));
+})(RerankingMetadataSelectiveModeConfiguration || (RerankingMetadataSelectiveModeConfiguration = {}));
+export const VectorSearchRerankingConfigurationType = {
+    BEDROCK_RERANKING_MODEL: "BEDROCK_RERANKING_MODEL",
+};
 export const RetrievalResultLocationType = {
     CONFLUENCE: "CONFLUENCE",
+    CUSTOM: "CUSTOM",
     S3: "S3",
     SALESFORCE: "SALESFORCE",
     SHAREPOINT: "SHAREPOINT",
     WEB: "WEB",
 };
-export var InvocationInputMember;
-(function (InvocationInputMember) {
-    InvocationInputMember.visit = (value, visitor) => {
-        if (value.apiInvocationInput !== undefined)
-            return visitor.apiInvocationInput(value.apiInvocationInput);
-        if (value.functionInvocationInput !== undefined)
-            return visitor.functionInvocationInput(value.functionInvocationInput);
+export var Caller;
+(function (Caller) {
+    Caller.visit = (value, visitor) => {
+        if (value.agentAliasArn !== undefined)
+            return visitor.agentAliasArn(value.agentAliasArn);
         return visitor._(value.$unknown[0], value.$unknown[1]);
     };
-})(InvocationInputMember || (InvocationInputMember = {}));
+})(Caller || (Caller = {}));
 export const GuardrailAction = {
     INTERVENED: "INTERVENED",
     NONE: "NONE",
@@ -371,6 +419,7 @@ export const GuardrailManagedWordType = {
 export const InvocationType = {
     ACTION_GROUP: "ACTION_GROUP",
     ACTION_GROUP_CODE_INTERPRETER: "ACTION_GROUP_CODE_INTERPRETER",
+    AGENT_COLLABORATOR: "AGENT_COLLABORATOR",
     FINISH: "FINISH",
     KNOWLEDGE_BASE: "KNOWLEDGE_BASE",
 };
@@ -392,6 +441,7 @@ export const Source = {
 };
 export const Type = {
     ACTION_GROUP: "ACTION_GROUP",
+    AGENT_COLLABORATOR: "AGENT_COLLABORATOR",
     ASK_USER: "ASK_USER",
     FINISH: "FINISH",
     KNOWLEDGE_BASE: "KNOWLEDGE_BASE",
@@ -433,6 +483,20 @@ export var PreProcessingTrace;
         return visitor._(value.$unknown[0], value.$unknown[1]);
     };
 })(PreProcessingTrace || (PreProcessingTrace = {}));
+export var RoutingClassifierTrace;
+(function (RoutingClassifierTrace) {
+    RoutingClassifierTrace.visit = (value, visitor) => {
+        if (value.invocationInput !== undefined)
+            return visitor.invocationInput(value.invocationInput);
+        if (value.observation !== undefined)
+            return visitor.observation(value.observation);
+        if (value.modelInvocationInput !== undefined)
+            return visitor.modelInvocationInput(value.modelInvocationInput);
+        if (value.modelInvocationOutput !== undefined)
+            return visitor.modelInvocationOutput(value.modelInvocationOutput);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(RoutingClassifierTrace || (RoutingClassifierTrace = {}));
 export var Trace;
 (function (Trace) {
     Trace.visit = (value, visitor) => {
@@ -444,6 +508,8 @@ export var Trace;
             return visitor.orchestrationTrace(value.orchestrationTrace);
         if (value.postProcessingTrace !== undefined)
             return visitor.postProcessingTrace(value.postProcessingTrace);
+        if (value.routingClassifierTrace !== undefined)
+            return visitor.routingClassifierTrace(value.routingClassifierTrace);
         if (value.failureTrace !== undefined)
             return visitor.failureTrace(value.failureTrace);
         if (value.customOrchestrationTrace !== undefined)
@@ -568,6 +634,19 @@ export var OptimizedPromptStream;
         return visitor._(value.$unknown[0], value.$unknown[1]);
     };
 })(OptimizedPromptStream || (OptimizedPromptStream = {}));
+export const RerankQueryContentType = {
+    TEXT: "TEXT",
+};
+export const RerankingConfigurationType = {
+    BEDROCK_RERANKING_MODEL: "BEDROCK_RERANKING_MODEL",
+};
+export const RerankDocumentType = {
+    JSON: "JSON",
+    TEXT: "TEXT",
+};
+export const RerankSourceType = {
+    INLINE: "INLINE",
+};
 export const ExternalSourceType = {
     BYTE_CONTENT: "BYTE_CONTENT",
     S3: "S3",
@@ -583,6 +662,36 @@ export const GuadrailAction = {
     INTERVENED: "INTERVENED",
     NONE: "NONE",
 };
+export var RetrieveAndGenerateStreamResponseOutput;
+(function (RetrieveAndGenerateStreamResponseOutput) {
+    RetrieveAndGenerateStreamResponseOutput.visit = (value, visitor) => {
+        if (value.output !== undefined)
+            return visitor.output(value.output);
+        if (value.citation !== undefined)
+            return visitor.citation(value.citation);
+        if (value.guardrail !== undefined)
+            return visitor.guardrail(value.guardrail);
+        if (value.internalServerException !== undefined)
+            return visitor.internalServerException(value.internalServerException);
+        if (value.validationException !== undefined)
+            return visitor.validationException(value.validationException);
+        if (value.resourceNotFoundException !== undefined)
+            return visitor.resourceNotFoundException(value.resourceNotFoundException);
+        if (value.serviceQuotaExceededException !== undefined)
+            return visitor.serviceQuotaExceededException(value.serviceQuotaExceededException);
+        if (value.throttlingException !== undefined)
+            return visitor.throttlingException(value.throttlingException);
+        if (value.accessDeniedException !== undefined)
+            return visitor.accessDeniedException(value.accessDeniedException);
+        if (value.conflictException !== undefined)
+            return visitor.conflictException(value.conflictException);
+        if (value.dependencyFailedException !== undefined)
+            return visitor.dependencyFailedException(value.dependencyFailedException);
+        if (value.badGatewayException !== undefined)
+            return visitor.badGatewayException(value.badGatewayException);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(RetrieveAndGenerateStreamResponseOutput || (RetrieveAndGenerateStreamResponseOutput = {}));
 export var RetrievalFilter;
 (function (RetrievalFilter) {
     RetrievalFilter.visit = (value, visitor) => {
@@ -652,6 +761,67 @@ export const AgentActionGroupFilterSensitiveLog = (obj) => ({
     ...(obj.apiSchema && { apiSchema: APISchemaFilterSensitiveLog(obj.apiSchema) }),
     ...(obj.functionSchema && { functionSchema: FunctionSchemaFilterSensitiveLog(obj.functionSchema) }),
 });
+export const ApiResultFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.apiPath && { apiPath: SENSITIVE_STRING }),
+});
+export const InvocationResultMemberFilterSensitiveLog = (obj) => {
+    if (obj.apiResult !== undefined)
+        return { apiResult: ApiResultFilterSensitiveLog(obj.apiResult) };
+    if (obj.functionResult !== undefined)
+        return { functionResult: obj.functionResult };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const ReturnControlResultsFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.returnControlInvocationResults && {
+        returnControlInvocationResults: obj.returnControlInvocationResults.map((item) => InvocationResultMemberFilterSensitiveLog(item)),
+    }),
+});
+export const AgentCollaboratorInputPayloadFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.text && { text: SENSITIVE_STRING }),
+    ...(obj.returnControlResults && {
+        returnControlResults: ReturnControlResultsFilterSensitiveLog(obj.returnControlResults),
+    }),
+});
+export const AgentCollaboratorInvocationInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.input && { input: AgentCollaboratorInputPayloadFilterSensitiveLog(obj.input) }),
+});
+export const ApiInvocationInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.apiPath && { apiPath: SENSITIVE_STRING }),
+    ...(obj.collaboratorName && { collaboratorName: SENSITIVE_STRING }),
+});
+export const FunctionInvocationInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.collaboratorName && { collaboratorName: SENSITIVE_STRING }),
+});
+export const InvocationInputMemberFilterSensitiveLog = (obj) => {
+    if (obj.apiInvocationInput !== undefined)
+        return { apiInvocationInput: ApiInvocationInputFilterSensitiveLog(obj.apiInvocationInput) };
+    if (obj.functionInvocationInput !== undefined)
+        return { functionInvocationInput: FunctionInvocationInputFilterSensitiveLog(obj.functionInvocationInput) };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const ReturnControlPayloadFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.invocationInputs && {
+        invocationInputs: obj.invocationInputs.map((item) => InvocationInputMemberFilterSensitiveLog(item)),
+    }),
+});
+export const AgentCollaboratorOutputPayloadFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.text && { text: SENSITIVE_STRING }),
+    ...(obj.returnControlPayload && { returnControlPayload: SENSITIVE_STRING }),
+});
+export const AgentCollaboratorInvocationOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.output && { output: AgentCollaboratorOutputPayloadFilterSensitiveLog(obj.output) }),
+});
 export const FlowInputContentFilterSensitiveLog = (obj) => {
     if (obj.document !== undefined)
         return { document: obj.document };
@@ -748,6 +918,20 @@ export const InvokeFlowResponseFilterSensitiveLog = (obj) => ({
     ...obj,
     ...(obj.responseStream && { responseStream: "STREAMING_CONTENT" }),
 });
+export const ContentBlockFilterSensitiveLog = (obj) => {
+    if (obj.text !== undefined)
+        return { text: obj.text };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const MessageFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.content && { content: SENSITIVE_STRING }),
+});
+export const ConversationHistoryFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.messages && { messages: obj.messages.map((item) => MessageFilterSensitiveLog(item)) }),
+});
 export const ByteContentFileFilterSensitiveLog = (obj) => ({
     ...obj,
     ...(obj.data && { data: SENSITIVE_STRING }),
@@ -760,18 +944,39 @@ export const InputFileFilterSensitiveLog = (obj) => ({
     ...obj,
     ...(obj.source && { source: FileSourceFilterSensitiveLog(obj.source) }),
 });
-export const ApiResultFilterSensitiveLog = (obj) => ({
+export const MetadataAttributeSchemaFilterSensitiveLog = (obj) => ({
     ...obj,
-    ...(obj.apiPath && { apiPath: SENSITIVE_STRING }),
 });
-export const InvocationResultMemberFilterSensitiveLog = (obj) => {
-    if (obj.apiResult !== undefined)
-        return { apiResult: ApiResultFilterSensitiveLog(obj.apiResult) };
-    if (obj.functionResult !== undefined)
-        return { functionResult: obj.functionResult };
+export const ImplicitFilterConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.metadataAttributes && { metadataAttributes: SENSITIVE_STRING }),
+});
+export const RerankingMetadataSelectiveModeConfigurationFilterSensitiveLog = (obj) => {
+    if (obj.fieldsToInclude !== undefined)
+        return { fieldsToInclude: SENSITIVE_STRING };
+    if (obj.fieldsToExclude !== undefined)
+        return { fieldsToExclude: SENSITIVE_STRING };
     if (obj.$unknown !== undefined)
         return { [obj.$unknown[0]]: "UNKNOWN" };
 };
+export const MetadataConfigurationForRerankingFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.selectiveModeConfiguration && {
+        selectiveModeConfiguration: RerankingMetadataSelectiveModeConfigurationFilterSensitiveLog(obj.selectiveModeConfiguration),
+    }),
+});
+export const VectorSearchBedrockRerankingConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.metadataConfiguration && {
+        metadataConfiguration: MetadataConfigurationForRerankingFilterSensitiveLog(obj.metadataConfiguration),
+    }),
+});
+export const VectorSearchRerankingConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.bedrockRerankingConfiguration && {
+        bedrockRerankingConfiguration: VectorSearchBedrockRerankingConfigurationFilterSensitiveLog(obj.bedrockRerankingConfiguration),
+    }),
+});
 export const TextResponsePartFilterSensitiveLog = (obj) => ({
     ...obj,
 });
@@ -817,24 +1022,6 @@ export const FilePartFilterSensitiveLog = (obj) => ({
     ...obj,
     ...(obj.files && { files: SENSITIVE_STRING }),
 });
-export const ApiInvocationInputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.apiPath && { apiPath: SENSITIVE_STRING }),
-});
-export const InvocationInputMemberFilterSensitiveLog = (obj) => {
-    if (obj.apiInvocationInput !== undefined)
-        return { apiInvocationInput: ApiInvocationInputFilterSensitiveLog(obj.apiInvocationInput) };
-    if (obj.functionInvocationInput !== undefined)
-        return { functionInvocationInput: obj.functionInvocationInput };
-    if (obj.$unknown !== undefined)
-        return { [obj.$unknown[0]]: "UNKNOWN" };
-};
-export const ReturnControlPayloadFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.invocationInputs && {
-        invocationInputs: obj.invocationInputs.map((item) => InvocationInputMemberFilterSensitiveLog(item)),
-    }),
-});
 export const CustomOrchestrationTraceEventFilterSensitiveLog = (obj) => ({
     ...obj,
 });
@@ -907,6 +1094,9 @@ export const InvocationInputFilterSensitiveLog = (obj) => ({
     ...(obj.knowledgeBaseLookupInput && {
         knowledgeBaseLookupInput: KnowledgeBaseLookupInputFilterSensitiveLog(obj.knowledgeBaseLookupInput),
     }),
+    ...(obj.agentCollaboratorInvocationInput && {
+        agentCollaboratorInvocationInput: AgentCollaboratorInvocationInputFilterSensitiveLog(obj.agentCollaboratorInvocationInput),
+    }),
 });
 export const ModelInvocationInputFilterSensitiveLog = (obj) => ({
     ...obj,
@@ -946,6 +1136,9 @@ export const ObservationFilterSensitiveLog = (obj) => ({
     ...(obj.actionGroupInvocationOutput && {
         actionGroupInvocationOutput: ActionGroupInvocationOutputFilterSensitiveLog(obj.actionGroupInvocationOutput),
     }),
+    ...(obj.agentCollaboratorInvocationOutput && {
+        agentCollaboratorInvocationOutput: AgentCollaboratorInvocationOutputFilterSensitiveLog(obj.agentCollaboratorInvocationOutput),
+    }),
     ...(obj.knowledgeBaseLookupOutput && {
         knowledgeBaseLookupOutput: KnowledgeBaseLookupOutputFilterSensitiveLog(obj.knowledgeBaseLookupOutput),
     }),
@@ -1006,6 +1199,23 @@ export const PreProcessingTraceFilterSensitiveLog = (obj) => {
     if (obj.$unknown !== undefined)
         return { [obj.$unknown[0]]: "UNKNOWN" };
 };
+export const RoutingClassifierModelInvocationOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.rawResponse && { rawResponse: SENSITIVE_STRING }),
+    ...(obj.metadata && { metadata: SENSITIVE_STRING }),
+});
+export const RoutingClassifierTraceFilterSensitiveLog = (obj) => {
+    if (obj.invocationInput !== undefined)
+        return { invocationInput: SENSITIVE_STRING };
+    if (obj.observation !== undefined)
+        return { observation: SENSITIVE_STRING };
+    if (obj.modelInvocationInput !== undefined)
+        return { modelInvocationInput: SENSITIVE_STRING };
+    if (obj.modelInvocationOutput !== undefined)
+        return { modelInvocationOutput: SENSITIVE_STRING };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
 export const TraceFilterSensitiveLog = (obj) => {
     if (obj.guardrailTrace !== undefined)
         return { guardrailTrace: SENSITIVE_STRING };
@@ -1015,6 +1225,8 @@ export const TraceFilterSensitiveLog = (obj) => {
         return { orchestrationTrace: SENSITIVE_STRING };
     if (obj.postProcessingTrace !== undefined)
         return { postProcessingTrace: SENSITIVE_STRING };
+    if (obj.routingClassifierTrace !== undefined)
+        return { routingClassifierTrace: SENSITIVE_STRING };
     if (obj.failureTrace !== undefined)
         return { failureTrace: SENSITIVE_STRING };
     if (obj.customOrchestrationTrace !== undefined)
@@ -1025,6 +1237,8 @@ export const TraceFilterSensitiveLog = (obj) => {
 export const TracePartFilterSensitiveLog = (obj) => ({
     ...obj,
     ...(obj.trace && { trace: SENSITIVE_STRING }),
+    ...(obj.callerChain && { callerChain: obj.callerChain.map((item) => item) }),
+    ...(obj.collaboratorName && { collaboratorName: SENSITIVE_STRING }),
 });
 export const ResponseStreamFilterSensitiveLog = (obj) => {
     if (obj.chunk !== undefined)
@@ -1180,6 +1394,34 @@ export const OptimizePromptResponseFilterSensitiveLog = (obj) => ({
     ...obj,
     ...(obj.optimizedPrompt && { optimizedPrompt: "STREAMING_CONTENT" }),
 });
+export const RerankTextDocumentFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const RerankQueryFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.textQuery && { textQuery: SENSITIVE_STRING }),
+});
+export const RerankDocumentFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.textDocument && { textDocument: SENSITIVE_STRING }),
+});
+export const RerankSourceFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.inlineDocumentSource && { inlineDocumentSource: SENSITIVE_STRING }),
+});
+export const RerankRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.queries && { queries: SENSITIVE_STRING }),
+    ...(obj.sources && { sources: SENSITIVE_STRING }),
+});
+export const RerankResultFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.document && { document: SENSITIVE_STRING }),
+});
+export const RerankResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.results && { results: obj.results.map((item) => RerankResultFilterSensitiveLog(item)) }),
+});
 export const RetrieveAndGenerateInputFilterSensitiveLog = (obj) => ({
     ...obj,
 });
@@ -1223,6 +1465,45 @@ export const RetrieveAndGenerateResponseFilterSensitiveLog = (obj) => ({
     ...(obj.output && { output: SENSITIVE_STRING }),
     ...(obj.citations && { citations: obj.citations.map((item) => CitationFilterSensitiveLog(item)) }),
 });
+export const CitationEventFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.citation && { citation: CitationFilterSensitiveLog(obj.citation) }),
+});
+export const RetrieveAndGenerateOutputEventFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const RetrieveAndGenerateStreamResponseOutputFilterSensitiveLog = (obj) => {
+    if (obj.output !== undefined)
+        return { output: SENSITIVE_STRING };
+    if (obj.citation !== undefined)
+        return { citation: CitationEventFilterSensitiveLog(obj.citation) };
+    if (obj.guardrail !== undefined)
+        return { guardrail: obj.guardrail };
+    if (obj.internalServerException !== undefined)
+        return { internalServerException: obj.internalServerException };
+    if (obj.validationException !== undefined)
+        return { validationException: obj.validationException };
+    if (obj.resourceNotFoundException !== undefined)
+        return { resourceNotFoundException: obj.resourceNotFoundException };
+    if (obj.serviceQuotaExceededException !== undefined)
+        return { serviceQuotaExceededException: obj.serviceQuotaExceededException };
+    if (obj.throttlingException !== undefined)
+        return { throttlingException: obj.throttlingException };
+    if (obj.accessDeniedException !== undefined)
+        return { accessDeniedException: obj.accessDeniedException };
+    if (obj.conflictException !== undefined)
+        return { conflictException: obj.conflictException };
+    if (obj.dependencyFailedException !== undefined)
+        return { dependencyFailedException: obj.dependencyFailedException };
+    if (obj.badGatewayException !== undefined)
+        return { badGatewayException: obj.badGatewayException };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const RetrieveAndGenerateStreamResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.stream && { stream: "STREAMING_CONTENT" }),
+});
 export const KnowledgeBaseQueryFilterSensitiveLog = (obj) => ({
     ...obj,
 });
@@ -1269,6 +1550,12 @@ export const RetrievalFilterFilterSensitiveLog = (obj) => {
 export const KnowledgeBaseVectorSearchConfigurationFilterSensitiveLog = (obj) => ({
     ...obj,
     ...(obj.filter && { filter: SENSITIVE_STRING }),
+    ...(obj.rerankingConfiguration && {
+        rerankingConfiguration: VectorSearchRerankingConfigurationFilterSensitiveLog(obj.rerankingConfiguration),
+    }),
+    ...(obj.implicitFilterConfiguration && {
+        implicitFilterConfiguration: ImplicitFilterConfigurationFilterSensitiveLog(obj.implicitFilterConfiguration),
+    }),
 });
 export const KnowledgeBaseRetrievalConfigurationFilterSensitiveLog = (obj) => ({
     ...obj,
@@ -1335,6 +1622,13 @@ export const RetrieveAndGenerateRequestFilterSensitiveLog = (obj) => ({
         retrieveAndGenerateConfiguration: RetrieveAndGenerateConfigurationFilterSensitiveLog(obj.retrieveAndGenerateConfiguration),
     }),
 });
+export const RetrieveAndGenerateStreamRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.input && { input: SENSITIVE_STRING }),
+    ...(obj.retrieveAndGenerateConfiguration && {
+        retrieveAndGenerateConfiguration: RetrieveAndGenerateConfigurationFilterSensitiveLog(obj.retrieveAndGenerateConfiguration),
+    }),
+});
 export const SessionStateFilterSensitiveLog = (obj) => ({
     ...obj,
     ...(obj.returnControlInvocationResults && {
@@ -1344,6 +1638,9 @@ export const SessionStateFilterSensitiveLog = (obj) => ({
     ...(obj.knowledgeBaseConfigurations && {
         knowledgeBaseConfigurations: obj.knowledgeBaseConfigurations.map((item) => KnowledgeBaseConfigurationFilterSensitiveLog(item)),
     }),
+    ...(obj.conversationHistory && {
+        conversationHistory: ConversationHistoryFilterSensitiveLog(obj.conversationHistory),
+    }),
 });
 export const InvokeAgentRequestFilterSensitiveLog = (obj) => ({
     ...obj,

package/dist-es/pagination/RerankPaginator.js

@@ -0,0 +1,4 @@
+import { createPaginator } from "@smithy/core";
+import { BedrockAgentRuntimeClient } from "../BedrockAgentRuntimeClient";
+import { RerankCommand } from "../commands/RerankCommand";
+export const paginateRerank = createPaginator(BedrockAgentRuntimeClient, RerankCommand, "nextToken", "nextToken", "");

package/dist-es/pagination/index.js

@@ -1,3 +1,4 @@
 export * from "./GetAgentMemoryPaginator";
 export * from "./Interfaces";
+export * from "./RerankPaginator";
 export * from "./RetrievePaginator";