neuro-simulator 0.1.3__tar.gz → 0.2.1__tar.gz

{neuro_simulator-0.1.3 → neuro_simulator-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: neuro_simulator
-Version: 0.1.3
+Version: 0.2.1
 Summary: Neuro Simulator Server
 Author-email: Moha-Master <hongkongreporter@outlook.com>
 License-Expression: MIT
@@ -39,7 +39,7 @@ Requires-Dist: flake8; extra == "dev"
 
 *本临时README由AI自动生成*
 
-这是 Neuro Simulator 的服务端，负责处理直播逻辑、AI 交互、TTS 合成等核心功能。
+这是 Neuro Simulator 的服务端，负责处理直播逻辑、AI 交互、TTS 合成等核心功能
 
 ## 功能特性
 
@@ -51,49 +51,99 @@ Requires-Dist: flake8; extra == "dev"
 
 ``` main
 neuro_simulator/
-├── main.py              # 应用入口和核心逻辑
-├── config.py            # 配置管理模块
-├── letta.py             # Letta Agent 集成
-├── chatbot.py           # 观众聊天生成器
-├── audio_synthesis.py   # 音频合成模块
-├── stream_chat.py       # 聊天消息处理
-├── stream_manager.py    # 直播管理器
-├── websocket_manager.py # WebSocket 连接管理
-├── process_manager.py   # 进程管理器
-├── shared_state.py      # 全局状态管理
-├── log_handler.py       # 日志处理模块
-├── requirements.txt     # Python 依赖列表
-├── pyproject.toml       # Python 包安装配置
+├── __init__.py
 ├── cli.py               # 命令行启动脚本
-├── config.yaml.example # 自带的备用配置模板
-└── media/               # 自带的备用媒体文件
-    └── neuro_start.mp4  # 用来计算Start Soon长度，仅读取时长
+├── core/                # 核心模块
+│   ├── __init__.py
+│   ├── application.py   # FastAPI应用和主要路由
+│   ├── config.py        # 配置管理模块
+│   ├── agent_factory.py # Agent工厂模式实现
+│   ├── agent_interface.py # Agent接口定义
+│   └── config.yaml.example # 自带的备用配置模板
+├── agent/               # 内建Agent模块
+│   ├── __init__.py
+│   ├── base.py          # Agent基类
+│   ├── core.py          # Agent核心实现
+│   ├── factory.py       # Agent工厂
+│   ├── llm.py           # LLM客户端
+│   ├── memory/          # 记忆管理模块
+│   │   ├── __init__.py
+│   │   ├── manager.py   # 记忆管理器
+│   │   ├── context.json # 上下文记忆文件
+│   │   ├── core_memory.json # 核心记忆文件
+│   │   ├── init_memory.json # 初始化记忆文件
+│   │   └── temp_memory.json # 临时记忆文件
+│   └── tools/           # 工具模块
+│       ├── __init__.py
+│       └── core.py      # 核心工具实现
+├── api/                 # API路由模块
+│   ├── __init__.py
+│   ├── agent.py         # Agent管理API
+│   ├── stream.py        # 直播控制API
+│   └── system.py        # 系统管理API
+├── services/            # 服务模块
+│   ├── __init__.py
+│   ├── audience.py      # 观众聊天生成器
+│   ├── audio.py         # 音频合成模块
+│   ├── builtin.py       # 内建Agent服务
+│   ├── letta.py         # Letta Agent 集成
+│   └── stream.py        # 直播管理服务
+├── utils/               # 工具模块
+│   ├── __init__.py
+│   ├── logging.py       # 日志处理模块
+│   ├── process.py       # 进程管理模块
+│   ├── queue.py         # 队列处理模块
+│   ├── state.py         # 状态管理模块
+│   └── websocket.py     # WebSocket连接管理
+├── assets/              # 自带的备用媒体文件
+│   └── neuro_start.mp4  # 用来计算Start Soon长度，仅读取时长
+├── requirements.txt     # Python 依赖列表
+└── pyproject.toml       # Python 包安装配置
 ```
 
 ``` workin'dir
 working_dir_example/     # 工作目录结构，请将这个目录重命名和复制到你想要的位置（推荐放到~/.config/neuro-simulator）
-├── media/               # 媒体文件夹，如缺失会使用自带资源覆盖
+├── assets/               # 媒体文件夹，如缺失会使用自带资源覆盖
 │   └── neuro_start.mp4  # 用来计算Start Soon长度，仅读取时长,请和客户端的视频保持一致
-├── config.yaml        # 由用户手工创建的配置文件
-└── config.yaml.example # 自动生成的配置文件模板，必须手动重命名和填写
+├── config.yaml          # 由用户手工创建的配置文件
+├── config.yaml.example  # 自动生成的配置文件模板，必须手动重命名和填写
+└── agent/               # Agent相关文件夹
+    └── memory/          # Agent记忆文件夹
+        ├── context.json     # 上下文记忆文件
+        ├── core_memory.json # 核心记忆文件
+        ├── init_memory.json # 初始化记忆文件
+        └── temp_memory.json # 临时记忆文件
 ```
 
 ## 安装与配置
 
-0. **在运行server前，必须有已经配置完成的Letta Agent。**
 1. 复制一份 `../docs/working_dir_example` 到你想要的位置，作为配置文件目录.
    - 程序会在未指定 `--dir` 的情况下自动生成一个工作目录，路径为 `~/.config/neuro-simulator/`
 2. 然后进入配置文件目录，复制 `config.yaml.example` 到 `config.yaml`
 3. 编辑 `config.yaml` 文件，填入必要的 API 密钥和配置项：
-   - Letta Token 和 Agent ID
-   - Gemini/OpenAI API Key
+   - 如果使用 Letta Agent，需要配置 Letta Token 和 Agent ID
+   - Gemini/OpenAI API Key（用于观众聊天生成和 Agent）
    - Azure TTS Key 和 Region
 
-可以执行替换media/neuro_start.mp4为其它视频文件，但记得手动替换client中的同名文件。
+可以自行替换 `$dir/assets/neuro_start.mp4` 为其它视频文件，但记得手动替换 client 中的同名文件
+
+### Agent配置
+
+服务端支持两种Agent类型：
+1. **Letta Agent**：需要配置 Letta Cloud 或自托管的 Letta Server
+2. **内建 Agent**：使用服务端自带的 Agent，支持 Gemini 和OpenAI API
+
+在 `config.yaml` 中通过 `agent_type` 字段选择使用的 Agent 类型：
+- `agent_type: "letta"`：使用 Letta Agent
+- `agent_type: "builtin"`：使用内建 Agent
+
+当使用内建Agent时，还需要配置：
+- `agent.agent_provider`：选择"gemini"或"openai"
+- `agent.agent_model`：指定具体的模型名称
 
 ### 直接安装方式（无需二次开发）
 
-若无需二次开发，可以直接使用pip安装：
+若无需二次开发，可以直接使用 pip 安装：
 ```bash
 python3 -m venv venv
 # Windows
@@ -104,7 +154,7 @@ venv/bin/pip install neuro-simulator
 
 ### 二次开发方式
 
-若需要二次开发，请克隆项目，在server下建立venv，然后pip install -e ./：
+若需要二次开发，请克隆项目：
 ```bash
 git clone https://github.com/your-username/Neuro-Simulator.git
 cd Neuro-Simulator/server
@@ -131,7 +181,7 @@ neuro -H 0.0.0.0 -P 8080
 neuro -D /path/to/your/config -H 0.0.0.0 -P 8080
 ```
 
-服务默认运行在 `http://127.0.0.1:8000`。
+服务默认运行在 `http://127.0.0.1:8000`
 
 ## API 接口
 
@@ -139,14 +189,14 @@ neuro -D /path/to/your/config -H 0.0.0.0 -P 8080
 
 - `/api/stream/*` - 直播控制接口（启动/停止/重启/状态）
 - `/api/configs/*` - 配置管理接口（获取/更新/重载配置）
-  - `api_keys` `server` 等敏感配置项无法从接口获取和修改。
+  - `api_keys` `server` 等敏感配置项无法从接口获取和修改
 - `/api/logs` - 日志获取接口
 - `/api/tts/synthesize` - TTS 合成接口
 - `/api/system/health` - 健康检查接口
-- `/ws/stream` - 直播内容 WebSocket 接口
-- `/ws/logs` - 日志流 WebSocket 接口
+- `/ws/stream` - 客户端使用的直播接口
+- `/ws/admin` - 日志和内建 Agent的 Context 流接口
 
-详细接口说明可通过 `http://127.0.0.1:8000/docs` 访问 API 文档查看。
+详细接口说明可通过 `http://127.0.0.1:8000/docs` 访问 API 文档查
 
 ## 配置说明
 
@@ -160,7 +210,7 @@ neuro -D /path/to/your/config -H 0.0.0.0 -P 8080
 - `performance` - 性能相关设置
 - `server` - 服务器设置（主机、端口、CORS 等）
 
-有关配置文件的完整示例，请参阅项目根目录下的 `docs/working_dir_example/` 文件夹。
+有关配置文件的完整示例，请参阅项目根目录下的 `docs/working_dir_example/` 文件夹
 
 ## 安全说明
 

neuro_simulator-0.2.1/README.md

@@ -0,0 +1,189 @@
+# Neuro-Simulator 服务端
+
+*本临时README由AI自动生成*
+
+这是 Neuro Simulator 的服务端，负责处理直播逻辑、AI 交互、TTS 合成等核心功能
+
+## 功能特性
+
+- **动态观众**：调用无状态LLM，动态生成观众聊天内容，支持 Gemini 和 OpenAI API
+- **配置管理**：支持通过 API 动态修改和热重载配置
+- **外部控制**：完全使用外部API端点操控服务端运行
+
+## 目录结构
+
+``` main
+neuro_simulator/
+├── __init__.py
+├── cli.py               # 命令行启动脚本
+├── core/                # 核心模块
+│   ├── __init__.py
+│   ├── application.py   # FastAPI应用和主要路由
+│   ├── config.py        # 配置管理模块
+│   ├── agent_factory.py # Agent工厂模式实现
+│   ├── agent_interface.py # Agent接口定义
+│   └── config.yaml.example # 自带的备用配置模板
+├── agent/               # 内建Agent模块
+│   ├── __init__.py
+│   ├── base.py          # Agent基类
+│   ├── core.py          # Agent核心实现
+│   ├── factory.py       # Agent工厂
+│   ├── llm.py           # LLM客户端
+│   ├── memory/          # 记忆管理模块
+│   │   ├── __init__.py
+│   │   ├── manager.py   # 记忆管理器
+│   │   ├── context.json # 上下文记忆文件
+│   │   ├── core_memory.json # 核心记忆文件
+│   │   ├── init_memory.json # 初始化记忆文件
+│   │   └── temp_memory.json # 临时记忆文件
+│   └── tools/           # 工具模块
+│       ├── __init__.py
+│       └── core.py      # 核心工具实现
+├── api/                 # API路由模块
+│   ├── __init__.py
+│   ├── agent.py         # Agent管理API
+│   ├── stream.py        # 直播控制API
+│   └── system.py        # 系统管理API
+├── services/            # 服务模块
+│   ├── __init__.py
+│   ├── audience.py      # 观众聊天生成器
+│   ├── audio.py         # 音频合成模块
+│   ├── builtin.py       # 内建Agent服务
+│   ├── letta.py         # Letta Agent 集成
+│   └── stream.py        # 直播管理服务
+├── utils/               # 工具模块
+│   ├── __init__.py
+│   ├── logging.py       # 日志处理模块
+│   ├── process.py       # 进程管理模块
+│   ├── queue.py         # 队列处理模块
+│   ├── state.py         # 状态管理模块
+│   └── websocket.py     # WebSocket连接管理
+├── assets/              # 自带的备用媒体文件
+│   └── neuro_start.mp4  # 用来计算Start Soon长度，仅读取时长
+├── requirements.txt     # Python 依赖列表
+└── pyproject.toml       # Python 包安装配置
+```
+
+``` workin'dir
+working_dir_example/     # 工作目录结构，请将这个目录重命名和复制到你想要的位置（推荐放到~/.config/neuro-simulator）
+├── assets/               # 媒体文件夹，如缺失会使用自带资源覆盖
+│   └── neuro_start.mp4  # 用来计算Start Soon长度，仅读取时长,请和客户端的视频保持一致
+├── config.yaml          # 由用户手工创建的配置文件
+├── config.yaml.example  # 自动生成的配置文件模板，必须手动重命名和填写
+└── agent/               # Agent相关文件夹
+    └── memory/          # Agent记忆文件夹
+        ├── context.json     # 上下文记忆文件
+        ├── core_memory.json # 核心记忆文件
+        ├── init_memory.json # 初始化记忆文件
+        └── temp_memory.json # 临时记忆文件
+```
+
+## 安装与配置
+
+1. 复制一份 `../docs/working_dir_example` 到你想要的位置，作为配置文件目录.
+   - 程序会在未指定 `--dir` 的情况下自动生成一个工作目录，路径为 `~/.config/neuro-simulator/`
+2. 然后进入配置文件目录，复制 `config.yaml.example` 到 `config.yaml`
+3. 编辑 `config.yaml` 文件，填入必要的 API 密钥和配置项：
+   - 如果使用 Letta Agent，需要配置 Letta Token 和 Agent ID
+   - Gemini/OpenAI API Key（用于观众聊天生成和 Agent）
+   - Azure TTS Key 和 Region
+
+可以自行替换 `$dir/assets/neuro_start.mp4` 为其它视频文件，但记得手动替换 client 中的同名文件
+
+### Agent配置
+
+服务端支持两种Agent类型：
+1. **Letta Agent**：需要配置 Letta Cloud 或自托管的 Letta Server
+2. **内建 Agent**：使用服务端自带的 Agent，支持 Gemini 和OpenAI API
+
+在 `config.yaml` 中通过 `agent_type` 字段选择使用的 Agent 类型：
+- `agent_type: "letta"`：使用 Letta Agent
+- `agent_type: "builtin"`：使用内建 Agent
+
+当使用内建Agent时，还需要配置：
+- `agent.agent_provider`：选择"gemini"或"openai"
+- `agent.agent_model`：指定具体的模型名称
+
+### 直接安装方式（无需二次开发）
+
+若无需二次开发，可以直接使用 pip 安装：
+```bash
+python3 -m venv venv
+# Windows
+venv/Scripts/pip install neuro-simulator
+# macOS/Linux
+venv/bin/pip install neuro-simulator
+```
+
+### 二次开发方式
+
+若需要二次开发，请克隆项目：
+```bash
+git clone https://github.com/your-username/Neuro-Simulator.git
+cd Neuro-Simulator/server
+python3 -m venv venv
+# Windows
+venv/Scripts/pip install -e .
+# macOS/Linux
+venv/bin/pip install -e .
+```
+
+### 运行服务
+
+```bash
+# 使用默认配置 (位于~/.config/neuro-simulator/)
+neuro
+
+# 指定工作目录
+neuro -D /path/to/your/config
+
+# 指定主机和端口
+neuro -H 0.0.0.0 -P 8080
+
+# 组合使用
+neuro -D /path/to/your/config -H 0.0.0.0 -P 8080
+```
+
+服务默认运行在 `http://127.0.0.1:8000`
+
+## API 接口
+
+后端提供丰富的 API 接口用于控制和管理：
+
+- `/api/stream/*` - 直播控制接口（启动/停止/重启/状态）
+- `/api/configs/*` - 配置管理接口（获取/更新/重载配置）
+  - `api_keys` `server` 等敏感配置项无法从接口获取和修改
+- `/api/logs` - 日志获取接口
+- `/api/tts/synthesize` - TTS 合成接口
+- `/api/system/health` - 健康检查接口
+- `/ws/stream` - 客户端使用的直播接口
+- `/ws/admin` - 日志和内建 Agent的 Context 流接口
+
+详细接口说明可通过 `http://127.0.0.1:8000/docs` 访问 API 文档查
+
+## 配置说明
+
+配置文件 `config.yaml` 包含以下主要配置项：
+
+- `api_keys` - 各种服务的 API 密钥
+- `stream_metadata` - 直播元数据（标题、分类、标签等）
+- `neuro_behavior` - Neuro 行为设置
+- `audience_simulation` - 观众模拟设置
+- `tts` - TTS 语音合成设置
+- `performance` - 性能相关设置
+- `server` - 服务器设置（主机、端口、CORS 等）
+
+有关配置文件的完整示例，请参阅项目根目录下的 `docs/working_dir_example/` 文件夹
+
+## 安全说明
+
+1. 通过 `panel_password` 配置项可以设置控制面板访问密码
+2. 敏感配置项（如 API 密钥）不会通过 API 接口暴露
+3. 支持 CORS，仅允许预配置的来源访问
+
+## 故障排除
+
+- 确保所有必需的 API 密钥都已正确配置
+- 检查网络连接是否正常
+- 查看日志文件获取错误信息
+- 确保端口未被其他程序占用 

neuro_simulator-0.2.1/neuro_simulator/__init__.py

@@ -0,0 +1 @@
+# neuro_simulator package root

neuro_simulator-0.2.1/neuro_simulator/agent/__init__.py

@@ -0,0 +1 @@
+# neuro_simulator.agent package

neuro_simulator-0.2.1/neuro_simulator/agent/base.py

@@ -0,0 +1,43 @@
+# agent/base.py
+"""Base classes for Neuro Simulator Agent"""
+
+from abc import ABC, abstractmethod
+from typing import List, Dict, Any, Optional
+
+
+class BaseAgent(ABC):
+    """Abstract base class for all agents"""
+    
+    @abstractmethod
+    async def initialize(self):
+        """Initialize the agent"""
+        pass
+    
+    @abstractmethod
+    async def reset_memory(self):
+        """Reset agent memory"""
+        pass
+    
+    @abstractmethod
+    async def get_response(self, chat_messages: List[Dict[str, str]]) -> Dict[str, Any]:
+        """Get response from the agent
+        
+        Args:
+            chat_messages: List of message dictionaries with 'username' and 'text' keys
+            
+        Returns:
+            Dictionary containing processing details including tool executions and final response
+        """
+        pass
+    
+    @abstractmethod
+    async def process_messages(self, messages: List[Dict[str, str]]) -> Dict[str, Any]:
+        """Process messages and generate a response
+        
+        Args:
+            messages: List of message dictionaries with 'username' and 'text' keys
+            
+        Returns:
+            Dictionary containing processing details including tool executions and final response
+        """
+        pass

neuro_simulator-0.2.1/neuro_simulator/agent/core.py

@@ -0,0 +1,201 @@
+# neuro_simulator/agent/core.py
+"""
+Core module for the Neuro Simulator's built-in agent.
+"""
+
+import asyncio
+import json
+import logging
+import re
+import sys
+from pathlib import Path
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+# Updated imports for the new structure
+from ..utils.logging import QueueLogHandler, agent_log_queue
+from ..utils.websocket import connection_manager
+
+# --- Agent-specific imports ---
+from .llm import LLMClient
+from .memory.manager import MemoryManager
+from .tools.core import ToolManager
+
+# Create a logger for the agent
+agent_logger = logging.getLogger("neuro_agent")
+agent_logger.setLevel(logging.DEBUG)
+
+# Configure agent logging to use the shared queue
+def configure_agent_logging():
+    """Configure agent logging to use the shared agent_log_queue."""
+    if agent_logger.hasHandlers():
+        agent_logger.handlers.clear()
+    
+    agent_queue_handler = QueueLogHandler(agent_log_queue)
+    # Use the same format as the server for consistency
+    formatter = logging.Formatter('%(asctime)s - [%(name)-24s] - %(levelname)-8s - %(message)s', datefmt='%H:%M:%S')
+    agent_queue_handler.setFormatter(formatter)
+    agent_logger.addHandler(agent_queue_handler)
+    agent_logger.propagate = False
+    agent_logger.info("Agent logging configured to use agent_log_queue.")
+
+configure_agent_logging()
+
+class Agent:
+    """Main Agent class that integrates LLM, memory, and tools. This is the concrete implementation."""
+    
+    def __init__(self, working_dir: str = None):
+        self.memory_manager = MemoryManager(working_dir)
+        self.tool_manager = ToolManager(self.memory_manager)
+        self.llm_client = LLMClient()
+        self._initialized = False
+        agent_logger.info("Agent instance created.")
+        agent_logger.debug(f"Agent working directory: {working_dir}")
+        
+    async def initialize(self):
+        """Initialize the agent, loading any persistent memory."""
+        if not self._initialized:
+            agent_logger.info("Initializing agent memory manager...")
+            await self.memory_manager.initialize()
+            self._initialized = True
+            agent_logger.info("Agent initialized successfully.")
+        
+    async def reset_all_memory(self):
+        """Reset all agent memory types."""
+        await self.memory_manager.reset_temp_memory()
+        await self.memory_manager.reset_context()
+        agent_logger.info("All agent memory has been reset.")
+        
+    async def process_messages(self, messages: List[Dict[str, str]]) -> Dict[str, Any]:
+        """Process incoming messages and generate a response with tool usage."""
+        await self.initialize()
+        agent_logger.info(f"Processing {len(messages)} messages.")
+
+        for msg in messages:
+            content = f"{msg['username']}: {msg['text']}"
+            await self.memory_manager.add_context_entry("user", content)
+        
+        context_messages = await self.memory_manager.get_recent_context()
+        await connection_manager.broadcast({"type": "agent_context", "action": "update", "messages": context_messages})
+        
+        processing_entry_id = await self.memory_manager.add_detailed_context_entry(
+            input_messages=messages, prompt="Processing started", llm_response="",
+            tool_executions=[], final_response="Processing started"
+        )
+            
+        context = await self.memory_manager.get_full_context()
+        tool_descriptions = self.tool_manager.get_tool_descriptions()
+        
+        # --- CORRECTED HISTORY GATHERING ---
+        recent_history = await self.memory_manager.get_detailed_context_history()
+        assistant_responses = []
+        for entry in reversed(recent_history):
+            if entry.get("type") == "llm_interaction":
+                for tool in entry.get("tool_executions", []):
+                    if tool.get("name") == "speak" and tool.get("result"):
+                        assistant_responses.append(tool["result"])
+
+        # Create LLM prompt from template
+        template_path = Path(self.memory_manager.memory_dir).parent / "prompt_template.txt"
+        with open(template_path, 'r', encoding='utf-8') as f:
+            prompt_template = f.read()
+
+        recent_speak_history_text = "\n".join([f"- {response}" for response in assistant_responses[:5]]) if assistant_responses else "You haven't said anything yet."
+        user_messages_text = "\n".join([f"{msg['username']}: {msg['text']}" for msg in messages])
+
+        prompt = prompt_template.format(
+            full_context=context,
+            tool_descriptions=tool_descriptions,
+            recent_speak_history=recent_speak_history_text,
+            user_messages=user_messages_text
+        )
+        
+        await self.memory_manager.add_detailed_context_entry(
+            input_messages=messages, prompt=prompt, llm_response="", tool_executions=[],
+            final_response="Prompt sent to LLM", entry_id=processing_entry_id
+        )
+        
+        response_text = await self.llm_client.generate(prompt)
+        agent_logger.debug(f"LLM raw response: {response_text[:100] if response_text else 'None'}...")
+        
+        await self.memory_manager.add_detailed_context_entry(
+            input_messages=messages, prompt=prompt, llm_response=response_text, tool_executions=[],
+            final_response="LLM response received", entry_id=processing_entry_id
+        )
+        
+        processing_result = {
+            "input_messages": messages, "llm_response": response_text,
+            "tool_executions": [], "final_response": ""
+        }
+        
+        if response_text:
+            tool_calls = self._parse_tool_calls(response_text)
+            for tool_call in tool_calls:
+                agent_logger.info(f"Executing tool: {tool_call['name']}")
+                await self._execute_parsed_tool(tool_call, processing_result)
+
+        await self.memory_manager.add_detailed_context_entry(
+            input_messages=messages, prompt=prompt, llm_response=response_text,
+            tool_executions=processing_result["tool_executions"],
+            final_response=processing_result["final_response"], entry_id=processing_entry_id
+        )
+            
+        final_context = await self.memory_manager.get_recent_context()
+        await connection_manager.broadcast({"type": "agent_context", "action": "update", "messages": final_context})
+            
+        agent_logger.info("Message processing completed.")
+        return processing_result
+        
+    async def _execute_parsed_tool(self, tool_call: Dict[str, Any], processing_result: Dict[str, Any]):
+        """Execute a parsed tool call and update processing result."""
+        try:
+            tool_result = await self.execute_tool(tool_call["name"], tool_call["params"])
+            tool_call["result"] = tool_result
+            if tool_call["name"] == "speak":
+                processing_result["final_response"] = tool_call["params"].get("text", "")
+            processing_result["tool_executions"].append(tool_call)
+        except Exception as e:
+            tool_call["error"] = str(e)
+            processing_result["tool_executions"].append(tool_call)
+            agent_logger.error(f"Error executing tool {tool_call['name']}: {e}")
+            
+    def _parse_tool_calls(self, text: str) -> List[Dict[str, Any]]:
+        """Parse tool calls using ast.literal_eval for robustness."""
+        import ast
+        calls = []
+        text = text.strip()
+        if text.startswith("speak(") and text.endswith(")"):
+            try:
+                # Extract the content inside speak(...)
+                # e.g., "text='Hello, I'm here'"
+                inner_content = text[len("speak("):-1].strip()
+
+                # Ensure it's a text=... call
+                if not inner_content.startswith("text="):
+                    return []
+                
+                # Get the quoted string part
+                quoted_string = inner_content[len("text="):
+].strip()
+
+                # Use ast.literal_eval to safely parse the Python string literal
+                parsed_text = ast.literal_eval(quoted_string)
+                
+                if isinstance(parsed_text, str):
+                    calls.append({
+                        "name": "speak",
+                        "params": {"text": parsed_text}
+                    })
+
+            except (ValueError, SyntaxError, TypeError) as e:
+                agent_logger.warning(f"Could not parse tool call using ast.literal_eval: {text}. Error: {e}")
+
+        return calls
+        
+    async def execute_tool(self, tool_name: str, params: Dict[str, Any]) -> Any:
+        """Execute a registered tool."""
+        await self.initialize()
+        agent_logger.debug(f"Executing tool: {tool_name} with params: {params}")
+        result = await self.tool_manager.execute_tool(tool_name, params)
+        agent_logger.debug(f"Tool execution result: {result}")
+        return result

neuro_simulator-0.2.1/neuro_simulator/agent/factory.py

@@ -0,0 +1,30 @@
+# agent/factory.py
+"""Factory for creating agent instances"""
+
+from .base import BaseAgent
+from ..config import config_manager
+
+
+async def create_agent() -> BaseAgent:
+    """Create an agent instance based on the configuration"""
+    agent_type = config_manager.settings.agent_type
+    
+    if agent_type == "builtin":
+        from ..builtin_agent import local_agent, BuiltinAgentWrapper, initialize_builtin_agent
+        if local_agent is None:
+            # Try to initialize the builtin agent
+            await initialize_builtin_agent()
+            # Re-import local_agent after initialization
+            from ..builtin_agent import local_agent
+            if local_agent is None:
+                raise RuntimeError("Failed to initialize Builtin agent")
+        return BuiltinAgentWrapper(local_agent)
+    elif agent_type == "letta":
+        from ..letta import get_letta_agent, initialize_letta_client
+        # Try to initialize the letta client
+        initialize_letta_client()
+        agent = get_letta_agent()
+        await agent.initialize()
+        return agent
+    else:
+        raise ValueError(f"Unknown agent type: {agent_type}")