def think(self, snapshot,

# 1. 定义核心指令库（确保包含help）
KNOWN_COMMANDS = {"look", "help", "north", "south", "east", "west", "inventory"}

def validate_action(action):
    """校验动作是否合法，非法则返回兜底动作（优先help）"""
    # 清洗动作（去除前缀/空格，提取核心指令）
    clean_action = action.replace("尝试动作: ", "").strip().lower()
    # 合法则返回清洗后的动作，非法则返回help
    if clean_action in KNOWN_COMMANDS:
        return clean_action, True
    else:
        logger.warning(f"非法指令：{action}，自动替换为 help")
        return "help", False

def build_prompt(snapshot, history, known_commands):
    """构建强制约束的Prompt"""
    prompt = f"""
    你的身份是Evennia游戏的探索智能体，必须遵守以下规则：
    1. 动作只能从已知合法指令库中选择：{', '.join(known_commands)}；
    2. 动作输出格式必须是纯字符串（如 look/help/north），禁止添加任何前缀（如“尝试动作: ”）；
    3. 当连续2次指令无效时，必须优先执行 help 指令探索新指令；
    4. 你的目标是探索新区域，对比当前状态和历史状态，避免重复无效动作。

    当前环境快照：
    {snapshot}

    历史交互记录：
    {history}

    请输出JSON格式的决策，仅包含 thought（思考）和 action（动作）字段：
    """
    return prompt

# 2. 在执行动作前调用校验
decision = brain.think(snapshot)  # 假设brain.think返回解析后的dict
action, is_valid = validate_action(decision["action"])
logger.info(f"🧠 思考: {decision['thought']}")
logger.info(f"🚀 执行: {action}")
# 发送清洗后的合法动作给游戏引擎
tn.write(f"{action}\n".encode('utf-8'))

def run_wagent():
    # 初始化计数器
    consecutive_invalid = 0
    max_invalid = 2  # 连续2次无效则执行help
    
    while True:
        # 接收游戏反馈
        raw = tn.read_very_eager().decode('utf-8', errors='ignore')
        if raw:
            logger.info(f"📥 接收反馈: {raw.strip()}")
            
            # 检测是否指令无效
            if "Command '...' is not available" in raw or "Maybe you meant" in raw:
                consecutive_invalid += 1
                # 触发兜底规则：执行help
                if consecutive_invalid >= max_invalid:
                    logger.info("⚠️ 连续无效指令，执行help探索新指令")
                    tn.write("help\n".encode('utf-8'))
                    consecutive_invalid = 0  # 重置计数器
                    continue
            else:
                consecutive_invalid = 0  # 有效指令则重置计数器
        
        # 正常思考和执行逻辑
        snapshot = raw.strip()
        decision = brain.think(snapshot)
        action, is_valid = validate_action(decision["action"])
        logger.info(f"🧠 思考: {decision['thought']}")
        logger.info(f"🚀 执行: {action}")
        tn.write(f"{action}\n".encode('utf-8'))
        time.sleep(4)

import logging
from logging.handlers import RotatingFileHandler
import time

# 配置日志（文件+控制台，自动切割）
def setup_logger():
    logger = logging.getLogger("wagent")
    logger.setLevel(logging.DEBUG)
    
    # 避免重复添加处理器
    if logger.handlers:
        return logger
    
    # 1. 文件处理器（自动切割，保留5个文件，每个最大10MB）
    file_handler = RotatingFileHandler(
        "wagent.log", maxBytes=10*1024*1024, backupCount=5, encoding="utf-8"
    )
    file_formatter = logging.Formatter(
        "%(asctime)s - %(levelname)s - [轮次%(lineno)d] - %(message)s"
    )
    file_handler.setFormatter(file_formatter)
    
    # 2. 控制台处理器（高亮ERROR）
    console_handler = logging.StreamHandler()
    console_formatter = logging.Formatter(
        "%(asctime)s - %(levelname)s - %(message)s"
    )
    console_handler.setFormatter(console_formatter)
    
    logger.addHandler(file_handler)
    logger.addHandler(console_handler)
    return logger

# 初始化日志
logger = setup_logger()

# 优化后日志记录示例
logger.info("--- 建立连接：以 seeker 身份进入 Evennia ---")
logger.error(f"非法指令：{action}，游戏反馈：{raw.strip()}")  # 错误级日志标记非法指令
logger.debug(f"当前已知指令库：{KNOWN_COMMANDS}")  # 调试级记录词库
logger.debug(f"模型原始响应：{raw_llm_response}")  # 记录模型原始JSON

# 捕获中断并记录上下文
try:
    run_wagent()
except KeyboardInterrupt:
    logger.warning("⚠️ 程序被手动中断")
    logger.debug(f"中断时已知指令库：{KNOWN_COMMANDS}")
    logger.debug(f"最后5轮历史：{brain.history[-5:]}")
    raise

import telnetlib
import time
import json
import requests
import logging
import sys
import re

# --- 辅助函数：清理 ANSI 颜色代码 ---
def strip_ansi(text):
    return re.sub(r'\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])', '', text)

# --- 日志配置优化 ---
logger = logging.getLogger()
logger.setLevel(logging.INFO)
formatter = logging.Formatter('%(asctime)s - %(message)s')
file_handler = logging.FileHandler("wagent.log", mode='a', encoding='utf-8')
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)
stream_handler = logging.StreamHandler(sys.stdout)
stream_handler.setFormatter(formatter)
logger.addHandler(stream_handler)

# 配置项
HOST, PORT = "127.0.0.1", 4000
USER, PASS = "seeker", "NickAI202409"
MODEL = "qwen2.5:3b"
# 新增配置项
RECONNECT_MAX_RETRY = 3  # 最大重连次数
HISTORY_MAX_LEN = 8      # 最大记忆长度
ACTION_VALID_LEN = 20    # 指令最大长度
STUCK_THRESHOLD = 3      # 连续无变化阈值（触发强制help）
NEW_CMD_MAX_NUM = 3      # 每次最多学习新指令数量

class WagentBrain:
    def __init__(self):
        self.history = []
        self.known_commands = ["help"]  # 初始只给一个求生指令
        self.last_actions = []          # 记录最近动作，检测原地踏步
        self.stuck_count = 0            # 原地踏步计数

    def is_stuck(self, current_raw, current_action):
        """检测是否原地踏步：连续多次动作后环境无变化"""
        # 简化判断：最近3次动作相同且环境内容无明显变化
        if len(self.last_actions) >= STUCK_THRESHOLD:
            last_3_actions = self.last_actions[-STUCK_THRESHOLD:]
            last_3_envs = [h.split("->")[0].strip() for h in self.history[-STUCK_THRESHOLD:]]
            
            # 动作重复且环境无变化
            if all(act == current_action for act in last_3_actions) and len(set(last_3_envs)) == 1:
                return True
        return False

    def think(self, snapshot, last_feedback):
        # 裁剪历史记录，避免过载
        history_text = "\n".join([f"历史交互 {i+1}: {h}" for i, h in enumerate(self.history[-HISTORY_MAX_LEN:])])
        
        prompt = f"""
        你是一个自主 MUD 探索者。你必须通过观察环境和使用 'help' 指令来学习。

        [当前世界状态]
        {snapshot}
        [上一步反馈]
        {last_feedback}
        [我的认知词库]
        {", ".join(self.known_commands)}
        [记忆记录]
        {history_text}

        [绝对禁令 - 必须遵守]
        1. "action" 字段只能包含英文指令单词，严禁出现任何中文、空格或“尝试”、“指令”等字样。
        2. 如果你发现词库中的指令都无法改变现状，你必须执行 'help' 来寻找新出路。
        3. 优先尝试从 'Exits:' 列表或 'help' 反馈中提取出的新指令。
        4. 如果检测到原地踏步（连续相同动作无环境变化），必须立即执行 'help'。

        [输出 JSON 格式]
        {{
            "thought": "对比记忆，评估当前状态。如果正在原地踏步，解释你为什么要尝试新指令或 help。",
            "action": "单单词英文指令",
            "new_commands": ["仅限从当前反馈中发现的、尚未在词库中的英文单词"]
        }}
        """
        try:
            resp = requests.post(
                "http://localhost:11434/api/generate",
                json={"model": MODEL, "prompt": prompt, "format": "json", "stream": False},
                timeout=15
            )
            resp.raise_for_status()  # 触发HTTP错误
            decision = json.loads(resp.json()['response'])
            
            # --- 智能过滤与去毒：修复空格允许问题，限制新指令数量 ---
            new_cmds = []
            if "new_commands" in decision and isinstance(decision["new_commands"], list):
                # 只取前NEW_CMD_MAX_NUM个，避免词库冗余
                for cmd in decision["new_commands"][:NEW_CMD_MAX_NUM]:
                    clean_cmd = cmd.strip().lower()
                    # 严格过滤：仅允许字母/数字/下划线，无空格，长度限制
                    if re.match(r'^[a-z0-9_]+$', clean_cmd) and 0 < len(clean_cmd) < ACTION_VALID_LEN:
                        if clean_cmd not in self.known_commands and clean_cmd not in new_cmds:
                            new_cmds.append(clean_cmd)
            
            # 批量添加新指令
            for cmd in new_cmds:
                logging.info(f"✨ 认知进化：学会新指令 -> {cmd}")
                self.known_commands.append(cmd)
            
            # --- 强制修正action：确保合规且在词库中 ---
            action = decision.get("action", "help").split()[-1].strip().lower()
            # 过滤非法字符，确保仅含字母/数字/下划线
            action = re.sub(r'[^a-z0-9_]', '', action)
            # 长度限制
            if len(action) >= ACTION_VALID_LEN:
                action = "help"
            # 确保action在词库中，否则强制help
            if action not in self.known_commands:
                action = "help"
            
            # 检测原地踏步，强制执行help
            if self.is_stuck(snapshot, action):
                self.stuck_count += 1
                logging.warning(f"⚠️ 检测到原地踏步（次数：{self.stuck_count}），强制执行help")
                action = "help"
            
            # 更新决策
            decision["action"] = action
            decision["new_commands"] = new_cmds  # 替换为过滤后的指令
            return decision
        
        except requests.exceptions.RequestException as e:
            logging.error(f"❌ 模型请求异常: {e}")
            return {"thought": f"模型请求错误: {e}", "action": "help", "new_commands": []}
        except json.JSONDecodeError as e:
            logging.error(f"❌ JSON解析异常: {e}")
            return {"thought": f"JSON解析错误: {e}", "action": "help", "new_commands": []}
        except Exception as e:
            logging.error(f"❌ 未知思考异常: {e}")
            return {"thought": f"未知错误: {e}", "action": "help", "new_commands": []}

def create_telnet_connection():
    """创建Telnet连接，带重连逻辑"""
    retry = 0
    while retry < RECONNECT_MAX_RETRY:
        try:
            tn = telnetlib.Telnet(HOST, PORT, timeout=10)
            logging.info("✅ Telnet连接成功")
            return tn
        except Exception as e:
            retry += 1
            logging.error(f"❌ Telnet连接失败（重试{retry}/{RECONNECT_MAX_RETRY}）: {e}")
            time.sleep(5)
    logging.critical("❌ 达到最大重连次数，退出程序")
    sys.exit(1)

def run_wagent():
    brain = WagentBrain()
    tn = create_telnet_connection()  # 初始化连接
    
    try:
        logging.info("--- 开始认证流程 ---")
        tn.write(f"connect {USER} {PASS}\n".encode('utf-8'))
        time.sleep(2)
        
        last_feedback = "Started"
        while True:
            time.sleep(4)
            
            # 检查连接状态，断开则重连
            try:
                # 发送空数据检测连接
                tn.sock.send(b'')
            except Exception as e:
                logging.warning(f"❌ 连接已断开，尝试重连: {e}")
                tn = create_telnet_connection()
                tn.write(f"connect {USER} {PASS}\n".encode('utf-8'))
                time.sleep(2)
            
            # 获取并清理反馈
            raw_data = tn.read_very_eager().decode('utf-8', errors='ignore')
            raw = strip_ansi(raw_data) if raw_data else "Environment stable."
            
            # 空数据处理：连续空数据触发help
            if raw == "Environment stable.":
                brain.stuck_count += 1
                if brain.stuck_count >= STUCK_THRESHOLD:
                    logging.warning(f"⚠️ 连续空环境数据，强制执行help")
                    action = "help"
                    tn.write(f"{action}\n".encode('utf-8'))
                    brain.history.append(f"状态: {raw[:30]} -> 动作: {action}")
                    brain.last_actions.append(action)
                    continue
            else:
                brain.stuck_count = 0  # 重置计数
            
            logging.info(f"📥 收到环境数据 (已清理 ANSI): {raw[:100]}...")  # 截断长日志
            logging.info(f"📚 当前认知词库: {brain.known_commands}")

            decision = brain.think(raw, last_feedback)
            
            logging.info(f"🧠 思考: {decision.get('thought', '无思考内容')[:100]}...")
            logging.info(f"🚀 执行动作: {decision.get('action')}")
            
            action = decision.get('action', 'help')
            tn.write(f"{action}\n".encode('utf-8'))
            
            # 记录历史和最近动作
            brain.history.append(f"状态: {raw[:30]} -> 动作: {action}")
            brain.last_actions.append(action)
            # 裁剪最近动作记录，避免过载
            if len(brain.last_actions) > HISTORY_MAX_LEN:
                brain.last_actions = brain.last_actions[-HISTORY_MAX_LEN:]
            
            last_feedback = raw

    except KeyboardInterrupt:
        logging.info("🛑 用户中断程序")
    except Exception as e:
        logging.error(f"💥 运行时异常: {e}", exc_info=True)
    finally:
        if 'tn' in locals() and tn:
            tn.close()
            logging.info("🔌 关闭Telnet连接")

if __name__ == "__main__":
    run_wagent()

# 新正则允许空格（\s），保留指令完整性
if re.match(r'^[a-z0-9_\s]+$', clean_cmd):
    # 加入词库

# action清理仅过滤非法字符，保留空格
decision["action"] = re.sub(r'[^a-z0-9_\s]', '', raw_action)

# 完整记录环境反馈，无截断
logging.info(f"📥 收到环境反馈:\n{raw}")

import telnetlib
import time
import json
import requests
import logging
import sys
import re

# --- 辅助函数：清理 ANSI 颜色/格式代码 ---
def strip_ansi(text):
    """移除MUD输出中的ANSI转义符，避免干扰文本解析"""
    ansi_pattern = re.compile(r'\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])')
    return ansi_pattern.sub('', text)

# --- 日志配置：完整记录 + 结构化输出 ---
def setup_logger():
    logger = logging.getLogger("Wagent")
    logger.setLevel(logging.INFO)
    # 避免重复添加处理器
    if logger.handlers:
        return logger
    
    # 1. 文件处理器（UTF-8编码，追加模式）
    file_handler = logging.FileHandler("wagent.log", mode='a', encoding='utf-8')
    file_formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
    file_handler.setFormatter(file_formatter)
    
    # 2. 控制台处理器（实时输出）
    stream_handler = logging.StreamHandler(sys.stdout)
    stream_handler.setFormatter(file_formatter)
    
    logger.addHandler(file_handler)
    logger.addHandler(stream_handler)
    return logger

# 初始化日志
logger = setup_logger()

# --- 核心配置项（可根据环境调整） ---
CONFIG = {
    "HOST": "127.0.0.1",
    "PORT": 4000,
    "USER": "seeker",
    "PASS": "NickAI202409",
    "MODEL": "qwen2.5:3b",
    "OLLAMA_API": "http://localhost:11434/api/generate",
    "RECONNECT_MAX_RETRY": 3,  # 最大重连次数
    "HISTORY_MAX_LEN": 8,      # 最大记忆长度
    "ACTION_MAX_LEN": 30,      # 指令最大长度
    "SLEEP_INTERVAL": 4        # 动作执行间隔（秒）
}

class WagentBrain:
    """Wagent核心大脑：贪心探索 + 状态机迁移 + 认知进化"""
    def __init__(self):
        self.history = []                # 交互历史
        self.known_commands = ["help", "look"]  # 初始指令库
        self.blocked_commands = []       # 死胡同指令（标记为不可用）
        self.last_raw_env = ""           # 上一轮环境状态

    def think(self, snapshot, last_feedback):
        """核心决策逻辑：基于贪心算法+状态机的自主探索"""
        # 1. 裁剪历史记录，避免上下文过载
        history_text = "\n".join([
            f"Step {i+1}: {h}" 
            for i, h in enumerate(self.history[-CONFIG['HISTORY_MAX_LEN']:])
        ])
        
        # 2. 构建Prompt：强化贪心评估+状态机迁移
        prompt = f"""
        你是基于Wagent理论的自主探索者，核心目标是【最大化新信息发现】（贪心算法）。

        [当前世界状态]
        {snapshot}
        
        [上一步反馈]
        {last_feedback}
        
        [已知合法指令库]
        {", ".join(self.known_commands)}
        
        [死胡同指令（禁止重复执行）]
        {", ".join(self.blocked_commands) if self.blocked_commands else "无"}
        
        [历史交互记录]
        {history_text}

        [Wagent 决策协议（必须严格遵守）]
        1. 进度评估（Progress Score）：
           - 0分：动作无新信息（如重复look、执行死胡同指令）；
           - 5-7分：动作有部分新信息（如发现新指令但未移动）；
           - 8-10分：动作能进入新区域（执行Exits中的出口指令）。
        2. 状态机迁移规则：
           - 观察期：仅知道look/help → 优先执行look/help；
           - 发现期：Exits列表出现新指令 → 立即执行该出口指令；
           - 阻塞期：指令返回"not available" → 标记为死胡同，换其他指令。
        3. 指令格式要求：
           - action字段仅允许英文（可含空格），严禁中文/特殊字符；
           - new_commands仅提取Exits或help中的新指令（可含空格）。

        [输出格式（严格JSON，无多余内容）]
        {{
            "progress_score": "0-10的数字",
            "thought": "说明：1.当前状态判断；2.为什么选这个动作；3.进度分数的理由",
            "action": "要执行的英文指令（可含空格）",
            "new_commands": ["从反馈中提取的新指令/出口名称"]
        }}
        """

        try:
            # 调用Ollama模型
            resp = requests.post(
                CONFIG['OLLAMA_API'],
                json={
                    "model": CONFIG['MODEL'],
                    "prompt": prompt,
                    "format": "json",
                    "stream": False
                },
                timeout=15
            )
            resp.raise_for_status()  # 触发HTTP错误（如404/500）
            decision = json.loads(resp.json()['response'])

            # 3. 认知进化：过滤并添加新指令到词库（允许空格）
            if "new_commands" in decision and isinstance(decision["new_commands"], list):
                for cmd in decision["new_commands"]:
                    clean_cmd = cmd.strip().lower()
                    # 过滤规则：仅允许字母/数字/下划线/空格，长度合规，非死胡同
                    if (re.match(r'^[a-z0-9_\s]+$', clean_cmd) and 
                        0 < len(clean_cmd) < CONFIG['ACTION_MAX_LEN'] and 
                        clean_cmd not in self.known_commands and 
                        clean_cmd not in self.blocked_commands):
                        logger.info(f"✨ 认知进化：学会新指令 -> {clean_cmd}")
                        self.known_commands.append(clean_cmd)

            # 4. 清理动作指令（保留空格，过滤非法字符）
            raw_action = decision.get("action", "help").strip().lower()
            clean_action = re.sub(r'[^a-z0-9_\s]', '', raw_action)
            # 长度超限则默认执行help
            if len(clean_action) >= CONFIG['ACTION_MAX_LEN']:
                clean_action = "help"
            decision["action"] = clean_action

            # 5. 提取进度分数（容错处理）
            try:
                decision["progress_score"] = float(decision.get("progress_score", 0))
            except:
                decision["progress_score"] = 0.0

            return decision

        except requests.exceptions.RequestException as e:
            logger.error(f"❌ 模型请求异常: {str(e)}")
            return self._default_decision(f"模型请求错误: {str(e)}")
        except json.JSONDecodeError as e:
            logger.error(f"❌ JSON解析异常: {str(e)}")
            return self._default_decision(f"JSON解析错误: {str(e)}")
        except Exception as e:
            logger.error(f"❌ 未知思考异常: {str(e)}")
            return self._default_decision(f"未知错误: {str(e)}")

    def _default_decision(self, error_msg):
        """异常时的兜底决策"""
        return {
            "progress_score": 0.0,
            "thought": error_msg,
            "action": "help",
            "new_commands": []
        }

    def mark_blocked_command(self, cmd):
        """标记死胡同指令（避免重复执行）"""
        if cmd.strip() and cmd not in self.blocked_commands:
            logger.warning(f"🚫 标记死胡同指令: {cmd}")
            self.blocked_commands.append(cmd)
            # 从已知指令库移除（如果存在）
            if cmd in self.known_commands:
                self.known_commands.remove(cmd)

def create_telnet_connection():
    """创建Telnet连接，带重连逻辑"""
    retry = 0
    while retry < CONFIG['RECONNECT_MAX_RETRY']:
        try:
            tn = telnetlib.Telnet(CONFIG['HOST'], CONFIG['PORT'], timeout=10)
            logger.info(f"✅ 成功连接 Evennia ({CONFIG['HOST']}:{CONFIG['PORT']})")
            return tn
        except Exception as e:
            retry += 1
            logger.error(f"❌ 连接失败（重试{retry}/{CONFIG['RECONNECT_MAX_RETRY']}）: {str(e)}")
            time.sleep(5)
    logger.critical("❌ 达到最大重连次数，退出程序")
    sys.exit(1)

def run_wagent():
    """启动Wagent主循环"""
    brain = WagentBrain()
    tn = create_telnet_connection()
    last_feedback = "Started"

    try:
        # 认证流程
        logger.info("--- 开始认证流程 ---")
        tn.write(f"connect {CONFIG['USER']} {CONFIG['PASS']}\n".encode('utf-8'))
        time.sleep(2)

        # 主探索循环
        while True:
            time.sleep(CONFIG['SLEEP_INTERVAL'])

            # 检查连接状态（断开则重连）
            try:
                tn.sock.send(b'')  # 空数据检测连接
            except Exception as e:
                logger.warning(f"❌ 连接已断开，尝试重连: {str(e)}")
                tn = create_telnet_connection()
                tn.write(f"connect {CONFIG['USER']} {CONFIG['PASS']}\n".encode('utf-8'))
                time.sleep(2)

            # 读取并清理环境反馈
            raw_data = tn.read_very_eager().decode('utf-8', errors='ignore')
            raw = strip_ansi(raw_data) if raw_data else "No environment data."
            
            # 完整记录环境反馈（关键：无截断）
            logger.info(f"\n📥 收到环境反馈:\n{raw}")
            logger.info(f"📚 当前已知指令库: {brain.known_commands}")
            logger.info(f"🚫 死胡同指令库: {brain.blocked_commands}")

            # 核心决策
            decision = brain.think(raw, last_feedback)

            # 日志输出决策结果
            logger.info(f"📊 贪心进度分数: {decision['progress_score']}")
            logger.info(f"🧠 思考过程: {decision['thought']}")
            logger.info(f"🚀 执行指令: {decision['action']}")

            # 执行指令
            action = decision['action']
            tn.write(f"{action}\n".encode('utf-8'))

            # 标记死胡同指令（检测"not available"反馈）
            if "not available" in raw.lower() and action != "help":
                brain.mark_blocked_command(action)

            # 记录历史（截断状态文本，避免冗余）
            brain.history.append(f"状态: {raw[:20]}.. -> 动作: {action} -> 分数: {decision['progress_score']}")
            last_feedback = raw

    except KeyboardInterrupt:
        logger.info("\n🛑 用户手动中断程序")
    except Exception as e:
        logger.error(f"💥 运行时异常: {str(e)}", exc_info=True)
    finally:
        if 'tn' in locals() and tn:
            tn.close()
            logger.info("🔌 已关闭Telnet连接")

if __name__ == "__main__":
    logger.info("=== Wagent 自主探索程序启动 ===")
    run_wagent()
    logger.info("=== Wagent 自主探索程序退出 ===")

import telnetlib
import time
import json
import requests
import logging
import sys
import re

# --- 辅助函数：清理 ANSI 颜色/格式代码 ---
def strip_ansi(text):
    """移除MUD输出中的ANSI转义符，避免干扰文本解析"""
    ansi_pattern = re.compile(r'\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])')
    return ansi_pattern.sub('', text)

# --- 日志配置：完整记录 + 结构化输出 ---
def setup_logger():
    logger = logging.getLogger("Wagent")
    logger.setLevel(logging.INFO)
    # 避免重复添加处理器
    if logger.handlers:
        return logger
    
    # 1. 文件处理器（UTF-8编码，追加模式）
    file_handler = logging.FileHandler("wagent.log", mode='a', encoding='utf-8')
    file_formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
    file_handler.setFormatter(file_formatter)
    
    # 2. 控制台处理器（实时输出）
    stream_handler = logging.StreamHandler(sys.stdout)
    stream_handler.setFormatter(file_formatter)
    
    logger.addHandler(file_handler)
    logger.addHandler(stream_handler)
    return logger

# 初始化日志
logger = setup_logger()

# --- 核心配置项（可根据环境调整） ---
CONFIG = {
    "HOST": "127.0.0.1",
    "PORT": 4000,
    "USER": "seeker",
    "PASS": "NickAI202409",
    "MODEL": "qwen2.5:3b",
    "OLLAMA_API": "http://localhost:11434/api/generate",
    "RECONNECT_MAX_RETRY": 3,  # 最大重连次数
    "HISTORY_MAX_LEN": 8,      # 最大记忆长度
    "ACTION_MAX_LEN": 30,      # 指令最大长度
    "SLEEP_INTERVAL": 4        # 动作执行间隔（秒）
}

class WagentBrain:
    """Wagent核心大脑：贪心探索 + 状态机迁移 + 认知进化"""
    def __init__(self):
        self.history = []                # 交互历史
        self.known_commands = ["help", "look"]  # 初始指令库
        self.blocked_commands = []       # 死胡同指令（标记为不可用）
        self.last_raw_env = ""           # 上一轮环境状态

    def think(self, snapshot, last_feedback):
        """核心决策逻辑：基于贪心算法+状态机的自主探索"""
        # 1. 裁剪历史记录，避免上下文过载
        history_text = "\n".join([
            f"Step {i+1}: {h}" 
            for i, h in enumerate(self.history[-CONFIG['HISTORY_MAX_LEN']:])
        ])
        
        # 2. 构建Prompt：强化贪心评估+强制提取Exits+状态机迁移
        prompt = f"""
        你是基于Wagent理论的自主探索者，核心目标是【最大化新信息发现】（贪心算法）。

        [当前世界状态]
        {snapshot}
        
        [上一步反馈]
        {last_feedback}
        
        [已知合法指令库]
        {", ".join(self.known_commands)}
        
        [死胡同指令（禁止重复执行）]
        {", ".join(self.blocked_commands) if self.blocked_commands else "无"}
        
        [历史交互记录]
        {history_text}

        [Wagent 决策协议（必须严格遵守，违反将失去探索意义）]
        1. 进度评估（Progress Score）：
           - 0分：动作无新信息（如重复look、执行死胡同指令）；
           - 5-7分：动作有部分新信息（如发现新指令但未移动）；
           - 8-10分：动作能进入新区域（执行Exits中的出口指令）。
        2. 状态机迁移规则（优先级最高）：
           - 观察期：仅知道look/help → 优先执行look/help；
           - 发现期：Exits列表出现新指令 → 立即终止观察期，强制执行该出口指令；
           - 阻塞期：指令返回"not available" → 标记为死胡同，换其他指令。
        3. 强制认知协议（必须执行）：
           - 只要当前状态中出现"Exits: "字符串，必须将冒号后的所有短语（如"climb the chain"）提取为新指令；
           - 新提取的出口指令必须添加到new_commands列表，且下一轮必须执行该指令（进度分数≥8分）；
           - 你不仅知道look/help，还必须主动识别并执行Exits中的所有新指令。
        4. 指令格式要求：
           - action字段仅允许英文（可含空格），严禁中文/特殊字符；
           - new_commands仅提取Exits中的新指令（可含空格），必须完整提取（如"climb the chain"而非仅"climb"）。

        [输出格式（严格JSON，无多余内容，必须包含所有字段）]
        {{
            "progress_score": "0-10的数字",
            "thought": "说明：1.当前状态判断（观察期/发现期/阻塞期）；2.是否发现新Exits指令；3.为什么选这个动作；4.进度分数的理由",
            "action": "要执行的英文指令（可含空格，优先执行Exits新指令）",
            "new_commands": ["从Exits中提取的完整新指令（如'climb the chain'）"]
        }}
        """

        try:
            # 调用Ollama模型
            resp = requests.post(
                CONFIG['OLLAMA_API'],
                json={
                    "model": CONFIG['MODEL'],
                    "prompt": prompt,
                    "format": "json",
                    "stream": False
                },
                timeout=15
            )
            resp.raise_for_status()  # 触发HTTP错误（如404/500）
            decision = json.loads(resp.json()['response'])

            # 3. 认知进化：过滤并添加新指令到词库（允许空格，强制提取Exits指令）
            if "new_commands" in decision and isinstance(decision["new_commands"], list):
                for cmd in decision["new_commands"]:
                    clean_cmd = cmd.strip().lower()
                    # 过滤规则：仅允许字母/数字/下划线/空格，长度合规，非死胡同
                    if (re.match(r'^[a-z0-9_\s]+$', clean_cmd) and 
                        0 < len(clean_cmd) < CONFIG['ACTION_MAX_LEN'] and 
                        clean_cmd not in self.known_commands and 
                        clean_cmd not in self.blocked_commands):
                        logger.info(f"✨ 认知进化：学会新指令 -> {clean_cmd}")
                        self.known_commands.append(clean_cmd)

            # 4. 清理动作指令（保留空格，过滤非法字符）
            raw_action = decision.get("action", "help").strip().lower()
            clean_action = re.sub(r'[^a-z0-9_\s]', '', raw_action)
            # 长度超限则默认执行help
            if len(clean_action) >= CONFIG['ACTION_MAX_LEN']:
                clean_action = "help"
            decision["action"] = clean_action

            # 5. 提取进度分数（容错处理）
            try:
                decision["progress_score"] = float(decision.get("progress_score", 0))
            except:
                decision["progress_score"] = 0.0

            return decision

        except requests.exceptions.RequestException as e:
            logger.error(f"❌ 模型请求异常: {str(e)}")
            return self._default_decision(f"模型请求错误: {str(e)}")
        except json.JSONDecodeError as e:
            logger.error(f"❌ JSON解析异常: {str(e)}")
            return self._default_decision(f"JSON解析错误: {str(e)}")
        except Exception as e:
            logger.error(f"❌ 未知思考异常: {str(e)}")
            return self._default_decision(f"未知错误: {str(e)}")

    def _default_decision(self, error_msg):
        """异常时的兜底决策"""
        return {
            "progress_score": 0.0,
            "thought": error_msg,
            "action": "help",
            "new_commands": []
        }

    def mark_blocked_command(self, cmd):
        """标记死胡同指令（避免重复执行）"""
        if cmd.strip() and cmd not in self.blocked_commands:
            logger.warning(f"🚫 标记死胡同指令: {cmd}")
            self.blocked_commands.append(cmd)
            # 从已知指令库移除（如果存在）
            if cmd in self.known_commands:
                self.known_commands.remove(cmd)

def create_telnet_connection():
    """创建Telnet连接，带重连逻辑"""
    retry = 0
    while retry < CONFIG['RECONNECT_MAX_RETRY']:
        try:
            tn = telnetlib.Telnet(CONFIG['HOST'], CONFIG['PORT'], timeout=10)
            logger.info(f"✅ 成功连接 Evennia ({CONFIG['HOST']}:{CONFIG['PORT']})")
            return tn
        except Exception as e:
            retry += 1
            logger.error(f"❌ 连接失败（重试{retry}/{CONFIG['RECONNECT_MAX_RETRY']}）: {str(e)}")
            time.sleep(5)
    logger.critical("❌ 达到最大重连次数，退出程序")
    sys.exit(1)

def run_wagent():
    """启动Wagent主循环"""
    brain = WagentBrain()
    tn = create_telnet_connection()
    last_feedback = "Started"

    try:
        # 认证流程
        logger.info("--- 开始认证流程 ---")
        tn.write(f"connect {CONFIG['USER']} {CONFIG['PASS']}\n".encode('utf-8'))
        time.sleep(2)

        # 主探索循环
        while True:
            time.sleep(CONFIG['SLEEP_INTERVAL'])

            # 检查连接状态（断开则重连）
            try:
                tn.sock.send(b'')  # 空数据检测连接
            except Exception as e:
                logger.warning(f"❌ 连接已断开，尝试重连: {str(e)}")
                tn = create_telnet_connection()
                tn.write(f"connect {CONFIG['USER']} {CONFIG['PASS']}\n".encode('utf-8'))
                time.sleep(2)

            # 读取并清理环境反馈
            raw_data = tn.read_very_eager().decode('utf-8', errors='ignore')
            raw = strip_ansi(raw_data) if raw_data else "No environment data."
            
            # 完整记录环境反馈（关键：无截断）
            logger.info(f"\n📥 收到环境反馈:\n{raw}")
            logger.info(f"📚 当前已知指令库: {brain.known_commands}")
            logger.info(f"🚫 死胡同指令库: {brain.blocked_commands}")

            # 核心决策
            decision = brain.think(raw, last_feedback)

            # 日志输出决策结果
            logger.info(f"📊 贪心进度分数: {decision['progress_score']}")
            logger.info(f"🧠 思考过程: {decision['thought']}")
            logger.info(f"🚀 执行指令: {decision['action']}")

            # 执行指令
            action = decision['action']
            tn.write(f"{action}\n".encode('utf-8'))

            # 标记死胡同指令（检测"not available"反馈）
            if "not available" in raw.lower() and action != "help":
                brain.mark_blocked_command(action)

            # 记录历史（截断状态文本，避免冗余）
            brain.history.append(f"状态: {raw[:20]}.. -> 动作: {action} -> 分数: {decision['progress_score']}")
            last_feedback = raw

    except KeyboardInterrupt:
        logger.info("\n🛑 用户手动中断程序")
    except Exception as e:
        logger.error(f"💥 运行时异常: {str(e)}", exc_info=True)
    finally:
        if 'tn' in locals() and tn:
            tn.close()
            logger.info("🔌 已关闭Telnet连接")

if __name__ == "__main__":
    logger.info("=== Wagent 自主探索程序启动 ===")
    run_wagent()
    logger.info("=== Wagent 自主探索程序退出 ===")

# 在prompt的最后一行前添加：
"你是专家级MUD探索者，你的核心准则是'发现新出口必须立即执行'，绝不重复执行无收益的look指令，你的progress_score必须真实反映动作的探索价值。"

import telnetlib
import time
import logging
import requests
import json

# 配置日志
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler('wagent.log', encoding='utf-8'),
        logging.StreamHandler()
    ]
)

# Ollama 配置
OLLAMA_URL = "http://localhost:11434/api/generate"
MODEL_NAME = "qwen2.5:3b"

# Evennia 配置
EVENNIA_HOST = "127.0.0.1"
EVENNIA_PORT = 4000
USERNAME = "seeker"
PASSWORD = "seeker"

class Wagent:
    def __init__(self):
        self.tn = None
        self.known_commands = ["help", "look"]  # 已知有效指令
        self.blocked_commands = []  # 死胡同指令（执行后无新区域）
        self.last_environment = ""  # 上一次环境反馈
        self.current_exits = []  # 当前场景的Exits指令

    def connect(self):
        """连接到Evennia服务器并认证"""
        try:
            self.tn = telnetlib.Telnet(EVENNIA_HOST, EVENNIA_PORT)
            logging.info("✅ 成功连接 Evennia (%s:%s)", EVENNIA_HOST, EVENNIA_PORT)
            
            # 认证流程
            logging.info("--- 开始认证流程 ---")
            time.sleep(2)
            self.tn.read_until(b"Username: ", timeout=5)
            self.tn.write(f"{USERNAME}\n".encode('utf-8'))
            time.sleep(1)
            self.tn.read_until(b"Password: ", timeout=5)
            self.tn.write(f"{PASSWORD}\n".encode('utf-8'))
            time.sleep(2)
            
            # 读取认证后的初始环境
            initial_response = self.tn.read_very_eager().decode('utf-8').strip()
            self.last_environment = initial_response
            logging.info("\n📥 收到环境反馈:\n%s", initial_response)
            
            return True
        except Exception as e:
            logging.error("连接失败: %s", str(e))
            return False

    def extract_exits(self, environment):
        """从环境反馈中提取Exits指令"""
        exits = []
        if "Exits:" in environment:
            exits_part = environment.split("Exits:")[-1].split("\n")[0].strip()
            # 处理多个Exits的情况（逗号分隔）
            for exit_cmd in exits_part.split(","):
                exit_cmd = exit_cmd.strip()
                if exit_cmd and exit_cmd not in self.known_commands and exit_cmd not in self.blocked_commands:
                    exits.append(exit_cmd)
        self.current_exits = exits
        return exits

    def call_ollama(self, prompt):
        """调用Ollama模型获取决策"""
        try:
            payload = {
                "model": MODEL_NAME,
                "prompt": prompt,
                "stream": False,
                "temperature": 0.1,  # 降低随机性，确保决策稳定
                "max_tokens": 500
            }
            response = requests.post(OLLAMA_URL, json=payload, timeout=30)
            response.raise_for_status()
            result = json.loads(response.text)
            return result["response"].strip()
        except Exception as e:
            logging.error("调用Ollama失败: %s", str(e))
            return "look"  # 降级策略：默认执行look

    def get_decision(self):
        """获取模型的决策指令"""
        # 核心改动：强化Prompt，明确Exits优先级和观察期终止条件
        prompt = f"""
你是一个智能MUD探索Agent，你的核心目标是**快速探索新区域**，规则如下：
1. 优先级：发现Exits指令后，立即执行该指令，**禁止重复执行look**；
2. 观察期：仅在未发现Exits时执行look，发现Exits后观察期立即结束；
3. 指令规则：
   - 已知有效指令库：{self.known_commands}
   - 死胡同指令库（永不执行）：{self.blocked_commands}
   - 当前环境反馈：{self.last_environment}
   - 当前提取的Exits指令：{self.current_exits}
4. 决策要求：
   - 如果有Exits指令，直接输出该指令（仅输出指令本身，无多余文字）；
   - 如果无Exits指令，仅输出look（唯一选择）；
   - 绝对禁止执行死胡同指令，禁止重复执行已执行过的无效指令；
   - 输出格式：仅指令文本（如look、hole into cliff、climb the chain）。

请输出你下一步要执行的指令：
        """
        
        # 调用模型并提取指令
        response = self.call_ollama(prompt)
        # 清洗模型输出（只保留核心指令）
        decision = response.strip().lower()
        # 过滤死胡同指令
        if decision in self.blocked_commands:
            decision = "look" if "look" not in self.blocked_commands else self.known_commands[0]
        # 记录思考过程（便于日志排查）
        logging.info(f"🧠 思考过程: 当前Exits={self.current_exits}，模型决策={response}，最终执行={decision}")
        return decision

    def execute_command(self, cmd):
        """执行指令并获取反馈"""
        try:
            logging.info(f"🚀 执行指令: {cmd}")
            self.tn.write(f"{cmd}\n".encode('utf-8'))
            time.sleep(4)  # 等待Evennia响应
            response = self.tn.read_very_eager().decode('utf-8').strip()
            self.last_environment = response
            logging.info(f"\n📥 收到环境反馈:\n{response}")
            
            # 检查是否为死胡同（指令无效/无新区域）
            if "is not available" in response or "Could not find" in response:
                logging.warning(f"🚫 标记死胡同指令: {cmd}")
                if cmd not in self.blocked_commands:
                    self.blocked_commands.append(cmd)
                if cmd in self.known_commands:
                    self.known_commands.remove(cmd)
            # 认知进化：学习新Exits指令
            exits = self.extract_exits(response)
            for exit_cmd in exits:
                if exit_cmd not in self.known_commands and exit_cmd not in self.blocked_commands:
                    logging.info(f"✨ 认知进化：学会新指令 -> {exit_cmd}")
                    self.known_commands.append(exit_cmd)
            
            return response
        except Exception as e:
            logging.error(f"执行指令失败: {str(e)}")
            return ""

    def run(self):
        """主运行循环"""
        logging.info("=== Wagent 自主探索程序启动 ===")
        if not self.connect():
            return
        
        # 初始提取Exits
        self.extract_exits(self.last_environment)
        
        # 探索循环（可设置最大步数避免无限循环）
        max_steps = 50
        step = 0
        while step < max_steps:
            step += 1
            # 获取决策
            cmd = self.get_decision()
            # 执行指令
            self.execute_command(cmd)
            # 日志更新词库
            logging.info(f"📚 当前已知指令库: {self.known_commands}")
            logging.info(f"🚫 死胡同指令库: {self.blocked_commands}")
            # 如果发现新Exits且指令有效，直接执行（跳过多余look）
            if self.current_exits and cmd == "look":
                next_cmd = self.current_exits[0]
                logging.info(f"⚡ 发现新Exits，跳过look，直接执行: {next_cmd}")
                self.execute_command(next_cmd)
                step += 1

if __name__ == "__main__":
    agent = Wagent()
    agent.run()

import telnetlib
import time
import json
import requests
import logging
import sys
import re

# --- 辅助函数：清理 ANSI 颜色/格式代码 ---
def strip_ansi(text):
    """移除MUD输出中的ANSI转义符，避免干扰文本解析"""
    ansi_pattern = re.compile(r'\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])')
    return ansi_pattern.sub('', text)

# --- 日志配置：完整记录 + 结构化输出 ---
def setup_logger():
    logger = logging.getLogger("Wagent")
    logger.setLevel(logging.INFO)
    # 避免重复添加处理器
    if logger.handlers:
        return logger
    
    # 1. 文件处理器（UTF-8编码，追加模式）
    file_handler = logging.FileHandler("wagent.log", mode='a', encoding='utf-8')
    file_formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
    file_handler.setFormatter(file_formatter)
    
    # 2. 控制台处理器（实时输出）
    stream_handler = logging.StreamHandler(sys.stdout)
    stream_handler.setFormatter(file_formatter)
    
    logger.addHandler(file_handler)
    logger.addHandler(stream_handler)
    return logger

# 初始化日志
logger = setup_logger()

# --- 核心配置项（可根据环境调整） ---
CONFIG = {
    "HOST": "127.0.0.1",
    "PORT": 4000,
    "USER": "seeker",
    "PASS": "NickAI202409",
    "MODEL": "qwen2.5:3b",
    "OLLAMA_API": "http://localhost:11434/api/generate",
    "RECONNECT_MAX_RETRY": 3,  # 最大重连次数
    "HISTORY_MAX_LEN": 8,      # 最大记忆长度
    "ACTION_MAX_LEN": 30,      # 指令最大长度
    "SLEEP_INTERVAL": 4        # 动作执行间隔（秒）
}

class WagentBrain:
    """Wagent核心大脑：贪心探索 + 状态机迁移 + 认知进化"""
    def __init__(self):
        self.history = []                # 交互历史
        self.known_commands = ["help", "look"]  # 初始指令库
        self.blocked_commands = []       # 死胡同指令（标记为不可用）
        self.last_raw_env = ""           # 上一轮环境状态

    def think(self, snapshot, last_feedback):
        """核心决策逻辑：基于贪心算法+状态机的自主探索"""
        # 1. 裁剪历史记录，避免上下文过载
        history_text = "\n".join([
            f"Step {i+1}: {h}" 
            for i, h in enumerate(self.history[-CONFIG['HISTORY_MAX_LEN']:])
        ])
        
        # 2. 构建Prompt：强化贪心评估+强制提取Exits+状态机迁移
        prompt = f"""
        你是基于Wagent理论的自主探索者，核心目标是【最大化新信息发现】（贪心算法）。

        [当前世界状态]
        {snapshot}
        
        [上一步反馈]
        {last_feedback}
        
        [已知合法指令库]
        {", ".join(self.known_commands)}
        
        [死胡同指令（禁止重复执行）]
        {", ".join(self.blocked_commands) if self.blocked_commands else "无"}
        
        [历史交互记录]
        {history_text}

        [Wagent 决策协议（必须严格遵守，违反将失去探索意义）]
        1. 进度评估（Progress Score）：
           - 0分：动作无新信息（如重复look、执行死胡同指令）；
           - 5-7分：动作有部分新信息（如发现新指令但未移动）；
           - 8-10分：动作能进入新区域（执行Exits中的出口指令）。
        2. 状态机迁移规则（优先级最高）：
           - 观察期：仅知道look/help → 优先执行look/help；
           - 发现期：Exits列表出现新指令 → 立即终止观察期，强制执行该出口指令；
           - 阻塞期：指令返回"not available" → 标记为死胡同，换其他指令。
        3. 强制认知协议（必须执行）：
           - 只要当前状态中出现"Exits: "字符串，必须将冒号后的所有短语（如"climb the chain"）提取为新指令；
           - 新提取的出口指令必须添加到new_commands列表，且下一轮必须执行该指令（进度分数≥8分）；
           - 你不仅知道look/help，还必须主动识别并执行Exits中的所有新指令。
        4. 指令格式要求：
           - action字段仅允许英文（可含空格），严禁中文/特殊字符；
           - new_commands仅提取Exits中的新指令（可含空格），必须完整提取（如"climb the chain"而非仅"climb"）。

        [输出格式（严格JSON，无多余内容，必须包含所有字段）]
        {{
            "progress_score": "0-10的数字",
            "thought": "说明：1.当前状态判断（观察期/发现期/阻塞期）；2.是否发现新Exits指令；3.为什么选这个动作；4.进度分数的理由",
            "action": "要执行的英文指令（可含空格，优先执行Exits新指令）",
            "new_commands": ["从Exits中提取的完整新指令（如'climb the chain'）"]
        }}
        """

        try:
            # 调用Ollama模型
            resp = requests.post(
                CONFIG['OLLAMA_API'],
                json={
                    "model": CONFIG['MODEL'],
                    "prompt": prompt,
                    "format": "json",
                    "stream": False
                },
                timeout=15
            )
            resp.raise_for_status()  # 触发HTTP错误（如404/500）
            decision = json.loads(resp.json()['response'])

            # 3. 认知进化：过滤并添加新指令到词库（允许空格，强制提取Exits指令）
            if "new_commands" in decision and isinstance(decision["new_commands"], list):
                for cmd in decision["new_commands"]:
                    clean_cmd = cmd.strip().lower()
                    # 过滤规则：仅允许字母/数字/下划线/空格，长度合规，非死胡同
                    if (re.match(r'^[a-z0-9_\s]+$', clean_cmd) and 
                        0 < len(clean_cmd) < CONFIG['ACTION_MAX_LEN'] and 
                        clean_cmd not in self.known_commands and 
                        clean_cmd not in self.blocked_commands):
                        logger.info(f"✨ 认知进化：学会新指令 -> {clean_cmd}")
                        self.known_commands.append(clean_cmd)

            # 4. 清理动作指令（保留空格，过滤非法字符）
            raw_action = decision.get("action", "help").strip().lower()
            clean_action = re.sub(r'[^a-z0-9_\s]', '', raw_action)
            # 长度超限则默认执行help
            if len(clean_action) >= CONFIG['ACTION_MAX_LEN']:
                clean_action = "help"
            decision["action"] = clean_action

            # 5. 提取进度分数（容错处理）
            try:
                decision["progress_score"] = float(decision.get("progress_score", 0))
            except:
                decision["progress_score"] = 0.0

            return decision

        except requests.exceptions.RequestException as e:
            logger.error(f"❌ 模型请求异常: {str(e)}")
            return self._default_decision(f"模型请求错误: {str(e)}")
        except json.JSONDecodeError as e:
            logger.error(f"❌ JSON解析异常: {str(e)}")
            return self._default_decision(f"JSON解析错误: {str(e)}")
        except Exception as e:
            logger.error(f"❌ 未知思考异常: {str(e)}")
            return self._default_decision(f"未知错误: {str(e)}")

    def _default_decision(self, error_msg):
        """异常时的兜底决策"""
        return {
            "progress_score": 0.0,
            "thought": error_msg,
            "action": "help",
            "new_commands": []
        }

    def mark_blocked_command(self, cmd):
        """标记死胡同指令（避免重复执行）"""
        if cmd.strip() and cmd not in self.blocked_commands:
            logger.warning(f"🚫 标记死胡同指令: {cmd}")
            self.blocked_commands.append(cmd)
            # 从已知指令库移除（如果存在）
            if cmd in self.known_commands:
                self.known_commands.remove(cmd)

def create_telnet_connection():
    """创建Telnet连接，带重连逻辑"""
    retry = 0
    tn = None
    while retry < CONFIG['RECONNECT_MAX_RETRY']:
        try:
            # 初始化Telnet连接（增加超时容错）
            tn = telnetlib.Telnet(CONFIG['HOST'], CONFIG['PORT'], timeout=20)
            logger.info(f"✅ 成功连接 Evennia ({CONFIG['HOST']}:{CONFIG['PORT']})")
            return tn
        except Exception as e:
            retry += 1
            logger.error(f"❌ 连接失败（重试{retry}/{CONFIG['RECONNECT_MAX_RETRY']}）: {str(e)}")
            time.sleep(5)
    logger.critical("❌ 达到最大重连次数，退出程序")
    sys.exit(1)

def run_wagent():
    """启动Wagent主循环（修复登录+连接稳定性）"""
    brain = WagentBrain()
    tn = create_telnet_connection()
    last_feedback = "Started"

    try:
        # ========== 修复登录流程：分步认证 + 等待服务器响应 ==========
        logger.info("--- 开始认证流程 ---")
        # 先读取服务器欢迎信息（避免指令被吞）
        time.sleep(2)
        welcome_data = tn.read_very_eager().decode('utf-8', errors='ignore')
        logger.info(f"📢 服务器欢迎信息: {strip_ansi(welcome_data)}")
        
        # 发送登录指令（确保换行符正确，编码稳定）
        login_cmd = f"connect {CONFIG['USER']} {CONFIG['PASS']}\n"
        tn.write(login_cmd.encode('utf-8'))
        logger.info(f"📤 发送登录指令: {login_cmd.strip()}")
        
        # 等待登录响应，确认登录成功
        time.sleep(3)
        login_resp = tn.read_very_eager().decode('utf-8', errors='ignore')
        login_resp_clean = strip_ansi(login_resp)
        logger.info(f"🔐 登录响应: {login_resp_clean}")
        
        # 检查登录是否成功（适配常见Evennia登录提示）
        if "successfully" in login_resp_clean.lower() or "connected" in login_resp_clean.lower():
            logger.info("✅ 登录成功，进入探索循环")
        else:
            logger.warning("⚠️ 登录响应未检测到成功标识，继续执行（可能已登录）")

        # ========== 主探索循环 ==========
        while True:
            time.sleep(CONFIG['SLEEP_INTERVAL'])

            # ========== 修复连接检测逻辑：避免空发送导致断开 ==========
            try:
                # 安全检测连接状态（替代空发送）
                if tn.sock is None or tn.sock._closed:
                    raise ConnectionError("Socket已关闭")
            except Exception as e:
                logger.warning(f"❌ 连接已断开，尝试重连: {str(e)}")
                tn = create_telnet_connection()
                # 重连后重新登录
                time.sleep(2)
                tn.write(f"connect {CONFIG['USER']} {CONFIG['PASS']}\n".encode('utf-8'))
                time.sleep(3)
                continue

            # 读取并清理环境反馈（确保完整读取）
            raw_data = tn.read_very_eager().decode('utf-8', errors='ignore')
            raw = strip_ansi(raw_data) if raw_data else "No environment data."
            
            # 完整记录环境反馈（关键：无截断）
            logger.info(f"\n📥 收到环境反馈:\n{raw}")
            logger.info(f"📚 当前已知指令库: {brain.known_commands}")
            logger.info(f"🚫 死胡同指令库: {brain.blocked_commands}")

            # 核心决策
            decision = brain.think(raw, last_feedback)

            # 日志输出决策结果
            logger.info(f"📊 贪心进度分数: {decision['progress_score']}")
            logger.info(f"🧠 思考过程: {decision['thought']}")
            logger.info(f"🚀 执行指令: {decision['action']}")

            # ========== 修复指令执行：确保指令正确发送 ==========
            action = decision['action']
            # 指令为空时默认执行look
            if not action or action.strip() == "":
                action = "look"
            # 发送指令（添加换行符，确保服务器识别）
            action_cmd = f"{action.strip()}\n"
            tn.write(action_cmd.encode('utf-8'))
            logger.info(f"📤 发送探索指令: {action_cmd.strip()}")

            # 标记死胡同指令（检测"not available"反馈）
            if "not available" in raw.lower() and action not in ["help", "look"]:
                brain.mark_blocked_command(action)

            # 记录历史（截断状态文本，避免冗余）
            brain.history.append(f"状态: {raw[:20]}.. -> 动作: {action} -> 分数: {decision['progress_score']}")
            last_feedback = raw

    except KeyboardInterrupt:
        logger.info("\n🛑 用户手动中断程序")
    except Exception as e:
        logger.error(f"💥 运行时异常: {str(e)}", exc_info=True)
    finally:
        if tn and not tn.sock._closed:
            tn.close()
            logger.info("🔌 已关闭Telnet连接")

if __name__ == "__main__":
    logger.info("=== Wagent 自主探索程序启动 ===")
    run_wagent()
    logger.info("=== Wagent 自主探索程序退出 ===")

import telnetlib
import time
import json
import requests
import logging
import sys
import re

# --- 辅助函数：清理 ANSI 颜色/格式代码 ---
def strip_ansi(text):
    """移除MUD输出中的ANSI转义符，避免干扰文本解析"""
    ansi_pattern = re.compile(r'\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])')
    return ansi_pattern.sub('', text)

# --- 辅助函数：提取Exits中的指令 ---
def extract_exits_from_text(text):
    """从环境文本中提取Exits后的指令，返回清理后的指令列表"""
    exit_pattern = re.compile(r'Exits:\s*(.*?)\n', re.IGNORECASE)
    matches = exit_pattern.findall(text)
    exits = []
    if matches:
        # 分割多个出口指令（支持逗号/空格分隔）
        exit_str = matches[0].strip()
        # 处理多种分隔符：逗号、空格、and等
        exit_commands = re.split(r'[,;\s+]|and', exit_str)
        for cmd in exit_commands:
            clean_cmd = cmd.strip().lower()
            if clean_cmd and clean_cmd not in exits:
                exits.append(clean_cmd)
    return exits

# --- 日志配置：完整记录 + 结构化输出 ---
def setup_logger():
    logger = logging.getLogger("Wagent")
    logger.setLevel(logging.INFO)
    # 避免重复添加处理器
    if logger.handlers:
        return logger
    
    # 1. 文件处理器（UTF-8编码，追加模式）
    file_handler = logging.FileHandler("wagent.log", mode='a', encoding='utf-8')
    file_formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
    file_handler.setFormatter(file_formatter)
    
    # 2. 控制台处理器（实时输出）
    stream_handler = logging.StreamHandler(sys.stdout)
    stream_handler.setFormatter(file_formatter)
    
    logger.addHandler(file_handler)
    logger.addHandler(stream_handler)
    return logger

# 初始化日志
logger = setup_logger()

# --- 核心配置项（可根据环境调整） ---
CONFIG = {
    "HOST": "127.0.0.1",
    "PORT": 4000,
    "USER": "seeker",
    "PASS": "NickAI202409",
    "MODEL": "qwen2.5:3b",
    "OLLAMA_API": "http://localhost:11434/api/generate",
    "RECONNECT_MAX_RETRY": 3,  # 最大重连次数
    "HISTORY_MAX_LEN": 8,      # 最大记忆长度
    "ACTION_MAX_LEN": 30,      # 指令最大长度
    "SLEEP_INTERVAL": 4        # 动作执行间隔（秒）
}

class WagentBrain:
    """Wagent核心大脑：贪心探索 + 状态机迁移 + 认知进化"""
    def __init__(self):
        self.history = []                # 交互历史
        self.known_commands = ["help", "look"]  # 初始指令库
        self.blocked_commands = []       # 死胡同指令（标记为不可用）
        self.last_raw_env = ""           # 上一轮环境状态
        self.pending_exit_command = None # 待执行的Exits指令（优先级最高）

    def think(self, snapshot, last_feedback):
        """核心决策逻辑：基于贪心算法+状态机的自主探索"""
        # 1. 优先提取Exits指令（绕过LLM，确保100%提取）
        exit_commands = extract_exits_from_text(snapshot)
        if exit_commands:
            # 筛选未执行过的Exits指令
            new_exit_cmds = [cmd for cmd in exit_commands if cmd not in self.known_commands and cmd not in self.blocked_commands]
            if new_exit_cmds:
                self.pending_exit_command = new_exit_cmds[0]
                logger.info(f"🔍 发现新Exits指令: {self.pending_exit_command}，标记为待执行")
                # 直接添加到已知指令库
                self.known_commands.append(self.pending_exit_command)
        
        # 2. 裁剪历史记录，避免上下文过载
        history_text = "\n".join([
            f"Step {i+1}: {h}" 
            for i, h in enumerate(self.history[-CONFIG['HISTORY_MAX_LEN']:])
        ])
        
        # 3. 构建Prompt：强化贪心评估+强制提取Exits+状态机迁移
        prompt = f"""
        你是基于Wagent理论的自主探索者，核心目标是【最大化新信息发现】（贪心算法）。

        [当前世界状态]
        {snapshot}
        
        [上一步反馈]
        {last_feedback}
        
        [已知合法指令库]
        {", ".join(self.known_commands)}
        
        [死胡同指令（禁止重复执行）]
        {", ".join(self.blocked_commands) if self.blocked_commands else "无"}
        
        [历史交互记录]
        {history_text}
        
        [待执行Exits指令]
        {self.pending_exit_command if self.pending_exit_command else "无"}

        [Wagent 决策协议（必须严格遵守，违反将失去探索意义）]
        1. 进度评估（Progress Score）：
           - 0分：动作无新信息（如重复look、执行死胡同指令）；
           - 5-7分：动作有部分新信息（如发现新指令但未移动）；
           - 8-10分：动作能进入新区域（执行Exits中的出口指令）。
        2. 状态机迁移规则（优先级最高）：
           - 观察期：仅知道look/help → 优先执行look/help；
           - 发现期：存在待执行Exits指令 → 立即执行该指令（进度分数≥8分）；
           - 阻塞期：指令返回"not available" → 标记为死胡同，换其他指令。
        3. 指令格式要求：
           - action字段仅允许英文（可含空格），严禁中文/特殊字符；
           - 优先执行pending_exit_command（如果存在），否则按观察期逻辑执行。

        [输出格式（严格JSON，无多余内容，必须包含所有字段）]
        {{
            "progress_score": 0-10的数字,
            "thought": "说明：1.当前状态判断（观察期/发现期/阻塞期）；2.是否发现新Exits指令；3.为什么选这个动作；4.进度分数的理由",
            "action": "要执行的英文指令（优先执行待执行Exits指令）",
            "new_commands": ["从Exits中提取的完整新指令"]
        }}
        """

        try:
            # 调用Ollama模型
            resp = requests.post(
                CONFIG['OLLAMA_API'],
                json={
                    "model": CONFIG['MODEL'],
                    "prompt": prompt,
                    "format": "json",
                    "stream": False
                },
                timeout=15
            )
            resp.raise_for_status()  # 触发HTTP错误（如404/500）
            decision = json.loads(resp.json()['response'])

            # 4. 优先使用待执行的Exits指令（绕过LLM可能的错误决策）
            if self.pending_exit_command:
                decision["action"] = self.pending_exit_command
                decision["progress_score"] = 9.0  # 执行Exits指令直接给高分
                decision["thought"] = f"发现期：检测到新Exits指令 {self.pending_exit_command}，强制执行该指令以进入新区域"
                self.pending_exit_command = None  # 执行后清空
            
            # 5. 清理动作指令（保留空格，过滤非法字符）
            raw_action = decision.get("action", "help").strip().lower()
            clean_action = re.sub(r'[^a-z0-9_\s]', '', raw_action)
            # 长度超限则默认执行help
            if len(clean_action) >= CONFIG['ACTION_MAX_LEN']:
                clean_action = "help"
            decision["action"] = clean_action

            # 6. 提取进度分数（容错处理）
            try:
                decision["progress_score"] = float(decision.get("progress_score", 0))
            except:
                decision["progress_score"] = 0.0 if clean_action == "look" else 9.0

            return decision

        except requests.exceptions.RequestException as e:
            logger.error(f"❌ 模型请求异常: {str(e)}")
            # 异常时优先执行Exits指令
            if self.pending_exit_command:
                return {
                    "progress_score": 9.0,
                    "thought": f"模型请求异常，但检测到待执行Exits指令 {self.pending_exit_command}，强制执行",
                    "action": self.pending_exit_command,
                    "new_commands": [self.pending_exit_command]
                }
            return self._default_decision(f"模型请求错误: {str(e)}")
        except json.JSONDecodeError as e:
            logger.error(f"❌ JSON解析异常: {str(e)}")
            # 异常时优先执行Exits指令
            if self.pending_exit_command:
                return {
                    "progress_score": 9.0,
                    "thought": f"JSON解析异常，但检测到待执行Exits指令 {self.pending_exit_command}，强制执行",
                    "action": self.pending_exit_command,
                    "new_commands": [self.pending_exit_command]
                }
            return self._default_decision(f"JSON解析错误: {str(e)}")
        except Exception as e:
            logger.error(f"❌ 未知思考异常: {str(e)}")
            # 异常时优先执行Exits指令
            if self.pending_exit_command:
                return {
                    "progress_score": 9.0,
                    "thought": f"未知异常，但检测到待执行Exits指令 {self.pending_exit_command}，强制执行",
                    "action": self.pending_exit_command,
                    "new_commands": [self.pending_exit_command]
                }
            return self._default_decision(f"未知错误: {str(e)}")

    def _default_decision(self, error_msg):
        """异常时的兜底决策"""
        # 兜底时也优先执行Exits指令
        if self.pending_exit_command:
            return {
                "progress_score": 9.0,
                "thought": f"{error_msg}，但检测到待执行Exits指令 {self.pending_exit_command}，强制执行",
                "action": self.pending_exit_command,
                "new_commands": [self.pending_exit_command]
            }
        return {
            "progress_score": 0.0,
            "thought": error_msg,
            "action": "look",
            "new_commands": []
        }

    def mark_blocked_command(self, cmd):
        """标记死胡同指令（避免重复执行）"""
        if cmd.strip() and cmd not in self.blocked_commands:
            logger.warning(f"🚫 标记死胡同指令: {cmd}")
            self.blocked_commands.append(cmd)
            # 从已知指令库移除（如果存在）
            if cmd in self.known_commands:
                self.known_commands.remove(cmd)
            # 如果是待执行指令，清空
            if cmd == self.pending_exit_command:
                self.pending_exit_command = None

def create_telnet_connection():
    """创建Telnet连接，带重连逻辑"""
    retry = 0
    tn = None
    while retry < CONFIG['RECONNECT_MAX_RETRY']:
        try:
            # 初始化Telnet连接（增加超时容错）
            tn = telnetlib.Telnet(CONFIG['HOST'], CONFIG['PORT'], timeout=20)
            logger.info(f"✅ 成功连接 Evennia ({CONFIG['HOST']}:{CONFIG['PORT']})")
            return tn
        except Exception as e:
            retry += 1
            logger.error(f"❌ 连接失败（重试{retry}/{CONFIG['RECONNECT_MAX_RETRY']}）: {str(e)}")
            time.sleep(5)
    logger.critical("❌ 达到最大重连次数，退出程序")
    sys.exit(1)

def run_wagent():
    """启动Wagent主循环（修复登录+连接稳定性）"""
    brain = WagentBrain()
    tn = create_telnet_connection()
    last_feedback = "Started"

    try:
        # ========== 修复登录流程：分步认证 + 等待服务器响应 ==========
        logger.info("--- 开始认证流程 ---")
        # 先读取服务器欢迎信息（避免指令被吞）
        time.sleep(2)
        welcome_data = tn.read_very_eager().decode('utf-8', errors='ignore')
        logger.info(f"📢 服务器欢迎信息: {strip_ansi(welcome_data)}")
        
        # 发送登录指令（确保换行符正确，编码稳定）
        login_cmd = f"connect {CONFIG['USER']} {CONFIG['PASS']}\n"
        tn.write(login_cmd.encode('utf-8'))
        logger.info(f"📤 发送登录指令: {login_cmd.strip()}")
        
        # 等待登录响应，确认登录成功
        time.sleep(3)
        login_resp = tn.read_very_eager().decode('utf-8', errors='ignore')
        login_resp_clean = strip_ansi(login_resp)
        logger.info(f"🔐 登录响应: {login_resp_clean}")
        
        # 检查登录是否成功（适配常见Evennia登录提示）
        if "successfully" in login_resp_clean.lower() or "connected" in login_resp_clean.lower() or "become" in login_resp_clean.lower():
            logger.info("✅ 登录成功，进入探索循环")
        else:
            logger.warning("⚠️ 登录响应未检测到成功标识，继续执行（可能已登录）")

        # ========== 主探索循环 ==========
        while True:
            time.sleep(CONFIG['SLEEP_INTERVAL'])

            # ========== 修复连接检测逻辑：避免空发送导致断开 ==========
            try:
                # 安全检测连接状态（替代空发送）
                if tn.sock is None or tn.sock._closed:
                    raise ConnectionError("Socket已关闭")
            except Exception as e:
                logger.warning(f"❌ 连接已断开，尝试重连: {str(e)}")
                tn = create_telnet_connection()
                # 重连后重新登录
                time.sleep(2)
                tn.write(f"connect {CONFIG['USER']} {CONFIG['PASS']}\n".encode('utf-8'))
                time.sleep(3)
                continue

            # 读取并清理环境反馈（确保完整读取）
            raw_data = tn.read_very_eager().decode('utf-8', errors='ignore')
            raw = strip_ansi(raw_data) if raw_data else "No environment data."
            
            # 完整记录环境反馈（关键：无截断）
            logger.info(f"\n📥 收到环境反馈:\n{raw}")
            logger.info(f"📚 当前已知指令库: {brain.known_commands}")
            logger.info(f"🚫 死胡同指令库: {brain.blocked_commands}")
            logger.info(f"⏳ 待执行Exits指令: {brain.pending_exit_command}")

            # 核心决策
            decision = brain.think(raw, last_feedback)

            # 日志输出决策结果
            logger.info(f"📊 贪心进度分数: {decision['progress_score']}")
            logger.info(f"🧠 思考过程: {decision['thought']}")
            logger.info(f"🚀 执行指令: {decision['action']}")

            # ========== 修复指令执行：确保指令正确发送 ==========
            action = decision['action']
            # 指令为空时默认执行look
            if not action or action.strip() == "":
                action = "look"
            # 发送指令（添加换行符，确保服务器识别）
            action_cmd = f"{action.strip()}\n"
            tn.write(action_cmd.encode('utf-8'))
            logger.info(f"📤 发送探索指令: {action_cmd.strip()}")

            # 标记死胡同指令（检测"not available"反馈）
            if "not available" in raw.lower() and action not in ["help", "look"]:
                brain.mark_blocked_command(action)

            # 记录历史（截断状态文本，避免冗余）
            brain.history.append(f"状态: {raw[:20]}.. -> 动作: {action} -> 分数: {decision['progress_score']}")
            last_feedback = raw

    except KeyboardInterrupt:
        logger.info("\n🛑 用户手动中断程序")
    except Exception as e:
        logger.error(f"💥 运行时异常: {str(e)}", exc_info=True)
    finally:
        if tn and not tn.sock._closed:
            tn.close()
            logger.info("🔌 已关闭Telnet连接")

if __name__ == "__main__":
    logger.info("=== Wagent 自主探索程序启动 ===")
    run_wagent()
    logger.info("=== Wagent 自主探索程序退出 ===")