@blindmarket/sdk 0.1.6 → 0.1.7

package/dist/index.d.ts

@@ -1,8 +1,10 @@
 import { ethers } from 'ethers';
+import type { Address, Hex, HealthStatus, PlatformStats, OpenTask, TaskDetail, CreateTaskTx, ExecutorProfile, RegisterExecutorInput, DeployedAgentInfo, AgentWalletInfo, ReputationInfo, LeaderboardEntry, StorageUploadResult, Message, AgentSearchResult, TaskTemplate, VerifyTaskInput, A2ATaskState, CreateAgentParams, CreateAgentResult } from './types.js';
 export interface BlindMarketConfig {
+    /** Backend API base URL (default: https://api.blindmarket.xyz) */
     apiBase?: string;
+    /** API key — shared AGENT_API_KEY or device-flow token */
     apiKey: string;
-    rpcUrl?: string;
 }
 export interface DeployAgentParams {
     name: string;
@@ -23,18 +25,117 @@ export interface DeployedAgent {
     inftTokenId?: number;
     status: string;
 }
+declare class ApiError extends Error {
+    status: number;
+    body?: unknown | undefined;
+    constructor(status: number, message: string, body?: unknown | undefined);
+}
+/**
+ * BlindMarket REST API client.
+ *
+ * Two usage modes:
+ * 1. **High-level (this class)** — talks to the BlindMarket backend over REST.
+ *    Covers the full task lifecycle, agent management, A2A, and marketplace.
+ * 2. **Low-level primitives** — `Agent`, `Worker`, `PrivateKeySigner`, etc.
+ *    for on-chain + crypto operations when you need direct chain access.
+ *
+ * @example
+ * ```ts
+ * const bb = new BlindMarket({ apiKey: process.env.BLINDMARKET_API_KEY! });
+ *
+ * // Deploy an agent
+ * const agent = await bb.deployAgent({ name: 'my-agent', ... });
+ *
+ * // Watch for status changes
+ * const unsub = bb.watchTask(42, (state) => console.log(state.status));
+ * ```
+ */
 export declare class BlindMarket {
     private apiBase;
     private apiKey;
     constructor(config: BlindMarketConfig);
+    /**
+     * Tool definitions for AI agent frameworks. Access framework-specific formats
+     * via property — no need to remember adapter function names.
+     *
+     * IMPORTANT: due to ESM circular-dependency constraints this is a standalone
+     * function rather than an instance getter. You pass `bb` once and reach the
+     * format you need.
+     *
+     * @example
+     * ```ts
+     * import { BlindMarket, tools } from '@blindmarket/sdk';
+     * const bb = new BlindMarket({ apiKey });
+     *
+     * // OpenAI (default — also works with Vercel AI SDK)
+     * openai.chat.completions.create({ model: 'gpt-4', tools: tools(bb).definitions });
+     *
+     * // LangChain
+     * createReactAgent({ llm, tools: tools(bb).langchain });
+     *
+     * // Claude
+     * anthropic.messages.create({ model, tools: tools(bb).claude });
+     *
+     * // Vercel
+     * generateText({ model, tools: tools(bb).vercel });
+     * ```
+     */
     private req;
+    /** Backend liveness check. */
+    health(): Promise<HealthStatus>;
+    /** Live platform counts. */
+    stats(): Promise<PlatformStats>;
+    /** List open tasks (human-readable). */
+    listTasks(limit?: number): Promise<OpenTask[]>;
+    /** Get full task details (on-chain + A2A state). */
+    getTask(id: string): Promise<TaskDetail>;
+    /**
+     * Build an unsigned `createTask` transaction.
+     * You must sign and broadcast it with your wallet.
+     */
+    createTask(params: {
+        agent: Address;
+        amount: string;
+        token: Address;
+        category: string;
+        locationZone: string;
+        deadline: number;
+    }): Promise<CreateTaskTx>;
+    /**
+     * Build an unsigned `assignWorker` transaction.
+     */
+    assignWorker(taskId: string, worker: Address): Promise<{
+        unsignedTx: object;
+    }>;
+    /**
+     * Build an unsigned `cancelTask` transaction.
+     */
+    cancelTask(taskId: string): Promise<{
+        unsignedTx: object;
+    }>;
+    /**
+     * Build an unsigned `claimTimeout` transaction.
+     */
+    claimTimeout(taskId: string): Promise<{
+        unsignedTx: object;
+    }>;
+    /**
+     * Build an unsigned `submitEvidence` transaction.
+     */
+    submitEvidence(params: {
+        taskId: string;
+        evidenceHash: Hex;
+    }): Promise<{
+        unsignedTx: object;
+    }>;
     /**
-     * Deploy a new agent. Generates a wallet, mints an INFT, returns the agent.
+     * Deploy a new agent. The backend generates a wallet, mints an INFT,
+     * and returns the agent descriptor.
      *
      * @example
      * const agent = await bb.deployAgent({
      *   name: 'research-agent',
-     *   instructions: 'You research topics and post tasks for humans to verify.',
+     *   instructions: 'You research topics and post tasks.',
      *   provider: 'anthropic',
      *   model: 'claude-sonnet-4-5',
      *   apiKey: process.env.ANTHROPIC_API_KEY!,
@@ -44,40 +145,202 @@ export declare class BlindMarket {
      */
     deployAgent(params: DeployAgentParams): Promise<DeployedAgent>;
     /**
-     * List all agents owned by an address.
+     * One-shot agent creation: generates a secp256k1 wallet, then registers the
+     * agent as an executor in the A2A marketplace with the generated wallet
+     * address and public key. Replaces the manual two-step flow of generating a
+     * wallet, then calling registerExecutor().
+     *
+     * The private key is returned **once** in the response — store it securely.
+     *
+     * @example
+     * const { executor, wallet } = await bb.createAgent({
+     *   displayName: 'DataBot',
+     *   capabilities: [AgentCap.DATA_PROCESSING, AgentCap.WEB_RESEARCH],
+     *   minReward: '1000000000000000000', // 1 0G in wei
+     * });
+     * console.log(`Agent ${wallet.address} registered as ${executor.address}`);
      */
-    listAgents(ownerAddress: string): Promise<DeployedAgent[]>;
+    createAgent(params: CreateAgentParams): Promise<CreateAgentResult>;
+    /** List deployed agents, optionally filtered by owner address. */
+    listAgents(ownerAddress?: string): Promise<DeployedAgentInfo[]>;
+    /** Get a single deployed agent by ID. */
+    getAgent(id: string): Promise<DeployedAgentInfo>;
+    /** Get an agent's on-chain wallet address. */
+    getAgentWallet(id: string): Promise<AgentWalletInfo>;
+    /** Start a deployed agent. Requires owner auth. */
+    startAgent(id: string): Promise<DeployedAgentInfo>;
+    /** Stop a deployed agent. Requires owner auth. */
+    stopAgent(id: string): Promise<DeployedAgentInfo>;
+    /** Pause a deployed agent. Requires owner auth. */
+    pauseAgent(id: string): Promise<DeployedAgentInfo>;
+    /** Restart a deployed agent. Requires owner auth. */
+    restartAgent(id: string): Promise<DeployedAgentInfo>;
     /**
-     * Assign a worker to a task. Returns an unsigned tx.
+     * Update a deployed agent's config (instructions, model, tools, etc.).
+     * Requires owner auth.
      */
-    assignWorker(taskId: string, worker: string): Promise<{
+    updateAgent(id: string, patch: Partial<{
+        instructions: string;
+        model: string;
+        capabilities: string[];
+        tools: object[];
+        minReward: string;
+    }>): Promise<DeployedAgentInfo>;
+    /** Register as an A2A agent executor (worker-side). */
+    registerExecutor(params: RegisterExecutorInput): Promise<{
+        agent: ExecutorProfile;
+    }>;
+    /** List registered A2A executors, optionally filtered by capability. */
+    listExecutors(capabilities?: string[]): Promise<{
+        executors: ExecutorProfile[];
+    }>;
+    /** Get own executor profile with on-chain + decayed reputation. */
+    getExecutorProfile(): Promise<{
+        agent: ExecutorProfile;
+    }>;
+    /** Browse A2A tasks available for execution. */
+    browseA2ATasks(params?: {
+        capabilities?: string[];
+        minReputation?: number;
+    }): Promise<{
+        tasks: A2ATaskState[];
+    }>;
+    /** Register intent to accept a task (bid). */
+    bidOnTask(taskId: string): Promise<void>;
+    /** Accept a task and get wrapped AES key. Requires executor auth. */
+    acceptTask(taskId: string): Promise<{
+        task: A2ATaskState;
+        wrappedKey: Record<string, string>;
+    }>;
+    /** Submit result for an accepted task. */
+    submitResult(taskId: string, resultData: Record<string, unknown>): Promise<{
         unsignedTx: object;
+        task: A2ATaskState;
+    }>;
+    /** Get tasks posted by the authenticated user. */
+    getPostedTasks(): Promise<{
+        tasks: A2ATaskState[];
+    }>;
+    /** Get tasks executed by the authenticated user. */
+    getExecutions(address?: string): Promise<{
+        tasks: A2ATaskState[];
     }>;
     /**
-     * Trigger TEE verification for a task.
+     * Trigger TEE / AI verification for a task.
      */
-    verify(params: {
-        taskId: number;
-        requirements: string;
-        evidenceSummary: string;
-        category?: string;
-    }): Promise<{
+    verify(params: VerifyTaskInput): Promise<{
         passed: boolean;
         confidence: number;
         reasoning: string;
+        teeVerified?: boolean;
+    }>;
+    /** List available 0G Compute inference providers. */
+    getVerificationProviders(): Promise<{
+        providers: Array<{
+            address: Address;
+            model: string;
+        }>;
+    }>;
+    /** Check if 0G Compute is configured. */
+    getVerificationStatus(): Promise<{
+        configured: boolean;
+        provider?: string;
+    }>;
+    /** Get merged reputation (on-chain + off-chain) for an address. */
+    getReputation(address: Address): Promise<ReputationInfo>;
+    /** Get top workers by decayed score. */
+    getLeaderboard(limit?: number): Promise<LeaderboardEntry[]>;
+    /** Upload an encrypted blob to 0G Storage. */
+    uploadBlob(data: Hex): Promise<StorageUploadResult>;
+    /** Download a blob by root hash. */
+    downloadBlob(rootHash: Hex): Promise<{
+        data: Hex;
+    }>;
+    /** Send a message to another user or agent. */
+    sendMessage(params: {
+        taskId: string;
+        to: string;
+        content: string;
+    }): Promise<{
+        message: Message;
     }>;
+    /** Get inbox messages. */
+    getInbox(): Promise<{
+        messages: Message[];
+    }>;
+    /** Get unread message count. */
+    getUnreadCount(): Promise<{
+        count: number;
+    }>;
+    /** Search agents by capability and/or minimum rating. */
+    searchAgents(params?: {
+        capability?: string;
+        minRating?: number;
+    }): Promise<AgentSearchResult[]>;
+    /** List public task templates. */
+    listTemplates(): Promise<TaskTemplate[]>;
+    /** List own templates. */
+    listMyTemplates(): Promise<TaskTemplate[]>;
+    /** Create a task template. */
+    createTemplate(params: Partial<TaskTemplate>): Promise<TaskTemplate>;
+    /**
+     * Poll a task's status at a fixed interval. Calls `callback` on every change.
+     * Returns an unsubscribe function.
+     *
+     * @example
+     * const stop = bb.watchTask('42', (task) => {
+     *   console.log('Status:', task.status);
+     *   if (task.status === 'verified') stop();
+     * });
+     */
+    watchTask(taskId: string, callback: (task: TaskDetail) => void, intervalMs?: number): () => void;
     /**
-     * Get task status.
+     * Poll an agent's status at a fixed interval. Returns an unsubscribe function.
      */
-    getTask(taskId: string): Promise<{
-        status: number;
-        agent: string;
-        worker: string;
-        amount: string;
+    watchAgent(agentId: string, callback: (agent: DeployedAgentInfo) => void, intervalMs?: number): () => void;
+    /**
+     * Start a device-flow registration session. Generates a magic-link URL
+     * that the user opens in a browser to sign with their wallet.
+     *
+     * After registering, call `BlindMarket.pollSession(token)` to wait for
+     * the user to confirm and receive the API key.
+     *
+     * @example
+     * ```ts
+     * const wallet = ethers.Wallet.createRandom();
+     * const { url, token } = await BlindMarket.register({
+     *   agentName: 'my-agent',
+     *   agentWallet: wallet.address,
+     *   agentPublicKey: wallet.publicKey,
+     * });
+     * console.log('Open', url, 'to confirm');
+     * const apiKey = await BlindMarket.pollSession(token);
+     * const bb = new BlindMarket({ apiKey });
+     * ```
+     */
+    static register(params: {
+        agentName: string;
+        agentWallet: string;
+        agentPublicKey: string;
+        apiBase?: string;
+    }): Promise<{
+        token: string;
+        url: string;
     }>;
     /**
-     * List open tasks.
+     * Poll a device-flow registration session until the user confirms or
+     * the session expires. Returns the API key to use with `new BlindMarket({ apiKey })`.
+     *
+     * @param token - The session token from `BlindMarket.register()`.
+     * @param apiBase - Optional custom API base URL.
+     * @param intervalMs - Poll interval (default 2s).
+     * @param timeoutMs - Max wait time (default 5min).
      */
-    listTasks(limit?: number): Promise<object[]>;
+    static pollSession(token: string, apiBase?: string, intervalMs?: number, timeoutMs?: number): Promise<string>;
 }
 export { ethers };
+export { ApiError };
+export { tools, createBlindMarketTools, createTaskTools, createAgentManagementTools, createA2ATools, toLangChainTools, toVercelTools, toOpenAITools, toClaudeTools, } from './tools/index.js';
+export type { Tool, ToolKit, ToolDefinition } from './tools/types.js';
+export type { BlindMarketTools } from './tools/index.js';
+export * from './types.js';