@ideascol/agents-generator-sdk 0.1.5 → 0.2.1

package/dist/index.js

@@ -166,7 +166,7 @@ var OpenAPI;
 var init_OpenAPI = __esm(() => {
   OpenAPI = {
     BASE: "",
-    VERSION: "main-3d2b2b5639d0562a58dff0378bc3fe9f7068678b",
+    VERSION: "main-2ca05a009ba704a733f8de2cabfb9379a45d1b79",
     WITH_CREDENTIALS: false,
     CREDENTIALS: "include",
     TOKEN: undefined,
@@ -401,15 +401,488 @@ var init_request = __esm(() => {
   init_CancelablePromise();
 });
 
+// src/lib/clients/agents-generator/services/AdminAgentsService.ts
+class AdminAgentsService {
+  static createAgent(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/agents",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static getAgents(skip, limit = 100) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/agents",
+      query: {
+        skip,
+        limit
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static updateAgent(agentId, requestBody, userId) {
+    return request(OpenAPI, {
+      method: "PUT",
+      url: "/agents/{agent_id}",
+      path: {
+        agent_id: agentId
+      },
+      query: {
+        user_id: userId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static getAgent(agentId, userId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/agents/{agent_id}",
+      path: {
+        agent_id: agentId
+      },
+      query: {
+        user_id: userId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static deleteAgent(agentId, userId) {
+    return request(OpenAPI, {
+      method: "DELETE",
+      url: "/agents/{agent_id}",
+      path: {
+        agent_id: agentId
+      },
+      query: {
+        user_id: userId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static initializeAgent(agentId) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/agents/{agent_id}/initialize",
+      path: {
+        agent_id: agentId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static queryAgent(agentId, requestBody, userId, conversationId) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/agents/{agent_id}/query",
+      path: {
+        agent_id: agentId
+      },
+      query: {
+        user_id: userId,
+        conversation_id: conversationId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static getAgentStructure(agentId, userId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/agents/{agent_id}/structure",
+      path: {
+        agent_id: agentId
+      },
+      query: {
+        user_id: userId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static visualizeAgent(agentId, userId, format = "png") {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/agents/{agent_id}/visualize",
+      path: {
+        agent_id: agentId
+      },
+      query: {
+        user_id: userId,
+        format
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+}
+var init_AdminAgentsService = __esm(() => {
+  init_OpenAPI();
+  init_request();
+});
+
+// src/lib/clients/agents-generator/services/AdminConversationsService.ts
+class AdminConversationsService {
+  static createConversation(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/conversations",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static getConversation(conversationId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/conversations/{conversation_id}",
+      path: {
+        conversation_id: conversationId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static updateConversation(conversationId, requestBody) {
+    return request(OpenAPI, {
+      method: "PUT",
+      url: "/conversations/{conversation_id}",
+      path: {
+        conversation_id: conversationId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static deleteConversation(conversationId) {
+    return request(OpenAPI, {
+      method: "DELETE",
+      url: "/conversations/{conversation_id}",
+      path: {
+        conversation_id: conversationId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static getAgentConversations(agentId, skip, limit = 100) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/conversations/agent/{agent_id}",
+      path: {
+        agent_id: agentId
+      },
+      query: {
+        skip,
+        limit
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+}
+var init_AdminConversationsService = __esm(() => {
+  init_OpenAPI();
+  init_request();
+});
+
+// src/lib/clients/agents-generator/services/AdminCredentialsService.ts
+class AdminCredentialsService {
+  static getCredentials() {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/credentials"
+    });
+  }
+  static createCredential(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/credentials",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static getCredential(credentialId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/credentials/{credential_id}",
+      path: {
+        credential_id: credentialId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static updateCredential(credentialId, requestBody) {
+    return request(OpenAPI, {
+      method: "PUT",
+      url: "/credentials/{credential_id}",
+      path: {
+        credential_id: credentialId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static deleteCredential(credentialId) {
+    return request(OpenAPI, {
+      method: "DELETE",
+      url: "/credentials/{credential_id}",
+      path: {
+        credential_id: credentialId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static getCredentialDecrypted(credentialId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/credentials/{credential_id}/decrypt",
+      path: {
+        credential_id: credentialId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+}
+var init_AdminCredentialsService = __esm(() => {
+  init_OpenAPI();
+  init_request();
+});
+
+// src/lib/clients/agents-generator/services/AdminFileLibraryService.ts
+class AdminFileLibraryService {
+  static getBuckets() {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/file-library/buckets"
+    });
+  }
+  static createBucket(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/file-library/buckets",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static getBucket(bucketId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/file-library/buckets/{bucket_id}",
+      path: {
+        bucket_id: bucketId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static deleteBucket(bucketId) {
+    return request(OpenAPI, {
+      method: "DELETE",
+      url: "/file-library/buckets/{bucket_id}",
+      path: {
+        bucket_id: bucketId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static createFolder(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/file-library/folders",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static getFoldersByBucket(bucketId, parentFolderId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/file-library/buckets/{bucket_id}/folders",
+      path: {
+        bucket_id: bucketId
+      },
+      query: {
+        parent_folder_id: parentFolderId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static deleteFolder(folderId) {
+    return request(OpenAPI, {
+      method: "DELETE",
+      url: "/file-library/folders/{folder_id}",
+      path: {
+        folder_id: folderId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static uploadFile(folderId, formData) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/file-library/folders/{folder_id}/files",
+      path: {
+        folder_id: folderId
+      },
+      formData,
+      mediaType: "multipart/form-data",
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static getFilesByFolder(folderId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/file-library/folders/{folder_id}/files",
+      path: {
+        folder_id: folderId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static deleteFile(fileId) {
+    return request(OpenAPI, {
+      method: "DELETE",
+      url: "/file-library/files/{file_id}",
+      path: {
+        file_id: fileId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static uploadFolder(parentFolderId, requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/file-library/folders/{parent_folder_id}/upload-folder",
+      path: {
+        parent_folder_id: parentFolderId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static createFolderVectorStore(folderId) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/file-library/folders/{folder_id}/create-vector-store",
+      path: {
+        folder_id: folderId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+}
+var init_AdminFileLibraryService = __esm(() => {
+  init_OpenAPI();
+  init_request();
+});
+
+// src/lib/clients/agents-generator/services/AdminMcpServersService.ts
+class AdminMcpServersService {
+  static getMcpServersMcpServersGet() {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/mcp-servers"
+    });
+  }
+  static createMcpServerMcpServersPost(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/mcp-servers",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static getMcpServerMcpServersServerIdGet(serverId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/mcp-servers/{server_id}",
+      path: {
+        server_id: serverId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+}
+var init_AdminMcpServersService = __esm(() => {
+  init_OpenAPI();
+  init_request();
+});
+
 // src/lib/clients/agents-generator/services/AgentService.ts
 class AgentService {
-  static createAgent(requestBody, userId) {
+  static createAgent(requestBody) {
     return request(OpenAPI, {
       method: "POST",
       url: "/agents",
-      query: {
-        user_id: userId
-      },
       body: requestBody,
       mediaType: "application/json",
       errors: {
@@ -925,6 +1398,79 @@ var init_McpServersService = __esm(() => {
   init_request();
 });
 
+// src/lib/clients/agents-generator/services/PublicAgentsService.ts
+class PublicAgentsService {
+  static getAgent(agentId, userId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/agents/{agent_id}",
+      path: {
+        agent_id: agentId
+      },
+      query: {
+        user_id: userId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+}
+var init_PublicAgentsService = __esm(() => {
+  init_OpenAPI();
+  init_request();
+});
+
+// src/lib/clients/agents-generator/services/PublicConversationsService.ts
+class PublicConversationsService {
+  static createConversation(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/conversations",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static getConversation(conversationId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/conversations/{conversation_id}",
+      path: {
+        conversation_id: conversationId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static addMessage(conversationId, requestBody, accept) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/conversations/{conversation_id}/messages",
+      path: {
+        conversation_id: conversationId
+      },
+      headers: {
+        accept
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        404: `Conversation or agent not found`,
+        422: `Validation Error`,
+        500: `Server error`
+      }
+    });
+  }
+}
+var init_PublicConversationsService = __esm(() => {
+  init_OpenAPI();
+  init_request();
+});
+
 // src/lib/clients/agents-generator/services/RootService.ts
 class RootService {
   static root() {
@@ -950,16 +1496,25 @@ var init_agents_generator = __esm(() => {
   init_ApiError();
   init_CancelablePromise();
   init_OpenAPI();
+  init_AdminAgentsService();
+  init_AdminConversationsService();
+  init_AdminCredentialsService();
+  init_AdminFileLibraryService();
+  init_AdminMcpServersService();
   init_AgentService();
   init_ConversationsService();
   init_CredentialsService();
   init_FileLibraryService();
   init_McpServersService();
+  init_PublicAgentsService();
+  init_PublicConversationsService();
   init_RootService();
 });
 
 // src/lib/index.ts
 class AgentClient {
+  admin;
+  public;
   agent;
   conversations;
   mcpServers;
@@ -987,6 +1542,17 @@ class AgentClient {
     this.fileLibrary = FileLibraryService;
     this.credentials = CredentialsService;
     this.conversationsStream = ConversationsServiceStream;
+    this.admin = {
+      agents: AdminAgentsService,
+      conversations: AdminConversationsService,
+      credentials: AdminCredentialsService,
+      fileLibrary: AdminFileLibraryService,
+      mcpServers: AdminMcpServersService
+    };
+    this.public = {
+      agents: PublicAgentsService,
+      conversations: PublicConversationsServiceExtended
+    };
     this.ApiError = ApiError;
     this.CancelError = CancelError;
     this.CancelablePromise = CancelablePromise;
@@ -999,7 +1565,7 @@ class AgentClient {
     return ConversationsServiceStream.addMessage(conversationId, requestBody, "text/plain");
   }
 }
-var ConversationsServiceStream, lib_default;
+var ConversationsServiceStream, PublicConversationsServiceExtended, lib_default;
 var init_lib = __esm(() => {
   init_agents_generator();
   init_agents_generator();
@@ -1179,6 +1745,10 @@ var init_lib = __esm(() => {
       return () => controller.abort();
     }
   };
+  PublicConversationsServiceExtended = class PublicConversationsServiceExtended extends PublicConversationsService {
+    static sendMessageWithStreaming;
+    static sendMessage;
+  };
   lib_default = AgentClient;
 });
 
@@ -1186,6 +1756,8 @@ var init_lib = __esm(() => {
 var exports_src = {};
 __export(exports_src, {
   RootService: () => RootService,
+  PublicConversationsService: () => PublicConversationsService,
+  PublicAgentsService: () => PublicAgentsService,
   OpenAPI: () => OpenAPI,
   McpServersService: () => McpServersService,
   FileLibraryService: () => FileLibraryService,
@@ -1195,7 +1767,12 @@ __export(exports_src, {
   CancelError: () => CancelError,
   ApiError: () => ApiError,
   AgentService: () => AgentService,
-  AgentClient: () => AgentClient
+  AgentClient: () => AgentClient,
+  AdminMcpServersService: () => AdminMcpServersService,
+  AdminFileLibraryService: () => AdminFileLibraryService,
+  AdminCredentialsService: () => AdminCredentialsService,
+  AdminConversationsService: () => AdminConversationsService,
+  AdminAgentsService: () => AdminAgentsService
 });
 module.exports = __toCommonJS(exports_src);
 init_lib();

package/dist/lib/clients/agents-generator/index.d.ts

@@ -41,9 +41,16 @@ export type { NodeData } from './models/NodeData';
 export type { Position } from './models/Position';
 export type { UpdateMCPServerRequest } from './models/UpdateMCPServerRequest';
 export type { ValidationError } from './models/ValidationError';
+export { AdminAgentsService } from './services/AdminAgentsService';
+export { AdminConversationsService } from './services/AdminConversationsService';
+export { AdminCredentialsService } from './services/AdminCredentialsService';
+export { AdminFileLibraryService } from './services/AdminFileLibraryService';
+export { AdminMcpServersService } from './services/AdminMcpServersService';
 export { AgentService } from './services/AgentService';
 export { ConversationsService } from './services/ConversationsService';
 export { CredentialsService } from './services/CredentialsService';
 export { FileLibraryService } from './services/FileLibraryService';
 export { McpServersService } from './services/McpServersService';
+export { PublicAgentsService } from './services/PublicAgentsService';
+export { PublicConversationsService } from './services/PublicConversationsService';
 export { RootService } from './services/RootService';