OpenAI Agents SDK ਇੰਟੀਗ੍ਰੇਸ਼ਨ।
ਕੋਈ ਏਜੰਟ ਐਸਡੀਕੇ ਪੈਕੇਜ ਨਹੀਂ ਹੈ, ਅਤੇ ਤੁਹਾਨੂੰ ਇੱਕ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ। @function_tool ਨਾਲ ਇੱਕ ਫੰਕਸ਼ਨ ਨੂੰ ਸਜਾਓ, ਅਸਲੀ blockchain0x ਕਲਾਇੰਟ ਨੂੰ ਕਾਲ ਕਰੋ, ਅਤੇ ਤੁਹਾਡਾ ਏਜੰਟ USDC ਨੂੰ ਬੇਸ 'ਤੇ ਚਲਾ ਸਕਦਾ ਹੈ।
OpenAI Agents SDK-specific ਕੋਈ package ਨਹੀਂ ਹੈ, ਅਤੇ ਤੁਹਾਨੂੰ ਇਸਦੀ ਲੋੜ ਵੀ ਨਹੀਂ। SDK ਇੱਕ decorated function ਨੂੰ ਨਾਲ tool ਵਿੱਚ ਬਦਲ ਦਿੰਦਾ ਹੈ, ਇਸ ਲਈ ਤੁਸੀਂ ਅਸਲੀ Python client ਨੂੰ ਇੱਕ function ਵਿੱਚ wrap ਕਰਦੇ ਹੋ ਅਤੇ ਉਸਨੂੰ ਆਪਣੇ ਵਿੱਚ add ਕਰਦੇ ਹੋ। Agent USDC ਭੇਜ ਸਕਦਾ ਹੈ, invoices settle ਕਰ ਸਕਦਾ ਹੈ, ਅਤੇ wallets ਪੜ੍ਹ ਸਕਦਾ ਹੈ - single agents, handoffs, ਅਤੇ underlying Responses API across। Payments Base 'ਤੇ settle ਹੁੰਦੀਆਂ ਹਨ।
ਸਾਫ਼ ਟੂਲ-ਕਾਲਿੰਗ ਸਤਹ ਜੋ OpenAI ਭੇਜਦਾ ਹੈ.
OpenAI ਏਜੰਟ SDK (ਜੋ 2025 ਵਿੱਚ ਜਾਰੀ ਕੀਤਾ ਗਿਆ) OpenAI ਦਾ ਸੁਝਾਅ ਹੈ ਕਿ ਏਜੰਟਾਂ ਨੂੰ Responses API ਦੇ ਉੱਪਰ ਬਣਾਉਣ ਦਾ ਤਰੀਕਾ। ਇਹ ਟੂਲ ਰਜਿਸਟ੍ਰੇਸ਼ਨ, ਸੁਨੇਹਾ ਲੂਪ, ਅਤੇ ਏਜੰਟਾਂ ਦੇ ਵਿਚਕਾਰ ਹੱਥਾਂ ਦੀ ਬੋਇਲਰਪਲੇਟ ਨੂੰ ਅਬਸਟਰੈਕਟ ਕਰਦਾ ਹੈ, ਅਤੇ ਇਹ ਸਾਫ, ਟਾਈਪ ਕੀਤੀ ਹੋਈ ਪਾਈਥਨ ਕੋਡ ਪੈਦਾ ਕਰਦਾ ਹੈ। ਜੇ ਤੁਸੀਂ ਅੱਜ ਇੱਕ OpenAI-ਕੇਂਦਰਿਤ ਏਜੰਟ ਪ੍ਰੋਜੈਕਟ ਸ਼ੁਰੂ ਕਰ ਰਹੇ ਹੋ ਅਤੇ ਤੁਹਾਡੇ ਕੋਲ ਫਰੇਮਵਰਕ ਦੀ ਪਸੰਦ ਨਹੀਂ ਹੈ, ਤਾਂ ਇਹ ਉਹ SDK ਹੈ ਜੋ ਅਸੀਂ ਸੁਝਾਉਂਦੇ ਹਾਂ.
Recipe ਜਾਣਬੂਝ ਕੇ thin ਹੈ। send_usdc ਇੱਕ plain function ਹੈ ਜਿਸ 'ਤੇ @function_tool ਦੀ decoration ਹੈ; ਤੁਸੀਂ ਇਸਨੂੰ Agent ਦੀ tools list ਵਿੱਚ add ਕਰਦੇ ਹੋ ਅਤੇ Runner ਇਸਨੂੰ pick ਕਰ ਲੈਂਦਾ ਹੈ। ਕੋਈ special configuration ਨਹੀਂ, ਕੋਈ extra wrapper ਨਹੀਂ, SDK ਦਾ ਕੋਈ fork ਨਹੀਂ। ਜਦੋਂ Agents SDK ਕੋਈ ਨਵਾਂ feature ship ਕਰਦਾ ਹੈ (multi-modal inputs, voice agents), ਤੁਹਾਡੀ function ਕੰਮ ਕਰਦੀ ਰਹਿੰਦੀ ਹੈ ਕਿਉਂਕਿ ਇਹ standard tool-calling surface 'ਤੇ ride ਕਰਦੀ ਹੈ - ਇਸ ਵਿੱਚ ਕੋਈ version-specific ਚੀਜ਼ ਨਹੀਂ ਹੁੰਦੀ।
Agents SDK ਅਤੇ ਕੋਰ SDK ਨੂੰ ਇੰਸਟਾਲ ਕਰੋ। ਦੋ ਕੁੰਜੀਆਂ।
ਕੋਈ blockchain0x ਏਜੰਟ ਐਸਡੀਕੇ ਪੈਕੇਜ ਨਹੀਂ ਹੈ ਜੋ ਜੋੜਿਆ ਜਾ ਸਕੇ। ਤੁਸੀਂ OpenAI ਏਜੰਟ ਐਸਡੀਕੇ (openai-agents ਪੈਕੇਜ, Python 3.10+) ਅਤੇ ਅਸਲੀ blockchain0x ਕੋਰ ਐਸਡੀਕੇ ਨੂੰ ਇੰਸਟਾਲ ਕਰਦੇ ਹੋ, ਫਿਰ ਹੇਠਾਂ ਦਿੱਤੀ ਫੰਕਸ਼ਨ ਲਿਖਦੇ ਹੋ। ਇਹ ਸਾਰੀ ਨਿਰਭਰਤਾ ਸੂਚੀ ਹੈ।
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 ਇਸਨੂੰ ਇੱਕ ਟੂਲ ਵਿੱਚ ਬਦਲਦਾ ਹੈ, ਅਤੇ Runner ਕਾਲ ਨੂੰ ਆਰਕੀਸਟ੍ਰੇਟ ਕਰਦਾ ਹੈ। 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 ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ, ਤਾਂ ਇਸਨੂੰ 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, arq) ਅਤੇ handler ਨੂੰ block ਕਰਨ ਦੀ ਬਜਾਏ ਤੁਰੰਤ 200 respond ਕਰੋ।
ਜਿਸ client ਨੂੰ ਤੁਸੀਂ wrap ਕਰ ਰਹੇ ਹੋ ਉਹ open ਹੈ। ਉਸਨੂੰ ਪੜ੍ਹੋ।
ਕੋਈ Agents SDK 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 ਕਰੋ।
ਪਹਿਲੀ ਇਕੀਕਰਨ 'ਤੇ ਦੇਖਣ ਲਈ ਪੰਜ ਚੀਜ਼ਾਂ।
ਇਹ ਸਾਡੇ ਸਹਾਇਤਾ ਇਨਬਾਕਸ ਤੋਂ ਆਉਂਦੇ ਹਨ। ਪਹਿਲਾਂ ਤੋਂ ਜਾਣਨਾ ਹਰ ਇੱਕ ਵਿੱਚ ਇੱਕ ਘੰਟਾ ਬਚਾਉਂਦਾ ਹੈ।
ਕੋਈ ਏਜੰਟ ਐਸਡੀਕੇ ਪੈਕੇਜ ਨਹੀਂ ਹੈ - ਤੁਸੀਂ ਐਸਡੀਕੇ ਨੂੰ ਲਪੇਟਦੇ ਹੋ
Blockchain0x LangChain ਅਤੇ CrewAI ਲਈ ਐਡਾਪਟਰਾਂ ਨੂੰ ਭੇਜਦਾ ਹੈ ਅਤੇ MCP ਸਰਵਰ; ਕੋਈ ਸਮਰਪਿਤ OpenAI Agents SDK ਪੈਕੇਜ ਨਹੀਂ ਹੈ। ਉਪਰੋਕਤ ਨੁਸਖਾ ਉਹ ਰਸਤਾ ਹੈ: ਇੱਕ ਸਧਾਰਣ ਟਾਈਪ ਕੀਤੀ ਫੰਕਸ਼ਨ ਨੂੰ @function_tool ਨਾਲ ਸਜਾਉਣਾ, ਅੰਦਰ ਅਸਲ blockchain0x ਕਲਾਇੰਟ ਨੂੰ ਕਾਲ ਕਰਨਾ, ਅਤੇ ਇਸਨੂੰ Agent(tools=[...]) ਵਿੱਚ ਸ਼ਾਮਲ ਕਰਨਾ। SDK ਦਸਤਖਤ ਅਤੇ ਡੌਕਸਟ੍ਰਿੰਗ ਨੂੰ ਪੜ੍ਹਦਾ ਹੈ ਤਾਂ ਜੋ ਟੂਲ ਸਕੀਮਾ ਬਣਾਇਆ ਜਾ ਸਕੇ, ਇਸ ਲਈ ਡੌਕਸਟ੍ਰਿੰਗ ਨੂੰ ਸਹੀ ਰੱਖੋ।
ਏਜੰਟਾਂ SDK ਸਹਾਇਕ API ਨਹੀਂ ਹੈ
OpenAI Agents SDK (openai-agents package, ਜਿਸਨੂੰ agents ਵਜੋਂ import ਕੀਤਾ ਜਾਂਦਾ ਹੈ) ਪੁਰਾਣੇ Assistants API ਤੋਂ ਵੱਖਰਾ product ਹੈ। ਇਹ recipe Agents SDK ਨੂੰ target ਕਰਦੀ ਹੈ: Responses API ਉੱਤੇ Agent + Runner + @function_tool। ਜੇ ਤੁਸੀਂ client.beta.assistants.create(...) call ਕਰ ਰਹੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਪੁਰਾਣੇ threads/runs model 'ਤੇ ਹੋ ਜਿਸਨੂੰ OpenAI ਹੌਲੀ-ਹੌਲੀ wind down ਕਰ ਰਿਹਾ ਹੈ - Agents SDK 'ਤੇ move ਕਰੋ ਅਤੇ ਉੱਪਰ ਵਾਲਾ function ਸਿੱਧਾ fit ਹੋ ਜਾਂਦਾ ਹੈ।
ਰਕਮਾਂ 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 ਵਾਪਸ ਕਰ ਸਕਦਾ ਹੈ। ਗਲਤੀ ਨੂੰ ਆਪਣੇ ਫੰਕਸ਼ਨ ਦੇ ਅੰਦਰ ਪਕੜੋ ਅਤੇ ਇੱਕ ਸਾਫ਼ ਸੁਨੇਹਾ ਵਾਪਸ ਕਰੋ ਜਿਸ 'ਤੇ ਮਾਡਲ ਕਾਰਵਾਈ ਕਰ ਸਕਦਾ ਹੈ, ਬਜਾਏ ਇਹਨੂੰ Runner ਲੂਪ ਕਰਨ ਦੇ। ਆਟੋ-ਮਿੰਟ ਕੀਤੀ ਗਈ idempotency ਕੁੰਜੀ ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਹੱਥ ਨਾਲ ਦੁਬਾਰਾ ਕੋਸ਼ਿਸ਼ ਕਰਨ ਨਾਲ ਦੋਹਰਾ ਭੁਗਤਾਨ ਨਹੀਂ ਹੋਵੇਗਾ।
ਐਸਿੰਕ-ਕੇਵਲ ਰਨਟਾਈਮ
Agents SDK async-first ਹੈ - await Runner.run(...). ਤੁਹਾਡੇ tool ਦੇ ਅੰਦਰ blockchain0x call synchronous ਹੁੰਦੀ ਹੈ, ਜੋ ਇੱਕ ਤੇਜ਼ payment ਲਈ ਠੀਕ ਹੈ ਪਰ load ਹੇਠਾਂ loop ਨੂੰ block ਕਰ ਦਿੰਦੀ ਹੈ। ਜੇ ਤੁਸੀਂ ਕਈ concurrent agents ਚਲਾ ਰਹੇ ਹੋ, ਤਾਂ SDK call ਨੂੰ asyncio.to_thread ਨਾਲ wrap ਕਰੋ। Sync entry point ਤੋਂ, top level 'ਤੇ asyncio.run() ਵਰਤੋ।