JavaScript SDK

Complete JavaScript SDK documentation for MeshAI Protocol

Installation

Install the MeshAI JavaScript SDK using npm or yarn:

npm

npm install meshai-sdk

Quick Start

ES6 Modules

import { MeshAI } from 'meshai-sdk';

// Initialize client
const client = new MeshAI({ apiKey: 'your_api_key' });

// Execute a simple task
const result = await client.executeTask({
  taskType: 'text_generation',
  input: 'Write a blog post about AI',
  qualityLevel: 'high'
});

console.log(result.output);

Client Configuration

Basic Configuration

Environment Variables

// Using environment variables (Node.js)
const client = new MeshAI({
  apiKey: process.env.MESHAI_API_KEY
});

Core Methods

executeTask()

Execute a single AI task with automatic agent selection.

async executeTask(options: {
  taskType: string;
  input: any;
  qualityLevel?: 'basic' | 'standard' | 'high' | 'premium';
  maxCost?: number;
  timeout?: number;
  agentRequirements?: object;
}): Promise<TaskResult>

Parameters:

Parameter	Type	Description	Default
taskType	string	Type of AI task to execute	Required
input	any	Input data for the task	Required
qualityLevel	string	Quality level: “basic”, “standard”, “high”, “premium"	"standard”
maxCost	number	Maximum cost in SOL	null
timeout	number	Timeout in milliseconds	30000
agentRequirements	object	Specific agent requirements	null

Basic Usage

// Simple text generation
const result = await client.executeTask({
  taskType: 'text_generation',
  input: 'Explain quantum computing'
});

console.log(`Output: ${result.output}`);
console.log(`Quality: ${result.qualityScore}`);
console.log(`Cost: ${result.cost} SOL`);

With Options

// Task with specific requirements
const result = await client.executeTask({
  taskType: 'image_analysis',
  input: { imageUrl: 'https://example.com/image.jpg' },
  qualityLevel: 'high',
  maxCost: 0.005,
  timeout: 60000,
  agentRequirements: {
    minReputation: 0.95,
    specialization: 'medical_imaging'
  }
});

Error Handling

try {
  const result = await client.executeTask({
    taskType: 'text_generation',
    input: 'Write a novel',
    qualityLevel: 'premium',
    timeout: 120000
  });
} catch (error) {
  switch (error.code) {
    case 'TASK_TIMEOUT':
      console.log('Task took too long to complete');
      break;
    case 'INSUFFICIENT_FUNDS':
      console.log(`Need ${error.requiredAmount} SOL`);
      break;
    case 'QUALITY_THRESHOLD':
      console.log(`Quality ${error.actualQuality} below threshold`);
      break;
    default:
      console.log(`Error: ${error.message}`);
  }
}

createWorkflow()

Create multi-step workflows with task dependencies.

createWorkflow(options?: {
  name?: string;
  description?: string;
  maxParallel?: number;
}): Workflow

Example:

// Create workflow
const workflow = client.createWorkflow({ name: 'document_analysis' });

// Add OCR task
const ocrTask = workflow.addTask({
  taskType: 'document_ocr',
  input: { documentUrl: 'https://example.com/doc.pdf' },
  qualityThreshold: 0.99
});

// Add analysis task (depends on OCR)
const analysisTask = workflow.addTask({
  taskType: 'document_analysis',
  input: ocrTask.output,
  dependsOn: ocrTask
});

// Execute workflow
const results = await workflow.execute();

Workflow Management

Workflow Class

class Workflow {
  addTask(options: TaskOptions): Task
  removeTask(taskId: string): boolean
  execute(maxParallel?: number): Promise<WorkflowResult>
  getStatus(): WorkflowStatus
  cancel(): Promise<boolean>
}

Task Dependencies

Sequential Tasks

const workflow = client.createWorkflow();

// Task 1
const task1 = workflow.addTask({
  taskType: 'ocr',
  input: document
});

// Task 2 depends on Task 1
const task2 = workflow.addTask({
  taskType: 'text_analysis',
  input: task1.output,
  dependsOn: task1
});

// Task 3 depends on Task 2
const task3 = workflow.addTask({
  taskType: 'summarization',
  input: task2.output,
  dependsOn: task2
});

Parallel Tasks

const workflow = client.createWorkflow();

// Base task
const ocrTask = workflow.addTask({
  taskType: 'ocr',
  input: document
});

// Parallel tasks (both depend on OCR)
const sentimentTask = workflow.addTask({
  taskType: 'sentiment_analysis',
  input: ocrTask.output,
  dependsOn: ocrTask
});

const entityTask = workflow.addTask({
  taskType: 'entity_extraction',
  input: ocrTask.output,
  dependsOn: ocrTask,
  parallelTo: sentimentTask
});

Complex Dependencies

const workflow = client.createWorkflow();

// Multiple input tasks
const ocrTask = workflow.addTask({
  taskType: 'ocr',
  input: document
});

const imageTask = workflow.addTask({
  taskType: 'image_analysis',
  input: image
});

// Task depending on multiple inputs
const synthesisTask = workflow.addTask({
  taskType: 'content_synthesis',
  input: {
    text: ocrTask.output,
    imageAnalysis: imageTask.output
  },
  dependsOn: [ocrTask, imageTask]
});

Task Types

Available Task Types

Task Type	Description	Input Format	Output Format
text_generation	Generate text content	string or object	string
text_analysis	Analyze text sentiment, entities	string	object
text_summarization	Summarize long text	string	string
document_ocr	Extract text from documents	object with URL/base64	string
image_analysis	Analyze and caption images	object with URL/base64	object
image_generation	Generate images from text	string	object with URL
code_generation	Generate code	string or object	string
translation	Translate text	object with text and languages	string
audio_transcription	Convert speech to text	object with audio URL	string

Task-Specific Examples

Text Generation

const result = await client.executeTask({
  taskType: 'text_generation',
  input: {
    prompt: 'Write a technical blog post about blockchain',
    maxTokens: 2000,
    style: 'professional',
    audience: 'developers'
  }
});

Image Analysis

const result = await client.executeTask({
  taskType: 'image_analysis',
  input: {
    imageUrl: 'https://example.com/image.jpg',
    analysisType: ['objects', 'text', 'faces'],
    detailLevel: 'high'
  }
});

Translation

const result = await client.executeTask({
  taskType: 'translation',
  input: {
    text: 'Hello, how are you?',
    sourceLanguage: 'en',
    targetLanguage: 'es',
    formality: 'formal'
  }
});

Response Objects

TaskResult

interface TaskResult {
  output: any;              // Task output data
  qualityScore: number;     // Quality score (0-1)
  cost: number;            // Cost in SOL
  agentId: string;         // Processing agent ID
  latency: number;         // Processing time (ms)
  metadata: object;        // Additional metadata
  timestamp: Date;         // Completion timestamp
}

WorkflowResult

interface WorkflowResult {
  results: Record<string, TaskResult>; // Results by task ID
  totalCost: number;                   // Total workflow cost
  totalLatency: number;                // Total execution time
  successRate: number;                 // Percentage of successful tasks
  metadata: object;                    // Workflow metadata