@aws/lsp-codewhisperer 0.0.58 → 0.0.59

package/node_modules/@amzn/codewhisperer-streaming/dist-es/protocols/Aws_restJson1.js

@@ -0,0 +1,677 @@
+import { CodeWhispererStreamingServiceException as __BaseException } from "../models/CodeWhispererStreamingServiceException";
+import { AccessDeniedException, ChatMessage, ConflictException, DryRunOperationException, ImageSource, InternalServerException, ResourceNotFoundException, ServiceQuotaExceededException, ThrottlingException, Tool, ToolResultContentBlock, ValidationException, } from "../models/models_0";
+import { awsExpectUnion as __expectUnion, loadRestJsonErrorCode, parseJsonBody as parseBody, parseJsonErrorBody as parseErrorBody, } from "@aws-sdk/core";
+import { requestBuilder as rb } from "@smithy/core";
+import { decorateServiceException as __decorateServiceException, expectString as __expectString, _json, collectBody, map, take, withBaseException, } from "@smithy/smithy-client";
+export const se_ExportResultArchiveCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        'content-type': 'application/json',
+    };
+    b.bp("/exportResultArchive");
+    let body;
+    body = JSON.stringify(take(input, {
+        'exportContext': _ => _json(_),
+        'exportId': [],
+        'exportIntent': [],
+        'profileArn': [],
+    }));
+    b.m("POST")
+        .h(headers)
+        .b(body);
+    return b.build();
+};
+export const se_GenerateAssistantResponseCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        'content-type': 'application/json',
+    };
+    b.bp("/generateAssistantResponse");
+    let body;
+    body = JSON.stringify(take(input, {
+        'conversationState': _ => se_ConversationState(_, context),
+        'profileArn': [],
+    }));
+    b.m("POST")
+        .h(headers)
+        .b(body);
+    return b.build();
+};
+export const se_GenerateTaskAssistPlanCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        'content-type': 'application/json',
+    };
+    b.bp("/generateTaskAssistPlan");
+    let body;
+    body = JSON.stringify(take(input, {
+        'conversationState': _ => se_ConversationState(_, context),
+        'profileArn': [],
+        'workspaceState': _ => _json(_),
+    }));
+    b.m("POST")
+        .h(headers)
+        .b(body);
+    return b.build();
+};
+export const se_SendMessageCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        'content-type': 'application/json',
+    };
+    b.bp("/SendMessageStreaming");
+    let body;
+    body = JSON.stringify(take(input, {
+        'conversationState': _ => se_ConversationState(_, context),
+        'dryRun': [],
+        'profileArn': [],
+        'source': [],
+    }));
+    b.m("POST")
+        .h(headers)
+        .b(body);
+    return b.build();
+};
+export const de_ExportResultArchiveCommand = 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.body = de_ResultArchiveStream(data, context);
+    return contents;
+};
+export const de_GenerateAssistantResponseCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+        [_cI]: [, output.headers[_xacci]],
+    });
+    const data = output.body;
+    contents.generateAssistantResponseResponse = de_ChatResponseStream(data, context);
+    return contents;
+};
+export const de_GenerateTaskAssistPlanCommand = 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.planningResponseStream = de_ChatResponseStream(data, context);
+    return contents;
+};
+export const de_SendMessageCommand = 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.sendMessageResponse = de_ChatResponseStream(data, context);
+    return contents;
+};
+const de_CommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context)
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazon.aws.codewhisperer#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazon.aws.codewhisperer#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazon.aws.codewhisperer#InternalServerException":
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazon.aws.codewhisperer#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazon.aws.codewhisperer#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazon.aws.codewhisperer#ValidationException":
+            throw await de_ValidationExceptionRes(parsedOutput, context);
+        case "ServiceQuotaExceededException":
+        case "com.amazon.aws.codewhisperer#ServiceQuotaExceededException":
+            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+        case "DryRunOperationException":
+        case "com.amazon.aws.codewhisperer#DryRunOperationException":
+            throw await de_DryRunOperationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode
+            });
+    }
+};
+const throwDefaultError = withBaseException(__BaseException);
+const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        'message': __expectString,
+        'reason': __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new AccessDeniedException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_ConflictExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        'message': __expectString,
+        'reason': __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new ConflictException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_DryRunOperationExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        'message': __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new DryRunOperationException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_InternalServerExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        'message': __expectString,
+        'reason': __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new InternalServerException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        'message': __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new ResourceNotFoundException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_ServiceQuotaExceededExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        'message': __expectString,
+        'reason': __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new ServiceQuotaExceededException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_ThrottlingExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        'message': __expectString,
+        'reason': __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new ThrottlingException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_ValidationExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        'message': __expectString,
+        'reason': __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new ValidationException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_ChatResponseStream = (output, context) => {
+    return context.eventStreamMarshaller.deserialize(output, async (event) => {
+        if (event["messageMetadataEvent"] != null) {
+            return {
+                messageMetadataEvent: await de_MessageMetadataEvent_event(event["messageMetadataEvent"], context),
+            };
+        }
+        if (event["assistantResponseEvent"] != null) {
+            return {
+                assistantResponseEvent: await de_AssistantResponseEvent_event(event["assistantResponseEvent"], context),
+            };
+        }
+        if (event["dryRunSucceedEvent"] != null) {
+            return {
+                dryRunSucceedEvent: await de_DryRunSucceedEvent_event(event["dryRunSucceedEvent"], context),
+            };
+        }
+        if (event["codeReferenceEvent"] != null) {
+            return {
+                codeReferenceEvent: await de_CodeReferenceEvent_event(event["codeReferenceEvent"], context),
+            };
+        }
+        if (event["supplementaryWebLinksEvent"] != null) {
+            return {
+                supplementaryWebLinksEvent: await de_SupplementaryWebLinksEvent_event(event["supplementaryWebLinksEvent"], context),
+            };
+        }
+        if (event["followupPromptEvent"] != null) {
+            return {
+                followupPromptEvent: await de_FollowupPromptEvent_event(event["followupPromptEvent"], context),
+            };
+        }
+        if (event["codeEvent"] != null) {
+            return {
+                codeEvent: await de_CodeEvent_event(event["codeEvent"], context),
+            };
+        }
+        if (event["intentsEvent"] != null) {
+            return {
+                intentsEvent: await de_IntentsEvent_event(event["intentsEvent"], context),
+            };
+        }
+        if (event["interactionComponentsEvent"] != null) {
+            return {
+                interactionComponentsEvent: await de_InteractionComponentsEvent_event(event["interactionComponentsEvent"], context),
+            };
+        }
+        if (event["toolUseEvent"] != null) {
+            return {
+                toolUseEvent: await de_ToolUseEvent_event(event["toolUseEvent"], context),
+            };
+        }
+        if (event["toolResultEvent"] != null) {
+            return {
+                toolResultEvent: await de_ToolResultEvent_event(event["toolResultEvent"], context),
+            };
+        }
+        if (event["citationEvent"] != null) {
+            return {
+                citationEvent: await de_CitationEvent_event(event["citationEvent"], context),
+            };
+        }
+        if (event["invalidStateEvent"] != null) {
+            return {
+                invalidStateEvent: await de_InvalidStateEvent_event(event["invalidStateEvent"], context),
+            };
+        }
+        if (event["error"] != null) {
+            return {
+                error: await de_InternalServerException_event(event["error"], context),
+            };
+        }
+        return { $unknown: output };
+    });
+};
+const de_ResultArchiveStream = (output, context) => {
+    return context.eventStreamMarshaller.deserialize(output, async (event) => {
+        if (event["binaryMetadataEvent"] != null) {
+            return {
+                binaryMetadataEvent: await de_BinaryMetadataEvent_event(event["binaryMetadataEvent"], context),
+            };
+        }
+        if (event["binaryPayloadEvent"] != null) {
+            return {
+                binaryPayloadEvent: await de_BinaryPayloadEvent_event(event["binaryPayloadEvent"], context),
+            };
+        }
+        if (event["internalServerException"] != null) {
+            return {
+                internalServerException: await de_InternalServerException_event(event["internalServerException"], context),
+            };
+        }
+        return { $unknown: output };
+    });
+};
+const de_AssistantResponseEvent_event = async (output, context) => {
+    const contents = {};
+    const data = await parseBody(output.body, context);
+    Object.assign(contents, _json(data));
+    return contents;
+};
+const de_BinaryMetadataEvent_event = async (output, context) => {
+    const contents = {};
+    const data = await parseBody(output.body, context);
+    Object.assign(contents, _json(data));
+    return contents;
+};
+const de_BinaryPayloadEvent_event = async (output, context) => {
+    const contents = {};
+    const data = await parseBody(output.body, context);
+    Object.assign(contents, de_BinaryPayloadEvent(data, context));
+    return contents;
+};
+const de_CitationEvent_event = async (output, context) => {
+    const contents = {};
+    const data = await parseBody(output.body, context);
+    Object.assign(contents, _json(data));
+    return contents;
+};
+const de_CodeEvent_event = async (output, context) => {
+    const contents = {};
+    const data = await parseBody(output.body, context);
+    Object.assign(contents, _json(data));
+    return contents;
+};
+const de_CodeReferenceEvent_event = async (output, context) => {
+    const contents = {};
+    const data = await parseBody(output.body, context);
+    Object.assign(contents, _json(data));
+    return contents;
+};
+const de_DryRunSucceedEvent_event = async (output, context) => {
+    const contents = {};
+    const data = await parseBody(output.body, context);
+    Object.assign(contents, _json(data));
+    return contents;
+};
+const de_FollowupPromptEvent_event = async (output, context) => {
+    const contents = {};
+    const data = await parseBody(output.body, context);
+    Object.assign(contents, _json(data));
+    return contents;
+};
+const de_IntentsEvent_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,
+        body: await parseBody(output.body, context)
+    };
+    return de_InternalServerExceptionRes(parsedOutput, context);
+};
+const de_InvalidStateEvent_event = async (output, context) => {
+    const contents = {};
+    const data = await parseBody(output.body, context);
+    Object.assign(contents, _json(data));
+    return contents;
+};
+const de_MessageMetadataEvent_event = async (output, context) => {
+    const contents = {};
+    const data = await parseBody(output.body, context);
+    Object.assign(contents, _json(data));
+    return contents;
+};
+const de_SupplementaryWebLinksEvent_event = async (output, context) => {
+    const contents = {};
+    const data = await parseBody(output.body, context);
+    Object.assign(contents, _json(data));
+    return contents;
+};
+const de_ToolResultEvent_event = async (output, context) => {
+    const contents = {};
+    const data = await parseBody(output.body, context);
+    Object.assign(contents, de_ToolResultEvent(data, context));
+    return contents;
+};
+const de_ToolUseEvent_event = async (output, context) => {
+    const contents = {};
+    const data = await parseBody(output.body, context);
+    Object.assign(contents, _json(data));
+    return contents;
+};
+const de_InteractionComponentsEvent_event = async (output, context) => {
+    const contents = {};
+    const data = await parseBody(output.body, context);
+    Object.assign(contents, de_InteractionComponentsEvent(data, context));
+    return contents;
+};
+const se_AssistantResponseMessage = (input, context) => {
+    return take(input, {
+        'content': [],
+        'followupPrompt': _json,
+        'messageId': [],
+        'references': _json,
+        'supplementaryWebLinks': _json,
+        'toolUses': _ => se_ToolUses(_, context),
+    });
+};
+const se_ChatHistory = (input, context) => {
+    return input.filter((e) => e != null).map(entry => {
+        return se_ChatMessage(entry, context);
+    });
+};
+const se_ChatMessage = (input, context) => {
+    return ChatMessage.visit(input, {
+        assistantResponseMessage: value => ({ "assistantResponseMessage": se_AssistantResponseMessage(value, context) }),
+        userInputMessage: value => ({ "userInputMessage": se_UserInputMessage(value, context) }),
+        _: (name, value) => ({ name: value })
+    });
+};
+const se_ConversationState = (input, context) => {
+    return take(input, {
+        'chatTriggerType': [],
+        'conversationId': [],
+        'currentMessage': _ => se_ChatMessage(_, context),
+        'customizationArn': [],
+        'history': _ => se_ChatHistory(_, context),
+        'workspaceId': [],
+    });
+};
+const se_ImageBlock = (input, context) => {
+    return take(input, {
+        'format': [],
+        'source': _ => se_ImageSource(_, context),
+    });
+};
+const se_ImageBlocks = (input, context) => {
+    return input.filter((e) => e != null).map(entry => {
+        return se_ImageBlock(entry, context);
+    });
+};
+const se_ImageSource = (input, context) => {
+    return ImageSource.visit(input, {
+        bytes: value => ({ "bytes": context.base64Encoder(value) }),
+        _: (name, value) => ({ name: value })
+    });
+};
+const se_SensitiveDocument = (input, context) => {
+    return input;
+};
+const se_Tool = (input, context) => {
+    return Tool.visit(input, {
+        toolSpecification: value => ({ "toolSpecification": se_ToolSpecification(value, context) }),
+        _: (name, value) => ({ name: value })
+    });
+};
+const se_ToolInputSchema = (input, context) => {
+    return take(input, {
+        'json': _ => se_SensitiveDocument(_, context),
+    });
+};
+const se_ToolResult = (input, context) => {
+    return take(input, {
+        'content': _ => se_ToolResultContent(_, context),
+        'status': [],
+        'toolUseId': [],
+    });
+};
+const se_ToolResultContent = (input, context) => {
+    return input.filter((e) => e != null).map(entry => {
+        return se_ToolResultContentBlock(entry, context);
+    });
+};
+const se_ToolResultContentBlock = (input, context) => {
+    return ToolResultContentBlock.visit(input, {
+        json: value => ({ "json": se_SensitiveDocument(value, context) }),
+        text: value => ({ "text": value }),
+        _: (name, value) => ({ name: value })
+    });
+};
+const se_ToolResults = (input, context) => {
+    return input.filter((e) => e != null).map(entry => {
+        return se_ToolResult(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_ToolUse = (input, context) => {
+    return take(input, {
+        'input': _ => se_SensitiveDocument(_, context),
+        'name': [],
+        'toolUseId': [],
+    });
+};
+const se_ToolUses = (input, context) => {
+    return input.filter((e) => e != null).map(entry => {
+        return se_ToolUse(entry, context);
+    });
+};
+const se_UserInputMessage = (input, context) => {
+    return take(input, {
+        'content': [],
+        'images': _ => se_ImageBlocks(_, context),
+        'modelId': [],
+        'origin': [],
+        'userInputMessageContext': _ => se_UserInputMessageContext(_, context),
+        'userIntent': [],
+    });
+};
+const se_UserInputMessageContext = (input, context) => {
+    return take(input, {
+        'additionalContext': _json,
+        'appStudioContext': _json,
+        'consoleState': _json,
+        'diagnostic': _json,
+        'editorState': _json,
+        'envState': _json,
+        'gitState': _json,
+        'shellState': _json,
+        'toolResults': _ => se_ToolResults(_, context),
+        'tools': _ => se_Tools(_, context),
+        'userSettings': _json,
+    });
+};
+const de_BinaryPayloadEvent = (output, context) => {
+    return take(output, {
+        'bytes': context.base64Decoder,
+    });
+};
+const de_SensitiveDocument = (output, context) => {
+    return output;
+};
+const de_ToolResult = (output, context) => {
+    return take(output, {
+        'content': (_) => de_ToolResultContent(_, context),
+        'status': __expectString,
+        'toolUseId': __expectString,
+    });
+};
+const de_ToolResultContent = (output, context) => {
+    const retVal = (output || []).filter((e) => e != null).map((entry) => {
+        return de_ToolResultContentBlock(__expectUnion(entry), context);
+    });
+    return retVal;
+};
+const de_ToolResultContentBlock = (output, context) => {
+    if (output.json != null) {
+        return {
+            json: de_SensitiveDocument(output.json, context)
+        };
+    }
+    if (__expectString(output.text) !== undefined) {
+        return { text: __expectString(output.text) };
+    }
+    return { $unknown: Object.entries(output)[0] };
+};
+const de_ToolResultEvent = (output, context) => {
+    return take(output, {
+        'toolResult': (_) => de_ToolResult(_, context),
+    });
+};
+const de_InteractionComponentsEvent = (output, context) => {
+    return take(output, {
+        'interactionComponentEntries': (_) => de_InteractionComponentEntryList(_, context),
+    });
+};
+const de_InteractionComponent = (output, context) => {
+    return take(output, {
+        'action': _json,
+        'alert': _json,
+        'infrastructureUpdate': _json,
+        'progress': _json,
+        'resource': _json,
+        'resourceList': _json,
+        'section': _json,
+        'step': _json,
+        'suggestions': _json,
+        'taskDetails': _json,
+        'taskReference': _json,
+        'text': _json,
+    });
+};
+const de_InteractionComponentEntry = (output, context) => {
+    return take(output, {
+        'interactionComponent': (_) => de_InteractionComponent(_, context),
+        'interactionComponentId': __expectString,
+    });
+};
+const de_InteractionComponentEntryList = (output, context) => {
+    const retVal = (output || []).filter((e) => e != null).map((entry) => {
+        return de_InteractionComponentEntry(entry, context);
+    });
+    return retVal;
+};
+const deserializeMetadata = (output) => ({
+    httpStatusCode: output.statusCode,
+    requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
+    extendedRequestId: output.headers["x-amz-id-2"],
+    cfId: output.headers["x-amz-cf-id"],
+});
+const collectBodyString = (streamBody, context) => collectBody(streamBody, context).then(body => context.utf8Encoder(body));
+const _cI = "conversationId";
+const _xacci = "x-amzn-codewhisperer-conversation-id";