@blindmarket/sdk 0.1.6 → 0.1.8

package/dist/network/types.d.ts

@@ -1,16 +1,3 @@
-import type { Address } from '../types.js';
-export interface NetworkContracts {
-    escrow: Address;
-    registry: Address;
-    reputation: Address;
-    usdc: Address;
-}
-export interface Network {
-    name: string;
-    chainId: bigint;
-    rpc: string[];
-    contracts: NetworkContracts;
-    indexer: string;
-    broker: string;
-    explorer?: string;
-}
+import type { NetworkName } from './presets.js';
+export type { Network, EVMNetwork, NetworkBase, BlockchainType, CreateTaskParams, DomainTask, DomainTaskMeta, DomainReputation, DomainTxReceipt, ChainSigner, } from '../chain/domain-types.js';
+export type { NetworkName };

package/dist/signer/EthersSigner.js

@@ -59,7 +59,7 @@ export class EthersSigner {
             return this.publicKeyCache;
         }
         // Slow path: sign a probe message and recover the public key.
-        const probe = 'BlindBounty-PublicKey-Recovery-v1';
+        const probe = 'BlindMarket-PublicKey-Recovery-v1';
         const sig = await this.inner.signMessage(probe);
         const recovered = ethers.SigningKey.recoverPublicKey(ethers.hashMessage(probe), sig);
         this.publicKeyCache = recovered;

package/dist/storage/index.d.ts

@@ -1,3 +1,2 @@
 export * from './Storage.js';
 export * from './MemoryStorage.js';
-export * from './ZgStorage.js';

package/dist/storage/index.js

@@ -1,3 +1,3 @@
 export * from './Storage.js';
 export * from './MemoryStorage.js';
-export * from './ZgStorage.js';
+// ZgStorage excluded — requires @0gfoundation/0g-ts-sdk optional dep

package/dist/tools/adapters.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Framework adapters — convert BlindMarket tools into ready-to-use tool arrays
+ * for each major agent SDK. No manual schema conversion needed.
+ *
+ * @example
+ * ```ts
+ * // LangChain
+ * import { toLangChainTools } from '@blindmarket/sdk/tools';
+ * const tools = toLangChainTools(bb);
+ *
+ * // Vercel AI SDK
+ * import { toVercelTools } from '@blindmarket/sdk/tools';
+ * const tools = toVercelTools(bb);
+ * ```
+ */
+import type { BlindMarket } from '../index.js';
+export type { Tool, ToolKit, ToolDefinition } from './types.js';
+export interface LangChainStructuredTool {
+    name: string;
+    description: string;
+    schema: {
+        shape: Record<string, unknown>;
+        parse: (raw: unknown) => Record<string, unknown>;
+    };
+    func: (args: Record<string, unknown>) => Promise<string>;
+}
+/**
+ * Convert BlindMarket tools to LangChain `DynamicStructuredTool`-compatible objects.
+ * Pass them directly into `createReactAgent`, `initializeAgentExecutorWithOptions`, etc.
+ *
+ * ```ts
+ * import { ChatOpenAI } from '@langchain/openai';
+ * import { createReactAgent } from '@langchain/langgraph/prebuilt';
+ *
+ * const tools = toLangChainTools(bb);
+ * const agent = createReactAgent({ llm: new ChatOpenAI({ model: 'gpt-4' }), tools });
+ * ```
+ */
+export declare function toLangChainTools(bb: BlindMarket): LangChainStructuredTool[];
+export interface VercelTool {
+    description: string;
+    parameters: {
+        type: 'object';
+        properties: Record<string, {
+            type: string;
+            description?: string;
+            enum?: string[];
+        }>;
+        required?: string[];
+    };
+    execute: (args: Record<string, unknown>) => Promise<unknown>;
+}
+/**
+ * Convert BlindMarket tools to Vercel AI SDK `tool()` compatible objects.
+ *
+ * ```ts
+ * import { generateText } from 'ai';
+ * import { openai } from '@ai-sdk/openai';
+ *
+ * const tools = toVercelTools(bb);
+ * const { text } = await generateText({ model: openai('gpt-4'), tools });
+ * ```
+ */
+export declare function toVercelTools(bb: BlindMarket): Record<string, VercelTool>;
+/**
+ * Get raw OpenAI-compatible tool definitions.
+ *
+ * ```ts
+ * const tools = toOpenAITools(bb);
+ * const response = await openai.chat.completions.create({ model: 'gpt-4', tools });
+ * ```
+ */
+export declare function toOpenAITools(bb: BlindMarket): import("./types.js").ToolDefinition[];
+export interface ClaudeTool {
+    name: string;
+    description: string;
+    input_schema: {
+        type: 'object';
+        properties: Record<string, {
+            type: string;
+            description?: string;
+            enum?: string[];
+        }>;
+        required?: string[];
+    };
+}
+/**
+ * Convert BlindMarket tools to Claude SDK tool format.
+ *
+ * ```ts
+ * const tools = toClaudeTools(bb);
+ * const response = await anthropic.messages.create({
+ *   model: 'claude-sonnet-4-20250514',
+ *   tools,
+ *   messages: [{ role: 'user', content: 'Find tasks' }],
+ * });
+ * ```
+ */
+export declare function toClaudeTools(bb: BlindMarket): ClaudeTool[];

package/dist/tools/adapters.js

@@ -0,0 +1,129 @@
+/**
+ * Framework adapters — convert BlindMarket tools into ready-to-use tool arrays
+ * for each major agent SDK. No manual schema conversion needed.
+ *
+ * @example
+ * ```ts
+ * // LangChain
+ * import { toLangChainTools } from '@blindmarket/sdk/tools';
+ * const tools = toLangChainTools(bb);
+ *
+ * // Vercel AI SDK
+ * import { toVercelTools } from '@blindmarket/sdk/tools';
+ * const tools = toVercelTools(bb);
+ * ```
+ */
+import { createBlindMarketTools } from './helpers.js';
+/**
+ * Convert BlindMarket tools to LangChain `DynamicStructuredTool`-compatible objects.
+ * Pass them directly into `createReactAgent`, `initializeAgentExecutorWithOptions`, etc.
+ *
+ * ```ts
+ * import { ChatOpenAI } from '@langchain/openai';
+ * import { createReactAgent } from '@langchain/langgraph/prebuilt';
+ *
+ * const tools = toLangChainTools(bb);
+ * const agent = createReactAgent({ llm: new ChatOpenAI({ model: 'gpt-4' }), tools });
+ * ```
+ */
+export function toLangChainTools(bb) {
+    return createBlindMarketTools(bb).map(mapToLangChain);
+}
+function mapToLangChain(t) {
+    const shape = {};
+    const props = t.definition.function.parameters.properties;
+    const required = t.definition.function.parameters.required ?? [];
+    for (const [key, prop] of Object.entries(props)) {
+        const p = prop;
+        const type = p.type === 'number' ? 'number'
+            : p.type === 'array' ? 'array'
+                : 'string';
+        shape[key] = { type, enum: p.enum, required: required.includes(key) };
+    }
+    return {
+        name: t.definition.function.name,
+        description: t.definition.function.description,
+        schema: {
+            shape,
+            parse: (raw) => raw,
+        },
+        func: async (args) => JSON.stringify(await t.execute(args)),
+    };
+}
+/**
+ * Convert BlindMarket tools to Vercel AI SDK `tool()` compatible objects.
+ *
+ * ```ts
+ * import { generateText } from 'ai';
+ * import { openai } from '@ai-sdk/openai';
+ *
+ * const tools = toVercelTools(bb);
+ * const { text } = await generateText({ model: openai('gpt-4'), tools });
+ * ```
+ */
+export function toVercelTools(bb) {
+    const result = {};
+    for (const t of createBlindMarketTools(bb)) {
+        const props = t.definition.function.parameters.properties;
+        const required = t.definition.function.parameters.required;
+        const converted = {};
+        for (const [key, prop] of Object.entries(props)) {
+            const p = prop;
+            converted[key] = {
+                type: p.type === 'number' ? 'number' : p.type === 'array' ? 'array' : 'string',
+                description: p.description,
+                ...(p.enum ? { enum: p.enum } : {}),
+            };
+        }
+        result[t.definition.function.name] = {
+            description: t.definition.function.description,
+            parameters: { type: 'object', properties: converted, required },
+            execute: (args) => t.execute(args),
+        };
+    }
+    return result;
+}
+// ── OpenAI adapter ──────────────────────────────────────────────────────────
+/**
+ * Get raw OpenAI-compatible tool definitions.
+ *
+ * ```ts
+ * const tools = toOpenAITools(bb);
+ * const response = await openai.chat.completions.create({ model: 'gpt-4', tools });
+ * ```
+ */
+export function toOpenAITools(bb) {
+    return createBlindMarketTools(bb).map(t => t.definition);
+}
+/**
+ * Convert BlindMarket tools to Claude SDK tool format.
+ *
+ * ```ts
+ * const tools = toClaudeTools(bb);
+ * const response = await anthropic.messages.create({
+ *   model: 'claude-sonnet-4-20250514',
+ *   tools,
+ *   messages: [{ role: 'user', content: 'Find tasks' }],
+ * });
+ * ```
+ */
+export function toClaudeTools(bb) {
+    return createBlindMarketTools(bb).map(t => {
+        const props = t.definition.function.parameters.properties;
+        const required = t.definition.function.parameters.required;
+        const converted = {};
+        for (const [key, prop] of Object.entries(props)) {
+            const p = prop;
+            converted[key] = {
+                type: p.type === 'number' ? 'number' : p.type === 'array' ? 'array' : 'string',
+                description: p.description,
+                ...(p.enum ? { enum: p.enum } : {}),
+            };
+        }
+        return {
+            name: t.definition.function.name,
+            description: t.definition.function.description,
+            input_schema: { type: 'object', properties: converted, required },
+        };
+    });
+}

package/dist/tools/helpers.d.ts

@@ -0,0 +1,9 @@
+import { BlindMarket } from '../index.js';
+import type { Tool, ToolKit } from './types.js';
+export declare function tool<T>(_bb: BlindMarket, name: string, description: string, properties: Record<string, unknown>, execute: (args: Record<string, any>) => Promise<T>, required?: string[]): Tool<Record<string, any>, T>;
+export declare function kit(name: string, description: string, all: Tool[], names: string[]): ToolKit;
+export declare function createBlindMarketTools(bb: BlindMarket): Tool[];
+export declare function createTaskTools(bb: BlindMarket): ToolKit;
+export declare function createAgentManagementTools(bb: BlindMarket): ToolKit;
+export declare function createA2ATools(bb: BlindMarket): ToolKit;
+export type { Tool, ToolKit, ToolDefinition } from './types.js';

package/dist/tools/helpers.js

@@ -0,0 +1,169 @@
+import { AgentCap } from '../types.js';
+const CAP_ENUM = Object.values(AgentCap);
+function def(name, description, properties, required) {
+    return {
+        type: 'function',
+        function: { name, description, parameters: { type: 'object', properties: properties, required } },
+    };
+}
+function str(desc, e) {
+    return e ? { type: 'string', description: desc, enum: e } : { type: 'string', description: desc };
+}
+function num(desc) {
+    return { type: 'number', description: desc };
+}
+function arr(desc, items) {
+    return items ? { type: 'array', description: desc, items } : { type: 'array', description: desc };
+}
+export function tool(_bb, name, description, properties, execute, required) {
+    return { definition: def(name, description, properties, required), execute };
+}
+export function kit(name, description, all, names) {
+    const namesSet = new Set(names);
+    return { name, description, tools: all.filter((t) => namesSet.has(t.definition.function.name)) };
+}
+export function createBlindMarketTools(bb) {
+    return [
+        tool(bb, 'list_open_tasks', 'List open tasks available for assignment', {}, async () => {
+            return bb.listTasks();
+        }),
+        tool(bb, 'get_task', 'Get full task details by ID', { taskId: str('Numeric or 0x task ID') }, async (a) => {
+            return bb.getTask(a.taskId);
+        }, ['taskId']),
+        tool(bb, 'search_agents', 'Search registered agents by capability or rating', {
+            capability: str('Agent capability filter'),
+            minRating: num('Minimum rating (1-5)'),
+        }, async (a) => {
+            return bb.searchAgents(a);
+        }),
+        tool(bb, 'create_agent', 'One-shot agent creation: generates wallet + registers as A2A executor', {
+            displayName: str('Display name for the agent'),
+            capabilities: arr('List of capabilities', str('Capability', CAP_ENUM)),
+            minReward: str('Minimum reward per task in wei (optional)'),
+            preferredCapabilities: arr('Preferred subset of capabilities (optional)', str('Capability', CAP_ENUM)),
+            agentCardUrl: str('Agent card URL for marketplace display (optional)'),
+            mcpEndpointUrl: str('MCP endpoint URL (optional)'),
+        }, async (a) => {
+            return bb.createAgent(a);
+        }, ['displayName', 'capabilities']),
+        tool(bb, 'register_as_executor', 'Register as an A2A executor to receive task offers', {
+            address: str('Your wallet address (0x...)'),
+            displayName: str('Human-readable display name'),
+            capabilities: arr('List of capabilities', str('Capability', CAP_ENUM)),
+            publicKey: str('Your uncompressed secp256k1 public key'),
+            minReward: str('Minimum reward in wei (optional)'),
+            preferredCapabilities: arr('Preferred subset of capabilities (optional)', str('Capability', CAP_ENUM)),
+        }, async (a) => {
+            return bb.registerExecutor(a);
+        }, ['address', 'displayName', 'capabilities', 'publicKey']),
+        tool(bb, 'browse_a2a_tasks', 'Browse tasks available for A2A execution', {
+            capabilities: arr('Required capabilities filter'),
+            minReputation: num('Minimum reputation filter'),
+        }, async (a) => {
+            return bb.browseA2ATasks(a);
+        }),
+        tool(bb, 'bid_on_task', 'Register bid intent on an A2A task', {
+            taskId: str('Task ID'),
+        }, async (a) => {
+            await bb.bidOnTask(a.taskId);
+            return { success: true };
+        }, ['taskId']),
+        tool(bb, 'accept_task', 'Accept a task and get the wrapped AES key', {
+            taskId: str('Task ID'),
+        }, async (a) => {
+            return bb.acceptTask(a.taskId);
+        }, ['taskId']),
+        tool(bb, 'submit_result', 'Submit execution result for an accepted task', {
+            taskId: str('Task ID'),
+            output: str('Result output text'),
+        }, async (a) => {
+            return bb.submitResult(a.taskId, { output: a.output });
+        }, ['taskId', 'output']),
+        tool(bb, 'deploy_agent', 'Deploy a new AI agent on BlindMarket', {
+            name: str('Agent name'),
+            instructions: str('System prompt / instructions'),
+            provider: str('LLM provider', ['openai', 'anthropic', 'groq', 'gemini']),
+            model: str('Model name (e.g. gpt-4, claude-sonnet-4-5)'),
+            apiKey: str('Provider API key'),
+            ownerAddress: str('Owner wallet address (0x...)'),
+            ownerPublicKey: str('Owner public key'),
+        }, async (a) => {
+            return bb.deployAgent(a);
+        }, ['name', 'instructions', 'provider', 'model', 'apiKey', 'ownerAddress', 'ownerPublicKey']),
+        tool(bb, 'list_agents', 'List deployed agents', {
+            ownerAddress: str('Filter by owner address'),
+        }, async (a) => {
+            return bb.listAgents(a.ownerAddress);
+        }),
+        tool(bb, 'get_agent', 'Get single deployed agent details', {
+            agentId: str('Agent ID'),
+        }, async (a) => {
+            return bb.getAgent(a.agentId);
+        }, ['agentId']),
+        tool(bb, 'start_agent', 'Start a deployed agent', {
+            agentId: str('Agent ID'),
+        }, async (a) => {
+            return bb.startAgent(a.agentId);
+        }, ['agentId']),
+        tool(bb, 'stop_agent', 'Stop a deployed agent', {
+            agentId: str('Agent ID'),
+        }, async (a) => {
+            return bb.stopAgent(a.agentId);
+        }, ['agentId']),
+        tool(bb, 'restart_agent', 'Restart a deployed agent', {
+            agentId: str('Agent ID'),
+        }, async (a) => {
+            return bb.restartAgent(a.agentId);
+        }, ['agentId']),
+        tool(bb, 'update_agent', "Update a deployed agent's config", {
+            agentId: str('Agent ID'),
+            instructions: str('New instructions'),
+            model: str('New model name'),
+            capabilities: arr('New capabilities list', str('Capability')),
+        }, async (a) => {
+            return bb.updateAgent(a.agentId, a);
+        }, ['agentId']),
+        tool(bb, 'verify_task', 'Trigger AI/TEE verification for a submitted task result', {
+            taskId: num('Numeric task ID'),
+            taskCategory: str('Task category (e.g. photography, research)'),
+            taskRequirements: str('What the task required'),
+            evidenceSummary: str('Summary of submitted evidence'),
+        }, async (a) => {
+            return bb.verify(a);
+        }, ['taskId', 'taskCategory', 'taskRequirements', 'evidenceSummary']),
+        tool(bb, 'get_reputation', "Get an address's on-chain + off-chain reputation", {
+            address: str('Wallet address (0x...)'),
+        }, async (a) => {
+            return bb.getReputation(a.address);
+        }, ['address']),
+        tool(bb, 'send_message', 'Send a message to a task participant', {
+            taskId: str('Task ID'),
+            to: str('Recipient address or "poster"/"agent" shortcut'),
+            content: str('Message content'),
+        }, async (a) => {
+            return bb.sendMessage(a);
+        }, ['taskId', 'to', 'content']),
+        tool(bb, 'get_inbox', 'Read inbox messages', {}, async () => {
+            return bb.getInbox();
+        }),
+        tool(bb, 'get_unread_count', 'Get unread message count', {}, async () => {
+            return bb.getUnreadCount();
+        }),
+    ];
+}
+export function createTaskTools(bb) {
+    return kit('tasks', 'Browse and manage tasks', createBlindMarketTools(bb), [
+        'list_open_tasks', 'get_task', 'bid_on_task', 'accept_task', 'submit_result',
+    ]);
+}
+export function createAgentManagementTools(bb) {
+    return kit('agents', 'Deploy and manage agents', createBlindMarketTools(bb), [
+        'deploy_agent', 'list_agents', 'get_agent', 'start_agent', 'stop_agent',
+        'restart_agent', 'update_agent', 'create_agent', 'register_as_executor',
+    ]);
+}
+export function createA2ATools(bb) {
+    return kit('a2a', 'Agent-to-agent task execution', createBlindMarketTools(bb), [
+        'create_agent', 'register_as_executor', 'browse_a2a_tasks', 'bid_on_task', 'accept_task', 'submit_result',
+    ]);
+}

package/dist/tools/index.d.ts

@@ -0,0 +1,36 @@
+import { BlindMarket } from '../index.js';
+import { toLangChainTools, toVercelTools, toClaudeTools } from './adapters.js';
+import type { ToolDefinition } from './types.js';
+/**
+ * Returns all framework tool formats from one call. No need to remember
+ * `toLangChainTools`, `toVercelTools`, etc. — just pick a property.
+ *
+ * @example
+ * ```ts
+ * import { BlindMarket, tools } from '@blindmarket/sdk';
+ * const bb = new BlindMarket({ apiKey });
+ *
+ * // OpenAI / Vercel
+ * 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 });
+ * ```
+ */
+export declare function tools(bb: BlindMarket): BlindMarketTools;
+export interface BlindMarketTools {
+    /** OpenAI-compatible tool definitions (array of `{type, function}`). */
+    definitions: ToolDefinition[];
+    /** LangChain `StructuredTool` instances. */
+    langchain: ReturnType<typeof toLangChainTools>;
+    /** Vercel AI SDK tool map (`Record<string, VercelTool>`). */
+    vercel: ReturnType<typeof toVercelTools>;
+    /** Claude tool shapes (`{name, description, input_schema}[]`). */
+    claude: ReturnType<typeof toClaudeTools>;
+}
+export type { Tool, ToolKit, ToolDefinition } from './types.js';
+export { createBlindMarketTools, createTaskTools, createAgentManagementTools, createA2ATools, } from './helpers.js';
+export { toLangChainTools, toVercelTools, toOpenAITools, toClaudeTools, } from './adapters.js';

package/dist/tools/index.js

@@ -0,0 +1,32 @@
+import { createBlindMarketTools, } from './helpers.js';
+import { toLangChainTools, toVercelTools, toClaudeTools, } from './adapters.js';
+// ── Single entry-point ───────────────────────────────────────────────────────
+/**
+ * Returns all framework tool formats from one call. No need to remember
+ * `toLangChainTools`, `toVercelTools`, etc. — just pick a property.
+ *
+ * @example
+ * ```ts
+ * import { BlindMarket, tools } from '@blindmarket/sdk';
+ * const bb = new BlindMarket({ apiKey });
+ *
+ * // OpenAI / Vercel
+ * 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 });
+ * ```
+ */
+export function tools(bb) {
+    const all = createBlindMarketTools(bb);
+    const definitions = all.map(t => t.definition);
+    const langchain = toLangChainTools(bb);
+    const vercel = toVercelTools(bb);
+    const claude = toClaudeTools(bb);
+    return { definitions, langchain, vercel, claude };
+}
+export { createBlindMarketTools, createTaskTools, createAgentManagementTools, createA2ATools, } from './helpers.js';
+export { toLangChainTools, toVercelTools, toOpenAITools, toClaudeTools, } from './adapters.js';

package/dist/tools/types.d.ts

@@ -0,0 +1,44 @@
+/**
+ * OpenAI-compatible function tool definition.
+ * Every major agent SDK can consume this format:
+ * - **OpenAI** — native function calling
+ * - **Claude** — tool_use format (convert name → tool name)
+ * - **Vercel AI SDK** — pass into `toolset` helper
+ * - **LangChain** — convert via `DynamicStructuredTool`
+ * - **OpenAI Agents SDK** — pass as `FunctionTool`
+ */
+export interface ToolDefinition {
+    type: 'function';
+    function: {
+        name: string;
+        description: string;
+        parameters: {
+            type: 'object';
+            properties: Record<string, JSONSchemaProperty>;
+            required?: string[];
+        };
+    };
+}
+export type JSONSchemaProperty = {
+    type: 'string' | 'number' | 'boolean' | 'array' | 'object';
+    description?: string;
+    enum?: string[];
+    items?: JSONSchemaProperty;
+    properties?: Record<string, JSONSchemaProperty>;
+    required?: string[];
+};
+/**
+ * A bound tool — ready to invoke with parsed args.
+ */
+export interface Tool<TArgs = Record<string, unknown>, TResult = unknown> {
+    definition: ToolDefinition;
+    execute: (args: TArgs) => Promise<TResult>;
+}
+/**
+ * Collection of tools grouped by domain.
+ */
+export interface ToolKit {
+    name: string;
+    description: string;
+    tools: Tool[];
+}

package/dist/tools/types.js

@@ -0,0 +1 @@
+export {};