@aws-sdk/client-bedrock-agentcore 3.847.0

package/dist-es/models/models_0.js

@@ -0,0 +1,421 @@
+import { SENSITIVE_STRING } from "@smithy/smithy-client";
+import { BedrockAgentCoreServiceException as __BaseException } from "./BedrockAgentCoreServiceException";
+export class AccessDeniedException extends __BaseException {
+    name = "AccessDeniedException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "AccessDeniedException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, AccessDeniedException.prototype);
+    }
+}
+export class InternalServerException extends __BaseException {
+    name = "InternalServerException";
+    $fault = "server";
+    constructor(opts) {
+        super({
+            name: "InternalServerException",
+            $fault: "server",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InternalServerException.prototype);
+    }
+}
+export class ResourceNotFoundException extends __BaseException {
+    name = "ResourceNotFoundException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ResourceNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
+    }
+}
+export class RuntimeClientError extends __BaseException {
+    name = "RuntimeClientError";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "RuntimeClientError",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, RuntimeClientError.prototype);
+    }
+}
+export class ServiceQuotaExceededException extends __BaseException {
+    name = "ServiceQuotaExceededException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ServiceQuotaExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ServiceQuotaExceededException.prototype);
+    }
+}
+export class ThrottlingException extends __BaseException {
+    name = "ThrottlingException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ThrottlingException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ThrottlingException.prototype);
+    }
+}
+export const ValidationExceptionReason = {
+    CANNOT_PARSE: "CannotParse",
+    FIELD_VALIDATION_FAILED: "FieldValidationFailed",
+    IDEMPOTENT_PARAMETER_MISMATCH_EXCEPTION: "IdempotentParameterMismatchException",
+    RESOURCE_CONFLICT: "ResourceConflict",
+    ROOT_EVENT_IN_OTHER_SESSION: "EventInOtherSession",
+};
+export class ValidationException extends __BaseException {
+    name = "ValidationException";
+    $fault = "client";
+    reason;
+    fieldList;
+    constructor(opts) {
+        super({
+            name: "ValidationException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ValidationException.prototype);
+        this.reason = opts.reason;
+        this.fieldList = opts.fieldList;
+    }
+}
+export const BrowserSessionStatus = {
+    READY: "READY",
+    TERMINATED: "TERMINATED",
+};
+export const AutomationStreamStatus = {
+    DISABLED: "DISABLED",
+    ENABLED: "ENABLED",
+};
+export class ConflictException extends __BaseException {
+    name = "ConflictException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ConflictException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ConflictException.prototype);
+    }
+}
+export var StreamUpdate;
+(function (StreamUpdate) {
+    StreamUpdate.visit = (value, visitor) => {
+        if (value.automationStreamUpdate !== undefined)
+            return visitor.automationStreamUpdate(value.automationStreamUpdate);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(StreamUpdate || (StreamUpdate = {}));
+export const CodeInterpreterSessionStatus = {
+    READY: "READY",
+    TERMINATED: "TERMINATED",
+};
+export class UnauthorizedException extends __BaseException {
+    name = "UnauthorizedException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "UnauthorizedException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, UnauthorizedException.prototype);
+    }
+}
+export const Oauth2FlowType = {
+    M2M: "M2M",
+    USER_FEDERATION: "USER_FEDERATION",
+};
+export const ProgrammingLanguage = {
+    JAVASCRIPT: "javascript",
+    PYTHON: "python",
+    TYPESCRIPT: "typescript",
+};
+export const ToolName = {
+    EXECUTE_CODE: "executeCode",
+    EXECUTE_COMMAND: "executeCommand",
+    GET_TASK: "getTask",
+    LIST_FILES: "listFiles",
+    READ_FILES: "readFiles",
+    REMOVE_FILES: "removeFiles",
+    START_COMMAND_EXECUTION: "startCommandExecution",
+    STOP_TASK: "stopTask",
+    WRITE_FILES: "writeFiles",
+};
+export const ResourceContentType = {
+    BLOB: "blob",
+    TEXT: "text",
+};
+export const ContentBlockType = {
+    EMBEDDED_RESOURCE: "resource",
+    IMAGE: "image",
+    RESOURCE_LINK: "resource_link",
+    TEXT: "text",
+};
+export const TaskStatus = {
+    CANCELED: "canceled",
+    COMPLETED: "completed",
+    FAILED: "failed",
+    SUBMITTED: "submitted",
+    WORKING: "working",
+};
+export var CodeInterpreterStreamOutput;
+(function (CodeInterpreterStreamOutput) {
+    CodeInterpreterStreamOutput.visit = (value, visitor) => {
+        if (value.result !== undefined)
+            return visitor.result(value.result);
+        if (value.accessDeniedException !== undefined)
+            return visitor.accessDeniedException(value.accessDeniedException);
+        if (value.conflictException !== undefined)
+            return visitor.conflictException(value.conflictException);
+        if (value.internalServerException !== undefined)
+            return visitor.internalServerException(value.internalServerException);
+        if (value.resourceNotFoundException !== undefined)
+            return visitor.resourceNotFoundException(value.resourceNotFoundException);
+        if (value.serviceQuotaExceededException !== undefined)
+            return visitor.serviceQuotaExceededException(value.serviceQuotaExceededException);
+        if (value.throttlingException !== undefined)
+            return visitor.throttlingException(value.throttlingException);
+        if (value.validationException !== undefined)
+            return visitor.validationException(value.validationException);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(CodeInterpreterStreamOutput || (CodeInterpreterStreamOutput = {}));
+export var Content;
+(function (Content) {
+    Content.visit = (value, visitor) => {
+        if (value.text !== undefined)
+            return visitor.text(value.text);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(Content || (Content = {}));
+export const Role = {
+    ASSISTANT: "ASSISTANT",
+    OTHER: "OTHER",
+    TOOL: "TOOL",
+    USER: "USER",
+};
+export var PayloadType;
+(function (PayloadType) {
+    PayloadType.visit = (value, visitor) => {
+        if (value.conversational !== undefined)
+            return visitor.conversational(value.conversational);
+        if (value.blob !== undefined)
+            return visitor.blob(value.blob);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(PayloadType || (PayloadType = {}));
+export class InvalidInputException extends __BaseException {
+    name = "InvalidInputException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidInputException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidInputException.prototype);
+    }
+}
+export class ServiceException extends __BaseException {
+    name = "ServiceException";
+    $fault = "server";
+    constructor(opts) {
+        super({
+            name: "ServiceException",
+            $fault: "server",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ServiceException.prototype);
+    }
+}
+export class ThrottledException extends __BaseException {
+    name = "ThrottledException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ThrottledException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ThrottledException.prototype);
+    }
+}
+export var MemoryContent;
+(function (MemoryContent) {
+    MemoryContent.visit = (value, visitor) => {
+        if (value.text !== undefined)
+            return visitor.text(value.text);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(MemoryContent || (MemoryContent = {}));
+export const InvokeAgentRuntimeRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.payload && { payload: SENSITIVE_STRING }),
+});
+export const InvokeAgentRuntimeResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.response && { response: SENSITIVE_STRING }),
+});
+export const GetResourceApiKeyRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.workloadIdentityToken && { workloadIdentityToken: SENSITIVE_STRING }),
+});
+export const GetResourceApiKeyResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.apiKey && { apiKey: SENSITIVE_STRING }),
+});
+export const GetResourceOauth2TokenRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.workloadIdentityToken && { workloadIdentityToken: SENSITIVE_STRING }),
+    ...(obj.customParameters && { customParameters: SENSITIVE_STRING }),
+});
+export const GetResourceOauth2TokenResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.accessToken && { accessToken: SENSITIVE_STRING }),
+});
+export const GetWorkloadAccessTokenResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.workloadAccessToken && { workloadAccessToken: SENSITIVE_STRING }),
+});
+export const GetWorkloadAccessTokenForJWTRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.userToken && { userToken: SENSITIVE_STRING }),
+});
+export const GetWorkloadAccessTokenForJWTResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.workloadAccessToken && { workloadAccessToken: SENSITIVE_STRING }),
+});
+export const GetWorkloadAccessTokenForUserIdResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.workloadAccessToken && { workloadAccessToken: SENSITIVE_STRING }),
+});
+export const InputContentBlockFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.blob && { blob: SENSITIVE_STRING }),
+});
+export const ToolArgumentsFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.content && { content: obj.content.map((item) => InputContentBlockFilterSensitiveLog(item)) }),
+});
+export const InvokeCodeInterpreterRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.arguments && { arguments: ToolArgumentsFilterSensitiveLog(obj.arguments) }),
+});
+export const CodeInterpreterStreamOutputFilterSensitiveLog = (obj) => {
+    if (obj.result !== undefined)
+        return { result: obj.result };
+    if (obj.accessDeniedException !== undefined)
+        return { accessDeniedException: obj.accessDeniedException };
+    if (obj.conflictException !== undefined)
+        return { conflictException: obj.conflictException };
+    if (obj.internalServerException !== undefined)
+        return { internalServerException: obj.internalServerException };
+    if (obj.resourceNotFoundException !== undefined)
+        return { resourceNotFoundException: obj.resourceNotFoundException };
+    if (obj.serviceQuotaExceededException !== undefined)
+        return { serviceQuotaExceededException: obj.serviceQuotaExceededException };
+    if (obj.throttlingException !== undefined)
+        return { throttlingException: obj.throttlingException };
+    if (obj.validationException !== undefined)
+        return { validationException: obj.validationException };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const InvokeCodeInterpreterResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.stream && { stream: "STREAMING_CONTENT" }),
+});
+export const ContentFilterSensitiveLog = (obj) => {
+    if (obj.text !== undefined)
+        return { text: SENSITIVE_STRING };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const ConversationalFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.content && { content: ContentFilterSensitiveLog(obj.content) }),
+});
+export const PayloadTypeFilterSensitiveLog = (obj) => {
+    if (obj.conversational !== undefined)
+        return { conversational: ConversationalFilterSensitiveLog(obj.conversational) };
+    if (obj.blob !== undefined)
+        return { blob: obj.blob };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const CreateEventInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.payload && { payload: obj.payload.map((item) => PayloadTypeFilterSensitiveLog(item)) }),
+});
+export const EventFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.payload && { payload: obj.payload.map((item) => PayloadTypeFilterSensitiveLog(item)) }),
+});
+export const CreateEventOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.event && { event: EventFilterSensitiveLog(obj.event) }),
+});
+export const GetEventOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.event && { event: EventFilterSensitiveLog(obj.event) }),
+});
+export const MemoryContentFilterSensitiveLog = (obj) => {
+    if (obj.text !== undefined)
+        return { text: SENSITIVE_STRING };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const MemoryRecordFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.content && { content: MemoryContentFilterSensitiveLog(obj.content) }),
+});
+export const GetMemoryRecordOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.memoryRecord && { memoryRecord: MemoryRecordFilterSensitiveLog(obj.memoryRecord) }),
+});
+export const ListEventsOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.events && { events: obj.events.map((item) => EventFilterSensitiveLog(item)) }),
+});
+export const MemoryRecordSummaryFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.content && { content: MemoryContentFilterSensitiveLog(obj.content) }),
+});
+export const ListMemoryRecordsOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.memoryRecordSummaries && {
+        memoryRecordSummaries: obj.memoryRecordSummaries.map((item) => MemoryRecordSummaryFilterSensitiveLog(item)),
+    }),
+});
+export const SearchCriteriaFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.searchQuery && { searchQuery: SENSITIVE_STRING }),
+});
+export const RetrieveMemoryRecordsInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.searchCriteria && { searchCriteria: SearchCriteriaFilterSensitiveLog(obj.searchCriteria) }),
+});
+export const RetrieveMemoryRecordsOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.memoryRecordSummaries && {
+        memoryRecordSummaries: obj.memoryRecordSummaries.map((item) => MemoryRecordSummaryFilterSensitiveLog(item)),
+    }),
+});

package/dist-es/pagination/Interfaces.js

@@ -0,0 +1 @@
+export {};

package/dist-es/pagination/ListActorsPaginator.js

@@ -0,0 +1,4 @@
+import { createPaginator } from "@smithy/core";
+import { BedrockAgentCoreClient } from "../BedrockAgentCoreClient";
+import { ListActorsCommand } from "../commands/ListActorsCommand";
+export const paginateListActors = createPaginator(BedrockAgentCoreClient, ListActorsCommand, "nextToken", "nextToken", "maxResults");

package/dist-es/pagination/ListEventsPaginator.js

@@ -0,0 +1,4 @@
+import { createPaginator } from "@smithy/core";
+import { BedrockAgentCoreClient } from "../BedrockAgentCoreClient";
+import { ListEventsCommand } from "../commands/ListEventsCommand";
+export const paginateListEvents = createPaginator(BedrockAgentCoreClient, ListEventsCommand, "nextToken", "nextToken", "maxResults");

package/dist-es/pagination/ListMemoryRecordsPaginator.js

@@ -0,0 +1,4 @@
+import { createPaginator } from "@smithy/core";
+import { BedrockAgentCoreClient } from "../BedrockAgentCoreClient";
+import { ListMemoryRecordsCommand, } from "../commands/ListMemoryRecordsCommand";
+export const paginateListMemoryRecords = createPaginator(BedrockAgentCoreClient, ListMemoryRecordsCommand, "nextToken", "nextToken", "maxResults");

package/dist-es/pagination/ListSessionsPaginator.js

@@ -0,0 +1,4 @@
+import { createPaginator } from "@smithy/core";
+import { BedrockAgentCoreClient } from "../BedrockAgentCoreClient";
+import { ListSessionsCommand, } from "../commands/ListSessionsCommand";
+export const paginateListSessions = createPaginator(BedrockAgentCoreClient, ListSessionsCommand, "nextToken", "nextToken", "maxResults");

package/dist-es/pagination/RetrieveMemoryRecordsPaginator.js

@@ -0,0 +1,4 @@
+import { createPaginator } from "@smithy/core";
+import { BedrockAgentCoreClient } from "../BedrockAgentCoreClient";
+import { RetrieveMemoryRecordsCommand, } from "../commands/RetrieveMemoryRecordsCommand";
+export const paginateRetrieveMemoryRecords = createPaginator(BedrockAgentCoreClient, RetrieveMemoryRecordsCommand, "nextToken", "nextToken", "maxResults");

package/dist-es/pagination/index.js

@@ -0,0 +1,6 @@
+export * from "./Interfaces";
+export * from "./ListActorsPaginator";
+export * from "./ListEventsPaginator";
+export * from "./ListMemoryRecordsPaginator";
+export * from "./ListSessionsPaginator";
+export * from "./RetrieveMemoryRecordsPaginator";