Toolkits

Pre-built tool collections for common integrations — web search, email, messaging, databases, and more.

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.

Web & Search

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

Toolkit	Tools	Auth Required
Calculator	calculate	None
File System	fs_read_file, fs_write_file, fs_list_directory, fs_file_info	None
Shell	shell_exec	None
Wikipedia	wikipedia_search, wikipedia_summary	None
DuckDuckGo	duckduckgo_search, duckduckgo_news	None
Hacker News	hackernews_top_stories, hackernews_user	None
Web Search	web_search	Tavily or SerpAPI key
HTTP / REST	http_request	Depends on target API
Web Scraper	scrape_url, scrape_links	None
YouTube	youtube_transcript, youtube_search	YouTube API key (search only)
SQL Database	sql_query, sql_tables, sql_describe	DB connection string
Gmail	gmail_send, gmail_search, gmail_read	Google OAuth2
WhatsApp	whatsapp_send_text, whatsapp_send_template	Meta access token
Slack	slack_send_message, slack_list_channels, slack_read_messages, slack_reply_thread	Slack Bot token
GitHub	github_search_repos, github_list_issues, github_get_issue, github_create_issue, github_list_prs, github_get_file_content	GitHub token
Jira	jira_search_issues, jira_get_issue, jira_create_issue, jira_update_issue, jira_add_comment	Jira API token
Notion	notion_search, notion_get_page, notion_create_page, notion_query_database	Notion token
Google Calendar	calendar_list_events, calendar_create_event, calendar_get_event, calendar_delete_event	Google 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:

Field	Description
id	Machine ID (e.g. "github", "slack")
name	Display name (e.g. "GitHub", "Slack")
description	What the toolkit does
category	utility, search, api, enterprise, or communication
requiresCredentials	Whether the toolkit needs API keys
configFields	Array 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),
});