OpenAI એજન્ટ SDK એકીકરણ.
એજન્ટ SDK પેકેજ નથી, અને તમને એકની જરૂર નથી. @function_tool સાથે એક કાર્યને સજાવો, વાસ્તવિક blockchain0x ક્લાયન્ટને કૉલ કરો, અને તમારો એજન્ટ Base પર USDC ખસેડી શકે છે.
કોઈ OpenAI Agents SDK package નથી, અને તમને તેની જરૂર પણ નથી. SDK સાથે decorated function ને tool માં ફેરવે છે, તેથી તમે real Python client ને function માં wrap કરો છો અને તેને તમારા માં ઉમેરો છો. agent USDC મોકલી શકે છે, invoices settle કરી શકે છે, અને wallets વાંચી શકે છે - single agents, handoffs, અને underlying Responses API across. Payments Base પર settle થાય છે.
સૌથી સ્વચ્છ ટૂલ-કૉલિંગ સપાટી OpenAI શિપ્સ.
OpenAI એજન્ટો SDK (2025માં પ્રકાશિત) એ OpenAIનો ભલામણ કરેલો માર્ગ છે જે Responses API પર એજન્ટો બનાવે છે. તે ટૂલ નોંધણી, સંદેશા લૂપ, અને એજન્ટો વચ્ચે હેન્ડઓફની આસપાસના બોઇલરપ્લેટને અભ્યાસ કરે છે, અને તે સ્વચ્છ, ટાઇપ કરેલ પાયથન કોડ ઉત્પન્ન કરે છે. જો તમે આજે OpenAI-કેન્દ્રિત એજન્ટ પ્રોજેક્ટ શરૂ કરી રહ્યા છો અને ફ્રેમવર્કની પસંદગીઓ નથી, તો આ SDK છે જે અમે ભલામણ કરીએ છીએ.
રીસિપી જાનબૂઝીને પાતળા છે. send_usdc એ એક સાદી કાર્ય છે જે @function_tool સાથે સજ્જ છે; તમે તેને એક એજન્ટના ટૂલ્સ યાદીમાં ઉમેરો છો અને રનર તેને ઉઠાવે છે. કોઈ વિશેષ કન્ફિગરેશન નથી, કોઈ વધારાની લપેટ નથી, SDK નો કોઈ ફોર્ક નથી. જ્યારે એજન્ટ SDK નવી સુવિધા (મલ્ટી-મોડલ ઇનપુટ, અવાજ એજન્ટ) મોકલે છે, ત્યારે તમારું કાર્ય કાર્યરત રહે છે કારણ કે તે ધોરણ ટૂલ-કૉલિંગ સપાટી પર ચાલે છે - તેમાં કંઈપણ સંસ્કરણ-વિશિષ્ટ નથી.
એજન્ટ્સ SDK અને મુખ્ય SDK સ્થાપિત કરો. બે કી.
જોડવા માટે કોઈ blockchain0x એજન્ટ SDK પેકેજ નથી. તમે OpenAI એજન્ટ SDK (openai-agents પેકેજ, પાયથન 3.10+) અને વાસ્તવિક blockchain0x મુખ્ય SDKને ઇન્સ્ટોલ કરો છો, પછી નીચેનું કાર્ય લખો. તે સમગ્ર નિર્ભરતા યાદી છે.
pip install openai-agents blockchain0xexport OPENAI_API_KEY=sk-... export BLOCKCHAIN0X_API_KEY=sk_test_... # sk_test_ = Base Sepolia, sk_live_ = Base mainnet
OPENAI_API_KEY તમારી હાલની OpenAI key છે (Agents SDK તેને underlying Responses API માટે વાપરે છે). BLOCKCHAIN0X_API_KEY તમારા dashboardમાંથી મળતી sk_test_ testnet અથવા sk_live_ mainnet key છે; client તેને environmentમાંથી વાંચે છે. જો તમારો agent પૈસા પણ મેળવે છે, તો webhook handler ને વધારામાં BLOCKCHAIN0X_WEBHOOK_SECRETની જરૂર પડશે.
એક @function_tool જે ચૂકવે છે, એજન્ટને સોંપવામાં આવે છે.
નીચે સમગ્ર એકીકરણ છે. send_usdc વાસ્તવિક blockchain0x ક્લાયન્ટને કોલ કરે છે; @function_tool તેને એક સાધનમાં ફેરવે છે, અને રનર કોલને સંચાલિત કરે છે. SDK પ્રકારના સંકેતો અને ડોકસ્ટ્રિંગને વાંચે છે જેથી સ્કીમા બનાવવામાં આવે, તેથી તેમને ઈમાનદાર રાખો. તેને ચલાવો અને એજન્ટ Base પર USDC ખસેડે છે.
from agents import Agent, Runner, function_tool from blockchain0x import Client blockchain0x = Client() # reads BLOCKCHAIN0X_API_KEY from the environment @function_tool 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. """ return str( blockchain0x.payments.create(body={"agentId": agent_id, "to": to, "amountWei": amount_wei}) ) agent = Agent( name="treasurer", instructions="You pay vendor invoices in USDC within owner-set limits.", tools=[send_usdc], model="gpt-4o", ) result = await Runner.run( agent, input="Pay 0.01 USDC from agent agt_123 to 0xVendor for the dataset.", ) print(result.final_output)
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 is another @function_tool in the list.
સહી કરેલ વેબહૂક સાથે ઇનબાઉન્ડ ચુકવણીઓની પુષ્ટિ કરો.
જો તમારો એજન્ટ પણ USDC પ્રાપ્ત કરે છે, તો તેને વેબહૂક સાથે પુષ્ટિ કરો, પોલિંગ દ્વારા નહીં. ચકાસણી સહાયક નોડ SDK માં શિપ થાય છે; એક પાયથન સેવા માં તમે દસ્તાવેજિત HMAC સામે હાથથી ચકાસો છો, જે સહાયક કરે છે. નીચેનું ફાસ્ટએપીઆઈ ઉદાહરણ; તે જ કોડ કોઈપણ અસિંક પાયથન ફ્રેમવર્કમાં કાર્ય કરે છે.
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}
અલ્ગોરિધમ t.rawBody પર HMAC-SHA256 છે, એક સ્થિર-સમયની તુલના, અને 300-સેકન્ડનું પુનરાવર્તન વિન્ડો. કાચી બોડીને await request.body() દ્વારા વાંચો, ક્યારેય request.json() ફરીથી-સિરિયલાઇઝ ન કરો, કારણ કે તે સહીના કવર કરેલા બાઇટ્સને બદલે છે. શિપ કરેલ ઇવેન્ટ્સ છે payment.received, payment.sent, wallet.deployed, અને webhook.test. ભારે અનુસરણ કાર્ય માટે, એક નોકરી (Celery, arq) એન્ક્યૂ કરો અને હેન્ડલરને બ્લોક કરવા કરતાં તરત 200 પ્રતિસાદ આપો.
તમે લપેટી રહેલા ક્લાયન્ટ ખુલ્લા છે. તેને વાંચો.
ક્લોન કરવા માટે કોઈ Agents SDK 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માં documented છે. Base Sepolia સામે sk_test_ keyથી શરૂ કરો, પછી function અપેક્ષા મુજબ કામ કરે ત્યારે sk_live_ પર switch કરો.
પ્રથમ એકીકરણ પર ધ્યાનમાં રાખવાની પાંચ વસ્તુઓ.
આ અમારા સપોર્ટ ઇનબોક્સમાંથી આવે છે. તેમને અગાઉથી જાણવાથી દરેકમાં એક કલાક બચે છે.
એજન્ટ SDK પેકેજ નથી - તમે SDK ને લપેટો છો
Blockchain0x LangChain અને CrewAI માટે એડેપ્ટર્સ મોકલે છે અને MCP સર્વર; ત્યાં કોઈ સમર્પિત OpenAI એજન્ટ SDK પેકેજ નથી. ઉપરનો નુસખો માર્ગ છે: @function_tool સાથે એક સાદી ટાઇપ કરેલ કાર્યને શણગારવું, અંદર વાસ્તવિક blockchain0x ક્લાયન્ટને કોલ કરવું, અને તેને Agent(tools=[...])માં ઉમેરવું. SDK હસ્તાક્ષર અને ડોકસ્ટ્રિંગને વાંચે છે જેથી સાધન સ્કીમા બનાવવામાં આવે, તેથી ડોકસ્ટ્રિંગને ચોક્કસ રાખો.
એજન્ટ SDK સહાયક API નથી
OpenAI એજન્ટ્સ SDK (openai-agents પેકેજ, એજન્ટ તરીકે આયાત કરેલ) જૂની સહાયક APIથી અલગ ઉત્પાદન છે. રેસીપી એજન્ટ્સ SDKને લક્ષ્ય બનાવે છે: એજન્ટ + રનર + @function_tool પ્રતિસાદ API પર. જો તમે client.beta.assistants.create(...) કૉલ કરી રહ્યા છો, તો તમે જૂની થ્રેડ્સ/રન મોડલ OpenAIને બંધ કરી રહ્યા છો - એજન્ટ્સ SDK પર જાઓ અને ઉપરનો ફંક્શન સીધા જ આવે છે.
રકમ USDC આધાર એકમો છે, સ્ટ્રિંગ્સ તરીકે
payments.create takes amountWei: a string of USDC base units, not a float. USDC has 6 decimals, so 0.01 USDC is "10000" and 5 USDC is "5000000". Type the function argument as str; a float will lose precision before it reaches the API. Keep it a string end to end.
send_payment વહેલા 503 જવાબ આપી શકે છે
payments.create ડિફોલ્ટ દ્વારા પુનરાવૃત્ત નથી કરે અને તમારા નેટવર્ક માટે ચેઇન એડેપ્ટર વાયર કરવામાં આવે ત્યાં સુધી 503 પાછું આપી શકે છે. તમારા ફંક્શનની અંદર ભૂલને પકડો અને મોડેલ કાર્ય કરી શકે તેવા સ્પષ્ટ સંદેશાને પાછું આપો, રનરને લૂપ પર મૂકવા બદલ. આપોઆપ મિન્ટ કરેલ idempotency કીનો અર્થ એ છે કે મેન્યુઅલ પુનરાવૃત્તિ ડબલ-ચુકવણી નહીં કરે.
અસંકલન-માત્ર રનટાઇમ
એજન્ટ્સ SDK અસંક્રામક-પ્રથમ છે - રાહ જુઓ Runner.run(...). તમારા ટૂલની અંદર blockchain0x કૉલ સમકાલીન છે, જે એક જ ઝડપી પેમેન્ટ માટે સારી છે પરંતુ લોડ હેઠળ લૂપને બ્લોક કરે છે. જો તમે ઘણા સમકાલીન એજન્ટ ચલાવી રહ્યા છો, તો SDK કૉલને asyncio.to_thread સાથે લપેટો. એક સમકાલીન પ્રવેશ બિંદુથી, asyncio.run() ટોચના સ્તરે.