Docs/SDK Reference

SDK Reference

Official TypeScript client for the Jarvis SDK module marketplace. Zero dependencies, fully typed.

Installation

TSTypeScript / JavaScript

npm install @jarvis-sdk/client

Node.js 18+, Deno, Bun. Zero dependencies.

PYPython

pip install jarvis-sdk

Coming Q2 2026.

KILLER FEATURE

client.superpower(mission)

One call to go from "new agent" to "capable agent." Describe your mission, get armed with the right tools — auto-installed and ready to execute.

import { JarvisClient } from '@jarvis-sdk/client';

const client = new JarvisClient({ apiKey: process.env.JARVIS_API_KEY! });

// One call — your agent is now armed with the right tools
const powers = await client.superpower(
  "I process customer emails, extract key data, and update CRM records"
);

console.log(`Armed with ${powers.total_tools} tools:`);
powers.toolkit.forEach(t =>
  console.log(`  ${t.module}.${t.action} — ${t.description}`)
);

// Execute any tool immediately — they're already installed
for (const tool of powers.toolkit) {
  const result = await client.execute(tool.module, tool.action, myInput);
  console.log(result.output);
}

// Options
await client.superpower(mission, {
  max_tools: 10,         // Maximum tools to recommend (default: 10)
  auto_install: true,    // Auto-install recommended modules (default: true)
  categories: ['data-processing', 'communications'],  // Limit to specific categories
});

// Returns:
// {
//   mission: "I process customer emails...",
//   toolkit: [
//     { module: "text-toolkit", action: "extract_entities", description: "...", installed: true },
//     { module: "email-toolkit", action: "parse_email", description: "...", installed: true },
//     ...
//   ],
//   total_tools: 8,
//   installed_count: 8
// }

Quick Start

import { JarvisClient } from '@jarvis-sdk/client';

const client = new JarvisClient({
  apiKey: process.env.JARVIS_API_KEY!,
});

// Option 1: superpower() — fastest path (recommended)
const powers = await client.superpower("I analyze sentiment in customer feedback");
// Your agent now has the right tools. Execute them.

// Option 2: Manual discovery + execution
const { modules } = await client.listModules({ q: 'text processing' });

const result = await client.execute('text-toolkit', 'word_count', {
  text: 'Hello from Jarvis SDK'
});
console.log(result.output); // { word_count: 4, ... }

// Check trust score before using an unfamiliar module
const trust = await client.getTrustScore('text-toolkit');
console.log(trust.tier); // "platinum" | "gold" | "silver" | "bronze"

Constructor

new JarvisClient(config)

interface JarvisClientConfig {
  apiKey: string;     // Required: your jsk_ API key
  baseUrl?: string;   // Default: 'https://jarvissdk.com'
}

Module Methods

client.listModules(options?)

Browse marketplace modules with filters.

const { modules, total } = await client.listModules({
  category: 'data-processing',  // Filter by category
  trust_tier: 'gold',           // Filter by trust tier
  pricing_tier: 'free',         // Filter by pricing
  q: 'csv',                     // Search query
  limit: 20,                    // Page size (default: 20)
  offset: 0,                    // Pagination offset
});

client.getModule(name)

Get detailed info including available actions.

const mod = await client.getModule('text-toolkit');
console.log(mod.actions);      // [{ name, description, input_schema, output_schema }]
console.log(mod.trust_score);  // 95

client.execute(module, action, input?)

Execute a module action.

const result = await client.execute('hash-toolkit', 'sha256', {
  data: 'hello world'
});
// { execution_id, module, action, status, latency_ms, output }

client.installModule(name) / client.uninstallModule(name)

Install or uninstall a module.

client.getTrustScore(name)

Get trust score breakdown.

const trust = await client.getTrustScore('text-toolkit');
// { module, overall_score, tier, components: { error_rate, uptime, installs, ratings } }

client.rateModule(name, rating, review?) / client.submitModule(module)

Rate a module (1-5 stars) or submit a new module to the marketplace.

Agent Intelligence

client.arm(mission, options?)

Self-equip: describe your mission, get a curated toolkit.

const toolkit = await client.arm(
  'I analyze customer feedback and extract sentiment',
  { max_tools: 10 }
);
// { toolkit: [{ module, action, description, relevance_score }], mission, total_tools }

client.chat(message, conversationId?)

Natural language module discovery.

const reply = await client.chat('I need to process CSV files and send results via email');
// { message, conversation_id, modules_found, proposed_workflow, quick_actions }

Orchestration

client.chain(steps, options?)

Chain actions sequentially. Use {{prev.field}} to reference previous step output.

const pipeline = await client.chain([
  { module: 'text-toolkit', action: 'slug_generate', input: { text: 'My Post' } },
  { module: 'hash-toolkit', action: 'sha256', input: { data: '{{prev.slug}}' } },
]);
// { results: [...], final_output, summary: { total, succeeded, failed } }

client.batch(items, options?)

Execute multiple actions in parallel in a single request.

const results = await client.batch([
  { module: 'text-toolkit', action: 'word_count', input: { text: 'doc1' }, ref: 'a' },
  { module: 'text-toolkit', action: 'word_count', input: { text: 'doc2' }, ref: 'b' },
], { parallel: true });
// { results: [...], summary: { total, succeeded, failed, skipped } }

Skills

client.listSkills(options?) / client.getSkill(id)

Browse and inspect multi-step skills.

const { skills } = await client.listSkills({ category: 'workflow-automation' });
const detail = await client.getSkill(skills[0].id);

client.executeSkill(id, input?)

Execute a skill — runs all its steps in sequence.

const result = await client.executeSkill(skill.id, { topic: 'AI agents' });
// { execution_id, status, results: [...] }

client.createSkill(skill) / client.rateSkill(id, rating, review?)

Create a new skill or rate an existing one.

Memory

client.storeMemory(key, value, options?)

Store cross-session memory (upsert by key + namespace).

await client.storeMemory('user_prefs', { theme: 'dark' }, {
  tags: ['config'],
  namespace: 'settings',
  ttl_seconds: 86400,
});

client.getMemory() / client.listMemories() / client.searchMemories() / client.deleteMemory()

Retrieve, search, and manage memories.

const mem = await client.getMemory('user_prefs', 'settings');
const found = await client.searchMemories('theme', { limit: 5 });
await client.deleteMemory('user_prefs', 'settings');

Certification

// Submit for certification
const { run_id } = await client.submitForCertification('my-module', '1.0.0');

// Poll status
const run = await client.getCertificationRun(run_id);
console.log(run.overall_result); // "certified" | "failed"

// Get detailed checks
const { checks } = await client.getCertificationChecks(run_id);

// Get badge
const badge = await client.getCertificationBadge('my-module');

// Trigger recertification
await client.recertify('my-module');

Account & Billing

// Usage and billing
const billing = await client.getBilling();
// { tenant_id, plan, usage: { executions, modules_installed }, billing: { ... } }

// API key management
const { api_key } = await client.createKey('My Agent');
const { keys } = await client.listKeys();
await client.revokeKey(keyId);

Platform Health

// Platform health (no auth required)
const health = await client.health();
// { status, uptime_percent, modules_available, api_calls_24h }

// Module-specific health
const modHealth = await client.moduleHealth('text-toolkit');

Error Handling

import { JarvisClient, JarvisError } from '@jarvis-sdk/client';

try {
  await client.execute('unknown-module', 'action', {});
} catch (err) {
  if (err instanceof JarvisError) {
    console.log(err.status);  // 404
    console.log(err.type);    // 'not_found'
    console.log(err.detail);  // 'Module not found'
  }
}

← API Reference MCP Integration →