Tools - Jade SDK

The Jade SDK includes a registry of tools that the AI can use. This reference documents all available tools and how to work with them.

Tool Categories

Tools are organized into categories:

Category	Description
`generation`	Create new media (images, videos, audio)
`processing`	Transform existing media
`utility`	Helper functions
`system`	Internal system tools

Generation Tools

mcpjadegenerative_image

Generate images from text prompts.

// Input
{
  prompt: string;           // Description of the image
  aspect_ratio?: string;    // "1:1", "16:9", "9:16", "4:3", "3:4"
  model?: string;           // "flux-1.1-pro" (default), etc.
  style?: string;           // Style preset
}

// Result
{
  url: string;              // Generated image URL
  model: string;            // Model used
  prompt: string;           // Original prompt
}

Display: Image icon, “Generative Image” title

mcpjadegenerative_video

Generate videos from text or images.

// Input
{
  prompt: string;           // Description of the video
  aspect_ratio?: string;    // "16:9", "9:16", "1:1"
  duration?: number;        // Duration in seconds
  image_url?: string;       // Starting image (optional)
}

// Result
{
  url: string;              // Generated video URL
  model: string;            // Model used
}

Display: Video icon, “Generative Video” title

mcpjadegenerative_audio

Generate audio from text.

// Input (Narration)
{
  mode: 'narration';
  text: string;             // Text to narrate
  voice?: string;           // Voice preset
}

// Input (Sound Effects)
{
  mode: 'sound_effects';
  prompt: string;           // Description of sound
  duration?: number;        // Duration in seconds
}

// Input (Music)
{
  mode: 'music';
  prompt: string;           // Description of music
  duration?: number;        // Duration in seconds
}

// Result
{
  url: string;              // Generated audio URL
  mode: string;             // Mode used
}

Display: Different icons based on mode (Mic, Waveform, Music)

mcpjadegenerative_character

Create character images with consistent style.

// Input
{
  prompt: string;           // Character description
  reference_images?: string[]; // Reference images
}

// Result
{
  url: string;              // Generated character image
}

Processing Tools

mcpjadebackground_removal

Remove backgrounds from images.

// Input
{
  image_url: string;        // Image to process
}

// Result
{
  url: string;              // Processed image URL
}

Display: Eraser icon, “Background Removal” title

mcpjadeupscale

Upscale images to higher resolution.

// Input
{
  image_url: string;        // Image to upscale
  scale?: number;           // Scale factor (2, 4)
}

// Result
{
  url: string;              // Upscaled image URL
}

Display: Maximize icon, “Upscale” title

mcpjadecaptions_highlights

Add captions to videos.

// Input
{
  video_url: string;        // Video to caption
  style?: string;           // Caption style
}

// Result
{
  url: string;              // Captioned video URL
}

Utility Tools

mcpjadeimport_media

Import external media URLs.

// Input
{
  urls: string[];           // URLs to import
}

// Result
{
  imported: string[];       // Imported URLs
}

mcpjaderequest_status

Check the status of a pending request.

// Input
{
  request_id: string;       // Request to check
}

// Result
{
  status: 'pending' | 'processing' | 'complete' | 'failed';
  progress?: number;        // 0-100
  result?: unknown;         // Result if complete
}

Using the Tool Registry

Get Tool Definition

import { getToolDefinition, TOOL_REGISTRY } from '@gr33n-ai/jade-sdk-client';

const tool = getToolDefinition('mcp__jade__generative_image');
console.log(tool?.displayName); // "Generative Image"
console.log(tool?.iconName);    // "Image"
console.log(tool?.category);    // "generation"

Get Tool Icon

import { getToolIconName } from '@gr33n-ai/jade-sdk-client';

// Basic icon
const icon = getToolIconName('mcp__jade__generative_image');
// "Image"

// Dynamic icon (e.g., audio mode)
const icon = getToolIconName('mcp__jade__generative_audio', { mode: 'music' });
// "Music"

All Registered Tools

import { TOOL_REGISTRY } from '@gr33n-ai/jade-sdk-client';

Object.entries(TOOL_REGISTRY).forEach(([name, def]) => {
  console.log(`${name}: ${def.displayName} (${def.category})`);
});

Tool Display in ProcessedEntry

When a tool is used, ProcessedEntry includes parsed data:

const entry: ProcessedEntry = {
  originalType: 'tool_call',
  displayType: 'generative_image',
  iconName: 'Image',
  title: 'Generative Image',

  toolDefinition: {
    name: 'mcp__jade__generative_image',
    displayName: 'Generative Image',
    // ...
  },

  parsedInput: {
    type: 'generative_image',
    data: {
      prompt: 'A sunset over mountains',
      aspect_ratio: '16:9',
    },
  },

  parsedResult: {
    type: 'media',
    data: {
      urls: ['https://cdn.jade.gr33n.ai/...'],
    },
  },

  mediaUrls: ['https://cdn.jade.gr33n.ai/...'],
};

Custom Tool UI

Build tool-specific UI based on displayType:

function ToolDisplay({ entry }: { entry: ProcessedEntry }) {
  switch (entry.displayType) {
    case 'generative_image':
      return <ImageGeneration entry={entry} />;

    case 'generative_video':
      return <VideoGeneration entry={entry} />;

    case 'generative_audio':
      return <AudioGeneration entry={entry} />;

    case 'background_removal':
      return <ImageProcessing entry={entry} />;

    default:
      return <GenericTool entry={entry} />;
  }
}

function ImageGeneration({ entry }: { entry: ProcessedEntry }) {
  const prompt = entry.parsedInput?.data?.prompt;
  const imageUrl = entry.mediaUrls?.[0];

  return (
    <div className="image-generation">
      <h4>{entry.title}</h4>
      {prompt && <p className="prompt">{prompt}</p>}
      {imageUrl && <img src={imageUrl} alt={prompt || ''} />}
    </div>
  );
}

System Tools

These tools are used internally and typically filtered from display:

Tool	Purpose
`Skill`	Skill context loading
`Bash`	Command execution
`TodoWrite`	Task management
`Read`	File reading
`Glob`	File pattern matching
`WebSearch`	Web searching
`Edit`	File editing
`Write`	File writing
`WebFetch`	URL fetching

System tools have category: 'system' and are handled specially by the SDK.

ProcessedEntry - Entry structure
Types Reference - Type definitions
Custom Tool UI Example - Building tool UIs

​Tool Categories

​Generation Tools

​mcp__jade__generative_image

​mcp__jade__generative_video

​mcp__jade__generative_audio

​mcp__jade__generative_character

​Processing Tools

​mcp__jade__background_removal

​mcp__jade__upscale

​mcp__jade__captions_highlights

​Utility Tools

​mcp__jade__import_media

​mcp__jade__request_status

​Using the Tool Registry

​Get Tool Definition

​Get Tool Icon

​All Registered Tools

​Tool Display in ProcessedEntry

​Custom Tool UI

​System Tools

​Related