Built-in Tools

import { LlmAgent, GoogleSearchTool, HttpRequestTool } from "@iqai/adk";

const agent = new LlmAgent({
  name: "research_agent",
  description:
    "An agent that helps users research topics using web search and HTTP requests",
  instruction: "Help users research topics using web search and HTTP requests",
  tools: [new GoogleSearchTool(), new HttpRequestTool()],
});

import { GoogleSearchTool } from "@iqai/adk";

const agent = new LlmAgent({
  name: "research_agent",
  description: "A research assistant that searches the web for information",
  tools: [new GoogleSearchTool()],
});

GOOGLE_API_KEY=your_api_key_here
GOOGLE_CSE_ID=your_search_engine_id

// User: "What are the latest updates about AI in 2024?"
// Agent automatically calls:
// google_search({ query: "latest AI updates 2024", numResults: 5 })
// Agent receives search results and summarizes them

{
  success: boolean;
  results?: Array<{
    title: string;
    link: string;
    snippet: string;
  }>;
  error?: string;
}

import { WebSearchTool } from "@iqai/adk";

const agent = new LlmAgent({
  name: "research_agent",
  description: "A research assistant with advanced web search",
  tools: [new WebSearchTool()],
});

TAVILY_API_KEY=your_tavily_api_key_here

// User: "Find recent news about renewable energy"
// Agent calls:
// web_search({
//   query: "renewable energy news",
//   topic: "news",
//   timeRange: "week",
//   maxResults: 10
// })

{
  success: boolean;
  data?: {
    query: string;
    results: Array<{
      title: string;
      url: string;
      content: string;
      raw_content?: string;
      favicon?: string;
      score?: number;
    }>;
    answer?: string;
    images?: Array<{
      url: string;
      description?: string;
    }>;
    response_time: number;
    usage?: Record<string, string>;
    request_id?: string;
  };
  error?: string;
}

import { WebFetchTool } from "@iqai/adk";

const agent = new LlmAgent({
  name: "web_reader_agent",
  description: "An agent that fetches and analyzes web page content",
  tools: [new WebFetchTool()],
});

// User: "What's on the React documentation homepage?"
// Agent calls:
// web_fetch({ url: "https://react.dev" })
// Returns parsed content with title and cleaned text

{
  success: boolean;
  data?: {
    title: string;
    content: string;
    metadata: {
      contentType: string;
      url: string;
    };
  };
  error?: string;
}

import { HttpRequestTool } from "@iqai/adk";

const agent = new LlmAgent({
  name: "api_agent",
  description: "An agent that integrates with external APIs and services",
  tools: [new HttpRequestTool()],
});

// User: "Get the weather from the API"
// Agent calls:
// http_request({
//   url: "https://api.weather.com/forecast",
//   method: "GET",
//   params: { city: "london" },
//   headers: { "Authorization": "Bearer YOUR_API_KEY" }
// })

import { ReadTool } from "@iqai/adk";

const agent = new LlmAgent({
  name: "file_reader_agent",
  description: "An agent that reads and analyzes file contents",
  tools: [new ReadTool()],
});

// User: "Read the contents of config.json"
// Agent calls:
// read_file({ path: "config.json" })
// Agent receives file contents and can analyze or respond

{
  success: boolean;
  data?: string; // File contents
  error?: string;
}

import { WriteTool } from "@iqai/adk";

const agent = new LlmAgent({
  name: "file_writer_agent",
  description: "An agent that creates new files",
  tools: [new WriteTool()],
});

// User: "Create a README.md file with project description"
// Agent calls:
// write_file({
//   path: "README.md",
//   content: "# My Project\n\nDescription here..."
// })

{
  success: boolean;
  data?: string; // Success message
  error?: string;
}

import { EditTool } from "@iqai/adk";

const agent = new LlmAgent({
  name: "file_editor_agent",
  description: "An agent that edits existing files precisely",
  tools: [new EditTool()],
});

// User: "Change the port from 3000 to 8080 in server.js"
// Agent calls:
// edit_file({
//   path: "server.js",
//   old_str: "const PORT = 3000;",
//   new_str: "const PORT = 8080;"
// })

{
  success: boolean;
  data?: string; // Preview of changes
  error?: string;
}

<<<<<< OLD
const PORT = 3000;
======
const PORT = 8080;
>>>>>> NEW

import { GlobTool } from "@iqai/adk";

const agent = new LlmAgent({
  name: "file_finder_agent",
  description: "An agent that finds files matching patterns",
  tools: [new GlobTool()],
});

// User: "Find all TypeScript files in the src directory"
// Agent calls:
// glob({ pattern: "src/**/*.ts" })
// Returns: ["src/index.ts", "src/utils/helper.ts", ...]

{
  success: boolean;
  data?: string[]; // Array of matching file paths
  error?: string;
}

import { GrepTool } from "@iqai/adk";

const agent = new LlmAgent({
  name: "code_search_agent",
  description: "An agent that searches through code for patterns",
  tools: [new GrepTool()],
});

// With custom configuration:
const customAgent = new LlmAgent({
  name: "custom_search_agent",
  description: "Custom search configuration",
  tools: [
    new GrepTool({
      maxMatches: 1000,
      maxFileSize: 5 * 1024 * 1024, // 5MB
      contextLines: 3,
      excludePatterns: ["**/custom-exclude/**"],
      includePatterns: ["**/*.custom"],
    }),
  ],
});

// User: "Find all TODO comments in TypeScript files"
// Agent calls:
// grep({
//   pattern: "TODO:",
//   files: "**/*.ts",
//   caseInsensitive: true,
//   contextLines: 2
// })

{
  success: boolean;
  matches: Array<{
    file: string;
    line: number;
    column: number;
    content: string;
    context?: {
      before: string[];
      after: string[];
    };
  }>;
  stats: {
    filesSearched: number;
    filesMatched: number;
    totalMatches: number;
    limitReached: boolean;
    duration: number; // milliseconds
  };
  error?: string;
  warnings?: string[];
}

import { FileOperationsTool } from "@iqai/adk";

const agent = new LlmAgent({
  name: "file_agent",
  description: "An agent that manages file operations on the local filesystem",
  tools: [new FileOperationsTool()],
});

// With custom base path for security:
const restrictedAgent = new LlmAgent({
  name: "restricted_file_agent",
  description: "An agent with restricted file access",
  tools: [
    new FileOperationsTool({
      basePath: "/safe/directory",
    }),
  ],
});

// User: "Read config.json"
// file_operations({ operation: "read", filepath: "config.json" })

// User: "Save data to output.txt"
// file_operations({ operation: "write", filepath: "output.txt", content: "data" })

// User: "What's in the data folder?"
// file_operations({ operation: "list", filepath: "data" })

{
  success: boolean;
  data?: any; // Varies by operation
  error?: string;
}

import { BashTool } from "@iqai/adk";

// Whitelist mode (safest for production):
const agent = new LlmAgent({
  name: "command_executor_agent",
  description: "An agent that executes safe terminal commands",
  tools: [
    new BashTool({
      enabled: true,
      mode: "whitelist",
      allowedCommands: ["ls", "pwd", "cat", "node --version"],
      maxTimeout: 30000,
    }),
  ],
});

// Sandboxed mode (Docker-based isolation):
const sandboxedAgent = new LlmAgent({
  name: "sandboxed_agent",
  description: "An agent with Docker-sandboxed command execution",
  tools: [
    new BashTool({
      enabled: true,
      mode: "sandboxed",
      dockerImage: "alpine:latest",
    }),
  ],
});

// User: "What files are in the current directory?"
// Agent calls:
// bash({ command: "ls -la" })

// User: "Check the Node.js version"
// Agent calls:
// bash({ command: "node --version" })

{
  exit_code: number | null;
  stdout: string;
  stderr: string;
  blocked?: boolean;
  reason?: string;
}

import { UserInteractionTool } from "@iqai/adk";

const agent = new LlmAgent({
  name: "approval_agent",
  description: "An agent that handles user approvals and confirmations",
  tools: [new UserInteractionTool()],
});

// User: "I want to delete my account"
// Agent internally decides it needs confirmation:
// user_interaction({
//   prompt: "Are you absolutely sure you want to delete your account? This cannot be undone.",
//   options: ["Yes, delete it", "No, keep it"]
// })

// User sees numbered options and selects one
// Agent receives the user's choice and proceeds

{
  success: boolean;
  userInput?: string;
  error?: string;
}

import { GetUserChoiceTool } from "@iqai/adk";

const agent = new LlmAgent({
  name: "choice_agent",
  description: "An agent that presents options and collects user selections",
  tools: [new GetUserChoiceTool()],
});

// User: "I want to choose a subscription plan"
// Agent calls:
// get_user_choice({
//   question: "Which plan would you like?",
//   options: ["Basic - $9/month", "Pro - $29/month", "Enterprise - $99/month"]
// })

// User sees numbered options and selects one
// Agent receives the selected option and proceeds

import { LoadMemoryTool } from "@iqai/adk";

const agent = new LlmAgent({
  name: "context_agent",
  description: "An agent that maintains context across conversations",
  tools: [new LoadMemoryTool()],
});

// User: "What did I ask you about last time?"
// Agent calls:
// load_memory({ query: "previous conversation topics" })
// Agent retrieves relevant memories and responds

// User: "I have that preference set, right?"
// Agent calls:
// load_memory({ query: "user preferences" })
// Agent confirms based on retrieved memory

import { LoadArtifactsTool } from "@iqai/adk";

const agent = new LlmAgent({
  name: "document_analyzer_agent",
  description: "An agent that analyzes and processes uploaded documents",
  tools: [new LoadArtifactsTool()],
});

// User uploads files and asks: "Analyze my resume"
// Agent calls:
// load_artifacts({ artifact_names: ["resume.pdf"] })
// Agent retrieves and analyzes the resume

// User: "What's in the contract?"
// Agent calls:
// load_artifacts({ artifact_names: ["contract.pdf"] })
// Agent reads and analyzes the contract

import { TransferToAgentTool } from "@iqai/adk";

const agent = new LlmAgent({
  name: "router_agent",
  description: "An agent that routes requests to specialized agents",
  tools: [new TransferToAgentTool()],
});

// User: "I need help with my payment"
// Router agent recognizes this is a payment issue:
// transfer_to_agent({ agent_name: "payment_specialist_agent" })
// Control transfers to the payment specialist

// User: "Can you check my order status?"
// Router agent calls:
// transfer_to_agent({ agent_name: "order_tracking_agent" })
// Control transfers to the order tracking agent

import { ExitLoopTool } from "@iqai/adk";

const agent = new LlmAgent({
  name: "loop_agent",
  description: "An agent that processes items in loops with exit control",
  tools: [new ExitLoopTool()],
});

// Agent is processing items in a loop
// When instructed to exit, agent calls:
// exit_loop()
// Loop execution terminates and control returns to parent workflow

// Example workflow:
// Agent: Processing item 1... done
// Agent: Processing item 2... done
// Agent: Processing item 3... done
// Agent: All items processed, calling exit_loop()
// Workflow exits loop successfully

const researchAgent = new LlmAgent({
  name: "researcher_agent",
  description:
    "A research assistant that searches the web for current information and recalls relevant details from previous conversations",
  instruction:
    "Use web search to find current information, then check memory for related previous discussions",
  tools: [new GoogleSearchTool(), new LoadMemoryTool()],
});

const documentAgent = new LlmAgent({
  name: "document_processor_agent",
  description:
    "An agent that analyzes uploaded documents and saves processed results",
  instruction:
    "Load and analyze uploaded documents, then save findings and summaries to files",
  tools: [
    new LoadArtifactsTool(),
    new FileOperationsTool({ basePath: "/output" }),
  ],
});

const apiAgent = new LlmAgent({
  name: "api_integration_agent",
  description: "An agent that calls external APIs and processes responses",
  instruction:
    "Make API calls to retrieve data, process responses, and save relevant information",
  tools: [new HttpRequestTool(), new FileOperationsTool()],
});

const interactiveAgent = new LlmAgent({
  name: "interactive_workflow_agent",
  description: "An agent that guides users through multi-step processes",
  instruction:
    "Interact with users to gather requirements and approvals, then perform file operations based on their input",
  tools: [new UserInteractionTool(), new FileOperationsTool()],
});

const codeAgent = new LlmAgent({
  name: "code_assistant_agent",
  description: "An agent that analyzes and modifies code files",
  instruction:
    "Search for code patterns, analyze files, and make precise edits as requested",
  tools: [new GrepTool(), new ReadTool(), new EditTool()],
});