import { Agency, Agent } from 'agency-agents';

const researcher = new Agent({
  name: 'Researcher',
  goal: 'Find and summarize information about a given topic',
  model: 'claude-3-5-sonnet-20241022',
  backstory: 'You are an expert researcher with years of experience in finding and synthesizing information.'
});

const writer = new Agent({
  name: 'Writer',
  goal: 'Create clear, engaging content based on research',
  model: 'claude-3-5-sonnet-20241022',
  backstory: 'You are a professional writer who transforms complex information into accessible content.'
});

// 创建 Agency
const agency = new Agency();

// 添加多个智能体
agency.addAgent(researcher);
agency.addAgent(writer);

// 定义工作流
agency.createWorkflow({
  name: 'Research and Write',
  agents: [researcher, writer],
  tasks: [
    {
      agent: researcher,
      task: 'Research the latest developments in AI'
    },
    {
      agent: writer,
      task: 'Write a blog post about the research'
    }
  ]
});

// 执行工作流
const result = await agency.run('Write a blog post about AI');

const agent = new Agent({
  name: 'Assistant',
  goal: 'Help users with their tasks',
  model: 'claude-3-5-sonnet-20241022',
  memory: {
    type: 'hybrid', // 'short' | 'long' | 'hybrid'
    maxTokens: 100000,
    summaryThreshold: 0.8
  }
});

import { Tool } from 'agency-agents';

const weatherTool = new Tool({
  name: 'get_weather',
  description: 'Get weather information for a location',
  parameters: {
    location: {
      type: 'string',
      required: true,
      description: 'The city name'
    }
  },
  handler: async ({ location }) => {
    // 调用天气 API
    const weather = await fetchWeatherAPI(location);
    return weather;
  }
});

// 添加工具到智能体
agent.addTool(weatherTool);

const agent = new Agent({
  name: 'Problem Solver',
  goal: 'Solve complex problems step by step',
  model: 'claude-3-5-sonnet-20241022',
  reasoning: {
    type: 'chain_of_thought', // 'chain_of_thought' | 'tree_of_thought'
    maxDepth: 5,
    confidenceThreshold: 0.9
  }
});

const stream = agency.run('Write a story', { streaming: true });

for await (const chunk of stream) {
  console.log(chunk); // 实时输出
}

// 保存状态
await agent.saveState('agent-state.json');

// 加载状态
await agent.loadState('agent-state.json');

// 跨会话持久化
const persistentAgency = new Agency({
  storage: {
    type: 'file', // 'file' | 'database' | 'cloud'
    path: './agency-state'
  }
});

npm install agency-agents
# 或
yarn add agency-agents
# 或
pnpm add agency-agents

# 设置 Claude API 密钥
export ANTHROPIC_API_KEY='your-api-key'

import { Agency, Agent } from 'agency-agents';

async function main() {
  // 创建智能体
  const assistant = new Agent({
    name: 'Assistant',
    goal: 'Help users with their questions',
    model: 'claude-3-5-sonnet-20241022'
  });

  // 创建 Agency
  const agency = new Agency();
  agency.addAgent(assistant);

  // 运行
  const response = await agency.run('What is the capital of France?');
  console.log(response);
}

main();

{
  "compilerOptions": {
    "target": "ES2020",
    "module": "commonjs",
    "strict": true,
    "esModuleInterop": true
  }
}

import { Agent } from 'agency-agents';

const agent = new Agent({
  name: 'ChatBot',
  goal: 'Conversational AI assistant',
  model: 'claude-3-5-sonnet-20241022'
});

const response = await agent.run('Hello!');
console.log(response);

const researcher = new Agent({
  name: 'Researcher',
  goal: 'Find accurate information',
  model: 'claude-3-5-sonnet-20241022'
});

const editor = new Agent({
  name: 'Editor',
  goal: 'Polish and refine content',
  model: 'claude-3-5-sonnet-20241022'
});

const agency = new Agency();
agency.addAgent(researcher);
agency.addAgent(editor);

// 研究员找信息，编辑润色
const result = await agency.run(
  'Find information about climate change and write a summary'
);

import { Agency, Agent, Tools } from 'agency-agents';

const agent = new Agent({
  name: 'Assistant',
  goal: 'Help with various tasks',
  model: 'claude-3-5-sonnet-20241022',
  tools: [Tools.webSearch, Tools.calculator]
});

const result = await agent.run(
  'What is 15% of 200 and search for latest AI news?'
);

import { Tool } from 'agency-agents';

const searchTool = new Tool({
  name: 'search_code',
  description: 'Search for code snippets',
  parameters: {
    query: { type: 'string', required: true },
    language: { type: 'string', required: false }
  },
  handler: async ({ query, language }) => {
    // 实现搜索逻辑
    const results = await searchCodeAPI(query, language);
    return results;
  }
});

const agent = new Agent({
  name: 'Developer Assistant',
  goal: 'Help with coding tasks',
  model: 'claude-3-5-sonnet-20241022',
  tools: [searchTool]
});

const agent = new Agent({
  name: 'Assistant',
  goal: 'Remember and use context',
  model: 'claude-3-5-sonnet-20241022',
  memory: {
    type: 'short',
    maxTokens: 50000
  }
});

// 对话历史被自动维护
await agent.run('My name is John');
const response = await agent.run('What is my name?');
// response 将包含 "John"

const agent = new Agent({
  name: 'Assistant',
  goal: 'Learn from interactions',
  model: 'claude-3-5-sonnet-20241022',
  memory: {
    type: 'long',
    storagePath: './memory-store',
    embeddingModel: 'text-embedding-3-small'
  }
});

const stream = await agency.run(
  'Write a long story about space exploration',
  { streaming: true }
);

for await (const chunk of stream) {
  process.stdout.write(chunk);
}

agency.createWorkflow({
  name: 'Content Pipeline',
  agents: [researcher, writer, editor],
  tasks: [
    {
      agent: researcher,
      task: 'Research the topic thoroughly',
      outputKey: 'research'
    },
    {
      agent: writer,
      task: 'Write initial draft using research: {research}',
      outputKey: 'draft',
      dependsOn: ['research']
    },
    {
      agent: editor,
      task: 'Edit and polish the draft: {draft}',
      outputKey: 'final',
      dependsOn: ['draft']
    }
  ]
});

const result = await agency.runWorkflow('Content Pipeline', {
  topic: 'Artificial Intelligence'
});

const agent = new Agent({
  name: 'Assistant',
  goal: 'Help with tasks',
  model: 'claude-3-5-sonnet-20241022',
  modelConfig: {
    temperature: 0.7,
    maxTokens: 4096,
    topP: 0.9,
    stopSequences: ['END']
  }
});

const agency = new Agency({
  maxConcurrency: 3, // 最大并发智能体数
  timeout: 60000     // 超时时间（毫秒）
});

const agency = new Agency({
  errorHandling: {
    maxRetries: 3,
    retryDelay: 1000,
    onError: (error) => {
      console.error('Agency error:', error);
    }
  }
});

import { Agent, AgentConfig } from 'agency-agents';

class SpecializedAgent extends Agent {
  constructor(config: AgentConfig) {
    super(config);
    this.specializedBehavior();
  }

  private specializedBehavior() {
    // 自定义行为
  }

  async execute(task: string): Promise<string> {
    // 自定义执行逻辑
    return super.execute(task);
  }
}

import { Tool, ToolResult } from 'agency-agents';

export class DatabaseTool extends Tool {
  constructor() {
    super({
      name: 'query_database',
      description: 'Execute SQL queries',
      parameters: {
        sql: { type: 'string', required: true }
      }
    });
  }

  async handler({ sql }: { sql: string }): Promise<ToolResult> {
    try {
      const results = await executeSQL(sql);
      return {
        success: true,
        data: results
      };
    } catch (error) {
      return {
        success: false,
        error: error.message
      };
    }
  }
}

import { MemoryStore } from 'agency-agents';

class CustomMemoryStore extends MemoryStore {
  async save(key: string, value: any): Promise<void> {
    // 自定义存储逻辑
  }

  async load(key: string): Promise<any> {
    // 自定义加载逻辑
  }

  async delete(key: string): Promise<void> {
    // 自定义删除逻辑
  }
}

const researcher = new Agent({
  name: 'Researcher',
  goal: 'Gather accurate information',
  tools: [Tools.webSearch]
});

const writer = new Agent({
  name: 'Writer',
  goal: 'Create engaging content'
});

const agency = new Agency();
agency.addAgents([researcher, writer]);

// 自动化写作工作流
const article = await agency.run(
  'Write an article about the latest AI trends'
);

const reviewer = new Agent({
  name: 'Code Reviewer',
  goal: 'Review code for bugs and improvements',
  model: 'claude-3-5-sonnet-20241022'
});

const agency = new Agency();
const result = await agency.run(
  `Review this code:\n${codeSnippet}`
);

const assistant = new Agent({
  name: 'Customer Support',
  goal: 'Help customers with their inquiries',
  memory: { type: 'long' }
});

const agency = new Agency();
agency.addAgent(assistant);