从零打造你的第一个AI Agent！eliza框架让智能体开发变得前所未有的简单

// 检查Node.js版本
node --version

// 检查npm版本（Node.js自带的包管理器）
npm --version

v20.10.0
10.2.3

// 验证Git是否已安装
git --version

// 正常的输出应该类似于
git version 2.43.0

// 使用HTTPS方式克隆仓库
git clone https://github.com/elizaOS/eliza.git

// 或者如果你的SSH密钥已经配置好，可以使用SSH方式
git clone git@github.com:elizaOS/eliza.git

// 进入项目目录
cd eliza

// 查看项目根目录结构
ls -la

// 项目根目录结构说明

// 核心代码包目录
packages/
    ├── agent/          # Agent核心运行时
    ├── client/         # 客户端SDK
    ├── server/         # API服务器
    ├── plugin-template/ # 插件开发模板

// 配置文件目录
configs/               # 各种环境配置文件
scripts/               # 构建和部署脚本

// 文档和资源
docs/                  # 项目文档
examples/              # 使用示例

// 根目录配置文件
package.json           # 项目依赖管理
pnpm-workspace.yaml    # pnpm工作空间配置
tsconfig.json          # TypeScript配置

// 使用npm全局安装pnpm
npm install -g pnpm

// 验证pnpm安装
pnpm --version

// 安装项目根目录依赖
pnpm install

// 如果遇到网络问题，可以使用国内镜像源
pnpm install --registry=https://registry.npmmirror.com

// 复制配置模板文件
cp .env.example .env

// 编辑配置文件
// 在Linux/macOS上可以使用nano或vim
nano .env

// 在Windows上可以使用notepad
notepad .env

// .env 文件示例配置

// Discord机器人配置（如果需要接入Discord平台）
DISCORD_BOT_TOKEN=your_discord_bot_token_here

// OpenAI API配置（用于GPT模型）
OPENAI_API_KEY=your_openai_api_key_here

// Anthropic API配置（用于Claude模型）
ANTHROPIC_API_KEY=your_anthropic_api_key_here

// Twitter/X API配置
TWITTER_USERNAME=your_twitter_username
TWITTER_PASSWORD=your_twitter_password
TWITTER_EMAIL=your_twitter_email

// Telegram Bot配置
TELEGRAM_BOT_TOKEN=your_telegram_bot_token_here

// 数据库配置（使用SQLite）
DATABASE_URL=./data/db.sqlite

// 服务器配置
PORT=3000
HOST=localhost

// 方式一：使用pnpm脚本启动
pnpm run dev

// 方式二：直接运行TypeScript代码
pnpm run start

// 方式三：进入特定包目录运行
cd packages/agent
pnpm run dev

// 成功启动的输出示例

> eliza@0.1.0 dev
> ts-node-dev --respawn --transpile-only src/index.ts

[INFO] 初始化Agent运行时...
[INFO] 加载配置文件...
[INFO] 连接数据库...
[INFO] 启动Web服务器...
[INFO] 服务器运行在 http://localhost:3000
[INFO] Agent初始化完成，等待连接...

// 消息流转的核心流程示意

// 消息接收 -> 格式转换 -> 上下文构建 -> AI生成 -> 响应发送

// 简化版的处理逻辑
async function processMessage(rawMessage, platform) {
    // 1. 接收原始消息
    const message = await platformAdapter.receive(rawMessage);

    // 2. 转换为统一格式
    const normalizedMessage = normalizeMessage(message);

    // 3. 构建上下文（包含记忆检索）
    const context = await buildContext(normalizedMessage);

    // 4. 调用AI生成响应
    const response = await generateResponse(context);

    // 5. 发送响应
    await platformAdapter.send(response);

    return response;
}

// 记忆对象的基本结构

const memory = {
    id: "mem_1234567890",           // 记忆的唯一标识符
    type: "long_term",              // 记忆类型：short_term, long_term, episodic
    content: "用户喜欢在早上使用助手",  // 记忆的实际内容
    embedding: [0.123, -0.456, ...], // 语义向量表示
    metadata: {
        source: "conversation",     // 记忆来源
        timestamp: 1699000000000,    // 创建时间戳
        importance: 0.8,            // 重要性评分
        tags: ["用户偏好", "使用习惯"]
    },
    agentId: "agent_001",           // 关联的Agent ID
    userId: "user_123"              // 关联的用户ID
};

// 向量检索的基本流程

async function retrieveMemories(query, agentId, limit = 10) {
    // 1. 将查询文本转换为向量
    const queryEmbedding = await embeddingModel.embed(query);

    // 2. 在向量数据库中检索相似向量
    const similarMemories = await vectorStore.search({
        vector: queryEmbedding,
        topK: limit,
        filter: { agentId: agentId }  // 筛选特定Agent的记忆
    });

    // 3. 过滤和排序结果
    const filteredMemories = similarMemories
        .filter(m => m.score > 0.7)   // 只保留相关性高的记忆
        .sort((a, b) => b.score - a.score);

    // 4. 返回记忆内容
    return filteredMemories.map(m => m.memory);
}

// 插件的典型结构示例

// plugin-example/index.ts

// 插件元数据
export const pluginConfig = {
    name: "example-plugin",
    version: "1.0.0",
    description: "这是一个示例插件，演示插件开发规范",
    author: "开发者名称",
    dependencies: [],  // 插件依赖的其他包
    config: {         // 插件配置项定义
        enabled: { type: "boolean", default: true },
        apiKey: { type: "string", required: true }
    }
};

// 插件初始化函数
export async function initializePlugin(context) {
    // 在Agent启动时执行初始化逻辑
    console.log("插件初始化中...");

    // 设置事件监听器
    context.on("message", handleMessage);

    // 注册自定义命令
    context.registerCommand({
        name: "hello",
        handler: handleHelloCommand
    });

    return {
        name: pluginConfig.name,
        status: "ready"
    };
}

// 消息处理器
async function handleMessage(message, context) {
    if (message.content.includes("插件测试")) {
        return {
            type: "text",
            content: "插件正常工作！"
        };
    }
    return null;  // 返回null表示不拦截消息
}

// 命令处理器
async function handleHelloCommand(args, context) {
    return `你好，${args.name || "世界"}！`;
}

// 插件加载流程示意

class PluginManager {
    async loadPlugins(config) {
        // 1. 收集所有启用的插件
        const plugins = config.enabledPlugins.map(pkg => {
            return require(`./plugins/${pkg}`);
        });

        // 2. 解析依赖关系并排序
        const sortedPlugins = this.resolveDependencies(plugins);

        // 3. 依次初始化插件
        const context = this.createPluginContext();

        for (const plugin of sortedPlugins) {
            try {
                const result = await plugin.initialize(context);
                console.log(`插件 ${plugin.name} 加载成功`);
            } catch (error) {
                console.error(`插件 ${plugin.name} 加载失败:`, error);
            }
        }

        // 4. 返回加载结果
        return {
            loaded: sortedPlugins.length,
            failed: plugins.length - sortedPlugins.length
        };
    }
}

// 模型接口的统一抽象

interface AIModelProvider {
    // 同步调用（非流式）
    complete(prompt: string, options?: CompletionOptions): Promise<string>;

    // 流式调用
    completeStream(prompt: string, options?: CompletionOptions): AsyncGenerator<string>;

    // 获取模型信息
    getModelInfo(): ModelInfo;

    // 检查API配额
    checkQuota(): Promise<QuotaStatus>;
}

// 不同模型的具体实现遵循相同接口

class ClaudeProvider implements AIModelProvider {
    async complete(prompt, options) {
        // Claude特定的实现
        const response = await this.anthropic.messages.create({
            model: options.model || "claude-3-sonnet-20240229",
            max_tokens: options.maxTokens || 4096,
            messages: [{ role: "user", content: prompt }]
        });
        return response.content[0].text;
    }
    // ...
}

class GPTProvider implements AIModelProvider {
    async complete(prompt, options) {
        // OpenAI特定的实现
        const response = await this.openai.chat.completions.create({
            model: options.model || "gpt-4-turbo",
            messages: [{ role: "user", content: prompt }],
            max_tokens: options.maxTokens || 4096
        });
        return response.choices[0].message.content;
    }
    // ...
}

// 平台适配器的通用接口定义

interface PlatformAdapter {
    // 平台标识
    platform: string;

    // 初始化适配器
    initialize(config: PlatformConfig): Promise<void>;

    // 连接到平台
    connect(): Promise<void>;

    // 断开连接
    disconnect(): Promise<void>;

    // 发送消息
    sendMessage(target: string, message: Message): Promise<void>;

    // 发送回复（作为对某条消息的回复）
    sendReply(target: string, originalMessage: string, reply: Message): Promise<void>;

    // 上传媒体文件
    uploadMedia(target: string, mediaPath: string, caption?: string): Promise<void>;

    // 事件监听器
    on(event: string, handler: EventHandler): void;
}

// 事件类型定义
type PlatformEvent = 
    | "message"      // 收到新消息
    | "reaction"     // 收到反应/表情
    | "mention"      // 被@提及
    | "dm"          // 收到私信
    | "error"       // 发生错误
    | "disconnect";  // 连接断开

// Discord平台适配器实现概要

class DiscordAdapter implements PlatformAdapter {
    platform = "discord";
    private client: DiscordClient;
    private handlers: Map<string, EventHandler[]> = new Map();

    async initialize(config: DiscordConfig) {
        // 创建Discord客户端实例
        this.client = new DiscordClient({
            intents: [
                Discord.Intents.FLAGS.GUILDS,
                Discord.Intents.FLAGS.GUILD_MESSAGES,
                Discord.Intents.FLAGS.DIRECT_MESSAGES
            ]
        });

        // 注册消息处理器
        this.client.on("messageCreate", this.handleMessage.bind(this));

        // 注册错误处理器
        this.client.on("error", this.handleError.bind(this));
    }

    async connect() {
        // 使用机器人令牌登录
        await this.client.login(process.env.DISCORD_BOT_TOKEN);
        console.log("Discord机器人已连接");
    }

    async sendMessage(channelId: string, message: Message) {
        const channel = await this.client.channels.fetch(channelId);
        if (channel.isText()) {
            await channel.send(this.formatMessage(message));
        }
    }

    // 将统一格式的消息转换为Discord格式
    private formatMessage(message: Message): DiscordMessage {
        return {
            content: message.content,
            embeds: message.embeds,
            files: message.attachments
        };
    }

    // 处理接收到的消息
    private async handleMessage(discordMessage: DiscordMessage) {
        // 忽略机器人自己的消息
        if (discordMessage.author.bot) return;

        // 转换为统一格式
        const normalizedMessage = {
            id: discordMessage.id,
            platform: "discord",
            channelId: discordMessage.channelId,
            guildId: discordMessage.guildId,
            author: {
                id: discordMessage.author.id,
                username: discordMessage.author.username,
                avatar: discordMessage.author.avatarURL()
            },
            content: discordMessage.content,
            timestamp: discordMessage.createdTimestamp,
            replyTo: discordMessage.reference?.messageId
        };

        // 触发事件
        this.emit("message", normalizedMessage);
    }

    private emit(event: string, data: any) {
        const handlers = this.handlers.get(event) || [];
        handlers.forEach(handler => handler(data));
    }

    on(event: string, handler: EventHandler) {
        if (!this.handlers.has(event)) {
            this.handlers.set(event, []);
        }
        this.handlers.get(event)!.push(handler);
    }
}

// 创建项目目录
mkdir my-first-agent
cd my-first-agent

// 初始化npm项目
npm init -y

// 安装eliza作为依赖
npm install @elizaos/core

// 安装TypeScript相关依赖
npm install -D typescript @types/node ts-node

// 初始化TypeScript配置
npx tsc --init

// tsconfig.json

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "NodeNext",
    "moduleResolution": "NodeNext",
    "lib": ["ES2022"],
    "outDir": "./dist",
    "rootDir": "./src",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true,
    "resolveJsonModule": true,
    "declaration": true,
    "declarationMap": true,
    "sourceMap": true
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules", "dist"]
}

// 创建目录结构
mkdir -p src/agents
mkdir -p src/adapters
mkdir -p src/plugins
mkdir -p src/config
mkdir -p src/utils
mkdir -p data
mkdir -p logs

// src目录结构
// ├── agents/      # Agent定义
// ├── adapters/   # 平台适配器
// ├── plugins/    # 自定义插件
// ├── config/     # 配置文件
// ├── utils/      # 工具函数
// └── index.ts    # 入口文件

// src/agents/my-first-agent.ts

import {
    Agent,
    AgentConfig,
    Memory,
    VectorStore,
    createVectorStore
} from "@elizaos/core";

// Agent配置类型定义
interface MyAgentConfig extends AgentConfig {
    name: string;
    description: string;
    greeting: string;
    personality: {
        traits: string[];
        speakingStyle: "formal" | "casual" | "friendly";
    };
}

// 创建Agent配置的工厂函数
function createAgentConfig(): MyAgentConfig {
    return {
        name: "小助手",
        description: "一个友善的AI助手，能够回答各种问题",
        greeting: "你好！我是你的AI助手，有什么我可以帮助你的吗？",

        // 底层Agent配置
        model: {
            provider: "openai",
            model: "gpt-4-turbo",
            temperature: 0.7,
            maxTokens: 2048
        },

        // 个性化设置
        personality: {
            traits: ["helpful", "friendly", "patient"],
            speakingStyle: "friendly"
        },

        // 系统提示词
        systemPrompt: `你是一个友善、耐心的AI助手。
你的目标是帮助用户解决问题和回答问题。
始终保持礼貌和专业，但又不失亲切感。
如果你不确定某个问题的答案，诚实地告诉用户，而不是编造信息。`,

        // 记忆配置
        memory: {
            type: "vector",
            vectorStore: "pinecone",  // 或 "faiss" 用于本地存储
            topK: 5,                   // 检索最相关的5条记忆
            similarityThreshold: 0.7  // 相似度阈值
        }
    };
}

// 创建Agent实例
async function createMyAgent() {
    const config = createAgentConfig();

    // 初始化向量存储
    const vectorStore = await createVectorStore({
        type: "faiss",  // 使用本地Faiss向量数据库
        dimension: 1536,  // OpenAI embedding维度
        persistPath: "./data/vectors"
    });

    // 创建Agent实例
    const agent = new Agent({
        ...config,
        vectorStore
    });

    return agent;
}

export { MyAgentConfig, createAgentConfig, createMyAgent };

// src/adapters/discord-adapter.ts

import { Client, GatewayIntentBits } from "discord.js";
import {
    PlatformAdapter,
    PlatformConfig,
    Message
} from "@elizaos/core";

// Discord适配器配置
interface DiscordConfig extends PlatformConfig {
    token: string;
    guildId?: string;
    channelIds?: string[];
}

// 消息转换函数
function convertDiscordMessage(discordMsg: any): Message {
    return {
        id: discordMsg.id,
        platform: "discord",
        content: discordMsg.content,
        author: {
            id: discordMsg.author.id,
            name: discordMsg.author.username,
            avatar: discordMsg.author.displayAvatarURL()
        },
        channel: {
            id: discordMsg.channelId,
            type: discordMsg.channel?.type
        },
        guild: discordMsg.guildId ? {
            id: discordMsg.guildId,
            name: discordMsg.guild?.name
        } : null,
        timestamp: discordMsg.createdTimestamp,
        attachments: discordMsg.attachments.map((att: any) => ({
            id: att.id,
            name: att.name,
            url: att.url,
            type: att.contentType
        }))
    };
}

// Discord适配器实现
class DiscordAdapter implements PlatformAdapter {
    private client: Client;
    private config: DiscordConfig;
    private messageHandler?: (message: Message) => Promise<void>;
    private messageHandlers: Array<(message: Message) => Promise<void>> = [];

    constructor(config: DiscordConfig) {
        this.config = config;

        // 创建Discord客户端，指定需要的权限
        this.client = new Client({
            intents: [
                GatewayIntentBits.Guilds,
                GatewayIntentBits.GuildMessages,
                GatewayIntentBits.MessageContent,
                GatewayIntentBits.DirectMessages,
                GatewayIntentBits.DirectMessageTyping
            ]
        });

        this.setupEventListeners();
    }

    private setupEventListeners() {
        // 监听消息事件
        this.client.on("messageCreate", async (msg) => {
            // 忽略机器人消息
            if (msg.author.bot) return;

            // 如果配置了限制频道，只处理指定频道的消息
            if (this.config.channelIds && 
                !this.config.channelIds.includes(msg.channelId)) {
                return;
            }

            // 转换为统一格式
            const normalizedMessage = convertDiscordMessage(msg);

            // 调用所有注册的消息处理器
            for (const handler of this.messageHandlers) {
                await handler(normalizedMessage);
            }
        });

        // 监听错误事件
        this.client.on("error", (error) => {
            console.error("Discord适配器错误:", error);
        });

        // 监听断开连接
        this.client.on("disconnect", () => {
            console.log("Discord机器人已断开连接");
        });
    }

    async connect(): Promise<void> {
        await this.client.login(this.config.token);
        console.log("Discord适配器已连接");
    }

    async disconnect(): Promise<void> {
        this.client.destroy();
        console.log("Discord适配器已断开");
    }

    async sendMessage(channelId: string, content: string): Promise<void> {
        const channel = await this.client.channels.fetch(channelId);
        if (channel?.isTextBased()) {
            await channel.send(content);
        }
    }

    async sendReply(channelId: string, messageId: string, content: string): Promise<void> {
        const channel = await this.client.channels.fetch(channelId);
        if (channel?.isTextBased()) {
            await channel.send({
                content: content,
                reply: {
                    messageReference: messageId
                }
            });
        }
    }

    async sendEmbed(channelId: string, embed: any): Promise<void> {
        const channel = await this.client.channels.fetch(channelId);
        if (channel?.isTextBased()) {
            await channel.send({ embeds: [embed] });
        }
    }

    on(event: "message", handler: (message: Message) => Promise<void>): void;
    on(event: string, handler: any): void {
        if (event === "message") {
            this.messageHandlers.push(handler);
        }
    }

    // 移除事件监听器
    off(event: "message", handler: (message: Message) => Promise<void>): void {
        const index = this.messageHandlers.indexOf(handler);
        if (index > -1) {
            this.messageHandlers.splice(index, 1);
        }
    }
}

export { DiscordAdapter, DiscordConfig };

// src/utils/conversation-engine.ts

import { Agent, Message, Memory } from "@elizaos/core";
import { v4 as uuidv4 } from "uuid";

// 对话上下文构建器
class ContextBuilder {
    private context: {
        systemPrompt: string;
        recentMessages: Message[];
        relevantMemories: Memory[];
        userInfo: any;
    } = {
        systemPrompt: "",
        recentMessages: [],
        relevantMemories: [],
        userInfo: null
    };

    setSystemPrompt(prompt: string): this {
        this.context.systemPrompt = prompt;
        return this;
    }

    addRecentMessages(messages: Message[], limit = 10): this {
        this.context.recentMessages = messages.slice(-limit);
        return this;
    }

    addRelevantMemories(memories: Memory[]): this {
        this.context.relevantMemories = memories;
        return this;
    }

    setUserInfo(userInfo: any): this {
        this.context.userInfo = userInfo;
        return this;
    }

    build(): string {
        const parts: string[] = [];

        // 添加系统提示
        if (this.context.systemPrompt) {
            parts.push(`系统提示: ${this.context.systemPrompt}`);
        }

        // 添加相关记忆
        if (this.context.relevantMemories.length > 0) {
            const memoryText = this.context.relevantMemories
                .map(m => `[记忆] ${m.content}`)
                .join("\n");
            parts.push(`相关记忆:\n${memoryText}`);
        }

        // 添加用户信息
        if (this.context.userInfo) {
            parts.push(`用户信息: ${JSON.stringify(this.context.userInfo)}`);
        }

        // 添加对话历史
        if (this.context.recentMessages.length > 0) {
            const historyText = this.context.recentMessages
                .map(m => `${m.author.name}: ${m.content}`)
                .join("\n");
            parts.push(`对话历史:\n${historyText}`);
        }

        return parts.join("\n\n");
    }
}

// 对话引擎
class ConversationEngine {
    private agent: Agent;
    private messageHistory: Map<string, Message[]> = new Map();
    private maxHistoryLength = 50;

    constructor(agent: Agent) {
        this.agent = agent;
    }

    // 处理用户消息
    async processMessage(message: Message): Promise<string> {
        const userId = message.author.id;

        // 1. 获取或初始化用户对话历史
        if (!this.messageHistory.has(userId)) {
            this.messageHistory.set(userId, []);
        }
        const history = this.messageHistory.get(userId)!;

        // 2. 检索相关记忆
        const relevantMemories = await this.agent.retrieveMemories({
            query: message.content,
            limit: 5,
            threshold: 0.7
        });

        // 3. 构建上下文
        const context = new ContextBuilder()
            .setSystemPrompt(this.agent.config.systemPrompt)
            .addRecentMessages(history)
            .addRelevantMemories(relevantMemories)
            .setUserInfo({
                id: message.author.id,
                name: message.author.name
            })
            .build();

        // 4. 调用AI生成响应
        const response = await this.agent.generate(context, message.content);

        // 5. 更新对话历史
        history.push(message);
        if (history.length > this.maxHistoryLength) {
            history.shift();
        }

        // 6. 保存对话到记忆（异步，不阻塞响应）
        this.saveToMemory(message, response).catch(console.error);

        return response;
    }

    // 保存对话到记忆系统
    private async saveToMemory(userMessage: Message, agentResponse: string): Promise<void> {
        // 保存用户消息
        await this.agent.addMemory({
            type: "conversation",
            content: `用户 ${userMessage.author.name}: ${userMessage.content}`,
            metadata: {
                platform: userMessage.platform,
                timestamp: Date.now(),
                type: "user_message"
            }
        });

        // 保存Agent响应
        await this.agent.addMemory({
            type: "conversation",
            content: `助手: ${agentResponse}`,
            metadata: {
                platform: userMessage.platform,
                timestamp: Date.now(),
                type: "agent_response"
            }
        });
    }

    // 获取对话历史
    getHistory(userId: string): Message[] {
        return this.messageHistory.get(userId) || [];
    }

    // 清空对话历史
    clearHistory(userId: string): void {
        this.messageHistory.delete(userId);
    }
}

export { ConversationEngine, ContextBuilder };

// src/index.ts

import dotenv from "dotenv";
import { createMyAgent } from "./agents/my-first-agent";
import { DiscordAdapter } from "./adapters/discord-adapter";
import { ConversationEngine } from "./utils/conversation-engine";
import { Message } from "@elizaos/core";

// 加载环境变量
dotenv.config();

// 主程序类
class MyAgentApplication {
    private agent: any;
    private discordAdapter: DiscordAdapter | null = null;
    private conversationEngine: ConversationEngine | null = null;
    private isRunning = false;

    // 初始化应用
    async initialize() {
        console.log("=".repeat(50));
        console.log("正在初始化AI Agent应用...");
        console.log("=".repeat(50));

        try {
            // 创建Agent实例
            console.log("[1/4] 创建Agent实例...");
            this.agent = await createMyAgent();
            console.log("[✓] Agent创建成功");

            // 初始化对话引擎
            console.log("[2/4] 初始化对话引擎...");
            this.conversationEngine = new ConversationEngine(this.agent);
            console.log("[✓] 对话引擎就绪");

            // 初始化Discord适配器（如果配置了）
            if (process.env.DISCORD_BOT_TOKEN) {
                console.log("[3/4] 初始化Discord适配器...");
                this.discordAdapter = new DiscordAdapter({
                    token: process.env.DISCORD_BOT_TOKEN,
                    channelIds: process.env.DISCORD_CHANNEL_IDS?.split(",")
                });

                // 注册消息处理器
                this.discordAdapter.on("message", this.handleMessage.bind(this));

                await this.discordAdapter.connect();
                console.log("[✓] Discord适配器已连接");
            }

            console.log("[4/4] 启动服务...");
            this.isRunning = true;
            console.log("[✓] 所有服务启动完成");

            console.log("\n" + "=".repeat(50));
            console.log("🎉 AI Agent应用已成功启动！");
            console.log("=".repeat(50));

        } catch (error) {
            console.error("初始化失败:", error);
            throw error;
        }
    }

    // 处理收到的消息
    private async handleMessage(message: Message) {
        console.log(`\n[收到消息] 来自 ${message.author.name}:`);
        console.log(`  内容: ${message.content.substring(0, 100)}${message.content.length > 100 ? "..." : ""}`);

        try {
            // 忽略空消息
            if (!message.content.trim()) {
                return;
            }

            // 忽略命令前缀的消息（如果有特殊命令处理器）
            if (message.content.startsWith("!")) {
                await this.handleCommand(message);
                return;
            }

            // 处理普通对话
            if (this.conversationEngine) {
                const response = await this.conversationEngine.processMessage(message);

                // 发送响应
                if (this.discordAdapter) {
                    await this.discordAdapter.sendReply(
                        message.channel.id,
                        message.id,
                        response
                    );
                }

                console.log(`[发送响应] ${response.substring(0, 50)}...`);
            }

        } catch (error) {
            console.error("处理消息时出错:", error);

            // 发送错误消息
            if (this.discordAdapter) {
                await this.discordAdapter.sendReply(
                    message.channel.id,
                    message.id,
                    "抱歉，处理你的消息时出现了一些问题，请稍后再试。"
                );
            }
        }
    }

    // 处理特殊命令
    private async handleCommand(message: Message) {
        const parts = message.content.split(" ");
        const command = parts[0].substring(1);  // 移除!前缀
        const args = parts.slice(1);

        switch (command) {
            case "help":
                await this.discordAdapter?.sendReply(
                    message.channel.id,
                    message.id,
                    `可用命令:\n!help - 显示帮助信息\n!history - 查看对话历史\n!clear - 清空对话历史\n!ping - 测试连接`
                );
                break;

            case "ping":
                await this.discordAdapter?.sendReply(
                    message.channel.id,
                    message.id,
                    "Pong! 🏓"
                );
                break;

            case "history":
                if (this.conversationEngine) {
                    const history = this.conversationEngine.getHistory(message.author.id);
                    const count = history.length;
                    await this.discordAdapter?.sendReply(
                        message.channel.id,
                        message.id,
                        `你目前有 ${count} 条对话记录。`
                    );
                }
                break;

            case "clear":
                if (this.conversationEngine) {
                    this.conversationEngine.clearHistory(message.author.id);
                    await this.discordAdapter?.sendReply(
                        message.channel.id,
                        message.id,
                        "对话历史已清空。"
                    );
                }
                break;

            default:
                await this.discordAdapter?.sendReply(
                    message.channel.id,
                    message.id,
                    `未知命令: ${command}。输入 !help 查看可用命令。`
                );
        }
    }

    // 关闭应用
    async shutdown() {
        console.log("\n正在关闭应用...");

        this.isRunning = false;

        if (this.discordAdapter) {
            await this.discordAdapter.disconnect();
        }

        console.log("应用已关闭。再见！");
    }
}

// 启动应用
async function main() {
    const app = new MyAgentApplication();

    // 处理进程退出信号
    process.on("SIGINT", async () => {
        console.log("\n收到中断信号...");
        await app.shutdown();
        process.exit(0);
    });

    process.on("SIGTERM", async () => {
        console.log("\n收到终止信号...");
        await app.shutdown();
        process.exit(0);
    });

    // 启动应用
    try {
        await app.initialize();
    } catch (error) {
        console.error("启动失败:", error);
        process.exit(1);
    }
}

// 运行主程序
main();

// 确保以下配置都已正确设置

// .env 文件检查清单
/*
1. OPENAI_API_KEY - OpenAI API密钥（必需）
2. DISCORD_BOT_TOKEN - Discord机器人令牌（如果要使用Discord）
3. 其他可选配置...
*/

// 检查.env文件是否存在
const fs = require("fs");
if (!fs.existsSync(".env")) {
    console.log("警告: .env文件不存在，请创建并配置");
}

// 编译TypeScript
npx tsc

// 或者使用监视模式开发
npx tsc --watch

// 开发模式启动（使用ts-node直接运行）
npx ts-node src/index.ts

// 或者使用ts-node-dev进行热重载开发
npx ts-node-dev --respawn src/index.ts

// 成功启动的输出示例

==================================================
正在初始化AI Agent应用...
==================================================
[1/4] 创建Agent实例...
[✓] Agent创建成功
[2/4] 初始化对话引擎...
[✓] 对话引擎就绪
[3/4] 初始化Discord适配器...
[✓] Discord适配器已连接
[4/4] 启动服务...
[✓] 所有服务启动完成

==================================================
🎉 AI Agent应用已成功启动！
==================================================

[收到消息] 来自 用户名:
  内容: 你好！

[发送响应] 你好！很高兴见到你，有什么我可以帮助你的吗？

// 安装Telegram Bot SDK
npm install node-telegram-bot-api

// 更新适配器目录
mkdir -p src/adapters/telegram

// src/adapters/telegram-adapter.ts

import TelegramBot from "node-telegram-bot-api";
import { PlatformAdapter, PlatformConfig, Message } from "@elizaos/core";

// Telegram适配器配置
interface TelegramConfig extends PlatformConfig {
    token: string;
    allowedChats?: number[];  // 允许接收消息的聊天ID
}

// Telegram适配器实现
class TelegramAdapter implements PlatformAdapter {
    private bot: TelegramBot;
    private config: TelegramConfig;
    private messageHandlers: Array<(message: Message) => Promise<void>> = [];

    constructor(config: TelegramConfig) {
        this.config = config;
        this.bot = new TelegramBot(config.token, { polling: true });
        this.setupEventListeners();
    }

    private setupEventListeners() {
        // 监听消息
        this.bot.on("message", async (msg) => {
            // 忽略命令消息（以/开头）
            if (msg.text?.startsWith("/")) return;

            // 检查是否在允许的聊天中
            if (this.config.allowedChats && 
                !this.config.allowedChats.includes(msg.chat.id)) {
                return;
            }

            // 转换为统一格式
            const normalizedMessage: Message = {
                id: msg.message_id.toString(),
                platform: "telegram",
                content: msg.text || "",
                author: {
                    id: msg.from?.id.toString() || "",
                    name: msg.from?.first_name || "Unknown",
                    avatar: msg.from?.photo?.small_file_id
                },
                channel: {
                    id: msg.chat.id.toString(),
                    type: msg.chat.type
                },
                timestamp: msg.date * 1000
            };

            // 调用消息处理器
            for (const handler of this.messageHandlers) {
                await handler(normalizedMessage);
            }
        });

        // 监听错误
        this.bot.on("error", (error) => {
            console.error("Telegram适配器错误:", error);
        });
    }

    async connect(): Promise<void> {
        console.log("Telegram适配器已启动");
    }

    async disconnect(): Promise<void> {
        this.bot.stopPolling();
        console.log("Telegram适配器已停止");
    }

    async sendMessage(chatId: string, content: string): Promise<void> {
        await this.bot.sendMessage(chatId, content);
    }

    async sendReply(chatId: string, originalMessageId: string, content: string): Promise<void> {
        await this.bot.sendMessage(chatId, content, {
            reply_to_message_id: parseInt(originalMessageId)
        });
    }

    on(event: "message", handler: (message: Message) => Promise<void>): void {
        if (event === "message") {
            this.messageHandlers.push(handler);
        }
    }

    off(event: "message", handler: (message: Message) => Promise<void>): void {
        const index = this.messageHandlers.indexOf(handler);
        if (index > -1) {
            this.messageHandlers.splice(index, 1);
        }
    }
}

export { TelegramAdapter, TelegramConfig };

// src/index.ts 的更新版本

import { createMyAgent } from "./agents/my-first-agent";
import { DiscordAdapter } from "./adapters/discord-adapter";
import { TelegramAdapter } from "./adapters/telegram-adapter";
import { ConversationEngine } from "./utils/conversation-engine";
import { Message } from "@elizaos/core";

class MultiPlatformAgentApplication {
    private agent: any;
    private discordAdapter: DiscordAdapter | null = null;
    private telegramAdapter: TelegramAdapter | null = null;
    private conversationEngine: ConversationEngine | null = null;

    async initialize() {
        console.log("正在初始化多平台AI Agent...");

        // 创建Agent实例
        this.agent = await createMyAgent();
        this.conversationEngine = new ConversationEngine(this.agent);

        // 初始化Discord
        if (process.env.DISCORD_BOT_TOKEN) {
            this.discordAdapter = new DiscordAdapter({
                token: process.env.DISCORD_BOT_TOKEN
            });
            this.discordAdapter.on("message", this.handleMessage.bind(this));
            await this.discordAdapter.connect();
            console.log("[✓] Discord已连接");
        }

        // 初始化Telegram
        if (process.env.TELEGRAM_BOT_TOKEN) {
            this.telegramAdapter = new TelegramAdapter({
                token: process.env.TELEGRAM_BOT_TOKEN,
                allowedChats: process.env.TELEGRAM_ALLOWED_CHATS?.split(",").map(Number)
            });
            this.telegramAdapter.on("message", this.handleMessage.bind(this));
            await this.telegramAdapter.connect();
            console.log("[✓] Telegram已连接");
        }

        console.log("多平台Agent启动完成！");
    }

    private async handleMessage(message: Message) {
        console.log(`[${message.platform}] 来自 ${message.author.name}: ${message.content}`);

        if (this.conversationEngine) {
            const response = await this.conversationEngine.processMessage(message);

            // 根据消息来源平台发送响应
            if (message.platform === "discord" && this.discordAdapter) {
                await this.discordAdapter.sendReply(
                    message.channel.id,
                    message.id,
                    response
                );
            } else if (message.platform === "telegram" && this.telegramAdapter) {
                await this.telegramAdapter.sendReply(
                    message.channel.id,
                    message.id,
                    response
                );
            }
        }
    }

    async shutdown() {
        if (this.discordAdapter) await this.discordAdapter.disconnect();
        if (this.telegramAdapter) await this.telegramAdapter.disconnect();
        console.log("所有平台已断开");
    }
}

export { MultiPlatformAgentApplication };

// src/plugins/weather-plugin.ts

import { Plugin, PluginContext, PluginConfig } from "@elizaos/core";

// 插件配置
const weatherPluginConfig: PluginConfig = {
    name: "weather-plugin",
    version: "1.0.0",
    description: "提供天气查询功能的插件",
    author: "开发者",

    // 插件依赖
    dependencies: [],

    // 配置项定义
    configSchema: {
        apiKey: {
            type: "string",
            required: true,
            description: "天气API密钥"
        },
        defaultUnit: {
            type: "string",
            default: "celsius",
            enum: ["celsius", "fahrenheit"],
            description: "温度单位"
        },
        defaultLocation: {
            type: "string",
            default: "Beijing",
            description: "默认查询位置"
        }
    }
};

// 天气API调用函数（示例，实际使用时请替换为真实的API）
async function fetchWeather(city: string, apiKey: string, unit: string = "celsius") {
    // 这里使用OpenWeatherMap API作为示例
    const baseUrl = "https://api.openweathermap.org/data/2.5/weather";
    const unitParam = unit === "celsius" ? "metric" : "imperial";

    try {
        const response = await fetch(
            `${baseUrl}?q=${encodeURIComponent(city)}&appid=${apiKey}&units=${unitParam}`
        );

        if (!response.ok) {
            throw new Error(`天气API请求失败: ${response.status}`);
        }

        const data = await response.json();

        return {
            city: data.name,
            country: data.sys.country,
            temperature: data.main.temp,
            feelsLike: data.main.feels_like,
            humidity: data.main.humidity,
            description: data.weather[0].description,
            icon: data.weather[0].icon,
            windSpeed: data.wind.speed
        };
    } catch (error) {
        console.error("获取天气信息失败:", error);
        return null;
    }
}

// 格式化天气信息
function formatWeatherResponse(weather: any): string {
    if (!weather) {
        return "抱歉，无法获取天气信息。请检查城市名称是否正确。";
    }

    const unitSymbol = weather.temperature > 0 ? "°C" : "°C";

    return `
🌤️ **${weather.city}, ${weather.country}**

当前天气: ${weather.description}
温度: ${weather.temperature}${unitSymbol}
体感温度: ${weather.feelsLike}${unitSymbol}
湿度: ${weather.humidity}%
风速: ${weather.windSpeed} m/s

📌 ${getWeatherAdvice(weather)}
`.trim();
}

// 根据天气给出建议
function getWeatherAdvice(weather: any): string {
    const temp = weather.temperature;
    const description = weather.description.toLowerCase();

    if (description.includes("rain") || description.includes("storm")) {
        return "今天有雨，出门记得带伞！";
    }

    if (temp < 0) {
        return "天气较冷，请注意保暖！";
    }

    if (temp > 30) {
        return "天气炎热，请注意防暑！";
    }

    return "天气不错，适合外出活动！";
}

// 插件初始化函数
async function initializePlugin(context: PluginContext): Promise<void> {
    const { config, registerCommand, registerAction } = context;

    // 注册天气命令
    registerCommand({
        name: "weather",
        aliases: ["天气", "查天气"],
        description: "查询指定城市的天气",
        usage: "!weather <城市名>",
        examples: [
            "!weather 北京",
            "!weather 上海",
            "天气 东京"
        ],

        async handler(args, messageContext) {
            const city = args.trim() || config.defaultLocation;

            if (!config.apiKey) {
                return "天气插件未配置API密钥，请联系管理员。";
            }

            // 显示加载提示
            context.emit("typing", { duration: 1000 });

            const weather = await fetchWeather(city, config.apiKey, config.defaultUnit);
            return formatWeatherResponse(weather);
        }
    });

    // 注册空气质量的子命令
    registerCommand({
        name: "aqi",
        aliases: ["空气质量", "空气"],
        description: "查询指定城市的空气质量",
        usage: "!aqi <城市名>",

        async handler(args, messageContext) {
            const city = args.trim() || config.defaultLocation;
            // 空气质量API调用逻辑...
            return `空气质量功能开发中...`;
        }
    });

    console.log(`[${weatherPluginConfig.name}] 插件初始化完成`);
}

// 导出插件配置和初始化函数
export {
    weatherPluginConfig,
    initializePlugin
};