@blindmarket/sdk 0.1.8 → 0.5.0

package/src/tools/adapters.ts

@@ -1,177 +0,0 @@
-/**
- * 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';
-import { createBlindMarketTools } from './helpers.js';
-import type { Tool } from './types.js';
-
-export type { Tool, ToolKit, ToolDefinition } from './types.js';
-
-// ── LangChain adapter ───────────────────────────────────────────────────────
-
-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 function toLangChainTools(bb: BlindMarket): LangChainStructuredTool[] {
-  return createBlindMarketTools(bb).map(mapToLangChain);
-}
-
-function mapToLangChain(t: Tool): LangChainStructuredTool {
-  const shape: Record<string, unknown> = {};
-  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 as any;
-    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: unknown) => raw as Record<string, unknown>,
-    },
-    func: async (args) => JSON.stringify(await t.execute(args)),
-  };
-}
-
-// ── Vercel AI SDK adapter ──────────────────────────────────────────────────
-
-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 function toVercelTools(bb: BlindMarket): Record<string, VercelTool> {
-  const result: Record<string, VercelTool> = {};
-  for (const t of createBlindMarketTools(bb)) {
-    const props = t.definition.function.parameters.properties;
-    const required = t.definition.function.parameters.required;
-
-    const converted: Record<string, { type: string; description?: string; enum?: string[] }> = {};
-    for (const [key, prop] of Object.entries(props)) {
-      const p = prop as any;
-      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: BlindMarket) {
-  return createBlindMarketTools(bb).map(t => t.definition);
-}
-
-// ── Claude (Anthropic SDK) adapter ─────────────────────────────────────────
-
-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 function toClaudeTools(bb: BlindMarket): ClaudeTool[] {
-  return createBlindMarketTools(bb).map(t => {
-    const props = t.definition.function.parameters.properties;
-    const required = t.definition.function.parameters.required;
-    const converted: Record<string, { type: string; description?: string; enum?: string[] }> = {};
-    for (const [key, prop] of Object.entries(props)) {
-      const p = prop as any;
-      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/src/tools/helpers.ts

@@ -1,199 +0,0 @@
-import { BlindMarket } from '../index.js';
-import type { Tool, ToolKit, ToolDefinition } from './types.js';
-import { AgentCap } from '../types.js';
-
-const CAP_ENUM = Object.values(AgentCap);
-
-function def(
-  name: string,
-  description: string,
-  properties: Record<string, unknown>,
-  required?: string[],
-): ToolDefinition {
-  return {
-    type: 'function',
-    function: { name, description, parameters: { type: 'object', properties: properties as any, required } },
-  };
-}
-
-function str(desc: string, e?: string[]): unknown {
-  return e ? { type: 'string', description: desc, enum: e } : { type: 'string', description: desc };
-}
-function num(desc: string): unknown {
-  return { type: 'number', description: desc };
-}
-function arr(desc: string, items?: unknown): unknown {
-  return items ? { type: 'array', description: desc, items } : { type: 'array', description: desc };
-}
-
-export 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> {
-  return { definition: def(name, description, properties, required), execute };
-}
-
-export function kit(name: string, description: string, all: Tool[], names: string[]): ToolKit {
-  const namesSet = new Set(names);
-  return { name, description, tools: all.filter((t) => namesSet.has(t.definition.function.name)) };
-}
-
-export function createBlindMarketTools(bb: BlindMarket): Tool[] {
-  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 as any);
-    }),
-    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 as any);
-    }, ['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 as any);
-    }, ['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 as any);
-    }),
-    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 as any);
-    }, ['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 as any);
-    }, ['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 as any);
-    }, ['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 as any);
-    }, ['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 as any);
-    }, ['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: BlindMarket): ToolKit {
-  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: BlindMarket): ToolKit {
-  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: BlindMarket): ToolKit {
-  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',
-  ]);
-}
-
-export type { Tool, ToolKit, ToolDefinition } from './types.js';

package/src/tools/index.ts

@@ -1,59 +0,0 @@
-import { BlindMarket } from '../index.js';
-import {
-  createBlindMarketTools, createTaskTools, createAgentManagementTools, createA2ATools,
-} from './helpers.js';
-import {
-  toLangChainTools, toVercelTools, toClaudeTools,
-} from './adapters.js';
-import type { Tool, ToolKit, ToolDefinition } from './types.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: BlindMarket): BlindMarketTools {
-  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 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>;
-}
-
-// ── Re-exports ───────────────────────────────────────────────────────────────
-
-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/src/tools/types.ts

@@ -1,47 +0,0 @@
-/**
- * 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[];
-}