Skip to main content

​
Toolkits

A Toolkit is a collection of related tools that share configuration and can be added to any Agent. RadarOS ships with 18 pre-built toolkits for common integrations so you don’t have to write boilerplate. 
import { Agent, openai, DuckDuckGoToolkit } from "@radaros/core";

const ddg = new DuckDuckGoToolkit();

const agent = new Agent({
  name: "assistant",
  model: openai("gpt-4o"),
  tools: [...ddg.getTools()],  // Spread toolkit tools into the agent
});

​
Available Toolkits

​
Utility (No API Key)

Calculator

Evaluate math expressions safely — arithmetic and Math functions.

File System

Read, write, list, and inspect local files with path sandboxing.

Shell

Execute shell commands with timeout and command allowlisting.

Wikipedia

Search and read Wikipedia articles — no API key required.

DuckDuckGo

Web search and news — no API key required.

Web Search

Tavily or SerpAPI-powered web search with AI-optimized results.

HTTP / REST

Make arbitrary HTTP requests — call any API.

Web Scraper

Extract text content and links from web pages.

Hacker News

Top stories and user details from HN — no API key required.

YouTube

Search videos and extract transcripts/captions.

​
Data

SQL Database

Query SQLite, PostgreSQL, or MySQL databases.

​
Communication

Gmail

Send, search, and read emails via Gmail API.

WhatsApp

Send messages via Meta’s WhatsApp Business Cloud API.

Slack

Send/read messages, list channels, and reply in threads.

​
Project Management & Productivity

GitHub

Repositories, issues, PRs, and file content.

Jira

Search, create, update issues and add comments.

Notion

Search pages, read content, create pages, and query databases.

Google Calendar

List, create, get, and delete calendar events.

​
Quick Reference

ToolkitToolsAuth Required
CalculatorcalculateNone
File Systemfs_read_file, fs_write_file, fs_list_directory, fs_file_infoNone
Shellshell_execNone
Wikipediawikipedia_search, wikipedia_summaryNone
DuckDuckGoduckduckgo_search, duckduckgo_newsNone
Hacker Newshackernews_top_stories, hackernews_userNone
Web Searchweb_searchTavily or SerpAPI key
HTTP / RESThttp_requestDepends on target API
Web Scraperscrape_url, scrape_linksNone
YouTubeyoutube_transcript, youtube_searchYouTube API key (search only)
SQL Databasesql_query, sql_tables, sql_describeDB connection string
Gmailgmail_send, gmail_search, gmail_readGoogle OAuth2
WhatsAppwhatsapp_send_text, whatsapp_send_templateMeta access token
Slackslack_send_message, slack_list_channels, slack_read_messages, slack_reply_threadSlack Bot token
GitHubgithub_search_repos, github_list_issues, github_get_issue, github_create_issue, github_list_prs, github_get_file_contentGitHub token
Jirajira_search_issues, jira_get_issue, jira_create_issue, jira_update_issue, jira_add_commentJira API token
Notionnotion_search, notion_get_page, notion_create_page, notion_query_databaseNotion token
Google Calendarcalendar_list_events, calendar_create_event, calendar_get_event, calendar_delete_eventGoogle OAuth2

​
Using Toolkits

Every toolkit extends the Toolkit base class and exposes a getTools() method that returns ToolDef[]: 
const toolkit = new SomeToolkit({ /* config */ });
const tools = toolkit.getTools();  // ToolDef[]
You can mix toolkit tools with local tools and MCP tools: 
const agent = new Agent({
  tools: [
    ...ddg.getTools(),           // DuckDuckGo toolkit
    ...hn.getTools(),            // Hacker News toolkit
    ...mcpServer.getTools(),     // MCP tools
    myLocalTool,                 // Custom tool
  ],
});

​
Building a Tool Library

Use collectToolkitTools() to combine multiple toolkit instances into a named tool library — useful for the Admin API and dynamic agent creation: 
import { collectToolkitTools, CalculatorToolkit, DuckDuckGoToolkit, GitHubToolkit } from "@radaros/core";

const toolLibrary = collectToolkitTools([
  new CalculatorToolkit(),
  new DuckDuckGoToolkit(),
  new GitHubToolkit({ token: process.env.GITHUB_TOKEN }),
]);
// { calculate: ToolDef, duckduckgo_search: ToolDef, github_list_repos: ToolDef, ... }
Use describeToolLibrary() to get a serializable summary for API responses: 
import { describeToolLibrary } from "@radaros/core";

const descriptions = describeToolLibrary(toolLibrary);
// [{ name: "calculate", description: "...", parameters: ["expression"] }, ...]

​
Toolkit Catalog

RadarOS includes a built-in toolkitCatalog that knows about all 18 toolkit types and their configuration requirements. This powers the Admin UI’s toolkit browser. 
import { toolkitCatalog } from "@radaros/core";

// List all available toolkit types
const all = toolkitCatalog.list();
// [{ id: "github", name: "GitHub", configFields: [...], requiresCredentials: true }, ...]

// Check what a toolkit needs
const github = toolkitCatalog.get("github");
// { id: "github", configFields: [{ name: "token", secret: true, envVar: "GITHUB_TOKEN" }], ... }

// Instantiate from a config object
const tk = toolkitCatalog.create("github", { token: "ghp_..." });
Each catalog entry includes:
FieldDescription
idMachine ID (e.g. "github", "slack")
nameDisplay name (e.g. "GitHub", "Slack")
descriptionWhat the toolkit does
categoryutility, search, api, enterprise, or communication
requiresCredentialsWhether the toolkit needs API keys
configFieldsArray of fields with name, label, type, required, secret, envVar, hint
The @radaros/admin package uses the toolkit catalog to let users configure toolkit credentials from a UI — see Admin: Toolkit Configuration.

​
Creating Custom Toolkits

Extend the Toolkit base class: 
import { Toolkit, defineTool } from "@radaros/core";
import { z } from "zod";

export class MyToolkit extends Toolkit {
  readonly name = "my-toolkit";

  getTools() {
    return [
      defineTool({
        name: "my_tool",
        description: "Does something useful",
        parameters: z.object({ input: z.string() }),
        execute: async (args) => `Result: ${args.input}`,
      }),
    ];
  }
}

​
Registering in the Catalog

To make a custom toolkit available in the admin UI’s toolkit browser, register it in the catalog: 
import { toolkitCatalog } from "@radaros/core";
import { MyToolkit } from "./my-toolkit.js";

toolkitCatalog.register({
  id: "my-toolkit",
  name: "My Toolkit",
  description: "Does useful things",
  category: "utility",
  requiresCredentials: false,
  configFields: [
    { name: "input", label: "Input", type: "string" },
  ],
  factory: (config) => new MyToolkit(config),
});