@aws-sdk/client-bedrock-agent-runtime - npm Package Compare versions

Comparing version 3.687.0 to 3.688.0

dist-es/models/models_0.js

@@ -102,2 +102,30 @@ import { SENSITIVE_STRING } from "@smithy/smithy-client";
 };
+export var FlowTraceNodeInputContent;
+(function (FlowTraceNodeInputContent) {
+    FlowTraceNodeInputContent.visit = (value, visitor) => {
+        if (value.document !== undefined)
+            return visitor.document(value.document);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(FlowTraceNodeInputContent || (FlowTraceNodeInputContent = {}));
+export var FlowTraceNodeOutputContent;
+(function (FlowTraceNodeOutputContent) {
+    FlowTraceNodeOutputContent.visit = (value, visitor) => {
+        if (value.document !== undefined)
+            return visitor.document(value.document);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(FlowTraceNodeOutputContent || (FlowTraceNodeOutputContent = {}));
+export var FlowTrace;
+(function (FlowTrace) {
+    FlowTrace.visit = (value, visitor) => {
+        if (value.nodeInputTrace !== undefined)
+            return visitor.nodeInputTrace(value.nodeInputTrace);
+        if (value.nodeOutputTrace !== undefined)
+            return visitor.nodeOutputTrace(value.nodeOutputTrace);
+        if (value.conditionNodeResultTrace !== undefined)
+            return visitor.conditionNodeResultTrace(value.conditionNodeResultTrace);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(FlowTrace || (FlowTrace = {}));
 export class ResourceNotFoundException extends __BaseException {
@@ -158,2 +186,4 @@ constructor(opts) {
             return visitor.flowCompletionEvent(value.flowCompletionEvent);
+        if (value.flowTraceEvent !== undefined)
+            return visitor.flowTraceEvent(value.flowTraceEvent);
         if (value.internalServerException !== undefined)
@@ -499,2 +529,45 @@ return visitor.internalServerException(value.internalServerException);
 });
+export const FlowTraceConditionFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const FlowTraceConditionNodeResultEventFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.satisfiedConditions && { satisfiedConditions: SENSITIVE_STRING }),
+});
+export const FlowTraceNodeInputContentFilterSensitiveLog = (obj) => {
+    if (obj.document !== undefined)
+        return { document: obj.document };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const FlowTraceNodeInputFieldFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.content && { content: SENSITIVE_STRING }),
+});
+export const FlowTraceNodeInputEventFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.fields && { fields: SENSITIVE_STRING }),
+});
+export const FlowTraceNodeOutputFieldFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.content && { content: obj.content }),
+});
+export const FlowTraceNodeOutputEventFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.fields && { fields: SENSITIVE_STRING }),
+});
+export const FlowTraceFilterSensitiveLog = (obj) => {
+    if (obj.nodeInputTrace !== undefined)
+        return { nodeInputTrace: SENSITIVE_STRING };
+    if (obj.nodeOutputTrace !== undefined)
+        return { nodeOutputTrace: SENSITIVE_STRING };
+    if (obj.conditionNodeResultTrace !== undefined)
+        return { conditionNodeResultTrace: SENSITIVE_STRING };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const FlowTraceEventFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.trace && { trace: SENSITIVE_STRING }),
+});
 export const FlowResponseStreamFilterSensitiveLog = (obj) => {
@@ -505,2 +578,4 @@ if (obj.flowOutputEvent !== undefined)
         return { flowCompletionEvent: SENSITIVE_STRING };
+    if (obj.flowTraceEvent !== undefined)
+        return { flowTraceEvent: FlowTraceEventFilterSensitiveLog(obj.flowTraceEvent) };
     if (obj.internalServerException !== undefined)
@@ -507,0 +582,0 @@ return { internalServerException: obj.internalServerException };

dist-es/protocols/Aws_restJson1.js

@@ -65,2 +65,3 @@ import { awsExpectUnion as __expectUnion, loadRestJsonErrorCode, parseJsonBody as parseBody, parseJsonErrorBody as parseErrorBody, } from "@aws-sdk/core";
     body = JSON.stringify(take(input, {
+        enableTrace: [],
         inputs: (_) => se_FlowInputs(_, context),
@@ -360,2 +361,7 @@ }));
         }
+        if (event["flowTraceEvent"] != null) {
+            return {
+                flowTraceEvent: await de_FlowTraceEvent_event(event["flowTraceEvent"], context),
+            };
+        }
         if (event["internalServerException"] != null) {
@@ -525,2 +531,8 @@ return {
 };
+const de_FlowTraceEvent_event = async (output, context) => {
+    const contents = {};
+    const data = await parseBody(output.body, context);
+    Object.assign(contents, de_FlowTraceEvent(data, context));
+    return contents;
+};
 const de_InternalServerException_event = async (output, context) => {
@@ -830,2 +842,90 @@ const parsedOutput = {
 };
+const de_FlowTrace = (output, context) => {
+    if (output.conditionNodeResultTrace != null) {
+        return {
+            conditionNodeResultTrace: de_FlowTraceConditionNodeResultEvent(output.conditionNodeResultTrace, context),
+        };
+    }
+    if (output.nodeInputTrace != null) {
+        return {
+            nodeInputTrace: de_FlowTraceNodeInputEvent(output.nodeInputTrace, context),
+        };
+    }
+    if (output.nodeOutputTrace != null) {
+        return {
+            nodeOutputTrace: de_FlowTraceNodeOutputEvent(output.nodeOutputTrace, context),
+        };
+    }
+    return { $unknown: Object.entries(output)[0] };
+};
+const de_FlowTraceConditionNodeResultEvent = (output, context) => {
+    return take(output, {
+        nodeName: __expectString,
+        satisfiedConditions: _json,
+        timestamp: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+    });
+};
+const de_FlowTraceEvent = (output, context) => {
+    return take(output, {
+        trace: (_) => de_FlowTrace(__expectUnion(_), context),
+    });
+};
+const de_FlowTraceNodeInputContent = (output, context) => {
+    if (output.document != null) {
+        return {
+            document: de_Document(output.document, context),
+        };
+    }
+    return { $unknown: Object.entries(output)[0] };
+};
+const de_FlowTraceNodeInputEvent = (output, context) => {
+    return take(output, {
+        fields: (_) => de_FlowTraceNodeInputFields(_, context),
+        nodeName: __expectString,
+        timestamp: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+    });
+};
+const de_FlowTraceNodeInputField = (output, context) => {
+    return take(output, {
+        content: (_) => de_FlowTraceNodeInputContent(__expectUnion(_), context),
+        nodeInputName: __expectString,
+    });
+};
+const de_FlowTraceNodeInputFields = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_FlowTraceNodeInputField(entry, context);
+    });
+    return retVal;
+};
+const de_FlowTraceNodeOutputContent = (output, context) => {
+    if (output.document != null) {
+        return {
+            document: de_Document(output.document, context),
+        };
+    }
+    return { $unknown: Object.entries(output)[0] };
+};
+const de_FlowTraceNodeOutputEvent = (output, context) => {
+    return take(output, {
+        fields: (_) => de_FlowTraceNodeOutputFields(_, context),
+        nodeName: __expectString,
+        timestamp: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+    });
+};
+const de_FlowTraceNodeOutputField = (output, context) => {
+    return take(output, {
+        content: (_) => de_FlowTraceNodeOutputContent(__expectUnion(_), context),
+        nodeOutputName: __expectString,
+    });
+};
+const de_FlowTraceNodeOutputFields = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_FlowTraceNodeOutputField(entry, context);
+    });
+    return retVal;
+};
 const de_InferenceConfiguration = (output, context) => {
@@ -832,0 +932,0 @@ return take(output, {

dist-types/commands/InvokeAgentCommand.d.ts

@@ -367,2 +367,4 @@ import { Command as $Command } from "@smithy/smithy-client";
  * //             type: "PRE_PROCESSING" || "ORCHESTRATION" || "KNOWLEDGE_BASE_RESPONSE_GENERATION" || "POST_PROCESSING",
+ * //             overrideLambda: "STRING_VALUE",
+ * //             promptCreationMode: "DEFAULT" || "OVERRIDDEN",
  * //             inferenceConfiguration: { // InferenceConfiguration
@@ -377,4 +379,2 @@ * //               temperature: Number("float"),
  * //             },
- * //             overrideLambda: "STRING_VALUE",
- * //             promptCreationMode: "DEFAULT" || "OVERRIDDEN",
  * //             parserMode: "DEFAULT" || "OVERRIDDEN",
@@ -500,2 +500,4 @@ * //           },
  * //             type: "PRE_PROCESSING" || "ORCHESTRATION" || "KNOWLEDGE_BASE_RESPONSE_GENERATION" || "POST_PROCESSING",
+ * //             overrideLambda: "STRING_VALUE",
+ * //             promptCreationMode: "DEFAULT" || "OVERRIDDEN",
  * //             inferenceConfiguration: {
@@ -510,4 +512,2 @@ * //               temperature: Number("float"),
  * //             },
- * //             overrideLambda: "STRING_VALUE",
- * //             promptCreationMode: "DEFAULT" || "OVERRIDDEN",
  * //             parserMode: "DEFAULT" || "OVERRIDDEN",
@@ -533,2 +533,4 @@ * //           },
  * //             type: "PRE_PROCESSING" || "ORCHESTRATION" || "KNOWLEDGE_BASE_RESPONSE_GENERATION" || "POST_PROCESSING",
+ * //             overrideLambda: "STRING_VALUE",
+ * //             promptCreationMode: "DEFAULT" || "OVERRIDDEN",
  * //             inferenceConfiguration: {
@@ -543,4 +545,2 @@ * //               temperature: Number("float"),
  * //             },
- * //             overrideLambda: "STRING_VALUE",
- * //             promptCreationMode: "DEFAULT" || "OVERRIDDEN",
  * //             parserMode: "DEFAULT" || "OVERRIDDEN",
@@ -547,0 +547,0 @@ * //           },

dist-types/commands/InvokeFlowCommand.d.ts

@@ -52,2 +52,3 @@ import { Command as $Command } from "@smithy/smithy-client";
  *   ],
+ *   enableTrace: true || false,
  * };
@@ -68,2 +69,39 @@ * const command = new InvokeFlowCommand(input);
  * //     },
+ * //     flowTraceEvent: { // FlowTraceEvent
+ * //       trace: { // FlowTrace Union: only one key present
+ * //         nodeInputTrace: { // FlowTraceNodeInputEvent
+ * //           nodeName: "STRING_VALUE", // required
+ * //           timestamp: new Date("TIMESTAMP"), // required
+ * //           fields: [ // FlowTraceNodeInputFields // required
+ * //             { // FlowTraceNodeInputField
+ * //               nodeInputName: "STRING_VALUE", // required
+ * //               content: { // FlowTraceNodeInputContent Union: only one key present
+ * //                 document: "DOCUMENT_VALUE",
+ * //               },
+ * //             },
+ * //           ],
+ * //         },
+ * //         nodeOutputTrace: { // FlowTraceNodeOutputEvent
+ * //           nodeName: "STRING_VALUE", // required
+ * //           timestamp: new Date("TIMESTAMP"), // required
+ * //           fields: [ // FlowTraceNodeOutputFields // required
+ * //             { // FlowTraceNodeOutputField
+ * //               nodeOutputName: "STRING_VALUE", // required
+ * //               content: { // FlowTraceNodeOutputContent Union: only one key present
+ * //                 document: "DOCUMENT_VALUE",
+ * //               },
+ * //             },
+ * //           ],
+ * //         },
+ * //         conditionNodeResultTrace: { // FlowTraceConditionNodeResultEvent
+ * //           nodeName: "STRING_VALUE", // required
+ * //           timestamp: new Date("TIMESTAMP"), // required
+ * //           satisfiedConditions: [ // FlowTraceConditions // required
+ * //             { // FlowTraceCondition
+ * //               conditionName: "STRING_VALUE", // required
+ * //             },
+ * //           ],
+ * //         },
+ * //       },
+ * //     },
  * //     internalServerException: { // InternalServerException
@@ -70,0 +108,0 @@ * //       message: "STRING_VALUE",

package.json

 {
   "name": "@aws-sdk/client-bedrock-agent-runtime",
   "description": "AWS SDK for JavaScript Bedrock Agent Runtime Client for Node.js, Browser and React Native",
-  "version": "3.687.0",
+  "version": "3.688.0",
   "scripts": {
@@ -6,0 +6,0 @@ "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",

No alert changes

Improved metrics

Total package byte prevSize

676733

increased by4.96%

Lines of code

16483

increased by5.28%

No dependency changes