@aws-sdk/client-bedrock-agent-runtime 3.687.0 → 3.688.0

package/dist-cjs/index.js

@@ -60,6 +60,18 @@ __export(src_exports, {
   FlowOutputEventFilterSensitiveLog: () => FlowOutputEventFilterSensitiveLog,
   FlowResponseStream: () => FlowResponseStream,
   FlowResponseStreamFilterSensitiveLog: () => FlowResponseStreamFilterSensitiveLog,
+  FlowTrace: () => FlowTrace,
+  FlowTraceConditionFilterSensitiveLog: () => FlowTraceConditionFilterSensitiveLog,
+  FlowTraceConditionNodeResultEventFilterSensitiveLog: () => FlowTraceConditionNodeResultEventFilterSensitiveLog,
+  FlowTraceEventFilterSensitiveLog: () => FlowTraceEventFilterSensitiveLog,
+  FlowTraceFilterSensitiveLog: () => FlowTraceFilterSensitiveLog,
+  FlowTraceNodeInputContent: () => FlowTraceNodeInputContent,
+  FlowTraceNodeInputContentFilterSensitiveLog: () => FlowTraceNodeInputContentFilterSensitiveLog,
+  FlowTraceNodeInputEventFilterSensitiveLog: () => FlowTraceNodeInputEventFilterSensitiveLog,
+  FlowTraceNodeInputFieldFilterSensitiveLog: () => FlowTraceNodeInputFieldFilterSensitiveLog,
+  FlowTraceNodeOutputContent: () => FlowTraceNodeOutputContent,
+  FlowTraceNodeOutputEventFilterSensitiveLog: () => FlowTraceNodeOutputEventFilterSensitiveLog,
+  FlowTraceNodeOutputFieldFilterSensitiveLog: () => FlowTraceNodeOutputFieldFilterSensitiveLog,
   GeneratedResponsePartFilterSensitiveLog: () => GeneratedResponsePartFilterSensitiveLog,
   GenerationConfigurationFilterSensitiveLog: () => GenerationConfigurationFilterSensitiveLog,
   GetAgentMemoryCommand: () => GetAgentMemoryCommand,
@@ -465,6 +477,34 @@ var NodeType = {
   LEX_NODE: "LexNode",
   PROMPT_NODE: "PromptNode"
 };
+var FlowTraceNodeInputContent;
+((FlowTraceNodeInputContent3) => {
+  FlowTraceNodeInputContent3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.document !== void 0)
+      return visitor.document(value.document);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(FlowTraceNodeInputContent || (FlowTraceNodeInputContent = {}));
+var FlowTraceNodeOutputContent;
+((FlowTraceNodeOutputContent3) => {
+  FlowTraceNodeOutputContent3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.document !== void 0)
+      return visitor.document(value.document);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(FlowTraceNodeOutputContent || (FlowTraceNodeOutputContent = {}));
+var FlowTrace;
+((FlowTrace3) => {
+  FlowTrace3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.nodeInputTrace !== void 0)
+      return visitor.nodeInputTrace(value.nodeInputTrace);
+    if (value.nodeOutputTrace !== void 0)
+      return visitor.nodeOutputTrace(value.nodeOutputTrace);
+    if (value.conditionNodeResultTrace !== void 0)
+      return visitor.conditionNodeResultTrace(value.conditionNodeResultTrace);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(FlowTrace || (FlowTrace = {}));
 var _ResourceNotFoundException = class _ResourceNotFoundException extends BedrockAgentRuntimeServiceException {
   /**
    * @internal
@@ -540,6 +580,8 @@ var FlowResponseStream;
       return visitor.flowOutputEvent(value.flowOutputEvent);
     if (value.flowCompletionEvent !== void 0)
       return visitor.flowCompletionEvent(value.flowCompletionEvent);
+    if (value.flowTraceEvent !== void 0)
+      return visitor.flowTraceEvent(value.flowTraceEvent);
     if (value.internalServerException !== void 0)
       return visitor.internalServerException(value.internalServerException);
     if (value.validationException !== void 0)
@@ -880,11 +922,56 @@ var FlowOutputEventFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
   ...obj,
   ...obj.content && { content: obj.content }
 }), "FlowOutputEventFilterSensitiveLog");
+var FlowTraceConditionFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj
+}), "FlowTraceConditionFilterSensitiveLog");
+var FlowTraceConditionNodeResultEventFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.satisfiedConditions && { satisfiedConditions: import_smithy_client.SENSITIVE_STRING }
+}), "FlowTraceConditionNodeResultEventFilterSensitiveLog");
+var FlowTraceNodeInputContentFilterSensitiveLog = /* @__PURE__ */ __name((obj) => {
+  if (obj.document !== void 0)
+    return { document: obj.document };
+  if (obj.$unknown !== void 0)
+    return { [obj.$unknown[0]]: "UNKNOWN" };
+}, "FlowTraceNodeInputContentFilterSensitiveLog");
+var FlowTraceNodeInputFieldFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.content && { content: import_smithy_client.SENSITIVE_STRING }
+}), "FlowTraceNodeInputFieldFilterSensitiveLog");
+var FlowTraceNodeInputEventFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.fields && { fields: import_smithy_client.SENSITIVE_STRING }
+}), "FlowTraceNodeInputEventFilterSensitiveLog");
+var FlowTraceNodeOutputFieldFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.content && { content: obj.content }
+}), "FlowTraceNodeOutputFieldFilterSensitiveLog");
+var FlowTraceNodeOutputEventFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.fields && { fields: import_smithy_client.SENSITIVE_STRING }
+}), "FlowTraceNodeOutputEventFilterSensitiveLog");
+var FlowTraceFilterSensitiveLog = /* @__PURE__ */ __name((obj) => {
+  if (obj.nodeInputTrace !== void 0)
+    return { nodeInputTrace: import_smithy_client.SENSITIVE_STRING };
+  if (obj.nodeOutputTrace !== void 0)
+    return { nodeOutputTrace: import_smithy_client.SENSITIVE_STRING };
+  if (obj.conditionNodeResultTrace !== void 0)
+    return { conditionNodeResultTrace: import_smithy_client.SENSITIVE_STRING };
+  if (obj.$unknown !== void 0)
+    return { [obj.$unknown[0]]: "UNKNOWN" };
+}, "FlowTraceFilterSensitiveLog");
+var FlowTraceEventFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.trace && { trace: import_smithy_client.SENSITIVE_STRING }
+}), "FlowTraceEventFilterSensitiveLog");
 var FlowResponseStreamFilterSensitiveLog = /* @__PURE__ */ __name((obj) => {
   if (obj.flowOutputEvent !== void 0)
     return { flowOutputEvent: import_smithy_client.SENSITIVE_STRING };
   if (obj.flowCompletionEvent !== void 0)
     return { flowCompletionEvent: import_smithy_client.SENSITIVE_STRING };
+  if (obj.flowTraceEvent !== void 0)
+    return { flowTraceEvent: FlowTraceEventFilterSensitiveLog(obj.flowTraceEvent) };
   if (obj.internalServerException !== void 0)
     return { internalServerException: obj.internalServerException };
   if (obj.validationException !== void 0)
@@ -1439,6 +1526,7 @@ var se_InvokeFlowCommand = /* @__PURE__ */ __name(async (input, context) => {
   let body;
   body = JSON.stringify(
     (0, import_smithy_client.take)(input, {
+      enableTrace: [],
       inputs: (_) => se_FlowInputs(_, context)
     })
   );
@@ -1738,6 +1826,11 @@ var de_FlowResponseStream = /* @__PURE__ */ __name((output, context) => {
         flowCompletionEvent: await de_FlowCompletionEvent_event(event["flowCompletionEvent"], context)
       };
     }
+    if (event["flowTraceEvent"] != null) {
+      return {
+        flowTraceEvent: await de_FlowTraceEvent_event(event["flowTraceEvent"], context)
+      };
+    }
     if (event["internalServerException"] != null) {
       return {
         internalServerException: await de_InternalServerException_event(event["internalServerException"], context)
@@ -1920,6 +2013,12 @@ var de_FlowOutputEvent_event = /* @__PURE__ */ __name(async (output, context) =>
   Object.assign(contents, de_FlowOutputEvent(data, context));
   return contents;
 }, "de_FlowOutputEvent_event");
+var de_FlowTraceEvent_event = /* @__PURE__ */ __name(async (output, context) => {
+  const contents = {};
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  Object.assign(contents, de_FlowTraceEvent(data, context));
+  return contents;
+}, "de_FlowTraceEvent_event");
 var de_InternalServerException_event = /* @__PURE__ */ __name(async (output, context) => {
   const parsedOutput = {
     ...output,
@@ -2212,6 +2311,90 @@ var de_FlowOutputEvent = /* @__PURE__ */ __name((output, context) => {
     nodeType: import_smithy_client.expectString
   });
 }, "de_FlowOutputEvent");
+var de_FlowTrace = /* @__PURE__ */ __name((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] };
+}, "de_FlowTrace");
+var de_FlowTraceConditionNodeResultEvent = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    nodeName: import_smithy_client.expectString,
+    satisfiedConditions: import_smithy_client._json,
+    timestamp: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_))
+  });
+}, "de_FlowTraceConditionNodeResultEvent");
+var de_FlowTraceEvent = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    trace: (_) => de_FlowTrace((0, import_core2.awsExpectUnion)(_), context)
+  });
+}, "de_FlowTraceEvent");
+var de_FlowTraceNodeInputContent = /* @__PURE__ */ __name((output, context) => {
+  if (output.document != null) {
+    return {
+      document: de_Document(output.document, context)
+    };
+  }
+  return { $unknown: Object.entries(output)[0] };
+}, "de_FlowTraceNodeInputContent");
+var de_FlowTraceNodeInputEvent = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    fields: (_) => de_FlowTraceNodeInputFields(_, context),
+    nodeName: import_smithy_client.expectString,
+    timestamp: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_))
+  });
+}, "de_FlowTraceNodeInputEvent");
+var de_FlowTraceNodeInputField = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    content: (_) => de_FlowTraceNodeInputContent((0, import_core2.awsExpectUnion)(_), context),
+    nodeInputName: import_smithy_client.expectString
+  });
+}, "de_FlowTraceNodeInputField");
+var de_FlowTraceNodeInputFields = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_FlowTraceNodeInputField(entry, context);
+  });
+  return retVal;
+}, "de_FlowTraceNodeInputFields");
+var de_FlowTraceNodeOutputContent = /* @__PURE__ */ __name((output, context) => {
+  if (output.document != null) {
+    return {
+      document: de_Document(output.document, context)
+    };
+  }
+  return { $unknown: Object.entries(output)[0] };
+}, "de_FlowTraceNodeOutputContent");
+var de_FlowTraceNodeOutputEvent = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    fields: (_) => de_FlowTraceNodeOutputFields(_, context),
+    nodeName: import_smithy_client.expectString,
+    timestamp: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_))
+  });
+}, "de_FlowTraceNodeOutputEvent");
+var de_FlowTraceNodeOutputField = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    content: (_) => de_FlowTraceNodeOutputContent((0, import_core2.awsExpectUnion)(_), context),
+    nodeOutputName: import_smithy_client.expectString
+  });
+}, "de_FlowTraceNodeOutputField");
+var de_FlowTraceNodeOutputFields = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_FlowTraceNodeOutputField(entry, context);
+  });
+  return retVal;
+}, "de_FlowTraceNodeOutputFields");
 var de_InferenceConfiguration = /* @__PURE__ */ __name((output, context) => {
   return (0, import_smithy_client.take)(output, {
     maximumLength: import_smithy_client.expectInt32,
@@ -2583,6 +2766,9 @@ var paginateRetrieve = (0, import_core.createPaginator)(BedrockAgentRuntimeClien
   FlowCompletionReason,
   FlowOutputContent,
   NodeType,
+  FlowTraceNodeInputContent,
+  FlowTraceNodeOutputContent,
+  FlowTrace,
   ResourceNotFoundException,
   ServiceQuotaExceededException,
   ThrottlingException,
@@ -2630,6 +2816,15 @@ var paginateRetrieve = (0, import_core.createPaginator)(BedrockAgentRuntimeClien
   InvokeFlowRequestFilterSensitiveLog,
   FlowCompletionEventFilterSensitiveLog,
   FlowOutputEventFilterSensitiveLog,
+  FlowTraceConditionFilterSensitiveLog,
+  FlowTraceConditionNodeResultEventFilterSensitiveLog,
+  FlowTraceNodeInputContentFilterSensitiveLog,
+  FlowTraceNodeInputFieldFilterSensitiveLog,
+  FlowTraceNodeInputEventFilterSensitiveLog,
+  FlowTraceNodeOutputFieldFilterSensitiveLog,
+  FlowTraceNodeOutputEventFilterSensitiveLog,
+  FlowTraceFilterSensitiveLog,
+  FlowTraceEventFilterSensitiveLog,
   FlowResponseStreamFilterSensitiveLog,
   InvokeFlowResponseFilterSensitiveLog,
   ByteContentFileFilterSensitiveLog,

package/dist-es/models/models_0.js

@@ -99,6 +99,34 @@ export const NodeType = {
     LEX_NODE: "LexNode",
     PROMPT_NODE: "PromptNode",
 };
+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 {
     constructor(opts) {
         super({
@@ -154,6 +182,8 @@ export var FlowResponseStream;
             return visitor.flowOutputEvent(value.flowOutputEvent);
         if (value.flowCompletionEvent !== undefined)
             return visitor.flowCompletionEvent(value.flowCompletionEvent);
+        if (value.flowTraceEvent !== undefined)
+            return visitor.flowTraceEvent(value.flowTraceEvent);
         if (value.internalServerException !== undefined)
             return visitor.internalServerException(value.internalServerException);
         if (value.validationException !== undefined)
@@ -494,11 +524,56 @@ export const FlowOutputEventFilterSensitiveLog = (obj) => ({
     ...obj,
     ...(obj.content && { content: obj.content }),
 });
+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) => {
     if (obj.flowOutputEvent !== undefined)
         return { flowOutputEvent: SENSITIVE_STRING };
     if (obj.flowCompletionEvent !== undefined)
         return { flowCompletionEvent: SENSITIVE_STRING };
+    if (obj.flowTraceEvent !== undefined)
+        return { flowTraceEvent: FlowTraceEventFilterSensitiveLog(obj.flowTraceEvent) };
     if (obj.internalServerException !== undefined)
         return { internalServerException: obj.internalServerException };
     if (obj.validationException !== undefined)

package/dist-es/protocols/Aws_restJson1.js

@@ -62,6 +62,7 @@ export const se_InvokeFlowCommand = async (input, context) => {
     b.p("flowAliasIdentifier", () => input.flowAliasIdentifier, "{flowAliasIdentifier}", false);
     let body;
     body = JSON.stringify(take(input, {
+        enableTrace: [],
         inputs: (_) => se_FlowInputs(_, context),
     }));
     b.m("POST").h(headers).b(body);
@@ -356,6 +357,11 @@ const de_FlowResponseStream = (output, context) => {
                 flowCompletionEvent: await de_FlowCompletionEvent_event(event["flowCompletionEvent"], context),
             };
         }
+        if (event["flowTraceEvent"] != null) {
+            return {
+                flowTraceEvent: await de_FlowTraceEvent_event(event["flowTraceEvent"], context),
+            };
+        }
         if (event["internalServerException"] != null) {
             return {
                 internalServerException: await de_InternalServerException_event(event["internalServerException"], context),
@@ -520,6 +526,12 @@ const de_FlowOutputEvent_event = async (output, context) => {
     Object.assign(contents, de_FlowOutputEvent(data, context));
     return contents;
 };
+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) => {
     const parsedOutput = {
         ...output,
@@ -824,6 +836,94 @@ const de_FlowOutputEvent = (output, context) => {
         nodeType: __expectString,
     });
 };
+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) => {
     return take(output, {
         maximumLength: __expectInt32,

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

@@ -364,6 +364,8 @@ declare const InvokeAgentCommand_base: {
  * //             traceId: "STRING_VALUE",
  * //             text: "STRING_VALUE",
  * //             type: "PRE_PROCESSING" || "ORCHESTRATION" || "KNOWLEDGE_BASE_RESPONSE_GENERATION" || "POST_PROCESSING",
+ * //             overrideLambda: "STRING_VALUE",
+ * //             promptCreationMode: "DEFAULT" || "OVERRIDDEN",
  * //             inferenceConfiguration: { // InferenceConfiguration
  * //               temperature: Number("float"),
  * //               topP: Number("float"),
@@ -373,8 +375,6 @@ declare const InvokeAgentCommand_base: {
  * //                 "STRING_VALUE",
  * //               ],
  * //             },
- * //             overrideLambda: "STRING_VALUE",
- * //             promptCreationMode: "DEFAULT" || "OVERRIDDEN",
  * //             parserMode: "DEFAULT" || "OVERRIDDEN",
  * //           },
  * //           modelInvocationOutput: { // PreProcessingModelInvocationOutput
@@ -495,6 +495,8 @@ declare const InvokeAgentCommand_base: {
  * //             traceId: "STRING_VALUE",
  * //             text: "STRING_VALUE",
  * //             type: "PRE_PROCESSING" || "ORCHESTRATION" || "KNOWLEDGE_BASE_RESPONSE_GENERATION" || "POST_PROCESSING",
+ * //             overrideLambda: "STRING_VALUE",
+ * //             promptCreationMode: "DEFAULT" || "OVERRIDDEN",
  * //             inferenceConfiguration: {
  * //               temperature: Number("float"),
  * //               topP: Number("float"),
@@ -504,8 +506,6 @@ declare const InvokeAgentCommand_base: {
  * //                 "STRING_VALUE",
  * //               ],
  * //             },
- * //             overrideLambda: "STRING_VALUE",
- * //             promptCreationMode: "DEFAULT" || "OVERRIDDEN",
  * //             parserMode: "DEFAULT" || "OVERRIDDEN",
  * //           },
  * //           modelInvocationOutput: { // OrchestrationModelInvocationOutput
@@ -526,6 +526,8 @@ declare const InvokeAgentCommand_base: {
  * //             traceId: "STRING_VALUE",
  * //             text: "STRING_VALUE",
  * //             type: "PRE_PROCESSING" || "ORCHESTRATION" || "KNOWLEDGE_BASE_RESPONSE_GENERATION" || "POST_PROCESSING",
+ * //             overrideLambda: "STRING_VALUE",
+ * //             promptCreationMode: "DEFAULT" || "OVERRIDDEN",
  * //             inferenceConfiguration: {
  * //               temperature: Number("float"),
  * //               topP: Number("float"),
@@ -535,8 +537,6 @@ declare const InvokeAgentCommand_base: {
  * //                 "STRING_VALUE",
  * //               ],
  * //             },
- * //             overrideLambda: "STRING_VALUE",
- * //             promptCreationMode: "DEFAULT" || "OVERRIDDEN",
  * //             parserMode: "DEFAULT" || "OVERRIDDEN",
  * //           },
  * //           modelInvocationOutput: { // PostProcessingModelInvocationOutput

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

@@ -49,6 +49,7 @@ declare const InvokeFlowCommand_base: {
  *       },
  *     },
  *   ],
+ *   enableTrace: true || false,
  * };
  * const command = new InvokeFlowCommand(input);
  * const response = await client.send(command);
@@ -64,6 +65,43 @@ declare const InvokeFlowCommand_base: {
  * //     flowCompletionEvent: { // FlowCompletionEvent
  * //       completionReason: "SUCCESS", // required
  * //     },
+ * //     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
  * //       message: "STRING_VALUE",
  * //     },