Agent

import { Agent } from 'praisonai';

const agent = new Agent({
  instructions: "You are a helpful AI assistant that provides concise answers."
});

const response = await agent.chat("What is the capital of France?");
console.log(response); // "Paris is the capital of France."

const agent = new Agent({
  name: "ResearchBot",
  instructions: "You are a research assistant specializing in scientific topics."
});

const agent = new Agent({
  instructions: "You are helpful",
  llm: "claude-3-5-sonnet-latest"  // or "gpt-4o", "gemini-2.0-flash", etc.
});

// Only ANTHROPIC_API_KEY is set → uses anthropic/claude-3-5-sonnet-latest
const agent = new Agent({ instructions: "You are helpful" });

// Only GEMINI_API_KEY is set → uses gemini/gemini-1.5-flash
const gemini = new Agent({ instructions: "You are helpful" });

// Only OLLAMA_HOST is set → uses ollama/llama3.2 (runs locally, no cloud key)
const local = new Agent({ instructions: "You are helpful" });

import { Agent } from 'praisonai';

// Define a simple tool function
const getWeather = (city: string) => `Weather in ${city}: 22°C, Sunny`;

const agent = new Agent({
  instructions: "You are a weather assistant. Use the getWeather tool to answer weather questions.",
  tools: [getWeather]
});

const response = await agent.chat("What's the weather in Paris?");
console.log(response); // Uses the tool and responds with weather info

const getWeather = (city: string) => `Weather in ${city}: 22°C`;
const getTime = (timezone: string) => `Current time in ${timezone}: 14:30`;
const calculate = (expression: string) => eval(expression).toString();

const agent = new Agent({
  instructions: "You can check weather, time, and do calculations.",
  tools: [getWeather, getTime, calculate]
});

import { Agent, db } from 'praisonai';

const agent = new Agent({
  instructions: "You are a helpful assistant with memory.",
  db: db("sqlite:./conversations.db"),
  sessionId: "user-123"
});

// Conversations are automatically persisted
await agent.chat("My name is Alice");
await agent.chat("What's my name?"); // Remembers: "Your name is Alice"

// SQLite — durable, survives restarts (recommended)
db("sqlite:./data.db")
db("sqlite::memory:")   // real SQLite, but process-local

// In-memory (default) — lost on exit
db("memory:")
db(":memory:")

// PostgreSQL / Redis — throw today (remote-only transports, not session stores)
db("postgres://user:pass@host:5432/dbname")
db("redis://localhost:6379")

interface SimpleAgentConfig {
  // Required
  instructions: string;           // System prompt / agent instructions

  // Optional - Identity
  name?: string;                  // Agent name (auto-generated if not provided)

  // Optional - LLM
  llm?: string;                   // Model: "gpt-4o-mini", "claude-3-sonnet", etc.

  // Optional - Credentials & transport
  apiKey?: string;                // Per-agent API key; falls back to *_API_KEY env var
  baseURL?: string;               // Custom endpoint (OpenAI-compatible proxies etc.)
  fetch?: typeof fetch;           // Custom fetch (Tauri / native bridge); implies browser support

  // Optional - Behavior
  verbose?: boolean;              // Enable logging (default: true)
  pretty?: boolean;               // Pretty output formatting
  markdown?: boolean;             // Markdown in responses (default: true)
  stream?: boolean;               // Streaming responses (default: true)

  // Optional - Tools
  tools?: Function[];             // Array of tool functions
  toolFunctions?: Record<string, Function>;  // Named tool implementations
  maxIterations?: number;         // Max tool-call round-trips before the loop aborts (default: 20)
  maxToolCallsPerTurn?: number;   // Max tool calls executed per round (default: 10)

  // Optional - Structured output (works on every provider)
  outputSchema?: Record<string, any>;  // JSON Schema for structured output
  outputSchemaName?: string;           // Schema name (default: "response")

  // Optional - Persistence
  db?: DbAdapter;                 // Database adapter for persistence
  sessionId?: string;             // Session ID (auto-generated if not provided)
  runId?: string;                 // Run ID for tracing

  // Optional - Advanced Mode (role/goal/backstory) — stored as readable fields
  role?: string;                  // Agent role (default: "Assistant")
  goal?: string;                  // Agent goal (default: instructions, else "Help the user with their tasks")
  backstory?: string;             // Agent backstory (default: instructions, else "I am an AI assistant")
}

import { Agent } from 'praisonai';

const agent = new Agent({
  name: "Researcher",
  instructions: "Answer questions using the available tools.",
  tools: [search, fetchUrl],
  maxIterations: 30,          // default is 20
  maxToolCallsPerTurn: 5,     // default is 10
});

const answer = await agent.chat("Summarise today's top AI story.");

import type {
  AgentEvent,
  AgentStreamOptions,
  AgentChatCallOptions,  // new — chat() with errorsAsNull
  AgentExecuteTask,      // new — execute() first-argument union
  AgentTaskLike,         // new — duck-type: { description?: string, ... }
} from 'praisonai';

import { Agent } from 'praisonai';

const agent = new Agent({
  instructions: "Use my local model",
  llm: "local-llama",
  apiKey: "not-needed",
  baseURL: "http://localhost:1234/v1",  // LM Studio, vLLM, etc.
});

const agent = new Agent({
  role: "Senior Research Analyst",
  goal: "Analyze market trends and provide investment insights",
  backstory: "You have 20 years of experience in financial markets..."
});

// Equivalent to:
const agent2 = new Agent({
  instructions: `You are a Senior Research Analyst.
Your goal is: Analyze market trends and provide investment insights
Background: You have 20 years of experience in financial markets...`
});

const agent = new Agent({ role: "Support Specialist", goal: "Resolve customer tickets" });

console.log(agent.role);      // "Support Specialist"
console.log(agent.goal);      // "Resolve customer tickets"
console.log(agent.backstory); // "I am an AI assistant" (default)

// ✅ mobile / webview bundle
import { Agent } from 'praisonai/mobile';

const agent = new Agent({
  instructions: "You are helpful",
  sessionId: "custom-session-id"
});

// Get session and run IDs
console.log(agent.getSessionId()); // "custom-session-id"
console.log(agent.getRunId());     // Auto-generated UUID

const response = await agent.chat("Hello!");

// With a Stop button:
const controller = new AbortController();
await agent.chat("Write an essay", undefined, controller.signal);

const result: string | null = await agent.chat(
  "Hello!",
  undefined,
  undefined,
  { errorsAsNull: true },
);

if (result === null) {
  // the turn failed; the error was still logged via Logger.error
}

import { Agent } from 'praisonai';

const agent = new Agent({ instructions: "Write a haiku about the ocean" });
await agent.start(); // uses instructions as the prompt

const response = await agent.start("Begin the task");

import { Agent } from 'praisonai';

const agent = new Agent({ instructions: "You are a research assistant" });

// A string runs as the task
await agent.execute("Summarise the Q3 revenue report.");

// A task-like object is read through `description`
await agent.execute({ description: "Write the release notes." });

// A real Task instance also works
import { Task } from 'praisonai';
const task = new Task({ name: "research", description: "…", expected_output: "…" });
await agent.execute(task);

// Chain prior output — substituted for {{previous}} in the prompt
await agent.execute("Improve this draft: {{previous}}", "the rough draft");

// An array of dependency results is joined with blank lines
await agent.execute("Merge: {{previous}}", ["result A", "result B"]);

// No task → runs the agent's own instructions (unchanged)
await agent.execute();

const agent = new Agent({ instructions: "You are helpful" });

agent.getResult(); // null

await agent.chat("Hello!");
agent.getResult(); // "Hi, how can I help?"

import { Agent, type AgentMessage } from 'praisonai';

const agent = new Agent({ instructions: 'You are helpful' });
await agent.chat('My name is Alice');

const saved: AgentMessage[] = agent.getHistory();  // persist this
// … later …
const restored = new Agent({ instructions: 'You are helpful' });
restored.setHistory(saved);
await restored.chat('What is my name?');           // "Your name is Alice"

import { Agent } from 'praisonai';
import type { StopReason } from 'praisonai';

const agent = new Agent({ instructions: 'You are helpful', tools: [search] });

try {
  await agent.chat('Do a hard task');
  console.log(agent.lastStopReason); // 'completed'
} catch (err) {
  console.log(agent.lastStopReason); // 'max_steps' or 'error'
}

for await (const token of agent.stream("Tell me a story")) {
  process.stdout.write(token);
}

for await (const event of agent.streamEvents("Hi")) {
  if (event.type === 'text') process.stdout.write(event.delta);
}

# Model selection — override the provider-aware default (see Default model above)
OPENAI_MODEL_NAME=gpt-4o
PRAISONAI_MODEL=gpt-4o

# Behavior
PRAISON_VERBOSE=true
PRAISON_PRETTY=true

# API Keys
OPENAI_API_KEY=sk-...
ANTHROPIC_API_KEY=sk-ant-...
GOOGLE_API_KEY=...

const researcher = new Agent({
  name: "Researcher",
  instructions: `You are a research assistant. 
  - Search for information on topics
  - Summarize findings concisely
  - Cite sources when possible`,
  llm: "gpt-4o"
});

const findings = await researcher.chat("Research the latest AI developments in 2024");

const coder = new Agent({
  name: "CodeHelper",
  instructions: `You are a coding assistant.
  - Write clean, well-documented code
  - Explain your solutions
  - Follow best practices`,
  tools: [runCode, searchDocs]
});

const code = await coder.chat("Write a function to sort an array");

import { Agent } from 'praisonai';

// auth — bill against a subscription seat; picks the provider's default model
const a1 = new Agent({ instructions: 'You are helpful', auth: 'claude-code' });

// toolsets — attach a named group
const a2 = new Agent({ instructions: 'Search the web', toolsets: ['web'] });

// reflection — critique and regenerate, then read the rounds
const a3 = new Agent({ instructions: 'Answer carefully', reflection: 'minimal' });
await a3.chat('Explain TLS');
console.log(a3.lastReflections);

// autonomy — approve edits automatically, prompt for the rest
const a4 = new Agent({ instructions: 'Refactor code', tools: [], autonomy: 'auto_edit' });

// templates — control the system prompt
const a5 = new Agent({
  instructions: 'Be terse',
  templates: { system: 'You are {name}. {instructions}', useSystemPrompt: true },
});

// selfImprove — review skills after a tool-using turn without blocking
const a6 = new Agent({ instructions: 'Do work', selfImprove: 'background' });

// toolConfig — cap a tool at 10s with two retries
const a7 = new Agent({
  instructions: 'Use tools',
  toolConfig: { timeout: 10, retryPolicy: { maxAttempts: 2 } },
});

// learn — extract and inject learnings each turn
const a8 = new Agent({ instructions: 'Assist', learn: 'agentic' });

// backend — run the whole agent on a custom managed backend
const a9 = new Agent({
  instructions: 'Hosted',
  backend: { async execute(prompt) { return `handled: ${prompt}`; } },
});

// runOn / toolsRunOn — see /js/placement for registration
// const a10 = new Agent({ instructions: 'Hosted', runOn: 'my-runtime' });
// const a11 = new Agent({ instructions: 'Local loop', toolsRunOn: 'local' });

// runtime — delegate the turn to the builtin runtime
const a12 = new Agent({ instructions: 'Delegated', runtime: true });

// toolSearch — defer big tool lists behind bridge tools
const a13 = new Agent({ instructions: 'Many tools', toolSearch: 'auto' });

// messageSteering — accept live guidance
const a14 = new Agent({ instructions: 'Steerable', messageSteering: true });

// sandbox — give the agent a subprocess sandbox
const a15 = new Agent({ instructions: 'Run code', sandbox: true });

import { Agent } from 'praisonai';

const agent = new Agent({ instructions: 'Describe images' });

// attachments — images for this turn only
await agent.chat('What is in this picture?', { attachments: ['./photo.png'] });

// reasoningSteps — one non-streaming reasoning completion
await agent.chat('Prove the theorem', { reasoningSteps: true });

// task metadata — readable afterwards
await agent.chat('Step 1', { taskName: 'ingest', taskDescription: 'load data', taskId: 't-1' });
console.log(agent.getTaskContext()); // { name: 'ingest', description: 'load data', id: 't-1' }

// config — forwarded to a managed backend's execute()
await agent.chat('Run remotely', { config: { region: 'eu' } });

import { Agent } from 'praisonai';
import { SteeringPriority } from 'praisonai';

const agent = new Agent({ instructions: 'Assist', messageSteering: true });
agent.steer('check the staging config first', SteeringPriority.HIGH);
await agent.chat('Deploy the service');

import { Agent } from 'praisonai';

const agent = new Agent({ instructions: 'Run code', sandbox: true });
const result = await agent.executeCode('print(2 + 2)', { language: 'python' });
console.log(result.stdout, result.metadata?.securityWarnings);