n8n-nodes-vercel-ai-sdk-universal-temp 0.3.1 → 0.3.2
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/nodes/UniversalAI/helpers/inputBuilder.js +1 -1
- package/dist/nodes/UniversalAI/helpers/inputBuilder.js.map +1 -1
- package/dist/nodes/UniversalAgent/UniversalAgent.node.d.ts +1 -2
- package/dist/nodes/UniversalAgent/UniversalAgent.node.js +8 -21
- package/dist/nodes/UniversalAgent/UniversalAgent.node.js.map +1 -1
- package/dist/nodes/shared/descriptions.js +2188 -12
- package/dist/nodes/shared/descriptions.js.map +1 -1
- package/dist/nodes/shared/letta/client.d.ts +23 -0
- package/dist/nodes/shared/letta/client.js +208 -1
- package/dist/nodes/shared/letta/client.js.map +1 -1
- package/dist/nodes/shared/letta/load-options.js +2 -2
- package/dist/nodes/shared/letta/load-options.js.map +1 -1
- package/package.json +1 -1
|
@@ -821,6 +821,2040 @@ exports.UNIVERSAL_AI_DESCRIPTION = {
|
|
|
821
821
|
name: 'WAV Audio (Audio/wav)',
|
|
822
822
|
value: 'audio/wav',
|
|
823
823
|
},
|
|
824
|
+
{
|
|
825
|
+
displayName: 'Agent Messages Operation',
|
|
826
|
+
name: 'agentMessagesOperation',
|
|
827
|
+
type: 'options',
|
|
828
|
+
required: true,
|
|
829
|
+
noDataExpression: true,
|
|
830
|
+
displayOptions: {
|
|
831
|
+
show: {
|
|
832
|
+
operation: ['agentMessages'],
|
|
833
|
+
},
|
|
834
|
+
},
|
|
835
|
+
options: [
|
|
836
|
+
{
|
|
837
|
+
name: 'List Messages',
|
|
838
|
+
value: 'list',
|
|
839
|
+
description: 'List messages for an agent',
|
|
840
|
+
action: 'List agent messages',
|
|
841
|
+
},
|
|
842
|
+
{
|
|
843
|
+
name: 'Create Message',
|
|
844
|
+
value: 'create',
|
|
845
|
+
description: 'Send a message to an agent',
|
|
846
|
+
action: 'Create message',
|
|
847
|
+
},
|
|
848
|
+
{
|
|
849
|
+
name: 'Stream Message',
|
|
850
|
+
value: 'stream',
|
|
851
|
+
description: 'Stream a message response from an agent',
|
|
852
|
+
action: 'Stream message',
|
|
853
|
+
},
|
|
854
|
+
{
|
|
855
|
+
name: 'Cancel Message',
|
|
856
|
+
value: 'cancel',
|
|
857
|
+
description: 'Cancel a running message',
|
|
858
|
+
action: 'Cancel message',
|
|
859
|
+
},
|
|
860
|
+
{
|
|
861
|
+
name: 'Create Async Message',
|
|
862
|
+
value: 'createAsync',
|
|
863
|
+
description: 'Create a message asynchronously',
|
|
864
|
+
action: 'Create async message',
|
|
865
|
+
},
|
|
866
|
+
{
|
|
867
|
+
name: 'Reset Messages',
|
|
868
|
+
value: 'reset',
|
|
869
|
+
description: 'Reset agent conversation history',
|
|
870
|
+
action: 'Reset messages',
|
|
871
|
+
},
|
|
872
|
+
{
|
|
873
|
+
name: 'Compact Messages',
|
|
874
|
+
value: 'compact',
|
|
875
|
+
description: 'Compact agent message history',
|
|
876
|
+
action: 'Compact messages',
|
|
877
|
+
},
|
|
878
|
+
],
|
|
879
|
+
default: 'create',
|
|
880
|
+
description: 'The agent messages operation to perform',
|
|
881
|
+
},
|
|
882
|
+
{
|
|
883
|
+
displayName: 'Agent ID',
|
|
884
|
+
name: 'agentId',
|
|
885
|
+
type: 'options',
|
|
886
|
+
required: true,
|
|
887
|
+
typeOptions: {
|
|
888
|
+
loadOptionsMethod: 'getLettaAgents',
|
|
889
|
+
},
|
|
890
|
+
displayOptions: {
|
|
891
|
+
show: {
|
|
892
|
+
operation: ['agentMessages'],
|
|
893
|
+
},
|
|
894
|
+
},
|
|
895
|
+
default: '',
|
|
896
|
+
description: 'The agent to perform the operation on',
|
|
897
|
+
},
|
|
898
|
+
{
|
|
899
|
+
displayName: 'Input Type',
|
|
900
|
+
name: 'inputType',
|
|
901
|
+
type: 'options',
|
|
902
|
+
required: true,
|
|
903
|
+
noDataExpression: true,
|
|
904
|
+
displayOptions: {
|
|
905
|
+
show: {
|
|
906
|
+
operation: ['agentMessages'],
|
|
907
|
+
agentMessagesOperation: ['create', 'stream', 'createAsync'],
|
|
908
|
+
},
|
|
909
|
+
},
|
|
910
|
+
options: [
|
|
911
|
+
{
|
|
912
|
+
name: 'Simple Prompt',
|
|
913
|
+
value: 'prompt',
|
|
914
|
+
description: 'Use a single prompt',
|
|
915
|
+
},
|
|
916
|
+
{
|
|
917
|
+
name: 'Messages',
|
|
918
|
+
value: 'messages',
|
|
919
|
+
description: 'Use a conversation with multiple messages',
|
|
920
|
+
},
|
|
921
|
+
],
|
|
922
|
+
default: 'prompt',
|
|
923
|
+
description: 'Choose how you want to provide input to the agent',
|
|
924
|
+
},
|
|
925
|
+
{
|
|
926
|
+
displayName: 'Prompt',
|
|
927
|
+
name: 'prompt',
|
|
928
|
+
type: 'string',
|
|
929
|
+
typeOptions: {
|
|
930
|
+
rows: 4,
|
|
931
|
+
},
|
|
932
|
+
displayOptions: {
|
|
933
|
+
show: {
|
|
934
|
+
operation: ['agentMessages'],
|
|
935
|
+
agentMessagesOperation: ['create', 'stream', 'createAsync'],
|
|
936
|
+
inputType: ['prompt'],
|
|
937
|
+
},
|
|
938
|
+
},
|
|
939
|
+
default: '',
|
|
940
|
+
required: true,
|
|
941
|
+
description: 'The single text prompt to send to the agent',
|
|
942
|
+
requiresDataPath: 'single',
|
|
943
|
+
},
|
|
944
|
+
{
|
|
945
|
+
displayName: 'Messages',
|
|
946
|
+
name: 'messages',
|
|
947
|
+
type: 'fixedCollection',
|
|
948
|
+
typeOptions: {
|
|
949
|
+
multipleValues: true,
|
|
950
|
+
sortable: true,
|
|
951
|
+
minValue: 1,
|
|
952
|
+
},
|
|
953
|
+
displayOptions: {
|
|
954
|
+
show: {
|
|
955
|
+
operation: ['agentMessages'],
|
|
956
|
+
agentMessagesOperation: ['create', 'stream', 'createAsync'],
|
|
957
|
+
inputType: ['messages'],
|
|
958
|
+
},
|
|
959
|
+
},
|
|
960
|
+
description: 'The messages for the conversation',
|
|
961
|
+
default: {
|
|
962
|
+
messagesUi: [
|
|
963
|
+
{
|
|
964
|
+
role: 'user',
|
|
965
|
+
content: 'Hello!',
|
|
966
|
+
},
|
|
967
|
+
],
|
|
968
|
+
},
|
|
969
|
+
required: true,
|
|
970
|
+
options: [
|
|
971
|
+
{
|
|
972
|
+
name: 'messagesUi',
|
|
973
|
+
displayName: 'Message',
|
|
974
|
+
values: [
|
|
975
|
+
{
|
|
976
|
+
displayName: 'Role',
|
|
977
|
+
name: 'role',
|
|
978
|
+
type: 'options',
|
|
979
|
+
noDataExpression: true,
|
|
980
|
+
options: [
|
|
981
|
+
{
|
|
982
|
+
name: 'Assistant',
|
|
983
|
+
value: 'assistant',
|
|
984
|
+
},
|
|
985
|
+
{
|
|
986
|
+
name: 'System',
|
|
987
|
+
value: 'system',
|
|
988
|
+
},
|
|
989
|
+
{
|
|
990
|
+
name: 'User',
|
|
991
|
+
value: 'user',
|
|
992
|
+
},
|
|
993
|
+
],
|
|
994
|
+
default: 'user',
|
|
995
|
+
required: true,
|
|
996
|
+
},
|
|
997
|
+
{
|
|
998
|
+
displayName: 'Text Content',
|
|
999
|
+
name: 'content',
|
|
1000
|
+
type: 'string',
|
|
1001
|
+
typeOptions: {
|
|
1002
|
+
rows: 4,
|
|
1003
|
+
},
|
|
1004
|
+
displayOptions: {
|
|
1005
|
+
show: {
|
|
1006
|
+
role: ['assistant', 'user'],
|
|
1007
|
+
},
|
|
1008
|
+
},
|
|
1009
|
+
default: '',
|
|
1010
|
+
description: 'Primary text content of the message',
|
|
1011
|
+
required: true,
|
|
1012
|
+
requiresDataPath: 'single',
|
|
1013
|
+
},
|
|
1014
|
+
],
|
|
1015
|
+
},
|
|
1016
|
+
],
|
|
1017
|
+
},
|
|
1018
|
+
{
|
|
1019
|
+
displayName: 'Stream Tokens',
|
|
1020
|
+
name: 'streamTokens',
|
|
1021
|
+
type: 'boolean',
|
|
1022
|
+
default: false,
|
|
1023
|
+
displayOptions: {
|
|
1024
|
+
show: {
|
|
1025
|
+
operation: ['agentMessages'],
|
|
1026
|
+
agentMessagesOperation: ['stream'],
|
|
1027
|
+
},
|
|
1028
|
+
},
|
|
1029
|
+
description: 'Stream individual tokens in the response',
|
|
1030
|
+
},
|
|
1031
|
+
{
|
|
1032
|
+
displayName: 'Background Processing',
|
|
1033
|
+
name: 'background',
|
|
1034
|
+
type: 'boolean',
|
|
1035
|
+
default: false,
|
|
1036
|
+
displayOptions: {
|
|
1037
|
+
show: {
|
|
1038
|
+
operation: ['agentMessages'],
|
|
1039
|
+
agentMessagesOperation: ['create', 'stream', 'createAsync'],
|
|
1040
|
+
},
|
|
1041
|
+
},
|
|
1042
|
+
description: 'Run the message in background mode for long-running tasks',
|
|
1043
|
+
},
|
|
1044
|
+
{
|
|
1045
|
+
displayName: 'Limit',
|
|
1046
|
+
name: 'limit',
|
|
1047
|
+
type: 'number',
|
|
1048
|
+
default: 50,
|
|
1049
|
+
typeOptions: {
|
|
1050
|
+
minValue: 1,
|
|
1051
|
+
maxValue: 1000,
|
|
1052
|
+
},
|
|
1053
|
+
displayOptions: {
|
|
1054
|
+
show: {
|
|
1055
|
+
operation: ['agentMessages'],
|
|
1056
|
+
agentMessagesOperation: ['list'],
|
|
1057
|
+
},
|
|
1058
|
+
},
|
|
1059
|
+
description: 'Maximum number of messages to return',
|
|
1060
|
+
},
|
|
1061
|
+
{
|
|
1062
|
+
displayName: 'Before',
|
|
1063
|
+
name: 'before',
|
|
1064
|
+
type: 'string',
|
|
1065
|
+
default: '',
|
|
1066
|
+
displayOptions: {
|
|
1067
|
+
show: {
|
|
1068
|
+
operation: ['agentMessages'],
|
|
1069
|
+
agentMessagesOperation: ['list'],
|
|
1070
|
+
},
|
|
1071
|
+
},
|
|
1072
|
+
description: 'Cursor for pagination (message ID to start before)',
|
|
1073
|
+
},
|
|
1074
|
+
{
|
|
1075
|
+
displayName: 'Message ID',
|
|
1076
|
+
name: 'messageId',
|
|
1077
|
+
type: 'string',
|
|
1078
|
+
required: true,
|
|
1079
|
+
displayOptions: {
|
|
1080
|
+
show: {
|
|
1081
|
+
operation: ['agentMessages'],
|
|
1082
|
+
agentMessagesOperation: ['cancel'],
|
|
1083
|
+
},
|
|
1084
|
+
},
|
|
1085
|
+
default: '',
|
|
1086
|
+
description: 'The ID of the message to cancel',
|
|
1087
|
+
},
|
|
1088
|
+
{
|
|
1089
|
+
displayName: 'Agent Blocks Operation',
|
|
1090
|
+
name: 'agentBlocksOperation',
|
|
1091
|
+
type: 'options',
|
|
1092
|
+
required: true,
|
|
1093
|
+
noDataExpression: true,
|
|
1094
|
+
displayOptions: {
|
|
1095
|
+
show: {
|
|
1096
|
+
operation: ['agentBlocks'],
|
|
1097
|
+
},
|
|
1098
|
+
},
|
|
1099
|
+
options: [
|
|
1100
|
+
{
|
|
1101
|
+
name: 'Retrieve Block',
|
|
1102
|
+
value: 'retrieve',
|
|
1103
|
+
description: 'Get a specific memory block from an agent',
|
|
1104
|
+
action: 'Retrieve agent block',
|
|
1105
|
+
},
|
|
1106
|
+
{
|
|
1107
|
+
name: 'Update Block',
|
|
1108
|
+
value: 'update',
|
|
1109
|
+
description: 'Update a memory block for an agent',
|
|
1110
|
+
action: 'Update agent block',
|
|
1111
|
+
},
|
|
1112
|
+
{
|
|
1113
|
+
name: 'List Blocks',
|
|
1114
|
+
value: 'list',
|
|
1115
|
+
description: 'List all memory blocks for an agent',
|
|
1116
|
+
action: 'List agent blocks',
|
|
1117
|
+
},
|
|
1118
|
+
{
|
|
1119
|
+
name: 'Attach Block',
|
|
1120
|
+
value: 'attach',
|
|
1121
|
+
description: 'Attach a memory block to an agent',
|
|
1122
|
+
action: 'Attach block to agent',
|
|
1123
|
+
},
|
|
1124
|
+
{
|
|
1125
|
+
name: 'Detach Block',
|
|
1126
|
+
value: 'detach',
|
|
1127
|
+
description: 'Detach a memory block from an agent',
|
|
1128
|
+
action: 'Detach block from agent',
|
|
1129
|
+
},
|
|
1130
|
+
],
|
|
1131
|
+
default: 'list',
|
|
1132
|
+
description: 'The agent blocks operation to perform',
|
|
1133
|
+
},
|
|
1134
|
+
{
|
|
1135
|
+
displayName: 'Agent ID',
|
|
1136
|
+
name: 'agentId',
|
|
1137
|
+
type: 'options',
|
|
1138
|
+
required: true,
|
|
1139
|
+
typeOptions: {
|
|
1140
|
+
loadOptionsMethod: 'getLettaAgents',
|
|
1141
|
+
},
|
|
1142
|
+
displayOptions: {
|
|
1143
|
+
show: {
|
|
1144
|
+
operation: ['agentBlocks'],
|
|
1145
|
+
},
|
|
1146
|
+
},
|
|
1147
|
+
default: '',
|
|
1148
|
+
description: 'The agent to perform the operation on',
|
|
1149
|
+
},
|
|
1150
|
+
{
|
|
1151
|
+
displayName: 'Block Label',
|
|
1152
|
+
name: 'blockLabel',
|
|
1153
|
+
type: 'string',
|
|
1154
|
+
required: true,
|
|
1155
|
+
displayOptions: {
|
|
1156
|
+
show: {
|
|
1157
|
+
operation: ['agentBlocks'],
|
|
1158
|
+
agentBlocksOperation: ['retrieve', 'update'],
|
|
1159
|
+
},
|
|
1160
|
+
},
|
|
1161
|
+
default: '',
|
|
1162
|
+
description: 'The label of the memory block',
|
|
1163
|
+
},
|
|
1164
|
+
{
|
|
1165
|
+
displayName: 'Block Value',
|
|
1166
|
+
name: 'blockValue',
|
|
1167
|
+
type: 'string',
|
|
1168
|
+
typeOptions: {
|
|
1169
|
+
rows: 4,
|
|
1170
|
+
},
|
|
1171
|
+
displayOptions: {
|
|
1172
|
+
show: {
|
|
1173
|
+
operation: ['agentBlocks'],
|
|
1174
|
+
agentBlocksOperation: ['update'],
|
|
1175
|
+
},
|
|
1176
|
+
},
|
|
1177
|
+
default: '',
|
|
1178
|
+
required: true,
|
|
1179
|
+
description: 'The new value for the memory block',
|
|
1180
|
+
},
|
|
1181
|
+
{
|
|
1182
|
+
displayName: 'Block ID',
|
|
1183
|
+
name: 'blockId',
|
|
1184
|
+
type: 'string',
|
|
1185
|
+
required: true,
|
|
1186
|
+
displayOptions: {
|
|
1187
|
+
show: {
|
|
1188
|
+
operation: ['agentBlocks'],
|
|
1189
|
+
agentBlocksOperation: ['attach', 'detach'],
|
|
1190
|
+
},
|
|
1191
|
+
},
|
|
1192
|
+
default: '',
|
|
1193
|
+
description: 'The ID of the memory block to attach/detach',
|
|
1194
|
+
},
|
|
1195
|
+
{
|
|
1196
|
+
displayName: 'Agent Tools Operation',
|
|
1197
|
+
name: 'agentToolsOperation',
|
|
1198
|
+
type: 'options',
|
|
1199
|
+
required: true,
|
|
1200
|
+
noDataExpression: true,
|
|
1201
|
+
displayOptions: {
|
|
1202
|
+
show: {
|
|
1203
|
+
operation: ['agentTools'],
|
|
1204
|
+
},
|
|
1205
|
+
},
|
|
1206
|
+
options: [
|
|
1207
|
+
{
|
|
1208
|
+
name: 'List Tools',
|
|
1209
|
+
value: 'list',
|
|
1210
|
+
description: 'List tools attached to an agent',
|
|
1211
|
+
action: 'List agent tools',
|
|
1212
|
+
},
|
|
1213
|
+
{
|
|
1214
|
+
name: 'Attach Tool',
|
|
1215
|
+
value: 'attach',
|
|
1216
|
+
description: 'Attach a tool to an agent',
|
|
1217
|
+
action: 'Attach tool to agent',
|
|
1218
|
+
},
|
|
1219
|
+
{
|
|
1220
|
+
name: 'Detach Tool',
|
|
1221
|
+
value: 'detach',
|
|
1222
|
+
description: 'Detach a tool from an agent',
|
|
1223
|
+
action: 'Detach tool from agent',
|
|
1224
|
+
},
|
|
1225
|
+
{
|
|
1226
|
+
name: 'Update Approval',
|
|
1227
|
+
value: 'updateApproval',
|
|
1228
|
+
description: 'Update tool approval settings for an agent',
|
|
1229
|
+
action: 'Update tool approval',
|
|
1230
|
+
},
|
|
1231
|
+
],
|
|
1232
|
+
default: 'list',
|
|
1233
|
+
description: 'The agent tools operation to perform',
|
|
1234
|
+
},
|
|
1235
|
+
{
|
|
1236
|
+
displayName: 'Agent ID',
|
|
1237
|
+
name: 'agentId',
|
|
1238
|
+
type: 'options',
|
|
1239
|
+
required: true,
|
|
1240
|
+
typeOptions: {
|
|
1241
|
+
loadOptionsMethod: 'getLettaAgents',
|
|
1242
|
+
},
|
|
1243
|
+
displayOptions: {
|
|
1244
|
+
show: {
|
|
1245
|
+
operation: ['agentTools'],
|
|
1246
|
+
},
|
|
1247
|
+
},
|
|
1248
|
+
default: '',
|
|
1249
|
+
description: 'The agent to perform the operation on',
|
|
1250
|
+
},
|
|
1251
|
+
{
|
|
1252
|
+
displayName: 'Tool ID',
|
|
1253
|
+
name: 'toolId',
|
|
1254
|
+
type: 'string',
|
|
1255
|
+
required: true,
|
|
1256
|
+
displayOptions: {
|
|
1257
|
+
show: {
|
|
1258
|
+
operation: ['agentTools'],
|
|
1259
|
+
agentToolsOperation: ['attach', 'detach', 'updateApproval'],
|
|
1260
|
+
},
|
|
1261
|
+
},
|
|
1262
|
+
default: '',
|
|
1263
|
+
description: 'The ID of the tool',
|
|
1264
|
+
},
|
|
1265
|
+
{
|
|
1266
|
+
displayName: 'Approval Required',
|
|
1267
|
+
name: 'approvalRequired',
|
|
1268
|
+
type: 'boolean',
|
|
1269
|
+
default: true,
|
|
1270
|
+
displayOptions: {
|
|
1271
|
+
show: {
|
|
1272
|
+
operation: ['agentTools'],
|
|
1273
|
+
agentToolsOperation: ['updateApproval'],
|
|
1274
|
+
},
|
|
1275
|
+
},
|
|
1276
|
+
description: 'Whether approval is required for this tool',
|
|
1277
|
+
},
|
|
1278
|
+
{
|
|
1279
|
+
displayName: 'Agent Folders Operation',
|
|
1280
|
+
name: 'agentFoldersOperation',
|
|
1281
|
+
type: 'options',
|
|
1282
|
+
required: true,
|
|
1283
|
+
noDataExpression: true,
|
|
1284
|
+
displayOptions: {
|
|
1285
|
+
show: {
|
|
1286
|
+
operation: ['agentFolders'],
|
|
1287
|
+
},
|
|
1288
|
+
},
|
|
1289
|
+
options: [
|
|
1290
|
+
{
|
|
1291
|
+
name: 'List Folders',
|
|
1292
|
+
value: 'list',
|
|
1293
|
+
description: 'List folders attached to an agent',
|
|
1294
|
+
action: 'List agent folders',
|
|
1295
|
+
},
|
|
1296
|
+
{
|
|
1297
|
+
name: 'Attach Folder',
|
|
1298
|
+
value: 'attach',
|
|
1299
|
+
description: 'Attach a folder to an agent',
|
|
1300
|
+
action: 'Attach folder to agent',
|
|
1301
|
+
},
|
|
1302
|
+
{
|
|
1303
|
+
name: 'Detach Folder',
|
|
1304
|
+
value: 'detach',
|
|
1305
|
+
description: 'Detach a folder from an agent',
|
|
1306
|
+
action: 'Detach folder from agent',
|
|
1307
|
+
},
|
|
1308
|
+
],
|
|
1309
|
+
default: 'list',
|
|
1310
|
+
description: 'The agent folders operation to perform',
|
|
1311
|
+
},
|
|
1312
|
+
{
|
|
1313
|
+
displayName: 'Agent ID',
|
|
1314
|
+
name: 'agentId',
|
|
1315
|
+
type: 'options',
|
|
1316
|
+
required: true,
|
|
1317
|
+
typeOptions: {
|
|
1318
|
+
loadOptionsMethod: 'getLettaAgents',
|
|
1319
|
+
},
|
|
1320
|
+
displayOptions: {
|
|
1321
|
+
show: {
|
|
1322
|
+
operation: ['agentFolders'],
|
|
1323
|
+
},
|
|
1324
|
+
},
|
|
1325
|
+
default: '',
|
|
1326
|
+
description: 'The agent to perform the operation on',
|
|
1327
|
+
},
|
|
1328
|
+
{
|
|
1329
|
+
displayName: 'Folder ID',
|
|
1330
|
+
name: 'folderId',
|
|
1331
|
+
type: 'string',
|
|
1332
|
+
required: true,
|
|
1333
|
+
displayOptions: {
|
|
1334
|
+
show: {
|
|
1335
|
+
operation: ['agentFolders'],
|
|
1336
|
+
agentFoldersOperation: ['attach', 'detach'],
|
|
1337
|
+
},
|
|
1338
|
+
},
|
|
1339
|
+
default: '',
|
|
1340
|
+
description: 'The ID of the folder',
|
|
1341
|
+
},
|
|
1342
|
+
{
|
|
1343
|
+
displayName: 'Agent Files Operation',
|
|
1344
|
+
name: 'agentFilesOperation',
|
|
1345
|
+
type: 'options',
|
|
1346
|
+
required: true,
|
|
1347
|
+
noDataExpression: true,
|
|
1348
|
+
displayOptions: {
|
|
1349
|
+
show: {
|
|
1350
|
+
operation: ['agentFiles'],
|
|
1351
|
+
},
|
|
1352
|
+
},
|
|
1353
|
+
options: [
|
|
1354
|
+
{
|
|
1355
|
+
name: 'List Files',
|
|
1356
|
+
value: 'list',
|
|
1357
|
+
description: 'List files opened by an agent',
|
|
1358
|
+
action: 'List agent files',
|
|
1359
|
+
},
|
|
1360
|
+
{
|
|
1361
|
+
name: 'Open File',
|
|
1362
|
+
value: 'open',
|
|
1363
|
+
description: 'Open a file for an agent',
|
|
1364
|
+
action: 'Open file for agent',
|
|
1365
|
+
},
|
|
1366
|
+
{
|
|
1367
|
+
name: 'Close File',
|
|
1368
|
+
value: 'close',
|
|
1369
|
+
description: 'Close a file for an agent',
|
|
1370
|
+
action: 'Close file for agent',
|
|
1371
|
+
},
|
|
1372
|
+
{
|
|
1373
|
+
name: 'Close All Files',
|
|
1374
|
+
value: 'closeAll',
|
|
1375
|
+
description: 'Close all files for an agent',
|
|
1376
|
+
action: 'Close all files for agent',
|
|
1377
|
+
},
|
|
1378
|
+
],
|
|
1379
|
+
default: 'list',
|
|
1380
|
+
description: 'The agent files operation to perform',
|
|
1381
|
+
},
|
|
1382
|
+
{
|
|
1383
|
+
displayName: 'Agent ID',
|
|
1384
|
+
name: 'agentId',
|
|
1385
|
+
type: 'options',
|
|
1386
|
+
required: true,
|
|
1387
|
+
typeOptions: {
|
|
1388
|
+
loadOptionsMethod: 'getLettaAgents',
|
|
1389
|
+
},
|
|
1390
|
+
displayOptions: {
|
|
1391
|
+
show: {
|
|
1392
|
+
operation: ['agentFiles'],
|
|
1393
|
+
},
|
|
1394
|
+
},
|
|
1395
|
+
default: '',
|
|
1396
|
+
description: 'The agent to perform the operation on',
|
|
1397
|
+
},
|
|
1398
|
+
{
|
|
1399
|
+
displayName: 'File Path',
|
|
1400
|
+
name: 'filePath',
|
|
1401
|
+
type: 'string',
|
|
1402
|
+
required: true,
|
|
1403
|
+
displayOptions: {
|
|
1404
|
+
show: {
|
|
1405
|
+
operation: ['agentFiles'],
|
|
1406
|
+
agentFilesOperation: ['open', 'close'],
|
|
1407
|
+
},
|
|
1408
|
+
},
|
|
1409
|
+
default: '',
|
|
1410
|
+
description: 'The path of the file to open/close',
|
|
1411
|
+
},
|
|
1412
|
+
{
|
|
1413
|
+
displayName: 'Agent Archives Operation',
|
|
1414
|
+
name: 'agentArchivesOperation',
|
|
1415
|
+
type: 'options',
|
|
1416
|
+
required: true,
|
|
1417
|
+
noDataExpression: true,
|
|
1418
|
+
displayOptions: {
|
|
1419
|
+
show: {
|
|
1420
|
+
operation: ['agentArchives'],
|
|
1421
|
+
},
|
|
1422
|
+
},
|
|
1423
|
+
options: [
|
|
1424
|
+
{
|
|
1425
|
+
name: 'Attach Archive',
|
|
1426
|
+
value: 'attach',
|
|
1427
|
+
description: 'Attach an archive to an agent',
|
|
1428
|
+
action: 'Attach archive to agent',
|
|
1429
|
+
},
|
|
1430
|
+
{
|
|
1431
|
+
name: 'Detach Archive',
|
|
1432
|
+
value: 'detach',
|
|
1433
|
+
description: 'Detach an archive from an agent',
|
|
1434
|
+
action: 'Detach archive from agent',
|
|
1435
|
+
},
|
|
1436
|
+
],
|
|
1437
|
+
default: 'attach',
|
|
1438
|
+
description: 'The agent archives operation to perform',
|
|
1439
|
+
},
|
|
1440
|
+
{
|
|
1441
|
+
displayName: 'Agent ID',
|
|
1442
|
+
name: 'agentId',
|
|
1443
|
+
type: 'options',
|
|
1444
|
+
required: true,
|
|
1445
|
+
typeOptions: {
|
|
1446
|
+
loadOptionsMethod: 'getLettaAgents',
|
|
1447
|
+
},
|
|
1448
|
+
displayOptions: {
|
|
1449
|
+
show: {
|
|
1450
|
+
operation: ['agentArchives'],
|
|
1451
|
+
},
|
|
1452
|
+
},
|
|
1453
|
+
default: '',
|
|
1454
|
+
description: 'The agent to perform the operation on',
|
|
1455
|
+
},
|
|
1456
|
+
{
|
|
1457
|
+
displayName: 'Archive ID',
|
|
1458
|
+
name: 'archiveId',
|
|
1459
|
+
type: 'string',
|
|
1460
|
+
required: true,
|
|
1461
|
+
displayOptions: {
|
|
1462
|
+
show: {
|
|
1463
|
+
operation: ['agentArchives'],
|
|
1464
|
+
},
|
|
1465
|
+
},
|
|
1466
|
+
default: '',
|
|
1467
|
+
description: 'The ID of the archive',
|
|
1468
|
+
},
|
|
1469
|
+
{
|
|
1470
|
+
displayName: 'Agent Identities Operation',
|
|
1471
|
+
name: 'agentIdentitiesOperation',
|
|
1472
|
+
type: 'options',
|
|
1473
|
+
required: true,
|
|
1474
|
+
noDataExpression: true,
|
|
1475
|
+
displayOptions: {
|
|
1476
|
+
show: {
|
|
1477
|
+
operation: ['agentIdentities'],
|
|
1478
|
+
},
|
|
1479
|
+
},
|
|
1480
|
+
options: [
|
|
1481
|
+
{
|
|
1482
|
+
name: 'Attach Identity',
|
|
1483
|
+
value: 'attach',
|
|
1484
|
+
description: 'Attach an identity to an agent',
|
|
1485
|
+
action: 'Attach identity to agent',
|
|
1486
|
+
},
|
|
1487
|
+
{
|
|
1488
|
+
name: 'Detach Identity',
|
|
1489
|
+
value: 'detach',
|
|
1490
|
+
description: 'Detach an identity from an agent',
|
|
1491
|
+
action: 'Detach identity from agent',
|
|
1492
|
+
},
|
|
1493
|
+
],
|
|
1494
|
+
default: 'attach',
|
|
1495
|
+
description: 'The agent identities operation to perform',
|
|
1496
|
+
},
|
|
1497
|
+
{
|
|
1498
|
+
displayName: 'Agent ID',
|
|
1499
|
+
name: 'agentId',
|
|
1500
|
+
type: 'options',
|
|
1501
|
+
required: true,
|
|
1502
|
+
typeOptions: {
|
|
1503
|
+
loadOptionsMethod: 'getLettaAgents',
|
|
1504
|
+
},
|
|
1505
|
+
displayOptions: {
|
|
1506
|
+
show: {
|
|
1507
|
+
operation: ['agentIdentities'],
|
|
1508
|
+
},
|
|
1509
|
+
},
|
|
1510
|
+
default: '',
|
|
1511
|
+
description: 'The agent to perform the operation on',
|
|
1512
|
+
},
|
|
1513
|
+
{
|
|
1514
|
+
displayName: 'Identity ID',
|
|
1515
|
+
name: 'identityId',
|
|
1516
|
+
type: 'string',
|
|
1517
|
+
required: true,
|
|
1518
|
+
displayOptions: {
|
|
1519
|
+
show: {
|
|
1520
|
+
operation: ['agentIdentities'],
|
|
1521
|
+
},
|
|
1522
|
+
},
|
|
1523
|
+
default: '',
|
|
1524
|
+
description: 'The ID of the identity',
|
|
1525
|
+
},
|
|
1526
|
+
{
|
|
1527
|
+
displayName: 'Agent ID',
|
|
1528
|
+
name: 'agentId',
|
|
1529
|
+
type: 'options',
|
|
1530
|
+
required: true,
|
|
1531
|
+
typeOptions: {
|
|
1532
|
+
loadOptionsMethod: 'getLettaAgents',
|
|
1533
|
+
},
|
|
1534
|
+
displayOptions: {
|
|
1535
|
+
show: {
|
|
1536
|
+
operation: ['agentGroups'],
|
|
1537
|
+
},
|
|
1538
|
+
},
|
|
1539
|
+
default: '',
|
|
1540
|
+
description: 'The agent to list groups for',
|
|
1541
|
+
},
|
|
1542
|
+
{
|
|
1543
|
+
displayName: 'Tools Operation',
|
|
1544
|
+
name: 'toolsOperation',
|
|
1545
|
+
type: 'options',
|
|
1546
|
+
required: true,
|
|
1547
|
+
noDataExpression: true,
|
|
1548
|
+
displayOptions: {
|
|
1549
|
+
show: {
|
|
1550
|
+
operation: ['tools'],
|
|
1551
|
+
},
|
|
1552
|
+
},
|
|
1553
|
+
options: [
|
|
1554
|
+
{
|
|
1555
|
+
name: 'List Tools',
|
|
1556
|
+
value: 'list',
|
|
1557
|
+
description: 'List all tools',
|
|
1558
|
+
action: 'List tools',
|
|
1559
|
+
},
|
|
1560
|
+
{
|
|
1561
|
+
name: 'Create Tool',
|
|
1562
|
+
value: 'create',
|
|
1563
|
+
description: 'Create a new tool',
|
|
1564
|
+
action: 'Create tool',
|
|
1565
|
+
},
|
|
1566
|
+
{
|
|
1567
|
+
name: 'Get Tool',
|
|
1568
|
+
value: 'retrieve',
|
|
1569
|
+
description: 'Get a specific tool',
|
|
1570
|
+
action: 'Get tool',
|
|
1571
|
+
},
|
|
1572
|
+
{
|
|
1573
|
+
name: 'Update Tool',
|
|
1574
|
+
value: 'update',
|
|
1575
|
+
description: 'Update an existing tool',
|
|
1576
|
+
action: 'Update tool',
|
|
1577
|
+
},
|
|
1578
|
+
{
|
|
1579
|
+
name: 'Delete Tool',
|
|
1580
|
+
value: 'delete',
|
|
1581
|
+
description: 'Delete a tool',
|
|
1582
|
+
action: 'Delete tool',
|
|
1583
|
+
},
|
|
1584
|
+
{
|
|
1585
|
+
name: 'Upsert Tool',
|
|
1586
|
+
value: 'upsert',
|
|
1587
|
+
description: 'Create or update a tool',
|
|
1588
|
+
action: 'Upsert tool',
|
|
1589
|
+
},
|
|
1590
|
+
{
|
|
1591
|
+
name: 'Upsert Base Tools',
|
|
1592
|
+
value: 'upsertBaseTools',
|
|
1593
|
+
description: 'Upsert base tools',
|
|
1594
|
+
action: 'Upsert base tools',
|
|
1595
|
+
},
|
|
1596
|
+
],
|
|
1597
|
+
default: 'list',
|
|
1598
|
+
description: 'The tools operation to perform',
|
|
1599
|
+
},
|
|
1600
|
+
{
|
|
1601
|
+
displayName: 'Tool ID',
|
|
1602
|
+
name: 'toolId',
|
|
1603
|
+
type: 'string',
|
|
1604
|
+
required: true,
|
|
1605
|
+
displayOptions: {
|
|
1606
|
+
show: {
|
|
1607
|
+
operation: ['tools'],
|
|
1608
|
+
toolsOperation: ['retrieve', 'update', 'delete'],
|
|
1609
|
+
},
|
|
1610
|
+
},
|
|
1611
|
+
default: '',
|
|
1612
|
+
description: 'The ID of the tool',
|
|
1613
|
+
},
|
|
1614
|
+
{
|
|
1615
|
+
displayName: 'Tool Name',
|
|
1616
|
+
name: 'toolName',
|
|
1617
|
+
type: 'string',
|
|
1618
|
+
required: true,
|
|
1619
|
+
displayOptions: {
|
|
1620
|
+
show: {
|
|
1621
|
+
operation: ['tools'],
|
|
1622
|
+
toolsOperation: ['create', 'update', 'upsert'],
|
|
1623
|
+
},
|
|
1624
|
+
},
|
|
1625
|
+
default: '',
|
|
1626
|
+
description: 'The name of the tool',
|
|
1627
|
+
},
|
|
1628
|
+
{
|
|
1629
|
+
displayName: 'Tool Description',
|
|
1630
|
+
name: 'toolDescription',
|
|
1631
|
+
type: 'string',
|
|
1632
|
+
typeOptions: {
|
|
1633
|
+
rows: 3,
|
|
1634
|
+
},
|
|
1635
|
+
displayOptions: {
|
|
1636
|
+
show: {
|
|
1637
|
+
operation: ['tools'],
|
|
1638
|
+
toolsOperation: ['create', 'update', 'upsert'],
|
|
1639
|
+
},
|
|
1640
|
+
},
|
|
1641
|
+
default: '',
|
|
1642
|
+
description: 'Description of what the tool does',
|
|
1643
|
+
},
|
|
1644
|
+
{
|
|
1645
|
+
displayName: 'Tool Source Code',
|
|
1646
|
+
name: 'toolSourceCode',
|
|
1647
|
+
type: 'string',
|
|
1648
|
+
typeOptions: {
|
|
1649
|
+
rows: 8,
|
|
1650
|
+
},
|
|
1651
|
+
displayOptions: {
|
|
1652
|
+
show: {
|
|
1653
|
+
operation: ['tools'],
|
|
1654
|
+
toolsOperation: ['create', 'update', 'upsert'],
|
|
1655
|
+
},
|
|
1656
|
+
},
|
|
1657
|
+
default: '',
|
|
1658
|
+
description: 'The Python source code for the tool',
|
|
1659
|
+
},
|
|
1660
|
+
{
|
|
1661
|
+
displayName: 'Tool Tags',
|
|
1662
|
+
name: 'toolTags',
|
|
1663
|
+
type: 'string',
|
|
1664
|
+
default: '',
|
|
1665
|
+
displayOptions: {
|
|
1666
|
+
show: {
|
|
1667
|
+
operation: ['tools'],
|
|
1668
|
+
toolsOperation: ['create', 'update', 'upsert'],
|
|
1669
|
+
},
|
|
1670
|
+
},
|
|
1671
|
+
description: 'Comma-separated tags for the tool',
|
|
1672
|
+
},
|
|
1673
|
+
{
|
|
1674
|
+
displayName: 'Blocks Operation',
|
|
1675
|
+
name: 'blocksOperation',
|
|
1676
|
+
type: 'options',
|
|
1677
|
+
required: true,
|
|
1678
|
+
noDataExpression: true,
|
|
1679
|
+
displayOptions: {
|
|
1680
|
+
show: {
|
|
1681
|
+
operation: ['blocks'],
|
|
1682
|
+
},
|
|
1683
|
+
},
|
|
1684
|
+
options: [
|
|
1685
|
+
{
|
|
1686
|
+
name: 'List Blocks',
|
|
1687
|
+
value: 'list',
|
|
1688
|
+
description: 'List all memory blocks',
|
|
1689
|
+
action: 'List blocks',
|
|
1690
|
+
},
|
|
1691
|
+
{
|
|
1692
|
+
name: 'Create Block',
|
|
1693
|
+
value: 'create',
|
|
1694
|
+
description: 'Create a new memory block',
|
|
1695
|
+
action: 'Create block',
|
|
1696
|
+
},
|
|
1697
|
+
{
|
|
1698
|
+
name: 'Get Block',
|
|
1699
|
+
value: 'retrieve',
|
|
1700
|
+
description: 'Get a specific memory block',
|
|
1701
|
+
action: 'Get block',
|
|
1702
|
+
},
|
|
1703
|
+
{
|
|
1704
|
+
name: 'Update Block',
|
|
1705
|
+
value: 'update',
|
|
1706
|
+
description: 'Update an existing memory block',
|
|
1707
|
+
action: 'Update block',
|
|
1708
|
+
},
|
|
1709
|
+
{
|
|
1710
|
+
name: 'Delete Block',
|
|
1711
|
+
value: 'delete',
|
|
1712
|
+
description: 'Delete a memory block',
|
|
1713
|
+
action: 'Delete block',
|
|
1714
|
+
},
|
|
1715
|
+
],
|
|
1716
|
+
default: 'list',
|
|
1717
|
+
description: 'The blocks operation to perform',
|
|
1718
|
+
},
|
|
1719
|
+
{
|
|
1720
|
+
displayName: 'Block ID',
|
|
1721
|
+
name: 'blockId',
|
|
1722
|
+
type: 'string',
|
|
1723
|
+
required: true,
|
|
1724
|
+
displayOptions: {
|
|
1725
|
+
show: {
|
|
1726
|
+
operation: ['blocks'],
|
|
1727
|
+
blocksOperation: ['retrieve', 'update', 'delete'],
|
|
1728
|
+
},
|
|
1729
|
+
},
|
|
1730
|
+
default: '',
|
|
1731
|
+
description: 'The ID of the memory block',
|
|
1732
|
+
},
|
|
1733
|
+
{
|
|
1734
|
+
displayName: 'Block Label',
|
|
1735
|
+
name: 'blockLabel',
|
|
1736
|
+
type: 'string',
|
|
1737
|
+
required: true,
|
|
1738
|
+
displayOptions: {
|
|
1739
|
+
show: {
|
|
1740
|
+
operation: ['blocks'],
|
|
1741
|
+
blocksOperation: ['create', 'update'],
|
|
1742
|
+
},
|
|
1743
|
+
},
|
|
1744
|
+
default: '',
|
|
1745
|
+
description: 'The label for the memory block',
|
|
1746
|
+
},
|
|
1747
|
+
{
|
|
1748
|
+
displayName: 'Block Value',
|
|
1749
|
+
name: 'blockValue',
|
|
1750
|
+
type: 'string',
|
|
1751
|
+
typeOptions: {
|
|
1752
|
+
rows: 4,
|
|
1753
|
+
},
|
|
1754
|
+
required: true,
|
|
1755
|
+
displayOptions: {
|
|
1756
|
+
show: {
|
|
1757
|
+
operation: ['blocks'],
|
|
1758
|
+
blocksOperation: ['create', 'update'],
|
|
1759
|
+
},
|
|
1760
|
+
},
|
|
1761
|
+
default: '',
|
|
1762
|
+
description: 'The content of the memory block',
|
|
1763
|
+
},
|
|
1764
|
+
{
|
|
1765
|
+
displayName: 'Block Limit',
|
|
1766
|
+
name: 'blockLimit',
|
|
1767
|
+
type: 'number',
|
|
1768
|
+
default: 50,
|
|
1769
|
+
typeOptions: {
|
|
1770
|
+
minValue: 1,
|
|
1771
|
+
maxValue: 1000,
|
|
1772
|
+
},
|
|
1773
|
+
displayOptions: {
|
|
1774
|
+
show: {
|
|
1775
|
+
operation: ['blocks'],
|
|
1776
|
+
blocksOperation: ['list'],
|
|
1777
|
+
},
|
|
1778
|
+
},
|
|
1779
|
+
description: 'Maximum number of blocks to return',
|
|
1780
|
+
},
|
|
1781
|
+
{
|
|
1782
|
+
displayName: 'Archives Operation',
|
|
1783
|
+
name: 'archivesOperation',
|
|
1784
|
+
type: 'options',
|
|
1785
|
+
required: true,
|
|
1786
|
+
noDataExpression: true,
|
|
1787
|
+
displayOptions: {
|
|
1788
|
+
show: {
|
|
1789
|
+
operation: ['archives'],
|
|
1790
|
+
},
|
|
1791
|
+
},
|
|
1792
|
+
options: [
|
|
1793
|
+
{
|
|
1794
|
+
name: 'List Archives',
|
|
1795
|
+
value: 'list',
|
|
1796
|
+
description: 'List all archives',
|
|
1797
|
+
action: 'List archives',
|
|
1798
|
+
},
|
|
1799
|
+
{
|
|
1800
|
+
name: 'Create Archive',
|
|
1801
|
+
value: 'create',
|
|
1802
|
+
description: 'Create a new archive',
|
|
1803
|
+
action: 'Create archive',
|
|
1804
|
+
},
|
|
1805
|
+
{
|
|
1806
|
+
name: 'Get Archive',
|
|
1807
|
+
value: 'retrieve',
|
|
1808
|
+
description: 'Get a specific archive',
|
|
1809
|
+
action: 'Get archive',
|
|
1810
|
+
},
|
|
1811
|
+
{
|
|
1812
|
+
name: 'Update Archive',
|
|
1813
|
+
value: 'update',
|
|
1814
|
+
description: 'Update an existing archive',
|
|
1815
|
+
action: 'Update archive',
|
|
1816
|
+
},
|
|
1817
|
+
{
|
|
1818
|
+
name: 'Delete Archive',
|
|
1819
|
+
value: 'delete',
|
|
1820
|
+
description: 'Delete an archive',
|
|
1821
|
+
action: 'Delete archive',
|
|
1822
|
+
},
|
|
1823
|
+
],
|
|
1824
|
+
default: 'list',
|
|
1825
|
+
description: 'The archives operation to perform',
|
|
1826
|
+
},
|
|
1827
|
+
{
|
|
1828
|
+
displayName: 'Archive ID',
|
|
1829
|
+
name: 'archiveId',
|
|
1830
|
+
type: 'string',
|
|
1831
|
+
required: true,
|
|
1832
|
+
displayOptions: {
|
|
1833
|
+
show: {
|
|
1834
|
+
operation: ['archives'],
|
|
1835
|
+
archivesOperation: ['retrieve', 'update', 'delete'],
|
|
1836
|
+
},
|
|
1837
|
+
},
|
|
1838
|
+
default: '',
|
|
1839
|
+
description: 'The ID of the archive',
|
|
1840
|
+
},
|
|
1841
|
+
{
|
|
1842
|
+
displayName: 'Archive Name',
|
|
1843
|
+
name: 'archiveName',
|
|
1844
|
+
type: 'string',
|
|
1845
|
+
required: true,
|
|
1846
|
+
displayOptions: {
|
|
1847
|
+
show: {
|
|
1848
|
+
operation: ['archives'],
|
|
1849
|
+
archivesOperation: ['create', 'update'],
|
|
1850
|
+
},
|
|
1851
|
+
},
|
|
1852
|
+
default: '',
|
|
1853
|
+
description: 'The name of the archive',
|
|
1854
|
+
},
|
|
1855
|
+
{
|
|
1856
|
+
displayName: 'Archive Description',
|
|
1857
|
+
name: 'archiveDescription',
|
|
1858
|
+
type: 'string',
|
|
1859
|
+
typeOptions: {
|
|
1860
|
+
rows: 3,
|
|
1861
|
+
},
|
|
1862
|
+
displayOptions: {
|
|
1863
|
+
show: {
|
|
1864
|
+
operation: ['archives'],
|
|
1865
|
+
archivesOperation: ['create', 'update'],
|
|
1866
|
+
},
|
|
1867
|
+
},
|
|
1868
|
+
default: '',
|
|
1869
|
+
description: 'Description of the archive',
|
|
1870
|
+
},
|
|
1871
|
+
{
|
|
1872
|
+
displayName: 'Folders Operation',
|
|
1873
|
+
name: 'foldersOperation',
|
|
1874
|
+
type: 'options',
|
|
1875
|
+
required: true,
|
|
1876
|
+
noDataExpression: true,
|
|
1877
|
+
displayOptions: {
|
|
1878
|
+
show: {
|
|
1879
|
+
operation: ['folders'],
|
|
1880
|
+
},
|
|
1881
|
+
},
|
|
1882
|
+
options: [
|
|
1883
|
+
{
|
|
1884
|
+
name: 'List Folders',
|
|
1885
|
+
value: 'list',
|
|
1886
|
+
description: 'List all folders',
|
|
1887
|
+
action: 'List folders',
|
|
1888
|
+
},
|
|
1889
|
+
{
|
|
1890
|
+
name: 'Create Folder',
|
|
1891
|
+
value: 'create',
|
|
1892
|
+
description: 'Create a new folder',
|
|
1893
|
+
action: 'Create folder',
|
|
1894
|
+
},
|
|
1895
|
+
{
|
|
1896
|
+
name: 'Get Folder',
|
|
1897
|
+
value: 'retrieve',
|
|
1898
|
+
description: 'Get a specific folder',
|
|
1899
|
+
action: 'Get folder',
|
|
1900
|
+
},
|
|
1901
|
+
{
|
|
1902
|
+
name: 'Update Folder',
|
|
1903
|
+
value: 'update',
|
|
1904
|
+
description: 'Update an existing folder',
|
|
1905
|
+
action: 'Update folder',
|
|
1906
|
+
},
|
|
1907
|
+
{
|
|
1908
|
+
name: 'Delete Folder',
|
|
1909
|
+
value: 'delete',
|
|
1910
|
+
description: 'Delete a folder',
|
|
1911
|
+
action: 'Delete folder',
|
|
1912
|
+
},
|
|
1913
|
+
],
|
|
1914
|
+
default: 'list',
|
|
1915
|
+
description: 'The folders operation to perform',
|
|
1916
|
+
},
|
|
1917
|
+
{
|
|
1918
|
+
displayName: 'Folder ID',
|
|
1919
|
+
name: 'folderId',
|
|
1920
|
+
type: 'string',
|
|
1921
|
+
required: true,
|
|
1922
|
+
displayOptions: {
|
|
1923
|
+
show: {
|
|
1924
|
+
operation: ['folders'],
|
|
1925
|
+
foldersOperation: ['retrieve', 'update', 'delete'],
|
|
1926
|
+
},
|
|
1927
|
+
},
|
|
1928
|
+
default: '',
|
|
1929
|
+
description: 'The ID of the folder',
|
|
1930
|
+
},
|
|
1931
|
+
{
|
|
1932
|
+
displayName: 'Folder Name',
|
|
1933
|
+
name: 'folderName',
|
|
1934
|
+
type: 'string',
|
|
1935
|
+
required: true,
|
|
1936
|
+
displayOptions: {
|
|
1937
|
+
show: {
|
|
1938
|
+
operation: ['folders'],
|
|
1939
|
+
foldersOperation: ['create', 'update'],
|
|
1940
|
+
},
|
|
1941
|
+
},
|
|
1942
|
+
default: '',
|
|
1943
|
+
description: 'The name of the folder',
|
|
1944
|
+
},
|
|
1945
|
+
{
|
|
1946
|
+
displayName: 'Embedding Config',
|
|
1947
|
+
name: 'embeddingConfig',
|
|
1948
|
+
type: 'string',
|
|
1949
|
+
displayOptions: {
|
|
1950
|
+
show: {
|
|
1951
|
+
operation: ['folders'],
|
|
1952
|
+
foldersOperation: ['create', 'update'],
|
|
1953
|
+
},
|
|
1954
|
+
},
|
|
1955
|
+
default: '',
|
|
1956
|
+
description: 'The embedding configuration for the folder',
|
|
1957
|
+
},
|
|
1958
|
+
{
|
|
1959
|
+
displayName: 'Models Operation',
|
|
1960
|
+
name: 'modelsOperation',
|
|
1961
|
+
type: 'options',
|
|
1962
|
+
required: true,
|
|
1963
|
+
noDataExpression: true,
|
|
1964
|
+
displayOptions: {
|
|
1965
|
+
show: {
|
|
1966
|
+
operation: ['models'],
|
|
1967
|
+
},
|
|
1968
|
+
},
|
|
1969
|
+
options: [
|
|
1970
|
+
{
|
|
1971
|
+
name: 'List Models',
|
|
1972
|
+
value: 'list',
|
|
1973
|
+
description: 'List all available models',
|
|
1974
|
+
action: 'List models',
|
|
1975
|
+
},
|
|
1976
|
+
{
|
|
1977
|
+
name: 'List Embedding Models',
|
|
1978
|
+
value: 'listEmbeddings',
|
|
1979
|
+
description: 'List all available embedding models',
|
|
1980
|
+
action: 'List embedding models',
|
|
1981
|
+
},
|
|
1982
|
+
],
|
|
1983
|
+
default: 'list',
|
|
1984
|
+
description: 'The models operation to perform',
|
|
1985
|
+
},
|
|
1986
|
+
{
|
|
1987
|
+
displayName: 'Tools Operation',
|
|
1988
|
+
name: 'toolsOperation',
|
|
1989
|
+
type: 'options',
|
|
1990
|
+
required: true,
|
|
1991
|
+
noDataExpression: true,
|
|
1992
|
+
displayOptions: {
|
|
1993
|
+
show: {
|
|
1994
|
+
operation: ['tools'],
|
|
1995
|
+
},
|
|
1996
|
+
},
|
|
1997
|
+
options: [
|
|
1998
|
+
{
|
|
1999
|
+
name: 'List Tools',
|
|
2000
|
+
value: 'list',
|
|
2001
|
+
description: 'List all tools',
|
|
2002
|
+
action: 'List tools',
|
|
2003
|
+
},
|
|
2004
|
+
{
|
|
2005
|
+
name: 'Create Tool',
|
|
2006
|
+
value: 'create',
|
|
2007
|
+
description: 'Create a new tool',
|
|
2008
|
+
action: 'Create tool',
|
|
2009
|
+
},
|
|
2010
|
+
{
|
|
2011
|
+
name: 'Get Tool',
|
|
2012
|
+
value: 'retrieve',
|
|
2013
|
+
description: 'Get a specific tool',
|
|
2014
|
+
action: 'Get tool',
|
|
2015
|
+
},
|
|
2016
|
+
{
|
|
2017
|
+
name: 'Update Tool',
|
|
2018
|
+
value: 'update',
|
|
2019
|
+
description: 'Update an existing tool',
|
|
2020
|
+
action: 'Update tool',
|
|
2021
|
+
},
|
|
2022
|
+
{
|
|
2023
|
+
name: 'Delete Tool',
|
|
2024
|
+
value: 'delete',
|
|
2025
|
+
description: 'Delete a tool',
|
|
2026
|
+
action: 'Delete tool',
|
|
2027
|
+
},
|
|
2028
|
+
{
|
|
2029
|
+
name: 'Upsert Tool',
|
|
2030
|
+
value: 'upsert',
|
|
2031
|
+
description: 'Create or update a tool',
|
|
2032
|
+
action: 'Upsert tool',
|
|
2033
|
+
},
|
|
2034
|
+
{
|
|
2035
|
+
name: 'Upsert Base Tools',
|
|
2036
|
+
value: 'upsertBaseTools',
|
|
2037
|
+
description: 'Upsert base tools',
|
|
2038
|
+
action: 'Upsert base tools',
|
|
2039
|
+
},
|
|
2040
|
+
],
|
|
2041
|
+
default: 'list',
|
|
2042
|
+
description: 'The tools operation to perform',
|
|
2043
|
+
},
|
|
2044
|
+
{
|
|
2045
|
+
displayName: 'Tool ID',
|
|
2046
|
+
name: 'toolId',
|
|
2047
|
+
type: 'string',
|
|
2048
|
+
required: true,
|
|
2049
|
+
displayOptions: {
|
|
2050
|
+
show: {
|
|
2051
|
+
operation: ['tools'],
|
|
2052
|
+
toolsOperation: ['retrieve', 'update', 'delete'],
|
|
2053
|
+
},
|
|
2054
|
+
},
|
|
2055
|
+
default: '',
|
|
2056
|
+
description: 'The ID of the tool',
|
|
2057
|
+
},
|
|
2058
|
+
{
|
|
2059
|
+
displayName: 'Tool Name',
|
|
2060
|
+
name: 'toolName',
|
|
2061
|
+
type: 'string',
|
|
2062
|
+
required: true,
|
|
2063
|
+
displayOptions: {
|
|
2064
|
+
show: {
|
|
2065
|
+
operation: ['tools'],
|
|
2066
|
+
toolsOperation: ['create', 'update', 'upsert'],
|
|
2067
|
+
},
|
|
2068
|
+
},
|
|
2069
|
+
default: '',
|
|
2070
|
+
description: 'The name of the tool',
|
|
2071
|
+
},
|
|
2072
|
+
{
|
|
2073
|
+
displayName: 'Tool Description',
|
|
2074
|
+
name: 'toolDescription',
|
|
2075
|
+
type: 'string',
|
|
2076
|
+
typeOptions: {
|
|
2077
|
+
rows: 3,
|
|
2078
|
+
},
|
|
2079
|
+
displayOptions: {
|
|
2080
|
+
show: {
|
|
2081
|
+
operation: ['tools'],
|
|
2082
|
+
toolsOperation: ['create', 'update', 'upsert'],
|
|
2083
|
+
},
|
|
2084
|
+
},
|
|
2085
|
+
default: '',
|
|
2086
|
+
description: 'Description of what the tool does',
|
|
2087
|
+
},
|
|
2088
|
+
{
|
|
2089
|
+
displayName: 'Tool Source Code',
|
|
2090
|
+
name: 'toolSourceCode',
|
|
2091
|
+
type: 'string',
|
|
2092
|
+
typeOptions: {
|
|
2093
|
+
rows: 8,
|
|
2094
|
+
},
|
|
2095
|
+
displayOptions: {
|
|
2096
|
+
show: {
|
|
2097
|
+
operation: ['tools'],
|
|
2098
|
+
toolsOperation: ['create', 'update', 'upsert'],
|
|
2099
|
+
},
|
|
2100
|
+
},
|
|
2101
|
+
default: '',
|
|
2102
|
+
description: 'The Python source code for the tool',
|
|
2103
|
+
},
|
|
2104
|
+
{
|
|
2105
|
+
displayName: 'Tool Tags',
|
|
2106
|
+
name: 'toolTags',
|
|
2107
|
+
type: 'string',
|
|
2108
|
+
default: '',
|
|
2109
|
+
displayOptions: {
|
|
2110
|
+
show: {
|
|
2111
|
+
operation: ['tools'],
|
|
2112
|
+
toolsOperation: ['create', 'update', 'upsert'],
|
|
2113
|
+
},
|
|
2114
|
+
},
|
|
2115
|
+
description: 'Comma-separated tags for the tool',
|
|
2116
|
+
},
|
|
2117
|
+
{
|
|
2118
|
+
displayName: 'Blocks Operation',
|
|
2119
|
+
name: 'blocksOperation',
|
|
2120
|
+
type: 'options',
|
|
2121
|
+
required: true,
|
|
2122
|
+
noDataExpression: true,
|
|
2123
|
+
displayOptions: {
|
|
2124
|
+
show: {
|
|
2125
|
+
operation: ['blocks'],
|
|
2126
|
+
},
|
|
2127
|
+
},
|
|
2128
|
+
options: [
|
|
2129
|
+
{
|
|
2130
|
+
name: 'List Blocks',
|
|
2131
|
+
value: 'list',
|
|
2132
|
+
description: 'List all memory blocks',
|
|
2133
|
+
action: 'List blocks',
|
|
2134
|
+
},
|
|
2135
|
+
{
|
|
2136
|
+
name: 'Create Block',
|
|
2137
|
+
value: 'create',
|
|
2138
|
+
description: 'Create a new memory block',
|
|
2139
|
+
action: 'Create block',
|
|
2140
|
+
},
|
|
2141
|
+
{
|
|
2142
|
+
name: 'Get Block',
|
|
2143
|
+
value: 'retrieve',
|
|
2144
|
+
description: 'Get a specific memory block',
|
|
2145
|
+
action: 'Get block',
|
|
2146
|
+
},
|
|
2147
|
+
{
|
|
2148
|
+
name: 'Update Block',
|
|
2149
|
+
value: 'update',
|
|
2150
|
+
description: 'Update an existing memory block',
|
|
2151
|
+
action: 'Update block',
|
|
2152
|
+
},
|
|
2153
|
+
{
|
|
2154
|
+
name: 'Delete Block',
|
|
2155
|
+
value: 'delete',
|
|
2156
|
+
description: 'Delete a memory block',
|
|
2157
|
+
action: 'Delete block',
|
|
2158
|
+
},
|
|
2159
|
+
],
|
|
2160
|
+
default: 'list',
|
|
2161
|
+
description: 'The blocks operation to perform',
|
|
2162
|
+
},
|
|
2163
|
+
{
|
|
2164
|
+
displayName: 'Block ID',
|
|
2165
|
+
name: 'blockId',
|
|
2166
|
+
type: 'string',
|
|
2167
|
+
required: true,
|
|
2168
|
+
displayOptions: {
|
|
2169
|
+
show: {
|
|
2170
|
+
operation: ['blocks'],
|
|
2171
|
+
blocksOperation: ['retrieve', 'update', 'delete'],
|
|
2172
|
+
},
|
|
2173
|
+
},
|
|
2174
|
+
default: '',
|
|
2175
|
+
description: 'The ID of the memory block',
|
|
2176
|
+
},
|
|
2177
|
+
{
|
|
2178
|
+
displayName: 'Block Label',
|
|
2179
|
+
name: 'blockLabel',
|
|
2180
|
+
type: 'string',
|
|
2181
|
+
required: true,
|
|
2182
|
+
displayOptions: {
|
|
2183
|
+
show: {
|
|
2184
|
+
operation: ['blocks'],
|
|
2185
|
+
blocksOperation: ['create', 'update'],
|
|
2186
|
+
},
|
|
2187
|
+
},
|
|
2188
|
+
default: '',
|
|
2189
|
+
description: 'The label for the memory block',
|
|
2190
|
+
},
|
|
2191
|
+
{
|
|
2192
|
+
displayName: 'Block Value',
|
|
2193
|
+
name: 'blockValue',
|
|
2194
|
+
type: 'string',
|
|
2195
|
+
typeOptions: {
|
|
2196
|
+
rows: 4,
|
|
2197
|
+
},
|
|
2198
|
+
required: true,
|
|
2199
|
+
displayOptions: {
|
|
2200
|
+
show: {
|
|
2201
|
+
operation: ['blocks'],
|
|
2202
|
+
blocksOperation: ['create', 'update'],
|
|
2203
|
+
},
|
|
2204
|
+
},
|
|
2205
|
+
default: '',
|
|
2206
|
+
description: 'The content of the memory block',
|
|
2207
|
+
},
|
|
2208
|
+
{
|
|
2209
|
+
displayName: 'Block Limit',
|
|
2210
|
+
name: 'blockLimit',
|
|
2211
|
+
type: 'number',
|
|
2212
|
+
default: 50,
|
|
2213
|
+
typeOptions: {
|
|
2214
|
+
minValue: 1,
|
|
2215
|
+
maxValue: 1000,
|
|
2216
|
+
},
|
|
2217
|
+
displayOptions: {
|
|
2218
|
+
show: {
|
|
2219
|
+
operation: ['blocks'],
|
|
2220
|
+
blocksOperation: ['list'],
|
|
2221
|
+
},
|
|
2222
|
+
},
|
|
2223
|
+
description: 'Maximum number of blocks to return',
|
|
2224
|
+
},
|
|
2225
|
+
{
|
|
2226
|
+
displayName: 'Folders Operation',
|
|
2227
|
+
name: 'foldersOperation',
|
|
2228
|
+
type: 'options',
|
|
2229
|
+
required: true,
|
|
2230
|
+
noDataExpression: true,
|
|
2231
|
+
displayOptions: {
|
|
2232
|
+
show: {
|
|
2233
|
+
operation: ['folders'],
|
|
2234
|
+
},
|
|
2235
|
+
},
|
|
2236
|
+
options: [
|
|
2237
|
+
{
|
|
2238
|
+
name: 'List Folders',
|
|
2239
|
+
value: 'list',
|
|
2240
|
+
description: 'List all folders',
|
|
2241
|
+
action: 'List folders',
|
|
2242
|
+
},
|
|
2243
|
+
{
|
|
2244
|
+
name: 'Create Folder',
|
|
2245
|
+
value: 'create',
|
|
2246
|
+
description: 'Create a new folder',
|
|
2247
|
+
action: 'Create folder',
|
|
2248
|
+
},
|
|
2249
|
+
{
|
|
2250
|
+
name: 'Get Folder',
|
|
2251
|
+
value: 'retrieve',
|
|
2252
|
+
description: 'Get a specific folder',
|
|
2253
|
+
action: 'Get folder',
|
|
2254
|
+
},
|
|
2255
|
+
{
|
|
2256
|
+
name: 'Update Folder',
|
|
2257
|
+
value: 'update',
|
|
2258
|
+
description: 'Update an existing folder',
|
|
2259
|
+
action: 'Update folder',
|
|
2260
|
+
},
|
|
2261
|
+
{
|
|
2262
|
+
name: 'Delete Folder',
|
|
2263
|
+
value: 'delete',
|
|
2264
|
+
description: 'Delete a folder',
|
|
2265
|
+
action: 'Delete folder',
|
|
2266
|
+
},
|
|
2267
|
+
],
|
|
2268
|
+
default: 'list',
|
|
2269
|
+
description: 'The folders operation to perform',
|
|
2270
|
+
},
|
|
2271
|
+
{
|
|
2272
|
+
displayName: 'Folder ID',
|
|
2273
|
+
name: 'folderId',
|
|
2274
|
+
type: 'string',
|
|
2275
|
+
required: true,
|
|
2276
|
+
displayOptions: {
|
|
2277
|
+
show: {
|
|
2278
|
+
operation: ['folders'],
|
|
2279
|
+
foldersOperation: ['retrieve', 'update', 'delete'],
|
|
2280
|
+
},
|
|
2281
|
+
},
|
|
2282
|
+
default: '',
|
|
2283
|
+
description: 'The ID of the folder',
|
|
2284
|
+
},
|
|
2285
|
+
{
|
|
2286
|
+
displayName: 'Folder Name',
|
|
2287
|
+
name: 'folderName',
|
|
2288
|
+
type: 'string',
|
|
2289
|
+
required: true,
|
|
2290
|
+
displayOptions: {
|
|
2291
|
+
show: {
|
|
2292
|
+
operation: ['folders'],
|
|
2293
|
+
foldersOperation: ['create', 'update'],
|
|
2294
|
+
},
|
|
2295
|
+
},
|
|
2296
|
+
default: '',
|
|
2297
|
+
description: 'The name of the folder',
|
|
2298
|
+
},
|
|
2299
|
+
{
|
|
2300
|
+
displayName: 'Embedding Config',
|
|
2301
|
+
name: 'embeddingConfig',
|
|
2302
|
+
type: 'string',
|
|
2303
|
+
displayOptions: {
|
|
2304
|
+
show: {
|
|
2305
|
+
operation: ['folders'],
|
|
2306
|
+
foldersOperation: ['create', 'update'],
|
|
2307
|
+
},
|
|
2308
|
+
},
|
|
2309
|
+
default: '',
|
|
2310
|
+
description: 'The embedding configuration for the folder',
|
|
2311
|
+
},
|
|
2312
|
+
{
|
|
2313
|
+
displayName: 'MCP Servers Operation',
|
|
2314
|
+
name: 'mcpServersOperation',
|
|
2315
|
+
type: 'options',
|
|
2316
|
+
required: true,
|
|
2317
|
+
noDataExpression: true,
|
|
2318
|
+
displayOptions: {
|
|
2319
|
+
show: {
|
|
2320
|
+
operation: ['mcpServers'],
|
|
2321
|
+
},
|
|
2322
|
+
},
|
|
2323
|
+
options: [
|
|
2324
|
+
{
|
|
2325
|
+
name: 'List MCP Servers',
|
|
2326
|
+
value: 'list',
|
|
2327
|
+
description: 'List all MCP servers',
|
|
2328
|
+
action: 'List MCP servers',
|
|
2329
|
+
},
|
|
2330
|
+
{
|
|
2331
|
+
name: 'Create MCP Server',
|
|
2332
|
+
value: 'create',
|
|
2333
|
+
description: 'Create a new MCP server',
|
|
2334
|
+
action: 'Create MCP server',
|
|
2335
|
+
},
|
|
2336
|
+
{
|
|
2337
|
+
name: 'Get MCP Server',
|
|
2338
|
+
value: 'retrieve',
|
|
2339
|
+
description: 'Get a specific MCP server',
|
|
2340
|
+
action: 'Get MCP server',
|
|
2341
|
+
},
|
|
2342
|
+
{
|
|
2343
|
+
name: 'Update MCP Server',
|
|
2344
|
+
value: 'update',
|
|
2345
|
+
description: 'Update an existing MCP server',
|
|
2346
|
+
action: 'Update MCP server',
|
|
2347
|
+
},
|
|
2348
|
+
{
|
|
2349
|
+
name: 'Delete MCP Server',
|
|
2350
|
+
value: 'delete',
|
|
2351
|
+
description: 'Delete an MCP server',
|
|
2352
|
+
action: 'Delete MCP server',
|
|
2353
|
+
},
|
|
2354
|
+
{
|
|
2355
|
+
name: 'Refresh MCP Server',
|
|
2356
|
+
value: 'refresh',
|
|
2357
|
+
description: 'Refresh an MCP server',
|
|
2358
|
+
action: 'Refresh MCP server',
|
|
2359
|
+
},
|
|
2360
|
+
],
|
|
2361
|
+
default: 'list',
|
|
2362
|
+
description: 'The MCP servers operation to perform',
|
|
2363
|
+
},
|
|
2364
|
+
{
|
|
2365
|
+
displayName: 'MCP Server ID',
|
|
2366
|
+
name: 'mcpServerId',
|
|
2367
|
+
type: 'string',
|
|
2368
|
+
required: true,
|
|
2369
|
+
displayOptions: {
|
|
2370
|
+
show: {
|
|
2371
|
+
operation: ['mcpServers'],
|
|
2372
|
+
mcpServersOperation: ['retrieve', 'update', 'delete', 'refresh'],
|
|
2373
|
+
},
|
|
2374
|
+
},
|
|
2375
|
+
default: '',
|
|
2376
|
+
description: 'The ID of the MCP server',
|
|
2377
|
+
},
|
|
2378
|
+
{
|
|
2379
|
+
displayName: 'MCP Server Name',
|
|
2380
|
+
name: 'mcpServerName',
|
|
2381
|
+
type: 'string',
|
|
2382
|
+
required: true,
|
|
2383
|
+
displayOptions: {
|
|
2384
|
+
show: {
|
|
2385
|
+
operation: ['mcpServers'],
|
|
2386
|
+
mcpServersOperation: ['create', 'update'],
|
|
2387
|
+
},
|
|
2388
|
+
},
|
|
2389
|
+
default: '',
|
|
2390
|
+
description: 'The name of the MCP server',
|
|
2391
|
+
},
|
|
2392
|
+
{
|
|
2393
|
+
displayName: 'MCP Server Command',
|
|
2394
|
+
name: 'mcpServerCommand',
|
|
2395
|
+
type: 'string',
|
|
2396
|
+
required: true,
|
|
2397
|
+
displayOptions: {
|
|
2398
|
+
show: {
|
|
2399
|
+
operation: ['mcpServers'],
|
|
2400
|
+
mcpServersOperation: ['create', 'update'],
|
|
2401
|
+
},
|
|
2402
|
+
},
|
|
2403
|
+
default: '',
|
|
2404
|
+
description: 'The command to run the MCP server',
|
|
2405
|
+
},
|
|
2406
|
+
{
|
|
2407
|
+
displayName: 'MCP Servers Operation',
|
|
2408
|
+
name: 'mcpServersOperation',
|
|
2409
|
+
type: 'options',
|
|
2410
|
+
required: true,
|
|
2411
|
+
noDataExpression: true,
|
|
2412
|
+
displayOptions: {
|
|
2413
|
+
show: {
|
|
2414
|
+
operation: ['mcpServers'],
|
|
2415
|
+
},
|
|
2416
|
+
},
|
|
2417
|
+
options: [
|
|
2418
|
+
{
|
|
2419
|
+
name: 'List MCP Servers',
|
|
2420
|
+
value: 'list',
|
|
2421
|
+
description: 'List all MCP servers',
|
|
2422
|
+
action: 'List MCP servers',
|
|
2423
|
+
},
|
|
2424
|
+
{
|
|
2425
|
+
name: 'Create MCP Server',
|
|
2426
|
+
value: 'create',
|
|
2427
|
+
description: 'Create a new MCP server',
|
|
2428
|
+
action: 'Create MCP server',
|
|
2429
|
+
},
|
|
2430
|
+
{
|
|
2431
|
+
name: 'Get MCP Server',
|
|
2432
|
+
value: 'retrieve',
|
|
2433
|
+
description: 'Get a specific MCP server',
|
|
2434
|
+
action: 'Get MCP server',
|
|
2435
|
+
},
|
|
2436
|
+
{
|
|
2437
|
+
name: 'Update MCP Server',
|
|
2438
|
+
value: 'update',
|
|
2439
|
+
description: 'Update an existing MCP server',
|
|
2440
|
+
action: 'Update MCP server',
|
|
2441
|
+
},
|
|
2442
|
+
{
|
|
2443
|
+
name: 'Delete MCP Server',
|
|
2444
|
+
value: 'delete',
|
|
2445
|
+
description: 'Delete an MCP server',
|
|
2446
|
+
action: 'Delete MCP server',
|
|
2447
|
+
},
|
|
2448
|
+
{
|
|
2449
|
+
name: 'Refresh MCP Server',
|
|
2450
|
+
value: 'refresh',
|
|
2451
|
+
description: 'Refresh an MCP server',
|
|
2452
|
+
action: 'Refresh MCP server',
|
|
2453
|
+
},
|
|
2454
|
+
],
|
|
2455
|
+
default: 'list',
|
|
2456
|
+
description: 'The MCP servers operation to perform',
|
|
2457
|
+
},
|
|
2458
|
+
{
|
|
2459
|
+
displayName: 'MCP Server ID',
|
|
2460
|
+
name: 'mcpServerId',
|
|
2461
|
+
type: 'string',
|
|
2462
|
+
required: true,
|
|
2463
|
+
displayOptions: {
|
|
2464
|
+
show: {
|
|
2465
|
+
operation: ['mcpServers'],
|
|
2466
|
+
mcpServersOperation: ['retrieve', 'update', 'delete', 'refresh'],
|
|
2467
|
+
},
|
|
2468
|
+
},
|
|
2469
|
+
default: '',
|
|
2470
|
+
description: 'The ID of the MCP server',
|
|
2471
|
+
},
|
|
2472
|
+
{
|
|
2473
|
+
displayName: 'MCP Server Name',
|
|
2474
|
+
name: 'mcpServerName',
|
|
2475
|
+
type: 'string',
|
|
2476
|
+
required: true,
|
|
2477
|
+
displayOptions: {
|
|
2478
|
+
show: {
|
|
2479
|
+
operation: ['mcpServers'],
|
|
2480
|
+
mcpServersOperation: ['create', 'update'],
|
|
2481
|
+
},
|
|
2482
|
+
},
|
|
2483
|
+
default: '',
|
|
2484
|
+
description: 'The name of the MCP server',
|
|
2485
|
+
},
|
|
2486
|
+
{
|
|
2487
|
+
displayName: 'MCP Server Command',
|
|
2488
|
+
name: 'mcpServerCommand',
|
|
2489
|
+
type: 'string',
|
|
2490
|
+
required: true,
|
|
2491
|
+
displayOptions: {
|
|
2492
|
+
show: {
|
|
2493
|
+
operation: ['mcpServers'],
|
|
2494
|
+
mcpServersOperation: ['create', 'update'],
|
|
2495
|
+
},
|
|
2496
|
+
},
|
|
2497
|
+
default: '',
|
|
2498
|
+
description: 'The command to run the MCP server',
|
|
2499
|
+
},
|
|
2500
|
+
{
|
|
2501
|
+
displayName: 'Runs Operation',
|
|
2502
|
+
name: 'runsOperation',
|
|
2503
|
+
type: 'options',
|
|
2504
|
+
required: true,
|
|
2505
|
+
noDataExpression: true,
|
|
2506
|
+
displayOptions: {
|
|
2507
|
+
show: {
|
|
2508
|
+
operation: ['runs'],
|
|
2509
|
+
},
|
|
2510
|
+
},
|
|
2511
|
+
options: [
|
|
2512
|
+
{
|
|
2513
|
+
name: 'List Runs',
|
|
2514
|
+
value: 'list',
|
|
2515
|
+
description: 'List all runs',
|
|
2516
|
+
action: 'List runs',
|
|
2517
|
+
},
|
|
2518
|
+
{
|
|
2519
|
+
name: 'Get Run',
|
|
2520
|
+
value: 'retrieve',
|
|
2521
|
+
description: 'Get a specific run',
|
|
2522
|
+
action: 'Get run',
|
|
2523
|
+
},
|
|
2524
|
+
],
|
|
2525
|
+
default: 'list',
|
|
2526
|
+
description: 'The runs operation to perform',
|
|
2527
|
+
},
|
|
2528
|
+
{
|
|
2529
|
+
displayName: 'Run ID',
|
|
2530
|
+
name: 'runId',
|
|
2531
|
+
type: 'string',
|
|
2532
|
+
required: true,
|
|
2533
|
+
displayOptions: {
|
|
2534
|
+
show: {
|
|
2535
|
+
operation: ['runs'],
|
|
2536
|
+
runsOperation: ['retrieve'],
|
|
2537
|
+
},
|
|
2538
|
+
},
|
|
2539
|
+
default: '',
|
|
2540
|
+
description: 'The ID of the run',
|
|
2541
|
+
},
|
|
2542
|
+
{
|
|
2543
|
+
displayName: 'Steps Operation',
|
|
2544
|
+
name: 'stepsOperation',
|
|
2545
|
+
type: 'options',
|
|
2546
|
+
required: true,
|
|
2547
|
+
noDataExpression: true,
|
|
2548
|
+
displayOptions: {
|
|
2549
|
+
show: {
|
|
2550
|
+
operation: ['steps'],
|
|
2551
|
+
},
|
|
2552
|
+
},
|
|
2553
|
+
options: [
|
|
2554
|
+
{
|
|
2555
|
+
name: 'List Steps',
|
|
2556
|
+
value: 'list',
|
|
2557
|
+
description: 'List all steps',
|
|
2558
|
+
action: 'List steps',
|
|
2559
|
+
},
|
|
2560
|
+
{
|
|
2561
|
+
name: 'Get Step',
|
|
2562
|
+
value: 'retrieve',
|
|
2563
|
+
description: 'Get a specific step',
|
|
2564
|
+
action: 'Get step',
|
|
2565
|
+
},
|
|
2566
|
+
],
|
|
2567
|
+
default: 'list',
|
|
2568
|
+
description: 'The steps operation to perform',
|
|
2569
|
+
},
|
|
2570
|
+
{
|
|
2571
|
+
displayName: 'Step ID',
|
|
2572
|
+
name: 'stepId',
|
|
2573
|
+
type: 'string',
|
|
2574
|
+
required: true,
|
|
2575
|
+
displayOptions: {
|
|
2576
|
+
show: {
|
|
2577
|
+
operation: ['steps'],
|
|
2578
|
+
stepsOperation: ['retrieve'],
|
|
2579
|
+
},
|
|
2580
|
+
},
|
|
2581
|
+
default: '',
|
|
2582
|
+
description: 'The ID of the step',
|
|
2583
|
+
},
|
|
2584
|
+
{
|
|
2585
|
+
displayName: 'Template Operation',
|
|
2586
|
+
name: 'templateOperation',
|
|
2587
|
+
type: 'options',
|
|
2588
|
+
required: true,
|
|
2589
|
+
noDataExpression: true,
|
|
2590
|
+
displayOptions: {
|
|
2591
|
+
show: {
|
|
2592
|
+
operation: ['templates'],
|
|
2593
|
+
},
|
|
2594
|
+
},
|
|
2595
|
+
options: [
|
|
2596
|
+
{
|
|
2597
|
+
name: 'Create Agent from Template',
|
|
2598
|
+
value: 'createAgent',
|
|
2599
|
+
description: 'Create an agent from a template',
|
|
2600
|
+
action: 'Create agent from template',
|
|
2601
|
+
},
|
|
2602
|
+
],
|
|
2603
|
+
default: 'createAgent',
|
|
2604
|
+
description: 'The template operation to perform',
|
|
2605
|
+
},
|
|
2606
|
+
{
|
|
2607
|
+
displayName: 'Template ID',
|
|
2608
|
+
name: 'templateId',
|
|
2609
|
+
type: 'string',
|
|
2610
|
+
required: true,
|
|
2611
|
+
displayOptions: {
|
|
2612
|
+
show: {
|
|
2613
|
+
operation: ['templates'],
|
|
2614
|
+
},
|
|
2615
|
+
},
|
|
2616
|
+
default: '',
|
|
2617
|
+
description: 'The ID of the template',
|
|
2618
|
+
},
|
|
2619
|
+
{
|
|
2620
|
+
displayName: 'Identities Operation',
|
|
2621
|
+
name: 'identitiesOperation',
|
|
2622
|
+
type: 'options',
|
|
2623
|
+
required: true,
|
|
2624
|
+
noDataExpression: true,
|
|
2625
|
+
displayOptions: {
|
|
2626
|
+
show: {
|
|
2627
|
+
operation: ['identities'],
|
|
2628
|
+
},
|
|
2629
|
+
},
|
|
2630
|
+
options: [
|
|
2631
|
+
{
|
|
2632
|
+
name: 'List Identities',
|
|
2633
|
+
value: 'list',
|
|
2634
|
+
description: 'List all identities',
|
|
2635
|
+
action: 'List identities',
|
|
2636
|
+
},
|
|
2637
|
+
{
|
|
2638
|
+
name: 'Create Identity',
|
|
2639
|
+
value: 'create',
|
|
2640
|
+
description: 'Create a new identity',
|
|
2641
|
+
action: 'Create identity',
|
|
2642
|
+
},
|
|
2643
|
+
{
|
|
2644
|
+
name: 'Upsert Identity',
|
|
2645
|
+
value: 'upsert',
|
|
2646
|
+
description: 'Create or update an identity',
|
|
2647
|
+
action: 'Upsert identity',
|
|
2648
|
+
},
|
|
2649
|
+
{
|
|
2650
|
+
name: 'Get Identity',
|
|
2651
|
+
value: 'retrieve',
|
|
2652
|
+
description: 'Get a specific identity',
|
|
2653
|
+
action: 'Get identity',
|
|
2654
|
+
},
|
|
2655
|
+
{
|
|
2656
|
+
name: 'Update Identity',
|
|
2657
|
+
value: 'update',
|
|
2658
|
+
description: 'Update an existing identity',
|
|
2659
|
+
action: 'Update identity',
|
|
2660
|
+
},
|
|
2661
|
+
{
|
|
2662
|
+
name: 'Delete Identity',
|
|
2663
|
+
value: 'delete',
|
|
2664
|
+
description: 'Delete an identity',
|
|
2665
|
+
action: 'Delete identity',
|
|
2666
|
+
},
|
|
2667
|
+
],
|
|
2668
|
+
default: 'list',
|
|
2669
|
+
description: 'The identities operation to perform',
|
|
2670
|
+
},
|
|
2671
|
+
{
|
|
2672
|
+
displayName: 'Identity ID',
|
|
2673
|
+
name: 'identityId',
|
|
2674
|
+
type: 'string',
|
|
2675
|
+
required: true,
|
|
2676
|
+
displayOptions: {
|
|
2677
|
+
show: {
|
|
2678
|
+
operation: ['identities'],
|
|
2679
|
+
identitiesOperation: ['retrieve', 'update', 'delete'],
|
|
2680
|
+
},
|
|
2681
|
+
},
|
|
2682
|
+
default: '',
|
|
2683
|
+
description: 'The ID of the identity',
|
|
2684
|
+
},
|
|
2685
|
+
{
|
|
2686
|
+
displayName: 'Identity Key',
|
|
2687
|
+
name: 'identityKey',
|
|
2688
|
+
type: 'string',
|
|
2689
|
+
required: true,
|
|
2690
|
+
displayOptions: {
|
|
2691
|
+
show: {
|
|
2692
|
+
operation: ['identities'],
|
|
2693
|
+
identitiesOperation: ['create', 'upsert', 'update'],
|
|
2694
|
+
},
|
|
2695
|
+
},
|
|
2696
|
+
default: '',
|
|
2697
|
+
description: 'The unique key for the identity',
|
|
2698
|
+
},
|
|
2699
|
+
{
|
|
2700
|
+
displayName: 'Identity Name',
|
|
2701
|
+
name: 'identityName',
|
|
2702
|
+
type: 'string',
|
|
2703
|
+
displayOptions: {
|
|
2704
|
+
show: {
|
|
2705
|
+
operation: ['identities'],
|
|
2706
|
+
identitiesOperation: ['create', 'upsert', 'update'],
|
|
2707
|
+
},
|
|
2708
|
+
},
|
|
2709
|
+
default: '',
|
|
2710
|
+
description: 'The name of the identity',
|
|
2711
|
+
},
|
|
2712
|
+
{
|
|
2713
|
+
displayName: 'Identity Type',
|
|
2714
|
+
name: 'identityType',
|
|
2715
|
+
type: 'options',
|
|
2716
|
+
options: [
|
|
2717
|
+
{ name: 'User', value: 'user' },
|
|
2718
|
+
{ name: 'Organization', value: 'org' },
|
|
2719
|
+
{ name: 'Other', value: 'other' },
|
|
2720
|
+
],
|
|
2721
|
+
default: 'user',
|
|
2722
|
+
displayOptions: {
|
|
2723
|
+
show: {
|
|
2724
|
+
operation: ['identities'],
|
|
2725
|
+
identitiesOperation: ['create', 'upsert', 'update'],
|
|
2726
|
+
},
|
|
2727
|
+
},
|
|
2728
|
+
description: 'The type of identity',
|
|
2729
|
+
},
|
|
2730
|
+
{
|
|
2731
|
+
displayName: 'Groups Operation',
|
|
2732
|
+
name: 'groupsOperation',
|
|
2733
|
+
type: 'options',
|
|
2734
|
+
required: true,
|
|
2735
|
+
noDataExpression: true,
|
|
2736
|
+
displayOptions: {
|
|
2737
|
+
show: {
|
|
2738
|
+
operation: ['groups'],
|
|
2739
|
+
},
|
|
2740
|
+
},
|
|
2741
|
+
options: [
|
|
2742
|
+
{
|
|
2743
|
+
name: 'List Groups',
|
|
2744
|
+
value: 'list',
|
|
2745
|
+
description: 'List all groups',
|
|
2746
|
+
action: 'List groups',
|
|
2747
|
+
},
|
|
2748
|
+
{
|
|
2749
|
+
name: 'Create Group',
|
|
2750
|
+
value: 'create',
|
|
2751
|
+
description: 'Create a new group',
|
|
2752
|
+
action: 'Create group',
|
|
2753
|
+
},
|
|
2754
|
+
{
|
|
2755
|
+
name: 'Get Group',
|
|
2756
|
+
value: 'retrieve',
|
|
2757
|
+
description: 'Get a specific group',
|
|
2758
|
+
action: 'Get group',
|
|
2759
|
+
},
|
|
2760
|
+
{
|
|
2761
|
+
name: 'Update Group',
|
|
2762
|
+
value: 'update',
|
|
2763
|
+
description: 'Update an existing group',
|
|
2764
|
+
action: 'Update group',
|
|
2765
|
+
},
|
|
2766
|
+
{
|
|
2767
|
+
name: 'Delete Group',
|
|
2768
|
+
value: 'delete',
|
|
2769
|
+
description: 'Delete a group',
|
|
2770
|
+
action: 'Delete group',
|
|
2771
|
+
},
|
|
2772
|
+
],
|
|
2773
|
+
default: 'list',
|
|
2774
|
+
description: 'The groups operation to perform',
|
|
2775
|
+
},
|
|
2776
|
+
{
|
|
2777
|
+
displayName: 'Group ID',
|
|
2778
|
+
name: 'groupId',
|
|
2779
|
+
type: 'string',
|
|
2780
|
+
required: true,
|
|
2781
|
+
displayOptions: {
|
|
2782
|
+
show: {
|
|
2783
|
+
operation: ['groups'],
|
|
2784
|
+
groupsOperation: ['retrieve', 'update', 'delete'],
|
|
2785
|
+
},
|
|
2786
|
+
},
|
|
2787
|
+
default: '',
|
|
2788
|
+
description: 'The ID of the group',
|
|
2789
|
+
},
|
|
2790
|
+
{
|
|
2791
|
+
displayName: 'Group Name',
|
|
2792
|
+
name: 'groupName',
|
|
2793
|
+
type: 'string',
|
|
2794
|
+
required: true,
|
|
2795
|
+
displayOptions: {
|
|
2796
|
+
show: {
|
|
2797
|
+
operation: ['groups'],
|
|
2798
|
+
groupsOperation: ['create', 'update'],
|
|
2799
|
+
},
|
|
2800
|
+
},
|
|
2801
|
+
default: '',
|
|
2802
|
+
description: 'The name of the group',
|
|
2803
|
+
},
|
|
2804
|
+
{
|
|
2805
|
+
displayName: 'Batches Operation',
|
|
2806
|
+
name: 'batchesOperation',
|
|
2807
|
+
type: 'options',
|
|
2808
|
+
required: true,
|
|
2809
|
+
noDataExpression: true,
|
|
2810
|
+
displayOptions: {
|
|
2811
|
+
show: {
|
|
2812
|
+
operation: ['batches'],
|
|
2813
|
+
},
|
|
2814
|
+
},
|
|
2815
|
+
options: [
|
|
2816
|
+
{
|
|
2817
|
+
name: 'List Batches',
|
|
2818
|
+
value: 'list',
|
|
2819
|
+
description: 'List all batches',
|
|
2820
|
+
action: 'List batches',
|
|
2821
|
+
},
|
|
2822
|
+
{
|
|
2823
|
+
name: 'Create Batch',
|
|
2824
|
+
value: 'create',
|
|
2825
|
+
description: 'Create a new batch',
|
|
2826
|
+
action: 'Create batch',
|
|
2827
|
+
},
|
|
2828
|
+
{
|
|
2829
|
+
name: 'Get Batch',
|
|
2830
|
+
value: 'retrieve',
|
|
2831
|
+
description: 'Get a specific batch',
|
|
2832
|
+
action: 'Get batch',
|
|
2833
|
+
},
|
|
2834
|
+
{
|
|
2835
|
+
name: 'Cancel Batch',
|
|
2836
|
+
value: 'cancel',
|
|
2837
|
+
description: 'Cancel a batch',
|
|
2838
|
+
action: 'Cancel batch',
|
|
2839
|
+
},
|
|
2840
|
+
],
|
|
2841
|
+
default: 'list',
|
|
2842
|
+
description: 'The batches operation to perform',
|
|
2843
|
+
},
|
|
2844
|
+
{
|
|
2845
|
+
displayName: 'Batch ID',
|
|
2846
|
+
name: 'batchId',
|
|
2847
|
+
type: 'string',
|
|
2848
|
+
required: true,
|
|
2849
|
+
displayOptions: {
|
|
2850
|
+
show: {
|
|
2851
|
+
operation: ['batches'],
|
|
2852
|
+
batchesOperation: ['retrieve', 'cancel'],
|
|
2853
|
+
},
|
|
2854
|
+
},
|
|
2855
|
+
default: '',
|
|
2856
|
+
description: 'The ID of the batch',
|
|
2857
|
+
},
|
|
824
2858
|
],
|
|
825
2859
|
},
|
|
826
2860
|
{
|
|
@@ -1318,6 +3352,54 @@ exports.UNIVERSAL_AGENT_DESCRIPTION = {
|
|
|
1318
3352
|
description: 'Send a message to an agent and receive a response',
|
|
1319
3353
|
action: 'Chat with agent',
|
|
1320
3354
|
},
|
|
3355
|
+
{
|
|
3356
|
+
name: 'Agent Messages',
|
|
3357
|
+
value: 'agentMessages',
|
|
3358
|
+
description: 'List, create, stream, or manage agent messages',
|
|
3359
|
+
action: 'Manage agent messages',
|
|
3360
|
+
},
|
|
3361
|
+
{
|
|
3362
|
+
name: 'Agent Blocks',
|
|
3363
|
+
value: 'agentBlocks',
|
|
3364
|
+
description: 'Manage memory blocks attached to agents',
|
|
3365
|
+
action: 'Manage agent blocks',
|
|
3366
|
+
},
|
|
3367
|
+
{
|
|
3368
|
+
name: 'Agent Tools',
|
|
3369
|
+
value: 'agentTools',
|
|
3370
|
+
description: 'Manage tools attached to agents',
|
|
3371
|
+
action: 'Manage agent tools',
|
|
3372
|
+
},
|
|
3373
|
+
{
|
|
3374
|
+
name: 'Agent Folders',
|
|
3375
|
+
value: 'agentFolders',
|
|
3376
|
+
description: 'Manage folders attached to agents',
|
|
3377
|
+
action: 'Manage agent folders',
|
|
3378
|
+
},
|
|
3379
|
+
{
|
|
3380
|
+
name: 'Agent Files',
|
|
3381
|
+
value: 'agentFiles',
|
|
3382
|
+
description: 'Manage files opened by agents',
|
|
3383
|
+
action: 'Manage agent files',
|
|
3384
|
+
},
|
|
3385
|
+
{
|
|
3386
|
+
name: 'Agent Archives',
|
|
3387
|
+
value: 'agentArchives',
|
|
3388
|
+
description: 'Manage archives attached to agents',
|
|
3389
|
+
action: 'Manage agent archives',
|
|
3390
|
+
},
|
|
3391
|
+
{
|
|
3392
|
+
name: 'Agent Identities',
|
|
3393
|
+
value: 'agentIdentities',
|
|
3394
|
+
description: 'Manage identities attached to agents',
|
|
3395
|
+
action: 'Manage agent identities',
|
|
3396
|
+
},
|
|
3397
|
+
{
|
|
3398
|
+
name: 'Agent Groups',
|
|
3399
|
+
value: 'agentGroups',
|
|
3400
|
+
description: 'List agent groups',
|
|
3401
|
+
action: 'List agent groups',
|
|
3402
|
+
},
|
|
1321
3403
|
{
|
|
1322
3404
|
name: 'Create Agent',
|
|
1323
3405
|
value: 'createAgent',
|
|
@@ -1331,10 +3413,82 @@ exports.UNIVERSAL_AGENT_DESCRIPTION = {
|
|
|
1331
3413
|
action: 'Manage agent',
|
|
1332
3414
|
},
|
|
1333
3415
|
{
|
|
1334
|
-
name: '
|
|
1335
|
-
value: '
|
|
1336
|
-
description: 'Create
|
|
1337
|
-
action: 'Manage
|
|
3416
|
+
name: 'Tools',
|
|
3417
|
+
value: 'tools',
|
|
3418
|
+
description: 'Create, read, update, delete tools',
|
|
3419
|
+
action: 'Manage tools',
|
|
3420
|
+
},
|
|
3421
|
+
{
|
|
3422
|
+
name: 'Blocks',
|
|
3423
|
+
value: 'blocks',
|
|
3424
|
+
description: 'Create, read, update, delete memory blocks',
|
|
3425
|
+
action: 'Manage blocks',
|
|
3426
|
+
},
|
|
3427
|
+
{
|
|
3428
|
+
name: 'Archives',
|
|
3429
|
+
value: 'archives',
|
|
3430
|
+
description: 'Create, read, update, delete archives and passages',
|
|
3431
|
+
action: 'Manage archives',
|
|
3432
|
+
},
|
|
3433
|
+
{
|
|
3434
|
+
name: 'Folders',
|
|
3435
|
+
value: 'folders',
|
|
3436
|
+
description: 'Create, read, update, delete folders and manage files',
|
|
3437
|
+
action: 'Manage folders',
|
|
3438
|
+
},
|
|
3439
|
+
{
|
|
3440
|
+
name: 'Models',
|
|
3441
|
+
value: 'models',
|
|
3442
|
+
description: 'List available models and embeddings',
|
|
3443
|
+
action: 'List models',
|
|
3444
|
+
},
|
|
3445
|
+
{
|
|
3446
|
+
name: 'MCP Servers',
|
|
3447
|
+
value: 'mcpServers',
|
|
3448
|
+
description: 'Manage Model Context Protocol servers',
|
|
3449
|
+
action: 'Manage MCP servers',
|
|
3450
|
+
},
|
|
3451
|
+
{
|
|
3452
|
+
name: 'Runs',
|
|
3453
|
+
value: 'runs',
|
|
3454
|
+
description: 'List and retrieve agent runs',
|
|
3455
|
+
action: 'Manage runs',
|
|
3456
|
+
},
|
|
3457
|
+
{
|
|
3458
|
+
name: 'Steps',
|
|
3459
|
+
value: 'steps',
|
|
3460
|
+
description: 'List and retrieve agent steps',
|
|
3461
|
+
action: 'Manage steps',
|
|
3462
|
+
},
|
|
3463
|
+
{
|
|
3464
|
+
name: 'Templates',
|
|
3465
|
+
value: 'templates',
|
|
3466
|
+
description: 'Create agents from templates',
|
|
3467
|
+
action: 'Use templates',
|
|
3468
|
+
},
|
|
3469
|
+
{
|
|
3470
|
+
name: 'Tags',
|
|
3471
|
+
value: 'tags',
|
|
3472
|
+
description: 'List available tags',
|
|
3473
|
+
action: 'List tags',
|
|
3474
|
+
},
|
|
3475
|
+
{
|
|
3476
|
+
name: 'Identities',
|
|
3477
|
+
value: 'identities',
|
|
3478
|
+
description: 'Create, read, update, delete identities',
|
|
3479
|
+
action: 'Manage identities',
|
|
3480
|
+
},
|
|
3481
|
+
{
|
|
3482
|
+
name: 'Groups',
|
|
3483
|
+
value: 'groups',
|
|
3484
|
+
description: 'Create, read, update, delete groups and messages',
|
|
3485
|
+
action: 'Manage groups',
|
|
3486
|
+
},
|
|
3487
|
+
{
|
|
3488
|
+
name: 'Batches',
|
|
3489
|
+
value: 'batches',
|
|
3490
|
+
description: 'Create, read, update, delete batches and messages',
|
|
3491
|
+
action: 'Manage batches',
|
|
1338
3492
|
},
|
|
1339
3493
|
],
|
|
1340
3494
|
default: 'chat',
|
|
@@ -1944,10 +4098,18 @@ exports.UNIVERSAL_AGENT_DESCRIPTION = {
|
|
|
1944
4098
|
displayName: 'Secret',
|
|
1945
4099
|
values: [
|
|
1946
4100
|
{
|
|
1947
|
-
displayName: '
|
|
1948
|
-
name: '
|
|
4101
|
+
displayName: 'Value',
|
|
4102
|
+
name: 'value',
|
|
1949
4103
|
type: 'string',
|
|
1950
4104
|
default: '',
|
|
4105
|
+
description: 'The content to store in the memory block. Can be a simple string, JSON, or any text-based data.',
|
|
4106
|
+
},
|
|
4107
|
+
{
|
|
4108
|
+
displayName: 'Description',
|
|
4109
|
+
name: 'description',
|
|
4110
|
+
type: 'string',
|
|
4111
|
+
default: '',
|
|
4112
|
+
description: 'A description of what this memory block contains and how it should be used.',
|
|
1951
4113
|
},
|
|
1952
4114
|
{
|
|
1953
4115
|
displayName: 'Value',
|
|
@@ -2134,18 +4296,32 @@ exports.UNIVERSAL_AGENT_DESCRIPTION = {
|
|
|
2134
4296
|
description: 'A new description for the agent.',
|
|
2135
4297
|
},
|
|
2136
4298
|
{
|
|
2137
|
-
displayName: '
|
|
2138
|
-
name: '
|
|
4299
|
+
displayName: 'Value',
|
|
4300
|
+
name: 'value',
|
|
2139
4301
|
type: 'string',
|
|
2140
4302
|
default: '',
|
|
2141
|
-
description: '
|
|
4303
|
+
description: 'The content to store in the memory block. Can be a simple string, JSON, or any text-based data.',
|
|
2142
4304
|
},
|
|
2143
4305
|
{
|
|
2144
|
-
displayName: '
|
|
2145
|
-
name: '
|
|
4306
|
+
displayName: 'Description',
|
|
4307
|
+
name: 'description',
|
|
4308
|
+
type: 'string',
|
|
4309
|
+
default: '',
|
|
4310
|
+
description: 'A description of what this memory block contains and how it should be used.',
|
|
4311
|
+
},
|
|
4312
|
+
{
|
|
4313
|
+
displayName: 'Value',
|
|
4314
|
+
name: 'value',
|
|
4315
|
+
type: 'string',
|
|
4316
|
+
default: '',
|
|
4317
|
+
description: 'The content to store in the memory block. Can be a simple string, JSON, or any text-based data.',
|
|
4318
|
+
},
|
|
4319
|
+
{
|
|
4320
|
+
displayName: 'Description',
|
|
4321
|
+
name: 'description',
|
|
2146
4322
|
type: 'string',
|
|
2147
4323
|
default: '',
|
|
2148
|
-
description: '
|
|
4324
|
+
description: 'A description of what this memory block contains and how it should be used.',
|
|
2149
4325
|
},
|
|
2150
4326
|
],
|
|
2151
4327
|
},
|