littleblacky/agenticforge/agenticforge-tools

Tool              — abstract base class: must be extended, implement run() + getParameters()
toolAction        — method decorator: @toolAction(key, description) — NOT a function wrapper
ToolRegistry      — register + execute tools by name
ToolChain         — sequential pipeline with addStep() + execute(registry, input)
AsyncToolExecutor — run multiple tool calls concurrently via executeBatch(requests)

import { Tool, type ToolParameter } from "@agenticforge/tools";
export class WeatherTool extends Tool {
  constructor() {
    super(
      "get-weather",  // name
      "Get current weather for a city. Returns temperature and conditions.",  // description
    );
  }
  getParameters(): ToolParameter[] {
    return [
      { name: "city",  type: "string", description: "City name", required: true,  default: null },
      { name: "units", type: "string", description: "celsius or fahrenheit", required: false, default: "celsius" },
    ];
  }
  async run(parameters: Record<string, unknown>): Promise<string> {
    const city  = String(parameters.city ?? "").trim();
    const units = String(parameters.units ?? "celsius");
    if (!city) return "Error: city is required";
    try {
      // Real implementation here
      return `${city}: 22°${units === "fahrenheit" ? "F" : "C"}, Sunny`;
    } catch (e) {
      return `Error: ${e instanceof Error ? e.message : String(e)}`;
    }
  }
}

import { Tool, toolAction, type ToolParameter } from "@agenticforge/tools";
export class NoteTool extends Tool {
  constructor() {
    super("note", "Create, read, update and delete notes.");
  }
  getParameters(): ToolParameter[] {
    return [
      { name: "action",  type: "string", description: "create|read|update|delete", required: true,  default: null },
      { name: "content", type: "string", description: "Note content",              required: false, default: "" },
    ];
  }
  async run(parameters: Record<string, unknown>): Promise<string> {
    const action = String(parameters.action ?? "");
    if (action === "create") return this.createNote(String(parameters.content ?? ""));
    return `Unknown action: ${action}`;
  }
  @toolAction("note_create", "Create a new note")
  async createNote(content: string): Promise<string> {
    // implementation
    return `Note created: ${content.slice(0, 50)}`;
  }
}

import { ToolRegistry } from "@agenticforge/tools";
const registry = new ToolRegistry();
registry.registerTool(new WeatherTool());
registry.registerTool(new NoteTool());
// Execute by name
const result = await registry.execute("get-weather", { city: "Tokyo" });
// Get OpenAI-compatible schemas for function calling
const schemas = registry.getOpenAISchemas();
// List all registered tools
const names = registry.listTools(); // string[]
// Check existence
if (registry.hasTool("get-weather")) { ... }
// Get tool instance
const tool = registry.getTool("get-weather");

import { ToolChain, ToolRegistry } from "@agenticforge/tools";
const registry = new ToolRegistry();
registry.registerTool(new SearchTool());
registry.registerTool(new SummarizeTool());
// Build the chain step by step
const chain = new ToolChain("research-chain", "Search then summarize");
chain.addStep("search",    "{input}",         "search_result");  // search tool → stored as search_result
chain.addStep("summarize", "{search_result}",  "summary");        // summarize tool → stored as summary
// Execute: returns the last step's output
const result = await chain.execute(registry, "AgenticFORGE latest release");
console.log(result); // summary output

import { ToolChain, ToolChainManager, ToolRegistry } from "@agenticforge/tools";
const registry = new ToolRegistry();
registry.registerTool(new SearchTool());
const manager = new ToolChainManager(registry);
const chain = new ToolChain("my-chain", "Research pipeline");
chain.addStep("search", "{input}", "result");
manager.registerChain(chain);
const output = await manager.executeChain("my-chain", "AI trends");

import { AsyncToolExecutor, ToolRegistry, type ToolCallRequest } from "@agenticforge/tools";
const registry = new ToolRegistry();
registry.registerTool(new WeatherTool());
registry.registerTool(new SearchTool());
const executor = new AsyncToolExecutor(registry, 4); // 4 = max concurrency
const requests: ToolCallRequest[] = [
  { id: "r1", toolName: "get-weather", parameters: { city: "Tokyo" } },
  { id: "r2", toolName: "get-weather", parameters: { city: "London" } },
  { id: "r3", toolName: "search",      parameters: { input: "AI news" } },
];
const results = await executor.executeBatch(requests);
for (const r of results) {
  console.log(r.toolName, r.output, r.durationMs);
  if (r.error) console.error(r.error);
}
// Execute a single call
const single = await executor.executeSingle({ id: "r4", toolName: "get-weather", parameters: { city: "Paris" } });

async run(parameters: Record<string, unknown>): Promise<string> {
  const url = String(parameters.url ?? "");
  try {
    const res = await fetch(url);
    if (!res.ok) return `Error: HTTP ${res.status}`;
    return await res.text();
  } catch (e) {
    return `Error: ${e instanceof Error ? e.message : String(e)}`;
  }
}