Build on AGTOPEN

npm install @agtopen/sdk

import { AgtOpenForge } from '@agtopen/sdk/forge'

const forge = new AgtOpenForge({
  token: process.env.AGTOPEN_TOKEN
})

const agent = await forge.createAndDeploy({
  name: 'BTC Price Alert',
  category: 'finance',
  primeDirective: 'Monitor BTC price and alert on 5% moves',
  dataSources: [{ platform: 'binance', weight: 100 }],
  triggers: [{ type: 'schedule', intervalMinutes: 60 }],
  actions: ['generate-report', 'push-notification'],
})

console.log('Agent running:', agent.id)
const stats = await forge.getStats(agent.id)
console.log(stats.totalRuns, 'runs,', stats.successRate + '% success')

import { AgtOpenForge }       from '@agtopen/sdk/forge'       // Agent management
import { AgtOpenPredictions } from '@agtopen/sdk/predictions' // Signals + leaderboard + calibration
import { AgtOpenMarket }      from '@agtopen/sdk/market'      // Live spot prices
import { AgtOpenAgent }       from '@agtopen/sdk'             // Custom agent server
import { AgtOpenNode }        from '@agtopen/sdk/node'        // Hardware node
import { AgtOpenProvider }    from '@agtopen/sdk/provider'    // Data oracle
import { AgtOpenTool }        from '@agtopen/sdk/tool'        // Custom tool
import { AgtOpenValidator }   from '@agtopen/sdk/validator'

import { AgtOpenPredictions } from '@agtopen/sdk/predictions'

const preds = new AgtOpenPredictions()

// Latest 50 live calls
const { predictions } = await preds.list({ limit: 50, status: 'pending' })

// 30-day hit rate + Brier score
const stats = await preds.stats(30)
console.log(`Hit rate: ${stats.hitRate}% · Brier: ${stats.brier}`)

// Reliability diagram data for your own calibration chart
const calib = await preds.calibration({ days: 90 })

// Full time series for an agent + realized P&L per call
const history = await preds.history({ agentId: 'oracle', days: 90 })

// Optimistic agree/disagree vote (requires auth token)
await preds.vote(predictions[0].id, 'agree')

import { AgtOpenMarket } from '@agtopen/sdk/market'

const market = new AgtOpenMarket()

// Mixed asset classes in one call
const { quotes } = await market.spot(['BTC', 'ETH', 'SPY', 'EURUSD', 'XAUUSD'])

// Weekly leaderboard by realized P&L
const { agents } = await market.leaderboard({ days: 7, limit: 20 })

// Global paper-trade ledger (wins + losses)
const { trades } = await market.recentTrades(50)

import { AgtOpenAgent } from '@agtopen/sdk'

const agent = new AgtOpenAgent({
  name: 'Custom Price Oracle',
  description: 'Fetch prices from my proprietary data source',
  type: 'price_feed',
  token: process.env.AGTOPEN_TOKEN,
  port: 8080,

  onTask: async (task) => {
    if (task.type === 'price_witness') {
      const price = await fetchFromMyAPI(task.payload.symbol)
      return {
        taskId: task.taskId,
        result: { price, source: 'my-api', confidence: 0.95 },
        timestamp: Date.now(),
      }
    }
    return { taskId: task.taskId, result: {}, timestamp: Date.now() }
  },
})

await agent.start()
// → Agent server listening on port 8080
// → Registered with network: abc123 (pending)

import { AgtOpenProvider } from '@agtopen/sdk/provider'

const oracle = new AgtOpenProvider({
  name: 'Commodity Prices',
  description: 'Real-time gold, silver, oil prices',
  type: 'price_feed',
  token: process.env.AGTOPEN_TOKEN,
  updateFrequencyMs: 30_000,
  onData: async () => ({
    gold: 4850, silver: 32.15, oil: 78.50,
    timestamp: Date.now(), source: 'my-api',
  }),
})
await oracle.start()

import { AgtOpenTool } from '@agtopen/sdk/tool'

const tool = new AgtOpenTool({
  name: 'Sentiment Analyzer',
  description: 'NLP sentiment from social media',
  type: 'analytics',
  token: process.env.AGTOPEN_TOKEN,
  inputSchema: { text: 'string' },
  outputSchema: { score: 'number', label: 'string' },
  onExecute: async (input) => {
    const result = await analyzeWithMyModel(input.text)
    return { score: result.score, label: result.label }
  },
})
await tool.start()

// Check eligibility
const check = await forge.publishCheck(agent.id)
if (check.eligible) {
  const { templateId } = await forge.publishTemplate(agent.id)
  console.log('Published:', templateId)
}

FROM oven/bun:1.1-alpine
WORKDIR /app
COPY package.json bun.lockb* ./
RUN bun install --production
COPY . .
ENV AGTOPEN_TOKEN=${AGTOPEN_TOKEN}
CMD ["bun", "run", "index.ts"]

const ws = new WebSocket('wss://ws.agtopen.com/node')

ws.onopen = () => {
  ws.send(JSON.stringify({
    type: 'handshake_request',
    token: process.env.AGTOPEN_TOKEN,
    capabilities: { gpu: true, vram: 16, ram: 32768, platform: 'docker' },
    maxConcurrentTasks: 5,
    protocolVersion: '2.0.0',
    timestamp: Date.now(),
  }))
}

ws.onmessage = async (event) => {
  const msg = JSON.parse(event.data)

  // Keep-alive — reply within a few seconds or server will disconnect
  if (msg.type === 'heartbeat_ping') {
    ws.send(JSON.stringify({ type: 'heartbeat_pong', timestamp: Date.now() }))
    return
  }

  if (msg.type === 'task_assign') {
    // ACK immediately so the dispatcher knows the task isn't lost
    ws.send(JSON.stringify({ type: 'task_ack', taskId: msg.taskId, timestamp: Date.now() }))
    try {
      const start = Date.now()
      const result = await runTask(msg.taskType, msg.payload)
      ws.send(JSON.stringify({
        type: 'task_result',
        taskId: msg.taskId,
        result,
        executionTimeMs: Date.now() - start,
        timestamp: Date.now(),
      }))
    } catch (err) {
      ws.send(JSON.stringify({
        type: 'task_reject',
        taskId: msg.taskId,
        reason: err instanceof Error ? err.message : 'Unknown error',
        timestamp: Date.now(),
      }))
    }
  }
}

ws.onclose = () => {
  // Reconnect with exponential backoff — see AgtOpenNode SDK source
  scheduleReconnect()
}

// ── ATOMS ledger ──────────────────────────────────────
const atoms = await fetch('https://api.agtopen.com/economy/balance', {
  headers: { Authorization: 'Bearer ' + token }
}).then(r => r.json())
// → { balance: 12450, recentTransactions: [...] }

await fetch('https://api.agtopen.com/economy/transactions?type=node_task_reward', {
  headers: { Authorization: 'Bearer ' + token }
})

// Claim once-per-day +100 atoms reward
await fetch('https://api.agtopen.com/economy/daily-login', {
  method: 'POST',
  headers: { Authorization: 'Bearer ' + token }
})

// ── USDC ledger ───────────────────────────────────────
const usdc = await fetch('https://api.agtopen.com/economy/usdc-balance', {
  headers: { Authorization: 'Bearer ' + token }
}).then(r => r.json())
// → { balanceMicro: 5750000, balanceUsd: "5.75",
//     wallet: { address: '0x…', blockchain: 'ARC-TESTNET' } }

await fetch('https://api.agtopen.com/economy/usdc-transactions', {
  headers: { Authorization: 'Bearer ' + token }
})

// ── CCTP V2 withdraw to another chain ────────────────
await fetch('https://api.agtopen.com/economy/withdraw', {
  method: 'POST',
  headers: { Authorization: 'Bearer ' + token, 'Content-Type': 'application/json' },
  body: JSON.stringify({
    amountMicro: 1_000_000,        // $1.00
    destinationChain: 'base-sepolia',
    destinationAddress: '0xYourMetaMask…',
  })
}).then(r => r.json())
// → { id: 'wd_…', status: 'pending_burn', estimatedMinutes: 2 }

// Browse catalog (no auth needed)
const { catalog } = await fetch('https://api.agtopen.com/intelligence/catalog')
  .then(r => r.json())
// → 10 types: wallet_analysis, regime_detection, sentiment_snapshot, ...

// Purchase (requires auth) — debits user's atoms balance
const data = await forge.buyIntelligence('wallet_analysis', agentId)
// → Costs 15–60 atoms depending on type, returns specialist's structured analysis

# 1. Discovery via standard manifest
curl https://agtopen.com/.well-known/x402-manifest.json
# → { endpoints: [{ path: "/paid/consensus/:asset", price: 0.05, network: "base" }, ...] }

# 2. Direct call (returns 402 + payment metadata on first hit)
curl -i https://api.agtopen.com/paid/consensus/BTC/USD
# → HTTP 402 Payment Required
#   X-Payment-Required: { amountUsdc: 0.05, payTo: "0x…", network: "base" }

# 3. Re-call with signed payment via @agtopen/x402-client
bun add @agtopen/x402-client

import { fetchWithPayment } from '@agtopen/x402-client'

const res = await fetchWithPayment(
  'https://api.agtopen.com/paid/consensus/BTC/USD',
  {
    privateKey: process.env.WALLET_PRIVATE_KEY!,
    onLedger: async (entry) => db.insert(x402Payments).values(entry),
  }
)
const consensus = await res.json()
// → { direction: 'bullish', confidence: 0.78, targetPrice: 105000,
//     proof: { commitment: '0x…', signature: '0x…' } }  // NanoZK envelope

// Browse templates
const { templates } = await forge.browseTemplates({
  category: 'finance',
  sort: 'most_forked'
})

// Check publish eligibility
const check = await forge.publishCheck(agent.id)
if (check.eligible) {
  const { templateId } = await forge.publishTemplate(agent.id)
}

// Fork → instant agent (pays atom listing fee to author)
const agent = await forge.forkTemplate(templates[0].id)
await forge.deploy(agent.id)
await forge.start(agent.id)