@aws-sdk/client-bedrock-agent-runtime 3.542.0 → 3.549.0

package/dist-es/protocols/Aws_restJson1.js

@@ -2,7 +2,7 @@ import { awsExpectUnion as __expectUnion, loadRestJsonErrorCode, parseJsonBody a
 import { requestBuilder as rb } from "@smithy/core";
 import { _json, collectBody, decorateServiceException as __decorateServiceException, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, limitedParseFloat32 as __limitedParseFloat32, map, take, withBaseException, } from "@smithy/smithy-client";
 import { BedrockAgentRuntimeServiceException as __BaseException } from "../models/BedrockAgentRuntimeServiceException";
-import { AccessDeniedException, BadGatewayException, ConflictException, DependencyFailedException, InternalServerException, ResourceNotFoundException, ServiceQuotaExceededException, ThrottlingException, ValidationException, } from "../models/models_0";
+import { AccessDeniedException, BadGatewayException, ConflictException, DependencyFailedException, InternalServerException, ResourceNotFoundException, RetrievalFilter, ServiceQuotaExceededException, ThrottlingException, ValidationException, } from "../models/models_0";
 export const se_InvokeAgentCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {
@@ -32,7 +32,7 @@ export const se_RetrieveCommand = async (input, context) => {
     let body;
     body = JSON.stringify(take(input, {
         nextToken: [],
-        retrievalConfiguration: (_) => _json(_),
+        retrievalConfiguration: (_) => se_KnowledgeBaseRetrievalConfiguration(_, context),
         retrievalQuery: (_) => _json(_),
     }));
     b.m("POST").h(headers).b(body);
@@ -47,7 +47,7 @@ export const se_RetrieveAndGenerateCommand = async (input, context) => {
     let body;
     body = JSON.stringify(take(input, {
         input: (_) => _json(_),
-        retrieveAndGenerateConfiguration: (_) => _json(_),
+        retrieveAndGenerateConfiguration: (_) => se_RetrieveAndGenerateConfiguration(_, context),
         sessionConfiguration: (_) => _json(_),
         sessionId: [],
     }));
@@ -91,7 +91,7 @@ export const de_RetrieveAndGenerateCommand = async (output, context) => {
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     const doc = take(data, {
-        citations: _json,
+        citations: (_) => de_Citations(_, context),
         output: _json,
         sessionId: __expectString,
     });
@@ -396,6 +396,83 @@ const de_ValidationException_event = async (output, context) => {
     };
     return de_ValidationExceptionRes(parsedOutput, context);
 };
+const se_FilterAttribute = (input, context) => {
+    return take(input, {
+        key: [],
+        value: (_) => se_FilterValue(_, context),
+    });
+};
+const se_FilterValue = (input, context) => {
+    return input;
+};
+const se_KnowledgeBaseRetrievalConfiguration = (input, context) => {
+    return take(input, {
+        vectorSearchConfiguration: (_) => se_KnowledgeBaseVectorSearchConfiguration(_, context),
+    });
+};
+const se_KnowledgeBaseRetrieveAndGenerateConfiguration = (input, context) => {
+    return take(input, {
+        generationConfiguration: _json,
+        knowledgeBaseId: [],
+        modelArn: [],
+        retrievalConfiguration: (_) => se_KnowledgeBaseRetrievalConfiguration(_, context),
+    });
+};
+const se_KnowledgeBaseVectorSearchConfiguration = (input, context) => {
+    return take(input, {
+        filter: (_) => se_RetrievalFilter(_, context),
+        numberOfResults: [],
+        overrideSearchType: [],
+    });
+};
+const se_RetrievalFilter = (input, context) => {
+    return RetrievalFilter.visit(input, {
+        andAll: (value) => ({ andAll: se_RetrievalFilterList(value, context) }),
+        equals: (value) => ({ equals: se_FilterAttribute(value, context) }),
+        greaterThan: (value) => ({ greaterThan: se_FilterAttribute(value, context) }),
+        greaterThanOrEquals: (value) => ({ greaterThanOrEquals: se_FilterAttribute(value, context) }),
+        in: (value) => ({ in: se_FilterAttribute(value, context) }),
+        lessThan: (value) => ({ lessThan: se_FilterAttribute(value, context) }),
+        lessThanOrEquals: (value) => ({ lessThanOrEquals: se_FilterAttribute(value, context) }),
+        notEquals: (value) => ({ notEquals: se_FilterAttribute(value, context) }),
+        notIn: (value) => ({ notIn: se_FilterAttribute(value, context) }),
+        orAll: (value) => ({ orAll: se_RetrievalFilterList(value, context) }),
+        startsWith: (value) => ({ startsWith: se_FilterAttribute(value, context) }),
+        _: (name, value) => ({ name: value }),
+    });
+};
+const se_RetrievalFilterList = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return se_RetrievalFilter(entry, context);
+    });
+};
+const se_RetrieveAndGenerateConfiguration = (input, context) => {
+    return take(input, {
+        knowledgeBaseConfiguration: (_) => se_KnowledgeBaseRetrieveAndGenerateConfiguration(_, context),
+        type: [],
+    });
+};
+const de_Attribution = (output, context) => {
+    return take(output, {
+        citations: (_) => de_Citations(_, context),
+    });
+};
+const de_Citation = (output, context) => {
+    return take(output, {
+        generatedResponsePart: _json,
+        retrievedReferences: (_) => de_RetrievedReferences(_, context),
+    });
+};
+const de_Citations = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_Citation(entry, context);
+    });
+    return retVal;
+};
 const de_InferenceConfiguration = (output, context) => {
     return take(output, {
         maximumLength: __expectInt32,
@@ -405,10 +482,16 @@ const de_InferenceConfiguration = (output, context) => {
         topP: __limitedParseFloat32,
     });
 };
+const de_KnowledgeBaseLookupOutput = (output, context) => {
+    return take(output, {
+        retrievedReferences: (_) => de_RetrievedReferences(_, context),
+    });
+};
 const de_KnowledgeBaseRetrievalResult = (output, context) => {
     return take(output, {
         content: _json,
         location: _json,
+        metadata: (_) => de_RetrievalResultMetadata(_, context),
         score: __limitedParseDouble,
     });
 };
@@ -431,6 +514,16 @@ const de_ModelInvocationInput = (output, context) => {
         type: __expectString,
     });
 };
+const de_Observation = (output, context) => {
+    return take(output, {
+        actionGroupInvocationOutput: _json,
+        finalResponse: _json,
+        knowledgeBaseLookupOutput: (_) => de_KnowledgeBaseLookupOutput(_, context),
+        repromptResponse: _json,
+        traceId: __expectString,
+        type: __expectString,
+    });
+};
 const de_OrchestrationTrace = (output, context) => {
     if (output.invocationInput != null) {
         return {
@@ -444,7 +537,7 @@ const de_OrchestrationTrace = (output, context) => {
     }
     if (output.observation != null) {
         return {
-            observation: _json(output.observation),
+            observation: de_Observation(output.observation, context),
         };
     }
     if (output.rationale != null) {
@@ -456,7 +549,7 @@ const de_OrchestrationTrace = (output, context) => {
 };
 const de_PayloadPart = (output, context) => {
     return take(output, {
-        attribution: _json,
+        attribution: (_) => de_Attribution(_, context),
         bytes: context.base64Decoder,
     });
 };
@@ -486,6 +579,33 @@ const de_PreProcessingTrace = (output, context) => {
     }
     return { $unknown: Object.entries(output)[0] };
 };
+const de_RetrievalResultMetadata = (output, context) => {
+    return Object.entries(output).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        acc[key] = de_RetrievalResultMetadataValue(value, context);
+        return acc;
+    }, {});
+};
+const de_RetrievalResultMetadataValue = (output, context) => {
+    return output;
+};
+const de_RetrievedReference = (output, context) => {
+    return take(output, {
+        content: _json,
+        location: _json,
+        metadata: (_) => de_RetrievalResultMetadata(_, context),
+    });
+};
+const de_RetrievedReferences = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_RetrievedReference(entry, context);
+    });
+    return retVal;
+};
 const de_Trace = (output, context) => {
     if (output.failureTrace != null) {
         return {

package/dist-types/commands/InvokeAgentCommand.d.ts

@@ -107,6 +107,9 @@ declare const InvokeAgentCommand_base: {
  * //                     uri: "STRING_VALUE",
  * //                   },
  * //                 },
+ * //                 metadata: { // RetrievalResultMetadata
+ * //                   "<keys>": "DOCUMENT_VALUE",
+ * //                 },
  * //               },
  * //             ],
  * //           },
@@ -198,6 +201,9 @@ declare const InvokeAgentCommand_base: {
  * //                       uri: "STRING_VALUE",
  * //                     },
  * //                   },
+ * //                   metadata: {
+ * //                     "<keys>": "DOCUMENT_VALUE",
+ * //                   },
  * //                 },
  * //               ],
  * //             },

package/dist-types/commands/RetrieveAndGenerateCommand.d.ts

@@ -26,7 +26,7 @@ declare const RetrieveAndGenerateCommand_base: {
     getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
 };
 /**
- * <p>Queries a knowledge base and generates responses based on the retrieved results. The response cites up to five sources but only selects the ones that are relevant to the query.</p>
+ * <p>Queries a knowledge base and generates responses based on the retrieved results. The response only cites sources that are relevant to the query.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript
@@ -47,6 +47,54 @@ declare const RetrieveAndGenerateCommand_base: {
  *         vectorSearchConfiguration: { // KnowledgeBaseVectorSearchConfiguration
  *           numberOfResults: Number("int"),
  *           overrideSearchType: "HYBRID" || "SEMANTIC",
+ *           filter: { // RetrievalFilter Union: only one key present
+ *             equals: { // FilterAttribute
+ *               key: "STRING_VALUE", // required
+ *               value: "DOCUMENT_VALUE", // required
+ *             },
+ *             notEquals: {
+ *               key: "STRING_VALUE", // required
+ *               value: "DOCUMENT_VALUE", // required
+ *             },
+ *             greaterThan: {
+ *               key: "STRING_VALUE", // required
+ *               value: "DOCUMENT_VALUE", // required
+ *             },
+ *             greaterThanOrEquals: {
+ *               key: "STRING_VALUE", // required
+ *               value: "DOCUMENT_VALUE", // required
+ *             },
+ *             lessThan: {
+ *               key: "STRING_VALUE", // required
+ *               value: "DOCUMENT_VALUE", // required
+ *             },
+ *             lessThanOrEquals: "<FilterAttribute>",
+ *             in: "<FilterAttribute>",
+ *             notIn: "<FilterAttribute>",
+ *             startsWith: "<FilterAttribute>",
+ *             andAll: [ // RetrievalFilterList
+ *               {//  Union: only one key present
+ *                 equals: "<FilterAttribute>",
+ *                 notEquals: "<FilterAttribute>",
+ *                 greaterThan: "<FilterAttribute>",
+ *                 greaterThanOrEquals: "<FilterAttribute>",
+ *                 lessThan: "<FilterAttribute>",
+ *                 lessThanOrEquals: "<FilterAttribute>",
+ *                 in: "<FilterAttribute>",
+ *                 notIn: "<FilterAttribute>",
+ *                 startsWith: "<FilterAttribute>",
+ *                 andAll: [
+ *                   "<RetrievalFilter>",
+ *                 ],
+ *                 orAll: [
+ *                   "<RetrievalFilter>",
+ *                 ],
+ *               },
+ *             ],
+ *             orAll: [
+ *               "<RetrievalFilter>",
+ *             ],
+ *           },
  *         },
  *       },
  *       generationConfiguration: { // GenerationConfiguration
@@ -89,6 +137,9 @@ declare const RetrieveAndGenerateCommand_base: {
  * //               uri: "STRING_VALUE",
  * //             },
  * //           },
+ * //           metadata: { // RetrievalResultMetadata
+ * //             "<keys>": "DOCUMENT_VALUE",
+ * //           },
  * //         },
  * //       ],
  * //     },

package/dist-types/commands/RetrieveCommand.d.ts

@@ -42,6 +42,54 @@ declare const RetrieveCommand_base: {
  *     vectorSearchConfiguration: { // KnowledgeBaseVectorSearchConfiguration
  *       numberOfResults: Number("int"),
  *       overrideSearchType: "HYBRID" || "SEMANTIC",
+ *       filter: { // RetrievalFilter Union: only one key present
+ *         equals: { // FilterAttribute
+ *           key: "STRING_VALUE", // required
+ *           value: "DOCUMENT_VALUE", // required
+ *         },
+ *         notEquals: {
+ *           key: "STRING_VALUE", // required
+ *           value: "DOCUMENT_VALUE", // required
+ *         },
+ *         greaterThan: {
+ *           key: "STRING_VALUE", // required
+ *           value: "DOCUMENT_VALUE", // required
+ *         },
+ *         greaterThanOrEquals: {
+ *           key: "STRING_VALUE", // required
+ *           value: "DOCUMENT_VALUE", // required
+ *         },
+ *         lessThan: {
+ *           key: "STRING_VALUE", // required
+ *           value: "DOCUMENT_VALUE", // required
+ *         },
+ *         lessThanOrEquals: "<FilterAttribute>",
+ *         in: "<FilterAttribute>",
+ *         notIn: "<FilterAttribute>",
+ *         startsWith: "<FilterAttribute>",
+ *         andAll: [ // RetrievalFilterList
+ *           {//  Union: only one key present
+ *             equals: "<FilterAttribute>",
+ *             notEquals: "<FilterAttribute>",
+ *             greaterThan: "<FilterAttribute>",
+ *             greaterThanOrEquals: "<FilterAttribute>",
+ *             lessThan: "<FilterAttribute>",
+ *             lessThanOrEquals: "<FilterAttribute>",
+ *             in: "<FilterAttribute>",
+ *             notIn: "<FilterAttribute>",
+ *             startsWith: "<FilterAttribute>",
+ *             andAll: [
+ *               "<RetrievalFilter>",
+ *             ],
+ *             orAll: [
+ *               "<RetrievalFilter>",
+ *             ],
+ *           },
+ *         ],
+ *         orAll: [
+ *           "<RetrievalFilter>",
+ *         ],
+ *       },
  *     },
  *   },
  *   nextToken: "STRING_VALUE",
@@ -61,6 +109,9 @@ declare const RetrieveCommand_base: {
  * //         },
  * //       },
  * //       score: Number("double"),
+ * //       metadata: { // RetrievalResultMetadata
+ * //         "<keys>": "DOCUMENT_VALUE",
+ * //       },
  * //     },
  * //   ],
  * //   nextToken: "STRING_VALUE",