@aws-sdk/client-bedrock-agent-runtime 3.461.0

package/dist-es/models/models_0.js

@@ -0,0 +1,396 @@
+import { SENSITIVE_STRING } from "@smithy/smithy-client";
+import { BedrockAgentRuntimeServiceException as __BaseException } from "./BedrockAgentRuntimeServiceException";
+export class AccessDeniedException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "AccessDeniedException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "AccessDeniedException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, AccessDeniedException.prototype);
+    }
+}
+export class BadGatewayException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "BadGatewayException",
+            $fault: "server",
+            ...opts,
+        });
+        this.name = "BadGatewayException";
+        this.$fault = "server";
+        Object.setPrototypeOf(this, BadGatewayException.prototype);
+        this.resourceName = opts.resourceName;
+    }
+}
+export class ConflictException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ConflictException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ConflictException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ConflictException.prototype);
+    }
+}
+export class DependencyFailedException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "DependencyFailedException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "DependencyFailedException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, DependencyFailedException.prototype);
+        this.resourceName = opts.resourceName;
+    }
+}
+export class InternalServerException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "InternalServerException",
+            $fault: "server",
+            ...opts,
+        });
+        this.name = "InternalServerException";
+        this.$fault = "server";
+        Object.setPrototypeOf(this, InternalServerException.prototype);
+    }
+}
+export const RetrievalResultLocationType = {
+    S3: "S3",
+};
+export class ResourceNotFoundException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ResourceNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ResourceNotFoundException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
+    }
+}
+export class ServiceQuotaExceededException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ServiceQuotaExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ServiceQuotaExceededException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ServiceQuotaExceededException.prototype);
+    }
+}
+export class ThrottlingException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ThrottlingException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ThrottlingException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ThrottlingException.prototype);
+    }
+}
+export const InvocationType = {
+    ACTION_GROUP: "ACTION_GROUP",
+    FINISH: "FINISH",
+    KNOWLEDGE_BASE: "KNOWLEDGE_BASE",
+};
+export const CreationMode = {
+    DEFAULT: "DEFAULT",
+    OVERRIDDEN: "OVERRIDDEN",
+};
+export const PromptType = {
+    KNOWLEDGE_BASE_RESPONSE_GENERATION: "KNOWLEDGE_BASE_RESPONSE_GENERATION",
+    ORCHESTRATION: "ORCHESTRATION",
+    POST_PROCESSING: "POST_PROCESSING",
+    PRE_PROCESSING: "PRE_PROCESSING",
+};
+export const Source = {
+    ACTION_GROUP: "ACTION_GROUP",
+    KNOWLEDGE_BASE: "KNOWLEDGE_BASE",
+    PARSER: "PARSER",
+};
+export const Type = {
+    ACTION_GROUP: "ACTION_GROUP",
+    ASK_USER: "ASK_USER",
+    FINISH: "FINISH",
+    KNOWLEDGE_BASE: "KNOWLEDGE_BASE",
+    REPROMPT: "REPROMPT",
+};
+export var OrchestrationTrace;
+(function (OrchestrationTrace) {
+    OrchestrationTrace.visit = (value, visitor) => {
+        if (value.rationale !== undefined)
+            return visitor.rationale(value.rationale);
+        if (value.invocationInput !== undefined)
+            return visitor.invocationInput(value.invocationInput);
+        if (value.observation !== undefined)
+            return visitor.observation(value.observation);
+        if (value.modelInvocationInput !== undefined)
+            return visitor.modelInvocationInput(value.modelInvocationInput);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(OrchestrationTrace || (OrchestrationTrace = {}));
+export var PostProcessingTrace;
+(function (PostProcessingTrace) {
+    PostProcessingTrace.visit = (value, visitor) => {
+        if (value.modelInvocationInput !== undefined)
+            return visitor.modelInvocationInput(value.modelInvocationInput);
+        if (value.modelInvocationOutput !== undefined)
+            return visitor.modelInvocationOutput(value.modelInvocationOutput);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(PostProcessingTrace || (PostProcessingTrace = {}));
+export var PreProcessingTrace;
+(function (PreProcessingTrace) {
+    PreProcessingTrace.visit = (value, visitor) => {
+        if (value.modelInvocationInput !== undefined)
+            return visitor.modelInvocationInput(value.modelInvocationInput);
+        if (value.modelInvocationOutput !== undefined)
+            return visitor.modelInvocationOutput(value.modelInvocationOutput);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(PreProcessingTrace || (PreProcessingTrace = {}));
+export var Trace;
+(function (Trace) {
+    Trace.visit = (value, visitor) => {
+        if (value.preProcessingTrace !== undefined)
+            return visitor.preProcessingTrace(value.preProcessingTrace);
+        if (value.orchestrationTrace !== undefined)
+            return visitor.orchestrationTrace(value.orchestrationTrace);
+        if (value.postProcessingTrace !== undefined)
+            return visitor.postProcessingTrace(value.postProcessingTrace);
+        if (value.failureTrace !== undefined)
+            return visitor.failureTrace(value.failureTrace);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(Trace || (Trace = {}));
+export class ValidationException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ValidationException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ValidationException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ValidationException.prototype);
+    }
+}
+export var ResponseStream;
+(function (ResponseStream) {
+    ResponseStream.visit = (value, visitor) => {
+        if (value.chunk !== undefined)
+            return visitor.chunk(value.chunk);
+        if (value.trace !== undefined)
+            return visitor.trace(value.trace);
+        if (value.internalServerException !== undefined)
+            return visitor.internalServerException(value.internalServerException);
+        if (value.validationException !== undefined)
+            return visitor.validationException(value.validationException);
+        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.accessDeniedException !== undefined)
+            return visitor.accessDeniedException(value.accessDeniedException);
+        if (value.conflictException !== undefined)
+            return visitor.conflictException(value.conflictException);
+        if (value.dependencyFailedException !== undefined)
+            return visitor.dependencyFailedException(value.dependencyFailedException);
+        if (value.badGatewayException !== undefined)
+            return visitor.badGatewayException(value.badGatewayException);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(ResponseStream || (ResponseStream = {}));
+export const RetrieveAndGenerateType = {
+    KNOWLEDGE_BASE: "KNOWLEDGE_BASE",
+};
+export const ActionGroupInvocationInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.actionGroupName && { actionGroupName: SENSITIVE_STRING }),
+    ...(obj.verb && { verb: SENSITIVE_STRING }),
+    ...(obj.apiPath && { apiPath: SENSITIVE_STRING }),
+});
+export const ActionGroupInvocationOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.text && { text: SENSITIVE_STRING }),
+});
+export const InvokeAgentRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.inputText && { inputText: SENSITIVE_STRING }),
+});
+export const PayloadPartFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.bytes && { bytes: SENSITIVE_STRING }),
+});
+export const FailureTraceFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.failureReason && { failureReason: SENSITIVE_STRING }),
+});
+export const KnowledgeBaseLookupInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.text && { text: SENSITIVE_STRING }),
+    ...(obj.knowledgeBaseId && { knowledgeBaseId: SENSITIVE_STRING }),
+});
+export const InvocationInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.actionGroupInvocationInput && {
+        actionGroupInvocationInput: ActionGroupInvocationInputFilterSensitiveLog(obj.actionGroupInvocationInput),
+    }),
+    ...(obj.knowledgeBaseLookupInput && {
+        knowledgeBaseLookupInput: KnowledgeBaseLookupInputFilterSensitiveLog(obj.knowledgeBaseLookupInput),
+    }),
+});
+export const ModelInvocationInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.text && { text: SENSITIVE_STRING }),
+});
+export const FinalResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.text && { text: SENSITIVE_STRING }),
+});
+export const RepromptResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.source && { source: SENSITIVE_STRING }),
+});
+export const ObservationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.actionGroupInvocationOutput && {
+        actionGroupInvocationOutput: ActionGroupInvocationOutputFilterSensitiveLog(obj.actionGroupInvocationOutput),
+    }),
+    ...(obj.finalResponse && { finalResponse: FinalResponseFilterSensitiveLog(obj.finalResponse) }),
+    ...(obj.repromptResponse && { repromptResponse: SENSITIVE_STRING }),
+});
+export const RationaleFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.text && { text: SENSITIVE_STRING }),
+});
+export const OrchestrationTraceFilterSensitiveLog = (obj) => {
+    if (obj.rationale !== undefined)
+        return { rationale: SENSITIVE_STRING };
+    if (obj.invocationInput !== undefined)
+        return { invocationInput: SENSITIVE_STRING };
+    if (obj.observation !== undefined)
+        return { observation: SENSITIVE_STRING };
+    if (obj.modelInvocationInput !== undefined)
+        return { modelInvocationInput: SENSITIVE_STRING };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const PostProcessingParsedResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.text && { text: SENSITIVE_STRING }),
+});
+export const PostProcessingModelInvocationOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.parsedResponse && { parsedResponse: SENSITIVE_STRING }),
+});
+export const PostProcessingTraceFilterSensitiveLog = (obj) => {
+    if (obj.modelInvocationInput !== undefined)
+        return { modelInvocationInput: SENSITIVE_STRING };
+    if (obj.modelInvocationOutput !== undefined)
+        return { modelInvocationOutput: SENSITIVE_STRING };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const PreProcessingParsedResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.rationale && { rationale: SENSITIVE_STRING }),
+});
+export const PreProcessingModelInvocationOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.parsedResponse && { parsedResponse: SENSITIVE_STRING }),
+});
+export const PreProcessingTraceFilterSensitiveLog = (obj) => {
+    if (obj.modelInvocationInput !== undefined)
+        return { modelInvocationInput: SENSITIVE_STRING };
+    if (obj.modelInvocationOutput !== undefined)
+        return { modelInvocationOutput: SENSITIVE_STRING };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const TraceFilterSensitiveLog = (obj) => {
+    if (obj.preProcessingTrace !== undefined)
+        return { preProcessingTrace: SENSITIVE_STRING };
+    if (obj.orchestrationTrace !== undefined)
+        return { orchestrationTrace: SENSITIVE_STRING };
+    if (obj.postProcessingTrace !== undefined)
+        return { postProcessingTrace: SENSITIVE_STRING };
+    if (obj.failureTrace !== undefined)
+        return { failureTrace: SENSITIVE_STRING };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const TracePartFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.trace && { trace: SENSITIVE_STRING }),
+});
+export const ResponseStreamFilterSensitiveLog = (obj) => {
+    if (obj.chunk !== undefined)
+        return { chunk: SENSITIVE_STRING };
+    if (obj.trace !== undefined)
+        return { trace: SENSITIVE_STRING };
+    if (obj.internalServerException !== undefined)
+        return { internalServerException: obj.internalServerException };
+    if (obj.validationException !== undefined)
+        return { validationException: obj.validationException };
+    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.accessDeniedException !== undefined)
+        return { accessDeniedException: obj.accessDeniedException };
+    if (obj.conflictException !== undefined)
+        return { conflictException: obj.conflictException };
+    if (obj.dependencyFailedException !== undefined)
+        return { dependencyFailedException: obj.dependencyFailedException };
+    if (obj.badGatewayException !== undefined)
+        return { badGatewayException: obj.badGatewayException };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const InvokeAgentResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.completion && { completion: "STREAMING_CONTENT" }),
+});
+export const RetrieveAndGenerateInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const RetrieveAndGenerateRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.input && { input: SENSITIVE_STRING }),
+});
+export const RetrieveAndGenerateOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const RetrieveAndGenerateResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.output && { output: SENSITIVE_STRING }),
+});
+export const KnowledgeBaseQueryFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const RetrieveRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.retrievalQuery && { retrievalQuery: SENSITIVE_STRING }),
+});
+export const RetrieveResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.retrievalResults && { retrievalResults: SENSITIVE_STRING }),
+});

package/dist-es/pagination/Interfaces.js

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

package/dist-es/pagination/RetrievePaginator.js

@@ -0,0 +1,24 @@
+import { BedrockAgentRuntimeClient } from "../BedrockAgentRuntimeClient";
+import { RetrieveCommand } from "../commands/RetrieveCommand";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new RetrieveCommand(input), ...args);
+};
+export async function* paginateRetrieve(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        if (config.client instanceof BedrockAgentRuntimeClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected BedrockAgentRuntime | BedrockAgentRuntimeClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/index.js

@@ -0,0 +1,2 @@
+export * from "./Interfaces";
+export * from "./RetrievePaginator";