sdk

The unified package that re-exports all Regent SDK functionality with high-level APIs.

Installation

bun add regent-sdk

High-Level APIs

createRegentAgent()

Create a full-featured agent with runtime and optional ERC-8004 identity:

import { createRegentAgent } from 'regent-sdk';

const agent = await createRegentAgent({
  name: 'My Agent',
  description: 'An intelligent assistant',
  version: '1.0.0',
  http: { port: 3000 },
  identity: {
    chainId: 84532,
    rpcUrl: 'https://sepolia.base.org',
    ipfs: 'pinata',
    ipfsConfig: { pinataJwt: process.env.PINATA_JWT },
  },
  trust: { reputation: true },
});

// Register on-chain
const { agentId } = await agent.registerOnchain();
console.log('Registered:', agentId);

// Search for other agents
const agents = await agent.search({ mcp: true });

RegentAgentConfig

interface RegentAgentConfig {
  // Required
  name: string;
  description: string;
  version: string;

  // HTTP configuration
  http?: {
    port?: number;
  };

  // Wallet configuration
  wallet?: {
    privateKey?: string;
  };

  // ERC-8004 identity configuration
  identity?: {
    chainId: number;
    rpcUrl: string;
    ipfs?: 'node' | 'pinata' | 'filecoinPin';
    ipfsConfig?: {
      nodeUrl?: string;
      pinataJwt?: string;
      filecoinPrivateKey?: string;
    };
    registries?: {
      identity?: string;
      reputation?: string;
      validation?: string;
    };
  };

  // Discovery configuration
  discovery?: {
    subgraphUrl?: string;
    mcpEndpoint?: string;
    a2aEndpoint?: string;
    oasfSkills?: string[];
    oasfDomains?: string[];
  };

  // Trust configuration
  trust?: {
    reputation?: boolean;
    cryptoEconomic?: boolean;
    teeAttestation?: boolean;
  };

  // Agent logo/image
  logo?: string;
}

RegentAgentResult

interface RegentAgentResult {
  // The agent runtime
  runtime: AgentRuntime;

  // The ERC-8004 SDK (if identity config provided)
  erc8004?: RegentErc8004SDK;

  // Register the agent on-chain
  registerOnchain: () => Promise<{ agentId: string; txHash: string }>;

  // Search for agents
  search: (params?: SearchParams) => Promise<AgentSummary[]>;
}

createRegentSDK()

Create a standalone ERC-8004 SDK for identity/discovery without the full runtime:

import { createRegentSDK } from 'regent-sdk';

const sdk = createRegentSDK({
  chainId: 84532,
  rpcUrl: 'https://sepolia.base.org',
  signer: process.env.PRIVATE_KEY,  // Optional for read-only
  ipfs: 'pinata',
  pinataJwt: process.env.PINATA_JWT,
});

// Create and register an agent
const agent = sdk.createAgent('My Agent', 'Description');
await agent.setMCP('https://mcp.example.com');
await agent.registerIPFS();

// Search for agents
const results = await sdk.searchAgents({ mcp: true });

// Give feedback
await sdk.giveFeedback('84532:42', { score: 90 });

Re-Exports

Core Runtime

import {
  createAgent,
  AgentBuilder,
  AgentCore,
  createAgentCore,
} from 'regent-sdk';

HTTP Extension

import { http } from 'regent-sdk';

A2A Extension

import { a2a } from 'regent-sdk';

ERC-8004 SDK

import {
  RegentErc8004SDK,   // Main SDK class
  Erc8004Agent,       // Agent class
  Web3Client,         // Blockchain client
  IPFSClient,         // IPFS client
  SubgraphClient,     // Subgraph client
  FeedbackManager,    // Feedback manager
  EndpointCrawler,    // Capability crawler
  AgentIndexer,       // Multi-chain indexer
} from 'regent-sdk';

Types

import type {
  AgentRuntime,
  Extension,
  AgentConfig,
  EntrypointDef,
  EntrypointHandler,
  EntrypointStreamHandler,
  Network,
  TrustConfig,
  TrustModel,
  RegistrationEntry,
  RegentAgentConfig,
  RegentErc8004Config,
  TransactionOptions,
  IPFSClientConfig,
  McpCapabilities,
  A2aCapabilities,
} from 'regent-sdk';

Usage Patterns

Full-Featured Agent with Identity

import { createRegentAgent } from 'regent-sdk';
import { z } from 'zod';

const agent = await createRegentAgent({
  name: 'trading-advisor',
  description: 'AI-powered trading recommendations',
  version: '1.0.0',
  http: { port: 3000 },
  wallet: { privateKey: process.env.WALLET_KEY },
  identity: {
    chainId: 84532,
    rpcUrl: 'https://sepolia.base.org',
    ipfs: 'pinata',
    ipfsConfig: { pinataJwt: process.env.PINATA_JWT },
  },
  discovery: {
    mcpEndpoint: 'https://trading-advisor.com/mcp',
    a2aEndpoint: 'https://trading-advisor.com/.well-known/agent.json',
    oasfSkills: ['financial_analysis/trading_recommendations'],
  },
  trust: { reputation: true },
});

// Add entrypoints
agent.runtime.agent.addEntrypoint({
  key: 'recommend',
  input: z.object({ symbol: z.string() }),
  async handler({ input }) {
    return { output: { recommendation: 'buy', confidence: 0.85 } };
  },
});

// Register on-chain
const { agentId } = await agent.registerOnchain();
console.log(`Agent registered: ${agentId}`);

Read-Only Discovery

import { createRegentSDK } from 'regent-sdk';

const sdk = createRegentSDK({
  chainId: 84532,
  rpcUrl: 'https://sepolia.base.org',
  // No signer = read-only mode
});

// Search for trading agents
const agents = await sdk.searchAgents({
  oasfSkills: ['financial_analysis'],
  supportedTrust: ['reputation'],
});

// Check reputation
for (const agent of agents.items) {
  const rep = await sdk.getReputationSummary(agent.agentId);
  console.log(`${agent.name}: ${rep.averageScore}/100 (${rep.count} reviews)`);
}

Multi-Chain Search

import { createRegentSDK, AgentIndexer } from 'regent-sdk';

const indexer = new AgentIndexer({
  defaultChainId: 84532,
  subgraphUrls: {
    84532: 'https://subgraph.base-sepolia.example.com',
    11155111: 'https://subgraph.sepolia.example.com',
  },
});

// Search across all configured chains
const results = await indexer.searchAgents(
  { mcp: true },
  ['averageScore:desc'],
  50,
  undefined,
  'all'  // Search all chains
);

console.log(`Found ${results.items.length} agents across ${results.meta.successfulChains.length} chains`);

When to Use Each API

Scenario	API
Building a new agent with identity	createRegentAgent()
Adding identity to existing agent	createRegentSDK() + manual integration
Searching/discovering agents	createRegentSDK()
Building without identity	createAgent() from @regent/core
Fine-grained extension control	Individual packages