AutoGen ਭੁਗਤਾਨ ਇੰਟਿਗਰੇਸ਼ਨ।
ਕੋਈ AutoGen ਪੈਕੇਜ ਨਹੀਂ ਹੈ, ਅਤੇ ਤੁਹਾਨੂੰ ਇੱਕ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ। ਅਸਲੀ blockchain0x ਕਲਾਇੰਟ ਨੂੰ ਇੱਕ ਫੰਕਸ਼ਨ ਵਿੱਚ ਲਪੇਟੋ, ਇਸਨੂੰ ਆਪਣੇ ਏਜੰਟ ਨੂੰ ਦਿਓ, ਅਤੇ ਇਹ USDC ਨੂੰ ਬੇਸ 'ਤੇ ਚਲਾ ਸਕਦਾ ਹੈ।
AutoGen-specific ਕੋਈ package ਨਹੀਂ ਹੈ, ਅਤੇ ਤੁਹਾਨੂੰ ਇਸਦੀ ਲੋੜ ਵੀ ਨਹੀਂ। AutoGen ਪਹਿਲਾਂ ਹੀ ਇੱਕ plain typed function ਨੂੰ tool ਵਿੱਚ ਬਦਲ ਦਿੰਦਾ ਹੈ, ਇਸ ਲਈ ਤੁਸੀਂ ਅਸਲੀ Python client ਨੂੰ ਇੱਕ function ਵਿੱਚ wrap ਕਰਦੇ ਹੋ, ਉਸਨੂੰ ਨੂੰ ਰਾਹੀਂ ਦੇ ਦਿੰਦੇ ਹੋ, ਅਤੇ agent Base 'ਤੇ USDC ਭੇਜ ਸਕਦਾ ਹੈ, invoices settle ਕਰ ਸਕਦਾ ਹੈ, ਅਤੇ wallets ਪੜ੍ਹ ਸਕਦਾ ਹੈ। ਸੈੱਟ ਕਰੋ ਅਤੇ ਸ਼ੁਰੂ ਕਰੋ।
AutoGen ਪਹਿਲਾਂ ਹੀ ਇੱਕ ਫੰਕਸ਼ਨ ਨੂੰ ਟੂਲ ਬਣਾਉਂਦਾ ਹੈ। ਇਸਨੂੰ ਵਰਤੋਂ ਕਰੋ।
AutoGen ਇੱਕ ਟੂਲ ਸਕੀਮਾ ਨੂੰ ਸਿੱਧੇ ਪਾਇਥਨ ਫੰਕਸ਼ਨ ਦੇ ਦਸਤਖਤ ਅਤੇ ਡੌਕਸਟ੍ਰਿੰਗ ਤੋਂ ਬਣਾਉਂਦਾ ਹੈ। ਇੱਕ ਸਮਰਪਿਤ AutoGen ਐਡਾਪਟਰ ਸਿਰਫ ਇੱਕ ਫੰਕਸ਼ਨ ਨੂੰ ਲਪੇਟੇਗਾ ਜੋ ਅਸੀਂ ਕਿਸੇ ਵੀ ਤਰੀਕੇ ਨਾਲ ਲਿਖਿਆ ਹੋਵੇਗਾ, ਫਿਰ AutoGen ਦੇ ਤੇਜ਼-ਗਤੀ ਵਾਲੇ API ਨਾਲ ਅਸਮਰੱਥ ਹੋ ਜਾਏਗਾ। ਇਸ ਲਈ ਅਸੀਂ ਇੱਕ ਨਹੀਂ ਭੇਜਦੇ। ਤੁਸੀਂ ਕੁਝ ਲਾਈਨਾਂ ਲਿਖਦੇ ਹੋ ਜੋ ਅਸਲ blockchain0x ਕਲਾਇੰਟ ਨੂੰ ਕਾਲ ਕਰਦੀਆਂ ਹਨ, ਅਤੇ ਤੁਸੀਂ ਆਰਗੂਮੈਂਟਾਂ, ਪ੍ਰਮਾਣੀਕਰਨ, ਅਤੇ ਗਲਤੀ ਸੰਭਾਲਣ 'ਤੇ ਪੂਰੀ ਨਿਗਰਾਨੀ ਰੱਖਦੇ ਹੋ।
ਇਹ ਉਹੀ ਕਲਾਇੰਟ ਹੈ ਜਿਸਨੂੰ ਭੇਜੇ ਗਏ LangChain ਅਤੇ CrewAI ਐਡਾਪਟਰ ਲਪੇਟਦੇ ਹਨ। ਇੱਥੇ ਤੁਸੀਂ ਇਸਨੂੰ ਆਪਣੇ ਆਪ ਲਪੇਟਦੇ ਹੋ, ਜਿਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਕੋਈ ਐਡਾਪਟਰ ਸੰਸਕਰਣ ਟ੍ਰੈਕ ਕਰਨ ਲਈ ਨਹੀਂ ਹੈ ਅਤੇ ਤੁਹਾਡੇ ਏਜੰਟ ਅਤੇ API ਦੇ ਵਿਚਕਾਰ ਕੁਝ ਵੀ ਨਹੀਂ ਹੈ ਸਿਵਾਏ ਤੁਹਾਡੇ ਆਪਣੇ ਫੰਕਸ਼ਨ ਦੇ। ਬਹੁ-ਏਜੰਟ ਟੀਮਾਂ ਇੱਕੋ ਤਰੀਕੇ ਨਾਲ ਕੰਮ ਕਰਦੀਆਂ ਹਨ: ਇੱਕ ਏਜੰਟ ਨੂੰ ਵਾਲਿਟ ਫੰਕਸ਼ਨ ਦਿਓ, ਦੂਜਿਆਂ ਨੂੰ ਇਸ ਤੋਂ ਬਿਨਾਂ ਛੱਡੋ, ਅਤੇ ਖਰਚ ਕਰਨ ਦੀ ਅਧਿਕਾਰ ਇੱਕ ਥਾਂ 'ਤੇ ਰਹਿੰਦੀ ਹੈ।
AutoGen ਅਤੇ ਕੋਰ SDK ਨੂੰ ਇੰਸਟਾਲ ਕਰੋ। ਇੱਕ ਵਾਤਾਵਰਣ ਚਰ।
ਕੋਈ ਸਮਰਪਿਤ AutoGen ਪੈਕੇਜ ਨਹੀਂ ਹੈ ਜੋ ਜੋੜਿਆ ਜਾ ਸਕੇ। ਤੁਸੀਂ AutoGen (Python 3.10+) ਅਤੇ ਅਸਲੀ blockchain0x ਕੋਰ ਐਸਡੀਕੇ ਨੂੰ ਇੰਸਟਾਲ ਕਰਦੇ ਹੋ, ਫਿਰ ਹੇਠਾਂ ਦਿੱਤੀ ਫੰਕਸ਼ਨ ਲਿਖਦੇ ਹੋ। ਇਹ ਸਾਰੀ ਨਿਰਭਰਤਾ ਸੂਚੀ ਹੈ।
pip install autogen-agentchat "autogen-ext[openai]" blockchain0x
export BLOCKCHAIN0X_API_KEY=sk_test_... # sk_test_ = Base Sepolia, sk_live_ = Base mainnet
BLOCKCHAIN0X_API_KEY ਤੁਹਾਡੇ dashboard ਤੋਂ ਇੱਕ sk_test_ testnet ਜਾਂ sk_live_ mainnet key ਹੈ; client ਇਸਨੂੰ environment ਤੋਂ ਪੜ੍ਹਦਾ ਹੈ। ਜੇ ਤੁਹਾਡਾ agent ਪੈਸੇ ਵੀ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ, ਤਾਂ webhook handler ਨੂੰ ਵਾਧੂ ਤੌਰ 'ਤੇ BLOCKCHAIN0X_WEBHOOK_SECRET ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਜੋ dashboard webhook create ਜਾਂ rotate ਕਰਨ ਸਮੇਂ ਇਕ ਵਾਰ ਦਿੰਦਾ ਹੈ।
ਇੱਕ ਫੰਕਸ਼ਨ ਜੋ ਭੁਗਤਾਨ ਕਰਦਾ ਹੈ, ਇੱਕ AssistantAgent ਨੂੰ ਦਿੱਤਾ ਗਿਆ.
ਹੇਠਾਂ ਪੂਰੀ ਇੰਟਿਗ੍ਰੇਸ਼ਨ ਹੈ। send_usdc ਅਸਲ blockchain0x ਕਲਾਇੰਟ ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ; AssistantAgent(tools=[send_usdc]) ਇਸਨੂੰ ਇੱਕ ਟੂਲ ਵਿੱਚ ਬਦਲਦਾ ਹੈ ਜਿਸਨੂੰ ਮਾਡਲ ਕਾਲ ਕਰ ਸਕਦਾ ਹੈ। AutoGen ਕਿਸਮ ਦੇ ਸੁਝਾਅ ਅਤੇ ਡੌਕਸਟ੍ਰਿੰਗ ਨੂੰ ਪੜ੍ਹਦਾ ਹੈ ਤਾਂ ਜੋ ਸਕੀਮਾ ਬਣਾਇਆ ਜਾ ਸਕੇ, ਇਸ ਲਈ ਇਨ੍ਹਾਂ ਨੂੰ ਸੱਚਾ ਰੱਖੋ। ਇਸਨੂੰ ਚਲਾਓ ਅਤੇ ਏਜੰਟ Base 'ਤੇ USDC ਨੂੰ ਚਲਾਉਂਦਾ ਹੈ।
from autogen_agentchat.agents import AssistantAgent from autogen_ext.models.openai import OpenAIChatCompletionClient from blockchain0x import Client blockchain0x = Client() # reads BLOCKCHAIN0X_API_KEY from the environment # AutoGen turns a plain typed function into a tool. No dedicated package needed. def send_usdc(agent_id: str, to: str, amount_wei: str) -> str: """Send a USDC payment from an agent wallet. amount_wei is USDC base units (6 decimals), so "10000" is 0.01 USDC. """ result = blockchain0x.payments.create( body={"agentId": agent_id, "to": to, "amountWei": amount_wei}, ) return str(result) treasurer = AssistantAgent( name="treasurer", model_client=OpenAIChatCompletionClient(model="gpt-4o"), tools=[send_usdc], system_message="You pay vendor invoices in USDC within owner-set limits.", ) result = await treasurer.run( task="Pay 0.01 USDC from agent agt_123 to 0xVendor for the dataset.", )
When the agent decides to pay, it calls send_usdc, the SDK submits the transfer, and you get a transaction hash back. amount_wei is base units, so 0.01 USDC is "10000". A sk_test_ key keeps it on Base Sepolia until you switch to sk_live_. Add more functions - read a wallet, settle an invoice - the same way; each becomes another entry in tools.
ਇੱਕ ਸਾਈਨ ਕੀਤੀ ਵੈਬਹੂਕ ਨਾਲ ਆਉਣ ਵਾਲੇ ਭੁਗਤਾਨਾਂ ਦੀ ਪੁਸ਼ਟੀ ਕਰੋ।
ਜੇ ਤੁਹਾਡਾ ਏਜੰਟ ਵੀ USDC ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ, ਤਾਂ ਇਸਨੂੰ webhook ਨਾਲ ਪੁਸ਼ਟੀ ਕਰੋ ਨਾ ਕਿ ਪੁਸ਼ਟੀ ਕਰਨ ਨਾਲ। ਪ੍ਰਮਾਣਿਤ ਕਰਨ ਵਾਲਾ ਸਹਾਇਕ Node SDK ਵਿੱਚ ਸ਼ਿਪ ਕੀਤਾ ਜਾਂਦਾ ਹੈ; ਇੱਕ Python ਸੇਵਾ ਵਿੱਚ ਤੁਸੀਂ ਦਸਤਾਵੇਜ਼ HMAC ਦੇ ਖਿਲਾਫ ਹੱਥ ਨਾਲ ਪ੍ਰਮਾਣਿਤ ਕਰਦੇ ਹੋ, ਜੋ ਕਿ ਸਹਾਇਕ ਕਰਦਾ ਹੈ। ਹੇਠਾਂ FastAPI ਉਦਾਹਰਨ; ਉਹੀ ਕੋਡ ਕਿਸੇ ਵੀ ਅਸਿੰਕ Python ਫਰੇਮਵਰਕ ਵਿੱਚ ਕੰਮ ਕਰਦਾ ਹੈ।
import hmac, hashlib, os, time from fastapi import FastAPI, Request, HTTPException app = FastAPI() SECRET = os.environ["BLOCKCHAIN0X_WEBHOOK_SECRET"].encode() @app.post("/webhooks/payment") async def receive(request: Request): raw = await request.body() # RAW bytes - do not parse first sig = request.headers.get("X-Blockchain0x-Signature", "") ts = request.headers.get("X-Blockchain0x-Timestamp", "") parts = dict(p.split("=", 1) for p in sig.split(",") if "=" in p) t, v1 = parts.get("t", ts), parts.get("v1", sig) want = hmac.new(SECRET, t.encode() + b"." + raw, hashlib.sha256).hexdigest() if not hmac.compare_digest(want, v1) or abs(time.time() - int(t)) > 300: raise HTTPException(status_code=401) if request.headers.get("X-Blockchain0x-Event-Type") == "payment.received": await trigger_followup() # USDC landed - run the next step return {"ok": True}
Algorithm t.rawBody string ਉੱਤੇ HMAC-SHA256, constant-time compare, ਅਤੇ 300-second replay window ਹੈ। Raw body ਨੂੰ await request.body() ਰਾਹੀਂ ਪੜ੍ਹੋ, ਕਦੇ ਵੀ request.json() ਨੂੰ re-serialized ਨਾ ਕਰੋ, ਕਿਉਂਕਿ ਇਸ ਨਾਲ signature ਵੱਲੋਂ cover ਕੀਤੇ bytes ਬਦਲ ਜਾਂਦੇ ਹਨ। Shipped events ਹਨ payment.received, payment.sent, wallet.deployed, ਅਤੇ webhook.test। ਭਾਰੀ follow-up ਕੰਮ ਲਈ, job queue ਕਰੋ (Celery, RQ, arq) ਅਤੇ handler ਨੂੰ block ਕਰਨ ਦੀ ਬਜਾਏ ਤੁਰੰਤ 200 respond ਕਰੋ।
ਜਿਸ client ਨੂੰ ਤੁਸੀਂ wrap ਕਰ ਰਹੇ ਹੋ ਉਹ open ਹੈ। ਉਸਨੂੰ ਪੜ੍ਹੋ।
ਕੋਈ AutoGen starter package ਨਹੀਂ ਹੈ ਜਿਸਨੂੰ clone ਕੀਤਾ ਜਾ ਸਕੇ - ਉੱਪਰ ਦਿੱਤਾ recipe ਹੀ integration ਹੈ। blockchain0x SDKs GitHub 'ਤੇ open source ਹਨ; ਇਹ recipe Python SDK (blockchain0x-python) ਨੂੰ wrap ਕਰਦੀ ਹੈ, ਅਤੇ ਪੂਰੀ method surface docs ਵਿੱਚ ਹੈ। function bodies ਲਈ reference ਵਜੋਂ ਇਸਨੂੰ ਪੜ੍ਹੋ।
github.com/tosh-labs/blockchain0x-pythonਪੂਰਾ SDK method surface ਅਤੇ scopes the docs 'ਤੇ documented ਹਨ। Base Sepolia ਦੇ ਖ਼ਿਲਾਫ਼ sk_test_ key ਨਾਲ ਸ਼ੁਰੂ ਕਰੋ, ਫਿਰ ਜਦੋਂ function ਤੁਹਾਡੀ ਉਮੀਦ ਅਨੁਸਾਰ ਕੰਮ ਕਰੇ, sk_live_ 'ਤੇ switch ਕਰੋ।
ਪੰਜ ਗਰੁੱਪ-ਚੈਟ ਅਤੇ ਅਸੰਕ੍ਰੋਨਸ ਜਾਲਾਂ ਤੋਂ ਬਚਣ ਲਈ।
AutoGen ਦਾ ਬਹੁ-ਏਜੰਟ + ਐਸਿੰਕ ਡਿਜ਼ਾਈਨ ਸ਼ਕਤੀਸ਼ਾਲੀ ਪੈਟਰਨ ਨੂੰ ਖੋਲ੍ਹਦਾ ਹੈ ਪਰ ਆਪਣੇ ਹੀ ਫੁੱਟਗਨ ਨੂੰ ਪੇਸ਼ ਕਰਦਾ ਹੈ। ਇਹ ਸਾਡੇ ਸਹਾਇਤਾ ਇਨਬਾਕਸ ਤੋਂ ਆਉਂਦੇ ਹਨ।
ਕੋਈ AutoGen ਪੈਕੇਜ ਨਹੀਂ ਹੈ - ਤੁਸੀਂ ਐਸਡੀਕੇ ਨੂੰ ਲਪੇਟਦੇ ਹੋ
Blockchain0x LangChain ਅਤੇ CrewAI ਲਈ ਐਡਾਪਟਰਾਂ ਨੂੰ ਭੇਜਦਾ ਹੈ ਅਤੇ MCP ਸਰਵਰ; ਕੋਈ ਸਮਰਪਿਤ AutoGen ਪੈਕੇਜ ਨਹੀਂ ਹੈ। ਉਪਰੋਕਤ ਨੁਸਖਾ ਸਮਰਥਿਤ ਰਸਤਾ ਹੈ: ਇੱਕ ਸਧਾਰਣ ਟਾਈਪ ਕੀਤੀ ਫੰਕਸ਼ਨ ਜੋ ਅਸਲ blockchain0x ਕਲਾਇੰਟ ਨੂੰ ਕਾਲ ਕਰਦੀ ਹੈ, AssistantAgent(tools=[...]) ਨੂੰ ਦਿੱਤੀ ਜਾਂਦੀ ਹੈ। AutoGen ਫੰਕਸ਼ਨ ਦੇ ਦਸਤਖਤ ਅਤੇ ਡੌਕਸਟ੍ਰਿੰਗ ਨੂੰ ਪੜ੍ਹਦਾ ਹੈ ਤਾਂ ਜੋ ਟੂਲ ਸਕੀਮਾ ਬਣਾਇਆ ਜਾ ਸਕੇ, ਇਸ ਲਈ ਡੌਕਸਟ੍ਰਿੰਗ ਨੂੰ ਸਹੀ ਰੱਖੋ।
ਰਕਮਾਂ USDC ਬੇਸ ਯੂਨਿਟ ਹਨ, ਸਤਰਾਂ ਵਜੋਂ
payments.create takes amountWei: a string of USDC base units, not a float and not a dollar figure. USDC has 6 decimals, so 0.01 USDC is "10000" and 5 USDC is "5000000". Type the tool argument as str and validate it before the call - a float that sneaks through either errors at the backend or moves a millionth of what you meant.
send_payment ਪਹਿਲਾਂ 503 ਦਾ ਜਵਾਬ ਦੇ ਸਕਦਾ ਹੈ
payments.create ਡਿਫਾਲਟ ਵਜੋਂ ਦੁਬਾਰਟ ਕੋਸ਼ਿਸ਼ ਨਹੀਂ ਕਰਦਾ ਅਤੇ ਤੁਹਾਡੇ ਨੈੱਟਵਰਕ ਲਈ ਚੇਨ ਐਡਾਪਟਰ ਵਾਇਰ ਹੋਣ ਤੱਕ 503 ਵਾਪਸ ਕਰ ਸਕਦਾ ਹੈ। ਸਮੂਹ ਚੈਟ ਨੂੰ ਇੱਕ ਫੇਲ ਭੁਗਤਾਨ 'ਤੇ ਲੂਪ ਕਰਨ ਨਾ ਦਿਓ - ਆਪਣੇ ਫੰਕਸ਼ਨ ਵਿੱਚ ਗਲਤੀ ਨੂੰ ਪਕੜੋ, ਇੱਕ ਸਾਫ਼ ਸੁਨੇਹਾ ਵਾਪਸ ਕਰੋ ਜਿਸ 'ਤੇ ਮਾਡਲ ਕਾਰਵਾਈ ਕਰ ਸਕਦਾ ਹੈ, ਅਤੇ ਆਟੋ-ਮਿੰਟ ਕੀਤੀ ਗਈ idempotency ਕੁੰਜੀ 'ਤੇ ਨਿਰਭਰ ਕਰੋ ਤਾਂ ਕਿ ਹੱਥ ਨਾਲ ਦੁਬਾਰਾ ਕੋਸ਼ਿਸ਼ ਕਰਨ ਨਾਲ ਦੋਹਰਾ ਭੁਗਤਾਨ ਨਾ ਹੋਵੇ।
AutoGen 0.4+ async ਹੈ; SDK ਕਾਲ ਸਮਕਾਲੀ ਹੈ
AutoGen 0.4 ਇੱਕ async ਲੂਪ ਵਿੱਚ ਟੂਲ ਚਲਾਉਂਦਾ ਹੈ। blockchain0x ਕਲਾਇੰਟ ਕਾਲ ਸਮਕਾਲੀ ਹੈ, ਜੋ ਇੱਕ ਤੇਜ਼ ਬੇਨਤੀ ਲਈ ਠੀਕ ਹੈ, ਪਰ ਇੱਕ ਹੌਲੀ ਕਾਲ ਲੂਪ ਨੂੰ ਰੋਕਦੀ ਹੈ। ਜੇ ਤੁਸੀਂ ਅਸਲੀ ਵੋਲਿਊਮ ਚਲਾ ਰਹੇ ਹੋ, ਤਾਂ SDK ਕਾਲ ਨੂੰ asyncio.to_thread ਨਾਲ ਲਪੇਟੋ ਤਾਂ ਜੋ ਇਵੈਂਟ ਲੂਪ ਜਵਾਬਦਾਰ ਰਹੇ। ਇੱਕ ਟਰਨ 'ਤੇ ਇੱਕ ਹੀ ਭੁਗਤਾਨ ਲਈ, ਇਸਨੂੰ ਸਿੱਧਾ ਕਾਲ ਕਰਨਾ ਠੀਕ ਹੈ।
ਕੱਚੇ ਸਰੀਰ ਦੇ ਖਿਲਾਫ ਆਉਣ ਵਾਲੇ ਵੈਬਹੂਕ ਦੀ ਪੁਸ਼ਟੀ ਕਰੋ
ਜੇ ਤੁਹਾਡਾ ਏਜੰਟ ਵੀ ਪੈਸਾ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ, ਤਾਂ ਇਸਨੂੰ webhook ਨਾਲ ਪੁਸ਼ਟੀ ਕਰੋ, ਪੁਸ਼ਟੀ ਕਰਨ ਨਾਲ ਨਹੀਂ। RAW ਬੇਨਤੀ ਬਾਈਟਸ (await request.body()) 'ਤੇ ਦਸਤਖਤ ਦੀ ਪੁਸ਼ਟੀ ਕਰੋ, ਕਦੇ ਵੀ request.json() ਦੁਬਾਰਾ-ਸਿਰਜਿਆ ਨਹੀਂ, ਕਿਉਂਕਿ HMAC ਸਹੀ ਬਾਈਟਾਂ ਨੂੰ ਕਵਰ ਕਰਦਾ ਹੈ। ਇਹ HMAC-SHA256 ਹੈ ਜਿਸ ਵਿੱਚ 300-ਸੈਕੰਡ ਦਾ ਦੁਬਾਰਾ ਖੇਡਣ ਦਾ ਵਿੰਡੋ ਹੈ। ਹੇਠਾਂ ਦਿੱਤਾ ਹੈਂਡਲਰ ਪੂਰੀ ਗੱਲ ਹੈ।