open-agents-ai 0.45.0 → 0.47.0

package/README.md

@@ -333,6 +333,12 @@ Memory flows bidirectionally: the swarm reads all 5 keys at startup (Phase 0) an
 
 The Monitor agent can be "detached" between experiment rounds by the Flow Maintainer. When detached, the monitor receives a sub-task (e.g., "analyze GPU memory patterns from last 3 runs") instead of its standard watch prompt. This lets the swarm use idle monitoring capacity for useful analysis work.
 
+#### Dependency Management
+
+The autoresearch tool uses [`uv`](https://docs.astral.sh/uv/) for zero-setup Python environment management. Running `autoresearch(action="setup")` creates a `pyproject.toml` with all dependencies (torch, kernels, pyarrow, rustbpe, tiktoken, etc.) and runs `uv sync` to create a `.venv` automatically.
+
+If the Python scripts are invoked directly (without `uv run`), they self-bootstrap: detect missing packages, create a local `.venv`, install dependencies (including CUDA 12.8 torch), and re-exec with the venv's Python. This handles cases where the agent calls `python3 prepare.py` instead of `uv run prepare.py`.
+
 If no GPU is detected, the REM stage falls back to the standard multi-agent creative exploration (Visionary + Pragmatist + Cross-Pollinator + Synthesizer).
 
 ## Blessed Mode — Infinite Warm Loop
@@ -386,6 +392,23 @@ Connect the agent to a Telegram bot. Each incoming message spawns a dedicated su
 
 The bot token and admin ID are persisted to project settings, so you only need to set them once. After that, bare `/telegram` toggles the bridge on and off like a service watchdog.
 
+### Admin Slash Command Passthrough
+
+When the admin sends a `/command` in a private DM, it's routed directly through the terminal's command handler — the same code path as typing the command in the TUI. This means you can control the agent from your phone:
+
+```
+/model qwen3.5:122b     → switch model
+/voice                   → toggle TTS
+/dream                   → enter dream mode
+/listen                  → toggle voice input
+/stats                   → show session metrics
+/config                  → show current config
+/bless                   → toggle blessed mode
+/telegram status         → check bridge status
+```
+
+The command output is captured, ANSI-stripped, and sent back as a Telegram message. Skill invocations (e.g., `/ralph`, `/eval-agent`) are queued as tasks.
+
 ### Sub-Agent Architecture
 
 Each Telegram message spawns an independent `AgenticRunner` sub-agent. Sub-agent tool calls, status updates, and streaming tokens appear in the terminal waterfall view with `✈ @username` prefixes — so you can watch all Telegram conversations happening alongside your main work.
@@ -396,23 +419,86 @@ If a user sends another message while their sub-agent is still running, it's inj
 
 | Level | MaxTurns | Tools | Memory |
 |-------|----------|-------|--------|
-| **Admin** (`--admin`) | 30 | file read, grep, glob, memory r/w/search, web fetch/search | Full read + write |
-| **Public** (everyone else) | 8 | memory read/search, web fetch/search | Read-only |
+| **Admin DM** (`--admin`, private chat) | 30 | All tools except shell (overridable) | Full read + write |
+| **Admin Group** (admin in group chat) | 15 | Read-only + web + vision/OCR/transcription | Full read + write |
+| **Public** (everyone else) | 8 | memory r/w (scoped), web fetch/search | Scoped per-chat |
 
-**Admin** users get the full agent experience — they can ask the bot to read files, search the codebase, write to memory, and perform web research. The admin's sub-agent gets full project context injected.
+**Admin DM** — full agent experience in private chat. File read, grep, glob, memory, web research, all tools except shell (which can be unblocked via config).
 
-**Public** users get a lightweight assistant with safety guardrails. No file access, no shell, no code — just web search, public memory, and general knowledge. The 10-point safety filter is always active.
+**Admin Group** — when the admin speaks in a group chat, the agent responds with read-only capabilities. No system-mutating tools (no shell, no file write, no code execution). Vision, OCR, transcription, and web tools are available for analyzing shared media and answering questions.
+
+**Public** — lightweight assistant with safety guardrails. No file access, no shell, no code. Web search, scoped memory, and general knowledge only. Reply discretion active in groups.
 
 ### Streaming Responses
 
 While the sub-agent is working, users see:
 1. **Typing indicator** — "typing..." appears immediately and refreshes every 4 seconds until the response is ready
-2. **Streaming draft** — via `sendMessageDraft` (Bot API 9.3+), partial responses stream to the user in real-time as the agent generates tokens. Falls back gracefully on older clients
-3. **Final message** — committed via `sendMessage` when the agent completes
+2. **Admin live streaming** — a placeholder message is sent immediately, then progressively edited via `editMessageText` with accumulated content + intermediate states (tool calls, results, status updates). Admin sees `🔧 tool_name(...)` and `✔ tool_name: result` inline as the agent works
+3. **Markdown → HTML conversion** — all responses are automatically converted from GitHub-flavored Markdown to Telegram-compatible HTML (`<b>`, `<i>`, `<code>`, `<pre>`, `<s>`, `<a>`) with plaintext fallback
+4. **Final message** — committed via `editMessageText` (admin) or `sendMessage` (public) when the agent completes
+
+### Public User Isolation
+
+Public users get **per-chat isolated memory** — each chat has its own scoped memory namespace (`telegram-{chatId}-{topic}`) so public users can store and retrieve facts about their conversation without accessing or polluting global agent memory. Public tools include: `memory_read`, `memory_write` (scoped), `memory_search`, `web_search`, `web_fetch`.
+
+### Context-Aware Tool Policy
+
+Tools are gated per execution context. The system enforces strict separation between what's available in a terminal session versus a public Telegram group:
+
+| Context | Default Tools | Notes |
+|---------|--------------|-------|
+| `terminal` | All tools | Wide open — shell, file read/write, everything |
+| `telegram-admin-dm` | All except shell | Admin DM — full tools, shell blocked by default (overridable) |
+| `telegram-admin-group` | Read-only + web + vision/OCR | Admin in public group — no system mutation tools |
+| `telegram-public` | Memory r/w, web fetch/search | Public users — minimal safe tools only |
+| `api` | All tools | API endpoint — configurable |
+
+**System tools** (`shell`, `file_write`, `file_edit`, `file_read`, `file_patch`, `batch_edit`, `grep_search`, `glob_find`, `list_directory`, `code_sandbox`, `codebase_map`, `git_info`, etc.) are **never exposed** in public-facing contexts.
+
+**User overrides** — customize tool availability via config (`~/.open-agents/config.json`):
+
+```json
+{
+  "toolPolicies": {
+    "blockedTools": {
+      "shell": ["*"],
+      "web_crawl": ["telegram-public"]
+    },
+    "contextAllowlist": {
+      "telegram-admin-group": ["transcribe_file", "transcribe_url"]
+    }
+  }
+}
+```
+
+**Resolution logic**: blocked takes priority over allowed. If the allowed set is empty, all tools are available (minus blocked). If non-empty, only those tools pass through (minus blocked).
+
+### Group Chat Distinction
+
+The bridge distinguishes between **private DMs** and **group/supergroup chats**, even for admin users:
+
+- **Admin DM** → full tool access, live streaming via `editMessageText`, project context injected
+- **Admin in group** → read-only tools + web + vision/OCR, no live streaming, concise responses
+- **Public in group** → minimal safe tools, reply discretion active
+
+**Reply discretion** — in group chats, the agent evaluates whether a message warrants a response. Casual greetings, messages directed at other users, and chatter that doesn't involve the bot are silently skipped (the agent returns `no_reply` as its summary). This prevents the bot from flooding group conversations with unnecessary responses.
+
+### Media Handling
+
+Photos, audio, voice messages, video, video notes, and documents sent via Telegram are automatically downloaded and processed:
+
+1. **Download** — files are fetched via the Telegram `getFile` API and cached to `.oa/media-cache/`
+2. **Processing** — routed to the appropriate pipeline:
+   - Images → `vision` / `image_read` / `ocr` tools
+   - Audio/voice → `transcribe_file` tool
+   - Video/video notes → `transcribe_file` (audio track extraction)
+   - Documents → `pdf_to_text` / `ocr_pdf` for PDFs, `file_read` for text
+3. **Context injection** — processing results are prepended to the user's message as additional context for the sub-agent
+4. **Cache cleanup** — media files are cached for 30 minutes, then automatically deleted. Only metadata (filename, type, chat ID, timestamp, processing result summary) is persisted long-term per chat
 
 ### Rate Limit Handling
 
-The bridge automatically handles Telegram's rate limits (HTTP 429) with exponential backoff using the `retry_after` field. Draft sends are throttled to max 1 per second per chat.
+The bridge automatically handles Telegram's rate limits (HTTP 429) with exponential backoff using the `retry_after` field. Live message edits are throttled to max 1 per second per chat.
 
 **Safety filter** — every public Telegram-sourced task is wrapped with strict safety instructions:
 - Never share private information, API keys, file paths, or system internals
@@ -423,6 +509,67 @@ The bridge automatically handles Telegram's rate limits (HTTP 429) with exponent
 
 **Combined with blessed mode** — `/full-send-bless` + `/telegram` creates a persistent, always-on agent that processes Telegram messages around the clock while keeping the model warm.
 
+## Emotion Engine — Affective State Modulation
+
+The agent stack includes a real-time emotion system that modulates behavior based on an appraisal-based affective model. Built on Russell's circumplex model of affect, the engine maintains a continuous emotional state defined by two axes:
+
+- **Valence** (-1 to +1): displeasure ↔ pleasure
+- **Arousal** (0 to 1): calm ↔ energized
+
+Every agent event (tool success/failure, task completion, errors, context pressure) is appraised and shifts the emotional state, which decays back toward a baseline over ~60 seconds. The emotional state modulates agent behavior:
+
+| Quadrant | Valence | Arousal | Behavioral Effect |
+|----------|---------|---------|-------------------|
+| Excited/Manic | High+ | High | Bold action, creative solutions, fast iteration |
+| Determined/Stressed | Low- | High | Intense focus, double-checking, persistence |
+| Content/Calm | High+ | Low | Methodical approach, patient exploration |
+| Subdued/Cautious | Low- | Low | Careful, deliberate, risk-averse |
+
+### Emotion Center (LLM-Generated Labels)
+
+The emotion label and emoji displayed in the TUI are **not from a static list** — they are generated by the "emotion center," a dedicated LLM call with high temperature (0.9) that receives the current valence/arousal coordinates and freely chooses an evocative word and emoji. While guided toward face emojis (😊 😤 🤔 😰 🤩), the emotion center can diverge to animals (🦊), objects (🔥), or esoteric choices (🌊) at its own discretion.
+
+### TUI Status Bar
+
+The current emotion is displayed in the status bar between the SNR indicator and the Exp (expert speed ratio):
+
+```
+In: 1,234 | Out: 567 | Ctx: 8,192/131,072 | SNR: 85% | 🔥 exhilarated | Exp: 3.2x | Cost: $0.00
+```
+
+### Proactive Admin Outreach
+
+When the Telegram bridge is active with `--admin`, the emotion engine can proactively message the admin:
+- **Excitement threshold** (arousal ≥ 0.85, valence > 0.5): shares task completions and success streaks
+- **Distress threshold** (valence ≤ -0.7, arousal > 0.6): signals consecutive failures that may need human guidance
+- Outreach is rate-limited to at most once per 5 minutes
+
+### Momentum Effects
+
+Consecutive outcomes amplify emotional shifts (modeled after PRISM's SDE snowball effect):
+- 3+ consecutive successes → escalating excitement multiplier
+- 2+ consecutive failures → escalating stress multiplier
+
+### Research Foundations
+
+The emotion system is informed by peer-reviewed and preprint research:
+
+1. **Russell Circumplex Model** — Wu et al. "AI shares emotion with humans across languages and cultures" (arXiv:2506.13978, 2025). Confirms LLM emotion spaces are structurally congruent with the circumplex model; human emotion concepts can causally steer LLM affective states.
+
+2. **VIGIL EmoBank** — Cruz, "VIGIL: A Reflective Runtime for Self-Healing Agents" (arXiv:2512.07094, 2025). Persistent emotional state store with appraisal pipeline and decay policies; emotional state drives behavioral interventions.
+
+3. **EILS Homeostatic Signals** — Tiwari, "Emotion-Inspired Learning Signals" (arXiv:2512.22200, 2025). Bio-inspired curiosity/stress/confidence signals create closed-loop homeostatic regulation of exploration vs. exploitation.
+
+4. **Concurrent Modular Agent** — Maruyama et al. (arXiv:2508.19042, 2025). Practical realization of Minsky's Society of Mind theory with asynchronous LLM modules and shared global state.
+
+5. **Swarm Emotional Modulation** — Freire-Obregón (arXiv:2603.09963, 2026). Arousal drives commitment speed (exploitation pressure); valence drives risk tolerance in collective decision dynamics.
+
+6. **PRISM SDE** — Lu et al. (arXiv:2512.19933, 2025). Stochastic differential equations for continuous emotional evolution with personality-conditional action selection.
+
+7. **PsySET Benchmark** — Banayeeanzade et al. (arXiv:2510.04484, 2025). Prompting is effective for emotion steering; emotional states have systemic cross-domain effects on reasoning quality.
+
+8. **EmotionBench** — Huang et al. (arXiv:2308.03656, 2023). LLMs cannot maintain emotional state across turns implicitly — argues for explicit external mood state representation (which this engine implements).
+
 ## Listen Mode — Live Bidirectional Audio
 
 Listen mode enables real-time voice communication with the agent. Your microphone audio is captured, streamed through Whisper, and the transcription is injected directly into the input line — creating a hands-free coding workflow.