Getting Started¶

import 'dotenv/config';
import { Agent, Rule, OpenAI } from '@arcaelas/agent';

// Create the provider — no external SDK needed
const provider = new OpenAI({
  api_key: process.env.OPENAI_API_KEY!,
  model: "gpt-4o-mini",
});

// Create the agent
const assistant = new Agent({
  rules: [new Rule("A helpful assistant that answers questions and provides information.")],
  providers: [provider],
});

// Start conversation
async function main() {
  const [messages, success] = await assistant.call("Hello! Can you introduce yourself?");

  if (success) {
    console.log("Assistant:", messages[messages.length - 1].content);
  } else {
    console.log("Failed to get response");
  }
}

main();

import { Agent, Tool, OpenAI } from '@arcaelas/agent';

// Create a simple time tool
const time_tool = new Tool("get_current_time", async (agent) => {
  return new Date().toLocaleString();
});

// Create agent with the tool
const assistant = new Agent({
  rules: [new Rule("Assistant that can tell the current time.")],
  tools: [time_tool],
  providers: [
    new OpenAI({
      api_key: process.env.OPENAI_API_KEY!,
      model: "gpt-4o-mini",
    }),
  ],
});

// Ask for the time
const [messages, success] = await assistant.call("What time is it?");

import { Agent, Rule, OpenAI } from '@arcaelas/agent';

const assistant = new Agent({
  rules: [
    new Rule("Professional customer support agent."),
    new Rule("Always maintain a professional and courteous tone"),
    new Rule("Never share confidential information"),
    new Rule("If unsure, admit it rather than making up information")
  ],
  providers: [
    new OpenAI({ api_key: process.env.OPENAI_API_KEY!, model: "gpt-4o-mini" }),
  ],
});

import { Agent, Rule, OpenAI, Claude, Groq } from '@arcaelas/agent';

const resilient_agent = new Agent({
  rules: [new Rule("High-availability assistant.")],
  providers: [
    // Primary: OpenAI
    new OpenAI({
      api_key: process.env.OPENAI_API_KEY!,
      model: "gpt-4o-mini",
    }),
    // Backup: Anthropic Claude
    new Claude({
      api_key: process.env.ANTHROPIC_API_KEY!,
      model: "claude-haiku-3-5",
    }),
    // Fallback: Groq (ultra-fast)
    new Groq({
      api_key: process.env.GROQ_API_KEY!,
      model: "llama-3.1-8b-instant",
    }),
  ],
});

import { Agent, Context, Metadata, Rule, OpenAI } from '@arcaelas/agent';

// Company-wide base context
const company_context = new Context({
  metadata: new Metadata()
    .set("organization", "Acme Corp")
    .set("compliance", "enterprise"),
  rules: [
    new Rule("Maintain professional communication"),
    new Rule("Protect confidential information")
  ]
});

// Department-specific context
const support_context = new Context({
  context: company_context,  // Inherits from company
  metadata: new Metadata().set("department", "Support"),
  tools: [kb_search_tool, ticket_tool]
});

// Create agent with inherited context
const support_agent = new Agent({
  rules: [new Rule("Customer support specialist.")],
  contexts: support_context,  // Has access to everything
  providers: [
    new OpenAI({ api_key: process.env.OPENAI_API_KEY!, model: "gpt-4o-mini" }),
  ],
});

// Agent automatically has:
// - Company metadata ("organization", "compliance")
// - Department metadata ("department")
// - Company rules + department rules
// - Department tools

import 'dotenv/config';
import { Agent, Tool, Rule, Metadata, OpenAI } from '@arcaelas/agent';

// Create utility tools
const weather_tool = new Tool("get_weather", {
  description: "Get current weather for a city",
  parameters: {
    city: "City name (e.g., 'London', 'New York')"
  },
  func: async (agent, params) => {
    // In production, call a real weather API
    return `Weather in ${params.city}: Sunny, 22°C`;
  }
});

const time_tool = new Tool("get_time", async (agent) => {
  return new Date().toLocaleString();
});

// Create the agent
const assistant = new Agent({
  rules: [
    new Rule("Intelligent assistant with weather and time capabilities."),
    new Rule("Be concise and helpful"),
    new Rule("Use tools when appropriate"),
    new Rule("Admit when you don't know something")
  ],

  metadata: new Metadata()
    .set("version", "1.0")
    .set("environment", "production"),

  tools: [weather_tool, time_tool],

  providers: [
    new OpenAI({
      api_key: process.env.OPENAI_API_KEY!,
      model: "gpt-4o-mini",
    }),
  ],
});

// Interactive conversation loop
async function startChat() {
  const readline = require('readline').createInterface({
    input: process.stdin,
    output: process.stdout
  });

  console.log("Chat started! Type 'exit' to quit.\n");

  const prompt = () => {
    readline.question('You: ', async (input: string) => {
      if (input.toLowerCase() === 'exit') {
        readline.close();
        return;
      }

      const [messages, success] = await assistant.call(input);

      if (success) {
        const response = messages[messages.length - 1].content;
        console.log(`Assistant: ${response}\n`);
      } else {
        console.log("Failed to get response. Try again.\n");
      }

      prompt();
    });
  };

  prompt();
}

startChat();

import { Agent, OpenAI } from '@arcaelas/agent';

const agent = new Agent({
  providers: [new OpenAI({ api_key: process.env.OPENAI_API_KEY!, model: "gpt-4o-mini" })],
});

for await (const chunk of agent.stream("Tell me a short story")) {
  if (chunk.role === "assistant") process.stdout.write(chunk.content);  // text token
  if (chunk.role === "thinking")  process.stdout.write(`[think] ${chunk.content}`); // reasoning
  if (chunk.role === "tool_call") console.log(`\n→ calling ${chunk.name}(${chunk.arguments})`);
  if (chunk.role === "tool")      console.log(`← ${chunk.name}: ${chunk.content}`);
}