@aws-sdk/client-bedrock-agentcore 3.847.0

package/dist-es/protocols/Aws_restJson1.js

@@ -0,0 +1,1367 @@
+import { awsExpectUnion as __expectUnion, loadRestJsonErrorCode, parseJsonBody as parseBody, parseJsonErrorBody as parseErrorBody, } from "@aws-sdk/core";
+import { requestBuilder as rb } from "@smithy/core";
+import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, isSerializableHeaderValue, limitedParseDouble as __limitedParseDouble, map, parseEpochTimestamp as __parseEpochTimestamp, parseRfc3339DateTimeWithOffset as __parseRfc3339DateTimeWithOffset, take, withBaseException, } from "@smithy/smithy-client";
+import { v4 as generateIdempotencyToken } from "uuid";
+import { BedrockAgentCoreServiceException as __BaseException } from "../models/BedrockAgentCoreServiceException";
+import { AccessDeniedException, ConflictException, InternalServerException, InvalidInputException, PayloadType, ResourceNotFoundException, RuntimeClientError, ServiceException, ServiceQuotaExceededException, ThrottledException, ThrottlingException, UnauthorizedException, ValidationException, } from "../models/models_0";
+export const se_CreateEventCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/memories/{memoryId}/events");
+    b.p("memoryId", () => input.memoryId, "{memoryId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        actorId: [],
+        branch: (_) => _json(_),
+        clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
+        eventTimestamp: (_) => _.getTime() / 1_000,
+        payload: (_) => se_PayloadTypeList(_, context),
+        sessionId: [],
+    }));
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
+export const se_DeleteEventCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/memories/{memoryId}/actor/{actorId}/sessions/{sessionId}/events/{eventId}");
+    b.p("memoryId", () => input.memoryId, "{memoryId}", false);
+    b.p("sessionId", () => input.sessionId, "{sessionId}", false);
+    b.p("eventId", () => input.eventId, "{eventId}", false);
+    b.p("actorId", () => input.actorId, "{actorId}", false);
+    let body;
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
+};
+export const se_DeleteMemoryRecordCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/memories/{memoryId}/memoryRecords/{memoryRecordId}");
+    b.p("memoryId", () => input.memoryId, "{memoryId}", false);
+    b.p("memoryRecordId", () => input.memoryRecordId, "{memoryRecordId}", false);
+    let body;
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
+};
+export const se_GetBrowserSessionCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/browsers/{browserIdentifier}/sessions/get");
+    b.p("browserIdentifier", () => input.browserIdentifier, "{browserIdentifier}", false);
+    const query = map({
+        [_sI]: [, __expectNonNull(input[_sI], `sessionId`)],
+    });
+    let body;
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
+};
+export const se_GetCodeInterpreterSessionCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/code-interpreters/{codeInterpreterIdentifier}/sessions/get");
+    b.p("codeInterpreterIdentifier", () => input.codeInterpreterIdentifier, "{codeInterpreterIdentifier}", false);
+    const query = map({
+        [_sI]: [, __expectNonNull(input[_sI], `sessionId`)],
+    });
+    let body;
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
+};
+export const se_GetEventCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/memories/{memoryId}/actor/{actorId}/sessions/{sessionId}/events/{eventId}");
+    b.p("memoryId", () => input.memoryId, "{memoryId}", false);
+    b.p("sessionId", () => input.sessionId, "{sessionId}", false);
+    b.p("actorId", () => input.actorId, "{actorId}", false);
+    b.p("eventId", () => input.eventId, "{eventId}", false);
+    let body;
+    b.m("GET").h(headers).b(body);
+    return b.build();
+};
+export const se_GetMemoryRecordCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/memories/{memoryId}/memoryRecord/{memoryRecordId}");
+    b.p("memoryId", () => input.memoryId, "{memoryId}", false);
+    b.p("memoryRecordId", () => input.memoryRecordId, "{memoryRecordId}", false);
+    let body;
+    b.m("GET").h(headers).b(body);
+    return b.build();
+};
+export const se_GetResourceApiKeyCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/identities/api-key");
+    let body;
+    body = JSON.stringify(take(input, {
+        resourceCredentialProviderName: [],
+        workloadIdentityToken: [],
+    }));
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
+export const se_GetResourceOauth2TokenCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/identities/oauth2/token");
+    let body;
+    body = JSON.stringify(take(input, {
+        customParameters: (_) => _json(_),
+        forceAuthentication: [],
+        oauth2Flow: [],
+        resourceCredentialProviderName: [],
+        resourceOauth2ReturnUrl: [],
+        scopes: (_) => _json(_),
+        userId: [],
+        workloadIdentityToken: [],
+    }));
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
+export const se_GetWorkloadAccessTokenCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/identities/GetWorkloadAccessToken");
+    let body;
+    body = JSON.stringify(take(input, {
+        workloadName: [],
+    }));
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
+export const se_GetWorkloadAccessTokenForJWTCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/identities/GetWorkloadAccessTokenForJWT");
+    let body;
+    body = JSON.stringify(take(input, {
+        userToken: [],
+        workloadName: [],
+    }));
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
+export const se_GetWorkloadAccessTokenForUserIdCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/identities/GetWorkloadAccessTokenForUserId");
+    let body;
+    body = JSON.stringify(take(input, {
+        userId: [],
+        workloadName: [],
+    }));
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
+export const se_InvokeAgentRuntimeCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = map({}, isSerializableHeaderValue, {
+        [_ct]: input[_cT] || "application/octet-stream",
+        [_a]: input[_a],
+        [_msi]: input[_mSI],
+        [_xabarsi]: input[_rSI] ?? generateIdempotencyToken(),
+        [_mpv]: input[_mPV],
+        [_xabarui]: input[_rUI],
+        [_xati]: input[_tI],
+        [_t]: input[_tP],
+        [_tr]: input[_tS],
+        [_b]: input[_b],
+    });
+    b.bp("/runtimes/{agentRuntimeArn}/invocations");
+    b.p("agentRuntimeArn", () => input.agentRuntimeArn, "{agentRuntimeArn}", false);
+    const query = map({
+        [_q]: [, input[_q]],
+    });
+    let body;
+    if (input.payload !== undefined) {
+        body = input.payload;
+    }
+    b.m("POST").h(headers).q(query).b(body);
+    return b.build();
+};
+export const se_InvokeCodeInterpreterCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = map({}, isSerializableHeaderValue, {
+        "content-type": "application/json",
+        [_xacisi]: input[_sI],
+    });
+    b.bp("/code-interpreters/{codeInterpreterIdentifier}/tools/invoke");
+    b.p("codeInterpreterIdentifier", () => input.codeInterpreterIdentifier, "{codeInterpreterIdentifier}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        arguments: (_) => se_ToolArguments(_, context),
+        name: [],
+    }));
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
+export const se_ListActorsCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/memories/{memoryId}/actors");
+    b.p("memoryId", () => input.memoryId, "{memoryId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        maxResults: [],
+        nextToken: [],
+    }));
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
+export const se_ListBrowserSessionsCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/browsers/{browserIdentifier}/sessions/list");
+    b.p("browserIdentifier", () => input.browserIdentifier, "{browserIdentifier}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        maxResults: [],
+        nextToken: [],
+        status: [],
+    }));
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
+export const se_ListCodeInterpreterSessionsCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/code-interpreters/{codeInterpreterIdentifier}/sessions/list");
+    b.p("codeInterpreterIdentifier", () => input.codeInterpreterIdentifier, "{codeInterpreterIdentifier}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        maxResults: [],
+        nextToken: [],
+        status: [],
+    }));
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
+export const se_ListEventsCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/memories/{memoryId}/actor/{actorId}/sessions/{sessionId}");
+    b.p("memoryId", () => input.memoryId, "{memoryId}", false);
+    b.p("sessionId", () => input.sessionId, "{sessionId}", false);
+    b.p("actorId", () => input.actorId, "{actorId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        filter: (_) => _json(_),
+        includePayloads: [],
+        maxResults: [],
+        nextToken: [],
+    }));
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
+export const se_ListMemoryRecordsCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/memories/{memoryId}/memoryRecords");
+    b.p("memoryId", () => input.memoryId, "{memoryId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        maxResults: [],
+        memoryStrategyId: [],
+        namespace: [],
+        nextToken: [],
+    }));
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
+export const se_ListSessionsCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/memories/{memoryId}/actor/{actorId}/sessions");
+    b.p("memoryId", () => input.memoryId, "{memoryId}", false);
+    b.p("actorId", () => input.actorId, "{actorId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        maxResults: [],
+        nextToken: [],
+    }));
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
+export const se_RetrieveMemoryRecordsCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/memories/{memoryId}/retrieve");
+    b.p("memoryId", () => input.memoryId, "{memoryId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        maxResults: [],
+        namespace: [],
+        nextToken: [],
+        searchCriteria: (_) => _json(_),
+    }));
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
+export const se_StartBrowserSessionCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/browsers/{browserIdentifier}/sessions/start");
+    b.p("browserIdentifier", () => input.browserIdentifier, "{browserIdentifier}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
+        name: [],
+        sessionTimeoutSeconds: [],
+        viewPort: (_) => _json(_),
+    }));
+    b.m("PUT").h(headers).b(body);
+    return b.build();
+};
+export const se_StartCodeInterpreterSessionCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/code-interpreters/{codeInterpreterIdentifier}/sessions/start");
+    b.p("codeInterpreterIdentifier", () => input.codeInterpreterIdentifier, "{codeInterpreterIdentifier}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
+        name: [],
+        sessionTimeoutSeconds: [],
+    }));
+    b.m("PUT").h(headers).b(body);
+    return b.build();
+};
+export const se_StopBrowserSessionCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/browsers/{browserIdentifier}/sessions/stop");
+    b.p("browserIdentifier", () => input.browserIdentifier, "{browserIdentifier}", false);
+    const query = map({
+        [_sI]: [, __expectNonNull(input[_sI], `sessionId`)],
+    });
+    let body;
+    body = JSON.stringify(take(input, {
+        clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
+    }));
+    b.m("PUT").h(headers).q(query).b(body);
+    return b.build();
+};
+export const se_StopCodeInterpreterSessionCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/code-interpreters/{codeInterpreterIdentifier}/sessions/stop");
+    b.p("codeInterpreterIdentifier", () => input.codeInterpreterIdentifier, "{codeInterpreterIdentifier}", false);
+    const query = map({
+        [_sI]: [, __expectNonNull(input[_sI], `sessionId`)],
+    });
+    let body;
+    body = JSON.stringify(take(input, {
+        clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
+    }));
+    b.m("PUT").h(headers).q(query).b(body);
+    return b.build();
+};
+export const se_UpdateBrowserStreamCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/browsers/{browserIdentifier}/sessions/streams/update");
+    b.p("browserIdentifier", () => input.browserIdentifier, "{browserIdentifier}", false);
+    const query = map({
+        [_sI]: [, __expectNonNull(input[_sI], `sessionId`)],
+    });
+    let body;
+    body = JSON.stringify(take(input, {
+        clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
+        streamUpdate: (_) => _json(_),
+    }));
+    b.m("PUT").h(headers).q(query).b(body);
+    return b.build();
+};
+export const de_CreateEventCommand = 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, {
+        event: (_) => de_Event(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_DeleteEventCommand = 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, {
+        eventId: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_DeleteMemoryRecordCommand = 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, {
+        memoryRecordId: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_GetBrowserSessionCommand = 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, {
+        browserIdentifier: __expectString,
+        createdAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        lastUpdatedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        name: __expectString,
+        sessionId: __expectString,
+        sessionReplayArtifact: __expectString,
+        sessionTimeoutSeconds: __expectInt32,
+        status: __expectString,
+        streams: _json,
+        viewPort: _json,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_GetCodeInterpreterSessionCommand = 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, {
+        codeInterpreterIdentifier: __expectString,
+        createdAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        name: __expectString,
+        sessionId: __expectString,
+        sessionTimeoutSeconds: __expectInt32,
+        status: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_GetEventCommand = 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, {
+        event: (_) => de_Event(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_GetMemoryRecordCommand = 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, {
+        memoryRecord: (_) => de_MemoryRecord(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_GetResourceApiKeyCommand = 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, {
+        apiKey: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_GetResourceOauth2TokenCommand = 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, {
+        accessToken: __expectString,
+        authorizationUrl: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_GetWorkloadAccessTokenCommand = 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, {
+        workloadAccessToken: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_GetWorkloadAccessTokenForJWTCommand = 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, {
+        workloadAccessToken: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_GetWorkloadAccessTokenForUserIdCommand = 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, {
+        workloadAccessToken: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_InvokeAgentRuntimeCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+        [_rSI]: [, output.headers[_xabarsi]],
+        [_mSI]: [, output.headers[_msi]],
+        [_mPV]: [, output.headers[_mpv]],
+        [_tI]: [, output.headers[_xati]],
+        [_tP]: [, output.headers[_t]],
+        [_tS]: [, output.headers[_tr]],
+        [_b]: [, output.headers[_b]],
+        [_cT]: [, output.headers[_ct]],
+    });
+    const data = output.body;
+    context.sdkStreamMixin(data);
+    contents.response = data;
+    map(contents, {
+        statusCode: [, output.statusCode],
+    });
+    return contents;
+};
+export const de_InvokeCodeInterpreterCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+        [_sI]: [, output.headers[_xacisi]],
+    });
+    const data = output.body;
+    contents.stream = de_CodeInterpreterStreamOutput(data, context);
+    return contents;
+};
+export const de_ListActorsCommand = 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, {
+        actorSummaries: _json,
+        nextToken: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_ListBrowserSessionsCommand = 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, {
+        items: (_) => de_BrowserSessionSummaries(_, context),
+        nextToken: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_ListCodeInterpreterSessionsCommand = 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, {
+        items: (_) => de_CodeInterpreterSessionSummaries(_, context),
+        nextToken: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_ListEventsCommand = 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, {
+        events: (_) => de_EventList(_, context),
+        nextToken: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_ListMemoryRecordsCommand = 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, {
+        memoryRecordSummaries: (_) => de_MemoryRecordSummaryList(_, context),
+        nextToken: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_ListSessionsCommand = 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, {
+        nextToken: __expectString,
+        sessionSummaries: (_) => de_SessionSummaryList(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_RetrieveMemoryRecordsCommand = 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, {
+        memoryRecordSummaries: (_) => de_MemoryRecordSummaryList(_, context),
+        nextToken: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_StartBrowserSessionCommand = 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, {
+        browserIdentifier: __expectString,
+        createdAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        sessionId: __expectString,
+        streams: _json,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_StartCodeInterpreterSessionCommand = 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, {
+        codeInterpreterIdentifier: __expectString,
+        createdAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        sessionId: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_StopBrowserSessionCommand = 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, {
+        browserIdentifier: __expectString,
+        lastUpdatedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        sessionId: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_StopCodeInterpreterSessionCommand = 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, {
+        codeInterpreterIdentifier: __expectString,
+        lastUpdatedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        sessionId: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_UpdateBrowserStreamCommand = 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, {
+        browserIdentifier: __expectString,
+        sessionId: __expectString,
+        streams: _json,
+        updatedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+    });
+    Object.assign(contents, doc);
+    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.amazonaws.bedrockagentcore#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "InvalidInputException":
+        case "com.amazonaws.bedrockagentcore#InvalidInputException":
+            throw await de_InvalidInputExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.bedrockagentcore#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ServiceException":
+        case "com.amazonaws.bedrockagentcore#ServiceException":
+            throw await de_ServiceExceptionRes(parsedOutput, context);
+        case "ServiceQuotaExceededException":
+        case "com.amazonaws.bedrockagentcore#ServiceQuotaExceededException":
+            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+        case "ThrottledException":
+        case "com.amazonaws.bedrockagentcore#ThrottledException":
+            throw await de_ThrottledExceptionRes(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.bedrockagentcore#ValidationException":
+            throw await de_ValidationExceptionRes(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.bedrockagentcore#InternalServerException":
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.bedrockagentcore#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
+        case "UnauthorizedException":
+        case "com.amazonaws.bedrockagentcore#UnauthorizedException":
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
+        case "RuntimeClientError":
+        case "com.amazonaws.bedrockagentcore#RuntimeClientError":
+            throw await de_RuntimeClientErrorRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.bedrockagentcore#ConflictException":
+            throw await de_ConflictExceptionRes(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,
+    });
+    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,
+    });
+    Object.assign(contents, doc);
+    const exception = new ConflictException({
+        $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,
+    });
+    Object.assign(contents, doc);
+    const exception = new InternalServerException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_InvalidInputExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        message: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new InvalidInputException({
+        $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_RuntimeClientErrorRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        message: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new RuntimeClientError({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_ServiceExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        message: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new ServiceException({
+        $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,
+    });
+    Object.assign(contents, doc);
+    const exception = new ServiceQuotaExceededException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_ThrottledExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        message: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new ThrottledException({
+        $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,
+    });
+    Object.assign(contents, doc);
+    const exception = new ThrottlingException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_UnauthorizedExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        message: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new UnauthorizedException({
+        $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, {
+        fieldList: _json,
+        message: __expectString,
+        reason: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new ValidationException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_CodeInterpreterStreamOutput = (output, context) => {
+    return context.eventStreamMarshaller.deserialize(output, async (event) => {
+        if (event["result"] != null) {
+            return {
+                result: await de_CodeInterpreterResult_event(event["result"], context),
+            };
+        }
+        if (event["accessDeniedException"] != null) {
+            return {
+                accessDeniedException: await de_AccessDeniedException_event(event["accessDeniedException"], context),
+            };
+        }
+        if (event["conflictException"] != null) {
+            return {
+                conflictException: await de_ConflictException_event(event["conflictException"], context),
+            };
+        }
+        if (event["internalServerException"] != null) {
+            return {
+                internalServerException: await de_InternalServerException_event(event["internalServerException"], context),
+            };
+        }
+        if (event["resourceNotFoundException"] != null) {
+            return {
+                resourceNotFoundException: await de_ResourceNotFoundException_event(event["resourceNotFoundException"], context),
+            };
+        }
+        if (event["serviceQuotaExceededException"] != null) {
+            return {
+                serviceQuotaExceededException: await de_ServiceQuotaExceededException_event(event["serviceQuotaExceededException"], context),
+            };
+        }
+        if (event["throttlingException"] != null) {
+            return {
+                throttlingException: await de_ThrottlingException_event(event["throttlingException"], context),
+            };
+        }
+        if (event["validationException"] != null) {
+            return {
+                validationException: await de_ValidationException_event(event["validationException"], context),
+            };
+        }
+        return { $unknown: event };
+    });
+};
+const de_AccessDeniedException_event = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    return de_AccessDeniedExceptionRes(parsedOutput, context);
+};
+const de_CodeInterpreterResult_event = async (output, context) => {
+    const contents = {};
+    const data = await parseBody(output.body, context);
+    Object.assign(contents, de_CodeInterpreterResult(data, context));
+    return contents;
+};
+const de_ConflictException_event = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    return de_ConflictExceptionRes(parsedOutput, context);
+};
+const de_InternalServerException_event = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    return de_InternalServerExceptionRes(parsedOutput, context);
+};
+const de_ResourceNotFoundException_event = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    return de_ResourceNotFoundExceptionRes(parsedOutput, context);
+};
+const de_ServiceQuotaExceededException_event = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    return de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+};
+const de_ThrottlingException_event = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    return de_ThrottlingExceptionRes(parsedOutput, context);
+};
+const de_ValidationException_event = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    return de_ValidationExceptionRes(parsedOutput, context);
+};
+const se_Document = (input, context) => {
+    return input;
+};
+const se_InputContentBlock = (input, context) => {
+    return take(input, {
+        blob: context.base64Encoder,
+        path: [],
+        text: [],
+    });
+};
+const se_InputContentBlockList = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return se_InputContentBlock(entry, context);
+    });
+};
+const se_PayloadType = (input, context) => {
+    return PayloadType.visit(input, {
+        blob: (value) => ({ blob: se_Document(value, context) }),
+        conversational: (value) => ({ conversational: _json(value) }),
+        _: (name, value) => ({ [name]: value }),
+    });
+};
+const se_PayloadTypeList = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return se_PayloadType(entry, context);
+    });
+};
+const se_ToolArguments = (input, context) => {
+    return take(input, {
+        clearContext: [],
+        code: [],
+        command: [],
+        content: (_) => se_InputContentBlockList(_, context),
+        directoryPath: [],
+        language: [],
+        path: [],
+        paths: _json,
+        taskId: [],
+    });
+};
+const de_BrowserSessionSummaries = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_BrowserSessionSummary(entry, context);
+    });
+    return retVal;
+};
+const de_BrowserSessionSummary = (output, context) => {
+    return take(output, {
+        browserIdentifier: __expectString,
+        createdAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        lastUpdatedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        name: __expectString,
+        sessionId: __expectString,
+        status: __expectString,
+    });
+};
+const de_CodeInterpreterResult = (output, context) => {
+    return take(output, {
+        content: (_) => de_ContentBlockList(_, context),
+        isError: __expectBoolean,
+        structuredContent: (_) => de_ToolResultStructuredContent(_, context),
+    });
+};
+const de_CodeInterpreterSessionSummaries = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_CodeInterpreterSessionSummary(entry, context);
+    });
+    return retVal;
+};
+const de_CodeInterpreterSessionSummary = (output, context) => {
+    return take(output, {
+        codeInterpreterIdentifier: __expectString,
+        createdAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        lastUpdatedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        name: __expectString,
+        sessionId: __expectString,
+        status: __expectString,
+    });
+};
+const de_ContentBlock = (output, context) => {
+    return take(output, {
+        data: context.base64Decoder,
+        description: __expectString,
+        mimeType: __expectString,
+        name: __expectString,
+        resource: (_) => de_ResourceContent(_, context),
+        size: __expectLong,
+        text: __expectString,
+        type: __expectString,
+        uri: __expectString,
+    });
+};
+const de_ContentBlockList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_ContentBlock(entry, context);
+    });
+    return retVal;
+};
+const de_Document = (output, context) => {
+    return output;
+};
+const de_Event = (output, context) => {
+    return take(output, {
+        actorId: __expectString,
+        branch: _json,
+        eventId: __expectString,
+        eventTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        memoryId: __expectString,
+        payload: (_) => de_PayloadTypeList(_, context),
+        sessionId: __expectString,
+    });
+};
+const de_EventList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_Event(entry, context);
+    });
+    return retVal;
+};
+const de_MemoryRecord = (output, context) => {
+    return take(output, {
+        content: (_) => _json(__expectUnion(_)),
+        createdAt: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        memoryRecordId: __expectString,
+        memoryStrategyId: __expectString,
+        namespaces: _json,
+    });
+};
+const de_MemoryRecordSummary = (output, context) => {
+    return take(output, {
+        content: (_) => _json(__expectUnion(_)),
+        createdAt: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        memoryRecordId: __expectString,
+        memoryStrategyId: __expectString,
+        namespaces: _json,
+        score: __limitedParseDouble,
+    });
+};
+const de_MemoryRecordSummaryList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_MemoryRecordSummary(entry, context);
+    });
+    return retVal;
+};
+const de_PayloadType = (output, context) => {
+    if (output.blob != null) {
+        return {
+            blob: de_Document(output.blob, context),
+        };
+    }
+    if (output.conversational != null) {
+        return {
+            conversational: _json(output.conversational),
+        };
+    }
+    return { $unknown: Object.entries(output)[0] };
+};
+const de_PayloadTypeList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_PayloadType(__expectUnion(entry), context);
+    });
+    return retVal;
+};
+const de_ResourceContent = (output, context) => {
+    return take(output, {
+        blob: context.base64Decoder,
+        mimeType: __expectString,
+        text: __expectString,
+        type: __expectString,
+        uri: __expectString,
+    });
+};
+const de_SessionSummary = (output, context) => {
+    return take(output, {
+        actorId: __expectString,
+        createdAt: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        sessionId: __expectString,
+    });
+};
+const de_SessionSummaryList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_SessionSummary(entry, context);
+    });
+    return retVal;
+};
+const de_ToolResultStructuredContent = (output, context) => {
+    return take(output, {
+        executionTime: __limitedParseDouble,
+        exitCode: __expectInt32,
+        stderr: __expectString,
+        stdout: __expectString,
+        taskId: __expectString,
+        taskStatus: __expectString,
+    });
+};
+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 _a = "accept";
+const _b = "baggage";
+const _cT = "contentType";
+const _ct = "content-type";
+const _mPV = "mcpProtocolVersion";
+const _mSI = "mcpSessionId";
+const _mpv = "mcp-protocol-version";
+const _msi = "mcp-session-id";
+const _q = "qualifier";
+const _rSI = "runtimeSessionId";
+const _rUI = "runtimeUserId";
+const _sI = "sessionId";
+const _t = "traceparent";
+const _tI = "traceId";
+const _tP = "traceParent";
+const _tS = "traceState";
+const _tr = "tracestate";
+const _xabarsi = "x-amzn-bedrock-agentcore-runtime-session-id";
+const _xabarui = "x-amzn-bedrock-agentcore-runtime-user-id";
+const _xacisi = "x-amzn-code-interpreter-session-id";
+const _xati = "x-amzn-trace-id";