@aws-sdk/client-bedrock-agent-runtime 3.701.0 → 3.703.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

@@ -259,10 +259,33 @@ 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 RerankingMetadataSelectionMode = {
+    ALL: "ALL",
+    SELECTIVE: "SELECTIVE",
+};
+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]);
+    };
+})(RerankingMetadataSelectiveModeConfiguration || (RerankingMetadataSelectiveModeConfiguration = {}));
+export const VectorSearchRerankingConfigurationType = {
+    BEDROCK_RERANKING_MODEL: "BEDROCK_RERANKING_MODEL",
+};
 export const ConfirmationState = {
     CONFIRM: "CONFIRM",
     DENY: "DENY",
@@ -283,6 +306,7 @@ export var InvocationResultMember;
 })(InvocationResultMember || (InvocationResultMember = {}));
 export const RetrievalResultLocationType = {
     CONFLUENCE: "CONFLUENCE",
+    CUSTOM: "CUSTOM",
     S3: "S3",
     SALESFORCE: "SALESFORCE",
     SHAREPOINT: "SHAREPOINT",
@@ -568,6 +592,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 +620,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) => {
@@ -760,6 +827,39 @@ export const InputFileFilterSensitiveLog = (obj) => ({
     ...obj,
     ...(obj.source && { source: FileSourceFilterSensitiveLog(obj.source) }),
 });
+export const MetadataAttributeSchemaFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+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 ApiResultFilterSensitiveLog = (obj) => ({
     ...obj,
     ...(obj.apiPath && { apiPath: SENSITIVE_STRING }),
@@ -1180,6 +1280,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 +1351,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 +1436,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 +1508,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 && {

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";

package/dist-es/protocols/Aws_restJson1.js

@@ -108,6 +108,22 @@ export const se_OptimizePromptCommand = async (input, context) => {
     b.m("POST").h(headers).b(body);
     return b.build();
 };
+export const se_RerankCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/rerank");
+    let body;
+    body = JSON.stringify(take(input, {
+        nextToken: [],
+        queries: (_) => _json(_),
+        rerankingConfiguration: (_) => se_RerankingConfiguration(_, context),
+        sources: (_) => se_RerankSourcesList(_, context),
+    }));
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
 export const se_RetrieveCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {
@@ -117,6 +133,7 @@ export const se_RetrieveCommand = async (input, context) => {
     b.p("knowledgeBaseId", () => input.knowledgeBaseId, "{knowledgeBaseId}", false);
     let body;
     body = JSON.stringify(take(input, {
+        guardrailConfiguration: (_) => _json(_),
         nextToken: [],
         retrievalConfiguration: (_) => se_KnowledgeBaseRetrievalConfiguration(_, context),
         retrievalQuery: (_) => _json(_),
@@ -140,6 +157,22 @@ export const se_RetrieveAndGenerateCommand = async (input, context) => {
     b.m("POST").h(headers).b(body);
     return b.build();
 };
+export const se_RetrieveAndGenerateStreamCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/retrieveAndGenerateStream");
+    let body;
+    body = JSON.stringify(take(input, {
+        input: (_) => _json(_),
+        retrieveAndGenerateConfiguration: (_) => se_RetrieveAndGenerateConfiguration(_, context),
+        sessionConfiguration: (_) => _json(_),
+        sessionId: [],
+    }));
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
 export const de_DeleteAgentMemoryCommand = async (output, context) => {
     if (output.statusCode !== 202 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -214,6 +247,21 @@ export const de_OptimizePromptCommand = async (output, context) => {
     contents.optimizedPrompt = de_OptimizedPromptStream(data, context);
     return contents;
 };
+export const de_RerankCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        nextToken: __expectString,
+        results: (_) => de_RerankResultsList(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
 export const de_RetrieveCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -223,6 +271,7 @@ export const de_RetrieveCommand = async (output, context) => {
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     const doc = take(data, {
+        guardrailAction: __expectString,
         nextToken: __expectString,
         retrievalResults: (_) => de_KnowledgeBaseRetrievalResults(_, context),
     });
@@ -246,6 +295,18 @@ export const de_RetrieveAndGenerateCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
+export const de_RetrieveAndGenerateStreamCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+        [_sI]: [, output.headers[_xabkbsi]],
+    });
+    const data = output.body;
+    contents.stream = de_RetrieveAndGenerateStreamResponseOutput(data, context);
+    return contents;
+};
 const de_CommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
@@ -659,6 +720,71 @@ const de_ResponseStream = (output, context) => {
         return { $unknown: output };
     });
 };
+const de_RetrieveAndGenerateStreamResponseOutput = (output, context) => {
+    return context.eventStreamMarshaller.deserialize(output, async (event) => {
+        if (event["output"] != null) {
+            return {
+                output: await de_RetrieveAndGenerateOutputEvent_event(event["output"], context),
+            };
+        }
+        if (event["citation"] != null) {
+            return {
+                citation: await de_CitationEvent_event(event["citation"], context),
+            };
+        }
+        if (event["guardrail"] != null) {
+            return {
+                guardrail: await de_GuardrailEvent_event(event["guardrail"], context),
+            };
+        }
+        if (event["internalServerException"] != null) {
+            return {
+                internalServerException: await de_InternalServerException_event(event["internalServerException"], context),
+            };
+        }
+        if (event["validationException"] != null) {
+            return {
+                validationException: await de_ValidationException_event(event["validationException"], context),
+            };
+        }
+        if (event["resourceNotFoundException"] != null) {
+            return {
+                resourceNotFoundException: await de_ResourceNotFoundException_event(event["resourceNotFoundException"], context),
+            };
+        }
+        if (event["serviceQuotaExceededException"] != null) {
+            return {
+                serviceQuotaExceededException: await de_ServiceQuotaExceededException_event(event["serviceQuotaExceededException"], context),
+            };
+        }
+        if (event["throttlingException"] != null) {
+            return {
+                throttlingException: await de_ThrottlingException_event(event["throttlingException"], context),
+            };
+        }
+        if (event["accessDeniedException"] != null) {
+            return {
+                accessDeniedException: await de_AccessDeniedException_event(event["accessDeniedException"], context),
+            };
+        }
+        if (event["conflictException"] != null) {
+            return {
+                conflictException: await de_ConflictException_event(event["conflictException"], context),
+            };
+        }
+        if (event["dependencyFailedException"] != null) {
+            return {
+                dependencyFailedException: await de_DependencyFailedException_event(event["dependencyFailedException"], context),
+            };
+        }
+        if (event["badGatewayException"] != null) {
+            return {
+                badGatewayException: await de_BadGatewayException_event(event["badGatewayException"], context),
+            };
+        }
+        return { $unknown: output };
+    });
+};
 const de_AccessDeniedException_event = async (output, context) => {
     const parsedOutput = {
         ...output,
@@ -679,6 +805,12 @@ const de_BadGatewayException_event = async (output, context) => {
     };
     return de_BadGatewayExceptionRes(parsedOutput, context);
 };
+const de_CitationEvent_event = async (output, context) => {
+    const contents = {};
+    const data = await parseBody(output.body, context);
+    Object.assign(contents, de_CitationEvent(data, context));
+    return contents;
+};
 const de_ConflictException_event = async (output, context) => {
     const parsedOutput = {
         ...output,
@@ -717,6 +849,12 @@ const de_FlowTraceEvent_event = async (output, context) => {
     Object.assign(contents, de_FlowTraceEvent(data, context));
     return contents;
 };
+const de_GuardrailEvent_event = async (output, context) => {
+    const contents = {};
+    const data = await parseBody(output.body, context);
+    Object.assign(contents, _json(data));
+    return contents;
+};
 const de_InlineAgentFilePart_event = async (output, context) => {
     const contents = {};
     const data = await parseBody(output.body, context);
@@ -767,6 +905,12 @@ const de_ResourceNotFoundException_event = async (output, context) => {
     };
     return de_ResourceNotFoundExceptionRes(parsedOutput, context);
 };
+const de_RetrieveAndGenerateOutputEvent_event = async (output, context) => {
+    const contents = {};
+    const data = await parseBody(output.body, context);
+    Object.assign(contents, _json(data));
+    return contents;
+};
 const de_ReturnControlPayload_event = async (output, context) => {
     const contents = {};
     const data = await parseBody(output.body, context);
@@ -812,6 +956,18 @@ const se_AdditionalModelRequestFields = (input, context) => {
 const se_AdditionalModelRequestFieldsValue = (input, context) => {
     return input;
 };
+const se_BedrockRerankingConfiguration = (input, context) => {
+    return take(input, {
+        modelConfiguration: (_) => se_BedrockRerankingModelConfiguration(_, context),
+        numberOfResults: [],
+    });
+};
+const se_BedrockRerankingModelConfiguration = (input, context) => {
+    return take(input, {
+        additionalModelRequestFields: (_) => se_AdditionalModelRequestFields(_, context),
+        modelArn: [],
+    });
+};
 const se_ByteContentDoc = (input, context) => {
     return take(input, {
         contentType: [],
@@ -979,8 +1135,10 @@ const se_KnowledgeBases = (input, context) => {
 const se_KnowledgeBaseVectorSearchConfiguration = (input, context) => {
     return take(input, {
         filter: (_) => se_RetrievalFilter(_, context),
+        implicitFilterConfiguration: _json,
         numberOfResults: [],
         overrideSearchType: [],
+        rerankingConfiguration: (_) => se_VectorSearchRerankingConfiguration(_, context),
     });
 };
 const se_OrchestrationConfiguration = (input, context) => {
@@ -1014,6 +1172,32 @@ const se_PromptOverrideConfiguration = (input, context) => {
         promptConfigurations: (_) => se_PromptConfigurations(_, context),
     });
 };
+const se_RerankDocument = (input, context) => {
+    return take(input, {
+        jsonDocument: (_) => se_Document(_, context),
+        textDocument: _json,
+        type: [],
+    });
+};
+const se_RerankingConfiguration = (input, context) => {
+    return take(input, {
+        bedrockRerankingConfiguration: (_) => se_BedrockRerankingConfiguration(_, context),
+        type: [],
+    });
+};
+const se_RerankSource = (input, context) => {
+    return take(input, {
+        inlineDocumentSource: (_) => se_RerankDocument(_, context),
+        type: [],
+    });
+};
+const se_RerankSourcesList = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return se_RerankSource(entry, context);
+    });
+};
 const se_RetrievalFilter = (input, context) => {
     return RetrievalFilter.visit(input, {
         andAll: (value) => ({ andAll: se_RetrievalFilterList(value, context) }),
@@ -1064,6 +1248,25 @@ const se_TextInferenceConfig = (input, context) => {
         topP: __serializeFloat,
     });
 };
+const se_VectorSearchBedrockRerankingConfiguration = (input, context) => {
+    return take(input, {
+        metadataConfiguration: _json,
+        modelConfiguration: (_) => se_VectorSearchBedrockRerankingModelConfiguration(_, context),
+        numberOfRerankedResults: [],
+    });
+};
+const se_VectorSearchBedrockRerankingModelConfiguration = (input, context) => {
+    return take(input, {
+        additionalModelRequestFields: (_) => se_AdditionalModelRequestFields(_, context),
+        modelArn: [],
+    });
+};
+const se_VectorSearchRerankingConfiguration = (input, context) => {
+    return take(input, {
+        bedrockRerankingConfiguration: (_) => se_VectorSearchBedrockRerankingConfiguration(_, context),
+        type: [],
+    });
+};
 const se_Document = (input, context) => {
     return input;
 };
@@ -1078,6 +1281,11 @@ const de_Citation = (output, context) => {
         retrievedReferences: (_) => de_RetrievedReferences(_, context),
     });
 };
+const de_CitationEvent = (output, context) => {
+    return take(output, {
+        citation: (_) => de_Citation(_, context),
+    });
+};
 const de_Citations = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
@@ -1363,6 +1571,28 @@ const de_PreProcessingTrace = (output, context) => {
     }
     return { $unknown: Object.entries(output)[0] };
 };
+const de_RerankDocument = (output, context) => {
+    return take(output, {
+        jsonDocument: (_) => de_Document(_, context),
+        textDocument: _json,
+        type: __expectString,
+    });
+};
+const de_RerankResult = (output, context) => {
+    return take(output, {
+        document: (_) => de_RerankDocument(_, context),
+        index: __expectInt32,
+        relevanceScore: __limitedParseFloat32,
+    });
+};
+const de_RerankResultsList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_RerankResult(entry, context);
+    });
+    return retVal;
+};
 const de_RetrievalResultMetadata = (output, context) => {
     return Object.entries(output).reduce((acc, [key, value]) => {
         if (value === null) {
@@ -1451,3 +1681,4 @@ const _sI = "sessionId";
 const _xabact = "x-amzn-bedrock-agent-content-type";
 const _xabami = "x-amz-bedrock-agent-memory-id";
 const _xabasi = "x-amz-bedrock-agent-session-id";
+const _xabkbsi = "x-amzn-bedrock-knowledge-base-session-id";