xapi-to 0.1.20 → 0.1.22

package/dist/openai-sandbox-client.js

@@ -7,7 +7,7 @@ import {
   sandboxQuote,
   sandboxStateAction,
   sandboxWait
-} from "./chunk-TYY6JR6O.js";
+} from "./chunk-2YRWNREY.js";
 
 // src/openai-sandbox-client.ts
 import { randomUUID } from "crypto";

package/examples/openai-gpt-live-text.mjs

@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+
+// Minimal GPT Live control-path example through xAPI. It uses managed Responses
+// delegation and text input so the session lifecycle is visible without audio
+// capture. Install the transport in your application first: npm install ws
+
+import { randomUUID } from 'node:crypto';
+
+const apiKey = process.env.XAPI_KEY || process.env.XAPI_API_KEY;
+if (!apiKey) {
+  throw new Error('Set XAPI_KEY or XAPI_API_KEY in the process environment');
+}
+
+let WebSocket;
+try {
+  ({ default: WebSocket } = await import('ws'));
+} catch {
+  throw new Error('This example requires the ws package: npm install ws');
+}
+
+const prompt = process.argv.slice(2).join(' ').trim() || 'Say hello in one short sentence.';
+const prefix = randomUUID();
+const url = 'wss://openai-live.p.xapi.to/v1/live/sessions';
+const socket = new WebSocket(url, {
+  headers: { 'XAPI-Key': apiKey },
+});
+
+const timeout = setTimeout(() => {
+  console.error('GPT Live example timed out');
+  socket.terminate();
+  process.exitCode = 1;
+}, 60_000);
+
+let closeRequested = false;
+let sessionClosedConfirmed = false;
+
+function send(event) {
+  socket.send(JSON.stringify(event));
+}
+
+function finish(error) {
+  clearTimeout(timeout);
+  if (error) {
+    console.error(error.message || error);
+    process.exitCode = 1;
+  }
+  if (socket.readyState === WebSocket.OPEN) socket.close();
+}
+
+socket.on('open', () => {
+  send({
+    type: 'session.start',
+    event_id: `${prefix}-start`,
+    session: {
+      model: 'gpt-live-1',
+      instructions: 'Respond concisely.',
+      delegation: { type: 'responses' },
+      store: false,
+    },
+  });
+});
+
+socket.on('message', (raw, isBinary) => {
+  if (isBinary) return finish(new Error('Unexpected binary GPT Live frame'));
+
+  let event;
+  try {
+    event = JSON.parse(raw.toString());
+  } catch {
+    return finish(new Error('GPT Live returned invalid JSON'));
+  }
+
+  if (event.type === 'session.started') {
+    send({
+      type: 'response.item.create',
+      event_id: `${prefix}-input`,
+      item: {
+        type: 'message',
+        role: 'user',
+        content: [{ type: 'input_text', text: prompt }],
+      },
+    });
+    send({ type: 'response.create', event_id: `${prefix}-response` });
+    return;
+  }
+
+  if (event.type === 'response.event') {
+    const nested = event.event || {};
+    if (nested.type === 'response.output_text.delta' && typeof nested.delta === 'string') {
+      process.stdout.write(nested.delta);
+      return;
+    }
+    if (nested.type === 'response.refusal.delta' && typeof nested.delta === 'string') {
+      process.stdout.write(nested.delta);
+      return;
+    }
+    if (nested.type === 'response.completed') {
+      process.stdout.write('\n');
+      closeRequested = true;
+      send({ type: 'session.close', event_id: `${prefix}-close` });
+      return;
+    }
+    if (nested.type === 'response.failed' || nested.type === 'response.incomplete') {
+      return finish(new Error(`Delegated response ended with ${nested.type}`));
+    }
+  }
+
+  if (event.type === 'error') {
+    return finish(new Error(event.error?.message || 'GPT Live session error'));
+  }
+
+  if (event.type === 'session.closed') {
+    if (!closeRequested || event.reason !== 'close_requested') {
+      return finish(new Error(`Unexpected session close: ${event.reason || 'unknown'}`));
+    }
+    sessionClosedConfirmed = true;
+    finish();
+  }
+});
+
+socket.on('error', (error) => finish(new Error(`WebSocket error: ${error.message}`)));
+socket.on('close', () => {
+  clearTimeout(timeout);
+  if (!sessionClosedConfirmed && process.exitCode !== 1) {
+    console.error('WebSocket closed before session.closed confirmation');
+    process.exitCode = 1;
+  }
+});

package/examples/provider/openapi.json

@@ -0,0 +1,34 @@
+{
+  "openapi": "3.0.3",
+  "info": {
+    "title": "Example Provider API",
+    "version": "1.0.0",
+    "description": "Replace this example with your own upstream API contract.",
+    "x-xapi-category": "Public-Utils",
+    "x-xapi-host": "example-provider-api"
+  },
+  "servers": [{ "url": "https://upstream.example.com" }],
+  "paths": {
+    "/status": {
+      "get": {
+        "summary": "Get status",
+        "description": "Return the upstream service status.",
+        "x-xapi-billing": { "type": "PER_CALL", "costPerCall": 0.001 },
+        "responses": {
+          "200": {
+            "description": "Service status",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": { "status": { "type": "string" } }
+                },
+                "example": { "status": "ok" }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xapi-to",
-  "version": "0.1.20",
+  "version": "0.1.22",
   "description": "Agent-friendly CLI for xapi - discover and call capabilities and APIs",
   "type": "module",
   "bin": {

package/skills/xapi/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: xapi
-description: Access real-time external data and managed cloud sandboxes via the xapi CLI — Twitter/X, social platforms, crypto, web/news search, AI generation, SMS verification, and auditable ephemeral compute. Configure the xAPI AI or WebSocket Gateways, or use sandbox run for automatic quote/create/execute/cleanup. Use when the user mentions xapi, external services, or sandbox compute.
+description: Access real-time external data and managed cloud sandboxes via the xapi CLI — Twitter/X, social platforms, domain purchase and DNS, normalized crypto, BlockPI RPC, Binance Web3 API, web/news search, AI generation, SMS verification, and auditable ephemeral compute. Configure the xAPI AI or WebSocket Gateways, or use sandbox run for automatic quote/create/execute/cleanup. Use when the user mentions xapi, external services, or sandbox compute.
 metadata: {"openclaw":{"emoji":"x","requires":{"anyBins":["npx"]},"primaryEnv":"XAPI_KEY"}}
 ---
 
@@ -57,7 +57,7 @@ Use these flags where the command documents them:
 
 xapi offers two types of APIs under a unified interface:
 
-1. **Capabilities** (`--source capability`) — Built-in APIs with known IDs (Twitter, crypto, AI, web search, news)
+1. **Capabilities** (`--source capability`) — Built-in APIs with known IDs (Twitter, domains/DNS, crypto, AI, web search, news)
 2. **Third-party APIs** (`--source api`) — Proxied services, discovered via `list`, `search`, or `services`
 
 Both types use the same discovery and call workflow. Use `--source capability` or `--source api` on commands that expose source filtering.
@@ -155,211 +155,60 @@ npx xapi-to call x-official.2_tweets --method POST --input '{"body":{"text":"Hel
 
 Always use `--input` with JSON for passing parameters.
 
-### Twitter / X (9 APIs)
+### Capability routing
 
-```bash
-# Get user profile
-npx xapi-to call twitter.user_by_screen_name --input '{"screen_name":"elonmusk"}'
-
-# Get user's tweets
-npx xapi-to call twitter.user_tweets --input '{"user_id":"44196397"}'
-
-# Get user's tweets and replies (timeline includes replies)
-npx xapi-to call twitter.user_tweets_and_replies --input '{"user_id":"44196397"}'
-
-# Get tweet details and replies; video media include the highest-bitrate MP4 in video_url
-npx xapi-to call twitter.tweet_detail --input '{"tweet_id":"1234567890"}'
-
-# Get user's media posts
-npx xapi-to call twitter.user_media --input '{"user_id":"44196397"}'
-
-# Get followers / following
-npx xapi-to call twitter.followers --input '{"user_id":"44196397"}'
-npx xapi-to call twitter.following --input '{"user_id":"44196397"}'
-
-# Search tweets
-npx xapi-to call twitter.search --input '{"raw_query":"bitcoin","count":20}'
-
-# Advanced search filters (provider x)
-npx xapi-to call twitter.search --input '{"raw_query":"AI","from":"OpenAI","since":"2026-08-01","min_likes":100,"count":20}'
-
-# Get retweeters of a tweet
-npx xapi-to call twitter.retweeters --input '{"tweet_id":"1234567890"}'
-```
-
-Note: Twitter user_id is a numeric ID. To get it, first call `twitter.user_by_screen_name` with the username, then extract `rest_id` from the response.
-
-Note: All `twitter.*` capabilities accept an optional `provider` — `"x"` (fapi.uk, default) or `"twitter"` (legacy upstream). Responses are normalized to an identical structure across providers, so you normally don't need to set it; pass `"provider":"twitter"` only to force the legacy upstream.
-
-Note: Timeline, reply, media, follower/following, retweeter, and search responses expose pagination cursors. Pass the previous response's bottom cursor back as `cursor`; see `guides/twitter.md` for the exact response field used by each endpoint.
-
-Note: For long-form **X Articles**, `twitter.tweet_detail` automatically returns the full article in `tweet.article`, including `text`, `markdown`, cover image, links, and timestamps. No raw GraphQL call is needed.
-
-Note: To download tweet videos, use the bundled `scripts/download_tweet_videos.sh` workflow documented in `guides/twitter.md`. It consumes `twitter.tweet_detail`'s normalized `media[].video_url`, handles multiple and nested quoted/retweeted videos, preserves automatic `x` → `twitter` failover, validates MP4 content, and publishes downloads atomically. Do not treat `media[].url` or `preview_url` as video files; they are preview images.
-
-### Crypto (17 registered APIs; 16 recommended)
-
-Two addressing models:
-
-- **On-chain by contract address** (`crypto.token.*`, `crypto.wallet.*`, `crypto.tx.*`, `crypto.dex.*`) — the `token`/`address`/`pair` field is a **contract/wallet address**, plus a `chain`. Supported chains: `eth`, `bsc` (default), `solana`, `base`, `arbitrum`, `polygon`, `optimism`, `avalanche`.
-- **By symbol** (`crypto.cex.*`) — for coins without a contract address (e.g. "how much is BTC?"), use the CEX endpoints with a `symbol`.
-
-```bash
-# --- Token by contract address ---
-
-# Price + 24h market data (aggregates multiple providers with fallback)
-npx xapi-to call crypto.token.price --input '{"token":"0x55d398326f99059ff775485246999027b3197955","chain":"bsc"}'
-
-# Full overview: metadata + price + market in one call (preferred over metadata)
-npx xapi-to call crypto.token.overview --input '{"token":"0x55d398326f99059ff775485246999027b3197955","chain":"bsc"}'
-
-# OHLCV candles (interval: 1m/5m/1h/1d…, default 1d)
-npx xapi-to call crypto.token.ohlcv --input '{"token":"0x...","chain":"bsc","interval":"1h","limit":100}'
-
-# Top holders / top traders / security (honeypot, tax, etc.)
-npx xapi-to call crypto.token.holders --input '{"token":"0x...","chain":"bsc"}'
-npx xapi-to call crypto.token.holders --input '{"token":"0x...","chain":"bsc","cursor":"<next_cursor>"}'
-npx xapi-to call crypto.token.top_traders --input '{"token":"0x...","chain":"bsc"}'
-npx xapi-to call crypto.token.security --input '{"token":"0x...","chain":"bsc"}'
-
-# Trending tokens on a chain
-npx xapi-to call crypto.token.trending --input '{"chain":"bsc","limit":20}'
-
-# Search tokens by name / symbol / address
-npx xapi-to call crypto.token.search --input '{"query":"PEPE"}'
-
-# --- Wallet / transaction / DEX pair ---
-npx xapi-to call crypto.wallet.balance --input '{"address":"0x...","chain":"bsc"}'
-npx xapi-to call crypto.wallet.pnl --input '{"address":"0x...","chain":"bsc"}'
-npx xapi-to call crypto.wallet.history --input '{"address":"0x...","chain":"bsc","limit":50}'
-npx xapi-to call crypto.tx.detail --input '{"txHash":"0x...","chain":"bsc"}'
-npx xapi-to call crypto.dex.pair --input '{"pair":"0x...","chain":"bsc"}'
-
-# --- CEX by symbol (no contract address needed) ---
-
-# Spot price of a coin by symbol
-npx xapi-to call crypto.cex.price --input '{"symbol":"BTC"}'
-
-# CEX OHLCV candles
-npx xapi-to call crypto.cex.ohlcv --input '{"symbol":"BTC","interval":"1d","limit":100}'
-
-# --- News ---
-npx xapi-to call crypto.news --input '{"symbol":"BTC","limit":20}'
-```
-
-Note: `crypto.token.metadata` is **deprecated** — use `crypto.token.overview` instead (it returns metadata + price + market in one call).
-Note: All `crypto.token.*`/`crypto.wallet.*`/etc. accept an optional `provider` to pin a specific upstream and disable automatic fallback.
-Note: `crypto.token.holders`, `crypto.wallet.balance`, and `crypto.wallet.history` return an opaque `next_cursor` when another page is available. Pass it back unchanged as `cursor`; it pins pagination to the provider that issued it.
+- Twitter/X reads and writes → `guides/twitter.md`; use the specialized social guide when applicable.
+- Domain search, purchase, and DNS management → `guides/domains.md` before any purchase or write.
+- Normalized token, wallet, DEX, CEX, and crypto-news data → `guides/crypto.md`.
+- General/news/image/video/scholar/maps/places/shopping search → `guides/google_search.md`.
+- AI text, embeddings, image/video/audio generation, and transcription → `guides/ai.md`.
 
-### Web Search (9 APIs)
+Common read-only examples:
 
 ```bash
-# General web search
+npx xapi-to call twitter.user_by_screen_name --input '{"screen_name":"OpenAI"}'
 npx xapi-to call web.search --input '{"q":"latest AI news"}'
-
-# Realtime web search with time filter
-npx xapi-to call web.search.realtime --input '{"q":"breaking news","timeRange":"day"}'
-
-# News search
-npx xapi-to call web.search.news --input '{"q":"crypto regulation"}'
-
-# Image search
-npx xapi-to call web.search.image --input '{"q":"aurora borealis"}'
-
-# Video search
-npx xapi-to call web.search.video --input '{"q":"machine learning tutorial"}'
-
-# Academic / scholar search
-npx xapi-to call web.search.scholar --input '{"q":"transformer architecture"}'
-
-# Maps search
-npx xapi-to call web.search.maps --input '{"q":"coffee shop near Times Square"}'
-
-# Places search (businesses with details)
-npx xapi-to call web.search.places --input '{"q":"best ramen in Tokyo"}'
-
-# Shopping search
-npx xapi-to call web.search.shopping --input '{"q":"mechanical keyboard"}'
-```
-
-### AI Text Processing (6 APIs)
-
-```bash
-# Fast chat completion
-npx xapi-to call ai.text.chat.fast --input '{"messages":[{"role":"user","content":"Explain quantum computing in one sentence"}]}'
-
-# Reasoning chat (more thorough)
-npx xapi-to call ai.text.chat.reasoning --input '{"messages":[{"role":"user","content":"Analyze the pros and cons of microservices"}]}'
-
-# Auto chat — pass a model explicitly, gateway auto-routes to the best upstream with fallback
-npx xapi-to call ai.text.chat.auto --input '{"model":"deepseek-v4-pro","messages":[{"role":"user","content":"Hello"}]}'
-
-# Summarize text
-npx xapi-to call ai.text.summarize --input '{"text":"<long text here>"}'
-
-# Rewrite text
-npx xapi-to call ai.text.rewrite --input '{"text":"<text>","mode":"formalize"}'
-
-# Generate embeddings
-npx xapi-to call ai.embedding.generate --input '{"input":"hello world"}'
-```
-
-### AI Image & Video Generation (2 APIs — asynchronous)
-
-```bash
-# Submit image generation (returns an async task)
-npx xapi-to call ai.image.generate --input '{"prompt":"A serene mountain landscape at sunset, digital art","model":"gpt-image-2"}'
-
-# Submit video generation through OpenRouter (+ optional reference image)
-npx xapi-to call ai.video.generate --input '{"prompt":"A cat playing piano in a jazz bar, cinematic"}'
-```
-
-Both capabilities return `{ "task_id": "...", "status": "pending", "poll_url": "..." }`. Wait for the result with `xapi-to task wait` (see below). Video generation uses provider `openrouter` and defaults to model `bytedance/seedance-2.0-fast`.
-
-### AI Speech Generation & Transcription (2 APIs)
-
-```bash
-# Text to speech (synchronous; returns a base64-encoded binary envelope)
-npx xapi-to call ai.audio.generate --input '{"text":"Hello world","model":"hexgrad/kokoro-82m","voice":"af_bella","format":"mp3"}'
-
-# Speech to text (audio.data is raw base64 without a data URI prefix)
-npx xapi-to call ai.audio.transcribe --input '{"audio":{"data":"<base64-audio>","format":"wav"},"model":"openai/whisper-large-v3"}'
+npx xapi-to call crypto.cex.price --input '{"symbol":"BTC"}'
 ```
 
-### AI Gateway — Anthropic/OpenAI-compatible HTTP
-
-Use CLI capabilities for one-off agent calls. Use the public AI Gateway when configuring Claude Code, Anthropic/OpenAI SDKs, or applications that expect standard AI API protocols:
-
-- Anthropic base URL: `https://ai.xapi.to/<strategy>`
-- OpenAI base URL: `https://ai.xapi.to/<strategy>/v1`
-- Strategies: `default`, `cost`, `speed`, `quality`
-- Authentication: use the xAPI key as `x-api-key`, `Authorization: Bearer`, or `XAPI-Key`
+### Crypto and Web3 selection
 
-Read `guides/ai_gateway.md` before configuring a client. It covers supported endpoints, current strategy behavior, streaming, fallback, routing/billing headers, direct media endpoints, and compatibility limitations.
+Use built-in `crypto.*` for normalized multi-provider market, token, wallet,
+DEX, CEX, and news data. Use a specialized service instead when the user asks
+for its provider-native behavior:
 
-### WebSocket Gateway — realtime and streaming audio
+- BlockPI network RPC or an arbitrary EVM JSON-RPC method → `guides/blockpi.md`.
+- Binance-native chain IDs, address analytics, RWA, aggregation, transaction,
+  wallet, or DeFi data → `guides/binance_web3.md`.
 
-Use the WebSocket Gateway for persistent, full-duplex sessions such as OpenAI Realtime, streaming ASR, bidirectional TTS, simultaneous interpretation, and podcast generation:
+Do not redirect an explicit BlockPI or Binance Web3 request to `crypto.*` merely
+because both are in the Crypto category.
 
-- Unified base: `wss://ai.xapi.to/<endpoint-path>`
-- Current paths include `/v1/realtime`, `/v1/asr`, `/v1/tts`, `/v1/ast`, and `/v1/podcast`
-- Service-specific form: `wss://<service-slug>.p.xapi.to/<endpoint-path>`
-- Server authentication: `XAPI-Key`, `Authorization: Bearer`, or `x-api-key`
+### Search selection
 
-Read `guides/ws_gateway.md` before opening a session. It explains path selection, browser-safe authentication, OpenAI Realtime usage, provider-native binary protocols, connection limits, billing, close codes, and reconnect behavior.
+Use normalized `web.search.*` capabilities for ordinary web, realtime, news,
+image, video, scholar, maps, places, or shopping results; read
+`guides/google_search.md`. Use direct `serper.*` actions only for provider-native
+fields, mini-batches, Lens, Reviews, or other Serper-specific behavior; read
+`guides/serper.md`.
 
-### Async Tasks
+### AI, async tasks, and gateways
 
-Some capabilities (currently `ai.image.generate` and `ai.video.generate`) run asynchronously and return a `task_id`. Prefer `task wait` to poll until a terminal status:
+Read `guides/ai.md` for text, embeddings, synchronous/SSE calls, speech,
+transcription, and asynchronous image/video generation. Use `task wait` for an
+async capability's returned task ID:
 
 ```bash
+npx xapi-to call ai.text.chat.fast \
+  --input '{"messages":[{"role":"user","content":"Hello"}]}'
 npx xapi-to task wait <task_id> --interval 2s --timeout 10m
-
-# Poll exactly once when the caller manages scheduling itself
-npx xapi-to task poll <task_id>
 ```
 
-`task wait` also accepts `--max-attempts`; duration flags support `ms`, `s`, `m`, and `h`. Status values are `pending` | `processing` | `succeeded` | `failed` | `expired`. It prints the terminal payload and exits nonzero for `failed` or `expired`.
+For application integrations, read `guides/ai_gateway.md` before configuring an
+Anthropic/OpenAI-compatible client. Read `guides/ws_gateway.md` before opening a
+persistent GPT Live, Realtime, ASR, TTS, interpretation, or podcast WebSocket
+session. GPT Live uses `/v1/live/sessions` and is not the Realtime protocol at
+`/v1/realtime`.
 
 ## Input Format
 
@@ -452,10 +301,11 @@ Beyond built-in capabilities, xapi proxies **dozens** of third-party API service
 - **5SIM SMS** (`5sim-sms`) — SMS verification (virtual numbers, activation codes)
 - **Serper API** (`serper`) — 12 provider-native Google Search actions including web, images, news, maps, places, video, shopping, scholar, patents, autocomplete, Lens, and reviews. Eleven support mini-batch; Reviews does not. Read `guides/serper.md` before calling them
 - **OpenRouter API** (`openrouter`) — Multi-model AI gateway (chat, embeddings, audio transcription/speech, video)
+- **Web3 infrastructure** — BlockPI RPC (`rpc`, 13 actions) and Binance Web3 API (`binance-web3-api`, 58 actions); read `guides/blockpi.md` or `guides/binance_web3.md` before calling them
 
 The full catalog also spans many other categories — crypto/on-chain data, CEX market data, stocks & macro, social platforms, news, weather, and more. Discover them with `search` / `services`.
 
-> For crypto data, prefer the built-in `crypto.*` capabilities above (they aggregate multiple upstreams with automatic fallback).
+> For ordinary normalized crypto data, prefer built-in `crypto.*`. For an explicit BlockPI, Binance Web3, raw RPC, provider-native, transaction-building, or DeFi request, use the matching specialized guide and service.
 
 ## Error Handling
 
@@ -464,11 +314,7 @@ The full catalog also spans many other categories — crypto/on-chain data, CEX
 - **Insufficient balance** → Run `npx xapi-to topup --method stripe --amount 10`
 - **Unknown API ID** → Use `search` or `list` to find the correct ID, then `get` to check parameters
 
-The CLI retries idempotent metadata reads and `task poll` for transient timeouts, network failures, `408`, `429`, and `502`–`504`. It does not automatically retry arbitrary `call` actions because the upstream may already have completed a write; confirm the result before manually retrying posts, payments, or other mutations. Ordinary JSON execution has a 60-second request ceiling. HTTP SSE streams and raw downloads instead use a 60-second no-data timeout, reset whenever a chunk arrives; override it with `XAPI_TRANSFER_IDLE_TIMEOUT_MS` when an upstream legitimately pauses longer.
-
-## Tips
-
-- Use `--page` and `--page-size` for pagination on `list`, `search`, and `services`.
+The CLI retries idempotent metadata reads and `task poll` for transient timeouts, network failures, `408`, `429`, and `502`–`504`. It does not automatically retry arbitrary `call` actions because the upstream may already have completed a write; confirm the result before manually retrying posts, payments, or other mutations. Ordinary JSON execution has a 60-second request ceiling. HTTP SSE streams and raw downloads instead use a 60-second no-data timeout, reset whenever a chunk arrives; override it with `XAPI_TRANSFER_IDLE_TIMEOUT_MS` when an upstream legitimately pauses longer. Use `--page` and `--page-size` for pagination on `list`, `search`, and `services`.
 
 ## Specialized Guides
 
@@ -484,11 +330,13 @@ When the user's task involves these workflows, read the corresponding guide file
 - **`guides/google_search.md`** — Google Search: web, realtime, news, image, video, scholar, maps, places, shopping
 - **`guides/serper.md`** — direct Serper v7 API: 12 provider-native actions, object-or-array mini-batches, Reviews pagination and batch exception, Lens, dynamic per-credit billing, and the current Webpage service boundary
 - **`guides/crypto.md`** — Crypto (加密货币): on-chain token price/overview/holders/security/OHLCV, wallet analytics, DEX pairs, CEX spot prices by symbol, news — covers contract-address vs symbol addressing and multi-chain
+- **`guides/domains.md`**, **`guides/blockpi.md`**, **`guides/binance_web3.md`** — domain purchase and DNS writes, BlockPI EVM JSON-RPC, and the official Binance Web3 API catalog; read the matching guide before any purchase, mutation, transaction build, signing, or broadcast
 - **`guides/ai.md`** — AI (人工智能): synchronous or SSE-streamed text, embeddings, asynchronous image/video generation with `task wait`, text-to-speech, and speech-to-text
 - **`guides/ai_gateway.md`** — xAPI AI Gateway: Claude Code and Anthropic/OpenAI SDK setup, model discovery, routing strategies, streaming, fallback, routing/billing headers, direct media endpoints, and known limitations
-- **`guides/ws_gateway.md`** — xAPI WebSocket Gateway: OpenAI Realtime, streaming ASR/TTS, simultaneous interpretation, podcast generation, service/path routing, browser authentication, native binary protocols, limits, billing, close codes, and reconnects
+- **`guides/ws_gateway.md`** — xAPI WebSocket Gateway: GPT Live, OpenAI Realtime, streaming ASR/TTS, simultaneous interpretation, podcast generation, service/path routing, browser authentication, native protocols, limits, billing, close codes, and reconnects
 - **`guides/sandbox.md`** — managed Sandbox compute: AI tool selection, one-shot and multi-step lifecycles, provider pinning, files, Cloudflare Web previews, suspension, GPU jobs, parallel agents, cleanup recovery, audit/history, and billing verification
 - **`guides/sms.md`** — SMS verification: buy virtual phone numbers, receive verification codes, finish/cancel orders (5SIM)
+- **`guides/provider.md`** — Provider management: create/update services, About/changelog, version lifecycle, metrics/events and request receipts, Skill upload/linking, rollback/delete, earnings transfer
 
 ## Security