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

package/dist-es/protocols/Aws_restJson1.js

@@ -1,8 +1,46 @@
-import { loadRestJsonErrorCode, parseJsonBody as parseBody, parseJsonErrorBody as parseErrorBody } from "@aws-sdk/core";
+import { awsExpectUnion as __expectUnion, loadRestJsonErrorCode, parseJsonBody as parseBody, parseJsonErrorBody as parseErrorBody, } from "@aws-sdk/core";
 import { requestBuilder as rb } from "@smithy/core";
-import { collectBody, decorateServiceException as __decorateServiceException, expectInt32 as __expectInt32, expectString as __expectString, map, take, withBaseException, } from "@smithy/smithy-client";
+import { _json, collectBody, decorateServiceException as __decorateServiceException, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, map, serializeFloat as __serializeFloat, take, withBaseException, } from "@smithy/smithy-client";
 import { BedrockRuntimeServiceException as __BaseException } from "../models/BedrockRuntimeServiceException";
-import { AccessDeniedException, InternalServerException, ModelErrorException, ModelNotReadyException, ModelStreamErrorException, ModelTimeoutException, ResourceNotFoundException, ServiceQuotaExceededException, ThrottlingException, ValidationException, } from "../models/models_0";
+import { AccessDeniedException, ContentBlock, ImageSource, InternalServerException, ModelErrorException, ModelNotReadyException, ModelStreamErrorException, ModelTimeoutException, ResourceNotFoundException, ServiceQuotaExceededException, ThrottlingException, Tool, ToolInputSchema, ToolResultContentBlock, ValidationException, } from "../models/models_0";
+export const se_ConverseCommand = async (input, context) => {
+    const b = rb(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(take(input, {
+        additionalModelRequestFields: (_) => se_Document(_, context),
+        additionalModelResponseFieldPaths: (_) => _json(_),
+        inferenceConfig: (_) => se_InferenceConfiguration(_, context),
+        messages: (_) => se_Messages(_, context),
+        system: (_) => _json(_),
+        toolConfig: (_) => se_ToolConfiguration(_, context),
+    }));
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
+export const se_ConverseStreamCommand = async (input, context) => {
+    const b = rb(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(take(input, {
+        additionalModelRequestFields: (_) => se_Document(_, context),
+        additionalModelResponseFieldPaths: (_) => _json(_),
+        inferenceConfig: (_) => se_InferenceConfiguration(_, context),
+        messages: (_) => se_Messages(_, context),
+        system: (_) => _json(_),
+        toolConfig: (_) => se_ToolConfiguration(_, context),
+    }));
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
 export const se_InvokeModelCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = map({}, isSerializableHeaderValue, {
@@ -39,6 +77,35 @@ export const se_InvokeModelWithResponseStreamCommand = async (input, context) =>
     b.m("POST").h(headers).b(body);
     return b.build();
 };
+export const de_ConverseCommand = 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, {
+        additionalModelResponseFields: (_) => de_Document(_, context),
+        metrics: _json,
+        output: (_) => de_ConverseOutput(__expectUnion(_), context),
+        stopReason: __expectString,
+        usage: _json,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_ConverseStreamCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = output.body;
+    contents.stream = de_ConverseStreamOutput(data, context);
+    return contents;
+};
 export const de_InvokeModelCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -88,15 +155,15 @@ const de_CommandError = 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);
@@ -244,6 +311,61 @@ const de_ValidationExceptionRes = async (parsedOutput, context) => {
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
+const de_ConverseStreamOutput = (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 };
+    });
+};
 const de_ResponseStream = (output, context) => {
     return context.eventStreamMarshaller.deserialize(output, async (event) => {
         if (event["chunk"] != null) {
@@ -279,6 +401,30 @@ const de_ResponseStream = (output, context) => {
         return { $unknown: output };
     });
 };
+const de_ContentBlockDeltaEvent_event = async (output, context) => {
+    const contents = {};
+    const data = await parseBody(output.body, context);
+    Object.assign(contents, _json(data));
+    return contents;
+};
+const de_ContentBlockStartEvent_event = async (output, context) => {
+    const contents = {};
+    const data = await parseBody(output.body, context);
+    Object.assign(contents, _json(data));
+    return contents;
+};
+const de_ContentBlockStopEvent_event = async (output, context) => {
+    const contents = {};
+    const data = await parseBody(output.body, context);
+    Object.assign(contents, _json(data));
+    return contents;
+};
+const de_ConverseStreamMetadataEvent_event = async (output, context) => {
+    const contents = {};
+    const data = await parseBody(output.body, context);
+    Object.assign(contents, _json(data));
+    return contents;
+};
 const de_InternalServerException_event = async (output, context) => {
     const parsedOutput = {
         ...output,
@@ -286,6 +432,18 @@ const de_InternalServerException_event = async (output, context) => {
     };
     return de_InternalServerExceptionRes(parsedOutput, context);
 };
+const de_MessageStartEvent_event = async (output, context) => {
+    const contents = {};
+    const data = await parseBody(output.body, context);
+    Object.assign(contents, _json(data));
+    return contents;
+};
+const de_MessageStopEvent_event = async (output, context) => {
+    const contents = {};
+    const data = await parseBody(output.body, context);
+    Object.assign(contents, de_MessageStopEvent(data, context));
+    return contents;
+};
 const de_ModelStreamErrorException_event = async (output, context) => {
     const parsedOutput = {
         ...output,
@@ -320,11 +478,228 @@ const de_ValidationException_event = async (output, context) => {
     };
     return de_ValidationExceptionRes(parsedOutput, context);
 };
+const se_ContentBlock = (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 }),
+    });
+};
+const se_ContentBlocks = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return se_ContentBlock(entry, context);
+    });
+};
+const se_ImageBlock = (input, context) => {
+    return take(input, {
+        format: [],
+        source: (_) => se_ImageSource(_, context),
+    });
+};
+const se_ImageSource = (input, context) => {
+    return ImageSource.visit(input, {
+        bytes: (value) => ({ bytes: context.base64Encoder(value) }),
+        _: (name, value) => ({ name: value }),
+    });
+};
+const se_InferenceConfiguration = (input, context) => {
+    return take(input, {
+        maxTokens: [],
+        stopSequences: _json,
+        temperature: __serializeFloat,
+        topP: __serializeFloat,
+    });
+};
+const se_Message = (input, context) => {
+    return take(input, {
+        content: (_) => se_ContentBlocks(_, context),
+        role: [],
+    });
+};
+const se_Messages = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return se_Message(entry, context);
+    });
+};
+const se_Tool = (input, context) => {
+    return Tool.visit(input, {
+        toolSpec: (value) => ({ toolSpec: se_ToolSpecification(value, context) }),
+        _: (name, value) => ({ name: value }),
+    });
+};
+const se_ToolConfiguration = (input, context) => {
+    return take(input, {
+        toolChoice: _json,
+        tools: (_) => se_Tools(_, context),
+    });
+};
+const se_ToolInputSchema = (input, context) => {
+    return ToolInputSchema.visit(input, {
+        json: (value) => ({ json: se_Document(value, context) }),
+        _: (name, value) => ({ name: value }),
+    });
+};
+const se_ToolResultBlock = (input, context) => {
+    return take(input, {
+        content: (_) => se_ToolResultContentBlocks(_, context),
+        status: [],
+        toolUseId: [],
+    });
+};
+const se_ToolResultContentBlock = (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 }),
+    });
+};
+const se_ToolResultContentBlocks = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return se_ToolResultContentBlock(entry, context);
+    });
+};
+const se_Tools = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return se_Tool(entry, context);
+    });
+};
+const se_ToolSpecification = (input, context) => {
+    return take(input, {
+        description: [],
+        inputSchema: (_) => se_ToolInputSchema(_, context),
+        name: [],
+    });
+};
+const se_ToolUseBlock = (input, context) => {
+    return take(input, {
+        input: (_) => se_Document(_, context),
+        name: [],
+        toolUseId: [],
+    });
+};
+const se_Document = (input, context) => {
+    return input;
+};
+const de_ContentBlock = (output, context) => {
+    if (output.image != null) {
+        return {
+            image: de_ImageBlock(output.image, context),
+        };
+    }
+    if (__expectString(output.text) !== undefined) {
+        return { text: __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] };
+};
+const de_ContentBlocks = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_ContentBlock(__expectUnion(entry), context);
+    });
+    return retVal;
+};
+const de_ConverseOutput = (output, context) => {
+    if (output.message != null) {
+        return {
+            message: de_Message(output.message, context),
+        };
+    }
+    return { $unknown: Object.entries(output)[0] };
+};
+const de_ImageBlock = (output, context) => {
+    return take(output, {
+        format: __expectString,
+        source: (_) => de_ImageSource(__expectUnion(_), context),
+    });
+};
+const de_ImageSource = (output, context) => {
+    if (output.bytes != null) {
+        return {
+            bytes: context.base64Decoder(output.bytes),
+        };
+    }
+    return { $unknown: Object.entries(output)[0] };
+};
+const de_Message = (output, context) => {
+    return take(output, {
+        content: (_) => de_ContentBlocks(_, context),
+        role: __expectString,
+    });
+};
+const de_MessageStopEvent = (output, context) => {
+    return take(output, {
+        additionalModelResponseFields: (_) => de_Document(_, context),
+        stopReason: __expectString,
+    });
+};
 const de_PayloadPart = (output, context) => {
     return take(output, {
         bytes: context.base64Decoder,
     });
 };
+const de_ToolResultBlock = (output, context) => {
+    return take(output, {
+        content: (_) => de_ToolResultContentBlocks(_, context),
+        status: __expectString,
+        toolUseId: __expectString,
+    });
+};
+const de_ToolResultContentBlock = (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 (__expectString(output.text) !== undefined) {
+        return { text: __expectString(output.text) };
+    }
+    return { $unknown: Object.entries(output)[0] };
+};
+const de_ToolResultContentBlocks = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_ToolResultContentBlock(__expectUnion(entry), context);
+    });
+    return retVal;
+};
+const de_ToolUseBlock = (output, context) => {
+    return take(output, {
+        input: (_) => de_Document(_, context),
+        name: __expectString,
+        toolUseId: __expectString,
+    });
+};
+const de_Document = (output, context) => {
+    return output;
+};
 const deserializeMetadata = (output) => ({
     httpStatusCode: output.statusCode,
     requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],

package/dist-types/BedrockRuntime.d.ts

@@ -1,8 +1,22 @@
 import { HttpHandlerOptions as __HttpHandlerOptions } from "@smithy/types";
 import { BedrockRuntimeClient } from "./BedrockRuntimeClient";
+import { ConverseCommandInput, ConverseCommandOutput } from "./commands/ConverseCommand";
+import { ConverseStreamCommandInput, ConverseStreamCommandOutput } from "./commands/ConverseStreamCommand";
 import { InvokeModelCommandInput, InvokeModelCommandOutput } from "./commands/InvokeModelCommand";
 import { InvokeModelWithResponseStreamCommandInput, InvokeModelWithResponseStreamCommandOutput } from "./commands/InvokeModelWithResponseStreamCommand";
 export interface BedrockRuntime {
+    /**
+     * @see {@link ConverseCommand}
+     */
+    converse(args: ConverseCommandInput, options?: __HttpHandlerOptions): Promise<ConverseCommandOutput>;
+    converse(args: ConverseCommandInput, cb: (err: any, data?: ConverseCommandOutput) => void): void;
+    converse(args: ConverseCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ConverseCommandOutput) => void): void;
+    /**
+     * @see {@link ConverseStreamCommand}
+     */
+    converseStream(args: ConverseStreamCommandInput, options?: __HttpHandlerOptions): Promise<ConverseStreamCommandOutput>;
+    converseStream(args: ConverseStreamCommandInput, cb: (err: any, data?: ConverseStreamCommandOutput) => void): void;
+    converseStream(args: ConverseStreamCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ConverseStreamCommandOutput) => void): void;
     /**
      * @see {@link InvokeModelCommand}
      */

package/dist-types/BedrockRuntimeClient.d.ts

@@ -8,6 +8,8 @@ import { HttpHandlerUserInput as __HttpHandlerUserInput } from "@smithy/protocol
 import { Client as __Client, DefaultsMode as __DefaultsMode, SmithyConfiguration as __SmithyConfiguration, SmithyResolvedConfiguration as __SmithyResolvedConfiguration } from "@smithy/smithy-client";
 import { AwsCredentialIdentityProvider, BodyLengthCalculator as __BodyLengthCalculator, CheckOptionalClientConfig as __CheckOptionalClientConfig, ChecksumConstructor as __ChecksumConstructor, Decoder as __Decoder, Encoder as __Encoder, EventStreamSerdeProvider as __EventStreamSerdeProvider, HashConstructor as __HashConstructor, HttpHandlerOptions as __HttpHandlerOptions, Logger as __Logger, Provider as __Provider, Provider, StreamCollector as __StreamCollector, UrlParser as __UrlParser, UserAgent as __UserAgent } from "@smithy/types";
 import { HttpAuthSchemeInputConfig, HttpAuthSchemeResolvedConfig } from "./auth/httpAuthSchemeProvider";
+import { ConverseCommandInput, ConverseCommandOutput } from "./commands/ConverseCommand";
+import { ConverseStreamCommandInput, ConverseStreamCommandOutput } from "./commands/ConverseStreamCommand";
 import { InvokeModelCommandInput, InvokeModelCommandOutput } from "./commands/InvokeModelCommand";
 import { InvokeModelWithResponseStreamCommandInput, InvokeModelWithResponseStreamCommandOutput } from "./commands/InvokeModelWithResponseStreamCommand";
 import { ClientInputEndpointParameters, ClientResolvedEndpointParameters, EndpointParameters } from "./endpoint/EndpointParameters";
@@ -16,11 +18,11 @@ export { __Client };
 /**
  * @public
  */
-export type ServiceInputTypes = InvokeModelCommandInput | InvokeModelWithResponseStreamCommandInput;
+export type ServiceInputTypes = ConverseCommandInput | ConverseStreamCommandInput | InvokeModelCommandInput | InvokeModelWithResponseStreamCommandInput;
 /**
  * @public
  */
-export type ServiceOutputTypes = InvokeModelCommandOutput | InvokeModelWithResponseStreamCommandOutput;
+export type ServiceOutputTypes = ConverseCommandOutput | ConverseStreamCommandOutput | InvokeModelCommandOutput | InvokeModelWithResponseStreamCommandOutput;
 /**
  * @public
  */