Pydantic AI ਭੁਗਤਾਨ ਏਕਤਾ।
ਕੋਈ Pydantic AI ਪੈਕੇਜ ਨਹੀਂ ਹੈ, ਅਤੇ ਤੁਹਾਨੂੰ ਇੱਕ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ। @agent.tool_plain ਨਾਲ ਇੱਕ ਟਾਈਪ ਕੀਤੀ ਫੰਕਸ਼ਨ ਰਜਿਸਟਰ ਕਰੋ, ਅਸਲੀ blockchain0x ਕਲਾਇੰਟ ਨੂੰ ਕਾਲ ਕਰੋ, ਅਤੇ ਤੁਹਾਡਾ ਏਜੰਟ USDC ਨੂੰ ਬੇਸ 'ਤੇ ਚਲਾ ਸਕਦਾ ਹੈ।
Pydantic AI-specific ਕੋਈ package ਨਹੀਂ ਹੈ, ਅਤੇ ਤੁਹਾਨੂੰ ਇਸਦੀ ਲੋੜ ਵੀ ਨਹੀਂ। Pydantic AI ਇੱਕ function ਨੂੰ ਨਾਲ validated tool ਵਿੱਚ ਬਦਲ ਦਿੰਦਾ ਹੈ, ਇਸ ਲਈ ਤੁਸੀਂ ਅਸਲੀ Python client ਨੂੰ ਇੱਕ typed function ਵਿੱਚ wrap ਕਰਦੇ ਹੋ ਅਤੇ agent USDC ਭੇਜ ਸਕਦਾ ਹੈ, invoices settle ਕਰ ਸਕਦਾ ਹੈ, ਅਤੇ wallets ਪੜ੍ਹ ਸਕਦਾ ਹੈ। ਇਹ OpenAI, Anthropic, Google, Mistral, Groq, ਅਤੇ ਹਰ ਹੋਰ Pydantic AI provider across ਕੰਮ ਕਰਦਾ ਹੈ, ਕਿਉਂਕਿ tool model ਨਹੀਂ, HTTP API ਨੂੰ call ਕਰਦਾ ਹੈ। Payments Base 'ਤੇ settle ਹੁੰਦੀਆਂ ਹਨ।
Pydantic AI ਦੀ ਟਾਈਪਿੰਗ ਜਿੱਤਦੀ ਹੈ। ਇਸਨੂੰ ਭੁਗਤਾਨਾਂ ਲਈ ਵੀ ਵਰਤੋਂ।
Pydantic AI ਦਾ ਮੁੱਖ ਮਕਸਦ ਮਜ਼ਬੂਤ ਟਾਈਪਿੰਗ ਹੈ: ਏਜੰਟ ਇਨਪੁਟ ਟਾਈਪ ਕੀਤੇ ਜਾਂਦੇ ਹਨ, ਆਉਟਪੁਟ ਟਾਈਪ ਕੀਤੇ ਜਾਂਦੇ ਹਨ, ਨਿਰਭਰਤਾਵਾਂ ਟਾਈਪ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ, ਦੁਬਾਰਾ ਕੋਸ਼ਿਸ਼ਾਂ ਟਾਈਪ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ। ਫਰੇਮਵਰਕ ਗਲਤ ਡੇਟਾ ਨੂੰ ਸਰਹੱਦ 'ਤੇ ਰੱਦ ਕਰਦਾ ਹੈ ਬਜਾਏ ਇਸਨੂੰ LLM ਕਾਲ ਰਾਹੀਂ ਫੈਲਣ ਦੇ। ਤੁਹਾਡਾ ਵਾਲਿਟ ਟੂਲ ਬਿਲਕੁਲ ਇਸ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ - ਆਰਗੂਮੈਂਟਸ ਨੂੰ ਟਾਈਪਾਂ ਨਾਲ ਘੋਸ਼ਿਤ ਕਰੋ, ਅਤੇ Pydantic AI ਸਿਗਨੇਚਰ ਅਤੇ ਡੌਕਸਟ੍ਰਿੰਗ ਤੋਂ ਇੱਕ ਵੈਰੀਫਾਈਡ ਸਕੀਮਾ ਬਣਾਉਂਦਾ ਹੈ ਜਿਸ ਤੋਂ ਪਹਿਲਾਂ ਮਾਡਲ ਨੂੰ ਕਾਲ ਕਰਨ ਦੀ ਆਗਿਆ ਨਹੀਂ ਦਿੱਤੀ ਜਾਂਦੀ।
Practical benefit ਇਹ ਹੈ: ਜੇ model send_usdc ਨੂੰ base-unit string ਦੀ ਬਜਾਏ float ਨਾਲ call ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੇ, ਤਾਂ failure Pydantic ਦੀ validation layer 'ਤੇ ਹੀ ਹੋ ਜਾਂਦਾ ਹੈ, ਸਾਡੇ ਵੱਲ ਕੋਈ HTTP call ਹੋਣ ਤੋਂ ਪਹਿਲਾਂ। ਤੁਹਾਨੂੰ ਇੱਕ clear ValidationError ਇੱਕ useful message ਨਾਲ ਮਿਲਦੀ ਹੈ, ਨਾ ਕਿ API ਤੋਂ cryptic field paths ਵਾਲਾ 422। ਇਸੇ ਲਈ ਇੱਥੇ client ਨੂੰ ਖੁਦ wrap ਕਰਨਾ ਸਹੀ ਹੈ, generic adapter ਲੈਣ ਦੀ ਬਜਾਏ - ਤੁਸੀਂ typing ਨੂੰ wire ਤੱਕ ਬਣਾਈ ਰੱਖਦੇ ਹੋ।
Pydantic AI ਅਤੇ ਕੋਰ SDK ਨੂੰ ਇੰਸਟਾਲ ਕਰੋ। ਦੋ ਕੁੰਜੀਆਂ।
ਕੋਈ blockchain0x Pydantic AI ਪੈਕੇਜ ਨਹੀਂ ਹੈ ਜੋ ਜੋੜਿਆ ਜਾ ਸਕੇ। ਤੁਸੀਂ Pydantic AI (Python 3.10+) ਅਤੇ ਅਸਲੀ blockchain0x ਕੋਰ ਐਸਡੀਕੇ ਨੂੰ ਇੰਸਟਾਲ ਕਰਦੇ ਹੋ, ਫਿਰ ਹੇਠਾਂ ਦਿੱਤੀ ਫੰਕਸ਼ਨ ਲਿਖਦੇ ਹੋ। ਇਹ ਸਾਰੀ ਨਿਰਭਰਤਾ ਸੂਚੀ ਹੈ।
pip install pydantic-ai blockchain0xexport OPENAI_API_KEY=sk-... export BLOCKCHAIN0X_API_KEY=sk_test_... # sk_test_ = Base Sepolia, sk_live_ = Base mainnet
OPENAI_API_KEY (ਜਾਂ ਜਿਸ provider ਨੂੰ ਤੁਸੀਂ ਵਰਤਦੇ ਹੋ, ਉਸਦੇ equivalent). BLOCKCHAIN0X_API_KEY ਤੁਹਾਡੇ dashboard ਤੋਂ ਇੱਕ sk_test_ testnet ਜਾਂ sk_live_ mainnet key ਹੈ; client ਇਸਨੂੰ environment ਤੋਂ ਪੜ੍ਹਦਾ ਹੈ। ਜੇ ਤੁਹਾਡਾ agent ਪੈਸੇ ਵੀ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ, ਤਾਂ webhook handler ਨੂੰ ਵਾਧੂ ਤੌਰ 'ਤੇ BLOCKCHAIN0X_WEBHOOK_SECRET ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।
ਇੱਕ ਟਾਈਪ ਕੀਤੀ ਗਈ ਫੰਕਸ਼ਨ ਜੋ ਭੁਗਤਾਨ ਕਰਦੀ ਹੈ, ਇੱਕ ਟੂਲ ਵਜੋਂ ਰਜਿਸਟਰ ਕੀਤੀ ਗਈ.
ਹੇਠਾਂ ਪੂਰੀ ਇੰਟਿਗ੍ਰੇਸ਼ਨ ਹੈ। send_usdc ਅਸਲ blockchain0x ਕਲਾਇੰਟ ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ; @agent.tool_plain ਇਸਨੂੰ ਇੱਕ ਸਕੀਮਾ ਨਾਲ ਰਜਿਸਟਰ ਕਰਦਾ ਹੈ ਜੋ ਕਿਸਮ ਦੇ ਸੁਝਾਅ ਅਤੇ ਡੌਕਸਟ੍ਰਿੰਗ ਤੋਂ ਬਣਾਇਆ ਗਿਆ ਹੈ। ਇਸਨੂੰ ਚਲਾਓ ਅਤੇ ਏਜੰਟ Base 'ਤੇ USDC ਨੂੰ ਚਲਾਉਂਦਾ ਹੈ, ਕਾਲ ਤੋਂ ਪਹਿਲਾਂ ਆਰਗੂਮੈਂਟਾਂ ਦੀ ਪੁਸ਼ਟੀ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।
from pydantic_ai import Agent from blockchain0x import Client blockchain0x = Client() # reads BLOCKCHAIN0X_API_KEY from the environment agent = Agent( "openai:gpt-4o", system_prompt="You pay vendor invoices in USDC within owner-set limits.", ) # Register a plain function as a tool. No dedicated package needed. @agent.tool_plain 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}) ) result = agent.run_sync( "Pay 0.01 USDC from agent agt_123 to 0xVendor for the dataset." ) print(result.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_. Want a typed result object instead of a string? Set the agent's output_type to your own Pydantic model and return it from the tool. Add read and settle functions the same way.
ਇੱਕ ਸਾਈਨ ਕੀਤੀ ਵੈਬਹੂਕ ਨਾਲ ਆਉਣ ਵਾਲੇ ਭੁਗਤਾਨਾਂ ਦੀ ਪੁਸ਼ਟੀ ਕਰੋ।
ਜੇ ਤੁਹਾਡਾ ਏਜੰਟ ਵੀ USDC ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ, ਤਾਂ ਇਸਨੂੰ webhook ਨਾਲ ਪੁਸ਼ਟੀ ਕਰੋ ਨਾ ਕਿ ਪੁਸ਼ਟੀ ਕਰਨ ਨਾਲ। ਪ੍ਰਮਾਣਿਤ ਕਰਨ ਵਾਲਾ ਸਹਾਇਕ Node SDK ਵਿੱਚ ਸ਼ਿਪ ਕੀਤਾ ਜਾਂਦਾ ਹੈ; ਇੱਕ Python ਸੇਵਾ ਵਿੱਚ ਤੁਸੀਂ ਦਸਤਾਵੇਜ਼ HMAC ਦੇ ਖਿਲਾਫ ਹੱਥ ਨਾਲ ਪ੍ਰਮਾਣਿਤ ਕਰਦੇ ਹੋ। ਜੇ ਤੁਸੀਂ ਟਾਈਪ ਕੀਤੇ ਇਵੈਂਟ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਆਪਣਾ Pydantic ਮਾਡਲ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ ਅਤੇ ਦਸਤਖਤ ਦੀ ਜਾਂਚ ਕਰਨ ਤੋਂ ਬਾਅਦ ਕੱਚੇ ਬੋਡੀ ਨੂੰ model_validate_json ਕਰੋ - ਟਾਈਪਿੰਗ ਤੁਹਾਡੀ ਹੈ ਜੋ ਸ਼ਾਮਲ ਕਰਨ ਲਈ। ਹੇਠਾਂ FastAPI ਉਦਾਹਰਨ।
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; branch ਕਰਨ ਲਈ X-Blockchain0x-Event-Type header 'ਤੇ narrow ਕਰੋ।
ਜਿਸ client ਨੂੰ ਤੁਸੀਂ wrap ਕਰ ਰਹੇ ਹੋ ਉਹ open ਹੈ। ਉਸਨੂੰ ਪੜ੍ਹੋ।
ਕੋਈ Pydantic AI 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 ਕਰੋ।
ਪੰਜ Pydantic AI-ਵਿਸ਼ੇਸ਼ ਜਾਲਾਂ ਤੋਂ ਬਚਣ ਲਈ।
Pydantic AI ਦੀ ਮਜ਼ਬੂਤ ਟਾਈਪਿੰਗ ਜ਼ਿਆਦਾਤਰ ਏਕਤਾ ਬੱਗਾਂ ਨੂੰ ਸੀਮਾ 'ਤੇ ਫੜ ਲੈਂਦੀ ਹੈ; ਇਹ ਕੁਝ ਹਨ ਜੋ ਫਿਸਲ ਜਾਂਦੇ ਹਨ।
ਕੋਈ Pydantic AI ਪੈਕੇਜ ਨਹੀਂ ਹੈ - ਤੁਸੀਂ ਇੱਕ ਟੂਲ ਰਜਿਸਟਰ ਕਰਦੇ ਹੋ
Blockchain0x LangChain ਅਤੇ CrewAI ਲਈ ਐਡਾਪਟਰਾਂ ਨੂੰ ਭੇਜਦਾ ਹੈ ਅਤੇ MCP ਸਰਵਰ; ਕੋਈ ਸਮਰਪਿਤ Pydantic AI ਪੈਕੇਜ ਨਹੀਂ ਹੈ। ਉਪਰੋਕਤ ਨੁਸਖਾ ਉਹ ਰਸਤਾ ਹੈ: ਇੱਕ ਸਧਾਰਣ ਟਾਈਪ ਕੀਤੀ ਫੰਕਸ਼ਨ ਜੋ @agent.tool_plain ਨਾਲ ਸਜਾਈ ਗਈ ਹੈ ਜੋ ਅਸਲ blockchain0x ਕਲਾਇੰਟ ਨੂੰ ਕਾਲ ਕਰਦੀ ਹੈ। Pydantic AI ਦਸਤਖਤ ਅਤੇ ਡੌਕਸਟ੍ਰਿੰਗ ਨੂੰ ਪੜ੍ਹਦਾ ਹੈ ਤਾਂ ਜੋ ਇੱਕ ਪ੍ਰਮਾਣਿਤ ਟੂਲ ਸਕੀਮਾ ਬਣਾਇਆ ਜਾ ਸਕੇ, ਜੋ ਕਿ ਉਹ ਟਾਈਪਿੰਗ ਜਿੱਤ ਹੈ ਜਿਸ ਲਈ ਤੁਸੀਂ Pydantic AI ਵਿੱਚ ਆਏ ਸੀ।
ਰਕਮ ਨੂੰ ਇੱਕ ਸਤਰ ਰੱਖੋ; Pydantic ਨੂੰ ਰਖਣ ਦਿਓ
payments.create takes amountWei: a string of USDC base units (6 decimals), so 0.01 USDC is "10000" and 5 USDC is "5000000". Type the tool argument as str and Pydantic AI rejects a float at the boundary with a clear ValidationError, before any HTTP call. That is the whole point of doing this in Pydantic AI - the malformed value never reaches the API.
send_payment ਪਹਿਲਾਂ 503 ਦਾ ਜਵਾਬ ਦੇ ਸਕਦਾ ਹੈ
payments.create ਡਿਫਾਲਟ ਵਜੋਂ ਦੁਬਾਰਾ ਕੋਸ਼ਿਸ਼ ਨਹੀਂ ਕਰਦਾ ਅਤੇ ਤੁਹਾਡੇ ਨੈੱਟਵਰਕ ਲਈ ਚੇਨ ਐਡਾਪਟਰ ਵਾਇਰ ਹੋਣ ਤੱਕ 503 ਵਾਪਸ ਕਰ ਸਕਦਾ ਹੈ। ਗਲਤੀ ਨੂੰ ਆਪਣੇ ਟੂਲ ਦੇ ਅੰਦਰ ਪਕੜੋ ਅਤੇ ਇੱਕ ਸਾਫ਼ ਸੁਨੇਹਾ ਵਾਪਸ ਕਰੋ ਜਿਸ 'ਤੇ ਮਾਡਲ ਕਾਰਵਾਈ ਕਰ ਸਕਦਾ ਹੈ, ਬਜਾਏ ਏਜੰਟ ਨੂੰ ਲੂਪ ਕਰਨ ਦੇ। ਆਟੋ-ਮਿੰਟ ਕੀਤੀ ਗਈ idempotency ਕੁੰਜੀ ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਹੱਥ ਨਾਲ ਦੁਬਾਰਾ ਕੋਸ਼ਿਸ਼ ਕਰਨ ਨਾਲ ਦੋਹਰਾ ਭੁਗਤਾਨ ਨਹੀਂ ਹੋਵੇਗਾ।
ਪ੍ਰਦਾਤਾ-ਪ੍ਰੀਫਿਕਸ ਮਾਡਲ ਸਤਰਾਂ
Pydantic AI ਪ੍ਰਦਾਤਾ-ਪ੍ਰੀਫਿਕਸ ਮਾਡਲ ਸਟਰਿੰਗਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ: 'openai:gpt-4o', 'anthropic:claude-3-5-sonnet-latest', 'google-gla:gemini-1.5-pro'. ਪ੍ਰੀਫਿਕਸ ਛੱਡਣ 'unknown model' ਗਲਤੀ ਦਿੰਦਾ ਹੈ। ਤੁਹਾਡਾ ਟੂਲ ਪ੍ਰਦਾਤਾ-ਅਗਨੋਸਟਿਕ ਹੈ ਕਿਉਂਕਿ ਇਹ HTTP API ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ, ਮਾਡਲ ਨੂੰ ਨਹੀਂ - ਪ੍ਰੀਫਿਕਸ ਨੂੰ ਆਜ਼ਾਦੀ ਨਾਲ ਬਦਲੋ ਅਤੇ ਵਾਲਿਟ ਫੰਕਸ਼ਨ ਬਦਲਿਆ ਨਹੀਂ ਜਾਵੇਗਾ।
tool_plain ਬਨਾਮ tool (RunContext)
ਜਦੋਂ ਫੰਕਸ਼ਨ ਨੂੰ ਚਲਾਉਣ ਤੋਂ ਕੁਝ ਵੀ ਨਹੀਂ ਚਾਹੀਦਾ, ਤਾਂ @agent.tool_plain ਦੀ ਵਰਤੋਂ ਕਰੋ, ਜਿਵੇਂ ਉਪਰ। ਜੇ ਤੁਸੀਂ ਟੂਲ ਦੇ ਅੰਦਰ ਏਜੰਟ ਦੀਆਂ ਨਿਰਭਰਤਾਵਾਂ ਚਾਹੁੰਦੇ ਹੋ (ਇੱਕ ਪ੍ਰਤੀ-ਬੇਨਤੀ ਕਲਾਇੰਟ ਆਈਡੀ, ਇੱਕ ਖਰਚ ਦੀ ਸੀਮਾ), ਤਾਂ @agent.tool ਦੀ ਵਰਤੋਂ ਕਰੋ ਅਤੇ ਪਹਿਲੇ ਆਰਗੂਮੈਂਟ ਨੂੰ ctx: RunContext[Deps] ਦੇ ਤੌਰ 'ਤੇ ਘੋਸ਼ਿਤ ਕਰੋ ਤਾਂ ਜੋ ctx.deps ਨੂੰ ਪੜ੍ਹ ਸਕੋ। ਦੋਨੋਂ ਨੂੰ ਮਿਲਾਉਣਾ - tool_plain 'ਤੇ ctx ਆਰਗੂਮੈਂਟ ਦੀ ਘੋਸ਼ਣਾ ਕਰਨਾ - ਰਜਿਸਟ੍ਰੇਸ਼ਨ 'ਤੇ ਇੱਕ TypeError ਉਠਾਉਂਦਾ ਹੈ।