@agentxv2/sdk 0.5.1 → 0.5.3

package/dist/index-DV-tFsBT.d.ts

@@ -0,0 +1,209 @@
+import { E as EncryptedPayload, g as AgentPayload, P as PackResult } from './types-2aHUvS4M.js';
+import { Address, PublicClient, WalletClient, Hash } from 'viem';
+
+interface IPFSFetcherConfig {
+    /** Primary IPFS gateway (default: ipfs.io) */
+    gateway?: string;
+    /** Fallback gateways in order of preference */
+    fallbackGateways?: string[];
+    /** Request timeout in ms (default: 10_000) */
+    timeoutMs?: number;
+    /** Max cached entries (LRU-like eviction, default: 200) */
+    maxCache?: number;
+}
+declare class IPFSFetcher {
+    private gateway;
+    private fallbackGateways;
+    private timeoutMs;
+    private cache;
+    private maxCache;
+    private pending;
+    private failed;
+    constructor(config?: IPFSFetcherConfig);
+    /** Fetch JSON from a single IPFS CID. */
+    fetchJSON<T = unknown>(cid: string): Promise<T>;
+    /** Fetch encrypted agent payload (validates algorithm). */
+    fetchEncryptedPayload(cid: string): Promise<EncryptedPayload>;
+    /** Batch fetch multiple CIDs with concurrency control. */
+    fetchBatch<T = unknown>(cids: string[], concurrency?: number): Promise<Map<string, T>>;
+    /** Check if a string looks like a valid IPFS CID. */
+    isValidCID(cid: string): boolean;
+    /** Clear cache (optionally for a specific CID). */
+    clearCache(cid?: string): void;
+    /** Number of cached entries. */
+    get cacheSize(): number;
+    private _doFetch;
+    private _fetchFrom;
+    private _cacheSet;
+}
+/** Singleton-friendly default instance. */
+declare const defaultIPFSFetcher: IPFSFetcher;
+
+/** Minimal on-chain reader interface — implement with viem. */
+interface OnChainReader {
+    /** Read tokenURI from IdentityRegistry by tokenId. */
+    getTokenURI(agentId: number): Promise<string>;
+    /** Get agent metadata attributes (returned as key-value pairs). */
+    getAttributes(agentId: number): Promise<Record<string, string>>;
+    /** Check if `address` has an active subscription for `agentId`. */
+    hasActiveSubscription(address: string, agentId: number): Promise<boolean>;
+}
+/** Minimal wallet signer interface — implement with wagmi/viem. */
+interface WalletSigner {
+    /** Sign a message (for authentication to MCP servers). */
+    signMessage(message: string): Promise<string>;
+    /** Get the current wallet address. */
+    getAddress(): Promise<string>;
+    /** Get the wallet's ECDSA private key (required for ECIES decryption). */
+    getPrivateKey?(): Promise<string>;
+}
+interface AgentRunnerConfig {
+    /** On-chain data reader (injected from viem/wagmi). */
+    reader: OnChainReader;
+    /** Wallet signer (injected from wagmi). */
+    wallet: WalletSigner;
+    /** IPFS fetcher instance (creates default if omitted). */
+    ipfsFetcher?: IPFSFetcher;
+    /** IPFS gateway list (overrides IPFSFetcher defaults). */
+    ipfsGateways?: string[];
+}
+interface AgentRunContext {
+    /** Agent NFT token ID */
+    agentId: number;
+    /** System prompt — inject into LLM conversation */
+    prompt: string;
+    /** All skills with execution metadata */
+    skills: RunnableSkill[];
+    /** MCP connection info */
+    mcp: {
+        type: string;
+        url?: string;
+        toolFilter?: string[];
+    };
+    /** Subscription expiry timestamp (0 = unknown) */
+    subscriptionExpiry: number;
+}
+interface RunnableSkill {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+    outputSchema?: Record<string, unknown>;
+    /** Execution mode */
+    mode: 'open' | 'mcp' | 'a2a';
+    /** If mode='a2a', the on-chain Agent ID being delegated to */
+    a2aTargetAgentId?: number;
+    /**
+     * Execute this skill with the given input.
+     * - Open: runs locally (caller provides implementation)
+     * - MCP: POSTs to the publisher's MCP server
+     * - A2A: loads target Agent context (prompt+skills) via AgentRunner
+     */
+    execute(input: Record<string, unknown>): Promise<unknown>;
+}
+/**
+ * Standard return type for A2A skill execution.
+ * The calling LLM receives the sub-Agent's prompt and skills
+ * and can inject them into the conversation.
+ */
+interface A2ASkillResult {
+    /** On-chain Agent ID that was delegated to */
+    agentId: number;
+    /** Sub-Agent's decrypted system prompt */
+    prompt: string;
+    /** Sub-Agent's skills (name + description + schema only, no execute) */
+    skills: {
+        name: string;
+        description: string;
+        inputSchema: Record<string, unknown>;
+    }[];
+    /** The original input passed by the caller */
+    callerInput: Record<string, unknown>;
+}
+declare class AgentRunner {
+    private reader;
+    private wallet;
+    private ipfs;
+    constructor(config: AgentRunnerConfig);
+    /**
+     * Load and decrypt an Agent, returning a run context ready to inject
+     * into any LLM conversation.
+     *
+     * Steps:
+     *   1. Verify on-chain subscription (frontend check)
+     *   2. Fetch metadata → get encryptedPayloadCid + eciesEncryptedKey
+     *   3. IPFS fetch encrypted payload
+     *   4. ECIES decrypt AES key (using wallet private key)
+     *   5. AES-256-GCM decrypt payload → { prompt, skills, mcp }
+     *   6. Build RunnableSkill wrappers (Open: local stub, Closed: MCP remote)
+     */
+    useAgent(agentId: number): Promise<AgentRunContext>;
+    /**
+     * Pack an AgentPayload for publishing (encryption only, no IPFS upload).
+     * Caller is responsible for IPFS upload and on-chain registration.
+     */
+    packForPublish(payload: AgentPayload, publicKey: string): PackResult;
+    /** Wrap a SkillDef into a RunnableSkill with execute(). */
+    private _wrapSkill;
+    /** Call a tool on the publisher's MCP server (Closed skill). */
+    private _executeMCPTool;
+    /**
+     * Execute an A2A skill — delegate to another AgentX Agent.
+     *
+     * Standard Interface:
+     *   Input:  { task, ...taskSpecificParams }
+     *   Output: { agentId, prompt, skills[] }
+     *
+     * The caller (LLM) receives the sub-Agent's prompt + skill list.
+     * The LLM then decides how to use the sub-Agent — typically by
+     * injecting the sub-Agent's system prompt and calling its skills.
+     */
+    private _executeA2ASkill;
+    private _getPrivateKey;
+}
+
+interface ChainConfig {
+    chainId: number;
+    contracts: {
+        identityRegistry: Address;
+        subscriptionManager: Address;
+        paymentGateway: Address;
+        a2aProtocolRegistry: Address;
+        reputationRegistry: Address;
+        configurationRegistry: Address;
+        multiEndpointRegistry: Address;
+    };
+    ipfsGateways: string[];
+    rpcUrl?: string;
+}
+declare const KNOWN_CHAINS: Record<number, ChainConfig>;
+interface ConfigRegistryOpts {
+    contractAddress: Address;
+    publicClient: PublicClient;
+    walletClient: WalletClient;
+}
+declare class ConfigurationRegistry {
+    private address;
+    private publicClient;
+    private walletClient;
+    constructor(opts: ConfigRegistryOpts);
+    private get account();
+    set(key: string, value: string): Promise<Hash>;
+    get(key: string): Promise<string>;
+    getAll(): Promise<Record<string, string>>;
+}
+
+interface UseAgentRunnerConfig {
+    agentId: number;
+    chainConfig?: ChainConfig;
+    ipfsGateways?: string[];
+}
+interface UseAgentRunnerResult {
+    ctx: AgentRunContext | null;
+    isLoading: boolean;
+    error: Error | null;
+    /** Re-trigger the load (e.g. after connecting wallet or subscribing) */
+    refetch: () => void;
+}
+declare function useAgentRunner(config: UseAgentRunnerConfig): UseAgentRunnerResult;
+
+export { type A2ASkillResult as A, type ChainConfig as C, IPFSFetcher as I, KNOWN_CHAINS as K, type OnChainReader as O, type RunnableSkill as R, type UseAgentRunnerConfig as U, type WalletSigner as W, type AgentRunContext as a, AgentRunner as b, type AgentRunnerConfig as c, type ConfigRegistryOpts as d, ConfigurationRegistry as e, type IPFSFetcherConfig as f, type UseAgentRunnerResult as g, defaultIPFSFetcher as h, useAgentRunner as u };

package/dist/index.d.mts

@@ -0,0 +1,271 @@
+import { A as AgentSubscription, a as A2AAgentCard, b as A2ATask, M as McpConnection, c as AgentReview, d as AgentReputation } from './types-2aHUvS4M.mjs';
+export { e as A2ASkillExecution, f as A2ATaskStatus, g as AgentPayload, h as AgentPricing, i as AgentPrivatePayload, j as AgentPublicPayload, k as AgentSearchQuery, l as AgentSearchResult, m as AgentXConfig, n as AgentXContracts, o as AgentXError, p as AgentXErrorCode, E as EncryptedPayload, J as JSONSchema, q as JSONSchemaProperty, r as McpTransport, O as OnChainAgentMetadata, P as PackResult, s as PricingType, R as RegisteredAgent, S as SkillDef, t as SkillExecutionMode, u as SkillExecutionRemote, v as SubscriptionRequired, w as SubscriptionStatus, U as UnpackResult } from './types-2aHUvS4M.mjs';
+export { aesDecrypt, aesEncrypt, decryptPayload, eciesDecrypt, eciesEncrypt, encryptPayload, generateAesKey, generateKeyPair, getPublicKey, packAgentForPublish, randomBytes, unpackAgent } from './core/index.mjs';
+export { A as A2ASkillResult, a as AgentRunContext, b as AgentRunner, c as AgentRunnerConfig, C as ChainConfig, d as ConfigRegistryOpts, e as ConfigurationRegistry, I as IPFSFetcher, f as IPFSFetcherConfig, K as KNOWN_CHAINS, O as OnChainReader, R as RunnableSkill, U as UseAgentRunnerConfig, g as UseAgentRunnerResult, W as WalletSigner, h as defaultIPFSFetcher, u as useAgentRunner } from './index-BlD1-fQt.mjs';
+export { EndpointRecord, MultiEndpointClient, MultiEndpointConfig } from './endpoint/index.mjs';
+export { ConfigEntry, ConfigurationClient, ConfigurationConfig } from './configuration/index.mjs';
+import { Address, PublicClient, WalletClient, Hash } from 'viem';
+export { bytesToHex, hexToBytes } from '@noble/ciphers/utils.js';
+
+interface AgentRegistryConfig {
+    /** IdentityRegistry contract address */
+    contractAddress: Address;
+    /** viem PublicClient for read calls */
+    publicClient: PublicClient;
+    /** viem WalletClient for write calls */
+    walletClient: WalletClient;
+}
+declare class AgentRegistry {
+    private address;
+    private publicClient;
+    private walletClient;
+    constructor(config: AgentRegistryConfig);
+    /**
+     * Register a new Agent NFT on-chain.
+     *
+     * @param tokenURI    IPFS URI of the public metadata (ipfs://...)
+     * @param metadata    Key-value metadata (encryptedPayloadCid, eciesEncryptedKey, etc.)
+     * @param valueWei    Optional: native currency to send with registration
+     * @returns           { agentId: number, txHash: Hash }
+     */
+    register(tokenURI: string, metadata: {
+        key: string;
+        value: string;
+    }[], valueWei?: bigint): Promise<{
+        agentId: number;
+        txHash: Hash;
+    }>;
+    /**
+     * Simple register — just a tokenURI, no extra metadata.
+     */
+    registerSimple(tokenURI: string, valueWei?: bigint): Promise<{
+        agentId: number;
+        txHash: Hash;
+    }>;
+    /** Get all agent IDs owned by an address. */
+    getAgentsByOwner(owner: Address): Promise<number[]>;
+    /** Get the current total agent count. */
+    getCurrentAgentId(): Promise<number>;
+    /** Check if an agent exists. */
+    agentExists(agentId: number): Promise<boolean>;
+    /** Get the tokenURI for an agent. */
+    tokenURI(agentId: number): Promise<string>;
+    /** Get all metadata attributes for an agent as key-value pairs. */
+    getAttributes(agentId: number): Promise<Record<string, string>>;
+    /** Extract tokenId from the Transfer event in the receipt. */
+    private _parseAgentIdFromReceipt;
+}
+/** Extract IPFS CID from an ipfs:// URI. */
+declare function cidFromURI(uri: string): string;
+
+declare const REGISTRY_VERSION = "0.1.0";
+
+interface SubscriptionConfig {
+    contractAddress: Address;
+    publicClient: PublicClient;
+    walletClient: WalletClient;
+}
+interface PlanDetail {
+    planId: number;
+    agentId: number;
+    creator: Address;
+    price: bigint;
+    period: string;
+    active: boolean;
+    payToken: Address;
+    trialDays: number;
+}
+interface SubscriptionDetail {
+    subscriptionId: number;
+    subscriber: Address;
+    agentId: number;
+    status: number;
+    startedAt: number;
+    expiresAt: number;
+    period: string;
+    payToken: Address;
+    amountPaid: bigint;
+    trialActive: boolean;
+    trialEndsAt: number;
+    fundsReleased: boolean;
+}
+declare class SubscriptionManager {
+    private address;
+    private publicClient;
+    private walletClient;
+    constructor(config: SubscriptionConfig);
+    /** Get current platform fee in basis points (e.g. 250 = 2.5%). */
+    getPlatformFeeBps(): Promise<number>;
+    /** Check if a token is whitelisted for payments. */
+    isTokenWhitelisted(token: Address): Promise<boolean>;
+    /** Get full plan details with v2 fields. */
+    getPlan(planId: number): Promise<PlanDetail>;
+    /**
+     * Subscribe to a plan.
+     * For ETH plans: pass valueWei = plan.price.
+     * For ERC20 plans: auto-detects from plan.payToken, calls approve + subscribe.
+     *                    User must have approved this contract for plan.price tokens.
+     */
+    subscribe(planId: number, opts?: {
+        valueWei?: bigint;
+        approveTokenFirst?: boolean;
+    }): Promise<{
+        subscriptionId: number;
+        txHash: Hash;
+    }>;
+    /** Release escrowed funds to creator after trial window ends. */
+    releaseFunds(subscriptionId: number): Promise<Hash>;
+    /** Cancel subscription (trial refund if within window). */
+    cancel(subscriptionId: number): Promise<Hash>;
+    hasActiveSubscription(subscriber: Address, agentId: number): Promise<boolean>;
+    getSubscription(subscriber: Address, agentId: number): Promise<AgentSubscription | null>;
+    /** Get full subscription detail with v2 fields (trial, payToken, fundsReleased). */
+    getSubscriptionDetail(subscriptionId: number): Promise<SubscriptionDetail>;
+    getUserSubscriptions(user: Address): Promise<number[]>;
+}
+declare function guardSubscription(manager: SubscriptionManager, user: Address, agentId: number): Promise<AgentSubscription>;
+
+interface AgentX402Config {
+    subscriptionManagerAddress: Address;
+    publicClient: PublicClient;
+    walletClient: WalletClient;
+}
+declare class AgentX402 {
+    private config;
+    constructor(config: AgentX402Config);
+    /**
+     * Require active subscription — or throw with auto-pay info.
+     *
+     * Usage:
+     *   await x402.requireSubscription(agentId, address, { planIds: [1,2,3] })
+     *
+     * On success, returns silently.
+     * On failure, throws AgentXError with paymentInfo populated
+     * so the caller can auto-pay via wallet/X402.
+     */
+    requireSubscription(agentId: number, address: Address, opts?: {
+        planIds?: number[];
+    }): Promise<void>;
+    /**
+     * Subscribe to a plan + wait for receipt.
+     * Returns subscriptionId from the Subscribed event.
+     *
+     * NOTE: For ERC20 plans, the caller must approve token spending
+     * BEFORE calling this method. Use X402 SDK or wagmi's useWriteContract
+     * for the approve step.
+     */
+    subscribeAndWait(planId: number, price: bigint, payToken: Address): Promise<number>;
+}
+
+declare const SUBSCRIPTION_VERSION = "0.2.0";
+
+interface A2AConfig {
+    contractAddress: Address;
+    publicClient: PublicClient;
+    walletClient: WalletClient;
+}
+declare class A2AProtocol {
+    private address;
+    private publicClient;
+    private walletClient;
+    constructor(config: A2AConfig);
+    private get account();
+    createAgentCard(agentId: number, card: {
+        name: string;
+        description: string;
+        version: string;
+        capabilities: string[];
+        supportedTasks: string[];
+        commProtocol?: string;
+        authMethod?: string;
+        cardURI?: string;
+    }): Promise<{
+        cardId: number;
+        txHash: Hash;
+    }>;
+    getAgentCard(agentId: number): Promise<A2AAgentCard | null>;
+    createTask(agentId: number, taskType: string, input: Record<string, unknown>): Promise<{
+        taskId: number;
+        txHash: Hash;
+    }>;
+    completeTask(taskId: number, output: unknown): Promise<Hash>;
+    getTask(taskId: number): Promise<A2ATask | null>;
+    getUserTasks(user: Address): Promise<number[]>;
+    private _parseUintFromLog;
+}
+
+declare const A2A_VERSION = "0.1.0";
+
+interface MCPTool {
+    name: string;
+    description?: string;
+    inputSchema: Record<string, unknown>;
+}
+interface MCPCallResult {
+    content: {
+        type: string;
+        text?: string;
+        data?: string;
+    }[];
+    isError?: boolean;
+}
+interface MCPConnectorConfig {
+    /** MCP server base URL */
+    url: string;
+    /** Transport type */
+    transport?: 'http' | 'sse';
+    /** Auth header value (e.g. "Bearer xxx") */
+    authHeader?: string;
+    /** Request timeout in ms (default: 30_000) */
+    timeoutMs?: number;
+    /** Optional: subscriber address for subscription-gated MCP servers */
+    subscriberAddress?: string;
+    /** Optional: wallet signature for authentication */
+    signature?: string;
+    timestamp?: number;
+}
+declare class MCPConnector {
+    private config;
+    constructor(config: MCPConnectorConfig);
+    /** Create from an Agent's McpConnection. */
+    static fromAgent(mcp: McpConnection, opts?: Partial<MCPConnectorConfig>): MCPConnector;
+    /** List available tools from the MCP server. */
+    listTools(): Promise<MCPTool[]>;
+    /** Call a tool on the MCP server. */
+    callTool(name: string, args?: Record<string, unknown>): Promise<MCPCallResult>;
+    listResources(): Promise<unknown[]>;
+    readResource(uri: string): Promise<unknown>;
+    private _request;
+}
+
+declare const MCP_VERSION = "0.1.0";
+
+interface ReputationConfig {
+    contractAddress: Address;
+    publicClient: PublicClient;
+    walletClient: WalletClient;
+}
+declare class ReputationRegistry {
+    private address;
+    private publicClient;
+    private walletClient;
+    constructor(config: ReputationConfig);
+    private get account();
+    /** Submit a rating (1-5) with optional comment. */
+    rate(agentId: number, rating: number, comment?: string): Promise<Hash>;
+    /** Get average rating and total count. */
+    getRating(agentId: number): Promise<{
+        averageRating: number;
+        totalRatings: number;
+    }>;
+    /** Get all reviews for an agent. */
+    getReviews(agentId: number): Promise<AgentReview[]>;
+    /** Get full reputation summary. */
+    getReputation(agentId: number): Promise<AgentReputation>;
+}
+
+declare const REPUTATION_VERSION = "0.1.0";
+
+declare const CONFIG_VERSION = "0.1.0";
+
+export { A2AAgentCard, type A2AConfig, A2AProtocol, A2ATask, A2A_VERSION, AgentRegistry, type AgentRegistryConfig, AgentReputation, AgentReview, AgentSubscription, AgentX402, type AgentX402Config, CONFIG_VERSION, type MCPCallResult, MCPConnector, type MCPConnectorConfig, type MCPTool, MCP_VERSION, McpConnection, type PlanDetail, REGISTRY_VERSION, REPUTATION_VERSION, type ReputationConfig, ReputationRegistry, SUBSCRIPTION_VERSION, type SubscriptionConfig, type SubscriptionDetail, SubscriptionManager, cidFromURI, guardSubscription };