@aws-sdk/client-bedrock-agent-runtime 3.697.0 → 3.701.0

package/dist-es/BedrockAgentRuntime.js

@@ -4,6 +4,7 @@ import { DeleteAgentMemoryCommand, } from "./commands/DeleteAgentMemoryCommand";
 import { GetAgentMemoryCommand, } from "./commands/GetAgentMemoryCommand";
 import { InvokeAgentCommand } from "./commands/InvokeAgentCommand";
 import { InvokeFlowCommand } from "./commands/InvokeFlowCommand";
+import { InvokeInlineAgentCommand, } from "./commands/InvokeInlineAgentCommand";
 import { OptimizePromptCommand, } from "./commands/OptimizePromptCommand";
 import { RetrieveAndGenerateCommand, } from "./commands/RetrieveAndGenerateCommand";
 import { RetrieveCommand } from "./commands/RetrieveCommand";
@@ -12,6 +13,7 @@ const commands = {
     GetAgentMemoryCommand,
     InvokeAgentCommand,
     InvokeFlowCommand,
+    InvokeInlineAgentCommand,
     OptimizePromptCommand,
     RetrieveCommand,
     RetrieveAndGenerateCommand,

package/dist-es/commands/InvokeInlineAgentCommand.js

@@ -0,0 +1,27 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { commonParams } from "../endpoint/EndpointParameters";
+import { InvokeInlineAgentRequestFilterSensitiveLog, InvokeInlineAgentResponseFilterSensitiveLog, } from "../models/models_0";
+import { de_InvokeInlineAgentCommand, se_InvokeInlineAgentCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class InvokeInlineAgentCommand extends $Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonBedrockAgentRunTimeService", "InvokeInlineAgent", {
+    eventStream: {
+        output: true,
+    },
+})
+    .n("BedrockAgentRuntimeClient", "InvokeInlineAgentCommand")
+    .f(InvokeInlineAgentRequestFilterSensitiveLog, InvokeInlineAgentResponseFilterSensitiveLog)
+    .ser(se_InvokeInlineAgentCommand)
+    .de(de_InvokeInlineAgentCommand)
+    .build() {
+}

package/dist-es/commands/index.js

@@ -2,6 +2,7 @@ export * from "./DeleteAgentMemoryCommand";
 export * from "./GetAgentMemoryCommand";
 export * from "./InvokeAgentCommand";
 export * from "./InvokeFlowCommand";
+export * from "./InvokeInlineAgentCommand";
 export * from "./OptimizePromptCommand";
 export * from "./RetrieveAndGenerateCommand";
 export * from "./RetrieveCommand";

package/dist-es/models/models_0.js

@@ -12,15 +12,61 @@ export class AccessDeniedException extends __BaseException {
         Object.setPrototypeOf(this, AccessDeniedException.prototype);
     }
 }
+export const CustomControlMethod = {
+    RETURN_CONTROL: "RETURN_CONTROL",
+};
+export var ActionGroupExecutor;
+(function (ActionGroupExecutor) {
+    ActionGroupExecutor.visit = (value, visitor) => {
+        if (value.lambda !== undefined)
+            return visitor.lambda(value.lambda);
+        if (value.customControl !== undefined)
+            return visitor.customControl(value.customControl);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(ActionGroupExecutor || (ActionGroupExecutor = {}));
 export const ExecutionType = {
     LAMBDA: "LAMBDA",
     RETURN_CONTROL: "RETURN_CONTROL",
 };
+export const ActionGroupSignature = {
+    AMAZON_CODEINTERPRETER: "AMAZON.CodeInterpreter",
+    AMAZON_USERINPUT: "AMAZON.UserInput",
+};
 export const ActionInvocationType = {
     RESULT: "RESULT",
     USER_CONFIRMATION: "USER_CONFIRMATION",
     USER_CONFIRMATION_AND_RESULT: "USER_CONFIRMATION_AND_RESULT",
 };
+export var APISchema;
+(function (APISchema) {
+    APISchema.visit = (value, visitor) => {
+        if (value.s3 !== undefined)
+            return visitor.s3(value.s3);
+        if (value.payload !== undefined)
+            return visitor.payload(value.payload);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(APISchema || (APISchema = {}));
+export const ParameterType = {
+    ARRAY: "array",
+    BOOLEAN: "boolean",
+    INTEGER: "integer",
+    NUMBER: "number",
+    STRING: "string",
+};
+export const RequireConfirmation = {
+    DISABLED: "DISABLED",
+    ENABLED: "ENABLED",
+};
+export var FunctionSchema;
+(function (FunctionSchema) {
+    FunctionSchema.visit = (value, visitor) => {
+        if (value.functions !== undefined)
+            return visitor.functions(value.functions);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(FunctionSchema || (FunctionSchema = {}));
 export class BadGatewayException extends __BaseException {
     constructor(opts) {
         super({
@@ -337,6 +383,7 @@ export const PromptType = {
     ORCHESTRATION: "ORCHESTRATION",
     POST_PROCESSING: "POST_PROCESSING",
     PRE_PROCESSING: "PRE_PROCESSING",
+    ROUTING_CLASSIFIER: "ROUTING_CLASSIFIER",
 };
 export const Source = {
     ACTION_GROUP: "ACTION_GROUP",
@@ -399,6 +446,8 @@ export var Trace;
             return visitor.postProcessingTrace(value.postProcessingTrace);
         if (value.failureTrace !== undefined)
             return visitor.failureTrace(value.failureTrace);
+        if (value.customOrchestrationTrace !== undefined)
+            return visitor.customOrchestrationTrace(value.customOrchestrationTrace);
         return visitor._(value.$unknown[0], value.$unknown[1]);
     };
 })(Trace || (Trace = {}));
@@ -434,6 +483,42 @@ export var ResponseStream;
         return visitor._(value.$unknown[0], value.$unknown[1]);
     };
 })(ResponseStream || (ResponseStream = {}));
+export const PromptState = {
+    DISABLED: "DISABLED",
+    ENABLED: "ENABLED",
+};
+export var InlineAgentResponseStream;
+(function (InlineAgentResponseStream) {
+    InlineAgentResponseStream.visit = (value, visitor) => {
+        if (value.chunk !== undefined)
+            return visitor.chunk(value.chunk);
+        if (value.trace !== undefined)
+            return visitor.trace(value.trace);
+        if (value.returnControl !== undefined)
+            return visitor.returnControl(value.returnControl);
+        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);
+        if (value.files !== undefined)
+            return visitor.files(value.files);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(InlineAgentResponseStream || (InlineAgentResponseStream = {}));
 export const MemoryType = {
     SESSION_SUMMARY: "SESSION_SUMMARY",
 };
@@ -541,6 +626,32 @@ export const ActionGroupInvocationOutputFilterSensitiveLog = (obj) => ({
     ...obj,
     ...(obj.text && { text: SENSITIVE_STRING }),
 });
+export const APISchemaFilterSensitiveLog = (obj) => {
+    if (obj.s3 !== undefined)
+        return { s3: obj.s3 };
+    if (obj.payload !== undefined)
+        return { payload: SENSITIVE_STRING };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const FunctionDefinitionFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.name && { name: SENSITIVE_STRING }),
+});
+export const FunctionSchemaFilterSensitiveLog = (obj) => {
+    if (obj.functions !== undefined)
+        return { functions: obj.functions.map((item) => FunctionDefinitionFilterSensitiveLog(item)) };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const AgentActionGroupFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.actionGroupName && { actionGroupName: SENSITIVE_STRING }),
+    ...(obj.description && { description: SENSITIVE_STRING }),
+    ...(obj.actionGroupExecutor && { actionGroupExecutor: obj.actionGroupExecutor }),
+    ...(obj.apiSchema && { apiSchema: APISchemaFilterSensitiveLog(obj.apiSchema) }),
+    ...(obj.functionSchema && { functionSchema: FunctionSchemaFilterSensitiveLog(obj.functionSchema) }),
+});
 export const FlowInputContentFilterSensitiveLog = (obj) => {
     if (obj.document !== undefined)
         return { document: obj.document };
@@ -724,6 +835,13 @@ export const ReturnControlPayloadFilterSensitiveLog = (obj) => ({
         invocationInputs: obj.invocationInputs.map((item) => InvocationInputMemberFilterSensitiveLog(item)),
     }),
 });
+export const CustomOrchestrationTraceEventFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const CustomOrchestrationTraceFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.event && { event: SENSITIVE_STRING }),
+});
 export const FailureTraceFilterSensitiveLog = (obj) => ({
     ...obj,
     ...(obj.failureReason && { failureReason: SENSITIVE_STRING }),
@@ -899,6 +1017,8 @@ export const TraceFilterSensitiveLog = (obj) => {
         return { postProcessingTrace: SENSITIVE_STRING };
     if (obj.failureTrace !== undefined)
         return { failureTrace: SENSITIVE_STRING };
+    if (obj.customOrchestrationTrace !== undefined)
+        return { customOrchestrationTrace: SENSITIVE_STRING };
     if (obj.$unknown !== undefined)
         return { [obj.$unknown[0]]: "UNKNOWN" };
 };
@@ -940,6 +1060,76 @@ export const InvokeAgentResponseFilterSensitiveLog = (obj) => ({
     ...obj,
     ...(obj.completion && { completion: "STREAMING_CONTENT" }),
 });
+export const InlineSessionStateFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.returnControlInvocationResults && {
+        returnControlInvocationResults: obj.returnControlInvocationResults.map((item) => InvocationResultMemberFilterSensitiveLog(item)),
+    }),
+    ...(obj.files && { files: obj.files.map((item) => InputFileFilterSensitiveLog(item)) }),
+});
+export const PromptConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.basePromptTemplate && { basePromptTemplate: SENSITIVE_STRING }),
+});
+export const PromptOverrideConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.promptConfigurations && {
+        promptConfigurations: obj.promptConfigurations.map((item) => PromptConfigurationFilterSensitiveLog(item)),
+    }),
+});
+export const InlineAgentPayloadPartFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.bytes && { bytes: SENSITIVE_STRING }),
+    ...(obj.attribution && { attribution: AttributionFilterSensitiveLog(obj.attribution) }),
+});
+export const InlineAgentFilePartFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.files && { files: SENSITIVE_STRING }),
+});
+export const InlineAgentReturnControlPayloadFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.invocationInputs && {
+        invocationInputs: obj.invocationInputs.map((item) => InvocationInputMemberFilterSensitiveLog(item)),
+    }),
+});
+export const InlineAgentTracePartFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.trace && { trace: SENSITIVE_STRING }),
+});
+export const InlineAgentResponseStreamFilterSensitiveLog = (obj) => {
+    if (obj.chunk !== undefined)
+        return { chunk: SENSITIVE_STRING };
+    if (obj.trace !== undefined)
+        return { trace: SENSITIVE_STRING };
+    if (obj.returnControl !== undefined)
+        return { returnControl: 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.files !== undefined)
+        return { files: InlineAgentFilePartFilterSensitiveLog(obj.files) };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const InvokeInlineAgentResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.completion && { completion: "STREAMING_CONTENT" }),
+});
 export const TextPromptFilterSensitiveLog = (obj) => ({
     ...obj,
 });
@@ -1086,6 +1276,13 @@ export const KnowledgeBaseRetrievalConfigurationFilterSensitiveLog = (obj) => ({
         vectorSearchConfiguration: KnowledgeBaseVectorSearchConfigurationFilterSensitiveLog(obj.vectorSearchConfiguration),
     }),
 });
+export const KnowledgeBaseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.description && { description: SENSITIVE_STRING }),
+    ...(obj.retrievalConfiguration && {
+        retrievalConfiguration: KnowledgeBaseRetrievalConfigurationFilterSensitiveLog(obj.retrievalConfiguration),
+    }),
+});
 export const KnowledgeBaseConfigurationFilterSensitiveLog = (obj) => ({
     ...obj,
     ...(obj.retrievalConfiguration && {
@@ -1120,6 +1317,17 @@ export const RetrieveAndGenerateConfigurationFilterSensitiveLog = (obj) => ({
         externalSourcesConfiguration: ExternalSourcesRetrieveAndGenerateConfigurationFilterSensitiveLog(obj.externalSourcesConfiguration),
     }),
 });
+export const InvokeInlineAgentRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.inputText && { inputText: SENSITIVE_STRING }),
+    ...(obj.inlineSessionState && { inlineSessionState: InlineSessionStateFilterSensitiveLog(obj.inlineSessionState) }),
+    ...(obj.instruction && { instruction: SENSITIVE_STRING }),
+    ...(obj.actionGroups && { actionGroups: obj.actionGroups.map((item) => AgentActionGroupFilterSensitiveLog(item)) }),
+    ...(obj.knowledgeBases && {
+        knowledgeBases: obj.knowledgeBases.map((item) => KnowledgeBaseFilterSensitiveLog(item)),
+    }),
+    ...(obj.promptOverrideConfiguration && { promptOverrideConfiguration: SENSITIVE_STRING }),
+});
 export const RetrieveAndGenerateRequestFilterSensitiveLog = (obj) => ({
     ...obj,
     ...(obj.input && { input: SENSITIVE_STRING }),

package/dist-es/protocols/Aws_restJson1.js

@@ -48,6 +48,7 @@ export const se_InvokeAgentCommand = async (input, context) => {
         inputText: [],
         memoryId: [],
         sessionState: (_) => se_SessionState(_, context),
+        streamingConfigurations: (_) => _json(_),
     }));
     b.m("POST").h(headers).b(body);
     return b.build();
@@ -68,6 +69,31 @@ export const se_InvokeFlowCommand = async (input, context) => {
     b.m("POST").h(headers).b(body);
     return b.build();
 };
+export const se_InvokeInlineAgentCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/agents/{sessionId}");
+    b.p("sessionId", () => input.sessionId, "{sessionId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        actionGroups: (_) => _json(_),
+        customerEncryptionKeyArn: [],
+        enableTrace: [],
+        endSession: [],
+        foundationModel: [],
+        guardrailConfiguration: (_) => _json(_),
+        idleSessionTTLInSeconds: [],
+        inlineSessionState: (_) => se_InlineSessionState(_, context),
+        inputText: [],
+        instruction: [],
+        knowledgeBases: (_) => se_KnowledgeBases(_, context),
+        promptOverrideConfiguration: (_) => se_PromptOverrideConfiguration(_, context),
+    }));
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
 export const se_OptimizePromptCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {
@@ -164,6 +190,19 @@ export const de_InvokeFlowCommand = async (output, context) => {
     contents.responseStream = de_FlowResponseStream(data, context);
     return contents;
 };
+export const de_InvokeInlineAgentCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+        [_cT]: [, output.headers[_xabact]],
+        [_sI]: [, output.headers[_xabasi]],
+    });
+    const data = output.body;
+    contents.completion = de_InlineAgentResponseStream(data, context);
+    return contents;
+};
 export const de_OptimizePromptCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -435,6 +474,76 @@ const de_FlowResponseStream = (output, context) => {
         return { $unknown: output };
     });
 };
+const de_InlineAgentResponseStream = (output, context) => {
+    return context.eventStreamMarshaller.deserialize(output, async (event) => {
+        if (event["chunk"] != null) {
+            return {
+                chunk: await de_InlineAgentPayloadPart_event(event["chunk"], context),
+            };
+        }
+        if (event["trace"] != null) {
+            return {
+                trace: await de_InlineAgentTracePart_event(event["trace"], context),
+            };
+        }
+        if (event["returnControl"] != null) {
+            return {
+                returnControl: await de_InlineAgentReturnControlPayload_event(event["returnControl"], context),
+            };
+        }
+        if (event["internalServerException"] != null) {
+            return {
+                internalServerException: await de_InternalServerException_event(event["internalServerException"], context),
+            };
+        }
+        if (event["validationException"] != null) {
+            return {
+                validationException: await de_ValidationException_event(event["validationException"], 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["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["dependencyFailedException"] != null) {
+            return {
+                dependencyFailedException: await de_DependencyFailedException_event(event["dependencyFailedException"], context),
+            };
+        }
+        if (event["badGatewayException"] != null) {
+            return {
+                badGatewayException: await de_BadGatewayException_event(event["badGatewayException"], context),
+            };
+        }
+        if (event["files"] != null) {
+            return {
+                files: await de_InlineAgentFilePart_event(event["files"], context),
+            };
+        }
+        return { $unknown: output };
+    });
+};
 const de_OptimizedPromptStream = (output, context) => {
     return context.eventStreamMarshaller.deserialize(output, async (event) => {
         if (event["optimizedPromptEvent"] != null) {
@@ -608,6 +717,30 @@ const de_FlowTraceEvent_event = async (output, context) => {
     Object.assign(contents, de_FlowTraceEvent(data, context));
     return contents;
 };
+const de_InlineAgentFilePart_event = async (output, context) => {
+    const contents = {};
+    const data = await parseBody(output.body, context);
+    Object.assign(contents, de_InlineAgentFilePart(data, context));
+    return contents;
+};
+const de_InlineAgentPayloadPart_event = async (output, context) => {
+    const contents = {};
+    const data = await parseBody(output.body, context);
+    Object.assign(contents, de_InlineAgentPayloadPart(data, context));
+    return contents;
+};
+const de_InlineAgentReturnControlPayload_event = async (output, context) => {
+    const contents = {};
+    const data = await parseBody(output.body, context);
+    Object.assign(contents, _json(data));
+    return contents;
+};
+const de_InlineAgentTracePart_event = async (output, context) => {
+    const contents = {};
+    const data = await parseBody(output.body, context);
+    Object.assign(contents, de_InlineAgentTracePart(data, context));
+    return contents;
+};
 const de_InternalServerException_event = async (output, context) => {
     const parsedOutput = {
         ...output,
@@ -770,6 +903,24 @@ const se_InferenceConfig = (input, context) => {
         textInferenceConfig: (_) => se_TextInferenceConfig(_, context),
     });
 };
+const se_InferenceConfiguration = (input, context) => {
+    return take(input, {
+        maximumLength: [],
+        stopSequences: _json,
+        temperature: __serializeFloat,
+        topK: [],
+        topP: __serializeFloat,
+    });
+};
+const se_InlineSessionState = (input, context) => {
+    return take(input, {
+        files: (_) => se_InputFiles(_, context),
+        invocationId: [],
+        promptSessionAttributes: _json,
+        returnControlInvocationResults: _json,
+        sessionAttributes: _json,
+    });
+};
 const se_InputFile = (input, context) => {
     return take(input, {
         name: [],
@@ -784,6 +935,13 @@ const se_InputFiles = (input, context) => {
         return se_InputFile(entry, context);
     });
 };
+const se_KnowledgeBase = (input, context) => {
+    return take(input, {
+        description: [],
+        knowledgeBaseId: [],
+        retrievalConfiguration: (_) => se_KnowledgeBaseRetrievalConfiguration(_, context),
+    });
+};
 const se_KnowledgeBaseConfiguration = (input, context) => {
     return take(input, {
         knowledgeBaseId: [],
@@ -811,6 +969,13 @@ const se_KnowledgeBaseRetrieveAndGenerateConfiguration = (input, context) => {
         retrievalConfiguration: (_) => se_KnowledgeBaseRetrievalConfiguration(_, context),
     });
 };
+const se_KnowledgeBases = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return se_KnowledgeBase(entry, context);
+    });
+};
 const se_KnowledgeBaseVectorSearchConfiguration = (input, context) => {
     return take(input, {
         filter: (_) => se_RetrievalFilter(_, context),
@@ -826,6 +991,29 @@ const se_OrchestrationConfiguration = (input, context) => {
         queryTransformationConfiguration: _json,
     });
 };
+const se_PromptConfiguration = (input, context) => {
+    return take(input, {
+        basePromptTemplate: [],
+        inferenceConfiguration: (_) => se_InferenceConfiguration(_, context),
+        parserMode: [],
+        promptCreationMode: [],
+        promptState: [],
+        promptType: [],
+    });
+};
+const se_PromptConfigurations = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return se_PromptConfiguration(entry, context);
+    });
+};
+const se_PromptOverrideConfiguration = (input, context) => {
+    return take(input, {
+        overrideLambda: [],
+        promptConfigurations: (_) => se_PromptConfigurations(_, context),
+    });
+};
 const se_RetrievalFilter = (input, context) => {
     return RetrievalFilter.visit(input, {
         andAll: (value) => ({ andAll: se_RetrievalFilterList(value, context) }),
@@ -1015,6 +1203,23 @@ const de_InferenceConfiguration = (output, context) => {
         topP: __limitedParseFloat32,
     });
 };
+const de_InlineAgentFilePart = (output, context) => {
+    return take(output, {
+        files: (_) => de_OutputFiles(_, context),
+    });
+};
+const de_InlineAgentPayloadPart = (output, context) => {
+    return take(output, {
+        attribution: (_) => de_Attribution(_, context),
+        bytes: context.base64Decoder,
+    });
+};
+const de_InlineAgentTracePart = (output, context) => {
+    return take(output, {
+        sessionId: __expectString,
+        trace: (_) => de_Trace(__expectUnion(_), context),
+    });
+};
 const de_KnowledgeBaseLookupOutput = (output, context) => {
     return take(output, {
         retrievedReferences: (_) => de_RetrievedReferences(_, context),
@@ -1186,6 +1391,11 @@ const de_RetrievedReferences = (output, context) => {
     return retVal;
 };
 const de_Trace = (output, context) => {
+    if (output.customOrchestrationTrace != null) {
+        return {
+            customOrchestrationTrace: _json(output.customOrchestrationTrace),
+        };
+    }
     if (output.failureTrace != null) {
         return {
             failureTrace: _json(output.failureTrace),

package/dist-types/BedrockAgentRuntime.d.ts

@@ -4,6 +4,7 @@ import { DeleteAgentMemoryCommandInput, DeleteAgentMemoryCommandOutput } from ".
 import { GetAgentMemoryCommandInput, GetAgentMemoryCommandOutput } from "./commands/GetAgentMemoryCommand";
 import { InvokeAgentCommandInput, InvokeAgentCommandOutput } from "./commands/InvokeAgentCommand";
 import { InvokeFlowCommandInput, InvokeFlowCommandOutput } from "./commands/InvokeFlowCommand";
+import { InvokeInlineAgentCommandInput, InvokeInlineAgentCommandOutput } from "./commands/InvokeInlineAgentCommand";
 import { OptimizePromptCommandInput, OptimizePromptCommandOutput } from "./commands/OptimizePromptCommand";
 import { RetrieveAndGenerateCommandInput, RetrieveAndGenerateCommandOutput } from "./commands/RetrieveAndGenerateCommand";
 import { RetrieveCommandInput, RetrieveCommandOutput } from "./commands/RetrieveCommand";
@@ -32,6 +33,12 @@ export interface BedrockAgentRuntime {
     invokeFlow(args: InvokeFlowCommandInput, options?: __HttpHandlerOptions): Promise<InvokeFlowCommandOutput>;
     invokeFlow(args: InvokeFlowCommandInput, cb: (err: any, data?: InvokeFlowCommandOutput) => void): void;
     invokeFlow(args: InvokeFlowCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: InvokeFlowCommandOutput) => void): void;
+    /**
+     * @see {@link InvokeInlineAgentCommand}
+     */
+    invokeInlineAgent(args: InvokeInlineAgentCommandInput, options?: __HttpHandlerOptions): Promise<InvokeInlineAgentCommandOutput>;
+    invokeInlineAgent(args: InvokeInlineAgentCommandInput, cb: (err: any, data?: InvokeInlineAgentCommandOutput) => void): void;
+    invokeInlineAgent(args: InvokeInlineAgentCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: InvokeInlineAgentCommandOutput) => void): void;
     /**
      * @see {@link OptimizePromptCommand}
      */

package/dist-types/BedrockAgentRuntimeClient.d.ts

@@ -12,6 +12,7 @@ import { DeleteAgentMemoryCommandInput, DeleteAgentMemoryCommandOutput } from ".
 import { GetAgentMemoryCommandInput, GetAgentMemoryCommandOutput } from "./commands/GetAgentMemoryCommand";
 import { InvokeAgentCommandInput, InvokeAgentCommandOutput } from "./commands/InvokeAgentCommand";
 import { InvokeFlowCommandInput, InvokeFlowCommandOutput } from "./commands/InvokeFlowCommand";
+import { InvokeInlineAgentCommandInput, InvokeInlineAgentCommandOutput } from "./commands/InvokeInlineAgentCommand";
 import { OptimizePromptCommandInput, OptimizePromptCommandOutput } from "./commands/OptimizePromptCommand";
 import { RetrieveAndGenerateCommandInput, RetrieveAndGenerateCommandOutput } from "./commands/RetrieveAndGenerateCommand";
 import { RetrieveCommandInput, RetrieveCommandOutput } from "./commands/RetrieveCommand";
@@ -21,11 +22,11 @@ export { __Client };
 /**
  * @public
  */
-export type ServiceInputTypes = DeleteAgentMemoryCommandInput | GetAgentMemoryCommandInput | InvokeAgentCommandInput | InvokeFlowCommandInput | OptimizePromptCommandInput | RetrieveAndGenerateCommandInput | RetrieveCommandInput;
+export type ServiceInputTypes = DeleteAgentMemoryCommandInput | GetAgentMemoryCommandInput | InvokeAgentCommandInput | InvokeFlowCommandInput | InvokeInlineAgentCommandInput | OptimizePromptCommandInput | RetrieveAndGenerateCommandInput | RetrieveCommandInput;
 /**
  * @public
  */
-export type ServiceOutputTypes = DeleteAgentMemoryCommandOutput | GetAgentMemoryCommandOutput | InvokeAgentCommandOutput | InvokeFlowCommandOutput | OptimizePromptCommandOutput | RetrieveAndGenerateCommandOutput | RetrieveCommandOutput;
+export type ServiceOutputTypes = DeleteAgentMemoryCommandOutput | GetAgentMemoryCommandOutput | InvokeAgentCommandOutput | InvokeFlowCommandOutput | InvokeInlineAgentCommandOutput | OptimizePromptCommandOutput | RetrieveAndGenerateCommandOutput | RetrieveCommandOutput;
 /**
  * @public
  */