littleblacky/agenticforge/agenticforge-agents

import "dotenv/config";
import { SimpleAgent, LLMClient } from "@agenticforge/kit";
const agent = new SimpleAgent({
  llm: new LLMClient({ provider: "openai", model: "gpt-4o" }),
  systemPrompt: "You are a concise technical writer. Answer in 2-3 sentences.",
});
// History is automatically tracked between calls
const r1 = await agent.run("What is RAG?");
const r2 = await agent.run("Give me a code example."); // knows context from r1
agent.clearHistory(); // reset when session ends

import "dotenv/config";
import { FunctionCallAgent, LLMClient } from "@agenticforge/kit";
import { Tool, type ToolParameter } from "@agenticforge/tools";
// Extend Tool — required, Tool is abstract
class CalculatorTool extends Tool {
  constructor() {
    super("calculator", "Evaluate a math expression. Returns the numeric result as string.");
  }
  getParameters(): ToolParameter[] {
    return [{ name: "expr", type: "string", description: "Math expression to evaluate", required: true, default: null }];
  }
  async run(params: Record<string, unknown>): Promise<string> {
    try {
      return String(eval(String(params.expr ?? ""))); // use a safe math library in production
    } catch (e) {
      return `Error: ${e instanceof Error ? e.message : String(e)}`;
    }
  }
}
const agent = new FunctionCallAgent({
  llm: new LLMClient({ provider: "openai", model: "gpt-4o" }),
  tools: [new CalculatorTool()],
  maxIterations: 10,
  systemPrompt: "You are a helpful math assistant.",
});
const result = await agent.run("What is (123 + 456) * 789?");
console.log(result);

import { ReActAgent, LLMClient } from "@agenticforge/kit";
const agent = new ReActAgent({
  llm: new LLMClient({ provider: "openai", model: "gpt-4o" }),
  tools: [new SearchTool(), new CalculatorTool()],
  maxIterations: 15,
});
// ReAct outputs: Thought → Action → Observation → ... → Answer
const result = await agent.run(
  "What is the GDP of Japan divided by its population? Show your reasoning."
);

import { PlanSolveAgent, LLMClient } from "@agenticforge/kit";
const agent = new PlanSolveAgent({
  llm: new LLMClient({ provider: "openai", model: "gpt-4o" }),
  tools: [new SearchTool(), new NoteTool()],
  // Note: makes 2 LLM calls per run — plan call + execute call
});
const result = await agent.run(
  "Research and write a 500-word report on the current state of AI regulation in the EU."
);

import { ReflectionAgent, LLMClient } from "@agenticforge/kit";
const agent = new ReflectionAgent({
  llm: new LLMClient({ provider: "openai", model: "gpt-4o" }),
  reflectionRounds: 2, // 1 generate + 2 critique-refine cycles
});
const result = await agent.run(
  "Write a compelling product description for an AI code editor."
);

import { SkillAgent } from "@agenticforge/agents";
import { SkillLoader } from "@agenticforge/skills";
import { LLMClient } from "@agenticforge/core";
const llm = new LLMClient({ provider: "openai", model: "gpt-4o" });
const mdSkills = await SkillLoader.fromDirectory(".cursor/skills");
const agent = new SkillAgent({
  name: "my-assistant",
  llm,
  skills: [...mdSkills],
});
const reply = await agent.run("What is Apple's stock price?");
const result = await agent.runSkill("stock-query", "AAPL price?"); // bypass routing

import "dotenv/config";
import { WorkflowAgent, LLMClient } from "@agenticforge/kit";
import type { WorkflowDefinition } from "@agenticforge/workflow";
import { ToolRegistry } from "@agenticforge/tools";
// Register Tool subclass instances for type:"tool" nodes
const registry = new ToolRegistry();
registry.registerTool(new SearchTool()); // SearchTool extends Tool
const agent = new WorkflowAgent({
  name: "report-workflow",   // required
  llm: new LLMClient({ provider: "openai", model: "gpt-4o" }),
  registry,                  // required for type:"tool" nodes
  verbose: true,             // log execution waves
  maxConcurrency: 4,         // max concurrent nodes per wave (default: unlimited)
});
// --- Linear pipeline ---
const linear: WorkflowDefinition = {
  name: "research-report",
  nodes: [
    { id: "fetch",   type: "tool", toolName: "search", inputTemplate: "{input}",          depends: [] },
    { id: "analyze", type: "llm",  promptTemplate: "Analyze:\n{fetch}",                   depends: ["fetch"] },
    { id: "report",  type: "llm",  promptTemplate: "Write a report based on:\n{analyze}", depends: ["analyze"] },
  ],
};
// --- Concurrent fan-out / fan-in ---
const fanOut: WorkflowDefinition = {
  name: "bilingual-report",
  nodes: [
    { id: "fetch",     type: "tool", toolName: "search", inputTemplate: "{input}",                  depends: [] },
    { id: "analyze",   type: "llm",  promptTemplate: "Analyze:\n{fetch}",                           depends: ["fetch"] },
    { id: "translate", type: "llm",  promptTemplate: "Translate to Chinese:\n{fetch}",              depends: ["fetch"] },
    { id: "report",    type: "llm",  promptTemplate: "Bilingual report:\n{analyze}\n\n{translate}", depends: ["analyze", "translate"] },
  ],
};
// --- Custom fn node ---
const withFn: WorkflowDefinition = {
  name: "custom-merge",
  nodes: [
    { id: "part1", type: "llm", promptTemplate: "Describe pros of {input}", depends: [] },
    { id: "part2", type: "llm", promptTemplate: "Describe cons of {input}", depends: [] },
    {
      id: "merge", type: "fn", depends: ["part1", "part2"],
      executor: async (ctx) => `Pros:\n${ctx.part1}\n\nCons:\n${ctx.part2}`,
    },
  ],
};
// runWorkflow → returns full result with per-node timing
const result = await agent.runWorkflow(fanOut, "State of AI in 2024");
console.log(result.output);
console.log(result.nodeResults); // [{ nodeId, status, output, durationMs }]
// setWorkflow + run → integrates with Agent base class interface
agent.setWorkflow(linear);
const output = await agent.run("2024 AI trends");