Update components/agentcreation.py

components/agentcreation.py

@@ -0,0 +1,191 @@
+from groq import Groq
+import json
+from solders.keypair import Keypair
+from solana.rpc.async_api import AsyncClient
+from .mongodbconnection import provideClient
+
+
+client=provideClient()
+db=client["agentpaymentdb"]
+coll=db["agentpaymentcol"]
+
+rpc=AsyncClient("https://mainnet.helius-rpc.com/?api-key=4e833ada-d32c-48c5-b020-c11b2253f25b")
+
+
+def create_keypair(agent):
+        """Create a new keypair and return it as MongoDB-friendly format"""
+        keypair = Keypair()
+        keypair_data = {
+            "agent_id": agent,
+            "public_key": str(keypair.pubkey())
+            "secret_key": bytes(keypair).hex()
+        }
+        coll.update_one(
+                {"owner": data.owner},
+                {"$push": {"agents": keypair_data}}
+                )
+
+
+async def transfer_sol(from_keypair, to_pubkey, amount_sol):
+            """Transfer SOL from one account to another"""
+            try:
+                lamports = int(amount_sol * 1e9)
+            
+                transfer_ix = transfer(
+                    TransferParams(
+                        from_pubkey=from_keypair.pubkey(),
+                        to_pubkey=to_pubkey,
+                        lamports=lamports
+                    ))
+    
+                recent_blockhash =rpc.get_latest_blockhash()
+            
+                txn = Transaction(recent_blockhash=recent_blockhash.value.blockhash)
+                txn.add(transfer_ix)
+                txn.sign(from_keypair)
+                result = await rpc.client.send_transaction(txn, from_keypair)
+                print(f"✅ SOL Transfer successful!")
+                print(f"📝 Signature: {result.value}")
+                return True
+            
+            except Exception as e:
+                print(f"❌ Transfer failed: {e}")
+                return False
+
+
+def load_keypair(agent):
+            """Load keypair from file"""
+
+            documents=coll.find_one({"owner":"system"})
+            keypair=None
+            
+            for doc in documents:
+                if doc["agent_id"]==agent:
+                    keypair=doc["secret_key"]
+                    
+            secret_key_bytes =bytes.fromhex(keypair)
+            keypair = Keypair.from_bytes(secret_key)
+        
+            print(f"✅ Keypair loaded from {path}")
+            print(f"📍 Public Key: {keypair.pubkey()}")
+        
+            return keypair
+
+
+
+
+
+
+
+class VelocityPayableAgent():
+
+    def __init__(self,agent):
+        
+        self.agent=agent
+        self.wallet=create_keypair(agent)
+        self.tools = [load_keypair_tool,transfer_sol_tool]
+
+
+    
+    def execute_tool_call(self,tool_call):
+        """Parse and execute a single tool call"""
+        function_name = tool_call.function.name
+        function_to_call = available_functions[function_name]
+        function_args = json.loads(tool_call.function.arguments)
+        return function_to_call(**function_args)
+
+        
+
+    def Agent(self):
+        client = Groq(api_key="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")
+        available_functions= {
+            "load_keypair": load_keypair,
+            "transfer_sol":transfer_sol,
+        }
+        load_keypair_tool = {
+            "type": "function",
+            "function": {
+                "name": "load_keypair",
+                "description": "Load the Solana keypair for this agent from MongoDB.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "agent":{
+                            "type":"string",
+                            "description":"agents id"
+                            
+                        }
+                    },
+                    "required": ["agent"]
+                }
+            }
+            }
+
+        transfer_sol_tool = {
+            "type": "function",
+            "function": {
+                "name": "transfer_sol",
+                "description": "Transfer SOL from one account  to other on Solana.",
+                "parameters": {
+                "type": "object",
+                "properties": {
+                    "from_keypair": {
+                        "type": "string",
+                        "description": "secret key of the agent"
+                    },
+                    "to_pubkey": {
+                        "type": "string",
+                        "description": "Destination public key."
+                    },
+                    "amount_sol": {
+                        "type": "number",
+                        "description": "Amount of SOL to send."
+                    }
+                },
+                "required": ["from_keypair", "to_pubkey", "amount_sol"]
+            }
+            }
+        }
+
+        messages=[
+            {"role":"system","content":"""
+            You are a tool-only agent.
+             Rules:
+                1. You MUST call a tool for every query from the user.
+                2. You are NOT allowed to answer directly.
+                3. If multiple tools exist, choose the one that is closest to the user's intent.
+                4. Always return a tool call in the correct function-calling JSON format.
+                5. When unsure, still pick a tool instead of answering directly.
+                6. Do not apologize, do not explain, do not output reasoning—only valid tool calls.
+             """},
+            {"role": "user", "content": user_input}]
+    
+        response = client.chat.completions.create(
+            model="llama-3.1-8b-instant",
+            messages=messages,
+            tools=self.tools,
+        )
+        messages.append(response.choices[0].message)
+   
+
+        if response.choices[0].message.tool_calls:
+         for tool_call in response.choices[0].message.tool_calls:
+             function_response = execute_tool_call(tool_call)
+             messages.append({
+                "role": "tool",
+                "tool_call_id": tool_call.id,
+                "name": tool_call.function.name,
+                "content": str(function_response)
+                })
+    
+        final = client.chat.completions.create(
+            model="llama-3.1-8b-instant",
+            messages=messages
+            )
+        print(final.choices[0].message.content)
+        return final.choices[0].message.content
+
+        
+        
+
+