@aws-sdk/client-bedrock-runtime 3.583.0 → 3.588.0

package/dist-cjs/index.js

@@ -25,6 +25,18 @@ __export(src_exports, {
   BedrockRuntime: () => BedrockRuntime,
   BedrockRuntimeClient: () => BedrockRuntimeClient,
   BedrockRuntimeServiceException: () => BedrockRuntimeServiceException,
+  ContentBlock: () => ContentBlock,
+  ContentBlockDelta: () => ContentBlockDelta,
+  ContentBlockStart: () => ContentBlockStart,
+  ConversationRole: () => ConversationRole,
+  ConverseCommand: () => ConverseCommand,
+  ConverseOutput: () => ConverseOutput,
+  ConverseStreamCommand: () => ConverseStreamCommand,
+  ConverseStreamOutput: () => ConverseStreamOutput,
+  ConverseStreamOutputFilterSensitiveLog: () => ConverseStreamOutputFilterSensitiveLog,
+  ConverseStreamResponseFilterSensitiveLog: () => ConverseStreamResponseFilterSensitiveLog,
+  ImageFormat: () => ImageFormat,
+  ImageSource: () => ImageSource,
   InternalServerException: () => InternalServerException,
   InvokeModelCommand: () => InvokeModelCommand,
   InvokeModelRequestFilterSensitiveLog: () => InvokeModelRequestFilterSensitiveLog,
@@ -41,7 +53,14 @@ __export(src_exports, {
   ResponseStream: () => ResponseStream,
   ResponseStreamFilterSensitiveLog: () => ResponseStreamFilterSensitiveLog,
   ServiceQuotaExceededException: () => ServiceQuotaExceededException,
+  StopReason: () => StopReason,
+  SystemContentBlock: () => SystemContentBlock,
   ThrottlingException: () => ThrottlingException,
+  Tool: () => Tool,
+  ToolChoice: () => ToolChoice,
+  ToolInputSchema: () => ToolInputSchema,
+  ToolResultContentBlock: () => ToolResultContentBlock,
+  ToolResultStatus: () => ToolResultStatus,
   Trace: () => Trace,
   ValidationException: () => ValidationException,
   __Client: () => import_smithy_client.Client
@@ -196,13 +215,15 @@ var BedrockRuntimeClient = _BedrockRuntimeClient;
 // src/BedrockRuntime.ts
 
 
-// src/commands/InvokeModelCommand.ts
+// src/commands/ConverseCommand.ts
 
 var import_middleware_serde = require("@smithy/middleware-serde");
 
 var import_types = require("@smithy/types");
 
-// src/models/models_0.ts
+// src/protocols/Aws_restJson1.ts
+var import_core2 = require("@aws-sdk/core");
+
 
 
 // src/models/BedrockRuntimeServiceException.ts
@@ -220,6 +241,7 @@ __name(_BedrockRuntimeServiceException, "BedrockRuntimeServiceException");
 var BedrockRuntimeServiceException = _BedrockRuntimeServiceException;
 
 // src/models/models_0.ts
+
 var _AccessDeniedException = class _AccessDeniedException extends BedrockRuntimeServiceException {
   /**
    * @internal
@@ -237,6 +259,105 @@ var _AccessDeniedException = class _AccessDeniedException extends BedrockRuntime
 };
 __name(_AccessDeniedException, "AccessDeniedException");
 var AccessDeniedException = _AccessDeniedException;
+var ImageFormat = {
+  GIF: "gif",
+  JPEG: "jpeg",
+  PNG: "png",
+  WEBP: "webp"
+};
+var ImageSource;
+((ImageSource2) => {
+  ImageSource2.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.bytes !== void 0)
+      return visitor.bytes(value.bytes);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(ImageSource || (ImageSource = {}));
+var ToolResultContentBlock;
+((ToolResultContentBlock2) => {
+  ToolResultContentBlock2.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.json !== void 0)
+      return visitor.json(value.json);
+    if (value.text !== void 0)
+      return visitor.text(value.text);
+    if (value.image !== void 0)
+      return visitor.image(value.image);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(ToolResultContentBlock || (ToolResultContentBlock = {}));
+var ToolResultStatus = {
+  ERROR: "error",
+  SUCCESS: "success"
+};
+var ContentBlock;
+((ContentBlock2) => {
+  ContentBlock2.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.text !== void 0)
+      return visitor.text(value.text);
+    if (value.image !== void 0)
+      return visitor.image(value.image);
+    if (value.toolUse !== void 0)
+      return visitor.toolUse(value.toolUse);
+    if (value.toolResult !== void 0)
+      return visitor.toolResult(value.toolResult);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(ContentBlock || (ContentBlock = {}));
+var ConversationRole = {
+  ASSISTANT: "assistant",
+  USER: "user"
+};
+var SystemContentBlock;
+((SystemContentBlock3) => {
+  SystemContentBlock3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.text !== void 0)
+      return visitor.text(value.text);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(SystemContentBlock || (SystemContentBlock = {}));
+var ToolChoice;
+((ToolChoice3) => {
+  ToolChoice3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.auto !== void 0)
+      return visitor.auto(value.auto);
+    if (value.any !== void 0)
+      return visitor.any(value.any);
+    if (value.tool !== void 0)
+      return visitor.tool(value.tool);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(ToolChoice || (ToolChoice = {}));
+var ToolInputSchema;
+((ToolInputSchema2) => {
+  ToolInputSchema2.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.json !== void 0)
+      return visitor.json(value.json);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(ToolInputSchema || (ToolInputSchema = {}));
+var Tool;
+((Tool2) => {
+  Tool2.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.toolSpec !== void 0)
+      return visitor.toolSpec(value.toolSpec);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(Tool || (Tool = {}));
+var ConverseOutput;
+((ConverseOutput3) => {
+  ConverseOutput3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.message !== void 0)
+      return visitor.message(value.message);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(ConverseOutput || (ConverseOutput = {}));
+var StopReason = {
+  CONTENT_FILTERED: "content_filtered",
+  END_TURN: "end_turn",
+  MAX_TOKENS: "max_tokens",
+  STOP_SEQUENCE: "stop_sequence",
+  TOOL_USE: "tool_use"
+};
 var _InternalServerException = class _InternalServerException extends BedrockRuntimeServiceException {
   /**
    * @internal
@@ -254,10 +375,6 @@ var _InternalServerException = class _InternalServerException extends BedrockRun
 };
 __name(_InternalServerException, "InternalServerException");
 var InternalServerException = _InternalServerException;
-var Trace = {
-  DISABLED: "DISABLED",
-  ENABLED: "ENABLED"
-};
 var _ModelErrorException = class _ModelErrorException extends BedrockRuntimeServiceException {
   /**
    * @internal
@@ -328,23 +445,6 @@ var _ResourceNotFoundException = class _ResourceNotFoundException extends Bedroc
 };
 __name(_ResourceNotFoundException, "ResourceNotFoundException");
 var ResourceNotFoundException = _ResourceNotFoundException;
-var _ServiceQuotaExceededException = class _ServiceQuotaExceededException extends BedrockRuntimeServiceException {
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "ServiceQuotaExceededException",
-      $fault: "client",
-      ...opts
-    });
-    this.name = "ServiceQuotaExceededException";
-    this.$fault = "client";
-    Object.setPrototypeOf(this, _ServiceQuotaExceededException.prototype);
-  }
-};
-__name(_ServiceQuotaExceededException, "ServiceQuotaExceededException");
-var ServiceQuotaExceededException = _ServiceQuotaExceededException;
 var _ThrottlingException = class _ThrottlingException extends BedrockRuntimeServiceException {
   /**
    * @internal
@@ -379,6 +479,24 @@ var _ValidationException = class _ValidationException extends BedrockRuntimeServ
 };
 __name(_ValidationException, "ValidationException");
 var ValidationException = _ValidationException;
+var ContentBlockDelta;
+((ContentBlockDelta2) => {
+  ContentBlockDelta2.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.text !== void 0)
+      return visitor.text(value.text);
+    if (value.toolUse !== void 0)
+      return visitor.toolUse(value.toolUse);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(ContentBlockDelta || (ContentBlockDelta = {}));
+var ContentBlockStart;
+((ContentBlockStart2) => {
+  ContentBlockStart2.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.toolUse !== void 0)
+      return visitor.toolUse(value.toolUse);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(ContentBlockStart || (ContentBlockStart = {}));
 var _ModelStreamErrorException = class _ModelStreamErrorException extends BedrockRuntimeServiceException {
   /**
    * @internal
@@ -398,6 +516,53 @@ var _ModelStreamErrorException = class _ModelStreamErrorException extends Bedroc
 };
 __name(_ModelStreamErrorException, "ModelStreamErrorException");
 var ModelStreamErrorException = _ModelStreamErrorException;
+var ConverseStreamOutput;
+((ConverseStreamOutput3) => {
+  ConverseStreamOutput3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.messageStart !== void 0)
+      return visitor.messageStart(value.messageStart);
+    if (value.contentBlockStart !== void 0)
+      return visitor.contentBlockStart(value.contentBlockStart);
+    if (value.contentBlockDelta !== void 0)
+      return visitor.contentBlockDelta(value.contentBlockDelta);
+    if (value.contentBlockStop !== void 0)
+      return visitor.contentBlockStop(value.contentBlockStop);
+    if (value.messageStop !== void 0)
+      return visitor.messageStop(value.messageStop);
+    if (value.metadata !== void 0)
+      return visitor.metadata(value.metadata);
+    if (value.internalServerException !== void 0)
+      return visitor.internalServerException(value.internalServerException);
+    if (value.modelStreamErrorException !== void 0)
+      return visitor.modelStreamErrorException(value.modelStreamErrorException);
+    if (value.validationException !== void 0)
+      return visitor.validationException(value.validationException);
+    if (value.throttlingException !== void 0)
+      return visitor.throttlingException(value.throttlingException);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(ConverseStreamOutput || (ConverseStreamOutput = {}));
+var Trace = {
+  DISABLED: "DISABLED",
+  ENABLED: "ENABLED"
+};
+var _ServiceQuotaExceededException = class _ServiceQuotaExceededException extends BedrockRuntimeServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ServiceQuotaExceededException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ServiceQuotaExceededException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ServiceQuotaExceededException.prototype);
+  }
+};
+__name(_ServiceQuotaExceededException, "ServiceQuotaExceededException");
+var ServiceQuotaExceededException = _ServiceQuotaExceededException;
 var ResponseStream;
 ((ResponseStream3) => {
   ResponseStream3.visit = /* @__PURE__ */ __name((value, visitor) => {
@@ -416,6 +581,34 @@ var ResponseStream;
     return visitor._(value.$unknown[0], value.$unknown[1]);
   }, "visit");
 })(ResponseStream || (ResponseStream = {}));
+var ConverseStreamOutputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => {
+  if (obj.messageStart !== void 0)
+    return { messageStart: obj.messageStart };
+  if (obj.contentBlockStart !== void 0)
+    return { contentBlockStart: obj.contentBlockStart };
+  if (obj.contentBlockDelta !== void 0)
+    return { contentBlockDelta: obj.contentBlockDelta };
+  if (obj.contentBlockStop !== void 0)
+    return { contentBlockStop: obj.contentBlockStop };
+  if (obj.messageStop !== void 0)
+    return { messageStop: obj.messageStop };
+  if (obj.metadata !== void 0)
+    return { metadata: obj.metadata };
+  if (obj.internalServerException !== void 0)
+    return { internalServerException: obj.internalServerException };
+  if (obj.modelStreamErrorException !== void 0)
+    return { modelStreamErrorException: obj.modelStreamErrorException };
+  if (obj.validationException !== void 0)
+    return { validationException: obj.validationException };
+  if (obj.throttlingException !== void 0)
+    return { throttlingException: obj.throttlingException };
+  if (obj.$unknown !== void 0)
+    return { [obj.$unknown[0]]: "UNKNOWN" };
+}, "ConverseStreamOutputFilterSensitiveLog");
+var ConverseStreamResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.stream && { stream: "STREAMING_CONTENT" }
+}), "ConverseStreamResponseFilterSensitiveLog");
 var InvokeModelRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
   ...obj,
   ...obj.body && { body: import_smithy_client.SENSITIVE_STRING }
@@ -454,9 +647,48 @@ var InvokeModelWithResponseStreamResponseFilterSensitiveLog = /* @__PURE__ */ __
 }), "InvokeModelWithResponseStreamResponseFilterSensitiveLog");
 
 // src/protocols/Aws_restJson1.ts
-var import_core2 = require("@aws-sdk/core");
-
-
+var se_ConverseCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/model/{modelId}/converse");
+  b.p("modelId", () => input.modelId, "{modelId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      additionalModelRequestFields: (_) => se_Document(_, context),
+      additionalModelResponseFieldPaths: (_) => (0, import_smithy_client._json)(_),
+      inferenceConfig: (_) => se_InferenceConfiguration(_, context),
+      messages: (_) => se_Messages(_, context),
+      system: (_) => (0, import_smithy_client._json)(_),
+      toolConfig: (_) => se_ToolConfiguration(_, context)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_ConverseCommand");
+var se_ConverseStreamCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/model/{modelId}/converse-stream");
+  b.p("modelId", () => input.modelId, "{modelId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      additionalModelRequestFields: (_) => se_Document(_, context),
+      additionalModelResponseFieldPaths: (_) => (0, import_smithy_client._json)(_),
+      inferenceConfig: (_) => se_InferenceConfiguration(_, context),
+      messages: (_) => se_Messages(_, context),
+      system: (_) => (0, import_smithy_client._json)(_),
+      toolConfig: (_) => se_ToolConfiguration(_, context)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_ConverseStreamCommand");
 var se_InvokeModelCommand = /* @__PURE__ */ __name(async (input, context) => {
   const b = (0, import_core.requestBuilder)(input, context);
   const headers = (0, import_smithy_client.map)({}, isSerializableHeaderValue, {
@@ -493,6 +725,35 @@ var se_InvokeModelWithResponseStreamCommand = /* @__PURE__ */ __name(async (inpu
   b.m("POST").h(headers).b(body);
   return b.build();
 }, "se_InvokeModelWithResponseStreamCommand");
+var de_ConverseCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    additionalModelResponseFields: (_) => de_Document(_, context),
+    metrics: import_smithy_client._json,
+    output: (_) => de_ConverseOutput((0, import_core2.awsExpectUnion)(_), context),
+    stopReason: import_smithy_client.expectString,
+    usage: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ConverseCommand");
+var de_ConverseStreamCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = output.body;
+  contents.stream = de_ConverseStreamOutput(data, context);
+  return contents;
+}, "de_ConverseStreamCommand");
 var de_InvokeModelCommand = /* @__PURE__ */ __name(async (output, context) => {
   if (output.statusCode !== 200 && output.statusCode >= 300) {
     return de_CommandError(output, context);
@@ -542,15 +803,15 @@ var de_CommandError = /* @__PURE__ */ __name(async (output, context) => {
     case "ResourceNotFoundException":
     case "com.amazonaws.bedrockruntime#ResourceNotFoundException":
       throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-    case "ServiceQuotaExceededException":
-    case "com.amazonaws.bedrockruntime#ServiceQuotaExceededException":
-      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
     case "ThrottlingException":
     case "com.amazonaws.bedrockruntime#ThrottlingException":
       throw await de_ThrottlingExceptionRes(parsedOutput, context);
     case "ValidationException":
     case "com.amazonaws.bedrockruntime#ValidationException":
       throw await de_ValidationExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.bedrockruntime#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
     case "ModelStreamErrorException":
     case "com.amazonaws.bedrockruntime#ModelStreamErrorException":
       throw await de_ModelStreamErrorExceptionRes(parsedOutput, context);
@@ -698,6 +959,64 @@ var de_ValidationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, cont
   });
   return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
 }, "de_ValidationExceptionRes");
+var de_ConverseStreamOutput = /* @__PURE__ */ __name((output, context) => {
+  return context.eventStreamMarshaller.deserialize(output, async (event) => {
+    if (event["messageStart"] != null) {
+      return {
+        messageStart: await de_MessageStartEvent_event(event["messageStart"], context)
+      };
+    }
+    if (event["contentBlockStart"] != null) {
+      return {
+        contentBlockStart: await de_ContentBlockStartEvent_event(event["contentBlockStart"], context)
+      };
+    }
+    if (event["contentBlockDelta"] != null) {
+      return {
+        contentBlockDelta: await de_ContentBlockDeltaEvent_event(event["contentBlockDelta"], context)
+      };
+    }
+    if (event["contentBlockStop"] != null) {
+      return {
+        contentBlockStop: await de_ContentBlockStopEvent_event(event["contentBlockStop"], context)
+      };
+    }
+    if (event["messageStop"] != null) {
+      return {
+        messageStop: await de_MessageStopEvent_event(event["messageStop"], context)
+      };
+    }
+    if (event["metadata"] != null) {
+      return {
+        metadata: await de_ConverseStreamMetadataEvent_event(event["metadata"], context)
+      };
+    }
+    if (event["internalServerException"] != null) {
+      return {
+        internalServerException: await de_InternalServerException_event(event["internalServerException"], context)
+      };
+    }
+    if (event["modelStreamErrorException"] != null) {
+      return {
+        modelStreamErrorException: await de_ModelStreamErrorException_event(
+          event["modelStreamErrorException"],
+          context
+        )
+      };
+    }
+    if (event["validationException"] != null) {
+      return {
+        validationException: await de_ValidationException_event(event["validationException"], context)
+      };
+    }
+    if (event["throttlingException"] != null) {
+      return {
+        throttlingException: await de_ThrottlingException_event(event["throttlingException"], context)
+      };
+    }
+    return { $unknown: output };
+  });
+}, "de_ConverseStreamOutput");
 var de_ResponseStream = /* @__PURE__ */ __name((output, context) => {
   return context.eventStreamMarshaller.deserialize(output, async (event) => {
     if (event["chunk"] != null) {
@@ -736,6 +1055,30 @@ var de_ResponseStream = /* @__PURE__ */ __name((output, context) => {
     return { $unknown: output };
   });
 }, "de_ResponseStream");
+var de_ContentBlockDeltaEvent_event = /* @__PURE__ */ __name(async (output, context) => {
+  const contents = {};
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  Object.assign(contents, (0, import_smithy_client._json)(data));
+  return contents;
+}, "de_ContentBlockDeltaEvent_event");
+var de_ContentBlockStartEvent_event = /* @__PURE__ */ __name(async (output, context) => {
+  const contents = {};
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  Object.assign(contents, (0, import_smithy_client._json)(data));
+  return contents;
+}, "de_ContentBlockStartEvent_event");
+var de_ContentBlockStopEvent_event = /* @__PURE__ */ __name(async (output, context) => {
+  const contents = {};
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  Object.assign(contents, (0, import_smithy_client._json)(data));
+  return contents;
+}, "de_ContentBlockStopEvent_event");
+var de_ConverseStreamMetadataEvent_event = /* @__PURE__ */ __name(async (output, context) => {
+  const contents = {};
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  Object.assign(contents, (0, import_smithy_client._json)(data));
+  return contents;
+}, "de_ConverseStreamMetadataEvent_event");
 var de_InternalServerException_event = /* @__PURE__ */ __name(async (output, context) => {
   const parsedOutput = {
     ...output,
@@ -743,6 +1086,18 @@ var de_InternalServerException_event = /* @__PURE__ */ __name(async (output, con
   };
   return de_InternalServerExceptionRes(parsedOutput, context);
 }, "de_InternalServerException_event");
+var de_MessageStartEvent_event = /* @__PURE__ */ __name(async (output, context) => {
+  const contents = {};
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  Object.assign(contents, (0, import_smithy_client._json)(data));
+  return contents;
+}, "de_MessageStartEvent_event");
+var de_MessageStopEvent_event = /* @__PURE__ */ __name(async (output, context) => {
+  const contents = {};
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  Object.assign(contents, de_MessageStopEvent(data, context));
+  return contents;
+}, "de_MessageStopEvent_event");
 var de_ModelStreamErrorException_event = /* @__PURE__ */ __name(async (output, context) => {
   const parsedOutput = {
     ...output,
@@ -777,11 +1132,216 @@ var de_ValidationException_event = /* @__PURE__ */ __name(async (output, context
   };
   return de_ValidationExceptionRes(parsedOutput, context);
 }, "de_ValidationException_event");
+var se_ContentBlock = /* @__PURE__ */ __name((input, context) => {
+  return ContentBlock.visit(input, {
+    image: (value) => ({ image: se_ImageBlock(value, context) }),
+    text: (value) => ({ text: value }),
+    toolResult: (value) => ({ toolResult: se_ToolResultBlock(value, context) }),
+    toolUse: (value) => ({ toolUse: se_ToolUseBlock(value, context) }),
+    _: (name, value) => ({ name: value })
+  });
+}, "se_ContentBlock");
+var se_ContentBlocks = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return se_ContentBlock(entry, context);
+  });
+}, "se_ContentBlocks");
+var se_ImageBlock = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    format: [],
+    source: (_) => se_ImageSource(_, context)
+  });
+}, "se_ImageBlock");
+var se_ImageSource = /* @__PURE__ */ __name((input, context) => {
+  return ImageSource.visit(input, {
+    bytes: (value) => ({ bytes: context.base64Encoder(value) }),
+    _: (name, value) => ({ name: value })
+  });
+}, "se_ImageSource");
+var se_InferenceConfiguration = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    maxTokens: [],
+    stopSequences: import_smithy_client._json,
+    temperature: import_smithy_client.serializeFloat,
+    topP: import_smithy_client.serializeFloat
+  });
+}, "se_InferenceConfiguration");
+var se_Message = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    content: (_) => se_ContentBlocks(_, context),
+    role: []
+  });
+}, "se_Message");
+var se_Messages = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return se_Message(entry, context);
+  });
+}, "se_Messages");
+var se_Tool = /* @__PURE__ */ __name((input, context) => {
+  return Tool.visit(input, {
+    toolSpec: (value) => ({ toolSpec: se_ToolSpecification(value, context) }),
+    _: (name, value) => ({ name: value })
+  });
+}, "se_Tool");
+var se_ToolConfiguration = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    toolChoice: import_smithy_client._json,
+    tools: (_) => se_Tools(_, context)
+  });
+}, "se_ToolConfiguration");
+var se_ToolInputSchema = /* @__PURE__ */ __name((input, context) => {
+  return ToolInputSchema.visit(input, {
+    json: (value) => ({ json: se_Document(value, context) }),
+    _: (name, value) => ({ name: value })
+  });
+}, "se_ToolInputSchema");
+var se_ToolResultBlock = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    content: (_) => se_ToolResultContentBlocks(_, context),
+    status: [],
+    toolUseId: []
+  });
+}, "se_ToolResultBlock");
+var se_ToolResultContentBlock = /* @__PURE__ */ __name((input, context) => {
+  return ToolResultContentBlock.visit(input, {
+    image: (value) => ({ image: se_ImageBlock(value, context) }),
+    json: (value) => ({ json: se_Document(value, context) }),
+    text: (value) => ({ text: value }),
+    _: (name, value) => ({ name: value })
+  });
+}, "se_ToolResultContentBlock");
+var se_ToolResultContentBlocks = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return se_ToolResultContentBlock(entry, context);
+  });
+}, "se_ToolResultContentBlocks");
+var se_Tools = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return se_Tool(entry, context);
+  });
+}, "se_Tools");
+var se_ToolSpecification = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    description: [],
+    inputSchema: (_) => se_ToolInputSchema(_, context),
+    name: []
+  });
+}, "se_ToolSpecification");
+var se_ToolUseBlock = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    input: (_) => se_Document(_, context),
+    name: [],
+    toolUseId: []
+  });
+}, "se_ToolUseBlock");
+var se_Document = /* @__PURE__ */ __name((input, context) => {
+  return input;
+}, "se_Document");
+var de_ContentBlock = /* @__PURE__ */ __name((output, context) => {
+  if (output.image != null) {
+    return {
+      image: de_ImageBlock(output.image, context)
+    };
+  }
+  if ((0, import_smithy_client.expectString)(output.text) !== void 0) {
+    return { text: (0, import_smithy_client.expectString)(output.text) };
+  }
+  if (output.toolResult != null) {
+    return {
+      toolResult: de_ToolResultBlock(output.toolResult, context)
+    };
+  }
+  if (output.toolUse != null) {
+    return {
+      toolUse: de_ToolUseBlock(output.toolUse, context)
+    };
+  }
+  return { $unknown: Object.entries(output)[0] };
+}, "de_ContentBlock");
+var de_ContentBlocks = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_ContentBlock((0, import_core2.awsExpectUnion)(entry), context);
+  });
+  return retVal;
+}, "de_ContentBlocks");
+var de_ConverseOutput = /* @__PURE__ */ __name((output, context) => {
+  if (output.message != null) {
+    return {
+      message: de_Message(output.message, context)
+    };
+  }
+  return { $unknown: Object.entries(output)[0] };
+}, "de_ConverseOutput");
+var de_ImageBlock = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    format: import_smithy_client.expectString,
+    source: (_) => de_ImageSource((0, import_core2.awsExpectUnion)(_), context)
+  });
+}, "de_ImageBlock");
+var de_ImageSource = /* @__PURE__ */ __name((output, context) => {
+  if (output.bytes != null) {
+    return {
+      bytes: context.base64Decoder(output.bytes)
+    };
+  }
+  return { $unknown: Object.entries(output)[0] };
+}, "de_ImageSource");
+var de_Message = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    content: (_) => de_ContentBlocks(_, context),
+    role: import_smithy_client.expectString
+  });
+}, "de_Message");
+var de_MessageStopEvent = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    additionalModelResponseFields: (_) => de_Document(_, context),
+    stopReason: import_smithy_client.expectString
+  });
+}, "de_MessageStopEvent");
 var de_PayloadPart = /* @__PURE__ */ __name((output, context) => {
   return (0, import_smithy_client.take)(output, {
     bytes: context.base64Decoder
   });
 }, "de_PayloadPart");
+var de_ToolResultBlock = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    content: (_) => de_ToolResultContentBlocks(_, context),
+    status: import_smithy_client.expectString,
+    toolUseId: import_smithy_client.expectString
+  });
+}, "de_ToolResultBlock");
+var de_ToolResultContentBlock = /* @__PURE__ */ __name((output, context) => {
+  if (output.image != null) {
+    return {
+      image: de_ImageBlock(output.image, context)
+    };
+  }
+  if (output.json != null) {
+    return {
+      json: de_Document(output.json, context)
+    };
+  }
+  if ((0, import_smithy_client.expectString)(output.text) !== void 0) {
+    return { text: (0, import_smithy_client.expectString)(output.text) };
+  }
+  return { $unknown: Object.entries(output)[0] };
+}, "de_ToolResultContentBlock");
+var de_ToolResultContentBlocks = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_ToolResultContentBlock((0, import_core2.awsExpectUnion)(entry), context);
+  });
+  return retVal;
+}, "de_ToolResultContentBlocks");
+var de_ToolUseBlock = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    input: (_) => de_Document(_, context),
+    name: import_smithy_client.expectString,
+    toolUseId: import_smithy_client.expectString
+  });
+}, "de_ToolUseBlock");
+var de_Document = /* @__PURE__ */ __name((output, context) => {
+  return output;
+}, "de_Document");
 var deserializeMetadata = /* @__PURE__ */ __name((output) => ({
   httpStatusCode: output.statusCode,
   requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
@@ -801,7 +1361,48 @@ var _xabg = "x-amzn-bedrock-guardrailidentifier";
 var _xabg_ = "x-amzn-bedrock-guardrailversion";
 var _xabt = "x-amzn-bedrock-trace";
 
+// src/commands/ConverseCommand.ts
+var _ConverseCommand = class _ConverseCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonBedrockFrontendService", "Converse", {}).n("BedrockRuntimeClient", "ConverseCommand").f(void 0, void 0).ser(se_ConverseCommand).de(de_ConverseCommand).build() {
+};
+__name(_ConverseCommand, "ConverseCommand");
+var ConverseCommand = _ConverseCommand;
+
+// src/commands/ConverseStreamCommand.ts
+
+
+
+
+var _ConverseStreamCommand = class _ConverseStreamCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonBedrockFrontendService", "ConverseStream", {
+  /**
+   * @internal
+   */
+  eventStream: {
+    output: true
+  }
+}).n("BedrockRuntimeClient", "ConverseStreamCommand").f(void 0, ConverseStreamResponseFilterSensitiveLog).ser(se_ConverseStreamCommand).de(de_ConverseStreamCommand).build() {
+};
+__name(_ConverseStreamCommand, "ConverseStreamCommand");
+var ConverseStreamCommand = _ConverseStreamCommand;
+
 // src/commands/InvokeModelCommand.ts
+
+
+
+
 var _InvokeModelCommand = class _InvokeModelCommand extends import_smithy_client.Command.classBuilder().ep({
   ...commonParams
 }).m(function(Command, cs, config, o) {
@@ -840,6 +1441,8 @@ var InvokeModelWithResponseStreamCommand = _InvokeModelWithResponseStreamCommand
 
 // src/BedrockRuntime.ts
 var commands = {
+  ConverseCommand,
+  ConverseStreamCommand,
   InvokeModelCommand,
   InvokeModelWithResponseStreamCommand
 };
@@ -856,20 +1459,39 @@ var BedrockRuntime = _BedrockRuntime;
   BedrockRuntimeClient,
   BedrockRuntime,
   $Command,
+  ConverseCommand,
+  ConverseStreamCommand,
   InvokeModelCommand,
   InvokeModelWithResponseStreamCommand,
   AccessDeniedException,
+  ImageFormat,
+  ImageSource,
+  ToolResultContentBlock,
+  ToolResultStatus,
+  ContentBlock,
+  ConversationRole,
+  SystemContentBlock,
+  ToolChoice,
+  ToolInputSchema,
+  Tool,
+  ConverseOutput,
+  StopReason,
   InternalServerException,
-  Trace,
   ModelErrorException,
   ModelNotReadyException,
   ModelTimeoutException,
   ResourceNotFoundException,
-  ServiceQuotaExceededException,
   ThrottlingException,
   ValidationException,
+  ContentBlockDelta,
+  ContentBlockStart,
   ModelStreamErrorException,
+  ConverseStreamOutput,
+  Trace,
+  ServiceQuotaExceededException,
   ResponseStream,
+  ConverseStreamOutputFilterSensitiveLog,
+  ConverseStreamResponseFilterSensitiveLog,
   InvokeModelRequestFilterSensitiveLog,
   InvokeModelResponseFilterSensitiveLog,
   InvokeModelWithResponseStreamRequestFilterSensitiveLog,