AutoGen ಪಾವತಿ ಏಕೀಕರಣ.
AutoGen ಪ್ಯಾಕೇಜ್ ಇಲ್ಲ, ಮತ್ತು ನಿಮಗೆ ಒಂದು ಅಗತ್ಯವಿಲ್ಲ. ವಾಸ್ತವ blockchain0x ಕ್ಲೈಂಟ್ ಅನ್ನು ಕಾರ್ಯದಲ್ಲಿ ಲುಪ್ತಗೊಳಿಸಿ, ಅದನ್ನು ನಿಮ್ಮ ಏಜೆಂಟ್ಗೆ ನೀಡಿ, ಮತ್ತು ಇದು USDC ಅನ್ನು Base ನಲ್ಲಿ ಚಲಾಯಿಸಬಹುದು.
AutoGen-specific package ಇಲ್ಲ, ಮತ್ತು ನಿಮಗೆ ಅದು ಬೇಕಾಗಿಲ್ಲ. AutoGen ಈಗಾಗಲೇ ಸರಳ typed function ಅನ್ನು tool ಆಗಿ ಪರಿವರ್ತಿಸುತ್ತದೆ, ಆದ್ದರಿಂದ ನೀವು ನಿಜವಾದ Python client ಅನ್ನು function ನಲ್ಲಿ wrap ಮಾಡಿ, ಅದನ್ನು ಗೆ ಮೂಲಕ ನೀಡಿ, ಮತ್ತು agent Base ನಲ್ಲಿ USDC ಕಳುಹಿಸಬಹುದು, invoices settle ಮಾಡಬಹುದು, ಮತ್ತು wallets ಓದಬಹುದು. ಅನ್ನು ಸೆಟ್ ಮಾಡಿ, ನಂತರ ಮುಂದುವರಿಯಿರಿ.
AutoGen ಈಗಾಗಲೇ ಕಾರ್ಯವನ್ನು ಸಾಧನವಾಗಿಸುತ್ತದೆ. ಅದನ್ನು ಬಳಸಿಕೊಳ್ಳಿ.
AutoGen Python ಕಾರ್ಯದ ಸಹಿ ಮತ್ತು ಡಾಕ್ಸ್ಟ್ರಿಂಗ್ ನಿಂದ ನೇರವಾಗಿ ಸಾಧನ ಶ್ರೇಣಿಯನ್ನು ನಿರ್ಮಿಸುತ್ತದೆ. ಒಂದು ಸಮರ್ಪಿತ AutoGen ಅಡಾಪ್ಟರ್ ಕೇವಲ ನಾವು ಬರೆದಿರಬಹುದಾದ ಕಾರ್ಯವನ್ನು ಮಾತ್ರ ಮರುಬಂದಿ ಮಾಡುತ್ತದೆ, ನಂತರ AutoGen ನ ವೇಗವಾಗಿ ಚಲಿಸುತ್ತಿರುವ API ನೊಂದಿಗೆ ಸಮಕಾಲಿಕತೆಯನ್ನು ಕಳೆದುಕೊಳ್ಳುತ್ತದೆ. ಆದ್ದರಿಂದ, ನಾವು ಒಂದನ್ನು ಕಳುಹಿಸುತ್ತಿಲ್ಲ. ನೀವು ವಾಸ್ತವ blockchain0x ಕ್ಲೈಂಟ್ ಅನ್ನು ಕರೆ ಮಾಡುವ ಕೆಲವು ಸಾಲುಗಳನ್ನು ಬರೆಯುತ್ತೀರಿ, ಮತ್ತು ನೀವು ಆರ್ಗ್ಯುಮೆಂಟ್ಗಳು, ಮಾನ್ಯತೆ ಮತ್ತು ದೋಷ ನಿರ್ವಹಣೆಯ ಸಂಪೂರ್ಣ ನಿಯಂತ್ರಣವನ್ನು ಹೊಂದಿರುತ್ತೀರಿ.
ಇದು ಕಳುಹಿಸಲಾದ LangChain ಮತ್ತು CrewAI ಅಡಾಪ್ಟರ್ಗಳು ಅಡಿಯಲ್ಲಿ ಲುಪ್ತಗೊಳಿಸುವ ಅದೇ ಕ್ಲೈಂಟ್. ಇಲ್ಲಿ ನೀವು ಇದನ್ನು ಸ್ವತಃ ಲುಪ್ತಗೊಳಿಸುತ್ತೀರಿ, ಇದು ಟ್ರ್ಯಾಕ್ ಮಾಡಲು ಅಡಾಪ್ಟರ್ ಆವೃತ್ತಿಯಿಲ್ಲ ಮತ್ತು ನಿಮ್ಮ ಏಜೆಂಟ್ ಮತ್ತು API ನಡುವಿನ ಏನೂ ಇಲ್ಲ ನಿಮ್ಮದೇ ಕಾರ್ಯವನ್ನು ಹೊರತುಪಡಿಸಿ. ಬಹು-ಏಜೆಂಟ್ ತಂಡಗಳು ಇದೇ ರೀತಿಯಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ: ಒಂದು ಏಜೆಂಟ್ಗೆ ವಾಲೆಟ್ ಕಾರ್ಯವನ್ನು ನೀಡಿ, ಇತರರನ್ನು ಅದರಿಂದ ಹೊರಗೊಮ್ಮಲು ಬಿಡಿ, ಮತ್ತು ಖರ್ಚು ಅಧಿಕಾರವು ಒಂದೇ ಸ್ಥಳದಲ್ಲಿ ಉಳಿಯುತ್ತದೆ.
AutoGen ಅನ್ನು ಮತ್ತು ಕೋರ್ SDK ಅನ್ನು ಸ್ಥಾಪಿಸಿ. ಒಂದು ಪರಿಸರ ಚರ.
ಜೋಡಿಸಲು ಸಮರ್ಪಿತ AutoGen ಪ್ಯಾಕೇಜ್ ಇಲ್ಲ. ನೀವು AutoGen ಅನ್ನು (Python 3.10+) ಮತ್ತು ವಾಸ್ತವ blockchain0x ಕೋರ್ SDK ಅನ್ನು ಸ್ಥಾಪಿಸುತ್ತೀರಿ, ನಂತರ ಕೆಳಗಿನ ಕಾರ್ಯವನ್ನು ಬರೆಯುತ್ತೀರಿ. ಇದು ಸಂಪೂರ್ಣ ಅವಲಂಬನೆ ಪಟ್ಟಿಯಾಗಿದೆ.
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 ಬೇಕಾಗುತ್ತದೆ, webhook ಅನ್ನು create ಅಥವಾ rotate ಮಾಡುವಾಗ dashboard ಅದನ್ನು ಒಮ್ಮೆ ಮಾತ್ರ ನೀಡುತ್ತದೆ.
ಪಾವತಿ ಮಾಡುವ function, ಒಂದು AssistantAgent ಗೆ ಒಪ್ಪಿಸಲಾಗಿದೆ.
ಕೆಳಗೆ ಸಂಪೂರ್ಣ ಏಕೀಕರಣವಿದೆ. send_usdc ವಾಸ್ತವ blockchain0x ಕ್ಲೈಂಟ್ ಅನ್ನು ಕರೆ ಮಾಡುತ್ತದೆ; AssistantAgent(tools=[send_usdc]) ಇದನ್ನು ಮಾದರಿ ಕರೆ ಮಾಡಬಹುದಾದ ಸಾಧನವಾಗಿಸುತ್ತದೆ. AutoGen ಶ್ರೇಣಿಯನ್ನು ನಿರ್ಮಿಸಲು ಟೈಪ್ ಹಿಂಟ್ಸ್ ಮತ್ತು ಡಾಕ್ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಓದುತ್ತದೆ, ಆದ್ದರಿಂದ ಅವುಗಳನ್ನು ಸತ್ಯವಾದವಾಗಿಡಿ. ಅದನ್ನು ಓಡಿಸಿ ಮತ್ತು ಏಜೆಂಟ್ 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 ಅನ್ನು RECEIVES ಮಾಡಿದರೆ, polling ಬದಲು ವೆಬ್ಹುಕ್ ಮೂಲಕ ದೃಢೀಕರಿಸಿ. ಪರಿಶೀಲನೆ ಸಹಾಯಕವು 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() ಮೂಲಕ read ಮಾಡಿ, ಎಂದಿಗೂ request.json() ಅನ್ನು re-serialized ಮಾಡಬೇಡಿ, ಏಕೆಂದರೆ ಅದು signature ಒಳಗೊಂಡ bytes ಅನ್ನು ಬದಲಾಯಿಸುತ್ತದೆ. ship ಮಾಡಲಾದ events payment.received, payment.sent, wallet.deployed, ಮತ್ತು webhook.test. ಹೆಚ್ಚಿನ follow-up ಕೆಲಸಕ್ಕಾಗಿ, job ಅನ್ನು enqueue ಮಾಡಿ (Celery, RQ, arq) ಮತ್ತು handler ಅನ್ನು block ಮಾಡದೇ ತಕ್ಷಣ 200 respond ಮಾಡಿ.
ನೀವು wrap ಮಾಡುತ್ತಿರುವ client open ಆಗಿದೆ. ಅದನ್ನು read ಮಾಡಿ.
ಕ್ಲೋನ್ ಮಾಡಲು ಯಾವುದೇ AutoGen starter package ಇಲ್ಲ - ಮೇಲಿನ 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 ನಲ್ಲಿ document ಮಾಡಲಾಗಿದೆ. Base Sepolia ವಿರುದ್ಧ sk_test_ key ನಿಂದ ಆರಂಭಿಸಿ, function ನೀವು ನಿರೀಕ್ಷಿಸುವಂತೆ ಕೆಲಸ ಮಾಡಿದಾಗ sk_live_ ಗೆ switch ಮಾಡಿ.
ಐದು ಗುಂಪು-ಚಾಟ್ ಮತ್ತು ಅಸಿಂಕ್ರೋನಸ್ ಬಲೆಗೆಗಳನ್ನು ತಪ್ಪಿಸಲು.
AutoGen ನ ಬಹು-ಏಜಂಟ್ + ಅಸಿಂಕ್ರೋನಸ್ ವಿನ್ಯಾಸವು ಶಕ್ತಿಶಾಲಿ ಮಾದರಿಗಳನ್ನು ಅನ್ಲಾಕ್ ಮಾಡುತ್ತದೆ ಆದರೆ ತನ್ನದೇ ಆದ ಪಾದಕೋಶಗಳನ್ನು ಪರಿಚಯಿಸುತ್ತದೆ. ಇವು ನಮ್ಮ ಬೆಂಬಲ ಇನ್ಬಾಕ್ಸ್ ನಿಂದ ಬರುತ್ತವೆ.
AutoGen ಪ್ಯಾಕೇಜ್ ಇಲ್ಲ - ನೀವು SDK ಅನ್ನು ಲುಪ್ತಗೊಳಿಸುತ್ತೀರಿ
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+ ಅಸಿಂಕ್ರೋನಸ್; SDK ಕರೆ ಸಮಕಾಲಿಕವಾಗಿದೆ
AutoGen 0.4 ಸಾಧನಗಳನ್ನು ಅಸಿಂಕ್ರೋನಸ್ ಲೂಪ್ನಲ್ಲಿ ನಿರ್ವಹಿಸುತ್ತದೆ. blockchain0x ಕ್ಲೈಂಟ್ ಕರೆ ಸಮಕಾಲಿಕವಾಗಿದೆ, ಇದು ತ್ವರಿತ ವಿನಂತಿಗೆ ಉತ್ತಮವಾಗಿದೆ, ಆದರೆ ನಿಧಾನವಾದ ಕರೆ ಲೂಪ್ನನ್ನು ಅಡ್ಡಗಟ್ಟುತ್ತದೆ. ನೀವು ವಾಸ್ತವ ಪ್ರಮಾಣವನ್ನು ಚಲಿಸುತ್ತಿದ್ದರೆ, ಘಟನೆ ಲೂಪ್ ಪ್ರತಿಕ್ರಿಯಾತ್ಮಕವಾಗಿರಲು SDK ಕರೆಗೆ asyncio.to_thread ಅನ್ನು ಬಳಸಿಕೊಳ್ಳಿ. ಪ್ರತಿ ತಿರುವಿಗೆ ಒಬ್ಬ ಪಾವತಿಗಾಗಿ, ಅದನ್ನು ನೇರವಾಗಿ ಕರೆ ಮಾಡುವುದು ಉತ್ತಮವಾಗಿದೆ.
Inbound webhooks ಅನ್ನು raw body ವಿರುದ್ಧ verify ಮಾಡಿ
ನಿಮ್ಮ ಏಜೆಂಟ್ ಹಣವನ್ನು RECEIVES ಮಾಡಿದರೆ, ಅದನ್ನು polling ಮೂಲಕ ಅಲ್ಲ, ವೆಬ್ಹುಕ್ ಮೂಲಕ ದೃಢೀಕರಿಸಿ. RAW ವಿನಂತಿ ಬೈಟ್ಸ್ (await request.body()) ಮೇಲೆ ಸಹಿ ಪರಿಶೀಲಿಸಿ, request.json() ಪುನಃ ಪುನರ್ಸೇರಿಸಲಾಗುವುದಿಲ್ಲ, ಏಕೆಂದರೆ HMAC ನಿಖರವಾದ ಬೈಟ್ಸ್ ಅನ್ನು ಒಳಗೊಂಡಿದೆ. ಇದು 300-ಸೆಕೆಂಡು ಪುನರಾವೃತ್ತ ಕಿಟಕಿಯೊಂದಿಗೆ HMAC-SHA256 ಆಗಿದೆ. ಕೆಳಗಿನ ಹ್ಯಾಂಡ್ಲರ್ ಸಂಪೂರ್ಣ ವಿಷಯ.