@ideascol/agents-generator-sdk 0.1.4 → 0.2.0

package/dist/bin/cli.js

@@ -598,7 +598,7 @@ var OpenAPI;
 var init_OpenAPI = __esm(() => {
   OpenAPI = {
     BASE: "",
-    VERSION: "main-6a6ce76bec2e854b841b630c73e9e239512aff88",
+    VERSION: "main-2ca05a009ba704a733f8de2cabfb9379a45d1b79",
     WITH_CREDENTIALS: false,
     CREDENTIALS: "include",
     TOKEN: undefined,
@@ -833,15 +833,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: {
@@ -1357,6 +1830,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() {
@@ -1382,16 +1928,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;
@@ -1418,6 +1973,17 @@ class AgentClient {
     this.root = RootService;
     this.fileLibrary = FileLibraryService;
     this.credentials = CredentialsService;
+    this.admin = {
+      agents: AdminAgentsService,
+      conversations: AdminConversationsService,
+      credentials: AdminCredentialsService,
+      fileLibrary: AdminFileLibraryService,
+      mcpServers: AdminMcpServersService
+    };
+    this.public = {
+      agents: PublicAgentsService,
+      conversations: PublicConversationsService
+    };
     this.conversationsStream = ConversationsServiceStream;
     this.ApiError = ApiError;
     this.CancelError = CancelError;
@@ -1631,7 +2197,10 @@ var init_agentsCommand = __esm(() => {
     action: async (args) => {
       const client = new lib_default({ apiUrl: args.URL, apiToken: "" });
       const agents = await client.agent.getAgents(0, 100);
+      const agents2 = await client.admin.agents.getAgents(0, 100);
+      const agent = await client.public.agents.getAgent("some-agent-id");
       console.log(agents);
+      console.log(agents2);
     }
   };
   agentsCommand_default = commandAgents;