AgentTeam

// memory — shared in-process store
const team = new AgentTeam({
  agents: [researcher, writer],
  tasks: ['Summarise whales', 'Draft the article'],
  memory: true,
});

// memory — bring your own store
const teamWithStore = new AgentTeam({
  agents: [researcher, writer],
  memory: {
    search: async (query, limit) => [{ entry: { content: '...', role: 'assistant' }, score: 1 }],
    add: async (content, role, metadata) => undefined,
  },
});

// memory — file path
new AgentTeam({ agents, memory: '/path/to/memories.jsonl' });

// memory — userId-scoped
new AgentTeam({ agents, memory: { userId: 'me', config: store } });

// context — third task sees "reply(task one)\n\nreply(task two)…"
const team = new AgentTeam({
  agents: [worker],
  tasks: ['task one', 'task two', 'task three'],
  context: true,
});

new AgentTeam({
  agents: [...],
  tasks: [...],
  hooks: {
    onTaskStart: (task, taskId) => { /* task: TeamTaskRef */ },
    onTaskComplete: (task, output) => { /* output: TaskOutput */ },
    completionChecker: (task, agentOutput) => agentOutput.length > 0, // false → retry
  },
});
// snake_case keys on_task_start, on_task_complete, completion_checker are also accepted

new AgentTeam({ agents, execution: 'fast' });        // maxIter 5,  maxRetries 3 (floor)
new AgentTeam({ agents, execution: 'balanced' });    // maxIter 10, maxRetries 5
new AgentTeam({ agents, execution: 'thorough' });    // maxIter 20, maxRetries 5
new AgentTeam({ agents, execution: 'unlimited' });   // maxIter 100, maxRetries 10
new AgentTeam({ agents, execution: { maxIter: 10, maxRetries: 7 } });
new AgentTeam({ agents, execution: ['balanced', { maxRetries: 8 }] });
// snake_case max_iter / max_retries also accepted

new AgentTeam({ agents, tasks: ['research whales'], planning: true });   // planner = gpt-4o-mini
new AgentTeam({ agents, planning: 'gpt-4o' });                           // string names planner LLM
new AgentTeam({ agents, planning: { llm: 'gpt-4o', autoApprove: true, approveFn: (plan) => true, onReject: (plan) => {} } });
new AgentTeam({ agents, planning: ['gpt-4o', { autoApprove: false }] });

// After start(), inspect the plan and todo list
team.getPlan();      // Plan | undefined
team.getTodoList();  // TodoList | undefined

const team = new AgentTeam({
  agents: [
    new Agent({ name: 'alpha', instructions: 'a', llm: 'alpha-model' }),
    new Agent({ name: 'beta',  instructions: 'b', llm: 'beta-model' }),
  ],
  tasks: ['task one', 'task two'],
  process: 'hierarchical',
  managerLlm: 'gpt-4o',
});
// Manager replies with JSON: { task_id, agent_name, action: 'execute' | 'stop' }
// Loop is bounded by MAX_INVALID_SELECTIONS = 3, MAX_TASK_RESELECTIONS = 3, plus execution.maxIter
// Results always stay in task order regardless of delegation order

// Every member without its own autonomy adopts 'full_auto'
const team = new AgentTeam({
  agents: [researcher, writer],
  autonomy: 'full_auto',
});
// researcher and writer both get _autonomyConfig.level === 'full_auto'

// Precedence — a member's own choice wins
const cautious = new Agent({ instructions: 'Careful edits', autonomy: 'suggest' });
const bold = new Agent({ instructions: 'Ship it' });
new AgentTeam({ agents: [cautious, bold], autonomy: 'full_auto' });
// cautious keeps 'suggest'; bold adopts 'full_auto'

// A prompting level creates the approval gate on adopted members
new AgentTeam({ agents: [worker], autonomy: 'suggest' });
// worker gets an ApprovalManager (CLI prompt for anything not full_auto) and a DoomLoopTracker

// Explicit opt-out — members are left untouched
new AgentTeam({ agents, autonomy: false });

// Both 'local' and 'docker' are built in — no import needed
const team = new AgentTeam({ agents: [a, b], toolsRunOn: 'local' });
a.getToolPlace()?.placeName === 'local';   // true
a.getToolPlace() === b.getToolPlace();      // true — same instance

new AgentTeam({ agents, toolsRunOn: 'docker' });

// Precedence — a member's own place wins
const own = new Agent({ instructions: 'Sandboxed', toolsRunOn: 'local' });
new AgentTeam({ agents: [own], toolsRunOn: 'docker' });
// own keeps its 'local' place

// Explicit opt-out — members are left unplaced
new AgentTeam({ agents, toolsRunOn: false });

// Unknown place — throws at team construction
new AgentTeam({ agents, toolsRunOn: 'nowhere' });
// TypeError: 'nowhere' is not a known place.

new AgentTeam({ agents, runOn: 'openai' });
// TypeError: AgentTeam(runOn="openai") is not supported: runOn= hands one agent's whole
// loop to a managed runtime, and a AgentTeam orchestrates several agents locally.
//   To run every step's tools in one shared sandbox: AgentTeam(toolsRunOn: "openai")
//   To host a single agent's loop, put runOn on that Agent.

new AgentTeam({ agents, runOn: 'openai', toolsRunOn: 'docker' });
// TypeError: ...points the tools at two machines...

import { Agent, AgentTeam } from 'praisonai';

const agent1 = new Agent({ instructions: 'Analyze data' });
const agent2 = new Agent({ instructions: 'Summarize analysis' });

// Simple array syntax
const team = new AgentTeam([agent1, agent2]);
const results = await team.start();

const team = new AgentTeam({
  agents: [researcher, analyst, writer],
  process: 'sequential'
});

// Research → Analysis → Writing
const results = await team.start();

const team = new AgentTeam({
  agents: [sentimentAgent, summaryAgent, keywordsAgent],
  process: 'parallel',
  tasks: [
    'Analyze sentiment: "Great product!"',
    'Summarize: "Great product!"',
    'Extract keywords: "Great product!"'
  ]
});

// All run simultaneously
const [sentiment, summary, keywords] = await team.start();

const team = new AgentTeam({
  agents: [agent1, agent2],
  tasks: [
    'Research the latest AI developments',
    'Write a blog post based on the research'
  ]
});

const results = await team.start();