@agentxv2/sdk 0.5.1 → 0.5.3

package/dist/index.d.ts

@@ -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.js';
+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.js';
+export { aesDecrypt, aesEncrypt, decryptPayload, eciesDecrypt, eciesEncrypt, encryptPayload, generateAesKey, generateKeyPair, getPublicKey, packAgentForPublish, randomBytes, unpackAgent } from './core/index.js';
+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-DV-tFsBT.js';
+export { EndpointRecord, MultiEndpointClient, MultiEndpointConfig } from './endpoint/index.js';
+export { ConfigEntry, ConfigurationClient, ConfigurationConfig } from './configuration/index.js';
+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 };

package/dist/index.js

@@ -2369,7 +2369,7 @@ var MultiEndpointClient = class {
     const endpoints = await this.getActiveEndpoints(agentId);
     if (endpoints.length === 0) return null;
     const http = endpoints.find((e) => e.protocol === "HTTP");
-    return http ?? endpoints[0];
+    return http ?? endpoints[0] ?? null;
   }
   /** Pick any active endpoint URL — for MCP connector */
   async getBestMCPUrl(agentId) {