Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills.
Python agent-contextagent-memoryagent-pluginsagentic-ragcontext-databasedsh-pluginknowledge-basememorymemory-managementself-evolvingvector-database
Feature/vikingbot_opt: OpenAPI interface standardization;Feishu multi-user experience; observability enhancements; configuration system modernization. (#419)
chenjw1b175344e8ff
diff --git a/bot/.coveragerc b/bot/.coveragercnew file mode 100644index 000000000..ff75cef6c--- /dev/null+++ b/bot/.coveragerc@@ -0,0 +1,26 @@+[run]+source = vikingbot+omit =+ */tests/*+ */test_*+ */__pycache__/*+ */venv/*+ */.venv/*+ */node_modules/*+ setup.py++[report]+exclude_lines =+ pragma: no cover+ def __repr__+ raise AssertionError+ raise NotImplementedError+ if __name__ == .__main__.:+ class .*\bProtocol\):+ @(abc\.)?abstractmethod++show_missing = True+skip_covered = False++[html]+directory = htmlcovdiff --git a/bot/.github/workflows/test.yml b/bot/.github/workflows/test.ymlnew file mode 100644index 000000000..5b9c8c213--- /dev/null+++ b/bot/.github/workflows/test.yml@@ -0,0 +1,72 @@+name: Tests++on:+ push:+ branches: [main, develop]+ pull_request:+ branches: [main, develop]++jobs:+ test:+ runs-on: ubuntu-latest+ strategy:+ matrix:+ python-version: ["3.10", "3.11", "3.12"]++ steps:+ - name: Checkout code+ uses: actions/checkout@v4++ - name: Set up Python ${{ matrix.python-version }}+ uses: actions/setup-python@v5+ with:+ python-version: ${{ matrix.python-version }}++ - name: Install uv+ uses: astral-sh/setup-uv@v3+ with:+ version: "latest"++ - name: Install dependencies+ run: |+ uv pip install -e ".[dev]"++ - name: Run tests with coverage+ run: |+ pytest --cov=vikingbot --cov-report=xml --cov-report=term-missing -v++ - name: Upload coverage to Codecov+ uses: codecov/codecov-action@v4+ with:+ file: ./coverage.xml+ flags: unittests+ name: codecov-umbrella++ lint:+ runs-on: ubuntu-latest++ steps:+ - name: Checkout code+ uses: actions/checkout@v4++ - name: Set up Python+ uses: actions/setup-python@v5+ with:+ python-version: "3.11"++ - name: Install uv+ uses: astral-sh/setup-uv@v3+ with:+ version: "latest"++ - name: Install dependencies+ run: |+ uv pip install ruff++ - name: Run ruff check+ run: |+ ruff check .++ - name: Run ruff format check+ run: |+ ruff format --check .diff --git a/bot/CHANNEL.md b/bot/CHANNEL.mdnew file mode 100644index 000000000..61eabbc9c--- /dev/null+++ b/bot/CHANNEL.md@@ -0,0 +1,414 @@+## 💬 聊天应用++通过 Telegram、Discord、WhatsApp、飞书、Mochat、钉钉、Slack、邮件或 QQ 与您的 vikingbot 对话 —— 随时随地。++| 渠道 | 设置难度 |+|---------|-------|+| **Telegram** | 简单(只需一个令牌) |+| **Discord** | 简单(机器人令牌 + 权限) |+| **WhatsApp** | 中等(扫描二维码) |+| **飞书** | 中等(应用凭证) |+| **Mochat** | 中等(claw 令牌 + websocket) |+| **钉钉** | 中等(应用凭证) |+| **Slack** | 中等(机器人 + 应用令牌) |+| **邮件** | 中等(IMAP/SMTP 凭证) |+| **QQ** | 简单(应用凭证) |++<details>+<summary><b>Telegram</b>(推荐)</summary>++**1. 创建机器人**+- 打开 Telegram,搜索 `@BotFather`+- 发送 `/newbot`,按照提示操作+- 复制令牌++**2. 配置**++```json+{+ "channels": [+ {+ "type": "telegram",+ "enabled": true,+ "token": "YOUR_BOT_TOKEN",+ "allowFrom": ["YOUR_USER_ID"]+ }+ ]+}+```++> 您可以在 Telegram 设置中找到您的 **用户 ID**。它显示为 `@yourUserId`。+> 复制这个值**不带 `@` 符号**并粘贴到配置文件中。+++**3. 运行**++```bash+vikingbot gateway+```++</details>++<details>+<summary><b>Mochat (Claw IM)</b></summary>++默认使用 **Socket.IO WebSocket**,并带有 HTTP 轮询回退。++**1. 让 vikingbot 为您设置 Mochat**++只需向 vikingbot 发送此消息(将 `xxx@xxx` 替换为您的真实邮箱):++```+Read https://raw.githubusercontent.com/HKUDS/MoChat/refs/heads/main/skills/vikingbot/skill.md and register on MoChat. My Email account is xxx@xxx Bind me as your owner and DM me on MoChat.+```++vikingbot 将自动注册、配置 `~/.vikingbot/config.json` 并连接到 Mochat。++**2. 重启网关**++```bash+vikingbot gateway+```++就这么简单 —— vikingbot 处理剩下的一切!++<br>++<details>+<summary>手动配置(高级)</summary>++如果您更喜欢手动配置,请将以下内容添加到 `~/.vikingbot/config.json`:++> 请保密 `claw_token`。它只应在 `X-Claw-Token` 头中发送到您的 Mochat API 端点。++```json+{+ "channels": [+ {+ "type": "mochat",+ "enabled": true,+ "base_url": "https://mochat.io",+ "socket_url": "https://mochat.io",+ "socket_path": "/socket.io",+ "claw_token": "claw_xxx",+ "agent_user_id": "6982abcdef",+ "sessions": ["*"],+ "panels": ["*"],+ "reply_delay_mode": "non-mention",+ "reply_delay_ms": 120000+ }+ ]+}+```+++</details>++</details>++<details>+<summary><b>Discord</b></summary>++**1. 创建机器人**+- 访问 https://discord.com/developers/applications+- 创建应用 → 机器人 → 添加机器人+- 复制机器人令牌++**2. 启用意图**+- 在机器人设置中,启用 **MESSAGE CONTENT INTENT**+- (可选)如果您计划使用基于成员数据的允许列表,启用 **SERVER MEMBERS INTENT**++**3. 获取您的用户 ID**+- Discord 设置 → 高级 → 启用 **开发者模式**+- 右键点击您的头像 → **复制用户 ID**++**4. 配置**++```json+{+ "channels": [+ {+ "type": "discord",+ "enabled": true,+ "token": "YOUR_BOT_TOKEN",+ "allowFrom": ["YOUR_USER_ID"]+ }+ ]+}+```++**5. 邀请机器人**+- OAuth2 → URL 生成器+- 范围:`bot`+- 机器人权限:`发送消息`、`读取消息历史`+- 打开生成的邀请 URL 并将机器人添加到您的服务器++**6. 运行**++```bash+vikingbot gateway+```++</details>++<details>+<summary><b>WhatsApp</b></summary>++需要 **Node.js ≥18**。++**1. 链接设备**++```bash+vikingbot channels login+# 使用 WhatsApp 扫描二维码 → 设置 → 链接设备+```++**2. 配置**++```json+{+ "channels": [+ {+ "type": "whatsapp",+ "enabled": true,+ "allowFrom": ["+1234567890"]+ }+ ]+}+```++**3. 运行**(两个终端)++```bash+# 终端 1+vikingbot channels login++# 终端 2+vikingbot gateway+```++</details>++<details>+<summary><b>飞书</b></summary>++使用 **WebSocket** 长连接 —— 不需要公网 IP。++**1. 创建飞书机器人**+- 访问 [飞书开放平台](https://open.feishu.cn/app)+- 创建新应用 → 启用 **机器人** 功能+- **权限**:添加 `im:message`(发送消息)+- **事件**:添加 `im.message.receive_v1`(接收消息)+ - 选择 **长连接** 模式(需要先运行 vikingbot 来建立连接)+- 从「凭证与基础信息」获取 **App ID** 和 **App Secret**+- 发布应用++**2. 配置**++```json+{+ "channels": [+ {+ "type": "feishu",+ "enabled": true,+ "appId": "cli_xxx",+ "appSecret": "xxx",+ "encryptKey": "",+ "verificationToken": "",+ "allowFrom": []+ }+ ]+}+```++> 长连接模式下,`encryptKey` 和 `verificationToken` 是可选的。+> `allowFrom`:留空以允许所有用户,或添加 `["ou_xxx"]` 以限制访问。++**3. 运行**++```bash+vikingbot gateway+```++> [!TIP]+> 飞书使用 WebSocket 接收消息 —— 不需要 webhook 或公网 IP!++</details>++<details>+<summary><b>QQ(QQ单聊)</b></summary>++使用 **botpy SDK** 配合 WebSocket —— 不需要公网 IP。目前仅支持 **私聊**。++**1. 注册并创建机器人**+- 访问 [QQ 开放平台](https://q.qq.com) → 注册为开发者(个人或企业)+- 创建新的机器人应用+- 进入 **开发设置** → 复制 **AppID** 和 **AppSecret**++**2. 设置沙箱测试环境**+- 在机器人管理控制台中,找到 **沙箱配置**+- 在 **在消息列表配置** 下,点击 **添加成员** 并添加您自己的 QQ 号+- 添加完成后,用手机 QQ 扫描机器人的二维码 → 打开机器人资料卡 → 点击「发消息」开始聊天++**3. 配置**++> - `allowFrom`:留空以供公开访问,或添加用户 openid 以限制。您可以在用户向机器人发消息时在 vikingbot 日志中找到 openid。+> - 生产环境:在机器人控制台提交审核并发布。查看 [QQ 机器人文档](https://bot.q.qq.com/wiki/) 了解完整发布流程。++```json+{+ "channels": [+ {+ "type": "qq",+ "enabled": true,+ "appId": "YOUR_APP_ID",+ "secret": "YOUR_APP_SECRET",+ "allowFrom": []+ }+ ]+}+```++**4. 运行**++```bash+vikingbot gateway+```++现在从 QQ 向机器人发送消息 —— 它应该会回复!++</details>++<details>+<summary><b>钉钉</b></summary>++使用 **流模式** —— 不需要公网 IP。++**1. 创建钉钉机器人**+- 访问 [钉钉开放平台](https://open-dev.dingtalk.com/)+- 创建新应用 -> 添加 **机器人** 功能+- **配置**:+ - 打开 **流模式**+- **权限**:添加发送消息所需的权限+- 从「凭证」获取 **AppKey**(客户端 ID)和 **AppSecret**(客户端密钥)+- 发布应用++**2. 配置**++```json+{+ "channels": [+ {+ "type": "dingtalk",+ "enabled": true,+ "clientId": "YOUR_APP_KEY",+ "clientSecret": "YOUR_APP_SECRET",+ "allowFrom": []+ }+ ]+}+```++> `allowFrom`:留空以允许所有用户,或添加 `["staffId"]` 以限制访问。++**3. 运行**++```bash+vikingbot gateway+```++</details>++<details>+<summary><b>Slack</b></summary>++使用 **Socket 模式** —— 不需要公网 URL。++**1. 创建 Slack 应用**+- 访问 [Slack API](https://api.slack.com/apps) → **创建新应用** →「从零开始」+- 选择名称并选择您的工作区++**2. 配置应用**+- **Socket 模式**:打开 → 生成一个具有 `connections:write` 范围的 **应用级令牌** → 复制它(`xapp-...`)+- **OAuth 与权限**:添加机器人范围:`chat:write`、`reactions:write`、`app_mentions:read`+- **事件订阅**:打开 → 订阅机器人事件:`message.im`、`message.channels`、`app_mention` → 保存更改+- **应用主页**:滚动到 **显示标签页** → 启用 **消息标签页** → 勾选 **"允许用户从消息标签页发送斜杠命令和消息"**+- **安装应用**:点击 **安装到工作区** → 授权 → 复制 **机器人令牌**(`xoxb-...`)++**3. 配置 vikingbot**++```json+{+ "channels": [+ {+ "type": "slack",+ "enabled": true,+ "botToken": "xoxb-...",+ "appToken": "xapp-...",+ "groupPolicy": "mention"+ }+ ]+}+```++**4. 运行**++```bash+vikingbot gateway+```++直接向机器人发送私信或在频道中 @提及它 —— 它应该会回复!++> [!TIP]+> - `groupPolicy`:`"mention"`(默认 —— 仅在 @提及時回复)、`"open"`(回复所有频道消息)或 `"allowlist"`(限制到特定频道)。+> - 私信策略默认为开放。设置 `"dm": {"enabled": false}` 以禁用私信。++</details>++<details>+<summary><b>邮件</b></summary>++给 vikingbot 一个自己的邮箱账户。它通过 **IMAP** 轮询收件箱并通过 **SMTP** 回复 —— 就像一个个人邮件助手。++**1. 获取凭证(Gmail 示例)**+- 为您的机器人创建一个专用的 Gmail 账户(例如 `[email protected]`)+- 启用两步验证 → 创建 [应用密码](https://myaccount.google.com/apppasswords)+- 将此应用密码用于 IMAP 和 SMTP++**2. 配置**++> - `consentGranted` 必须为 `true` 以允许邮箱访问。这是一个安全门 —— 设置为 `false` 以完全禁用。+> - `allowFrom`:留空以接受来自任何人的邮件,或限制到特定发件人。+> - `smtpUseTls` 和 `smtpUseSsl` 分别默认为 `true` / `false`,这对 Gmail(端口 587 + STARTTLS)是正确的。无需显式设置它们。+> - 如果您只想读取/分析邮件而不发送自动回复,请设置 `"autoReplyEnabled": false`。++```json+{+ "channels": [+ {+ "type": "email",+ "enabled": true,+ "consentGranted": true,+ "imapHost": "imap.gmail.com",+ "imapPort": 993,+ "imapUsername": "[email protected]",+ "imapPassword": "your-app-password",+ "smtpHost": "smtp.gmail.com",+ "smtpPort": 587,+ "smtpUsername": "[email protected]",+ "smtpPassword": "your-app-password",+ "fromAddress": "[email protected]",+ "allowFrom": ["[email protected]"]+ }+ ]+}+```+++**3. 运行**++```bash+vikingbot gateway+```++</details>\ No newline at end of filediff --git a/bot/README.md b/bot/README.mdindex da0993bbf..c8e88a5cb 100644--- a/bot/README.md+++ b/bot/README.md@@ -31,8 +31,38 @@ uv venv --python 3.11source .venv/bin/activate # macOS/Linux# .venv\Scripts\activate # Windows-# Install dependencies+# Install dependencies (minimal)uv pip install -e .++# Or install with optional features+uv pip install -e ".[langfuse,telegram,console]"+```++### Optional Dependencies++Install only the features you need:++| Feature Group | Install Command | Description |+|---------------|-----------------|-------------|+| **Full** | `uv pip install -e ".[full]"` | All features included |+| **Langfuse** | `uv pip install -e ".[langfuse]"` | LLM observability and tracing |+| **FUSE** | `uv pip install -e ".[fuse]"` | OpenViking filesystem mount |+| **Sandbox** | `uv pip install -e ".[sandbox]"` | Code execution sandbox |+| **OpenCode** | `uv pip install -e ".[opencode]"` | OpenCode AI integration |++#### Channels (chat apps)++| Channel | Install Command |+|---------|-----------------|+| **Telegram** | `uv pip install -e ".[telegram]"` |+| **Feishu/Lark** | `uv pip install -e ".[feishu]"` |+| **DingTalk** | `uv pip install -e ".[dingtalk]"` |+| **Slack** | `uv pip install -e ".[slack]"` |+| **QQ** | `uv pip install -e ".[qq]"` |++Multiple features can be combined:+```bash+uv pip install -e ".[langfuse,telegram,console]"```## 🚀 Quick Start@@ -48,7 +78,7 @@ vikingbot gateway```This will automatically:-- Create a default config at `~/.vikingbot/config.json`+- Create a default config at `~/.openviking/ov.conf`- Start the Console Web UI at http://localhost:18791**2. Configure via Console**@@ -61,7 +91,17 @@ Open http://localhost:18791 in your browser and:**3. Chat**```bash-vikingbot agent -m "What is 2+2?"+# Send a single message directly+vikingbot chat -m "What is 2+2?"++# Enter interactive chat mode (supports multi-turn conversations)+vikingbot chat++# Show plain-text replies (no Markdown rendering)+vikingbot chat --no-markdown++# Show runtime logs during chat (useful for debugging)+vikingbot chat --logs```That's it! You have a working AI assistant in 2 minutes.@@ -70,17 +110,6 @@ That's it! You have a working AI assistant in 2 minutes.You can also deploy vikingbot using Docker for easier setup and isolation.-## ☁️ Volcengine VKE Deployment--If you want to deploy vikingbot on Volcengine Kubernetes Engine (VKE), see the detailed deployment guide:--👉 [VKE Deployment Guide (Chinese)](deploy/vke/README.md)--The guide includes:-- Complete prerequisites-- How to create Volcengine account, VKE cluster, container registry, and TOS bucket-- One-click deployment script usage-- Configuration details and troubleshooting### PrerequisitesFirst, install Docker:@@ -93,7 +122,6 @@ Verify Docker installation:docker --version```-### Quick Volcengine Registry Deploy (Recommended)### Quick Docker Deploy```bash@@ -105,7 +133,7 @@ docker run -d \--name vikingbot \--restart unless-stopped \--platform linux/amd64 \- -v ~/.vikingbot:/root/.vikingbot \+ -v ~/.openviking:/root/.openviking \-p 18791:18791 \vikingbot-cn-beijing.cr.volces.com/vikingbot/vikingbot:latest \gateway@@ -161,14 +189,16 @@ Talk to your vikingbot through Telegram, Discord, WhatsApp, Feishu, Mochat, Ding```json{- "channels": [- {- "type": "telegram",- "enabled": true,- "token": "YOUR_BOT_TOKEN",- "allowFrom": ["YOUR_USER_ID"]- }- ]+ "bot": {+ "channels": [+ {+ "type": "telegram",+ "enabled": true,+ "token": "YOUR_BOT_TOKEN",+ "allowFrom": ["YOUR_USER_ID"]+ }+ ]+ }}```@@ -197,7 +227,7 @@ Simply send this message to vikingbot (replace `xxx@xxx` with your real email):Read https://raw.githubusercontent.com/HKUDS/MoChat/refs/heads/main/skills/vikingbot/skill.md and register on MoChat. My Email account is xxx@xxx Bind me as your owner and DM me on MoChat.```-vikingbot will automatically register, configure `~/.vikingbot/config.json`, and connect to Mochat.+vikingbot will automatically register, configure `~/.openviking/ov.conf`, and connect to Mochat.**2. Restart gateway**@@ -212,27 +242,29 @@ That's it — vikingbot handles the rest!<details><summary>Manual configuration (advanced)</summary>-If you prefer to configure manually, add the following to `~/.vikingbot/config.json`:+If you prefer to configure manually, add the following to `~/.openviking/ov.conf`:> Keep `claw_token` private. It should only be sent in `X-Claw-Token` header to your Mochat API endpoint.```json{- "channels": [- {- "type": "mochat",- "enabled": true,- "base_url": "https://mochat.io",- "socket_url": "https://mochat.io",- "socket_path": "/socket.io",- "claw_token": "claw_xxx",- "agent_user_id": "6982abcdef",- "sessions": ["*"],- "panels": ["*"],- "reply_delay_mode": "non-mention",- "reply_delay_ms": 120000- }- ]+ "bot": {+ "channels": [+ {+ "type": "mochat",+ "enabled": true,+ "base_url": "https://mochat.io",+ "socket_url": "https://mochat.io",+ "socket_path": "/socket.io",+ "claw_token": "claw_xxx",+ "agent_user_id": "6982abcdef",+ "sessions": ["*"],+ "panels": ["*"],+ "reply_delay_mode": "non-mention",+ "reply_delay_ms": 120000+ }+ ]+ }}```@@ -262,14 +294,16 @@ If you prefer to configure manually, add the following to `~/.vikingbot/config.j```json{- "channels": [- {- "type": "discord",- "enabled": true,- "token": "YOUR_BOT_TOKEN",- "allowFrom": ["YOUR_USER_ID"]- }- ]+ "bot": {+ "channels": [+ {+ "type": "discord",+ "enabled": true,+ "token": "YOUR_BOT_TOKEN",+ "allowFrom": ["YOUR_USER_ID"]+ }+ ]+ }}```@@ -303,13 +337,15 @@ vikingbot channels login```json{- "channels": [- {- "type": "whatsapp",- "enabled": true,- "allowFrom": ["+1234567890"]- }- ]+ "bot": {+ "channels": [+ {+ "type": "whatsapp",+ "enabled": true,+ "allowFrom": ["+1234567890"]+ }+ ]+ }}```@@ -343,17 +379,19 @@ Uses **WebSocket** long connection — no public IP required.```json{- "channels": [- {- "type": "feishu",- "enabled": true,- "appId": "cli_xxx",- "appSecret": "xxx",- "encryptKey": "",- "verificationToken": "",- "allowFrom": []- }- ]+ "bot": {+ "channels": [+ {+ "type": "feishu",+ "enabled": true,+ "appId": "cli_xxx",+ "appSecret": "xxx",+ "encryptKey": "",+ "verificationToken": "",+ "allowFrom": []+ }+ ]+ }}```@@ -393,15 +431,17 @@ Uses **botpy SDK** with WebSocket — no public IP required. Currently supports```json{- "channels": [- {- "type": "qq",- "enabled": true,- "appId": "YOUR_APP_ID",- "secret": "YOUR_APP_SECRET",- "allowFrom": []- }- ]+ "bot": {+ "channels": [+ {+ "type": "qq",+ "enabled": true,+ "appId": "YOUR_APP_ID",+ "secret": "YOUR_APP_SECRET",+ "allowFrom": []+ }+ ]+ }}```@@ -433,15 +473,17 @@ Uses **Stream Mode** — no public IP required.```json{- "channels": [- {- "type": "dingtalk",- "enabled": true,- "clientId": "YOUR_APP_KEY",- "clientSecret": "YOUR_APP_SECRET",- "allowFrom": []- }- ]+ "bot": {+ "channels": [+ {+ "type": "dingtalk",+ "enabled": true,+ "clientId": "YOUR_APP_KEY",+ "clientSecret": "YOUR_APP_SECRET",+ "allowFrom": []+ }+ ]+ }}```@@ -475,15 +517,17 @@ Uses **Socket Mode** — no public URL required.```json{- "channels": [- {- "type": "slack",- "enabled": true,- "botToken": "xoxb-...",- "appToken": "xapp-...",- "groupPolicy": "mention"- }- ]+ "bot": {+ "channels": [+ {+ "type": "slack",+ "enabled": true,+ "botToken": "xoxb-...",+ "appToken": "xapp-...",+ "groupPolicy": "mention"+ }+ ]+ }}```@@ -520,23 +564,25 @@ Give vikingbot its own email account. It polls **IMAP** for incoming mail and re```json{- "channels": [- {- "type": "email",- "enabled": true,- "consentGranted": true,- "imapHost": "imap.gmail.com",- "imapPort": 993,- "imapUsername": "[email protected]",- "imapPassword": "your-app-password",- "smtpHost": "smtp.gmail.com",- "smtpPort": 587,- "smtpUsername": "[email protected]",- "smtpPassword": "your-app-password",- "fromAddress": "[email protected]",- "allowFrom": ["[email protected]"]- }- ]+ "bot": {+ "channels": [+ {+ "type": "email",+ "enabled": true,+ "consentGranted": true,+ "imapHost": "imap.gmail.com",+ "imapPort": 993,+ "imapUsername": "[email protected]",+ "imapPassword": "your-app-password",+ "smtpHost": "smtp.gmail.com",+ "smtpPort": 587,+ "smtpUsername": "[email protected]",+ "smtpPassword": "your-app-password",+ "fromAddress": "[email protected]",+ "allowFrom": ["[email protected]"]+ }+ ]+ }}```@@ -562,31 +608,32 @@ Simply send the command above to your vikingbot (via CLI or any chat channel), a## ⚙️ Configuration-Config file: `~/.vikingbot/config.json`+Config file: `~/.openviking/ov.conf`> [!IMPORTANT]> After modifying the configuration (either via Console UI or by editing the file directly),> you need to restart the gateway service for changes to take effect.+> [!NOTE]+> Configuration has been migrated from `~/.vikingbot/config.json` to `~/.openviking/ov.conf`.+> The configuration is now nested under the `bot` key.+### Manual Configuration (Advanced)If you prefer to edit the config file directly instead of using the Console UI:```json{- "providers": {- "openai": {- "apiKey": "sk-xxx"- }- },- "agents": {- "defaults": {+ "bot": {+ "agents": {"model": "openai/doubao-seed-2-0-pro-260215"}}}```+Provider configuration is read from OpenViking config (`vlm` section in `ov.conf`).+### Providers> [!TIP]@@ -661,62 +708,198 @@ That's it! Environment variables, model prefixing, config matching, and `vikingb| `tools.restrictToWorkspace` | `true` | When `true`, restricts **all** agent tools (shell, file read/write/edit, list) to the workspace directory. Prevents path traversal and out-of-scope access. || `channels.*.allowFrom` | `[]` (allow all) | Whitelist of user IDs. Empty = allow everyone; non-empty = only listed users can interact. |+### Observability (Optional)++**Langfuse** integration for LLM observability and tracing.++<details>+<summary><b>Langfuse Configuration</b></summary>++**Option 1: Local Deployment (Recommended for testing)**++Deploy Langfuse locally using Docker:++```bash+# Navigate to the deployment script+cd deploy/docker++# Run the deployment script+./deploy_langfuse.sh+```++This will start Langfuse locally at `http://localhost:3000` with pre-configured credentials.++**Option 2: Langfuse Cloud**++1. Sign up at [langfuse.com](https://langfuse.com)+2. Create a new project+3. Copy the **Secret Key** and **Public Key** from project settings++**Configuration**++Add to `~/.openviking/ov.conf`:++```json+{+ "langfuse": {+ "enabled": true,+ "secret_key": "sk-lf-vikingbot-secret-key-2026",+ "public_key": "pk-lf-vikingbot-public-key-2026",+ "base_url": "http://localhost:3000"+ }+}+```++For Langfuse Cloud, use `https://cloud.langfuse.com` as the `base_url`.++**Install Langfuse support:**+```bash+uv pip install -e ".[langfuse]"+```++**Restart vikingbot:**+```bash+vikingbot gateway+```++**Features enabled:**+- Automatic trace creation for each conversation+- Session and user tracking+- LLM call monitoring+- Token usage tracking++</details>+### Sandbox-vikingbot supports sandboxed execution for enhanced security. By default, sandbox is disabled. To enable sandbox with SRT backend in per-session mode, set `"enabled": true`.+vikingbot supports sandboxed execution for enhanced security.++**By default, no sandbox configuration is needed in `ov.conf`:**+- Default backend: `direct` (runs code directly on host)+- Default mode: `shared` (single sandbox shared across all sessions)++You only need to add sandbox configuration when you want to change these defaults.<details>-<summary><b>Sandbox Configuration (SRT Backend)</b></summary>+<summary><b>Sandbox Configuration Options</b></summary>++**To use a different backend or mode:**+```json+{+ "sandbox": {+ "backend": "opensandbox",+ "mode": "per-session"+ }+}+```++**Available Backends:**+| Backend | Description |+|---------|-------------|+| `direct` | (Default) Runs code directly on the host |+| `docker` | Uses Docker containers for isolation |+| `opensandbox` | Uses OpenSandbox service |+| `srt` | Uses Anthropic's SRT sandbox runtime |+| `aiosandbox` | Uses AIO Sandbox service |++**Available Modes:**+| Mode | Description |+|------|-------------|+| `shared` | (Default) Single sandbox shared across all sessions |+| `per-session` | Separate sandbox instance for each session |++**Backend-specific Configuration (only needed when using that backend):**++**Direct Backend:**+```json+{+ "sandbox": {+ "backends": {+ "direct": {+ "restrictToWorkspace": false+ }+ }+ }+}+```++**OpenSandbox Backend:**+```json+{+ "sandbox": {+ "backend": "opensandbox",+ "backends": {+ "opensandbox": {+ "serverUrl": "http://localhost:18792",+ "apiKey": "",+ "defaultImage": "opensandbox/code-interpreter:v1.0.1"+ }+ }+ }+}+```++**Docker Backend:**+```json+{+ "sandbox": {+ "backend": "docker",+ "backends": {+ "docker": {+ "image": "python:3.11-slim",+ "networkMode": "bridge"+ }+ }+ }+}+```+**SRT Backend:**```json{"sandbox": {- "enabled": false,"backend": "srt",- "mode": "per-session",- "network": {- "allowedDomains": [],- "deniedDomains": [],- "allowLocalBinding": false- },- "filesystem": {- "denyRead": [],- "allowWrite": [],- "denyWrite": []- },- "runtime": {- "cleanupOnExit": true,- "timeout": 300- },"backends": {"srt": {- "nodePath": "node"+ "settingsPath": "~/.vikingbot/srt-settings.json",+ "nodePath": "node",+ "network": {+ "allowedDomains": [],+ "deniedDomains": [],+ "allowLocalBinding": false+ },+ "filesystem": {+ "denyRead": [],+ "allowWrite": [],+ "denyWrite": []+ },+ "runtime": {+ "cleanupOnExit": true,+ "timeout": 300+ }}}}}```-**Configuration Options:**--| Option | Default | Description |-|--------|---------|-------------|-| `enabled` | `false` | Enable sandbox execution |-| `backend` | `"srt"` | Sandbox backend: `srt` or `docker` |-| `mode` | `"per-session"` | Sandbox mode: `per-session` (isolated per session) or `shared` (shared across sessions) |-| `network.allowedDomains` | `[]` | List of allowed domains for network access (empty = all allowed) |-| `network.deniedDomains` | `[]` | List of denied domains (blocked regardless of allowed list) |-| `network.allowLocalBinding` | `false` | Allow binding to local addresses (localhost, 127.0.0.1) |-| `filesystem.denyRead` | `[]` | Paths/files to deny read access |-| `filesystem.allowWrite` | `[]` | Paths/files to explicitly allow write access |-| `filesystem.denyWrite` | `[]` | Paths/files to deny write access |-| `runtime.cleanupOnExit` | `true` | Clean up sandbox resources on exit |-| `runtime.timeout` | `300` | Command execution timeout in seconds |-| `backends.srt.nodePath` | `"/usr/local/bin/node"` | Path to Node.js executable (use full path if `node` is not in PATH) |+**AIO Sandbox Backend:**+```json+{+ "sandbox": {+ "backend": "aiosandbox",+ "backends": {+ "aiosandbox": {+ "baseUrl": "http://localhost:18794"+ }+ }+ }+}+```**SRT Backend Setup:**-The SRT backend uses `@anthropic-ai/sandbox-runtime`. It's automatically installed when you run `vikingbot onboard`.+The SRT backend uses `@anthropic-ai/sandbox-runtime`.**System Dependencies:**@@ -783,11 +966,10 @@ which nodejs| Command | Description ||---------|-------------|-| `vikingbot agent -m "..."` | Chat with the agent |-| `vikingbot agent` | Interactive chat mode |-| `vikingbot agent --no-markdown` | Show plain-text replies |-| `vikingbot agent --logs` | Show runtime logs during chat |-| `vikingbot tui` | Launch TUI (Terminal User Interface) |+| `vikingbot chat -m "..."` | Chat with the agent |+| `vikingbot chat` | Interactive chat mode |+| `vikingbot chat --no-markdown` | Show plain-text replies |+| `vikingbot chat --logs` | Show runtime logs during chat || `vikingbot gateway` | Start the gateway and Console Web UI || `vikingbot status` | Show status || `vikingbot channels login` | Link WhatsApp (scan QR) |@@ -810,23 +992,6 @@ The Console Web UI is automatically started when you run `vikingbot gateway`, acInteractive mode exits: `exit`, `quit`, `/exit`, `/quit`, `:q`, or `Ctrl+D`.-<details>-<summary><b>TUI (Terminal User Interface)</b></summary>--Launch the vikingbot TUI for a rich terminal-based chat experience:--```bash-vikingbot tui-```--The TUI provides:-- Rich text rendering with markdown support-- Message history and conversation management-- Real-time agent responses-- Keyboard shortcuts for navigation--</details>-<details><summary><b>Scheduled Tasks (Cron)</b></summary>diff --git a/bot/README_CN.md b/bot/README_CN.mdindex 7d8a4b79b..48f879663 100644--- a/bot/README_CN.md+++ b/bot/README_CN.md@@ -7,11 +7,11 @@Vikingbot 深度集成 OpenViking,提供强大的知识管理和记忆检索能力:-- **本地/远程双模式**:支持本地存储(`~/.vikingbot/ov_data/`)和远程服务器模式+- **本地/远程双模式**:支持本地存储(`~/.openviking/data/`)和远程服务器模式- **7 个专用 Agent 工具**:资源管理、语义搜索、正则搜索、通配符搜索、记忆搜索- **三级内容访问**:L0(摘要)、L1(概览)、L2(完整内容)- **会话记忆自动提交**:对话历史自动保存到 OpenViking-- **火山引擎 TOS 集成**:远程模式下支持云存储+- **模型配置**:从 OpenViking 配置(`vlm` 部分)读取,无需在 bot 配置中单独设置 provider## 📦 安装@@ -40,8 +40,38 @@ uv venv --python 3.11source .venv/bin/activate # macOS/Linux# .venv\Scripts\activate # Windows-# 安装依赖+# 安装依赖(最小化)uv pip install -e .++# 或安装包含可选功能+uv pip install -e ".[langfuse,telegram,console]"+```++### 可选依赖++只安装你需要的功能:++| 功能组 | 安装命令 | 描述 |+|---------------|-----------------|-------------|+| **完整版** | `uv pip install -e ".[full]"` | 包含所有功能 |+| **Langfuse** | `uv pip install -e ".[langfuse]"` | LLM 可观测性和追踪 |+| **FUSE** | `uv pip install -e ".[fuse]"` | OpenViking 文件系统挂载 |+| **沙箱** | `uv pip install -e ".[sandbox]"` | 代码执行沙箱 |+| **OpenCode** | `uv pip install -e ".[opencode]"` | OpenCode AI 集成 |++#### 聊天渠道++| 渠道 | 安装命令 |+|---------|-----------------|+| **Telegram** | `uv pip install -e ".[telegram]"` |+| **飞书/Lark** | `uv pip install -e ".[feishu]"` |+| **钉钉** | `uv pip install -e ".[dingtalk]"` |+| **Slack** | `uv pip install -e ".[slack]"` |+| **QQ** | `uv pip install -e ".[qq]"` |++可以组合多个功能:+```bash+uv pip install -e ".[langfuse,telegram,console]"```## 🚀 快速开始@@ -57,7 +87,8 @@ vikingbot gateway```这将自动:-- 在 `~/.vikingbot/config.json` 创建默认配置+- 在 `~/.openviking/ov.conf` 创建默认配置+- 在 openviking的工作空间下创建bot启动文件。默认路径为 `~/.openviking/data/bot/`- 在 http://localhost:18791 启动控制台 Web UI**2. 通过控制台配置**@@ -70,7 +101,17 @@ vikingbot gateway**3. 聊天**```bash-vikingbot agent -m "What is 2+2?"+# 直接发送单条消息+vikingbot chat -m "What is 2+2?"++# 进入交互式聊天模式(支持多轮对话)+vikingbot chat++# 显示纯文本回复(不渲染 Markdown)+vikingbot chat --no-markdown++# 聊天时显示运行时日志(便于调试)+vikingbot chat --logs```就这么简单!您只需 2 分钟就能拥有一个可用的 AI 助手。@@ -79,18 +120,6 @@ vikingbot agent -m "What is 2+2?"您也可以使用 Docker 部署 vikingbot,以便更轻松地设置和隔离。-## ☁️ 火山引擎 VKE 部署--如果您想在火山引擎容器服务(VKE)上部署 vikingbot,请查看详细的部署文档:--👉 [VKE 部署指南](deploy/vke/README.md)--该指南包含:-- 完整的前置准备步骤-- 火山引擎账号、VKE 集群、镜像仓库、TOS 存储桶的创建方法-- 一键部署脚本使用说明-- 配置详解和故障排查-### 前置要求首先安装 Docker:@@ -108,14 +137,14 @@ docker --version```bash# 1. 创建必要目录-mkdir -p ~/.vikingbot/+mkdir -p ~/.openviking/# 2. 启动容器docker run -d \--name vikingbot \--restart unless-stopped \--platform linux/amd64 \- -v ~/.vikingbot:/root/.vikingbot \+ -v ~/.openviking:/root/.openviking \-p 18791:18791 \vikingbot-cn-beijing.cr.volces.com/vikingbot/vikingbot:latest \gateway@@ -143,420 +172,10 @@ docker logs --tail 50 -f vikingbot更多 Docker 部署选项,请查看 [deploy/docker/README.md](deploy/docker/README.md)。-## 💬 聊天应用通过 Telegram、Discord、WhatsApp、飞书、Mochat、钉钉、Slack、邮件或 QQ 与您的 vikingbot 对话 —— 随时随地。-| 渠道 | 设置难度 |-|---------|-------|-| **Telegram** | 简单(只需一个令牌) |-| **Discord** | 简单(机器人令牌 + 权限) |-| **WhatsApp** | 中等(扫描二维码) |-| **飞书** | 中等(应用凭证) |-| **Mochat** | 中等(claw 令牌 + websocket) |-| **钉钉** | 中等(应用凭证) |-| **Slack** | 中等(机器人 + 应用令牌) |-| **邮件** | 中等(IMAP/SMTP 凭证) |-| **QQ** | 简单(应用凭证) |--<details>-<summary><b>Telegram</b>(推荐)</summary>--**1. 创建机器人**-- 打开 Telegram,搜索 `@BotFather`-- 发送 `/newbot`,按照提示操作-- 复制令牌--**2. 配置**--```json-{- "channels": [- {- "type": "telegram",- "enabled": true,- "token": "YOUR_BOT_TOKEN",- "allowFrom": ["YOUR_USER_ID"]- }- ]-}-```--> 您可以在 Telegram 设置中找到您的 **用户 ID**。它显示为 `@yourUserId`。-> 复制这个值**不带 `@` 符号**并粘贴到配置文件中。---**3. 运行**--```bash-vikingbot gateway-```--</details>--<details>-<summary><b>Mochat (Claw IM)</b></summary>--默认使用 **Socket.IO WebSocket**,并带有 HTTP 轮询回退。--**1. 让 vikingbot 为您设置 Mochat**--只需向 vikingbot 发送此消息(将 `xxx@xxx` 替换为您的真实邮箱):--```-Read https://raw.githubusercontent.com/HKUDS/MoChat/refs/heads/main/skills/vikingbot/skill.md and register on MoChat. My Email account is xxx@xxx Bind me as your owner and DM me on MoChat.-```--vikingbot 将自动注册、配置 `~/.vikingbot/config.json` 并连接到 Mochat。--**2. 重启网关**--```bash-vikingbot gateway-```--就这么简单 —— vikingbot 处理剩下的一切!--<br>--<details>-<summary>手动配置(高级)</summary>--如果您更喜欢手动配置,请将以下内容添加到 `~/.vikingbot/config.json`:--> 请保密 `claw_token`。它只应在 `X-Claw-Token` 头中发送到您的 Mochat API 端点。--```json-{- "channels": [- {- "type": "mochat",- "enabled": true,- "base_url": "https://mochat.io",- "socket_url": "https://mochat.io",- "socket_path": "/socket.io",- "claw_token": "claw_xxx",- "agent_user_id": "6982abcdef",- "sessions": ["*"],- "panels": ["*"],- "reply_delay_mode": "non-mention",- "reply_delay_ms": 120000- }- ]-}-```---</details>--</details>--<details>-<summary><b>Discord</b></summary>--**1. 创建机器人**-- 访问 https://discord.com/developers/applications-- 创建应用 → 机器人 → 添加机器人-- 复制机器人令牌--**2. 启用意图**-- 在机器人设置中,启用 **MESSAGE CONTENT INTENT**-- (可选)如果您计划使用基于成员数据的允许列表,启用 **SERVER MEMBERS INTENT**--**3. 获取您的用户 ID**-- Discord 设置 → 高级 → 启用 **开发者模式**-- 右键点击您的头像 → **复制用户 ID**--**4. 配置**--```json-{- "channels": [- {- "type": "discord",- "enabled": true,- "token": "YOUR_BOT_TOKEN",- "allowFrom": ["YOUR_USER_ID"]- }- ]-}-```--**5. 邀请机器人**-- OAuth2 → URL 生成器-- 范围:`bot`-- 机器人权限:`发送消息`、`读取消息历史`-- 打开生成的邀请 URL 并将机器人添加到您的服务器--**6. 运行**--```bash-vikingbot gateway-```--</details>--<details>-<summary><b>WhatsApp</b></summary>--需要 **Node.js ≥18**。--**1. 链接设备**--```bash-vikingbot channels login-# 使用 WhatsApp 扫描二维码 → 设置 → 链接设备-```--**2. 配置**--```json-{- "channels": [- {- "type": "whatsapp",- "enabled": true,- "allowFrom": ["+1234567890"]- }- ]-}-```--**3. 运行**(两个终端)--```bash-# 终端 1-vikingbot channels login--# 终端 2-vikingbot gateway-```--</details>--<details>-<summary><b>飞书</b></summary>--使用 **WebSocket** 长连接 —— 不需要公网 IP。--**1. 创建飞书机器人**-- 访问 [飞书开放平台](https://open.feishu.cn/app)-- 创建新应用 → 启用 **机器人** 功能-- **权限**:添加 `im:message`(发送消息)-- **事件**:添加 `im.message.receive_v1`(接收消息)- - 选择 **长连接** 模式(需要先运行 vikingbot 来建立连接)-- 从「凭证与基础信息」获取 **App ID** 和 **App Secret**-- 发布应用--**2. 配置**--```json-{- "channels": [- {- "type": "feishu",- "enabled": true,- "appId": "cli_xxx",- "appSecret": "xxx",- "encryptKey": "",- "verificationToken": "",- "allowFrom": []- }- ]-}-```--> 长连接模式下,`encryptKey` 和 `verificationToken` 是可选的。-> `allowFrom`:留空以允许所有用户,或添加 `["ou_xxx"]` 以限制访问。--**3. 运行**--```bash-vikingbot gateway-```--> [!TIP]-> 飞书使用 WebSocket 接收消息 —— 不需要 webhook 或公网 IP!--</details>--<details>-<summary><b>QQ(QQ单聊)</b></summary>--使用 **botpy SDK** 配合 WebSocket —— 不需要公网 IP。目前仅支持 **私聊**。--**1. 注册并创建机器人**-- 访问 [QQ 开放平台](https://q.qq.com) → 注册为开发者(个人或企业)-- 创建新的机器人应用-- 进入 **开发设置** → 复制 **AppID** 和 **AppSecret**--**2. 设置沙箱测试环境**-- 在机器人管理控制台中,找到 **沙箱配置**-- 在 **在消息列表配置** 下,点击 **添加成员** 并添加您自己的 QQ 号-- 添加完成后,用手机 QQ 扫描机器人的二维码 → 打开机器人资料卡 → 点击「发消息」开始聊天--**3. 配置**--> - `allowFrom`:留空以供公开访问,或添加用户 openid 以限制。您可以在用户向机器人发消息时在 vikingbot 日志中找到 openid。-> - 生产环境:在机器人控制台提交审核并发布。查看 [QQ 机器人文档](https://bot.q.qq.com/wiki/) 了解完整发布流程。--```json-{- "channels": [- {- "type": "qq",- "enabled": true,- "appId": "YOUR_APP_ID",- "secret": "YOUR_APP_SECRET",- "allowFrom": []- }- ]-}-```--**4. 运行**--```bash-vikingbot gateway-```--现在从 QQ 向机器人发送消息 —— 它应该会回复!--</details>--<details>-<summary><b>钉钉</b></summary>--使用 **流模式** —— 不需要公网 IP。--**1. 创建钉钉机器人**-- 访问 [钉钉开放平台](https://open-dev.dingtalk.com/)-- 创建新应用 -> 添加 **机器人** 功能-- **配置**:- - 打开 **流模式**-- **权限**:添加发送消息所需的权限-- 从「凭证」获取 **AppKey**(客户端 ID)和 **AppSecret**(客户端密钥)-- 发布应用--**2. 配置**--```json-{- "channels": [- {- "type": "dingtalk",- "enabled": true,- "clientId": "YOUR_APP_KEY",- "clientSecret": "YOUR_APP_SECRET",- "allowFrom": []- }- ]-}-```--> `allowFrom`:留空以允许所有用户,或添加 `["staffId"]` 以限制访问。--**3. 运行**--```bash-vikingbot gateway-```--</details>--<details>-<summary><b>Slack</b></summary>--使用 **Socket 模式** —— 不需要公网 URL。--**1. 创建 Slack 应用**-- 访问 [Slack API](https://api.slack.com/apps) → **创建新应用** →「从零开始」-- 选择名称并选择您的工作区--**2. 配置应用**-- **Socket 模式**:打开 → 生成一个具有 `connections:write` 范围的 **应用级令牌** → 复制它(`xapp-...`)-- **OAuth 与权限**:添加机器人范围:`chat:write`、`reactions:write`、`app_mentions:read`-- **事件订阅**:打开 → 订阅机器人事件:`message.im`、`message.channels`、`app_mention` → 保存更改-- **应用主页**:滚动到 **显示标签页** → 启用 **消息标签页** → 勾选 **"允许用户从消息标签页发送斜杠命令和消息"**-- **安装应用**:点击 **安装到工作区** → 授权 → 复制 **机器人令牌**(`xoxb-...`)--**3. 配置 vikingbot**--```json-{- "channels": [- {- "type": "slack",- "enabled": true,- "botToken": "xoxb-...",- "appToken": "xapp-...",- "groupPolicy": "mention"- }- ]-}-```--**4. 运行**--```bash-vikingbot gateway-```--直接向机器人发送私信或在频道中 @提及它 —— 它应该会回复!--> [!TIP]-> - `groupPolicy`:`"mention"`(默认 —— 仅在 @提及時回复)、`"open"`(回复所有频道消息)或 `"allowlist"`(限制到特定频道)。-> - 私信策略默认为开放。设置 `"dm": {"enabled": false}` 以禁用私信。--</details>--<details>-<summary><b>邮件</b></summary>--给 vikingbot 一个自己的邮箱账户。它通过 **IMAP** 轮询收件箱并通过 **SMTP** 回复 —— 就像一个个人邮件助手。--**1. 获取凭证(Gmail 示例)**-- 为您的机器人创建一个专用的 Gmail 账户(例如 `[email protected]`)-- 启用两步验证 → 创建 [应用密码](https://myaccount.google.com/apppasswords)-- 将此应用密码用于 IMAP 和 SMTP--**2. 配置**--> - `consentGranted` 必须为 `true` 以允许邮箱访问。这是一个安全门 —— 设置为 `false` 以完全禁用。-> - `allowFrom`:留空以接受来自任何人的邮件,或限制到特定发件人。-> - `smtpUseTls` 和 `smtpUseSsl` 分别默认为 `true` / `false`,这对 Gmail(端口 587 + STARTTLS)是正确的。无需显式设置它们。-> - 如果您只想读取/分析邮件而不发送自动回复,请设置 `"autoReplyEnabled": false`。--```json-{- "channels": [- {- "type": "email",- "enabled": true,- "consentGranted": true,- "imapHost": "imap.gmail.com",- "imapPort": 993,- "imapUsername": "[email protected]",- "imapPassword": "your-app-password",- "smtpHost": "smtp.gmail.com",- "smtpPort": 587,- "smtpUsername": "[email protected]",- "smtpPassword": "your-app-password",- "fromAddress": "[email protected]",- "allowFrom": ["[email protected]"]- }- ]-}-```---**3. 运行**--```bash-vikingbot gateway-```--</details>+详细配置请参考 [CHANNEL.md](CHANNEL.md)。## 🌐 代理社交网络@@ -571,40 +190,75 @@ vikingbot gateway## ⚙️ 配置-配置文件:`~/.vikingbot/config.json`+配置文件:`~/.openviking/ov.conf`(可通过环境变量 `OPENVIKING_CONFIG_FILE` 自定义路径)++> [!TIP]+> Vikingbot 与 OpenViking 共享同一配置文件,配置项位于文件的 `bot` 字段下,同时会自动合并 `vlm`、`storage`、`server` 等全局配置,无需单独维护配置文件。> [!IMPORTANT]> 修改配置后(无论是通过控制台 UI 还是直接编辑文件),> 您需要重启网关服务以使更改生效。-### OpenViking 配置--Vikingbot 支持本地和远程两种 OpenViking 模式。--#### 本地模式(默认)-+### Openviking Server配置+bot将连接远程的OpenViking服务器,使用前需启动Openviking Server。 默认使用`ov.conf`中配置的OpenViking server信息+- Openviking默认启动地址为 127.0.0.1:1933+- 如果配置了 root_api_key,则开启多租户模式。详见 [多租户](https://github.com/volcengine/OpenViking/blob/main/examples/multi_tenant/README.md)+- Openviking Server配置示例```json{- "openviking": {- "mode": "local"+ "server": {++ "host": "127.0.0.1",+ "port": 1933,+ "root_api_key": "test"}}```-数据存储在 `~/.vikingbot/ov_data/`。--#### 远程模式(配合火山引擎 TOS)+### bot配置+全部配置在`ov.conf`中`bot`字段下,配置项自带默认值。可选手动配置项说明如下:+- `agents`:Agent 配置+ - max_tool_iterations:单轮对话任务最大循环次数,超过则直接返回结果+ - memory_window:自动提交session到Openviking的对话轮次上限+ - gen_image_model:生成图片的模型+- gateway:Gateway 配置+ - host:Gateway 监听地址,默认值为 `0.0.0.0`+ - port:Gateway 监听端口,默认值为 `18790`+- sandbox:沙箱配置+ - mode:沙箱模式,可选值为 `shared`(所有session共享工作空间)或 `private`(私有,按Channel、session隔离工作空间)。默认值为 `shared`。+- ov_server:OpenViking Server 配置。+ - 不配置,默认使用`ov.conf`中配置的OpenViking server信息+ - 若不使用本地启动的OpenViking Server,可在此配置url和对应的root user的API Key+- channels:消息平台配置,详见 [消息平台配置](CHANNEL.md)```json{- "openviking": {- "mode": "remote",- "server_url": "https://your-openviking-server.com",- "tos_endpoint": "https://tos-cn-beijing.volces.com",- "tos_region": "cn-beijing",- "tos_bucket": "your-bucket-name",- "tos_ak": "your-access-key",- "tos_sk": "your-secret-key"+ "bot": {+ "agents": {+ "max_tool_iterations": 50,+ "memory_window": 50,+ "gen_image_model": "openai/doubao-seedream-4-5-251128"+ },+ "gateway": {+ "host": "0.0.0.0",+ "port": 18790+ },+ "sandbox": {+ "mode": "shared"+ },+ "ov_server": {+ "server_url": "http://127.0.0.1:1933",+ "root_api_key": "test"+ },+ "channels": [+ {+ "type": "feishu",+ "enabled": true,+ "appId": "",+ "appSecret": "",+ "allowFrom": []+ }+ ]}}```@@ -644,19 +298,16 @@ Vikingbot 默认启用 OpenViking 钩子:```json{- "providers": {- "openai": {- "apiKey": "sk-xxx"- }- },- "agents": {- "defaults": {+ "bot": {+ "agents": {"model": "openai/doubao-seed-2-0-pro-260215"}}}```+Provider 配置从 OpenViking 配置(`ov.conf` 的 `vlm` 部分)读取。+### 提供商> [!TIP]@@ -724,6 +375,70 @@ class ProvidersConfig(BaseModel):</details>+### 可观测性(可选)++**Langfuse** 集成,用于 LLM 可观测性和追踪。++<details>+<summary><b>Langfuse 配置</b></summary>++**方式 1:本地部署(测试推荐)**++使用 Docker 在本地部署 Langfuse:++```bash+# 进入部署脚本目录+cd deploy/docker++# 运行部署脚本+./deploy_langfuse.sh+```++这将在 `http://localhost:3000` 启动 Langfuse,并使用预配置的凭据。++**方式 2:Langfuse Cloud**++1. 在 [langfuse.com](https://langfuse.com) 注册+2. 创建新项目+3. 从项目设置中复制 **Secret Key** 和 **Public Key**++**配置**++添加到 `~/.openviking/ov.conf`:++```json+{+ "bot": {+ "langfuse": {+ "enabled": true,+ "secret_key": "sk-lf-vikingbot-secret-key-2026",+ "public_key": "pk-lf-vikingbot-public-key-2026",+ "base_url": "http://localhost:3000"+ }+ }+}+```++对于 Langfuse Cloud,使用 `https://cloud.langfuse.com` 作为 `base_url`。++**安装 Langfuse 支持:**+```bash+uv pip install -e ".[langfuse]"+```++**重启 vikingbot:**+```bash+vikingbot gateway+```++**启用的功能:**+- 每次对话自动创建 trace+- Session 和 User 追踪+- LLM 调用监控+- Token 使用量追踪++</details>+### 安全| 选项 | 默认值 | 描述 |@@ -733,60 +448,146 @@ class ProvidersConfig(BaseModel):### 沙箱-vikingbot 支持沙箱执行以增强安全性。默认情况下,沙箱是禁用的。要在会话模式下使用 SRT 后端启用沙箱,请设置 `"enabled": true`。+vikingbot 支持沙箱执行以增强安全性。++**默认情况下,`ov.conf` 中不需要配置 sandbox:**+- 默认后端:`direct`(直接在主机上运行代码)+- 默认模式:`shared`(所有会话共享一个沙箱)++只有当您想要更改这些默认值时,才需要添加 sandbox 配置。<details>-<summary><b>沙箱配置(SRT 后端)</b></summary>+<summary><b>沙箱配置选项</b></summary>+**使用不同的后端或模式:**```json{- "sandbox": {- "enabled": false,- "backend": "srt",- "mode": "per-session",- "network": {- "allowedDomains": [],- "deniedDomains": [],- "allowLocalBinding": false- },- "filesystem": {- "denyRead": [],- "allowWrite": [],- "denyWrite": []- },- "runtime": {- "cleanupOnExit": true,- "timeout": 300- },- "backends": {- "srt": {- "nodePath": "node"+ "bot": {+ "sandbox": {+ "backend": "opensandbox",+ "mode": "per-session"+ }+ }+}+```++**可用后端:**+| 后端 | 描述 |+|---------|-------------|+| `direct` | (默认)直接在主机上运行代码 |+| `docker` | 使用 Docker 容器进行隔离 |+| `opensandbox` | 使用 OpenSandbox 服务 |+| `srt` | 使用 Anthropic 的 SRT 沙箱运行时 |+| `aiosandbox` | 使用 AIO Sandbox 服务 |++**可用模式:**+| 模式 | 描述 |+|------|-------------|+| `shared` | (默认)所有会话共享一个沙箱 |+| `per-session` | 每个会话使用独立的沙箱实例 |++**后端特定配置(仅在使用该后端时需要):**++**Direct 后端:**+```json+{+ "bot": {+ "sandbox": {+ "backends": {+ "direct": {+ "restrictToWorkspace": false+ }}}}}```-**配置选项:**+**OpenSandbox 后端:**+```json+{+ "bot": {+ "sandbox": {+ "backend": "opensandbox",+ "backends": {+ "opensandbox": {+ "serverUrl": "http://localhost:18792",+ "apiKey": "",+ "defaultImage": "opensandbox/code-interpreter:v1.0.1"+ }+ }+ }+ }+}+```-| 选项 | 默认值 | 描述 |-|--------|---------|-------------|-| `enabled` | `false` | 启用沙箱执行 |-| `backend` | `"srt"` | 沙箱后端:`srt` 或 `docker` |-| `mode` | `"per-session"` | 沙箱模式:`per-session`(每个会话隔离)或 `shared`(跨会话共享) |-| `network.allowedDomains` | `[]` | 允许网络访问的域列表(空 = 允许所有) |-| `network.deniedDomains` | `[]` | 拒绝的域列表(无论允许列表如何都被阻止) |-| `network.allowLocalBinding` | `false` | 允许绑定到本地地址(localhost、127.0.0.1) |-| `filesystem.denyRead` | `[]` | 拒绝读取访问的路径/文件 |-| `filesystem.allowWrite` | `[]` | 明确允许写入访问的路径/文件 |-| `filesystem.denyWrite` | `[]` | 拒绝写入访问的路径/文件 |-| `runtime.cleanupOnExit` | `true` | 退出时清理沙箱资源 |-| `runtime.timeout` | `300` | 命令执行超时(秒) |-| `backends.srt.nodePath` | `"/usr/local/bin/node"` | Node.js 可执行文件的路径(如果 `node` 不在 PATH 中,请使用完整路径) |+**Docker 后端:**+```json+{+ "bot": {+ "sandbox": {+ "backend": "docker",+ "backends": {+ "docker": {+ "image": "python:3.11-slim",+ "networkMode": "bridge"+ }+ }+ }+ }+}+```++**SRT 后端:**+```json+{+ "bot": {+ "sandbox": {+ "backend": "srt",+ "backends": {+ "srt": {+ "settingsPath": "~/.vikingbot/srt-settings.json",+ "nodePath": "node",+ "network": {+ "allowedDomains": [],+ "deniedDomains": [],+ "allowLocalBinding": false+ },+ "filesystem": {+ "denyRead": [],+ "allowWrite": [],+ "denyWrite": []+ },+ "runtime": {+ "cleanupOnExit": true,+ "timeout": 300+ }+ }+ }+ }+ }+}+```++**AIO Sandbox 后端:**+```json+{+ "bot": {+ "sandbox": {+ "backend": "aiosandbox",+ "backends": {+ "aiosandbox": {+ "baseUrl": "http://localhost:18794"+ }+ }+ }+ }+}+```**SRT 后端设置:**-SRT 后端使用 `@anthropic-ai/sandbox-runtime`。当您运行 `vikingbot onboard` 时它会自动安装。+SRT 后端使用 `@anthropic-ai/sandbox-runtime`。**系统依赖:**@@ -853,11 +654,10 @@ which nodejs| 命令 | 描述 ||---------|-------------|-| `vikingbot agent -m "..."` | 与代理聊天 |-| `vikingbot agent` | 交互式聊天模式 |-| `vikingbot agent --no-markdown` | 显示纯文本回复 |-| `vikingbot agent --logs` | 聊天期间显示运行时日志 |-| `vikingbot tui` | 启动 TUI(终端用户界面) |+| `vikingbot chat -m "..."` | 与代理聊天 |+| `vikingbot chat` | 交互式聊天模式 |+| `vikingbot chat --no-markdown` | 显示纯文本回复 |+| `vikingbot chat --logs` | 聊天期间显示运行时日志 || `vikingbot gateway` | 启动网关和控制台 Web UI || `vikingbot status` | 显示状态 || `vikingbot channels login` | 链接 WhatsApp(扫描二维码) |@@ -880,23 +680,6 @@ which nodejs交互模式退出:`exit`、`quit`、`/exit`、`/quit`、`:q` 或 `Ctrl+D`。-<details>-<summary><b>TUI(终端用户界面)</b></summary>--启动 vikingbot TUI 以获得丰富的基于终端的聊天体验:--```bash-vikingbot tui-```--TUI 提供:-- 支持 markdown 的富文本渲染-- 消息历史和对话管理-- 实时代理响应-- 导航的键盘快捷键--</details>-<details><summary><b>定时任务(Cron)</b></summary>diff --git a/bot/deploy/docker/deploy_langfuse.sh b/bot/deploy/docker/deploy_langfuse.shnew file mode 100755index 000000000..80dd0be77--- /dev/null+++ b/bot/deploy/docker/deploy_langfuse.sh@@ -0,0 +1,28 @@+#!/bin/bash+# Deploy local Langfuse using Docker Compose++set -e++SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"+LANGFUSE_DIR="$SCRIPT_DIR/langfuse"++cd "$LANGFUSE_DIR"++echo "🚀 Starting Langfuse..."+docker-compose up -d++echo ""+echo "✅ Langfuse deployed successfully!"+echo ""+echo "🌐 Web UI: http://localhost:3000"+echo ""+echo "📧 Login credentials:"+echo " Email: [email protected]"+echo " Password: vikingbot-admin-password-2026"+echo ""+echo "🔑 API keys:"+echo " Public key: pk-lf-vikingbot-public-key-2026"+echo " Secret key: sk-lf-vikingbot-secret-key-2026"+echo ""+echo "📝 To view logs: docker-compose -f $LANGFUSE_DIR/docker-compose.yml logs -f"+echo "📝 To stop: docker-compose -f $LANGFUSE_DIR/docker-compose.yml down"diff --git a/bot/deploy/docker/langfuse/docker-compose.yml b/bot/deploy/docker/langfuse/docker-compose.ymlnew file mode 100644index 000000000..cf9a18c25--- /dev/null+++ b/bot/deploy/docker/langfuse/docker-compose.yml@@ -0,0 +1,175 @@+# Make sure to update the credential placeholders with your own secrets.+# We mark them with # CHANGEME in the file below.+# In addition, we recommend to restrict inbound traffic on the host to langfuse-web (port 3000) and minio (port 9090) only.+# All other components are bound to localhost (127.0.0.1) to only accept connections from the local machine.+# External connections from other machines will not be able to reach these services directly.+services:+ langfuse-worker:+ image: docker.io/langfuse/langfuse-worker:3+ restart: always+ depends_on: &langfuse-depends-on+ postgres:+ condition: service_healthy+ minio:+ condition: service_healthy+ redis:+ condition: service_healthy+ clickhouse:+ condition: service_healthy+ ports:+ - 127.0.0.1:3030:3030+ environment: &langfuse-worker-env+ NEXTAUTH_URL: ${NEXTAUTH_URL:-http://localhost:3000}+ DATABASE_URL: ${DATABASE_URL:-postgresql://postgres:postgres@postgres:5432/postgres} # CHANGEME+ SALT: ${SALT:-vikingbot-salt-2026}+ ENCRYPTION_KEY: ${ENCRYPTION_KEY:-0000000000000000000000000000000000000000000000000000000000000000}+ TELEMETRY_ENABLED: ${TELEMETRY_ENABLED:-false}+ LANGFUSE_ENABLE_EXPERIMENTAL_FEATURES: ${LANGFUSE_ENABLE_EXPERIMENTAL_FEATURES:-false}+ CLICKHOUSE_MIGRATION_URL: ${CLICKHOUSE_MIGRATION_URL:-clickhouse://clickhouse:9000}+ CLICKHOUSE_URL: ${CLICKHOUSE_URL:-http://clickhouse:8123}+ CLICKHOUSE_USER: ${CLICKHOUSE_USER:-clickhouse}+ CLICKHOUSE_PASSWORD: ${CLICKHOUSE_PASSWORD:-clickhouse}+ CLICKHOUSE_CLUSTER_ENABLED: ${CLICKHOUSE_CLUSTER_ENABLED:-false}+ LANGFUSE_USE_AZURE_BLOB: ${LANGFUSE_USE_AZURE_BLOB:-false}+ LANGFUSE_S3_EVENT_UPLOAD_BUCKET: ${LANGFUSE_S3_EVENT_UPLOAD_BUCKET:-langfuse}+ LANGFUSE_S3_EVENT_UPLOAD_REGION: ${LANGFUSE_S3_EVENT_UPLOAD_REGION:-auto}+ LANGFUSE_S3_EVENT_UPLOAD_ACCESS_KEY_ID: ${LANGFUSE_S3_EVENT_UPLOAD_ACCESS_KEY_ID:-minio}+ LANGFUSE_S3_EVENT_UPLOAD_SECRET_ACCESS_KEY: ${LANGFUSE_S3_EVENT_UPLOAD_SECRET_ACCESS_KEY:-miniosecret}+ LANGFUSE_S3_EVENT_UPLOAD_ENDPOINT: ${LANGFUSE_S3_EVENT_UPLOAD_ENDPOINT:-http://minio:9000}+ LANGFUSE_S3_EVENT_UPLOAD_FORCE_PATH_STYLE: ${LANGFUSE_S3_EVENT_UPLOAD_FORCE_PATH_STYLE:-true}+ LANGFUSE_S3_EVENT_UPLOAD_PREFIX: ${LANGFUSE_S3_EVENT_UPLOAD_PREFIX:-events/}+ LANGFUSE_S3_MEDIA_UPLOAD_BUCKET: ${LANGFUSE_S3_MEDIA_UPLOAD_BUCKET:-langfuse}+ LANGFUSE_S3_MEDIA_UPLOAD_REGION: ${LANGFUSE_S3_MEDIA_UPLOAD_REGION:-auto}+ LANGFUSE_S3_MEDIA_UPLOAD_ACCESS_KEY_ID: ${LANGFUSE_S3_MEDIA_UPLOAD_ACCESS_KEY_ID:-minio}+ LANGFUSE_S3_MEDIA_UPLOAD_SECRET_ACCESS_KEY: ${LANGFUSE_S3_MEDIA_UPLOAD_SECRET_ACCESS_KEY:-miniosecret}+ LANGFUSE_S3_MEDIA_UPLOAD_ENDPOINT: ${LANGFUSE_S3_MEDIA_UPLOAD_ENDPOINT:-http://localhost:9090}+ LANGFUSE_S3_MEDIA_UPLOAD_FORCE_PATH_STYLE: ${LANGFUSE_S3_MEDIA_UPLOAD_FORCE_PATH_STYLE:-true}+ LANGFUSE_S3_MEDIA_UPLOAD_PREFIX: ${LANGFUSE_S3_MEDIA_UPLOAD_PREFIX:-media/}+ LANGFUSE_S3_BATCH_EXPORT_ENABLED: ${LANGFUSE_S3_BATCH_EXPORT_ENABLED:-false}+ LANGFUSE_S3_BATCH_EXPORT_BUCKET: ${LANGFUSE_S3_BATCH_EXPORT_BUCKET:-langfuse}+ LANGFUSE_S3_BATCH_EXPORT_PREFIX: ${LANGFUSE_S3_BATCH_EXPORT_PREFIX:-exports/}+ LANGFUSE_S3_BATCH_EXPORT_REGION: ${LANGFUSE_S3_BATCH_EXPORT_REGION:-auto}+ LANGFUSE_S3_BATCH_EXPORT_ENDPOINT: ${LANGFUSE_S3_BATCH_EXPORT_ENDPOINT:-http://minio:9000}+ LANGFUSE_S3_BATCH_EXPORT_EXTERNAL_ENDPOINT: ${LANGFUSE_S3_BATCH_EXPORT_EXTERNAL_ENDPOINT:-http://localhost:9090}+ LANGFUSE_S3_BATCH_EXPORT_ACCESS_KEY_ID: ${LANGFUSE_S3_BATCH_EXPORT_ACCESS_KEY_ID:-minio}+ LANGFUSE_S3_BATCH_EXPORT_SECRET_ACCESS_KEY: ${LANGFUSE_S3_BATCH_EXPORT_SECRET_ACCESS_KEY:-miniosecret}+ LANGFUSE_S3_BATCH_EXPORT_FORCE_PATH_STYLE: ${LANGFUSE_S3_BATCH_EXPORT_FORCE_PATH_STYLE:-true}+ LANGFUSE_INGESTION_QUEUE_DELAY_MS: ${LANGFUSE_INGESTION_QUEUE_DELAY_MS:-}+ LANGFUSE_INGESTION_CLICKHOUSE_WRITE_INTERVAL_MS: ${LANGFUSE_INGESTION_CLICKHOUSE_WRITE_INTERVAL_MS:-}+ REDIS_HOST: ${REDIS_HOST:-redis}+ REDIS_PORT: ${REDIS_PORT:-6379}+ REDIS_AUTH: ${REDIS_AUTH:-vikingbot-redis-secret}+ REDIS_TLS_ENABLED: ${REDIS_TLS_ENABLED:-false}+ REDIS_TLS_CA: ${REDIS_TLS_CA:-/certs/ca.crt}+ REDIS_TLS_CERT: ${REDIS_TLS_CERT:-/certs/redis.crt}+ REDIS_TLS_KEY: ${REDIS_TLS_KEY:-/certs/redis.key}+ EMAIL_FROM_ADDRESS: ${EMAIL_FROM_ADDRESS:-}+ SMTP_CONNECTION_URL: ${SMTP_CONNECTION_URL:-}++ langfuse-web:+ image: docker.io/langfuse/langfuse:3+ restart: always+ depends_on: *langfuse-depends-on+ ports:+ - 3000:3000+ environment:+ <<: *langfuse-worker-env+ NEXTAUTH_SECRET: ${NEXTAUTH_SECRET:-vikingbot-nextauth-secret-2026}+ LANGFUSE_INIT_ORG_ID: ${LANGFUSE_INIT_ORG_ID:-vikingbot-org}+ LANGFUSE_INIT_ORG_NAME: ${LANGFUSE_INIT_ORG_NAME:-Vikingbot Org}+ LANGFUSE_INIT_PROJECT_ID: ${LANGFUSE_INIT_PROJECT_ID:-vikingbot-project}+ LANGFUSE_INIT_PROJECT_NAME: ${LANGFUSE_INIT_PROJECT_NAME:-Vikingbot Project}+ LANGFUSE_INIT_PROJECT_PUBLIC_KEY: ${LANGFUSE_INIT_PROJECT_PUBLIC_KEY:-pk-lf-vikingbot-public-key-2026}+ LANGFUSE_INIT_PROJECT_SECRET_KEY: ${LANGFUSE_INIT_PROJECT_SECRET_KEY:-sk-lf-vikingbot-secret-key-2026}+ LANGFUSE_INIT_USER_EMAIL: ${LANGFUSE_INIT_USER_EMAIL:[email protected]}+ LANGFUSE_INIT_USER_NAME: ${LANGFUSE_INIT_USER_NAME:-Vikingbot Admin}+ LANGFUSE_INIT_USER_PASSWORD: ${LANGFUSE_INIT_USER_PASSWORD:-vikingbot-admin-password-2026}++ clickhouse:+ image: docker.io/clickhouse/clickhouse-server+ restart: always+ user: "101:101"+ environment:+ CLICKHOUSE_DB: default+ CLICKHOUSE_USER: ${CLICKHOUSE_USER:-clickhouse}+ CLICKHOUSE_PASSWORD: ${CLICKHOUSE_PASSWORD:-clickhouse}+ volumes:+ - langfuse_clickhouse_data:/var/lib/clickhouse+ - langfuse_clickhouse_logs:/var/log/clickhouse-server+ ports:+ - 127.0.0.1:8123:8123+ - 127.0.0.1:9000:9000+ healthcheck:+ test: wget --no-verbose --tries=1 --spider http://localhost:8123/ping || exit 1+ interval: 5s+ timeout: 5s+ retries: 10+ start_period: 1s++ minio:+ image: cgr.dev/chainguard/minio+ restart: always+ entrypoint: sh+ # create the 'langfuse' bucket before starting the service+ command: -c 'mkdir -p /data/langfuse && minio server --address ":9000" --console-address ":9001" /data'+ environment:+ MINIO_ROOT_USER: ${MINIO_ROOT_USER:-minio}+ MINIO_ROOT_PASSWORD: ${MINIO_ROOT_PASSWORD:-miniosecret}+ ports:+ - 9090:9000+ - 127.0.0.1:9091:9001+ volumes:+ - langfuse_minio_data:/data+ healthcheck:+ test: ["CMD", "mc", "ready", "local"]+ interval: 1s+ timeout: 5s+ retries: 5+ start_period: 1s++ redis:+ image: docker.io/redis:7+ restart: always+ command: >+ --requirepass ${REDIS_AUTH:-vikingbot-redis-secret}+ --maxmemory-policy noeviction+ ports:+ - 127.0.0.1:6379:6379+ volumes:+ - langfuse_redis_data:/data+ healthcheck:+ test: ["CMD", "redis-cli", "ping"]+ interval: 3s+ timeout: 10s+ retries: 10++ postgres:+ image: docker.io/postgres:${POSTGRES_VERSION:-17}+ restart: always+ healthcheck:+ test: ["CMD-SHELL", "pg_isready -U postgres"]+ interval: 3s+ timeout: 3s+ retries: 10+ environment:+ POSTGRES_USER: ${POSTGRES_USER:-postgres}+ POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-postgres}+ POSTGRES_DB: ${POSTGRES_DB:-postgres}+ TZ: UTC+ PGTZ: UTC+ ports:+ - 127.0.0.1:5432:5432+ volumes:+ - langfuse_postgres_data:/var/lib/postgresql/data++volumes:+ langfuse_postgres_data:+ driver: local+ langfuse_clickhouse_data:+ driver: local+ langfuse_clickhouse_logs:+ driver: local+ langfuse_minio_data:+ driver: local+ langfuse_redis_data:+ driver: localdiff --git a/bot/docs/openclaw-plugin-analysis.md b/bot/docs/openclaw-plugin-analysis.mdnew file mode 100644index 000000000..33e208f58--- /dev/null+++ b/bot/docs/openclaw-plugin-analysis.md@@ -0,0 +1,353 @@+# OpenClaw 插件机制深度分析++> 分析日期:2026-03-03+> 基于 OpenClaw 最新代码库++---++## 目录++1. [插件机制概述](#1-插件机制概述)+2. [插件分类体系](#2-插件分类体系)+3. [注册与加载机制](#3-注册与加载机制)+4. [架构设计详解](#4-架构设计详解)+5. [内置插件清单](#5-内置插件清单)+6. [关于动态修改 SKILL.md 的分析](#6-关于动态修改-skillmd-的分析)++---++## 1. 插件机制概述++OpenClaw 采用**分层、可扩展的插件架构**,支持三种类型的插件:++- **内置插件 (Bundled)** - 随 OpenClaw 一起发布+- **托管插件 (Managed)** - 通过 ClawHub 安装管理+- **工作空间插件 (Workspace)** - 项目特定的本地插件++插件发现层级遵循以下优先级(从高到低):++```+Config paths → Workspace → Global → Bundled+```++---++## 2. 插件分类体系++OpenClaw 支持以下扩展类型:++| 扩展类型 | 说明 | 示例 |+|---------|------|------|+| **Channel 插件** | 消息通道集成 | Matrix, Zalo, WhatsApp |+| **Tool 插件** | 工具扩展 | 文件操作、网络请求 |+| **Gateway RPC** | RPC 接口扩展 | 自定义 API 端点 |+| **HTTP Handlers** | HTTP 请求处理器 | Webhook 处理 |+| **CLI Commands** | 命令行命令 | 自定义 CLI 指令 |+| **Services** | 后台服务 | 定时任务、监听器 |+| **Hooks** | 事件钩子 | 生命周期钩子 |+| **Provider Auth** | 认证提供者 | OAuth、API Key 管理 |++---++## 3. 注册与加载机制++### 3.1 插件加载器++OpenClaw 使用 **jiti** 作为插件加载器,支持**运行时直接执行 TypeScript**,无需预编译:++```typescript+// 核心加载函数来自 pi-coding-agent 包+import { loadSkillsFromDir } from '@mariozechner/pi-coding-agent';++// 加载技能目录+const skills = await loadSkillsFromDir(skillDir);+```++### 3.2 注册 API++插件通过以下 API 注册到系统:++```typescript+// 注册通道+api.registerChannel(config: ChannelConfig);++// 注册工具+api.registerTool(name: string, handler: ToolHandler);++// 注册 Gateway 方法+api.registerGatewayMethod(method: string, handler: Function);+```++### 3.3 文件监听与热重载++OpenClaw 使用 `chokidar` 监听文件变化,实现热重载:++```typescript+// 来自 src/agents/skills/refresh.ts+const watcher = chokidar.watch(watchTargets, {+ ignoreInitial: true,+ awaitWriteFinish: {+ stabilityThreshold: debounceMs,+ pollInterval: 100,+ },+ ignored: DEFAULT_SKILLS_WATCH_IGNORED,+});+```++---++## 4. 架构设计详解++### 4.1 基于 Hook 的事件驱动架构++OpenClaw 的核心是事件驱动的 Hook 系统,主要事件包括:++| 事件 | 触发时机 |+|------|---------|+| `message:inbound` | 消息流入系统 |+| `message:outbound` | 消息流出系统 |+| `agent:start` | Agent 开始工作 |+| `agent:complete` | Agent 完成工作 |+| `config:reload` | 配置重新加载 |+| `before_prompt_build` | 构建 prompt 之前 |+| `llm_input` | LLM 输入前 |+| `llm_output` | LLM 输出后 |++### 4.2 插件 SDK 能力++插件 SDK 提供以下核心能力:++```typescript+interface PluginSDK {+ // 后台服务+ Background: {+ start(service: BackgroundService): void;+ stop(serviceId: string): void;+ };++ // 生命周期钩子+ Lifecycle: {+ on(event: LifecycleEvent, handler: Function): void;+ };++ // 配置管理+ Config: {+ get<T>(key: string): T;+ set<T>(key: string, value: T): void;+ };++ // 日志+ Logger: {+ info(msg: string): void;+ error(msg: string): void;+ debug(msg: string): void;+ };+}+```++---++## 5. 内置插件清单++### 5.1 内置通道 (Bundled Channels)++| 通道 | 说明 |+|------|------|+| WhatsApp | WhatsApp 商业 API |+| Telegram | Telegram Bot |+| Slack | Slack App |+| Discord | Discord Bot |+| Signal | Signal 集成 |+| iMessage | Apple iMessage |+| Google Chat | Google Workspace Chat |++### 5.2 扩展插件 (位于 `/extensions/`)++| 插件 | 说明 |+|------|------|+| Matrix | 去中心化聊天协议 |+| Microsoft Teams | 微软团队协作 |+| Zalo (User/Business) | 越南社交应用 |+| Nostr | 去中心化社交网络 |+| LINE | 日本即时通讯 |+| Mattermost | 开源团队协作 |+| Nextcloud Talk | 私有云通话 |++---++## 6. 关于动态修改 SKILL.md 的分析++### 6.1 核心结论++**OpenClaw 目前无法直接在 skill 加载时修改 SKILL.md 内容。**++原因:+1. **无生命周期钩子** - Skill 系统没有提供 `onLoad`、`beforeLoad` 等钩子+2. **静态声明式架构** - Skills 通过 `SKILL.md` 静态定义,使用 `pi-coding-agent` 包加载,没有预留修改入口+3. **只读解析** - Frontmatter 解析器只读取不写入+4. **加载后只读** - Skill 加载后被用于构建 system prompt,本身不会被修改++### 6.2 可行替代方案++#### 方案 1: 外部预处理脚本(推荐)++在启动 OpenClaw 之前,运行脚本修改 SKILL.md:++```bash+#!/bin/bash+# preprocess-skills.sh+node scripts/modify-skills.js+openclaw start # 启动 OpenClaw+```++```javascript+// scripts/modify-skills.js+const fs = require('fs');+const path = require('path');+const yaml = require('yaml');++const skillPath = process.env.SKILL_PATH || './skills/my-skill/SKILL.md';+const content = fs.readFileSync(skillPath, 'utf8');++// 解析 frontmatter+const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);+if (match) {+ const frontmatter = yaml.parse(match[1]);+ const body = match[2];++ // 动态修改内容+ frontmatter.lastModified = new Date().toISOString();+ frontmatter.dynamicValue = calculateDynamicValue();++ // 写回文件+ const newContent = `---\n${yaml.stringify(frontmatter)}---\n${body}`;+ fs.writeFileSync(skillPath, newContent);+}+```++#### 方案 2: 使用 OpenClaw Hooks 系统++利用 `before_prompt_build` hook 在构建 prompt 时动态修改 skill 内容:++```typescript+// 在你的插件中+import { definePlugin } from 'openclaw';++export default definePlugin({+ name: 'dynamic-skill-modifier',++ hooks: {+ // 在构建 prompt 之前修改 skill 内容+ before_prompt_build: async ({ skills, context }) => {+ // 动态修改 skill 对象(不修改文件,只修改内存中的表示)+ for (const skill of skills) {+ if (skill.name === 'my-dynamic-skill') {+ skill.content = modifySkillContent(skill.content, context);+ }+ }+ return { skills };+ }+ }+});+```++#### 方案 3: 自定义 Skill 加载器(高级)++创建一个自定义的 skill 加载插件,拦截加载过程:++```typescript+// plugins/dynamic-skill-loader.ts+import { loadSkillsFromDir } from 'pi-coding-agent';+import * as fs from 'fs';+import * as path from 'path';++export class DynamicSkillLoader {+ async loadSkills(skillDir: string) {+ // 1. 复制 skill 到临时目录+ const tempDir = this.createTempCopy(skillDir);++ // 2. 修改临时目录中的 SKILL.md+ this.modifySkillMdFiles(tempDir);++ // 3. 从临时目录加载+ return loadSkillsFromDir(tempDir);+ }++ private modifySkillMdFiles(dir: string) {+ const skillMdFiles = this.findSkillMdFiles(dir);+ for (const file of skillMdFiles) {+ let content = fs.readFileSync(file, 'utf8');++ // 动态修改内容+ content = this.applyDynamicModifications(content);++ fs.writeFileSync(file, content);+ }+ }++ private applyDynamicModifications(content: string): string {+ // 添加动态生成的内容+ const dynamicSection = `\n\n<!-- 动态生成于 ${new Date().toISOString()} -->\n`;+ return content + dynamicSection;+ }+}+```++#### 方案 4: 文件监听 + 触发重载(最符合 OpenClaw 设计)++利用 OpenClaw 已有的文件监听机制,在修改 SKILL.md 后自动重载:++```typescript+// 在你的构建脚本中+import * as chokidar from 'chokidar';+import * as fs from 'fs';++// 监听原始 skill 定义文件+const watcher = chokidar.watch('./skill-sources/**/*.md');++watcher.on('change', (filepath) => {+ console.log(`Source changed: ${filepath}`);++ // 重新生成 SKILL.md+ generateSkillMd(filepath);+});++function generateSkillMd(sourcePath: string) {+ const source = fs.readFileSync(sourcePath, 'utf8');++ // 动态生成 frontmatter+ const frontmatter = {+ name: extractName(source),+ version: calculateVersion(),+ lastBuild: new Date().toISOString(),+ dynamicConfig: loadDynamicConfig()+ };++ // 写入 SKILL.md(触发 OpenClaw 重载)+ const skillMd = `---\n${yaml.stringify(frontmatter)}---\n${extractBody(source)}`;+ fs.writeFileSync('./skills/my-skill/SKILL.md', skillMd);+}+```++### 6.3 方案对比++| 方案 | 复杂度 | 侵入性 | 适用场景 | 推荐度 |+|------|--------|--------|----------|--------|+| 预处理脚本 | 低 | 低 | 启动前一次性修改 | ★★★★★ |+| Hooks 系统 | 中 | 中 | 运行时动态修改内存中的 skill | ★★★★ |+| 自定义加载器 | 高 | 高 | 需要完全控制加载过程 | ★★★ |+| 文件监听重载 | 中 | 低 | 需要持续同步外部变更 | ★★★★ |++### 6.4 核心结论++**OpenClaw 的 Skill 系统是静态声明式的**,设计理念是:+- Skill 定义(SKILL.md)是**只读的声明**+- 动态行为通过 **Hooks** 和 **插件** 实现+- 文件变化通过 **监听 + 重载** 机制处理++因此,如果需要"在 skill 加载时修改 SKILL.md",应该:+1. **在加载前** 通过预处理脚本修改(方案 1)+2. **在加载后** 通过 Hooks 修改内存中的表示(方案 2)+3. **避免** 尝试在加载过程中 hack 内部机制++这种设计与 OpenClaw 的整体架构哲学一致:**声明式配置 + 程序化扩展**。diff --git a/bot/docs/rfc-openviking-cli-ov-chat.md b/bot/docs/rfc-openviking-cli-ov-chat.mdnew file mode 100644index 000000000..0e43f620e--- /dev/null+++ b/bot/docs/rfc-openviking-cli-ov-chat.md@@ -0,0 +1,341 @@+# RFC: OpenViking CLI Support for ov chat Command++**Author:** OpenViking Team+**Status:** Implemented+**Date:** 2025-03-03++---++## 1. Executive Summary / 执行摘要++This document describes the integration architecture between `ov` CLI (Rust), `openviking-server` (Python/FastAPI), and `vikingbot` (Python AI agent framework). The goal is to provide a unified chat interface where the bot service shares the same port and authentication mechanism as the OpenViking server.++本文档描述了 `ov` CLI(Rust)、`openviking-server`(Python/FastAPI)和 `vikingbot`(Python AI agent 框架)之间的集成架构。目标是提供一个统一的聊天界面,使 bot 服务与 OpenViking 服务器共享相同的端口和认证机制。++---++## 2. Architecture Overview / 架构概览++### 2.1 系统整体架构 / System Architecture++**部署说明 / Deployment Note:** OpenViking Server 和 Vikingbot 部署在同一台机器上,通过本地端口通信。++```mermaid+flowchart TB+ subgraph Client["客户端 / Client (可远程)"]+ CLI["ov CLI<br/>(Rust)"]+ end++ subgraph SameMachine["同一台机器 / Same Machine"]+ direction TB++ subgraph Server["OpenViking Server<br/>(Python/FastAPI, Port 1933)"]+ Auth["统一认证中间件<br/>Unified Auth"]+ BotAPIProxy["Bot API Proxy<br/>(--with-bot)"]+ BotRouter["/api/v1/bot/*<br/>Router"]+ end++ subgraph Vikingbot["Vikingbot (Process 2, Port 18791)"]+ subgraph Channels["Channels (BaseChannel 实现)"]+ OC["OpenAPIChannel"]+ FC["FeishuChannel<br/>(Webhook)"]+ DC["DiscordChannel"]+ TC["TelegramChannel"]+ end+ MB["MessageBus"]+ AL["Agent Loop"]+ end+ end++ CLI -->|"HTTP + API Key"| Auth+ Auth --> BotAPIProxy+ BotAPIProxy -->|"Proxy to"| BotRouter+ BotRouter -->|"Forward to"| OC++ FC -->|"Webhook Events"| MB+ DC -->|"WebSocket"| MB+ TC -->|"Bot API"| MB+ OC -->|"send_to_bus()"| MB+ MB --> AL++ OC -.->|"implements"| BaseChannel["BaseChannel"]+ FC -.->|"implements"| BaseChannel+ DC -.->|"implements"| BaseChannel+ TC -.->|"implements"| BaseChannel+```++### 2.2 Channel-Bus-Agent 架构详解++展示 Channel 与 MessageBus 的关系,以及各 Channel 如何作为 BaseChannel 实现:++```mermaid+flowchart TB+ subgraph Vikingbot["Vikingbot Core"]+ direction TB++ subgraph BaseChannelImpl["BaseChannel Implementations / 通道实现"]+ direction LR++ subgraph OC["OpenAPIChannel<br/>(HTTP API 通道)"]+ OCEndpoints["Endpoints:<br/>- /chat<br/>- /chat/stream<br/>- /health<br/>- /docs"]+ OCService["Service:<br/>OpenAPIChannelService"]+ end++ subgraph FC["FeishuChannel<br/>(飞书 Webhook)"]+ FCEndpoints["Endpoints:<br/>- /webhook/event<br/>- /webhook/card"]+ FCService["Service:<br/>FeishuChannelService"]+ end++ subgraph Others["Other Channels"]+ Discord["DiscordChannel"]+ Telegram["TelegramChannel"]+ Slack["SlackChannel"]+ end+ end++ subgraph Core["Core Components / 核心组件"]+ MB["MessageBus<br/>消息总线<br/><br/>- inbound queue<br/>- outbound queue<br/>- log store"]+ AL["Agent Loop<br/>代理循环<br/><br/>- ContextBuilder<br/>- LLM (LiteLLM)<br/>- Tool Executor"]+ end+ end++ subgraph External["External Clients / 外部客户端"]+ CLI["ov CLI"]+ FeishuApp["Feishu App<br/>飞书应用"]+ DiscordClient["Discord Client"]+ end++ CLI -->|"HTTP POST<br/>http://localhost:18791/chat"| OCEndpoints+ FeishuApp -->|"Webhook POST<br/>/webhook/event"| FCEndpoints+ DiscordClient -->|"WebSocket"| Discord++ OCEndpoints --> OCService+ FCEndpoints --> FCService++ OCService -->|"send_to_bus()<br/>message → bus"| MB+ FCService -->|"send_to_bus()<br/>message → bus"| MB+ Discord -->|"send_to_bus()"| MB+ Telegram -->|"send_to_bus()"| MB++ MB -->|"consume"| AL+ AL -->|"reply"| MB+ MB -->|"dispatch"| OCService+ MB -->|"dispatch"| FCService++ classDef channelClass fill:#e1f5fe,stroke:#01579b,stroke-width:2px+ classDef coreClass fill:#fff3e0,stroke:#e65100,stroke-width:2px+ classDef externalClass fill:#e8f5e9,stroke:#2e7d32,stroke-width:2px++ class OC,FC,Discord,Telegram,Others channelClass+ class MB,AL coreClass+ class CLI,FeishuApp,DiscordClient externalClass+```++---++## 3. Key Components / 关键组件++### 3.1 OpenViking Server (`openviking-server`)++**Role:** HTTP API Gateway with Bot API proxy / 带 Bot API 代理的 HTTP API 网关++**Key Features / 主要特性:**+- Unified authentication middleware for all endpoints / 为所有端点提供统一认证中间件+- Bot API proxy layer (enabled via `--with-bot`) / Bot API 代理层(通过 `--with-bot` 启用)+- Request forwarding to Vikingbot OpenAPIChannel / 请求转发到 Vikingbot OpenAPI 通道++**Architecture Position / 架构位置:**+- Process 1 (Port 1933) / 进程1(端口 1933)+- Entry point for all external clients (CLI, Feishu, etc.) / 所有外部客户端的入口点++---++### 3.2 `ov` CLI Client (`ov chat`)++**Role:** Command-line chat interface / 命令行聊天界面++**Key Features / 主要特性:**+- Interactive mode and single-message mode / 交互模式和单消息模式+- Configurable endpoint via environment variable / 通过环境变量配置端点+- HTTP POST with JSON request/response / 使用 JSON 请求/响应的 HTTP POST++**Architecture Position / 架构位置:**+- External client layer / 外部客户端层+- Communicates with OpenViking Server (Port 1933) / 与 OpenViking 服务器通信(端口 1933)++---++### 3.3 Vikingbot OpenAPIChannel++**Role:** AI agent framework with HTTP API / 带 HTTP API 的 AI 代理框架++**Key Features / 主要特性:**+- HTTP endpoints for chat, streaming, and health checks / 聊天、流式传输和健康检查的 HTTP 端点+- Integration with MessageBus for message routing / 与 MessageBus 集成进行消息路由+- Support for session management and context building / 支持会话管理和上下文构建++**Architecture Position / 架构位置:**+- Process 2 (Port 18791 default) / 进程2(默认端口 18791)+- Receives proxied requests from OpenViking Server / 接收来自 OpenViking 服务器的代理请求++---++### 3.4 MessageBus and Agent Loop / 消息总线与代理循环++**Role:** Core message routing and processing engine / 核心消息路由和处理引擎++**Components / 组件:**+- **MessageBus / 消息总线:** Inbound queue, Outbound queue, Log store / 入队队列、出队队列、日志存储+- **Agent Loop / 代理循环:** ContextBuilder, LLM (LiteLLM), Tool Executor / 上下文构建器、LLM、工具执行器++**Flow / 流程:**+```+Channel → MessageBus.inbound → Agent Loop → MessageBus.outbound → Channel+```++---++## 4. API Endpoints / API 端点++### 4.1 Bot API (via OpenViking Server)++| Method | Path | Description |+|--------|------|-------------|+| GET | `/api/v1/bot/health` | Health check |+| POST | `/api/v1/bot/chat` | Send message (non-streaming) |+| POST | `/api/v1/bot/chat/stream` | Send message (streaming, SSE) |++### 4.2 Response Codes++| Code | Condition |+|------|-----------|+| 200 | Success |+| 503 | `--with-bot` not enabled or bot service unavailable |+| 502 | Bot service returned an error |++---++## 5. Usage Examples / 使用示例++### 5.1 Start the services / 启动服务++```bash+# 启动 OpenViking Server (带 --with-bot 会自动启动 vikingbot gateway)+openviking-server --with-bot++# Output:+# OpenViking HTTP Server is running on 127.0.0.1:1933+# Bot API proxy enabled, forwarding to http://localhost:18791+# [vikingbot] Starting gateway on port 18791...+```++**说明 / Note:**+- `--with-bot`: 自动在同一机器上启动 `vikingbot gateway` 进程+- 不加 `--with-bot`: 仅启动 OpenViking Server,不会启动 Vikingbot++**设计意图 / Design Rationale:**+OpenViking Server 统一代理 Vikingbot 的 CLI 请求,目的是:+1. **共享鉴权机制** - 复用 OpenViking Server 的统一认证中间件+2. **端口共享** - 服务端部署时可共享端口,简化网络配置++### 5.2 Using `ov chat` CLI / 使用 `ov chat` CLI++```bash+# Interactive mode (default)+ov chat++# Single message mode+ov chat -m "Hello, bot!"++# Use custom endpoint+VIKINGBOT_ENDPOINT=http://localhost:1933/api/v1/bot ov chat -m "Hello!"+```++### 5.3 Direct HTTP API usage / 直接 HTTP API 使用++```bash+# Health check+curl http://localhost:1933/api/v1/bot/health++# Send a message+curl -X POST http://localhost:1933/api/v1/bot/chat \+ -H "Content-Type: application/json" \+ -d '{+ "message": "Hello!",+ "session_id": "test-session",+ "user_id": "test-user"+ }'++# Streaming response+curl -X POST http://localhost:1933/api/v1/bot/chat/stream \+ -H "Content-Type: application/json" \+ -d '{+ "message": "Hello!",+ "session_id": "test-session",+ "stream": true+ }'+```++---++## 6. Configuration / 配置++### 6.1 配置共享说明 / Configuration Sharing++**重要 / Important:** Vikingbot 与 OpenViking Server 共享同一个 `ov.conf` 配置文件,不再使用 `~/.vikingbot/config.json`。++Vikingbot 的配置项统一放在 `ov.conf` 的 `bot` 字段下:++```json+{+ "server": {+ "host": "127.0.0.1",+ "port": 1933,+ "root_api_key": "your-api-key",+ "with_bot": true,+ "bot_api_url": "http://localhost:18791"+ },+ "bot": {+ "agents": {+ "model": "openai/gpt-4o",+ "max_tool_iterations": 50,+ "memory_window": 50+ },+ "gateway": {+ "host": "0.0.0.0",+ "port": 18791+ },+ "channels": [+ {"type": "feishu", "enabled": false, "app_id": "", "app_secret": ""}+ ],+ "sandbox": {+ "backend": "direct",+ "mode": "shared"+ }+ }+}+```++**配置说明 / Configuration Notes:**+- `server.with_bot`: 启用时自动在同一机器上启动 Vikingbot gateway+- `bot.agents`: Agent 配置,包括 LLM 模型、最大工具迭代次数、记忆窗口+- `bot.gateway`: HTTP Gateway 监听地址+- `bot.channels`: 渠道配置列表,支持 openapi、feishu 等+- `bot.sandbox`: 沙箱执行配置++### 6.2 Command-line Options++```bash+# Enable Bot API proxy+openviking-server --with-bot++# Custom bot URL+openviking-server --with-bot --bot-url http://localhost:8080++# With config file+openviking-server --config /path/to/ov.conf+```++---++*End of Document*diff --git a/bot/pyproject.toml b/bot/pyproject.tomlindex 245031158..dc4ebbaa6 100644--- a/bot/pyproject.toml+++ b/bot/pyproject.toml@@ -1,6 +1,6 @@[project]name = "vikingbot"-version = "0.1.1"+version = "0.1.2"description = "A lightweight personal AI assistant framework"requires-python = ">=3.11, <=3.14"license = {text = "MIT"}@@ -28,32 +28,19 @@ dependencies = ["readability-lxml>=0.8.0","rich>=13.0.0","croniter>=2.0.0",- "dingtalk-stream>=0.4.0",- "python-telegram-bot[socks]>=21.0",- "lark-oapi>=1.0.0","socksio>=1.0.0","python-socketio>=5.11.0","msgpack>=1.0.8",- "slack-sdk>=3.26.0",- "qq-botpy>=1.0.0","python-socks[asyncio]>=2.4.0","prompt-toolkit>=3.0.0",- "textual>=0.50.0","pygments>=2.16.0",- "ddgs>=9.0.0","fastapi>=0.100.0","uvicorn>=0.20.0",- "opensandbox>=0.1.0",- "opensandbox-server>=0.1.0",- "agent-sandbox>=0.0.23","html2text>=2020.1.16","beautifulsoup4>=4.12.0",- "opencode-ai>=0.1.0a0","openviking>=0.1.18",- "tos>=2.9.0",+ "ddgs>=9.0.0","gradio>=6.6.0",- "fusepy>=3.0.1",- "pytest>=9.0.2",][project.optional-dependencies]@@ -62,6 +49,53 @@ dev = ["pytest-asyncio>=0.21.0","ruff>=0.1.0",]+langfuse = [+ "langfuse>=3.0.0",+]+# Channels - install only the ones you need+telegram = [+ "python-telegram-bot[socks]>=21.0",+]+feishu = [+ "lark-oapi>=1.0.0",+]+dingtalk = [+ "dingtalk-stream>=0.4.0",+]+slack = [+ "slack-sdk>=3.26.0",+]+qq = [+ "qq-botpy>=1.0.0",+]+# Sandbox backends+sandbox = [+ "opensandbox>=0.1.0",+ "opensandbox-server>=0.1.0",+ "agent-sandbox>=0.0.23",+]+# FUSE filesystem mount+fuse = [+ "fusepy>=3.0.1",+]+# OpenCode AI integration+opencode = [+ "opencode-ai>=0.1.0a0",+]+# Full installation - includes everything+full = [+ "langfuse>=3.0.0",+ "python-telegram-bot[socks]>=21.0",+ "lark-oapi>=1.0.0",+ "dingtalk-stream>=0.4.0",+ "slack-sdk>=3.26.0",+ "qq-botpy>=1.0.0",+ "opensandbox>=0.1.0",+ "opensandbox-server>=0.1.0",+ "agent-sandbox>=0.0.23",+ "fusepy>=3.0.1",+ "opencode-ai>=0.1.0a0",+][project.scripts]vikingbot = "vikingbot.cli.commands:app"diff --git a/bot/scripts/restart_openviking_server.sh b/bot/scripts/restart_openviking_server.shnew file mode 100755index 000000000..9094ba0b9--- /dev/null+++ b/bot/scripts/restart_openviking_server.sh@@ -0,0 +1,148 @@+#!/bin/bash++# Restart OpenViking Server with Bot API enabled+# Usage: ./restart_openviking_server.sh [--port PORT] [--bot-url URL]++set -e++# Default values+PORT="1933"+BOT_URL="http://localhost:18791"++# Parse arguments+while [[ $# -gt 0 ]]; do+ case $1 in+ --port)+ PORT="$2"+ shift 2+ ;;+ --bot-url)+ BOT_URL="$2"+ shift 2+ ;;+ *)+ echo "Unknown option: $1"+ echo "Usage: $0 [--port PORT] [--bot-url URL]"+ exit 1+ ;;+ esac+done++# Parse Bot URL to extract port+BOT_PORT=$(echo "$BOT_URL" | sed -n 's/.*:\([0-9]*\).*/\1/p')+if [ -z "$BOT_PORT" ]; then+ BOT_PORT="18791"+fi++echo "=========================================="+echo "Restarting OpenViking Server with Bot API"+echo "=========================================="+echo "OpenViking Server Port: $PORT"+echo "Bot URL: $BOT_URL"+echo "Bot Port: $BOT_PORT"+echo ""++# Step 0: Kill existing vikingbot processes+echo "Step 0: Stopping existing vikingbot processes..."+if pgrep -f "vikingbot.*openapi" > /dev/null 2>&1 || pgrep -f "vikingbot.*gateway" > /dev/null 2>&1; then+ pkill -f "vikingbot.*openapi" 2>/dev/null || true+ pkill -f "vikingbot.*gateway" 2>/dev/null || true+ sleep 2+ echo " ✓ Stopped existing vikingbot processes"+else+ echo " ✓ No existing vikingbot processes found"+fi++# Step 1: Kill existing openviking-server processes+echo "Step 1: Stopping existing openviking-server processes..."+if pgrep -f "openviking-server" > /dev/null 2>&1; then+ pkill -f "openviking-server" 2>/dev/null || true+ sleep 2+ # Force kill if still running+ if pgrep -f "openviking-server" > /dev/null 2>&1; then+ echo " Force killing remaining processes..."+ pkill -9 -f "openviking-server" 2>/dev/null || true+ sleep 1+ fi+ echo " ✓ Stopped existing processes"+else+ echo " ✓ No existing processes found"+fi++# Step 2: Wait for port to be released+echo ""+echo "Step 2: Waiting for port $PORT to be released..."+for i in {1..10}; do+ if ! lsof -i :"$PORT" > /dev/null 2>&1; then+ echo " ✓ Port $PORT is free"+ break+ fi+ sleep 1+done++# Step 3: Start openviking-server with --with-bot+echo ""+echo "Step 3: Starting openviking-server with Bot API..."+echo " Command: openviking-server --with-bot --port $PORT --bot-url $BOT_URL"+echo ""++# Start in background and log to file+#nohup openviking-server \+ --with-bot \+ --port "$PORT" \+ --bot-url "$BOT_URL" \+ > /tmp/openviking-server.log 2>&1 &++openviking-server \+ --with-bot \+ --port "$PORT" \+ --bot-url "$BOT_URL"+++SERVER_PID=$!+echo " Server PID: $SERVER_PID"++# Step 4: Wait for server to start+echo ""+echo "Step 4: Waiting for server to be ready..."+sleep 3++# First check if server is responding at all+for i in {1..10}; do+ if curl -s http://localhost:"$PORT"/api/v1/bot/health > /dev/null 2>&1; then+ echo ""+ echo "=========================================="+ echo "✓ OpenViking Server started successfully!"+ echo "=========================================="+ echo ""+ echo "Server URL: http://localhost:$PORT"+ echo "Health Check: http://localhost:$PORT/api/v1/bot/health"+ echo "Logs: tail -f /tmp/openviking-server.log"+ echo ""+ exit 0+ fi+ # Check actual health response+ health_response=$(curl -s http://localhost:"$PORT"/api/v1/bot/health 2>/dev/null)+ if echo "$health_response" | grep -q "Vikingbot"; then+ echo " ✓ Vikingbot is healthy"+ elif echo "$health_response" | grep -q "Bot service unavailable"; then+ echo " ⏳ Waiting for Vikingbot to start (attempt $i/10)..."+ fi+ sleep 2+done++# If we reach here, server failed to start+echo ""+echo "=========================================="+echo "✗ Failed to start OpenViking Server"+echo "=========================================="+echo ""+echo "Recent logs:"+tail -20 /tmp/openviking-server.log 2>/dev/null || echo "(No logs available)"+echo ""+echo "Troubleshooting:"+echo " 1. Check if port $PORT is in use: lsof -i :$PORT"+echo " 2. Check Vikingbot is running on $BOT_URL"+echo " 3. Check logs: tail -f /tmp/openviking-server.log"+echo ""+exit 1diff --git a/bot/uv.lock b/bot/uv.lockindex 2bcce9761..638cb0827 100644--- a/bot/uv.lock+++ b/bot/uv.lock@@ -263,6 +263,15 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/f6/22/91616fe707a5c5510de2cac9b046a30defe7007ba8a0c04f9c08f27df312/audioop_lts-0.2.2-cp314-cp314t-win_arm64.whl", hash = "sha256:b492c3b040153e68b9fdaff5913305aaaba5bb433d8a7f73d5cf6a64ed3cc1dd", size = 25206, upload-time = "2025-08-05T16:43:16.444Z" },]+[[package]]+name = "backoff"+version = "2.2.1"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/47/d7/5bbeb12c44d7c4f2fb5b56abce497eb5ed9f34d85701de869acedd602619/backoff-2.2.1.tar.gz", hash = "sha256:03f829f5bb1923180821643f8753b0502c3b682293992485b0eef2807afa5cba", size = 17001, upload-time = "2022-10-05T19:19:32.061Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/df/73/b6e24bd22e6720ca8ee9a85a0c4a2971af8497d8f3193fa05390cbd46e09/backoff-2.2.1-py3-none-any.whl", hash = "sha256:63579f9a0628e06278f7e47b7d7d5b6ce20dc65c5e96a6f3ca99a6adca0396e8", size = 15148, upload-time = "2022-10-05T19:19:30.546Z" },+]+[[package]]name = "beautifulsoup4"version = "4.14.3"@@ -535,12 +544,6 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },]-[[package]]-name = "crcmod"-version = "1.7"-source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/6b/b0/e595ce2a2527e169c3bcd6c33d2473c1918e0b7f6826a043ca1245dd4e5b/crcmod-1.7.tar.gz", hash = "sha256:dc7051a0db5f2bd48665a990d3ec1cc305a466a77358ca4492826f41f283601e", size = 89670, upload-time = "2010-06-27T14:35:29.538Z" }-[[package]]name = "croniter"version = "6.0.0"@@ -647,18 +650,6 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/4e/8c/f3147f5c4b73e7550fe5f9352eaa956ae838d5c51eb58e7a25b9f3e2643b/decorator-5.2.1-py3-none-any.whl", hash = "sha256:d316bb415a2d9e2d2b3abcc4084c6502fc09240e292cd76a76afc106a1c8e04a", size = 9190, upload-time = "2025-02-24T04:41:32.565Z" },]-[[package]]-name = "deprecated"-version = "1.3.1"-source = { registry = "https://pypi.org/simple" }-dependencies = [- { name = "wrapt" },-]-sdist = { url = "https://files.pythonhosted.org/packages/49/85/12f0a49a7c4ffb70572b6c2ef13c90c88fd190debda93b23f026b25f9634/deprecated-1.3.1.tar.gz", hash = "sha256:b1b50e0ff0c1fddaa5708a2c6b0a6588bb09b892825ab2b214ac9ea9d92a5223", size = 2932523, upload-time = "2025-10-30T08:19:02.757Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/84/d0/205d54408c08b13550c733c4b85429e7ead111c7f0014309637425520a9a/deprecated-1.3.1-py2.py3-none-any.whl", hash = "sha256:597bfef186b6f60181535a29fbe44865ce137a5079f295b479886c82729d5f3f", size = 11298, upload-time = "2025-10-30T08:19:00.758Z" },-]-[[package]]name = "dingtalk-stream"version = "0.24.3"@@ -953,6 +944,18 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/ac/35/17c9141c4ae21e9a29a43acdfd848e3e468a810517f862cad07977bf8fe9/google-3.0.0-py2.py3-none-any.whl", hash = "sha256:889cf695f84e4ae2c55fbc0cfdaf4c1e729417fa52ab1db0485202ba173e4935", size = 45258, upload-time = "2020-07-11T14:49:58.287Z" },]+[[package]]+name = "googleapis-common-protos"+version = "1.72.0"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "protobuf" },+]+sdist = { url = "https://files.pythonhosted.org/packages/e5/7b/adfd75544c415c487b33061fe7ae526165241c1ea133f9a9125a56b39fd8/googleapis_common_protos-1.72.0.tar.gz", hash = "sha256:e55a601c1b32b52d7a3e65f43563e2aa61bcd737998ee672ac9b951cd49319f5", size = 147433, upload-time = "2025-11-06T18:29:24.087Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/c4/ab/09169d5a4612a5f92490806649ac8d41e3ec9129c636754575b3553f4ea4/googleapis_common_protos-1.72.0-py3-none-any.whl", hash = "sha256:4299c5a82d5ae1a9702ada957347726b167f9f8d1fc352477702a1e851ff4038", size = 297515, upload-time = "2025-11-06T18:29:13.14Z" },+]+[[package]]name = "gradio"version = "6.6.0"@@ -1354,30 +1357,39 @@ wheels = [][[package]]-name = "lark-oapi"-version = "1.5.3"+name = "langfuse"+version = "3.14.5"source = { registry = "https://pypi.org/simple" }dependencies = [+ { name = "backoff" },{ name = "httpx" },- { name = "pycryptodome" },+ { name = "openai" },+ { name = "opentelemetry-api" },+ { name = "opentelemetry-exporter-otlp-proto-http" },+ { name = "opentelemetry-sdk" },+ { name = "packaging" },+ { name = "pydantic" },{ name = "requests" },- { name = "requests-toolbelt" },- { name = "websockets" },+ { name = "wrapt" },]+sdist = { url = "https://files.pythonhosted.org/packages/ec/6b/7a945e8bc56cbf343b6f6171fd45870b0ea80ea38463b2db8dd5a9dc04a2/langfuse-3.14.5.tar.gz", hash = "sha256:2f543ec1540053d39b08a50ed5992caf1cd54d472a55cb8e5dcf6d4fcb7ff631", size = 235474, upload-time = "2026-02-23T10:42:47.721Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/bf/ff/2ece5d735ebfa2af600a53176f2636ae47af2bf934e08effab64f0d1e047/lark_oapi-1.5.3-py3-none-any.whl", hash = "sha256:fda6b32bb38d21b6bdaae94979c600b94c7c521e985adade63a54e4b3e20cc36", size = 6993016, upload-time = "2026-01-27T08:21:49.307Z" },+ { url = "https://files.pythonhosted.org/packages/a3/a1/10f04224542d6a57073c4f339b6763836a0899c98966f1d4ffcf56d2cf61/langfuse-3.14.5-py3-none-any.whl", hash = "sha256:5054b1c705ec69bce2d7077ce7419727ac629159428da013790979ca9cae77d5", size = 421240, upload-time = "2026-02-23T10:42:46.085Z" },][[package]]-name = "linkify-it-py"-version = "2.0.3"+name = "lark-oapi"+version = "1.5.3"source = { registry = "https://pypi.org/simple" }dependencies = [- { name = "uc-micro-py" },+ { name = "httpx" },+ { name = "pycryptodome" },+ { name = "requests" },+ { name = "requests-toolbelt" },+ { name = "websockets" },]-sdist = { url = "https://files.pythonhosted.org/packages/2a/ae/bb56c6828e4797ba5a4821eec7c43b8bf40f69cda4d4f5f8c8a2810ec96a/linkify-it-py-2.0.3.tar.gz", hash = "sha256:68cda27e162e9215c17d786649d1da0021a451bdc436ef9e0fa0ba5234b9b048", size = 27946, upload-time = "2024-02-04T14:48:04.179Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/04/1e/b832de447dee8b582cac175871d2f6c3d5077cc56d5575cadba1fd1cccfa/linkify_it_py-2.0.3-py3-none-any.whl", hash = "sha256:6bcbc417b0ac14323382aef5c5192c0075bf8a9d6b41820a2b66371eac6b6d79", size = 19820, upload-time = "2024-02-04T14:48:02.496Z" },+ { url = "https://files.pythonhosted.org/packages/bf/ff/2ece5d735ebfa2af600a53176f2636ae47af2bf934e08effab64f0d1e047/lark_oapi-1.5.3-py3-none-any.whl", hash = "sha256:fda6b32bb38d21b6bdaae94979c600b94c7c521e985adade63a54e4b3e20cc36", size = 6993016, upload-time = "2026-01-27T08:21:49.307Z" },][[package]]@@ -1547,11 +1559,6 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/94/54/e7d793b573f298e1c9013b8c4dade17d481164aa517d1d7148619c2cedbf/markdown_it_py-4.0.0-py3-none-any.whl", hash = "sha256:87327c59b172c5011896038353a81343b6754500a08cd7a4973bb48c6d578147", size = 87321, upload-time = "2025-08-11T12:57:51.923Z" },]-[package.optional-dependencies]-linkify = [- { name = "linkify-it-py" },-]-[[package]]name = "markdownify"version = "1.2.2"@@ -1639,18 +1646,6 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/70/bc/6f1c2f612465f5fa89b95bead1f44dcb607670fd42891d8fdcd5d039f4f4/markupsafe-3.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:32001d6a8fc98c8cb5c947787c5d08b0a50663d139f1305bac5885d98d9b40fa", size = 14146, upload-time = "2025-09-27T18:37:28.327Z" },]-[[package]]-name = "mdit-py-plugins"-version = "0.5.0"-source = { registry = "https://pypi.org/simple" }-dependencies = [- { name = "markdown-it-py" },-]-sdist = { url = "https://files.pythonhosted.org/packages/b2/fd/a756d36c0bfba5f6e39a1cdbdbfdd448dc02692467d83816dff4592a1ebc/mdit_py_plugins-0.5.0.tar.gz", hash = "sha256:f4918cb50119f50446560513a8e311d574ff6aaed72606ddae6d35716fe809c6", size = 44655, upload-time = "2025-08-11T07:25:49.083Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/fb/86/dd6e5db36df29e76c7a7699123569a4a18c1623ce68d826ed96c62643cae/mdit_py_plugins-0.5.0-py3-none-any.whl", hash = "sha256:07a08422fc1936a5d26d146759e9155ea466e842f5ab2f7d2266dd084c8dab1f", size = 57205, upload-time = "2025-08-11T07:25:47.597Z" },-]-[[package]]name = "mdurl"version = "0.1.2"@@ -1969,6 +1964,88 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/69/8b/39f0a9ece971139c9370bdd7b7c8a11aedb39a6216098c5dd63267fe5e07/opensandbox_server-0.1.2-py3-none-any.whl", hash = "sha256:49807cf9c463fbfd3ada12d5f082af9fdd09c021998abb0908b444b729145631", size = 84905, upload-time = "2026-02-09T12:23:01.623Z" },]+[[package]]+name = "opentelemetry-api"+version = "1.39.1"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "importlib-metadata" },+ { name = "typing-extensions" },+]+sdist = { url = "https://files.pythonhosted.org/packages/97/b9/3161be15bb8e3ad01be8be5a968a9237c3027c5be504362ff800fca3e442/opentelemetry_api-1.39.1.tar.gz", hash = "sha256:fbde8c80e1b937a2c61f20347e91c0c18a1940cecf012d62e65a7caf08967c9c", size = 65767, upload-time = "2025-12-11T13:32:39.182Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/cf/df/d3f1ddf4bb4cb50ed9b1139cc7b1c54c34a1e7ce8fd1b9a37c0d1551a6bd/opentelemetry_api-1.39.1-py3-none-any.whl", hash = "sha256:2edd8463432a7f8443edce90972169b195e7d6a05500cd29e6d13898187c9950", size = 66356, upload-time = "2025-12-11T13:32:17.304Z" },+]++[[package]]+name = "opentelemetry-exporter-otlp-proto-common"+version = "1.39.1"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "opentelemetry-proto" },+]+sdist = { url = "https://files.pythonhosted.org/packages/e9/9d/22d241b66f7bbde88a3bfa6847a351d2c46b84de23e71222c6aae25c7050/opentelemetry_exporter_otlp_proto_common-1.39.1.tar.gz", hash = "sha256:763370d4737a59741c89a67b50f9e39271639ee4afc999dadfe768541c027464", size = 20409, upload-time = "2025-12-11T13:32:40.885Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/8c/02/ffc3e143d89a27ac21fd557365b98bd0653b98de8a101151d5805b5d4c33/opentelemetry_exporter_otlp_proto_common-1.39.1-py3-none-any.whl", hash = "sha256:08f8a5862d64cc3435105686d0216c1365dc5701f86844a8cd56597d0c764fde", size = 18366, upload-time = "2025-12-11T13:32:20.2Z" },+]++[[package]]+name = "opentelemetry-exporter-otlp-proto-http"+version = "1.39.1"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "googleapis-common-protos" },+ { name = "opentelemetry-api" },+ { name = "opentelemetry-exporter-otlp-proto-common" },+ { name = "opentelemetry-proto" },+ { name = "opentelemetry-sdk" },+ { name = "requests" },+ { name = "typing-extensions" },+]+sdist = { url = "https://files.pythonhosted.org/packages/80/04/2a08fa9c0214ae38880df01e8bfae12b067ec0793446578575e5080d6545/opentelemetry_exporter_otlp_proto_http-1.39.1.tar.gz", hash = "sha256:31bdab9745c709ce90a49a0624c2bd445d31a28ba34275951a6a362d16a0b9cb", size = 17288, upload-time = "2025-12-11T13:32:42.029Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/95/f1/b27d3e2e003cd9a3592c43d099d2ed8d0a947c15281bf8463a256db0b46c/opentelemetry_exporter_otlp_proto_http-1.39.1-py3-none-any.whl", hash = "sha256:d9f5207183dd752a412c4cd564ca8875ececba13be6e9c6c370ffb752fd59985", size = 19641, upload-time = "2025-12-11T13:32:22.248Z" },+]++[[package]]+name = "opentelemetry-proto"+version = "1.39.1"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "protobuf" },+]+sdist = { url = "https://files.pythonhosted.org/packages/49/1d/f25d76d8260c156c40c97c9ed4511ec0f9ce353f8108ca6e7561f82a06b2/opentelemetry_proto-1.39.1.tar.gz", hash = "sha256:6c8e05144fc0d3ed4d22c2289c6b126e03bcd0e6a7da0f16cedd2e1c2772e2c8", size = 46152, upload-time = "2025-12-11T13:32:48.681Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/51/95/b40c96a7b5203005a0b03d8ce8cd212ff23f1793d5ba289c87a097571b18/opentelemetry_proto-1.39.1-py3-none-any.whl", hash = "sha256:22cdc78efd3b3765d09e68bfbd010d4fc254c9818afd0b6b423387d9dee46007", size = 72535, upload-time = "2025-12-11T13:32:33.866Z" },+]++[[package]]+name = "opentelemetry-sdk"+version = "1.39.1"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "opentelemetry-api" },+ { name = "opentelemetry-semantic-conventions" },+ { name = "typing-extensions" },+]+sdist = { url = "https://files.pythonhosted.org/packages/eb/fb/c76080c9ba07e1e8235d24cdcc4d125ef7aa3edf23eb4e497c2e50889adc/opentelemetry_sdk-1.39.1.tar.gz", hash = "sha256:cf4d4563caf7bff906c9f7967e2be22d0d6b349b908be0d90fb21c8e9c995cc6", size = 171460, upload-time = "2025-12-11T13:32:49.369Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/7c/98/e91cf858f203d86f4eccdf763dcf01cf03f1dae80c3750f7e635bfa206b6/opentelemetry_sdk-1.39.1-py3-none-any.whl", hash = "sha256:4d5482c478513ecb0a5d938dcc61394e647066e0cc2676bee9f3af3f3f45f01c", size = 132565, upload-time = "2025-12-11T13:32:35.069Z" },+]++[[package]]+name = "opentelemetry-semantic-conventions"+version = "0.60b1"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "opentelemetry-api" },+ { name = "typing-extensions" },+]+sdist = { url = "https://files.pythonhosted.org/packages/91/df/553f93ed38bf22f4b999d9be9c185adb558982214f33eae539d3b5cd0858/opentelemetry_semantic_conventions-0.60b1.tar.gz", hash = "sha256:87c228b5a0669b748c76d76df6c364c369c28f1c465e50f661e39737e84bc953", size = 137935, upload-time = "2025-12-11T13:32:50.487Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/7a/5e/5958555e09635d09b75de3c4f8b9cae7335ca545d77392ffe7331534c402/opentelemetry_semantic_conventions-0.60b1-py3-none-any.whl", hash = "sha256:9fa8c8b0c110da289809292b0591220d3a7b53c1526a23021e977d68597893fb", size = 219982, upload-time = "2025-12-11T13:32:36.955Z" },+]+[[package]]name = "openviking"version = "0.1.18"@@ -2090,11 +2167,11 @@ wheels = [[[package]]name = "packaging"-version = "26.0"+version = "25.0"source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/65/ee/299d360cdc32edc7d2cf530f3accf79c4fca01e96ffc950d8a52213bd8e4/packaging-26.0.tar.gz", hash = "sha256:00243ae351a257117b6a241061796684b084ed1c516a08c48a3f7e147a9d80b4", size = 143416, upload-time = "2026-01-21T20:50:39.064Z" }+sdist = { url = "https://files.pythonhosted.org/packages/a1/d4/1fc4078c65507b51b96ca8f8c3ba19e6a61c8253c72794544580a7b6c24d/packaging-25.0.tar.gz", hash = "sha256:d443872c98d677bf60f6a1f2f8c1cb748e8fe762d2bf9d3148b5599295b0fc4f", size = 165727, upload-time = "2025-04-19T11:48:59.673Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/b7/b9/c538f279a4e237a006a2c98387d081e9eb060d203d8ed34467cc0f0b9b53/packaging-26.0-py3-none-any.whl", hash = "sha256:b36f1fef9334a5588b4166f8bcd26a14e521f2b55e6b9de3aaa80d3ff7a37529", size = 74366, upload-time = "2026-01-21T20:50:37.788Z" },+ { url = "https://files.pythonhosted.org/packages/20/12/38679034af332785aac8774540895e234f4d07f7545804097de4b666afd8/packaging-25.0-py3-none-any.whl", hash = "sha256:29572ef2b1f17581046b3a2227d5c611fb25ec70ca1ba8554b24b0e69331a484", size = 66469, upload-time = "2025-04-19T11:48:57.875Z" },][[package]]@@ -2265,15 +2342,6 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/f2/26/c56ce33ca856e358d27fda9676c055395abddb82c35ac0f593877ed4562e/pillow-12.1.1-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:cb9bb857b2d057c6dfc72ac5f3b44836924ba15721882ef103cecb40d002d80e", size = 7029880, upload-time = "2026-02-11T04:23:04.783Z" },]-[[package]]-name = "platformdirs"-version = "4.7.0"-source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/71/25/ccd8e88fcd16a4eb6343a8b4b9635e6f3928a7ebcd82822a14d20e3ca29f/platformdirs-4.7.0.tar.gz", hash = "sha256:fd1a5f8599c85d49b9ac7d6e450bc2f1aaf4a23f1fe86d09952fe20ad365cf36", size = 23118, upload-time = "2026-02-12T22:21:53.764Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/cb/e3/1eddccb2c39ecfbe09b3add42a04abcc3fa5b468aa4224998ffb8a7e9c8f/platformdirs-4.7.0-py3-none-any.whl", hash = "sha256:1ed8db354e344c5bb6039cd727f096af975194b508e37177719d562b2b540ee6", size = 18983, upload-time = "2026-02-12T22:21:52.237Z" },-]-[[package]]name = "pluggy"version = "1.6.0"@@ -3371,23 +3439,6 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/40/44/4a5f08c96eb108af5cb50b41f76142f0afa346dfa99d5296fe7202a11854/tabulate-0.9.0-py3-none-any.whl", hash = "sha256:024ca478df22e9340661486f85298cff5f6dcdba14f3813e8830015b9ed1948f", size = 35252, upload-time = "2022-10-06T17:21:44.262Z" },]-[[package]]-name = "textual"-version = "7.5.0"-source = { registry = "https://pypi.org/simple" }-dependencies = [- { name = "markdown-it-py", extra = ["linkify"] },- { name = "mdit-py-plugins" },- { name = "platformdirs" },- { name = "pygments" },- { name = "rich" },- { name = "typing-extensions" },-]-sdist = { url = "https://files.pythonhosted.org/packages/9f/38/7d169a765993efde5095c70a668bf4f5831bb7ac099e932f2783e9b71abf/textual-7.5.0.tar.gz", hash = "sha256:c730cba1e3d704e8f1ca915b6a3af01451e3bca380114baacf6abf87e9dac8b6", size = 1592319, upload-time = "2026-01-30T13:46:39.881Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/9c/78/96ddb99933e11d91bc6e05edae23d2687e44213066bcbaca338898c73c47/textual-7.5.0-py3-none-any.whl", hash = "sha256:849dfee9d705eab3b2d07b33152b7bd74fb1f5056e002873cc448bce500c6374", size = 718164, upload-time = "2026-01-30T13:46:37.635Z" },-]-[[package]]name = "tiktoken"version = "0.12.0"@@ -3477,20 +3528,6 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/bd/75/8539d011f6be8e29f339c42e633aae3cb73bffa95dd0f9adec09b9c58e85/tomlkit-0.13.3-py3-none-any.whl", hash = "sha256:c89c649d79ee40629a9fda55f8ace8c6a1b42deb912b2a8fd8d942ddadb606b0", size = 38901, upload-time = "2025-06-05T07:13:43.546Z" },]-[[package]]-name = "tos"-version = "2.9.0"-source = { registry = "https://pypi.org/simple" }-dependencies = [- { name = "crcmod" },- { name = "deprecated" },- { name = "pytz" },- { name = "requests" },- { name = "six" },- { name = "wrapt" },-]-sdist = { url = "https://files.pythonhosted.org/packages/9a/b3/13451226f564f88d9db2323e9b7eabcced792a0ad5ee1e333751a7634257/tos-2.9.0.tar.gz", hash = "sha256:861cfc348e770f099f911cb96b2c41774ada6c9c51b7a89d97e0c426074dd99e", size = 157071, upload-time = "2026-01-06T04:13:08.921Z" }-[[package]]name = "tqdm"version = "4.67.3"@@ -3572,15 +3609,6 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/c2/14/e2a54fabd4f08cd7af1c07030603c3356b74da07f7cc056e600436edfa17/tzlocal-5.3.1-py3-none-any.whl", hash = "sha256:eb1a66c3ef5847adf7a834f1be0800581b683b5608e74f86ecbcef8ab91bb85d", size = 18026, upload-time = "2025-03-05T21:17:39.857Z" },]-[[package]]-name = "uc-micro-py"-version = "1.0.3"-source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/91/7a/146a99696aee0609e3712f2b44c6274566bc368dfe8375191278045186b8/uc-micro-py-1.0.3.tar.gz", hash = "sha256:d321b92cff673ec58027c04015fcaa8bb1e005478643ff4a500882eaab88c48a", size = 6043, upload-time = "2024-02-09T16:52:01.654Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/37/87/1f677586e8ac487e29672e4b17455758fce261de06a0d086167bb760361a/uc_micro_py-1.0.3-py3-none-any.whl", hash = "sha256:db1dffff340817673d7b466ec86114a9dc0e9d4d9b5ba229d9d60e5c12600cd5", size = 6229, upload-time = "2024-02-09T16:52:00.371Z" },-]-[[package]]name = "urllib3"version = "2.6.3"@@ -3608,39 +3636,26 @@ name = "vikingbot"version = "0.1.1"source = { editable = "." }dependencies = [- { name = "agent-sandbox" },{ name = "beautifulsoup4" },{ name = "croniter" },{ name = "ddgs" },- { name = "dingtalk-stream" },{ name = "fastapi" },- { name = "fusepy" },{ name = "gradio" },{ name = "html2text" },{ name = "httpx", extra = ["socks"] },- { name = "lark-oapi" },{ name = "litellm" },{ name = "loguru" },{ name = "msgpack" },- { name = "opencode-ai" },- { name = "opensandbox" },- { name = "opensandbox-server" },{ name = "openviking" },{ name = "prompt-toolkit" },{ name = "pydantic" },{ name = "pydantic-settings" },{ name = "pygments" },- { name = "pytest" },{ name = "python-socketio" },{ name = "python-socks" },- { name = "python-telegram-bot", extra = ["socks"] },- { name = "qq-botpy" },{ name = "readability-lxml" },{ name = "rich" },- { name = "slack-sdk" },{ name = "socksio" },- { name = "textual" },- { name = "tos" },{ name = "typer" },{ name = "uvicorn" },{ name = "websocket-client" },@@ -3653,51 +3668,102 @@ dev = [{ name = "pytest-asyncio" },{ name = "ruff" },]+dingtalk = [+ { name = "dingtalk-stream" },+]+feishu = [+ { name = "lark-oapi" },+]+full = [+ { name = "agent-sandbox" },+ { name = "dingtalk-stream" },+ { name = "fusepy" },+ { name = "langfuse" },+ { name = "lark-oapi" },+ { name = "opencode-ai" },+ { name = "opensandbox" },+ { name = "opensandbox-server" },+ { name = "python-telegram-bot", extra = ["socks"] },+ { name = "qq-botpy" },+ { name = "slack-sdk" },+]+fuse = [+ { name = "fusepy" },+]+langfuse = [+ { name = "langfuse" },+]+opencode = [+ { name = "opencode-ai" },+]+qq = [+ { name = "qq-botpy" },+]+sandbox = [+ { name = "agent-sandbox" },+ { name = "opensandbox" },+ { name = "opensandbox-server" },+]+slack = [+ { name = "slack-sdk" },+]+telegram = [+ { name = "python-telegram-bot", extra = ["socks"] },+][package.metadata]requires-dist = [- { name = "agent-sandbox", specifier = ">=0.0.23" },+ { name = "agent-sandbox", marker = "extra == 'full'", specifier = ">=0.0.23" },+ { name = "agent-sandbox", marker = "extra == 'sandbox'", specifier = ">=0.0.23" },{ name = "beautifulsoup4", specifier = ">=4.12.0" },{ name = "croniter", specifier = ">=2.0.0" },{ name = "ddgs", specifier = ">=9.0.0" },- { name = "dingtalk-stream", specifier = ">=0.4.0" },+ { name = "dingtalk-stream", marker = "extra == 'dingtalk'", specifier = ">=0.4.0" },+ { name = "dingtalk-stream", marker = "extra == 'full'", specifier = ">=0.4.0" },{ name = "fastapi", specifier = ">=0.100.0" },- { name = "fusepy", specifier = ">=3.0.1" },+ { name = "fusepy", marker = "extra == 'full'", specifier = ">=3.0.1" },+ { name = "fusepy", marker = "extra == 'fuse'", specifier = ">=3.0.1" },{ name = "gradio", specifier = ">=6.6.0" },{ name = "html2text", specifier = ">=2020.1.16" },{ name = "httpx", extras = ["socks"], specifier = ">=0.25.0" },- { name = "lark-oapi", specifier = ">=1.0.0" },+ { name = "langfuse", marker = "extra == 'full'", specifier = ">=3.0.0" },+ { name = "langfuse", marker = "extra == 'langfuse'", specifier = ">=3.0.0" },+ { name = "lark-oapi", marker = "extra == 'feishu'", specifier = ">=1.0.0" },+ { name = "lark-oapi", marker = "extra == 'full'", specifier = ">=1.0.0" },{ name = "litellm", specifier = ">=1.0.0" },{ name = "loguru", specifier = ">=0.7.0" },{ name = "msgpack", specifier = ">=1.0.8" },- { name = "opencode-ai", specifier = ">=0.1.0a0" },- { name = "opensandbox", specifier = ">=0.1.0" },- { name = "opensandbox-server", specifier = ">=0.1.0" },+ { name = "opencode-ai", marker = "extra == 'full'", specifier = ">=0.1.0a0" },+ { name = "opencode-ai", marker = "extra == 'opencode'", specifier = ">=0.1.0a0" },+ { name = "opensandbox", marker = "extra == 'full'", specifier = ">=0.1.0" },+ { name = "opensandbox", marker = "extra == 'sandbox'", specifier = ">=0.1.0" },+ { name = "opensandbox-server", marker = "extra == 'full'", specifier = ">=0.1.0" },+ { name = "opensandbox-server", marker = "extra == 'sandbox'", specifier = ">=0.1.0" },{ name = "openviking", specifier = ">=0.1.18" },{ name = "prompt-toolkit", specifier = ">=3.0.0" },{ name = "pydantic", specifier = ">=2.0.0" },{ name = "pydantic-settings", specifier = ">=2.0.0" },{ name = "pygments", specifier = ">=2.16.0" },- { name = "pytest", specifier = ">=9.0.2" },{ name = "pytest", marker = "extra == 'dev'", specifier = ">=7.0.0" },{ name = "pytest-asyncio", marker = "extra == 'dev'", specifier = ">=0.21.0" },{ name = "python-socketio", specifier = ">=5.11.0" },{ name = "python-socks", extras = ["asyncio"], specifier = ">=2.4.0" },- { name = "python-telegram-bot", extras = ["socks"], specifier = ">=21.0" },- { name = "qq-botpy", specifier = ">=1.0.0" },+ { name = "python-telegram-bot", extras = ["socks"], marker = "extra == 'full'", specifier = ">=21.0" },+ { name = "python-telegram-bot", extras = ["socks"], marker = "extra == 'telegram'", specifier = ">=21.0" },+ { name = "qq-botpy", marker = "extra == 'full'", specifier = ">=1.0.0" },+ { name = "qq-botpy", marker = "extra == 'qq'", specifier = ">=1.0.0" },{ name = "readability-lxml", specifier = ">=0.8.0" },{ name = "rich", specifier = ">=13.0.0" },{ name = "ruff", marker = "extra == 'dev'", specifier = ">=0.1.0" },- { name = "slack-sdk", specifier = ">=3.26.0" },+ { name = "slack-sdk", marker = "extra == 'full'", specifier = ">=3.26.0" },+ { name = "slack-sdk", marker = "extra == 'slack'", specifier = ">=3.26.0" },{ name = "socksio", specifier = ">=1.0.0" },- { name = "textual", specifier = ">=0.50.0" },- { name = "tos", specifier = ">=2.9.0" },{ name = "typer", specifier = ">=0.9.0" },{ name = "uvicorn", specifier = ">=0.20.0" },{ name = "websocket-client", specifier = ">=1.6.0" },{ name = "websockets", specifier = ">=12.0" },]-provides-extras = ["dev"]+provides-extras = ["dev", "langfuse", "telegram", "feishu", "dingtalk", "slack", "qq", "sandbox", "fuse", "opencode", "full"][[package]]name = "volcengine"diff --git a/bot/vikingbot/__init__.py b/bot/vikingbot/__init__.pyindex 5da128147..58982321f 100644--- a/bot/vikingbot/__init__.py+++ b/bot/vikingbot/__init__.py@@ -2,5 +2,5 @@vikingbot - A lightweight AI agent framework"""-__version__ = "0.1.0"+__version__ = "0.1.2"__logo__ = "🐈"diff --git a/bot/vikingbot/agent/context.py b/bot/vikingbot/agent/context.pyindex 40c36e50a..25570043e 100644--- a/bot/vikingbot/agent/context.py+++ b/bot/vikingbot/agent/context.py@@ -29,12 +29,18 @@ class ContextBuilder:self,workspace: Path,sandbox_manager: SandboxManager | None = None,+ sender_id: str = None,+ is_group_chat: bool = False,+ eval: bool = False,):self.workspace = workspaceself._templates_ensured = Falseself.sandbox_manager = sandbox_managerself._memory = Noneself._skills = None+ self._sender_id = sender_id+ self._is_group_chat = is_group_chat+ self._eval = eval@propertydef memory(self):@@ -72,7 +78,7 @@ class ContextBuilder:"""# Ensure workspace templates exist only when first neededself._ensure_templates_once()- sandbox_key = self.sandbox_manager.to_sandbox_key(session_key)+ workspace_id = self.sandbox_manager.to_workspace_id(session_key)parts = []@@ -82,22 +88,29 @@ class ContextBuilder:# Sandbox environment infoif self.sandbox_manager:sandbox_cwd = await self.sandbox_manager.get_sandbox_cwd(session_key)-parts.append(f"## Sandbox Environment\n\nYou are running in a sandboxed environment. All file operations and command execution are restricted to the sandbox directory.\nThe sandbox root directory is `{sandbox_cwd}` (use relative paths for all operations).")+ # Add group chat context if applicable+ if self._is_group_chat:+ parts.append(+ f"\n\n## Group Chat Context\nThis is a group chat session. Multiple users can participate in this conversation. Each user message is prefixed with the user ID in brackets like @<user_id>. "+ f"You should pay attention to who is speaking to understand the context. Current user ID: {self._sender_id}")+# Viking user profile- profile = await self.memory.get_viking_user_profile(sandbox_key=sandbox_key)+ profile = await self.memory.get_viking_user_profile(+ workspace_id=workspace_id, user_id=self._sender_id+ )if profile:- parts.append(profile)+ parts.append(f"## Current user's information\n{profile}")- # Viking memory+ # Viking agent memoryviking_memory = await self.memory.get_viking_memory_context(- current_message=current_message, sandbox_key=sandbox_key+ current_message=current_message, workspace_id=workspace_id)if viking_memory:- parts.append(viking_memory)+ parts.append(f"## Your memories. Using tools to read more details.\n{viking_memory}")# Bootstrap filesbootstrap = self._load_bootstrap_files()@@ -198,7 +211,6 @@ Always be helpful, accurate, and concise. When using tools, think step by step:self,history: list[dict[str, Any]],current_message: str,- skill_names: list[str] | None = None,media: list[str] | None = None,session_key: SessionKey | None = None,) -> list[dict[str, Any]]:@@ -208,10 +220,8 @@ Always be helpful, accurate, and concise. When using tools, think step by step:Args:history: Previous conversation messages.current_message: The new user message.- skill_names: Optional skills to include.media: Optional list of local file paths for images/media.- channel: Current channel (telegram, feishu, etc.).- chat_id: Current chat/user ID.+ session_key: Optional session key.Returns:List of messages including system prompt.@@ -220,13 +230,14 @@ Always be helpful, accurate, and concise. When using tools, think step by step:# System promptsystem_prompt = await self.build_system_prompt(session_key, current_message, history)- if session_key.channel_id and session_key.chat_id:+ if session_key and session_key.channel_id and session_key.chat_id:system_prompt += f"\n\n## Current Session\nChannel: {session_key.type}:{session_key.channel_id}\nChat ID: {session_key.chat_id}"messages.append({"role": "system", "content": system_prompt})# logger.debug(f"system_prompt: {system_prompt}")# History- messages.extend(history)+ if not self._eval:+ messages.extend(history)# Current message (with optional image attachments)user_content = self._build_user_content(current_message, media)diff --git a/bot/vikingbot/agent/loop.py b/bot/vikingbot/agent/loop.pyindex 11962ccd7..349dca90e 100644--- a/bot/vikingbot/agent/loop.py+++ b/bot/vikingbot/agent/loop.py@@ -3,9 +3,6 @@import asyncioimport jsonimport time-from dataclasses import dataclass, field-from datetime import datetime-from enum import Enumfrom pathlib import Pathfrom loguru import logger@@ -15,8 +12,9 @@ from vikingbot.agent.memory import MemoryStorefrom vikingbot.agent.subagent import SubagentManagerfrom vikingbot.agent.tools import register_default_toolsfrom vikingbot.agent.tools.registry import ToolRegistry-from vikingbot.bus.events import InboundMessage, OutboundMessage+from vikingbot.bus.events import InboundMessage, OutboundMessage, OutboundEventTypefrom vikingbot.bus.queue import MessageBus+from vikingbot.config import load_configfrom vikingbot.config.schema import Configfrom vikingbot.config.schema import SessionKeyfrom vikingbot.hooks import HookContext@@ -25,25 +23,7 @@ from vikingbot.providers.base import LLMProviderfrom vikingbot.sandbox import SandboxManagerfrom vikingbot.session.manager import SessionManagerfrom vikingbot.utils.helpers import cal_str_tokens---class ThinkingStepType(Enum):- """思考步骤类型(简化版本,避免循环依赖)"""-- REASONING = "reasoning"- TOOL_CALL = "tool_call"- TOOL_RESULT = "tool_result"- ITERATION = "iteration"---@dataclass-class ThinkingStep:- """单个思考步骤(简化版本,避免循环依赖)"""-- step_type: ThinkingStepType- content: str- timestamp: datetime = field(default_factory=datetime.now)- metadata: dict = field(default_factory=dict)+from vikingbot.utils.tracing import traceclass AgentLoop:@@ -73,9 +53,41 @@ class AgentLoop:cron_service: "CronService | None" = None,session_manager: SessionManager | None = None,sandbox_manager: SandboxManager | None = None,- thinking_callback=None,config: Config = None,+ eval: bool = False,):+ """+ Initialize the AgentLoop with all required dependencies and configuration.++ Args:+ bus: MessageBus instance for publishing and subscribing to messages.+ provider: LLMProvider instance for making LLM calls.+ workspace: Path to the workspace directory for file operations.+ model: Optional model identifier. If not provided, uses the provider's default.+ max_iterations: Maximum number of tool execution iterations per message (default: 50).+ memory_window: Maximum number of messages to keep in session memory (default: 50).+ brave_api_key: Optional API key for Brave search integration.+ exa_api_key: Optional API key for Exa search integration.+ gen_image_model: Optional model identifier for image generation (default: openai/doubao-seedream-4-5-251128).+ exec_config: Optional configuration for the exec tool (command execution).+ cron_service: Optional CronService for scheduled task management.+ session_manager: Optional SessionManager for session persistence. If not provided, a new one is created.+ sandbox_manager: Optional SandboxManager for sandboxed operations.+ config: Optional Config object with full configuration. Used if other parameters are not provided.++ Note:+ The AgentLoop creates its own ContextBuilder, SessionManager (if not provided),+ ToolRegistry, and SubagentManager during initialization.++ Example:+ >>> loop = AgentLoop(+ ... bus=message_bus,+ ... provider=llm_provider,+ ... workspace=Path("/path/to/workspace"),+ ... model="gpt-4",+ ... max_iterations=30,+ ... )+ """from vikingbot.config.schema import ExecToolConfigself.bus = bus@@ -96,9 +108,10 @@ class AgentLoop:self._register_builtin_hooks()self.sessions = session_manager or SessionManager(- workspace, sandbox_manager=sandbox_manager+ self.config.bot_data_path, sandbox_manager=sandbox_manager)self.tools = ToolRegistry()+ self._eval = evalself.subagents = SubagentManager(provider=provider,workspace=workspace,@@ -109,8 +122,46 @@ class AgentLoop:)self._running = False- self.thinking_callback = thinking_callbackself._register_default_tools()+ self._token_usage = {+ "prompt_tokens": 0,+ "completion_tokens": 0,+ "total_tokens": 0,+ }++ async def _publish_thinking_event(+ self, session_key: SessionKey, event_type: OutboundEventType, content: str+ ) -> None:+ """+ Publish a thinking event to the message bus.++ Thinking events are used to communicate the agent's internal processing+ state to the user, such as when the agent is executing a tool or+ processing a complex request.++ Args:+ session_key: The session key identifying the conversation.+ event_type: The type of thinking event (e.g., THINKING, TOOL_START).+ content: The message content to display to the user.++ Note:+ This is an internal method used by the agent loop to communicate+ progress to users during long-running operations.++ Example:+ >>> await self._publish_thinking_event(+ ... session_key=SessionKey(channel="telegram", chat_id="123"),+ ... event_type=OutboundEventType.TOOL_START,+ ... content="Executing web search..."+ ... )+ """+ await self.bus.publish_outbound(+ OutboundMessage(+ session_key=session_key,+ content=content,+ event_type=event_type,+ )+ )def _register_builtin_hooks(self):"""Register built-in hooks."""@@ -158,68 +209,24 @@ class AgentLoop:self._running = Falselogger.info("Agent loop stopping")- async def _process_message(self, msg: InboundMessage) -> OutboundMessage | None:+ async def _run_agent_loop(+ self,+ messages: list[dict],+ session_key: SessionKey,+ publish_events: bool = True,+ sender_id: str | None = None,+ ) -> tuple[str | None, list[dict]]:"""- Process a single inbound message.+ Run the core agent loop: call LLM, execute tools, repeat until done.Args:- msg: The inbound message to process.- session_key: Override session key (used by process_direct).+ messages: Initial message list+ session_key: Session key for tool execution context+ publish_events: Whether to publish ITERATION/REASONING/TOOL_CALL events to the busReturns:- The response message, or None if no response needed.+ tuple of (final_content, tools_used)"""- # Handle system messages (subagent announces)- # The chat_id contains the original "channel:chat_id" to route back to- if msg.session_key.type == "system":- return await self._process_system_message(msg)-- preview = msg.content[:80] + "..." if len(msg.content) > 80 else msg.content- logger.info(f"Processing message from {msg.session_key}:{msg.sender_id}: {preview}")-- # Get or create session- session_key = msg.session_key- # For CLI/direct sessions, skip heartbeat by default- skip_heartbeat = session_key.type in ("cli", "tui")- session = self.sessions.get_or_create(session_key, skip_heartbeat=skip_heartbeat)-- # Handle slash commands- cmd = msg.content.strip().lower()- if cmd == "/new":- await self._consolidate_memory(session, archive_all=True)- session.clear()- self.sessions.save(session)- return OutboundMessage(- session_key=msg.session_key, content="🐈 New session started. Memory consolidated."- )- if cmd == "/help":- return OutboundMessage(- session_key=msg.session_key,- content="🐈 vikingbot commands:\n/new — Start a new conversation\n/help — Show available commands",- )-- # Consolidate memory before processing if session is too large- if len(session.messages) > self.memory_window:- await self._consolidate_memory(session)-- if self.sandbox_manager:- message_workspace = self.sandbox_manager.get_workspace_path(session_key)- else:- message_workspace = self.workspace-- from vikingbot.agent.context import ContextBuilder-- message_context = ContextBuilder(message_workspace, sandbox_manager=self.sandbox_manager)-- # Build initial messages (use get_history for LLM-formatted messages)- messages = await message_context.build_messages(- history=session.get_history(),- current_message=msg.content,- media=msg.media if msg.media else None,- session_key=msg.session_key,- )-- # Agent loopiteration = 0final_content = Nonetools_used: list[dict] = []@@ -227,32 +234,36 @@ class AgentLoop:while iteration < self.max_iterations:iteration += 1- # 回调:迭代开始- if self.thinking_callback:- self.thinking_callback(- ThinkingStep(- step_type=ThinkingStepType.ITERATION,+ if publish_events:+ await self.bus.publish_outbound(+ OutboundMessage(+ session_key=session_key,content=f"Iteration {iteration}/{self.max_iterations}",- metadata={"iteration": iteration},+ event_type=OutboundEventType.ITERATION,))- # Call LLMresponse = await self.provider.chat(- messages=messages, tools=self.tools.get_definitions(), model=self.model+ messages=messages,+ tools=self.tools.get_definitions(),+ model=self.model,+ session_id=session_key.safe_name(),)-- # 回调:推理内容- if response.reasoning_content and self.thinking_callback:- self.thinking_callback(- ThinkingStep(- step_type=ThinkingStepType.REASONING,+ if response.usage:+ cur_token = response.usage+ self._token_usage["prompt_tokens"] += cur_token["prompt_tokens"]+ self._token_usage["completion_tokens"] += cur_token["completion_tokens"]+ self._token_usage["total_tokens"] += cur_token["total_tokens"]++ if publish_events and response.reasoning_content:+ await self.bus.publish_outbound(+ OutboundMessage(+ session_key=session_key,content=response.reasoning_content,- metadata={},+ event_type=OutboundEventType.REASONING,))- # Handle tool callsif response.has_tool_calls:args_list = [tc.arguments for tc in response.tool_calls]tool_call_dicts = [@@ -261,7 +272,7 @@ class AgentLoop:"type": "function","function": {"name": tc.name,- "arguments": json.dumps(args), # Use truncated args+ "arguments": json.dumps(args),},}for tc, args in zip(response.tool_calls, args_list)@@ -273,20 +284,17 @@ class AgentLoop:reasoning_content=response.reasoning_content,)- # Execute toolsfor tool_call in response.tool_calls:args_str = json.dumps(tool_call.arguments, ensure_ascii=False)- # 回调:工具调用- if self.thinking_callback:- self.thinking_callback(- ThinkingStep(- step_type=ThinkingStepType.TOOL_CALL,+ if publish_events:+ await self.bus.publish_outbound(+ OutboundMessage(+ session_key=session_key,content=f"{tool_call.name}({args_str})",- metadata={"tool": tool_call.name, "args": tool_call.arguments},+ event_type=OutboundEventType.TOOL_CALL,))-logger.info(f"[TOOL_CALL]: {tool_call.name}({args_str[:200]})")tool_execute_start_time = time.time()result = await self.tools.execute(@@ -294,23 +302,19 @@ class AgentLoop:tool_call.arguments,session_key=session_key,sandbox_manager=self.sandbox_manager,+ sender_id=sender_id,)tool_execute_duration = (time.time() - tool_execute_start_time) * 1000logger.info(f"[RESULT]: {str(result)[:600]}")- # 回调:工具结果- if self.thinking_callback:- result_str = str(result)- if len(result_str) > 500:- result_str = result_str[:500] + "..."- self.thinking_callback(- ThinkingStep(- step_type=ThinkingStepType.TOOL_RESULT,- content=result_str,- metadata={"tool": tool_call.name},+ if publish_events:+ await self.bus.publish_outbound(+ OutboundMessage(+ session_key=session_key,+ content=str(result),+ event_type=OutboundEventType.TOOL_RESULT,))-messages = self.context.add_tool_result(messages, tool_call.id, tool_call.name, result)@@ -327,12 +331,11 @@ class AgentLoop:"output_token": cal_str_tokens(result, text_type="mixed"),}tools_used.append(tool_used_dict)- # Interleaved CoT: reflect before next action+messages.append(- {"role": "user", "content": "Reflect on the results and decide next steps."}+ {"role": "system", "content": "Reflect on the results and decide next steps."})else:- # No tool calls, we're donefinal_content = response.contentbreak@@ -342,21 +345,103 @@ class AgentLoop:else:final_content = "I've completed processing but have no response to give."+ return final_content, tools_used++ @trace(+ name="process_message",+ extract_session_id=lambda msg: msg.session_key.safe_name(),+ extract_user_id=lambda msg: msg.sender_id,+ )+ async def _process_message(self, msg: InboundMessage) -> OutboundMessage | None:+ """+ Process a single inbound message.++ Args:+ msg: The inbound message to process.+ session_key: Override session key (used by process_direct).++ Returns:+ The response message, or None if no response needed.+ """+ # Handle system messages (subagent announces)+ # The chat_id contains the original "channel:chat_id" to route back to+ if msg.session_key.type == "system":+ return await self._process_system_message(msg)++ preview = msg.content[:80] + "..." if len(msg.content) > 80 else msg.content+ logger.info(f"Processing message from {msg.session_key}:{msg.sender_id}: {preview}")++ # Get or create session+ session_key = msg.session_key+ # For CLI/direct sessions, skip heartbeat by default+ skip_heartbeat = session_key.type == "cli"+ session = self.sessions.get_or_create(session_key, skip_heartbeat=skip_heartbeat)++ # Handle slash commands+ is_group_chat = msg.metadata.get("chat_type") == "group" if msg.metadata else False+ if is_group_chat:+ cmd = msg.content.replace(f"@{msg.sender_id}", "").strip().lower()+ else:+ cmd = msg.content.strip().lower()+ if cmd == "/new":+ await self._consolidate_memory(session, archive_all=True)+ session.clear()+ await self.sessions.save(session)+ return OutboundMessage(+ session_key=msg.session_key, content="🐈 New session started. Memory consolidated."+ )+ if cmd == "/help":+ return OutboundMessage(+ session_key=msg.session_key,+ content="🐈 vikingbot commands:\n/new — Start a new conversation\n/help — Show available commands",+ )++ # Consolidate memory before processing if session is too large+ if len(session.messages) > self.memory_window:+ await self._consolidate_memory(session)++ if self.sandbox_manager:+ message_workspace = self.sandbox_manager.get_workspace_path(session_key)+ else:+ message_workspace = self.workspace++ from vikingbot.agent.context import ContextBuilder+ message_context = ContextBuilder(+ message_workspace, sandbox_manager=self.sandbox_manager, sender_id=msg.sender_id, is_group_chat=is_group_chat, eval=self._eval+ )++ # Build initial messages (use get_history for LLM-formatted messages)+ messages = await message_context.build_messages(+ history=session.get_history(),+ current_message=msg.content,+ media=msg.media if msg.media else None,+ session_key=msg.session_key,+ )++ # Run agent loop+ final_content, tools_used = await self._run_agent_loop(+ messages=messages,+ session_key=session_key,+ publish_events=True,+ sender_id=msg.sender_id,+ )+# Log response preview- preview = final_content[:120] + "..." if len(final_content) > 120 else final_content+ preview = final_content[:300] + "..." if len(final_content) > 300 else final_contentlogger.info(f"Response to {msg.session_key}: {preview}")# Save to session (include tool names so consolidation sees what happened)- session.add_message("user", msg.content)+ session.add_message("user", msg.content, sender_id=msg.sender_id)session.add_message("assistant", final_content, tools_used=tools_used if tools_used else None)- self.sessions.save(session)+ await self.sessions.save(session)return OutboundMessage(session_key=msg.session_key,content=final_content,- metadata=msg.metadata+ metadata=msg.metadata,+ token_usage=self._token_usageor {}, # Pass through for channel-specific needs (e.g. Slack thread_ts))@@ -376,60 +461,22 @@ class AgentLoop:history=session.get_history(), current_message=msg.content, session_key=msg.session_key)- # Agent loop (limited for announce handling)- iteration = 0- final_content = None-- while iteration < self.max_iterations:- iteration += 1-- response = await self.provider.chat(- messages=messages, tools=self.tools.get_definitions(), model=self.model- )-- if response.has_tool_calls:- tool_call_dicts = [- {- "id": tc.id,- "type": "function",- "function": {"name": tc.name, "arguments": json.dumps(tc.arguments)},- }- for tc in response.tool_calls- ]- messages = self.context.add_assistant_message(- messages,- response.content,- tool_call_dicts,- reasoning_content=response.reasoning_content,- )-- for tool_call in response.tool_calls:- args_str = json.dumps(tool_call.arguments, ensure_ascii=False)- logger.info(f"Tool call: {tool_call.name}({args_str[:200]})")- result = await self.tools.execute(- tool_call.name,- tool_call.arguments,- session_key=msg.session_key,- sandbox_manager=self.sandbox_manager,- )- messages = self.context.add_tool_result(- messages, tool_call.id, tool_call.name, result- )- # Interleaved CoT: reflect before next action- messages.append(- {"role": "user", "content": "Reflect on the results and decide next steps."}- )- else:- final_content = response.content- break+ # Run agent loop (no events published)+ final_content, tools_used = await self._run_agent_loop(+ messages=messages,+ session_key=msg.session_key,+ publish_events=False,+ )if final_content is None:final_content = "Background task completed."# Save to session (mark as system message in history)session.add_message("user", f"[System: {msg.sender_id}] {msg.content}")- session.add_message("assistant", final_content)- self.sessions.save(session)+ session.add_message(+ "assistant", final_content, tools_used=tools_used if tools_used else None+ )+ await self.sessions.save(session)return OutboundMessage(session_key=msg.session_key, content=final_content)@@ -443,7 +490,8 @@ class AgentLoop:context=HookContext(event_type="message.compact",session_id=session.key.safe_name(),- sandbox_key=self.sandbox_manager.to_sandbox_key(session.key),+ workspace_id=self.sandbox_manager.to_workspace_id(session.key),+ session_key=session.key,),session=session,)@@ -509,6 +557,7 @@ Respond with ONLY valid JSON, no markdown fences."""{"role": "user", "content": prompt},],model=self.model,+ session_id=session.key.safe_name(),)text = (response.content or "").strip()if text.startswith("```"):@@ -518,11 +567,11 @@ Respond with ONLY valid JSON, no markdown fences."""if entry := result.get("history_entry"):memory.append_history(entry)if update := result.get("memory_update"):- if update != current_memory:+ if load_config().use_local_memory and update != current_memory:memory.write_long_term(update)session.messages = session.messages[-keep_count:] if keep_count else []- self.sessions.save(session)+ await self.sessions.save(session)logger.info(f"Memory consolidation done, session trimmed to {len(session.messages)} messages")diff --git a/bot/vikingbot/agent/memory.py b/bot/vikingbot/agent/memory.pyindex a8be18f9d..1a7b43a08 100644--- a/bot/vikingbot/agent/memory.py+++ b/bot/vikingbot/agent/memory.py@@ -15,9 +15,6 @@ class MemoryStore:self.memory_dir = ensure_dir(workspace / "memory")self.memory_file = self.memory_dir / "MEMORY.md"self.history_file = self.memory_dir / "HISTORY.md"- config = load_config()- ov_config = config.openviking- self.user_id = ov_config.user_id if ov_config.mode == "remote" else "default"def read_long_term(self) -> str:if self.memory_file.exists():@@ -48,24 +45,22 @@ class MemoryStore:long_term = self.read_long_term()return f"## Long-term Memory\n{long_term}" if long_term else ""- async def get_viking_memory_context(self, current_message: str, sandbox_key: str) -> str:- client = await VikingClient.create(agent_id=sandbox_key)- result = await client.search_memory(current_message, limit=5)+ async def get_viking_memory_context(self, current_message: str, workspace_id: str) -> str:+ client = await VikingClient.create(agent_id=workspace_id)+ admin_user_id = load_config().ov_server.admin_user_id+ result = await client.search_memory(current_message, user_id=admin_user_id, limit=5)if not result:return ""user_memory = self._parse_viking_memory(result["user_memory"])agent_memory = self._parse_viking_memory(result["agent_memory"])return (- f"## Related memories.Using tools to read more details.\n"f"### user memories:\n{user_memory}\n"f"### agent memories:\n{agent_memory}")- async def get_viking_user_profile(self, sandbox_key: str) -> str:- client = await VikingClient.create(agent_id=sandbox_key)- result = await client.read_content(- uri=f"viking://user/{self.user_id}/memories/profile.md", level="read"- )+ async def get_viking_user_profile(self, workspace_id: str, user_id: str) -> str:+ client = await VikingClient.create(agent_id=workspace_id)+ result = await client.read_user_profile(user_id)if not result:return ""- return f"## User Information\n{result}"+ return resultdiff --git a/bot/vikingbot/agent/skills.py b/bot/vikingbot/agent/skills.pyindex ab07ff4fb..b524ddbfa 100644--- a/bot/vikingbot/agent/skills.py+++ b/bot/vikingbot/agent/skills.py@@ -2,6 +2,7 @@import jsonimport os+from loguru import loggerimport reimport shutilfrom pathlib import Pathdiff --git a/bot/vikingbot/agent/subagent.py b/bot/vikingbot/agent/subagent.pyindex 4dfdd1cd0..b397d3a13 100644--- a/bot/vikingbot/agent/subagent.py+++ b/bot/vikingbot/agent/subagent.py@@ -4,17 +4,15 @@ import asyncioimport jsonimport uuidfrom pathlib import Path-from typing import TYPE_CHECKING, Any+from typing import Anyfrom loguru import logger+from vikingbot.agent.tools.registry import ToolRegistryfrom vikingbot.bus.events import InboundMessagefrom vikingbot.bus.queue import MessageBusfrom vikingbot.config.schema import SessionKeyfrom vikingbot.providers.base import LLMProvider-from vikingbot.agent.tools.registry import ToolRegistry--from vikingbot.sandbox.manager import SandboxManagerdiff --git a/bot/vikingbot/agent/tools/base.py b/bot/vikingbot/agent/tools/base.pyindex de997fbe8..eb0898c19 100644--- a/bot/vikingbot/agent/tools/base.py+++ b/bot/vikingbot/agent/tools/base.py@@ -8,11 +8,33 @@ from vikingbot.sandbox.manager import SandboxManager@dataclassclass ToolContext:- """Context passed to tools during execution, containing runtime information."""+ """Context passed to tools during execution, containing runtime information.++ This class encapsulates all the runtime context that a tool might need during+ execution, including session identification, sandbox access, and sender information.++ Attributes:+ session_key: Unique identifier for the current session, typically in the format+ 'channel:chat_id'.+ sandbox_manager: Optional manager for sandbox operations like file access and+ command execution. If provided, tools can perform sandboxed operations.+ workspace_id: Computed workspace identifier derived from the sandbox_manager+ and session_key. This determines the sandbox directory for the session.+ sender_id: Optional identifier for the message sender, used for tracking+ and permission checks.++ Example:+ >>> context = ToolContext(+ ... session_key=SessionKey(channel="telegram", chat_id="12345"),+ ... sandbox_manager=sandbox_mgr,+ ... sender_id="user_123"+ ... )+ """session_key: SessionKey = Nonesandbox_manager: SandboxManager | None = None- sandbox_key: str = sandbox_manager.to_sandbox_key(session_key) if sandbox_manager else None+ workspace_id: str = sandbox_manager.to_workspace_id(session_key) if sandbox_manager else None+ sender_id: str | None = None"""Base class for agent tools."""@@ -25,8 +47,43 @@ class Tool(ABC):"""Abstract base class for agent tools.- Tools are capabilities that the agent can use to interact with- the environment, such as reading files, executing commands, etc.+ Tools are capabilities that the agent can use to interact with the environment,+ such as reading files, executing commands, searching the web, etc. Each tool+ defines its own name, description, parameters schema, and execution logic.++ To create a new tool, subclass Tool and implement the required abstract+ properties and methods:+ - name: The unique identifier for the tool+ - description: Human-readable explanation of what the tool does+ - parameters: JSON Schema defining the tool's input parameters+ - execute(): The actual implementation of the tool's functionality++ Attributes:+ _TYPE_MAP: Internal mapping of JSON schema types to Python types for+ parameter validation.++ Example:+ >>> class GreetingTool(Tool):+ ... @property+ ... def name(self) -> str:+ ... return "greet"+ ...+ ... @property+ ... def description(self) -> str:+ ... return "Sends a greeting message"+ ...+ ... @property+ ... def parameters(self) -> dict[str, Any]:+ ... return {+ ... "type": "object",+ ... "properties": {+ ... "name": {"type": "string", "description": "Name to greet"}+ ... },+ ... "required": ["name"]+ ... }+ ...+ ... async def execute(self, context: ToolContext, name: str) -> str:+ ... return f"Hello, {name}!""""_TYPE_MAP = {@@ -71,13 +128,57 @@ class Tool(ABC):passdef validate_params(self, params: dict[str, Any]) -> list[str]:- """Validate tool parameters against JSON schema. Returns error list (empty if valid)."""+ """+ Validate tool parameters against the tool's JSON schema.++ This method validates that the provided parameters match the tool's+ defined schema, including type checking, required field validation,+ enum validation, and range constraints.++ Args:+ params: Dictionary of parameter names to values to validate.++ Returns:+ List of error messages. An empty list indicates the parameters+ are valid.++ Raises:+ ValueError: If the tool's parameter schema is not an object type.++ Example:+ >>> tool = MyTool()+ >>> errors = tool.validate_params({"name": "test", "count": 5})+ >>> if errors:+ ... print("Validation failed:", errors)+ ... else:+ ... print("Parameters are valid")+ """schema = self.parameters or {}if schema.get("type", "object") != "object":raise ValueError(f"Schema must be object type, got {schema.get('type')!r}")return self._validate(params, {**schema, "type": "object"}, "")def _validate(self, val: Any, schema: dict[str, Any], path: str) -> list[str]:+ """+ Recursively validate a value against a JSON schema.++ This internal method performs recursive validation of values against+ JSON schema definitions, supporting all common JSON schema features+ including type checking, enums, ranges, string length, object properties,+ and array items.++ Args:+ val: The value to validate.+ schema: The JSON schema to validate against.+ path: The current path in the data structure (for error messages).++ Returns:+ List of validation error messages. Empty list if validation passes.++ Note:+ This is an internal method used by validate_params(). It should+ not be called directly from outside the class.+ """t, label = schema.get("type"), path or "parameter"if t in self._TYPE_MAP and not isinstance(val, self._TYPE_MAP[t]):return [f"{label} should be {t}"]@@ -111,7 +212,30 @@ class Tool(ABC):return errorsdef to_schema(self) -> dict[str, Any]:- """Convert tool to OpenAI function schema format."""+ """+ Convert tool to OpenAI function schema format.++ This method transforms the tool's definition into the format expected by+ OpenAI's function calling API, which can be used with chat completions.++ Returns:+ Dictionary containing the function schema in OpenAI format with:+ - type: Always "function"+ - function: Object containing name, description, and parameters++ Example:+ >>> tool = MyTool()+ >>> schema = tool.to_schema()+ >>> print(schema)+ {+ 'type': 'function',+ 'function': {+ 'name': 'my_tool',+ 'description': 'Does something useful',+ 'parameters': {'type': 'object', 'properties': {...}}+ }+ }+ """return {"type": "function","function": {diff --git a/bot/vikingbot/agent/tools/factory.py b/bot/vikingbot/agent/tools/factory.pyindex 96a738690..8716a8aeb 100644--- a/bot/vikingbot/agent/tools/factory.py+++ b/bot/vikingbot/agent/tools/factory.py@@ -19,6 +19,7 @@ from vikingbot.agent.tools.registry import ToolRegistryfrom vikingbot.agent.tools.shell import ExecToolfrom vikingbot.agent.tools.web import WebFetchToolfrom vikingbot.agent.tools.websearch import WebSearchTool+from vikingbot.config.loader import load_configif TYPE_CHECKING:from vikingbot.agent.tools.spawn import SpawnTool@@ -56,12 +57,13 @@ def register_default_tools(exec_config = config.tools.execbrave_api_key = config.tools.web.search.api_key if config.tools.web.search else Noneexa_api_key = None # TODO: Add to config if needed- gen_image_model = config.agents.defaults.gen_image_model# Get provider API key and base from config- provider_config = config.get_provider()- provider_api_key = provider_config.api_key if provider_config else None- provider_api_base = provider_config.api_base if provider_config else None++ agent_config = load_config().agents+ provider_api_key = agent_config.api_key if agent_config else None+ provider_api_base = agent_config.api_base if agent_config else None+ gen_image_model = agent_config.gen_image_model# File toolsregistry.register(ReadFileTool())registry.register(WriteFileTool())diff --git a/bot/vikingbot/agent/tools/ov_file.py b/bot/vikingbot/agent/tools/ov_file.pyindex 2e0a58767..d16ccfd9c 100644--- a/bot/vikingbot/agent/tools/ov_file.py+++ b/bot/vikingbot/agent/tools/ov_file.py@@ -16,7 +16,7 @@ class OVFileTool(Tool, ABC):async def _get_client(self, tool_context: ToolContext):if self._client is None:- self._client = await VikingClient.create(tool_context.sandbox_key)+ self._client = await VikingClient.create(tool_context.workspace_id)return self._client@@ -375,10 +375,10 @@ class VikingSearchUserMemoryTool(OVFileTool):"required": ["query"],}- async def execute(self, tool_context: "ToolContext", query: str, **kwargs: Any) -> str:+ async def execute(self, tool_context: ToolContext, query: str, **kwargs: Any) -> str:try:client = await self._get_client(tool_context)- results = await client.search_user_memory(query)+ results = await client.search_user_memory(query, tool_context.sender_id)if not results:return f"No results found for query: {query}"@@ -396,7 +396,7 @@ class VikingMemoryCommitTool(OVFileTool):@propertydef description(self) -> str:- return "Commit messages to OpenViking session to persist conversation history."+ return "When user has personal information needs to be remembered, Commit messages to OpenViking."@propertydef parameters(self) -> dict[str, Any]:@@ -405,7 +405,7 @@ class VikingMemoryCommitTool(OVFileTool):"properties": {"messages": {"type": "array",- "description": "List of messages to commit, each with role, content, and optional tools_used",+ "description": "List of messages to commit, each with role, content","items": {"type": "object","properties": {@@ -426,9 +426,11 @@ class VikingMemoryCommitTool(OVFileTool):**kwargs: Any,) -> str:try:+ if not tool_context.sender_id:+ return "Error committed, sender_id is required."client = await self._get_client(tool_context)session_id = tool_context.session_key.safe_name()- await client.commit(session_id, messages)+ await client.commit(session_id, messages, tool_context.sender_id)return f"Successfully committed to session {session_id}"except Exception as e:logger.exception(f"Error processing message: {e}")diff --git a/bot/vikingbot/agent/tools/registry.py b/bot/vikingbot/agent/tools/registry.pyindex e86c47dbd..628e2bd44 100644--- a/bot/vikingbot/agent/tools/registry.py+++ b/bot/vikingbot/agent/tools/registry.py@@ -1,25 +1,17 @@"""Tool registry for dynamic tool management."""-from loguru import logger--from typing import Any, TYPE_CHECKING--from vikingbot.agent.tools.base import Tool, ToolContext-from vikingbot.config import loader-from vikingbot.config.schema import SessionKey-from vikingbot.hooks import HookContext-from vikingbot.hooks.manager import hook_manager-from vikingbot.sandbox.manager import SandboxManager+import time-"""Tool registry for dynamic tool management."""from loguru import loggerfrom typing import Any-from vikingbot.agent.tools.base import Tool+from vikingbot.agent.tools.base import Tool, ToolContextfrom vikingbot.config.schema import SessionKeyfrom vikingbot.hooks import HookContextfrom vikingbot.hooks.manager import hook_manager+from vikingbot.integrations.langfuse import LangfuseClient+from vikingbot.sandbox.manager import SandboxManagerclass ToolRegistry:@@ -31,25 +23,99 @@ class ToolRegistry:def __init__(self):self._tools: dict[str, Tool] = {}+ self.langfuse = LangfuseClient.get_instance()def register(self, tool: Tool) -> None:- """Register a tool."""+ """+ Register a tool in the registry.++ Adds the tool to the internal registry dictionary, using the tool's name+ as the key. If a tool with the same name already exists, it will be+ silently overwritten.++ Args:+ tool: The Tool instance to register. Must have a unique name property.++ Note:+ Currently, duplicate registration silently overwrites the existing tool.+ Consider checking for duplicates if this behavior is not desired.++ Example:+ >>> registry = ToolRegistry()+ >>> tool = MyTool()+ >>> registry.register(tool)+ >>> assert registry.has(tool.name)+ """self._tools[tool.name] = tooldef unregister(self, name: str) -> None:- """Unregister a tool by name."""+ """+ Unregister a tool by name.++ Removes the tool with the specified name from the registry. If no tool+ with that name exists, this operation is a no-op (no error is raised).++ Args:+ name: The name of the tool to unregister.++ Example:+ >>> registry.register(my_tool)+ >>> registry.unregister(my_tool.name)+ >>> assert not registry.has(my_tool.name)+ """self._tools.pop(name, None)def get(self, name: str) -> Tool | None:- """Get a tool by name."""+ """+ Get a tool by name.++ Retrieves the tool with the specified name from the registry.++ Args:+ name: The name of the tool to retrieve.++ Returns:+ The Tool instance if found, or None if no tool with that name exists.++ Example:+ >>> tool = registry.get("read_file")+ >>> if tool:+ ... print(f"Found tool: {tool.description}")+ """return self._tools.get(name)def has(self, name: str) -> bool:- """Check if a tool is registered."""+ """+ Check if a tool is registered.++ Args:+ name: The name of the tool to check.++ Returns:+ True if a tool with the given name is registered, False otherwise.++ Example:+ >>> if registry.has("read_file"):+ ... print("Read file tool is available")+ """return name in self._toolsdef get_definitions(self) -> list[dict[str, Any]]:- """Get all tool definitions in OpenAI format."""+ """+ Get all tool definitions in OpenAI format.++ Converts all registered tools to the OpenAI function schema format,+ suitable for use with OpenAI's function calling API.++ Returns:+ List of tool schemas in OpenAI format, where each schema contains+ the tool's type, name, description, and parameters.++ Example:+ >>> definitions = registry.get_definitions()+ >>> for defn in definitions:+ ... print(f"Tool: {defn['function']['name']}")+ """return [tool.to_schema() for tool in self._tools.values()]async def execute(@@ -58,6 +124,7 @@ class ToolRegistry:params: dict[str, Any],session_key: SessionKey,sandbox_manager: SandboxManager | None = None,+ sender_id: str | None = None,) -> str:"""Execute a tool by name with given parameters.@@ -67,6 +134,7 @@ class ToolRegistry:params: Tool parameters.session_key: Session key for the current session.sandbox_manager: Sandbox manager for file/shell operations.+ sender_id: Sender id for the current session.Returns:Tool execution result as string.@@ -81,24 +149,56 @@ class ToolRegistry:tool_context = ToolContext(session_key=session_key,sandbox_manager=sandbox_manager,- sandbox_key=sandbox_manager.to_sandbox_key(session_key),+ sender_id=sender_id,)+ # Langfuse tool call tracing - automatic for all tools+ tool_span = None+ start_time = time.time()result = Nonetry:+ if self.langfuse.enabled:+ tool_ctx = self.langfuse.tool_call(+ name=name,+ input=params,+ session_id=session_key.safe_name(),+ )+ tool_span = tool_ctx.__enter__()+errors = tool.validate_params(params)if errors:- return f"Error: Invalid parameters for tool '{name}': " + "; ".join(errors)- result = await tool.execute(tool_context, **params)+ result = f"Error: Invalid parameters for tool '{name}': " + "; ".join(errors)+ else:+ result = await tool.execute(tool_context, **params)except Exception as e:result = elogger.exception("Tool call fail: ", e)+ finally:+ # End Langfuse tool call tracing+ duration_ms = (time.time() - start_time) * 1000+ if tool_span is not None:+ try:+ execute_success = not isinstance(result, Exception) and not (+ isinstance(result, str) and result.startswith("Error")+ )+ output_str = str(result) if result is not None else None+ self.langfuse.end_tool_call(+ span=tool_span,+ output=output_str,+ success=execute_success,+ metadata={"duration_ms": duration_ms},+ )+ if hasattr(tool_span, "__exit__"):+ tool_span.__exit__(None, None, None)+ self.langfuse.flush()+ except Exception:+ passhook_result = await hook_manager.execute_hooks(context=HookContext(event_type="tool.post_call",- session_id=session_key.safe_name(),- sandbox_key=sandbox_manager.to_sandbox_key(session_key),+ session_key=session_key,+ workspace_id=sandbox_manager.to_workspace_id(session_key),),tool_name=name,params=params,diff --git a/bot/vikingbot/bus/events.py b/bot/vikingbot/bus/events.pyindex 982702195..b3e9accb7 100644--- a/bot/vikingbot/bus/events.py+++ b/bot/vikingbot/bus/events.py@@ -2,29 +2,32 @@from dataclasses import dataclass, fieldfrom datetime import datetime+from enum import Enumfrom typing import Anyfrom vikingbot.config.schema import SessionKey+class OutboundEventType(str, Enum):+ """Type of outbound message/event."""+ RESPONSE = "response" # Normal response message+ TOOL_CALL = "tool_call" # Tool being called+ TOOL_RESULT = "tool_result" # Result from tool execution+ REASONING = "reasoning" # Reasoning content+ ITERATION = "iteration" # Iteration marker++@dataclassclass InboundMessage:"""Message received from a chat channel."""- # channel: str # telegram, discord, slack, whatsappsender_id: str # User identifier- # chat_id: str # Chat/channel identifiercontent: str # Message textsession_key: SessionKeytimestamp: datetime = field(default_factory=datetime.now)media: list[str] = field(default_factory=list) # Media URLsmetadata: dict[str, Any] = field(default_factory=dict) # Channel-specific data- # @property- # def session_key(self) -> str:- # """Unique key for session identification."""- # return f"{self.channel}:{self.chat_id}"-@dataclassclass OutboundMessage:@@ -32,6 +35,18 @@ class OutboundMessage:session_key: SessionKeycontent: str+ event_type: OutboundEventType = OutboundEventType.RESPONSEreply_to: str | None = Nonemedia: list[str] = field(default_factory=list)metadata: dict[str, Any] = field(default_factory=dict)+ token_usage: dict[str, int] = field(default_factory=dict)++ @property+ def channel(self) -> str:+ """Get channel key from session key."""+ return self.session_key.channel_key()++ @property+ def is_normal_message(self) -> bool:+ """Check if this is a normal response message."""+ return self.event_type == OutboundEventType.RESPONSEdiff --git a/bot/vikingbot/bus/queue.py b/bot/vikingbot/bus/queue.pyindex 82d3a002f..83c96e971 100644--- a/bot/vikingbot/bus/queue.py+++ b/bot/vikingbot/bus/queue.py@@ -1,7 +1,7 @@"""Async message queue for decoupled channel-agent communication."""import asyncio-from typing import Callable, Awaitable+from typing import Callable, Awaitable, Anyfrom loguru import logger@@ -26,6 +26,7 @@ class MessageBus:async def publish_inbound(self, msg: InboundMessage) -> None:"""Publish a message from a channel to the agent."""+ #print(f'publish_inbound={msg}')await self.inbound.put(msg)async def consume_inbound(self) -> InboundMessage:@@ -34,6 +35,7 @@ class MessageBus:async def publish_outbound(self, msg: OutboundMessage) -> None:"""Publish a response from the agent to channels."""+ #print(f'publish_outbound={msg}')await self.outbound.put(msg)async def consume_outbound(self) -> OutboundMessage:@@ -41,12 +43,12 @@ class MessageBus:return await self.outbound.get()def subscribe_outbound(- self, channel: str, callback: Callable[[OutboundMessage], Awaitable[None]]+ self, channel_key: str, callback: Callable[[OutboundMessage], Awaitable[None]]) -> None:- """Subscribe to outbound messages for a specific channel."""- if channel not in self._outbound_subscribers:- self._outbound_subscribers[channel] = []- self._outbound_subscribers[channel].append(callback)+ """Subscribe to outbound messages for a specific channel key."""+ if channel_key not in self._outbound_subscribers:+ self._outbound_subscribers[channel_key] = []+ self._outbound_subscribers[channel_key].append(callback)async def dispatch_outbound(self) -> None:"""@@ -57,14 +59,17 @@ class MessageBus:while self._running:try:msg = await asyncio.wait_for(self.outbound.get(), timeout=1.0)- subscribers = self._outbound_subscribers.get(msg.channel, [])+ channel_key = msg.session_key.channel_key()+ subscribers = self._outbound_subscribers.get(channel_key, [])for callback in subscribers:try:await callback(msg)except Exception as e:- logger.exception(f"Error dispatching to {msg.channel}: {e}")+ logger.exception(f"Error dispatching to {channel_key}: {e}")except asyncio.TimeoutError:continue+ except asyncio.CancelledError:+ breakdef stop(self) -> None:"""Stop the dispatcher loop."""diff --git a/bot/vikingbot/channels/base.py b/bot/vikingbot/channels/base.pyindex f5cef1a72..abf266d83 100644--- a/bot/vikingbot/channels/base.py+++ b/bot/vikingbot/channels/base.py@@ -138,7 +138,7 @@ class BaseChannel(ABC):msg = InboundMessage(session_key=SessionKey(- type=str(self.channel_type.value), channel_id=self.channel_id, chat_id=chat_id+ type=str(getattr(self.channel_type, 'value', self.channel_type)), channel_id=self.channel_id, chat_id=chat_id),sender_id=str(sender_id),content=content,diff --git a/bot/vikingbot/channels/chat.py b/bot/vikingbot/channels/chat.pynew file mode 100644index 000000000..7e8bd6b53--- /dev/null+++ b/bot/vikingbot/channels/chat.py@@ -0,0 +1,163 @@+# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.+# SPDX-License-Identifier: Apache-2.0+"""Chat channel for interactive mode."""++import asyncio+import os+import signal+import sys+from pathlib import Path+from typing import Any++from loguru import logger+from rich.style import Style++from vikingbot.bus.events import InboundMessage, OutboundMessage, OutboundEventType+from vikingbot.bus.queue import MessageBus+from vikingbot.channels.base import BaseChannel+from vikingbot.config.schema import SessionKey, BaseChannelConfig+++class ChatChannelConfig(BaseChannelConfig):+ """Configuration for ChatChannel."""++ enabled: bool = True+ type: Any = "cli"++ def channel_id(self) -> str:+ return "chat"+++class ChatChannel(BaseChannel):+ """+ Chat channel for interactive mode.++ This channel supports:+ - Interactive mode (prompt-based)+ - Displays thinking steps and tool calls+ """++ name: str = "chat"++ def __init__(+ self,+ config: BaseChannelConfig,+ bus: MessageBus,+ workspace_path: Path | None = None,+ session_id: str = "cli__chat__default",+ markdown: bool = True,+ logs: bool = False,+ ):+ super().__init__(config, bus, workspace_path)+ self.session_id = session_id+ self.markdown = markdown+ self.logs = logs+ self._response_received = asyncio.Event()+ self._last_response: str | None = None++ async def start(self) -> None:+ """Start the chat channel."""+ self._running = True++ # Interactive mode only+ await self._run_interactive()++ async def stop(self) -> None:+ """Stop the chat channel."""+ self._running = False++ async def send(self, msg: OutboundMessage) -> None:+ """Send a message - display thinking events and store final response."""+ from vikingbot.cli.commands import console+ from rich.markdown import Markdown+ from rich.text import Text++ if msg.is_normal_message:+ self._last_response = msg.content+ self._response_received.set()+ # Print Bot: response+ console.print()+ content = msg.content or ""+ console.print("[bold red]Bot:[/bold red]")+ from rich.markdown import Markdown+ from rich.text import Text+ body = Markdown(content, style="red") if self.markdown else Text(content, style=Style(color="red"))++ console.print(body)+ console.print()+ else:+ # Handle thinking events+ if msg.event_type == OutboundEventType.REASONING:+ # Truncate long reasoning+ content = msg.content.strip()+ if content:+ if len(content) > 100:+ content = content[:100] + "..."+ console.print(f" [dim]Think: {content}[/dim]")+ elif msg.event_type == OutboundEventType.TOOL_CALL:+ console.print(f" [dim]├─ Calling: {msg.content}[/dim]")+ elif msg.event_type == OutboundEventType.TOOL_RESULT:+ # Truncate long tool results+ content = msg.content+ if len(content) > 150:+ content = content[:150] + "..."+ console.print(f" [dim]└─ Result: {content}[/dim]")++ async def _run_interactive(self) -> None:+ """Run in interactive mode."""+ from vikingbot.cli.commands import (+ _flush_pending_tty_input,+ _init_prompt_session,+ _is_exit_command,+ _restore_terminal,+ __logo__,+ console,+ _read_interactive_input_async,+ )++ _init_prompt_session()++ def _exit_on_sigint(signum, frame):+ _restore_terminal()+ console.print("\nGoodbye!")+ os._exit(0)++ signal.signal(signal.SIGINT, _exit_on_sigint)++ while self._running:+ try:+ _flush_pending_tty_input()++ user_input = await _read_interactive_input_async()+ command = user_input.strip()++ if not command:+ continue++ if _is_exit_command(command):+ _restore_terminal()+ console.print("\nGoodbye!")+ break++ # Reset and send message+ self._response_received.clear()+ self._last_response = None++ msg = InboundMessage(+ session_key=SessionKey.from_safe_name(self.session_id),+ sender_id="user",+ content=user_input,+ )+ await self.bus.publish_inbound(msg)++ # Wait for response+ await self._response_received.wait()++ except KeyboardInterrupt:+ _restore_terminal()+ console.print("\nGoodbye!")+ break+ except EOFError:+ _restore_terminal()+ console.print("\nGoodbye!")+ breakdiff --git a/bot/vikingbot/channels/dingtalk.py b/bot/vikingbot/channels/dingtalk.pyindex 3584b1228..51809a08f 100644--- a/bot/vikingbot/channels/dingtalk.py+++ b/bot/vikingbot/channels/dingtalk.py@@ -112,7 +112,7 @@ class DingTalkChannel(BaseChannel):try:if not DINGTALK_AVAILABLE:logger.exception(- "DingTalk Stream SDK not installed. Run: pip install dingtalk-stream"+ "DingTalk Stream SDK not installed. Install with: uv pip install 'vikingbot[dingtalk]' (or uv pip install -e \".[dingtalk]\" for local dev)")return@@ -189,6 +189,10 @@ class DingTalkChannel(BaseChannel):async def send(self, msg: OutboundMessage) -> None:"""Send a message through DingTalk."""+ # Only send normal response messages, skip thinking/tool_call/etc.+ if not msg.is_normal_message:+ return+token = await self._get_access_token()if not token:returndiff --git a/bot/vikingbot/channels/discord.py b/bot/vikingbot/channels/discord.pyindex b1e433883..b80ad4950 100644--- a/bot/vikingbot/channels/discord.py+++ b/bot/vikingbot/channels/discord.py@@ -75,6 +75,10 @@ class DiscordChannel(BaseChannel):async def send(self, msg: OutboundMessage) -> None:"""Send a message through Discord REST API."""+ # Only send normal response messages, skip thinking/tool_call/etc.+ if not msg.is_normal_message:+ return+if not self._http:logger.warning("Discord HTTP client not initialized")returndiff --git a/bot/vikingbot/channels/feishu.py b/bot/vikingbot/channels/feishu.pyindex 1aa787968..d17ca8c04 100644--- a/bot/vikingbot/channels/feishu.py+++ b/bot/vikingbot/channels/feishu.py@@ -1,22 +1,14 @@"""Feishu/Lark channel implementation using lark-oapi SDK with WebSocket long connection."""import asyncio-import base64import ioimport jsonimport re-import os-import threadingimport tempfile+import threadingfrom collections import OrderedDict-from pathlib import Path-from typing import Any, Tuple-from urllib.parse import urlparse--import httpx-from loguru import logger+from typing import Any-from vikingbot.utils import get_data_pathimport httpxfrom loguru import logger@@ -51,6 +43,8 @@ try:P2ImMessageReceiveV1,GetImageRequest,GetMessageResourceRequest,+ ReplyMessageRequest,+ ReplyMessageRequestBody,)FEISHU_AVAILABLE = True@@ -122,7 +116,6 @@ class FeishuChannel(BaseChannel):"""Upload image to Feishu media library and get image_key."""- import timetoken = await self._get_tenant_access_token()url = "https://open.feishu.cn/open-apis/im/v1/images"@@ -133,12 +126,9 @@ class FeishuChannel(BaseChannel):files = {"image": ("image.png", io.BytesIO(image_data), "image/png")}data = {"image_type": "message"}- logger.debug(f"Uploading image to {url} with image_data {image_data[:20]}...")-async with httpx.AsyncClient(timeout=60.0) as client:resp = await client.post(url, headers=headers, data=data, files=files)- logger.debug(f"Upload response status: {resp.status_code}")- logger.debug(f"Upload response content: {resp.text}")+ # logger.debug(f"Upload response status: {resp.status_code}")resp.raise_for_status()result = resp.json()if result.get("code") != 0:@@ -185,13 +175,14 @@ class FeishuChannel(BaseChannel):f.write(image_bytes)temp_path = f.name- logger.debug(f"Saved image to temp file: {temp_path}")return temp_pathasync def start(self) -> None:"""Start the Feishu bot with WebSocket long connection."""if not FEISHU_AVAILABLE:- logger.exception("Feishu SDK not installed. Run: pip install lark-oapi")+ logger.exception(+ "Feishu SDK not installed. Install with: uv pip install 'vikingbot[feishu]' (or uv pip install -e \".[feishu]\" for local dev)"+ )returnif not self.config.app_id or not self.config.app_secret:@@ -280,8 +271,6 @@ class FeishuChannel(BaseChannel):if not response.success():logger.warning(f"Failed to add reaction: code={response.code}, msg={response.msg}")- else:- logger.debug(f"Added {emoji_type} reaction to message {message_id}")except Exception as e:logger.warning(f"Error adding reaction: {e}")@@ -410,7 +399,6 @@ class FeishuChannel(BaseChannel):alt_text = m.group(1) or ""img_url = m.group(2)try:- logger.debug(f"Processing Markdown image: {img_url[:100]}...")is_content, result = await self._parse_data_uri(img_url)if not is_content and isinstance(result, bytes):@@ -427,7 +415,6 @@ class FeishuChannel(BaseChannel):for m in re.finditer(send_pattern, content):img_url = m.group(1) or ""try:- logger.debug(f"Processing Markdown image: {img_url[:100]}...")is_content, result = await self._parse_data_uri(img_url)if not is_content and isinstance(result, bytes):@@ -460,6 +447,10 @@ class FeishuChannel(BaseChannel):logger.warning("Feishu client not initialized")return+ # Only send normal response messages, skip thinking/tool_call/etc.+ if not msg.is_normal_message:+ return+try:# Determine receive_id_type based on chat_id format# open_id starts with "ou_", chat_id starts with "oc_"@@ -467,40 +458,126 @@ class FeishuChannel(BaseChannel):receive_id_type = "chat_id"else:receive_id_type = "open_id"- logger.info(f"[DEBUG] Feishu send() content: {msg.content[:300]}")- # No images extracted from content, but content might still have Markdown images- elements = await self._process_content_with_images(- msg.content, receive_id_type, msg.session_key.chat_id- )- card = {- "config": {"wide_screen_mode": True},- "elements": elements,- }- content = json.dumps(card, ensure_ascii=False)+ # Process images and get cleaned content+ cleaned_content, images = await self._extract_and_upload_images(msg.content)- request = (- CreateMessageRequest.builder()- .receive_id_type(receive_id_type)- .request_body(- CreateMessageRequestBody.builder()- .receive_id(msg.session_key.chat_id)- .msg_type("interactive")- .content(content)- .build()- )- .build()+ # Process @mentions: convert @ou_xxxx to Feishu mention format+ # Pattern: @ou_xxxxxxx (user open_id)+ import re++ mention_pattern = r"@(ou_[a-zA-Z0-9_-]+)"++ def replace_mention(match):+ open_id = match.group(1)+ return f'<at user_id="{open_id}">@{open_id}</at>'++ # Replace all mentions+ content_with_mentions = re.sub(mention_pattern, replace_mention, cleaned_content)++ # Also support @all mention+ content_with_mentions = content_with_mentions.replace(+ "@all", '<at user_id="all">所有人</at>')- response = self._client.im.v1.message.create(request)+ # Check if we need to reply to a specific message+ # Get reply message ID from metadata (original incoming message ID)+ reply_to_message_id = None+ if msg.metadata:+ reply_to_message_id = msg.metadata.get("reply_to_message_id") or msg.metadata.get(+ "message_id"+ )- if not response.success():- logger.exception(- f"Failed to send Feishu message: code={response.code}, "- f"msg={response.msg}, log_id={response.get_log_id()}"+ # Build post message content+ content_elements = []++ # Add @mention for the original sender when replying+ original_sender_id = None+ if reply_to_message_id and msg.metadata:+ original_sender_id = msg.metadata.get("sender_id")++ # Build content line: [@mention, text content]+ content_line = []++ # Add @mention element for original sender when replying+ if original_sender_id:+ content_line.append({"tag": "at", "user_id": original_sender_id})++ # Add text content+ if content_with_mentions.strip():+ content_line.append({"tag": "text", "text": content_with_mentions})++ # Add content line if not empty+ if content_line:+ content_elements.append(content_line)++ # Add images+ for img in images:+ content_elements.append([{"tag": "img", "image_key": img["image_key"]}])++ # Ensure we have content+ if not content_elements:+ content_elements.append([{"tag": "text", "text": " "}])++ post_content = {"zh_cn": {"title": "", "content": content_elements}}++ import json++ content = json.dumps(post_content, ensure_ascii=False)++ if reply_to_message_id:+ # Reply to existing message (quotes the original)+ # Only reply in thread if the original message is in a topic (has root_id and is a thread)+ should_reply_in_thread = False+ if msg.metadata:+ root_id = msg.metadata.get("root_id")+ # Only use reply_in_thread=True if this is an actual topic group thread+ # In Feishu, topic groups have root_id set for messages in threads+ # root_id will be set if the message is already part of a thread+ should_reply_in_thread = root_id is not None and root_id != reply_to_message_id++ request = (+ ReplyMessageRequest.builder()+ .message_id(reply_to_message_id)+ .request_body(+ ReplyMessageRequestBody.builder()+ .content(content)+ .msg_type("post")+ # Only reply in topic thread if it's actually a topic thread (not regular group)+ .reply_in_thread(should_reply_in_thread)+ .build()+ )+ .build())+ response = self._client.im.v1.message.reply(request)else:- logger.debug(f"Feishu message sent to {msg.session_key.chat_id}")+ # Send new message+ request = (+ CreateMessageRequest.builder()+ .receive_id_type(receive_id_type)+ .request_body(+ CreateMessageRequestBody.builder()+ .receive_id(msg.session_key.chat_id)+ .msg_type("post")+ .content(content)+ .build()+ )+ .build()+ )+ response = self._client.im.v1.message.create(request)++ if not response.success():+ if response.code == 230011:+ # Original message was withdrawn, just log warning+ logger.warning(+ f"Failed to reply to message: original message was withdrawn, code={response.code}, "+ f"msg={response.msg}, log_id={response.get_log_id()}"+ )+ else:+ logger.exception(+ f"Failed to send Feishu message: code={response.code}, "+ f"msg={response.msg}, log_id={response.get_log_id()}"+ )except Exception as e:logger.exception(f"Error sending Feishu message: {e}")@@ -547,11 +624,6 @@ class FeishuChannel(BaseChannel):content = ""media = []- # Log detailed message info for debugging- logger.info(- f"Received Feishu message: msg_type={msg_type}, content={message.content[:200]}"- )-if msg_type == "text":try:content = json.loads(message.content).get("text", "")@@ -621,8 +693,6 @@ class FeishuChannel(BaseChannel):logger.warning(f"Could not download image for image_key: {image_key}")- else:- logger.warning(f"No image_key found in message content: {msg_content}")except Exception as e:logger.warning(f"Failed to download Feishu image: {e}")import traceback@@ -634,8 +704,15 @@ class FeishuChannel(BaseChannel):if not content:return+ import re++ mention_pattern = re.compile(r"@_user_\d+")+ content = mention_pattern.sub(f"@{sender_id}", content)+# Forward to message busreply_to = chat_id if chat_type == "group" else sender_id+ logger.info(f"Received message from Feishu: {content}")+await self._handle_message(sender_id=sender_id,chat_id=reply_to,@@ -645,8 +722,49 @@ class FeishuChannel(BaseChannel):"message_id": message_id,"chat_type": chat_type,"msg_type": msg_type,+ "root_id": message.root_id, # Topic/thread ID for topic groups+ "sender_id": sender_id, # Original message sender ID for @mention in replies},)except Exception as e:logger.exception(f"Error processing Feishu message")++ async def _extract_and_upload_images(self, content: str) -> tuple[str, list[dict]]:+ """Extract images from markdown content, upload to Feishu, and return cleaned content."""+ images = []+ cleaned_content = content++ # Pattern 1: + markdown_pattern = r"!\[([^\]]*)\]\((send://[^)\s]+\.(png|jpeg|jpg|gif|bmp|webp))\)"+ for m in re.finditer(markdown_pattern, content):+ img_url = m.group(2)+ try:+ is_content, result = await self._parse_data_uri(img_url)++ if not is_content and isinstance(result, bytes):+ image_key = await self._upload_image_to_feishu(result)+ images.append({"image_key": image_key})+ except Exception as e:+ logger.exception(f"Failed to upload Markdown image {img_url[:100]}: {e}")++ # Remove markdown image syntax+ cleaned_content = re.sub(markdown_pattern, "", cleaned_content)++ # Pattern 2: send://... (without alt text)+ send_pattern = r"(send://[^)\s]+\.(png|jpeg|jpg|gif|bmp|webp))\)?"+ for m in re.finditer(send_pattern, content):+ img_url = m.group(1) or ""+ try:+ is_content, result = await self._parse_data_uri(img_url)++ if not is_content and isinstance(result, bytes):+ image_key = await self._upload_image_to_feishu(result)+ images.append({"image_key": image_key})+ except Exception as e:+ logger.exception(f"Failed to upload Markdown image {img_url[:100]}: {e}")++ # Remove standalone send:// URLs+ cleaned_content = re.sub(send_pattern, "", cleaned_content)++ return cleaned_content.strip(), imagesdiff --git a/bot/vikingbot/channels/manager.py b/bot/vikingbot/channels/manager.pyindex 68e0c333b..f61d6344c 100644--- a/bot/vikingbot/channels/manager.py+++ b/bot/vikingbot/channels/manager.py@@ -10,7 +10,7 @@ from loguru import loggerfrom vikingbot.bus.events import OutboundMessagefrom vikingbot.bus.queue import MessageBusfrom vikingbot.channels.base import BaseChannel-from vikingbot.config.schema import Config, ChannelsConfig+from vikingbot.config.schema import BaseChannelConfig, ChannelType, Configclass ChannelManager:@@ -18,120 +18,151 @@ class ChannelManager:Manages chat channels and coordinates message routing.Responsibilities:- - Initialize enabled channels (Telegram, WhatsApp, etc.)+ - Add channels (directly or from config)- Start/stop channels- Route outbound messages"""- def __init__(self, config: Config, bus: MessageBus):- self.config = config+ def __init__(self, bus: MessageBus):self.bus = busself.channels: dict[str, BaseChannel] = {}self._dispatch_task: asyncio.Task | None = None+ self._workspace_path: Any | None = None+ self._additional_deps: dict[str, Any] = {}++ def add_channel(self, channel: BaseChannel) -> None:+ """Add a channel directly."""+ channel_key = channel.config.channel_key()+ self.channels[channel_key] = channel+ logger.info(f"Channel added: {channel.name} ({channel_key})")++ def add_channel_from_config(+ self,+ channel_config: BaseChannelConfig,+ workspace_path: Any | None = None,+ **additional_deps,+ ) -> None:+ """+ Add a channel from config.++ Args:+ channel_config: Channel configuration+ workspace_path: Workspace path for channels that need it+ **additional_deps: Additional dependencies for specific channels+ """+ if not channel_config.enabled:+ return- self._init_channels()-- def _init_channels(self) -> None:- """Initialize channels based on config."""- from vikingbot.config.schema import ChannelType-- channels_config = self.config.channels_config+ try:+ channel = None++ if channel_config.type == ChannelType.TELEGRAM:+ from vikingbot.channels.telegram import TelegramChannel++ channel = TelegramChannel(+ channel_config,+ self.bus,+ groq_api_key=additional_deps.get("groq_api_key"),+ )++ elif channel_config.type == ChannelType.FEISHU:+ from vikingbot.channels.feishu import FeishuChannel++ channel = FeishuChannel(+ channel_config,+ self.bus,+ workspace_path=workspace_path,+ )++ elif channel_config.type == ChannelType.DISCORD:+ from vikingbot.channels.discord import DiscordChannel++ channel = DiscordChannel(+ channel_config,+ self.bus,+ workspace_path=workspace_path,+ )++ elif channel_config.type == ChannelType.WHATSAPP:+ from vikingbot.channels.whatsapp import WhatsAppChannel++ channel = WhatsAppChannel(+ channel_config,+ self.bus,+ workspace_path=workspace_path,+ )++ elif channel_config.type == ChannelType.MOCHAT:+ from vikingbot.channels.mochat import MochatChannel++ channel = MochatChannel(+ channel_config,+ self.bus,+ workspace_path=workspace_path,+ )++ elif channel_config.type == ChannelType.DINGTALK:+ from vikingbot.channels.dingtalk import DingTalkChannel++ channel = DingTalkChannel(+ channel_config,+ self.bus,+ workspace_path=workspace_path,+ )++ elif channel_config.type == ChannelType.EMAIL:+ from vikingbot.channels.email import EmailChannel++ channel = EmailChannel(+ channel_config,+ self.bus,+ workspace_path=workspace_path,+ )++ elif channel_config.type == ChannelType.SLACK:+ from vikingbot.channels.slack import SlackChannel++ channel = SlackChannel(+ channel_config,+ self.bus,+ workspace_path=workspace_path,+ )++ elif channel_config.type == ChannelType.QQ:+ from vikingbot.channels.qq import QQChannel++ channel = QQChannel(+ channel_config,+ self.bus,+ workspace_path=workspace_path,+ )++ if channel:+ self.add_channel(channel)++ except ImportError as e:+ channel_type = getattr(channel_config.type, "value", str(channel_config.type))+ logger.warning(+ f"Channel {channel_config.type} not available: {e}. "+ f"Install with: uv pip install 'vikingbot[{channel_type}]' "+ f"(or uv pip install -e \".[{channel_type}]\" for local dev)"+ )++ def load_channels_from_config(+ self,+ config: Config,+ ) -> None:+ """Load all enabled channels from a Config object."""+ channels_config = config.channels_configall_channel_configs = channels_config.get_all_channels()- workspace_path = self.config.workspace_path+ workspace_path = config.workspace_pathfor channel_config in all_channel_configs:- if not channel_config.enabled:- continue-- try:- channel = None- if channel_config.type == ChannelType.TELEGRAM:- from vikingbot.channels.telegram import TelegramChannel-- channel = TelegramChannel(- channel_config,- self.bus,- groq_api_key=self.config.providers.groq.api_key,- )-- elif channel_config.type == ChannelType.FEISHU:- from vikingbot.channels.feishu import FeishuChannel-- channel = FeishuChannel(- channel_config,- self.bus,- workspace_path=workspace_path,- )-- elif channel_config.type == ChannelType.DISCORD:- from vikingbot.channels.discord import DiscordChannel-- channel = DiscordChannel(- channel_config,- self.bus,- workspace_path=workspace_path,- )-- elif channel_config.type == ChannelType.WHATSAPP:- from vikingbot.channels.whatsapp import WhatsAppChannel-- channel = WhatsAppChannel(- channel_config,- self.bus,- workspace_path=workspace_path,- )-- elif channel_config.type == ChannelType.MOCHAT:- from vikingbot.channels.mochat import MochatChannel-- channel = MochatChannel(- channel_config,- self.bus,- workspace_path=workspace_path,- )-- elif channel_config.type == ChannelType.DINGTALK:- from vikingbot.channels.dingtalk import DingTalkChannel-- channel = DingTalkChannel(- channel_config,- self.bus,- workspace_path=workspace_path,- )-- elif channel_config.type == ChannelType.EMAIL:- from vikingbot.channels.email import EmailChannel-- channel = EmailChannel(- channel_config,- self.bus,- workspace_path=workspace_path,- )-- elif channel_config.type == ChannelType.SLACK:- from vikingbot.channels.slack import SlackChannel-- channel = SlackChannel(- channel_config,- self.bus,- workspace_path=workspace_path,- )-- elif channel_config.type == ChannelType.QQ:- from vikingbot.channels.qq import QQChannel-- channel = QQChannel(- channel_config,- self.bus,- workspace_path=workspace_path,- )-- if channel:- self.channels[channel.config.channel_key()] = channel- logger.info(f"Channel enabled: {channel.name}")-- except ImportError as e:- logger.warning(f"Channel {channel_config.type} not available: {e}")+ self.add_channel_from_config(+ channel_config,+ workspace_path=workspace_path,+ groq_api_key=config.providers.groq.api_key if hasattr(config.providers, "groq") else None,+ )async def _start_channel(self, name: str, channel: BaseChannel) -> None:"""Start a channel and log any exceptions."""diff --git a/bot/vikingbot/channels/openapi.py b/bot/vikingbot/channels/openapi.pynew file mode 100644index 000000000..2443ea322--- /dev/null+++ b/bot/vikingbot/channels/openapi.py@@ -0,0 +1,443 @@+"""OpenAPI channel for HTTP-based chat API."""++import asyncio+import secrets+import uuid+from datetime import datetime+from pathlib import Path+from typing import Any, AsyncGenerator, Callable, Dict, List, Optional++from fastapi import APIRouter, Depends, Header, HTTPException, Request+from fastapi.responses import StreamingResponse+from loguru import logger+from pydantic import BaseModel++from vikingbot.bus.events import InboundMessage, OutboundEventType, OutboundMessage+from vikingbot.bus.queue import MessageBus+from vikingbot.channels.base import BaseChannel+from vikingbot.channels.openapi_models import (+ ChatMessage,+ ChatRequest,+ ChatResponse,+ ChatStreamEvent,+ ErrorResponse,+ EventType,+ HealthResponse,+ MessageRole,+ SessionCreateRequest,+ SessionCreateResponse,+ SessionDetailResponse,+ SessionInfo,+ SessionListResponse,+)+from vikingbot.config.schema import BaseChannelConfig, Config, SessionKey+++class OpenAPIChannelConfig(BaseChannelConfig):+ """Configuration for OpenAPI channel."""++ enabled: bool = True+ type: str = "openapi"+ api_key: str = "" # If empty, no auth required+ allow_from: list[str] = []+ max_concurrent_requests: int = 100++ def channel_id(self) -> str:+ return "openapi"+++class PendingResponse:+ """Tracks a pending response from the agent."""++ def __init__(self):+ self.events: List[Dict[str, Any]] = []+ self.final_content: Optional[str] = None+ self.event = asyncio.Event()+ self.stream_queue: asyncio.Queue[Optional[ChatStreamEvent]] = asyncio.Queue()++ async def add_event(self, event_type: str, data: Any):+ """Add an event to the response."""+ event = {"type": event_type, "data": data, "timestamp": datetime.now().isoformat()}+ self.events.append(event)+ await self.stream_queue.put(ChatStreamEvent(event=EventType(event_type), data=data))++ def set_final(self, content: str):+ """Set the final response content."""+ self.final_content = content+ self.event.set()++ async def close_stream(self):+ """Close the stream queue."""+ await self.stream_queue.put(None)+++class OpenAPIChannel(BaseChannel):+ """+ OpenAPI channel exposing HTTP endpoints for chat API.+ This channel works differently from others - it doesn't subscribe+ to outbound messages directly but uses request-response pattern.+ """++ name: str = "openapi"++ def __init__(+ self,+ config: OpenAPIChannelConfig,+ bus: MessageBus,+ workspace_path: Path | None = None,+ app: "FastAPI | None" = None,+ ):+ super().__init__(config, bus, workspace_path)+ self.config = config+ self._pending: Dict[str, PendingResponse] = {}+ self._sessions: Dict[str, Dict[str, Any]] = {}+ self._router: Optional[APIRouter] = None+ self._app = app # External FastAPI app to register routes on+ self._server: Optional[asyncio.Task] = None # Server task++ async def start(self) -> None:+ """Start the channel - register routes to external FastAPI app if provided."""+ self._running = True++ # Register routes to external FastAPI app+ if self._app is not None:+ self._setup_routes()++ logger.info("OpenAPI channel started")++ async def stop(self) -> None:+ """Stop the channel."""+ self._running = False+ # Complete all pending responses+ for pending in self._pending.values():+ pending.set_final("")+ logger.info("OpenAPI channel stopped")++ async def send(self, msg: OutboundMessage) -> None:+ """+ Handle outbound messages - routes to pending responses.+ This is called by the message bus dispatcher.+ """+ session_id = msg.session_key.chat_id+ pending = self._pending.get(session_id)++ if not pending:+ # No pending request for this session, ignore+ return++ if msg.event_type == OutboundEventType.RESPONSE:+ # Final response+ pending.set_final(msg.content or "")+ await pending.close_stream()+ elif msg.event_type == OutboundEventType.REASONING:+ await pending.add_event("reasoning", msg.content)+ elif msg.event_type == OutboundEventType.TOOL_CALL:+ await pending.add_event("tool_call", msg.content)+ elif msg.event_type == OutboundEventType.TOOL_RESULT:+ await pending.add_event("tool_result", msg.content)++ def get_router(self) -> APIRouter:+ """Get or create the FastAPI router."""+ if self._router is None:+ self._router = self._create_router()+ return self._router++ def _create_router(self) -> APIRouter:+ """Create the FastAPI router with all routes."""+ router = APIRouter()+ channel = self # Capture for closures++ async def verify_api_key(x_api_key: Optional[str] = Header(None)) -> bool:+ """Verify API key if configured."""+ if not channel.config.api_key:+ return True # No auth required+ if not x_api_key:+ raise HTTPException(status_code=401, detail="X-API-Key header required")+ # Use secrets.compare_digest for timing-safe comparison+ if not secrets.compare_digest(x_api_key, channel.config.api_key):+ raise HTTPException(status_code=403, detail="Invalid API key")+ return True++ @router.get("/health", response_model=HealthResponse)+ async def health_check():+ """Health check endpoint."""+ from vikingbot import __version__++ return HealthResponse(+ status="healthy" if channel._running else "unhealthy",+ version=__version__,+ )++ @router.post("/chat", response_model=ChatResponse)+ async def chat(+ request: ChatRequest,+ authorized: bool = Depends(verify_api_key),+ ):+ """Send a chat message and get a response."""+ return await channel._handle_chat(request)++ @router.post("/chat/stream")+ async def chat_stream(+ request: ChatRequest,+ authorized: bool = Depends(verify_api_key),+ ):+ """Send a chat message and get a streaming response."""+ if not request.stream:+ request.stream = True+ return await channel._handle_chat_stream(request)++ @router.get("/sessions", response_model=SessionListResponse)+ async def list_sessions(+ authorized: bool = Depends(verify_api_key),+ ):+ """List all sessions."""+ sessions = []+ for session_id, session_data in channel._sessions.items():+ sessions.append(+ SessionInfo(+ id=session_id,+ created_at=session_data.get("created_at", datetime.now()),+ last_active=session_data.get("last_active", datetime.now()),+ message_count=session_data.get("message_count", 0),+ )+ )+ return SessionListResponse(sessions=sessions, total=len(sessions))++ @router.post("/sessions", response_model=SessionCreateResponse)+ async def create_session(+ request: SessionCreateRequest,+ authorized: bool = Depends(verify_api_key),+ ):+ """Create a new session."""+ session_id = str(uuid.uuid4())+ now = datetime.now()+ channel._sessions[session_id] = {+ "user_id": request.user_id,+ "created_at": now,+ "last_active": now,+ "message_count": 0,+ "metadata": request.metadata or {},+ }+ return SessionCreateResponse(session_id=session_id, created_at=now)++ @router.get("/sessions/{session_id}", response_model=SessionDetailResponse)+ async def get_session(+ session_id: str,+ authorized: bool = Depends(verify_api_key),+ ):+ """Get session details."""+ if session_id not in channel._sessions:+ raise HTTPException(status_code=404, detail="Session not found")++ session_data = channel._sessions[session_id]+ info = SessionInfo(+ id=session_id,+ created_at=session_data.get("created_at", datetime.now()),+ last_active=session_data.get("last_active", datetime.now()),+ message_count=session_data.get("message_count", 0),+ )+ # Get messages from session manager if available+ messages = session_data.get("messages", [])+ return SessionDetailResponse(session=info, messages=messages)++ @router.delete("/sessions/{session_id}")+ async def delete_session(+ session_id: str,+ authorized: bool = Depends(verify_api_key),+ ):+ """Delete a session."""+ if session_id not in channel._sessions:+ raise HTTPException(status_code=404, detail="Session not found")++ del channel._sessions[session_id]+ return {"deleted": True}++ return router++ def _setup_routes(self) -> None:+ """Setup routes on the external FastAPI app."""+ if self._app is None:+ logger.warning("No external FastAPI app provided, cannot setup routes")+ return++ # Get the router and include it at root path+ # Note: openviking-server adds its own /bot/v1 prefix when proxying+ router = self.get_router()+ self._app.include_router(router, prefix="/bot/v1")+ logger.info("OpenAPI routes registered at root path")++ async def _handle_chat(self, request: ChatRequest) -> ChatResponse:+ """Handle a chat request."""+ # Generate or use provided session ID+ session_id = request.session_id or str(uuid.uuid4())+ user_id = request.user_id or "anonymous"++ # Create session if new+ if session_id not in self._sessions:+ self._sessions[session_id] = {+ "user_id": user_id,+ "created_at": datetime.now(),+ "last_active": datetime.now(),+ "message_count": 0,+ "messages": [],+ }++ # Update session activity+ self._sessions[session_id]["last_active"] = datetime.now()+ self._sessions[session_id]["message_count"] += 1++ # Create pending response tracker+ pending = PendingResponse()+ self._pending[session_id] = pending++ try:+ # Build session key+ session_key = SessionKey(+ type="openapi",+ channel_id=self.config.channel_id(),+ chat_id=session_id,+ )++ # Build content with context if provided+ content = request.message+ if request.context:+ # Context is handled separately by session manager+ pass++ # Create and publish inbound message+ msg = InboundMessage(+ session_key=session_key,+ sender_id=user_id,+ content=content,+ )++ await self.bus.publish_inbound(msg)++ # Wait for response with timeout+ try:+ await asyncio.wait_for(pending.event.wait(), timeout=300.0)+ except asyncio.TimeoutError:+ raise HTTPException(status_code=504, detail="Request timeout")++ # Build response+ response_content = pending.final_content or ""++ return ChatResponse(+ session_id=session_id,+ message=response_content,+ events=pending.events if pending.events else None,+ )++ except HTTPException:+ raise+ except Exception as e:+ logger.exception(f"Error handling chat request: {e}")+ raise HTTPException(status_code=500, detail=f"Internal error: {str(e)}")+ finally:+ # Clean up pending+ self._pending.pop(session_id, None)++ async def _handle_chat_stream(self, request: ChatRequest) -> StreamingResponse:+ """Handle a streaming chat request."""+ session_id = request.session_id or str(uuid.uuid4())+ user_id = request.user_id or "anonymous"++ # Create session if new+ if session_id not in self._sessions:+ self._sessions[session_id] = {+ "user_id": user_id,+ "created_at": datetime.now(),+ "last_active": datetime.now(),+ "message_count": 0,+ "messages": [],+ }++ self._sessions[session_id]["last_active"] = datetime.now()+ self._sessions[session_id]["message_count"] += 1++ pending = PendingResponse()+ self._pending[session_id] = pending++ async def event_generator():+ try:+ # Build session key and send message+ session_key = SessionKey(+ type="openapi",+ channel_id=self.config.channel_id(),+ chat_id=session_id,+ )++ msg = InboundMessage(+ session_key=session_key,+ sender_id=user_id,+ content=request.message,+ )++ await self.bus.publish_inbound(msg)++ # Stream events as they arrive+ while True:+ try:+ event = await asyncio.wait_for(pending.stream_queue.get(), timeout=300.0)+ if event is None:+ break+ yield f"data: {event.model_dump_json()}\n\n"+ except asyncio.TimeoutError:+ yield f"data: {ChatStreamEvent(event=EventType.RESPONSE, data={'error': 'timeout'}).model_dump_json()}\n\n"+ break++ except Exception as e:+ logger.exception(f"Error in stream generator: {e}")+ error_event = ChatStreamEvent(+ event=EventType.RESPONSE,+ data={"error": str(e)}+ )+ yield f"data: {error_event.model_dump_json()}\n\n"+ finally:+ self._pending.pop(session_id, None)++ return StreamingResponse(+ event_generator(),+ media_type="text/event-stream",+ headers={+ "Cache-Control": "no-cache",+ "Connection": "keep-alive",+ },+ )+++def get_openapi_router(bus: MessageBus, config: Config) -> APIRouter:+ """+ Create and return the OpenAPI router for mounting in FastAPI.++ This factory function creates an OpenAPIChannel and returns its router.+ The router should be mounted in the main FastAPI app.+ """+ # Find OpenAPI config from channels+ openapi_config = None+ for ch_config in config.channels:+ if isinstance(ch_config, dict) and ch_config.get("type") == "openapi":+ openapi_config = OpenAPIChannelConfig(**ch_config)+ break+ elif hasattr(ch_config, "type") and getattr(ch_config, "type", None) == "openapi":+ openapi_config = ch_config+ break++ if openapi_config is None:+ # Create default config+ openapi_config = OpenAPIChannelConfig()++ # Create channel and get router+ channel = OpenAPIChannel(+ config=openapi_config,+ bus=bus,+ workspace_path=config.workspace_path,+ )++ # Register channel's send method as subscriber for outbound messages+ bus.subscribe_outbound(+ f"openapi__{openapi_config.channel_id()}",+ channel.send,+ )++ return channel.get_router()diff --git a/bot/vikingbot/channels/openapi_models.py b/bot/vikingbot/channels/openapi_models.pynew file mode 100644index 000000000..0d4da5c80--- /dev/null+++ b/bot/vikingbot/channels/openapi_models.py@@ -0,0 +1,114 @@+"""Pydantic models for OpenAPI channel."""++from datetime import datetime+from enum import Enum+from typing import Any, Dict, List, Optional++from pydantic import BaseModel, Field+++class MessageRole(str, Enum):+ """Message role enumeration."""++ USER = "user"+ ASSISTANT = "assistant"+ SYSTEM = "system"+ TOOL = "tool"+++class EventType(str, Enum):+ """Event type enumeration."""++ RESPONSE = "response"+ TOOL_CALL = "tool_call"+ TOOL_RESULT = "tool_result"+ REASONING = "reasoning"+ ITERATION = "iteration"+++class ChatMessage(BaseModel):+ """A single chat message."""++ role: MessageRole = Field(..., description="Role of the message sender")+ content: str = Field(..., description="Message content")+ timestamp: Optional[datetime] = Field(default_factory=datetime.now, description="Message timestamp")+++class ChatRequest(BaseModel):+ """Request body for chat endpoint."""++ message: str = Field(..., description="User message to send", min_length=1)+ session_id: Optional[str] = Field(default=None, description="Session ID (optional, will create new if not provided)")+ user_id: Optional[str] = Field(default=None, description="User identifier (optional)")+ stream: bool = Field(default=False, description="Whether to stream the response")+ context: Optional[List[ChatMessage]] = Field(default=None, description="Additional context messages")+++class ChatResponse(BaseModel):+ """Response from chat endpoint (non-streaming)."""++ session_id: str = Field(..., description="Session ID")+ message: str = Field(..., description="Assistant's response message")+ events: Optional[List[Dict[str, Any]]] = Field(default=None, description="Intermediate events (thinking, tool calls)")+ timestamp: datetime = Field(default_factory=datetime.now, description="Response timestamp")+++class ChatStreamEvent(BaseModel):+ """A single event in the chat stream (SSE)."""++ event: EventType = Field(..., description="Event type")+ data: Any = Field(..., description="Event data")+ timestamp: datetime = Field(default_factory=datetime.now, description="Event timestamp")+++class SessionInfo(BaseModel):+ """Session information."""++ id: str = Field(..., description="Session ID")+ created_at: datetime = Field(..., description="Session creation time")+ last_active: datetime = Field(..., description="Last activity time")+ message_count: int = Field(default=0, description="Number of messages in session")+++class SessionCreateRequest(BaseModel):+ """Request to create a new session."""++ user_id: Optional[str] = Field(default=None, description="User identifier")+ metadata: Optional[Dict[str, Any]] = Field(default=None, description="Optional session metadata")+++class SessionCreateResponse(BaseModel):+ """Response from session creation."""++ session_id: str = Field(..., description="Created session ID")+ created_at: datetime = Field(default_factory=datetime.now, description="Creation timestamp")+++class SessionListResponse(BaseModel):+ """Response listing all sessions."""++ sessions: List[SessionInfo] = Field(default_factory=list, description="List of sessions")+ total: int = Field(..., description="Total number of sessions")+++class SessionDetailResponse(BaseModel):+ """Detailed session information including messages."""++ session: SessionInfo = Field(..., description="Session information")+ messages: List[ChatMessage] = Field(default_factory=list, description="Session messages")+++class HealthResponse(BaseModel):+ """Health check response."""++ status: str = Field(default="healthy", description="Service status")+ version: Optional[str] = Field(default=None, description="API version")+ timestamp: datetime = Field(default_factory=datetime.now, description="Check timestamp")+++class ErrorResponse(BaseModel):+ """Error response."""++ error: str = Field(..., description="Error message")+ code: Optional[str] = Field(default=None, description="Error code")+ detail: Optional[str] = Field(default=None, description="Detailed error information")diff --git a/bot/vikingbot/channels/qq.py b/bot/vikingbot/channels/qq.pyindex 237b4fbc2..49eda8fdf 100644--- a/bot/vikingbot/channels/qq.py+++ b/bot/vikingbot/channels/qq.py@@ -60,7 +60,7 @@ class QQChannel(BaseChannel):async def start(self) -> None:"""Start the QQ bot."""if not QQ_AVAILABLE:- logger.exception("QQ SDK not installed. Run: pip install qq-botpy")+ logger.exception("QQ SDK not installed. Install with: uv pip install 'vikingbot[qq]' (or uv pip install -e \".[qq]\" for local dev)")returnif not self.config.app_id or not self.config.secret:@@ -98,6 +98,10 @@ class QQChannel(BaseChannel):async def send(self, msg: OutboundMessage) -> None:"""Send a message through QQ."""+ # Only send normal response messages, skip thinking/tool_call/etc.+ if not msg.is_normal_message:+ return+if not self._client:logger.warning("QQ client not initialized")returndiff --git a/bot/vikingbot/channels/single_turn.py b/bot/vikingbot/channels/single_turn.pynew file mode 100644index 000000000..d4c44f091--- /dev/null+++ b/bot/vikingbot/channels/single_turn.py@@ -0,0 +1,95 @@+# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.+# SPDX-License-Identifier: Apache-2.0+"""Single-turn channel - no extra output, just the result."""++import asyncio+from pathlib import Path+from typing import Any+import json++from loguru import logger++from vikingbot.bus.events import InboundMessage, OutboundMessage, OutboundEventType+from vikingbot.bus.queue import MessageBus+from vikingbot.channels.base import BaseChannel+from vikingbot.config.schema import SessionKey, BaseChannelConfig+++class SingleTurnChannelConfig(BaseChannelConfig):+ """Configuration for SingleTurnChannel."""++ enabled: bool = True+ type: Any = "cli"++ def channel_id(self) -> str:+ return "chat"+++class SingleTurnChannel(BaseChannel):+ """+ Single-turn channel for one-off messages.++ Only outputs the final result, no extra messages, no thinking/tool call display.+ Only error-level logs are shown.+ """++ name: str = "single_turn"++ def __init__(+ self,+ config: BaseChannelConfig,+ bus: MessageBus,+ workspace_path: Path | None = None,+ message: str = "",+ session_id: str = "cli__chat__default",+ markdown: bool = True,+ eval: bool = False,+ ):+ super().__init__(config, bus, workspace_path)+ self.message = message+ self.session_id = session_id+ self.markdown = markdown+ self._response_received = asyncio.Event()+ self._last_response: str | None = None+ self._eval = eval++ async def start(self) -> None:+ """Start the single-turn channel - send message and wait for response."""+ self._running = True++ # Send the message+ msg = InboundMessage(+ session_key=SessionKey.from_safe_name(self.session_id),+ sender_id="default",+ content=self.message,+ )+ await self.bus.publish_inbound(msg)++ # Wait for response with timeout+ try:+ await asyncio.wait_for(self._response_received.wait(), timeout=300.0)+ if self._last_response:+ from vikingbot.cli.commands import console+ from rich.markdown import Markdown+ from rich.text import Text+ content = self._last_response or ""+ body = Markdown(content) if self.markdown else Text(content)+ console.print(body)+ except asyncio.TimeoutError:+ logger.error("Timeout waiting for response")++ async def stop(self) -> None:+ """Stop the single-turn channel."""+ self._running = False++ async def send(self, msg: OutboundMessage) -> None:+ """Send a message - store final response for later retrieval."""+ if msg.is_normal_message:+ if self._eval:+ output = {+ "text": msg.content,+ "token_usage": msg.token_usage,+ }+ msg.content = json.dumps(output, ensure_ascii=False)+ self._last_response = msg.content+ self._response_received.set()diff --git a/bot/vikingbot/channels/slack.py b/bot/vikingbot/channels/slack.pyindex 42fc07b53..e8744afbc 100644--- a/bot/vikingbot/channels/slack.py+++ b/bot/vikingbot/channels/slack.py@@ -74,6 +74,10 @@ class SlackChannel(BaseChannel):async def send(self, msg: OutboundMessage) -> None:"""Send a message through Slack."""+ # Only send normal response messages, skip thinking/tool_call/etc.+ if not msg.is_normal_message:+ return+if not self._web_client:logger.warning("Slack client not running")returndiff --git a/bot/vikingbot/channels/stdio.py b/bot/vikingbot/channels/stdio.pynew file mode 100644index 000000000..58a82443d--- /dev/null+++ b/bot/vikingbot/channels/stdio.py@@ -0,0 +1,179 @@+# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.+# SPDX-License-Identifier: Apache-2.0+"""Stdio channel for vikingbot - communicates via stdin/stdout."""++import asyncio+import json+import sys+from pathlib import Path+from typing import Any++from loguru import logger++from vikingbot.bus.events import InboundMessage, OutboundMessage+from vikingbot.bus.queue import MessageBus+from vikingbot.channels.base import BaseChannel+from vikingbot.config.schema import SessionKey, BaseChannelConfig, ChannelType+++class StdioChannelConfig(BaseChannelConfig):+ """Configuration for StdioChannel."""++ enabled: bool = True+ type: Any = "stdio"++ def channel_id(self) -> str:+ return "stdio"+++class StdioChannel(BaseChannel):+ """+ Stdio channel for vikingbot.++ This channel communicates via stdin/stdout using JSON messages:+ - Reads JSON messages from stdin+ - Publishes them to the MessageBus+ - Subscribes to outbound messages and writes them to stdout+ """++ name: str = "stdio"++ def __init__(+ self, config: BaseChannelConfig, bus: MessageBus, workspace_path: Path | None = None+ ):+ super().__init__(config, bus, workspace_path)+ self._response_queue: asyncio.Queue[str] = asyncio.Queue()++ async def start(self) -> None:+ """Start the stdio channel."""+ self._running = True+ logger.info("Starting stdio channel")++ # Start reader and writer tasks+ reader_task = asyncio.create_task(self._read_stdin())+ writer_task = asyncio.create_task(self._write_stdout())++ # Send ready signal+ await self._send_json({"type": "ready"})++ try:+ await asyncio.gather(reader_task, writer_task)+ except asyncio.CancelledError:+ self._running = False+ reader_task.cancel()+ writer_task.cancel()+ await asyncio.gather(reader_task, writer_task, return_exceptions=True)++ async def stop(self) -> None:+ """Stop the stdio channel."""+ self._running = False+ logger.info("Stopping stdio channel")++ async def send(self, msg: OutboundMessage) -> None:+ """Send a message via stdout."""+ if msg.is_normal_message:+ await self._send_json({+ "type": "response",+ "content": msg.content,+ })+ else:+ # For thinking events, just send the content as-is+ await self._send_json({+ "type": "event",+ "event_type": msg.event_type.value if hasattr(msg.event_type, "value") else str(msg.event_type),+ "content": msg.content,+ })++ async def _send_json(self, data: dict[str, Any]) -> None:+ """Send JSON data to stdout."""+ try:+ line = json.dumps(data, ensure_ascii=False)+ print(line, flush=True)+ except Exception as e:+ logger.exception(f"Failed to send JSON: {e}")++ async def _read_stdin(self) -> None:+ """Read lines from stdin and publish to bus."""+ loop = asyncio.get_event_loop()++ while self._running:+ try:+ # Read a line from stdin+ line = await loop.run_in_executor(None, sys.stdin.readline)++ if not line:+ # EOF+ self._running = False+ break++ line = line.strip()+ if not line:+ continue++ # Parse the input+ try:+ request = json.loads(line)+ except json.JSONDecodeError:+ # Treat as simple text message+ request = {"type": "message", "content": line}++ await self._handle_request(request)++ except Exception as e:+ logger.exception(f"Error reading from stdin: {e}")+ await self._send_json({+ "type": "error",+ "message": str(e),+ })++ async def _write_stdout(self) -> None:+ """Write responses from the queue to stdout."""+ while self._running:+ try:+ # Wait for a response with timeout+ content = await asyncio.wait_for(+ self._response_queue.get(),+ timeout=0.5,+ )+ await self._send_json({+ "type": "response",+ "content": content,+ })+ except asyncio.TimeoutError:+ continue+ except Exception as e:+ logger.exception(f"Error writing to stdout: {e}")++ async def _handle_request(self, request: dict[str, Any]) -> None:+ """Handle an incoming request."""+ request_type = request.get("type", "message")++ if request_type == "ping":+ await self._send_json({"type": "pong"})++ elif request_type == "message":+ content = request.get("content", "")+ chat_id = request.get("chat_id", "default")+ sender_id = request.get("sender_id", "user")++ # Create and publish inbound message+ msg = InboundMessage(+ session_key=SessionKey(+ type="stdio",+ channel_id=self.channel_id,+ chat_id=chat_id,+ ),+ sender_id=sender_id,+ content=content,+ )+ await self.bus.publish_inbound(msg)++ elif request_type == "quit":+ await self._send_json({"type": "bye"})+ self._running = False++ else:+ await self._send_json({+ "type": "error",+ "message": f"Unknown request type: {request_type}",+ })diff --git a/bot/vikingbot/channels/telegram.py b/bot/vikingbot/channels/telegram.pyindex ef8318624..2e76a32d8 100644--- a/bot/vikingbot/channels/telegram.py+++ b/bot/vikingbot/channels/telegram.py@@ -193,6 +193,10 @@ class TelegramChannel(BaseChannel):async def send(self, msg: OutboundMessage) -> None:"""Send a message through Telegram."""+ # Only send normal response messages, skip thinking/tool_call/etc.+ if not msg.is_normal_message:+ return+if not self._app:logger.warning("Telegram bot not running")returndiff --git a/bot/vikingbot/channels/whatsapp.py b/bot/vikingbot/channels/whatsapp.pyindex f5fc981d7..23794a88f 100644--- a/bot/vikingbot/channels/whatsapp.py+++ b/bot/vikingbot/channels/whatsapp.py@@ -79,6 +79,10 @@ class WhatsAppChannel(BaseChannel):async def send(self, msg: OutboundMessage) -> None:"""Send a message through WhatsApp."""+ # Only send normal response messages, skip thinking/tool_call/etc.+ if not msg.is_normal_message:+ return+if not self._ws or not self._connected:logger.warning("WhatsApp bridge not connected")returndiff --git a/bot/vikingbot/cli/commands.py b/bot/vikingbot/cli/commands.pyindex ad1bc555f..ebf951357 100644--- a/bot/vikingbot/cli/commands.py+++ b/bot/vikingbot/cli/commands.py@@ -3,40 +3,38 @@import asyncioimport jsonimport os-import signal-from multiprocessing.spawn import prepare-from pathlib import Pathimport select+import signalimport sys-from xml.etree.ElementPath import prepare_self-from loguru import logger+from pathlib import Path+import typer-from jinja2.filters import prepare_map+from loguru import logger+from prompt_toolkit import PromptSession+from prompt_toolkit.formatted_text import HTML+from prompt_toolkit.history import FileHistory+from prompt_toolkit.patch_stdout import patch_stdoutfrom rich.console import Consolefrom rich.markdown import Markdownfrom rich.table import Tablefrom rich.text import Text-from prompt_toolkit import PromptSession-from prompt_toolkit.formatted_text import HTML-from prompt_toolkit.history import FileHistory-from prompt_toolkit.patch_stdout import patch_stdout-from vikingbot.config.loader import load_config, ensure_config, get_data_dir, get_config_path-from vikingbot.bus.queue import MessageBus+from vikingbot import __logo__, __version__from vikingbot.agent.loop import AgentLoop--from vikingbot.session.manager import SessionManager+from vikingbot.bus.queue import MessageBus+from vikingbot.channels.manager import ChannelManager+from vikingbot.config.loader import ensure_config, get_config_path, get_data_dir, load_config+from vikingbot.config.schema import SessionKeyfrom vikingbot.cron.service import CronServicefrom vikingbot.cron.types import CronJobfrom vikingbot.heartbeat.service import HeartbeatService-from vikingbot import __version__, __logo__-from vikingbot.config.schema import SessionKey+from vikingbot.integrations.langfuse import LangfuseClient+from vikingbot.config.loader import load_config# Create sandbox managerfrom vikingbot.sandbox.manager import SandboxManager-from vikingbot.utils.helpers import get_source_workspace_path-from vikingbot.channels.manager import ChannelManager-+from vikingbot.session.manager import SessionManager+from vikingbot.utils.helpers import get_source_workspace_path, set_bot_data_path, get_history_path, get_bridge_pathapp = typer.Typer(name="vikingbot",@@ -47,6 +45,12 @@ app = typer.Typer(console = Console()EXIT_COMMANDS = {"exit", "quit", "/exit", "/quit", ":q"}++def _init_bot_data(config):+ """Initialize bot data directory and set global paths."""+ set_bot_data_path(config.bot_data_path)++# ---------------------------------------------------------------------------# CLI input: prompt_toolkit for editing, paste, history, and display# ---------------------------------------------------------------------------@@ -107,7 +111,7 @@ def _init_prompt_session() -> None:except Exception:pass- history_file = Path.home() / ".vikingbot" / "history" / "cli_history"+ history_file = get_history_path() / "cli_history"history_file.parent.mkdir(parents=True, exist_ok=True)_PROMPT_SESSION = PromptSession(@@ -145,7 +149,7 @@ async def _read_interactive_input_async() -> str:try:with patch_stdout():return await _PROMPT_SESSION.prompt_async(- HTML("<b fg='ansiblue'>You:</b> "),+ HTML("<b fg='ansiblack'>You:</b> "),)except EOFError as exc:raise KeyboardInterrupt from exc@@ -165,15 +169,18 @@ def main(pass-def _make_provider(config):+def _make_provider(config, langfuse_client: None = None):"""Create LiteLLMProvider from config. Allows starting without API key."""from vikingbot.providers.litellm_provider import LiteLLMProvider- p = config.get_provider()- model = config.agents.defaults.model++ config = load_config()+ p = config.agents++ model = p.modelapi_key = p.api_key if p else None- api_base = config.get_api_base()- provider_name = config.get_provider_name()+ api_base = p.api_base if p else None+ provider_name = p.provider if p else Noneif not (api_key) and not model.startswith("bedrock/"):console.print("[yellow]Warning: No API key configured.[/yellow]")@@ -185,6 +192,7 @@ def _make_provider(config):default_model=model,extra_headers=p.extra_headers if p else None,provider_name=provider_name,+ # langfuse_client=langfuse_client,)@@ -195,14 +203,17 @@ def _make_provider(config):@app.command()def gateway(- port: int = typer.Option(18790, "--port", "-p", help="Gateway port"),- console_port: int = typer.Option(18791, "--console-port", help="Console web UI port"),+ port: int = typer.Option(18791, "--port", "-p", help="Gateway port"),+ # console_port: int = typer.Option(18791, "--console-port", help="Console web UI port"),enable_console: bool = typer.Option(True, "--console/--no-console", help="Enable console web UI"),+ agent: bool = typer.Option(+ True, "--agent/--no-agent", help="Enable agent loop for OpenAPI/chat"+ ),verbose: bool = typer.Option(False, "--verbose", "-v", help="Verbose output"),):- """Start the vikingbot gateway."""+ """Start the vikingbot gateway with OpenAPI chat enabled by default."""if verbose:import logging@@ -211,51 +222,103 @@ def gateway(bus = MessageBus()config = ensure_config()- session_manager = SessionManager(config.workspace_path)+ _init_bot_data(config)+ session_manager = SessionManager(config.bot_data_path)++ # Create FastAPI app for OpenAPI+ from fastapi import FastAPI+ fastapi_app = FastAPI(+ title="Vikingbot OpenAPI",+ description="HTTP API for Vikingbot chat",+ version="1.0.0",+ )cron = prepare_cron(bus)- channels = prepare_channel(config, bus)+ channels = prepare_channel(config, bus, fastapi_app=fastapi_app, enable_openapi=True, openapi_port=port)agent_loop = prepare_agent_loop(config, bus, session_manager, cron)heartbeat = prepare_heartbeat(config, agent_loop, session_manager)async def run():+ import uvicorn++ # Setup OpenAPI routes before starting+ openapi_channel = None+ for name, channel in channels.channels.items():+ if hasattr(channel, 'name') and channel.name == "openapi":+ openapi_channel = channel+ break++ if openapi_channel is not None and hasattr(openapi_channel, '_setup_routes'):+ openapi_channel._setup_routes()+ logger.info("OpenAPI routes registered")++ # Start uvicorn server for OpenAPI+ config_uvicorn = uvicorn.Config(+ fastapi_app,+ host="0.0.0.0",+ port=port,+ log_level="info",+ )+ server = uvicorn.Server(config_uvicorn)+tasks = []tasks.append(cron.start())tasks.append(heartbeat.start())tasks.append(channels.start_all())tasks.append(agent_loop.run())- if enable_console:- tasks.append(start_console(console_port))+ tasks.append(server.serve()) # Start HTTP server+ # if enable_console:+ # tasks.append(start_console(console_port))await asyncio.gather(*tasks)asyncio.run(run())-def prepare_agent_loop(config, bus, session_manager, cron):- sandbox_parent_path = config.workspace_path+def prepare_agent_loop(config, bus, session_manager, cron, quiet: bool = False, eval: bool = False):+ sandbox_parent_path = config.bot_data_pathsource_workspace_path = get_source_workspace_path()sandbox_manager = SandboxManager(config, sandbox_parent_path, source_workspace_path)- console.print(- f"[green]✓[/green] Sandbox: enabled (backend={config.sandbox.backend}, mode={config.sandbox.mode})"- )- provider = _make_provider(config)+ if config.sandbox.backend == "direct":+ logger.warning("Sandbox: disabled (using DIRECT mode - commands run directly on host)")+ else:+ logger.info(f"Sandbox: enabled (backend={config.sandbox.backend}, mode={config.sandbox.mode})")++ # Initialize Langfuse if enabled+ langfuse_client = None+ # logger.info(f"[LANGFUSE] Config check: has langfuse attr={hasattr(config, 'langfuse')}")++ if hasattr(config, "langfuse") and config.langfuse.enabled:+ langfuse_client = LangfuseClient(+ enabled=config.langfuse.enabled,+ secret_key=config.langfuse.secret_key,+ public_key=config.langfuse.public_key,+ base_url=config.langfuse.base_url,+ )+ LangfuseClient.set_instance(langfuse_client)+ if langfuse_client.enabled:+ logger.info(f"Langfuse: enabled (base_url={config.langfuse.base_url})")+ else:+ logger.warning("Langfuse: configured but failed to initialize")++ provider = _make_provider(config, langfuse_client)# Create agent with cron serviceagent = AgentLoop(bus=bus,provider=provider,workspace=config.workspace_path,- model=config.agents.defaults.model,- max_iterations=config.agents.defaults.max_tool_iterations,- memory_window=config.agents.defaults.memory_window,+ model=config.agents.model,+ max_iterations=config.agents.max_tool_iterations,+ memory_window=config.agents.memory_window,brave_api_key=config.tools.web.search.api_key or None,exa_api_key=None,- gen_image_model=config.agents.defaults.gen_image_model,+ gen_image_model=config.agents.gen_image_model,exec_config=config.tools.exec,cron_service=cron,session_manager=session_manager,sandbox_manager=sandbox_manager,config=config,+ eval=eval)# Set the agent reference in cron if it uses the holder patternif hasattr(cron, '_agent_holder'):@@ -263,7 +326,7 @@ def prepare_agent_loop(config, bus, session_manager, cron):return agent-def prepare_cron(bus) -> CronService:+def prepare_cron(bus, quiet: bool = False) -> CronService:# Create cron service first (callback set after agent creation)cron_store_path = get_data_dir() / "cron" / "jobs.json"cron = CronService(cron_store_path)@@ -314,15 +377,42 @@ Reminder message to deliver:cron._agent_holder = agent_holdercron_status = cron.status()- if cron_status["jobs"] > 0:- console.print(f"[green]✓[/green] Cron: {cron_status['jobs']} scheduled jobs")+ if cron_status["jobs"] > 0 and not quiet:+ logger.info(f"Cron: {cron_status['jobs']} scheduled jobs")return cron-def prepare_channel(config, bus):+def prepare_channel(config, bus, fastapi_app=None, enable_openapi: bool = False, openapi_port: int = 18790):+ """Prepare channels for the bot.++ Args:+ config: Bot configuration+ bus: Message bus for communication+ fastapi_app: External FastAPI app to register OpenAPI routes on+ enable_openapi: Whether to enable OpenAPI channel for gateway mode+ openapi_port: Port for OpenAPI channel (default: 18790)+ """+ channels = ChannelManager(bus)+ channels.load_channels_from_config(config)++ # Enable OpenAPI channel for gateway mode if requested+ if enable_openapi and fastapi_app is not None:+ from vikingbot.channels.openapi import OpenAPIChannel, OpenAPIChannelConfig++ openapi_config = OpenAPIChannelConfig(+ enabled=True,+ port=openapi_port,+ api_key="", # No auth required by default+ )+ openapi_channel = OpenAPIChannel(+ openapi_config,+ bus,+ app=fastapi_app, # Pass the external FastAPI app+ )+ channels.add_channel(openapi_channel)+ logger.info(f"OpenAPI channel enabled on port {openapi_port}")- channels = ChannelManager(config, bus)if channels.enabled_channels:console.print(f"[green]✓[/green] Channels enabled: {', '.join(channels.enabled_channels)}")else:@@ -357,20 +447,22 @@ def prepare_heartbeat(config, agent_loop, session_manager) -> HeartbeatService:async def start_console(console_port):+ """Start the console web UI in a separate thread within the same process."""try:- import subprocess- import sys- import os-- def start_gradio():- script_path = os.path.join(- os.path.dirname(__file__), "..", "console", "console_gradio_simple.py"- )- subprocess.Popen([sys.executable, script_path, str(console_port)])-- start_gradio()+ import threading+ from vikingbot.console.console_gradio_simple import run_console_server++ def run_in_thread():+ try:+ run_console_server(console_port)+ except Exception as e:+ console.print(f"[yellow]Console server error: {e}[/yellow]")++ thread = threading.Thread(target=run_in_thread, daemon=True)+ thread.start()+ console.print(f"[green]✓[/green] Console: http://localhost:{console_port}")except Exception as e:- console.print(f"[yellow]Warning: Gradio not available ({e})[/yellow]")+ console.print(f"[yellow]Warning: Console not available ({e})[/yellow]")# ============================================================================@@ -378,92 +470,134 @@ async def start_console(console_port):# ============================================================================+# Helper for thinking spinner context+def _thinking_ctx(logs: bool):+ """Return a context manager for showing thinking spinner."""+ if logs:+ from contextlib import nullcontext+ return nullcontext()+ return console.status("[dim]vikingbot is thinking...[/dim]", spinner="dots")+++def prepare_agent_channel(config, bus, mode: str, message: str | None, session_id: str, markdown: bool, logs: bool, eval: bool = False):+ """Prepare channel for agent command."""+ from vikingbot.channels.chat import ChatChannel, ChatChannelConfig+ from vikingbot.channels.stdio import StdioChannel, StdioChannelConfig+ from vikingbot.channels.single_turn import SingleTurnChannel, SingleTurnChannelConfig++ channels = ChannelManager(bus)++ if mode == "stdio":+ channel_config = StdioChannelConfig()+ channel = StdioChannel(+ channel_config,+ bus,+ workspace_path=config.workspace_path,+ )+ channels.add_channel(channel)+ elif message is not None:+ # Single message mode - use SingleTurnChannel for clean output+ channel_config = SingleTurnChannelConfig()+ channel = SingleTurnChannel(+ channel_config,+ bus,+ workspace_path=config.workspace_path,+ message=message,+ session_id=session_id,+ markdown=markdown,+ eval=eval,+ )+ channels.add_channel(channel)+ else:+ # Interactive mode - use ChatChannel with thinking display+ channel_config = ChatChannelConfig()+ channel = ChatChannel(+ channel_config,+ bus,+ workspace_path=config.workspace_path,+ session_id=session_id,+ markdown=markdown,+ logs=logs,+ )+ channels.add_channel(channel)++ return channels++@app.command()-def agent(+def chat(message: str = typer.Option(None, "--message", "-m", help="Message to send to the agent"),- session_id: str = typer.Option("cli__default__direct", "--session", "-s", help="Session ID"),+ session_id: str = typer.Option(None, "--session", "-s", help="Session ID"),markdown: bool = typer.Option(True, "--markdown/--no-markdown", help="Render assistant output as Markdown"),logs: bool = typer.Option(False, "--logs/--no-logs", help="Show vikingbot runtime logs during chat"),+ mode: str = typer.Option(+ "direct", "--mode", help="Mode: direct (interactive), stdio (JSON IPC)"+ ),+ eval: bool = typer.Option(+ False, "--eval", "-e", help="Run evaluation mode, output JSON results"+ ),):"""Interact with the agent directly."""- if logs:+ if message is not None:+ # Single-turn mode: only show error logs+ logger.remove()+ logger.add(sys.stderr, level="ERROR")+ elif logs:logger.enable("vikingbot")else:logger.disable("vikingbot")- session_key = SessionKey.from_safe_name(session_id)-bus = MessageBus()config = ensure_config()- session_manager = SessionManager(config.workspace_path)+ _init_bot_data(config)+ session_manager = SessionManager(config.bot_data_path)- cron = prepare_cron(bus)- agent_loop = prepare_agent_loop(config, bus, session_manager, cron)+ is_single_turn = message is not None+ # Use unified default session ID+ if session_id is None:+ session_id = "cli__chat__default"+ cron = prepare_cron(bus, quiet=is_single_turn)+ channels = prepare_agent_channel(config, bus, mode, message, session_id, markdown, logs, eval)+ agent_loop = prepare_agent_loop(config, bus, session_manager, cron, quiet=is_single_turn, eval=eval)- # Show spinner when logs are off (no output to miss); skip when logs are on- def _thinking_ctx():- if logs:- from contextlib import nullcontext+ async def run():+ if is_single_turn:+ # Single-turn mode: run channels and agent, exit after response+ task_cron = asyncio.create_task(cron.start())+ task_channels = asyncio.create_task(channels.start_all())+ task_agent = asyncio.create_task(agent_loop.run())++ # Wait for channels to complete (it will complete after getting response)+ done, pending = await asyncio.wait(+ [task_channels],+ return_when=asyncio.FIRST_COMPLETED+ )- return nullcontext()- # Animated spinner is safe to use with prompt_toolkit input handling- return console.status("[dim]vikingbot is thinking...[/dim]", spinner="dots")+ # Cancel all other tasks+ for task in pending:+ task.cancel()+ task_cron.cancel()+ task_agent.cancel()- if message:- # Single message mode- async def run_once():- with _thinking_ctx():- response = await agent_loop.process_direct(message, session_key=session_key)- _print_agent_response(response, render_markdown=markdown)+ # Wait for cancellation+ await asyncio.gather(task_cron, task_agent, return_exceptions=True)+ else:+ # Interactive mode: run forever+ tasks = []+ tasks.append(cron.start())+ tasks.append(channels.start_all())+ tasks.append(agent_loop.run())- asyncio.run(run_once())- else:- # Interactive mode- _init_prompt_session()- console.print(- f"{__logo__} Interactive mode (type [bold]exit[/bold] or [bold]Ctrl+C[/bold] to quit)\n"- )+ await asyncio.gather(*tasks)- def _exit_on_sigint(signum, frame):- _restore_terminal()- console.print("\nGoodbye!")- os._exit(0)-- signal.signal(signal.SIGINT, _exit_on_sigint)-- async def run_interactive():- while True:- try:- _flush_pending_tty_input()- user_input = await _read_interactive_input_async()- command = user_input.strip()- if not command:- continue-- if _is_exit_command(command):- _restore_terminal()- console.print("\nGoodbye!")- break-- with _thinking_ctx():- response = await agent_loop.process_direct(- user_input, session_key=session_key- )- _print_agent_response(response, render_markdown=markdown)- except KeyboardInterrupt:- _restore_terminal()- console.print("\nGoodbye!")- break- except EOFError:- _restore_terminal()- console.print("\nGoodbye!")- break-- asyncio.run(run_interactive())+ try:+ asyncio.run(run())+ except KeyboardInterrupt:+ console.print("\nGoodbye!")# ============================================================================@@ -478,7 +612,6 @@ app.add_typer(channels_app, name="channels")@channels_app.command("status")def channels_status():"""Show channel status."""- from vikingbot.config.loader import load_configfrom vikingbot.config.schema import ChannelTypeconfig = load_config()@@ -525,7 +658,7 @@ def _get_bridge_dir() -> Path:import subprocess# User's bridge location- user_bridge = Path.home() / ".vikingbot" / "bridge"+ user_bridge = get_bridge_path()# Check if already builtif (user_bridge / "dist" / "index.js").exists():@@ -548,7 +681,7 @@ def _get_bridge_dir() -> Path:if not source:console.print("[red]Bridge source not found.[/red]")- console.print("Try reinstalling: pip install --force-reinstall vikingbot")+ console.print("Try reinstalling: uv pip install --force-reinstall vikingbot")raise typer.Exit(1)console.print(f"{__logo__} Setting up bridge...")@@ -581,7 +714,7 @@ def _get_bridge_dir() -> Path:def channels_login():"""Link device via QR code."""import subprocess- from vikingbot.config.loader import load_config+from vikingbot.config.schema import ChannelTypeconfig = load_config()@@ -763,7 +896,7 @@ def cron_run(return await service.run_job(job_id, force=force)if asyncio.run(run()):- console.print(f"[green]✓[/green] Job executed")+ console.print("[green]✓[/green] Job executed")else:console.print(f"[red]Failed to run job {job_id}[/red]")@@ -776,7 +909,6 @@ def cron_run(@app.command()def status():"""Show vikingbot status."""- from vikingbot.config.loader import load_config, get_config_pathconfig_path = get_config_path()config = load_config()@@ -794,7 +926,7 @@ def status():if config_path.exists():from vikingbot.providers.registry import PROVIDERS- console.print(f"Model: {config.agents.defaults.model}")+ console.print(f"Model: {config.agents.model}")# Check API keys from registryfor spec in PROVIDERS:@@ -814,34 +946,16 @@ def status():)-def tui(- console_port: int = typer.Option(18791, "--console-port", help="Console web UI port"),- enable_console: bool = typer.Option(- True, "--console/--no-console", help="Enable console web UI"- ),-):- """Launch vikingbot TUI interface interface."""- """Interact with the agent directly."""- logger.enable("vikingbot")- if enable_console:- console.print(f"[green]✓[/green] Console: http://localhost:{console_port} ")-- bus = MessageBus()- config = ensure_config()- session_manager = SessionManager(config.workspace_path)-- cron = prepare_cron(bus)- agent_loop = prepare_agent_loop(config, bus, session_manager, cron)-- async def run():- tasks = []- from vikingbot.tui.app import run_tui-- tasks.append(run_tui(agent_loop, bus, config))- await asyncio.gather(*tasks)+# ============================================================================+# Test Commands+# ============================================================================- asyncio.run(run())+try:+ from vikingbot.cli.test_commands import test_app+ app.add_typer(test_app, name="test")+except ImportError:+ # If test commands not available, don't add them+ passif __name__ == "__main__":diff --git a/bot/vikingbot/config/loader.py b/bot/vikingbot/config/loader.pyindex 25c464f5e..4a17e76af 100644--- a/bot/vikingbot/config/loader.py+++ b/bot/vikingbot/config/loader.py@@ -1,6 +1,7 @@"""Configuration loading utilities."""import json+import osfrom pathlib import Pathfrom typing import Anyfrom loguru import logger@@ -8,8 +9,26 @@ from vikingbot.config.schema import Configdef get_config_path() -> Path:- """Get the default configuration file path."""- return Path.home() / ".vikingbot" / "config.json"+ """Get the path to ov.conf config file.++ Resolution order:+ 1. OPENVIKING_CONFIG_FILE environment variable+ 2. ~/.openviking/ov.conf+ """+ return _resolve_ov_conf_path()+++def _resolve_ov_conf_path() -> Path:+ """Resolve the ov.conf file path."""+ # Check environment variable first+ env_path = os.environ.get("OPENVIKING_CONFIG_FILE")+ if env_path:+ path = Path(env_path).expanduser()+ if path.exists():+ return path++ # Default path+ return Path.home() / ".openviking" / "ov.conf"def get_data_dir() -> Path:@@ -20,23 +39,30 @@ def get_data_dir() -> Path:def ensure_config():+ """Ensure ov.conf exists, create with default bot config if not."""config_path = get_config_path()+if not config_path.exists():logger.info("Config not found, creating default config...")- config = Config()- save_config(config)+ # Create directory if needed+ config_path.parent.mkdir(parents=True, exist_ok=True)++ # Create default config with empty bot section+ default_config = Config()+ save_config(default_config, config_path)logger.info(f"[green]✓[/green] Created default config at {config_path}")+config = load_config(config_path)return configdef load_config(config_path: Path | None = None) -> Config:"""- Load configuration from file or create default.+ Load configuration from ov.conf's bot field, and merge vlm config for model.Args:- config_path: Optional path to config file. Uses default if not provided.+ config_path: Optional path to ov.conf file. Uses default if not provided.Returns:Loaded configuration object.@@ -46,9 +72,32 @@ def load_config(config_path: Path | None = None) -> Config:if path.exists():try:with open(path) as f:- data = json.load(f)- data = _migrate_config(data)- return Config.model_validate(convert_keys(data))+ full_data = json.load(f)++ # Extract bot section+ bot_data = full_data.get("bot", {})+ bot_data = convert_keys(bot_data)++ # Extract storage.workspace from root level, default to ~/.openviking_data+ storage_data = full_data.get("storage", {})+ if isinstance(storage_data, dict) and "workspace" in storage_data:+ bot_data["storage_workspace"] = storage_data["workspace"]+ else:+ bot_data["storage_workspace"] = "~/.openviking/data"++ # Extract and merge vlm config for model settings only+ # Provider config is directly read from OpenVikingConfig at runtime+ vlm_data = full_data.get("vlm", {})+ vlm_data = convert_keys(vlm_data)+ if vlm_data:+ _merge_vlm_model_config(bot_data, vlm_data)++ bot_server_data = bot_data.get("ov_server", {})+ ov_server_data = full_data.get("server", {})+ _merge_ov_server_config(bot_server_data, ov_server_data)+ bot_data["ov_server"] = bot_server_data++ return Config.model_validate(bot_data)except (json.JSONDecodeError, ValueError) as e:print(f"Warning: Failed to load config from {path}: {e}")print("Using default configuration.")@@ -56,45 +105,71 @@ def load_config(config_path: Path | None = None) -> Config:return Config()+def _merge_vlm_model_config(bot_data: dict, vlm_data: dict) -> None:+ """+ Merge vlm model config into bot config.++ Only sets model - provider config is read directly from OpenVikingConfig.+ """+ # Set default model from vlm.model+ if vlm_data.get("model"):+ if "agents" not in bot_data:+ bot_data["agents"] = {}+ # Prepend provider prefix if provider is specified+ model = vlm_data["model"]+ provider = vlm_data.get("provider")+ if provider and "/" not in model:+ model = f"{provider}/{model}"+ bot_data["agents"]["model"] = model+ bot_data["agents"]["provider"] = provider if provider else ""+ bot_data["agents"]["api_base"] = vlm_data.get("api_base", "")+ bot_data["agents"]["api_key"] = vlm_data.get("api_key", "")++def _merge_ov_server_config(bot_data: dict, ov_data: dict) -> None:+ """+ Merge ov_server config into bot config.+ """+ if "server_url" not in bot_data or not bot_data["server_url"]:+ host = ov_data.get("host", "127.0.0.1")+ port = ov_data.get("port", "1933")+ bot_data["server_url"] = f"http://{host}:{port}"+ if "root_api_key" not in bot_data or not bot_data["root_api_key"]:+ bot_data["root_api_key"] = ov_data.get("root_api_key", "")+ if "root_api_key" in ov_data and ov_data["root_api_key"]:+ bot_data["mode"] = "remote"+ else:+ bot_data["mode"] = "local"+def save_config(config: Config, config_path: Path | None = None) -> None:"""- Save configuration to file.+ Save configuration to ov.conf's bot field, preserving other sections.Args:config: Configuration to save.- config_path: Optional path to save to. Uses default if not provided.+ config_path: Optional path to ov.conf file. Uses default if not provided."""path = config_path or get_config_path()path.parent.mkdir(parents=True, exist_ok=True)- data = config.model_dump()- data = convert_to_camel(data)-+ # Read existing config if it exists+ full_data = {}+ if path.exists():+ try:+ with open(path) as f:+ full_data = json.load(f)+ except (json.JSONDecodeError, IOError):+ pass++ # Update bot section - only save fields that were explicitly set+ bot_data = config.model_dump(exclude_unset=True)+ if bot_data:+ full_data["bot"] = convert_to_camel(bot_data)+ else:+ full_data.pop("bot", None)++ # Write back full configwith open(path, "w") as f:- json.dump(data, f, indent=2)---def _migrate_config(data: dict) -> dict:- """Migrate old config formats to current."""- # Move sandbox.network/filesystem/runtime to sandbox.backends.srt if they exist- if "sandbox" in data:- sandbox = data["sandbox"]- # Initialize backends if not present- if "backends" not in sandbox:- sandbox["backends"] = {}- if "srt" not in sandbox["backends"]:- sandbox["backends"]["srt"] = {}- srt_backend = sandbox["backends"]["srt"]- # Move network- if "network" in sandbox:- srt_backend["network"] = sandbox.pop("network")- # Move filesystem- if "filesystem" in sandbox:- srt_backend["filesystem"] = sandbox.pop("filesystem")- # Move runtime- if "runtime" in sandbox:- srt_backend["runtime"] = sandbox.pop("runtime")- return data+ json.dump(full_data, f, indent=2)def convert_keys(data: Any) -> Any:diff --git a/bot/vikingbot/config/schema.py b/bot/vikingbot/config/schema.pyindex 6a517c70c..4bd1e10a3 100644--- a/bot/vikingbot/config/schema.py+++ b/bot/vikingbot/config/schema.py@@ -2,8 +2,9 @@from enum import Enumfrom pathlib import Path-from typing import Union, Any-from pydantic import BaseModel, Field, ConfigDict+from typing import Any, Dict, Optional++from pydantic import BaseModel, ConfigDict, Fieldfrom pydantic_settings import BaseSettings, SettingsConfigDict@@ -19,6 +20,7 @@ class ChannelType(str, Enum):EMAIL = "email"SLACK = "slack"QQ = "qq"+ OPENAPI = "openapi"class SandboxBackend(str, Enum):@@ -41,11 +43,14 @@ class SandboxMode(str, Enum):class BaseChannelConfig(BaseModel):"""Base channel configuration."""- type: ChannelType+ type: Any = ChannelType.TELEGRAM # Default for backwards compatibilityenabled: bool = Truedef channel_id(self) -> str:- raise "default"+ return "default"++ def channel_key(self):+ return f"{getattr(self.type, 'value', self.type)}__{self.channel_id()}"# ========== Channel helper configs ==========@@ -95,7 +100,7 @@ class FeishuChannelConfig(BaseChannelConfig):app_secret: str = ""encrypt_key: str = ""verification_token: str = ""- allow_from: list[str] = Field(default_factory=list)+ allow_from: list[str] = Field(default_factory=list) ## 允许更新Agent对话的Feishu用户ID列表def channel_id(self) -> str:# Use app_id directly as the ID@@ -237,6 +242,19 @@ class QQChannelConfig(BaseChannelConfig):return self.app_id+class OpenAPIChannelConfig(BaseChannelConfig):+ """OpenAPI channel configuration for HTTP-based chat API."""++ type: ChannelType = ChannelType.OPENAPI+ enabled: bool = True+ api_key: str = "" # If empty, no auth required+ allow_from: list[str] = Field(default_factory=list)+ max_concurrent_requests: int = 100++ def channel_id(self) -> str:+ return "openapi"++class ChannelsConfig(BaseModel):"""Configuration for chat channels - array of channel configs."""@@ -334,6 +352,8 @@ class ChannelsConfig(BaseModel):return SlackChannelConfig(**config)elif channel_type == ChannelType.QQ:return QQChannelConfig(**config)+ elif channel_type == ChannelType.OPENAPI:+ return OpenAPIChannelConfig(**config)else:return BaseChannelConfig(**config)@@ -348,22 +368,17 @@ class ChannelsConfig(BaseModel):return result-class AgentDefaults(BaseModel):- """Default agent configuration."""+class AgentsConfig(BaseModel):+ """Agent configuration."""- workspace: str = "~/.vikingbot/workspace"model: str = "openai/doubao-seed-2-0-pro-260215"- max_tokens: int = 8192- temperature: float = 0.7max_tool_iterations: int = 50memory_window: int = 50gen_image_model: str = "openai/doubao-seedream-4-5-251128"---class AgentsConfig(BaseModel):- """Agent configuration."""-- defaults: AgentDefaults = Field(default_factory=AgentDefaults)+ provider: str = ""+ api_key: str = ""+ api_base: str = ""+ extra_headers: dict[str, str] = Noneclass ProviderConfig(BaseModel):@@ -418,10 +433,12 @@ class WebSearchConfig(BaseModel):class OpenVikingConfig(BaseModel):"""Viking tools configuration."""- mode: str = "local" # local or remote+ mode: str = "remote" # local or remoteserver_url: str = ""- user_id: str = ""- api_key: str = ""+ root_api_key: str = ""+ account_id: str = "default"+ admin_user_id: str = "default"+ agent_id: str = ""class WebToolsConfig(BaseModel):@@ -543,6 +560,15 @@ class SandboxBackendsConfig(BaseModel):aiosandbox: AioSandboxBackendConfig = Field(default_factory=AioSandboxBackendConfig)+class LangfuseConfig(BaseModel):+ """Langfuse observability configuration."""++ enabled: bool = False+ secret_key: str = "sk-lf-vikingbot-secret-key-2026"+ public_key: str = "pk-lf-vikingbot-public-key-2026"+ base_url: str = "http://localhost:3000"++class SandboxConfig(BaseModel):"""Sandbox configuration."""@@ -556,12 +582,13 @@ class Config(BaseSettings):agents: AgentsConfig = Field(default_factory=AgentsConfig)channels: list[Any] = Field(default_factory=list)- providers: ProvidersConfig = Field(default_factory=ProvidersConfig)+ providers: ProvidersConfig = Field(default_factory=ProvidersConfig, deprecated=True) # Deprecated: Use ov.conf vlm config insteadgateway: GatewayConfig = Field(default_factory=GatewayConfig)tools: ToolsConfig = Field(default_factory=ToolsConfig)- openviking: OpenVikingConfig = Field(default_factory=OpenVikingConfig)+ ov_server: OpenVikingConfig = Field(default_factory=OpenVikingConfig)sandbox: SandboxConfig = Field(default_factory=SandboxConfig)heartbeat: HeartbeatConfig = Field(default_factory=HeartbeatConfig)+ langfuse: LangfuseConfig = Field(default_factory=LangfuseConfig)hooks: list[str] = Field(["vikingbot.hooks.builtins.openviking_hooks.hooks"])skills: list[str] = Field(default_factory=lambda: [@@ -575,6 +602,8 @@ class Config(BaseSettings):"summarize",])+ storage_workspace: str | None = None # From ov.conf root level storage.workspace+ use_local_memory: bool = False@propertydef channels_config(self) -> ChannelsConfig:@@ -583,30 +612,61 @@ class Config(BaseSettings):config.channels = self.channelsreturn config+ @property+ def bot_data_path(self) -> Path:+ """Get expanded bot data path: {storage_workspace}/bot."""+ return Path(self.storage_workspace).expanduser() / "bot"+@propertydef workspace_path(self) -> Path:- """Get expanded workspace path."""- return Path(self.agents.defaults.workspace).expanduser()+ """Get expanded workspace path: {storage_workspace}/bot/workspace."""+ return self.bot_data_path / "workspace"++ @property+ def ov_data_path(self) -> Path:+ return self.bot_data_path / "ov_data"++ def _get_vlm_config(self) -> Optional[Dict[str, Any]]:+ """Get vlm config from OpenVikingConfig. Returns (vlm_config_dict)."""+ from openviking_cli.utils.config import get_openviking_config+ ov_config = get_openviking_config()++ if hasattr(ov_config, "vlm"):+ return ov_config.vlm.model_dump()+ return Nonedef _match_provider(self, model: str | None = None) -> tuple["ProviderConfig | None", str | None]:- """Match provider config and its registry name. Returns (config, spec_name)."""- from vikingbot.providers.registry import PROVIDERS-- model_lower = (model or self.agents.defaults.model).lower()-- # Match by keyword (order follows PROVIDERS registry)- for spec in PROVIDERS:- p = getattr(self.providers, spec.name, None)- if p and any(kw in model_lower for kw in spec.keywords) and p.api_key:- return p, spec.name-- # Fallback: gateways first, then others (follows registry order)- for spec in PROVIDERS:- p = getattr(self.providers, spec.name, None)- if p and p.api_key:- return p, spec.name+ """Match provider config from ov.conf vlm section. Returns (config, spec_name)."""+ # Get from OpenVikingConfig vlm+ vlm_config = self._get_vlm_config()++ if vlm_config:+ provider_name = vlm_config.get("provider")+ if provider_name:+ # Build provider config from vlm+ provider_config = ProviderConfig()++ # Try to get from vlm.providers first+ if "providers" in vlm_config and provider_name in vlm_config["providers"]:+ p_data = vlm_config["providers"][provider_name]+ if "api_key" in p_data:+ provider_config.api_key = p_data["api_key"]+ if "api_base" in p_data:+ provider_config.api_base = p_data["api_base"]+ if "extra_headers" in p_data:+ provider_config.extra_headers = p_data["extra_headers"]+ else:+ # Fall back to top-level vlm fields+ if vlm_config.get("api_key"):+ provider_config.api_key = vlm_config["api_key"]+ if vlm_config.get("api_base"):+ provider_config.api_base = vlm_config["api_base"]++ if provider_config.api_key:+ return provider_config, provider_name+return None, Nonedef get_provider(self, model: str | None = None) -> ProviderConfig | None:@@ -631,9 +691,6 @@ class Config(BaseSettings):p, name = self._match_provider(model)if p and p.api_base:return p.api_base- # Only gateways get a default api_base here. Standard providers- # (like Moonshot) set their base URL via env vars in _setup_env- # to avoid polluting the global litellm.api_base.if name:spec = find_by_name(name)if spec and spec.is_gateway and spec.default_api_base:diff --git a/bot/vikingbot/console/console_gradio_simple.py b/bot/vikingbot/console/web_console.pysimilarity index 92%rename from bot/vikingbot/console/console_gradio_simple.pyrename to bot/vikingbot/console/web_console.pyindex ef39c2c77..4617dfaef 100644--- a/bot/vikingbot/console/console_gradio_simple.py+++ b/bot/vikingbot/console/web_console.py@@ -6,7 +6,7 @@ from typing import Any, Dict, List, Optional, Tupleimport gradio as gr-from vikingbot.config.loader import load_config, save_config+from vikingbot.config.loader import load_config, save_config, get_config_pathfrom vikingbot.config.schema import Config, ChannelType, SandboxBackend, SandboxMode@@ -38,7 +38,7 @@ def create_dashboard_tab():|--------|-------|| 🟢 Status | Running || 📦 Version | {__version__} |- | 📁 Config Path | {str(config.workspace_path.parent / "config.json")} |+ | 📁 Config Path | {str(get_config_path())} || 🖥️ Workspace Path | {str(config.workspace_path)} |""")@@ -299,7 +299,8 @@ def create_sessions_tab():status_msg = gr.Markdown("")def refresh_sessions():- sessions_dir = Path.home() / ".vikingbot" / "sessions"+ config = load_config()+ sessions_dir = config.bot_data_path / "sessions"if not sessions_dir.exists():return gr.Dropdown(choices=[], value=None), ""session_files = list(sessions_dir.glob("*.jsonl")) + list(sessions_dir.glob("*.json"))@@ -309,7 +310,8 @@ def create_sessions_tab():def load_session(session_name):if not session_name:return "", "Please select a session"- sessions_dir = Path.home() / ".vikingbot" / "sessions"+ config = load_config()+ sessions_dir = config.bot_data_path / "sessions"session_file_jsonl = sessions_dir / f"{session_name}.jsonl"session_file_json = sessions_dir / f"{session_name}.json"@@ -403,17 +405,10 @@ with gr.Blocks(title="Vikingbot Console") as demo:create_workspace_tab()-if __name__ == "__main__":- import uvicorn+def create_console_app(bus=None, config=None):+ """Create and return the FastAPI app with Gradio mounted."""from fastapi import FastAPI- port = 18791- if len(sys.argv) > 1:- try:- port = int(sys.argv[1])- except ValueError:- pass-# Create FastAPI app for health endpointapp = FastAPI()@@ -424,9 +419,42 @@ if __name__ == "__main__":return {"status": "healthy", "version": __version__}+ # Mount OpenAPI router if bus and config are provided+ if bus is not None and config is not None:+ try:+ from vikingbot.channels.openapi import get_openapi_router++ openapi_router = get_openapi_router(bus, config)+ app.include_router(+ openapi_router,+ prefix="/api/v1/openapi",+ tags=["openapi"],+ )+ except Exception as e:+ import logging++ logging.getLogger(__name__).warning(f"Failed to mount OpenAPI router: {e}")+# Mount Gradio appdemo.queue()app = gr.mount_gradio_app(app, demo, path="/")- # Launch with uvicorn- uvicorn.run(app, host="0.0.0.0", port=port)+ return app+++def run_console_server(port: int = 18791):+ """Run the console server in the current thread."""+ import uvicorn++ app = create_console_app()+ uvicorn.run(app, host="0.0.0.0", port=port, log_level="warning")+++if __name__ == "__main__":+ port = 18791+ if len(sys.argv) > 1:+ try:+ port = int(sys.argv[1])+ except ValueError:+ pass+ run_console_server(port)diff --git a/bot/vikingbot/hooks/base.py b/bot/vikingbot/hooks/base.pyindex ed7705b86..4d9e8c684 100644--- a/bot/vikingbot/hooks/base.py+++ b/bot/vikingbot/hooks/base.py@@ -4,6 +4,8 @@ from dataclasses import dataclassfrom typing import Any, Dict, Optionalfrom datetime import datetime+from vikingbot.config.schema import SessionKey+# class HookType(Enum):# SYNC = "sync"@@ -16,7 +18,8 @@ class HookContext:event_type: strsession_id: Optional[str] = None# 沙箱唯一主键- sandbox_key: Optional[str] = None+ workspace_id: Optional[str] = None+ session_key: SessionKey = Nonemetadata: Dict[str, Any] = Nonetimestamp: datetime = Nonediff --git a/bot/vikingbot/hooks/builtins/openviking_hooks.py b/bot/vikingbot/hooks/builtins/openviking_hooks.pyindex ce201f9ce..3e3daded2 100644--- a/bot/vikingbot/hooks/builtins/openviking_hooks.py+++ b/bot/vikingbot/hooks/builtins/openviking_hooks.py@@ -8,6 +8,7 @@ from ..base import Hook, HookContextfrom ...session import Sessionfrom vikingbot.config.loader import load_config+from vikingbot.config.schema import SessionKeytry:from vikingbot.openviking_mount.ov_server import VikingClient@@ -26,18 +27,45 @@ class OpenVikingCompactHook(Hook):def __init__(self):self._client = None- async def _get_client(self, sandbox_key: str) -> VikingClient:+ async def _get_client(self, workspace_id: str) -> VikingClient:if not self._client:- client = await VikingClient.create(sandbox_key)+ client = await VikingClient.create(workspace_id)self._client = clientreturn self._client+ def _filter_messages_by_sender(self, messages: list[dict], allow_from: list[str]) -> list[dict]:+ """筛选出 sender_id 在 allow_from 列表中的消息"""+ if not allow_from:+ return []+ return [msg for msg in messages if msg.get("sender_id") in allow_from]++ def _get_channel_allow_from(self, session_key: SessionKey) -> list[str]:+ """根据 session_id 获取对应频道的 allow_from 配置"""+ config = load_config()+ if not session_key or not config.channels:+ return []++ # 查找对应类型的 channel config+ for channel_config in config.channels:+ if hasattr(channel_config, "type") and channel_config.type == session_key.channel_id:+ if hasattr(channel_config, "allow_from"):+ return channel_config.allow_from+ return []+async def execute(self, context: HookContext, **kwargs) -> Any:vikingbot_session: Session = kwargs.get("session", {})- session_id = context.session_id+ session_id = context.session_key.safe_name()+try:- client = await self._get_client(context.sandbox_key)- result = await client.commit(session_id, vikingbot_session.messages)+ allow_from = self._get_channel_allow_from(session_id)+ filtered_messages = self._filter_messages_by_sender(vikingbot_session.messages, allow_from)++ if not filtered_messages:+ logger.info(f"No messages to commit openviking for session {session_id} (allow_from filter applied)")+ return {"success": True, "message": "No messages matched allow_from filter"}++ client = await self._get_client(context.workspace_id)+ result = await client.commit(session_id, filtered_messages, load_config().ov_server.admin_user_id)return resultexcept Exception as e:logger.exception(f"Failed to add message to OpenViking: {e}")@@ -51,26 +79,26 @@ class OpenVikingPostCallHook(Hook):def __init__(self):self._client = None- async def _get_client(self, sandbox_key: str) -> VikingClient:+ async def _get_client(self, workspace_id: str) -> VikingClient:if not self._client:- client = await VikingClient.create(sandbox_key)+ client = await VikingClient.create(workspace_id)self._client = clientreturn self._client- async def _read_skill_memory(self, sandbox_key: str, skill_name: str) -> str:- ov_client = await self._get_client(sandbox_key)+ async def _read_skill_memory(self, workspace_id: str, skill_name: str) -> str:+ ov_client = await self._get_client(workspace_id)config = load_config()- openviking_config = config.openviking- if not skill_name or (not sandbox_key and openviking_config.mode != "local"):+ openviking_config = config.ov_server+ if not skill_name:return ""try:if openviking_config.mode == "local":skill_memory_uri = f"viking://agent/ffb1327b18bf/memories/skills/{skill_name}.md"else:+ agent_space_name = ov_client.get_agent_space_name(openviking_config.admin_user_id)skill_memory_uri = (- f"viking://agent/{ov_client.agent_space_name}/memories/skills/{skill_name}.md"+ f"viking://agent/{agent_space_name}/memories/skills/{skill_name}.md")- # logger.warning(f"skill_memory_uri={skill_memory_uri}")content = await ov_client.read_content(skill_memory_uri, level="read")# logger.warning(f"content={content}")return f"\n\n---\n## Skill Memory\n{content}" if content else ""@@ -86,7 +114,7 @@ class OpenVikingPostCallHook(Hook):skill_name = match.group(1).strip()# logger.debug(f"skill_name={skill_name}")- agent_space_name = context.sandbox_key+ agent_space_name = context.workspace_id# logger.debug(f"agent_space_name={agent_space_name}")skill_memory = await self._read_skill_memory(agent_space_name, skill_name)diff --git a/bot/vikingbot/integrations/__init__.py b/bot/vikingbot/integrations/__init__.pynew file mode 100644index 000000000..62567e3db--- /dev/null+++ b/bot/vikingbot/integrations/__init__.py@@ -0,0 +1,16 @@+"""Integrations with external services."""++from typing import TYPE_CHECKING++if TYPE_CHECKING:+ from vikingbot.integrations.langfuse import LangfuseClient++__all__ = ["LangfuseClient"]+++def __getattr__(name: str):+ if name == "LangfuseClient":+ from vikingbot.integrations.langfuse import LangfuseClient++ return LangfuseClient+ raise AttributeError(f"module {__name__!r} has no attribute {name!r}")diff --git a/bot/vikingbot/integrations/langfuse.py b/bot/vikingbot/integrations/langfuse.pynew file mode 100644index 000000000..cd6f8d2c1--- /dev/null+++ b/bot/vikingbot/integrations/langfuse.py@@ -0,0 +1,321 @@+"""Langfuse integration for LLM observability."""++from contextlib import contextmanager+from typing import Any, Generator++from loguru import logger++# Try to import langfuse - will be None if not installed+Langfuse = None+propagate_attributes = None++try:+ from langfuse import Langfuse+ from langfuse import propagate_attributes as _propagate_attributes+ propagate_attributes = _propagate_attributes+except ImportError:+ pass+++class LangfuseClient:+ """Wrapper for Langfuse client with optional support."""++ _instance: "LangfuseClient | None" = None++ def __init__(+ self,+ enabled: bool = False,+ secret_key: str = "",+ public_key: str = "",+ base_url: str = "https://cloud.langfuse.com",+ ):+ self._client = None+ self.enabled = enabled++ if not self.enabled:+ return++ if Langfuse is None:+ logger.warning("Langfuse not installed. Install with: uv pip install vikingbot[langfuse] (or uv pip install -e \".[langfuse]\" for local dev). Configure in ~/.openviking/ov.conf under bot.langfuse")+ self.enabled = False+ return++ if not secret_key:+ logger.warning("Langfuse enabled but no secret_key provided. Configure in ~/.openviking/ov.conf under bot.langfuse")+ self.enabled = False+ return++ try:+ self._client = Langfuse(+ secret_key=secret_key,+ public_key=public_key,+ host=base_url,+ )+ self._client.auth_check()+ except Exception as e:+ logger.warning(f"Langfuse initialized failed: {type(e).__name__}: {e}")+ self.enabled = False+ self._client = None++ @classmethod+ def get_instance(cls) -> "LangfuseClient":+ """Get the singleton instance."""+ if cls._instance is None:+ logger.warning("[LANGFUSE] No instance set, creating default (disabled) instance")+ cls._instance = LangfuseClient(enabled=False)+ return cls._instance++ @classmethod+ def set_instance(cls, instance: "LangfuseClient") -> None:+ """Set the singleton instance."""+ cls._instance = instance++ def flush(self) -> None:+ """Flush pending events to Langfuse."""+ if self.enabled and self._client:+ self._client.flush()++ @contextmanager+ def propagate_attributes(+ self,+ session_id: str | None = None,+ user_id: str | None = None,+ ) -> Generator[None, None, None]:+ """+ Propagate attributes (session_id, user_id) to all nested observations.++ Args:+ session_id: Optional session ID to associate with all nested observations+ user_id: Optional user ID to associate with all nested observations+ """+ if not self.enabled:+ logger.warning(f"[LANGFUSE] propagate_attributes skipped: Langfuse client not enabled")+ yield+ return+ if not self._client:+ logger.warning(f"[LANGFUSE] propagate_attributes skipped: Langfuse client not initialized")+ yield+ return++ try:+ propagate_kwargs = {}+ if session_id:+ propagate_kwargs["session_id"] = session_id+ if user_id:+ propagate_kwargs["user_id"] = user_id++ if not propagate_kwargs:+ yield+ return++ # Use module-level propagate_attributes from langfuse SDK v3+ global propagate_attributes+ if propagate_attributes is not None:+ logger.info(f"[LANGFUSE] Propagating attributes: {list(propagate_kwargs.keys())}")+ with propagate_attributes(**propagate_kwargs):+ yield+ else:+ logger.warning(f"[LANGFUSE] propagate_attributes not available (SDK version may not support it)")+ yield+ except Exception as e:+ logger.debug(f"[LANGFUSE] propagate_attributes error: {e}")+ yield++ @contextmanager+ def trace(+ self,+ name: str,+ session_id: str | None = None,+ user_id: str | None = None,+ metadata: dict[str, Any] | None = None,+ ) -> Generator[Any, None, None]:+ """+ Create a trace context manager.+ In v3 SDK, trace is implicitly created by first span/generation.+ """+ if not self.enabled or not self._client:+ yield None+ return++ try:+ # In v3, we use start_as_current_span to create the root span+ with self._client.start_as_current_span(+ name=name,+ session_id=session_id,+ user_id=user_id,+ metadata=metadata or {},+ ) as span:+ yield span+ except Exception as e:+ logger.debug(f"Langfuse trace error: {e}")+ yield None++ @contextmanager+ def span(+ self,+ name: str,+ trace_id: str | None = None,+ parent_observation_id: str | None = None,+ metadata: dict[str, Any] | None = None,+ ) -> Generator[Any, None, None]:+ """Create a span context manager."""+ if not self.enabled or not self._client:+ yield None+ return++ try:+ with self._client.start_as_current_span(+ name=name,+ metadata=metadata or {},+ ) as span:+ yield span+ except Exception as e:+ logger.debug(f"Langfuse span error: {e}")+ yield None++ @contextmanager+ def generation(+ self,+ name: str,+ model: str,+ trace_id: str | None = None,+ parent_observation_id: str | None = None,+ prompt: list[dict[str, Any]] | None = None,+ metadata: dict[str, Any] | None = None,+ ) -> Generator[Any, None, None]:+ """+ Create a generation context manager for LLM calls.++ Args:+ name: Name of the generation+ model: Model name+ trace_id: Optional trace ID (not used in v3)+ parent_observation_id: Optional parent observation ID (not used in v3)+ prompt: Optional prompt messages+ metadata: Optional metadata+ """+ if not self.enabled or not self._client:+ yield None+ return++ try:+ with self._client.start_as_current_generation(+ name=name,+ model=model,+ input=prompt,+ metadata=metadata or {},+ ) as generation:+ yield generation+ except Exception as e:+ logger.debug(f"Langfuse generation error: {e}")+ yield None++ def update_generation(+ self,+ generation: Any,+ output: str | None = None,+ usage: dict[str, int] | None = None,+ metadata: dict[str, Any] | None = None,+ ) -> None:+ """Update a generation with output and usage."""+ if not self.enabled or not generation:+ return++ try:+ update_kwargs: dict[str, Any] = {}+ if output is not None:+ update_kwargs["output"] = output+ if usage:+ update_kwargs["usage"] = {+ "prompt_tokens": usage.get("prompt_tokens", 0),+ "completion_tokens": usage.get("completion_tokens", 0),+ "total_tokens": usage.get("total_tokens", 0),+ }+ if metadata:+ if hasattr(generation, "metadata") and generation.metadata:+ update_kwargs["metadata"] = {**generation.metadata, **metadata}+ else:+ update_kwargs["metadata"] = metadata++ # In v3, update via the generation object's update method+ if hasattr(generation, "update"):+ generation.update(**update_kwargs)+ # Or use client's update_current_generation+ elif self._client and hasattr(self._client, "update_current_generation"):+ self._client.update_current_generation(**update_kwargs)++ except Exception as e:+ logger.debug(f"Langfuse update generation error: {e}")++ @contextmanager+ def tool_call(+ self,+ name: str,+ input: dict[str, Any] | None = None,+ session_id: str | None = None,+ metadata: dict[str, Any] | None = None,+ ) -> Generator[Any, None, None]:+ """+ Create a span for tool/function call execution.++ Args:+ name: Name of the tool/function+ input: Input arguments to the tool+ session_id: Optional session ID for tracing+ metadata: Optional metadata++ Yields:+ Langfuse span object or None if not enabled+ """+ if not self.enabled or not self._client:+ yield None+ return++ try:+ combined_metadata = metadata or {}+ if session_id:+ combined_metadata["session_id"] = session_id++ with self._client.start_as_current_span(+ name=f"tool:{name}",+ input=input,+ metadata=combined_metadata,+ ) as span:+ yield span+ except Exception as e:+ logger.debug(f"Langfuse tool call span error: {e}")+ yield None++ def end_tool_call(+ self,+ span: Any,+ output: str | None = None,+ success: bool = True,+ metadata: dict[str, Any] | None = None,+ ) -> None:+ """+ End a tool call span with output and status.++ Args:+ span: The span object from tool_call()+ output: Output of the tool call+ success: Whether the tool call succeeded+ metadata: Optional additional metadata+ """+ if not self.enabled or not span:+ return++ try:+ update_kwargs: dict[str, Any] = {}+ if output is not None:+ update_kwargs["output"] = output++ combined_metadata = metadata or {}+ combined_metadata["success"] = success+ update_kwargs["metadata"] = combined_metadata++ if hasattr(span, "update"):+ span.update(**update_kwargs)++ except Exception as e:+ logger.debug(f"Langfuse end tool call error: {e}")diff --git a/bot/vikingbot/openviking_mount/__init__.py b/bot/vikingbot/openviking_mount/__init__.pyindex deb924917..cbce294f1 100644--- a/bot/vikingbot/openviking_mount/__init__.py+++ b/bot/vikingbot/openviking_mount/__init__.py@@ -5,9 +5,10 @@ OpenViking Filesystem Mount Module让用户可以像操作普通文件一样操作OpenViking上的数据。"""+from typing import TYPE_CHECKING+from .mount import OpenVikingMount, MountScope, MountConfig, FileInfofrom .manager import OpenVikingMountManager, MountPoint, get_mount_manager-from .viking_fuse import OpenVikingFUSE, mount_fuse, FUSEMountManager, FUSE_AVAILABLEfrom .session_integration import SessionOpenVikingManager, get_session_ov_manager__all__ = [@@ -25,3 +26,14 @@ __all__ = ["SessionOpenVikingManager","get_session_ov_manager",]++if TYPE_CHECKING:+ from .viking_fuse import OpenVikingFUSE, mount_fuse, FUSEMountManager, FUSE_AVAILABLE+++def __getattr__(name: str):+ if name in ("OpenVikingFUSE", "mount_fuse", "FUSEMountManager", "FUSE_AVAILABLE"):+ from .viking_fuse import OpenVikingFUSE, mount_fuse, FUSEMountManager, FUSE_AVAILABLE++ return locals()[name]+ raise AttributeError(f"module {__name__!r} has no attribute {name!r}")diff --git a/bot/vikingbot/openviking_mount/ov_server.py b/bot/vikingbot/openviking_mount/ov_server.pyindex 51183fa74..1e40bbf61 100644--- a/bot/vikingbot/openviking_mount/ov_server.py+++ b/bot/vikingbot/openviking_mount/ov_server.py@@ -1,11 +1,13 @@import asyncioimport hashlib-from typing import Any, Dict, List, Optional+from typing import List, Dict, Any, Optional-import openviking as ovfrom loguru import logger+import time-from vikingbot.config.loader import get_data_dir, load_config+import openviking as ov+from vikingbot.config.loader import load_config+from vikingbot.openviking_mount.user_apikey_manager import UserApiKeyManagerviking_resource_prefix = "viking://resources/"@@ -13,34 +15,52 @@ viking_resource_prefix = "viking://resources/"class VikingClient:def __init__(self, agent_id: Optional[str] = None):config = load_config()- openviking_config = config.openviking+ openviking_config = config.ov_server+ self.openviking_config = openviking_config+ self.ov_path = config.ov_data_pathif openviking_config.mode == "local":- ov_data_path = get_data_dir() / "ov_data"- ov_data_path.mkdir(parents=True, exist_ok=True)- self.client = ov.AsyncOpenViking(path=str(ov_data_path))- self.user_id = "default"+ self.client = ov.AsyncHTTPClient(+ url=openviking_config.server_url+ )self.agent_id = "default"- self.agent_space_name = self.client.user.agent_space_name()+ self.account_id = "default"+ self.admin_user_id = "default"+ self._apikey_manager = Noneelse:self.client = ov.AsyncHTTPClient(url=openviking_config.server_url,- api_key=openviking_config.api_key,+ api_key=openviking_config.root_api_key,agent_id=agent_id,)self.agent_id = agent_id- self.user_id = openviking_config.user_id- self.agent_space_name = hashlib.md5(- (self.user_id + self.agent_id).encode()- ).hexdigest()[:12]+ self.account_id = openviking_config.account_id+ self.admin_user_id = openviking_config.admin_user_id+ self._apikey_manager = None+ if self.ov_path:+ self._apikey_manager = UserApiKeyManager(+ ov_path=self.ov_path,+ server_url=openviking_config.server_url,+ account_id=openviking_config.account_id,+ )self.mode = openviking_config.modeasync def _initialize(self):"""Initialize the client (must be called after construction)"""await self.client.initialize()+ # 检查并初始化 admin_user_id(如果配置了)+ if self.mode == "remote" and self.admin_user_id:+ user_exists = await self._check_user_exists(self.admin_user_id)+ if not user_exists:+ await self._initialize_user(self.admin_user_id, role="admin")+@classmethodasync def create(cls, agent_id: Optional[str] = None):- """Factory method to create and initialize a VikingClient instance"""+ """Factory method to create and initialize a VikingClient instance.++ Args:+ agent_id: The agent ID to use+ """instance = cls(agent_id)await instance._initialize()return instance@@ -70,6 +90,9 @@ class VikingClient:"reason": getattr(relation, "reason", ""),}+ def get_agent_space_name(self, user_id: str) -> str:+ return hashlib.md5((user_id + self.agent_id).encode()).hexdigest()[:12]+async def find(self, query: str, target_uri: Optional[str] = None):"""搜索资源"""if target_uri:@@ -114,6 +137,31 @@ class VikingClient:logger.warning(f"Failed to read content from {uri}: {e}")return ""+ async def read_user_profile(self, user_id: str) -> str:+ """读取用户 profile。++ 首先检查用户是否存在,如不存在则初始化用户并返回空字符串。+ 用户存在时,再查询 profile 信息。++ Args:+ user_id: 用户ID++ Returns:+ str: 用户 profile 内容,如果用户不存在或查询失败返回空字符串+ """+ # Step 1: 检查用户是否存在+ user_exists = await self._check_user_exists(user_id)++ # Step 2: 如果用户不存在,初始化用户并直接返回+ if not user_exists:+ await self._initialize_user(user_id)+ return ""++ # Step 3: 用户存在,查询 profile+ uri = f"viking://user/{user_id}/memories/profile.md"+ result = await self.read_content(uri=uri, level="read")+ return result+async def search(self, query: str, target_uri: Optional[str] = "") -> Dict[str, Any]:# session = self.client.session()@@ -135,8 +183,11 @@ class VikingClient:"target_uri": target_uri,}- async def search_user_memory(self, query: str) -> list[Any]:- uri_user_memory = f"viking://user/{self.user_id}/memories/"+ async def search_user_memory(self, query: str, user_id: str) -> list[Any]:+ user_exists = await self._check_user_exists(user_id)+ if not user_exists:+ return []+ uri_user_memory = f"viking://user/{user_id}/memories/"result = await self.client.search(query, target_uri=uri_user_memory)return ([self._matched_context_to_dict(m) for m in result.memories]@@ -144,15 +195,126 @@ class VikingClient:else [])- async def search_memory(self, query: str, limit: int = 10) -> dict[str, list[Any]]:- """通过上下文消息,检索viking 的user、Agent memory"""- uri_user_memory = f"viking://user/{self.user_id}/memories/"+ async def _check_user_exists(self, user_id: str) -> bool:+ """检查用户是否存在于账户中。++ Args:+ user_id: 用户ID++ Returns:+ bool: 用户是否存在+ """+ if self.mode == "local":+ return True+ try:+ res = await self.client.admin_list_users(self.account_id)+ if not res or len(res) == 0:+ return False+ return any(user.get("user_id") == user_id for user in res)+ except Exception as e:+ logger.warning(f"Failed to check user existence: {e}")+ return False++ async def _initialize_user(self, user_id: str, role: str = "user") -> bool:+ """初始化用户。++ Args:+ user_id: 用户ID++ Returns:+ bool: 初始化是否成功+ """+ if self.mode == "local":+ return True+ try:+ result = await self.client.admin_register_user(+ account_id=self.account_id, user_id=user_id, role=role+ )++ # Save the API key if returned and we're in remote mode with a valid apikey manager+ if self._apikey_manager and isinstance(result, dict):+ api_key = result.get("user_key")+ if api_key:+ self._apikey_manager.set_apikey(user_id, api_key)++ return True+ except Exception as e:+ if "User already exists" in str(e):+ return True+ logger.warning(f"Failed to initialize user {user_id}: {e}")+ return False++ async def _get_or_create_user_apikey(self, user_id: str) -> Optional[str]:+ """获取或创建用户的 API key。++ 优先从本地 json 文件获取,如果本地没有则:+ 1. 删除用户(如果存在)+ 2. 重新创建用户+ 3. 保存新的 API key++ Args:+ user_id: 用户ID++ Returns:+ API key 或 None(如果获取失败)+ """+ if not self._apikey_manager:+ return None++ # Step 1: Check local storage first+ api_key = self._apikey_manager.get_apikey(user_id)+ if api_key:+ return api_key++ try:+ # 2a. Remove user if exists+ user_exists = await self._check_user_exists(user_id)+ if user_exists:+ await self.client.admin_remove_user(self.account_id, user_id)+ # 2b. Recreate user - this will save API key in _initialize_user+ success = await self._initialize_user(user_id)+ if not success:+ logger.warning(f"Failed to recreate user {user_id}")+ return None++ # 2c. Get API key from local storage (it was saved by _initialize_user)+ api_key = self._apikey_manager.get_apikey(user_id)+ if api_key:+ return api_key+ else:+ return None++ except Exception as e:+ logger.error(f"Error getting or creating API key for user {user_id}: {e}")+ return None++ async def search_memory(+ self, query: str, user_id: str, limit: int = 10+ ) -> dict[str, list[Any]]:+ """通过上下文消息,检索viking 的user、Agent memory。++ 首先检查用户是否存在,如不存在则初始化用户并返回空结果。+ 用户存在时,再进行记忆检索。+ """+ # Step 1: 检查用户是否存在+ user_exists = await self._check_user_exists(user_id)++ # Step 2: 如果用户不存在,初始化用户并直接返回+ if not user_exists:+ await self._initialize_user(user_id)+ return {+ "user_memory": [],+ "agent_memory": [],+ }+ # Step 3: 用户存在,查询记忆+ uri_user_memory = f"viking://user/{user_id}/memories/"user_memory = await self.client.find(query=query,target_uri=uri_user_memory,limit=limit,)- uri_agent_memory = f"viking://agent/{self.agent_space_name}/memories/"+ agent_space_name = self.get_agent_space_name(user_id)+ uri_agent_memory = f"viking://agent/{agent_space_name}/memories/"agent_memory = await self.client.find(query=query,target_uri=uri_agent_memory,@@ -171,114 +333,101 @@ class VikingClient:"""通过 glob 模式匹配文件"""return await self.client.glob(pattern, uri=uri)- async def commit(self, session_id: str, messages: list[dict[str, Any]]):+ async def commit(self, session_id: str, messages: list[dict[str, Any]], user_id: str = None):"""提交会话"""import reimport uuid-from openviking.message.part import Part, TextPart, ToolPart- session = self.client.session(session_id)-- if self.mode == "local":- for message in messages:- # logger.debug(f"message === {message}")- role = message.get("role")- content = message.get("content")- tools_used = message.get("tools_used") or []-- parts: list[Part] = []-- if content:- parts.append(TextPart(text=content))-- for tool_info in tools_used:- tool_name = tool_info.get("tool_name", "")- # logger.debug(f"tool_name === {tool_name}")- if not tool_name:- continue-- tool_id = f"{tool_name}_{uuid.uuid4().hex[:8]}"- tool_input = None- try:- import json-- args_str = tool_info.get("args", "{}")- tool_input = json.loads(args_str) if args_str else {}- except Exception:- tool_input = {"raw_args": tool_info.get("args", "")}-- result_str = str(tool_info.get("result", ""))-- skill_uri = ""- if tool_name == "read_file" and result_str:- match = re.search(r"^---\s*\nname:\s*(.+?)\s*\n", result_str, re.MULTILINE)- if match:- skill_name = match.group(1).strip()- skill_uri = f"viking://agent/skills/{skill_name}"- # logger.debug(f"skill_uri === {skill_uri}")-- execute_success = tool_info.get("execute_success", True)- tool_status = "completed" if execute_success else "error"- # logger.debug(f"tool_info={tool_info}")- parts.append(- ToolPart(- tool_id=tool_id,- tool_name=tool_name,- tool_uri=f"viking://session/{session_id}/tools/{tool_id}",- tool_input=tool_input,- tool_output=result_str[:2000],- tool_status=tool_status,- skill_uri=skill_uri,- duration_ms=float(tool_info.get("duration", 0.0)),- prompt_tokens=tool_info.get("input_token"),- completion_tokens=tool_info.get("output_token"),- )+ user_exists = await self._check_user_exists(user_id)+ if not user_exists:+ success = await self._initialize_user(user_id)+ if not success:+ return {"error": "Failed to initialize user"}++ # For remote mode, try to get user's API key and create a dedicated client+ client = self.client+ start = time.time()+ if self.mode == "remote" and user_id and user_id != self.admin_user_id and self._apikey_manager:+ user_api_key = await self._get_or_create_user_apikey(user_id)+ if user_api_key:+ # Create a new HTTP client with user's API key+ client = ov.AsyncHTTPClient(+ url=self.openviking_config.server_url,+ api_key=user_api_key,+ agent_id=self.agent_id,+ )+ await client.initialize()++ create_res = await client.create_session()+ session_id = create_res['session_id']+ session = client.session(session_id)++ for message in messages:+ role = message.get("role")+ content = message.get("content")+ tools_used = message.get("tools_used") or []++ parts: list[Any] = []++ if content:+ parts.append(TextPart(text=content))++ for tool_info in tools_used:+ tool_name = tool_info.get("tool_name", "")+ if not tool_name:+ continue++ tool_id = f"{tool_name}_{uuid.uuid4().hex[:8]}"+ tool_input = None+ try:+ import json++ args_str = tool_info.get("args", "{}")+ tool_input = json.loads(args_str) if args_str else {}+ except Exception:+ tool_input = {"raw_args": tool_info.get("args", "")}++ result_str = str(tool_info.get("result", ""))++ skill_uri = ""+ if tool_name == "read_file" and result_str:+ match = re.search(r"^---\s*\nname:\s*(.+?)\s*\n", result_str, re.MULTILINE)+ if match:+ skill_name = match.group(1).strip()+ skill_uri = f"viking://agent/skills/{skill_name}"++ execute_success = tool_info.get("execute_success", True)+ tool_status = "completed" if execute_success else "error"+ parts.append(+ ToolPart(+ tool_id=tool_id,+ tool_name=tool_name,+ tool_uri=f"viking://session/{session_id}/tools/{tool_id}",+ tool_input=tool_input,+ tool_output=result_str[:2000],+ tool_status=tool_status,+ skill_uri=skill_uri,+ duration_ms=float(tool_info.get("duration", 0.0)),+ prompt_tokens=tool_info.get("input_token"),+ completion_tokens=tool_info.get("output_token"),)+ )- if not parts:- parts = [TextPart(text=content or "")]-- session.add_message(role=role, parts=parts)+ if not parts:+ continue+ await session.add_message(role=role, parts=parts)- result = session.commit()- else:- for message in messages:- await session.add_message(role=message.get("role"), content=message.get("content"))- result = await session.commit()- logger.debug(f"Message add ed to OpenViking session {session_id}")+ result = await session.commit()+ if client is not self.client:+ await client.close()+ logger.info(f"time spent: {time.time() - start}")+ logger.debug(f"Message add ed to OpenViking session {session_id}, user: {user_id}")return {"success": result["status"]}- def close(self):+ async def close(self):"""关闭客户端"""- self.client.close()-- def _parse_viking_memory(self, result: Any) -> str:- if result and len(result) > 0:- user_memories = []- for idx, memory in enumerate(result, start=1):- user_memories.append(- f"{idx}. {getattr(memory, 'abstract', '')}; "- f"uri: {getattr(memory, 'uri', '')}; "- f"isDir: {getattr(memory, 'is_leaf', False)}; "- f"related score: {getattr(memory, 'score', 0.0)}"- )- return "\n".join(user_memories)- return ""-- async def get_viking_memory_context(- self, session_id: str, current_message: str, history: list[dict[str, Any]]- ) -> str:- result = await self.search_memory(current_message, limit=5)- if not result:- return ""- user_memory = self._parse_viking_memory(result["user_memory"])- agent_memory = self._parse_viking_memory(result["agent_memory"])- return (- f"## Related openviking memories.Using tools to read more details.\n"- f"### user memories:\n{user_memory}\n"- f"### agent memories:\n{agent_memory}"- )+ await self.client.close()async def main_test():@@ -286,33 +435,32 @@ async def main_test():# res = client.list_resources()# res = await client.search("头有点疼", target_uri="viking://user/memories/")# res = await client.get_viking_memory_context("123", current_message="头疼", history=[])- # res = await client.search_memory("你好")+ # res = await client.search_memory("你好", "user_1")# res = await client.list_resources("viking://resources/")# res = await client.read_content("viking://user/memories/profile.md", level="read")# res = await client.add_resource("/Users/bytedance/Documents/论文/吉比特年报.pdf", "吉比特年报")res = await client.commit(- "123",- [- {"role": "user", "content": "我叫吴彦祖"},- {- "role": "assistant",- "content": "好的吴彦祖😎,我已经记 住你的名字啦,之后随时都可以认出你~",- },- ],+ session_id="99999",+ messages=[{"role": "user", "content": "你好"}],+ user_id="1010101010",)# res = await client.commit("1234", [{"role": "user", "content": "帮我搜索 Python asyncio 教程"}# ,{"role": "assistant", "content": "我来帮你r搜索 Python asyncio 相关的教程。"}])print(res)- print("等待后台处理完成...")- await client.client.wait_processed(timeout=60)+ await client.close()print("处理完成!")async def account_test():- client = ov.AsyncHTTPClient(url="")+ client = ov.AsyncHTTPClient(url="http://localhost:1933", api_key="test")await client.initialize()- res = await client.search("test", target_uri="viking://memories/")++ # res = await client.admin_list_users("eval")+ # res = await client.admin_remove_user("default", "ou_69e48b1314d1400af9d40fe3e4c24b8a")+ # res = await client.admin_remove_user("default", "admin")+ # res = await client.admin_list_accounts()+ res = await client.admin_create_account("eval", "default")print(res)diff --git a/bot/vikingbot/openviking_mount/user_apikey_manager.py b/bot/vikingbot/openviking_mount/user_apikey_manager.pynew file mode 100644index 000000000..da638d95d--- /dev/null+++ b/bot/vikingbot/openviking_mount/user_apikey_manager.py@@ -0,0 +1,122 @@+"""User API Key persistence manager for OpenViking remote mode."""++import json+import hashlib+from pathlib import Path+from typing import Optional++from loguru import logger+++class UserApiKeyManager:+ """Manages user API key persistence based on server_url and account_id.++ Stores API keys in a JSON file located at:+ {ov_path}/user_apikeys_{hash}.json++ where {hash} is derived from server_url and account_id.+ """++ def __init__(self, ov_path: Path, server_url: str, account_id: str):+ """Initialize the API key manager.++ Args:+ ov_path: The ov_path where config files are stored+ server_url: The OpenViking server URL+ account_id: The account ID+ """+ self.ov_path = Path(ov_path)+ self.server_url = server_url+ self.account_id = account_id++ # Generate hash from server_url and account_id+ hash_input = f"{server_url}:{account_id}"+ self.config_hash = hashlib.md5(hash_input.encode()).hexdigest()[:16]++ # Config file path+ self.config_dir = self.ov_path+ self.config_file = self.config_dir / f"user_apikeys_{self.config_hash}.json"++ # In-memory cache+ self._apikeys: dict[str, str] = {}+ self._loaded = False++ def _ensure_config_dir(self) -> None:+ """Ensure the config directory exists."""+ self.config_dir.mkdir(parents=True, exist_ok=True)++ def _load(self) -> None:+ """Load API keys from the config file."""+ if self._loaded:+ return++ if self.config_file.exists():+ try:+ with open(self.config_file, "r", encoding="utf-8") as f:+ data = json.load(f)+ self._apikeys = data.get("apikeys", {})+ except Exception as e:+ logger.warning(f"Failed to load API keys from {self.config_file}: {e}")+ self._apikeys = {}+ else:+ logger.debug(f"API key config file not found: {self.config_file}")++ self._loaded = True++ def _save(self) -> None:+ """Save API keys to the config file."""+ self._ensure_config_dir()++ try:+ data = {+ "server_url": self.server_url,+ "account_id": self.account_id,+ "apikeys": self._apikeys,+ }++ with open(self.config_file, "w", encoding="utf-8") as f:+ json.dump(data, f, indent=2, ensure_ascii=False)++ logger.debug(f"Saved {len(self._apikeys)} API keys to {self.config_file}")+ except Exception as e:+ logger.error(f"Failed to save API keys to {self.config_file}: {e}")+ raise++ def get_apikey(self, user_id: str) -> Optional[str]:+ """Get the API key for a specific user.++ Args:+ user_id: The user ID++ Returns:+ The API key if found, None otherwise+ """+ self._load()+ return self._apikeys.get(user_id)++ def set_apikey(self, user_id: str, api_key: str) -> None:+ """Set the API key for a specific user.++ Args:+ user_id: The user ID+ api_key: The API key to store+ """+ self._load()+ self._apikeys[user_id] = api_key+ self._save()++ def delete_apikey(self, user_id: str) -> bool:+ """Delete the API key for a specific user.++ Args:+ user_id: The user ID++ Returns:+ True if the key was deleted, False if not found+ """+ self._load()+ if user_id in self._apikeys:+ del self._apikeys[user_id]+ self._save()+ return True+ return Falsediff --git a/bot/vikingbot/openviking_mount/viking_fuse.py b/bot/vikingbot/openviking_mount/viking_fuse.pyindex 7d59a19d8..d3fac59aa 100644--- a/bot/vikingbot/openviking_mount/viking_fuse.py+++ b/bot/vikingbot/openviking_mount/viking_fuse.py@@ -25,7 +25,6 @@ try:FUSE_AVAILABLE = Trueexcept (ImportError, OSError) as e:FUSE_AVAILABLE = False- logger.warning(f"fusepy not available: {e}")# 创建占位符Operations = objectFUSE = None@@ -478,7 +477,7 @@ else:def mount_fuse(*args, **kwargs):raise ImportError(- "fusepy and libfuse are required. Install with: pip install fusepy and install libfuse system package"+ "fusepy and libfuse are required. Install with: uv pip install 'vikingbot[fuse]' (or uv pip install -e \".[fuse]\" for local dev) and install libfuse system package")class FUSEMountManager:diff --git a/bot/vikingbot/providers/base.py b/bot/vikingbot/providers/base.pyindex 0b0caf9cb..6d00de8f1 100644--- a/bot/vikingbot/providers/base.py+++ b/bot/vikingbot/providers/base.py@@ -51,6 +51,7 @@ class LLMProvider(ABC):model: str | None = None,max_tokens: int = 4096,temperature: float = 0.7,+ session_id: str | None = None,) -> LLMResponse:"""Send a chat completion request.@@ -61,6 +62,7 @@ class LLMProvider(ABC):model: Model identifier (provider-specific).max_tokens: Maximum tokens in response.temperature: Sampling temperature.+ session_id: Optional session ID for tracing.Returns:LLMResponse with content and/or tool calls.diff --git a/bot/vikingbot/providers/litellm_provider.py b/bot/vikingbot/providers/litellm_provider.pyindex f5412eb5b..84eea4055 100644--- a/bot/vikingbot/providers/litellm_provider.py+++ b/bot/vikingbot/providers/litellm_provider.py@@ -4,9 +4,11 @@ import jsonimport osfrom typing import Any+from loguru import loggerimport litellmfrom litellm import acompletion+from vikingbot.integrations.langfuse import LangfuseClientfrom vikingbot.providers.base import LLMProvider, LLMResponse, ToolCallRequestfrom vikingbot.providers.registry import find_by_model, find_gatewayfrom vikingbot.utils.helpers import cal_str_tokens@@ -28,10 +30,12 @@ class LiteLLMProvider(LLMProvider):default_model: str = "anthropic/claude-opus-4-5",extra_headers: dict[str, str] | None = None,provider_name: str | None = None,+ langfuse_client: LangfuseClient | None = None,):super().__init__(api_key, api_base)self.default_model = default_modelself.extra_headers = extra_headers or {}+ self.langfuse = langfuse_client or LangfuseClient.get_instance()# Detect gateway / local deployment.# provider_name (from config key) is the primary signal;@@ -107,6 +111,7 @@ class LiteLLMProvider(LLMProvider):model: str | None = None,max_tokens: int = 4096,temperature: float = 0.7,+ session_id: str | None = None,) -> LLMResponse:"""Send a chat completion request via LiteLLM.@@ -117,6 +122,7 @@ class LiteLLMProvider(LLMProvider):model: Model identifier (e.g., 'anthropic/claude-sonnet-4-5').max_tokens: Maximum tokens in response.temperature: Sampling temperature.+ session_id: Optional session ID for tracing.Returns:LLMResponse with content and/or tool calls.@@ -149,10 +155,71 @@ class LiteLLMProvider(LLMProvider):kwargs["tools"] = toolskwargs["tool_choice"] = "auto"+ # Direct Langfuse v3 SDK usage+ # Note: session_id is set via propagate_attributes in loop.py, not here+ langfuse_generation = Nonetry:+ if self.langfuse.enabled and self.langfuse._client:+ metadata = {"has_tools": tools is not None}+ langfuse_generation = self.langfuse._client.start_generation(+ name="llm-chat",+ model=model,+ input=messages,+ metadata=metadata,+ )+response = await acompletion(**kwargs)- return self._parse_response(response)+ llm_response = self._parse_response(response)++ # Update and end Langfuse generation+ if langfuse_generation:+ output_text = llm_response.content or ""+ if llm_response.tool_calls:+ output_text = (+ output_text+ or f"[Tool calls: {[tc.name for tc in llm_response.tool_calls]}]"+ )++ # Update generation with output and usage+ update_kwargs: dict[str, Any] = {+ "output": output_text,+ "metadata": {"finish_reason": llm_response.finish_reason},+ }++ if llm_response.usage:+ # Langfuse v3 SDK expects "usage_details" with "input" and "output" keys+ usage_details: dict[str, Any] = {+ "input": llm_response.usage.get("prompt_tokens", 0),+ "output": llm_response.usage.get("completion_tokens", 0),+ }++ # Add cache read tokens if available (OpenAI/Anthropic prompt caching)+ # Try multiple possible field names for cached tokens+ cache_read_tokens = (+ llm_response.usage.get("cache_read_input_tokens") or+ llm_response.usage.get("prompt_tokens_details", {}).get("cached_tokens")+ )+ if cache_read_tokens:+ usage_details["cache_read_input_tokens"] = cache_read_tokens++ update_kwargs["usage_details"] = usage_details+ # Log the usage details being sent to Langfuse+ # logger.info(f"[LANGFUSE] Updating generation with usage_details: {usage_details}")++ langfuse_generation.update(**update_kwargs)+ langfuse_generation.end()+ self.langfuse.flush()++ return llm_responseexcept Exception as e:+ # End Langfuse generation with error+ if langfuse_generation:+ langfuse_generation.update(+ output=f"Error: {str(e)}",+ metadata={"error": str(e)},+ )+ langfuse_generation.end()+ self.langfuse.flush()# Return error as content for graceful handlingreturn LLMResponse(content=f"Error calling LLM: {str(e)}",@@ -189,6 +256,20 @@ class LiteLLMProvider(LLMProvider):"total_tokens": response.usage.total_tokens,}+ # Extract cached tokens from various provider formats+ # OpenAI style: prompt_tokens_details.cached_tokens+ if hasattr(response.usage, "prompt_tokens_details"):+ details = response.usage.prompt_tokens_details+ if details and hasattr(details, "cached_tokens"):+ cached = details.cached_tokens+ if cached:+ usage["cache_read_input_tokens"] = cached+ # Anthropic style: cache_read_input_tokens+ elif hasattr(response.usage, "cache_read_input_tokens"):+ cached = response.usage.cache_read_input_tokens+ if cached:+ usage["cache_read_input_tokens"] = cached+reasoning_content = getattr(message, "reasoning_content", None)return LLMResponse(diff --git a/bot/vikingbot/sandbox/backends/aiosandbox.py b/bot/vikingbot/sandbox/backends/aiosandbox.pyindex e459feedb..e15cf03cb 100644--- a/bot/vikingbot/sandbox/backends/aiosandbox.py+++ b/bot/vikingbot/sandbox/backends/aiosandbox.py@@ -35,7 +35,7 @@ class AioSandboxBackend(SandboxBackend):self._client = AsyncSandbox(base_url=self._base_url)logger.info("[AioSandbox] Connected successfully")except ImportError:- logger.error("agent-sandbox SDK not installed. Install with: pip install agent-sandbox")+ logger.error("agent-sandbox SDK not installed. Install with: uv pip install 'vikingbot[sandbox]' (or uv pip install -e \".[sandbox]\" for local dev)")raiseexcept Exception as e:logger.error("[AioSandbox] Failed to start: {}", e)diff --git a/bot/vikingbot/sandbox/backends/direct.py b/bot/vikingbot/sandbox/backends/direct.pyindex 95c02ac98..37859a21d 100644--- a/bot/vikingbot/sandbox/backends/direct.py+++ b/bot/vikingbot/sandbox/backends/direct.py@@ -29,7 +29,7 @@ class DirectBackend(SandboxBackend):"""Start the backend (no-op for direct backend)."""self._workspace.mkdir(parents=True, exist_ok=True)self._running = True- logger.info("Direct backend started")+ #logger.info("Direct backend started")async def execute(self, command: str, timeout: int = 60, **kwargs: Any) -> str:"""Execute a command directly on the host."""diff --git a/bot/vikingbot/sandbox/backends/opensandbox.py b/bot/vikingbot/sandbox/backends/opensandbox.pyindex 99e3a7628..66c1027fe 100644--- a/bot/vikingbot/sandbox/backends/opensandbox.py+++ b/bot/vikingbot/sandbox/backends/opensandbox.py@@ -205,7 +205,7 @@ class OpenSandboxBackend(SandboxBackend):logger.info("OpenSandbox created successfully")except ImportError:- logger.error("opensandbox SDK not installed. Install with: pip install opensandbox")+ logger.error("opensandbox SDK not installed. Install with: uv pip install 'vikingbot[sandbox]' (or uv pip install -e \".[sandbox]\" for local dev)")raiseexcept Exception as e:logger.error("Failed to create OpenSandbox: {}", e)diff --git a/bot/vikingbot/sandbox/manager.py b/bot/vikingbot/sandbox/manager.pyindex 02230428d..91bc651e0 100644--- a/bot/vikingbot/sandbox/manager.py+++ b/bot/vikingbot/sandbox/manager.py@@ -31,16 +31,16 @@ class SandboxManager:async def _get_or_create_sandbox(self, session_key: SessionKey) -> SandboxBackend:"""Get or create session-specific sandbox."""- sandbox_key = self.to_sandbox_key(session_key)- if sandbox_key not in self._sandboxes:- sandbox = await self._create_sandbox(sandbox_key)- self._sandboxes[sandbox_key] = sandbox- return self._sandboxes[sandbox_key]+ workspace_id = self.to_workspace_id(session_key)+ if workspace_id not in self._sandboxes:+ sandbox = await self._create_sandbox(workspace_id)+ self._sandboxes[workspace_id] = sandbox+ return self._sandboxes[workspace_id]- async def _create_sandbox(self, sandbox_key: str) -> SandboxBackend:+ async def _create_sandbox(self, workspace_id: str) -> SandboxBackend:"""Create new sandbox instance."""- workspace = self.workspace / sandbox_key- instance = self._backend_cls(self.config.sandbox, sandbox_key, workspace)+ workspace = self.workspace / workspace_id+ instance = self._backend_cls(self.config.sandbox, workspace_id, workspace)try:await instance.start()except Exception as e:@@ -88,10 +88,10 @@ class SandboxManager:async def cleanup_session(self, session_key: SessionKey) -> None:"""Clean up sandbox for a session."""- sandbox_key = self.to_sandbox_key(session_key)- if sandbox_key in self._sandboxes:- await self._sandboxes[sandbox_key].stop()- del self._sandboxes[sandbox_key]+ workspace_id = self.to_workspace_id(session_key)+ if workspace_id in self._sandboxes:+ await self._sandboxes[workspace_id].stop()+ del self._sandboxes[workspace_id]async def cleanup_all(self) -> None:"""Clean up all sandboxes."""@@ -100,9 +100,9 @@ class SandboxManager:self._sandboxes.clear()def get_workspace_path(self, session_key: SessionKey) -> Path:- return self.workspace / self.to_sandbox_key(session_key)+ return self.workspace / self.to_workspace_id(session_key)- def to_sandbox_key(self, session_key: SessionKey):+ def to_workspace_id(self, session_key: SessionKey):if self.config.sandbox.mode == "shared":return "shared"else:diff --git a/bot/vikingbot/session/manager.py b/bot/vikingbot/session/manager.pyindex ca00574b8..e97ae97ce 100644--- a/bot/vikingbot/session/manager.py+++ b/bot/vikingbot/session/manager.py@@ -31,9 +31,13 @@ class Session:updated_at: datetime = field(default_factory=datetime.now)metadata: dict[str, Any] = field(default_factory=dict)- def add_message(self, role: str, content: str, **kwargs: Any) -> None:+ def add_message(+ self, role: str, content: str, sender_id: str | None = None, **kwargs: Any+ ) -> None:"""Add a message to the session."""msg = {"role": role, "content": content, "timestamp": datetime.now().isoformat(), **kwargs}+ if sender_id is not None:+ msg["sender_id"] = sender_idself.messages.append(msg)self.updated_at = datetime.now()@@ -63,18 +67,39 @@ class Session:class SessionManager:"""- Manages conversation sessions.-- Sessions are stored as JSONL files in sessions directory.+ Manages conversation sessions with persistence and caching.++ SessionManager handles the lifecycle of conversation sessions, including+ creation, retrieval, caching, and persistent storage. Sessions are stored+ as JSONL files in a designated directory for durability.++ The manager maintains an in-memory cache of active sessions to improve+ performance and reduce disk I/O. Sessions are automatically persisted when+ modified.++ Attributes:+ bot_data_path: Path to the bot's data directory.+ workspace: Path to the workspace directory within bot_data.+ sessions_dir: Path where session JSONL files are stored.+ _cache: In-memory cache mapping SessionKey to Session objects.+ sandbox_manager: Optional sandbox manager for isolated operations.++ Example:+ >>> manager = SessionManager(Path("/path/to/bot/data"))+ >>> session_key = SessionKey(channel="telegram", chat_id="12345")+ >>> session = manager.get_or_create(session_key)+ >>> session.add_message("user", "Hello!")+ >>> await manager.save(session)"""def __init__(self,- workspace: Path,+ bot_data_path: Path,sandbox_manager: "SandboxManager | None" = None,):- self.workspace = workspace- self.sessions_dir = ensure_dir(Path.home() / ".vikingbot" / "sessions")+ self.bot_data_path = bot_data_path+ self.workspace = bot_data_path / "workspace"+ self.sessions_dir = ensure_dir(bot_data_path / "sessions")self._cache: dict[SessionKey, Session] = {}self.sandbox_manager = sandbox_manager@@ -111,7 +136,7 @@ class SessionManager:if self.sandbox_manager.config.mode == "shared":workspace_path = self.sandbox_manager.workspace / "shared"else:- workspace_path = self.sandbox_manager.workspace / key.replace(":", "_")+ workspace_path = self.sandbox_manager.workspace / key.safe_name()ensure_session_workspace(workspace_path)# Initialize sandbox@@ -175,7 +200,7 @@ class SessionManager:logger.warning(f"Failed to load session {session_key}: {e}")return None- def save(self, session: Session) -> None:+ async def save(self, session: Session) -> None:"""Save a session to disk."""path = self._get_session_path(session.key)diff --git a/bot/vikingbot/tests/__init__.py b/bot/vikingbot/tests/__init__.pynew file mode 100644index 000000000..1ed28a3ab--- /dev/null+++ b/bot/vikingbot/tests/__init__.py@@ -0,0 +1 @@+"""Vikingbot test suite."""diff --git a/bot/vikingbot/tests/integration/__init__.py b/bot/vikingbot/tests/integration/__init__.pynew file mode 100644index 000000000..c210facce--- /dev/null+++ b/bot/vikingbot/tests/integration/__init__.py@@ -0,0 +1 @@+"""Integration tests."""diff --git a/bot/vikingbot/tests/unit/__init__.py b/bot/vikingbot/tests/unit/__init__.pynew file mode 100644index 000000000..e0310a01e--- /dev/null+++ b/bot/vikingbot/tests/unit/__init__.py@@ -0,0 +1 @@+"""Unit tests."""diff --git a/bot/vikingbot/tests/unit/test_agent/__init__.py b/bot/vikingbot/tests/unit/test_agent/__init__.pynew file mode 100644index 000000000..e34162309--- /dev/null+++ b/bot/vikingbot/tests/unit/test_agent/__init__.py@@ -0,0 +1 @@+"""Agent module tests."""diff --git a/bot/vikingbot/tests/unit/test_bus/__init__.py b/bot/vikingbot/tests/unit/test_bus/__init__.pynew file mode 100644index 000000000..785e27236--- /dev/null+++ b/bot/vikingbot/tests/unit/test_bus/__init__.py@@ -0,0 +1 @@+"""Message bus tests."""diff --git a/bot/vikingbot/tests/unit/test_channels/__init__.py b/bot/vikingbot/tests/unit/test_channels/__init__.pynew file mode 100644index 000000000..4294d6287--- /dev/null+++ b/bot/vikingbot/tests/unit/test_channels/__init__.py@@ -0,0 +1 @@+"""Channel adapter tests."""diff --git a/bot/vikingbot/tests/unit/test_config/__init__.py b/bot/vikingbot/tests/unit/test_config/__init__.pynew file mode 100644index 000000000..b27d053b5--- /dev/null+++ b/bot/vikingbot/tests/unit/test_config/__init__.py@@ -0,0 +1 @@+"""Configuration tests."""diff --git a/bot/vikingbot/tui/app.py b/bot/vikingbot/tui/app.pydeleted file mode 100644index ecab2d4fb..000000000--- a/bot/vikingbot/tui/app.py+++ /dev/null@@ -1,379 +0,0 @@-"""Main TUI application using Textual framework."""--import asyncio-from typing import Optional--from textual import on-from textual.app import App, ComposeResult-from textual.containers import Container, Vertical, Horizontal-from textual.widgets import Header, Footer, Static, Input, Button, RichLog-from textual.binding import Binding-from textual.reactive import reactive--from vikingbot.config.schema import SessionKey-from vikingbot.tui.state import TUIState, MessageRole, Message, ThinkingStep, ThinkingStepType-from vikingbot import __logo__---class ThinkingPanel(Vertical):- """思考过程面板"""-- def __init__(self, state: TUIState) -> None:- super().__init__()- self.state = state- self.thinking_log = RichLog(id="thinking-log", markup=True, wrap=True, auto_scroll=True)- self.title = Static("[bold yellow]🧠 Thinking Process[/bold yellow]", id="thinking-title")-- def compose(self) -> ComposeResult:- yield self.title- yield self.thinking_log-- def add_step(self, step: ThinkingStep) -> None:- """添加思考步骤"""- if step.step_type == ThinkingStepType.ITERATION:- self.thinking_log.write(f"[dim]━━━ {step.content} ━━━[/dim]")- elif step.step_type == ThinkingStepType.REASONING:- self.thinking_log.write(f"[cyan]💭 Reasoning:[/cyan] {step.content}")- elif step.step_type == ThinkingStepType.TOOL_CALL:- self.thinking_log.write(f"[magenta]🔧 Tool:[/magenta] {step.content}")- elif step.step_type == ThinkingStepType.TOOL_RESULT:- self.thinking_log.write(f"[green]✓ Result:[/green] {step.content}")-- def clear(self) -> None:- """清空思考过程"""- self.thinking_log.clear()---class MessageList(RichLog):- """消息列表组件,显示聊天消息"""-- def add_message(self, message: Message) -> None:- """添加消息到列表"""- if message.role == MessageRole.USER:- self.write(f"[bold cyan]You:[/bold cyan] {message.content}")- elif message.role == MessageRole.ASSISTANT:- self.write(f"[bold green]🐈 vikingbot:[/bold green]")- self.write(message.content)- elif message.role == MessageRole.SYSTEM:- self.write(f"[dim]{message.content}[/dim]")- self.write("")---class ChatInput(Horizontal):- """聊天输入框组件"""-- def compose(self) -> ComposeResult:- yield Input(placeholder="Type your message here...", id="chat-input")- yield Button("Send", variant="primary", id="send-button")---class ThinkingIndicator(Static):- """思考状态指示器"""-- is_thinking = reactive(False)-- def render(self) -> str:- if self.is_thinking:- return "[dim]vikingbot is thinking...[/dim]"- return ""---class StatusBar(Static):- """状态栏显示会话信息"""-- def __init__(self, state: TUIState) -> None:- super().__init__()- self.state = state-- def render(self) -> str:- status = f"Messages: {self.state.message_count}"- if self.state.total_tokens > 0:- status += f" | Tokens: {self.state.total_tokens}"- if self.state.last_error:- status += f" | [red]Error: {self.state.last_error}[/red]"- status += " | [F2] Toggle Thinking | [F3] Clear Thinking"- return status---class ChatScreen(Horizontal):- """聊天主屏幕(左右分栏布局)"""-- def __init__(self, state: TUIState) -> None:- super().__init__()- self.state = state- self.message_list = MessageList(id="message-list", markup=True, wrap=True)- self.thinking_panel = ThinkingPanel(state)- self.thinking_indicator = ThinkingIndicator(id="thinking-indicator")- self.status_bar = StatusBar(state)-- def compose(self) -> ComposeResult:- # 左侧:聊天区域- with Vertical(id="left-panel"):- yield self.message_list- yield self.thinking_indicator- yield ChatInput(id="chat-input-container")-- # 右侧:思考过程面板- with Vertical(id="right-panel"):- yield self.thinking_panel-- yield self.status_bar-- def on_mount(self) -> None:- """挂载时初始化消息列表"""- for message in self.state.messages:- self.message_list.add_message(message)- # 根据状态显示/隐藏思考面板- self._update_thinking_panel_visibility()-- def _update_thinking_panel_visibility(self) -> None:- """更新思考面板可见性"""- right_panel = self.query_one("#right-panel", Vertical)- right_panel.display = self.state.show_thinking_panel-- def toggle_thinking_panel(self) -> None:- """切换思考面板显示/隐藏"""- self.state.show_thinking_panel = not self.state.show_thinking_panel- self._update_thinking_panel_visibility()- self.status_bar.refresh()-- def update_thinking(self, is_thinking: bool) -> None:- """更新思考状态"""- self.thinking_indicator.is_thinking = is_thinking-- def add_message(self, message: Message) -> None:- """添加消息并更新状态"""- self.state.messages.append(message)- self.message_list.add_message(message)- self.state.message_count = len(self.state.messages)- self.status_bar.refresh()-- def add_thinking_step(self, step: ThinkingStep) -> None:- """添加思考步骤"""- self.state.current_thinking_steps.append(step)- self.thinking_panel.add_step(step)-- def clear_thinking(self) -> None:- """清空思考过程"""- self.state.current_thinking_steps.clear()- self.thinking_panel.clear()---class NanobotTUI(App):- """vikingbot Textual TUI 主应用"""-- CSS_PATH = "styles/tui.css"- BINDINGS = [- Binding("ctrl+c", "quit", "Quit", show=True),- Binding("ctrl+d", "quit", "Quit", show=True),- Binding("escape", "quit", "Quit", show=True),- Binding("up", "history_up", "Previous message", show=True),- Binding("down", "history_down", "Next message", show=True),- Binding("ctrl+l", "clear", "Clear chat", show=True),- Binding("f2", "toggle_thinking", "Toggle thinking panel", show=True),- Binding("f3", "clear_thinking", "Clear thinking", show=True),- ]-- def __init__(self, agent_loop, bus, config) -> None:- super().__init__()- self.agent_loop = agent_loop- self.bus = bus- self.config = config- self.state = TUIState()- self.chat_screen: Optional[ChatScreen] = None-- # 设置思考回调- self.state.thinking_callback = self._on_thinking_step-- def _on_thinking_step(self, step) -> None:- """思考步骤回调(处理来自 agent loop 的回调)"""- # 转换 step 类型(来自 loop.py 的简化版本)- from vikingbot.agent.loop import ThinkingStepType as LoopThinkingStepType-- converted_type_map = {- LoopThinkingStepType.REASONING: ThinkingStepType.REASONING,- LoopThinkingStepType.TOOL_CALL: ThinkingStepType.TOOL_CALL,- LoopThinkingStepType.TOOL_RESULT: ThinkingStepType.TOOL_RESULT,- LoopThinkingStepType.ITERATION: ThinkingStepType.ITERATION,- }-- converted_step = ThinkingStep(- step_type=converted_type_map.get(step.step_type, ThinkingStepType.REASONING),- content=step.content,- timestamp=step.timestamp,- metadata=step.metadata or {},- )-- if self.chat_screen:- self.chat_screen.add_thinking_step(converted_step)-- def compose(self) -> ComposeResult:- """创建应用布局"""- yield Header()- self.chat_screen = ChatScreen(self.state)- yield self.chat_screen- yield Footer()-- def on_mount(self) -> None:- """应用挂载时显示欢迎信息"""- self.title = "🐈 vikingbot TUI"- self.sub_title = "Interactive AI Programming Assistant"-- # 添加欢迎消息- if self.chat_screen:- welcome_msg = Message(- role=MessageRole.SYSTEM,- content=f"{__logo__} Welcome to vikingbot TUI! Type your message below.",- )- self.chat_screen.add_message(welcome_msg)-- # 延迟聚焦到输入框,确保组件已完全挂载- self.call_later(self._focus_input)-- def _focus_input(self) -> None:- """设置焦点到输入框"""- try:- input_widget = self.query_one("#chat-input", Input)- self.set_focus(input_widget)- except Exception:- pass-- @on(Input.Submitted, "#chat-input")- @on(Button.Pressed, "#send-button")- async def on_message_sent(self) -> None:- """处理消息发送"""- if not self.chat_screen:- return-- input_widget = self.query_one("#chat-input", Input)- message_text = input_widget.value.strip()-- if not message_text:- return-- # 检查退出命令- if self._is_exit_command(message_text):- await self.action_quit()- return-- # 清空输入框- input_widget.value = ""-- # 让输入框失去焦点,避免光标一直闪烁- self.set_focus(None)-- # 清空当前思考过程- self.chat_screen.clear_thinking()-- # 添加用户消息- user_message = Message(role=MessageRole.USER, content=message_text)- self.chat_screen.add_message(user_message)- self.state.input_history.append(message_text)- self.state.history_index = len(self.state.input_history)-- # 显示思考状态- self.chat_screen.update_thinking(True)-- original_callback = None- try:- # 设置 agent loop 的回调- original_callback = getattr(self.agent_loop, "thinking_callback", None)- self.agent_loop.thinking_callback = self._on_thinking_step-- # 处理消息- response = await self.agent_loop.process_direct(- message_text, session_key=self.state.session_key- )-- # 恢复原回调- self.agent_loop.thinking_callback = original_callback-- # 添加助手回复- assistant_message = Message(role=MessageRole.ASSISTANT, content=response)- self.chat_screen.add_message(assistant_message)-- # 更新令牌计数(简化)- self.state.total_tokens += len(response) // 4-- # 重新聚焦到输入框- self.set_focus(input_widget)-- except Exception as e:- # 恢复原回调- if hasattr(self.agent_loop, "thinking_callback"):- self.agent_loop.thinking_callback = original_callback- # 显示错误- error_msg = Message(role=MessageRole.SYSTEM, content=f"[red]Error: {e}[/red]")- self.chat_screen.add_message(error_msg)- self.state.last_error = str(e)- # 重新聚焦到输入框- self.set_focus(input_widget)- finally:- # 隐藏思考状态- self.chat_screen.update_thinking(False)- self.chat_screen.status_bar.refresh()-- def action_history_up(self) -> None:- """上一条历史消息"""- if self.state.input_history:- input_widget = self.query_one("#chat-input", Input)- if self.state.history_index > 0:- self.state.history_index -= 1- input_widget.value = self.state.input_history[self.state.history_index]- input_widget.cursor_position = len(input_widget.value)-- def action_history_down(self) -> None:- """下一条历史消息"""- if self.state.input_history:- input_widget = self.query_one("#chat-input", Input)- if self.state.history_index < len(self.state.input_history) - 1:- self.state.history_index += 1- input_widget.value = self.state.input_history[self.state.history_index]- input_widget.cursor_position = len(input_widget.value)- elif self.state.history_index == len(self.state.input_history) - 1:- self.state.history_index = len(self.state.input_history)- input_widget.value = ""-- def action_clear(self) -> None:- """清空聊天并开始新会话"""- self.state.messages.clear()- self.state.message_count = 0- self.state.total_tokens = 0- self.state.last_error = None-- # 生成新的 session ID- import uuid-- self.state.session_key = SessionKey(- type="tui", channel_id="default", chat_id="uuid.uuid4().hex[:8]"- )-- # 清空思考过程- if self.chat_screen:- self.chat_screen.clear_thinking()- self.chat_screen.message_list.clear()- welcome_msg = Message(- role=MessageRole.SYSTEM,- content=f"{__logo__} Chat cleared. New session started (Session: {self.state.session_key}).",- )- self.chat_screen.add_message(welcome_msg)-- def action_toggle_thinking(self) -> None:- """切换思考面板"""- if self.chat_screen:- self.chat_screen.toggle_thinking_panel()-- def action_clear_thinking(self) -> None:- """清空思考过程"""- if self.chat_screen:- self.chat_screen.clear_thinking()-- def _is_exit_command(self, command: str) -> bool:- """检查是否为退出命令"""- return command.lower().strip() in {"exit", "quit", "/exit", "/quit", ":q"}---async def run_tui(agent_loop, bus, config) -> None:- """运行 TUI 应用"""- app = NanobotTUI(agent_loop, bus, config)- await app.run_async()diff --git a/bot/vikingbot/tui/state.py b/bot/vikingbot/tui/state.pydeleted file mode 100644index 996142d5b..000000000--- a/bot/vikingbot/tui/state.py+++ /dev/null@@ -1,61 +0,0 @@-"""TUI state management module."""--from dataclasses import dataclass, field-from datetime import datetime-from enum import Enum-from typing import List, Optional, Callable, Any--from vikingbot.config.schema import SessionKey---class MessageRole(Enum):- USER = "user"- ASSISTANT = "assistant"- SYSTEM = "system"---class ThinkingStepType(Enum):- """思考步骤类型"""-- REASONING = "reasoning" # 推理内容- TOOL_CALL = "tool_call" # 工具调用- TOOL_RESULT = "tool_result" # 工具结果- ITERATION = "iteration" # 迭代开始---@dataclass-class ThinkingStep:- """单个思考步骤"""-- step_type: ThinkingStepType- content: str- timestamp: datetime = field(default_factory=datetime.now)- metadata: dict = field(default_factory=dict)---@dataclass-class Message:- role: MessageRole- content: str- timestamp: datetime = field(default_factory=datetime.now)- tokens_used: Optional[int] = None- thinking_steps: List[ThinkingStep] = field(default_factory=list)---@dataclass-class TUIState:- messages: List[Message] = field(default_factory=list)- session_key: SessionKey = SessionKey(type="tui", channel_id="default", chat_id="default")- is_thinking: bool = False- thinking_message: str = "vikingbot is thinking..."- input_text: str = ""- input_history: List[str] = field(default_factory=list)- history_index: int = -1- last_error: Optional[str] = None- total_tokens: int = 0- message_count: int = 0-- # 思考过程相关- current_thinking_steps: List[ThinkingStep] = field(default_factory=list)- show_thinking_panel: bool = True # 是否显示思考面板- thinking_callback: Optional[Callable[[ThinkingStep], None]] = Nonediff --git a/bot/vikingbot/tui/styles/tui.css b/bot/vikingbot/tui/styles/tui.cssdeleted file mode 100644index 4f5c28611..000000000--- a/bot/vikingbot/tui/styles/tui.css+++ /dev/null@@ -1,135 +0,0 @@-/* vikingbot TUI 样式 */--/* 应用整体样式 */-NanobotTUI {- background: $surface;-}--/* 聊天屏幕(左右分栏) */-ChatScreen {- height: 1fr;- layout: horizontal;-}--/* 左侧面板 */-#left-panel {- width: 60%;- height: 1fr;- layout: vertical;- border-right: solid $primary;-}--/* 右侧面板 */-#right-panel {- width: 40%;- height: 1fr;- layout: vertical;- background: $surface-lighten-1;-}--/* 思考面板标题 */-#thinking-title {- height: 1;- padding: 0 1;- background: $primary;- color: $text;- text-style: bold;-}--/* 思考日志 */-#thinking-log {- height: 1fr;- padding: 0 1;- background: $surface-lighten-1;- border: none;-}--/* 消息列表 */-#message-list {- height: 1fr;- padding: 0 1;- background: $surface;- border: none;-}--/* 思考指示器 */-#thinking-indicator {- height: 1;- padding: 0 1;- color: $text-muted;- text-style: italic;-}--/* 聊天输入容器 */-#chat-input-container {- height: auto;- padding: 1 1;- border-top: solid $primary;- background: $surface;-}--/* 输入框 */-#chat-input {- width: 1fr;- margin-right: 1;-}--/* 发送按钮 */-#send-button {- width: auto;- min-width: 8;-}--/* 状态栏 */-StatusBar {- height: 1;- padding: 0 1;- background: $panel;- color: $text-muted;- dock: bottom;-}--/* 消息样式 */-.assistant-message {- color: $success;-}--.user-message {- color: $primary;-}--.system-message {- color: $text-muted;- text-style: italic;-}--/* 错误消息 */-.error-message {- color: $error;-}--/* 按钮悬停效果 */-Button:hover {- background: $primary-lighten-1;-}--Button:focus {- border: solid $primary;-}--/* 输入框焦点效果 */-Input:focus {- border: solid $primary;-}--/* 禁用输入框 hover 闪烁效果 */-Input:hover {- background: $surface;- border: solid $surface;-}--/* 确保输入框保持稳定样式 */-#chat-input:hover {- background: $surface;- border: solid $surface;-}\ No newline at end of filediff --git a/bot/vikingbot/utils/__init__.py b/bot/vikingbot/utils/__init__.pyindex cb0686125..265714801 100644--- a/bot/vikingbot/utils/__init__.py+++ b/bot/vikingbot/utils/__init__.py@@ -1,5 +1,33 @@"""Utility functions for vikingbot."""-from vikingbot.utils.helpers import ensure_dir, get_workspace_path, get_data_path+from vikingbot.utils.helpers import (+ ensure_dir,+ get_workspace_path,+ get_data_path,+ get_bot_data_path,+ set_bot_data_path,+ get_sessions_path,+ get_history_path,+ get_bridge_path,+ get_images_path,+ get_media_path,+ get_received_path,+ get_mochat_path,+ get_mounts_path,+)-__all__ = ["ensure_dir", "get_workspace_path", "get_data_path"]+__all__ = [+ "ensure_dir",+ "get_workspace_path",+ "get_data_path",+ "get_bot_data_path",+ "set_bot_data_path",+ "get_sessions_path",+ "get_history_path",+ "get_bridge_path",+ "get_images_path",+ "get_media_path",+ "get_received_path",+ "get_mochat_path",+ "get_mounts_path",+]diff --git a/bot/vikingbot/utils/helpers.py b/bot/vikingbot/utils/helpers.pyindex 62899a683..cf1d761ce 100644--- a/bot/vikingbot/utils/helpers.py+++ b/bot/vikingbot/utils/helpers.py@@ -10,36 +10,76 @@ def ensure_dir(path: Path) -> Path:return path+# Global bot data path - must be set before use+_bot_data_path: Path | None = None+++def set_bot_data_path(path: Path) -> None:+ """Set the global bot data path."""+ global _bot_data_path+ _bot_data_path = path+++def get_bot_data_path() -> Path:+ """Get the bot data directory. set_bot_data_path() must be called first."""+ global _bot_data_path+ if not _bot_data_path:+ raise RuntimeError("bot_data_path not set. Call set_bot_data_path() first.")+ return ensure_dir(_bot_data_path)++def get_data_path() -> Path:- """Get the vikingbot data directory (~/.vikingbot)."""- return ensure_dir(Path.home() / ".vikingbot")+ """Get the bot data directory. Alias for get_bot_data_path()."""+ return get_bot_data_path()-def get_source_workspace_path() -> Path:- """Get the source workspace path from the codebase."""- return Path(__file__).parent.parent.parent / "workspace"+def get_sessions_path() -> Path:+ """Get the sessions storage directory."""+ return ensure_dir(get_bot_data_path() / "sessions")-def get_workspace_path(workspace: str | None = None, ensure_exists: bool = True) -> Path:- """- Get the workspace path.+def get_history_path() -> Path:+ """Get the CLI history directory."""+ return ensure_dir(get_bot_data_path() / "history")- Args:- workspace: Optional workspace path. Defaults to ~/.vikingbot/workspace/shared.- ensure_exists: If True, ensure the directory exists (creates it if necessary.- Returns:- Expanded workspace path.- """- if workspace:- path = Path(workspace).expanduser()- else:- path = Path.home() / ".vikingbot" / "workspace" / "shared"+def get_bridge_path() -> Path:+ """Get the bridge directory."""+ return ensure_dir(get_bot_data_path() / "bridge")+++def get_images_path() -> Path:+ """Get the images directory."""+ return ensure_dir(get_bot_data_path() / "images")+++def get_media_path() -> Path:+ """Get the media directory."""+ return ensure_dir(get_bot_data_path() / "media")- if ensure_exists:- ensure_workspace_templates(path)- return ensure_dir(path)- return path++def get_received_path() -> Path:+ """Get the received files directory."""+ return ensure_dir(get_bot_data_path() / "received")+++def get_mochat_path() -> Path:+ """Get the mochat state directory."""+ return ensure_dir(get_bot_data_path() / "mochat")+++def get_mounts_path() -> Path:+ """Get the mounts directory."""+ return ensure_dir(get_bot_data_path() / "mounts")+++def get_source_workspace_path() -> Path:+ """Get the source workspace path from the codebase."""+ return Path(__file__).parent.parent.parent / "workspace"+++def get_workspace_path() -> Path:+ return ensure_dir(get_bot_data_path() / "workspace")def ensure_workspace_templates(workspace: Path) -> None:@@ -212,11 +252,6 @@ This file stores important information that should persist across sessions.skills_dir.mkdir(exist_ok=True)-def get_sessions_path() -> Path:- """Get the sessions storage directory."""- return ensure_dir(get_data_path() / "sessions")--def get_skills_path(workspace: Path | None = None) -> Path:"""Get the skills directory within the workspace."""ws = workspace or get_workspace_path()diff --git a/bot/vikingbot/utils/tracing.py b/bot/vikingbot/utils/tracing.pynew file mode 100644index 000000000..9dee85348--- /dev/null+++ b/bot/vikingbot/utils/tracing.py@@ -0,0 +1,174 @@+"""+Abstract tracing utilities for observability.++This module provides a tracing abstraction that is not tied to any specific+backend (Langfuse, OpenTelemetry, etc.), allowing for easy switching of+implementations.+"""++from contextlib import contextmanager+from contextvars import ContextVar+from functools import wraps+from typing import Any, Callable, Generator, TypeVar++from loguru import logger++# Context variable to store current session ID+_session_id: ContextVar[str | None] = ContextVar("session_id", default=None)++T = TypeVar("T")++# Try to import langfuse observe decorator+try:+ from langfuse.decorators import observe as langfuse_observe+except ImportError:+ langfuse_observe = None+++def get_current_session_id() -> str | None:+ """Get the current session ID from context."""+ return _session_id.get()++++@contextmanager+def set_session_id(session_id: str | None) -> Generator[None, None, None]:+ """+ Set the session ID for the current context.++ Args:+ session_id: The session ID to set, or None to clear.++ Example:+ with set_session_id("user-123"):+ # All nested operations will see this session_id+ result = await process_message(msg)+ """+ token = _session_id.set(session_id)+ try:+ yield+ finally:+ _session_id.reset(token)+++def trace(+ name: str | None = None,+ *,+ extract_session_id: Callable[..., str] | None = None,+ extract_user_id: Callable[..., str] | None = None,+) -> Callable[[Callable[..., T]], Callable[..., T]]:+ """+ Decorator to trace a function execution with session context.++ This decorator is backend-agnostic. It manages session ID injection+ through context variables, without binding to any specific tracing+ implementation (Langfuse, OpenTelemetry, etc.).++ Args:+ name: Optional name for the trace span. Defaults to function name.+ extract_session_id: Optional callable to extract session_id from+ function arguments. The callable receives all positional (*args)+ and keyword (**kwargs) arguments of the decorated function.+ extract_user_id: Optional callable to extract user_id from+ function arguments (e.g., lambda msg: msg.sender_id).++ Returns:+ Decorated function with tracing context management.++ Example:+ @trace(+ name="process_message",+ extract_session_id=lambda msg: msg.session_key.safe_name(),+ extract_user_id=lambda msg: msg.sender_id,+ )+ async def process_message(msg: InboundMessage) -> Response:+ # session_id and user_id are automatically propagated+ return await handle(msg)+ """+ def decorator(func: Callable[..., T]) -> Callable[..., T]:+ span_name = name or func.__name__++ # Apply @observe decorator if available for Langfuse tracing+ wrapped_func = func+ if langfuse_observe is not None:+ wrapped_func = langfuse_observe(name=span_name)(func)++ @wraps(func)+ async def async_wrapper(*args: Any, **kwargs: Any) -> T:+ # Extract session_id if extractor provided+ session_id: str | None = None+ if extract_session_id:+ try:+ # Inspect the extractor's signature to determine how to call it+ import inspect+ sig = inspect.signature(extract_session_id)+ param_count = len([+ p for p in sig.parameters.values()+ if p.kind in (p.POSITIONAL_ONLY, p.POSITIONAL_OR_KEYWORD)+ ])++ if param_count == 1 and len(args) >= 1:+ # Extractor expects single arg (e.g., lambda msg: ...)+ # Use the last arg which is typically the message/object+ session_id = extract_session_id(args[-1])+ else:+ # Extractor expects multiple args or specific signature+ session_id = extract_session_id(*args, **kwargs)+ except Exception as e:+ logger.warning(f"Failed to extract session_id: {e}")++ # Extract user_id if extractor provided+ user_id: str | None = None+ if extract_user_id:+ try:+ import inspect+ sig = inspect.signature(extract_user_id)+ param_count = len([+ p for p in sig.parameters.values()+ if p.kind in (p.POSITIONAL_ONLY, p.POSITIONAL_OR_KEYWORD)+ ])++ if param_count == 1 and len(args) >= 1:+ user_id = extract_user_id(args[-1])+ else:+ user_id = extract_user_id(*args, **kwargs)+ except Exception as e:+ logger.warning(f"Failed to extract user_id: {e}")++ # Fall back to current context if no session_id extracted+ if session_id is None:+ session_id = get_current_session_id()+ logger.debug(f"[TRACE] No session_id extracted, using context: {session_id}")+ else:+ #logger.info(f"[TRACE] Extracted session_id: {session_id}")+ pass++ if user_id:+ #logger.info(f"[TRACE] Extracted user_id: {user_id}")+ pass++ # Use context manager to set session_id for nested operations+ if session_id:+ with set_session_id(session_id):+ # Also propagate to langfuse if available+ from vikingbot.integrations.langfuse import LangfuseClient++ langfuse = LangfuseClient.get_instance()+ has_propagate = hasattr(langfuse, "propagate_attributes")+ # logger.info(f"[LANGFUSE] Client status: enabled={langfuse.enabled}, has_propagate_attributes={has_propagate}")+ if langfuse.enabled and has_propagate:+ # logger.info(f"[LANGFUSE] Starting trace with attributes: session_id={session_id}, user_id={user_id}")+ with langfuse.propagate_attributes(session_id=session_id, user_id=user_id):+ return await wrapped_func(*args, **kwargs)+ else:+ if not langfuse.enabled:+ logger.warning(f"[LANGFUSE] Client not enabled")+ if not has_propagate:+ logger.warning(f"[LANGFUSE] propagate_attributes not available")+ return await wrapped_func(*args, **kwargs)+ else:+ return await wrapped_func(*args, **kwargs)++ return async_wrapper # type: ignore[return-value]++ return decoratordiff --git a/bot/workspace/TOOLS.md b/bot/workspace/TOOLS.mdindex 6e70d5b51..479aae3d6 100644--- a/bot/workspace/TOOLS.md+++ b/bot/workspace/TOOLS.md@@ -34,7 +34,7 @@ Search for user-related memories and events.```openviking_memory_commit(session_id: str, messages: list) -> str```-**All important conversations, events, and memories MUST be committed to OpenViking** for future retrieval and context understanding.+**All user's important conversations, information, and memories MUST be committed to OpenViking** for future retrieval and context understanding.---@@ -172,49 +172,6 @@ cron()```-## OpenViking Tools--### openviking_read-Read content from OpenViking resources at different levels.-```-openviking_read(uri: str, level: str = "abstract") -> str-```--**Levels:**-- `abstract`: L0 - Brief summary-- `overview`: L1 - Medium overview-- `read`: L2 - Full content--### openviking_list-List resources in an OpenViking path.-```-openviking_list(uri: str = "", recursive: bool = False) -> str-```--### openviking_search-Search for resources in OpenViking using semantic search.-```-openviking_search(query: str, target_uri: str = None) -> str-```--### openviking_grep-Search OpenViking resources using regex patterns.-```-openviking_grep(uri: str, pattern: str, case_insensitive: bool = False) -> str-```--### openviking_glob-Find OpenViking resources using glob patterns.-```-openviking_glob(pattern: str, uri: str = "") -> str-```--### user_memory_search-Search for user memories in OpenViking.-```-user_memory_search(query: str) -> str-```-## Heartbeat Task ManagementThe `HEARTBEAT.md` file in the workspace is checked at regular intervals.diff --git a/crates/ov_cli/Cargo.toml b/crates/ov_cli/Cargo.tomlindex 2ff7eac00..8a93a1d85 100644--- a/crates/ov_cli/Cargo.toml+++ b/crates/ov_cli/Cargo.toml@@ -16,6 +16,7 @@ reqwest = { version = "0.12", features = ["json", "multipart", "rustls-tls"], deserde = { version = "1.0", features = ["derive"] }serde_json = { version = "1.0", features = ["preserve_order"] }tokio = { version = "1.38", features = ["full"] }+futures = "0.3"colored = "2.1"dirs = "5.0"anyhow = "1.0"@@ -28,3 +29,4 @@ zip = "2.2"tempfile = "3.12"url = "2.5"walkdir = "2.5"+which = "6.0"diff --git a/crates/ov_cli/src/commands/chat.rs b/crates/ov_cli/src/commands/chat.rsnew file mode 100644index 000000000..23dcc9405--- /dev/null+++ b/crates/ov_cli/src/commands/chat.rs@@ -0,0 +1,329 @@+//! Chat command for interacting with Vikingbot via OpenAPI++use std::io::Write;+use std::time::Duration;++use clap::Parser;+use reqwest::Client;+use serde::{Deserialize, Serialize};++use crate::error::{Error, Result};++const DEFAULT_ENDPOINT: &str = "http://localhost:18790/api/v1/openapi";++/// Chat with Vikingbot via OpenAPI+#[derive(Debug, Parser)]+pub struct ChatCommand {+ /// API endpoint URL+ #[arg(short, long, default_value = DEFAULT_ENDPOINT)]+ pub endpoint: String,++ /// API key for authentication+ #[arg(short, long, env = "VIKINGBOT_API_KEY")]+ pub api_key: Option<String>,++ /// Session ID to use (creates new if not provided)+ #[arg(short, long)]+ pub session: Option<String>,++ /// User ID+ #[arg(short, long, default_value = "cli_user")]+ pub user: String,++ /// Non-interactive mode (single message)+ #[arg(short = 'M', long)]+ pub message: Option<String>,++ /// Stream the response+ #[arg(long)]+ pub stream: bool,++ /// Disable rich formatting+ #[arg(long)]+ pub no_format: bool,+}++/// Chat message for API+#[derive(Debug, Serialize, Deserialize)]+struct ChatMessage {+ role: String,+ content: String,+}++/// Chat request body+#[derive(Debug, Serialize)]+struct ChatRequest {+ message: String,+ #[serde(skip_serializing_if = "Option::is_none")]+ session_id: Option<String>,+ #[serde(skip_serializing_if = "Option::is_none")]+ user_id: Option<String>,+ stream: bool,+ #[serde(skip_serializing_if = "Option::is_none")]+ context: Option<Vec<ChatMessage>>,+}++/// Chat response+#[derive(Debug, Deserialize)]+struct ChatResponse {+ session_id: String,+ message: String,+ #[serde(default)]+ events: Option<Vec<serde_json::Value>>,+}++/// Stream event+#[derive(Debug, Deserialize)]+struct StreamEvent {+ event: String,+ data: serde_json::Value,+}++impl ChatCommand {+ /// Execute the chat command+ pub async fn execute(&self) -> Result<()> {+ let client = Client::builder()+ .timeout(Duration::from_secs(300))+ .build()+ .map_err(|e| Error::Network(format!("Failed to create HTTP client: {}", e)))?;++ if let Some(message) = &self.message {+ // Single message mode - ignore stream flag for now+ self.send_message(&client, message).await+ } else {+ // Interactive mode+ self.run_interactive(&client).await+ }+ }++ /// Send a single message and get response+ async fn send_message(&self, client: &Client, message: &str) -> Result<()> {+ let url = format!("{}/chat", self.endpoint);++ let request = ChatRequest {+ message: message.to_string(),+ session_id: self.session.clone(),+ user_id: Some(self.user.clone()),+ stream: false,+ context: None,+ };++ let mut req_builder = client.post(&url).json(&request);++ if let Some(api_key) = &self.api_key {+ req_builder = req_builder.header("X-API-Key", api_key);+ }++ let response = req_builder+ .send()+ .await+ .map_err(|e| Error::Network(format!("Failed to send request: {}", e)))?;++ if !response.status().is_success() {+ let status = response.status();+ let text = response.text().await.unwrap_or_default();+ return Err(Error::Api(format!("Request failed ({}): {}", status, text)));+ }++ let chat_response: ChatResponse = response+ .json()+ .await+ .map_err(|e| Error::Parse(format!("Failed to parse response: {}", e)))?;++ // Print events if any+ if let Some(events) = &chat_response.events {+ for event in events {+ if let (Some(etype), Some(data)) = (+ event.get("type").and_then(|v| v.as_str()),+ event.get("data"),+ ) {+ match etype {+ "reasoning" => {+ let content = data.as_str().unwrap_or("");+ if !self.no_format {+ println!("\x1b[2mThink: {}...\x1b[0m", &content[..content.len().min(100)]);+ }+ }+ "tool_call" => {+ let content = data.as_str().unwrap_or("");+ if !self.no_format {+ println!("\x1b[2m├─ Calling: {}\x1b[0m", content);+ }+ }+ "tool_result" => {+ let content = data.as_str().unwrap_or("");+ if !self.no_format {+ let truncated = if content.len() > 150 {+ format!("{}...", &content[..150])+ } else {+ content.to_string()+ };+ println!("\x1b[2m└─ Result: {}\x1b[0m", truncated);+ }+ }+ _ => {}+ }+ }+ }+ }++ // Print final response+ if !self.no_format {+ println!("\n\x1b[1;31mBot:\x1b[0m");+ println!("{}", chat_response.message);+ println!();+ } else {+ println!("{}", chat_response.message);+ }++ Ok(())+ }++ /// Run interactive chat mode+ async fn run_interactive(&self, client: &Client) -> Result<()> {+ println!("Vikingbot Chat - Interactive Mode");+ println!("Endpoint: {}", self.endpoint);+ if let Some(session) = &self.session {+ println!("Session: {}", session);+ }+ println!("Type 'exit', 'quit', or press Ctrl+C to exit");+ println!("----------------------------------------\n");++ let mut session_id = self.session.clone();++ loop {+ // Read input+ print!("\x1b[1;32mYou:\x1b[0m ");+ std::io::stdout().flush().map_err(|e| Error::Io(e))?;++ let mut input = String::new();+ std::io::stdin().read_line(&mut input).map_err(|e| Error::Io(e))?;+ let input = input.trim();++ if input.is_empty() {+ continue;+ }++ // Check for exit+ if input.eq_ignore_ascii_case("exit") || input.eq_ignore_ascii_case("quit") {+ println!("\nGoodbye!");+ break;+ }++ // Send message+ let url = format!("{}/chat", self.endpoint);++ let request = ChatRequest {+ message: input.to_string(),+ session_id: session_id.clone(),+ user_id: Some(self.user.clone()),+ stream: false,+ context: None,+ };++ let mut req_builder = client.post(&url).json(&request);++ if let Some(api_key) = &self.api_key {+ req_builder = req_builder.header("X-API-Key", api_key);+ }++ match req_builder.send().await {+ Ok(response) => {+ if response.status().is_success() {+ match response.json::<ChatResponse>().await {+ Ok(chat_response) => {+ // Save session ID+ if session_id.is_none() {+ session_id = Some(chat_response.session_id.clone());+ }++ // Print events+ if let Some(events) = chat_response.events {+ for event in events {+ if let (Some(etype), Some(data)) = (+ event.get("type").and_then(|v| v.as_str()),+ event.get("data"),+ ) {+ match etype {+ "reasoning" => {+ let content = data.as_str().unwrap_or("");+ if content.len() > 100 {+ println!("\x1b[2mThink: {}...\x1b[0m", &content[..100]);+ } else {+ println!("\x1b[2mThink: {}\x1b[0m", content);+ }+ }+ "tool_call" => {+ println!("\x1b[2m├─ Calling: {}\x1b[0m", data.as_str().unwrap_or(""));+ }+ "tool_result" => {+ let content = data.as_str().unwrap_or("");+ let truncated = if content.len() > 150 {+ format!("{}...", &content[..150])+ } else {+ content.to_string()+ };+ println!("\x1b[2m└─ Result: {}\x1b[0m", truncated);+ }+ _ => {}+ }+ }+ }+ }++ // Print response+ println!("\n\x1b[1;31mBot:\x1b[0m");+ println!("{}", chat_response.message);+ println!();+ }+ Err(e) => {+ eprintln!("\x1b[1;31mError parsing response: {}\x1b[0m", e);+ }+ }+ } else {+ let status = response.status();+ let text = response.text().await.unwrap_or_default();+ eprintln!("\x1b[1;31mRequest failed ({}): {}\x1b[0m", status, text);+ }+ }+ Err(e) => {+ eprintln!("\x1b[1;31mFailed to send request: {}\x1b[0m", e);+ }+ }+ }++ println!("\nGoodbye!");+ Ok(())+ }+}++impl ChatCommand {+ /// Execute the chat command (public wrapper)+ pub async fn run(&self) -> Result<()> {+ self.execute().await+ }+}++impl ChatCommand {+ /// Create a new ChatCommand with the given parameters+ #[allow(clippy::too_many_arguments)]+ pub fn new(+ endpoint: String,+ api_key: Option<String>,+ session: Option<String>,+ user: String,+ message: Option<String>,+ stream: bool,+ no_format: bool,+ ) -> Self {+ Self {+ endpoint,+ api_key,+ session,+ user,+ message,+ stream,+ no_format,+ }+ }+}diff --git a/crates/ov_cli/src/commands/mod.rs b/crates/ov_cli/src/commands/mod.rsindex be3b61fd0..1e8d1bcda 100644--- a/crates/ov_cli/src/commands/mod.rs+++ b/crates/ov_cli/src/commands/mod.rs@@ -1,4 +1,5 @@pub mod admin;+pub mod chat;pub mod content;pub mod search;pub mod filesystem;diff --git a/crates/ov_cli/src/main.rs b/crates/ov_cli/src/main.rsindex a0d58d8f0..72bdfeb1e 100644--- a/crates/ov_cli/src/main.rs+++ b/crates/ov_cli/src/main.rs@@ -326,6 +326,21 @@ enum Commands {#[arg(default_value = "viking://")]uri: String,},+ /// Chat with vikingbot agent+ Chat {+ /// Message to send to the agent+ #[arg(short, long)]+ message: Option<String>,+ /// Session ID+ #[arg(short, long, default_value = "cli__chat__default")]+ session: String,+ /// Render assistant output as Markdown+ #[arg(long = "markdown", default_value = "true")]+ markdown: bool,+ /// Show vikingbot runtime logs during chat+ #[arg(long = "logs", default_value = "false")]+ logs: bool,+ },/// Configuration managementConfig {#[command(subcommand)]@@ -462,8 +477,16 @@ enum ConfigCommands {#[tokio::main]async fn main() {+ // Check for chat command first - handle it directly to bypass clap global args+ // but we keep it in Cli enum so it shows up in help+ let args: Vec<String> = std::env::args().collect();+ if args.len() >= 2 && args[1] == "chat" {+ handle_chat_direct(&args[2..]).await;+ return;+ }+let cli = Cli::parse();-+let output_format = cli.output;let compact = cli.compact;@@ -560,6 +583,18 @@ async fn main() {Commands::Tui { uri } => {handle_tui(uri, ctx).await}+ Commands::Chat { message, session, markdown, logs } => {+ let cmd = commands::chat::ChatCommand {+ endpoint: std::env::var("VIKINGBOT_ENDPOINT").unwrap_or_else(|_| "http://localhost:18790/api/v1/openapi".to_string()),+ api_key: std::env::var("VIKINGBOT_API_KEY").ok(),+ session: Some(session),+ user: "cli_user".to_string(),+ message,+ stream: false,+ no_format: !markdown,+ };+ cmd.run().await+ }Commands::Config { action } => handle_config(action, ctx).await,Commands::Version => {println!("{}", env!("CARGO_PKG_VERSION"));@@ -991,6 +1026,69 @@ async fn handle_health(ctx: CliContext) -> Result<()> {Ok(())}+async fn handle_chat_direct(args: &[String]) {+ use tokio::process::Command;++ // First check if vikingbot is available+ let vikingbot_available = which::which("vikingbot").is_ok() || {+ // Also check if we can import the module+ let python = std::env::var("PYTHON").unwrap_or_else(|_| "python3".to_string());+ let check = Command::new(&python)+ .args(["-c", "import vikingbot; print('ok')"])+ .output()+ .await;+ check.map(|o| o.status.success()).unwrap_or(false)+ };++ if !vikingbot_available {+ eprintln!("Error: vikingbot not found. Please install vikingbot first:");+ eprintln!();+ eprintln!(" Option 1: Install from local source (recommended for development)");+ eprintln!(" cd bot");+ eprintln!(" uv pip install -e \".[dev]\"");+ eprintln!();+ eprintln!(" Option 2: Install from PyPI (coming soon)");+ eprintln!(" pip install vikingbot");+ eprintln!();+ std::process::exit(1);+ }++ // Try to find vikingbot executable first+ let (cmd, mut vikingbot_args) = if let Ok(vikingbot) = which::which("vikingbot") {+ (vikingbot, vec!["chat".to_string()])+ } else {+ let python = std::env::var("PYTHON").unwrap_or_else(|_| "python3".to_string());+ (+ std::path::PathBuf::from(python),+ vec!["-m".to_string(), "vikingbot.cli.commands".to_string(), "chat".to_string()],+ )+ };++ // Always add our default session first+ vikingbot_args.push("--session".to_string());+ vikingbot_args.push("cli__chat__default".to_string());++ // Now add all user args - if user provided --session it will override the default+ vikingbot_args.extend(args.iter().cloned());++ // Execute and pass through all signals+ let status = Command::new(&cmd)+ .args(&vikingbot_args)+ .status()+ .await;++ match status {+ Ok(s) if !s.success() => {+ std::process::exit(s.code().unwrap_or(1));+ }+ Err(e) => {+ eprintln!("Error: {}", e);+ std::process::exit(1);+ }+ _ => {}+ }+}+async fn handle_tui(uri: String, ctx: CliContext) -> Result<()> {let client = ctx.get_client();tui::run_tui(client, &uri).awaitdiff --git a/openviking/server/app.py b/openviking/server/app.pyindex 038aeb25e..a99d248bb 100644--- a/openviking/server/app.py+++ b/openviking/server/app.py@@ -16,6 +16,7 @@ from openviking.server.dependencies import set_servicefrom openviking.server.models import ERROR_CODE_TO_HTTP_STATUS, ErrorInfo, Responsefrom openviking.server.routers import (admin_router,+ bot_router,content_router,debug_router,filesystem_router,@@ -147,6 +148,14 @@ def create_app().model_dump(),)+ # Configure Bot API if --with-bot is enabled+ if config.with_bot:+ import openviking.server.routers.bot as bot_module+ bot_module.set_bot_api_url(config.bot_api_url)+ logger.info(f"Bot API proxy enabled, forwarding to {config.bot_api_url}")+ else:+ logger.info("Bot API proxy disabled (use --with-bot to enable)")+# Register routersapp.include_router(system_router)app.include_router(admin_router)@@ -159,5 +168,6 @@ def create_app(app.include_router(pack_router)app.include_router(debug_router)app.include_router(observer_router)+ app.include_router(bot_router, prefix="/bot/v1")return appdiff --git a/openviking/server/bootstrap.py b/openviking/server/bootstrap.pyindex 8d9d95cda..83b8149c5 100644--- a/openviking/server/bootstrap.py+++ b/openviking/server/bootstrap.py@@ -4,6 +4,9 @@import argparseimport os+import subprocess+import sys+import timeimport uvicorn@@ -50,6 +53,23 @@ def main():default=None,help="Path to ov.conf config file",)+ parser.add_argument(+ "--bot",+ action="store_true",+ help="Also start vikingbot gateway after server starts",+ )+ parser.add_argument(+ "--with-bot",+ action="store_true",+ dest="with_bot",+ help="Enable Bot API proxy to Vikingbot (requires Vikingbot running)",+ )+ parser.add_argument(+ "--bot-url",+ default="http://localhost:18790",+ dest="bot_url",+ help="Vikingbot OpenAPIChannel URL (default: http://localhost:18790)",+ )args = parser.parse_args()@@ -66,6 +86,10 @@ def main():config.host = args.hostif args.port is not None:config.port = args.port+ if args.with_bot:+ config.with_bot = True+ if args.bot_url:+ config.bot_api_url = args.bot_url# Configure logging for Uvicornconfigure_uvicorn_logging()@@ -73,7 +97,100 @@ def main():# Create and run appapp = create_app(config)print(f"OpenViking HTTP Server is running on {config.host}:{config.port}")- uvicorn.run(app, host=config.host, port=config.port, log_config=None)+ if config.with_bot:+ print(f"Bot API proxy enabled, forwarding to {config.bot_api_url}")++ # Start vikingbot gateway if --with-bot is set+ bot_process = None+ if args.with_bot:+ bot_process = _start_vikingbot_gateway()++ try:+ uvicorn.run(app, host=config.host, port=config.port, log_config=None)+ finally:+ # Cleanup vikingbot process on shutdown+ if bot_process is not None:+ _stop_vikingbot_gateway(bot_process)+++def _start_vikingbot_gateway() -> subprocess.Popen:+ """Start vikingbot gateway as a subprocess."""+ print("Starting vikingbot gateway...")++ # Check if vikingbot is available+ vikingbot_cmd = None+ if subprocess.run(["which", "vikingbot"], capture_output=True).returncode == 0:+ vikingbot_cmd = ["vikingbot", "gateway"]+ else:+ # Try python -m vikingbot+ python_cmd = sys.executable+ try:+ result = subprocess.run(+ [python_cmd, "-m", "vikingbot", "--help"],+ capture_output=True,+ timeout=5+ )+ if result.returncode == 0:+ vikingbot_cmd = [python_cmd, "-m", "vikingbot", "gateway"]+ except (subprocess.TimeoutExpired, FileNotFoundError):+ pass++ if vikingbot_cmd is None:+ print("Warning: vikingbot not found. Please install vikingbot first.")+ print(" cd bot && uv pip install -e '.[dev]'")+ return None++ # Start vikingbot gateway process+ try:+ # Set environment to ensure it uses the same Python environment+ env = os.environ.copy()++ process = subprocess.Popen(+ vikingbot_cmd,+ stdout=subprocess.PIPE,+ stderr=subprocess.PIPE,+ text=True,+ env=env,+ )++ # Wait a moment to check if it started successfully+ time.sleep(2)+ if process.poll() is not None:+ # Process exited early+ stdout, stderr = process.communicate(timeout=1)+ print(f"Warning: vikingbot gateway exited early (code {process.returncode})")+ if stderr:+ print(f"Error: {stderr[:500]}")+ return None++ print(f"Vikingbot gateway started (PID: {process.pid})")+ return process++ except Exception as e:+ print(f"Warning: Failed to start vikingbot gateway: {e}")+ return None+++def _stop_vikingbot_gateway(process: subprocess.Popen) -> None:+ """Stop the vikingbot gateway subprocess."""+ if process is None:+ return++ print(f"\nStopping vikingbot gateway (PID: {process.pid})...")++ try:+ # Try graceful termination first+ process.terminate()+ try:+ process.wait(timeout=5)+ print("Vikingbot gateway stopped gracefully.")+ except subprocess.TimeoutExpired:+ # Force kill if it doesn't stop in time+ process.kill()+ process.wait()+ print("Vikingbot gateway force killed.")+ except Exception as e:+ print(f"Error stopping vikingbot gateway: {e}")if __name__ == "__main__":diff --git a/openviking/server/config.py b/openviking/server/config.pyindex 9b1631d69..2fdbcbdf6 100644--- a/openviking/server/config.py+++ b/openviking/server/config.py@@ -25,6 +25,8 @@ class ServerConfig:port: int = 1933root_api_key: Optional[str] = Nonecors_origins: List[str] = field(default_factory=lambda: ["*"])+ with_bot: bool = False # Enable Bot API proxy to Vikingbot+ bot_api_url: str = "http://localhost:18790" # Vikingbot OpenAPIChannel URL (default port)def load_server_config(config_path: Optional[str] = None) -> ServerConfig:diff --git a/openviking/server/routers/__init__.py b/openviking/server/routers/__init__.pyindex d90e66872..05a75f97c 100644--- a/openviking/server/routers/__init__.py+++ b/openviking/server/routers/__init__.py@@ -3,6 +3,7 @@"""OpenViking HTTP Server routers."""from openviking.server.routers.admin import router as admin_router+from openviking.server.routers.bot import router as bot_routerfrom openviking.server.routers.content import router as content_routerfrom openviking.server.routers.debug import router as debug_routerfrom openviking.server.routers.filesystem import router as filesystem_router@@ -16,6 +17,7 @@ from openviking.server.routers.system import router as system_router__all__ = ["admin_router",+ "bot_router","system_router","resources_router","filesystem_router",diff --git a/openviking/server/routers/bot.py b/openviking/server/routers/bot.pynew file mode 100644index 000000000..b39f16f8e--- /dev/null+++ b/openviking/server/routers/bot.py@@ -0,0 +1,204 @@+"""Bot API router for proxying requests to Vikingbot OpenAPIChannel.++This router provides endpoints for the Bot API that proxy requests to the+Vikingbot OpenAPIChannel when the --with-bot option is enabled.+"""++import json+import os+from typing import AsyncGenerator, Optional++import httpx+from fastapi import APIRouter, Depends, Header, HTTPException, Request, status+from fastapi.responses import JSONResponse, StreamingResponse+from loguru import logger++router = APIRouter(prefix="", tags=["bot"])++# Bot API configuration - set when --with-bot is enabled+BOT_API_URL: Optional[str] = None # e.g., "http://localhost:18791"+++def set_bot_api_url(url: str) -> None:+ """Set the Bot API URL. Called by app.py when --with-bot is enabled."""+ global BOT_API_URL+ BOT_API_URL = url+++def get_bot_url() -> str:+ """Get the Bot API URL, raising 503 if not configured."""+ if BOT_API_URL is None:+ raise HTTPException(+ status_code=status.HTTP_503_SERVICE_UNAVAILABLE,+ detail="Bot service not enabled. Start server with --with-bot option.",+ )+ return BOT_API_URL+++async def verify_auth(request: Request) -> Optional[str]:+ """Extract and return authorization token from request."""+ # Try X-API-Key header first+ api_key = request.headers.get("X-API-Key")+ if api_key:+ return api_key++ # Try Authorization header (Bearer token)+ auth_header = request.headers.get("Authorization")+ if auth_header and auth_header.startswith("Bearer "):+ return auth_header[7:] # Remove "Bearer " prefix++ return None++[email protected]("/health")+async def health_check(request: Request):+ """Health check endpoint for Bot API.++ Returns 503 if --with-bot is not enabled.+ Proxies to Vikingbot health check if enabled.+ """+ bot_url = get_bot_url()++ try:+ async with httpx.AsyncClient() as client:+ print(f'url={f"{bot_url}/bot/v1/health"}')+ # Forward to Vikingbot OpenAPIChannel health endpoint+ response = await client.get(+ f"{bot_url}/bot/v1/health",+ timeout=5.0,+ )+ response.raise_for_status()+ return response.json()+ except httpx.RequestError as e:+ logger.error(f"Failed to connect to bot service at {bot_url}: {e}")+ raise HTTPException(+ status_code=status.HTTP_502_BAD_GATEWAY,+ detail=f"Bot service unavailable: {str(e)}",+ )+ except httpx.HTTPStatusError as e:+ logger.error(f"Bot service returned error: {e}")+ raise HTTPException(+ status_code=status.HTTP_502_BAD_GATEWAY,+ detail=f"Bot service error: {e.response.text}",+ )++[email protected]("/chat")+async def chat(request: Request):+ """Send a message to the bot and get a response.++ Proxies the request to Vikingbot OpenAPIChannel.+ """+ bot_url = get_bot_url()+ auth_token = await verify_auth(request)++ # Read request body+ try:+ body = await request.json()+ except json.JSONDecodeError:+ raise HTTPException(+ status_code=status.HTTP_400_BAD_REQUEST,+ detail="Invalid JSON in request body",+ )++ try:+ async with httpx.AsyncClient() as client:+ # Build headers+ headers = {"Content-Type": "application/json"}+ if auth_token:+ headers["X-API-Key"] = auth_token++ # Forward to Vikingbot OpenAPIChannel chat endpoint+ response = await client.post(+ f"{bot_url}/bot/v1/chat",+ json=body,+ headers=headers,+ timeout=300.0, # 5 minute timeout for chat+ )+ response.raise_for_status()+ return response.json()+ except httpx.RequestError as e:+ logger.error(f"Failed to connect to bot service: {e}")+ raise HTTPException(+ status_code=status.HTTP_502_BAD_GATEWAY,+ detail=f"Bot service unavailable: {str(e)}",+ )+ except httpx.HTTPStatusError as e:+ logger.error(f"Bot service returned error: {e}")+ # Forward the status code if it's a client error+ if e.response.status_code < 500:+ raise HTTPException(+ status_code=e.response.status_code,+ detail=e.response.text,+ )+ raise HTTPException(+ status_code=status.HTTP_502_BAD_GATEWAY,+ detail=f"Bot service error: {e.response.text}",+ )++[email protected]("/chat/stream")+async def chat_stream(request: Request):+ """Send a message to the bot and get a streaming response.++ Proxies the request to Vikingbot OpenAPIChannel with SSE streaming.+ """+ bot_url = get_bot_url()+ auth_token = await verify_auth(request)++ # Read request body+ try:+ body = await request.json()+ except json.JSONDecodeError:+ raise HTTPException(+ status_code=status.HTTP_400_BAD_REQUEST,+ detail="Invalid JSON in request body",+ )++ async def event_stream() -> AsyncGenerator[str, None]:+ """Generate SSE events from bot response stream."""+ try:+ async with httpx.AsyncClient() as client:+ # Build headers+ headers = {"Content-Type": "application/json"}+ if auth_token:+ headers["X-API-Key"] = auth_token++ # Forward to Vikingbot OpenAPIChannel stream endpoint+ async with client.stream(+ "POST",+ f"{bot_url}/chat/stream",+ json=body,+ headers=headers,+ timeout=300.0,+ ) as response:+ response.raise_for_status()++ # Stream the response content+ async for line in response.aiter_lines():+ if line:+ # Forward the SSE line+ yield f"{line}\n\n"+ except httpx.RequestError as e:+ logger.error(f"Failed to connect to bot service: {e}")+ error_event = {+ "event": "error",+ "data": json.dumps({"error": f"Bot service unavailable: {str(e)}"}),+ }+ yield f"data: {json.dumps(error_event)}\n\n"+ except httpx.HTTPStatusError as e:+ logger.error(f"Bot service returned error: {e}")+ error_event = {+ "event": "error",+ "data": json.dumps({"error": f"Bot service error: {e.response.text}"}),+ }+ yield f"data: {json.dumps(error_event)}\n\n"++ return StreamingResponse(+ event_stream(),+ media_type="text/event-stream",+ headers={+ "Cache-Control": "no-cache",+ "Connection": "keep-alive",+ },+ )diff --git a/openviking_cli/cli/commands/chat.py b/openviking_cli/cli/commands/chat.pynew file mode 100644index 000000000..71c7b6ae0--- /dev/null+++ b/openviking_cli/cli/commands/chat.py@@ -0,0 +1,82 @@+# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.+# SPDX-License-Identifier: Apache-2.0+"""Chat command - wrapper for vikingbot agent."""++import importlib.util+import shutil+import subprocess+import sys++import typer+++def _check_vikingbot() -> bool:+ """Check if vikingbot is available."""+ return importlib.util.find_spec("vikingbot") is not None+++def chat(+ message: str = typer.Option(None, "--message", "-m", help="Message to send to the agent"),+ session_id: str = typer.Option(+ "cli__default__direct", "--session", "-s", help="Session ID"+ ),+ markdown: bool = typer.Option(+ True, "--markdown/--no-markdown", help="Render assistant output as Markdown"+ ),+ logs: bool = typer.Option(+ False, "--logs/--no-logs", help="Show vikingbot runtime logs during chat"+ ),+):+ """+ Chat with vikingbot agent.++ This is equivalent to `vikingbot chat`.+ """+ if not _check_vikingbot():+ typer.echo(+ typer.style(+ "Error: vikingbot not found. Please install vikingbot first:",+ fg="red",+ )+ )+ typer.echo()+ typer.echo(" Option 1: Install from local source (recommended for development)")+ typer.echo(" cd bot")+ typer.echo(" uv pip install -e \".[dev]\"")+ typer.echo()+ typer.echo(" Option 2: Install from PyPI (coming soon)")+ typer.echo(" pip install vikingbot")+ typer.echo()+ raise typer.Exit(1)++ # Build the command arguments+ args = []++ if message:+ args.extend(["--message", message])+ args.extend(["--session", session_id])+ if not markdown:+ args.append("--no-markdown")+ if logs:+ args.append("--logs")++ # Check if vikingbot command exists+ vikingbot_path = shutil.which("vikingbot")++ if vikingbot_path:+ # Build the command: vikingbot chat [args...]+ full_args = [vikingbot_path, "chat"] + args+ else:+ # Fallback: use python -m+ full_args = [sys.executable, "-m", "vikingbot.cli.commands", "chat"] + args++ # Pass through all arguments to vikingbot agent+ try:+ subprocess.run(full_args, check=True)+ except subprocess.CalledProcessError as e:+ raise typer.Exit(e.returncode)+++def register(app: typer.Typer) -> None:+ """Register chat command."""+ app.command("chat")(chat)diff --git a/openviking_cli/client/http.py b/openviking_cli/client/http.pyindex 0c6f612f7..312f5d08c 100644--- a/openviking_cli/client/http.py+++ b/openviking_cli/client/http.py@@ -143,9 +143,12 @@ class AsyncHTTPClient(BaseClient):timeout: HTTP request timeout in seconds. Default 60.0."""if url is None:+ print(f'OPENVIKING_CLI_CONFIG_ENV={OPENVIKING_CLI_CONFIG_ENV}')+ print(f'DEFAULT_OVCLI_CONF={DEFAULT_OVCLI_CONF}')config_path = resolve_config_path(None, OPENVIKING_CLI_CONFIG_ENV, DEFAULT_OVCLI_CONF)if config_path:cfg = load_json_config(config_path)+url = cfg.get("url")api_key = api_key or cfg.get("api_key")agent_id = agent_id or cfg.get("agent_id")diff --git a/openviking_cli/utils/config/open_viking_config.py b/openviking_cli/utils/config/open_viking_config.pyindex 427e4ae0e..b78020b43 100644--- a/openviking_cli/utils/config/open_viking_config.py+++ b/openviking_cli/utils/config/open_viking_config.py@@ -128,6 +128,7 @@ class OpenVikingConfig(BaseModel):# Remove sections managed by other loaders (e.g. server config)config_copy.pop("server", None)+ config_copy.pop("bot", None)# Handle parser configurations from nested "parsers" sectionparser_configs = {}diff --git a/test_chat_command.py b/test_chat_command.pynew file mode 100644index 000000000..520e7a8c2--- /dev/null+++ b/test_chat_command.py@@ -0,0 +1,31 @@+#!/usr/bin/env python3+"""Test script to verify the ov chat command implementation."""++import sys+from pathlib import Path++# Add the root directory to Python path+root_dir = Path(__file__).parent+sys.path.insert(0, str(root_dir))++from openviking_cli.cli.commands.chat import _check_vikingbot+++def test_vikingbot_detection():+ """Test that vikingbot detection works."""+ print("Testing vikingbot detection...")+ has_vikingbot = _check_vikingbot()+ print(f"vikingbot available: {has_vikingbot}")++ # Also check via import+ try:+ import vikingbot+ print(f"Direct import successful: vikingbot {vikingbot.__version__}")+ except ImportError:+ print("Direct import: vikingbot not found")++ return has_vikingbot+++if __name__ == "__main__":+ test_vikingbot_detection()diff --git a/test_chat_integration.py b/test_chat_integration.pynew file mode 100644index 000000000..9d97178bb--- /dev/null+++ b/test_chat_integration.py@@ -0,0 +1,77 @@+#!/usr/bin/env python3+"""Integration test for ov chat command."""++import sys+import subprocess+from pathlib import Path++# Add root to path+root_dir = Path(__file__).parent+sys.path.insert(0, str(root_dir))+++def test_chat_command_exists():+ """Test that chat command is registered."""+ print("Testing chat command registration...")+ result = subprocess.run(+ [sys.executable, "-m", "openviking_cli.cli.main", "--help"],+ capture_output=True,+ text=True,+ )+ print("Exit code:", result.returncode)+ print("\nSTDOUT:")+ print(result.stdout)+ if result.stderr:+ print("\nSTDERR:")+ print(result.stderr)++ # Check if chat is in the help output+ if "chat" in result.stdout:+ print("\n✓ SUCCESS: chat command found in help!")+ return True+ else:+ print("\n✗ FAILED: chat command not found in help")+ return False+++def test_chat_help():+ """Test that chat --help shows correct parameters."""+ print("\n\nTesting chat --help...")+ result = subprocess.run(+ [sys.executable, "-m", "openviking_cli.cli.main", "chat", "--help"],+ capture_output=True,+ text=True,+ )+ print("Exit code:", result.returncode)+ print("\nSTDOUT:")+ print(result.stdout)+ if result.stderr:+ print("\nSTDERR:")+ print(result.stderr)++ # Check for expected parameters+ expected_params = ["--message", "-m", "--session", "-s", "--markdown", "--logs"]+ found = all(p in result.stdout for p in expected_params)+ if found:+ print("\n✓ SUCCESS: All expected parameters found!")+ else:+ print("\n✗ FAILED: Some parameters missing")+ return found+++if __name__ == "__main__":+ print("=" * 60)+ print("Testing ov chat command integration")+ print("=" * 60)+ print()++ success1 = test_chat_command_exists()+ success2 = test_chat_help()++ print("\n" + "=" * 60)+ if success1 and success2:+ print("✓ All tests passed!")+ sys.exit(0)+ else:+ print("✗ Some tests failed!")+ sys.exit(1)